


bcc(1)                                                     bcc(1)


NAME
     bcc - Bruce's C compiler

SYNOPSIS
     bcc [-03EGNOPSVcegvwxW] [-Aas_option]  [-Bexecutable_prefix]
     [-Ddefine]   [-Uundef]   [-Mc_mode]   [-o outfile]   [-ansi]
     [-Ccc1_option]  [-Iinclude_dir]   [-Lld_option]   [-Ttmpdir]
     [-Qc386_option] [-ttext_segno] [ld_options] [infiles]

DESCRIPTION
     Bcc is a simple C compiler that produces 8086 assembler,  in
     addition  compiler  compile time options allow 80386 or 6809
     versions.  The compiler understands traditional K&R  C  with
     just  the  restriction  that bit fields are mapped to one of
     the other integer types.

     The default operation  is  to  produce  an  8086  executable
     called a.out from the source file.

OPTIONS

     -ansi
          Pass   the   C   source   through   unprotoize    after
          preprocessing  and  before  code generation.  This will
          allow some ansi C to be compiled but  it  is  definitly
          NOT a true ansi-C compiler.

     -0   8086 target (works on 80386 host, but not 6809)

     -3   80386 target (may work on 8086 host, but not 6809)

     -A   pass  remainder  of  option  to  assembler  (e.g.  -A-l
          -Alistfile for a listing)

     -B   prefix for executable search path (as usual; the search
          order  is  all paths specified using -B, in order, then
          the   path   given   in   the   environment    variable
          BCC_EXEC_PREFIX  if  that  is set, then the compiled-in
          defaults  (something  like  /usr/lib/bcc/  followed  by
          /usr/bin/)

     -C   pass   remainder   of   option  to  bcc-cc1,  see  code
          generation options.

     -D   preprocessor define

     -E   produce preprocessor output to standard out.

     -G   produce GCC objects (only useful for i386 code)

     -Ixyz
          include search 'xyz' path

     -I   don't add default include to search list



                            Nov, 1997                           1





bcc(1)                                                     bcc(1)


     -Lxyz
          add  directory  name  'xyz'  to the head of the list of
          library directories searched

     -L   don't add default library to search list

     -Md  alters the arguments for all passes  to  produce  MSDOS
          executable   COM   files.    These   are   small  model
          executables, use -i to get tiny model.

     -Mf  sets bcc to pass the -c and -f arguments  to  the  code
          generator  for  smaller faster code.  Note this code is
          not compatible with the standard calling conventions so
          a different version of the C library is linked too.

     -Mc  sets  bcc to pass the -c argument to the code generator
          for smaller faster code.  Note  the  standard  libc  is
          normally transparent to this, but there are exceptions.

     -Ms  alters   the  arguments  for  all  passes  and  selects
          C-library to produce standalone Linux-86 executables

     -Ml  switches to  i386-Linux  code  generator  and  library.
          This  configuration  accepts  the  -z  flag to generate
          QMAGIC a.out files instead of the normal OMAGIC.

     -N   makes the linker produce a  native  a.out  file  (Linux
          OMAGIC)  if  combined  with  -3 the executable will run
          under Linux-i386.

     -O   optimize,  call  copt(1)   to   optimize   8086   code.
          Specifiers to choose which rules copt should use can be
          appended to the -O and the option can be repeated.

     -P   produce preprocessor output with  no  line  numbers  to
          standard output.

     -Q   pass full option to c386 (Only for c386 version)

     -S   produce assembler file

     -T   temporary   directory  (overrides  previous  value  and
          default;  default  is  from  the  environment  variable
          TMPDIR if that is set, otherwise /tmp)

     -U   preprocessor undefine

     -V   print names of files being compiled

     -X   pass  remainder  of option to linker (e.g.  -X-Ofile is
          passed to the linker as -Ofile)

     -c   produce object file




                            Nov, 1997                           2





bcc(1)                                                     bcc(1)


     -e   run the preprocess pass separately.   This  takes  less
          memory, and may help or harm by giving more traditional
          semantics like token pasting with /**/.

     -f   error (float emulation not supported)

     -g   produce debugging info (does nothing)

     -o   output  file  name  follows   (assembler,   object   or
          executable) (as usual)

     -p   error (profiling not supported)

     -t1  pass  to the assembler to renumber the text segment for
          multi-segment programs.

     -v   print names and args of subprocesses being run.  Two or
          more  -v's  print names of files being unlinked.  Three
          or more -v's print names of paths being searched.

     -w   Supress any warning diagnostics.

     -W   Turn on assembler warning messages.

     -x   don't include crt0.o in the link.

     -i   don't pass -i to the linker so that it will  create  an
          impure executable.

     Other  options  are passed to the linker, in particular -lx,
     -M, -m, -s, -H.

CODE GENERATOR OPTIONS
     These  are  all options that the code generator pass bcc-cc1
     understands, only some will be useful for the -C  option  of
     bcc.   The  code  generator is normally used as a combined C
     preprocessor and generator but the -e and -ansi  options  of
     bcc split the operation.

     -0   8086 target (works even on 80386 host, not on 6809)

     -3   80386 target (may work even on 8086 host, not on 6809)

     -D   define (as usual)

     -E   produce preprocessor output (as usual)

     -I   include search path (as usual)

     -P   produce  preprocessor  output  with no line numbers (as
          usual)

     -c   produce code with caller saving  regs  before  function
          calls



                            Nov, 1997                           3





bcc(1)                                                     bcc(1)


     -d   print debugging information in assembly output

     -f   produce code with 1st argument  passed  in  a  register
          (AX, EAX or X)

     -l   produce code for 2 3 1 0 long byte order (only works in
          16-bit code), a  special  library  of  compiler  helper
          functions is needed for this mode.

     -o   assembler output file name follows

     -p   produce  (almost)  position-independent  code (only for
          the 6809)

     -t   print source code in assembly output

     -w   print what  cc1  thinks  is  the  location  counter  in
          assembly output

     All  the  options  except -D, -I and -o may be turned off by
     following the option letter by a '-'.  Options are processed
     left to right so the last setting has precedence.

PREPROCESSOR DEFINES
     The preprocessor has a number of manifest constants.

     __BCC__ 1
          The   compiler   identifier,  normally  used  to  avoid
          compiler limitations.

     __FILE__
          stringized name of current input file

     __LINE__
          current line number

     __MSDOS__ 1
          compiler  is configured for generating MSDOS executable
          COM files.

     __STANDALONE__ 1
          compiler   is   configured  for  generating  standalone
          executables.

     __AS386_16__ 1
          compiler  is  generating  16 bit 8086 assembler and the
          #asm keyword is available for including 8086 code.

     __AS386_32__ 1
          compiler  is  generating 32 bit 80386 assembler and the
          #asm keyword is available for including 80386 code.

     __CALLER_SAVES__ 1
          compiler calling conventions are altered so the calling



                            Nov, 1997                           4





bcc(1)                                                     bcc(1)


          function must save the SI and DI registers if they  are
          in use (ESI and EDI on the 80386)

     __FIRST_ARG_IN_AX__ 1
          compiler calling conventions are altered so the calling
          function  is passing the first argument to the function
          in the AX (or EAX ) register.

     __LONG_BIG_ENDIAN__ 1
          alters  the  word  order  of code generated by the 8086
          compiler.

     These  defines  only  occur  in  the  6809  version  of  the
     compiler.

     __AS09__ 1
          compiler is generating 6809 code

     __FIRST_ARG_IN_X__ 1
          the  first  argument  to  functions  is passed in the X
          register.

     __POS_INDEPENDENT__ 1
          the code generated is (almost) position independent.

ENVIRONMENT

     BCC_EXEC_PREFIX
          default directory to seach for compiler passes

     TMPDIR
          directory to place temporary files (default /tmp)

DIRECTORIES
     All the include, library and compiler components are  stored
     under  the /usr/bcc directory under Linux-i386, this is laid
     out the same as a /usr filesystem and if bcc is  to  be  the
     primary  compiler on a system it should be moved there.  The
     configuration for this is in the bcc.c source file only, all
     other executables are independent of location.

     The    library    installation   also   creates   the   file
     /usr/lib/liberror.txt, this path is  hardcoded  into  the  C
     library.

     The bcc executable itself, as86 and ld86 are in /usr/bin.

SEE ALSO
     as86(1), ld86(1), elksemu(1)

BUGS
     The bcc.c compiler driver source is very untidy.

     The  linker,  ld86,  produces  a broken a.out object file if



                            Nov, 1997                           5





bcc(1)                                                     bcc(1)


     given one  input  and  the  -r  option  this  is  so  it  is
     compatible with pre-dev86 versions.























































                            Nov, 1997                           6


