cc man page on Xenix

Man page or keyword search:  
man Server   1130 pages
apropos Keyword Search (all sections)
Output format
Xenix logo
[printable version]



     CC(CP)		      XENIX System V			CC(CP)

     Name
	  cc - Invokes the C compiler.

     Syntax
	  cc [ option ... ] filename ...

     Description
	  cc is the XENIX C compiler command.  It creates executable
	  programs by compiling and linking the files named by the
	  filename arguments.  cc copies the resulting program to the
	  file a.out.

	  The filename can name any C or assembly language source file
	  or any object or library file.  C source files must have a
	  .c filename extension.  Assembly language source files must
	  have .s, object files .o, and library files .a extensions.
	  cc invokes the C compiler for each C source file and copies
	  the result to an object file whose basename is the same as
	  the source file but whose extension is .o.  cc invokes the
	  XENIX assembler, masm , for each assembly source file and
	  copies the result to an object file with extension .o.  cc
	  ignores object and library files until all source files have
	  been compiled or assembled. It then invokes the XENIX link
	  editor, ld , and combines all the object files it has
	  created together with object files and libraries given in
	  the command line to form a single program.

	  Files are processed in the order they are encountered in the
	  command line, so the order of files is important.  Library
	  files are examined only if functions referenced in previous
	  files have not yet been defined.  Library files must be in
	  ranlib(CP) format, that is, the first member must be named
	  __.SYMDEF, which is a dictionary for the library.  Only
	  those functions that define unresolved references are
	  concatenated.	 A number of ``standard'' libraries are
	  searched automatically.  These libraries support the
	  standard C library functions and program startup routines.
	  Which libraries are used depends on the program's memory
	  model (see ``Memory Models'' below).	The entry point of the
	  resulting program is set to the beginning of the standard
	  startup code which then calls the ``main()'' function of the
	  program.

	  There are the following options:

	  -c
	       Creates a linkable object file for each source file but
	       does not link these files.  No executable program is
	       created.

	  -C   Preserves comments when preprocessing a file with -E ,
	       -P , or -EP.  That is, comments are not removed from

     Page 1					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       the preprocessed source.	 This option may only be used
	       in conjunction with -E , -P , or -EP.

	  -compat
	       Makes an executable file that is binary compatible
	       across the following systems (as distributed by certain
	       vendors):

	       -286 System V
	       -386 System V
	       -286 3.0
	       -8086 System V

	  -CSON,  -CSOFF
	       When optimization (-O) is also specified, these options
	       enable or disable ``common sub-expression''
	       optimization.  The default is disabled for the small
	       model passes and enabled for the large (with -LARGE).

	  -d   Displays the various passes and their arguments before
	       they are executed.

	  -Dname[=string ]
	       Defines name to the preprocessor as if defined by
	       #define in each source file.  The form ``-Dname'' sets
	       name to 1.  The form ``-Dname=string'' sets name to the
	       given string.

	  -dos Directs cc to create an executable program for MS-DOS
	       systems.

	  -E   Preprocesses each source file as described for -P, but
	       copies the result to the standard output. The option
	       also places a #line directive with the current input
	       line number and source file name at the beginning of
	       output for each file.

	  -EP  Preprocesses each source file as described for -E, but
	       does not place a #line directive at the beginning of
	       the file.

	  -F num
	       Sets the size of the program stack to num bytes.	 The
	       value of num must be given in hexadecimal.  The default
	       stack for the 8086 is variable, starting at the top of
	       a full 64 Kbyte data segment that grows down until it
	       reaches data.  The default stack for the 80286 is 1000
	       bytes (hexadecimal).  This option does not apply to the
	       80386, which has a variable stack.

	  -Fa, -Faname
	       Create an assembly source listing in source.s or the

     Page 2					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       named file.  Continues with the link if requested.

	  -Fc, -Fcname
	       Create a merged assembler and C listing in source.L or
	       in the named file.

	  -Fename
	       Names the executable program file name.

	  -Fl, -Flname
	       Create a listing file in source.L (or the named file)
	       with assembly source and object code.  Continues with
	       the link if requested.

	  -Fm, -Fmname
	       Instruct the linker to create a map listing in a file
	       called a.map (or the named file).  This file contains
	       the names of all segments in order of their appearance
	       in the load module.

	  -Foname
	       The object filename will be name instead of source.o.

	  -FPa, -FPc, -FPc87, -FPi, -FPi87
	       When used in conjunction with -dos these options
	       control the type of floating point code generated and
	       which library support to use.  The default is -FPi.
	       For more information see Appendix A, of the C Library
	       Guide .

	  -Fs, -Fsname
	       Creates a C source listing in source.S or the named
	       file.

	  -g
	       Includes information for the symbolic debugger. (This
	       is equivalent to the -Zi option.)

	  -i
	       Creates separate instruction and data spaces for small
	       model programs. When the output file is executed, the
	       program text and data areas are allocated separate
	       physical segments.  The text portion will be read-only
	       and may be shared by all users executing the file.
	       This option is implied when creating middle or large
	       model programs.	(Not implemented on all machines.)

	  -I pathname
	       Adds pathname to the list of directories to be searched
	       when an #include file is not found in the directory
	       containing the current source file or whenever angle
	       brackets (< >) enclose the filename.  If the file

     Page 3					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       cannot be found in directories in this list,
	       directories in a standard list are searched.

	  -K   Removes stack probes from a program. Stack probes are
	       used to detect stack overflow on entry to program
	       routines.  Code
	       generated for the 80386 processor does not require
	       stack probes, therefore this option has no effect if
	       -M3 is specified.

	  -lname
	       Searches library name for unresolved function
	       references.

	  -L   Creates an assembler listing file containing assembled
	       code and assembly source instructions.  The listing is
	       made in a file whose basename is the same as the source
	       but whose extension is .L.  This option suppresses the
	       -S option.

	  -LARGE
	       Invokes the large model passes of the compiler
	       (executable on 286 and 386 processors only).  Using
	       large model passes is advised when ``Out of heap
	       space'' errors are encountered.

	  -M string
	       Sets the program configuration.	This configuration
	       defines the program's memory model, word order, and
	       data threshold.	It also enables C language
	       enhancements such as advanced instruction set and
	       keywords. The string may be any combination of the
	       following (``s'', ``m'', ``l'', and ``h'' are mutually
	       exclusive):

	       s    Creates a small model program (default).
	       m    Creates a middle model program.
	       l    Creates a large model program.
	       h    Creates a huge model program.
	       e    Enables the far, near, huge, pascal, and fortran
		    keywords.  Also enables certain non-ANSI
	       entensions
		    necessary to ensure compatibility with existing
		    versions of the C compiler (applies only to
	       versions
		    of the C compiler that support ANSI C).
	       0    Enables 8086 code generation for compiled C source
		    files. Default is 8086 code generation.
	       1    Enables 186 code generation for compiled C source
		    files.
	       2    Enables 286 code generation for compiled C source
		    files.

     Page 4					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       3    Enables 386 code generation for compiled C source
		    files (80386 processors only).
	       b    Reverses the word order for long types.  High
	       order
		    word is first.  Default is low order word first.
	       tnum    Causes all data items greater than num bytes
		    to be allocated to a new data segment. Num,
		    the	 data threshold, defaults to 32,767. This
	       option
		    can only be used in large model 8086/80286
	       programs
		    (Ml0 or Ml2).
	       d    Instructs the compiler to not assume SS=DS.
		    Warning: This option has no practical use on
	       XENIX.
		    It will not cause the stack to be put in a
	       separate
		    segment. It may be used for DOS cross development.

	  -n   Sets pure text model. This option is equivalent to the
	       -i option. Gives a warning that it is setting -i when
	       used.

	  -ND name
	       Sets the data segment name for each compiled or
	       assembled source file to name. If -ND is not given, the
	       name ``_DATA'' is used.

	       In large model programs (-Ml) the -ND option can only
	       be used on "leaf modules" - those that make no calls to
	       routines in another segment.

	  -nl num
	       Sets the maximum length of external symbols to num.
	       Names longer than num are truncated before being copied
	       to the external symbol table.

	  -NM name
	       Sets the module name for each compiled or assembled
	       source file to name. If not given, the filename of each
	       source file is used.

	  -NT name
	       Sets the text segment name for each compiled or
	       assembled source file to name. If not given, the name
	       ``module_TEXT'' is used for middle model and ``_TEXT''
	       for small model programs.  This option should not be
	       used on 386 code.

	  -o filename
	       Defines filename to be the name of the final executable

     Page 5					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       program.	 This option overrides the default name a.out.
	       Filename can not end in .o or .c.

	  -O string
	       Invokes the object code optimizer. The string consists
	       of one or more of the following characters:
	       d    Default. Disables optimization
	       a    Relaxes alias checking
	       s    Optimizes code for space
	       t    Default. Optimizes code for speed. Equivalent to
	       -O
	       x    Performs maximum optimization. Equivalent to
	       -Oactl
	       c    Eliminates common expressions
	       l    Performs various loop optimizations.

	  -p
	       Adds code for program profiling.	 Profiling code counts
	       the number of calls to each routine in the program and
	       copies this information to the mon.out file.  This file
	       can be examined using the prof(CP) command.

	  -P
	       Preprocesses each source file and copies the result to
	       a file whose basename is the same as the source but
	       whose extension is .i.

	  -pack
	       Packs structures.  Each structure member is stored at
	       the first available byte, without regard to int
	       boundaries.  Although this will save space, execution
	       will be slower because of the extra time required to
	       access 16 bit members that begin on odd boundaries.

	  -r   Invokes the incremental linker, /lib/ldr , for the link
	       step.

	  -s   Instructs the linker to strip the symbol table
	       information from the executable output file.

	  -S
	       Creates an assembly source listing in a file whose
	       basename is the same as the source but whose extension
	       is .s.  It should be noted that this file is not
	       suitable for assembly.  This option provides code for
	       reading only.

	  -SEG num
	       Sets the maximum number of segments that the linker can
	       handle to num, which can range from 1 to 1024.  If 1024
	       is too small, use the -NT option to reduce the number

     Page 6					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	       of different segment names.

	  -u   Eliminates all manifest defines.	 Also see -U.

	  -U definition
	       Removes or undefines the given manifest define.	The
	       manifest defines are as follows:

	       M_I86
	       M_XENIX
	       M_SYS3 or M_SYSIII
	       M_SYS5 or M_SYSV
	       M_BITFIELDS
	       M_WORDSWAP
	       M_SDATA or M_LDATA
	       M_STEXT or M_LTEXT
	       M_I8086 or M_I186 or M_I286 or M_I386
	       M_I86SM or M_I86MM or M_I86LM

	  -V string
	       Copies string to the object file created from the given
	       source file.  This option can be used for version
	       control.

	  -w   Prevents compiler warning messages from being issued.
	       Same as ``-W 0''.

	  -W num
	       Sets the output level for compiler warning messages.
	       If num is 0, no warning messages are issued.  If 1,
	       only warnings about program structure and overt type
	       mismatches are issued. If 2, warnings about strong
	       typing mismatches are issued. If 3, warnings for all
	       automatic conversions are issued.  This option does not
	       affect compiler error message output.

	  -X   Removes the standard directories from the list of
	       directories to be searched for #include files.

	  -z   Displays the various passes and their arguments but
	       does not execute them.

	  -Zp1, -Zp2, -Zp4
	       Aligns data structures on one, two or four-byte
	       boundaries (80386 only).

	  -Zi  Includes information used by the symbolic debugger
	       (sdb) in the output file.  (This is equivalent to the
	       -g option.)

	  Many options (or equivalent forms of these options) are
	  passed to the link editor as the last phase of compilation.

     Page 7					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	  The -M option with the ``s'', ``m'', and ``l'' configuration
	  options are passed to specify memory requirements.  The -i,
	  -F, and -p are passed to specify other characteristics of
	  the final program.

	  The -D and -I options may be used several times on the
	  command line.	 The -D option must not define the same name
	  twice.  These options affect subsequent source files only.

     Memory Models
	  cc can create programs for four different memory models:
	  small, middle, large, and huge.  In addition, small model
	  programs can be pure or impure.  On the 8086 and 80286
	  processors, these various segmentation models allow programs
	  with code or data larger than 64K bytes.  Since the 80386
	  can address segments larger than 64K bytes, the middle,
	  large and huge models are not supported on the 80386.

	  Impure-Text Small Model
	       These programs occupy one 64K byte physical segment in
	       which both text and data are combined.  cc creates
	       impure small model programs by default.	They can also
	       be created using the -Ms option.

	  Pure-Text Small Model
	       These programs occupy two 64K byte physical segments.
	       Text and data are in separate segments. The text is
	       read-only and may be shared by several processes at
	       once.   The maximum program size is 128 Kbytes.	Pure
	       small model programs are created using the -i and -Ms
	       options.

	  Middle Model
	       These programs occupy several physical segments, but
	       only one segment contains data.	Text is divided among
	       as many segments as required.  Special calls and
	       returns are used to access functions in other segments.
	       Text can be any size. Data must not exceed 64K bytes.
	       Middle models programs are created using the -Mm
	       option.	These programs are always pure.

	  Large Model
	       These programs occupy several physical segments with
	       both text and data in as many segments as required.
	       Special calls and returns are used to access functions
	       in other segments.  Special addresses are used to
	       access data in other segments.  Text and data may be
	       any size, but no data item may be larger than 64K
	       bytes.  Large model programs are created using the -Ml
	       option.	These programs are always pure.

     Page 8					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	  Huge Model
	       These programs occupy several physical segments with
	       both text and data in as many segments as required. It
	       is possible to allow a data construct that spans 64K
	       byte segments. This implementation imposes limits on
	       the way the data construct is put together and where it
	       is located in memory.  Huge model programs are created
	       using the -Mh option.  These programs are always pure.

	    Small, middle, large and huge model object files can only
	    be linked with object and library files of the same model.
	    It is not possible to combine small, medium, large, and
	    huge model object files in one executable program.	cc
	    automatically selects the correct small, middle, large, or
	    huge versions of the standard libraries based on the
	    configuration option.  It is up to users to make sure that
	    all of their own object files and private libraries are
	    properly compiled in the appropriate model.

	    The special calls and returns used in middle, large, and
	    huge model programs may affect execution time.  In
	    particular, the execution time of a program which makes
	    heavy use of functions and function pointers may differ
	    noticably from small model programs.

	    In middle, large, and huge model programs, function
	    pointers are 32 bits long.	 In large and huge model
	    programs, data pointers are 32 bits long.  Programs making
	    use of such pointers must be written carefully to avoid
	    incorrect declaration and use of these variables.

	    The -NM, -NT, and -ND options may be used with middle,
	    large, and huge model programs to direct the text and data
	    of specific object files to named physical segments.  All
	    text having the same text segment name is placed in a
	    single physical segment.  Similarly, all data having the
	    same data segment name is placed in a single physical
	    segment.

	  cc reads /etc/default/cc to obtain information about default
	  options and libraries. The default file may contain lines
	  beginning with the following patterns:

	       FLAGS=
	  and
	       LIBS=

	  Any parameters following the FLAGS= pattern are treated by
	  cc as if they had been specified at the start of the cc
	  command line. Parameters following the LIBS= pattern are
	  treated as if they had been specified at the end of the
	  command line. This option is intended for, but not

     Page 9					      (printed 8/7/87)

     CC(CP)		      XENIX System V			CC(CP)

	  restricted to, the specification of additional libraries.
	  cc always searches for a file in /etc/default that matches
	  the last component of the pathname by which cc was invoked.
	  Thus by linking cc to several different names and invoking
	  it by those names, different defaults can be selected.

	  An example /etc/default/cc file follows:

	  FLAGS= -LARGE -M2e

	  LIBS= -lx

	  This invokes the large model versions of the compiler passes
	  to generate 286 code with far and near keywords enabled, and
	  includes libx.a on all links.

     Files
	  /bin/cc		   Driver
	  /lib/p0, p1, p2, p3	   Small model passes
	  /lib/p1L, p2L, p3L	   Large model passes
	  /lib/*.a		   Standard libraries
	  /etc/default/cc		Default options and libraries

     See Also
	  ar(CP), ld(CP), lint(CP), machine(M), masm(CP), ranlib(CP)
	  XENIX C User's Guide, C Library Guide, and C Language
	  Reference

     Notes
	  Error messages are produced by the program that detects the
	  error.  These messages are usually produced by the C
	  compiler, but may occasionally be produced by the assembler
	  or the link loader.

	  All object module libraries must have a current ranlib
	  directory. The user must make sure that the most recent
	  library versions have been processed with ranlib(CP) before
	  linking.  If this is not done, ld cannot create executable
	  programs using these libraries.

     Page 10					      (printed 8/7/87)

[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Xenix

List of man pages available for Xenix

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net