loadsomcofflib.c

VXWORKS源代码

/* loadSomCoffLib.c - HP-PA SOM COFF object module loader */

/* Copyright 1984-1994 Wind River Systems, Inc. */
#include "copyright_wrs.h"
/*
modification history
--------------------
02n,30nov98,dbt  no longer clear seg.flags<xxx> after loadSegmentAllocate()
                 call. (SPR #23553).
02m,05oct98,pcn  Initialize all the fields in the SEG_INFO structure.
02l,16sep98,pcn  Set to SEG_ALIGN the flags field in seg structure
                 (SPR #21836).
02k,19aug98,cym  Fixed SPR #22030: Target Loader won't load partially linked
		 objects.
02j,17jul98,pcn  Fixed SPR #21836: alignment mismatch between sections and
                 target.
02i,01apr97,jmb  propagated an arg_reloc patch from the target server loader.
02h,14nov96,mem  rewrote handling of branch stubs in order to fix some
		 link problems.  Stubs now have the arg_reloc bits of the
		 symbol they represent stored with them, rather than
		 the bits of the call they where originally created with.
02g,02aug96,jmb  merged in ease patch (mem) for sign_ext.
02f,19dec95,mem  fixed fieldValue() function which did not always use the
		 roundConst value.
		 Modified section placement for GNU.
		 Fixed B{1,2,3,4} macros which had multiple uses of
		 pThisFixup++ in a single expression, (which is
		 undefined behavior).
02e,14nov94,kdl  removed conditional for CPU==SIMHPPA.
02d,09nov94,ms   made R_UNINIT fixup act just like R_ZEROS fixup.
02c,07nov94,kdl  merge cleanup - made conditional for CPU==SIMHPPA.
02b,02aug94,ms   cleaned up the code a bit.
02a,07jul94,ms   too many bug fixes to count. Major rewrite.
                 Added "long branch stub" generation.
                 Added "parameter relocation stub" generation
                 Added "unwind" segment generation.
01g,03may94,ms   fixed the handling of R_PREV_FIXUP requests.
01f,02may94,ms   checked in yaos work. Added minor bug fix (bssFlag).
01e,18apr94,yao  added fileType paramater to rdSymtab().  changed to add
                 DATA_SEGMENT_BASE to symbol of data type for shared 
                 object files.
01d,28mar94,yao  changed to call lst operation routines in relSegments().
01c,28feb94,yao  added loadBssSizeGet () for relocatable files.  removed 
                 macro STORE(), added routine fixBits() to deposit relocation 
                 bits.  added fieldGetDefault(). added deassemble control 
                 functions de_assemble_X(). added fixup rounding functions 
                 X_fixup().
01c,02feb94,yao  included dsmLib.h.
01b,06dec93,gae  fixed warnings.
01a,12sep93,yao  written.
*/

/*
DESCRIPTION
This library provides an object module loading facility for the
HP-PA compiler environment.  Relocatable SOM COFF format files may be 
loaded into memory, relocated, their external references resolved, 
and their external definitions added to the system symbol table for use by 
other modules and from the shell.  Modules may be loaded from any I/O stream
which supports FIOSEEK.

EXAMPLE
.CS
    fdX = open ("/devX/objFile", O_RDONLY);
    loadModule (fdX, ALL_SYMBOLS);
    close (fdX);
.CE
This code fragment would load the HP-PA SOM file "objFile" located on
device "/devX/" into memory which would be allocated from the system
memory pool.  All external and static definitions from the file would be
added to the system symbol table.

This could also have been accomplished from the shell, by typing:
.CS
    -> ld (1) </devX/objFile
.CE

INCLUDE FILE: loadSomCoffLib.h

SEE ALSO: loadLib, usrLib, symLib, memLib,
.pG "Basic OS"
*/

/*
INTERNAL

The HP-PA SOM COFF linking loader is complicated as hell.
This is due to a combination of the fact that the PA-RISC
has a very un-RISC like instruction set, and that the
calling conventions have a strange parameter passing mechanism.
The following is an attempt to describe
some of the differences between this loader and other VxWorks
loaders.

Subspace to segment mapping
---------------------------
The current VxWorks paradigm assumes there are three "segments" -
text, data, and bss. The SOM COFF format instead uses the concept
of spaces and subspaces. There are two loadable spaces; text and data.
Each of these spaces is divided into many subspaces.
For example, each function is put in its own text subspace,
and each global variable is put in its own data subspace.

To fit the VxWorks paradigm we must map the subspaces into VxWorks segments.
The routine subspaceToSegment() performs this function by looping through
each subspace and deciding what segment to put it in. The array pSubInfo
is initialized with information on each subspace: It's loadType (text,
data, or bss), and it's loadAddr (we compute a relative load address for
each subspace - it's final load address won't be know until we
allocate memory for the text, data, and bss segments).

Uninitailized global (but non-static) variables are treated by the
compiler as "request for storage" (sometimes called "common data" or
"weak externals"). All VxWorks loaders simply add these variables
as bss, so we do likewise. The routine commSizeGet() computes the number
of bytes needed for these variables, and this size is added to the bss size.
This is more efficient than performing a malloc() for each variable,
as is done in other VxWorks loaders.

A "stack unwind" segment is also generated for the stack tracer to use.
See src/arch/simhppa/trcLib.c for details.

Long branch stubs
-----------------
When code is compiled with optimization, the compiler generates
a PC-relative "BL" (branch and link) instruction for all procedure calls.
The problem is that the displacement must fit into 19 bits, so if the
called procedure is further than 256k bytes away, we have no way to
fixup the instruction.

The solution is to generate a two instruction "long branch stub",
and make that stub the target of the "BL" instruction. It is our
responsibility to generate this stub, and to make sure that the stub
itself is close enough to the caller of "BL".

For each text subspace, the procedure subspaceSizeExtra() computes
the amount of space needed by that subspace for possible long branch stubs.
Thus when we map the text subspaces to the "text segment", we actually leave
a bit of room between each subspace according to the value of
subspaceSizeExtra() for that subspace.

Parameter relocation
--------------------
The PA-RISC passes the first four words of the parameter list in
registers, and the return value also goes in a register.
floating point parameters are passed in floating point registers,
and other parameters are passed in general purpose registers.
The problem is that the caller and the callee may not agree as
to where the parameters are located. For example, printf() expects
its parameters to be in the general purpose registers, whereas a call
like
   printf ("%f", myFloat)
passes the second parameter in a floating point register.
The compiler generates information on how a procedure expects
to be called, and on how it is actually called. It is our job to
make sure they match, and if they don't, to insert a "parameter
relocation stub" between the caller and the callee.

Parameter relocation information is encoded in 10 bits - 2 bits
each for the first four arguments words and the return value.
Each 2 bit quantity specifies "unused, general register, float
register, or double persion float register".

When a new function is loaded, the 10 bit relocation info generated
by the compiler must be stored away in the VxWorks symbol table for
future reference, In order to do this I had to
create a new structure called "MY_SYMBOL", which is just like
the VxWorks "SYMBOL", but has an extra 8 bit field at the end. It turns
out that the size of MY_SYMBOL is the same as the size of SYMBOL
because of compiler padding, so no harm was done. The functions
externSymResolve() and externSymAdd() perform VxWorks symbol
table manipulation with MY_SYMBOL stuctures.

When a function is called, the 10 parameter relocation bits
are encoded in the fixup request associated with the function call.
The routines rbits1() and rbits2() get the bits from the fixup request
(actually, the 10 bits are encoded in 9 or fewer bits in the fixup
request, so rbits1() and rbits2() do some work to extract the info
and decode it to 10 bits). We then compare the callers reclocation
bits with the callees and if they differ, we may ned to generate
a stub (if we hadn't previously generated a stub for that function).

Currently, this is only done if the callee expects general registers
and the caller passses a double - which takes care of functions
like printf, sprintf, etc. The loader prints an error message if
any other type of parameter reloction is needed. It would be easy to add
other parameter relocation stubs at a later time.

Fixup requests
--------------
The linking fixup requests are passed to us as a byte stream.
The number of bytes in each fixup request depends on the
fixup request, and there are 71 different types of fixup requests!
The routine linkSubspaces() performs the linker fixup requests, and
it is complicated as hell. The comments in that routine describe it further.
just to give you an idea of how complicated our friends at HP have made
things: The linker must keep a queue of the last four multi-byte
fixup requests. There is a one byte fixup requests called "repeat
previous fixup" which directs us to repeat one of the previous fixups
from the queue, and then move the fixup to the front of the queue!
Currently there are many branches in linkSubspaces() that have
not been tested.
*/

#include "vxWorks.h"
#include "stdio.h"
#include "som_coff.h"
#include "ioLib.h"
#include "dsmLib.h"
#include "fioLib.h"
#include "bootLoadLib.h"
#include "loadLib.h"
#include "loadSomCoffLib.h"
#include "memLib.h"
#include "pathLib.h"
#include "lstLib.h"
#include "string.h"
#include "symLib.h"
#include "sysSymTbl.h"
#include "errnoLib.h"
#include "stdlib.h"
#include "symbol.h"
#include "moduleLib.h"
#include "cacheLib.h"



#define LOAD_NONE   0
#define LOAD_TEXT   1
#define LOAD_DATA   2
#define LOAD_BSS    3

#define SEG_ALIGN  8

/* Some PA-RISC opCodes */

#define LDIL_CODE       0x08
#define ADDIL_CODE      0x0a
#define BL_CODE         0x3a
#define COMBT_CODE      0x20
#define COMBF_CODE      0x22
#define ADDB_CODE       0x28
#define ADDBF_CODE      0x2a
#define BB_CODE         0x31
#define LDW_CODE        0x12
#define LDH_CODE        0x11
#define LDB_CODE        0x10
#define STW_CODE        0x1a
#define STH_CODE        0x19
#define STB_CODE        0x18
#define LDWM_CODE       0x13
#define STWM_CODE       0x1b
#define LDO_CODE        0x0d
#define ADDI_CODE       0x2d
#define ADDIT_CODE      0x2c
#define SUBI_CODE       0x25
#define COMICKR_CODE    0x24
#define ADDIBT_CODE     0x29
#define ADDIBF_CODE     0x2b
#define COMIBT_CODE     0x21
#define COMIBF_CODE     0x23
#define BE_CODE         0x38
#define BLE_CODE        0x39

/* some handy macros for linkSubspaces() */

#define B1 (*(pThisFixup++))
#define B2 ((int)(pThisFixup += 2), \
    (int) ((pThisFixup[-2] << 8) + pThisFixup[-1]))
#define B3 ((int)(pThisFixup += 3), \
    (int) ((pThisFixup[-3] << 16) + (pThisFixup[-2] << 8) + pThisFixup[-1]))
#define B4 ((int)(pThisFixup += 4), \
    (int) ((pThisFixup[-4] << 24) + (pThisFixup[-3] << 16) \
           + (pThisFixup[-2] << 8) + pThisFixup[-1]))

#define REL_STACK_SIZE  (10000)   /* size of relocation stack pointer */
#define POP_EXPR        (*--sp)
#define PUSH_EXPR(x)    (*sp ++ = (x))
#define CHECK_STACK_OVER  if (sp >= pExpStack + REL_STACK_SIZE) \
                              { \
                              printErr ("ld error: stack overflow\n");\
                              status = ERROR; \
                              }
#define CHECK_STACK_UNDER if (sp <= pExpStack) \
                              { \
                              printErr ("ld error: stack underflow\n");\
                              status = ERROR; \
                              }
#define FLAG_RESET(flag)  if (flag) flag = FALSE;

/* subspace relocation info */

typedef struct
    {
    char * loadAddr;
    int loadType;
    } SUB_INFO;

/* "previous fixup" queue */

typedef struct
    {
    NODE node;
    UCHAR *pFixup;
    } PREV_FIXUP;

/* stack unwind structures */

typedef struct
    {
    char *startAddr;
    char *endAddr;
    UINT word3;
    UINT word4;
    } UNWIND_DESC;

typedef struct
    {
    NODE node;
    UNWIND_DESC unwindDesc;
    } UNWIND_NODE;

/* list of long branch stubs */

typedef struct stubListNode
    {
    NODE node;
    int symNum;
    int arg_reloc;
    } STUB_LIST_NODE;

/* list of argument relocation stubs */

typedef struct
    {
    NODE     node;
    SYMREC * pSym;
    int      arg_reloc;
    char *   stubAddr;
    } ARG_RELOC_NODE;

/* modified symbol table entry */

typedef struct                  /* MY_SYMBOL - entry in symbol table */
    {
    SL_NODE     nameHNode;      /* hash node (must come first) */
    char        *name;          /* pointer to symbol name */
    char        *value;         /* symbol value */
    UINT16      group;          /* symbol group */
    SYM_TYPE    type;           /* symbol type */
    UCHAR       arg_reloc;      /* relocation bits */
    } MY_SYMBOL;

/* local variables */

/* SPR 22030: changed entry for fixup 62 from 0 to 1 */

static int fixupLen [256] =
    {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 19 */
    1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 2, 4, 2, 4, 1, 2, 4, 2, /* 20 - 39 */
    4, 1, 2, 3, 5, 8, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, /* 40 - 59 */
    5, 5, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 5, 5, 0, 0, /* 60 - 79 */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 99 */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 0, 0, 0, 0, 0, 0, /* 100 - 119 */
    2, 4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 120 - 139 */
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 140 - 159 */
    2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 2, 4, 1, 9, /* 160 - 179 */
    6, 1, 1, 1, 1, 2, 4, 1, 1, 2, 3, 4, 1, 1, 1, 1, 1, 1, 1, 1, /* 180 - 199 */
    1, 1, 2, 3, 4, 5, 1,12, 2, 5, 6, 1, 1, 1, 1, 1, 0, 0, 0, 0, /* 200 - 219 */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 220 - 239 */
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0              /* 240 - 255 */
    };

static UINT longBranchStub[] =
        {
        0x20200000,     /* LDIL    0, r1 */
        0xe0202002      /* BE,n    0(s4, r1) */
        };

static stubSize = 8;

/* externals */

extern low_sign_ext (int x, int len);
extern sign_ext     (int x, int len);
extern assemble_21  (int x);
extern assemble_17  (int x, int y, int z);
extern assemble_12  (int x, int y);
extern sysMemTop    (void);

/* forward static functions */