nix

• By default, gcc compiles the source code, assembles the assembly language code the compiler produces, and invokes the UNIX loader, Id, to produce an executable file.
• 
• Preprocessing: This step resolves directives like #define, #include, and #if. Like many UNIX systems, gcc invokes a separate utility called cpp to do the preprocessing.
• Compilation: This produces assembly language from the input files; since the assembler is usually invoked right away, the output is not normally saved in files.
• Assembly: This takes the assembly language as input and produces object files with extensions. While some compilers build in the assembly capability, gcc does it by internally invoking a separate utility called the assembler, gas. GNU assemblers aren't available for all architectures; if the GNU assembler isn't available, gcc invokes the "native" assembler (as).
• Linking: This is the final stage, where the modules are placed in their proper places in the executable file. Library functions that the program refers to are also placed in the file. (Systems with shared libraries use a slightly more complicated method.)
  UNIX compilers perform this phase by internally invoking the linker, which is called ld.
• gcc also cleans up by deleting any object files that it created from source files (but not any pre-existing object files that you specified on the command line).
• ld stands for "link editor" initially, but we haven't heard anybody use this term for years. In some early UNIX documentation, ld is also called a "loader," which can be confusing because most people think of loading as reading the executable file into memory at run time.
• General options:

-o	Naming the output (executable) file.
-c	Compiler but do not link, produce object files.
-Dname	Acts like #define in the source code.
-Uname	Acts like #undef in the source code.
-Ipath	Include file in a non-standard directory. Ex: gcc -c -I../headsrs filter_driver.c
-llibname   -Llibpath	Linking with libraries, -l must be specified at the end of the command, after the filenames, while all other options are specified before the filenames. When specify -Iname, the system searches for libname.a or libname.so in the directory where the system stores its standard libraries, normally /usr/lib. Ex: -lg++ stands for libg++.a or libg++.so Use the -L option to make gcc look in a particular directory for libraries. Ex: gcc -o plot -L/src/local/lib main.o plot_line.o -Im
-v	Verbose
-w	Suppress all warning messages.
-W	Produce some additional warning messages about legal (but questionable) coding practices.
-Wall	Produce even more warning messages about questionable coding practices.
-Wtraditional	Produce warning messages about code that is legal in both the "Kernighan and Ritchie" and ANSI definitions of the C language, but behaves differently in each case.
-Werror	Make all warnings into errors; that is, don't attempt to produce an object file if a warning has occurred.
-save-temps	Save all intermediate files.

• UNIX linkers search libraries in the order in which they occur on the command line and only resolve the references that are outstanding at the time the library is searched.
• How gcc handles files:

Filename	Interpretation	Action
file.c	C source	Preprocessed and compiled by gcc
file.C	C++ source	Preprocessed and compiled by g++
file.cc	C++ source	Preprocessed and compiled by g++
file.i	Preprocessed C source	Compiled by gcc
file.ii	Preprocessed C++ source	Compiled by g++
file.s	Assembly language source	Assembled by as
file.S	Assembly language source	Preprocessed and assembled by as
file.o	Compiled object module	Passed to Id
file.a	Object module library	Passed to Id

• All other files, together with options that gcc does not recognize, are passed to ld.
• If writing C++ code, use the g++ command instead of gcc. The same compiler is invoked, but the compiler expects C++ instead of regular C source code. Also, g++ uses different default libraries.
• Output Files at Each Stage of Compilation:

preprocessing	-E
compilation	-S
assembly	-c

• The GNU version of make: gmake, gnumake.
• The ANSI C standard and "traditional" (Kernighan and Ritchie) C both accept prototypes and define the behavior of the preprocessor-either explicitly or implicitly. Therefore, the options (-traditional, -ansi) affect both cpp and gcc.

-traditional	Supports the traditional C language, including lots of questionable, but common, practices. The traditional option also supports all of the FSF's extensions to the C language.
-ansi	Supports the ANSI C standard, though somewhat loosely. The FSF's extensions are recognized, except for a few that are incompatible with the ANSI standard. Thus, ANSI programs compile correctly, but the compiler doesn't try too hard to reject non-conformant programs, or programs using non-ANSI features.
-pedantic	Issues all the warning messages that are required by the ANSI C standard. Forbids the use of all the FSF extensions to the C language and considers the use of such extensions errors. Use __extension__ before the expression to avoid warnings for GNU c extensions.

• Preprocessor options:

-M	Read the source files, figure out which other files they include, and output lists of dependencies for make. The dependency lists are sent to standard output, and compilation doesn't proceed past preprocessing (i.e., -M implies -E).
-C	The preprocessor normally deletes all comments from the program. With -C, it doesn't. The -C option doesn't automatically imply -E, but gcc won't let you use –C on the command line unless -E is also present.

• Options to specify libraries:

-nostartfiles	Don't use the standard system startup files when linking. This is useful for cross-compilation, or for compiling code for an embedded processor, where you may want to provide your own startup file.
-nostdlib	Don't use the standard libraries and startup files when linking.
-static	Link only to static libraries, not shared libraries.
-shared	If shared libraries are available, use them wherever possible, rather than static libraries. (This is the default.)

• Debugging and profiling options:
  These options request the compiler to create additional code and an expanded symbol table for the various profilers and debuggers (dbx, prof, gprof, and the branch count profiler).

-p	Link the program for profiling with prof. When you execute a program compiled with this option, it produces a file named mon.out that contains program execution statistics. The profiler prof reads this file and produces a table describing your program's execution.
-pg	Link the program for profiling with gprof. Executing a program compiled with this option produces a file named gmon.out that includes execution statistics. The profiler gprof reads this file and produces detailed information about your program's execution.
-g	Generate an expanded symbol table for debugging, the additional symbols tell the assembler where to find the source code. If you need to use your system's native debugger, and you have trouble with -g, try -gstabs for dbx on BSD UNIX systems; -gcoff for sdb under SVR3 and earlier releases of System V; -gxcoff for dbx on the RS/600a0n;d -gdwarf for sVR4 debuggers.

• Optimization:

-O0	No optimization. This is the default.
-O1/-O	The compiler tries to reduce both the size of the compiled code and the execution time.
-O2	Enables more optimizations than -01.
-ffast-math	Make floating-point arithmetic optimizations that violate the ANSI or IEEE standards. Code compiled with this option may yield incorrect results-but it will be slightly faster. Seriously: carefully written code shouldn't run into trouble.
-finline-functions	Expand all "simple functions" into their callers. The compiler gets to decide whether any function is "simple" or not. Inline expansion is a two-edged sword.
-fno-inline	Inhibit all inlining, even inlining that is requested by the inline keyword in the source code. gcc performs inlining according to statements in the source code with both -O1 and -O2; the keyword is ignored if optimization isn't in effect.
-funroll-loops	On some architectures, loop unrolling can be a very important optimization. With the -funroll-loops option, gcc unrolls all loops that have a fixed iteration count known at the time of compilation. Loop unrolling is another risky optimization.

• The inline keyword, used in the declaration or definition of a function, is a gcc extension to the C language. It requests inline expansion for the function. If you compile with -ansi or -traditional, the inline keyword is not allowed, but you can use __inline__ instead.
• Passing options to the assembler or linker
  gcc allows you to pass options directly to the assembler or linker when they are invoked. There must not be any spaces in the list; options in the list are separated by commas.

-Wa,option-list	Pass the option-list to the assembler. Ex: gcc –c –g –Wa,-alh,-L source.c, producing a listing of the assembly language generated, together with C source listings, -L stands for retain local labels.
-Wl,option-list	Pass the option-list to the linker.

• as list-of-options list-of-source-files
  The list-of source-files can contain the special name --, which means “Read standard input for assembly source code”.

-ah	Generate a listing of the high-level code only. (Only possible if the object file was compiled with gcc's -g option).
-al	Generate a listing of the assembly language code only.
-as	Generate a listing of the symbol table only.

• ld list-of-options list-of-files-and-libraries.
• The linker processes the list-of-files-and-libraries in order. When it reaches a library, it extracts only those modules that it currently needs to resolve external references.
• User generated library should contain an index, so that the linker can find each module regardless of its order within the library. Some systems always generate an index when you create or modify the library with the ar command (the GNU ar does this). On other systems you have to put in the index yourself by using the ranlib command.
• For creating an executable file, the beginning of the first file in the list-of-files must be the program's entry point. Before the program begins executing, the computer must execute a standard run-time initialization routine. To ensure that this is in place, usr/lib/crt0.o must be the first file in the list-of--files. This ensures that this initialization routine is linked to your program. Alternatively, you can link by using the gcc command without any C source files.
• Linker options:

-o name	Instead of naming the executable output file a.out, name it name.
-Ilibname	Link the program to the library named libname.a. The linker looks in the directories /lib and /usr/Iib to find this library.
-Llibpath	To find any libraries, look in the directory dir before looking in the standard library directories /lib and /usr/lib.
-s	Remove the symbol table from the executable output file. Using the program strip has the same effect.
-x	Remove all local symbols from the output file. Global symbols (subprograms and common block names) remain in the output file. Ignored unless -s is specified.
-n	Make the text segment read-only.
-r	Create an object file that can be included in further linking runs (i.e., further passes through ld). Among other things, this inhibits "Undefined symbol" messages and prevents ld from creating common storage immediately. If you wish to create common storage at this time, use the -d option also.
-e name	Use the symbol name (address, symbol offset+section_name) as the entry point to the executable program. By default, the entry point is the beginning of the first object module. gcc automatically links your object files with a run-time initialization module (/usr/lib/crt0.o that starts your program and provides its initial entry point. If you run the linker separately, you must either put /usr/lib/crt0.o at the start of your object files, or provide your own entry point.
-M	Produce a "load map" that shows where each function is located in the resulting object file, where each section begins and ends, and the value of each global symbol.
-b format	Read object modules in the given format. To get a list of formats that Id understands, give the command objdump -i.
-oformat format	Create object modules in the given format.

• Link-order optimization: By changing the link order, you're changing the way the executable file "lies" in the instruction cache.
• ar rs lib-name list-of-files        /* Create a new library */
  The option r indicates that the command ar should add the files named in the list-of-files to the library named lib-name, creating a new library if necessary. If a file is mentioned twice in the list-of-files, ar includes it in the archive twice. The s option tells ar to produce an index for the archive; this is the function that ranlib would perform. If you include the s option whenever you create or modify a library, you'll never need to use ranlib.
• ar rus lib-name list-of-files     /* Update a library */
  This compares the dates of any listed files with the version of the file in the library. If the file in list-files is more recent than the version contained in the library, ar substitutes the newer version for the older version.
• ar ds lib-name list-of-files       /* Delete one or more files form a library */
  This deletes all the files found in list-of-files.
  ar x lib-name list-of-files         /* Extract one or more files form a library */
  This does not modify the library file itself. It extracts the files named in the list-of-files from the library, regenerating them in the current directory with their original names. Normally, the timestamp of the extracted files is the time at which ar recreated them. If you use the option xo instead of x, ar sets the timestamp of the extracted files to the time recorded in the archive.
• Cross-compilation needs: cross-compiler, assembler, linker, header files, libraries, and run-time startup files (crt0.o for UNIX system) for the target architecture.