The lines of instructional code that make a program work

Some more complicated cases are not diagnosed by this option, and it may give an occasional false positive result, but in general it has been found fairly effective at detecting this sort of problem in programs.

The present implementation of this option only works for C programs. The C standard is worded confusingly, therefore there is some debate over the precise meaning of the sequence point rules in subtle cases. Also warn about any return statement with no return-value in a function whose return-type is not void.

For C, also warn if the return type of a function has a type qualifier such as const. Such a type qualifier has no effect, since the value returned by a function is not an lvalue. ISO C prohibits qualified void return types on function definitions, so such return types always receive a warning even without this option.

The only exceptions are main and functions defined in system headers. The presence of a default label prevents this warning. To suppress this warning use the unused attribute. To suppress this warning cast the expression to void. In order to get a warning about an unused function parameter, you must either specify -Wextra -Wunused note that -Wall implies -Wunused , or separately specify -Wunused-parameter.

These warnings are possible only in optimizing compilation, because they require data flow information that is computed only when optimizing. If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the -Winit-self option. These warnings occur for individual uninitialized or clobbered elements of structure, union or array variables as well as for variables which are uninitialized or clobbered as a whole.

They do not occur for variables or elements declared volatile. Because these warnings depend on optimization, the exact variables or elements for which there are warnings will depend on the precise optimization options and version of GCC used. Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such computations may be deleted by data flow analysis before the warnings are printed.

These warnings are made optional because GCC is not smart enough to see all the reasons why the code might be correct despite appearing to have an error. This option also warns when a non-volatile automatic variable might be changed by a call to longjmp. These warnings as well are possible only in optimizing compilation. The compiler sees only the calls to setjmp.

It cannot know where longjmp will be called; in fact, a signal handler could call it at any point in the code. As a result, you may get a warning even when there is in fact no problem because longjmp cannot in fact be called at the place which would cause a problem.

Some spurious warnings can be avoided if you declare all the functions you use that never return as noreturn. If this command line option is used, warnings will even be issued for unknown pragmas in system header files.

This is not the case if the warnings were only enabled by the -Wall command line option. See also -Wunknown-pragmas. It warns about code which might break the strict aliasing rules that the compiler is using for optimization. The warning does not catch all cases, but does attempt to catch the more common pitfalls.

It is included in -Wall. This warning catches more cases than -Wstrict-aliasing , but it will also give a warning for some ambiguous cases that are safe. This enables all the warnings about constructions that some users consider questionable, and that are easy to avoid or modify to prevent the warning , even in conjunction with macros. Some of them warn about constructions that users generally do not consider questionable, but which occasionally you might wish to check for; others warn about constructions that are necessary or hard to avoid in some cases, and there is no simple way to modify the code to suppress the warning.

Tag Description -Wextra This option used to be called -W. The older name is still supported, but the newer name is more descriptive. Falling off the end of the function body is considered returning without a value. To suppress the warning, cast the unused expression to void. For example, an expression such as x[i,j] will cause a warning, but x[ void i,j] will not.

According to the C Standard, this usage is obsolescent. This warning can be independently controlled by -Wmissing-field-initializers.

Floating point division by zero is not warned about, as it can be a legitimate way of obtaining infinities and NaNs. Warnings from system headers are normally suppressed, on the assumption that they usually do not indicate real problems and would only make the compiler output harder to read. Using this command line option tells GCC to emit warnings from system headers as if they occurred in user code.

However, note that using -Wall in conjunction with this option will not warn about unknown pragmas in system headersfor that, -Wunknown-pragmas must also be used. The idea behind this is that sometimes it is convenient for the programmer to consider floating-point values as approximations to infinitely precise real numbers.

In particular, instead of testing for equality, you would check to see whether the two values have ranges that overlap; and this is done with the relational operators, so equality comparisons are probably mistaken.

Traditional preprocessors would only consider a line to be a directive if the appeared in column 1 on the line. Therefore -Wtraditional warns about directives that traditional C understands but would ignore because the does not appear as the first character on the line.

It also suggests you hide directives like pragma not understood by traditional C by indenting them. Some traditional implementations would not recognize elif , so it suggests avoiding it altogether. Traditional C does support the L suffix on integer constants.

Note, these suffixes appear in macros defined in the system headers of most modern systems, e. This construct is not accepted by some traditional C compilers. This warning is only issued if the base of the constant is ten. Traditional C lacks a separate namespace for labels. If the initializer is zero, the warning is omitted. This is done under the assumption that the zero initializer in user code appears conditioned on e. The absence of these prototypes when compiling with traditional C would cause serious problems.

This is a subset of the possible conversion warnings, for the full set use -Wconversion. This warning is also bypassed for nested functions because that feature is already a GCC extension and thus not relevant to traditional C compatibility. With -funsafe-loop-optimizations warn if the compiler made such assumptions.

These warnings will help you find at compile time code that can try to write into a string constant, but only if you have been very careful about using const in declarations and prototypes. Otherwise, it will just be a nuisance; this is why we did not make -Wall request these warnings. This includes conversions of fixed point to floating and vice versa, and conversions changing the width or signedness of a fixed point argument except when the same as the default promotion. Also, warn if a negative integer constant expression is implicitly converted to an unsigned type.

But do not warn about explicit casts like unsigned This warning is also enabled by -Wextra ; to get the other warnings of -Wextra without this warning, use -Wextra -Wno-sign-compare. In languages where you can return an array, this also elicits a warning.

This will not stop errors for incorrect use of supported attributes. An old-style function definition is permitted without a warning if preceded by a declaration which specifies the argument types. A warning is given even if there is a previous prototype. This warning is issued even if the definition itself provides a prototype. The aim is to detect global functions that fail to be declared in header files.

Do so even if the definition itself provides a prototype. Use this option to detect global functions that are not declared in header files.

For example, the following code would cause such a warning, because x. To get other -Wextra warnings without this one, use -Wextra -Wno-missing-field-initializers. Note these are only possible candidates, not absolute ones. Care should be taken to manually verify functions actually do not ever return before adding the noreturn attribute, otherwise subtle code generation bugs could be introduced.

You will not get a warning for main in hosted C environments. GCC will guess that function pointers with format attributes that are used in assignment, initialization, parameter passing or return statements should have a corresponding format attribute in the resulting type.

GCC will also warn about function definitions which might be candidates for format attributes. Again, these are only possible candidates. GCC will guess that format attributes might be appropriate for any function that calls a function like vprintf or vscanf , but this might not always be the case, and some functions for which format attributes are appropriate may not be detected.

However, sometimes when characters outside the basic ASCII character set are used, you can have two different character sequences that look the same. To avoid confusion, the ISO standard sets out some normalization rules which when applied ensure that two sequences that look the same are turned into the same sequence. GCC can warn you if you are using identifiers which have not been normalized; this option controls that warning. There are four levels of warning that GCC supports.

NFC is the recommended form for most uses. It is hoped that future versions of the standards involved will correct this, which is why this option is not the default. You would only want to do this if you were using some other normalization scheme like D , because otherwise you can easily create bugs that are literally impossible to see.

Some characters in ISO have distinct meanings but look identical in some fonts or display methodologies, especially once formatting has been applied. This warning is comparable to warning about every identifier that contains the letter O because it might be confused with the digit 0, and so is not the default, but may be useful as a local coding convention if the programming environment is unable to be fixed to display these characters distinctly.

Such structures may be mis-aligned for little benefit. For instance, in this code, the variable f. Sometimes when this happens it is possible to rearrange the fields of the structure to reduce the padding and so make the structure smaller. This option is intended to warn when the compiler detects that at least a whole line of source code will never be executed, because some condition is never satisfied or because it is after a procedure that never returns.

It is possible for this option to produce a warning even though there are circumstances under which part of the affected line can be executed, so care should be taken when removing apparently-unreachable code. For instance, when a function is inlined, a warning may mean that the line is unreachable in only one inlined copy of the function.

This option is not made part of -Wall because in a debugging version of a program there is often substantial code which checks correct functioning of the program and is, hopefully, unreachable because the program does work.

Another common use of unreachable code is to provide behavior which is selectable at compile-time. Even with this option, the compiler will not warn about failures to inline functions declared in system headers. The compiler uses a variety of heuristics to determine whether or not to inline a function. For example, the compiler takes into account the size of the function being inlined and the amount of inlining that has already been done in the current function.

Therefore, seemingly insignificant changes in the source program can cause the warnings produced by -Winline to appear or disappear. Such as a simple struct that fails to be a POD type only by virtue of having a constructor. This flag is for users who are aware that they are writing nonportable code and who have deliberately chosen to ignore the warning about it. This is default. To inhibit the warning messages, use -Wno-long-long. Flags -Wlong-long and -Wno-long-long are taken into account only when -pedantic flag is used.

To inhibit the warning messages, use -Wno-variadic-macros. Often, the problem is that your code is too big or too complex; GCC will refuse to optimize programs when the optimization itself is likely to take inordinate amounts of time.

This option is only supported for C and Objective-C. It is implied by -Wall and by -pedantic , which can be disabled with -Wno-pointer-sign. It warns about functions that will not be protected against stack smashing.

GDB can work with this debugging information. On most systems that use stabs format, -g enables use of extra debugging information that only GDB can use; this extra information makes debugging work better in GDB but will probably make other debuggers crash or refuse to read the program.

GCC allows you to use -g with -O. The shortcuts taken by optimized code may occasionally produce surprising results: some variables you declared may not exist at all; flow of control may briefly move where you did not expect it; some statements may not be executed because they compute constant results or their values were already at hand; some statements may execute in different places because they were moved out of loops. Nevertheless it proves possible to debug optimized output. This makes it reasonable to use the optimizer for programs that might have bugs.

The following options are useful when GCC is generated with the capability for more than one debugging format. This means to use the most expressive format available DWARF 2, stabs, or the native format if neither of those are supported , including GDB extensions if at all possible. The use of these extensions is likely to make other debuggers crash or refuse to read the program.

The use of these extensions is likely to make other debuggers crash or refuse to read the program, and may cause assemblers other than the GNU assembler GAS to fail with an error. With this option, GCC uses features of DWARF version 3 when they are useful; version 3 is upward compatible with version 2, but may still cause problems for older debuggers.

The default level is 2. This includes descriptions of functions and external variables, but no information about local variables and no line numbers. Level 3 includes extra information, such as all the macro definitions present in the program.

Some debuggers support macro expansion when you use -g3. That debug format is long obsolete, but the option cannot be changed now. You must use this option when compiling the source files you want data about, and you must also use it when linking. During execution the program records how many times each branch and call is executed and how many times it is taken or returns. When the compiled program exits it saves this data to a file called auxname.

The data may be used for profile-directed optimizations -fbranch-probabilities , or for test coverage analysis -ftest-coverage. In both cases any suffix is removed e. The option is a synonym for -fprofile-arcs -ftest-coverage when compiling and -lgcov when linking. See the documentation for those options for more details. Tag Description bullet Compile the source files with -fprofile-arcs plus optimization and code generation options.

For test coverage analysis, use the additional -ftest-coverage option. You do not need to profile every source file in a program. This may be repeated any number of times. You can run concurrent instances of your program, and provided that the file system supports locking, the data files will be correctly updated. Also fork calls are detected and correctly handled double counting will not happen. Refer to the gcov documentation for further information. With -fprofile-arcs , for each function of your program GCC creates a program flow graph, then finds a spanning tree for the graph.

Only arcs that are not on the spanning tree have to be instrumented: the compiler adds code to count the number of times that these arcs are executed. When an arc is the only exit or only entrance to a block, the instrumentation code can be added to the block; otherwise, a new basic block must be created to hold the instrumentation code. Refer to the -fprofile-arcs option above for a description of auxname and instructions on how to generate test coverage data. Coverage data will match the source files more closely, if you do not optimize.

This is used for debugging the RTL-based passes of the compiler. The file names for most of the dumps are made by appending a pass number and a word to the dumpname. Most debug dumps can be enabled either passing a letter to the -d option, or with a long -fdump-rtl switch; here are the possible letters for use in letters and pass , and their meanings: Tag Description -dA Annotate the assembler output with miscellaneous debugging information.

The length of each instruction is also printed. Also turns on -dp annotation. Usually used with r -fdump-rtl-expand. This makes it more feasible to use diff on debugging dumps for compiler invocations with different options, in particular with and without -g. The file name is made by appending. If the - options form is used, options controls the details of the dump as described for the -fdump-tree options.

The file name is generated by appending a switch specific suffix to the source file name. The following dumps are possible: Tag Description all Enables all inter-procedural analysis dumps; currently the only produced dump is the cgraph dump. If the - options form is used, options is a list of - separated options that control the details of the dump. Not all options are applicable to all dumps, those which are not meaningful will be ignored.

The following options are available Tag Description address Print the address of each node. Usually this is not meaningful as it changes according to the environment and source file. Its primary use is for tying up a dump file with a debug environment. Only dump such items when they are directly reachable by some other path. When dumping pretty-printed trees, this option inhibits dumping the bodies of control structures. By default, trees are pretty-printed into a C-like representation.

The following tree dumps are possible: Tag Description original Dump before any tree based optimization, to file. Note that if the file contains more than one function, the generated file cannot be used directly by VCG. This file name is made by appending.

This information is written to standard error, unless -fdump-tree-all or -fdump-tree-vect is specified, in which case it is output to the usual dump listing file,. It is used to generate certain symbol names that have to be different in every compiled file. It is also used to place unique stamps in coverage data files and the object files that produce them. You can use the -frandom-seed option to produce reproducibly identical object files.

The string should be different for every file you compile. This information is written to standard error, unless -dS or -dR is specified, in which case it is output to the usual dump listing file,. However for n greater than nine, the output is always printed to standard error. For n greater than zero, -fsched-verbose outputs the same information as -dRS. For n greater than two, it includes RTL at abort point, control-flow and regions info.

And for n over four, -fsched-verbose also includes dependence info. Thus, compiling foo. This creates a preprocessed foo. When used in combination with the -x command line option, -save-temps is sensible enough to avoid over writing an input source file with the same extension as an intermediate file.

The corresponding intermediate file may be obtained by renaming the source file before using -save-temps. For C source files, this is the compiler proper and assembler plus the linker if linking is done. The output looks like this: cc1 0. The second number is system time, time spent executing operating system routines on behalf of the program. Both numbers are in seconds. It computes where variables are stored at each position in code.

Better debugging information is then generated if the debugging information format supports this information. It is enabled by default when compiling with optimization -Os , -O , -O2 , With this option, GCC does not compile or link anything; it just prints the file name. This is supposed to ease shell-processing. This is useful when you use -nostdlib or -nodefaultlibs but you do want to link with libgcc. This is useful when gcc prints the error message installation problem, cannot exec cpp0: No such file or directory.

This is used when GCC itself is being built. Sometimes this is useful, such as if, in the debugger, you want to cast a value to a type that is not actually used in your program but is declared. More often, however, this results in a significant amount of wasted space. With this option, GCC will avoid producing debug symbol output for types that are nowhere used in the source file being compiled.

Options That Control Optimization These options control various sorts of optimizations. Statements are independent: if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.

The compiler performs optimization based on the knowledge it has of the program. Optimization levels -O and above, in particular, enable unit-at-a-time mode, which allows the compiler to consider information gained from later functions in the file when compiling a function.

Compiling multiple files at once to a single output file in unit-at-a-time mode allows the compiler to use information gained from all of the files when compiling each of them. Not all optimizations are controlled directly by a flag.

Only optimizations that have a flag are listed. Tag Description -O -O1 Optimize. Optimizing compilation takes somewhat more time, and a lot more memory for a large function.

With -O , the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time. This option must be explicitly specified on the command line to be enabled for the Ada compiler. GCC performs nearly all supported optimizations that do not involve a space-speed tradeoff. The compiler does not perform loop unrolling or function inlining when you specify -O2.

As compared to -O , this option increases both compilation time and the performance of the generated code. It also turns on the following optimization flags: -fthread-jumps -fcrossjumping -foptimize-sibling-calls -fcse-follow-jumps -fcse-skip-blocks -fgcse -fgcse-lm -fexpensive-optimizations -fstrength-reduce -frerun-cse-after-loop -frerun-loop-opt -fcaller-saves -fpeephole2 -fschedule-insns -fschedule-insns2 -fsched-interblock -fsched-spec -fregmove -fstrict-aliasing -fdelete-null-pointer-checks -freorder-blocks -freorder-functions -falign-functions -falign-jumps -falign-loops -falign-labels -ftree-vrp -ftree-pre Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos.

This is the default. It also performs further optimizations designed to reduce code size. Options of the form -f flag specify machine-independent flags. Most flags have both positive and negative forms; the negative form of -ffoo would be -fno-foo. In the table below, only one of the forms is listedthe one you typically will use. You can figure out the other form by either removing no- or adding it. The following options control specific optimizations.

They are either activated by -O options or are related to ones that are. You can use the following flags in the rare cases when fine-tuning of optimizations to be performed is desired. Otherwise, when you specify -O , member functions defined inside class scope are compiled inline by default; i. For machines which must pop arguments after a function call, the compiler normally lets arguments accumulate on the stack for several function calls and pops them all at once.

Disabled at levels -O , -O2 , -O3 , -Os. This produces better code by making all memory references potential common subexpressions. When they are not common subexpressions, instruction combination should eliminate the separate register-load.

This option is now a nop and will be removed in 4. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. It also makes debugging impossible on some machines.

Enabled at levels -O , -O2 , -O3 , -Os. Enabled at levels -O2 , -O3 , -Os. Normally this option is used to keep the compiler from expanding any functions inline. Note that if you are not optimizing, no functions can be expanded inline.

The compiler heuristically decides which functions are simple enough to be worth integrating in this way. If all calls to a given function are integrated, and the function is declared static , then the function is normally not output as assembler code in its own right. Enabled at level -O3. If a call to a given function is integrated, then the function is not output as assembler code in its own right. Enabled if -funit-at-a-time is enabled.

Doing so makes profiling significantly cheaper and usually inlining faster on programs having large chains of nested wrapper functions. Enabled by default. This flag allows the control of this limit for functions that are explicitly marked as inline i.

The default value of n is Increasing this value can result in more inlined code at the cost of compilation time and memory consumption. Decreasing usually makes the compilation faster and less code will be inlined which presumably means slower programs. See below for a documentation of the individual parameters controlling inlining. In no way does it represent a count of assembly instructions and as such its exact meaning might change from one release to an another. This switch does not affect functions using the extern inline extension in GNU C.

GCC enables this option by default. If you want to force the compiler to check if the variable was referenced, regardless of whether or not optimization is turned on, use the -fno-keep-static-consts option. This option is the default for optimized compilation if the assembler and linker support it. Use -fno-merge-constants to inhibit this behavior. This option implies -fmerge-constants.

In addition to -fmerge-constants this considers e. This pass looks at innermost loops and reorders their instructions by overlapping different iterations. The default is -fbranch-count-reg , enabled when -fstrength-reduce is enabled. This option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used.

This can save space in the resulting code. This option turns off this behavior because some programs explicitly rely on variables going to the data section. The default is -fzero-initialized-in-bss. The instrumentation relies on a separate runtime library libmudflap , which will be linked into a program if -fmudflap is given at link time.

Use -fmudflapth instead of -fmudflap to compile and to link if your program is multi-threaded. Use -fmudflapir , in addition to -fmudflap or -fmudflapth , if instrumentation should ignore pointer reads.

This produces less instrumentation and therefore faster execution and still provides some protection against outright memory corrupting writes, but allows erroneously read data to propagate within a program. If so, the first branch is redirected to either the destination of the second branch or a point immediately following it, depending on whether the condition is known to be true or false. For example, when CSE encounters an if statement with an else clause, CSE will follow the jump when the condition tested is false.

When CSE encounters a simple if statement with no else clause, -fcse-skip-blocks causes CSE to follow the jump around the body of the if. This pass also performs global constant and copy propagation. Note: When compiling a program using computed gotos, a GCC extension, you may get better runtime performance if you disable the global common subexpression elimination pass by adding -fno-gcse to the command line.

Enabled by default when gcse is enabled. This pass will attempt to move stores out of loops. Not enabled at any optimization level. The purpose of this pass is to cleanup redundant spilling.

The optimizations loop unrolling, peeling and unswitching, loop invariant motion are enabled by separate flags. This enables a wider range of loop optimizations even if the loop optimizer itself cannot prove that these assumptions are valid.

Using -Wunsafe-loop-optimizations , the compiler will warn you if it finds this kind of loop. This transformation unifies equivalent code and save code size. The resulting code may or may not perform better than without cross-jumping. This include use of conditional moves, min, max, set flags and abs instructions, and some tricks doable by standard arithmetics. The use of conditional execution on chips where it is available is controlled by if-conversion2.

The compiler assumes that dereferencing a null pointer would have halted the program. If a pointer is checked after it has already been dereferenced, it cannot be null.

In some environments, this assumption is not true, and programs can safely dereference null pointers. Use -fno-delete-null-pointer-checks to disable this optimization for programs which depend on that behavior.

This is especially helpful on machines with two-operand instructions. Note -fregmove and -foptimize-register-move are the same optimization. This helps machines that have slow floating point or memory load instructions by allowing other instructions to be issued until the result of the load or floating point instruction is required.

This is especially useful on machines with a relatively small number of registers and where memory load instructions take more than one cycle. This is normally enabled by default when scheduling before register allocation, i. This only makes sense when scheduling before register allocation, i.

If n is unspecified then there is no limit on how many queued insns can be moved prematurely. This has an effect only during the second scheduling pass, and only if -fsched-stalled-insns is used and its value is not zero. Superblock scheduling allows motion across basic block boundaries resulting on faster schedules. This option is experimental, as not all machine descriptions used by GCC model the CPU closely enough to avoid unreliable results from the algorithm. This only makes sense when scheduling after register allocation, i.

See -ftracer for details on trace formation. This mode should produce faster but significantly longer programs. Also without -fbranch-probabilities the traces constructed may not match the reality and hurt the performance.

Such allocation is done only when it seems to result in better code than would otherwise be produced. This option is always enabled by default on certain machines, usually those which have no call-preserved registers to use instead. This flag is enabled by default at -O2 and -O3. This analysis faster than PRE , though it exposes fewer redundancies. This flag is enabled by default at -O and higher.

This pass eliminates unnecessary copy operations. This pass eliminates unnecessary copy operations in memory references structures, global variables, arrays, etc. This flag is enabled by default at -O2 and higher. This pass only operates on local scalar variables and is enabled by default at -O and higher. This pass operates on both local scalar variables and memory stores and loads global variables, structures, arrays, etc.

This also performs jump threading to reduce jumps to jumps. This is beneficial since it increases effectiveness of code motion optimizations. It also saves one jump. It is not enabled for -Os , since it usually increases code size. This flag can improve cache performance and allow further loop optimizations to take place. This pass moves only invariants that would be hard to handle at RTL level function calls, operations that expand to nontrivial sequences of insns. With -funswitch-loops it also moves operands of conditions that are invariant out of the loop, so that we can use just trivial invariantness analysis in loop unswitching.

The pass also includes store motion. Later optimizations then may determine the number easily. Useful especially in connection with unrolling. This pass replaces structure references with scalars to prevent committing structures to memory too early. This pass attempts to rename compiler temporaries to other variables at copy locations, usually resulting in variable names which more closely resemble the original variables. This is enabled by default at -O and higher. Distinct live ranges of a variable are split into unique variables, allowing for better optimization later.

When a loop appears to be vectorizable except that data alignment or data dependence cannot be determined at compile time then vectorized and non-vectorized versions of the loop are generated along with runtime checks for alignment or dependence to control which version is executed.

This option is enabled by default except at level -Os where it is disabled. This is similar to the constant propagation pass, but instead of values, ranges of values are propagated. This allows the optimizers to remove unnecessary range checks like array bound checks and null pointer checks. This is enabled by default at -O2 and higher. About Us. Privacy Policy. Video library We are building a growing library of educational videos available for re-use by educators worldwide, online or in classrooms.

Introducing How AI Works. Share on Facebook Share on Twitter. What is Machine Learning? Neural Networks. Computer Vision. Introducing How Computers Work. What Makes a Computer, a Computer? Binary and Data.

Circuits Logic. Hardware and Software. What is the internet? Computer science in Data and Medicine. This is a 3-part assignment. You need to say o the file name, assignment numbe…. You need to say o the file name, assignment number 1 , due date, your name, your student ID o describe what the program does in English , o state the status of the program. It should create a hw1 directory with the same content as the original.

There is a space and a dot. The output can print all entries on the same line. Part 2: Write a C program that asks the user to type in the starting and ending values and then prints the ASCII table entries using a for-loop. Assume the user types two valid integers within range separated by space.

Part 3: Write a C program that uses a printf statement to print the source code to your program in Part 2.