IBM C and C++ Compilers and XL C Compatibility

This appendix discusses compatibility issues between IBM C and C++ Compilers and the XL C compiler.

IBM C and C++ Compilers is not fully compatible with XL C: it is a stricter compiler than XL C. The following are the differences:

1. IBM C and C++ Compilers implements tighter ANSI conformance. For example, the following code segments are accepted by XL C, but not by IBM C and C++ Compilers:

   Example 1: Mixing K&R-style and ANSI-style function prototypes.

   void func();
   void func(float f){ ..... }

   Accepting this code leads to runtime problems since the float parameter in the definition is first promoted to double (default argument promotions). When the float argument is passed in, the wrong size registers are taken off the stack.

   Example 2: Null dimension multi-dimensional arrays.

   Arrays of incomplete arrays are not allowed, not even on parameters:

   void f(int p[][]);

   All dimensions except the first must be specified for a multi-dimensional array. In the above example, p is defined to be an incomplete array of an incomplete type (an incomplete array of an incomplete array of int).

   Example 3: Tags introduced at parameter scope are not exported to the enclosing non-parameter scope.

   int f(struct a *);
   struct a { int a; };
   int f(struct a* i ) { return i->a; }

   The type struct a was introduced in a parameter list, and will go out of scope at the end of the function declaration or definition.

2. IBM C and C++ Compilers may differ from XL C in implementation-defined parts of the language.
   • Apparent order of evaluation of arguments to functions with assignments will generate different results with XL C 1.3 and with IBM C and C++ Compilers. Other industry compilers may generate results with even greater differences. This code is not portable and should be avoided.

     #include <stdio.h>
      
     void func(int i, int j, int k)
     {
       printf("i = %d, j = %d, k = %d\n",i,j,k);
     }
      
     main()
     {
        int r=1;
        int c=0;
      
        func(c=r,r,r=4);
     }

     With XL C 1.3 the results are:

     i = 1	j = 1	k = 4

     With IBM C and C++ Compilers the results are:

     i = 1	j = 4	k = 4

   • Preprocessor differences include:
     • Output preserves coordinates of each token.
     • No redundant #line directives or multiple blank lines in output.
     • Erroneous/incomplete macro invocations are expanded anyway. This includes:
       • Extra arguments (ignored)
       • Empty arguments
       • Missing arguments (treated as empty)
       • Incomplete argument list (treated as completed)
         
         
3. IBM C and C++ Compilers differs from XL C where provisions for future extensions are implemented.
   • IBM C and C++ Compilers requires that #pragma options align=suboption appears before the structure definition. XL C allows the #pragma to appear anywhere before the last closing brace of the structure definition.
   • long long type is supported, even under ANSI mode. long long is recognized by all of the invocation commands except for ic89 and c89, which disable it by specifying the -qnolonglong option.
   • Invoking the compiler does not define _ANSI_C_SOURCE (unless you use the ic89 or c89 invocation commands, or unless you include standards.h). This is because there are many useful definitions in header files that are not detected when _ANSI_C_SOURCE is in effect. You can define _ANSI_C_SOURCE by supplying -D_ANSI_C_SOURCE at compiler invocation.