


      LD(1)                       (bsd 4.2)                       LD(1)



      NAME
           ld - link editor

      SYNTAX
           ld [ option ] ... file ...

      DESCRIPTION
           Ld combines several object programs into one, resolves
           external references, and searches libraries.  In the
           simplest case, several object files are given, and ld
           combines them into an executable object module called a.out.
           If no errors occur during the load, the execute permission
           for a.out is set.

           The argument routines are concatenated in the order
           specified.  The entry point of the output is the beginning
           of the first routine (unless the -e option is specified).

           If any argument is a library, it is searched exactly once at
           the point it is encountered in the argument list.  Only
           those routines defining an unresolved external reference are
           loaded.  If a routine from a library references another
           routine in the library, and the library has not been
           processed by ranlib(1), the referenced routine must appear
           after the referencing routine in the library.  Thus the
           order of programs within libraries may be important.  The
           first member of a library should be a file named
           `__.SYMDEF', which is understood to be a dictionary for the
           library as produced by ranlib(1); the dictionary is searched
           iteratively to satisfy as many references as possible.

           The symbols `_etext', `_edata' and `_end' (`etext', `edata'
           and `end' in C) are reserved, and if referred to, are set to
           the first location above the program, the first location
           above initialized data, and the first location above all
           data respectively.  Do not define these symbols.

           Ld understands several options.  Except for -l, they should
           appear before the file names.

           -A   This option specifies incremental loading, i.e.
                linking is to be done in a manner so that the resulting
                object may be read into an already executing program.
                The next argument is the name of a file whose symbol
                table will be taken as a basis on which to define
                additional symbols.  Only newly linked material will be
                entered into the text and data portions of a.out, but
                the new symbol table will reflect every symbol defined
                before and after the incremental load.  This argument
                must appear before any other object file in the
                argument list.  The -T option may be used as well, and
                will be taken to mean that the newly linked segment



      Page 1                                          (73 A2 02MT REV1)






      LD(1)                       (bsd 4.2)                       LD(1)



                will commence at the corresponding address (which must
                be a multiple of 4096).  The default value is the old
                value of _end.

           -C   Produce an executable file with  shared code and data.
                The data segment is put at the first page boundary past
                the end of the code segment.  The output file is given
                the magic number 9B01, which signals exec(2) (or
                spawn(2)) to cause the code and data segments to be
                mapped to the same address space.

           -Ddorg
                Set the data segment origin to dorg, which is
                hexadecimal.  The default origin is 0.

           -d   Force definition of common storage even if the -r flag
                is present.

           -e   The following argument is taken to be the name of the
                entry point of the loaded program; location 0 is the
                default.

           -lx  This option is an abbreviation for the library name
                `/lib/libx.a', where x is a string.  If that does not
                exist, ld tries `/usr/lib/libx.a' A library is searched
                when its name is encountered, so the placement of a -l
                is significant.

           -M   produce a primitive load map, listing the names of the
                files which will be loaded.

























      Page 2                                          (73 A2 02MT REV1)






      LD(1)                       (bsd 4.2)                       LD(1)



           -m mapfile
                create a load map called mapfile (as described in
                map(1)).

           -N   Do not make the text portion read only or sharable.
                (Use "magic number" 0407.)

           -o   The name argument after -o is used as the name of the
                ld output file, instead of a.out.

           -r   Generate relocation bits in the output file so that it
                can be the subject of another ld run.  This flag also
                prevents final definitions from being given to common
                symbols, and suppresses the `undefined symbol'
                diagnostics.

           -S   `Strip' the output by removing all symbols except
                locals and globals.

           -s   Strip the output of the symbol table and relocation
                bits to save space (but impair the usefulness of the
                debuggers).  This information can be removed with
                strip(1).

           -T   The next argument is a hexadecimal number which sets
                the text segment origin.  The default origin is the
                size of the a.out header (see a.out(4)).

           -t   ("trace")  Print the name of each file as it is
                processed.

           -u   Take the following argument as a symbol and enter it as
                undefined in the symbol table.  This is useful for
                loading wholly from a library, since initially the
                symbol table is empty and an unresolved reference is
                needed to force the loading of the first routine.

           -Vhexarg
                Set the a_version field of the header to hexarg, which
                is hexadecimal.

           -Whexarg
                Set the a_type field of the header to hexarg, which is
                hexadecimal.

           -X   Save local symbols except for those whose names begin
                with `L'.  This option is used by rc(1) to discard
                internally-generated labels while retaining symbols
                local to routines.

           -x   Do not preserve local (non-global) symbols in the
                output symbol table; only enter external symbols.  This



      Page 3                                          (73 A2 02MT REV1)






      LD(1)                       (bsd 4.2)                       LD(1)



                option saves some space in the output file.

           -ysym
                Indicate each file in which sym appears, its type and
                whether the file defines or references it.  Many such
                options may be given to trace many symbols.  (It is
                usually necessary to begin sym with an `_' because
                external C and FORTRAN variables begin with
                underscores.)

      FILES
           /lib/lib*.a            libraries
           /usr/lib/lib*.a        more libraries
           /usr/local/lib/lib*.a  still more libraries
           a.out                  output file

      SEE ALSO
           as(1), ar(1), rc(1), ranlib(1), map(1)

      BUGS
           There is no way to force data to be page-aligned.


































      Page 4                                          (73 A2 02MT REV1)



