2C(10.1) 2C(10.1)
NAME
0c, 1c, 2c, 5c, 6c, 7c, 8c, kc, qc, vc - C compilers
SYNOPSIS2c [ option ... ] [ file ... ]
etc.
DESCRIPTION
These commands compile the named C files into object files for the cor‐
responding architecture. Associated with each compiler is a string
objtype, for example
0c spim Little-endian MIPS
1c 68000 Motorola MC68000
2c 68020 Motorola MC68020
5c arm ARM 7500
6c amd64 AMD64 extension to x86
7c alpha Digital Alpha APX
8c 386 Intel i386, i486, Pentium, etc.
kc sparc Sun SPARC
qc power Power PC,
vc mips big-endian MIPS 3000 family
Let the first letter of the compiler name be O= 0, 1, 2, 5, 6, 7, 8, k,
q, or v. The output object files end in .O. The letter is also the
prefix of related programs: Oa is the assembler, Ol is the loader.
Plan 9 conventionally sets the $objtype environment variable to the
objtype string appropriate to the current machine's type. Plan 9 also
conventionally has /objtype directories, which contain among other
things: include, for machine-dependent include files; lib, for public
object code libraries; bin, for public programs; and mkfile, for pre‐
conditioning mk(10.1).
For Inferno cross-compilation on all platforms, not just Plan 9, both
$objtype and $OBJTYPE are set by every native kernel mkfile to corre‐
spond to the target processor type. The Inferno mkfiles also set the
-I option appropriately to search the Inferno include directories,
since the Plan 9 defaults are inappropriate.
The compiler options are:
-o obj Place output in file obj (allowed only if there is just one
input file). Default is to take the last element of the
input file name, strip any trailing .c, and append .O.
-w Print warning messages about unused variables, etc.
-B Accept functions without a new-style ANSI C function proto‐
type. By default, the compilers reject functions used with‐
out a defined prototype, although ANSI C permits them.
-Dname=def
-Dname Define the name to the preprocessor, as if by If no defini‐
tion is given, the name is defined as
-F Warn when the elements of a format (eg, those used by print)
disagree with in type or size with the corresponding parame‐
ter, or there is a mismatch in number. See the discussion of
extensions, below.
-Idir An file whose name does not begin with slash or is enclosed
in double quotes is always sought first in the directory of
the file argument. If this fails, the -. flag is given or
the name is enclosed in <>, it is then sought in directories
named in -I options, then in /sys/include, and finally in
/$objtype/include.
-. Suppress the automatic searching for include files in the
directory of the file argument.
-N Suppress automatic registerization and optimization.
-S Print an assembly language version of the object code on
standard output as well as generating the .O file.
-T Pass type signatures on all external and global entities.
The signature is based on the C signof operator, an extension
in this compiler. See dynld(10.2).
-V By default, the compilers are non-standardly lax about type
equality between void* values and other pointers; this flag
requires ANSI C conformance.
-a Instead of compiling, print on standard output acid functions
(see acid(10.1)) for examining structures declared in the
source files.
-aa Like -a except suppress information about structures declared
in included header files.
The compilers handle most preprocessing directives themselves, but sup‐
port excludes the #if and #elif directives, and the ## preprocessor
operation.
The compilers support several extensions to ANSI C:
- A structure or union may contain unnamed substructures and sub‐
unions. The fields of the substructures or subunions can then
be used as if they were members of the parent structure or union
(the resolution of a name conflict is unspecified). When a
pointer to the outer structure or union is used in a context
that is only legal for the unnamed substructure, the compiler
promotes the type and adjusts the pointer value to point at the
substructure. If the unnamed structure or union is of a type
with a tag name specified by a typedef statement, the unnamed
structure or union can be explicitly referenced by <struct vari‐
able>.<tagname>.
- A structure value can be formed with an expression such as
(struct S){v1, v2, v3}
where the list elements are values for the fields of struct S.
- Array initializers can specify the indices of the array in
square brackets, as
int a[] = { [3] 1, [10] 5 };
which initializes the third and tenth elements of the eleven-
element array a.
- Structure initializers can specify the structure element by
using the name following a period, as
struct { int x; int y; } s = { .y 1, .x 5 };
which initializes elements y and then x of the structure s.
These forms also accept the new ANSI C notation, which includes
an equal sign:
int a[] = { [3] = 1, [10] = 5 };
struct { int x; int y; } s = { .y = 1, .x = 5 };
- A global variable can be dedicated to a register by declaring it
extern register in all modules and libraries.
- A #pragma of the form
#pragma lib "libbio.a"
records that the program needs to be loaded with file /$obj‐
type/lib/libbio.a; such lines, typically placed in library
header files, obviate the -l option of the loaders. To help
identify files in non-standard directories, within the file
names in the #pragmas the string $M represents the name of the
architecture (e.g., mips) and $O represents its identifying
character (e.g., v).
- Two #pragma requests to define rules for checking print-like
formats (see the -F option above). One #pragma tells for a
given routine which argument is the format. For example:
#pragma varargck argpos print 1
#pragma varargck argpos sprint 2
say that print has a format as its first argument, and sprint
has one as its second. Another #pragma associates format char‐
acter sequences and types:
#pragma varargck type "lld" vlong
#pragma varargck type "lx" void*
#pragma varargck type "S" Rune*
where the format characters are those following the % in the
format (ignoring any preceding formatting flags). Note the
assumption that all formats arguments are compatible. The sys‐
tem include files have appropriate #pragma lines for the stan‐
dard format elements and formatting functions.
- A #pragma of the form
#pragma incomplete type
tells the compiler that type should have its signature calcu‐
lated as an incomplete type even when it is fully defined. This
allows the type signature mechanism to work in the presence of
opaque types declared in header files, with their full defini‐
tions visible only to the code which manipulates them. With
some imported software it might be necessary to turn off the
signature generation completely for a large body of code (typi‐
cally at the start and end of a particular include file). If
type is the word _off_, signature generation is turned off; if
type is the word _on_, the compiler will generate signatures.
- The C++ comment (// to end of line) is accepted as well as the
normal convention of /* */.
- The compilers accept long long variables as a 64-bit type. The
standard header typedefs this to vlong. Arithmetic on vlong
values is usually emulated by a run-time library.
EXAMPLE
For the 68020, produce a program prog from C files main.c and sub.c:
2c-FVw main.c sub.c
2l -o prog main.2 sub.2
FILES
/sys/include
host system area for machine-independent #include directives.
/$objtype/include
host system area for machine-dependent #include directives.
SOURCE
/utils/cc
machine-independent part
/utils/2c, etc.
machine-dependent part
SEE ALSO
2a(10.1), 2l(10.1), mk(10.1), inm(10.1), acid(10.1),
Rob Pike, ``How to Use the Plan 9 C Compiler''
BUGS
The preprocessor only handles and
2C(10.1)
