Pastebin: OpenWatcom C++ options

Format

AA (Ascii Art)

Post date

2020-11-26 10:06

Publication Period

Unlimited

 C:\WINDOWS\system32>C:\WATCOM\binnt\wpp386
 Open Watcom C++32 Optimizing Compiler Version 1.9
 Portions Copyright (c) 1989-2002 Sybase, Inc. All Rights Reserved.
 Source code is available under the Sybase Open Watcom Public License.
 See http://www.openwatcom.org/ for details.
 Usage: wpp386 [options] file [options]
 Options:
             ( /option is also accepted )
             ( '=' is always optional, i.e., -w4 -zp4 )
 -3r             386 register calling conventions
 -3s             386 stack calling conventions
 -4r             486 register calling conventions
 -4s             486 stack calling conventions
 -5r             Pentium register calling conventions
 -5s             Pentium stack calling conventions
 -6r             Pentium Pro register calling conventions
 -6s             Pentium Pro stack calling conventions
 -ad[=<file>]    generate make style automatic dependency file
 -adbs           force path separators to '\' in auto-depend file
 -add[=<file>]   specify first dependency in make style auto-depend file
 -adfs           force path separators to '/' in auto-depend file
 -adhp[=<file>]  specify default path for headers without one
 -adt[=<file>]   specify target in make style auto-depend file
 -bc             build target is a console application
 -bd             build target is a dynamic link library (DLL)
 -bg             build target is a GUI application
 -bm             build target is a multi-thread environment
 -br             build target uses DLL version of C/C++ run-time library
 -bt[=<id>]      build target is operating system <id>
 -bw             build target is a default windowing application
 -d<name>[=text] same as #define name [text] before compilation
 -d0             no debugging information
 -d1             line number debugging information
 -d2             symbolic debugging information
 -d2i            -d2 and debug inlines; emit inlines as COMDATs
 -d2s            -d2 and debug inlines; emit inlines as statics
 -d2t            -d2 but without type names
 -d3             symbolic debugging information with unreferenced type names
 -d3i            -d3 and debug inlines; emit inlines as COMDATs
 -d3s            -d3 and debug inlines; emit inlines as statics
 -d+             allow extended -d macro definitions
 -db             generate browsing information
 -e=<num>        set limit on number of error messages
 -ecc            set default calling convention to __cdecl
 -ecd            set default calling convention to __stdcall
 -ecf            set default calling convention to __fastcall
 -ecp            set default calling convention to __pascal
 -ecr            set default calling convention to __fortran
 -ecs            set default calling convention to __syscall
 -ecw            set default calling convention to __watcall (default)
 -ee             call epilogue hook routine
 -ef             use full path names in error messages
 -ei             force enum base type to use at least an int
 -em             force enum base type to use minimum integral type
 -en             emit routine names in the code segment
 -ep[=<num>]     call prologue hook routine with <num> stack bytes available
 -eq             do not display error messages (but still write to .err file)
 -er             do not recover from undefined symbol errors
 -et             emit Pentium profiling code
 -et0            emit Pentium-CTR0 profiling code
 -ew             alternate error message formatting
 -ez             generate PharLap EZ-OMF object files
 -fc=<file>      specify file of command lines to be batch processed
 -fh[=<file>]    use pre-compiled header (PCH) file
 -fhd            store debug info for PCH once (DWARF only)
 -fhq[=<file>]   do not display PCH activity warnings
 -fhr            force compiler to read PCH (will never write)
 -fhw            force compiler to write PCH (will never read)
 -fhwe           don't count PCH activity warnings (see -we option)
 -fi=<file>      force <file> to be included
 -fo[=<file>]    set object or preprocessor output file name
 -fp2            generate 287 floating-point code
 -fp3            generate 387 floating-point code
 -fp5            optimize floating-point for Pentium
 -fp6            optimize floating-point for Pentium Pro
 -fpc            calls to floating-point library
 -fpd            enable Pentium FDIV check
 -fpi            inline 80x87 instructions with emulation
 -fpi87          inline 80x87 instructions
 -fpr            generate backward compatible 80x87 code
 -fr[=<file>]    set error file name
 -ft             check for truncated versions of file names
 -fx             do not check for truncated versions of file names
 -fzh            do not automatically postfix include file names
 -fzs            do not automatically postfix source file names
 -g=<id>         set code group name
 -hc             generate Codeview debugging information
 -hd             generate DWARF debugging information
 -hw             generate Watcom debugging information
 -i=<path>       add another include path
 -j              change char default from unsigned to signed
 -k              continue processing files (ignore errors)
 -mc             compact memory model (small code/large data)
 -mf             flat memory model (small code/small data assuming CS=DS=SS=ES)
 -mfi            flat memory model (interrupt functions will assume flat model)
 -ml             large memory model (large code/large data)
 -mm             medium memory model (large code/small data)
 -ms             small memory model (small code/small data)
 -na             disable automatic inclusion of _ialias.h
 -nc=<id>        set code class name
 -nd=<id>        set data segment name
 -nm=<file>      set module name
 -nt=<id>        set name of text segment
 -o{a,b,c,d,e[=<num>],f,f+,h,i,i+,k,l,l+,m,n,o,p,r,s,t,u,x,z} optimization
   a             -> relax aliasing constraints
   b             -> enable branch prediction
   c             -> disable <call followed by return> to <jump> optimization
   d             -> disable all optimizations
   e[=<num>]     -> expand user functions inline (<num> controls max size)
   f             -> generate traceable stack frames as needed
   f+            -> always generate traceable stack frames
   h             -> enable expensive optimizations (longer compiles)
   i             -> expand intrinsic functions inline
   i+            -> enable maximum inlining depth
   k             -> include prologue/epilogue in flow graph
   l             -> enable loop optimizations
   l+            -> enable loop unrolling optimizations
   m             -> generate inline code for math functions
   n             -> allow numerically unstable optimizations
   o             -> continue compilation if low on memory
   p             -> generate consistent floating-point results
   r             -> reorder instructions for best pipeline usage
   s             -> favor code size over execution time in optimizations
   t             -> favor execution time over code size in optimizations
   u             -> all functions must have unique addresses
   x             -> equivalent to -obmiler -s
   z             -> NULL points to valid memory in the target environment
 -p{c,e,l,w=<num>} preprocess source file
   c             -> preserve comments
   e             -> encrypt identifiers
   l             -> insert #line directives
   w=<num>       -> wrap output lines at <num> columns. Zero means no wrap.
 -pil            preprocessor ignores #line directives
 -q              operate quietly (display only error messages)
 -r              save/restore segment registers across calls
 -ri             return chars and shorts as ints
 -s              remove stack overflow checks
 -sg             generate calls to grow the stack
 -st             touch stack through SS first
 -t=<num>        set number of spaces in a tab stop
 -u[=<name>]     undefine macro name
 -v              output function declarations to .def file
 -vcap           VC++ compatibility: alloca allowed in argument lists
 -w=<num>        set warning level number
 -wcd=<num>      warning control: disable warning message <num>
 -wce=<num>      warning control: enable warning message <num>
 -we             treat all warnings as errors
 -wx             set warning level to maximum setting
 -xd             disable exception handling (default)
 -xds            disable exception handling (table-driven destructors)
 -xdt            disable exception handling (same as -xd)
 -xr             enable RTTI
 -xs             enable exception handling
 -xss            enable exception handling (table-driven destructors)
 -xst            enable exception handling (direct calls for destruction)
 -za             disable extensions (i.e., accept only ISO/ANSI C++)
 -za0x           enable some features of the upcoming ISO C++0x standard
 -zat            disable alternative tokens (e.g. and, or, not)
 -zc             place const data into the code segment
 -zdf            DS floats (i.e. not fixed to DGROUP)
 -zdl            load DS directly from DGROUP
 -zdp            DS is pegged to DGROUP
 -ze             enable extensions (i.e., near, far, export, etc.)
 -zf             scope of for loop initializer extends beyond loop
 -zff            FS floats (i.e. not fixed to a segment)
 -zfp            FS is pegged to a segment
 -zfw            generate FWAIT instructions
 -zg             generate function prototypes using base types
 -zgf            GS floats (i.e. not fixed to a segment)
 -zgp            GS is pegged to a segment
 -zk0            double-byte character support: Kanji
 -zk0u           translate double-byte Kanji to Unicode
 -zk1            double-byte character support: Chinese/Taiwanese
 -zk2            double-byte character support: Korean
 -zkl            double-byte character support: local installed language
 -zku=<num>      load Unicode translate table for specified code page
 -zl             remove default library information
 -zld            remove file dependency information
 -zlf            always generate default library information
 -zls            remove automatically inserted symbols
 -zm             emit functions in separate segments
 -zmf            emit functions in separate segments (near functions allowed)
 -zo             use exception-handling for a specific operating system
 -zp=<num>       pack structure members with alignment {1,2,4,8,16}
 -zpw            output warning when padding is added in a class
 -zq             operate quietly (display only error messages)
 -zri            inline floating point rounding calls
 -zro            omit floating point rounding calls (non ANSI)
 -zs             syntax check only
 -zt[=<num>]     far data threshold (i.e., larger objects go in far memory)
 -zu             SS != DGROUP (i.e., do not assume stack is in data segment)
 -zv             enable virtual function removal optimization
 -zw             generate code for Microsoft Windows
 -zz             remove "@size" from __stdcall function names (10.0 compatible)