Compiler Compatibility
This section discusses compiler features and other behavior that affect compatibility between Oracle Developer Studio and GCC.
Implementation Defined Behavior
Some parts of the C and C++ standards are left as “implementation defined behavior”. These details are defined in the GCC and Oracle Developer Studio documentation, and they differ in some ways.
Both bit-fields and enumerated types can be either signed or unsigned by the choice of the compiler. For enums, this choice can vary based on the list of enumerated values. The behavior of Oracle Developer Studio C and C++ is different from the behavior of gcc.
Signed and Unsigned int Bit-fields
Bit-fields which are declared as int (not signed int or unsigned int) can be implemented by the compiler using either signed or unsigned types. This makes a difference when extracting a value and deciding whether to sign extend it.
The Oracle Developer Studio compiler uses unsigned types for int
bit-fields and the gcc compiler uses signed types. Use the
gcc
–funsigned-bitfields flag to control this behavior.
For more information, see the sixth list item at https://gcc.gnu.org/onlinedocs/gcc-3.3.6/gcc/Non_002dbugs.html.
Signed and Unsigned enum Types
enum types in C and C++ can be implemented by the compiler
using either signed or unsigned types. It can depend on the enumeration values
in the specific type, so it is harder to predict. The behavior of the
Oracle Developer Studio compilers is different from gcc in this regard.
Oracle Developer Studio compilers use signed values for enums and
gcc compilers use an unsigned type unless some the values
in the enum type are explicitly assigned negative
values.
Understanding the implementation differences between bit-fields declared as enum types is (so far) left as an exercise for the reader. It is best to update the source code to be more portable. For bit-fields, you can simply update the “int” declaration to be either “signed” or “unsigned” depending on how the code was written. For enum types, you can cast the type when you want to convert it to an integer and not depend on its default type.
C Language Extensions
Many C language extensions in Oracle Developer Studio are also implemented in Oracle Developer Studio
C++. Some of the C extensions are documented in Extensions in Oracle Developer Studio 12.5: C User’s Guide. For the list of gcc language
extensions, see Extensions to the C Language Family in the GCC
documentatioin.
Some of the items listed in the gcc table are now standard features of a relevant language standard and are listed in Table 1 as C11, C99, C++03, C++11, and C++14.
Features of a newer language standard are often available as an extension when
compiling according to older language standards unless either they conflict with
existing code or you are using an option to enable a strict conformance mode. For
more information about features that are available in different modes, see the
documentation for that compiler.
The following table lists the extensions that are implemented in Oracle Developer Studio.
Table 1 GCC Extensions implemented in Oracle Developer Studio
|
|
Statement Expressions: Putting statements and declarations inside expressions.
|
Implemented.
|
Local Labels: Labels local to a block.
|
Implemented in C only.
|
Labels as Values: Getting pointers to labels, and computed
gotos.
|
Implemented in C only.
|
Nested Functions: As in Algol and Pascal, lexical scoping of functions.
|
Not Implemented.
|
Constructing Calls: Dispatching a call to another function.
|
Not Implemented.
|
Typeof: referring to the type of an expression.
|
Implemented. New in Oracle Developer Studio 12.5 C++ C++11 defines
decltype for this. In Sun
(–compat=5) mode, C++ omits the
typeof keyword, but still supports
__typeof and
__typeof__.
|
Conditionals: Omitting the middle operand of a ‘?:’ expression.
|
Implemented in C only.
|
__int128: 128-bit integers—__int128.
|
Not implemented.
|
Long Long: Double-word integers—long long int.
|
Implemented in C and C++.
|
Complex: Data types for complex numbers.
|
untyped _Complex defaults to double for compatibility with gcc. Implemented in C only.
|
Floating Types: Additional Floating Types.
|
Oracle Developer Studio C and C++ implement the 128-bit long
double type, but not with the type named
__float128.
|
Half-Precision: Half-Precision Floating Point.
|
Not implemented.
|
Decimal Float: Decimal Floating Types.
|
Not implemented.
|
Hex Floats: Hexadecimal floating-point constants.
|
C99. Implemented in C only.
|
Fixed-Point: Fixed-Point Types.
|
Not implemented.
|
Named Address Spaces: Named address spaces.
|
Not implemented.
|
Zero Length: Zero-length arrays (general zero length arrays).
|
int foo[0];
Implemented in C++ in GNU compatibility mode, or with –features=zla.
|
Zero Length: Zero-length arrays (flexible array members).
|
int foo[]; // at the end of a struct
Implemented in C++ in GNU compatibility mode, or with –features=zla.
|
Empty Structures: Structures with no members.
|
Implemented. For C, requires –features=extensions.
|
Variable Length: Arrays whose length is computed at run time.
|
C99. Implemented in C and C++.
|
Variadic Macros: Macros with a variable number of arguments
|
C99. Implemented in C and C++. Oracle Developer Studio implements the gcc extension for supplying a user-defined name for the variable macro arguments. gcc extensions for missing variables arguments are not implemented in C++.
|
Escaped Newlines: Slightly looser rules for escaped newlines.
|
Not implemented.
|
Subscripting: Any array can be subscripted, even if not an lvalue.
|
C99. Standard C++. Implemented in C and C++.
|
Pointer Arith: Arithmetic on void-pointers and function pointers.
|
Implemented in C only. Warning is generated.
|
Pointers to Arrays: Pointers to arrays with qualifiers work as expected.
|
Not implemented.
|
Initializers: Non-constant initializers.
|
C99. Standard C++. Implemented.
|
Compound Literals: Compound literals give structures, unions,
or arrays as values.
|
C99. Implemented in C.
|
Designated Inits: Labeling elements of initializers.
|
C99. Implemented in C.
|
Case Ranges: `case 1 ... 9` and
such.
|
Implemented.
|
Cast to Union: Casting to the union type
from any member of the union.
|
Not implemented.
|
Mixed Declarations: Mixing declarations and code.
|
C99. Standard C++. Implemented.
|
Attribute Extensions
|
__has_attribute() can be used to test for recognized attributes. For more information, see Attributes.
|
Function Prototypes: Prototype declarations and old-style definitions.
|
Implemented in C only. Not relevant to C++.
|
C++ Comments: are recognized.
|
Implemented in C.
|
Dollar Signs: Dollar sign is allowed in identifiers.
|
Implemented. Requires –features=iddollar.
|
Character Escapes: ‘\e’ stands for the character <ESC>.
|
Not implemented.
|
Alignment: Inquiring about the alignment of a type or variable.
|
C11, spelled _Alignof. __alignof__ supported in C and C++. C++ supports alignof in C++11 mode.
|
Inline: Defining inline functions (as fast as macros).
|
C99 and Standard C++. Implemented. Before GCC implemented the
standard, it created a static function body instead of an
external one. If your code depends on this, you can use the C
option –features=no%extinl to get similar
behavior from the Oracle Developer Studio C compiler.
|
Volatiles: What constitutes an access to a volatile object.
|
Implemented. Compatible with GCC.
|
Using Assembly Language with C: Instructions and extensions for interfacing C with assembler.
|
Implemented. C and C++ implement
gcc-compatible asm()
statements, including constraints, asm()
labels, and explicit register variables.
|
Alternate Keywords: __const__, __asm__, among others, for header files.
|
Implemented. Oracle Developer Studio 12.5 C++ added __asm and __volatile keyword spellings.
|
Incomplete Enums: enum foo;, with a
subsequent definition.
|
C++11. Implemented in C and C++. Must be C++11 mode.
|
Function Names: Printable strings which are the name of the current function.
|
Oracle Developer Studio compirs support __func____FUNCTION__ and __PRETTY_FUNCTION__.
|
Return Address: Getting the return or frame address of a function.
|
Not implemented.
|
Vector Extensions: Using vector instructions through built-in functions.
|
|
Offsetof: Special syntax for implementing offsetof.
|
Not implemented.
|
__sync Builtins: Legacy built-in functions for atomic memory access.
|
Implemented. Use –xatomic=studio. See Atomics. ( gcc deprecates these functions in favor of the standard __atomic builtins.)
|
__atomic Builtins: Atomic built-in functions with memory model.
|
Implemented. New in Oracle Developer Studio 12.5. Use –xatomic=studio. See Atomics.
|
Integer Overflow Builtins: Built-in functions to perform
arithmetic and arithmetic overflow checking.
|
Not implemented.
|
x86 Specific Memory Model Extensions for Transactional Memory:
x86 memory models.
|
Not implemented.
|
Object Size Checking: Built-in functions for limited buffer overflow checking.
|
Not implemented.
|
Pointer Bounds Checker Built-ins: Built-in functions for
Pointer Bounds Checker.
|
Not implemented.
|
Cilk Plus Built-ins: Built-in functions for the Cilk Plus
language extension.
|
Not implemented.
|
Other Builtins: Other built-in functions.
|
__builtin_constant_p() can test whether
something is a compile-time constant. Most other built-ins are
not yet implemented by Oracle Developer Studio.
|
Target Builtins: Built-in functions specific to particular targets.
|
Not implemented.
|
Target Format Checks: Format checks specific to particular targets.
|
Not implemented.
|
Pragmas: Pragmas accepted by gcc.
|
#pragma once implemented. Others not implemented.
|
Unnamed Fields: Unnamed struct/union fields within structs/unions.
|
C++11. Implemented in C and C++.
|
Thread-Local: Per-thread variables.
|
C99. C++11. Implemented in C and C++.
|
Binary Constants: Binary constants using the
‘0b’ prefix.
|
Implemented in C++ only.
|
|
SIMD Vector Support
Oracle Developer Studio supports some architecture-specific intrinsics to encode vector
operations using CPU-specific instructions. The data types for these are created
using the vector_size attribute or by including an
appropriate header file as described in Header File Compatibility. Some C operators are supported on such types, but in
some cases you might have to use the CPU-specific intrinsics.
For a discussion of types like _m128 and operations on
them, see the SPARC64 X section in SIMD Intrinsics in Oracle Developer Studio 12.5: C User’s Guide.
C++ Specific Features
The Oracle Developer Studio C++ compiler supports the –features=cplusplus_redef option that enables a non-standard value of the __cplusplus macro for source codes that requires that setting.–xrestrict[=f] in Oracle Developer Studio 12.5: C++ User’s Guide
Some other GNU extensions for C++ are as follows:
-
long long constants in enumerations
-
Allowing a typedef for void as a
function parameter
-
typedef void VOID;
int foo(VOID);
-
_Bool, which is equivalent to bool on Oracle Linux when <stdbool.h> is included
-
extern template
-
long long bit-field
-
pragma pack push/pop
For information about C++ Extensions, see Extensions to the C++ Language in the GCC documentation.
Information about this same functionality in the Oracle Developer Studio compiler can be found
in the following table.
Table 2 GNU C++ Extensions
|
|
C++ Volatiles: Determine what constitutes an access to a
volatile object.
|
Compatible Implementation.
|
Restricted Pointers: C99 restricted pointers and references.
|
Implemented.
|
Vague Linkage: Where G++ puts inlines, vtables and the
like.
|
Oracle Developer Studio also uses COMDAT for these, probably in a slightly different way.
|
C++ Interface: You can use a single C++ header file for both declarations and definitions.
|
Not implemented. Deprecated in gcc.
|
Template Instantiation: Methods for ensuring that exactly one copy of each needed template instantiation is emitted.
|
Oracle Developer Studio also uses COMDAT for these, probably in a slightly different way.
|
Bound member functions: You can extract a function pointer to the method denoted by a ‘->*’ or ‘.*’ expression.
|
Not Implemented.
|
C++ Attributes: Variable, function, and type attributes for C++ only.
|
|
Function Multiversioning: Declaring multiple function versions.
|
Not Implemented.
|
Namespace Association: Strong using directives for namespace
association.
|
Not implemented. Deprecated in gcc in favor
of a standard C++11 feature.
|
Type Traits: Compiler support for type traits.
|
Not Implemented.
|
C++ Concepts: Improved support for generic programming.
|
Not Implemented.
|
Java Exceptions: Tweaking exception handling to work with Java.
|
Not Implemented.
|
Deprecated Features: Things that are scheduled to be removed
from C++.
|
Not Implemented.
|
Backwards Compatibility: Compatibilities with earlier definitions of C++.
|
Not Implemented.
|
|
Attributes
The full documentation for attributes implemented in the Oracle Developer Studio 12.5 compilers is in Supported Attributes in Oracle Developer Studio 12.5: C User’s Guide and Supported Attributes in Oracle Developer Studio 12.5: C++ User’s Guide.
The __has_attribute() built-in can be used with both gcc and Oracle Developer Studio compilers to test for recognized attributes.
The following attributes are new in Oracle Developer Studio 12.5 C++: aligned, deprecated, weak(alias), weakref, packed, tls_model, vector_size, and visibility.
The Oracle Developer Studio compilers do not support all of the syntaxes for attributes.
Table 3 GCC Attributes
|
|
Function Attributes: Declaring that functions have no side effects, or that they can never return.
|
alias, aligned, always_inline, const, constructor / destructor, deprecated (C++14), malloc, noinline, noreturn, nothrow (c++ only), pure, returns_twice, visibility, weak (and alias), weakref (C++)
|
Variable Attributes: Specifying attributes of variables.
|
aligned, deprecated, mode (C++), packed (partial implementation), tls_model, vector_size, weak
|
Type Attributes: Specifying attributes of types.
|
aligned, deprecated, packed, visibility
|
Enumerator Attributes: Specifying attributes on enumerators.
|
deprecated
|
|
Command-Line Options
Both the Oracle Developer Studio and the gcc compilers implement
traditional compiler options like –g, –c,
–o, and many others. The following table describes the options
in the Oracle Developer Studio compilers that have been implemented specifically to be
compatible with gcc.
The following options in Oracle Developer Studio are compatible with
gcc.
Table 4 Compatible Options
|
|
–std
|
The –std option selects a language standard like C11, C++11, and others.
|
–pedantic
|
Issues errors or warnings for technical violations of the standard that would otherwise be accepted. This option is new in the Oracle Developer Studio 12.5 C++ compiler.
|
–m32 / –m64
|
Selects 32-bit or 64-bit binary output.
|
–shared
|
Produce a shared library. In Oracle Solaris Studio 12.4, the –shared option acted like an alias for –G. In Oracle Developer Studio 12.5, this option acts like the –shared option in gcc. See Table 5.
|
|
The following options work differently between Oracle Developer Studio and GCC.
Table 5 Options with Differences
|
|
|
–xM
|
–M
|
Print make-style dependencies for a source file. In
gcc, –xM performs another
function. In Oracle Developer Studio, –M selects a linker
map file.
|
–B(static| dynamic)
|
–Wl,–B(static| dynamic)
|
GNU Linker supports this behavior, but gcc
does not. Use –Wl to pass the option to GNU
ld. In gcc,
–B performs another function.
|
–G
|
–shared
|
When producing a shared library, –shared in
gcc adds C++ library dependencies. The
–G option in the Oracle Developer Studio compilers
does not add them.
|
|
The following gcc-style options are automatically translated into corresponding options in Oracle Developer Studio. This list of options can be seen by passing this option to the following option to the C or C++ compiler: –xhelp=gccflags.
Table 6 Automatically Translated Options
|
|
–MM
|
Same as –xM1
|
–Ofast
|
Same as –fast
|
–Wall
|
Same as +w2 (C++ only)
|
–Wall
|
Same as –v (C only)
|
–Werror
|
Same as –errwarn=%all
|
–Wpedantic
|
Same as –pedantic
|
–fno-elimininate-unused-debug-types
|
Accept and ignore
|
–fopenmp
|
Same as –xopenmp
|
–fPIC
|
Same as –KPIC
|
–fpic
|
Same as –Kpic
|
–fplan9-extensions
|
Accept and ignore (C only).
|
–fplugin-arg-name=t
|
Warn and ignore (C only)
|
–fplugin=t
|
Warn and ignore (C only)
|
–fsigned-char
|
Same as –xchar=signed (C only)
|
–fsyntax-only
|
Same as –xe
|
–funsigned-char
|
Same as –xchar=unsigned (C only)
|
–gdwarf-version
|
Same as –xdebugformat=dwarf
|
–gstabs
|
Same as –xdebugformat=stabs
|
–gstabs+
|
Suggest using –xdebugformat=stabs; option ignored
|
–iplugindir=t
|
Warn and ignore
|
–march=a
|
Same as
–xtarget=a
|
–mcpu=a
|
Same as
–xtarget=a
|
–mfmaf
|
Same as –fma=fused
|
–mno-vis
|
Same as –xvis=no
|
–mno-vis2
|
Same as –xvis=no
|
–mno-vis3
|
Same as –xvis=no
|
–mtune=a
|
Same as
–xtarget=a
|
–mvis
|
Same as –xvis
|
–mvis2
|
Same as –xvis
|
–mvis3
|
Same as –xvis
|
–no-canonical-prefixes
|
Accept and ignore
|
–no-fma
|
Same as –fma=none
|
–no-fmaf
|
Same as –fma=none
|
–no-trigraphs
|
Same as –xtrigraphs=no
|
–nodefaultlibs
|
Same as –xnolib (C++ only)
|
–pass-exit-codes
|
Warn and ignore
|
–pedantic-errors
|
Same as –pedantic
|
–pipe
|
Warn and ignore
|
–save-temps
|
Same as –keeptmp
|
–shared
|
Same as –G
|
–specs=t
|
Warn and ignore
|
–traditional
|
Same as –Xs (C only)
|
–trigraphs
|
Same as –xtrigraphs=yes
|
|