


bcc(1)                                                     bcc(1)


NAME
       bcc - Bruce's C compiler

SYNOPSIS
       bcc  [-03EGNOPSVcegv]  [-Aas_option] [-Bexecutable_prefix]
       [-Ddefine]  [-Uundef]  [-Mc_mode]   [-o outfile]   [-ansi]
       [-Ccc1_option]  [-Iinclude_dir]  [-Lld_option]  [-Ttmpdir]
       [-Qc386_option] [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(1)  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

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



                            Jan, 1997                           1





bcc(1)                                                     bcc(1)


              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.

       -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

       -e     run the preprocess  pass  separately.   This  takes



                            Jan, 1997                           2





bcc(1)                                                     bcc(1)


              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)

       -t     error  (substitution  of   some   cc   passes   not
              supported)

       -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     allow the assembler to  generate  warnings,  useful
              for finding 80186+ instructions.

       Other options are passed to the linker, in particular -i-,
       -lx, -M, -m, -s, -H.  The -i option is  always  passed  to
       the linker but can be cancelled using -i-.


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

       -d     print debugging information in assembly output




                            Jan, 1997                           3





bcc(1)                                                     bcc(1)


       -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.




                            Jan, 1997                           4





bcc(1)                                                     bcc(1)


       __CALLER_SAVES__ 1
              compiler  calling  conventions  are  altered so the
              calling 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
       unprotoize(1), as86(1), ld86(1), elksemu(1)



                            Jan, 1997                           5





bcc(1)                                                     bcc(1)


BUGS
       The compiler cannot generate 8086 floating point code,  if
       it's  made  to try it produces a nasty mixture of 8086 and
       80386 code that really upsets the assembler.

       The bcc.c compiler driver source is very untidy.

       The linker, ld86, produces a broken a.out object  file  if
       given  one  input  and  the  -r  option  this  is so it is
       compatible with pre-dev86 versions.















































                            Jan, 1997                           6


