Compile Options from Earlier Versions of VisualAge C++ (AIX)

VisualAge C++ includes both an incremental compiler that replaces the traditional C++ compiler supplied in earlier versions of the product, and a C compiler. The old form of options are no longer used. For both C and C++, you control the compile and link stages of build by specifying options in a configuration file.

The syntax of configuration file options indicates whether the option relates to code generation, optimization, the C or C++ language, the link stage, or other features of builds.

The table below gives the configuration file option equivalent to compile options of C Set ++ version 3.1.4. In an incremental C++ compile, not all the old options are meaningful, some are automatic, and the functionality of others is provided in a different way. An entry of N/A in the table indicates that an equivalent new option is not available. Whether the new option applies only to C or only to C++ code in this version of VisualAge C++ is indicated in the description column.

In the option syntax, the characters [ and ] enclose optional items, and the character | indicates alternatives. For example, Fm[+|-] is equivalent to Fm+, Fm-, or Fm.

Old Option Description Configuration File Option
-# Display language commands but do not invoke them; output goes to stdout. N/A
-+ Treat .c files as C++ source code. N/A
-a Produce test coverage information; output goes to .d file. N/A
-ae Produce test coverage information, exception C++ exception handling to disrupt the normal flow of control; output goes to .d file. N/A
-B Construct alternate compiler/assembler/linkage editor program names. N/A
-bbigtoc
-bnobigtoc
Generates extra code when the size of the table of contents (TOC) grows to a size greater than 64KB. link(bigTOC, yes)
link(bigTOC, no)
-bD:number
-bmaxdata:number
Set the size of the heap in bytes. The first number specifies the total virtual address space to reserve. The second number the amount of physical memory to commit initially. link(heap, number)
-bdynamic
-bstatic
Determines which types of library files are searched by linkage editor. link(linkWithSharedLib[,yes])
link(linkWithSharedLib,no)
-bI:filename   supported as a source in the configuration:
source type(imp) "filename"
or
source "filename.imp"
-blibpath:string Override search path. link(libPathOut, string)
-bnoentry Specify that the address of the symbol is the start address of the executable module being built. link(entry,no)
-bnso or -bnautoimp
-bso or -bautoimp
Specifies if unstripped, shared objects are statically linked as ordinary object files. link(static, yes)
link(static, no)
-brtl Tells the linkage editor to accept both .so and .a library file types. N/A
-c Do not send object files to the linkage editor. N/A
-C Preserve comments in preprocessed output. pp(preprocessOnly)
pp(preserveComments)
-D<name>[=<def>] Define <name> as in #define directive. If <def> is not specified, 1 is assumed. define(...)
-Dname[=[value]] Define preprocessor macro. define(macro_name[, string])
-Wl,-Dnumber Set the starting address for the data section of the output file to number. link(dataStart, number)
-E Preprocess but do not compile. Output goes to stdout. pp(preprocessOnly)
pp(stdout)
-ename Specify that the address of the symbol is the start address of the executable module being built. link(entry, string)
-F Use alternate configuration file, etc. supported as a vacbld command option
-F<x>[:<stanza>] Use alternate configuration file, etc. supported as a vacbld command option
stanzas also supported by defaults(stanza)
-g Include traditional debug option. link(debug[, yes])
link(debug, no)
-Hnumber Set the address alignment for all loadable segments so that the start of each segment is aligned at a multiple of the specified number of bytes. link(alignAddr, number)
-I Specify #include search paths. incl(searchpath, path)
-I<dir> Search in directory <dir> for include files that do not start with an absolut path. include(searchPath,string)
-I<key> Search the specified library file, where <key> selects the file lib<key>.a. N/A
-K
-z
  N/A
-lname   N/A
-Lstring Specify search path for library files. link(libSearchPath,string)
-ma Generate inline calls to the "alloca" function as if "#pragma alloca" directives were in the source file. N/A
-M Generate information to be included in a "make" description file; output goes to .u file. file(makeDep[,yes])
-o Name generated executable or object file. N/A
-o<name> Name generated executable or object file. file(genObject[,yes])
file(genObject,string)
file(genObject,no)
-O
-O2
-O3
Optimize code. opt(level, number)
-O4 Equivalent to -O3 -qipa with automatic detection of architecture and tuning option. N/A
-p
-pq
Enable code for performance analysis. gen(profile[, yes])
-pg Generate profiling support code including BSD profiling support. gen(profile, bsd)
link(debug[,yes])
-P Preprocess but do not compile. Output goes to .i file. pp(preprocessOnly[,yes])
-Q Inline specified user functions. opt(inline[, yes])
opt(inline, no)
opt(autoInline[, yes])
opt(autoInline, no)
opt(autoInlineLimit)
-Q!
-qnoinline
Do not inline any function. opt(inline, no)
opt(autoInline, no)
-Q=<lc>
-qinline=<lc>
Inline if number of source statement in function is less than the number specified in <lc>. opt(inline)
opt(autoInline)
opt(autoInlineLimit)
-Q-<nm>
-qinline-<nm>
Not inline function listed by names in <nm>. opt(inline[, yes])
opt(autoInline)
opt(noInlineFunc,name)
-Q+<nm>
-qinline+<nm>
Attemp to inline funtion listed by names in <nm>.

opt(inline[, yes])
opt(inlineFunc,name)

-qalias=<typ|allp|addr|ansi> Specifies the aliasing assertion to be applied to your compilation unit. The available options are:

typ= Pointers to different types are never aliased.

allp= Pointers are never aliased.

addr= Variables are disjoint from pointers unless their address is taken.

ansi= Pointers can only point to an object of the same type. Require -O option.
opt(alias,...)
-qalign=option Specify alignment of data items. gen(align, option)
-qansialias
-qnoansialias
Specify which aliasing rules can be used during optimization. opt(alias, ...)
-qarch=name
-qarch=<com|pwr|pwr2|pwrx|ppc|ppcgr>
Specifies the architecture on which the executable program will be run. The available options are:

com= Produce an object that contains instructions that will run on all the POWER and PowerPC hardware platforms.

pwr= Produce an object that contains instructions that will run on the POWER hardware platform.

pwr2= Produce an object that contains instructions that will run on the POWER2 hardware platform.

pwrx= Same as pwr2.

ppc= Produce an object that contains instructions that will run on any of the 32-bit PowerPC hardware platforms.

ppcgr= Produce an object that contains optional graphics instructions for PowerPC processors.
The default is -qarch=com. If the -qarch option is specified without the -qtune=<option>, the compiler uses -qtune=pwr.
gen(arch, name)
gen(arch,...)
-qassert=option
-qassert=<typ|allp|addr>
Specifies the aliasing assertion to be applied to your compilaton unit. The available options are:

typ= Pointers to different types are never aliased.

allp= Pointers are never aliased.

addr= Variables are disjoint from pointers unless their address is taken.
opt(alias, option)
opt(aliasAssert,typ[,yes])
opt(aliasAssert,typ,no)
opt(aliasAssert,allp[,yes])
opt(aliasAssert,allp,no)
opt(aliasAssert,addr[,yes])
opt(aliasAssert,addr,no)
-qattr Produce an attribute listing; output goes to.lst file. list(attr[,yes])
-qattr=full Produce an attribute listing containing all names, whether referenced or not; output goes to .lst file. list(attr, full)
-qbitfields=signed
-qbitfields=unsigned
Specify whether bitfields will be signed or unsigned. lang(signedBitfields[,yes])
lang(singedBitfields,no)
-qbrowse Produce information for the source code browser; output goes to .brs file. N/A
-qchars=signed
-qchars=unsigned
Treat plain char variables as signed or unsigned. lang(signedChars[, yes])
lang(signedChars, no)
-qcheck
-qnocheck
-qcheck=suboptions
The suboptions are:

all= Switches on all of the following suboptions.

nullptr= Performs run-time checking of addresses contained in pointer variables used to reference storage.

bounds= Performs run-time checking of addresses when subscipting within an object of known size.

divzero= Performs run-time checking of integer division.
gen(check, zeroDivide[, yes])
gen(check, zeroDivide, no)
gen(check, nullPointer[,yes])
gen(check, nullPointer,no)
gen(check, bounds[,yes])
gen(check, bounds,no)
-qcinc=<prefix>
-qnocinc=prefix
Includes files form/user/include by inserting
extern "C" {
before each <prefix> and inserting } after it.
incl(externC, prefix)
incl(noExternC, prefix)
-qcompact
-qnocompact
Optimize code for size. opt(size[, yes])
opt(size, no)
-qcpluscmt
-qnocpluscmt
Permit "//" to introduce comment that lasts until the end of the current source line, as in C++. lang(slashSlashComment[,yes])
lang(slashSlashComment,no)
-qdataimported
-qdataimported=string
-qdataimported=<name1>:<name2>:...
Specify which data items are imported. If no names are specified, all data items are assumed to be imported. This is the default. link(dataImported, none)
link(dataImported, all)
link(dataImported, names)
link(dataImportedNames, string)
-qdatalocal
-qdatalocal=string
-qdatalocal=<name1>:<name2>:...
Specify which data items are local. If no names are specified, all data items are assumed to be local. link(dataLocal, none)
link(dataLocal, all)
link(dataLocal, names)

link(dataLocalNames, string)
-qdbcs
-qnodbcs
Allow use of DBCS. lang(dbcs[,yes])
lang(dbcs,no)
-qdbxextra
-nodbxextra
Produce symbol table for unreferenced variables. gen(debugunreferenced[, yes])
-qdigraph
-qnodigraph
Permit ANSI digraph and keyword operators. lang(digraphs[, yes])
lang(digraphs, no)
-qdisjoint=<disjointSpec> Tell the optimizer that certain aliases are impossible. N/A
-qdollar
-qnodollar
Allow user to specify dollar sign ('$') in identifier names. lang(allowDollarInNames[, yes])
lang(allowDollarInNames, no)
-qenum=enumopt
-qenum=<small|int|1|2|4>
Specify whether minimum-sized enumerated types will be produced or not. <enumopt> can be either small, int, 1, 2 or 4.

small denotes that either one, two or four bytes of storage will be allocated for enum variables based on the range of the enum constants.

int is the default, and causes enum variables to be treated as though they were of type signed int for C or either signed or unsigned int for C++ depending on the range of the enum constants.

1 will cause enum variables to be packed into 1 byte.

2 will cause enum variables to be packed into 2 bytes.

4 will cause enum variables to be packed into 4 bytes.
gen(enumSize, ...)
-qextchk
-qnoextchk
Perform external name type-checking and function call checking. link(typeCheck[, yes])
link(typeCheck, no)
-qfdpr
-qnofdpr
Collect information about programs for use with the AIX fdpr (Feedback Directed Program Restructuring) performance-tuning utility. N/A
-qflag Set minimum severity level. report(level, ...)
-qflag=<sev> Specify severity level of diagnostics to be reported in source listing adn stderr; the severity level is one of <i,w,e,s,u>. list(reportLevel, sev)
report(level,sev)
-qflag=<sev1>:<sev2> Specify severity level of diagnostics to be reported in source listing (<sev1>), adn stderr (<sev2>); the severity levels are one of <i,w,e,s,u>. list(reportLevel, sev1)
report(level, sev2)
-qfloat
-qfloat=<opt1>:<opt2>:...:<optN>
The available options are:
emulate= Function calls are emitted in place of PowerPC floating-point instructions. Use this option only in a single-threded stand-alone environment, targeting the PowerPC 403 processor. Do not use this suboption with any of the following:
o -qarch=pwr, -qarch=pwr2, -qarch=pwrx
o -qlongdouble, -qldb1128
o -xlC128,xlc128 invocation commands

fltint= Specify whether range checking of floating point to integer conversions is done.
Default at -O2: -qfloat=nofltint.
Default at -O3: -qfloat=fltint.

hsflt= Never round single-precision expressions, and don't perform range checking for floating-point to integer conversions.

hssngl= Round single-precision expressions only when the results are stored into REAL*4 memory locations.

nans= Detect conversion of single-precision NaNS to double precision call checking.

nomaf= Suppress generation of multiply-add instructions.

nofold= Suppress compile-time evaluation of constant floating-point expressions.

rndsngl= Ensure strict adherence to IEEE standard. All operations on single-precision values produce results that remain in single precision.

rrm= Specify run-time rounding mode. Compile with this option if the run-time rounding mode is round toward minus infinity, round toward positive infinity, or not known.

rsqrt= Specify whether a division by the result of a spuare root can be replaced with a multiple by the reciprocal of the square root.
Default at -O2: -qfloat=norsqrt.
Default at -O3: -qfloat=rsqrt.

spnans= Generate extra instructions to detect signalling NaN of conversion from single precision to double precision. Obsolete; use the equivalent -qfloat=nans option.
Windows NT and OS/2 only:
gen(float, ...)
gen(float, string[,yes])
gen(float, string,no)
-qflttrap
-qflttrap=option
-qflttrap=<opt1>:<opt2>:...:<optN>
-qnoflttrap
Generate calls to detect and trap floating point. The available options are: overflow, underflow, zerodivide, invalid, inexact, enable, imprecise. gen(floatTrap, option[, yes])
gen(floatTrap,option, no)
-qfold
-qnofold
Specifies that constant floating-point expressions are to be evaluated at compile time. gen(float, fold[, yes])
gen(float, fold, no)
-qfullpath
-qnofullpath
Specify path information. link(debugFullPath[, yes])
link(debugFullPath, no)
-qfuncsect
-qnofuncsect
Place instructions for each function in a separate cset. gen(funcSect[, yes])
gen(funcSect, no)
-qgenpcomp Generate pretokenized include files. N/A
-qgenpcomp[=dirname] Generate pretokenized include files. file(genPCH[, yes])
file(genPCH, string)
file(genPCH, no)
-qgenproto Generate ANSI prototypes form K&R function definitions. N/A
-qgenproto=<parmnames> Produces ANSI prototypes from K&R function definitions. file(genProto[, yes])
file(genProto, no)
-qhalt
-qhalt=<w|e|s|u>
Stop compiler after first phase if severity of errors detected equals or exceeds <sev>; the severity lievel is one of w, e, s, u. N/A
-qhd Generate additional information for use with the Heapview debugger. N/A
-qheapdebug
-qnoheapdebug
Enables debug versions of memory management functions. alloc(debug[,yes])
alloc(debug,no)
-qidirfirst
-qnoidirfirst
Specify search order for files. incl(searchpathfirst[, yes])
incl(searchpathfirst, no)
-qignerrno
-qnoignerrno
Tell optimizer that program will never refer to or set errno. opt(ignErrno)
opt(ignErrno, no)
-qignprag
-qignprag=disjoint
-qignprag=isolated
-qignprag=all
Honour or ignore references to #pragma disjoint and/or isolated_call. opt(pragmaDisjoint[, yes])
opt(pragmaDisjoint, no)
opt(pragmaIsolatedCall[, yes])
opt(pragmaIsolatedCall, no)
-qinfo=infoopt
-qinfo=<class>
Produce additional lint-like messages based on <class>. info()
-qinitauto=value
-qinitauto=<hh>
Initialialize automatic storage to <hh>. <hh> is a hexadecimal value. This generates extra code and should only be used for error determination. gen(initAuto[, yes])
gen(initAuto, number)
gen(initAuto, no)
-qinlglue
-qnoinlglue
Generate fast external linkage by inlining the code (pointer glue code) necessary at calls via a function pointer and calls to external procedures. gen(inlinePointerGlue[, yes])
gen(inlinePointerGlue, no)
-qinline
-qnoinline
Determine whether functions in your code qualified with the _Inline or inline keywords are candidates for inlining. opt(inline[, yes])
opt(inline, no)
-qipa
-qnoipa
-qipa=option
Turn the IPA optimizer on or off. opt(ipa)
opt(ipa, no)
opt(ipaoption, option)
-qipa[=<ipa_options>] Uurn on inter procedural analysis. N/A
-qisolated_call=<name1>:<name2>:... Specify that the calls to the functios listed have no side effcts. <name1> and <name2> are function names. The user may specify as many function names as necessary. opt(isolatedCall,...)
-qlanglvl Set language level. N/A
-qlanglvl=<ansi|saa12|saa|extended|classic> Specify language level to be used during compilation. <langlvl> can be ansi, saa12, saa, extended, or classic. lang(level,...)
-qldbl128
-qnoldbl128
-qlongdouble
-qnolongdouble
Represent long doubles as 80 bit values on OS/2 and Windows, or as 128 bit values on AIX. gen(longDouble[, yes])
gen(longDouble, no)
-qlibansi
-qnolibansi
Process ANSI C library names as system functions. gen(libansi)
gen(libansi, no)
-qlinedebug
-qnolinedebug
Generates abbreviated line number and source file name information for the debugger. gen(lineOnlyDebug[,yes])
gen(lineOnlyDebug,no)
-qlist
-qnolist
Produce an object listing; output goes to .lst file. list(listing[,yes])
list(listing,no)
-qlistopt
-qnolistopt
Display the settings of all options; output goes to .lst file. list(options[, yes])
-qlonglong
-qnolonglong
Processor disallow long long int. lang(longlong)
lang(longlong, no)
-qmacpstr
-qnomacpstr
Allow '\p' as the first character of a string constant. lang(macPStr[, yes])
lang(macPStr, no)
-qmakedep
-qnomakedep
Creates an output file that contains targets suitable for inclusion in a description file for the AIX make command. file(makeDep[,yes])
file(makeDep,no)
-qmaxerr Instructs the compiler to halt compilation when a specified number of errors of specified or greater severity is reached. debug(maxErrors, number)
-qmaxmen=<num> Limit the amount of memory used by space intensive ooptimization to <num>. <num> specified in kilobytes. priority=NNN opt(maxMem, number)
-qmbcs
-qnombcs
Allow use of DBCS. lang(dbcs[, yes])
lang(dbcs, no)
-qnoprint Direct listing to /dev/null. list(listing, no)
-qnostdinc
-qstdinc
Specify which files are included with the #include "file_name" and #include <file_name> directives. If -qnostdinc is specified, the /usr/include directory is not searched. incl(standardInclude, no)
-qonce
-qnoonce
Process #include files only once. file(once[, yes])
file(once, no)
-qpascal
-nopascal
Accept and ignore the keyword 'pascal' as a type modifier. lang(pascal[, yes])
lang(pascal, no)
-qpdf1
-qpdf2
Perform aggressive optimizations with profile directed feedback. N/A
-qphsinfo Produce compiler phase information N/A
-qpriority=<num> Specifies the priority level for initialization of static constructors. link(sharedLibPriority, number)
-qproclocal
-qproclocal=<name1>:<name2>:...
Specify which functions are local. If no filenames are specified, all invoked functions are assumed to be defined within the current file. The last explicit specification for a function takes precedence. link(procLocal,<none|all|names>)
link(procLocalName, string)
-qprocimported
-qprocimported=<name1>:<name2>:...
Specify which functions are imported. If no filenames are specified, all invoked functions are assumed to be defined outside the current file. The last explicit specification for a function takes precedence. link(procImport,<nome|all|names>)
link(procImportName,string)
-qprocunknown
-qprocunknown=<name1>:<name2>:...
Specify which functions are unknown to be local or imported. If no filenames are specified, all functions called are assumed to be unknown. This is the default when no user options are specified. The last explicit specification for a function takes precedence. link(procUnknown,<none|all|names>)
link(procUnknownName, string)
-qproto
-qnoproto
Assert that procedure call points agree with their declarations even if the procedure has not been prototyped. This allows the caller to pass floating point arguments floating point registers instead of general purpose registers. lang(checkNonProto[,yes])
lang(checkNonProto,no)
-qro
-qnoro
Put string literals in read only area. gen(readonly[, yes])
gen(readonly, no)
-qroconst
-qnoroconst
Put constant values in read only area. gen(readonlyconst)
gen(readonlyconst, no)
-qrwvftable
-qnorwvftable
Place virtual function tables into read/write memory. N/A
-qshowinc
-qnoshowinc
Include the source for all included files in the source listing, if the -qsource option is in effect. list(expAllInc[,yes])
list(expAllInc,no)
-qsom Turn on implicit SOM mode. N/A
-qsomgs Disable direct access to SOM attributes. N/A
-qsominc Include or exclude files in implicit SOM mode. N/A
-qsomro Write the release order of the specified class to stdout. N/A
-qsource
-qnosource
Produce a source listing; output goes to.lst file. list(incSource[,yes])
list(incSource,no)
-qspill=number
-qspill=<size>
Specify the size of the register allocation spill area. opt(registerSpillSize, number)
-qsrcmsg
-qnosrcmsg
Reconstruct source lines in error along with the diagnostic messages. report(srcMsg[, yes])
report(srcMsg, no)
-qstatsym
-qnostatsym
Adds user-defined, nonexternal names that have a persistent storage class, such as initialized and uninitialized static variables, to the name list (the symbol table of xcoff objects). link(staticSymbols)
link(staticSymbols, no)
-qstrict
-qnostrict
Valid only at -03. This option turns off aggresive optimizations which have the potential to alter the semantics of a user's program. This option also sets -qfloat=nofltint:norsqrt. opt(strict)
opt(strict, no)
-qsyntaxonly
-qnosyntaxonly
Causes the compiler to perform syntax checking without generating an object file. file(syntaxOnly[,yes])
file(syntaxOnly,no)
-qtabsize=<size> Change the length of tabs in your source file. file(tabSize, number)
-qtbtable=option
-qtbtable=<option>
Generate a traceback table for each function and place it in the text segment at the end of the function code.
The available options are:

none= No traceback table is generated.

full= A full traceback table is generated. This is the default with -g specified.

small= A traceback table is generated with no name or parameter information. This is the default when -g is NOT specified.
gen(traceBackTable,option)
link(traceBackTable,<none|full|small>)
-qtempinc
-qtempinc=<directory>
-qnotempinc
Automatically generate template functions in the specified directory. Use the "notempinc" option to suppress this behaviour. N/A
-qtempmax Specify the maximum number of files to be created in the tempinc directory for each template file. N/A
-qtune=name
-qtune=<403|601|603|604|pwr|pwr2|pwr2s>
Specifies the architecture system for which the executable program is optimized. The available options are:

403= Produce an object optimized for all the PowerPC 403 processors. Use -qfloat=emulate to emulate the floating-pointing instructions omitted by the 403 processor.

601= Produce an object optimized for all the PowerPC 601 processors.

603= Produce an object optimized for all the Power PC 603 processors.

604= Produce an object optimized for all the PowerPC 604 processors.

pwr= Produce an object optimized for the POWER hardware platform.

pwr2= Produce an object optimized for the POWER2 hardware platform.

pwr2s= Produce an object optimized for the POWER2 hardware platform, avoiding certain quadruple-precision instructions that would slow program performance.

pwrx= Same as pwr2.
opt(tune, name)
opt(tune,...)
-qtwolink
-qnotwolink
Link twice in order to minimize the number of static constructors included form libraries (default with langlvl=compat). N/A
-qunique
-qnounique
Generates unique names for static constuctor/descructor file ocmpilation units. link(uniqueNames[, yes])
link(uniqueNames, no)
-qunroll
-qunroll=number
-qnounroll
-qunroll[=n]
Allow the optimizer to unroll loops. opt(loopUnroll[, yes])
opt(loopUnroll, number)
opt(loopUnroll, no)
-qupconv
-qnoupconv
Preserves the unsigned specification when performing integral promotions. lang(preserveUnsignedPromotion[, yes])
lang(preserveUnsignedPromotion, no)
-qusepcomp Use pretokenized include files. N/A
-qusepcomp[=dirname] Use pretokenized include files. file(usePCH[,yes])
file(usePCH,string)
file(usePCH,no)
-qvftable
-qnovftable
Determine whether the virtual function table is included in the module that is the target of the build. gen(vft[, yes])
gen(vft, no)
-qwait
-qwait[=<seconds>]
Specify the number of seconds to wait for a NetLS license to become available. The default is to wait forever. N/A
-qxcall
-qnoxcall
Generate code to static routines within a compilation unit as if they were external routines. gen(externStaticLinkage[, yes])
gen(externStaticLinkage, no)
-qxref
-noxref
Produce a cross-reference listing; output goes to .lst file. list(minXRef[, yes])
list(minXRef, no)
-qxref=full Produce a cross-reference listing containing all names, whether referenced or not; output goes to .lst file. list(fullXRef[, yes])
list(fullXRef, no)
-r Permits the output file to be produced even if it contains unresolved symbols. link(force)
-s   link(strip[, yes])
link(strip, no)
-S Generate an assembler language (.s) file file(genAsm[,yes])
-Snumber Set the total size of the program stack in bytes. Windows NT and OS/2 only:
link(stack, number)
-t Apply prefix from the -B option to the specified program. N/A
-t<p/c/b/i/a/l/m/f/I> Apply prefix form the -B option to the specified program <x>, where x can be on or more of the following:

p= preprocessor
c= compiler frontend
b= compiler backend
i= compiler inliner
a= assembler
l= linkage editor
m= 'munch' utility
I= inter procedural analysis
N/A
-Tnumber Sets the start address of the text section of the output file to number. link(textStart, number)
-U<name> Undefine name as in #undef directive. undefine(name)
-v Display language processing commands as they are invoked by xIC; output goes to stdout. N/A
-w Suppress information, language-level, and warning messages. report(level, ...)
-W Give specified options to specidied compiler program. N/A
-W<x,y> Give the options <y> to the compiler program <c> where x can be one or more of the following:
<p,c,b,i,a,l,I,m>
N/A
-y<option> Specifies compile-time rounding of constant floating-point expressions. (is this the right description?) gen(roundConstFp, option)
-Y<x> Specify compile-time rounding of constant floating-point expressions, where <x> can be one of the following:
n= round to nearest
m= round toward minus infinity
p= round toward positive infinity
z= round toward zero.
gen(roundConstFp, option)
 -Zstring Prefix the names of the library search paths with the string. link(libsearchpathprefix, string)


Incremental C++ Build
C Compilation
Configuration Files


Set Build Options
Build


Link Options from Earlier Versions of VisualAge C++
Build Options
Build Options for ANSI C++ Compliance
Build Options for Compatibitility with Old C++ Compilers