C++ compiler

• New -fident/-fno-indent options to control generation of .ident strings on platforms that support that.

• New -fgcc-version=x.y.z option to specify desired GCC compatility (for Linux and z/TPF environments.)

• New -fsyntax-only/-fno-syntax-only options to simply parse the source and not generate the program.

• The -D and -U options are now processed in the order they appear on the command line.

• The alignment of _Decimal128 changed to match GCC's for DCC, z/TPF and Linux environments. For LE environments the alignment will match IBM's.

• For z/Linux CFI information, default to using .cfi_xxx instructions the GNU gas assembler. -fno-dwarf2-cfi-asm selects the old manually-generated tables.

• If allowed, the __builtin_popcount() function takes advantage of the Miscellaneous-Instruction-Extentions Facility 3 enhancements to the POPCNT instruction to reduce the generated code

• Support for GCC's -MM option which is similar to -M except that dependencies involving system include files are not included in the output.

• Support conversion between 128-bit integers and the various floating point formats.

• Support conversion between 128-bit integers and packed decimal data.

• Improvements in tracking the setting of the CC in the register allocator for improved code.

• The compiler uses relative jumps within regions for performance if the architecture option allows.

• Option names are migrating to the same style as GCC and CLANG, where '-' is used instead of '_'. The old option names continue to be accepted, but the new names will appear in the listing and documentation.

• The optimizer now recognizes (s+/-C s) style expressions where 's' is a signed integer value. The assumption is that signed integer arithmetic is undefined when it overflows, so such an expression can be deduced to be TRUE or FALSE . The new -fwrapv and -fno-wrapv options control this assumption. -fwrapv indicates the compiler should assume signed integer overflow "wraps-around" and defeats such optimization. -fwrapv is the default but that may change in the future.

• The optimizer now recognizes (ptr+/-C ptr) with the assumption that pointer arithmetic doesn't wrap-around. New -fwrapv-pointer and -fno-wrapv-pointer options to control this.

• For MVS or z/OS targets, we properly follow z/OS convention of saving/restoring FPR8-FPR15 if used in a function. There is a new -mafp_volatile option also causes any function call to indicate the registers are altered and thus saved/restored in the calling function.

• The code generated for the builtin strcmp() function was improved to 'swap' the comparison addresses for CLC and CLST instructions and take advantage of IPM + shifts to produce a -1, 0, +1 result.

• The code generated for the builtin memcmp() function was improved to do no branches for constant lengths when possible. Also, the code was dramatically improved over the previous byte-by-byte comparison code to do the comparison in 256-byte chunks, then a final CLC for the remainder.

• -@ processing improved on MVS to support quoted strings.

• Use pointer-sized offset (like ptrdiff_t) for the pointer to data member types. That means "type class::*var", which defines a variable of type "pointer to data member of type within class" will now be 8 bytes in 64-bit mode. It used to be always 4 bytes, which was a mistake and makes it incompatible with IA64 ABI (g++ for z/Linux and z/TPF).

• -D and -U options are now processed in command line order.

• Support GCC's -fshort-enums. -fshort-enums is equivalent to -fenum=SMALL and -fno-short-enums is equivalent to -fenum=INT.

C++ compiler

• Support C++17 constexpr if

• Enable statement expressions in DCXX LE mode

• Reduce the size of very large stack frames by about 0.1% that had been reserved for spill slots that could not have been used.

• Add support for UTF-8 encoded source, using -fsource_enc=utf8.

• Add support for __builtin_* math functions (sin/exp/etc...) for compatibility with g++.

• Support the __builtin_sqrtf(), __builtin_sqrt() and __builtin_sqrtl() builtins from GCC, for both IEEE and HFP data

• __atomic_load / store / exchange / compare_exchange now use the builtin implementation for pointer types (previously, it punted to the run-time implementation). And provide a run-time implementation of these for z/TPF.

• Added last remaining __atomic builtins: __atomic_test_and_set() and __atomic_clear().

• Support GCC's __builtin_bswap16(), __builtin_bswap32() and __builtin_bswap64() builtins. Generated code will use hardware instructions when allowed by the architecture settings.

• Add -mtpf-trace-skip option which alters the z/TPF trace branch targets in the prologue and epilogue to point to a skip-frame variant.

• Reduce memory usage in the compilers by up to 75% when optimization is enabled (-O).

• Support for the __builtin_isdigit() function.

• Support new -march=z13 flag for the 13th edition (Sept. 2019) of the Principles of Operation and take advantage of the new miscellaneous-instruction-extensions facility 3 instructions when we can.

• If -mmisc-instructions-extensions-facility-2 is allowed, the compiler will now take advantage of the AGH/SGH and MGH instructions for operations involving 64-bit signed values and 16-bit signed values in memory.

• Reduce memory usage in the compilers by up to 75% when optimization is enabled (-O).

• Optimizer improvements for constant-propagation of string constant addresses.

• Improvements to live variable analysis in the code generator to speed up compile-time for large functions.

C++ library

• Support C++ standard threading (based on the POSIX pthread model now provided in the C library.)

C++ compiler:

• New cross-platform debugger with C++ support.

• Support the __cs1()/__cds1()/__csg()/__cdsg() builtins in LE mode.

• For the Dignus environment, alloca() was defined to be __builtin_alloca() (as Linux and, essentially, LE environments do.) This allows the compiler to be aware when alloca() has been used.

• Add support for gcc-style Transactional-Execution Facility (-mtransaction-facility or -march=z10) builtins: __builtin_tbegin, __builtin_tbegin_nofloat, __builtin_tbegin_retry, __builtin_tbegin_retry_nofloat, __builtin_tend, __builtin_tabort, __builtin_tx_assist, __builtin_tx_nesting_depth, __builtin_non_tx_store.

• Support C++14 (-fcpp14) and experimental C++17 (-fcpp17).

• Improvements to floating-pt code generation/optimiztion to be more conforming and consistent between optimized and non-optimized code.

• Duplicate file-scoped string constants now only appear once in the generated code.

• Non-re-entrant visible data now goes into its own CSECT (instead of part of the @CODE section.) This allows for duplicate non-rent definitions to be elided at link time.

• Correct issue in register allocation that caused very slow compile-time and excessive register spilling when encountering high register contention.

• In IBM compatiblity mode, XPLINK __callback function pointers are fully supported, allowing via non-XPLINK function pointers passed to other DLLs.

C++ compiler:

• C++11 is now the default. A new -fcpp98 option indicates that the previous C98 standard should apply.

• Allocation of offsets in the local stack frame was greatly improved to reduce total runtime stack size.

• Many improvements to use newer instructions when the appropriate architecture level is selected. The maximum architecture level is now -march=z11 which represents the 11th revision of the z/Architecture Priniciples of Operation.

• Loops that involve constant assignments are converted into memset-style operations.

• The C++ compiler now accepts the _Ieee and _Hexadec qualifiers on floating-point types (indicating a value in IEEE or HFP format regardless of the -fieee compile time setting.)

• Support for __builtin_fpclassify() for HFP and BFP data. This is the 'generic' version; __builtin_bfp_fpclassify() accepts BFP data, and __builtin_hfp_fpclassify() accepts HFP data.

• Support for floating-pt builtin functions: __builtin_frexpf, __builtin_frexp, __builtin_frexpl, __builtin_signbitf, __builtin_signbit, __builtin_signbitl, __builtin_isnanf, __builtin_isnan, __builtin_isnanl, __builtin_isinff, __builtin_isinf, __builtin_isinfl, __builtin_isfinitef, __builtin_isfinite, __builtin_isfinitel, __builtin_isnormalf, __builtin_isnormal, __builtin_isnormall These are 'generic' versions that depend on the current setting of the -fieee option. There are also BFP or HFP specific versions of these (with _bfp or _hfp qualifications after the __builtin portion of the name.)

• Support __builtin_return_address in all environments.

• Add LE compatibility (-fc370) support for #pragma namemangling(ansi/compat) and #pragma namemanglingrule(fnparmtype/fnparmscmp, on/off).

• new -febcdic=name option that indicates which EBCDIC code page to use for compile-time ASCII<->EBCDIC constant translations. Consult the C++ compiler documentation for the list of supported EBCDIC character sets.

• Improve temporary file creation on Windows platforms so the compiler won't encounter problems when run in parallel.

• Add support for the remaining IBM _Traits_is_...() and _Traits_has_...() operators when -fc370 is specified.

• Add support for #pragma namemangling(v5/v7/v8/pop) for IBM compatibility (-fc370).

• Predefine the __NO_INLINE__ macro if inlining disabled.

• New -fvtable_listing option that adds the virtual function table offsets to the C++ compiler listing.

• If optimization is enabled, predefine the __OPTIMIZE__ and __OPTIMIZE_SIZE__ macros.

• -frtti now applies to both -fc370 and -fc370_extended (LE compatibility) modes.

• Internal improvements to improve compilation speed for programs that have many global initializers.

• Implement -fsigned_char in DCXX. Previously, most operations were still treated as unsigned. Name mangling (ABI) is not affected by this change.

• Anonymous structures are now accepted as operands of the sizeof() operator.

• If the 3rd argument to __builtin_memchr() is 0, then the result is definitionally NULL.

C++ Library:

• The older StlPort library was replaced with a more modern version based on LLVM. This version is C++11 compliant; with many C++14 features.

• The C++ library is now floating-point type agnostic and can handle BFP and HFP values in the same load module.

C++ compiler:

• Ongoing C++ 11 support

• Support __attribute__((visibility("hidden")) for Systems/C shared objects.

• Support for many GCC-style __builtin functions

• Support __attribute__((always_inline)) on functions to bypass compiler heuristics when determining if a function is eligible for inlining.

• New -isystem option for providing the location of system include files.

• Support "dignus.inf-relative" paths for "System Include" specified in the license key file.

• Support new -Spath option that is similar to IBM's SEARCH option for searching for included files.

• Support IBM's _Traits_is_pod() operator in IBM compatibility mode.

• New __bit_offsetof() and __bit_sizeof() operations similarly to offsetof() and sizeof() but returning the values in bits.

• Support for GCC-style inline assembly.

• New -M=fn option to specify an optional file name for dependency information. New -fdep[=fn] option to generate the dependency information during the normal compilation.

• Add -MT and -MF options compatibly with GCC. -MT targ provides the target name to use in dependency information. -MF names the output (equivalent to '=filename' for -fdep and -M.)

• If in-line __asm__ or gcc-style asm("") appears in a function, generate an LTORG in the 4K region in which it appears so that the in-line ASM can reference ASM literals.

• The compiler will now recognize a BASER=int specification in a #pragma prolkey() and use that given integer value as the code base register for the specific function. This allows the programmer to change the code-base for individual functions.

• Support (unsigned long long) (64-bit) bitfields in 32-bit compilations.

• Accept 0-sized arrays in any C++ context for better general compatibility with code written for gcc.

• New -fhfpfloatpromote option indicating if HFP (float) values should be promoted. For LE these are promoted to (double) when passed directly in parm blocks. For Linux and Systems/C mode, these are not promoted (to be compatible with IEEE values.) The -fnohfpfloatpromote option will disable the promotion, -fhfpfloatpromote enables it. Previous compiler versions did the promotion in Systems/C mode but this was changed.

• Add support for SFINAE, which involved some minor C++ ABI changes to support decltype template parameters.

• On going optimization improvements, etc...

C++ Library:

• Global dynamic initializations were removed to eliminate ordering problems.

• Import the C standard functions into the std:: namespace for situations like the <cmath> header where there are overloaded versions supplied in C++.

C++ compiler:

• Improve global optimizations.

• Improve generated code for conversion of 64-bit values to IEEE floating point.

• The -M option output was changed to be consistent with among all the Dignus tools.

• Improve compile time performance.

• New -fcpp11 option to enable support for most C++11 language features:
  • The >> token can be used to indicate two closing angle brackets, in addition to the right shift operator.
  • The static_assert declaration is supported.
  • The friend specifier can indicate non-class types.
  • Local and anonymous types can be template parameters.
  • Mixed string literal concatenations are supported.
  • C99 preprocessor extensions, including variadic macros, are supported.
  • C99-style _Pragma is supported.
  • __func__ string is defined.
  • Trailing comma in enum is accepted.
  • Constants too large for (long)) are now (long long).
  • extern template can be used to suppress instantiation.
  • typename can appear outside of a template.
  • auto is a valid type specifier.
  • Trailing return type syntax (func() -> type) is supported.
  • The decltype operator (a standardized replacement for the typeof extension) is supported.
  • Scoped enumeration types (enum class) are supported.
  • Lambda functions (closures) are supported (but std::function is not).
  • Rvalue references (&&) are supported.
  • Reference-qualifiers on implicit this argument are supported.
  • Functions can be assigned to delete or to default to control automatic generation of special member functions and cast operations.
  • Default move constructors and move assignment operators are generated.
  • Explicit conversion functions can be supplied.
  • The sizeof, typeid, and decltype operators can refer to non-static data members of classes.
  • The nullptr keyword is supported.
  • Certain declarator attributes can occur in double square brackets.
  • The final keyword may appear on class types and virtual member functions.
  • Alias declarations (with using) are supported.
  • Variadic templates are supported.
  • The char16_t and char32_t types are supported, along with their matching u''/u""/U''/U"" literals.
  • Access checking for base classes is performed in the context of the class being defined.
  • inline namespace is supported.
  • Initializer lists (type var{...};, etc.) are supported.
  • The noexcept specifier and operator are supported (influenced by -fimplicit_noexcept).
  • Range-based for loops (for (auto i : container)) are supported.
  • Initializers can be provided for non-static class data members.
  • The constexpr specifier is supported.
  • Unrestricted unions are supported (controlled by the -funrestricted_unions option).
  • Delegating constructors are supported.
  • Raw strings (R"(...)") and UTF-8 strings (u8"...") are supported.

• New optimization calculations to extend the range of global optimzations and greatly improve optimized code.

• The -march=z option was extended to become -march=zN, where N indicates the revision number of the z/Architecture Principles of Operation.

• New -mhfp-mult-add, -mgeneral-instructions-extension, -mimmediate-extension options to control the use of the z/Architecture instructions available with those hardware extensions.

• Loop optimizations were significantly enhanced to provide better loop-invariant and strength-reduction optimizations.

• Generation of switch-table selection code was considerably enhanced to employ several methods, or combinations of those methods, including binary search, bit-testing, etc..

• The listing was expanded to provide a STATIC MAP section detailing the layout of the static data area.

• The listing was expected to provide a cross-reference.

• Improved IBM C++ compatibility, -fc370=v2rx now implies -flate_tiebreaker for ambiguous overload cases.

• New -fpermission_friend option to emulate the older behavior that permits friend declarations to refer to private members of other classes.

• Support for -ftempinc in IBM compatibility mode, to generate a tempinc instantation directory.

• Added support for -fll=cba (CALL BACK ANY) mode in IBM DLL compatibility.

• New -funsigned_bitfields and -fsigned_bitfields to adjust the default signedness of bitfields in the generated code.

• New -ffnio (function name in object) that stores the function name in the generated code just prior to the function. This is helpful in IBM compatibility mode when reading LE dumps.

• New -fhide_skipped option which removes listing lines which are skipped during preprocessing.

• Improved constant folding of IEEE and HFP floating-pt values in the optimizer.

• Improved generated code for 64-bit shifts.

• Generated code takes advantage of NIHH/NIHL/NILH/NILL and OIHH/ OIHL/OILH/OILL when z/Architecture instructions are allowed.

• Improved compilation time.

• Support for -On option, where n is a the value 0, 1, 2 or 3 that controls the application of optimizations.

• New optimizer with many more global optimizations. These new optimizations demonstrate a significant improvement in the generated code. Some test examples showed improvement between 22% - 38% in runtime performance.

C++ compiler

• Support for use with z/TPF, including z/TPF runtime components.
• Improved codegeneration & optimization
• Integrated support for building for z/TPF, as well as TPF 4.1 in the same compiler.
• Support for specifying both -g and -O on the command line (generating some debugging information for optimized code.)

• Reductions to compile-time memory use, especially for large functions.

• Improved use of builtin memset() instead of invoking the library memset() routine in certain internal operations.

• Compatibility with GCC when the -flinux or -fztpf options are specified. We no longer provide Dignus C++ runtime libraries, the system-provided ones are now used.

• Improvements in optimizations, including improved inlining, improved global constant propagation and value-number functions.

• Support for z/TPF and TPF 4.1 integrated into one compiler.

• Support for GCC's __asm__("string") syntax, applied to variables and function declarations; basically the same as #pragma map().

• #pragma pack() extensions to provide configurable support for LE-style packing, Systems/C-style packing, or GCC-style packing.

• Support #pragma export and _Export for ELF (z/TPF and z/Linux) objects.

• The, now deprecated, -fansi_bitfield option has been replaced by -fansi_bitfield_packing.

• -fno_old_specializations is now the default, to match more modern compilers.

• New -fwchar_ucs option that causes wide-character string or char constants to be encoded in UCS-2/UCS-4 regardless of the -fasciiout setting.

• Listing enhanced so that the options appear in alphabetical order, the command-line paramters are also provided.

• Optimize expection specifications on functions that are simply wrappers for builtins.

• New -fdfe/-fnodfe option which enables/disables elimination of dead (unreferenced) functions.

• New -mmvcle option to allow the compiler to use the MVCLE/CLCLE instruction for large memory moves/compares.

• New -w option to suppress all warnings.

• New -femitdefs option to add #define values to the -E output.

• Unique name mangling for 64-bit and 32-bit pointers, so that a template can be initialized for both 31-bit and 64-bit pointers. New -fcompat_ptr64 option to select the old name mangling if needed.

• In Systems/C++ mode, changed to a variant of the IA64 ABI for the Dignus C++ runtime.

• Accept __local/__remote qualifiers in more positions.

• #pragma linkage("OS") now implies __local.

• #pragma prolkey/epilkey now imply that the function cannot be inlined.

• Support #pragma options(inline)/#pragma options(noinline)

• Support the Microsoft/GNU __COUNTER__ predefined macro extension.

• Support #pragma variable(name, RENT) and #pragma variable(name, NORENT)

• New -march=z option that indicates that the z/Architecture instructions are available even in 31-bit mode.

• New -mlp64 option which replaces the now deprecated -march=zarch option. -mlp64 indicates 64-bit long and 64-bit pointer.

• New -mdistinct-operands option that indicates the compiler can generate code that uses the z196 distinct-operands-facility instructions.

• New -mload-store-on-condition option that indicates the compiler can generate code that uses the z196 load-store-on-condition--facility instructions.

• New -mmvcle option that indicates the compiler can use the mvcle/clcle instructions for large memory moves/compares.

• Improved code generation for builtin strlen().

• Builtin strcat()/memchr() will use string instructions if they are allowed.

• Block move and builtin memcpy() with a constant length was improved to use a simple MVC loop with only one EXecuted MVC if needed, or the MVCLE instruction if allowed.

• Improvements to recognize common BCTR+LTR+BNZ sequences and fold those into a single BCT instruction.

• If the length parameter to builtin memcpy() is a (non-constant) unsigned character, the compiler will generate a single EXecuted MVC instruction as the length cannot be longer than 256.

C++ library

• The compiler now operates in GNU compatible mode in z/Linux, Linux/390 and z/TPF modes. Thus, a C++ library for these environments is no longer provided. The version that is installed with the operating system is used.

C++ Compiler:

• Improved codegeneration & optimization.

• Allow function pointers to have __ptr31/__ptr64 qualifiers even if they are not defined through a typedef.

• Allow calls to function pointers with __ptr31 and __ptr64.

• When -g (debugging mode) is specified in IBM compatibility mode, the compiler will now generate ISD debugging information, or DWARF debugging information.

• Options are now listed in alphabetical order in the compiler listing.

• Support for z/TPF code genration.

• Guiding declarations is now disabled by default, use -fguiding_decls to achieve the old behavior.

• Support for GCC's __attribute__((__packed__)).

• New -fstructmaphex option for displaying offsets/lengths in the structure map in hex values.

• Default section name length expanded to 1023.

• Add support for A/E prefix on string/character literals to specify ASCII or EBCDIC independently of -fasciiout.

• Improve generated code for 1-byte signed __asmval() values.

• Provide the __370__ predefined macro as the IBM compiler does.

• Added -fnamemangling=ansi for IBM compatibility mode.

• Add support for include files in .zip files, like -Imyheaders.zip.

• Many codegeneration/optionization improvments, some of which include:
  • Use TML instruction for situations like:
       if(x & val) {
    (where 'val' is sufficiently sized to take advantage of the instructions.)
  • Improved the codegenerator to eliminate LTRs after certain arithmetic and logical operations.
  • Improved value-numbering algorithms for local/block optimizations.
  • Improved memory usage in register allocator on many large examples.
  • Improvide in-liner algorithms and heuristics.

• Add support for #pragma runopts(POSIX(ON/OFF)) in IBM compatibility mode.

• Support for z/OS 1.9 and z/OS 1.10 versions in IBM compatibility mode.

• Many improvements in IBM compatibility and XPLINK modes.

C++ Compiler

• Improved support for volatile data references, forcing them to be in memory and loaded/stored at each reference.

• Support for XPLINK linkages in IBM compatibility mode.

• Support for later versions of IBM compatibility, including support through z/OS 1.7. This also includes newer IBM predefined macros.

• Improved compile time for large programs with large amounts of constant data.

• New optimizations, including improved constant propogation and basic-block related optimizations.

• Improved code generation, particularly when -march=esa390 or later is enabled.

• Added support for IBM-style "events file" for use with the IBM TPF Toolkit.

• Support Microsoft's __int8/__int16/__int32 and __int64 builtin types.

C++ Library

• Updated to version 4.6.2 of the industry-standard STLPort library.

C++ Compiler

• New -fpack option to specify per-compilation structure member alignment.
• Support for reading #include files from PDS members under OpenEdition.
• Support for -frsa=NNN to provide the user a mechanism for defining the per-function register-save-area.
• Support for IBM compatible namespaces if -fc370=z1r2i (or later) is enabled.
• Support for extern "OS" and extern "PLI" linkages.
• Support for 128-bit (long double) data type.
• New -march=esa390 option; causes the compiler to use halfword immediate instructions, use string instructions and to assume 16 floating-pt registers. Enabled by default with -flinux is specified.
• New state-of-the-art register allocation algorithms, greatly improving register use in the generated code.

Other Enhancements

• Version 1.76 is a maintenance release for C++.

C++ compiler:

• Support for the __rent and __norent keywords applied to data.
• If -march=zarch is specified, the compiler will predefine the macro _LP64 to 1; otherwise, it defines the _ILP32 macro to 1.
• Constant modulus by power-of-two (either signed or unsigned) is now optimized in the code-generator.
• When -fc370 is not specified, the compiler recognizes #pragma pack(pop) as a equivalent to #pragma pack(reset).
• Compiler was changed to define the name of the function (in Systems/C mode) in a compiler-generated character string that preceeds the function prologue. Then, a new LNAMEADDR= parameter was added to DCCPRLG which provides the label for this string. This allows the string to be as long as necessary, and contain any required bytes, and also be properly demangled in the C++ case. With this change, the results of a call to __traceback are much better.
• New -fc370=z1r2 option, to indicate compatibility with the IBM V1R2 z/OS compiler.
• New -fptr_to_unsized_array_parm option, to allow for compatibility with compilers that incorrectly allow this in C++ source (e.g. SAS/C++ and Microsoft.)
• Improved code generation for passing constant parameters to functions, particularly in Linux mode.
• In conjunction with the library, changed the name that is saved in the Systems/C prologue to be the de-mangled C++ name, along with removing the extraneous $s.

Other enhancements

Utilities:

• PLINK supplied with Systesm/C has been rewritten to better support automatic template instantiation. The C++ compiler now generates weakly defined functions for template instantiations. During the PLINK step, duplicate definitions of these weakly defined functions are eliminated.

  This allows version 1.70 of Systems/C++ to provide much better management of automatic template instantiation; without the need for "side files", or bloated executables.

Compilers:

• New -finstrument_functions option. For Linux (-flinux), this decorates function entry/exit points compatibly with the normal Linux utilities. In Systems/C mode, this causes macros to be generated a function entry/exit points.
• New -fstructmap/-fno_structmap option to enable/disable the "structure map" portion of the listing.
• New -fasmcomm option in the C++ compiler, which describes how the original C++ lines should appear in the generated assembler output.
• New -fasmlnno option in the C++ compiler. This causes the codegenerator to generate comments detailing the line number in the generated assembler source.
• New -fflex, -fmin_lm_reg=X and -fmin_stm_reg=X options in the C and C++ compiler. These control peepholing of consecutive Load/STore instructions. On the FLEX/ES(tm) system, LM and STM instructions can perform slower than the sequence of L/ST instructions.
• New -fopts[=macro] and -fendmacro[=text] option in the C++ compiler.
• New -fexportall option in C++ compiler (in IBM mode.)
• New -fdollar option in the C++ compiler - allows '$' in identifiers.
• Improved code generation in testing "flag" bytes, unsigned char operations and unsigned int operations.
• Code generation improvements to add new options to the prologue/epilogue to not save/restore as many registers (or, possibly no saving/restoring of registers.) Also, improvements to reduce the local DSA requirements.
• Improvements in constant multiplication evaluation to avoid unnecessary register copies.
• Linux prologue/epilogue improvements.

Compiler:

• Improved inlining, the compiler can now inline functions which were not previously inlined.
• Operator keywords supported in #if directives e.g. #if 0 or 1
• Value-initialization implemented.
• Many front-end improvements, including performance improvements, diagnostic improvements and listing file improvements.
• Support for #pragma ident and #ident which place text characters into the generated object.
• -O option to engage optimizations.
• Improved register tracking in the code generator, providing faster runtime performance.

As well as the new features of the C compiler , Systems/C++ V1.60 provides the following enhancements

Compiler:

• -fquiet option, which suppresses the banner messages
• -march=zarch option:
  True 64-bit compiler using "Grande" instructions
  extern "align4" linkage for C++
  Uses all 16 floating point registers for improved math code.
  Takes advantage immediate instructions
  New -famode=any to support using Grande instructions and 64-bit integers/pointers when the execution AMODE may not be 64-bits.
• __ptr31/__ptr64 pointer type qualifiers, for specifically declaring 32 (31) bit or 64 bit pointers, no matter what type of code is being compiled.
• switch() statements extended to support long-long integral values when -fc99 not enabled
• -fc370 now supports the following IBM builtin functions: alloca, tsched, cs, cds. Thus, all of the documented IBM C builtin functions are now supported.
• export supported in IBM compatiblity mode
• C++ compiler now includes a structure map in the listing file.
• Enhanced debugging information support for C and C++ compilers in -flinux mode. C and C++ code compiled with -flinux is now directly debuggable by the Linux debugger gdb.
• Support for -fpic and -fPIC for Linux/390 and z/Linux.
• Continued "general" code-generation improvements.
• z/Linux and OS/390 USS (OpenEdition) are now supported platforms.

C++ Library:

• New z/Architecture rent and non-rent libraries, allowing stack/heap/PRV above-the-bar, user-configurable.
• Non z/Architecture library now supports stack/heap/PRV above-the-line, user-configurable.
• Runtime support for executing C programs on MVS 3.8. at program startup for non-DCALL programs.

Documentation:

• Documentation PDFs now include a table of context with links into the documentation sections, and links within the document to interesting sections.