VSI C++ V10.1-3 for OpenVMS x86-64

Fixed issues with 32-bit string allocation, including problems with template functions and functions returning std::string with pointer-type parameters.

Updated global allocation ::operator new to depend on pointer size. It now allocates from 32-bit space when compiled under #pragma pointer_size 32 or when the /POINTER_SIZE=32 qualifier is used.

Corrected the MMS dependency file format generator. The /MMS_DEPENDENCIES qualifier now produces valid dependency files.

Resolved multiple bugs related to 32-bit pointer size handling.

Standardized Clang/CXX and llvm-mc messages with OpenVMS-specific prefixes: %CXX-F-FATAL, %CXX-E-ERROR, %CXX-W-WARN, %CXX-I-INFO. Conclusion messages now start with %CXX-W-ENDDIAG or %CXX-E-ENDDIAG.

Fixed and improved debug information generation and handling in the back end.

Improved listing file generation with prologue/epilogue files, and fixed issues with long filenames.

By default, the operators new and new[] return 64-bit addresses that will not fit into 32-bit pointers. This is a change from the V10.1-1 compiler that always allocated memory in 32-bit heap. Compilations that use /POINTER_SIZE=32 on the command line will allocate memory from the 32-bit heap, but compilations that do not use /POINTER_SIZE or those that use /POINTER_SIZE=64 will allocate memory from the 64-bit heap. The #pragma pointer_size also changes the behavior of the new() operator and it allocates memory from the 32-bit or 64-bit space depending on the pragma option.

For programs that revert back to 32-bit memory allocation with /POINTER_SIZE=32, ensure that all systems have the newest LIBCXX and LIBCXXABI libraries installed on target systems. Currently, these updated RTLs are only available with the C++ kit, so you must install C++ on all target systems, even those that will not be used for development. The updated RTLs will be included in a future update for OpenVMS V9.2-2.

The /LIST qualifier is now supported. The compiler supports most of the /SHOW keywords (like on IA-64) and creates a listing file that has a very similar look and feel to the listing files created by the Alpha and IA-64 compilers.

LIB$ESTABLISH built-in is fully supported by CXX.

The allocation of objects of std::string is now based on the current pointer size setting. The default allocator for std::string will automatically be changed to the allocator appropriate for the 32-bit address space based on the current /POINTER_SIZE or #pragma [required_]pointer_size setting. When the pointer size is set to 32 bits, the object will be allocated in the 32-bit memory to ensure that std::string::c_str() and std::string::data() return valid 32-bit pointer values.

The ability to do source-level debugging in the OpenVMS debugger is now supported. When debugging, users need to enter SET SOURCE before printing a line from a file.

long double

The long double data type is not fully supported yet.

No machine code listing file generation. The ANALYZE/OBJECT/DISASSEMBLE command will produce machine code with source line numbers. It does not show any static data or static constants.

Still have some problems with 32-bit pointers.

Previously built and linked applications may have problems using the new versions of C++ RTLs (LIBCXX and LIBCXXABI). Please report any issues related to 32/64-bit pointers.

Calling std::cout.operator<< within global objects constructors brings to %SYSTEM-F-ACCVIO when linked with static libraries CXX_STATIC.OLB and CXXABI_STATIC.OLB.

The overloading of global new/delete operators are currently not supported.

Comma-separated list of source files is not supported by CXX, meaning you cannot compile multiple files at once.

If you have one or more files with the same name as the standard library header name, you must specify their location with the -iquote option of Clang instead of the /INCLUDE qualifier to avoid confusion.

Let's say the file is in the current directory. Instead of specifying

$ CXX /INCLUDE=[] FOO.CXX

use:

$ CXX /CLANG=("-iquote", "[]")

If your C++ code calls LIB$FIND_IMAGE_SYMBOL or any other code that in turn calls LIB$FIND_IMAGE_SYMBOL, you must link with /THREADS_ENABLE.

The built-in functions are not fully supported yet for OpenVMS x86-64. Currently, only the functions with the __ATOMIC_* and __PAL_* prefixes are supported:

• __ATOMIC_ADD_LONG
• __ATOMIC_ADD_LONG_RETRY
• __ATOMIC_AND_LONG
• __ATOMIC_AND_LONG_RETRY
• __ATOMIC_OR_LONG
• __ATOMIC_OR_LONG_RETRY
• __ATOMIC_INCREMENT_LONG
• __ATOMIC_INCREMENT_LONG_RETRY
• __ATOMIC_DECREMENT_LONG
• __ATOMIC_DECREMENT_LONG_RETRY
• __ATOMIC_EXCH_LONG
• __ATOMIC_EXCH_LONG_RETRY
• __ATOMIC_ADD_QUAD
• __ATOMIC_ADD_QUAD_RETRY
• __ATOMIC_AND_QUAD
• __ATOMIC_AND_QUAD_RETRY
• __ATOMIC_OR_QUAD
• __ATOMIC_OR_QUAD_RETRY
• __ATOMIC_INCREMENT_QUAD
• __ATOMIC_INCREMENT_QUAD_RETRY
• __ATOMIC_DECREMENT_QUAD
• __ATOMIC_DECREMENT_QUAD_RETRY
• __ATOMIC_EXCH_QUAD
• __ATOMIC_EXCH_QUAD_RETRY
• __PAL_INSQHIL
• __PAL_INSQTIL
• __PAL_INSQUEL
• __PAL_INSQUEL_D
• __PAL_INSQHILR
• __PAL_INSQTILR
• __PAL_REMQHIL
• __PAL_REMQTIL
• __PAL_REMQUEL
• __PAL_REMQUEL_D
• __PAL_REMQHILR
• __PAL_REMQTILR
• __PAL_INSQHIQ
• __PAL_INSQTIQ
• __PAL_INSQUEQ
• __PAL_INSQUEQ_D
• __PAL_INSQHIQR
• __PAL_INSQTIQR
• __PAL_REMQHIQ
• __PAL_REMQTIQ
• __PAL_REMQUEQ
• __PAL_REMQUEQ_D
• __PAL_REMQHIQR
• __PAL_REMQTIQR

Information for each group of newly supported built-in functions will be added here and in the RELEASE_NOTES file of the OpenVMS x86-64 CXX kit.

In some cases, the optimizer unexpectedly removes a user-defined operator delete(). This optimizer bug has already been fixed in a currently unreleased version of the LLVM backend. A future version of VSI C++ will include this newer LLVM. The workaround is to disable the optimizer at compilation time.

Sample code:

$ type bug.cxx
   extern "C" int printf(const char *,...);
   class C {
     public:
       C() { throw "up"; }
   };

   void operator delete(void *ptr) throw()
   {
     printf("Called delete\n");
   }

   int main()
   {
     try {
       C *p = new C; // C() will throw exception, invoking delete
     }
     catch (...) { printf("Exception Caught\n"); }

     return 0;
   }

   $ CXX  /OPT=(LEVEL=3) bug.cxx
   $ link bug
   $ run  bug
   Exception Caught

   // But the expected output is:
   Called delete
   Exception Caught

To be able to successfully use CXX NL: or CXX SYS$INPUT on ODS-5 disks, please set DECC$RENAME_NO_INHERIT to 1 as follows:

$ define decc$rename_no_inherit 1

std::string becomes std::string32 in contexts where the pointer size is 32 bits, and these two types can be implicitly converted to each other. Still, these pointers and non-const references for these types are not implicitly convertible.

Example:

#include <string>

#pragma required_pointer_size short
void foo32(std::string& str32);
void foo32const(const std::string& str32);
#pragma required_pointer_size long

void foo64(std::string& str64);
void foo64const(const std::string& str64);

int main () {
#pragma required_pointer_size short
  std::string str32 = "hello str32";
  std::string* str32p = &str32;
#pragma required_pointer_size long
  std::string str64 = "hello str64";
  std::string* str64p = &str64;

  str32 = str64; // Ok
  str64 = str32; // Ok
  foo32const(str64); // Ok
  foo64const(str32); // Ok

  str64p = str32p; //Failure
  str32p = str64p; //Failure
  foo32(str64); //Failure
  foo64(str32); //Failure

  return 0;
}

Previously, stdlib.h included the math.h header file. Starting from the current version, this inclusion has been removed.

As a result, you may encounter compilation errors due to undeclared symbols (such as abs or logf). To resolve this, please add #include <math.h> to your code.

There could be some differences with IA-64 CXX in handling of #pragma extern_model strict_refdef. For example:

#pragma extern_model strict_refdef "ABCD" lcl, shr, exe, wrt, novec, long

In the map file, it is as:

ABCD                            xxxxxxxx xxxxxxxx xxxxxxxx (         dd.) OCTA  4 CON,REL,LCL,  SHR,NOEXE,  WRT,NOVEC,NOMOD

But should be:

ABCD                            xxxxxxxx xxxxxxxx xxxxxxxx (         dd.) OCTA  4 CON,REL,LCL,  SHR,NOEXE,  WRT,NOVEC,NOMOD

Two functions called floatundidf() and floatundisf(), from LLVM compiler_rt library (which is now loaded in LIBOTS2.EXE shared library) are not working correctly. The problem is under investigation.