man(1) Manual page archive

     2C(1)                                                       2C(1)

          2c, 6c, 8c, kc, vc, xc - C compilers

          2c [ option ... ] [ file ... ]
          6c [ option ... ] [ file ... ]
          8c [ option ... ] [ file ... ]
          kc [ option ... ] [ file ... ]
          vc [ option ... ] [ file ... ]
          xc [ option ... ] [ file ... ]

          2c, 6c, 8c, kc, vc, and xc compile the named C files into
          MC68020, i960, i386, SPARC, MIPS, and ATT3210 object files.
          The compilers handle most preprocessing directives them-
          selves; a complete preprocessor is available in cpp(1),
          which must be run separately.

          Let the first letter of the compiler name be O= 2, 6, 8, k,
          v, or x.  The output object files end in .O.  The letter is
          also the prefix of related programs: Oa is the assembler, Ol
          is the loader.  Associated with each compiler is a string
          objtype= 68020, 960, 386, sparc, mips, or 3210.  Plan 9 con-
          ventionally 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 preconditioning mk(1).

          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,

          -B        Accept functions without a new-style ANSI C func-
                    tion prototype.  By default, the compilers reject
                    functions used without a defined prototype,
                    although ANSI C permits them.

          -Dname    Define the name to the preprocessor, as if by
                    `#define'.  If no definition is given, the name is
                    defined as `1'.

     2C(1)                                                       2C(1)

          -Idir     An `#include' file whose name does not begin with
                    slash or is enclosed in double quotes is always
                    sought first in the directory of the file argu-
                    ment.  If this fails, or the name is enclosed in
                    <>, it is then sought in directories named in -I
                    options, then in /sys/include, and finally in

          -N        Suppress automatic registerization and optimiza-

          -S        Print an assembly language version of the object
                    code on standard output as well as generating the
                    .O file.

          -a        Instead of compiling, print on standard output
                    acid functions (see acid(1)) for examining struc-
                    tures declared in the source files.

          -aa       Like -a except suppress information about struc-
                    tures declared in included header files.

          The compilers support several extensions to ANSI C:

          -    A structure or union may contain unnamed substructures
               and subunions.  The fields of the substructures or sub-
               unions 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 pro-
               motes 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 variable>.<tagname>.

          -    A structure value can be formed with an expression such
                   (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 ele-
               ment by using the name following a period, as
                   int struct { int x; int y; } s = { .y 1, .x 5 };

     2C(1)                                                       2C(1)

               which initializes elements y and then x of the struc-
               ture s.

          -    A global variable can be dedicated to a register by
               declaring it extern register in all modules and

          -    A #pragma of the form
                   #pragma lib "libbio.a"
               records that the program needs to be loaded with file
               /$objtype/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 direc-
               tories, within the file names in the #pragmas the
               string $M represents the name of the architecture
               (e.g., mips) and $O represents its identifying charac-
               ter (e.g., v).

          -    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.  The
               vlong runtime is slow.

          For the 68020, produce a program prog from C files main.c
          and sub.c:

               2c -w main.c sub.c
               2l -o prog main.2 sub.2

          /sys/include       system area for machine-independent
                             #include directives.
          /$objtype/include  system area for machine-dependent
                             #include directives.

          /sys/src/cmd/cc        machine-independent part
          /sys/src/cmd/2c, etc.  machine-dependent part

          2a(1), 2l(1), cpp(1), mk(1), nm(1), pcc(1), db(1), acid(1),

          Rob Pike, ``How to Use the Plan 9 C Compiler''

          The i960 compiler has been used only to program one I/O con-
          troller and is certainly buggy.

          The preprocessor only handles `#define', `#include',

     2C(1)                                                       2C(1)

          `#undef', `#ifdef', `#line', and `#ifndef'.  For a full ANSI
          preprocessor, use cpp(1) on the files first.