Whether each nonempty sequence of white-space characters other than newline is retained or replaced by one space character (2.1.1.2).

A nonempty sequence of white-space characters (other than newline) is retained.

How a diagnostic is identified (2.1.1.3).

Successful compilations are silent. Diagnostics are, in general, emitted to standard error. Diagnostic messages have the general pattern of file-name,line-number:severity(number): message in 64-bit mode. Diagnostics have a slightly different pattern in 32-bit mode. Also, the range of numbers in 32-bit mode are disjointed from the range 64-bit mode.

For example, typical messages from the ANSI C compiler front end in 64-bit mode look like this:

"t4.c”, line 4: error(1020):identifier "x” is undefined 
"t4.c”, line 5: warning(1551):variable "y” is used before its value is set

Messages can also be issued by other internal compiler passes.

Classes of diagnostic messages, their return codes and control over them

Basically two classes of messages exist: warning and error. Warning messages include the notation “warning” (which can be capitalized), and allow the compilation to continue (return code 0). Error messages cause the compilation to fail (return code 1).

Warning messages from the compiler front end have a unique diagnostic number. You can suppress these messages individually by putting the number in the numberlist of a -woff numberlist switch to cc(1). numberlist is a comma-separated list of warning numbers and ranges of warning numbers. For example, to suppress the warning message in the previous example, type:

-woff 1551

To suppress warning messages numbered 1642, 1643, 1644, and 1759, type:

-woff 1642-1644,1759

Support of freestanding environments.

No support is provided for a freestanding environment.

The semantics of the arguments to main (2.1.2.2.1).

main is defined to have the two required parameters argc and argv. A third parameter, envp, is provided as an extension. That is, main would have the equivalent of the prototype int main(int argc, char *argv[], char *envp[]). The parameters have the following semantics:

What constitutes an interactive device (2.1.2.3).

Asynchronous terminals, including windows, are interactive devices and are, by default, line buffered. In addition, the standard error device, stderr, is unbuffered by default.

The number of significant initial characters (beyond 31) in an identifier without external linkage (3.1.2).

All characters are significant.

The number of significant initial characters (beyond 6) in an identifier with external linkage (3.1.2).

All characters are significant.

Whether case distinctions are significant in an identifier with external linkage (3.1.2).

Case distinctions are always significant.

The members of the source and execution character sets, except as explicitly specified in the standard (2.2.1).

Only the mandated characters are present. The source character set includes all printable ASCII characters, hexadecimal 0x20 through 0x7e, and 0x7 through 0xc (the standard escape sequences).

The values to which the standard escape sequences are translated (2.2.2).

The escape sequences are translated as specified for standard ASCII: \a = 0x7, \b = 0x8, \f = 0xc, \n = 0xa, \r = 0xd, \t = 0x9, \v=0xb

The shift states used for the encoding of multibyte characters (2.2.1.2)

The multibyte character set is identical to the source and execution character sets. There are no shift states.

The number of bits in a character in the execution character set (2.2.4.2.1).

There are eight bits per character.

The mapping of members of the source character set (in character constants and string literals) to members of the execution character set (3.1.3.4).

The mapping is the identity mapping.

The value of an integer character constant that contains a character or escape sequence not represented in the basic execution character set or in the extended character set for a wide character constant (3.1.3.4).

With the exception of newline (0xa), backslash ('\'), and 0xff (end-of-file), eight-bit values appearing in an integer character constant are placed in the resultant integer in the same fashion as are characters which are members of the execution character set (see below). A backslash, newline, or 0xff can be placed in a character constant by preceding it with a backslash (that is, “escaping” it).

The value of an integer character constant that contains more than one character or a wide character constant that contains more than one multibyte character (3.1.3.4).

You can assign up to four characters to an int using a character constant. The encoding of multiple characters in an integer consists of the assignment of the corresponding character values of the n characters in the constant to the least-significant n bytes of the integer, filling any unused bytes with zeros. The most significant byte assigned contains the value of the lexically first character in the constant. For example:

int t = 'a'; /* integer value 0x61 */ 
int t2 = 'ab'; /* integer value 0x6162 */ 
int t4 = 'abcd'; /* integer value 0x61626364 */ 
int t4 = 'abcde'; /* error: too many characters for */
 /* character constant */ 

Since the multibyte character set is identical to the source and execution character sets, the above discussion applies to the assignment of more than one multibyte character to a wide character constant.

The current locale used to convert multibyte characters into corresponding wide character (codes) for a wide character constant (3.1.3.4).

The mapping is the identity mapping to the standard ASCII character set. The C locale is used.

Whether a “plain” char has the same range of values as signed char or unsigned char.

Plain char is the same as unsigned char by default. Use the –signed option to cc to switch the range to be that of signed char.

The representations and sets of values of the various types of integers (3.1.2.5).

Integers are two's complement binary. Table A-1 lists the sizes and ranges of the various types of integer. The use of long long results in a warning in –ansi and –ansiposix modes.

In the 32-bit implementation, to take full advantage of the support for 64 bits integral values in –ansi and –ansiposix modes, you can define the macro _LONGLONG on the cc(1) command line when using the types __uint64_t, __int64_t, or library routines that are prototyped in terms of these types.

The result of converting an integer to a shorter signed integer, or the result of converting an unsigned integer to a signed integer of equal length, if the value cannot be represented (3.2.1.2).

The least significant n bits (n being the length of the result integer) of the source are copied to the result.

The results of bitwise operations on signed integers (3.3).

With the exception of right-shift of a negative signed integer (defined below), operations on signed and unsigned integers produce the same bitwise results.

The sign of the remainder on integer division (3.3.5)

The sign of the remainder is that of the numerator.

The result of a right shift of a negative-valued signed integral type (3.3.7).

The sign bit is propagated, so the result value is still negative.

The representations and sets of values of the various types of floating-point numbers (3.1.2.5).

The representation is IEEE:

See ANSI/IEEE Standard 754-1985 and IEEE Standard for Binary Floating-Point Arithmetic. Table A-2 lists ranges of floating-point types.

The type of rounding or truncation used when representing a floating-point constant which is within its range.

Per IEEE, the rounding is round-to-nearest (IEEE Standard 754, sections 4.1 and 5.5). If the two values are equally near, then the one with the least significant bit zero is chosen.

The direction of truncation when an integral number is converted to a floating-point number that cannot exactly represent the original value (3.2.1.3).

Conversion of an integral type to a float type, if the integral value is too large to be exactly represented, gives the next higher value.

The direction of truncation or rounding when a floating-point number is converted to a narrower floating-point number.

Per IEEE, the rounding is round-to-nearest (IEEE Standard 754, Section 4.1 and 5.5). If the two values are equally near, then the one with the least significant bit zero is chosen.

The type of integer required to hold the maximum size of an array— that is, the type of the sizeof operator, size_t (3.3.3.4,4.1.1).

An unsigned long holds the maximum array size.

The size of integer required for a pointer to be converted to an integer type (3.3.4).

long ints are large enough to hold pointers in –32 mode. Both are 32 bits wide.

long ints are large enough to hold pointers in –64 mode. Both are 64 bits wide.

The result of casting a pointer to an integer or vice versa (3.3.4).

The result is bitwise exact provided the integer type is large enough to hold a pointer.

The type of integer required to hold the difference between two pointers to elements of the same array, ptrdiff_t (3.3.6, 4.1.1).

An int is large enough to hold the difference between two pointers to elements of the same array in –32 mode.

A long int is large enough to hold the difference between two pointers to elements of the same array in both –32 and –64 modes.

The extent to which objects can actually be placed in registers by use of the register storage-class specifier (3.5.1).

The compilation system can use up to eight of the register storage-class specifiers for nonoptimized code in –32 mode, and it ignores register specifiers for formal parameters. Use of register specifiers is not recommended.

The register storage-class specifier is always ignored and the compilation system makes its own decision about what should be in registers for optimized code (–O2 and above).

What is the result if a member of a union object is accessed using a member of a different type (3.3.2.3).

The bits of the accessed member are interpreted according to the type used to access the member. For integral types, the N bits of the type are simply accessed. For floating types, the access might cause a trap if the bits are not a legal floating-point value. For pointer types, the 32 bits (64 bits if in –64 mode) of the pointer are picked up. The usability of the pointer depends on whether it points to a valid object or function, and whether it is used appropriately. For example, a pointer whose least-significant bit is set can point to a character, but not to an integer.

The padding and alignment of members of structures (3.5.2.1).

This should present no problem unless binary data written by one implementation are read by another.

Members of structures are on the same boundaries as the base data type alignments anywhere else. A word is 32 bits and is aligned on an address, which is a multiple of 4. Unsigned and signed versions of a basic type use identical alignment. Type alignments are given in Table A-3.

Whether a “plain” int bit-field is treated as a signed int bit-field or as an unsigned int bit-field (3.5.2.1).

A “plain” int bit-field is treated as a signed int bit-field.

The order of allocation of bitfields within a unit (3.5.2.1).

Bits in a bitfield are allocated with the most-significant bit first within a unit.

Whether a bitfield can straddle a storage-unit boundary (3.5.2.1).

Bitfields cannot straddle storage unit boundaries (relative to the beginning of the struct or union), where a storage unit can be of size 8, 16, 32, or 64 bits.

The integer type chosen to represent the values of an enumeration type (3.5.2.2).

The int type is always used. Note that long or long long enumerations are not supported.

What constitutes an access to an object that has volatile-qualified type (3.5.3).

Objects of volatile-qualified type are accessed only as specified by the abstract semantics, and as would be expected on a RISC architecture. No complex instructions exist (for example, read-modify-write). volatile objects appearing on the left side of an assignment expression are accessed once for the write. If the assignment is not simple, an additional read access is performed. volatile objects appearing in other contexts are accessed once per instance. Incrementation and decrementation require both a read and a write access.

volatile objects that are memory-mapped are accessed only as specified: if such an object is of size char, for example, adjacent bytes are not accessed. If the object is a bitfield, a read may access the entire storage unit containing the field. A write of an unaligned field necessitates a read and write of the storage unit that contains it.

The maximum number of declarators that can modify an arithmetic, structure, or union type (3.5.4).

There is no limit.

The maximum number of case values in a switch statement (3.6.4.2).

There is no limit.

Whether the value of a single-character character constant in a constant expression that controls conditional inclusion matches the value of the same character constant in the execution character set. Whether such a character constant can have a negative value (3.8.1).

The preprocessing and execution phases use exactly the same meanings for character constants.

A single-character character constant is always positive.

The method for locating includable source files (3.8.2).

For file names surrounded by <>, the includable source files are searched for in /usr/include.

The default search list includes /usr/include. You can change this list with various compiler options. See cc(1), the –I, and –nostdinc options.

The support of quoted names for includable source files (3.8.2).

Quoted names are supported for includable source files. For file names surrounded by ““, the includable source files are searched for in the directory of the current include file, then in /usr/include.

The default search list includes /usr/include. You can change this list with various compiler options. See cc(1), the –I, and –nostdinc options.

The mapping of source file character sequences (3.8.2).

The mapping is the identity mapping.

The behavior on each recognized #pragma directive.

#pragma weak weak_symbol = strong_symbol

The weak_symbol is an alias that denotes the same function or data object denoted by the strong_symbol, unless a defining declaration for the weak_symbol is encountered at static link time. If encountered, the defining declaration preempts the weak denotation.

You must define the strong_symbol within the same compilation unit in which the pragma occurs. You should also declare the weak_symbol with extern linkage in the same compilation unit. The extern declaration of the weak symbol is not required, unless the symbol is referenced within the compilation unit, but Silicon Graphics recommends it for type-checking purposes. The weak and strong symbols must be declared with compatible types. When the strong symbol is a data object, its declaration must be initialized.

Weak extern declarations are typically used to export non-ANSI C symbols from a library without polluting the ANSI C name-space. As an example, libc may export a weak symbol read(), which aliases a strong symbol _read(), where _read() is used in the implementation of the exported symbol fread(). You can either use the exported (weak) version of read(), or define your own version of read() thereby preempting the weak denotation of this symbol. This will not alter the definition of fread(), since it only depends on the (strong) symbol _read(), which is outside the ANSI C name-space.

#pragma weak weak_symbol

The pragma weak weak_symbol tells the link editor not to complain if it does not find a defining declaration of the weak_symbol. References to the symbol use the appropriate lvalue if the symbol is defined; otherwise, it uses memory location zero (0).

#pragma once

This pragma has no effect in –32 mode, but will ensure idempotent include files in –64 mode (i.e. that an include file is included at most once in one compilation unit). Silicon Graphics recommends enclosing the contents of an include file afile.h with an #ifdef directive similar to:

#ifndef afile_INCLUDED
#define afile_INCLUDED
<contents of afile.h>
#endif

#pragma pack(n)

This pragma controls the layout of structure offsets, such that the strictest alignment for any structure member will be n bytes, where n is 0, 1, 2, 4, 8, or 16. When n is 0, the compiler returns to default alignment for any subsequent struct definitions.

A struct type defined in the scope of a #pragma pack(n) has at most an alignment of n bytes, and the packed characteristics of the type apply wherever the type is used, even outside the scope of the pragma in which the type was declared. The scope of a #pragma pack ends with the next #pragma pack, hence this pragma does not nest: There is no way to “return” from one instance of the pragma to a lexically earlier instance of the pragma.

A structure declaration must be subjected to identical instances of a #pragma pack in all files, or else misaligned memory accesses and erroneous struct member dereferencing may ensue.

Silicon Graphics strongly discourages the use of #pragma pack, since it is a nonportable feature, may result in less efficient field dereferencing, and it may not be supported in future compiler releases.

#pragma intrinsic(a_function)

This pragma allows certain preselected functions from math.h, stdio.h, and string.h to be inlined at a call-site for execution efficiency. The #pragma intrinsic has no effect on functions other than the preselected ones. Exactly which functions may be inlined, how they are inlined, and under what circumstances inlining occurs is implementation defined and may vary from one release of the compilers to the next. The inlining of intrinsics may violate some aspect of the ANSI C standard (e.g., the errno setting for math.h functions). All intrinsics are activated through pragmas in the respective standard header files and only when the preprocessor symbol __INLINE_INTRINSICS is defined and the appropriate include files are included. __INLINE_INTRINSICS is predefined by default only in –cckr and –xansi mode.

The MIPSpro compilers also silently recognize many commonly used pragmas; however, they have no effect. Some of these include:

#pragma no side effect(a_function)

Tells the compiler that a call to a function of the given name does not cause any modifications to objects accessible outside the function body. Such information can be useful for optimization and parallelization purposes. In –64 mode, the syntax for this pragma is changed to #pragma no_side_effect(a_function).

#pragma ident version

Adds a .comment section in the object file and puts the revision string inside it.

#pragma int_to_unsigned identifier

Identifies identifier as a function whose type was int in a previous releases of the compilation system, but whose type is unsigned int in the MIPSpro compiler release. The declaration of the identifier must precede the pragma:

unsigned int strlen(const char*);
#pragma int_to_unsigned strlen

This declaration makes it possible for the compiler to identify where the changed type may affect the evaluation of expressions.

Other #pragmas are used for C multiprocessing. They are described in the Power C User's Guide.

The definitions for __DATE__ and __TIME__ when, respectively, the date and time of translation are not available.

The date and time of translation are always available in this implementation.

What is the maximum nesting depth of include files (3.8.2).

The maximum nesting of include files is 200.

The null pointer constant to which the macro NULL expands (4.1.5)

The NULL pointer constant expands to an int with value zero. That is,

#define NULL 0

The diagnostic printed by and the termination behavior of the assert function (4.2).

If an assertion given by assert(EX) fails, the following message is printed on stderr using a _write to its underlying fileno.

Assertion failed: EX, file <filename>, line <linenumber> 

This is followed by a call to abort(3c) (which exits with a SIGABRT).

The sets of characters tested for by the isalnum, isalpha, iscntrl, islower, isprint, and isupper functions (4.3.1).

The following is true when operating in the C locale. The C locale is in effect at program startup for programs compiled for pure ANSI C (that is, -ansi), or by invoking setlocale(LC_ALL,”C”). The C locale can be overridden at startup for any program that does not explicitly invoke setlocale by setting the value of the environment variable CHRCLASS. (See the man page ctype(3C).)

The values returned by the mathematics functions on domain errors (4.5.1).

The value returned by the math functions on domain errors is the default IEEE Quiet NaN in all cases except the following:

Whether mathematics functions set the integer expression errno to the value of the macro ERANGE on underflow range errors (4.5.1).

Yes, except intrinsic functions that have been inlined. Note that fabs, fabsf, sqrt, sqrtf, hypotf, fhypot, pow, and powf are intrinsic by default in –xansi and –cckr modes and can be made intrinsic in –ansi mode by using the compiler option D__INLINE_INTRINSICS.

Whether a domain error occurs or zero is returned when the fmod function has a second argument of zero (4.5.6.4).

fmod(x,0) gives a domain error and returns the default IEEE Quiet NaN.