I'm working under Sun Studio 12.3 on SunOS 5.11 (Solaris 11.3). I need to see the macros that Sun Studio defines to fix a bug report taken under the suite. This is similar to Solaris and Preprocessor Macros, but the cited question uses GCC and its preprocessor; and not Sun Studio's preprocessor.
I've run CC -flags but I don't see an option similar to GCC's cpp -dM or g++ -dM -E - </dev/null. CC does have a -E, but its fairly anemic and does not print any preprocessor definitions:
$ echo $CXX
/opt/solarisstudio12.3/bin/CC
$ $CXX -E /dev/null
#1 "/dev/null"
Using a real test file produces a similar result - preprocessor macros are missing:
$ $CXX -E test.cxx | grep __cplusplus
$
I also found the discussion of preprocessor macros in the Sun Studio manual at 2.5.3 Predefined Names. Table A-2 is OK, but its mostly anemic, too. Its missing basics like __cplusplus, and its missing other defines like _RWSTD_NO_CLASS_PARTIAL_SPEC.
How do I print preprocessor macros under Sun Studio?
$ /opt/solarisstudio12.3/bin/CC -flags
______________________________________________________________________________
Items within [ ] are optional. Items within < > are variable parameters.
Bar | indicates choice of literal values.
______________________________________________________________________________
-# Verbose mode
-### Show compiler commands built by driver, no compilation
-B[static|dynamic] Specify dynamic or static binding
-D<name[=token]> Associate name with token as if by #define
-E Compile source through preprocessor only, output to stdout
-G Build a dynamic shared library
-H Print path name of each file included during compilation
-I<dir> Add <dir> to preprocessor #include file search path
-KPIC Compile position independent code with 32-bit addresses
-Kpic Compile position independent code
-L<dir> Pass to linker to add <dir> to the library search path
-M<file> Pass <file> mapfile to linker
-O Use default optimization level (-xO3)
-O<n> Same as -xO<n>
-P Compile source through preprocessor only, output to .i file
-PIC Same as -KPIC
-Qoption <prog> <o>[,<o>...] Pass options list <o> to compilation phase <prog>
-R<dir[:dir]> Build runtime search path list into executable
-S Compile and only generate assembly code (.s)
-U<name> Delete initial definition of preprocessor symbol <name>
-V Report version number of each compilation phase
-W<c>,<arg> Pass <arg> to specified component <c> (a,d,h,i,l,m,p,u,0,2)
-Xlinker <arg> Pass <arg> to linker
-Xm Support dollar character in C++ identifiers
-Y<c>,<dir> Specify <dir> for location of component <c> (a,l,m,p,0,h,i,u)
-YA,<dir> Change default directory searched for components
-YI,<dir> Change default directory searched for include files
-YP,<dir> Change default directory for finding libraries files
-YS,<dir> Change default directory for startup object files
-c Compile only - produce .o files, suppress linking
-compat=5 Standard mode; accept source code that conforms to the C++ standard (default mode)
-compat=g G++ compatibility mode; accept g++ source code and generate g++ compatible object code
+d Do not expand inline functions
-dalign Ignored
-d{n|y} Dynamic [-dy] or static [-dn] option to linker
-dryrun Show compiler commands built by driver, no compilation
-e<arg> Passed to linker
-erroff[=<tags>] Suppress warnings specified by tags; <tags>={%none, %all, <tag list>}
-errtags[={yes|no}] Display messages with tags
-errwarn[=<tags>] Treats warnings specified by tags as errors; <tags>={%none, %all, <tag list>}
-fPIC Same as -KPIC
-fast Optimize using a selection of options
-features=<a>[,<a>] Enable/disable various C++ language features
-filt[=<a>[,<a>]] Control the filtering of both linker and compiler error messages;
<a>={errors,names,returns,stdlib}
-flags Show this summary of compiler options
-flagsrc=<f> Accept command options from file <f>
-fnonstd Initialize floating-point hardware to non-standard preferences
-fns[={yes|no}] Select non-standard floating point mode
-fpic Same as -Kpic
-fprecision=<a> Set FP rounding precision mode; <a>={single|double|extended}
-fround=<r> Select the IEEE rounding mode in effect at startup
-fsimple[=<n>] Select floating-point optimization preferences <n>
-fstore Force floating pt. values to target precision on assignment
-ftrap=<t> Select floating-point trapping mode in effect at startup
-g Compile for debugging
-g0 Compile for debugging by dbx but allow inlining
-g3 Compile for debugging by dbx including macros.
-h <name> Assign <name> to generated dynamic shared library
-help Same as -xhelp=flags
-i Passed to linker to ignore any LD_LIBRARY_PATH setting
-include <file> Include the contents of <file> before other files
-inline=<v> Attempt inlining of specified user routines; <v>={%auto,<func>,no%<func>}
-instances=<a> Control the link attributes of template instantiations;
<a>={static|global|extern|explicit|semiexplicit}
-instlib=<library> Inhibit generation of instances already in <library>
-keeptmp Keep temporary files created during compilation
-l<name> Link with library lib<name>.a or lib<name>.so
-libmieee Same as -xlibmieee
-libmil Same as -xlibmil
-library=<a>[,<a>] Incorporates specified CC-provided libraries into compilation and linking
-m32 Set 32-bit addressing model
-m64 Set 64-bit addressing model
-mc Remove duplicate strings from .comment section of output files
-migration Show where to get information about migrating from C++ 4.2
-mr Remove all strings from .comment section of output files
-mr,"string" Remove all strings and append "string" to .comment section
-mt[={yes|no}] Specify options needed when compiling multi-threaded code
-native Optimize for the host system (-xtarget=native)
-noex Same as -features=no%except
-nofstore Do not force floating pt. values to target precision on assignment
-o <outputfile> Set name of output file to <outputfile>
-p Compile for profiling with prof
+p Ignore non-standard preprocessor asserts
-pg Compile for profiling with gprof
-pic Same as -Kpic
-qp Compile for profiling with prof
-s Strip symbol table from the executable file
-shared Same as -G
-staticlib=<a>[,<a>] Force linkage of specified libraries to be static
-sync_stdio[={yes|no}] Controls synchronization of the I/O libraries
-temp=<path> Use <path> as directory for temporary files
-template=<a>[,<a>] Enable/disable various template options;
<a>={wholeclass,extdef,geninlinefuncs}
-time Same as -xtime
-traceback[=<a>[,<a>]] Provide stack traceback for the abnormal termination by signals; <a>={%none|common|<signal>}
-unroll=<n> Enable unrolling loops <n> times where possible
-v Same as -verbose=diags
-verbose=<a>[,<a>] Control verbosity during compilation; <a>={template,diags,version}
-w Suppress compiler warning messages
+w Print warnings about additional questionable constructs
+w2 Emit warnings for code with additional portability problems
-xF[=<a>[,<a>]] Compile for later mapfile reordering and data fragmentation
-xM Generate makefile dependencies
-xM1 Generate makefile dependencies, but exclude /usr/include
-xMD Generate makefile dependencies and compile at once
-xMMD Generate makefile dependencies like -xMD, but excluding standard headers
-xMF <file> Specify output <file> for makefile dependencies dump
-xMerge Merge data segment into text segment
-xO<n> Generate optimized code; <n>={1|2|3|4|5}
-xaddr32[={yes|no}] Generate binaries assuming the associated process is restricted to the lower 32bit address space
-xalias_level[=<a>] Enable optimizations based on the specified alias_level;
<a>={any|simple|compatible}
-xanalyze=code Generate static analysis information for the code analyzer
-xannotate[={yes|no}] Annotate binaries for optimization and analysis
-xar Create archive library with instantiated templates
-xarch=<a> Specify target architecture instruction set
-xautopar Enable automatic loop parallelization
-xbuiltin[=<a>] Inline system functions and intrinsics when beneficial;
<a>={%none|%default|%all}
-xcache=<t> Define cache properties for use by optimizer
-xchar[=<a>] Treat type char as signed (s) or unsigned (u);
<a>={s|signed|u|unsigned}
-xcheck[=<a>[,<a>]] Generate runtime checks for error condition;
<a>={stkovf,init_local}
-xchip=<a> Specify the target processor for use by the optimizer
-xcode=<a> Generate different code for forming addresses; <a>={pic13|pic32}
-xdebugformat=<a> Selects the format of debugging information; <a>={stabs|dwarf}
-xdepend[={yes|no}] Analyze loops for data dependencies
-xdumpmacros[=<a>[,<a>]] Prints macro definitions on the standard error output;
<a>={defs,undefs,use,loc,conds,sys}
-xdryrun The same as -###
-xe Perform only syntax/semantic checking, no code generation
-xhelp=<a> Display on-line help information; <a>={flags|readme}
-xia Enable interval arithmetic
-xinline=<v> Attempt inlining of specified user routines; <v>={%auto,<func>,no%<func>}
-xinstrument=[no_]datarace Enable/disable instrumentation for race detection tool
-xipo[=<n>] Enable optimization and inlining across source files; <n>={0|1|2}
-xipo_archive=<a> Enable crossfile optimization including archive files;
<a>={none|readonly|writeback}
-xivdep[=<a>] Ignore loop-carried dependences on array references in a loop; <a>={loop|loop_any|back|back_any|none}
-xjobs=<n> Maximum number of components compiler will fork in parallel
-xkeepframe[=<v>] Do not optimize stack frame of specified user routine; <v>={%all|%none|[no%]<func>}
-xlang=<a>[,<a>] The set of languages used in the program; <a>={f90,f95,c99}
-xldscope=<a> Indicates the appropriate linker scoping within the source program;
<a>={global|symbolic|hidden}
-xlibmieee Force IEEE 754 return values for math routines in exceptional cases
-xlibmil Inline selected libm math routines for optimization
-xlibmopt Link with optimized math library
-xlic_lib=sunperf (Obsolete) Use -library=sunperf instead
-xloopinfo Show loops that parallelized
-xmaxopt=[off,1,2,3,4,5] Maximum optimization level allowed on #pragma opt
-xmodel=<a> Specify memory model for 64-bit programs;
<a>={small|kernel|medium}
-xnolib Do not link with default system libraries
-xnolibmil Cancel -xlibmil on command line
-xnolibmopt Cancel -xlibmopt on command line
-xnorunpath Do not build a runtime search path into the executable
-xopenmp[=<a>] Enable OpenMP language extension; <a>={none|noopt|parallel}
-xpagesize=<a> Controls the preferred page size for the stack and for the heap; <a>={4K|2M|4M|1G|default}
-xpagesize_heap=<a> Controls the preferred page size for the heap; <a>={4K|2M|4M|1G|default}
-xpagesize_stack=<a> Controls the preferred page size for the stack; <a>={4K|2M|4M|1G|default}
-xpch=<t> Enable precompiled headers. Collect data for, or use existing, PCH file; <t>={auto|autofirst|{collect,use}:<file>[.cpch]}
-xpchstop=<file> Specified include file marks end of initial common sequence of pre-processing directives for precompiled headers
-xpec[={yes|no}] Generate a PEC binary
-xpg Compile for profiling with gprof
-xport64[=<a>] Enable extra checking for code ported from 32-bit to 64-bit platforms;
<a>={no|implicit|full}
-xprefetch[=<p>] Specify instruction prefetch; <p>={auto,no%auto,explicit,no%explicit}
-xprefetch_auto_type=<a> Specify automatic indirect prefetch insertion for loops;
<a>={indirect_array_access}
-xprefetch_level[=<n>] Controls the aggressiveness of the -xprefetch=auto option; <n>={1|2|3}
-xprofile=<t> Collect data for a profile or use a profile to optimize; <t>={{collect,use}[:<path>],tcov}
-xprofile_ircache[=<t>] Path to intermediate file cache used with -xprofile option
-xreduction Recognize reduction operations in parallelized loops
-xregs=<a>[,<a>] Specify the usage of optional registers; <a>={frameptr}
-xrestrict[=<f>] Treat pointer valued function parameters as restricted; <f>={%none,%all,<function-name list>}
-xs Allow debugging without object (.o) files
-xspace Do not do optimizations that increase code size
-xtarget=<a> Specify target system for optimization
-xtemp=<dir> Set directory for temporary files to <dir>
-xthreadvar[=<a>] Control code generation for thread variables; <a>={dynamic}
-xtime[=<a>] Report the execution time for each compilation phase; <a>={1|2|3}
-xtrigraphs[={yes|no}] Enable|disable trigraph translation
-xunroll=<n> Enable unrolling loops <n> times where possible
-xustr=<a> Recognize sixteen-bit string literals; <a>={ascii_utf16_ushort|no}
-xvector[=<a>[,<a>]] Automatic generation of calls to the vector library functions and/or the generation of the SIMD instructions
-xvpara Verbose parallelization warnings
-xwe Convert all warnings to errors
Suffix 'a' Object library
Suffix 'il' Inline template file
Suffix 'o' Object file
Suffix 'so' Shared object
Suffix 's' Assembler source
Suffix 'S' Assembler source for cpp
Suffix 'c' C++ source
Suffix 'cc' C++ source
Suffix 'cxx' C++ source
Suffix 'cpp' C++ source
Suffix 'C' C++ source
Suffix 'c++' C++ source
Suffix 'i' C++ source after preprocessing
Suffix 'err' ld error file
Suffix 'd' Build dependencies file
Use the -xdumpmacros option.
Per the Solaris Studio 12.4 C User's Guide:
B.2.105 -xdumpmacros[=value[,value...]]
Use this option when you want to see how macros are behaving in your program. This option provides information such as macro defines, undefines, and instances of usage. It prints output to the standard error (
stderr), based on the order in which macros are processed. The-xdumpmacrosoption is in effect through the end of the file or until it is overridden by the dumpmacros or end_dumpmacros pragma. See dumpmacros.The following table lists the valid arguments for value. The prefix
no%disables the associated value....
cc -E -xdumpmacros /dev/null produces this output:
#define __LINE__
#define __FILE__
#define __STDC__ 0
#define __STDC_VERSION__ 199409L
#define __DATE__ "Jun 9 2016"
#define __TIME__ "09:09:48"
#define __STDC_IEC_559__ 1
#define __STDC_IEC_559_COMPLEX__ 1
#define __STDC_HOSTED__ 1
#define __SunOS_5_11 1
#define __SUNPRO_C 0x5120
#define __unix 1
#define __SVR4 1
#define __sun 1
#define __SunOS 1
#define __i386 1
#define __BUILTIN_VA_ARG_INCR 1
#define __C99FEATURES__ 1
#define __PRAGMA_REDEFINE_EXTNAME 1
#define unix 1
#define sun 1
#define i386 1
#define __RESTRICT 1
#define __FLT_EVAL_METHOD__ - 1
#define __SUN_PREFETCH 1
#define __NOVECTORSIZE__ 1
# 1 "/dev/null"
#ident "acomp: Sun C 5.12 SunOS_i386 2011/11/16"