XL C/C++ compilers

Introduction
This paper details what's new in the IBM XL C/C++ compiler family. IBM XL C/C++ for AIX, XL C/C++ for Linux, and XL C/C++ for Blue Gene/Q compiler products are the successor to IBM's VisualAge C++ compiler. Compiler features vary slightly by operating system platform, and platform-specific features are described in the appropriate sections. The IBM XL C/C++ compilers share the common features described below unless otherwise noted. IBM XL C for AIX, V12.1, XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and IBM XL C/C++ for Blue Gene/Q, V12.1 are part of a multi-platform XL compiler family derived from a common code base optimized to run on IBM Power Architecture. IBM XL C for AIX , XL C/C++ for AIX, XL C/C++ for Linux, and XL C/C++ for Blue Gene/Q are industry leading optimizing compiler products that support IBM Power systems. IBM XL C/C++ fully exploits POWER6 and POWER7 architectures including the Power 970 as used in the IBM BladeCenter systems. The POWER7 processor is the very latest member of the IBM Power family, announced February 2010. IBM XL C/C++ for AIX and XL C/C++ for Linux support all new features and enhancements for the POWER7 processors, including the Vector Scalar eXtension (VSX) instruction set and the prefetch instructions. IBM XL C/C++ for Blue Gene/Q supports all new features and enhancements for the PowerPC processor, including the Quad Processing eXtension (QPX) instruction set. Note: For more information about the benchmarks for IBM Power Systems, see: v www.ibm.com/systems/power (IBM Power Systems) v www.spec.org/ v www.tpc.org/tpcc/ New features and enhancements in IBM XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1: v New C++11 features v New C11 features v OpenMP 3.1 support v Performance and optimization enhancements v New diagnostic reports v New built-in functions IBM XL C/C++ for AIX, V12.1 supports IBM Power Systems capable of running IBM AIX V5.3, AIX V6.1, AIX V7.1, PASE for i 6.1, and PASE for i 7.1. For more information, see: www.ibm.com/software/ awdtools/xlcpp/aix/ . IBM XL C/C++ for Linux, V12.1 is available on selected Linux distributions running on IBM Power Systems servers. You can run the compiler on Red Hat Enterprise Linux 5.7 (RHEL5.7), Red Hat Enterprise Linux 6.2 (RHEL6.2), SUSE Linux Enterprise Server 10 Service Pack 4 (SLES 10 SP4) and SUSE Linux Enterprise Server 11 Service Pack 2 (SLES 11 SP2). For more information, see: www.ibm.com/ software/awdtools/xlcpp/linux/. IBM XL C/C++ for Blue Gene/Q, along with the compiler related tools, supports the Red Hat Enterprise Linux 6.2 (RHEL 6.2) operating system on Blue Gene/Q Front End nodes. The generated object programs and runtime libraries are run on Blue Gene/Q compute nodes with the required software and disk space.

Blue Gene/Q compute nodes support the Blue Gene Compute Node Kernel (CNK) operating system. For more information, see: http://www-01.ibm.com/software/awdtools/xlcpp/features/bg/index.html. Other members of the IBM XL C/C++ compiler family include: v z/OS XL C/C++ (an optional priced feature of the z/OS operating system) The XL C/C++ compiler feature for z/OS is a comprehensive and powerful development package for creating optimized high-performance z/OS-based XL C/C++ business software solutions. z/OS XL C/C++ includes the latest compiler features and optimization technologies available with the IBM XL C/C++ compiler family, including support for selected features of the new C++ standard, ISO/IEC 14882:2011 (C++11). For more information, see: www.ibm.com/software/awdtools/czos/. v XL C/C++ for z/VM IBM XL C/C++ for z/VM is an advanced optimizing compiler for the z/VM platform. XL C/C++ is a standards-based professional programming tool that can be used for developing large, complex, and computationally intensive applications. XL C/C++ for z/VM provides you with the flexibility to write C and C++ applications, and to extend existing C applications using C++. XL C/C++ supports the ISO/IEC 9899:1999 international standard (C99), ISO/IEC 14882: 2003 (ISO C++ 2003), and selected features for the new C++ standard, ISO/IEC 14882:2011 (C++11). For more information, see: www.ibm.com/software/awdtools/czvm/. IBM XL C/C++ compilers comply with the latest C and C++ international standards and industry specifications, facilitating application portability across hardware platforms and operating systems. The compilers support a large array of common language features. The increased compatibility with GNU C/C++ gives you the versatility to build different parts of your application with either the IBM or GNU compiler, and still bind the parts together into a single application. One common use of this functionality is to build an application with IBM XL C/C++ that interacts with the GNU-built dynamic libraries, without recompiling the library source code. Applications built with this functionality can integrate with GNU assembler, and also provide full support for debugging through gdb, the GNU debugger. IBM XL C/C++ compilers on AIX and Linux also offer support for the IBM XL Fortran compiler on AIX and Linux through interlanguage calls. IBM XL C/C++ offers developers the opportunity to create and optimize 32-bit and 64-bit applications for the AIX and Linux platforms, and 64-bit applications for the Blue Gene/Q platform. On operating systems and architectures supporting the VMX instruction set, the IBM XL C/C++ compilers allow you to take advantage of the AltiVec programming model and APIs. They also allow you to improve the performance of your data and CPU intensive applications by exploiting the cutting edge IBM XL C/C++ automatic SIMD vectorization technology. Information on IBM XL C and XL C/C++ compilers is available at: https://www.ibm.com/developerworks/rational/community/cafe/ccpp.html

Standards conformance
IBM compilers strive to maximize the performance of scientific, technical, and commercial applications on server platforms. Multiple operating system availability ensures cross-platform portability, augmented by standards compliance. IBM XL C and XL C++ compilers conform to the following language standards and industry specifications: v C89, C99, and selected features of C11 standard

Note: C11 is a new version of the C programming language standard, published as ISO/IEC 9899:2011. IBM continues to develop and implement the features of the new standard. The implementation of the language level is based on IBM's interpretation of the standard. Until IBM's implementation of all the features of the C11 standard is complete, including the support of a new C standard library, the implementation may change from release to release. IBM makes no attempt to maintain compatibility, in source, binary, or listings and other compiler interfaces, with earlier releases of IBM's implementation of the new features of the standard and therefore they should not be relied on as a stable programming interface. v C++98, C++03, and selected features of C++11 standard Note: C++11 is a new version of the C++ programming language standard, published as ISO/IEC14882:2011. IBM continues to develop and implement the features of the new standard. The implementation of the language level is based on IBM's interpretation of the standard. Until IBM's implementation of all the features of the C++11 standard is complete, including the support of a new C++ standard library, the implementation may change from release to release. IBM makes no attempt to maintain compatibility, in source, binary, or listings and other compiler interfaces, with earlier releases of IBM's implementation of the new features of the C++11 standard and therefore they should not be relied on as a stable programming interface. v OpenMP V3.1 (excluding z/OS XL C/C++ and XL C/C++ for z/VM) v AltiVec (excluding z/OS XL C/C++, XL C/C++ for z/VM, and XL C/C++ for Blue Gene/Q) v IEEE POSIX 1003.2

Key features
Optimization capabilities
One of the key strengths of IBM XL C/C++ is optimization. These compilers offer the benefit of optimization technology that has been evolving at IBM since the late 1980s, combining extensive hardware knowledge with a comprehensive understanding of compiler technology and what users look for in a compiler when building end-user applications. The optimizations can decrease execution time and make your applications run faster, producing code that is highly tuned for execution on Power Architecture platforms. Improving optimization is a key goal of the IBM compiler team, and one that will continue to be a major focus with each iteration of the IBM XL C/C++ compilers. The optimizer includes five base optimization levels: -O0, -O2, -O3, -O4, and -O5. These levels allow you to choose from minimal optimization to intense program analysis that provides benefits even across programming languages. Optimization analyses range from local basic block to subprogram to file-level to whole-program analysis. The higher the optimization level, the more intense the program analysis becomes as increasingly sophisticated optimization techniques are applied to your code. At any optimization level, the optimizer performs transformations that result in performance improvements, while still executing your code the way it was written. At higher levels, the optimizer can trade numeric precision for execution speed. If this effect is not desired, you can specify compiler options such as -qstrict to prevent such trade-offs. Other options such as -qsmallstack or -qcompact allow you to bias optimization decisions in favor of smaller stack space or program size. The IBM XL C/C++ compilers do not limit your optimization choices unnecessarily. All of the optimization capabilities, including those discussed above, can be combined. You choose the levels and types of optimizations best suited to your application and build constraints, putting ultimate control of how your application builds and runs firmly in your hands. For more information on optimization, see the Code optimization with the IBM XL Compilers whitepaper at www.ibm.com/support/docview.wss?uid=swg27005174 and the IBM XL C/C++ Optimization and Programming Guide.

Additional enhancements assisting performance tuning and application optimization

Enhancements to -qpdf (not supported on Blue Gene/Q) Three new suboptions are added to the -qpdf option: level, exename, and defname. These new suboptions allow more fine-grained control over performance improvement and extend -qpdf to support multiple pass profiling, cache miss profiling, block counter profiling, call counter profiling, and extended value profiling. Reports about compiler optimizations (not supported on Blue Gene/Q) There have been a number of enhancements to the listing reports to give you more information on how the compiler optimized your code. You can use this information to get further benefits from the compiler's optimization capabilities. Compiler reports in XML or HTML format It is now possible to get information in XML or HTML format about the optimizations that the compiler was able to perform and also which optimization opportunities were missed. This information can be used to reduce programming effort for tuning applications, especially high-performance applications. The -qlistfmt option and its associated suboptions can be used to generate the XML or HTML report. By default, this option now generates all the available content if you do not specify the type of content. To view the HTML version of an XML report that has been already generated, you can now use the genhtml tool. Enhancements to profiling reports Additional sections of the listing report have been added to help you understand your programs. When using the -qreport option with the -qpdf2 option, you can get the additional sections added to your listing file in the section entitled PDF Report: Loop iteration count, Block and call count, and Cache miss. Report of data reorganization The compiler can generate the following information in the listing files: v Data reorganizations (a summary of useful information about how program variable data gets reorganized by the compiler) v The location of data prefetch instructions inserted by the compiler Additional loop analysis A new suboption has been added to -qhot to support more aggressive loop analysis. -qhot=level=2 together with -qsmp and -qreport add information about loop nests on which the aggressive loop analysis was performed to the LOOP TRANSFORMATION SECTION of the listing file. This information can also appear in the XML listing file created with the -qlistfmt option.

POWER 7 processor support

Support for the POWER7 processors started with the IBM XL C for AIX, V11.1, XL C/C++ for AIX, V11.1, and XL C/C++ for Linux, V11.1 compilers. The new features and enhancements for POWER7 processors fall into four categories: v vector scalar extension data types and intrinsic functions v MASS libraries for POWER7 processors

v built-in functions for POWER7 processors v compiler options for POWER7 processors Vector scalar extension data types and intrinsic functions IBM XL C and XL C/C++ compilers, V11.1 compilers and later support the Vector Scalar eXtension (VSX) instruction set in the POWER7 processors. New data types and intrinsic functions are introduced to support the VSX instructions. With the VSX intrinsic functions and the original Vector Multimedia eXtension (VMX) intrinsic functions, you can efficiently manipulate vector operations in your application. For more information about the VSX data types and intrinsic functions, see Vector types in the XL C/C++ Language Reference and Vector built-in functions in the XL C/C++ Compiler Reference. Mathematical Acceleration Subsystem (MASS) libraries for POWER7 processors Vector libraries The vector MASS library libmassvp7.a contains vector functions that have been tuned for the POWER7 architecture. The functions can be used in either 32-bit mode or 64-bit mode. SIMD libraries The MASS SIMD library libmass_simdp7.a contains an accelerated set of frequently used math intrinsic functions that provide improved performance over the corresponding standard system library functions. Built-in functions for POWER7 processors IBM XL C/C++ compilers provide a number of built-in functions that map directly to POWER hardware instructions. These functions provide access to powerful hardware operations at a source level such as cache prefetching and direct insertion of arithmetic hardware operations. Built-in functions can be used in all the IBM XL C/C++ compilers allowing you to port your code between AIX and Linux, and still exploit the hardware. Compiler options for POWER7 processors The POWER7 processor has cache control and stream prefetch extensions that support store stream prefetch and prefetch depth control. IBM XL C/C++ provides several built-in functions to provide you direct access to these instructions.

Blue Gene/Q architecture support

A Blue Gene/Q solution typically combines multiple racks of 1024 compute nodes, each containing an SMP PowerPC A2 processor. Each processor contains 16 cores for use by the application and one core for use by the system. Vector scalar extension data types and intrinsic functions IBM XL C/C++ for Blue Gene/Q, V12.1 supports the Quad Processing eXtension (QPX) instruction set in the Blue Gene/Q architecture. New data types and intrinsic functions are introduced to support the QPX instructions. With the QPX intrinsic functions, you can efficiently manipulate vector operations in your application. Mathematical Acceleration Subsystem (MASS) libraries Vector libraries

The vector MASS library libmass.a contains vector functions that have been tuned for the Blue Gene/Q architecture. The functions is used in 64-bit mode. SIMD libraries The MASS SIMD library libmass_simd.a contains an accelerated set of frequently used math intrinsic functions that provide improved performance over the corresponding standard system library functions.

Decimal floating-point support for XL C/C++

Decimal floating point arithmetic offers greater computational performance and precision in business and financial applications where numeric data I/O is usually performed in decimal form. Data conversions from decimal type to binary floating-point type and back are avoided, as are inherent rounding errors accumulated during data conversions.
Table 1. Decimal floating-point compiler options Options -qdfp | -qnodfp -qfloat= dfpemulate | nodfpemulate -y Description Specifying -qdfp enables compiler support for decimal floating-point data types and literals. Specifying -qfloat=dfpemulate instructs the compiler to use software emulation when handling decimal floating-point computations. There are suboptions specific to decimal floating-point arithmetic for the -y option to control rounding of constant expressions.

Note: v Compiler support for decimal floating-point operations requires AIX 5L for POWER V5.3 with the 5300-06 Technology Level or later. For more information, see Extension for the programming language C to support decimal floating-point arithmetic: TR 24732 and Decimal Types for C++: Draft 4. v Compiler support for decimal floating-point operations on Linux requires Advanced Tool Chain 4.0.

Diagnostic listings
The compiler output listing can provide important information to help you develop and debug your applications more efficiently. Listing information is organized into optional sections that you can include or omit. For more information about the applicable compiler options and the listing itself, refer to Compiler messages and listings in the XL C/C++ Compiler Reference.

Parallel programming
IBM provides parallel programming through AltiVec/VMX (on AIX and Linux), OpenMP, and internal automatic parallelization and autosimdization.

Thread-local storage (TLS)

IBM XL C for AIX, V10.1 and XL C/C++ for AIX, V10.1 added thread-specific variables support through the thread-local storage (TLS) feature. TLS has been included in IBM XL C/C++ for Linux since V8.0. In multi-threaded applications, we need to support thread-specific data. This is data that is unique to a thread and is called thread-local storage. This is a GNU extension that has been commonly adapted by many vendors and is similar to the POSIX getthreadspecific and setthreadspecific functions. But the

POSIX functions are slow and not useful for converting single-threaded applications to multi-threaded applications. This feature allows thread-local storage using a new storage that indicates a variable has thread storage duration. Thread-local storage (TLS) is enabled by the __thread storage class specifier, or the threadprivate directive in OpenMP. -qtls enables recognition of the __thread storage class specifier. Thread-local variables are global-lifetime memory locations (variables with linkage) that are replicated one per thread. At runtime, a copy of the variable is created for each thread that accesses it. Use of thread-local storage prevents race conditions to global data, without the need for low-level synchronization of threads. A simple example demonstrating a practical use of thread-local storage is the C error code variable errno. The thread-local storage support has been enhanced to include __attribute__((tls-model("string"))), where string is one of local-exec, initial-exec, local-dynamic, or global-dynamic.

AltiVec support
IBM XL C/C++ for AIX and Linux supports the AltiVec programming model through non-orthogonal language extensions. These language extensions can be used on operating systems and hardware supporting the VMX instruction set. The IBM implementation of the AltiVec Programming Interface specification is an extended syntax that allows type qualifiers and storage class specifiers to precede the keyword vector (or alternately, __vector) in a declaration. Although not strictly required by the AltiVec Programming Interface specification, the vector keyword is recognized in a declaration context only when used as a type specifier (and when you compile the application with -qaltivec). The other AltiVec keywords, pixel and bool (for C), are recognized as valid type specifiers only when used in a vector declaration context. This approach has an important advantage: it allows your application to continue to use vector and pixel as variables and function names. To ensure maximum portability, use the underscore versions of the specifiers vector and pixel (__vector and __pixel) in declarations. VMX support is available on V12.1 AIX compilers where the target environment is running AIX V5.3, AIX V6.1, and AIX 7.1 on architectures that support the Single Instruction Multiple Data (SIMD) instruction set.

OpenMP support
IBM XL C for AIX, V12.1, XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1 include support for the OpenMP API V3.1 specification for shared memory parallel programming. OpenMP provides a simple and flexible interface for parallel application development. OpenMP is comprised of three components: compiler directives, runtime library functions, and environment variables. Applications that conform to the OpenMP specification are easily ported to other platforms from desktop to super computer that support the specification. OpenMP supports applications that run both as parallel programs (multiple threads of execution and a full OpenMP support library) and as sequential programs (directives are ignored and a stub library is linked). For a more in-depth discussion of application parallelization using OpenMP, see the following IBM Redbooks, Developing and Porting C and C++ Applications on AIX: v www.redbooks.ibm.com/abstracts/SG245674.html?Open For more information on OpenMP, see: v www.openmp.org

Shared memory parallelization

XL C/C++ supports application development for multiprocessor system architectures. You can use any of the following methods to develop your parallelized applications with XL C/C++: v Directive-based shared memory parallelization (OpenMP, SMP). v Instructing the compiler to automatically generate shared memory parallelization. v Message passing based shared or distributed memory parallelization (MPI). v POSIX threads (Pthreads) parallelization. v Low-level UNIX parallelization using fork() and exec(). The parallel programming facilities of the AIX operating system are based on the concept of threads. Parallel programming exploits the advantages of multiprocessor systems, while maintaining a full binary compatibility with existing uniprocessor systems. This means that a multithreaded program that works on a uniprocessor system can take advantage of a multiprocessor system without recompiling. For more information, see Parallelizing your programs in the XL C/C++ Optimization and Programming Guide.

Enhanced Unicode and NLS support

As recommended by the C Standard committee, the C compiler extends C99 to add new data types to support UTF-16 and UTF-32 literals. The data types are u-literals and U-literals. To enable support for UTF literals in your source code, you must compile with the option -qutf enabled. The C++ compiler also supports these new data types for compatibility with C. IBM is a corporate member of the Unicode Consortium. For more information regarding Unicode, see: v www.unicode.org

Boost C++ Library support

Boost C++ Libraries are open source libraries that take you beyond the C++ Standard Library. Boost makes C++ programming more elegant, robust, and productive. The Boost license grants permission to copy, use, and modify the software for any commercial or non-commercial use. With the non-restrictive licensing, these libraries are used directly by many commercial applications. Many of the libraries are planned for inclusion in the next version of the C++ Standard Library. Boost libraries allow you to be more productive through software reuse. The ability to compile and execute the Boost Libraries properly demonstrates IBM's support of the latest C++ idioms and paradigms, specifically generic programming and template metaprogramming. Boost C++ libraries are coded by the leading C++ experts in the world, many of whom are long time members of the C++ Standard Committee. They use Boost as a test bed for cutting edge C++ programming techniques and codify discoveries and best practices without the long delay that it takes for a library to be formally accepted into the C++ Standard. However, the Boost community subjects each submission to rigorous peer review. This free sharing of knowledge, exposes a submission to a larger audience which helps C++ evolve and grow. The IBM XL C/C++ compilers, starting from V7.0, have attained a high degree of compatibility with Boost and continue to support Boost as new releases appear. Each version of the compiler is fully tested on one version of Boost, usually the latest. The following table shows the Boost support in each version of the compiler.
Table 2. IBM XL C++ compiler and Boost version supported IBM XL C++ Compiler Version 12.1 11.1 Boost version supported 1.47.0 1.40.0

Table 2. IBM XL C++ compiler and Boost version supported (continued) 10.1 1.34.1

A patch file is available that modifies the Boost 1.47.0 C++ libraries so that they can be built and used with XL C/C++ applications. The patch or modification file does not extend or otherwise provide additional functionality to the Boost C++ libraries. To download the patch file and for more information on support for these libraries, see the relevant links on the XL C/C++ Library page. Check the IBM XL C/C++ web pages for information regarding modifications that apply to the supported version of Boost. For a summary of the results of regression tests, see (Boost Library Regression Test Summaries): v www.ibm.com/support/docview.wss?uid=swg27006911 For more information on portable C++ source libraries from Boost, see: v www.boost.org

IBM Mathematics Acceleration Subsystem (MASS) libraries

IBM XL C/C++ compilers ship the IBM Mathematical Accelerated Subsystem (MASS) libraries of mathematical intrinsic functions specifically tuned for optimum performance on IBM Power Architectures. The MASS libraries are thread-safe, include scalar and vector functions, support both 32-bit and 64-bit compilations, and offer improved performance. The MASS libraries contain tuned and threadsafe intrinsic functions that can be used with either Fortran or C applications.
Table 3. Libraries included in the MASS library Mass vector library libmassv.a libmassvp7.a libmassvp6.a Tuned for processor All POWER systems POWER7 POWER6

The MASS scalar library, libmass.a, contains an accelerated set of frequently used math intrinsic functions in the AIX system library libm.a. The vector MASS library libmassvp7.a contains vector functions that have been tuned for the POWER7 architecture. The functions can be used in either 32-bit mode or 64-bit mode.

Basic Linear Algebra Subprograms (BLAS)

There are four BLAS high-performance algebraic functions shipped with IBM XL C/C++ in the libxlopt library. The functions are as follows: v sgemv (single-precision) and dgemv (double-precision), which compute the matrix-vector product for a general matrix or its transpose. v sgemm (single-precision) and dgemm (double-precision), which perform combined matrix multiplication and addition for general matrices or their transposes. Because the BLAS routines are written in Fortran, all parameters are passed to them by reference, and all arrays are stored in column-major order.

Source-code migration and conformance checking

XL C/C++ helps protect your investment in your existing C/C++ source code by providing compiler invocation commands that instruct the compiler to compile your application code to a specific language level. You can also use the -qlanglvl compiler option to specify a given language level, and the compiler will issue warnings, errors, and severe error messages if language or language extension elements in your program source do not conform to that language level. See -qlanglvl in the XL C/C++ Compiler Reference for more information.

C++ Templates
Templates are an area of the C++ language that provides a great deal of flexibility for developers. The ISO C++ standard defines the language facilities and features for templates. The IBM XL C++ compiler provides several methods to compile templates: v Simple layout method. This results in code bloat and longer compile time, but it is easy to use and requires no specific structuring by programmers. v Automatic instantiation using -qtempinc. This requires user code structuring but it addresses the long compile time problem inherent in the simple layout method. v Automatic instantiation using -qtemplateregistry. This requires no user code restructuring and addresses both the long compile time and code bloat issues. The instantiation mechanisms are the external mechanisms that allow C++ implementations to create instantiations correctly. These mechanisms may be constrained by requirements of the linker and other software building tools. IBM XL C++ compilers have two queried instantiation mechanisms, -qtempinc available before V7.0 and -qtemplateregistry available since V7.0. One of the differences between -qtempinc and -qtemplateregistry is that -qtempinc delays the instantiation until link time, and the -qtemplateregistry does the instantiation in the first compilation unit that uses it. -qtempinc and -qtemplateregistry compiler options are mutually exclusive. Here is how you get the various instantiation models on our compiler: Greedy instantiation default is -qtmplinst=auto -qnotemplateregistry -qnotempinc or -qtmplinst=always Queried instantiation -qtemplateregistry or -qtempinc (for example -qtmplinst=auto) Manual instantiation -qtmplinst=none with explicit instantiations in your code.

Utilization tracking and reporting

On AIX and Linux, the utilization tracking and reporting feature is a lightweight and simple mechanism for tracking the compiler utilization within your organization. It is disabled by default. You can use this feature to detect whether your organization's use of the compiler exceeds your compiler license entitlements. When utilization tracking is enabled, each invocation of the compiler is recorded in a compiler utilization file. You can run the utilization reporting tool to generate a report from one or more of these files to get a picture of the overall usage of the compiler within your organization. The urt command can be used to control how the report is generated. In particular, the report indicates whether the compiler usage complies with the number of Concurrent User licenses that you have purchased.

10

The utilization tracking and reporting feature is easy to set up and manage, and utilization tracking does not impact the usage or performance of the compiler. For detailed information about the utilization tracking and reporting feature, see Tracking and reporting compiler usage in the XL C/C++ Compiler Reference.

What's new in XL C for AIX, V12.1, XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1
New features of C++11
The following features are introduced in IBM XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1: v Explicit conversion operators v Generalized constant expressions v Reference collapsing v Right angle brackets v Rvalue references v Scoped enumerations v Trailing return type You can use the -qlanglvl=extended0x option to enable most of the C++ features and all the currently-supported C++11 features. For details, see -qlanglvl in the XL C/C++ Compiler Reference. Explicit conversion operators The explicit conversion operators feature supports the explicit function specifier being applied to the definition of a user-defined conversion function. You can use this feature to inhibit implicit conversions from being applied where they might be unintended, and thus program more robust classes with fewer ambiguity errors. You can use the -qlanglvl=explicitconversionoperators option to enable this feature. Generalized constant expressions The generalized constant expressions feature extends the expressions permitted within constant expressions. A constant expression is one that can be evaluated at compile time. You can use the -qlanglvl=constexpr option to enable this feature. Note: In XL C/C++ V12.1, this feature is a partial implementation of what is defined in the C++11 standard. Reference collapsing With the reference collapsing feature, you can form a reference to a reference type using one of the following contexts: v A decltype specifier v A typedef name v A template type parameter You can use the -qlanglvl=referencecollapsing option to enable this feature. Right angle brackets

11

In the C++ language, two consecutive closing angle brackets (>) must be separated with a white space, because they are otherwise parsed as the bitwise right-shift operator (>>). The right angle bracket feature removes the white space requirement for consecutive right angle brackets, thus making programming more convenient. You can use the -qlanglvl=rightanglebracket option to enable this feature. Rvalue references With the rvalue references feature, you can overload functions based on the value categories of arguments and similarly have lvalueness detected by template argument deduction. You can also have an rvalue bound to an rvalue reference and modify the rvalue through the reference. This enables a programming technique with which you can reuse the resources of expiring objects and therefore improve the performance of your libraries, especially if you use generic code with class types, for example, template data structures. Additionally, the value category can be considered when writing a forwarding function. You can use the -qlanglvl=rvaluereferences option to enable this feature. Scoped enumerations With the scoped enumeration feature, you can get the following benefits: v The ability to declare a scoped enumeration type, whose enumerators are declared in the scope of the enumeration. v The ability to declare an enumeration without providing the enumerators. The declaration of an enumeration without providing the enumerators is referred to as forward declaration. v The ability to specify explicitly the underlying type of an enumeration. v Improved type safety with no conversions from the value of an enumerator (or an object of an enumeration type) to an integer. You can use the -qlanglvl=scopedenum option to enable this feature. Trailing return type The trailing return type feature is useful when declaring the following types of templates and functions: v Function templates or member functions of class templates with return types that depend on the types of the function arguments v Functions or member functions of classes with complicated return types v Perfect forwarding functions You can use the -qlanglvl=autotypededuction option to enable this feature.

New features of C11

The following features are introduced in IBM XL C for AIX, V12.1, XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1: v New language level extc1x v Anonymous structures v The following C11 features are also supported when you compile with the XL C++ compiler: Complex type initialization The _Noreturn function specifier Static assertions New language level extc1x A new suboption has been added to the -qlanglvl option in this release. When you compile with the C compiler, you can use -qlanglvl=extc1x to enable C11 features that are currently supported by XL C.

12

Anonymous structures This feature enables the declaration of anonymous structures under the extc1x language level. Complex type initialization This feature enables the initialization of the C99 style complex types. The _Noreturn function specifier The _Noreturn function specifier declares that a function does not return to its caller. You can define your own functions that do not return using this function specifier. The compiler can produce better code by ignoring what would happen if the function returns. Static assertions The addition of static assertions to the C language has the following benefits: v Libraries can detect common usage errors at compile time. v Implementations of the C Standard Library can detect and diagnose common usage errors, improving usability. You can declare static assertions to check important program invariants at compile time.

OpenMP 3.1 support

IBM IBM XL C for AIX, V12.1, XL C/C++ for AIX, V12.1, XL C/C++ for Linux, V12.1, and XL C/C++ for Blue Gene/Q, V12.1 support the OpenMP Application Program Interface Version 3.1 specification. The XL C/C++ implementation is based on IBM's interpretation of the OpenMP Application Program Interface Version 3.1. OpenMP 3.1 includes the following updates to OpenMP 3.0: v Adds FINAL and MERGEABLE clauses to the TASK construct to support optimization. v Adds the TASKYIELD construct to allow users to specify where in the program can perform task switching. v Adds the omp_in_final runtime library function to support specialization of final task regions. v Extends the ATOMIC construct to include READ, WRITE, and CAPTURE forms; adds the UPDATE clause to apply the existing form of the ATOMIC construct. v Adds two REDUCTION operators: MIN and MAX. v Allows const-qualified types to be specified on the FIRSTPRIVATE clause. v Adds the OMP_PROC_BIND environment variable to control whether OpenMP threads are allowed to move between processors. v Extends the OMP_NUM_THREADS environment variable to specify the number of threads to use for nested parallel regions.

Performance and optimization enhancements

Additional features and enhancements assist with performance tuning and application optimization. Reports about compiler optimizations There are a number of enhancements to the listing reports to give you more information about how the compiler optimized your code. You can use this information to get further benefits from the optimization capabilities of the compiler.

13

Small String Optimized string class If you have programs that produce large amounts of small strings, that is, strings smaller than 32 bytes, consider using the new ssostring.h header file supplied by IBM to reduce runtime overhead and improve runtime performance.

New diagnostic reports

The new diagnostic reports can help you identify opportunities to improve the performance of your code. Compiler reports in HTML format You can use the -qlistfmt option and its associated suboptions to generate report in XML or HTML format about the optimizations that the compiler was able to perform and also which optimization opportunities were missed. You can use the genhtml tool to view the XML reports in HTML format. Enhancements to profiling reports (Not supported on Blue Gene/Q) New sections have been added to your listing file to help you analyze your programs. When using the -qreport option with the -qpdf2 option, you can get the following sections added to the listing file in the section entitled PDF Report: v Relevance of profiling data: This section shows the relevance of the profiling data to the source code during the -qpdf1 phase. The relevance is indicated by a number in the range of 0 - 100. The larger the number is, the more relevant the profiling data is to the source code, and the more performance gain can be achieved by using the profiling data. v Missing profiling data: This section might include a warning message about missing profiling data. The warning message is issued for each function for which the compiler does not find profiling data. v Outdated profiling data: This section might include a warning message about outdated profiling data. The compiler issues this warning message for each function that is modified after the -qpdf1 phase. The warning message is also issued when the optimization level changes from the -qpdf1 phase to the -qpdf2 phase. Enhancements to showpdf reports (Not supported on Blue Gene/Q) In addition to block-counter and call-counter profiling information currently provided, you can also use the showpdf utility to view cache-miss profiling and value profiling information. Cache-miss profiling and value profiling information can be displayed only in XML format. However, all the other types of profiling information can be displayed in either text or XML format. In this release, the profile-directed feedback (PDF) information is saved in two files. One is a PDF map file that is generated during the -qpdf1 phase, and the other is a PDF file that is generated during the execution of the resulting application. You can run the showpdf utility to display the PDF information contained in these two files.

New built-in functions

GCC atomic memory access built-in functions New XL C/C++ built-in functions for atomic memory access, whose behavior corresponds to those provided by GNU Compiler Collection (GCC), are added in this release. In a program with multiple threads, you can use these functions to atomically and safely modify data in one thread without interference from another thread. For more information about built-in functions provided by XL C/C++, see Compiler built-in functions in the XL C/C++ Compiler Reference.

14

New or changed compiler options and directives

Compiler options can be specified on the command line or through directives embedded in your application source files. See the XL C/C++ Compiler Reference for detailed descriptions and usage information for these and other compiler options.
Table 4. New or changed compiler options Option -g -qhaltonmsg Description The -g option is extended to include new levels to improve the debugging of optimized programs. The -qhaltonmsg option, previously supported only by the C++ compiler, is now supported by XL C. It stops compilation before producing any object files, executable files, or assembler source files if a specified error message is generated. The negative form -qnohaltonmsg has also been added. The negative form -qnoinclude is added to ignore the previously specified -qinclude option. -qinfo=all now enables all diagnostic messages for all groups except als and ppt. The -qinitauto option is enhanced to perform word initialization for automatic variables. The new suboption -q[no]keyword=constexpr enables or disables the constexpr keyword.

-qinclude -qinfo -qinitauto -qkeyword

15

Table 4. New or changed compiler options (continued) Option -qlanglvl Description New suboptions have been added or updated to -qlanglvl: v -qlanglvl=autotypededuction: This suboption can now enable the trailing return type feature in addition to the auto type deduction feature. v qlanglvl=c1xnoreturn: This suboption enables support for the _Noreturn function specifier. v -qlanglvl=complexinit: This suboption controls whether to enable the initialization of complex types. v -qlanglvl=compatrvaluebinding: This suboption instructs the compiler to allow a non-const lvalue reference to bind to an rvalue of a user-defined type where an initializer is not required. v -qlanglvl=constexpr: This suboption enables the generalized constant expressions feature, which extends the expressions permitted within constant expressions. v -qlanglvl=explicitconversionoperators: This suboption enables the explicit conversion operators feature, which allows you to inhibit unintended implicit conversions through the user-defined conversion function. v -qlanglvl=extc1x: This suboption enables all the currently supported C11 features and other implementation-specific language extensions. v -qlanglvl=referencecollapsing: This suboption enables the reference collapsing feature, with which you can form a reference to a reference type using a decltype specifier, a typedef name, or a template type parameter. v -qlanglvl=rightanglebracket: This suboption enables the right angle bracket feature, which removes the white space requirement for consecutive right angle brackets. v -qlanglvl=rvaluereferences: This suboption enables the rvalue references feature. v -qlanglvl=scopedenum: This suboption enables the scoped enumeration feature, with which you can declare a scoped enumeration type or an enumeration without providing the enumerators. v -qlanglvl=tempsaslocals: This suboption extends the lifetime of temporaries to reduce migration difficulty. v -qlanglvl=textafterendif: This suboption suppresses the warning message that is emitted when you are porting code from a compiler that allows extra text after #endif or #else to IBM XL C/C++ compiler. -qlistfmt The -qlistfmt option is enhanced to generate HTML reports as well as XML reports, containing information about optimizations performed by the compiler and missed optimization opportunities. The default behavior of -qlistfmt has changed. In this release, if you do not specify a particular type of content, the option generates all the available content, rather than generating none.

16

Table 4. New or changed compiler options (continued) Option -qnamemangling -qoptfile Description The v12 namemangling scheme is added to preserves the cv-qualifiers nested within template argument lists. The new option -qoptfile specifies a file containing a list of additional command line options to be used for the compilation. -qpic=large now enables large Table of Contents (TOC) access and prevents TOC overflow conditions when the TOC is larger than 64 Kb. The default value is changed from -qnoshowpdf to -qshowpdf.

-qpic

-qshowpdf (Not supported on Blue Gene/Q)

Table 5. New or changed compiler directives Directive #pragma ibm independent_loop Description The independent_loop pragma is added. It explicitly states that the iterations of the chosen loop are independent, and that the iterations can be executed in parallel. The iterations pragma is added. It specifies the approximate number of loop iterations for the chosen loop. The max_iterations pragma is added. It specifies the approximate maximum number of loop iterations for the chosen loop. The min_iterations pragma is added. It specifies the approximate minimum number of loop iterations for the chosen loop. The simd_level pragma is added. It controls the compiler code generation of vector instructions for individual loops.

#pragma ibm iterations

#pragma ibm max_iterations

#pragma ibm min_iterations

#pragma simd_level

Compatibility and porting

Porting from open source and other platforms
The cross-platform portability of gcc and g++ has ensured GNU a place in the Open Source community. GNU has excelled in educational and compiler research arenas as a test bed for new language syntax. IBM compilers are built on a platform of reliability, customer service, and cutting-edge optimization. In recent years, the IBM XL compilers have been evolving to gain some of the additional flexibility and portability of the GNU compilers, while still retaining the strengths that have built the IBM XL C/C++ compiler's reputation in the industry.

GNU source compatibility

On Linux and Blue Gene/Q platforms the compilers use the GNU C and C++ headers, and the resulting application is linked with the C and C++ runtime libraries provided by the GNU compiler shipped with the operating system. IBM ships an implementation of some header files with the product to override the corresponding GNU header files. These header files are functionally equivalent to the corresponding GNU implementation. Other IBM headers are wrappers that include the corresponding GNU header files.

17

XL C/C++ supports a subset of the GNU compiler command options to facilitate porting applications developed with gcc and g++ compilers. This support is available when the gxlc or gxlc++ invocation command is used together with select GNU compiler options. Where possible, the XL C/C++ compiler maps GNU options to their XL C/C++ compiler option counterparts before invoking the XL C/C++ compiler. These invocation commands use a plain text configuration file to control GNU-to-XL C/C++ option mappings and defaults. You can customize this configuration file to better meet the needs of any unique compilation requirements you may have. See "Reusing GNU C /C++ compiler options with gxlc and gxlc++" for more information.

GNU Binary Compatibility

The IBM XL C/C++ for Linux and Blue Gene/Q compilers achieve a high degree of binary compatibility with GNU-built objects, archives, and shared objects. The compiler achieves this by adhering to the system ABI and calling conventions, and by closely following the GNU behavior where alignment modifiers like the attributes aligned and packed are used. C++ interoperability is somewhat more difficult to achieve due to differing conventions for name mangling, object model, and exception handling. However, the GNU C++ compiler, since V3.2, has adopted a common vendor C++ ABI that defines a way to allow interoperability of C++ object model, name mangling, and exception handling. This common C++ ABI is supported in the IBM XL C++ compilers. IBM XL C/C++ for Linux, V12.1 has been fully tested with GNU C/C++ 4.1.2 on SLES10 and RHEL5, GNU C/C++ 4.3.3 on SLES 11, and GNU C/C++ 4.4.4 on RHEL6, and offer a high degree of binary compatibility in addition to source compatibility. The XL C++ compiler for Linux and Blue Gene/Q also has an option to display the class layouts, the virtual function tables entries as well as all the intermediate object model tables such as the construction virtual function table, and the virtual function table. These help you to ensure binary compatibility through verification of internal table layouts, and significantly enhance the debugging of incompatibility problems.

Command-line compatibility and other utilities

When you are porting GNU makefiles to IBM XL C/C++ for Linux, the gxlc and gxlc++ invocation commands are available to translate a GNU compiler invocation command into the corresponding XL C/C++ for Linux command where applicable, and invoke the XL C/C++ for Linux compiler. This facilitates the transition to XL C/C++ for Linux while minimizing the number of changes to makefiles built with a GNU compiler. To fully exploit the capabilities of IBM XL C/C++, you should use the XL C/C++ invocation commands and their associated options.

Support for third-party C++ runtime libraries

The IBM XL C++ compiler on AIX can compile C++ applications so that the application supports only the core language, thus enabling it to link with C++ runtime libraries from third-party vendors. The following archive files enable this functionality.
Table 6. Core Language libraries Library name lib*C*core.a Content (see -qheapdebug for more information) Contains exception handling, RTTI, static initialization, new and delete operators. Does not contain any of the following libraries: Input/Output, Localization, STL Containers, Iterators, Algorithms, Numerics, Strings. The core language version of the C++ runtime library, libC.a. The core language version of libC128.a.

libCcore.a libC128core.a

18

Table 6. Core Language libraries (continued) libhCcore.a The language core version of libhC.a.

Invocation commands have been added to facilitate using these libraries: v xlc++core v xlCcore Equivalent special invocations: v xlc++core_r, xlc++core_r7, xlc++core128, xlc++core128_r, xlc++core128_r7 v xlCcore_r, xlCcore_r7, xlC128core, xlC128core_r, xlC128core_r7 Explanation of suffixes for special invocations: v 128-suffixed invocations - All 128-suffixed invocation commands are functionally similar to their corresponding base compiler invocations. They specify the -qldbl128 option, which increases the length of long double types in your program from 64 to 128 bits. They also link with the 128-bit versions of the C and C++ runtime libraries. v _r suffixed invocations - All _r suffixed invocations allow for threadsafe compilation and you can use them to link the programs that use multithreading. Use these commands if you want to create threaded applications. The _r7 invocations are provided to help migrate programs based on POSIX Draft 7 to POSIX Draft 10.

Compatibility of redistributable library libxlopt.a

Starting from V11.1, compatibility of the redistributable library, libxlopt.a, will be maintained. The libxlopt.a library is compatible with compiler XL C/C++ for AIX, V11.1, or later versions of these compilers. You can download and use the latest redistributable library for multiple applications compiled with XL C/C++ for AIX, V11.1 and later versions, on supported platforms. For more information about the redistributable libraries, see Redistributable libraries in the XL C/C++ Compiler Reference.

Tools supporting IBM XL C/C++ compilers

Debugging capabilities
You can instruct IBM XL C/C++ compilers to include debugging information in your compiled objects. The debugging information can be examined by any symbolic debugger to help you debug your programs. For debugging capability on AIX, you have the choice of any symbolic debugger that supports the AIX XCOFF executable format including dbx, TotalView, DDT, and IBM Debugger for AIX. IBM Debugger for AIX is included with IBM XL C for AIX and XL C/C++ for AIX. On Linux, you can use debuggers including DDT, gdb, or TotalView. TotalView also supports debugging OpenMP applications. For more information about IBM Debuggers, see: www.ibm.com/software/awdtools/debugger/

19

Additionally, the compilers offer the SNAPSHOT directive and the -qoptdebug and -qkeepparm options to assist you in debugging optimized code.

Rational PurifyPlus
IBM Rational PurifyPlus is a dynamic software analysis solution designed to help developers write faster, more reliable code. It includes the following capabilities packaged into a single product: Memory debugging Pinpoints memory errors that are hard to find, such as uninitialized memory access, buffer overflow, and improper freeing of memory. Memory leak detection Identifies memory blocks that no longer have a valid pointer. Performance profiling Highlights application performance bottlenecks and improves application understanding with a graphical representation of function calls. Code coverage Identifies untested code with line-level precision. Rational PurifyPlus is supported on Windows, Linux, Solaris, and AIX. Rational PurifyPlus for Linux and UNIX supports AIX, Linux, and Sun Solaris. For more information, see: www.ibm.com/software/awdtools/purifyplus/

Rational Team Concert

IBM Rational Team Concert is a lean collaborative lifecycle management solution. It helps companies build better software and products with a complete lean development environment for teams, which includes complete agile, formal and hybrid planning and reporting, all on a common platform. Rational Team Concert also supports geographically distributed teams with features such as communication in context, event feeds, integrated chat, and automated traceability, all beyond simple e-mail. Rational Team Concert can be easily adopted by component, as a unified solution, or surrounding existing tooling. Operating systems supported by Rational Team Concert include AIX, IBM i, Linux, Solaris (Sun Microsystems), Windows family, and z/OS. For more information, see: http://www.ibm.com/software/rational/products/rtc/

Rational Developer for Power Systems Software

IBM Rational Developer for Power Systems Software provides rich desktop Integrated Development Environments to create, maintain, or port applications to IBM Power Systems. It provides you with a rich family of tools integrated into an Eclipse workbench including remote (IBM i, AIX, or Linux) file management, searching, editing, refactoring, application analysis, build, and debug. It also enables you to develop in both host-connected and disconnected modes. For more information, see: www.ibm.com/software/rational/products/rdp/

Summary
20

IBM XL C/C++ compilers are stable and flexible, providing industry leading optimization techniques that can address your compiler needs for everything from small applications, to large, computationally intensive programs. The extensive cross-platform availability of the IBM XL C/C++ compilers eases the porting process between AIX, z/OS, z/VM, Linux, and Blue Gene. Standards conformance and GNU compatibility improve portability of source code from GNU compilers to IBM compilers. The binary compatibility feature allows direct linkage with objects, shared libraries, and archives built by either the GNU or IBM compilers. This allows you to take advantage of the features offered by both suites of compiler products. IBM is also deeply involved in the High Performance Computing effort. Many of the TOP500 supercomputers are from IBM using IBM XL C/C++ compiler optimizations. The IBM XL C/C++ compiler team is deeply involved in parallel computing and supporting different parallel memory models. Other new features support customer requests and enable middleware applications. Finally, optimization through chip-specific instruction generation and tuning, parallelization, vectorization, interprocedural analysis, and profile-directed feedback, offers an increase in performance without sacrificing stability or flexibility. Coupled with IBM's excellent service and support, IBM XL C/C++ compilers are robust, versatile, and capable of delivering mission critical applications.

Support information
Documentation
IBM XL C/C++ compiler product documentation is available in a fully searchable HTML-based information centers. PDF versions of the documentation are available with the installation media (either product CD or electronic package) and can be accessed online from the product library page. For XL C for AIX, XL C/C++ for AIX, and XL C/C++ for Linux compilers, you can also download a version of the information center containing the product documentation from the library pages. The AIX information center can be installed on any AIX 7.1, AIX 6.1 or AIX 5.3 system running on a 64-bit capable processor, and the Linux information center can be installed on any RHEL 5.7, RHEL 6.2, SLES 10 SP4, or SLES 11 SP2 system. The IBM XL C/C++ compilers also include man pages for all utilities and compiler invocation commands. An extensive collection of technical material, trials and demos, support information, and features and benefits of IBM XL C/C++ can be found at the following URL: www.ibm.com/software/awdtools/xlcpp/ You can access the information centers for XL C/C++ compilers from the following library page links: v v v v IBM XL C for AIX: http://www.ibm.com/software/awdtools/xlc/aix/library/ IBM XL C/C++ for AIX: http://www.ibm.com/software/awdtools/xlcpp/aix/library/ IBM XL C/C++ for Linux: http://www.ibm.com/software/awdtools/xlcpp/linux/library/ IBM XL C/C++ for Blue Gene/Q: http://www.ibm.com/software/awdtools/xlcpp/features/bg/ library/

v IBM XL C/C++ for z/OS: http://www.ibm.com/software/awdtools/czos/library/ v IBM XL C/C++ for z/VM: http://www.ibm.com/software/awdtools/czvm/library/

21

Premier customer service

The IBM XL C/C++ compilers come with IBM's premier service and support. The IBM Service and Support organization is made up of a team dedicated to providing you with responsive platform and cross-platform software support. For complex or code-related problems, IBM employs specialized service teams with access to compiler development experts. The vision of IBM Service and Support is to achieve a level of support excellence that exceeds customer expectations and differentiates IBM in the marketplace. You will always have access to the right level of IBM expertise when you need it. More information is available at: http://www-947.ibm.com/support/entry/portal/ctt/Software/Rational/C_and_C++_Compilers You can also find the latest updates for IBM XL C and XL C++ compilers at: http://www-01.ibm.com/support/docview.wss?uid=swg21110831

Trial versions and purchasing

The following link contains the XL C/C++ compiler product Web pages where you can download trial versions of the compilers: www.ibm.com/software/awdtools/xlcpp/ Information on how to buy IBM XL C/C++ is also available at this Web site.

Contacting IBM
IBM welcomes your comments. You can send them to compinfo@ca.ibm.com.

June 2012 References in this document to IBM products, programs, or services do not imply that IBM intends to make these available in all countries in which IBM operates. Any reference to an IBM program product in this publication is not intended to state or imply that only IBM's program product may be used. Any functionally equivalent program may be used instead. IBM, the IBM logo, ibm.com, AIX, AIX 5L, BladeCenter, Blue Gene, Blue Gene/P, Blue Gene/Q, POWER, POWER6, POWER7, Power Architecture, Power Systems, PowerPC, PurifyPlus, Rational, Redbooks, VisualAge, z/OS, and z/VM are trademarks of International Business Machines Corp., registered in many jurisdictions worldwide. Other product and service names might be trademarks of IBM or other companies. A current list of IBM trademarks is available on the Web at Copyright and trademark information at www.ibm.com/legal/copytrade.shtml. Linux is a trademark of Linus Torvalds in the United States, other countries, or both. UNIX is a registered trademark of The Open Group in the United States and other countries. Copyright IBM Corporation 1999, 2012. US Government Users Restricted Rights Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.