Compile command (QNX Neutrino, QNX 4)
For C:
qcc [options] [operands]
For C++:
QCC [options] [operands]
QNX Neutrino, Linux, Microsoft Windows
The development tools have been designed to work out of their
processor directories (x86, ppcbe, etc.).
This means you can use the same tool set for any target platform.
If you have development libraries for a certain platform, put them into the platform-specific library directory (e.g. /x86/lib), which is where the compiler tools look by default. Don't put the libraries in /lib or /usr/lib, which are ignored. Alternatively, use the -L option to specify the libraries' location. |
You can specify more than one -l option. The qcc configuration files might specify some libraries for you; for example, qcc usually links against libc.
You need to link C++ programs with the -lang-c++ option in order for exceptions to work. |
Note that the make utility, when used with the default settings,
produces an output file with the same name as the input file. For example:
make file1 results in the executable output file file1. |
qcc -V3.3.5,gcc_ntoppcbe -set-default
will set GCC 3.3.5 for PPC big-endian as the default.
You must be root to use the -set-default option. Note also that the option is intended for use at the command line, not for makefiles. |
If you specify the target, qcc looks for the target configuration files in the following paths, according to how compiler, version, and target are specified:
If you specify: | qcc looks here: |
-Vtarget | ${QCC_CONF_PATH}/compiler/version (where compiler is inferred from target, and version is the default). |
-Vversion,target | ${QCC_CONF_PATH}/compiler/version (where compiler is inferred from target; if that path doesn't exist, or if version contains a slash [/], then ${QCC_CONF_PATH}/version is used). |
-Vcompiler,target | ${QCC_CONF_PATH}/compiler/version (where version is the specified compiler's default version). |
-Vcompiler/version,target | ${QCC_CONF_PATH}/compiler/version |
For example, this command:
qcc -Vgcc,
lists all targets in all versions of gcc. See the Examples section below for more examples.
The targets include:
For a list of supported targets, specify -V (or -Vcompiler or -Vcompiler/version or -Vversion, provided there's a valid ${QCC_CONF_PATH}/version directory).
For example, if you want to pass the -MD option to the compiler, specify -Wc,-MD on the command line for qcc.
If you specify -w along with multiple warning options, all warnings are suppressed regardless of the order of the options. In other words, -w always wins. |
Note that using these options will produce warnings in the standard C++ library headers, and possibly other system headers.
as well as valid file extensions, such as .c, .cc, .cpp, .C, .i, .ii, .s, and .S.
Use -xnone to go back to normal suffix typing. For example, to compile myfile.h as if it were a .c file:
qcc -xc myfile.h
Even with exceptions disabled, the new() operator throws a std::out_of_memory exception if there isn't enough memory. If you want new() to return NULL instead of throwing an exception, overload the new() operator with your own. |
QCC and qcc are the QNX compiler interface. They're based on the POSIX c89 utility. By default, QCC considers a program to be C++, while qcc considers it to be C.
QCC and qcc take a list of source and object modules on the command line and invokes the appropriate parser to compile each file. Object modules are passed straight through to the linker. The file suffix determines which parser is used, as follows:
Suffix | Parser |
---|---|
.s | Assembler |
.S | Assembler with preprocessor directives |
.c | C compiler |
.i | Preprocessed C file |
.C, .cc, .cpp | C++ compiler |
.ii | Preprocessed C++ file |
.o | Object file |
.a | Library file |
These utilities don't allow multiple options to be specified after a dash character (-). For example, -gc isn't valid; you must specify -g -c instead. Operands (source and object files) and options may be mixed and specified in any order. Some options, such as -I and -L, are order-dependent—the order in which they appear in the command line determines the order of the searches made. All command-line arguments are processed before any compilation or linking begins.
The single-pass linker resolves symbols from left to right: If a module refers to a symbol that is contained in a library, make sure you specify the library to the right of the module. |
When qcc encounters a compilation error that stops an object file from being created, it writes a diagnostic to the standard error and continues to compile other source files, but it bypasses the link phase and returns a nonzero exit status. If the link phase is entered and is unsuccessful, a diagnostic is written and qcc exits with a nonzero status.
The -c option suppresses the link phase. If you have many separate source files that you must update and modify individually, you'll probably use the -c option frequently.
You may occasionally wish to examine the assembly code produced by the code generator. The -S option produces an assembly file ending in .s.
If you need to specify a parameter to any of the language processors, you may use the -W c,option. Check the documentation on each processor to determine its options.
The compiler defines various preprocessor symbols (or manifest constants) that can help you make decisions at compile time. For more information, see the Manifests chapter of the Library Reference.
Here's how to profile your application, so you can see where it's spending its time:
make CCOPTS+=-p LDOPTS+=-p
gprof [your_app] | less
For more information, see the GNU documentation for gprof, and Profiling an Application in the IDE User's Guide.
Compile myfile.c and create a 32-bit executable program for QNX Neutrino on an Intel x86 machine in the current directory with the name a.out:
qcc -Vgcc_ntox86 myfile.c
Compile myfile.c and create a 32-bit executable program for QNX Neutrino on an Intel x86 machine in the current directory with the name myfile:
qcc -Vgcc_ntox86 -o myfile myfile.c
Use the default compiler, version, and target:
qcc
The default compiler is gcc, the default version of the compiler is 4.2, and the default target is ntox86. |
Use the default version of the compiler, and build for an ARM little-endian target:
qcc -Vgcc_ntoarmle
Use the 3.3.5 version of the compiler, and build for a PPC big-endian target:
qcc -V3.3.5,gcc_ntoppcbe
Use make to compile myfile.c and create an executable program in the current directory with the name myfile:
make myfile
Make a shared library:
qcc -Vgcc_ntox86 -shared -c shared.c qcc -Vgcc_ntox86 -shared -o libshared.so shared.o
Compiling and Debugging chapter of the Neutrino Programmer's Guide
Manifests chapter of the Library Reference