Go to main content
Oracle® Developer Studio 12.6: C++ User's Guide

Exit Print View

Updated: July 2017

2.4 Compiling and Linking

This section describes some aspects of compiling and linking programs. In the following example, CC is used to compile three source files and to link the object files to produce an executable file named prgrm.

example% CC file1.cc file2.cc file3.cc -o prgrm

2.4.1 Compile-Link Sequence

In the previous example, the compiler automatically generates the loader object files (file1.o, file2.o, and file3.o) and then invokes the system linker to create the executable program for the file prgrm.

After compilation, the object files (file1.o, file2.o,and file3.o) remain. This convention enables you to easily relink and recompile your files.

Note -  If only one source file is compiled and a program is linked in the same operation, the corresponding .o file is deleted automatically. To preserve all .o files, do not compile and link in the same operation unless more than one source file gets compiled.

If the compilation fails, you will receive a message for each error. No .o files are generated for those source files with errors, and no executable program is written.

2.4.2 Separate Compiling and Linking

You can compile and link in separate steps. The -c option compiles source files and generates .o object files, but does not create an executable. Without the -c option, the compiler invokes the linker. By splitting the compile and link steps, a complete recompilation is not needed just to fix one file. The following example shows how to compile one file and link with others in separate steps:

example% CC -c file1.cc         Make new object file
example% CC -o prgrm file1.o file2.o file3.o       Make executable file

Be sure that the link step lists all the object files needed to make the complete program. If any object files are missing from this step, the link will fail with “undefined external reference” errors (missing routines).

Libraries and object files created with an earlier release of a Studio compiler can be used when linking with a later compiler release. When you link a mixed set of object files and libraries created with different releases of Studio compilers, you must use the most recent compiler that produced any of the object files or libraries being linked.

2.4.3 Consistent Compiling and Linking

If you compile and link in separate steps, consistent compiling and linking is critical when using the compiler options listed in Compile-Time and Link-Time Options.

If you compile a subprogram using any of these options, you must link using the same option as well:

  • If you compile with the -library or -m64/-m32 options, you must include these same options on all CC commands.

  • If you compile with -compat or -std options, you must include the same or equivalent options on all CC commands. For example, -compat=5 and -std=sun03 are equivalent.

  • With -p, -xpg, and -xprofile, including the option in one phase and excluding it from the other phase will not affect the correctness of the program, but you will not be able to do profiling.

  • With -g[n] and -xdebuginfo, including the option in one phase and excluding it from the other phase will not affect the correctness of the program, but it will affect the ability to debug the program. Any module that is not compiled with either of these options but is linked with -g[n] or -xdebuginfo will not be prepared properly for debugging. Note that compiling the module that contains the function main with the –g[n] option or the -xdebuginfo option is usually necessary for debugging.

In the following example, the programs are compiled using the -library=stlport4 compiler option.

example% CC -library=stlport4 sbr.cc -c
example% CC -library=stlport4 main.cc -c
example% CC -library=stlport4 sbr.o main.o -o myprogram 

If you do not use -library=stlport4 consistently, some parts of the program will use the default library, and others will use the optional replacement STLport library. The resulting program might not link, and would not in any case run correctly.

If the program uses templates, some templates might get instantiated at link time. In that case, the command-line options from the last line (the link line) will be used to compile the instantiated templates.

2.4.4 Compiler Command-Line Diagnostics

The -V option displays the name and version number of each program invoked by CC. The -v option displays the full command lines invoked by CC.

The —verbose=%all displays additional information about the compiler.

Any arguments on the command line that the compiler does not recognize are interpreted as linker options, object program file names, or library names.

The basic distinctions are:

  • Unrecognized options, which are preceded by a dash () or a plus sign (+), generate warnings.

  • Unrecognized nonoptions, which are not preceded by a dash or a plus sign, generate no warnings. However, they are passed to the linker. If the linker does not recognize them, they generate linker error messages.

In the following example, note that -bit is not recognized by CC and the option is passed on to the linker (ld), which tries to interpret it. Because single letter ld options can be strung together, the linker sees -bit as -b -i -t, all of which are legitimate ld options. This result might not be what you intend or expect:

example% CC -bit move.cc      -bit is not a recognized compiler option
CC: Warning: Option -bit passed to ld, if ld is invoked, ignored otherwise

In the next example, the user intended to type the CC option -fast but omitted the leading dash. The compiler again passes the argument to the linker, which in turn interprets it as a file name:

example% CC fast move.cc           < -  The user meant to type -fast
ld: fatal: file fast: cannot open file; errno=2
ld: fatal: File processing errors. No output written to a.out

2.4.5 Understanding the Compiler Organization

The C++ compiler package consists of a front end, optimizer, code generator, assembler, template prelinker, and link editor. The CC command invokes each of these components automatically, if needed, unless you use command-line options to specify otherwise.

Because any of these components may generate an error, and the components perform different tasks, identifying the component that generates an error might be helpful. Use the -v and -dryrun options to display more detail during compiler execution.

The following table shows the various compiler components.

Table 2  Components of the C++ Compilation System
Notes on Use
Front end (compiler preprocessor and compiler)
Code optimizer
-xO[2-5], -fast
(SPARC) Inline expansion of assembly language templates
.il file specified
(SPARC) Code generator, inliner, assembler
(x86) Code generator
Template prelinker
Used only with the -instances=extern option
link editor