开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
loadSomCoffLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：116k
源码类别：

VxWorks

开发平台：

C/C++

loadSomCoffLib.c：源码内容
  1. /* loadSomCoffLib.c - HP-PA SOM COFF object module loader */
  3. /* Copyright 1984-1994 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  5. /*
  6. modification history
  7. --------------------
  8. 02n,30nov98,dbt  no longer clear seg.flags<xxx> after loadSegmentAllocate()
  9.                  call. (SPR #23553).
  10. 02m,05oct98,pcn  Initialize all the fields in the SEG_INFO structure.
  11. 02l,16sep98,pcn  Set to SEG_ALIGN the flags field in seg structure
  12.                  (SPR #21836).
  13. 02k,19aug98,cym  Fixed SPR #22030: Target Loader won't load partially linked
  14.  objects.
  15. 02j,17jul98,pcn  Fixed SPR #21836: alignment mismatch between sections and
  16.                  target.
  17. 02i,01apr97,jmb  propagated an arg_reloc patch from the target server loader.
  18. 02h,14nov96,mem  rewrote handling of branch stubs in order to fix some
  19.  link problems.  Stubs now have the arg_reloc bits of the
  20.  symbol they represent stored with them, rather than
  21.  the bits of the call they where originally created with.
  22. 02g,02aug96,jmb  merged in ease patch (mem) for sign_ext.
  23. 02f,19dec95,mem  fixed fieldValue() function which did not always use the
  24.  roundConst value.
  25.  Modified section placement for GNU.
  26.  Fixed B{1,2,3,4} macros which had multiple uses of
  27.  pThisFixup++ in a single expression, (which is
  28.  undefined behavior).
  29. 02e,14nov94,kdl  removed conditional for CPU==SIMHPPA.
  30. 02d,09nov94,ms   made R_UNINIT fixup act just like R_ZEROS fixup.
  31. 02c,07nov94,kdl  merge cleanup - made conditional for CPU==SIMHPPA.
  32. 02b,02aug94,ms   cleaned up the code a bit.
  33. 02a,07jul94,ms   too many bug fixes to count. Major rewrite.
  34.                  Added "long branch stub" generation.
  35.                  Added "parameter relocation stub" generation
  36.                  Added "unwind" segment generation.
  37. 01g,03may94,ms   fixed the handling of R_PREV_FIXUP requests.
  38. 01f,02may94,ms   checked in yaos work. Added minor bug fix (bssFlag).
  39. 01e,18apr94,yao  added fileType paramater to rdSymtab().  changed to add
  40.                  DATA_SEGMENT_BASE to symbol of data type for shared 
  41.                  object files.
  42. 01d,28mar94,yao  changed to call lst operation routines in relSegments().
  43. 01c,28feb94,yao  added loadBssSizeGet () for relocatable files.  removed 
  44.                  macro STORE(), added routine fixBits() to deposit relocation 
  45.                  bits.  added fieldGetDefault(). added deassemble control 
  46.                  functions de_assemble_X(). added fixup rounding functions 
  47.                  X_fixup().
  48. 01c,02feb94,yao  included dsmLib.h.
  49. 01b,06dec93,gae  fixed warnings.
  50. 01a,12sep93,yao  written.
  51. */
  53. /*
  54. DESCRIPTION
  55. This library provides an object module loading facility for the
  56. HP-PA compiler environment.  Relocatable SOM COFF format files may be 
  57. loaded into memory, relocated, their external references resolved, 
  58. and their external definitions added to the system symbol table for use by 
  59. other modules and from the shell.  Modules may be loaded from any I/O stream
  60. which supports FIOSEEK.
  62. EXAMPLE
  63. .CS
  64.     fdX = open ("/devX/objFile", O_RDONLY);
  65.     loadModule (fdX, ALL_SYMBOLS);
  66.     close (fdX);
  67. .CE
  68. This code fragment would load the HP-PA SOM file "objFile" located on
  69. device "/devX/" into memory which would be allocated from the system
  70. memory pool.  All external and static definitions from the file would be
  71. added to the system symbol table.
  73. This could also have been accomplished from the shell, by typing:
  74. .CS
  75.     -> ld (1) </devX/objFile
  76. .CE
  78. INCLUDE FILE: loadSomCoffLib.h
  80. SEE ALSO: loadLib, usrLib, symLib, memLib,
  81. .pG "Basic OS"
  82. */
  84. /*
  85. INTERNAL
  87. The HP-PA SOM COFF linking loader is complicated as hell.
  88. This is due to a combination of the fact that the PA-RISC
  89. has a very un-RISC like instruction set, and that the
  90. calling conventions have a strange parameter passing mechanism.
  91. The following is an attempt to describe
  92. some of the differences between this loader and other VxWorks
  93. loaders.
  95. Subspace to segment mapping
  96. ---------------------------
  97. The current VxWorks paradigm assumes there are three "segments" -
  98. text, data, and bss. The SOM COFF format instead uses the concept
  99. of spaces and subspaces. There are two loadable spaces; text and data.
  100. Each of these spaces is divided into many subspaces.
  101. For example, each function is put in its own text subspace,
  102. and each global variable is put in its own data subspace.
  104. To fit the VxWorks paradigm we must map the subspaces into VxWorks segments.
  105. The routine subspaceToSegment() performs this function by looping through
  106. each subspace and deciding what segment to put it in. The array pSubInfo
  107. is initialized with information on each subspace: It's loadType (text,
  108. data, or bss), and it's loadAddr (we compute a relative load address for
  109. each subspace - it's final load address won't be know until we
  110. allocate memory for the text, data, and bss segments).
  112. Uninitailized global (but non-static) variables are treated by the
  113. compiler as "request for storage" (sometimes called "common data" or
  114. "weak externals"). All VxWorks loaders simply add these variables
  115. as bss, so we do likewise. The routine commSizeGet() computes the number
  116. of bytes needed for these variables, and this size is added to the bss size.
  117. This is more efficient than performing a malloc() for each variable,
  118. as is done in other VxWorks loaders.
  120. A "stack unwind" segment is also generated for the stack tracer to use.
  121. See src/arch/simhppa/trcLib.c for details.
  123. Long branch stubs
  124. -----------------
  125. When code is compiled with optimization, the compiler generates
  126. a PC-relative "BL" (branch and link) instruction for all procedure calls.
  127. The problem is that the displacement must fit into 19 bits, so if the
  128. called procedure is further than 256k bytes away, we have no way to
  129. fixup the instruction.
  131. The solution is to generate a two instruction "long branch stub",
  132. and make that stub the target of the "BL" instruction. It is our
  133. responsibility to generate this stub, and to make sure that the stub
  134. itself is close enough to the caller of "BL".
  136. For each text subspace, the procedure subspaceSizeExtra() computes
  137. the amount of space needed by that subspace for possible long branch stubs.
  138. Thus when we map the text subspaces to the "text segment", we actually leave
  139. a bit of room between each subspace according to the value of
  140. subspaceSizeExtra() for that subspace.
  142. Parameter relocation
  143. --------------------
  144. The PA-RISC passes the first four words of the parameter list in
  145. registers, and the return value also goes in a register.
  146. floating point parameters are passed in floating point registers,
  147. and other parameters are passed in general purpose registers.
  148. The problem is that the caller and the callee may not agree as
  149. to where the parameters are located. For example, printf() expects
  150. its parameters to be in the general purpose registers, whereas a call
  151. like
  152.    printf ("%f", myFloat)
  153. passes the second parameter in a floating point register.
  154. The compiler generates information on how a procedure expects
  155. to be called, and on how it is actually called. It is our job to
  156. make sure they match, and if they don't, to insert a "parameter
  157. relocation stub" between the caller and the callee.
  159. Parameter relocation information is encoded in 10 bits - 2 bits
  160. each for the first four arguments words and the return value.
  161. Each 2 bit quantity specifies "unused, general register, float
  162. register, or double persion float register".
  164. When a new function is loaded, the 10 bit relocation info generated
  165. by the compiler must be stored away in the VxWorks symbol table for
  166. future reference, In order to do this I had to
  167. create a new structure called "MY_SYMBOL", which is just like
  168. the VxWorks "SYMBOL", but has an extra 8 bit field at the end. It turns
  169. out that the size of MY_SYMBOL is the same as the size of SYMBOL
  170. because of compiler padding, so no harm was done. The functions
  171. externSymResolve() and externSymAdd() perform VxWorks symbol
  172. table manipulation with MY_SYMBOL stuctures.
  174. When a function is called, the 10 parameter relocation bits
  175. are encoded in the fixup request associated with the function call.
  176. The routines rbits1() and rbits2() get the bits from the fixup request
  177. (actually, the 10 bits are encoded in 9 or fewer bits in the fixup
  178. request, so rbits1() and rbits2() do some work to extract the info
  179. and decode it to 10 bits). We then compare the callers reclocation
  180. bits with the callees and if they differ, we may ned to generate
  181. a stub (if we hadn't previously generated a stub for that function).
  183. Currently, this is only done if the callee expects general registers
  184. and the caller passses a double - which takes care of functions
  185. like printf, sprintf, etc. The loader prints an error message if
  186. any other type of parameter reloction is needed. It would be easy to add
  187. other parameter relocation stubs at a later time.
  189. Fixup requests
  190. --------------
  191. The linking fixup requests are passed to us as a byte stream.
  192. The number of bytes in each fixup request depends on the
  193. fixup request, and there are 71 different types of fixup requests!
  194. The routine linkSubspaces() performs the linker fixup requests, and
  195. it is complicated as hell. The comments in that routine describe it further.
  196. just to give you an idea of how complicated our friends at HP have made
  197. things: The linker must keep a queue of the last four multi-byte
  198. fixup requests. There is a one byte fixup requests called "repeat
  199. previous fixup" which directs us to repeat one of the previous fixups
  200. from the queue, and then move the fixup to the front of the queue!
  201. Currently there are many branches in linkSubspaces() that have
  202. not been tested.
  203. */
  205. #include "vxWorks.h"
  206. #include "stdio.h"
  207. #include "som_coff.h"
  208. #include "ioLib.h"
  209. #include "dsmLib.h"
  210. #include "fioLib.h"
  211. #include "bootLoadLib.h"
  212. #include "loadLib.h"
  213. #include "loadSomCoffLib.h"
  214. #include "memLib.h"
  215. #include "pathLib.h"
  216. #include "lstLib.h"
  217. #include "string.h"
  218. #include "symLib.h"
  219. #include "sysSymTbl.h"
  220. #include "errnoLib.h"
  221. #include "stdlib.h"
  222. #include "symbol.h"
  223. #include "moduleLib.h"
  224. #include "cacheLib.h"
  228. #define LOAD_NONE   0
  229. #define LOAD_TEXT   1
  230. #define LOAD_DATA   2
  231. #define LOAD_BSS    3
  233. #define SEG_ALIGN  8
  235. /* Some PA-RISC opCodes */
  237. #define LDIL_CODE       0x08
  238. #define ADDIL_CODE      0x0a
  239. #define BL_CODE         0x3a
  240. #define COMBT_CODE      0x20
  241. #define COMBF_CODE      0x22
  242. #define ADDB_CODE       0x28
  243. #define ADDBF_CODE      0x2a
  244. #define BB_CODE         0x31
  245. #define LDW_CODE        0x12
  246. #define LDH_CODE        0x11
  247. #define LDB_CODE        0x10
  248. #define STW_CODE        0x1a
  249. #define STH_CODE        0x19
  250. #define STB_CODE        0x18
  251. #define LDWM_CODE       0x13
  252. #define STWM_CODE       0x1b
  253. #define LDO_CODE        0x0d
  254. #define ADDI_CODE       0x2d
  255. #define ADDIT_CODE      0x2c
  256. #define SUBI_CODE       0x25
  257. #define COMICKR_CODE    0x24
  258. #define ADDIBT_CODE     0x29
  259. #define ADDIBF_CODE     0x2b
  260. #define COMIBT_CODE     0x21
  261. #define COMIBF_CODE     0x23
  262. #define BE_CODE         0x38
  263. #define BLE_CODE        0x39
  265. /* some handy macros for linkSubspaces() */
  267. #define B1 (*(pThisFixup++))
  268. #define B2 ((int)(pThisFixup += 2), 
  269.     (int) ((pThisFixup[-2] << 8) + pThisFixup[-1]))
  270. #define B3 ((int)(pThisFixup += 3), 
  271.     (int) ((pThisFixup[-3] << 16) + (pThisFixup[-2] << 8) + pThisFixup[-1]))
  272. #define B4 ((int)(pThisFixup += 4), 
  273.     (int) ((pThisFixup[-4] << 24) + (pThisFixup[-3] << 16) 
  274.            + (pThisFixup[-2] << 8) + pThisFixup[-1]))
  276. #define REL_STACK_SIZE  (10000)   /* size of relocation stack pointer */
  277. #define POP_EXPR        (*--sp)
  278. #define PUSH_EXPR(x)    (*sp ++ = (x))
  279. #define CHECK_STACK_OVER  if (sp >= pExpStack + REL_STACK_SIZE) 
  280.                               { 
  281.                               printErr ("ld error: stack overflown");
  282.                               status = ERROR; 
  283.                               }
  284. #define CHECK_STACK_UNDER if (sp <= pExpStack) 
  285.                               { 
  286.                               printErr ("ld error: stack underflown");
  287.                               status = ERROR; 
  288.                               }
  289. #define FLAG_RESET(flag)  if (flag) flag = FALSE;
  291. /* subspace relocation info */
  293. typedef struct
  294.     {
  295.     char * loadAddr;
  296.     int loadType;
  297.     } SUB_INFO;
  299. /* "previous fixup" queue */
  301. typedef struct
  302.     {
  303.     NODE node;
  304.     UCHAR *pFixup;
  305.     } PREV_FIXUP;
  307. /* stack unwind structures */
  309. typedef struct
  310.     {
  311.     char *startAddr;
  312.     char *endAddr;
  313.     UINT word3;
  314.     UINT word4;
  315.     } UNWIND_DESC;
  317. typedef struct
  318.     {
  319.     NODE node;
  320.     UNWIND_DESC unwindDesc;
  321.     } UNWIND_NODE;
  323. /* list of long branch stubs */
  325. typedef struct stubListNode
  326.     {
  327.     NODE node;
  328.     int symNum;
  329.     int arg_reloc;
  330.     } STUB_LIST_NODE;
  332. /* list of argument relocation stubs */
  334. typedef struct
  335.     {
  336.     NODE     node;
  337.     SYMREC * pSym;
  338.     int      arg_reloc;
  339.     char *   stubAddr;
  340.     } ARG_RELOC_NODE;
  342. /* modified symbol table entry */
  344. typedef struct                  /* MY_SYMBOL - entry in symbol table */
  345.     {
  346.     SL_NODE     nameHNode;      /* hash node (must come first) */
  347.     char        *name;          /* pointer to symbol name */
  348.     char        *value;         /* symbol value */
  349.     UINT16      group;          /* symbol group */
  350.     SYM_TYPE    type;           /* symbol type */
  351.     UCHAR       arg_reloc;      /* relocation bits */
  352.     } MY_SYMBOL;
  354. /* local variables */
  356. /* SPR 22030: changed entry for fixup 62 from 0 to 1 */
  358. static int fixupLen [256] =
  359.     {
  360.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 00 - 19 */
  361.     1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 2, 4, 2, 4, 1, 2, 4, 2, /* 20 - 39 */
  362.     4, 1, 2, 3, 5, 8, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, /* 40 - 59 */
  363.     5, 5, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 5, 5, 0, 0, /* 60 - 79 */
  364.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80 - 99 */
  365.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 0, 0, 0, 0, 0, 0, /* 100 - 119 */
  366.     2, 4, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 120 - 139 */
  367.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 140 - 159 */
  368.     2, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 4, 2, 4, 1, 9, /* 160 - 179 */
  369.     6, 1, 1, 1, 1, 2, 4, 1, 1, 2, 3, 4, 1, 1, 1, 1, 1, 1, 1, 1, /* 180 - 199 */
  370.     1, 1, 2, 3, 4, 5, 1,12, 2, 5, 6, 1, 1, 1, 1, 1, 0, 0, 0, 0, /* 200 - 219 */
  371.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 220 - 239 */
  372.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0              /* 240 - 255 */
  373.     };
  375. static UINT longBranchStub[] =
  376.         {
  377.         0x20200000,     /* LDIL    0, r1 */
  378.         0xe0202002      /* BE,n    0(s4, r1) */
  379.         };
  381. static stubSize = 8;
  383. /* externals */
  385. extern low_sign_ext (int x, int len);
  386. extern sign_ext     (int x, int len);
  387. extern assemble_21  (int x);
  388. extern assemble_17  (int x, int y, int z);
  389. extern assemble_12  (int x, int y);
  390. extern sysMemTop    (void);
  392. /* forward static functions */
  394. /* The entry point to the loader */
  396. static MODULE_ID ldSomCoffMdlAtSym (int fd, int symFlag, char **ppText, 
  397.     char **ppData, char **ppBss, SYMTAB_ID symTbl);
  399. /* primary loader support functions */
  401. static void symbolNameSet (SYMREC *pSym, int nSyms, char *pSymStr,
  402.     SUBSPACE *pSubspace, int nSubs, char *pSpaceStr, SPACE *pSpace,
  403.     int nSpaces);
  405. static void subspaceToSegment (SOM_HDR *pHpHdr, UCHAR *pRelocCmds,
  406.     SUB_INFO *pSubInfo,
  407.     SPACE *pSpace, SUBSPACE *pSubspace, SYMREC *pSym,
  408.     SYMTAB_ID symTbl, int *pTextSize, int *pDataSize,
  409.     int *pBssSize);
  411. static int subspaceSizeExtra (UCHAR *pRelCmds, SUBSPACE *pSubspace,
  412.     SYMREC *pSym, int numSyms, SYMTAB_ID symTbl);
  414. static void subspaceNoReloc (SOM_HDR *pHpHdr,
  415.     SUB_INFO *  pSubInfo, SUBSPACE *  pSubspace);
  417. static void commSizeGet (SYMREC *pSym, int nEnts, SUBSPACE *pSubspace,
  418.     int *pCommSize);
  420. static STATUS rdSymtab (SYMREC * pSym, FAST int nEnts,
  421.     SUBSPACE *pSubspace, SUB_INFO *pSubInfo, int symFlag,
  422.     SYMTAB_ID symTbl, SYMREC **pSymGlobal, char *pComm, int group);
  424. static STATUS loadSubspaces (int fd, SOM_HDR *pHpHdr, SUB_INFO *pSubInfo, 
  425.     SUBSPACE *pSubspace, char *pText, char *pData, char *pBss);
  427. static STATUS linkSubspaces (UCHAR *pRelCmds, SUBSPACE *pScnHdr, 
  428.     int numSubspace, SUB_INFO *pSubInfo, SYMREC *pSym, int numSyms,
  429.     SYMTAB_ID pSymTab, SYMREC *pSymGlobal, MODULE_ID moduleId);
  431. /* Symbol table manipulation functions */
  433. static BOOL externSymResolve (SYMTAB_ID symTblId, char * name, SYMREC *pSym);
  435. static BOOL externSymAdd (SYMTAB_ID symTblId, char * name, char *value,
  436.     SYM_TYPE type, UINT16 group, UCHAR arg_reloc);
  438. /* "argument relocation stub" functions */
  440. static BOOL argRelocDiffer (int arg_reloc1, int arg_reloc2);
  442. static char *argRelocStubListFind (LIST *stubList, SYMREC *pSym,
  443.     int arg_reloc, MODULE_ID moduleId);
  445. static void rbitsShow (int rbits);
  447. static int  rbits1 (int x);
  449. static int  rbits2 (int x);
  451. /* "long branch stub" manipulation functions */
  453. static int stubListFind (LIST *stubList, int symNum, int arg_reloc);
  455. static int stubListAdd (LIST *stubList, int symNum, int arg_reloc);
  457. static void stubInit (char *stubAddr, char *procAddr);
  459. /* stack unwind manipulation functions */
  461. static void unwindListAdd (LIST *unwindList, UNWIND_NODE *pUnwindNode);
  463. static void unwindSegmentCreate (LIST *unwindList, MODULE_ID moduleId);
  465. int loadSomCoffDebug = 0;
  466. #define DBG_PUT if (loadSomCoffDebug == 1) printf
  467. int loadSomCoffWarn  = 0;
  468. #define WARN if (loadSomCoffWarn == 1) printf
  470. /*******************************************************************************
  471. *
  472. * loadSomCoffInit - initialize the system for HP-PA SOM COFF load modules
  473. *
  474. * This routine initialized VxWorks to use an extended HP-PA SOM COFF format for
  475. * loading modules.
  476. *
  477. * RETURNS: OK
  478. *
  479. * SEE ALSO: loadModuleAt()
  480. */
  482. STATUS loadSomCoffInit (void)
  483.     {
  484.     loadRoutine = (FUNCPTR) ldSomCoffMdlAtSym;
  485.     return (OK);
  486.     }
  488. /******************************************************************************
  489. *
  490. * ldSomCoffMdlAtSym - load object module into memory with symbol table
  491. *
  492. * This routine is the underlying routine to loadModuleAtSym().  This interface
  493. * allows specification of the the symbol table used to resolve undefined
  494. * external references and to which to add new symbols.
  495. *
  496. * RETURNS:
  497. * MODULE_ID, or
  498. * NULL if can't read file or not enough memory or illegal file format
  499. */  
  501. static MODULE_ID ldSomCoffMdlAtSym
  502.     (
  503.     FAST int  fd,        /* fd from which to read module */
  504.     int       symFlag,   /* symbols to be added to table 
  505.                           *   ([NO | GLOBAL | ALL]_SYMBOLS) */
  506.     char **   ppText,    /* load text segment at address pointed to by this
  507.                           * pointer, return load address via this pointer */
  508.     char **   ppData,    /* load data segment at address pointed to by this
  509.                           * pointer, return load address via this pointer */
  510.     char **   ppBss,     /* load bss segment at address pointed to by this
  511.                           * pointer, return load address via this pointer */
  512.     SYMTAB_ID symTbl     /* symbol table to use */
  513.     )
  514.     {
  515.     char *    pText = (ppText == NULL) ? LD_NO_ADDRESS : *ppText;
  516.     char *    pData = (ppData == NULL) ? LD_NO_ADDRESS : *ppData;
  517.     char *    pBss  = (ppBss  == NULL) ? LD_NO_ADDRESS : *ppBss;
  518.     char *    pComm;
  519.     int       textSize;
  520.     int       dataSize;
  521.     int       bssSize;
  522.     int       commSize;         /* gets added to bssSize */
  523.     int       status = ERROR; /* function return value */
  524.     SEG_INFO  seg;                      /* file segment info */
  525.     char      fileName[255]; /* file being loaded */
  526.     UINT16    group; /* loader group */
  527.     MODULE_ID moduleId; /* module ID */
  529.     SOM_HDR   somHdr;                   /* SOM header */
  530.     SPACE *   pSpace = NULL;            /* space dictionary */
  531.     int       spaceSize;                /* number of spaces */
  532.     SUBSPACE *pSubspace = NULL; /* subspace dictionary */
  533.     int       subspaceSize; /* number of subspaces */
  534.     char *    pSpaceStrings = NULL; /* space/subspace names */
  535.     SYMREC *  pSymBuf = NULL;           /* symbol record dictionary */
  536.     int       symBufSize;               /* number of symbols */
  537.     char *    pSymStr = NULL;           /* symbol names */
  538.     FIXUP *   pReloc = NULL; /* linker fixup requests */
  539.     int       relSize;                 /* size of fixup requests */
  541.     SUB_INFO *pSubInfo = NULL; /* subspace load info */
  542.     SYMREC *  pGlobal = NULL; /* the symbol "$global$" */
  544.     /* initialization */
  546.     memset ((void *)&seg, 0, sizeof (seg));
  548.     /* Get the name of the file we are loading */
  550.     if (ioctl (fd, FIOGETNAME, (int) fileName) == ERROR)
  551.         {
  552.         printErr ("ldSomCoffMdlAtSym: can't get filenamen");
  553.         return (NULL);
  554.         }
  555.     
  556.     if ((moduleId = loadModuleGet (fileName, MODULE_ECOFF, &symFlag)) == NULL)
  557.         return (NULL);
  559.     group = moduleId->group;
  561.     /* read the SOM header */
  563.     bzero ((char *) &somHdr, sizeof(SOM_HDR));
  564.     if (read (fd, (char *)&somHdr, sizeof (SOM_HDR)) != sizeof(SOM_HDR))
  565.         {
  566.         errno = S_loadSomCoffLib_HDR_READ;
  567.         goto error;
  568.         }
  570.     /* check object file type - only relocatable and executable are supported */
  572.     if (somHdr.a_magic != RELOC_MAGIC &&
  573.         somHdr.a_magic != EXEC_MAGIC &&
  574.         somHdr.a_magic != SHARE_MAGIC)
  575.         {
  576.         printErr ("ldSomCoffMdlAtSym: bad magic #%#xn", somHdr.a_magic);
  577.         errno = S_loadSomCoffLib_OBJ_FMT;
  578.         goto error;
  579.         }
  581.     /* read in space dictionary */
  583.     if (somHdr.space_total != 0)
  584.         {
  585.         spaceSize=somHdr.space_total*sizeof(struct space_dictionary_record);
  586.         if ((pSpace = calloc (1, spaceSize)) == NULL)
  587.             {
  588.             errno = S_loadSomCoffLib_SPHDR_ALLOC;
  589.             goto error;
  590.             }
  591.         if (ioctl (fd, FIOSEEK, somHdr.space_location) == ERROR ||
  592.             read (fd, (char*)pSpace, spaceSize) != spaceSize)
  593.             {
  594.             errno = S_loadSomCoffLib_SPHDR_READ;
  595.             goto error;
  596.             }
  597.         }
  599.     /* read in subspace dictionary */
  601.     if (somHdr.subspace_total != 0)
  602.         {
  603.         subspaceSize = somHdr.subspace_total * SBPSZ;
  604.         if ((pSubspace = calloc (1, subspaceSize)) == NULL)
  605.             {
  606.             errno = S_loadSomCoffLib_SUBSPHDR_ALLOC;
  607.             goto error;
  608.             }
  610.         if (ioctl (fd, FIOSEEK, somHdr.subspace_location) == ERROR ||
  611.             read (fd, (char*)pSubspace, subspaceSize) != subspaceSize)
  612.             {
  613.             errno = S_loadSomCoffLib_SUBSPHDR_READ;
  614.             goto error;
  615.             }
  616.         }
  618.     /* read in space string table */
  620.     if (somHdr.space_strings_size != 0)
  621.         {
  622.         if ((pSpaceStrings = (char *) calloc (1, somHdr.space_strings_size)) ==
  623.              NULL)
  624.             {
  625.             errno = S_loadSomCoffLib_SPSTRING_ALLOC;
  626.             goto error;
  627.             }
  629.         if (ioctl (fd, FIOSEEK, somHdr.space_strings_location) == ERROR ||
  630.             read (fd, pSpaceStrings, somHdr.space_strings_size) != 
  631.                      somHdr.space_strings_size)
  632.             {
  633.             errno = S_loadSomCoffLib_SPSTRING_READ;
  634.             goto error;
  635.             }
  636.         }
  637.     if (somHdr.subspace_total != 0)
  638.         {
  639.         if ((pSubInfo = (SUB_INFO *) calloc (1, sizeof(SUB_INFO) *
  640.                                             somHdr.subspace_total)) == NULL)
  641.             {
  642.             errno = S_loadSomCoffLib_INFO_ALLOC;
  643.             goto error;
  644.             }
  645.         }
  646.     else
  647.         {
  648.         pSubInfo = (SUB_INFO *) calloc (1, sizeof(SUB_INFO)); 
  649.         }
  651.     /* read in symbol table */
  653.     symBufSize = somHdr.symbol_total * sizeof (SYMREC);
  655.     if ((pSymBuf = (SYMREC *) calloc (1, symBufSize)) == NULL)
  656.         {
  657.         errno = S_loadSomCoffLib_SYM_READ;
  658.         goto error;
  659.         }
  661.     if (ioctl (fd, FIOSEEK, somHdr.symbol_location) == ERROR)
  662.         {
  663.         errno = S_loadSomCoffLib_SYM_READ;
  664.         goto error;
  665.         }
  667.     if (read (fd, (char *) pSymBuf, symBufSize) != symBufSize)
  668.         {
  669.         errno = S_loadSomCoffLib_SYM_READ;
  670.         goto error;
  671.         }
  673.     /* read in symbol string table */
  675.     if ((pSymStr = calloc (1, somHdr.symbol_strings_size)) == NULL)
  676.         {
  677.         errno = S_loadSomCoffLib_SYMSTR_READ;
  678.         goto error;
  679.         }
  681.     if (ioctl (fd, FIOSEEK,somHdr.symbol_strings_location) == ERROR ||
  682.         read (fd, pSymStr, somHdr.symbol_strings_size) != 
  683.                  somHdr.symbol_strings_size)
  684.         {
  685.         errno = S_loadSomCoffLib_SYMSTR_READ;
  686.         goto error;
  687.         }
  689.     /* read in linker fixup requests */
  691.     if (somHdr.fixup_request_total != 0)
  692.         {
  693.         relSize = (int)somHdr.fixup_request_total;
  694.         if ((pReloc = (FIXUP *) calloc (1, relSize)) == NULL)
  695.             {
  696.             errno = S_loadSomCoffLib_RELOC_ALLOC;
  697.             goto error;
  698.             }
  699.         if (ioctl (fd, FIOSEEK, somHdr.fixup_request_location) == ERROR ||
  700.             read (fd, (char*)pReloc, relSize) != relSize)
  701.             {
  702.             errno = S_loadSomCoffLib_RELOC_READ;
  703.             goto error;
  704.             }
  705.         }
  707.     /* make each symbol, space, and subspace point to its name string */
  709.     symbolNameSet (pSymBuf, somHdr.symbol_total, pSymStr,
  710.                    pSubspace, somHdr.subspace_total, pSpaceStrings,
  711.                    pSpace, somHdr.space_total);
  714.     /* We don't really load non-relocatable files.
  715.      * Since VxWorks.sym is non-relocatable, we
  716.      * allow non-relocatable files to have their
  717.      * symbols added to the symbol table, without any loading */
  719.     if (somHdr.a_magic != RELOC_MAGIC)
  720.         {
  721.         /* process subspace addresses with no relocation */
  723.         subspaceNoReloc (&somHdr, pSubInfo, pSubspace);
  725.         /* read in the symbol table */
  727.         status = rdSymtab (pSymBuf, somHdr.symbol_total, pSubspace,
  728.                            pSubInfo, symFlag, symTbl, &pGlobal,
  729.                            NULL, group);
  731.         goto done;
  732.         }
  735.     /* 
  736.      * Loaded code won't work if VxWorks was linked without the "-N" flag.
  737.      * However VxWorks itself will work - so we put this check after
  738.      * allowing VxWorks to load it's symbol table
  739.      */
  741.     if (sysMemTop() > 0x40000000)
  742.         {
  743.         printErr ("n");
  744.         printErr ("load error: VxWorks wasn't linked with the "-N" flagn");
  745.         printErr ("Please read the "source debugging" section of then");
  746.         printErr ("VxSim Users Guide for detailsn");
  747.         printErr ("n");
  748.         goto error;
  749.         }
  751.     /* Map SOM subspaces to VxWorks "segments", and get the segment sizes */
  753.     subspaceToSegment (&somHdr, (UCHAR *)pReloc, pSubInfo,
  754.         pSpace, pSubspace, pSymBuf, symTbl, &textSize, &dataSize,
  755.         &bssSize);
  757.     /* Allocate memory for text, data, and bss. We must be careful
  758.      * to align everything, since loadSegmentsAllocate() will
  759.      * put all segemnts in one block */
  761.     seg.addrText = pText;
  762.     seg.addrData = pData;
  763.     seg.addrBss  = pBss;
  764.     seg.sizeText = ROUND_UP(textSize, SEG_ALIGN);
  765.     seg.sizeData = ROUND_UP(dataSize, SEG_ALIGN);
  766.     seg.sizeBss  = ROUND_UP(bssSize, SEG_ALIGN);
  768.     /* 
  769.      * SPR #21836: pSeg->flagsText, pSeg->flagsData, pSeg->flagsBss are used
  770.      * to save the max value of each segments. These max values are computed
  771.      * for each sections. These fields of pSeg are only used on output, then
  772.      * a temporary use is allowed.
  773.      */
  775.     seg.flagsText = SEG_ALIGN;
  776.     seg.flagsData = SEG_ALIGN;
  777.     seg.flagsBss  = SEG_ALIGN;
  779.     commSizeGet (pSymBuf, somHdr.symbol_total,
  780.                     pSubspace, (int *)&commSize);
  781.     seg.sizeBss += ROUND_UP(commSize, SEG_ALIGN);
  782.     DBG_PUT ("bssSize = 0x%x, commSize = 0x%xn", bssSize, commSize);
  784.     /* 
  785.      * SPR #21836: loadSegmentsAllocate() allocate memory aligned on 
  786.      * the max value of sections alignement saved in seg.flagsText,
  787.      * seg.flagsData, seg.flagsBss.
  788.      */
  790.     if (loadSegmentsAllocate (&seg) != OK)
  791.         {
  792.         printErr ("Could not allocate segmentsn");
  793.         goto error;
  794.         }
  796.     /*
  797.      * make sure all allocated segments are aligned OK.
  798.      * This will always be true if the memory is malloc'ed,
  799.      * since SEG_ALIGN, and _MEM_ALIGN, and the maximum
  800.      * possible subspace alignment are all "8"
  801.      */
  803.     pText = (char *) ROUND_UP (seg.addrText, SEG_ALIGN);
  804.     pData = (char *) ROUND_UP (seg.addrData, SEG_ALIGN);
  805.     pBss  = (char *) ROUND_UP (seg.addrBss, SEG_ALIGN);
  806.     pComm = (char *) ((int)pBss + seg.sizeBss
  807.                       - ROUND_UP(commSize, SEG_ALIGN));
  808.     if ( (pText != seg.addrText) ||
  809.          (pData != seg.addrData) ||
  810.          (pBss  != seg.addrBss) )
  811.         {
  812.         printErr ("loadModuleAtSym: segment alignment errorn");
  813.         goto error;
  814.         }
  815.     DBG_PUT ("pText = 0x%x, pData = 0x%x, pBss = 0x%x pComm = 0x%xn",
  816.              (int)pText, (int)pData, (int)pBss, (int)pComm);
  817.     DBG_PUT ("sizeText = 0x%x, sizeData = 0x%x, sizeBss = 0x%xn",
  818.              seg.sizeText, seg.sizeData, seg.sizeBss);
  820.     /* load all subspaces into memory */
  822.     if (loadSubspaces (fd, &somHdr, pSubInfo, pSubspace, pText, pData, pBss)
  823.                       != OK)
  824.         {
  825.         errno = S_loadSomCoffLib_LOAD_SPACE;
  826.         goto error;
  827.         }
  829.     /* add segment names to symbol table before other symbols */
  831.     if (!(symFlag & LOAD_NO_SYMBOLS))
  832.         addSegNames (fd, pText, pData, pBss, symTbl, group);
  834.     /* process symbol table */
  836.     status = rdSymtab (pSymBuf, somHdr.symbol_total, pSubspace,
  837.                        pSubInfo, symFlag, symTbl, &pGlobal, pComm, group);
  839.     /* Perform linker fixup requests on the subspaces */
  841.     if (somHdr.version_id == NEW_VERSION_ID)
  842.         {
  843.         if (somHdr.fixup_request_total != 0)
  844.             (void) linkSubspaces ((UCHAR *) pReloc, pSubspace, 
  845.                                    somHdr.subspace_total, pSubInfo, pSymBuf, 
  846.                                    somHdr.symbol_total,
  847.                                    symTbl, pGlobal, moduleId);
  848.         }
  849.     else
  850.         {
  851.         errno = S_loadSomCoffLib_RELOC_VERSION;
  852.         goto error;
  853.         }
  855.     /* return load addresses, where called for */
  857.     if (ppText != NULL)
  858.         *ppText = pText;
  860.     if (ppData != NULL)
  861.         *ppData = pData;
  863.     if (ppBss != NULL)
  864.         *ppBss = pBss;
  866.     /* clear out bss */
  868.     bzero (pBss, (int) seg.sizeBss);
  870.     /* flush text to memory */
  872.     CACHE_TEXT_UPDATE (pText, seg.sizeText);
  874.     /*
  875.      * Add the segments to the module.
  876.      * This has to happen after the relocation gets done.
  877.      * If the relocation happens first, the checksums won't be
  878.      * correct.
  879.      */
  881.     moduleSegAdd (moduleId, SEGMENT_TEXT, pText, seg.sizeText, seg.flagsText);
  882.     moduleSegAdd (moduleId, SEGMENT_DATA, pData, seg.sizeData, seg.flagsData);
  883.     moduleSegAdd (moduleId, SEGMENT_BSS, pBss, seg.sizeBss, seg.flagsBss);
  884.                 
  885.     /* error:
  886.      * clean up dynamically allocated temporary buffers and return ERROR */
  888. error:
  889. done:
  890.     if (pSubInfo != NULL)
  891.         free ((char *) pSubInfo);
  892.     if (pSpaceStrings != NULL)
  893.         free ((char *) pSpaceStrings);
  894.     if (pSpace!= NULL)
  895.         free ((char *) pSpace);
  896.     if (pSubspace!= NULL)
  897.         free ((char *) pSubspace);
  898.     if (pSymBuf != NULL)
  899.         free ((char *) pSymBuf);
  900.     if (pSymStr != NULL)
  901.         free ((char *) pSymStr);
  902.     if (pReloc!= NULL)
  903.         free ((char *) pReloc);
  905.     if (status == OK)
  906.         return (moduleId);
  907.     else
  908.         {
  909.         moduleDelete (moduleId);
  910.         return (NULL);
  911.         }
  912.     }
  914. /******************************************************************************
  915. *
  916. * symbolNameSet - make all symbols records point to their name strings
  917. */ 
  918.  
  919. static void symbolNameSet
  920.     (
  921.     SYMREC *   pSym,           /* pointer to symbol table */
  922.     int        nSyms,          /* # of entries in symbol table */
  923.     char *     pSymStr,        /* pointer to symbol string table */
  924.     SUBSPACE * pSubspace,      /* pointer to subspace dictionary */
  925.     int        nSubs,          /* number of subspaces */
  926.     char *     pSpaceStr,      /* pointer to space name string table */
  927.     SPACE *    pSpace,        /* pointer to space dictionary */
  928.     int        nSpaces        /* number of spaces */
  929.     )
  930.     {
  931.     int ix;
  933.     for (ix = 0; ix < nSyms; ix++)
  934.         pSym[ix].symbol_name = pSymStr + pSym[ix].name.n_strx;
  936.     for (ix = 0; ix < nSubs; ix++)
  937.         pSubspace[ix].subspace_name = pSpaceStr + pSubspace[ix].name.n_strx;
  939.     for (ix = 0; ix < nSpaces; ix++)
  940.         pSpace[ix].space_name = pSpaceStr + pSpace[ix].name.n_strx;
  941.     }
  943. /*******************************************************************************
  944. *
  945. * commSizeGet - this routine go through the symbol table to calculate the 
  946. *                  size of STORAGE data for relocatable files
  947. *
  948. * STORAGE requests (i.e., "common data") are simply turned into BSS
  949. * by this loader (and all other VxWorks loaders). The loader adds
  950. * an area for these symbols by increasing the normal BSS area.
  951. * This allows us to not have to malloc memory for each STORAGE symbol.
  952. *
  953. * As a side effect, all the STORAGE symbols are partially relocated.
  954. * That is - the symbol_value field of the symbols SYMREC structure
  955. * is turned into an offset from the start of the STORAGE segment
  956. */
  958. static void commSizeGet
  959.     (
  960.     SYMREC * pSymBuf,              /* symbol dictionary */
  961.     int      nEnts,                /* number of symbols */
  962.     SUBSPACE *pSubspace,           /* subspace relocation info */
  963.     int *    pCommSize             /* where to return comm size */
  964.     )
  965.     {
  966.     SYMREC * pSym = pSymBuf;
  967.     int      size =  0;
  968.     int      subspaceIndex;
  969.     int      ix;
  970.     int      iy;
  971.     SYMREC * pSearch;
  972.     int      symSize;
  974.     for (ix = 0; ix < nEnts; ix ++)
  975.         {
  976.         if (pSym->symbol_type == ST_STORAGE)
  977.             {
  978.             pSearch = pSymBuf;
  980.             /* XXX - search for the previous record for same symbol
  981.              * in symbol table. For some reason STORAGE symbols
  982.              * sometime appear in pairs.
  983.              */
  985.             for (iy = 0; iy < ix; iy ++)
  986.                 {
  987.                 if (strcmp(pSym->symbol_name, pSearch->symbol_name) == 0)
  988.                     break;
  989.                 pSearch ++;
  990.                 }
  992.             /* deal with a new storage symbol */
  994.             if (iy == ix)
  995.                 {
  996.                 subspaceIndex = pSym->symbol_info;
  997.                 size = ROUND_UP (size, pSubspace[subspaceIndex].alignment);
  998.                 symSize = pSym->symbol_value;
  999.                 pSym->symbol_value = size;
  1000.                 size += symSize;
  1001.                 pSym->secondary_def = 0;
  1002.                 }
  1004.             /* duplicate storage symbol */
  1006.             else
  1007.                 {
  1008.                 pSym->secondary_def = 1;
  1009.                 }
  1010.             }
  1011.         pSym ++;
  1012.         }
  1014.     *pCommSize = size;
  1015.     }
  1017. /*******************************************************************************
  1018. *
  1019. * rdSymtab - Process the VxWorks symbol table
  1020. *
  1021. * This is passed a pointer to an HP-PA SOM symbol table and processes
  1022. * each of the external symbols defined therein.  This processing performs
  1023. * two functions:
  1024. *  1) New symbols are entered in the system symbol table as
  1025. *     specified by the "symFlag" argument:
  1026. *        ALL_SYMBOLS    = all defined symbols (LOCAL and GLOBAL) are added,
  1027. *        GLOBAL_SYMBOLS = only external (GLOBAL) symbols are added,
  1028. *        NO_SYMBOLS     = no symbols are added;
  1029. *  2) Undefined externals are looked up in the system table.
  1030. *     If an undefined external cannot be found in the symbol table,
  1031. *     an error message is printed, but ERROR is not returned until the entire
  1032. *     symbol table has been read, which allows all undefined externals to be
  1033. *     reported.
  1034. *
  1035. * Absolute symbols are automatically discarded.
  1036. *
  1037. * RETURNS: OK or ERROR
  1038. */
  1040. static STATUS rdSymtab 
  1041.     (
  1042.     SYMREC *   pSymBuf, /* pointer to symbol table */
  1043.     FAST int   nEnts,           /* # of entries in symbol table */
  1044.     SUBSPACE * pSubspace,       /* pointer to subspace dictionary */
  1045.     SUB_INFO * pSubInfo,        /* subspace relocation info */
  1046.     int        symFlag,         /* symbols to be added to table 
  1047.                                  *   ([NO|GLOBAL|ALL]_SYMBOLS) */
  1048.     SYMTAB_ID  symTbl,          /* symbol table to use */
  1049.     SYMREC **  pSymGlobal,      /* '$global$' symbol entry pointer */
  1050.     char *     pComm,           /* start of comm area (within bss segment) */
  1051.     int        group            /* symbol group */
  1052.     )
  1053.     {
  1054.     char *   name;              /* symbol name (plus EOS) */
  1055.     SYMREC * pSym = (SYMREC *) pSymBuf;  /* symbol entry pointer */
  1056.     int      ix; /* symbols subspace index */
  1057.     SYM_TYPE vxSymType;         /* symbol type */
  1058.     UCHAR    arg_reloc; /* argument relocation info */
  1059.     int      status  = OK;      /* return status */
  1061.     *pSymGlobal = NULL;
  1062.     for (; nEnts > 0; nEnts -= 1, pSym ++)
  1063.         {
  1064.         /* throw away absolute symbols */
  1066.         if (pSym->symbol_type == ST_ABSOLUTE)
  1067.             continue;
  1069.         /* throw away symbol and argument extentions */
  1070.         if (pSym->symbol_type == ST_SYM_EXT)
  1071.             continue;
  1073.         if (pSym->symbol_type == ST_ARG_EXT)
  1074.             continue;
  1076.         /* throw away invalid symbols */
  1078.         if (pSym->symbol_type == ST_NULL)
  1079.             continue;
  1081.         /* get the symbol name */
  1083.         name = pSym->symbol_name;
  1085.         /* keep the symbol $global$ handy */
  1087.         if ( (pSym->symbol_type == ST_DATA) && (!strcmp(name, "$global$")) )
  1088.             *pSymGlobal = pSym;
  1090.         if (!pSubspace[pSym->symbol_info].is_loadable)
  1091.             WARN ("Warning: symbol %s is unloadable!n", name);
  1092.         if (pSym->must_qualify)
  1093.             WARN ("Warning: symbol %s must qualify!n", name);
  1094.         if (pSym->is_common || pSym->dup_common)
  1095.             WARN ("Warning: symbol %s is a common block!n", name);
  1097.         /* add new symbols to the symbol table */
  1099.         if ((pSym->symbol_scope == SS_UNIVERSAL) ||
  1100.             (pSym->symbol_scope == SS_LOCAL))
  1101.             {
  1103.             /* relocate the symbol relative to it's associated subspace */
  1105.             ix = pSym->symbol_info;
  1106.             pSym->symbol_value = pSym->symbol_value
  1107.                                  - pSubspace[ix].subspace_start
  1108.                                  + (unsigned int)pSubInfo[ix].loadAddr;
  1110.             switch (pSym->symbol_type)
  1111.                 {
  1112.                 /* Data or BSS symbols */
  1114.                 case ST_DATA:
  1115.                     if (pSubInfo[ix].loadType == LOAD_BSS)
  1116.                         {
  1117.                         vxSymType = N_BSS;
  1118.                         DBG_PUT ("new BSS symbol %s (0x%x)n", name,
  1119.                                  pSym->symbol_value);
  1120.                         }
  1121.                     else
  1122.                         {
  1123.                         vxSymType = N_DATA;
  1124.                         DBG_PUT ("new DATA symbol %s (0x%x)n", name, 
  1125.                                  pSym->symbol_value);
  1126.                         }
  1127.                     arg_reloc = 0;
  1128.                     break;
  1130.                 /* Text symbols */
  1132.                 case ST_CODE:
  1133.                 case ST_PRI_PROG:
  1134.                 case ST_SEC_PROG:
  1135.                 case ST_MILLICODE:
  1136.                 case ST_ENTRY:
  1137.                     vxSymType = N_TEXT | ((UCHAR)(pSym->arg_reloc & 3) << 6);
  1138.                     arg_reloc = (UCHAR)(pSym->arg_reloc >> 2);
  1139.                     pSym->symbol_value &= 0xfffffffc;
  1140.                     break;
  1142.                 /* ignore stubs */
  1144.                 case ST_STUB:
  1145.                     continue;
  1147.                 /* These have never popped up yet */
  1149.                 case ST_MODULE:
  1150.                 case ST_PLABEL:
  1151.                 case ST_OCT_DIS:
  1152.                 case ST_MILLI_EXT:
  1153.                 default:
  1154.                     WARN ("Warning: symbol %s is of type %dn", 
  1155.                               name, pSym->symbol_type);
  1156.                     continue;
  1157.                 }
  1159.             if ( (pSym->symbol_scope == SS_UNIVERSAL) && (!pSym->hidden) )
  1160.                 vxSymType |= N_EXT;
  1162.             if ( ((symFlag & LOAD_LOCAL_SYMBOLS) && !(vxSymType & N_EXT)) ||
  1163.                 ((symFlag & LOAD_GLOBAL_SYMBOLS) && (vxSymType & N_EXT)) )
  1164.                 {
  1165.                 DBG_PUT ("adding symbol %s to symTbln", name);
  1166.                 if (externSymAdd (symTbl, name, (char*)pSym->symbol_value,
  1167.                             vxSymType, group, arg_reloc) != OK)
  1168.                     {
  1169.                     printErr ("can't add symbol %s (errno=%#x)n",
  1170.                                 name, errnoGet());
  1171.                     }
  1172.                 }
  1173.             }
  1175.         /* Add STORAGE (common) symbols as BSS */
  1177.         else if (pSym->symbol_type == ST_STORAGE)
  1178.             {
  1179.             if (pSym->secondary_def)
  1180.                 continue;
  1181.             vxSymType = N_BSS | N_EXT;
  1182.             pSym->symbol_value += (unsigned int)pComm;
  1183.             DBG_PUT ("new STORAGE symbol %s (0x%x)n", name,
  1184.                      pSym->symbol_value);
  1185.             if (externSymAdd (symTbl, name, (char*)pSym->symbol_value,
  1186.                 vxSymType, group, 0) != OK)
  1187.                 {
  1188.                 printErr ("can't add symbol %s (errno=%#x)n",
  1189.                             name, errnoGet());
  1190.                 }
  1191.             }
  1193.         /* look up external symbols */
  1195.         else
  1196.             {
  1197.             if (externSymResolve (symTbl, name, pSym) != OK)
  1198.                 {
  1199.                 printErr ("undefined symbol: %sn", name);
  1200.                 status = ERROR;
  1201.                 }
  1202.             }
  1204.         }
  1206.     DBG_PUT ("done with rdSymtabn");
  1208.     return (status);
  1209.     }
  1211. /*******************************************************************************
  1212. *
  1213. * de_assemble_21 - encode a 21 bit immediate.
  1214. *
  1215. * The PA-RISC encode immediate values in the instruction word in bizaar
  1216. * ways. See the PA-RISC architecture manual for details.
  1217. */
  1219. static int de_assemble_21
  1220.     (
  1221.     unsigned int x
  1222.     )
  1223.     {
  1224.     return ((x & 0x100000) >> 20 | (x & 0xffe00) >> 8 |
  1225.             (x & 0x180) << 7  | ( x & 0x7c) << 14 | (x & 0x3) << 12);
  1226.     }
  1228. /*******************************************************************************
  1229. *
  1230. * de_assemble_17 - encode a 17 bit immediate.
  1231. *
  1232. * The PA-RISC encode immediate values in the instruction word in bizaar
  1233. * ways. See the PA-RISC architecture manual for details.
  1234. */
  1236. static int de_assemble_17 
  1237.     (
  1238.     unsigned int x
  1239.     )
  1240.     {
  1241.     return ((x & 0x10000) >> 16 | (x & 0xf800) << 5 | (x & 0x400) >> 8 |
  1242.             (x & 0x3ff) << 3);
  1243.     }
  1245. /*******************************************************************************
  1246. *
  1247. * de_assemble_12 - encode a 12 bit immediate.
  1248. *
  1249. * The PA-RISC encode immediate values in the instruction word in bizaar
  1250. * ways. See the PA-RISC architecture manual for details.
  1251. */
  1253. static int de_assemble_12
  1254.     (
  1255.     unsigned  int x
  1256.     )
  1257.     {
  1258.     return ((x & 0x800) >> 11 | (x & 0x400) >> 8 | (x & 0x3ff) << 3);
  1259.     }
  1261. /*******************************************************************************
  1262. *
  1263. * de_low_sign_ext - encode a sign extended immediate of length len
  1264. *
  1265. * The PA-RISC encode immediate values in the instruction word in bizaar
  1266. * ways. See the PA-RISC architecture manual for details.
  1267. */
  1269. static int de_low_sign_ext
  1270.     (
  1271.     int x,
  1272.     int len
  1273.     )
  1274.     {
  1275.     int tmp;
  1277.     if (len > 32)
  1278.         return (x);
  1280.     tmp = x & ((1 << len) - 1);
  1282.     return ((tmp & ((1 << (len - 1)))) >> (len - 1) |
  1283.             ((tmp & ((1 << (len -1)) - 1)) << 1));
  1284.     }
  1286. /*******************************************************************************
  1287. *
  1288. * L_fixValue - mask off the low bits.
  1289. */
  1291. static unsigned long L_fixValue 
  1292.     (
  1293.     unsigned long x
  1294.     )
  1295.     {
  1296.     return (x & 0xfffff800);
  1297.     }
  1299. /*******************************************************************************
  1300. *
  1301. * R_fixValue - mask off the high bits.
  1302. */
  1304. static unsigned long R_fixValue 
  1305.     (
  1306.     unsigned long x
  1307.     )
  1308.     {
  1309.     return (x & 0x000007ff);
  1310.     }
  1312. /*******************************************************************************
  1313. *
  1314. * RND_fixValue - round to nearest 8k (0x2000) byte boundary
  1315. */
  1317. static unsigned long RND_fixValue 
  1318.     (
  1319.     unsigned long x
  1320.     )
  1321.     {
  1322.     return ((x + 0x1000) & 0xffffe000);
  1323.     }
  1325. /******************************************************************************
  1326. *
  1327. * LR_fixValue - mask off low bits after rounding.
  1328. */
  1330. static unsigned long LR_fixValue 
  1331.     (
  1332.     unsigned long x,
  1333.     unsigned long fixConst
  1334.     )
  1335.     {
  1336.     return (L_fixValue (x + RND_fixValue(fixConst)));
  1337.     }
  1339. /******************************************************************************
  1340. *
  1341. * RR_fixValue - mask off high bits after rounding.
  1342. */
  1344. static unsigned long RR_fixValue 
  1345.     (
  1346.     unsigned long x,
  1347.     unsigned long fixConst
  1348.     )
  1349.     {
  1350.     return (R_fixValue (x + RND_fixValue(fixConst)) + 
  1351.             (fixConst - RND_fixValue(fixConst)));
  1352.     }
  1354. /*******************************************************************************
  1355. *
  1356. * fieldValue - perform rounding.
  1357. *
  1358. * This function performs rounding during a fixup request.
  1359. * The field selector, mode selector, and round constant are computed
  1360. * by the fuction fieldGetDefault() (see below) and passed to us.
  1361. *
  1362. * RETURNS: A rounded value, based on the original value, field selector,
  1363. *          mode selector, and round constant.
  1364. */
  1366. static UINT fieldValue
  1367.     (
  1368.     UINT value,
  1369.     UINT fSel,
  1370.     UINT mSel,
  1371.     UINT roundConst
  1372.     )
  1373.     {
  1374.     UINT retVal = value;
  1376.     switch (fSel)
  1377.         {
  1378.         /* FSEL = no rounding needed */
  1380.       case R_FSEL:
  1381. retVal = value + roundConst;
  1382. break;
  1384.         /* LSEL = "left" bits (round first, then zero out the right bits) */
  1386.       case R_LSEL:
  1387. switch (mSel)
  1388.     {
  1389.   case R_N_MODE:        /* round down (L') mode */
  1390.     retVal = L_fixValue (value + roundConst);
  1391.     break;
  1392.   case R_S_MODE:        /* round to nearest page (LS') mode */
  1393.     value += roundConst;
  1394.     if (value & 0x00000400)
  1395. retVal = L_fixValue (value + 0x800);
  1396.     else
  1397. retVal = value;
  1398.     break;
  1399.   case R_D_MODE:        /* round up (LD') mode */
  1400.     retVal = L_fixValue (value + roundConst + 0x800);
  1401.     break;
  1402.   case R_R_MODE:        /* round up with adjust (LR') mode */
  1403.     retVal = LR_fixValue (value, roundConst);
  1404.     break;
  1405.     }
  1406. break;
  1408.         /* RSEL = "right" bits (round first, then zero out the left bits) */
  1410.       case R_RSEL:        
  1411. switch (mSel)
  1412.     {
  1413.   case R_N_MODE:        /* round down (R') mode */
  1414.     retVal = R_fixValue (value + roundConst);
  1415.     break;
  1416.   case R_S_MODE:        /* round to nearest page (RS') mode */
  1417.     value += roundConst;
  1418.     if (value & 0x00000400)
  1419. retVal = value | 0xfffff800;
  1420.     else
  1421. retVal = value;
  1422.     break;
  1423.   case R_D_MODE:        /* round up (RD') mode */
  1424.     retVal = (value + roundConst) | 0xfffff800;
  1425.     break;
  1426.   case R_R_MODE:        /* round with adjust (RR') mode */
  1427.     retVal = RR_fixValue (value, roundConst);
  1428.     break;
  1429.     }
  1430. break;
  1431.       default:
  1432. WARN ("Warning: unknown field selector %dn", fSel);
  1433. break;
  1434.         }
  1435.     return (retVal);
  1436.     }
  1438. /*******************************************************************************
  1439. *
  1440. * fieldGetDefault - compute the field selector and rounding mode.
  1441. *
  1442. * This function looks at the current instruction to determine
  1443. * the field value, rounding mode, and rounding constant.
  1444. */
  1446. static void fieldGetDefault 
  1447.     (
  1448.     UINT  instr,                  /* machine instruction */
  1449.     int   fieldOverride,          /* field selector override flag */
  1450.     int   dataOverride,           /* fixed constant override flag */
  1451.     int * pFieldSel,              /* where to return field selector */
  1452.     int * pFormat,                /* how to deposit bits */
  1453.     int * pFixConst               /* where to return fixup constant */
  1454.     )
  1455.     {
  1456.     unsigned int disp;
  1457.     unsigned int majorCode = (instr & 0xfc000000) >> 26;
  1459.     /* set field selector */
  1461.     if (!fieldOverride)
  1462.         {
  1463.         switch (majorCode)
  1464.             {
  1465.             case LDIL_CODE:
  1466.             case ADDIL_CODE:
  1467.                 *pFieldSel = R_LSEL;
  1468.                 break;
  1469.             case BL_CODE:
  1470.             case COMBT_CODE:
  1471.             case COMBF_CODE:
  1472.             case ADDB_CODE:
  1473.             case ADDBF_CODE:
  1474.             case BB_CODE:
  1475.                 *pFieldSel = R_FSEL;
  1476.                 break;
  1477.             default:
  1478.                 *pFieldSel = R_RSEL;
  1479.                 break;
  1480.             }
  1481.         }
  1483.     /* get relocation bit */
  1485.     switch (majorCode)
  1486.         {
  1487.         /* i_exp14 */
  1488.         case LDW_CODE:
  1489.         case LDH_CODE:
  1490.         case LDB_CODE:
  1491.         case STW_CODE:
  1492.         case STH_CODE:
  1493.         case STB_CODE:
  1494.         case LDWM_CODE:
  1495.         case STWM_CODE:
  1496.         case LDO_CODE:
  1497.             disp = instr & 0x3fff;
  1498.             disp = low_sign_ext (disp, 14);
  1499.             *pFormat = i_exp14;
  1500.             break;
  1501.         /* i_exp11 */
  1502.         case ADDI_CODE:
  1503.         case ADDIT_CODE:
  1504.         case SUBI_CODE:
  1505.         case COMICKR_CODE:
  1506.             disp = instr & 0x7ff;
  1507.             disp = low_sign_ext (disp, 11);
  1508.             *pFormat = i_exp11;
  1509.             break;
  1510.         /* i_exp21 */
  1511.         case LDIL_CODE:
  1512.         case ADDIL_CODE:
  1513.             disp = assemble_21 (instr & 0x1fffff);
  1514.             disp = disp & 0x3fff;
  1515.             *pFormat = i_exp21;
  1516.             break;
  1517.         /* i_rel17 */
  1518.         case BL_CODE:
  1519.         /* i_abs17 */
  1520.         case BE_CODE:
  1521.         case BLE_CODE:
  1522.             disp = instr & 0x1fffff;
  1523.             disp = sign_ext(assemble_17 ((disp & 0x1f0000)>>16, 
  1524.                                          (disp & 0x1ffc) >> 2,
  1525.                                          disp & 0x1), 17) << 2;
  1526.             *pFormat = i_rel17;        /* i_rel17 and i_abs17 same format */
  1527.             break;
  1528.         /* i_rel12 */
  1529.         case ADDIBT_CODE:
  1530.         case ADDIBF_CODE:
  1531.         case COMIBT_CODE:
  1532.         case COMIBF_CODE:
  1533.             disp = instr & 0x1ffd;
  1534.             disp = sign_ext (assemble_12 ((disp & 0x1ffc) >> 2, disp & 0x1), 12)
  1535.                    << 2;
  1536.             *pFormat = i_rel12;
  1537.             break;
  1538.         default:
  1539.             disp = 0;
  1540.             *pFormat = i_none;
  1541.             break;
  1542.         }
  1543.     if (!dataOverride)
  1544.         *pFixConst = disp;
  1545.     }
  1547. /*******************************************************************************
  1548. *
  1549. * fixBits - Perform a linker fixup to modify an instruction.
  1550. */
  1552. static void fixBits
  1553.     (
  1554.     INSTR * adrs,        /* where to fix */
  1555.     int     value,       /* value to fix */
  1556.     int     format       /* fixup format */
  1557.     )
  1558.     {
  1559.     int mask;
  1561.     switch (format)
  1562.         {
  1563.         case i_exp14:
  1564.             value = de_low_sign_ext (value, 14);
  1565.             mask = 0x3fff;
  1566.             break;
  1567.         case i_exp21:
  1568.             value = de_assemble_21 (value >> 11);
  1569.             mask = 0x1fffff;
  1570.             break;
  1571.         case i_exp11:
  1572.             value = de_low_sign_ext (value, 11);
  1573.             mask = 0x7ff;
  1574.             break;
  1575.         case i_rel17:
  1576.         case i_abs17:
  1577.             value = de_assemble_17 (value >> 2);
  1578.             mask = 0x001f1ffd;
  1579.             break;
  1580.         case i_rel12:
  1581.             value = de_assemble_12 (value >> 2);
  1582.             mask = 0x1ffd;
  1583.             break;
  1584.         case i_data:
  1585.             mask = 0xffffffff;
  1586.             break;
  1587.         case i_milli:
  1588.         case i_break:
  1589.         default:
  1590.             mask = 0;
  1591.             break;
  1592.         }
  1593.     *adrs = ((*adrs) & ~mask) | (value & mask);
  1594.     }
  1596. /*******************************************************************************
  1597. *
  1598. * linkSubspaces - perform linker fixup commands for relocation.
  1599. *
  1600. * RETURNS: OK or ERROR
  1601. */
  1603. static STATUS linkSubspaces
  1604.     (
  1605.     UCHAR *   pRelCmds,        /* list of relocation commands */
  1606.     SUBSPACE *pSubspace,       /* subspace dictionary */
  1607.     int       nSubs,           /* number of subspaces */
  1608.     SUB_INFO *pSubInfo,        /* load information for the subspaces */
  1609.     SYMREC *  pSym,            /* symbols dictionary */
  1610.     int       numSyms,         /* number of symbols */
  1611.     SYMTAB_ID pSymTab,         /* VxWorks symbol table */
  1612.     SYMREC *  pSymGlobal,      /* pointer to '$global$' entry */
  1613.     MODULE_ID moduleId         /* module being linked */
  1614.     )
  1615.     {
  1616.     int status = OK; /* function return value */
  1618.     /*
  1619.      * generic fixup variables
  1620.      *
  1621.      * For each subspace, we must process a stream of fixup requests
  1622.      * in order to complete the relocation. The fixup requests are
  1623.      * variable size, and there are no "markers" to separate the
  1624.      * fixups - so ya gotta be real careful. The first byte of each
  1625.      * fixup request is called the opCode.
  1626.      */
  1628.     int ix; /* index of subspace being fixed up */
  1629.     UCHAR * pThisFixup; /* start of relocation fixup stream */
  1630.     UCHAR * pLastFixup; /* end of stream */
  1631.     UCHAR opCode;               /* the type of fixup request */
  1632.     char *relAdr;               /* address that need fixing */
  1633.     int relValue;               /* value to apply (e.g., a function address) */
  1635.     /*
  1636.      * Variables for maintaining the REPEAT_PREV_FIXUP list.
  1637.      *
  1638.      * The linker maintains a list of the last 4 multibyte
  1639.      * fixup requests. When a REPEAT_PREV_FIXUP fixup occurs,
  1640.      * we repeat one of the fixups from our list.
  1641.      */
  1643.     LIST prevFixupList;         /* previous fixup list */
  1644.     PREV_FIXUP prevFixupNodes[4];    /* the nodes in the list */
  1645.     PREV_FIXUP *pPrevFixupNode; /* pointer to some node in the list */
  1646.     UCHAR *pOldFixup = 0;       /* before executing a previous fixup, we save
  1647.                                  * our current place in the fixup stream */
  1648.     BOOL usingPrevFixup;        /* are we currently are using a queued fixup? */
  1650.     /*
  1651.      * variables for fixups that manipulate the expession stack.
  1652.      *
  1653.      * An expession stack is used to evaluate complex combinations of values.
  1654.      * The R_COMPX fixups either push a value on the expression stack or
  1655.      * modifies what is on top of the stack (e.g., it might pop the top
  1656.      * two elements, and push their sum).
  1657.      * These fixups have a secondary opCode which describes what to do.
  1658.      * The value at the top of the expession stack is used in the
  1659.      * R_DATA_EXPR and R_CODE_EXPR fixups.
  1660.      * XXX - these have not been tested yet.
  1661.      */
  1663.     UCHAR opCode2;              /* 2nd opcode for stack manipulation fixups */
  1664.     int * pExpStack;                /* initial stack pointer */
  1665.     int * sp; /* current stack pointer */
  1666.     int top1;                   /* first item on stack */
  1667.     int top2;                   /* second item on stack */
  1668.     int C;                      /* condition code for stack operation */
  1670.     /*
  1671.      * variables to hold the fixup request parameters.
  1672.      *
  1673.      * Most fixup requests pass us parameters (e.g., the symbol number
  1674.      * which we need to branch to). The parameters passed depend on
  1675.      * the fixup. The way the parameters are encoded in the fixup stream
  1676.      * also depends on the fixup.
  1677.      */
  1679.     int L;                      /* number of bytes to relocate */
  1680.     int S;                      /* symbol index used */
  1681.     int R = 0;                  /* parameter relocation bits */
  1682.     int V = 0;                  /* variable or fix up constant */
  1683.     int U; /* stack unwind bits */
  1684.     int F; /* procedure stack frame size */
  1685.     int D;                      /* difference of operation code */
  1686.     int X; /* previous fixup index */
  1687.     int M; /* number of bytes for R_REPEATED_INIT */
  1688.     int N; /* statement number in R_STATEMENT */
  1690.     /*
  1691.      * variables for handling the rounding mode during fixups
  1692.      *
  1693.      * Many fixups come in pairs, where we move the left (high order)
  1694.      * bits of a value in the first fixup, and the right (low order)
  1695.      * bits in the next fixup. Before applying a fixup value
  1696.      * at an address, it must be rounded.
  1697.      * The rounded constant is then applied to the address.
  1698.      *
  1699.      * The field selector specifies if we should apply the
  1700.      * left bits (LSEL), the right bits (RSEL), or everything (FSEL).
  1701.      * The field selector depends on the current instruction, but
  1702.      * can be overridden with a feild selector override fixup.
  1703.      *
  1704.      * The interpretation of the field selector depends on the current
  1705.      * rounding mode. The rounding mode selector can be
  1706.      * round down (N_MODE), round to nearest page (S_MODE), round up (D_MODE),
  1707.      * or round down with adjusted constant (R_MODE).
  1708.      * The rounding mode is persistent until explicity changed by
  1709.      * a mode select fixup request. The default at the begining of each
  1710.      * subspace is N_MODE.
  1711.      *
  1712.      * The function fieldGetDefault() computes the field selector
  1713.      * (and adjusted constant if we are in R_MODE) based on the current
  1714.      * instruction and rounding mode. It also computes how to
  1715.      * apply the rounded constant to a given instruction.
  1716.      */
  1718.     int fixConstant;            /* adjusted constant used in R_MODE rounding */
  1719.     int modeSel;                /* mode select */
  1720.     int fieldSel;               /* field select */
  1721.     int fieldOverride; /* field select override flag */
  1722.     int dataOverride;           /* data override flag */
  1723.     int relFormat; /* how to apply the rounded constant */
  1725.     /* 
  1726.      * variables for stub manipulation.
  1727.      *
  1728.      * The linker must generate "long branch stubs" and "parameter
  1729.      * relocation stubs" whenever needed. Read the INTERNAL
  1730.      * comments at the begining of the file for more info.
  1731.      * The long branch stubs are generated per subspace, while
  1732.      * the parameter relocation stubs are generated per module.
  1733.      */
  1735.     LIST stubList;              /* list of current long branch stubs */
  1736.     char *pLongBranchStubs;     /* starting address this subspaces stubs */
  1737.     char *pStub;                /* address of current stub */
  1738.     int stubIx;                 /* current stubs index in the list */
  1740.     LIST argRelocStubList; /* list of argument relocation stubs */
  1742.     /*
  1743.      * variables for stack unwind generation
  1744.      *
  1745.      * The PA-RISC has no frame pointer. To calculate the frame pointer,
  1746.      * the linker must generate an array of stack unwind descriptors
  1747.      * which, for each function, specifies its starting address, ending
  1748.      * address, and the amount of stack space it requires. 
  1749.      */
  1751.     LIST unwindList; /* linked list of unwind descriptors */
  1752.     UNWIND_NODE *pUnwindNode = NULL; /* pointer to an unwind descriptor */
  1754.     /* scratch variables */
  1756.     char *tmpBuf;               /* tempoaray buffer */
  1757.     int bufSize;                /* size of temporary buffer */
  1759.     /* create the expression stack */
  1761.     if ((pExpStack = (int *) calloc (1, REL_STACK_SIZE)) == NULL)
  1762.         {
  1763.         printErr ("ld error: unable to allocate relocation stackn");
  1764.         return (ERROR);
  1765.         }
  1767.     /* Initialize the previous fixup queue */
  1769.     lstInit (&prevFixupList);
  1770.     for (ix = 0; ix < 4; ix++)
  1771.         {
  1772.         lstAdd (&prevFixupList, &(prevFixupNodes[ix].node));
  1773.         prevFixupNodes[ix].pFixup = NULL;
  1774.         }
  1776.     /* initialize the list of long branch and parameter relocation stubs */
  1778.     lstInit (&stubList);
  1779.     lstInit (&argRelocStubList);
  1781.     /* initialize the stack unwind list */
  1783.     lstInit (&unwindList);
  1785.     /* perform linker fixups on each subspace */
  1787.     for (ix = 0; ix < nSubs; ix ++, pSubspace++)
  1788.         {
  1789.         if (!pSubspace->is_loadable)
  1790.             {
  1791.             DBG_PUT ("linker: skipping fixups for unloadable subspacen");
  1792.             continue;
  1793.             }
  1795.         if (pSubspace->fixup_request_quantity == 0)
  1796.             {
  1797.             continue;
  1798.             }
  1800.         DBG_PUT ("nnnsubSpace: 0x%x - 0x%xn", (int)(pSubInfo[ix].loadAddr),
  1801.                  (int)(pSubInfo[ix].loadAddr) + pSubspace->subspace_length);
  1803.         /* Initialize the long branch stub list for this subspace to be empty */
  1805.         lstFree (&stubList);
  1806.         pLongBranchStubs = pSubInfo[ix].loadAddr +
  1807.                            pSubspace->subspace_length;
  1808.         pLongBranchStubs = (char *)ROUND_UP (pLongBranchStubs,
  1809.                            pSubspace->alignment);
  1811.         /* get the starting address for this subspace */
  1813.         relAdr = (pSubInfo + ix)->loadAddr;
  1815.         /* get the list of fixup requests for this subspace */
  1817.         pThisFixup = pRelCmds + pSubspace->fixup_request_index;
  1818.         pLastFixup = pThisFixup + pSubspace->fixup_request_quantity;
  1820.         /* set some default modes */
  1822.         modeSel = R_N_MODE; /* default rounding mode for each subspace */
  1823.         fieldSel = R_FSEL;      /* default field selector. XXX - needed? */
  1824.         dataOverride = FALSE;
  1825.         fieldOverride = FALSE;
  1826.         usingPrevFixup = FALSE;
  1827.         sp = pExpStack; /* each subspace starts with a fresh
  1828.                                  * expression stack. XXX - added */
  1830.         /* process this subspaces fixups in a huge switch statement */
  1832.         while (pThisFixup < pLastFixup)
  1833.             {
  1834.             opCode = *pThisFixup;
  1835.             DBG_PUT ("opCode (0x%x) = %d. relAdr = 0x%x.n", (int)pThisFixup,
  1836.                      opCode, (int)relAdr);
  1838.             /* keep track of the last 4 multibyte fixup requests */
  1840.             if (fixupLen[opCode] > 1)
  1841.                 {
  1842.                 pPrevFixupNode = (PREV_FIXUP *)lstNth (&prevFixupList, 4);
  1843.                 lstDelete (&prevFixupList, &(pPrevFixupNode->node));
  1844.                 pPrevFixupNode->pFixup = pThisFixup;
  1845.                 lstInsert (&prevFixupList, NULL, &(pPrevFixupNode->node));
  1846.                 }
  1847.             pThisFixup++;
  1849.             /* perform the fixup based on the opCode */
  1851.             if (/* opCode >= R_NO_RELOCATION && */ opCode < R_ZEROES )
  1852.                 {
  1853.                 /* 00-1f: n words, not relocatable */
  1854.                 if (opCode < 24)
  1855.                     {
  1856.                     D = opCode - R_NO_RELOCATION;
  1857.                     L = (D + 1) * 4;
  1858.                     }
  1859.                 else if (opCode >= 24 && opCode < 28)
  1860.                     {
  1861.                     D = opCode - 24;
  1862.                     L = ((D << 8) + B1 + 1) * 4;
  1863.                     }
  1864.                 else if (opCode >= 28 && opCode < 31)
  1865.                     {
  1866.                     D = opCode - 28;
  1867.                     L = ((D << 16) + B2 + 1) * 4;
  1868.                     }
  1869.                 else
  1870.                     {
  1871.                     D = opCode - 31;
  1872.                     L = B3 + 1;
  1873.                     }
  1874.                 DBG_PUT ("R_NO_RELOCATION: 0x%x bytesn", L);
  1875.                 relAdr += L;
  1876.                 }
  1878.             else if (opCode >= R_ZEROES && opCode < R_UNINIT)
  1879.                 {
  1880.                 /* 20-21: n words, all zero */
  1881.                 if (opCode == R_ZEROES)
  1882.                     {
  1883.                     L = (B1 + 1) * 4;
  1884.                     }
  1885.                 else
  1886.                     {
  1887.                     L = B3 + 1;
  1888.                     }
  1889.                 /* insert L bytes zero */
  1891.                 bufSize = (int)(pSubInfo+ix)->loadAddr +
  1892.                         pSubspace->subspace_length - (int)relAdr;
  1893.                 tmpBuf = malloc (bufSize); 
  1894.                 if (tmpBuf == NULL)
  1895.                         printErr ("ld error: reloc malloc failedn");
  1896.                 DBG_PUT ("inserting %d zeros at 0x%xn",
  1897.                             L, (int)relAdr);
  1898.                 bcopy (relAdr, tmpBuf, bufSize);
  1899.                 bzero (relAdr, L);
  1900.                 relAdr += L;
  1901.                 bcopy (tmpBuf, relAdr, bufSize - L);
  1902.                 free ((char *) tmpBuf);
  1903.                 }
  1905.             else if (opCode >= R_UNINIT && opCode < R_RELOCATION)
  1906.                 {
  1907.                 /* 22-23: n words, uninitialized */
  1908.                 if (opCode == R_UNINIT)
  1909.                     {
  1910.                     L = (B1 + 1) * 4;
  1911.                     }
  1912.                 else
  1913.                     {
  1914.                     L = B3 + 1;
  1915.                     }
  1917.                 /* skip L bytes */
  1918.                 bufSize = (int)(pSubInfo+ix)->loadAddr +
  1919.                                 pSubspace->subspace_length - (int)relAdr;
  1920.                 tmpBuf = malloc (bufSize); 
  1921.                 if (tmpBuf == NULL)
  1922.                         printErr ("ld error: reloc malloc failedn");
  1923.                 DBG_PUT ("skipping %d bytes at 0x%x.n", L, (int)relAdr);
  1924.                 bcopy ((char *) relAdr, tmpBuf, bufSize);
  1925.                 bzero (relAdr, L);
  1926.                 relAdr += L;
  1927.                 bcopy (tmpBuf, relAdr, bufSize - L);
  1928.                 free ((char *) tmpBuf);
  1929.                 }
  1931.             else if (opCode == R_RELOCATION)
  1932.                 { /* XXX - untested */
  1933.                 /* 24: 1 word relocatable data */
  1934.                 relValue = *(int *)relAdr + (int)(pSubInfo[ix].loadAddr);
  1935.                 *((unsigned int *)(relAdr)) = relValue;
  1936.                 WARN ("Warning: R_RELOCATION fixup is untestedn");
  1937.                 WARN ("address = 0x%xn", (int)relAdr);
  1938.                 relAdr += 4;
  1939.                 }
  1941.             else if (opCode >= R_DATA_ONE_SYMBOL && opCode < R_DATA_PLABEL)
  1942.                 {
  1943.                 /* 25-26: 1 word, data external reference */
  1944.                 if (opCode == R_DATA_ONE_SYMBOL)
  1945.                     {
  1946.                     S = B1;
  1947.                     }
  1948.                 else
  1949.                     {
  1950.                     S = B3;
  1951.                     }
  1952.                 relValue = *(int *)relAdr + (pSym + S)->symbol_value;
  1953.                 *((int *)relAdr) = relValue;
  1954.                 DBG_PUT ("R_DATA_ONE_SYMBOL: relAdr = 0x%xn", (int)relAdr);
  1955.                 relAdr +=4;
  1956.                 }
  1958.             else if (opCode >= R_DATA_PLABEL && opCode < R_SPACE_REF)
  1959.                 {
  1960.                 /* 27-28: 1 word, data plabel reference */
  1961.                 if (opCode == R_DATA_PLABEL)
  1962.                     {
  1963.                     S = B1;
  1964.                     }
  1965.                 else
  1966.                     {
  1967.                     S = B3;
  1968.                     }
  1969.                 relValue = ((SYMREC *)(pSym + S))->symbol_value;
  1970.                 *((int *)relAdr) = relValue;
  1971.                 DBG_PUT ("R_DATA_PLABEL: relAdr = 0x%xn", (int)relAdr);
  1972.                 relAdr += 4;
  1973.                 }
  1975.             else if (opCode == R_SPACE_REF)
  1976.                 {
  1977.                 /* 29: 1 word, initialized space id */
  1978.                 printErr ("ld error: R_SPACE_REF relocation unsupportedn");
  1979.                 status = ERROR;
  1980.                 }
  1982.             else if (opCode >= R_REPEATED_INIT && opCode < 46)
  1983.                 {
  1984.                 /* 30-3d: n words, repeated pattern */
  1986.                 if (opCode == R_REPEATED_INIT)
  1987.                     {
  1988.                     L = 4;
  1989.                     M = (B1 + 1) * 4;
  1990.                     }
  1991.                 else if (opCode == (R_REPEATED_INIT + 1))
  1992.                     {
  1993.                     L = B1 * 4;
  1994.                     M = (B1 + 1) * L;
  1995.                     }
  1996.                 else if (opCode == (R_REPEATED_INIT + 2))
  1997.                     {
  1998.                     L = B1 * 4;
  1999.                     M = (B3 + 1) * 4;
  2000.                     }
  2001.                 else
  2002.                     {
  2003.                     L = B3 + 1;
  2004.                     M = B4 + 1;
  2005.                     }
  2006.                 DBG_PUT ("Bcopy R_REPEATED_INITn");
  2007.                 bcopy (relAdr, relAdr + L, M);
  2008.                 relAdr += M + L;
  2009.                 }
  2011.             else if (opCode >= R_PCREL_CALL && opCode < 62)
  2012.                 {
  2013.                 /* 3e-3f: 1 word, pc-relative call */
  2014.                 if (opCode >= R_PCREL_CALL && opCode < (R_PCREL_CALL + 10))
  2015.                     {
  2016.                     D = opCode - R_PCREL_CALL;
  2017.                     R = rbits1 (D);
  2018.                     S = B1;
  2019.                     }
  2020.                 else if (opCode >= (R_PCREL_CALL + 10) && 
  2021.                          opCode < (R_PCREL_CALL + 12))
  2022.                     {
  2023.                     D = opCode - (R_PCREL_CALL + 10);
  2024.                     R = rbits2 ((D << 8) + B1);
  2025.                     S = B1;
  2026.                     }
  2027.                 else
  2028.                     {
  2029.                     D = opCode - (R_PCREL_CALL + 12);
  2030.                     R = rbits2 ((D << 8) + B1);
  2031.                     S = B3;
  2032.                     }
  2033.                 DBG_PUT ("R_PCREL_CALL %dn", opCode - R_PCREL_CALL);
  2034.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2035.                                  dataOverride, &fieldSel, &relFormat, 
  2036.                                  &fixConstant);
  2038.                 relValue = fieldValue ((int)((pSym+S)->symbol_value - 
  2039.                                         (int)relAdr - 8), fieldSel, 
  2040.                                         modeSel, fixConstant);
  2042.                 /*
  2043.                  * if we are out of range for a PC relative branch,
  2044.                  * then we must create a "long branch stub"
  2045.                  * and patch this routine to jump to the stub 
  2046.                  */
  2048.                 if ( (relValue > 0x3ffff) || (relValue < -0x40000) ||
  2049.                     argRelocDiffer (pSym[S].arg_reloc, R) )
  2050.                     {
  2051.                     stubIx = stubListFind (&stubList, S, R);
  2052.                     if (stubIx == -1)
  2053.                         {
  2054.                         char *procAddr;
  2055. int parm_reloc;
  2057. /* Always add unmodified arg_reloc case first */
  2058. stubIx = stubListFind(&stubList, S, pSym[S].arg_reloc);
  2059. if (stubIx == -1)
  2060.     {
  2061.                             procAddr = (char *) pSym[S].symbol_value;
  2062.     stubIx = stubListAdd (&stubList, S,
  2063.   pSym[S].arg_reloc);
  2064.     pStub = pLongBranchStubs + stubIx*stubSize;
  2065.     DBG_PUT ("Creating long branch stub at 0x%x calling 0x%xn",
  2066.      (int) pStub, pSym[S].symbol_value);
  2067.     stubInit (pStub, (char *) pSym[S].symbol_value);
  2068.     }
  2070. /* See if a parameter reloc stub is needed */
  2071. parm_reloc = (pSym[S].arg_reloc & 0x03f3) | 0x0c;
  2072. if (argRelocDiffer (pSym[S].arg_reloc, R)
  2073.     && !argRelocDiffer (parm_reloc, R))
  2074.     {
  2075.     stubIx = stubListAdd (&stubList, S, parm_reloc);
  2076.     pStub = pLongBranchStubs + stubIx*stubSize;
  2077.                             procAddr = argRelocStubListFind (&argRelocStubList,
  2078.                                           pSym + S, R, moduleId);
  2079.     DBG_PUT ("Creating long branch stub at 0x%x calling 0x%x (0x%x)n",
  2080.      (int) pStub, (int) procAddr,
  2081.      pSym[S].symbol_value);
  2082.     stubInit (pStub, procAddr);
  2083.     }
  2084. if (stubIx == -1)
  2085.     {
  2086.     printErr ("stub not foundn");
  2087.     break;
  2088.     }
  2089.                         }
  2090.                     pStub = pLongBranchStubs + stubIx*stubSize;
  2091.                     relValue = fieldValue ((int)(pStub - (int)relAdr - 8),
  2092.                                            fieldSel, modeSel, fixConstant);
  2093.                     }
  2094.                 fixBits ((INSTR *) relAdr, relValue, relFormat);
  2095.                 FLAG_RESET (fieldOverride);
  2096.                 FLAG_RESET (dataOverride);
  2097.                 relAdr += 4;
  2098.                 }
  2099.             else if (opCode == 62)
  2100. {
  2101. /* SPR 22030: ignore this reserved fixup type */
  2102. }
  2104.             else if (opCode >= R_ABS_CALL && opCode < 78)
  2105.                 {
  2106.                 /* 40-4d: 1 word, absolute call */
  2107.                 /* 4e-4f: reserved */
  2108.                 if ( opCode >= 0x40 && opCode < 0x4a)
  2109.                     {
  2110.                     D = opCode - R_ABS_CALL;
  2111.                     R = rbits1 (D);
  2112.                     S = B1;
  2113.                     }
  2114.                 else if (opCode == 74 || opCode == 75)
  2115.                     {
  2116.                     D = opCode - 74;
  2117.                     R = rbits2 ((D << 8) + B1);
  2118.                     S = B1;
  2119.                     }
  2120.                 else
  2121.                     {
  2122.                     D = opCode - 76;
  2123.                     R = rbits2 ((D << 8) + B1);
  2124.                     S = B3;
  2125.                     }
  2126.                 DBG_PUT ("R_ABS_CALL + %dn", opCode - R_ABS_CALL);
  2127.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2128.                                  dataOverride, &fieldSel, &relFormat, 
  2129.                                  &fixConstant);
  2131.                 /*
  2132.                  * if we are calling a procedure with the wrong parameters,
  2133.                  * then we must generate a "parameter relocation stub"
  2134.                  * and call the stub instead
  2135.                  */
  2137.                 if (argRelocDiffer(R, pSym[S].arg_reloc))
  2138.                     {
  2139.                     tmpBuf = argRelocStubListFind (&argRelocStubList,
  2140.                                           pSym + S, R, moduleId);
  2142.                     relValue = fieldValue ((int)(tmpBuf), fieldSel,
  2143.                                             modeSel, fixConstant);
  2144.                     }
  2145.                 else
  2146.                     {
  2147.                     relValue = fieldValue (
  2148.                         (int)(pSym[S].symbol_value),
  2149.                         fieldSel, modeSel, fixConstant);
  2150.                     }
  2151.                 fixBits ((INSTR *) relAdr, relValue, relFormat);
  2152.                 FLAG_RESET (fieldOverride);
  2153.                 FLAG_RESET (dataOverride);
  2154.                 relAdr += 4;
  2155.                 }
  2157.             else if (opCode >= R_DP_RELATIVE && opCode < 114)
  2158.                 {
  2159.                 /* 50-72: 1 word, dp-relative load/store */
  2160.                 /* 73-77: reserved */
  2161.                 if (opCode == 112)
  2162.                     {
  2163.                     S = B1;
  2164.                     }
  2165.                 else if (opCode == 113)
  2166.                     {
  2167.                     S = B3;
  2168.                     }
  2169.                 else
  2170.                     {
  2171.                     D = opCode - R_DP_RELATIVE;
  2172.                     S = D;
  2173.                     }
  2175.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2176.                                  dataOverride, &fieldSel, &relFormat, 
  2177.                                  &fixConstant);
  2178.                 if (pSymGlobal == NULL)
  2179.                     {
  2180.                     printErr ("ld error: no $global$n");
  2181.                     status = ERROR;
  2182.                     }
  2183.                 else
  2184.                     {
  2185.                     relValue = (int)((pSym+S)->symbol_value) - 
  2186.                                pSymGlobal->symbol_value;
  2187.                     relValue = fieldValue (relValue, fieldSel, modeSel, 
  2188.                                            fixConstant);
  2189.                     fixBits ((INSTR *) relAdr, relValue, relFormat);
  2190.                     }
  2191.                 DBG_PUT ("R_DP_RELATIVE at 0x%xn", (int)relAdr);
  2192.                 FLAG_RESET (fieldOverride);
  2193.                 FLAG_RESET (dataOverride);
  2194.                 relAdr += 4;
  2195.                 }
  2197.             else if (opCode >= R_DLT_REL && opCode < 122)
  2198.                 {
  2199.                 /* 78-79: 1 word, dlt-relative load/store */
  2200.                 if (opCode == R_DLT_REL)
  2201.                     {
  2202.                     S = B1;
  2203.                     }
  2204.                 else
  2205.                     {
  2206.                     S = B3;
  2207.                     }
  2208.                 printErr ("ld error: R_DLT_REL relocation unsupportedn");
  2209.                 status = ERROR;
  2210.                 relAdr += 4;
  2211.                 }
  2213.             else if (opCode >= R_CODE_ONE_SYMBOL && opCode < 162)
  2214.                 {
  2215.                 /* 80-a2: 1 word, relocatable code */
  2216.                 /* a3-ad: reserved */
  2217.                 if (opCode == 160)
  2218.                     {
  2219.                     S = B1;
  2220.                     }
  2221.                 else if (opCode == 161)
  2222.                     {
  2223.                     S = B3;
  2224.                     }
  2225.                 else
  2226.                     {
  2227.                     D = opCode - R_CODE_ONE_SYMBOL;
  2228.                     S = D;
  2229.                     }
  2230.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2231.                                  dataOverride, &fieldSel, &relFormat, 
  2232.                                  &fixConstant);
  2233.                 relValue = fieldValue ((int)((pSym + S)->symbol_value),
  2234.                                         fieldSel, modeSel, fixConstant);
  2235.                 DBG_PUT ("    fieldValue(0x%x, %d, %d, 0x%x) = 0x%xn",
  2236.  (int)((pSym + S)->symbol_value),
  2237.  fieldSel, modeSel, fixConstant, relValue);
  2238.                 fixBits ((INSTR *) relAdr, relValue, relFormat);
  2239.                 FLAG_RESET (fieldOverride);
  2240.                 FLAG_RESET (dataOverride);
  2241.                 DBG_PUT ("R_CODE_ONE_SYMBOL at 0x%xn", (int)relAdr);
  2242.                 DBG_PUT ("    symVal= 0x%x fixConst= 0x%x, relValue= 0x%xn",
  2243.  (int)((pSym + S)->symbol_value), fixConstant,
  2244.  relValue);
  2245.                 relAdr += 4;
  2246.                 }
  2248.             else if (opCode >= R_MILLI_REL && opCode < R_CODE_PLABEL)
  2249.                 {
  2250.                 /* ae-af: 1 word, millicode-relative branch */
  2251.                 if (opCode == R_MILLI_REL)
  2252.                     {
  2253.                     S = B1;
  2254.                     }
  2255.                 else
  2256.                     {
  2257.                     S = B3;
  2258.                     }
  2259.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2260.                                  dataOverride, &fieldSel, &relFormat, 
  2261.                                  &fixConstant);
  2262.                 WARN ("Warning: R_MILLI_REL fixup is untestedn");
  2263.                 WARN ("address = 0x%xn", (int)relAdr);
  2264.                 relValue = fieldValue ((pSym[S].symbol_value -
  2265.                                        pSym[1].symbol_value + fixConstant),
  2266.                                        fieldSel, modeSel, fixConstant);
  2267.                 fixBits ((INSTR *) relAdr, relValue, relFormat); 
  2268.                 FLAG_RESET (fieldOverride);
  2269.                 FLAG_RESET (dataOverride);
  2270.                 relAdr += 4;
  2271.                 }
  2273.             else if (opCode >= R_CODE_PLABEL && opCode < R_BREAKPOINT)
  2274.                 {
  2275.                 /* b0-b1: 1 word, code plabel reference */
  2276.                 if (opCode == R_CODE_PLABEL)
  2277.                     {
  2278.                     S = B1;
  2279.                     }
  2280.                 else
  2281.                     {
  2282.                     S = B3;
  2283.                     }
  2284.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride, 
  2285.                                  dataOverride, &fieldSel, &relFormat, 
  2286.                                  &fixConstant);
  2287.                 if (fixConstant != 0 && fixConstant != 2)
  2288.                     printErr ("R_CODE_PLABEL: wrong displacement valuen");
  2289.                 relValue = fieldValue ((int)(pSym + S)->symbol_value, 
  2290.                                        fieldSel, modeSel, fixConstant);
  2291.                 fixBits ((INSTR *) relAdr, relValue, relFormat);
  2292.                 FLAG_RESET (fieldOverride);
  2293.                 FLAG_RESET (dataOverride);
  2294.                 relAdr += 4;
  2295.                 }
  2297.             else if (opCode == R_BREAKPOINT)
  2298.                 {
  2299.                 /* b2: 1 word, statement breakpoint */
  2300.                 *(int *)relAdr = 0;
  2301.                 DBG_PUT ("R_BREAKPOINT at address 0x%xn", (int)relAdr);
  2302.                 relAdr += 4;
  2303.                 }
  2305.             else if (opCode >= R_ENTRY && opCode < R_ALT_ENTRY)
  2306.                 {
  2307.                 /* b3-b4: procedure entry */
  2308.                 if (opCode == R_ENTRY)
  2309.                     {
  2310.                     U = B4; /* unwind descriptor word 3 */
  2311.                     F = B4; /* unwind descriptor word 4 */
  2312.                     }
  2313.                 else
  2314.                     {
  2315.                     U = B4 << 5;
  2316.                     U |= (B1 >> 3);
  2317.                     CHECK_STACK_UNDER;
  2318.                     F = POP_EXPR;
  2319.                     }
  2320.                 DBG_PUT ("proc entry at 0x%xn", (int)relAdr);
  2321.                 pUnwindNode = (UNWIND_NODE *)malloc (sizeof(UNWIND_NODE));
  2322.                 pUnwindNode->unwindDesc.startAddr = relAdr;
  2323.                 pUnwindNode->unwindDesc.word3 = U;
  2324.                 pUnwindNode->unwindDesc.word4 = F;
  2325.                 }
  2327.             else if (opCode == R_ALT_ENTRY)
  2328.                 {
  2329.                 /* b5: alternate entry */
  2330.                 WARN ("alternate entry point at 0x%x ignored!n", (int)relAdr);
  2331.                 }
  2333.             else if (opCode == R_EXIT)
  2334.                 {
  2335.                 /* b6: procedure exit */
  2336.                 DBG_PUT ("proc exit at 0x%xn", (int)relAdr);
  2337.                 if (pUnwindNode == NULL)
  2338.                     {
  2339.                     WARN ("proc exit has no proc entry!n");
  2340.                     }
  2341.                 else
  2342.                     {
  2343.                     pUnwindNode->unwindDesc.endAddr = relAdr - 4;
  2344.                     pUnwindNode->unwindDesc.word3 &= (~0x18000000);
  2345.                     unwindListAdd (&unwindList, pUnwindNode);
  2346.                     }
  2347.                 pUnwindNode = NULL;
  2348.                 }
  2350.             else if (opCode == R_BEGIN_TRY)
  2351.                 {
  2352.                 /* b7: start of try block */
  2353.                 }
  2355.             else if (opCode >= R_END_TRY && opCode < R_BEGIN_BRTAB)
  2356.                 {
  2357.                 /* b8-ba: end of try block */
  2358.                 if (opCode == R_END_TRY)
  2359.                     {
  2360.                     R = 0;
  2361.                     }
  2362.                 else if (opCode == (R_END_TRY + 1))
  2363.                     {
  2364.                     R = B1 * 4;
  2365.                     }
  2366.                 else
  2367.                     {
  2368.                     R = B3 * 4;
  2369.                     }
  2370.                 }
  2372.             else if (opCode == R_BEGIN_BRTAB)
  2373.                 {
  2374.                 /* bb: start of branch table */
  2375.                 }
  2377.             else if (opCode == R_END_BRTAB)
  2378.                 {
  2379.                 /* bc: end of branch table */
  2380.                 }
  2382.             else if (opCode >= R_STATEMENT && opCode < R_DATA_EXPR)
  2383.                 {
  2384.                 /* bd-bf: statement number */
  2385.                 if (opCode == R_STATEMENT)
  2386.                     {
  2387.                     N = B1;
  2388.                     }
  2389.                 else if (opCode == (R_STATEMENT + 1))
  2390.                     {
  2391.                     N = B2;
  2392.                     }
  2393.                 else
  2394.                     {
  2395.                     N = B3;
  2396.                     }
  2397.                 }
  2399.             else if (opCode == R_DATA_EXPR)
  2400.                 { /* XXX - untested */
  2401.                 /* c0: 1 word, relocatable data expr */
  2402.                 CHECK_STACK_UNDER;
  2403.                 relValue = (*(int *)relAdr) + POP_EXPR;
  2404.                 *(int *)relAdr = relValue;
  2405.                 WARN ("Warning: R_DATA_EXPR fixup is untestedn");
  2406.                 WARN ("address = 0x%xn", (int)relAdr);
  2407.                 relAdr += 4;
  2408.                 }
  2410.             else if (opCode == R_CODE_EXPR)
  2411.                 {
  2412.                 /* c1: 1 word, relocatable code expr */
  2413.                 CHECK_STACK_UNDER;
  2414.                 fieldGetDefault (*(unsigned int *)relAdr, fieldOverride,
  2415.                                  dataOverride, 
  2416.                                  &fieldSel, &relFormat, &fixConstant);
  2417.                 relValue = fixConstant + POP_EXPR;
  2418.                 fixBits ((INSTR *) relAdr, relValue, relFormat);
  2419.                 FLAG_RESET (fieldOverride);
  2420.                 FLAG_RESET (dataOverride);
  2421.                 relAdr += 4;
  2422.                 }
  2424.             else if (opCode == R_FSEL)
  2425.                 {
  2426.                 /* c2: F' override */
  2427.                 fieldSel = R_FSEL;
  2428.                 fieldOverride = TRUE;
  2429.                 DBG_PUT ("R_FSELn");
  2430.                 }
  2432.             else if (opCode == R_LSEL)
  2433.                 {
  2434.                 /* c3: L'/LD'/LS'/LR' override */
  2435.                 fieldSel = R_LSEL;
  2436.                 fieldOverride = TRUE;
  2437.                 DBG_PUT ("R_LSELn");
  2438.                 }
  2440.             else if (opCode == R_RSEL)
  2441.                 {
  2442.                 /* c4: R'/RD'/RS'/RR' override */
  2443.                 fieldSel = R_RSEL;
  2444.                 fieldOverride = TRUE;
  2445.                 DBG_PUT ("R_RSELn");
  2446.                 }
  2448.             else if (opCode == R_N_MODE)
  2449.                 {
  2450.                 /* c5: set L'/R' mode */
  2451.                 modeSel = R_N_MODE;
  2452.                 DBG_PUT ("R_N_MODEn");
  2453.                 }
  2455.             else if (opCode == R_S_MODE)
  2456.                 {
  2457.                 /* c6: set LS'/RS' mode */
  2458.                 modeSel = R_S_MODE;
  2459.                 DBG_PUT ("R_N_MODEn");
  2460.                 }
  2462.             else if (opCode == R_D_MODE)
  2463.                 {
  2464.                 /* c7: set LD'/RD' mode */
  2465.                 modeSel = R_D_MODE;
  2466.                 DBG_PUT ("R_D_MODEn");
  2467.                 }
  2469.             else if (opCode == R_R_MODE)
  2470.                 {
  2471.                 /* c8: set LR'/RR' mode */
  2472.                 modeSel = R_R_MODE;
  2473.                 DBG_PUT ("R_R_MODEn");
  2474.                 }
  2476.             else if (opCode >= R_DATA_OVERRIDE && opCode < R_TRANSLATED)
  2477.                 {
  2478.                 /* c9-cd: get data from fixup area */
  2479.                 if (opCode == 201)
  2480.                     V = 0;
  2481.                 else if (opCode == 202)
  2482.                     V = sign_ext (B1, 8);
  2483.                 else if (opCode == 203)
  2484.                     V = sign_ext (B2, 16);
  2485.                 else if (opCode == 204)
  2486.                     V = sign_ext (B3, 24);
  2487.                 else /* opCode == 205 */
  2488.                     V = B4;
  2489.                 fixConstant = V;
  2490.                 dataOverride = TRUE;
  2491.                 }
  2493.             else if (opCode == R_TRANSLATED)
  2494.                 {
  2495.                 /* ce: toggle translated mode */
  2496.                 printErr ("ld error: R_TRANSLATED not supportedn");
  2497.                 }
  2499.             else if (opCode == R_AUX_UNWIND)
  2500.                 {
  2501.                 /* cf: auxiliary unwind (proc begin) */
  2502.                 int SK;
  2503.                 int SN;
  2504.                 int CN;
  2506.                 CN = B3;
  2507.                 SN = B4;
  2508.                 SK = B4;
  2509.                 }
  2511.             else if (opCode == R_COMP1)
  2512.                 {
  2513.                 /* d0: arbitrary expression */
  2514.                 opCode2 = B1;
  2515.                 V = opCode2 & 0x3f;
  2516.                 C = opCode2 & 0x1f;
  2517.                 switch (opCode2)
  2518.                     {
  2519.                     case R_PUSH_PCON1:
  2520.                         CHECK_STACK_OVER;
  2521.                         PUSH_EXPR (abs(V));
  2522.                         break;
  2523.                     case R_PUSH_DOT:
  2524.                         CHECK_STACK_OVER;
  2525.                         PUSH_EXPR ((int)relAdr);
  2526.                         break;
  2527.                     case R_MAX:
  2528.                         CHECK_STACK_UNDER;
  2529.                         top1 = POP_EXPR;
  2530.                         CHECK_STACK_UNDER;
  2531.                         top2 = POP_EXPR;
  2532.                         CHECK_STACK_OVER;
  2533.                         PUSH_EXPR (max (top1, top2));
  2534.                         break;
  2535.                     case R_MIN:
  2536.                         CHECK_STACK_UNDER;
  2537.                         top1 = POP_EXPR;
  2538.                         CHECK_STACK_UNDER;
  2539.                         top2 = POP_EXPR;
  2540.                         CHECK_STACK_OVER;
  2541.                         PUSH_EXPR (min (top1, top2));
  2542.                         break;
  2543.                     case R_ADD:
  2544.                         CHECK_STACK_UNDER;
  2545.                         top1 = POP_EXPR;
  2546.                         CHECK_STACK_UNDER;
  2547.                         top2 = POP_EXPR;
  2548.                         CHECK_STACK_OVER;
  2549.                         PUSH_EXPR (top1 + top2);
  2550.                         break;
  2551.                     case R_SUB:
  2552.                         CHECK_STACK_UNDER;
  2553.                         top1 = POP_EXPR;
  2554.                         CHECK_STACK_UNDER;
  2555.                         top2 = POP_EXPR;
  2556.                         CHECK_STACK_OVER;
  2557.                         PUSH_EXPR (top2 - top1);
  2558.                         break;
  2559.                     case R_MULT:
  2560.                         CHECK_STACK_UNDER;
  2561.                         top1 = POP_EXPR;
  2562.                         CHECK_STACK_UNDER;
  2563.                         top2 = POP_EXPR;
  2564.                         CHECK_STACK_OVER;
  2565.                         PUSH_EXPR (top1 * top2);
  2566.                         break;
  2567.                     case R_DIV:
  2568.                         CHECK_STACK_UNDER;
  2569.                         top1 = POP_EXPR;
  2570.                         CHECK_STACK_UNDER;
  2571.                         top2 = POP_EXPR;
  2572.                         CHECK_STACK_OVER;
  2573.                         PUSH_EXPR (top2 / top1);
  2574.                         break;
  2575.                     case R_MOD:
  2576.                         CHECK_STACK_UNDER;
  2577.                         top1 = POP_EXPR;
  2578.                         CHECK_STACK_UNDER;
  2579.                         top2 = POP_EXPR;
  2580.                         CHECK_STACK_OVER;
  2581.                         PUSH_EXPR (top2 % top1);
  2582.                         break;
  2583.                     case R_AND:
  2584.                         CHECK_STACK_UNDER;
  2585.                         top1 = POP_EXPR;
  2586.                         CHECK_STACK_UNDER;
  2587.                         top2 = POP_EXPR;
  2588.                         CHECK_STACK_OVER;
  2589.                         PUSH_EXPR (top1 & top2);
  2590.                         break;
  2591.                     case R_OR:
  2592.                         CHECK_STACK_UNDER;
  2593.                         top1 = POP_EXPR;
  2594.                         CHECK_STACK_UNDER;
  2595.                         top2 = POP_EXPR;
  2596.                         CHECK_STACK_OVER;
  2597.                         PUSH_EXPR (top1 | top2);
  2598.                         break;
  2599.                     case R_XOR:
  2600.                         CHECK_STACK_UNDER;
  2601.                         top1 = POP_EXPR;
  2602.                         CHECK_STACK_UNDER;
  2603.                         top2 = POP_EXPR;
  2604.                         CHECK_STACK_OVER;
  2605.                         PUSH_EXPR (top1 ^ top2);
  2606.                         break;
  2607.                     case R_NOT: 
  2608.                         CHECK_STACK_UNDER;
  2609.                         top1 = POP_EXPR;
  2610.                         CHECK_STACK_OVER;
  2611.                         PUSH_EXPR (~top1);
  2612.                         break;
  2613.                     case R_LSHIFT:
  2614.                         if (C == 0)
  2615.                             {
  2616.                             CHECK_STACK_UNDER;
  2617.                             top1 = POP_EXPR;
  2618.                             CHECK_STACK_UNDER;
  2619.                             top2 = POP_EXPR;
  2620.                             CHECK_STACK_OVER;
  2621.                             PUSH_EXPR (top2 << top1);
  2622.                             }
  2623.                         else
  2624.                             {
  2625.                             top1 = POP_EXPR;
  2626.                             PUSH_EXPR (top1 << C);
  2627.                             }
  2628.                         break;
  2629.                     case R_ARITH_RSHIFT:
  2630.                         if (C == 0)
  2631.                             {
  2632.                             CHECK_STACK_UNDER;
  2633.                             top1 = POP_EXPR;
  2634.                             CHECK_STACK_UNDER;
  2635.                             top2 = POP_EXPR;
  2636.                             CHECK_STACK_OVER;
  2637.                             PUSH_EXPR (top2 >> top1);
  2638.                             }
  2639.                         else
  2640.                             {
  2641.                             top1 = POP_EXPR;
  2642.                             PUSH_EXPR (top1 >> C);
  2643.                             }
  2644.                         break;
  2645.                     case R_LOGIC_RSHIFT:
  2646.                         if (C == 0)
  2647.                             {
  2648.                             CHECK_STACK_UNDER;
  2649.                             top1 = POP_EXPR;
  2650.                             CHECK_STACK_UNDER;
  2651.                             top2 = POP_EXPR;
  2652.                             PUSH_EXPR (((UINT)top2) >> top1);
  2653.                             }
  2654.                         else
  2655.                             {
  2656.                             top1 = POP_EXPR;
  2657.                             PUSH_EXPR (((UINT)top1) >> C);
  2658.                             }
  2659.                         break;
  2660.                     case R_PUSH_NCON1:
  2661.                         CHECK_STACK_OVER;
  2662.                         PUSH_EXPR (-abs(V));
  2663.                         break;
  2664.                     default:
  2665.                         printErr ("linker: error reading fixupsn");
  2666.                         status = ERROR;
  2667.                         break;
  2668.                     }
  2669.                 }
  2671.             else if (opCode == R_COMP2)
  2672.                 {
  2673.                 /* d1: arbitrary expression */
  2674.                 opCode2 = B1;
  2675.                 S = B3;
  2676.                 L = opCode2 & 1;
  2677.                 switch (opCode2)
  2678.                     {
  2679.                     case R_PUSH_PCON2:
  2680.                         CHECK_STACK_OVER;
  2681.                         PUSH_EXPR (abs(V));
  2682.                         break;
  2683.                     case R_PUSH_SYM:
  2684.                         CHECK_STACK_OVER;
  2685.                         PUSH_EXPR (pSym[S].symbol_value);
  2686.                         break;
  2687.                     case R_PUSH_PLABEL:
  2688.                         CHECK_STACK_OVER;
  2689.                         PUSH_EXPR (pSym[S].symbol_value);
  2690.                         break;
  2691.                     case R_PUSH_NCON2:
  2692.                         CHECK_STACK_OVER;
  2693.                         PUSH_EXPR (-abs(V));
  2694.                         break;
  2695.                     default:
  2696.                         printErr ("linker: error reading fixupsn");
  2697.                         status = ERROR;
  2698.                         break;
  2699.                     }
  2700.                 }
  2702.             else if (opCode == R_COMP3)
  2703.                 {
  2704.                 /* d2: arbitrary expression */
  2705.                 opCode2 = B1;
  2706.                 V = B4;
  2707.                 S = V & 0xffffff;
  2708.                 R = ((opCode2 & 1) << 8) | (V >> 16);
  2709.                 switch (opCode2)
  2710.                     {
  2711.                     case R_PUSH_PROC:
  2712.                         CHECK_STACK_OVER;
  2713.                         if (argRelocDiffer (pSym[S].arg_reloc, R))
  2714.                             relValue = (int)argRelocStubListFind (
  2715.                                           &argRelocStubList, pSym + S, R,
  2716.                                           moduleId);
  2717.                         else
  2718.                             relValue = pSym[S].symbol_value;
  2719.                         PUSH_EXPR (relValue);
  2720.                         break;
  2721.                     case R_PUSH_CONST:
  2722.                         CHECK_STACK_OVER;
  2723.                         PUSH_EXPR (V);
  2724.                         break;
  2725.                     default:
  2726.                         printErr ("linker: error reading fixupsn");
  2727.                         status = ERROR;
  2728.                         break;
  2729.                     }
  2730.                 WARN ("Warning: R_COMP3 fixup is untestedn");
  2731.                 }
  2733.             else if (opCode >= R_PREV_FIXUP && opCode < R_SEC_STMT)
  2734.                 {
  2735.                 /* d3-d6: apply previous fixup again */
  2736.                 X = opCode - R_PREV_FIXUP + 1;
  2737.                 DBG_PUT ("R_PREV_FIXUP - X = %dn", X);
  2739.                 /* remember our old place in the fixup stream */
  2740.                 pOldFixup = pThisFixup;
  2742.                 /* restore old fixup pointer (from list) */
  2743.                 pPrevFixupNode = (PREV_FIXUP *)lstNth (&prevFixupList, X);
  2744.                 if (pPrevFixupNode->pFixup == NULL)
  2745.                     printErr ("fixup request queue emptyn");
  2746.                 pThisFixup = pPrevFixupNode->pFixup;
  2748.                 /* remove old fixup pointer from the list */
  2749.                 lstDelete (&prevFixupList, &(pPrevFixupNode->node));
  2750.                 lstAdd (&prevFixupList, &(pPrevFixupNode->node));
  2751.                 pPrevFixupNode->pFixup = NULL;
  2753.                 usingPrevFixup = TRUE;
  2754.                 continue;
  2755.                 }
  2757.             else if (opCode == R_SEC_STMT)
  2758.                 {
  2759.                 /* d7: secondary statement number */
  2760.                 /* d8-df: reserved */
  2761.                 }
  2763.             else
  2764.                 {        
  2765.                 printErr ("loader: error reading fixup listn");
  2766.                 return (ERROR);
  2767.                 }
  2769.             if (usingPrevFixup)
  2770.                 {
  2771.                 pThisFixup = pOldFixup;
  2772.                 usingPrevFixup = FALSE;
  2773.                 }
  2774.             }
  2775.         }
  2777.     /*
  2778.      * allocate an array of unwind desciptors.
  2779.      * copy the "unwindList" into the array.
  2780.      * add the array as a module segment of type SEGMENT_UNWIND
  2781.      */
  2783.     unwindSegmentCreate (&unwindList, moduleId);
  2785.     /* free up dynamically allocated memory */
  2787.     free ((char *) pExpStack);
  2788.     lstFree (&stubList);
  2789.     lstFree (&argRelocStubList);
  2790.     lstFree (&unwindList);
  2791.     return (status);
  2792.     }
  2794. /*******************************************************************************
  2795. *
  2796. * subspaceToSegment - map subspaces into VxWorks "segments"
  2797. *
  2798. * For each subspace, we decidide if it belongs in the text, data, or
  2799. * bss segment.
  2800. * This routine alse performs partial subspace relocation by setting the
  2801. * subspace load addresses relative to zero. Full relocation will have
  2802. * to wait until we have malloc'ed text, data, and bss segments.
  2803. * We are careful to leave some space ebtween text subspaces for
  2804. * possible "long branch" stub insertion later on.
  2805. * 
  2806. * RETURNS: N/A
  2807. */
  2809. static void subspaceToSegment 
  2810.     (
  2811.     SOM_HDR *    pHpHdr,         /* file header */
  2812.     UCHAR *      pRelocCmds,     /* relocation commands */
  2813.     SUB_INFO *   pSubInfo,       /* pointer to subspace information */
  2814.     SPACE *      pSpace,         /* pointer to space dictionary */ 
  2815.     SUBSPACE *   pSubspace,      /* pointer to subspace dictionary */ 
  2816.     SYMREC *     pSym,           /* pointer to symbol table */
  2817.     SYMTAB_ID    pSymTab,        /* symbol table */
  2818.     int *        pTextSize,      /* returns textsize */
  2819.     int *        pDataSize,      /* returns data size */ 
  2820.     int *        pBssSize        /* returns bss size */ 
  2821.     )
  2822.     {
  2823.     int  ix;
  2824.     int  tSize = 0;
  2825.     int  dSize = 0;
  2826.     int  bSize = 0;
  2827.     int  sizeExtra;
  2829.     /* locate the $LIT$ section */
  2830.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2831.         {
  2832. if (!pSubspace[ix].is_loadable)
  2833.             continue;
  2834. if (!strcmp(pSubspace[ix].subspace_name, "$LIT$"))
  2835.     {
  2836.     tSize = ROUND_UP (tSize, pSubspace[ix].alignment);
  2837.     pSubInfo[ix].loadAddr = (char *)tSize;
  2838.     tSize += pSubspace[ix].subspace_length;
  2839.     pSubInfo[ix].loadType = LOAD_TEXT;
  2840.     }
  2841. }
  2842.     /* locate the $CODE$ section */
  2843.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2844.         {
  2845. if (!pSubspace[ix].is_loadable)
  2846.             continue;
  2847. if (!strcmp(pSubspace[ix].subspace_name, "$CODE$"))
  2848.     {
  2849.     tSize = ROUND_UP (tSize, pSubspace[ix].alignment);
  2850.     pSubInfo[ix].loadAddr = (char *)tSize;
  2851.     tSize += pSubspace[ix].subspace_length;
  2852.     pSubInfo[ix].loadType = LOAD_TEXT;
  2854.     /* compute how much room is needed for long branch stubs */
  2855.     sizeExtra = subspaceSizeExtra (pRelocCmds, &pSubspace[ix], pSym,
  2856.    pHpHdr->symbol_total, pSymTab);
  2858.     DBG_PUT ("subspace %d sizeExtra= 0x%xn", ix, sizeExtra);
  2859.     tSize = ROUND_UP (tSize, pSubspace[ix].alignment);
  2861.     tSize += sizeExtra;
  2862.     }
  2863. }
  2864.     /* locate the $DATA$ section */
  2865.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2866.         {
  2867. if (!pSubspace[ix].is_loadable)
  2868.             continue;
  2869. if (!strcmp(pSubspace[ix].subspace_name, "$DATA$"))
  2870.     {
  2871.     dSize = ROUND_UP (dSize, pSubspace[ix].alignment);
  2872.     pSubInfo[ix].loadAddr = (char *)dSize;
  2873.     dSize += pSubspace[ix].subspace_length;
  2874.     pSubInfo[ix].loadType = LOAD_DATA;
  2875.     }
  2876. }
  2877.     /* locate the $BSS$ section */
  2878.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2879.         {
  2880. if (!pSubspace[ix].is_loadable)
  2881.             continue;
  2882. if (!strcmp(pSubspace[ix].subspace_name, "$BSS$"))
  2883.     {
  2884.     bSize = ROUND_UP (bSize, pSubspace[ix].alignment);
  2885.     pSubInfo[ix].loadAddr = (char *)bSize;
  2886.     bSize += pSubspace[ix].subspace_length;
  2887.     pSubInfo[ix].loadType = LOAD_BSS;
  2888.     }
  2889. }
  2891.     /* set return value */
  2892.     *pTextSize = tSize;
  2893.     *pDataSize = dSize;
  2894.     *pBssSize  = bSize;
  2895.     }
  2897. /*******************************************************************************
  2898. *
  2899. * subspaceNoReloc -
  2900. *
  2901. * Set the load address to be the same as the subspace start address.
  2902. *
  2903. * RETURNS: OK or ERROR
  2904. */
  2906. static void subspaceNoReloc
  2907.     (
  2908.     SOM_HDR *   pHpHdr,         /* file header */
  2909.     SUB_INFO *  pSubInfo,       /* pointer to subspace information */
  2910.     SUBSPACE *  pSubspace       /* pointer to subspace dictionary */
  2911.     )
  2912.     {
  2913.     int   ix;
  2914.     char *name;
  2916.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2917.         {
  2918.         pSubInfo[ix].loadAddr = (char *) (pSubspace[ix].subspace_start);
  2919.         name = pSubspace[ix].subspace_name;
  2920.         if ((int)strstr (name, "BSS"))
  2921.             pSubInfo[ix].loadType = LOAD_BSS;
  2922.         }
  2923.     }
  2925. /*******************************************************************************
  2926. *
  2927. * loadSubspaces - load the subspaces with initial data from the object file.
  2928. *
  2929. * RETURNS: OK or ERROR
  2930. */
  2932. static STATUS loadSubspaces 
  2933.     (
  2934.     int           fd,
  2935.     SOM_HDR *     pHpHdr, 
  2936.     SUB_INFO *    pSubInfo, 
  2937.     SUBSPACE *    pSubspace, 
  2938.     char *        pText, 
  2939.     char *        pData, 
  2940.     char *        pBss
  2941.     )
  2942.     {
  2943.     int      ix;
  2945.     /* loop through each subspace to get info */
  2946.     for (ix = 0; ix < pHpHdr->subspace_total; ix ++)
  2947. {
  2948.         if (!pSubspace[ix].is_loadable || !pSubspace[ix].subspace_length)
  2949.     continue;
  2951.         if (pSubspace[ix].continuation)
  2952.             WARN ("Warning: continuation subspaces are untestedn");
  2954. switch (pSubInfo[ix].loadType)
  2955.     {
  2956.   case LOAD_TEXT:
  2957.     pSubInfo[ix].loadAddr += (int) pText;
  2958.     break;
  2960.   case LOAD_DATA:
  2961.     pSubInfo[ix].loadAddr += (int) pData;
  2962.     break;
  2964.   case LOAD_BSS:
  2965.     pSubInfo[ix].loadAddr += (int) pBss;
  2966.     break;
  2968.   default:
  2969.             WARN ("unknown load typen");
  2970.     break;
  2971.     }
  2973.         DBG_PUT ("subspace %d type= %d addr= 0x%x size= 0x%xn",
  2974.  ix, pSubInfo[ix].loadType, (int)pSubInfo[ix].loadAddr,
  2975.  pSubspace[ix].subspace_length);
  2977.         /* if initialization length == 0, fill subspace with pattern
  2978.          * specified by file_loc_init_value */
  2980. if (pSubspace[ix].initialization_length == 0)
  2981.     {
  2982.             DBG_PUT ("initializing subspace with pattern 0x%xn",
  2983.      pSubspace[ix].file_loc_init_value);
  2984.             *(int *)(pSubInfo[ix].loadAddr)
  2985. = pSubspace[ix].file_loc_init_value;
  2986.             bcopyLongs (pSubInfo[ix].loadAddr, pSubInfo[ix].loadAddr + 4,
  2987.                         (pSubspace[ix].subspace_length - 4)/4);
  2988.             continue;
  2989.             }
  2991.         /* if initialization length != 0, read from file into subspace */
  2993.         if (ioctl (fd, FIOSEEK, pSubspace[ix].file_loc_init_value)
  2994.                    == ERROR ||
  2995.             read (fd, pSubInfo[ix].loadAddr, pSubspace[ix].initialization_length)
  2996.     != pSubspace[ix].initialization_length)
  2997.             {
  2998.             printErr ("loadSubspaces: error reading filen");
  2999.             return (ERROR);
  3000.             }
  3002.         if (pSubspace[ix].replicate_init)
  3003.             {
  3004.             bcopy (pSubInfo[ix].loadAddr,
  3005.    pSubInfo[ix].loadAddr + pSubspace[ix].initialization_length,
  3006.    pSubspace[ix].subspace_length - pSubspace[ix].initialization_length);
  3007.             }
  3009.         }
  3011.     return (OK);
  3012.     }
  3014. /******************************************************************************
  3015. *
  3016. * argRelocDiffer - decide if the two argument relocation bit desciptors
  3017. *                  are compatable.
  3018. *
  3019. * RETURNS: TRUE if an argument relocation stub is needed.
  3020. */
  3022. static BOOL argRelocDiffer (int arg_reloc1, int arg_reloc2)
  3023.     {
  3024.     int i;
  3025.     int reloc1, reloc2;
  3026.     for (i=0; i<5; i++)
  3027.         {
  3028.         reloc1 = arg_reloc1 & 3;
  3029.         reloc2 = arg_reloc2 & 3;
  3030.         if (reloc1 && reloc2 && (reloc1 != reloc2))
  3031.             return (TRUE);
  3032.         arg_reloc1 >>= 2;
  3033.         arg_reloc2 >>= 2;
  3034.         }
  3035.     return (FALSE);
  3036.     }
  3038. /******************************************************************************
  3039. *
  3040. * subspaceSizeExtra - calculate additional space needed for a subspace
  3041. *
  3042. * This routine calculates additional storage space needed for each
  3043. * subspace. It is used to reserve space for "long branch stubs"
  3044. * which we must insert later if a fixup request for a PC relative call
  3045. * can't be stuffed into a 19 bit immediate.
  3046. *
  3047. * RETURNS number of additional bytes needed
  3048. */
  3050. static int subspaceSizeExtra
  3051.     (
  3052.     UCHAR *    pRelCmds,        /* address of relocation commands */
  3053.     SUBSPACE * pSubspace,       /* subspace index */
  3054.     SYMREC *   pSym,            /* pointer to symbol records */
  3055.     int        numSyms,         /* maximun number of symbols */
  3056.     SYMTAB_ID  symTblId
  3057.     )
  3058.     {
  3059.     UCHAR *  pNextFixup;             /* current fixup request pointer */
  3060.     UCHAR *  pLastFixup;             /* last fixup request pointer */
  3061.     UCHAR    opCode;                 /* fixup request opCode */
  3062.     int      symNum;
  3063.     int      R;
  3065.     LIST     stubList;
  3066.     int      numStubs;
  3068.     lstInit (&stubList);
  3070.     if (pSubspace->fixup_request_quantity == 0)
  3071.         return (0);
  3073.     pNextFixup = pRelCmds + pSubspace->fixup_request_index;
  3074.     pLastFixup = pNextFixup + pSubspace->fixup_request_quantity;
  3076.     while (pNextFixup < pLastFixup)
  3077.         {
  3078.         opCode = *pNextFixup;
  3079.         R = 0;
  3081.         /* do we have a pc-relative call fixup request? */
  3083.         /* SPR 22030 :Changed R_ABS_CALL below to 62 */
  3084.         if ( (opCode >= R_PCREL_CALL) && (opCode < 62) )
  3085.             {
  3086.             /* if so, get the symbol index we are calling */
  3087.             if (opCode <= 57)
  3088.                 {
  3089.                 R = rbits1 ((int)opCode - R_PCREL_CALL);
  3090.                 symNum = *(pNextFixup + 1);
  3091.                 }
  3092.             else if (opCode <= 59)
  3093.                 {
  3094.                 R = rbits2 ( (((int)opCode - 58)<<8) + *(pNextFixup+1) );
  3095.                 symNum = *(pNextFixup + 2);
  3096.                 }
  3097.             else
  3098.                 {
  3099.                 R = rbits2 ( (((int)opCode - 60)<<8) + *(pNextFixup+1) );
  3100.                 symNum = ((int)(*(pNextFixup + 2)) << 16) +
  3101.                          ((int)(*(pNextFixup + 3)) << 8) +
  3102.                          *(pNextFixup + 4);
  3103.                 }
  3104.             DBG_PUT ("sizeExtra: symNum = %d n", symNum);
  3105.             if (stubListFind (&stubList, symNum, R) == -1)
  3106. {
  3107. SYMREC tmp;
  3108. int arg_reloc;
  3109. int parm_reloc;
  3111. if (externSymResolve(symTblId, pSym[symNum].symbol_name, &tmp) == OK)
  3112.     arg_reloc = tmp.arg_reloc;
  3113.                 else
  3114.     arg_reloc = pSym[symNum].arg_reloc;
  3115.                 if (!arg_reloc)
  3116.     WARN("symbol %s has arg_reloc of zero.n",
  3117. pSym[symNum].symbol_name);
  3119. /* Now make sure we don't get a duplicate entry */
  3120. if (stubListFind(&stubList, symNum, tmp.arg_reloc) == -1)
  3121.     stubListAdd (&stubList, symNum, tmp.arg_reloc);
  3122. /* Now see if we need a parm reloc stub */
  3123. parm_reloc = (tmp.arg_reloc & 0x03f3) | 0x0c;
  3124. if (argRelocDiffer(R, tmp.arg_reloc)
  3125.     && !argRelocDiffer(R, parm_reloc))
  3126.     {
  3127.     stubListAdd (&stubList, symNum, parm_reloc);
  3128.     }
  3129.                 }
  3130.             }
  3132.         if (fixupLen [opCode] == 0)
  3133.             {
  3134.             printErr ("subspaceSizeExtra: error reading fixup table.n");
  3135.             break;
  3136.             }
  3138.         pNextFixup += fixupLen [opCode];
  3139.         }
  3141.     numStubs = lstCount (&stubList);
  3142.     lstFree (&stubList);
  3143.     return (numStubs*stubSize);
  3144.     }
  3146. /******************************************************************************
  3147. *
  3148. * externSymResolve - look up a MY_SYMBOL in the VxWorks symbol table.
  3149. */
  3151. static BOOL externSymResolve
  3152.     (
  3153.     SYMTAB_ID symTblId,
  3154.     char *    name,
  3155.     SYMREC *  pSym
  3156.     )
  3157.     {
  3158.     MY_SYMBOL *pSymbol;
  3159.     MY_SYMBOL keySym;
  3161.     keySym.name = name;
  3162.     keySym.type = N_EXT;
  3163.     pSymbol = (MY_SYMBOL *)hashTblFind (symTblId->nameHashId,
  3164.                                        &keySym.nameHNode, N_EXT);
  3166.     if (pSymbol == NULL)
  3167.         return (ERROR);
  3169.     pSym->symbol_value = (int)pSymbol->value;
  3170.     pSym->arg_reloc    = (pSymbol->arg_reloc << 2) | ((pSymbol->type >> 6) & 3);
  3171.     return (OK);
  3172.     }
  3174. /******************************************************************************
  3175. *
  3176. * externSymAdd - add a MY_SYMBOL to the VxWorks symbol table.
  3177. */
  3179. static BOOL externSymAdd
  3180.     (
  3181.     SYMTAB_ID symTblId,
  3182.     char *    name,
  3183.     char      *value,           /* symbol address */
  3184.     SYM_TYPE  type,             /* symbol type */
  3185.     UINT16    group,            /* symbol group */
  3186.     UCHAR     arg_reloc
  3187.     )
  3188.     {
  3189.     SYMBOL *pSymbol = symAlloc (symTblId, name, value, type, group);
  3191.     if (pSymbol == NULL)                        /* out of memory? */
  3192.         return (ERROR);
  3194.     ((MY_SYMBOL *)pSymbol)->arg_reloc = arg_reloc;
  3196.     if (symTblAdd (symTblId, pSymbol) != OK)    /* try to add symbol */
  3197.         {
  3198.         symFree (symTblId, pSymbol);            /* deallocate symbol if fail */
  3199.         return (ERROR);
  3200.         }
  3202.     return (OK);
  3203.     }
  3205. /******************************************************************************
  3206. *
  3207. * rbitsShow - Display the 10 bit argument relocation info in human readable
  3208. *             form.
  3209. */
  3211. static void rbitsShow (int x)
  3212.     {
  3213.     int i;
  3214.     DBG_PUT ("(");
  3215.     for (i=0; i<4; i++)
  3216.         {
  3217.         switch ((x >> (8 - 2*i)) & 3)
  3218.             {
  3219.             case 0:
  3220.                 DBG_PUT ("? ");
  3221.                 break;
  3222.             case 1:
  3223.                 DBG_PUT ("int ");
  3224.                 break;
  3225.             case 2:
  3226.                 DBG_PUT ("float ");
  3227.                 break;
  3228.             case 3:
  3229.                 DBG_PUT ("double ");
  3230.                 break;
  3231.             }
  3232.         DBG_PUT ("arg%d", i);
  3233.         if (i != 3)
  3234.             DBG_PUT (", ");
  3235.         }
  3236.     DBG_PUT (")");
  3237.     DBG_PUT (". Returns: ");
  3238.     switch (x & 3)
  3239.         {
  3240.         case 0:
  3241.             DBG_PUT ("?n");
  3242.             break;
  3243.         case 1:
  3244.             DBG_PUT ("intn");
  3245.             break;
  3246.         case 2:
  3247.             DBG_PUT ("floatn");
  3248.             break;
  3249.         case 3:
  3250.             DBG_PUT ("doublen");
  3251.             break;
  3252.         }
  3253.     }
  3255. /******************************************************************************
  3256. *
  3257. * rbits1 - return the 10 argument relocation bits encoded in a fixup.
  3258. */
  3260. static int rbits1 (int x)
  3261.     {
  3262.     return ( ((0x55 & ~((1 << 2*(4 - (x % 5))) - 1)) << 2) | (x/5));
  3263.     }
  3265. /******************************************************************************
  3266. *
  3267. * rbits2 - return the 10 argument relocation bits encoded in a fixup.
  3268. */
  3270. static int rbits2 (int x)
  3271.     {
  3272.     int args01;
  3273.     int args23;
  3274.     int arg0, arg1, arg2, arg3;
  3276.     args01 = (x>>2) / 10;
  3277.     if (args01 == 9)
  3278.         {
  3279.         arg0 = 0;
  3280.         arg1 = 3;
  3281.         }
  3282.     else
  3283.         {
  3284.         arg0 = args01 / 3;
  3285.         arg1 = args01 % 3;
  3286.         }
  3288.     args23 = (x>>2) % 10;
  3289.     if (args23 == 9)
  3290.         {
  3291.         arg2 = 0;
  3292.         arg3 = 3;
  3293.         }
  3294.     else
  3295.         {
  3296.         arg2 = args23 / 3;
  3297.         arg3 = args23 % 3;
  3298.         }
  3300.     return ((arg0 << 8) | (arg1 << 6) | (arg2 << 4) | (arg3 << 2) | (x & 3));
  3301.     }
  3303. /******************************************************************************
  3304. *
  3305. * stubListFind - find a long branch stub in the list.
  3306. *
  3307. * RETURNS: the index in the list of the stub, or -1 if the stub isn't found.
  3308. */
  3310. static int stubListFind
  3311.     (
  3312.     LIST *stubList,
  3313.     int symNum,
  3314.     int arg_reloc
  3315.     )
  3316.     {
  3317.     STUB_LIST_NODE *pNode;
  3318.     int i = 0;
  3320.     for (pNode = (STUB_LIST_NODE *)lstFirst(stubList);
  3321.         pNode != NULL;
  3322.         pNode = (STUB_LIST_NODE *)lstNext(&(pNode->node)))
  3323.         {
  3324.         if ( (pNode->symNum == symNum) &&
  3325.             !argRelocDiffer (pNode->arg_reloc, arg_reloc))
  3326.             break;
  3327.         i++;
  3328.         }
  3329.     return (pNode == NULL ? -1 : i);
  3330.     }
  3332. /******************************************************************************
  3333. *
  3334. * stubListAdd - add a long branch stub to the list.
  3335. */
  3337. static int stubListAdd
  3338.     (
  3339.     LIST *stubList,
  3340.     int symNum,
  3341.     int arg_reloc
  3342.     )
  3343.     {
  3344.     STUB_LIST_NODE *pNode;
  3346.     pNode = (STUB_LIST_NODE *)malloc (sizeof(STUB_LIST_NODE));
  3347.     pNode->symNum = symNum;
  3348.     pNode->arg_reloc = arg_reloc;
  3349.     lstAdd (stubList, &(pNode->node));
  3350.     return (lstCount(stubList) - 1);
  3351.     }
  3353. /******************************************************************************
  3354. *
  3355. * stubInit - initialize a long branch stub at address stubAddr. The stub
  3356. *            created branches to the procedure at procAddr.
  3357. */
  3359. static void stubInit
  3360.     (
  3361.     char *stubAddr,
  3362.     char *procAddr
  3363.     )
  3364.     {
  3365.     bcopy ((char *)longBranchStub, stubAddr, stubSize);
  3366.     fixBits ((INSTR *)stubAddr, (int)procAddr, i_exp21);
  3367.     fixBits ((INSTR *)(stubAddr+4), (int)procAddr & 0x7ff, i_rel12);
  3368.     }
  3370. /******************************************************************************
  3371. *
  3372. * argRelocStubCreate - create an argument relocation stub.
  3373. *
  3374. * The stub created relocates the arguments from the arg_reloc format
  3375. * to the pSym->arg_reloc format, and then branches to procAddr.
  3376. *
  3377. * RETURNS: the address of the newly created stub. If a stub cannot be
  3378. *          generated (we currently only support one type of stub),
  3379. *          then an error message is printed and NULL is returned.
  3380. */
  3382. static char *argRelocStubCreate
  3383.     (
  3384.     SYMREC * pSym,
  3385.     int      arg_reloc,
  3386.     char *   procAddr
  3387.     )
  3388.     {
  3389.     char *   stubAddr;
  3390.     int      parm_reloc;
  3392.    /*
  3393.     * This is the stub code for parameter relocation if the second parameter
  3394.     * is passed in a double persion floating point register, and must be
  3395.     * move to the general registers.
  3396.     * Currently, this is the only parameter relocation stub this linker
  3397.     * generates, but it would be a simple matter to add others.
  3398.     */
  3400.     static int argReloc_double_to_regs[5] =
  3401.         {
  3402.         0x2fd01227,     /* FSTDS,MA fr7, 8(r30)   */
  3403.         0x0fd91098,     /* LDWS     -4(r30),r24   */
  3404.         0x0fd130b7,     /* LDWS,MB  -8(r30),r23   */
  3405.         0x20200000,     /* LDIL    0, r1          */
  3406.         0xe0202002      /* BE,n    0(s4, r1)      */
  3407.         };
  3409.     parm_reloc = (pSym->arg_reloc & 0x03f3) | 0x0c;
  3410.     if (!argRelocDiffer (parm_reloc, arg_reloc))
  3411.         {
  3412.         int oldLoadSomCoffDebug = loadSomCoffDebug;
  3413.         loadSomCoffDebug = 1;
  3414.         printErr ("Link error: You called %s ");
  3415.         rbitsShow (arg_reloc);
  3416.         printErr ("But it is supposed to be called as ");
  3417.         rbitsShow (pSym->arg_reloc);
  3418.         printErr ("Unable to relocate these parameters between ");
  3419.         printErr ("the floating point and general purpose registers!n");
  3420.         loadSomCoffDebug = oldLoadSomCoffDebug;
  3421.         return (NULL);
  3422.         }
  3424.     stubAddr = (char *)malloc (sizeof (argReloc_double_to_regs));
  3426.     DBG_PUT ("creating arg_reloc stub at 0x%x, which jumps to %sn",
  3427.               (int)stubAddr, pSym->symbol_name);
  3429.     bcopy ((char *)argReloc_double_to_regs, stubAddr,
  3430.            sizeof (argReloc_double_to_regs));
  3431.     fixBits ((INSTR *)(stubAddr + 12), (int)procAddr, i_exp21);
  3432.     fixBits ((INSTR *)(stubAddr + 16), (int)procAddr & 0x7ff, i_rel12);
  3433.     return (stubAddr);
  3434.     }
  3436. /******************************************************************************
  3437. *
  3438. * argRelocStubListAdd - put an argument relocation stub into the list.
  3439. *
  3440. * After the stub is created, we add a node to the list which points to
  3441. * the stub. This way we can keep track of the stubs already generated
  3442. * so we don't generate the same stub twice.
  3443. */
  3445. static BOOL argRelocStubListAdd
  3446.     (
  3447.     LIST *   stubList,
  3448.     SYMREC * pSym,
  3449.     int      arg_reloc,
  3450.     char *   stubAddr
  3451.     )
  3452.     {
  3453.     ARG_RELOC_NODE *pNode;
  3455.     pNode = (ARG_RELOC_NODE *)malloc (sizeof(ARG_RELOC_NODE));
  3456.     if (pNode == NULL)
  3457.         return (ERROR);
  3458.     pNode->pSym = pSym;
  3459.     pNode->arg_reloc = arg_reloc;
  3460.     pNode->stubAddr = stubAddr;
  3461.     lstAdd (stubList, &pNode->node);
  3462.     return (OK);
  3463.     }
  3465. /******************************************************************************
  3466. *
  3467. * argRelocStubListFind - Find an argument relocation stub in the list.
  3468. *                 If it doesn;t exist, create it and add it to the list.
  3469. *
  3470. * RETURNS: the address of the stub.
  3471. */
  3473. static char *argRelocStubListFind
  3474.     (
  3475.     LIST *    stubList,
  3476.     SYMREC *  pSym,
  3477.     int       arg_reloc,
  3478.     MODULE_ID moduleId
  3479.     )
  3480.     {
  3481.     ARG_RELOC_NODE *pNode;
  3482.     char *    stubAddr;
  3483.     int       parm_reloc;
  3485.     for (pNode = (ARG_RELOC_NODE *)lstFirst(stubList);
  3486.         pNode != NULL;
  3487.         pNode = (ARG_RELOC_NODE *)lstNext(&(pNode->node)))
  3488.         {
  3489.         if ( (pNode->pSym == pSym) &&
  3490.             !argRelocDiffer (pNode->arg_reloc, arg_reloc))
  3491.             {
  3492.             DBG_PUT ("found stub at 0x%xn", (int)pNode->stubAddr);
  3493.             return (pNode->stubAddr);
  3494.             }
  3495.         }
  3497.     stubAddr = argRelocStubCreate (pSym, arg_reloc,
  3498.                                   (char *)(pSym->symbol_value));
  3499.     if (stubAddr == NULL)
  3500.         return (NULL);
  3502.     moduleSegAdd (moduleId, SEGMENT_STUB, stubAddr, 0, SEG_FREE_MEMORY);
  3504.     parm_reloc = (arg_reloc & 0x03f3) | 0x0c;
  3505.     if (argRelocStubListAdd (stubList, pSym, parm_reloc, stubAddr) == ERROR)
  3506.         return (NULL);
  3508.     return (stubAddr);
  3509.     }
  3511. /******************************************************************************
  3512. *
  3513. * unwindSegmentCreate - Create a stack unwind segement for a module.
  3514. *
  3515. * This routine takes a sorted linked list of stack unwind descriptors.
  3516. * It uses this list to create an unwind segment for the module.
  3517. * The unwind segment is needed by the stack tracer.
  3518. */
  3520. static void unwindSegmentCreate
  3521.     (
  3522.     LIST *    unwindList,
  3523.     MODULE_ID moduleId
  3524.     )
  3525.     {
  3526.     UNWIND_DESC * unwindArray;
  3527.     UNWIND_NODE * pThisNode;
  3528.     int           numDescs;
  3529.     int           i;
  3531.     numDescs = lstCount(unwindList);
  3533.     unwindArray = calloc (numDescs, sizeof (UNWIND_DESC));
  3535.     if (unwindArray == NULL)
  3536.         {
  3537.         printErr ("load error: can't allocate stack unwind descriptorsn");
  3538.         return;
  3539.         }
  3541.     DBG_PUT ("initializing unwind array of size %d at 0x%xn", 
  3542.               (int)numDescs, (int)unwindArray);
  3544.     for (pThisNode = (UNWIND_NODE *)lstFirst (unwindList), i = 0;
  3545.          (pThisNode != NULL) && (i < numDescs);
  3546.          pThisNode = (UNWIND_NODE *)lstNext (&pThisNode->node), i++)
  3547.         {
  3548.         bcopy ((char *)(&pThisNode->unwindDesc), (char *)(unwindArray + i),
  3549.                sizeof (UNWIND_DESC));
  3550.         }
  3552.     moduleSegAdd (moduleId, SEGMENT_UNWIND, (void *)unwindArray,
  3553.                   sizeof (UNWIND_DESC) * numDescs, SEG_FREE_MEMORY);
  3554.     }
  3556. /******************************************************************************
  3557. *
  3558. * unwindListAdd - add a stack unwind descriptor to a list.
  3559. *
  3560. * The desciptor is sorted into the list.
  3561. */
  3563. static void unwindListAdd
  3564.     (
  3565.     LIST *        unwindList,
  3566.     UNWIND_NODE * pUnwindNode
  3567.     )
  3568.     {
  3569.     UNWIND_NODE * pThisNode;
  3571.     for (pThisNode = (UNWIND_NODE *)lstLast (unwindList);
  3572.          pThisNode != NULL;
  3573.          pThisNode = (UNWIND_NODE *)lstPrevious (&pThisNode->node))
  3574.         {
  3575.         if (pUnwindNode->unwindDesc.startAddr > pThisNode->unwindDesc.startAddr)
  3576.             break;
  3577.         }
  3579.     lstInsert (unwindList, &pThisNode->node, &pUnwindNode->node);
  3580.     }