Compile Options from Earlier Versions of VisualAge C++ (OS/2, Windows)

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 from earlier versions of VisualAge C++ and predecessor products. 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. In this version of VisualAge C++, some options may apply to only one of C or C++ code, but not both. Option applicability 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 help N/A
/B"options" Pass options to linker link options
/C[+|-] Perform compile without linking N/A
/Dname
Dname=[value]
Define preprocessor macro. define(macro_name[, string])
/Fa[+|-][dir][name] Produce assembler listing file(genAsm[, yes])
file(genAsm, no)

file(asmFileName, String)
/Fb[+|-|*] Produce a browser file N/A
/Fc[+|-] Perform syntax check only, instead of a full compile. file(syntaxOnly[, yes])
file(syntaxOnly, no)
/Fename Specify name of executable output file target [exe] fileName
/Fi[+|-][dir][name] Produce, name, and direct precompiled header file file(genPCH[, yes])
file(genPCH, fileName)
file(genPCH, no)
/Fl[+|-][dir][name] Produce, name, and direct listing file list(listing[, yes])
list(listing, no)

list(fileName, string)
/Fm[+|-]
/Fmname
Produce a linker map file link(map[, yes])
link(map, no)

link(map, name)
/Fn[+|-]
/Fn[dir][name]
Produce assembler listing with code file(genAsmWithCode[ ,yes])
file(genAsmWithCode, fileName)
file(genAsmWithCode, no)
/Fo[+|-][dir][name] Control and name object file file(genObject[, yes])
file(genObject, fileName)
file(genObject, no)
/Ft[+|-][dir] Control and direct files for template resolution N/A
/Fw[+|-][dir][name] Create intermediate code files only N/A
/G3
/G4
/G5
Specify the processor for which the code is optimized opt(tune, processor)
/Ga Turn on implicit SOM mode N/A
/Gb Disable direct access to attributes for DSOM N/A
/Gd[+|-] Dynamically link to the runtime library, instead of linking statically link(linkWithSharedLib[, yes])
link(linkWithSharedLib, no)
/Ge[+|-] Build .exe or .dll file target [type] fileName
/Gf[+|-] Use fast floating-point execution. opt(float[, yes])
opt(float, no)
/Gh[+|-] Enable code for performance analysis gen(profile[, yes])
gen(profile, no)
/Gi[+|-] Use fast integer execution opt(integer[, yes])
opt(integer, no)
/Gk[+|-] Support objects generated with C Set ++ and containing templates N/A
/Gl[+|-] Remove unreferenced functions gen(unreferenced[, yes])
gen(unreferenced, no)
/Gm[+|-] Link with the multithread library, instead of the single-thread library link(linkWithMultiThreadLib[, yes])
link(linkWithMultiThreadLib, no)
/Gn[+|-] Hide default library information from linker link(defaultLibs[, yes]
link(defaultLibs, no)
/Gp[+|-] Support parmdwords gen(parmDWord[, yes]
gen(parmDWord, no)
/Gr[+|-] Generate code to run on ring 0 gen(ring0[, yes]
gen(ring0, no)
/Gs[+|-] Support stack probes gen(probe[, yes]
gen(probe, no)
/Gt[+|-] Support tiled memory for 16-bit code gen(tiledMemory[, yes]
gen(tiledMemory, no)
/Gu[+|-] Stop external functions from using data defined in intermediate files N/A
/Gv[+|-] Perform special handling of ES and DS registers gen(loadDS[, yes]
gen(loadDS, no)
/Gw[+|-] Generate FWAIT instruction after each floating-point load instruction N/A
/Gx[+|-] Enable C++ exception handling gen(eh[, yes]
gen(eh, no)
/Gy[+|-] Decorate all external data names with leading underscore gen(decorateExternalNames[, yes]
gen(decorateExternalNames, no)
/Gz[+|-] Prebuild SOM classes N/A
/Hnum Set maximum length of external names link(nameLength, bytes)
link(nameMangling, ansi, size)
link(nameMangling, compat, size)
/Ipath[;path] Specify #include search paths incl(searchPath, path)
/J[+|-] Treat unspecified char variables as signed char lang(signedChars[, yes]
lang(signedChars, no
)
/L[+|-] Produce a minimal listing file list(listing[, yes]
list(listing, no)
/La[+|-] Include a minimal layout in the listing file list(refStructVar[, yes]
list(refStructVar, no)
/Lb[+|-] Include a layout in the listing file list(allStructVar[, yes]
list(allStructVar, no)
/Le[+|-] Expand macros in the listing file list(expMacros[, yes]
list(expMacros, no)
/Lf[+|-] Set all listing options on. list(full[, yes]
list(full, no)
/Li[+|-] Expand user #include files in the listing file list(expusrinc[, yes]
list(expusrinc, no)
/Lj[+|-] Expand user and system #include files in the listing file list(expAllInc[, yes]
list(expAllInc, no)
/Lpnumber Set page length of listing file list(pageLen, number)
/Ls[+|-] Include the source code in the listing file list(incSource[, yes]
list(incSource, no)
/Lt"string" Set title string for the listing file list(title, string)
/Lu"string" Set subtitle string in the listing file list(subTitle, string)
/Lx[+|-] Generate a minimal cross-reference table in the listing file list(minXRef[, yes]
list(minXRef, no)
/Ly[+|-] Generate a cross-reference table in the listing file list(fullXRef[, yes]
list(fullXRef, no)
/Mp
/Ms
/Mc
/Mt
Set default calling convention gen(call, optlink)
gen(call, system)
gen(call, cdecl)
gen(call, stdcall)
/Nnumber End compilation when error count reaches number debug(maxerror, number)
/Ndname Set names of default data, uninitialized data, and constant segments gen(dataSeg, name)
gen(uninitSeg, name)
gen(constSeg, name)
/Ntname Set names of default code or data segment gen(codeSeg, name)
/Nxname Set names of exception-handling code or data segments gen(ehCodeSeg, name)
gen(ehDataSeg, name)
/O[+|-|2|3|4] Optimize code for speed. opt(level, level)
/Oc[+|-] Optimize code for size. opt(size[, yes])
opt(size, no)
/Oi[+|-]  Inline specified user functions opt(inline[, yes])
opt(inline, no)
opt(autoInline[, yes])
opt(autoInline, no)
/Ol[+|-] Use intermediate code linker N/A
/Om[+|-] Limit working set size opt(limitWorkingSet[, yes])
opt(limitWorkingSet, no)
/Op[+|-] Perform optimizations that involve the stack pointer opt(stackPointer[, yes])
opt(stackPointer, no)
/Oq[+|-] Control stack chaining. opt(stackChaining[, yes])
opt(stackChaining, no)
/Os[+|-] Invoke the instruction scheduler opt(schedule[, yes])
opt(schedule, no)
/P[+|-] Run the preprocessor only pp(preprocessOnly[, yes])
pp(preprocessOnly, no)
/Pc[+|-] Preserve source code comments in preprocessor output. pp(preserveComments[, yes])
pp(preserveComments, no)
/Pd[+|-] Redirect preprocessor output to stdout pp(stdout[, yes])
pp(stdout, no)
/Pe[+|-] Suppress #line directives in preprocessor output pp(suppressLine[, yes])
pp(suppressLine, no)
/Q[+|-] Suppress the compiler logo when invoking the compiler N/A
/qalias Specify which aliasing rules can be used during optimization opt(alias, allp)
opt(alias, typ)
opt(alias, addr)
opt(alias, ansi)
/qarch Specify target CPU architecture opt(arch, CPUtype)
/qautoimported /qnoautoimported Import all external references gen(import[, yes])
gen(import, no)
/qautothread /qnoautothread Turn static, nonconstant data into thread-local data N/A
/qbitfields=signed
/qbitfields =unsigned
Specify default sign of bitfields gen(signedBitfields[, yes])
gen(signedBitfields, no)
/qdbgunref /qnodbgunref Use referenced and unreferenced symbols during debugging gen(debugUnreferenced[, yes])
gen(debugUnreferenced, no)
/qdigraph
/qnodigraph
Permit standard digraph and keyword operators lang(cDigraphs[, yes])
lang(cDigraphs, no)
lang(digraphs[, yes])
lang(digraphs, no)
/qignerrno Tell the optimizer that the program will never refer to or set errno lang(ignerrno[, yes])
lang(ignerrno, no)
/qignprag=disjoint
/qignprag=isolated
/qignprag=all
Ignore references to #pragma disjoint and #pragma isolated_call opt(pragmaDisjoint[, yes])
opt(pragmaDisjoint, no)

opt(pragmaIsolatedCall[, yes])
opt(pragmaIsolatedCall, no)
/qinitauto Initialize automatic storage gen(initAuto[, yes])
gen(initAuto, number)
gen(initAuto, no)
/qipa Use interprocedure analysis for optimization N/A
/qisolated_call  =fname[:fname]... List functions that do not change data objects at time of function call opt(isolatedCall, string)
/qlibansi
/qnolibansi
Process standard C library names as system functions gen(libANSI[, yes])
gen(libANSI, no)
/qlonglong /qnolonglong Process or disallow type long long int lang(longLong[, yes])
lang(longLong, no)
/qmakedep Create dependency files to include in makefile file(makeDep[, yes])
/qro
/qnoro
Use read-only, or read-write storage for string literals gen(readOnly[, yes])
gen(readOnly, no)
/qrtti=rtoption
/qnortti
Generate information for run-time type information N/A
/qsomvolattr /qnosomvolattr Use volatile on attribute prototypes N/A
/qtune=option Specify the processor for which code is optimized opt(tune, processor)
/qwin32s
/qnowin32s
Help port your program to the Win32s runtime environment. N/A
/R[e|n] Generate code that can be used as a subsystem without a runtime environment. link(standAlone[, yes])
link(standAlone, no)
/Sa
/Se
/S2
Set language level. lang(level, ansi)
lang(level, extended)
lang(level, saa12)
/Sc Set C++ language level. N/A
/Sd[+|-] Set the default file extension for source files to .c, instead of .obj N/A
/Sg[left][,right|*] /Sg[-] Set left and right margins for the input file misc(margins[, yes])
misc(margins, no)

misc(marginValues, left[, right])
/Sh[+|-] Allow use of ddNames lang(ddNames[, yes])
lang(ddNames, no)
/Si[+|-]
/Si[dir][filename]
Use precompiled header files, if they exist and are current file(usePCH[, yes])
file(usePCH, fileName)
file(usePCHl, no)
/Sm[+|-] Ignore obsolete keywords, instead of treating them like any other identifier lang(ignObsoleteKeywords[, yes])
lang(ignObsoletekeywords, no)
/Sn[+|-] Allow use of DBCS lang(dbcs[, yes])
lang(dbcs, no)
/Sp[1|2|4|8|16] Specify alignment or packing of data items within structures and unions gen(pack, number)
/Sq[left][, right]
/Sq[left][, *]
/Sq[-]
Ignore sequence numbers in source columns misc(sequenceNumbers[, yes])
misc(sequenceNumbers, no)

misc(sequenceNumberValues, left[, right])
/Sr[+|-] Use old-style rules for type conversion lang(preserveUnsignedPromotion[, yes])
lang(preserveUnsignedPromotion, no)
/Ss[+|-] Allow double-slash comments lang(slashSlashComments[, yes])
lang(slashSlashComments, no)
/Su[+|-|1|2|4] Control size of enum variables gen(enumSize, int)
gen(enumSize, small)
gen(enumSize, bytes)
/Sv[+|-] Allow use of memory files lang(memoryFiles[, yes])
lang(memoryFiles, no)
/Tcfilename Compile as a C source file, regardless of extension N/A
/Td[c|p] Specify the default language for sourc files, overriding extension N/A
/Ti[+|-] Generate debugger information. gen(debug[, yes])
gen(debug, no)
/Tm[+|-] Enable debug version of memory management functions alloc(debug[, yes])
alloc(debug, no)
/Tn[+|-] Generate line number information for debugging gen(lineOnlyDebug[, yes])
gen(lineOnlyDebug, no)
/Tpfilename Compile as a C++ source file, regardless extension N/A
/Tx[+|-] Provide a complete machine-state dump when an exception occurs, instead of providing only the exception message and address gen(dump[, yes])
gen(dump, no)
/Uname
/U*
Undefine macros undefine(macro_name)
/V"string" Include a version string in the object and executable files link(versionString, string)
/W0
/W1
/W2
/W3
Set minimum severity level of messages the compiler produces and counts report(level, E)
report(level, W)
report(level, I)
/Wgroup[+|-][group] Generate or suppress messages in a group info(group[, yes])
info(group, no)
info(all[, yes])
info(all, no)
/Xc[+|-] Do not search paths specified using /I file(ignoreusrincpaths[, yes])
file(ignoreusrincpaths, no)
/Xi[+|-] Do not search paths specified in INCLUDE file(ignoreEnvIncPaths[, yes])
file(ignoreEnvIncPaths, no)


Incremental C++ Build
C Compilation
Configuration Files


Set Build Options
Build


Link Options from Earlier Versions of VisualAge C++
Build Options
Build Options for Compliance With the C++ Standard
Build Options for Compatibility with Old C++ Compilers