Contents

1. Introduction
2. About the C Compiler 5.9
3. New and Changed Features
4. Software Corrections, Patches, Problems and Workarounds
5. Documentation Errors

 

---

A. Introduction

This document contains information about this release of the Sun[tm] Studio 12 C Compiler 5.9. This document describes the software corrections, known problems, limitations, and incompatibilities of this release.

Product Documentation

• Release Notes: Available on the Sun Developer Network (SDN) Sun Studio portal at http://developers.sun.com/sunstudio/documentation/ss12/release_notes.html. Information in the release notes updates and extends information in all readme files.
• Compilers and Tools Documentation: Product man pages, HTML versions of readmes, and manuals can be accessed from /installation_directory/SUNWspro/docs/index.html. The default installation directory for Solaris platforms is /opt. If your Sun Studio software is not installed in the default /opt directory, ask your system administrator for the equivalent path on your system.
• Developer Resources Portal: For technical articles, code samples, documentation, and a knowledge base, see the SDN Sun Studio portal at http://developers.sun.com/sunstudio.  For additional information, see the Support page on the portal.

Note - If your compiler collection software has not been installed in the default /opt directory, ask your system administrator for the equivalent path on your system.

---

B. About Sun Studio 12 C Compiler 5.9

This compiler is in full compliance with ISO/IEC 9899:1999, Programming Language - C and is available on Solaris 10 when you specify the -xc99 option. This compiler supports all C language features of ISO/IEC 9899:1999, Programming Language - C on all supported operating systems.

---

C. New and Changed Features

This section describes new and changed features for this release of the C compiler 5.9. For additional information regarding new features in other Sun Studio 12 components, see the SDN Sun Studio portal at http://developers.sun.com/sunstudio/documentation/index.jsp.

A New Way To Specify 32-bit or 64-bit Address Model

You no longer need use the -xarch option to specify a 32-bit or 64-bit address model (LP64 versus ILP32). Two new options make it easier:

• -m32 specifies the ILP32 model: 32-bit ints, longs, and pointer types.
• -m64 specifies the LP64 model: 32-bit ints, 64-bit longs and pointers types. (Note that -m64 is the default on 64-bit Linux platforms.)

Deprecated -xarch Flags and Their Replacements Across SPARC and x86
If you are using -xarch=v9 or -xarch=amd64 to specify a 64-bit address model, use just -m64 instead. No -xarch value is required.

• Use -m64 in place of -xarch=generic64
• Use -m64 -xarch=native in place of -xarch=native64

Deprecated -xarch Flags and Their Replacements on SPARC Only

• Use -xarch=sparc in place -xarch=v8plus
• Use -xarch=sparcvis in place of -xarch=v8plusa
• Use -xarch=sparcvis2 in place of -xarch=v8plusb
• Use -xarch=sparc -m64 in place of -xarch=v9
• Use -xarch=sparcvis -m64 in place of -xarch=v9a
• Use -xarch=sparcvis2 -m64 in place of -xarch=v9b

Deprecated -xarch Flags and Their Replacements on x86 Only

• Use -xarch=sse2 -m64 in place of -xarch=amd64.
• Use -xarch=sse2a -m64 in place of -xarch=amd64a.

Disallowed Combinations and Warnings
The compilers do not allow the combination of a deprecated -xarch value and the new -m32, -m64 options on the command line. For example, specifying -xarch=v9 -m32 is now a fatal error. Specifying -xarch=sparc -xarch=v9 is also a fatal error.

Some older -xarch values do not have 64-bit counterparts. You cannot combine the following -xarch options with -m64 on the command line"

• SPARC platforms: -xarch=v7, -xarch=v8, -xarch=v8a
• x86 platforms: -xarch=386, -xarch=pentium_pro, -xarch=pentium_proa, -xarch=sse, -xarch=ssea

If you specify a 32-bit -xarch value followed by -m64, the compiler does not issue a warning. For example -m64 -fast or -fast -m64 are allowed. However, if you specify a 64-bit -xarch value followed by -m32, the compiler issues a warning that -m32 overrides the -xarch value. This situation does not occur using macro options, only when an -xarch option has been explicitly specified.

New C Compiler Options and Features

In addition to the new options and features detailed in the rest of this readme, the following new C compiler options are supported in this release:

• Expanded -D to accept marcos with arguments.
• A new -errhdr option which limits warnings from header files to a specified group.
• A new -xnorunpath option prevents the compiler from building a runtime search path for shared libraries into the executable.
• A new -xMMD option generates makefile dependencies excluding system headers. This is the same functionality as with -xM1, but includes compilation.
• A new -xMD option generates makefile dependencies. This is the same functionality as with -xM, but includes compilation.
• A new -xMF filename options allows you to specify a filename for makefile-dependency output.

The -xM, -xM1, -xMD, and -xMMD options are mutually exclusive, and only one can be in effect. When you specify -xMD or -xMMD, but do not specify -xMF, the compiler generates an output file for makefile-dependency output whose default filename is derived from the input filename but with the addition of a .d suffix.

The -xM and -xM1 options behave as usual when you do not specify -xMF. If you do specify -xMF, all makefile-dependency output is appended to the specified file. There is no way to specify individual filenames for multiple input files with -xMF on one command line.

• Support for the #include_next directive

  The C compiler now supports the #include_next directive. The directive does not distinguish between <filename> and "filename" inclusion, nor does it check that the file you specify has the same name as the current file. The compiler looks for the specified file starting with the directory in the search path after the one where the current file which contains the #include_next directive.

• Additions to the __attributes__ clause

  The always_inline, noinline, pure, const, malloc, and aligned attributes are now supported by the __attributes__ clause.

• Support for the aligned attribute

  int __attribute__ ((aligned (16))) i = 0;

• Support for the visibility attribute

  The visibility attribute has been mapped to the linker scoping specifiers of the Sun Studio C compiler as follows:

  The symbol has global linker scoping and is the least restrictive linker scoping. All references to the symbol bind to the definition in the first dynamic module that defines the symbol. This linker scoping is the current linker scoping for extern symbols.

  int __attribute__ ((visibility ("default"))) v5 = 0;
  int __global v6 = 0;

  The symbol has symbolic linker scoping and is more restrictive than global linker scoping. All references to the symbol from within the dynamic module being linked bind to the symbol defined within the module. Outside of the module, the symbol appears as though it were global.

  int __attribute__ ((visibility ("protected"))) v1 = 0; 
  int __symbolic v2 = 0;

  The symbol has hidden linker scoping. Hidden linker scoping is more restrictive than symbolic and global linker scoping. All references within a dynamic module bind to a definition within that module. The symbol will not be visible outside of the module.

  int __attribute__ ((visibility ("internal"))) v3 = 0; 
  int __attribute__ ((visibility ("hidden"))) v4 = 0;
  int __hidden l = 0;

• Support for value-returning blocks

   #define maxint(a,b) \
  ({int _a = (a), _b = (b); _a > _b ? _a : _b; })

• Support for the typeof operator

   #define max(a,b) \
  ({ __typeof__ (a) _a = (a); \
   __typeof__ (b) _b = (b); \
   _a > _b ? _a : _b; })

• Support for zero-length arrays

   struct foo {
  int a;
  int flexarray [0];
  int b;
  int c;
  };

• Support for the __alignof__ operator

  The __alignof__ operator returns the alignment associated with a given type or expression. Its syntax is the same as the syntax of the sizeof operator. The following examples demonstrate how to call __alignof__ and supply an argument:

  __alignof__(float)  /* return 4
  __alignof__(double) /* returns 8
  
  char foo;
  __alignof__(foo)  /* returns 1
  __alignof__(1+1)  /* returns 4 (default integer alignment)
  

  It's an error to ask for the alignment of an incomplete type or of a bit-field.

• Support for local labels

  The following search-macro example demonstrates a typical use of local labels. The example incorporates statement expressions and the typeof operator. A search for an element of a one dimensional array could be written as follows:

  #define SEARCH(array, value,max) \ 
      ({ \ 
         __label__ found_it; \ 
        typeof (value) _value =(value); \ 
        typeof (*(array)) *_array = (array); \ 
        typeof (max) _max = (max); \ 
        typeof (max) i, index; \ 
                               \ 
        for (i =0; i < max; i++) \ 
            if (_array[i] == _value) \ 
               { \ 
                 index= i; \ 
                 goto found_it; \ 
               } index = -1; \ 
  found_it: \
            index; \ 
       }) 
  

  Note the use of the local label "found_it". Without the ability to declare a local label (through the __label__ declaration), multiple uses of the macro would result in multiple definitions for "found_it". Note also that local labels can be used in any block, not just within statement expression blocks.

• Support for GNU-style inline assembly and support for long-long bitfields.

New x86 Features and Updates

The following are new x86 flags for the -xarch option:

• -xarch=sse3 specifies that the compiler should generate instructions based on both the SSE3 and SSE2 architectures.
• -xarch=sse3a specifies that the compiler should generate instructions based on the SSE3, SSE2 and AMD extended architectures as well as the 3DNow extensions.

Changes to -fast
The -fast option on x86 now includes -xregs=frameptr, which means that the compiler can use the frame-pointer register (%ebp on IA32, %rbp on AMD64) as a general purpose register to generate code for all the compilation units. Consequently frame pointers will not be generated in each function or routine.

However, if you want to override this new behavior, specify -xregs=no%frameptr after -fast in the compilation command and the frame-pointer register will not be used as a general purpose register. The following example demonstrates how to override the -fast default for -xregs:

      cc -fast -xregs=no%frameptr foo.c

Static data-race and deadlock-detection with lock_lint
The C compiler option -Zll creates database files (.ll) for use by the lock_lint utility. See lock_lint(1). The -Zll option and the lock_lint utility are now available on x86.

New SPARC Features and Updates

This release of the Sun Studio compilers includes support for the SPARC64 VI and UltraSPARC T2 processors. Use the following new options to specify these processors:

• -xtarget=sparc64vi
• -xtarget=ultraT2

You can also specify the following -xchip options to generate code for these processors without setting the -xarch value automatically as happens when you use -xtarget:

• -xchip=sparc64vi
• -xchip=ultraT2

New Math and Visual Instruction Set Support in SPARC64 VI

Specify the following new option if you want to use instructions from the SPARC-V9 instruction set including the UltraSPARC extensions, the Visual Instruction Set (VIS) version 1.0, the UltraSPARC-III extensions, the Visual Instruction Set (VIS) version 2.0, and the SPARC64 VI extensions for floating-point multiply-add:

• -xarch=sparcfmaf
• -xarch=sparcvis2

You must also specify -m32 or -m64 when you specify -xarch=sparcfmaf to get 32-bit code or 64-bit code respectively. When you specify -xarch=sparcfmaf, the compiler predefines the following new values:

• -D__FP_FAST_FMA__
• -D__FP_FAST_FMAF__

Note: You must use -xarch=sparcfmaf in conjunction with the new -fma=fused option detailed below and some optimization level in order for the compiler to find opportunities to use the multiply-add instructions automatically.

New Option for Floating-Point, Fused or Multiply-Add Instructions

Specify the following new option to enable or disable the automatic generation of floating-point, fused, multiply-add instructions:

• -fma={none,fused}

The none value indicates that the compiler should not generate any floating-point, fused, or multiply-add instructions. The fused value allows the compiler to attempt to find opportunities to improve the performance of the code by using floating-point, fused, or multiply-add instructions.

Linux Support

See the release notes for processor and distribution version requirements.

The New Thread Analyzer

The following new compiler option causes the compiler to instrument your multi-threaded application for analysis by the new Thread Analyzer. 

• -xinstrument[=[no%]datarace]

The default is -xinstrument=no%datarace. See tha(1) and the Thread Analyzer User's Guide. The user's guide includes two tutorials, a FAQ and lists of supported APIs.

D. Software Corrections, Patches, Problems and Workarounds

There is no new information as of this publication date, however, check the Support page on the SDN Sun Studio portal, http://developers.sun.com/sunstudio/support/ for latest information.

G. Documentation Errors

The C User's Guide and the cc(1) manpage do not include descriptions for the new -xMMD, -xMD, and -xMF options. The manual and manpage will be updated on docs.sun.com before the next major release of the C compiler to cover these new options.

Copyright © 2007 Sun Microsystems, Inc. All rights reserved. Use is subject to license terms.