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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
loadPecoffLib.c
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：58k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

loadPecoffLib.c：源码内容
  1. /* loadPecoffLib.c - pecoff object module loader */
  3. /* Copyright 1998-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01l,11may02,fmk  SPR 77007 - improve common symbol support
  10. 01k,13mar02,pfl  removed GNU_LD_ADDS_VMA, fixed data symbol relocation 
  11.                  calculation (SPR 73145)
  12. 01j,08mar02,pfl  rewind to the beginning of the file before reading the
  13.                  header information (SPR 73136)
  14. 01i,19oct01,pad  Fixed erroneous relocation of non-text segments and made
  15.  compliant with a Microsoft-directed bizarreness (BSS section
  16.  size set in BSS section header's physical address field) in
  17.  the Gnu toolchain (SPR 70767). This fixes SPR 71534 along the
  18.  way. Now discardable sections are really not relocated.
  19.  Now really handles absolute symbols. No longer complains
  20.  because of .stab and .stabstr symbols. Tidied setting of
  21.  errnos and other little things of the like.
  22. 01h,26sep01,jmp  increased MAX_SCNS to 100 (SPR# 63431).
  23. 01g,30nov98,dbt  no longer clear seg.flags<xxx> after loadSegmentAllocate()
  24.                  call. (SPR #23553).
  25. 01f,05oct98,pcn  Initialize all the fields in the SEG_INFO structure.
  26. 01e,23sep98,cym  adding check for STYP_INFO,NO_LOAD,REG,PAD before relocating.
  27. 01d,18sep98,pcn  Set to _ALLOC_ALIGN_SIZE the flags field in seg structure
  28.                  (SPR #21836).
  29. 01c,15sep98,cym  ignoring s_vaddr for relocatable objects until ldsimpc -r
  30.  is fixed to sych it correctly.
  31. 01b,17jul98,pcn  Fixed SPR #21836: alignment mismatch between sections and
  32.                  target.
  33. 01a,19mar98,cym  created from on loadCoffLib.c
  34. */
  36. /*
  37. DESCRIPTION
  38. This library provides an object module loading facility for loading
  39. PECOFF format object files.  The object files are loaded into memory, 
  40. relocated properly, their external references resolved, and their external 
  41. definitions added to the system symbol table for use by other modules and 
  42. from the shell.  Modules may be loaded from any I/O stream.
  44. EXAMPLE
  45. .CS
  46.     fdX = open ("/devX/objFile", READ);
  47.     loadModule (fdX, ALL_SYMBOLS);
  48.     close (fdX);
  49. .CE
  50. This code fragment would load the PECOFF file "objFile" located on
  51. device "/devX/" into memory which would be allocated from the system
  52. memory pool.  All external and static definitions from the file would be
  53. added to the system symbol table.
  55. This could also have been accomplished from the shell, by typing:
  56. .CS
  57.     -> ld (1) </devX/objFile
  58. .CE
  60. INCLUDE FILE: loadLib.h
  62. SEE ALSO: usrLib, symLib, memLib,
  63. .pG "Basic OS"
  64. */
  66. /* includes */
  68. #include "vxWorks.h"
  69. #include "bootLoadLib.h"
  70. #include "cacheLib.h"
  71. #include "errnoLib.h"
  72. #include "fioLib.h"
  73. #include "ioLib.h"
  74. #include "loadLib.h"
  75. #include "memLib.h"
  76. #include "pathLib.h"
  77. #include "stdio.h"
  78. #include "stdlib.h"
  79. #include "string.h"
  80. #include "symLib.h"
  81. #include "symbol.h" /* for SYM_TYPE typedef */
  82. #include "sysSymTbl.h"
  83. #include "private/vmLibP.h"
  84. #include "private/loadLibP.h"
  86. #if CPU==SIMNT
  87. #include "loadPecoffLib.h"
  89. /*  VxWorks Symbol Type definitions.
  90.  *
  91.  *  These are the symbol types for symbols stored in the vxWorks symbol table.
  92.  *  These are currently defined in b_out.h as N_xxx (e.g. N_ABS).
  93.  *  They are defined with new macro names so that they are
  94.  *       independent of the object format.
  95.  *  It would probably be better to define these in symLib.h.
  96.  */
  98. #define VX_ABS 2 /* Absolute symbol */
  99. #define VX_TEXT 4 /* Text symbol */
  100. #define VX_DATA 6 /* Data symbol */
  101. #define VX_BSS 8 /* BSS symbol */
  102. #define VX_EXT 1 /* External symbol (OR'd in with one of above) */
  104. /* 
  105.  * SYM_BASIC_NOT_COMM_MASK and SYM_BASIC_MASK are temporary masks until
  106.  * symbol values are harmonized between host and target sides
  107.  */
  109. #define SYM_BASIC_NOT_COMM_MASK   0x0d   /* basic mask but unset bit two for common symbol */
  110. #define SYM_BASIC_MASK            0x0f   /* only basic types are of interest */
  112. /*
  113.  *  Abridged edition of a object file symbol entry SYMENT
  114.  *
  115.  *  This is used to minimize the amount of malloc'd memory.
  116.  *  The abridged edition contains all elements of SYMENT required
  117.  *  to perform relocation.
  118.  */
  120. struct symentAbridged {
  121. long n_value; /* value of symbol */
  122. short n_scnum; /* section number */
  123. char n_sclass; /* storage class */
  124. char n_numaux;       /* number of auxiliary entries  */
  125. };
  127. #define SYMENT_A struct symentAbridged
  128. #define SYMESZ_A sizeof(SYMENT_A)
  130. /* 
  131.  *  PECOFF symbol types and classes as macros
  132.  *
  133.  *   'sym' in the macro defintion must be defined as:   SYMENT *sym;
  134.  */
  135. #define U_SYM_VALUE    n_value
  137. #define PECOFF_EXT(sym) 
  138.     ((sym)->n_sclass == C_EXT)
  140. /*  PECOFF Undefined External Symbol */
  141. #define PECOFF_UNDF(sym) 
  142.     (((sym)->n_sclass == C_EXT) && ((sym)->n_scnum == N_UNDEF))
  144. /*  PECOFF Common Symbol
  145.  *    A common symbol type is denoted by undefined external
  146.  *    with its value set to non-zero.
  147.  */
  148. #define PECOFF_COMM(sym) ((PECOFF_UNDF(sym)) && ((sym)->n_value != 0))
  150. /* PECOFF Unassigned type
  151.  *    An unassigned type symbol of class C_STAT generated by
  152.  *    some assemblers
  153.  */
  154. #define PECOFF_UNASSIGNED(sym) (((sym)->n_sclass == C_STAT) && ((sym)->n_type == T_NULL))
  157. /* misc defines */
  159. #define INSERT_HWORD(WORD,HWORD)        
  160.     (((WORD) & 0xff00ff00) | (((HWORD) & 0xff00) << 8) | ((HWORD)& 0xff))
  161. #define EXTRACT_HWORD(WORD) 
  162.     (((WORD) & 0x00ff0000) >> 8) | ((WORD)& 0xff)
  163. #define SIGN_EXTEND_HWORD(HWORD) 
  164.     ((HWORD) & 0x8000 ? (HWORD)|0xffff0000 : (HWORD))
  166. #define SWAB_SHORT(s) 
  167.   ((((unsigned short) s & 0x00ff) << 8) | (((unsigned short) s & 0xff00) >> 8))
  169. #define MAX_SCNS        100 /* max sections supported */
  170. #define NO_SCNS         0
  172. #define MAX_ALIGNMENT 4 /* max boundary for architecture */
  174. char *addrScn[MAX_SCNS];                /* where each section is located */
  175. LOCAL int  max_scns = MAX_SCNS; /* load with MAX */
  177. LOCAL char stringMemErrMsg [] =
  178.     "loadLib error: insufficient memory for strings table (need %d bytes).n";
  179. LOCAL char extMemErrMsg [] =
  180.     "loadLib error: insufficient memory for externals table (need %d bytes).n";
  181. LOCAL char cantConvSymbolType [] =
  182.     "loadLib error: can't convert '%s' symbol type - error = %#x.n";
  183. LOCAL char cantAddSymErrMsg [] =
  184.     "loadLib error: can't add '%s' to system symbol table - error = %#x.n";
  185. #ifndef MULTIPLE_LOADERS
  186. LOCAL char fileTypeUnsupported [] =
  187.     "loadLib error: File type with magic number %#x is not supported.n";
  188. #endif
  191. /* forward declarations */
  193. LOCAL void pecoffFree ();
  194. LOCAL void pecoffSegSizes ();
  195. LOCAL STATUS pecoffReadSym ();
  196. LOCAL STATUS fileRead ();
  197. LOCAL STATUS swabData ();
  198. LOCAL void swabLong ();
  199. LOCAL ULONG pecoffTotalCommons ();
  200. LOCAL ULONG dataAlign ();
  201. LOCAL STATUS pecoffHdrRead ();
  202. LOCAL STATUS pecoffOpthdrRead ();
  203. LOCAL STATUS pecoffSecHdrRead ();
  204. LOCAL STATUS pecoffLoadSections ();
  205. LOCAL STATUS pecoffReadRelocInfo ();
  206. LOCAL STATUS pecoffReadExtSyms ();
  207. LOCAL STATUS pecoffReadExtStrings ();
  208. LOCAL STATUS pecoffRelSegmentI386 ();
  209. LOCAL STATUS pecoffSymTab (int fd, struct filehdr * pHdr, SYMENT * pSymbols, 
  210.    char *** externals, int symFlag, SEG_INFO * pSeg,
  211.    char * symStrings, SYMTAB_ID symTbl,
  212.    char * pNextCommon, struct scnhdr * pScnHdrArray,
  213.    char ** pScnAddr, BOOL fullyLinked,
  214.    UINT16 group, int imageBase);
  215. LOCAL STATUS loadPecoffCommonManage (char * symName, SYMTAB_ID symTbl, 
  216.                                      SYM_ADRS * pSymAddr,
  217.                                      SYM_TYPE * pSymType, int loadFlag);
  219. /******************************************************************************
  220. *
  221. * ldPecoffModAtSym - load object module into memory with specified symbol table
  222. *
  223. * This routine is the underlying routine to loadModuleAtSum().  This interface
  224. * allows specification of the the symbol table used to resolve undefined
  225. * external references and to which to add new symbols.
  226. *
  227. * RETURNS:
  228. * MODULE_ID, or
  229. * NULL if can't read file or not enough memory or illegal file format
  230. *
  231. * NOMANUAL
  232. */
  234. MODULE_ID ldPecoffModAtSym
  235.     (
  236.     int fd, /* fd from which to read module */
  237.     int symFlag, /* symbols to be added to table 
  238.  *   ([NO | GLOBAL | ALL]_SYMBOLS) */
  239.     char **ppText, /* load text segment at address pointed to by this
  240.  * pointer, return load address via this pointer */
  241.     char **ppData, /* load data segment at address pointed to by this
  242.  * pointer, return load address via this pointer */
  243.     char **ppBss, /* load bss segment at address pointed to by this
  244.  * pointer, return load address via this pointer */
  245.     SYMTAB_ID symTbl /* symbol table to use */
  246.     )
  247.     {
  248.     char *pText = (ppText == NULL) ? LD_NO_ADDRESS : *ppText;
  249.     char *pData = (ppData == NULL) ? LD_NO_ADDRESS : *ppData;
  250.     char *pBss  = (ppBss  == NULL) ? LD_NO_ADDRESS : *ppBss;
  251.     char **externalsBuf = NULL;         /* array of symbol absolute values */
  252.     char *externalSyms = NULL;          /* buffer for object file symbols */
  253.     char *stringsBuf = NULL; /* string table pointer */
  254.     FILHDR hdr; /* module's PECOFF header */
  255.     PEOPTION optHdr;              /* module's PECOFF optional header */
  256.     SCNHDR scnHdr[MAX_SCNS]; /* module's PECOFF section headers */
  257.     char *scnAddr[MAX_SCNS];            /* array of section loaded address */
  258.     RELOC  *relsPtr[MAX_SCNS];  /* section relocation */
  259.     SEG_INFO seg; /* file segment info */
  260.     BOOL tablesAreLE; /* boolean for table sex */
  261.     BOOL fullyLinked = FALSE;          /* TRUE if already absolutely located*/
  262.     int status; /* return value */
  263.     int ix; /* temp counter */
  264.     int nbytes; /* temp counter */
  265.     char *pCommons;                     /* start of common symbols in bss */
  266.     char *addrBss;
  267.     char        fileName[255];
  268.     UINT16      group;
  269.     MODULE_ID   moduleId;
  270.     int hdrEnd;
  272.     /* initialization */
  274.     memset ((void *)&seg, 0, sizeof (seg));
  276.     /* Set up the module */
  278.     ioctl (fd, FIOGETNAME, (int) fileName);
  279.     moduleId = loadModuleGet (fileName, MODULE_ECOFF, &symFlag);
  281.     if (moduleId == NULL)
  282.         return (NULL);
  284.     group = moduleId->group;
  286.     /* init section pointers to NULL */
  288.     for (ix = 0; ix < MAX_SCNS; ix++)
  289. {
  290. scnAddr[ix] = NULL;
  291. relsPtr[ix] = NULL;
  292. bzero((char *) &scnHdr[ix], (int) sizeof(SCNHDR));
  293. }
  295.     /* read object module header */
  297.     if (pecoffHdrRead (fd, &hdr, &tablesAreLE) != OK)
  298. {
  299. /*  Preserve errno value from subroutine. */
  301. goto error;
  302. }
  304.     hdrEnd = lseek (fd, 0, SEEK_CUR);
  306.     /* Read in optional header if one exists */
  308.     if (hdr.f_opthdr)
  309.         {
  310.         if (pecoffOpthdrRead (fd, &optHdr, tablesAreLE) != OK)
  311.             {
  312.     errnoSet(S_loadLib_OPTHDR_READ);
  313.             goto error;
  314.             }
  315.         }
  317.     lseek (fd,hdrEnd + hdr.f_opthdr, SEEK_SET);
  319.     /* read in section headers */
  321.     if (pecoffSecHdrRead (fd, &scnHdr[0], &hdr, tablesAreLE) != OK)
  322. {
  323. errnoSet(S_loadLib_SCNHDR_READ);
  324. goto error;
  325. }
  327.     /* Determine segment sizes */
  329.     /* 
  330.      * XXX seg.flagsXxx mustn't be used between coffSegSizes() and 
  331.      * loadSegmentsAllocate().
  332.      */
  334.     pecoffSegSizes (&hdr, scnHdr, &seg);
  336.     /* 
  337.      * If object file is already absolutely located (by linker on host),
  338.      *  then override parameters pText, pData and pBss.
  339.      */
  341.     if ((hdr.f_flags & F_EXEC) || (hdr.f_flags & F_RELFLG))
  342.         {
  343.         if (hdr.f_opthdr)               /* if there is an optional header */
  344.             {
  345.             fullyLinked = TRUE;
  346.             pText = (INT8 *)(optHdr.text_start + optHdr.image_base);
  347.             pData = (INT8 *)(optHdr.data_start + optHdr.image_base);
  349.             /* bss follows data segment */
  350.             pBss = (INT8 *) pData + optHdr.dsize;
  351.             pBss += dataAlign(MAX_ALIGNMENT, pBss);
  352.     }
  353. }
  355.     seg.addrText = pText;
  356.     seg.addrData = pData;
  358.     /*
  359.      * If pBss is set to LD_NO_ADDRESS, change it to something else.
  360.      * The pecoff loader allocates one large BSS segment later on, and
  361.      * loadSegmentsAllocate doesn't work correctly for it.
  362.      */
  364.     seg.addrBss = (pBss == LD_NO_ADDRESS ? LD_NO_ADDRESS + 1 : pBss);
  366.     /* 
  367.      * SPR #21836: loadSegmentsAllocate() allocate memory aligned on 
  368.      * the max value of sections alignement saved in seg.flagsText,
  369.      * seg.flagsData, seg.flagsBss.
  370.      */
  372.     if (loadSegmentsAllocate (&seg) != OK)
  373.         {
  374.         printErr ("Could not allocate segmentsn");
  375.         goto error;
  376.         }
  377.     else
  378.         {
  379.         pText = seg.addrText;
  380.         pData = seg.addrData;
  381.         pBss = LD_NO_ADDRESS;
  382.         }
  384.     /*  Ensure that section starts on the appropriate alignment.
  385.      */
  386.     pText += dataAlign (MAX_ALIGNMENT, pText);
  387.     if (pData == LD_NO_ADDRESS)
  388.         {
  389. pData = pText + seg.sizeText;
  390.         }
  392.     /*  Ensure that section starts on the appropriate alignment.
  393.      */
  394.     pData += dataAlign (MAX_ALIGNMENT, pData);
  396.     seg.addrText = pText;
  397.     seg.addrData = pData;
  399.     /* load text and data sections */
  401.     if (!fullyLinked)
  402.         {
  403. if (pecoffLoadSections (fd, &scnHdr[0], &scnAddr[0], pText,
  404. pData) != OK)
  405.     {
  406.     errnoSet (S_loadLib_LOAD_SECTIONS);
  407.     goto error;
  408.     }
  410. /* get section relocation info */
  412.         if (pecoffReadRelocInfo (fd, &scnHdr[0], &relsPtr[0],
  413.  tablesAreLE) != OK)
  414.         {
  415.     errnoSet (S_loadLib_RELOC_READ);
  416.     goto error;
  417.     }
  418.         }
  420.     /* read symbols */
  422.     if (pecoffReadExtSyms (fd, &externalSyms, &externalsBuf, &hdr,
  423.    tablesAreLE) != OK)
  424. {
  425. errnoSet (S_loadLib_EXTSYM_READ);
  426. goto error;
  427. }
  429.     /* read string table */
  431.     if (pecoffReadExtStrings (fd, &stringsBuf, tablesAreLE) != OK)
  432. {
  433. errnoSet (S_loadLib_EXTSTR_READ);
  434. goto error;
  435. }
  437.     /*  Determine additional amount of memory required to append
  438.      *  common symbols on to the end of the BSS section.
  439.      */
  440.     nbytes = pecoffTotalCommons(externalSyms, hdr.f_nsyms, seg.sizeBss);
  442.     /* set up for bss */
  444.     seg.sizeBss += nbytes;
  446.     if (pBss == LD_NO_ADDRESS)
  447.         {
  448.         if (seg.sizeBss != 0)
  449.             {
  450.             if ((pBss = malloc (seg.sizeBss)) == NULL) 
  451.                 goto error;
  452.             else                                 
  453. seg.flagsBss |= SEG_FREE_MEMORY;  
  454.             }
  455.         else
  456.             {
  457.             pBss = (char *) ((long) pData + (long) seg.sizeData);
  458.             }
  459.         }
  461.     pBss += dataAlign(MAX_ALIGNMENT, pBss);
  462.     seg.addrBss = pBss;
  464.     /* fix up start address of bss sections */
  466.     addrBss = pBss;
  467.     for (ix = 0; ix < max_scns; ix++)
  468.         {
  469.         if (scnHdr[ix].s_flags & STYP_BSS)
  470.     {
  471.     addrBss += dataAlign (MAX_ALIGNMENT, addrBss);
  472.     scnAddr[ix] = addrBss;
  473.     addrBss += scnHdr[ix].s_size;
  474.             }
  475.         }
  476.     
  477.     /* set up address for first common symbol */
  479.     pCommons = (char *) ((long) seg.addrBss + (seg.sizeBss - nbytes));
  481.     /* add segment names to symbol table before other symbols */
  483.     if (symFlag != LOAD_NO_SYMBOLS)
  484.         addSegNames (fd, pText, pData, pBss, symTbl, group);
  486.     /* process symbol table */
  488.     status = pecoffSymTab (fd, &hdr, (SYMENT *)externalSyms, &externalsBuf, 
  489.  symFlag, &seg, stringsBuf, symTbl, pCommons, scnHdr,
  490.  scnAddr, fullyLinked, group, optHdr.image_base);
  492.     /* 
  493.      * Relocate text and data segments
  494.      *
  495.      *   note: even if symbol table had missing symbols, continue with
  496.      *   relocation of those symbols that were found.
  497.      *   note: relocation is for changing the values of the relocated
  498.      *   symbols.  bss is uninitialized data, so it is not relocated
  499.      *   in the symbol table.
  500.      */
  502.     if ((status == OK) || (errnoGet() == S_symLib_SYMBOL_NOT_FOUND))
  503.         for (ix = 0; ix < max_scns; ix++)
  504.     {
  505.     /*
  506.      * Only meaningful sections are relocated. Note that the section
  507.      * flags set for PECOFF do not allow to test for STYP_REG. The
  508.      * PE extension IMAGE_SCN_MEM_DISCARDABLE should be used instead.
  509.      */
  511.     if ((relsPtr[ix] != NULL)   &&
  512.                 !(scnHdr[ix].s_flags & STYP_INFO)   &&
  513.                 !(scnHdr[ix].s_flags & STYP_NOLOAD)   &&
  514.                 !(scnHdr[ix].s_flags & IMAGE_SCN_MEM_DISCARDABLE) &&
  515.                 !(scnHdr[ix].s_flags & STYP_PAD))
  516. {
  517.                 if (pecoffRelSegmentI386 (relsPtr[ix], scnHdr, externalsBuf, 
  518.                                externalSyms, &seg, ix) != OK)
  519.     {
  520.             goto error;
  521.     }
  522. }
  523.     }
  525.     pecoffFree(externalsBuf, externalSyms, stringsBuf, relsPtr);
  527.     /* write protect the text if text segment protection is turned on */
  529.     if (seg.flagsText & SEG_WRITE_PROTECTION)
  530. {
  531. if (VM_STATE_SET (NULL, pText, seg.sizeProtectedText,
  532.   VM_STATE_MASK_WRITABLE,
  533.   VM_STATE_WRITABLE_NOT) == ERROR)
  534.     goto error;
  535. }
  537.     /* return load addresses, where called for */
  539.     if (ppText != NULL)
  540.         *ppText = pText;
  542.     if (ppData != NULL)
  543.         *ppData = pData;
  545.     if (ppBss != NULL)
  546.         *ppBss = pBss;
  548.     /* clear out bss */
  550.     bzero (pBss, (int) seg.sizeBss);
  552.     /*
  553.      * Add the segments to the module.
  554.      * This has to happen after the relocation gets done.
  555.      * If the relocation happens first, the checksums won't be
  556.      * correct.
  557.      */
  559.     moduleSegAdd (moduleId, SEGMENT_TEXT, pText, seg.sizeText, seg.flagsText);
  560.     moduleSegAdd (moduleId, SEGMENT_DATA, pData, seg.sizeData, seg.flagsData);
  561.     moduleSegAdd (moduleId, SEGMENT_BSS, pBss, seg.sizeBss, seg.flagsBss);
  563.     if (status == OK)
  564.         return (moduleId);
  565.     else
  566.         return (NULL);
  568.     /* error:
  569.      * clean up dynamically allocated temporary buffers and return ERROR
  570.      */
  571. error:
  572.     pecoffFree(externalsBuf, externalSyms, stringsBuf, relsPtr);
  573.     moduleDelete (moduleId);
  574.     return (NULL);
  575.     }
  577. /******************************************************************************
  578. *
  579. * loadPecoffInit - initialize the system for pecoff load modules.
  580. *
  581. * This routine initializes VxWorks to use a PECOFF format for loading 
  582. * modules.
  583. *
  584. * RETURNS: OK
  585. *
  586. * SEE ALSO: loadModuleAt()
  587. */
  589. STATUS loadPecoffInit (void)
  590.     {
  591.     /* XXX check for installed? */
  592.     loadRoutine = (FUNCPTR) ldPecoffModAtSym;
  593.     return (OK);
  594.     }
  596. /*******************************************************************************
  597. *
  598. * pecoffFree - free any malloc'd memory
  599. *
  600. */
  602. LOCAL void pecoffFree
  603.     (
  604.     char **pExternalsBuf,       /* pointers to external symbols */
  605.     char *pExternalSyms,        /* buffer for external symbols */
  606.     char *pStringsBuf, /* string table pointer */
  607.     RELOC  **pRelsPtr  /* section relocation */
  608.     )
  609.     {
  610.     int ix;
  612.     if (pStringsBuf != NULL)
  613. free (pStringsBuf);
  614.     if (pExternalsBuf != NULL)
  615. free ((char *) pExternalsBuf);
  616.     if (pExternalSyms != NULL)
  617. free ((char *) pExternalSyms);
  619.     for (ix = 0; ix < MAX_SCNS; ix++)
  620. {
  621. if (*pRelsPtr != NULL)
  622.     free((char *) *pRelsPtr);
  623.         pRelsPtr++;
  624. }
  625.     }
  628. /*******************************************************************************
  629. *
  630. * pecoffSegSizes - determine segment sizes
  631. *
  632. * This function fills in the size fields in the SEG_INFO structure.
  633. * Note that the bss size may need to be readjusted for common symbols. 
  634. */
  636. LOCAL void pecoffSegSizes
  637.     (
  638.     FILHDR *pHdr,               /* pointer to file header */
  639.     SCNHDR *pScnHdrArray,       /* pointer to array of section headers */
  640.     SEG_INFO *pSeg        /* section addresses and sizes */
  641.     )
  642.     {
  643.     int ix;
  644.     int nbytes;             /* additional bytes required for alignment */
  645.     SCNHDR *pScnHdr;            /* pointer to a section header */
  647.     pSeg->sizeText = 0;
  648.     pSeg->sizeData = 0;
  649.     pSeg->sizeBss = 0;
  651.     /* 
  652.      * SPR #21836: pSeg->flagsText, pSeg->flagsData, pSeg->flagsBss are used
  653.      * to save the max value of each segments. These max values are computed
  654.      * for each sections. These fields of pSeg are only used on output, then
  655.      * a temporary use is allowed.
  656.      */
  658.     pSeg->flagsText = _ALLOC_ALIGN_SIZE;
  659.     pSeg->flagsData = _ALLOC_ALIGN_SIZE;
  660.     pSeg->flagsBss  = _ALLOC_ALIGN_SIZE;
  662.     for (ix=0; ix < pHdr->f_nscns; ix++) /* loop thru all sections */
  663.         {
  664.         pScnHdr = pScnHdrArray + ix;
  665.         if (pScnHdr->s_flags & STYP_TEXT)
  666.             {
  667.             /*  Assume that there was a previous section of same type.
  668.              *  First, align data to boundary from section header.
  669.              *  Add the size of this section to the total segment size.
  670.              */
  672.             nbytes = dataAlign(MAX_ALIGNMENT, pSeg->sizeText);
  673.             pSeg->sizeText += pScnHdr->s_size + nbytes;
  675.     /* SPR #21836 */
  677.     if (MAX_ALIGNMENT > pSeg->flagsText)
  678. pSeg->flagsText = MAX_ALIGNMENT;
  679.             }
  680.         else if (pScnHdr->s_flags & STYP_DATA)
  681.             {
  682.             nbytes = dataAlign(MAX_ALIGNMENT, pSeg->sizeData);
  683.             pSeg->sizeData += pScnHdr->s_size + nbytes;
  685.     /* SPR #21836 */
  687.     if (MAX_ALIGNMENT > pSeg->flagsData)
  688. pSeg->flagsData = MAX_ALIGNMENT;
  689.             }
  690.         else if (pScnHdr->s_flags & STYP_BSS)
  691.             {
  692.             nbytes = dataAlign(MAX_ALIGNMENT, pSeg->sizeBss);
  693.             pSeg->sizeBss += pScnHdr->s_size + nbytes;
  695.     /* SPR #21836 */
  697.     if (MAX_ALIGNMENT > pSeg->flagsBss)
  698. pSeg->flagsBss = MAX_ALIGNMENT;
  699.             }
  700.         }
  701.     }
  703. /*******************************************************************************
  704. *
  705. * pecoffLoadSections - read sections into memory
  706. * 
  707. */
  709. LOCAL STATUS pecoffLoadSections
  710.     (
  711.     int     fd,
  712.     SCNHDR  *pScnHdr,
  713.     char    **pScnAddr,
  714.     char    *pText,
  715.     char    *pData
  716.     )
  717.     {
  718.     int     ix;
  719.     int     textCount = 0;
  720.     int     dataCount = 0;
  721.     INT32   size;               /* section size */
  722.     int     nbytes;             /* additional bytes required for alignment */
  723.     char    *pLoad;             /* address to load data at */
  725.     for (ix = 0; ix < max_scns; ix++)
  726. {
  727.         pLoad = NULL;
  728.         size = pScnHdr->s_size;
  729. if (size != 0 && pScnHdr->s_scnptr != 0)
  730.     {
  731.             if (pScnHdr->s_flags & STYP_TEXT)
  732.                 {
  733.                 pLoad = pText;
  734.                 nbytes = dataAlign(MAX_ALIGNMENT, pLoad);
  735.                 pLoad += nbytes;
  736.                 pText = (char *) ((int) pLoad + size); /* for next load */
  737.                 textCount += size + nbytes;
  738.                 }
  739.             else if (pScnHdr->s_flags & STYP_DATA)
  740.                 {
  741.                 pLoad = pData;
  742.                 nbytes = dataAlign(MAX_ALIGNMENT, pLoad);
  743.                 pLoad += nbytes;
  744.                 pData = (char *) ((int) pLoad + size); /* for next load */
  745.                 dataCount += size + nbytes;
  746.                 }
  747.             else
  748.                 {
  749.                 /* ignore all other sections */
  750.                 pScnAddr[ix] = pLoad;
  751.                pScnHdr++;
  752. continue;
  753.                 }
  755.             /*  Advance to position in file
  756.              *  and read section directly into memory.
  757.              */
  758.     if ((lseek (fd, pScnHdr->s_scnptr, SEEK_SET) == ERROR) ||
  759. (fioRead (fd, pLoad, size) != size))
  760. {
  761. return (ERROR);
  762. }
  763.     }
  764.         pScnAddr[ix] = pLoad;
  765. pScnHdr++;
  766. }
  767.     return (OK);
  768.     }
  770. /*******************************************************************************
  771. *
  772. * loadPecoffCommonManage - process a common symbol
  773. *
  774. * This routine processes the common symbols found in the object module.
  775. * Common symbols are symbols declared global without being assigned a
  776. * value.  
  777. *
  778. * loadPecoffCommonManage() is derived from loadCommonMange() in
  779. * loadLib.c, but unlike loadCommonManage(), loadPecoffCommonManage() does
  780. * not allocate memory or add symbols to the symbol table:
  781. * loadPecoffCommonManage() leaves the chores of allocating memory
  782. * or adding symbols to the symbol table up to the caller.
  783. *
  784. * For more information on common symbol types,LOAD_COMMON_MATCH_NONE,
  785. * LOAD_COMMON_MATCH_USER and LOAD_COMMON_MATCH_ALL see
  786. * loadCommonManage() in loadLib.c.
  787. *
  788. * NOMANUAL 
  789. */
  791. LOCAL STATUS loadPecoffCommonManage
  792.     (
  793.     char *       symName,        /* symbol name */
  794.     SYMTAB_ID    symTbl,        /* target symbol table */
  795.     SYM_ADRS *   pSymAddr,       /* where to return symbol's address */
  796.     SYM_TYPE *   pSymType,       /* where to return symbol's type */
  797.     int          loadFlag       /* control of loader's behavior */
  798.     )
  799.     {
  800.     COMMON_INFO commInfo;       /* what to do with commons */
  802.     /* Force the default choice if no flag set */
  804.     if(!(loadFlag & LOAD_COMMON_MATCH_ALL) &&
  805.        !(loadFlag & LOAD_COMMON_MATCH_USER) &&
  806.        !(loadFlag & LOAD_COMMON_MATCH_NONE))
  807.         loadFlag |= LOAD_COMMON_MATCH_NONE;
  809.     /* Must we do more than the default ? */
  811.     if(!(loadFlag & LOAD_COMMON_MATCH_NONE))
  812.         {
  813.         /* Initialization */
  815.         memset (&commInfo, 0, sizeof (COMMON_INFO));
  816.         commInfo.symName = symName;
  818.         /* Do we involve the core's symbols ? */
  820.         if(loadFlag & LOAD_COMMON_MATCH_USER)
  821.             commInfo.vxWorksSymMatched = FALSE;    /* no */
  822.         else if(loadFlag & LOAD_COMMON_MATCH_ALL)
  823.             commInfo.vxWorksSymMatched = TRUE;    /* yes */
  825.         /* Get the last occurences of matching global symbols in bss and data  */
  827.         loadCommonMatch (&commInfo, symTbl);
  829.         /* Prefered order for matching symbols is : bss then data */
  831.         if(commInfo.pSymAddrBss != NULL)    /* matching sym in bss */
  832.             {
  833.             *pSymAddr = commInfo.pSymAddrBss;
  834.             *pSymType = commInfo.bssSymType;
  835.             }
  836.         else if(commInfo.pSymAddrData != NULL)    /* matching sym in data */
  837.             {
  838.             *pSymAddr = commInfo.pSymAddrData;
  839.             *pSymType = commInfo.dataSymType;
  840.             }
  841.         else *pSymAddr = NULL;          /* no matching symbol */
  843.         /* If we found a matching symbol, stop here */
  845.         if(*pSymAddr != NULL)
  846.             return (OK);
  847. }
  848.     
  849.     /* if a matching common symbol is not found, return ERROR*/
  851.     return (ERROR);
  852.     }
  855. /*******************************************************************************
  856. *
  857. * pecoffSymTab - process an object module symbol table
  858. *
  859. * This is passed a pointer to a pecoff symbol table and processes
  860. * each of the external symbols defined therein.  This processing performs
  861. * two functions:
  862. *
  863. *  1) Defined symbols are entered in the system symbol table as
  864. *     specified by the "symFlag" argument:
  865. * LOAD_ALL_SYMBOLS = all defined symbols (LOCAL and GLOBAL) are added,
  866. * LOAD_GLOBAL_SYMBOLS = only external (GLOBAL) symbols are added,
  867. * LOAD_NO_SYMBOLS = no symbols are added;
  868. *
  869. *  2) Any undefined externals are looked up in the system symbol table to
  870. *     determine their values.  The values are entered into the specified
  871. *     'externals' array.  This array is indexed by the symbol number
  872. *     (position in the symbol table).
  873. *     Note that all symbol values, not just undefined externals, are entered
  874. *     into the 'externals' array.  The values are used to perform relocations.
  875. *
  876. *     Note that "common" symbols have type undefined external - the value
  877. *     field of the symbol will be non-zero for type common, indicating
  878. *     the size of the object.
  879. *
  880. * If an undefined external cannot be found in the system symbol table,
  881. * an error message is printed, but ERROR is not returned until the entire
  882. * symbol table has been read, which allows all undefined externals to be
  883. * looked up.
  884. *
  885. * RETURNS: OK or ERROR
  886. */
  888. LOCAL STATUS pecoffSymTab
  889.     (
  890.     int fd, /* file descriptor of module being loaded */
  891.     FILHDR * pHdr, /* pointer to file header */
  892.     SYMENT * externalSyms, /* pointer to symbols array */
  893.     char *** externals, /* pointer to pointer to array to fill in 
  894.    symbol absolute values */
  895.     int symFlag, /* symbols to be added to table 
  896.  *   ([NO|GLOBAL|ALL]_SYMBOLS) */
  897.     SEG_INFO * pSeg, /* pointer to segment information */
  898.     char * symStrings, /* symbol string table */
  899.     SYMTAB_ID symTbl, /* symbol table to use */
  900.     char * pNextCommon, /* next common address in bss */
  901.     SCNHDR * pScnHdrArray, /* pointer to PECOFF section header array */
  902.     char ** pScnAddr, /* pointer to section loaded address array */
  903.     BOOL fullyLinked, /* TRUE if module already absolutely located */
  904.     UINT16 group, /* module's group */
  905.     int imageBase /* base addr of the simulateur image in RAM */
  906.     )
  907.     {
  908.     int status  = OK; /* return status */
  909.     char * name; /* symbol name (plus EOS) */
  910.     SYMENT * symbol; /* symbol struct */
  911.     SYM_TYPE vxSymType; /* vxWorks symbol type */
  912.     int symNum; /* symbol index */
  913.     char * adrs; /* table resident symbol address */
  914.     char * bias; /* section relative address */
  915.     ULONG bssAlignment; /* alignment value of common type */
  916.     long scnFlags; /* flags from section header */
  917.     int auxEnts = 0; /* auxiliary symbol entries to skip */
  918.     SCNHDR * pScnHdr = NULL; /* pointer to a PECOFF section header */
  919.     char * scnAddr = NULL; /* section loaded address */
  920.     char nameTemp[SYMNMLEN+1]; /* temporary for symbol name string */
  922.     /*  Loop thru all symbol table entries in object file */
  924.     for (symNum = 0, symbol = externalSyms; symNum < pHdr->f_nsyms; 
  925.  symbol++, symNum++)
  926. {
  927.         if (auxEnts)                    /* if this is an auxiliary entry */
  928.             {
  929.             auxEnts--;
  930.             continue;                   /* skip it */
  931.             }
  932.         auxEnts = symbol->n_numaux;      /* # of aux entries for this symbol */
  934. /* Get rid of debug symbols */
  936.         if (symbol->n_scnum == N_DEBUG)
  937.             continue;
  939. /* Setup pointer to symbol name string */
  941.         if (symbol->n_zeroes)            /* if name is in symbol entry */
  942.             {
  943.             name = symbol->n_name;
  944.             if (*(name + SYMNMLEN -1) != '')
  945.                 {
  946.                 /*
  947.  * If the symbol name array is full,
  948.                  * the string is not terminated by a null.
  949.                  * So, move the string to a temporary array,
  950.                  * where it can be null terminated.
  951.                  */
  953.                 bcopy (name, nameTemp, SYMNMLEN);
  954.                 nameTemp[SYMNMLEN] = '';
  955.                 name = nameTemp;
  956.                 }
  957.             }
  958.         else
  959.             name = symStrings + symbol->n_offset;
  962.         if (! PECOFF_UNDF(symbol) && ! PECOFF_COMM(symbol))
  963.             {
  964.             /*
  965.      * The symbol is a defined, local or global (though not common).
  966.              *
  967.              * Determine symbol's section and address bias
  968.              */
  970.             if (symbol->n_scnum > 0)
  971.                 {
  972.                 pScnHdr = pScnHdrArray + (symbol->n_scnum - 1);
  973. scnAddr = pScnAddr[symbol->n_scnum - 1];
  974.                 scnFlags = pScnHdr->s_flags;
  975.                 }
  976.             else
  977.                 scnFlags = 0;       /* section has no text, data or bss */
  979.             if (symbol->n_scnum == N_ABS) /* special check for absolute syms */
  980.                 {
  981. /*
  982.  * No bias is applied to absolute symbols: they have to be
  983.  * valid for the actual location in Window's memory space
  984.  * where the simulator is installed.
  985.  *
  986.  * PLEASE, DO NOT CHANGE THIS AS THIS IS A CONSCIOUS AND
  987.  * DOCUMENTED DECISION.
  988.  */
  990.                 bias = 0;
  991.                 vxSymType = VX_ABS;
  992.                 }
  993.             else if (scnFlags & STYP_TEXT)
  994.                 {
  995.                 bias = (char *) scnAddr;
  996.                 vxSymType = VX_TEXT;
  997. }
  998.             else if (scnFlags & STYP_DATA)
  999.                 {
  1000.                 bias = (char *) scnAddr;
  1001.                 vxSymType = VX_DATA;
  1002. }
  1003.             else if (scnFlags & STYP_BSS)
  1004.                 {
  1005.                 bias = (char *) scnAddr;
  1006.                 vxSymType = VX_BSS;
  1007. }
  1008.             else if (scnFlags & STYP_DRECTVE)
  1009.                 {
  1010. /* Ignore this section */
  1012.                 continue;
  1013.                 }
  1014.             else
  1015.                 {
  1016. /*
  1017.  * Lets not print error messages for debug-related symbols
  1018.  * that are not flagged as N_DEBUG...
  1019.  */
  1021. if (!strcmp (name, ".stab") || !strcmp (name, ".stabstr"))
  1022.     continue;
  1024.                 printErr (cantConvSymbolType, name, errnoGet());
  1025.                 continue;
  1026.                 }
  1028.     /*
  1029.      * Since, in the VxWorks simulator's image all the symbols' values
  1030.      * are offsets from zero a bias has to be introduced to get the
  1031.      * real (post-installation) addresses of these symbols in
  1032.      * Windows' memory space. The bias computation is however
  1033.      * different from the one for the regular object modules and must
  1034.      * overwrite whatever has been computed just above: the bias is
  1035.      * the base address of the simulator in Windows' memory space
  1036.      * plus the offset to the section which holds the symbol.
  1037.      *
  1038.      * Note: the section header's s_vaddr field holds this offset
  1039.      *       _not_ a real virtual address...
  1040.      */
  1042.             if (fullyLinked)
  1043. bias = (char *)(pScnHdr->s_vaddr + imageBase);
  1045.             /*  Determine if symbol should be put into symbol table */
  1047.             if (((symFlag & LOAD_LOCAL_SYMBOLS) && !PECOFF_EXT(symbol))
  1048.                 || ((symFlag & LOAD_GLOBAL_SYMBOLS) && PECOFF_EXT(symbol)))
  1049.                 {
  1050.                 if (PECOFF_EXT(symbol))
  1051.                     vxSymType |= VX_EXT;
  1053.                 /*  Add symbol to symbol table but cut out Local tags */
  1055.                 if (name[0] != '$')
  1056.          if (symSAdd (symTbl, name, symbol->U_SYM_VALUE + bias,
  1057.      vxSymType, group) != OK)
  1058.         printErr (cantAddSymErrMsg, name, errnoGet());
  1059.                 }
  1061.             /* Add symbol address to externals table.
  1062.              * For PECOFF, we add all symbol addresses into the externals
  1063.              * table, not only those symbols saved in the vxWorks symbol
  1064.              * table.
  1065.              */
  1067.             (*externals) [symNum] = symbol->U_SYM_VALUE + bias;
  1068.     }
  1069. else
  1070.     {
  1071.     /* Undefined external symbol or "common" symbol
  1072.              *
  1073.      *   A common symbol type is denoted by undefined external
  1074.              *   with its value set to non-zero.
  1075.      */
  1077.     /* if symbol is a common, then allocate space and add to
  1078.      * symbol table as BSS
  1079.      */
  1081.     /* common symbol - create new symbol */
  1083.             if (PECOFF_COMM(symbol))
  1084. {
  1085. if (symFlag == LOAD_NO_SYMBOLS)
  1086.     ;
  1087. else
  1088.     {
  1089.     /* 
  1090.      *  common symbol - create new symbol 
  1091.      *
  1092.      *  Common symbols are now tacked to the end of the bss
  1093.      *  section.  This is done to accomodate systems that have
  1094.      *  multiple boards sharing memory with common symbols
  1095.      *  over the system bus.  
  1096.      *  This portion of code checks for a matching
  1097.                      *  common symbol. If a matching common symbol is not
  1098.                      *  found the symbol value is read
  1099.      *  (which contains the symbol size) and the symbol is
  1100.                      *  placed in the bss section.  The function dataAlign uses
  1101.      *  the next possible address for a common symbol to
  1102.      *  determine the proper alignment.
  1103.      */
  1104.       
  1105.                     if (loadPecoffCommonManage (name, symTbl, (void *) &adrs,
  1106.                         &vxSymType, symFlag) != OK)
  1107.                 {
  1108.                 adrs = pNextCommon;
  1109.                 bssAlignment = dataAlign (symbol->U_SYM_VALUE,
  1110.                                                   (ULONG)adrs);
  1111.                 adrs += bssAlignment;
  1112.                 pNextCommon += (symbol->U_SYM_VALUE + bssAlignment);
  1113.     
  1114.                 if (symSAdd (symTbl, name, adrs, (VX_BSS | VX_EXT),
  1115.                     group) != OK)
  1116.             printErr (cantAddSymErrMsg, name, errnoGet());
  1117.         }
  1118.     }
  1119. }
  1121.     /* look up undefined external symbol in symbol table */
  1123.     else if (symFindByNameAndType (symTbl, name, &adrs, &vxSymType,
  1124.    VX_EXT, VX_EXT) != OK)
  1125.                 {
  1126.                 /* Symbol not found in symbol table */
  1128.                 printErr ("undefined symbol: %sn", name);
  1129.                 adrs = NULL;
  1130.                 status = ERROR;
  1131.                 }
  1133.     /* Add symbol address to externals table */
  1135.     (*externals) [symNum] = adrs;
  1136.     }
  1137. }
  1138.     
  1139.     return status;
  1140.     }
  1142. /*******************************************************************************
  1143. *
  1144. * pecoffRelSegmentI386 - perform relocation for the I386 family
  1145. *
  1146. * This routine reads the specified relocation command segment and performs
  1147. * all the relocation specified therein.
  1148. * Absuolute symbol addresses are looked up in the 'externals' table.
  1149. *
  1150. * This function handles the following types of relocation commands for the
  1151. * I386 family of processor:
  1152. *  IMAGE_REL_I386_DIR32  - direct 32 bit relocation
  1153. *  IMAGE_REL_I386_REL32  - relative 32b bit relocation
  1154. *
  1155. * RETURNS: OK or ERROR
  1156. */
  1158. LOCAL STATUS pecoffRelSegmentI386
  1159.     (
  1160.     RELOC * pRelCmds, /* list of relocation commands */
  1161.     SCNHDR * pScnHdrArray,  /* array of section headers */
  1162.     char ** pExternals, /* array of absolute symbols values */
  1163.     SYMENT * pExtSyms, /* pointer to object file symbols */ 
  1164.     SEG_INFO *  pSeg, /* section addresses and sizes */
  1165.     int         section         /* section number -1 for relocation */
  1166.     )
  1167.     {
  1168.     long *      pAdrs = NULL;   /* relocation address */
  1169.     int         nCmds;          /* # reloc commands for seg */
  1170.     RELOC       relocCmd;       /* relocation structure */
  1171.     SCNHDR *    pScnHdr;        /* section header for relocation */
  1172.     STATUS      status = OK;
  1174.     pScnHdr = pScnHdrArray + section;
  1176.     for (nCmds = pScnHdr->s_nreloc; nCmds > 0; nCmds--)
  1177.         {
  1178.         /* read relocation command */
  1180.         relocCmd = *pRelCmds++;
  1182. /*
  1183.          * Calculate actual address in memory that needs relocation.
  1184.  * XXX PAD - we now apply the fix for SPR 70767 
  1185.          */
  1187. if (pScnHdr->s_flags & STYP_TEXT)
  1188.     {
  1189.     if (!(pScnHdr->s_flags & STYP_LIT))
  1190. {
  1191. pAdrs = (long *)((long) pSeg->addrText + relocCmd.r_vaddr);
  1192. }
  1193.     else
  1194. {
  1195. printf ("STYP_LIT type sections are unsupported.n");
  1196. return ERROR;
  1197. }
  1198.     }
  1199. else
  1200.     /*
  1201.      * The computation of the address of relocable data symbol 
  1202.              * should take into account the offset from the beginning of the
  1203.              * file that the compiler toolchain may require to account for
  1204.              * in some cases. The code was fixed to substract this offset
  1205.              * for data symbol, SPR 73145. 
  1206.      */
  1208.     {
  1209.     pAdrs = (long *)((long) pSeg->addrData +
  1210.              (relocCmd.r_vaddr - pScnHdr->s_vaddr));
  1211.     }
  1213. /* do relocations */
  1215.         switch (relocCmd.r_type)
  1216.             {
  1217.     case IMAGE_REL_I386_DIR32:
  1218. /*
  1219.  * This relocation is preformed by adding the absolute address
  1220.  * of the symbol to the relocation value in the code.
  1221.  */
  1222. *pAdrs += (INT32) pExternals [relocCmd.r_symndx];
  1223.    break;
  1225.     case IMAGE_REL_I386_REL32:
  1226. /*
  1227.  * Call near, displacement relative to the next instruction.
  1228.  * First, find the next instruction addr, then subtract it from
  1229.  * the addr of the found symbol to obtain the relocation addr.
  1230.  */
  1232.                 *pAdrs = (UINT32)pExternals[relocCmd.r_symndx] -
  1233.          ((UINT32)pAdrs + 4);
  1234.                 break;
  1236.     default:
  1237. printf("Unknown Relocation Errorn");
  1238. errnoSet (S_loadLib_UNRECOGNIZED_RELOCENTRY);
  1239. status = ERROR;
  1240. break;
  1241.             }
  1242.         }
  1244.     return status;
  1245.     }
  1247. /*******************************************************************************
  1248. *
  1249. * pecoffHdrRead - read in PECOFF header and swap if necessary
  1250. * 
  1251. * Note:  To maintain code portability, we can not just read sizeof(FILHDR) 
  1252. * bytes.  Compilers pad structures differently,
  1253. * resulting in different structure sizes.
  1254. * So, we read the structure in an element at a time, using the size
  1255. * of each element.
  1256. */
  1258. LOCAL STATUS pecoffHdrRead
  1259.     (
  1260.     int fd,
  1261.     FILHDR *pHdr,
  1262.     BOOL *pSwap
  1263.     )
  1264.     {
  1265.     int status;
  1266.     int i;
  1267.     struct dosheader dhead;
  1269.     *pSwap = 0;
  1271.     ioctl(fd, FIOSEEK, 0);
  1273.     if (fioRead (fd, (char *) &(pHdr->f_magic), sizeof (pHdr->f_magic))
  1274. != sizeof (pHdr->f_magic))
  1275. {
  1276. errnoSet (S_loadLib_FILE_READ_ERROR);
  1277. return ERROR;
  1278. }
  1280.     switch (pHdr->f_magic)
  1281. {
  1282. case (SWAB_SHORT(IMAGE_DOS_SIGNATURE)):
  1283.             *pSwap = TRUE;
  1285. case (IMAGE_DOS_SIGNATURE):
  1286.     /* Remove DOS EXE header */
  1288.             fioRead(fd,(char *)&dhead + 2,sizeof(dhead)-2);
  1289.     lseek (fd, dhead.e_lfanew, SEEK_SET);
  1291.             /* Check for NT SIGNATURE */
  1293.             fioRead (fd, (char *)&i, 4);
  1294.             if ( i != IMAGE_NT_SIGNATURE )
  1295.                 {
  1296.                 printf("Bad Image Signature %x %xn",i,IMAGE_NT_SIGNATURE);
  1297. errnoSet (S_loadLib_HDR_READ);
  1298.                 return ERROR;
  1299.                 }
  1300.             fioRead (fd, (char *)&pHdr->f_magic, 2);
  1301.     break;
  1303. case (SWAB_SHORT(IMAGE_FILE_MACHINE_I386)):
  1304.             *pSwap = TRUE;
  1305.     break;
  1307.         case (IMAGE_FILE_MACHINE_I386):
  1308.     *pSwap = FALSE;
  1309.     break;
  1310.     
  1311. default:
  1312. #ifndef MULTIPLE_LOADERS
  1313.     printErr (fileTypeUnsupported, pHdr->f_magic);
  1314. #endif
  1315.     errnoSet (S_loadLib_FILE_ENDIAN_ERROR);
  1316.     return ERROR;
  1317.     break;
  1318. }
  1320.     status = fileRead (fd, &pHdr->f_nscns, sizeof(pHdr->f_nscns), *pSwap);
  1321.     status |= fileRead (fd, &pHdr->f_timdat, sizeof(pHdr->f_timdat), *pSwap);
  1322.     status |= fileRead (fd, &pHdr->f_symptr, sizeof(pHdr->f_symptr), *pSwap);
  1323.     status |= fileRead (fd, &pHdr->f_nsyms, sizeof(pHdr->f_nsyms), *pSwap);
  1324.     status |= fileRead (fd, &pHdr->f_opthdr, sizeof(pHdr->f_opthdr), *pSwap);
  1325.     status |= fileRead (fd, &pHdr->f_flags, sizeof(pHdr->f_flags), *pSwap);
  1327.     max_scns = pHdr->f_nscns;
  1329.     return status;
  1330.     }
  1332. /*******************************************************************************
  1333. *
  1334. * pecoffOpthdrRead - read in PECOFF optional header and swap if necessary
  1335. * 
  1336. */
  1338. LOCAL STATUS pecoffOpthdrRead
  1339.     (
  1340.     int      fd,
  1341.     PEOPTION  *pOptHdr,
  1342.     BOOL     swapTables
  1343.     )
  1344.     {
  1345.     int status;
  1347.     status = fileRead(fd, &pOptHdr->magic, sizeof(pOptHdr->magic),
  1348.                             swapTables);
  1349.     status |= fileRead(fd, &pOptHdr->vstamp, sizeof(pOptHdr->vstamp),
  1350.                             swapTables);
  1351.     status |= fileRead(fd, &pOptHdr->tsize, sizeof(pOptHdr->tsize),
  1352.                             swapTables);
  1353.     status |= fileRead(fd, &pOptHdr->dsize, sizeof(pOptHdr->dsize),
  1354.                             swapTables);
  1355.     status |= fileRead(fd, &pOptHdr->bsize, sizeof(pOptHdr->bsize),
  1356.                             swapTables);
  1357.     status |= fileRead(fd, &pOptHdr->entry, sizeof(pOptHdr->entry),
  1358.                             swapTables);
  1359.     status |= fileRead(fd, &pOptHdr->text_start, sizeof(pOptHdr->text_start),
  1360.                             swapTables);
  1361.     status |= fileRead(fd, &pOptHdr->data_start, sizeof(pOptHdr->data_start),
  1362.                             swapTables);
  1363.     status |= fileRead(fd, &pOptHdr->image_base, sizeof(pOptHdr->image_base),
  1364.                             swapTables);
  1365.     status |= fileRead(fd, &pOptHdr->section_align, sizeof(pOptHdr->section_align),
  1366.                             swapTables);
  1367.     status |= fileRead(fd, &pOptHdr->file_align, sizeof(pOptHdr->file_align),
  1368.                             swapTables);
  1370.     return (status);
  1371.     }
  1374. /*******************************************************************************
  1375. *
  1376. * pecoffSecHdrRead - read in PECOFF section header and swap if necessary
  1377. * 
  1378. */
  1380. LOCAL STATUS pecoffSecHdrRead
  1381.     (
  1382.     int    fd,
  1383.     SCNHDR *pScnHdr,
  1384.     FILHDR *pHdr,
  1385.     BOOL   swapTables
  1386.     )
  1387.     {
  1388.     int ix;
  1389.     int status = 0;
  1391.     /* check for correct section count */
  1393.     if (pHdr->f_nscns > MAX_SCNS)
  1394. {
  1395. return (ERROR);
  1396. }
  1398.     for (ix = 0; ix < pHdr->f_nscns; ix++)
  1399. {
  1400.         status = fileRead(fd, pScnHdr->s_name, sizeof(pScnHdr->s_name),
  1401.                           FALSE);
  1402.         status |= fileRead(fd, &pScnHdr->s_paddr, sizeof(pScnHdr->s_paddr),
  1403.                            swapTables);
  1404.         status |= fileRead(fd, &pScnHdr->s_vaddr, sizeof(pScnHdr->s_vaddr),
  1405.                             swapTables);
  1406.         status |= fileRead(fd, &pScnHdr->s_size, sizeof(pScnHdr->s_size),
  1407.                             swapTables);
  1408.         status |= fileRead(fd, &pScnHdr->s_scnptr, sizeof(pScnHdr->s_scnptr),
  1409.                             swapTables);
  1410.         status |= fileRead(fd, &pScnHdr->s_relptr, sizeof(pScnHdr->s_relptr),
  1411.                             swapTables);
  1412.         status |= fileRead(fd, &pScnHdr->s_lnnoptr, sizeof(pScnHdr->s_lnnoptr),
  1413.                             swapTables);
  1414.         status |= fileRead(fd, &pScnHdr->s_nreloc, sizeof(pScnHdr->s_nreloc),
  1415.                             swapTables);
  1416.         status |= fileRead(fd, &pScnHdr->s_nlnno, sizeof(pScnHdr->s_nlnno),
  1417.                             swapTables);
  1418.         status |= fileRead(fd, &pScnHdr->s_flags, sizeof(pScnHdr->s_flags),
  1419.                             swapTables);
  1421. /*
  1422.  * In order to comply with an obscure requirement from Microsoft, the
  1423.  * GNU toolchain puts the size of the bss section in the section
  1424.  * header's physical address field. This piece of code addresses the
  1425.  * SPR 70767 by reseting the s_size field as appropriate for the rest
  1426.  * of the loader code.
  1427.  */
  1429. if (pScnHdr->s_flags & STYP_BSS)
  1430.     {
  1431.     if ((pScnHdr->s_size == 0) && (pScnHdr->s_paddr != 0))
  1432. pScnHdr->s_size = pScnHdr->s_paddr;
  1433.     }
  1435. pScnHdr++;
  1436. }
  1438.     return (status);
  1439.     }
  1441. /*******************************************************************************
  1442. *
  1443. * pecoffReadRelocInfo - read in PECOFF relocation info and swap if necessary
  1444. * 
  1445. * Assumptions:  The file pointer is positioned at the start of the relocation
  1446. * records.
  1447. *
  1448. * The relocation records are ordered by section.
  1449. */
  1451. LOCAL STATUS pecoffReadRelocInfo
  1452.     (
  1453.     int     fd,
  1454.     SCNHDR  *pScnHdr,
  1455.     RELOC   **pRelsPtr,
  1456.     BOOL    swapTables
  1457.     )
  1458.     {
  1459.     int ix;
  1460.     int iy;
  1461.     int relocSize;
  1462.     int status = OK;
  1463.     RELOC *pRels;                       /* pointer to single reloc entry */
  1465.     for (ix = 0; ix < max_scns; ix++)
  1466. {
  1467.         if (pScnHdr->s_nreloc > 0)
  1468.     {
  1469.     relocSize = (int) pScnHdr->s_nreloc * RELSZ;
  1470.     if ((*pRelsPtr = (RELOC *)malloc (relocSize)) == NULL)
  1471. {
  1472. return (ERROR);
  1473. }
  1475. if (lseek (fd, pScnHdr->s_relptr, SEEK_SET) == ERROR)
  1476.     {
  1477.     return (ERROR);
  1478.     }
  1480.             for (iy = 0, pRels = *pRelsPtr;
  1481.                  (iy < (int) pScnHdr->s_nreloc) && (status == OK);
  1482.                  iy++, pRels++)
  1483.                 {
  1484.                 status = fileRead(fd, &pRels->r_vaddr,
  1485.                                    sizeof(pRels->r_vaddr), swapTables);
  1486.                 status |= fileRead(fd, &pRels->r_symndx,
  1487.                                    sizeof(pRels->r_symndx), swapTables);
  1488.                 status |= fileRead(fd, &pRels->r_type,
  1489.                                    sizeof(pRels->r_type), swapTables);
  1490.                 }
  1492.             if (status != OK)
  1493.                 return(status);
  1494.     }
  1496. pScnHdr++;
  1497. pRelsPtr++;
  1498.         }
  1500.     return (OK);
  1501.     }
  1504. /*******************************************************************************
  1505. *
  1506. * pecoffReadSym - read one PECOFF symbol entry
  1507. * 
  1508. */
  1510. LOCAL STATUS pecoffReadSym
  1511.     (
  1512.     int     fd,
  1513.     SYMENT *pSym,                       /* where to read symbol entry */
  1514.     BOOL    swapTables
  1515.     )
  1516.     {
  1517.     int status;
  1519.     status = fioRead (fd, pSym->n_name, sizeof(pSym->n_name));
  1520.     if(status != sizeof(pSym->n_name))
  1521.         {
  1522.         printf(" Status %x %x : %x %x %x %xn",status,sizeof(pSym->n_name),
  1523.             pSym->n_name[0], 
  1524.             pSym->n_name[1], 
  1525.             pSym->n_name[2], 
  1526.             pSym->n_name[3]);
  1527.     status = fioRead (fd, pSym->n_name, sizeof(pSym->n_name));
  1528.         printf(" Status  #2 %x : %x %x %x %xn",status,
  1529.             pSym->n_name[0], 
  1530.             pSym->n_name[1], 
  1531.             pSym->n_name[2], 
  1532.             pSym->n_name[3]);
  1533. status = ERROR;
  1534.         }
  1535.     else
  1536.         status = OK;
  1538.     if (swapTables && (status == OK))
  1539.         {
  1540.         /*  The n_name field is part of a union in the syment struct.
  1541.          *  If the union uses n_name (array of char), then no
  1542.          *  swabbing in required.
  1543.          *  If the union uses n_offset (into string table), then
  1544.          *  the n_offset must be swabbed.
  1545.          */
  1546.         if (pSym->n_zeroes == 0)
  1547.             {
  1548.             swabData(&pSym->n_offset, sizeof(pSym->n_offset));
  1549.             }
  1550.         }
  1551.      status |= fileRead (fd, &pSym->n_value, sizeof(pSym->n_value),
  1552.                         swapTables);
  1553.     status |= fileRead (fd, &pSym->n_scnum, sizeof(pSym->n_scnum),
  1554.                         swapTables);
  1555.     status |= fileRead (fd, &pSym->n_type, sizeof(pSym->n_type),
  1556.                         swapTables);
  1557.     status |= fileRead (fd, &pSym->n_sclass, sizeof(pSym->n_sclass),
  1558.                         swapTables);
  1559.     status |= fileRead (fd, &pSym->n_numaux, sizeof(pSym->n_numaux),
  1560.                         swapTables);
  1561.     return(status);
  1562.     }
  1565. /*******************************************************************************
  1566. *
  1567. * pecoffReadExtSyms - read PECOFF symbols
  1568. * 
  1569. *  For low memory systems, we can't afford to keep the entire
  1570. *  symbol table in memory at once.
  1571. *  For each symbol entry, the fields required for relocation
  1572. *  are saved in the externalSyms array.
  1573. */
  1575. LOCAL STATUS pecoffReadExtSyms
  1576.     (
  1577.     int fd,
  1578.     SYMENT **pSymbols,       /* pointer to array of symbol entries */
  1579.     char ***pSymAddr,          /* pointer to array of addresses */
  1580.     FILHDR *pHdr,
  1581.     BOOL    swapTables
  1582.     )
  1583.     {
  1584.     int status;
  1585.     int ix;
  1586.     SYMENT *pSym;                     /* pointer to symbol entry */
  1588.     if (pHdr->f_nsyms)
  1589.         {
  1590.         /*  malloc space for array of absolute addresses
  1591.          */
  1592.         if ((*pSymAddr = malloc((UINT)(pHdr->f_nsyms) * sizeof(char *)))
  1593.             == NULL)
  1594.     {
  1595.     printErr (extMemErrMsg, (UINT)(pHdr->f_nsyms) * sizeof (char *));
  1596.     return (ERROR);
  1597.     }
  1599.         /*  malloc space for symbols
  1600.          */
  1601.         if ((*pSymbols = malloc((UINT)(pHdr->f_nsyms) * SYMESZ))
  1602.             == NULL)
  1603.     {
  1604.     return (ERROR);
  1605.     }
  1608. if (lseek (fd, pHdr->f_symptr, SEEK_SET) == ERROR)
  1609.     {
  1610.     return (ERROR);
  1611.     }
  1613.         for (ix = 0, pSym = *pSymbols; ix < pHdr->f_nsyms; ix++, pSym++)
  1614.             {
  1615.             if ((status = pecoffReadSym(fd, pSym, swapTables) != OK))
  1616. return (status);
  1617.             }
  1618.       }
  1619.     return (OK);
  1620.     }
  1621. /*******************************************************************************
  1622. *
  1623. * pecoffReadExtStrings - read in PECOFF external strings
  1624. * 
  1625. * Assumptions:  The file pointer is positioned at the start of the
  1626. * string table.
  1627. */
  1628. #define STR_BYTES_SIZE 4                /* size of string table length field */
  1630. LOCAL STATUS pecoffReadExtStrings
  1631.     (
  1632.     int fd,
  1633.     char **pStrBuf,
  1634.     BOOL    swapTables
  1635.     )
  1636.     {
  1637.     unsigned long strBytes;
  1638.     int status;
  1640.     /* Read length of string table
  1641.      */
  1642.     if ((status = fileRead (fd, &strBytes, STR_BYTES_SIZE, swapTables))
  1643.         != OK)
  1644.         {
  1645.         return (status);
  1646.         }
  1648.     if (strBytes > STR_BYTES_SIZE)
  1649.         {
  1650.         if ((*pStrBuf = malloc(strBytes)) == NULL)
  1651.     {
  1652.             printErr (stringMemErrMsg, strBytes);
  1653.     return (ERROR);
  1654.     }
  1656.         bcopy((char *) &strBytes, (char *) *pStrBuf, STR_BYTES_SIZE);
  1657.         strBytes -= STR_BYTES_SIZE;     /* # bytes left to read  */
  1659.     if (fioRead (fd, *pStrBuf + STR_BYTES_SIZE, strBytes) 
  1660. != strBytes)
  1661.     {
  1662.     return (ERROR);
  1663.     }
  1664.         }
  1665.     return (OK);
  1666.     }
  1668. #if FALSE /* XXX PAD - this is no longer used apparently */
  1669. /*******************************************************************************
  1670. *
  1671. * softSeek - seek forward into a file
  1672. *
  1673. * This procedure seeks forward into a file without actually using seek
  1674. * calls.  It is usefull since seek does not work on all devices.
  1675. *
  1676. * RETURNS:
  1677. * OK, or
  1678. * ERROR if forward seek could not be accomplished
  1679. *
  1680. */
  1682. #define SEEKBUF 1024
  1684. LOCAL STATUS softSeek
  1685.     (
  1686.     int fd, /* fd to seek with */
  1687.     int startOfFileOffset /* byte index to seek to */
  1688.     )
  1689.     {
  1690.     int position; /* present file position */
  1691.     int bytesToRead; /* bytes needed to read */
  1692.     char tempBuffer[SEEKBUF]; /* temp buffer for bytes */
  1694.     position = ioctl (fd, FIOWHERE, startOfFileOffset);
  1696.     if (position > startOfFileOffset)
  1697. return(ERROR);
  1699.     /* calculate bytes to read */
  1701.     bytesToRead = startOfFileOffset - position;
  1703.     while (bytesToRead >= SEEKBUF)
  1704. {
  1705.         if (fioRead (fd, tempBuffer, SEEKBUF) != SEEKBUF)
  1706.     return (ERROR);
  1707. bytesToRead -= SEEKBUF;
  1708. }
  1710.     if (bytesToRead > 0)
  1711. {
  1712.         if (fioRead (fd, tempBuffer, bytesToRead) != bytesToRead)
  1713.     return (ERROR);
  1714. }
  1715. #ifdef NO_PECOFF_SOFT_SEEK
  1716.     if (ioctl (fd, FIOSEEK, startOfFileOffset) == ERROR)
  1717.         return (ERROR);
  1718. #endif
  1719.     return(OK);
  1720.     }
  1721. #endif /* FALSE */
  1723. /*******************************************************************************
  1724. *
  1725. * fileRead - loader file read function
  1726. * 
  1727. */
  1729. LOCAL STATUS fileRead
  1730.     (
  1731.     int     fd,
  1732.     char    *pBuf,                      /* buffer to read data into */
  1733.     UINT    size,                       /* size of data field in bytes */
  1734.     BOOL    swap
  1735.     )
  1736.     {
  1737.     int     status = OK;
  1739.     if (fioRead (fd, pBuf, size) != size)
  1740.         {
  1741. errnoSet (S_loadLib_FILE_READ_ERROR);
  1742.         return(ERROR);
  1743.         }
  1744.     if (swap)
  1745.         {
  1746.         status = swabData(pBuf, size);
  1747.         }
  1748.     return(status);
  1749.     }
  1751. /*******************************************************************************
  1752. *
  1753. *  swabData - swap endianess of data field of any length
  1754. *
  1755. */
  1757. LOCAL STATUS swabData
  1758.     (
  1759.     char    *pBuf,                      /* buffer containing data */
  1760.     UINT    size                       /* size of data field in bytes */
  1761.     )
  1762.     {
  1763. #define TEMP_BUF_SIZE 256
  1765.     int     status = OK;
  1766.     char    tempBuf[TEMP_BUF_SIZE];
  1768.     switch(size)
  1769.         {
  1770.         case sizeof(char):
  1771.             break;                      /* ok as is */
  1773.         case sizeof(short):
  1774.             *(unsigned short *) pBuf = SWAB_SHORT(*(unsigned short *) pBuf);
  1775.             break;
  1777.         case sizeof(long):
  1778.             swabLong(pBuf, tempBuf);
  1779.             bcopy(tempBuf, pBuf, size);
  1780.             break;
  1782.         default:
  1783.             if (size <= TEMP_BUF_SIZE)
  1784.                 {
  1785.                 swab(pBuf, tempBuf, size);
  1786.                 bcopy(tempBuf, pBuf, size);
  1787.                 }
  1788.             else
  1789.                 status = ERROR;
  1790.             break;
  1791.         }
  1792.     return(status);
  1793.     }
  1795. /*******************************************************************************
  1796. *
  1797. *  swabLong - swap endianess of long word
  1798. *
  1799. */
  1801. LOCAL void swabLong
  1802.     (
  1803.     char input[],
  1804.     char output[]
  1805.     )
  1806.     {
  1807.     output[0] = input[3];
  1808.     output[1] = input[2];
  1809.     output[2] = input[1];
  1810.     output[3] = input[0];
  1811.     }
  1814. /*******************************************************************************
  1815. *
  1816. * pecoffTotalCommons - 
  1817. * 
  1818. *  INTERNAL
  1819. *  All common external symbols are being tacked on to the end
  1820. *  of the BSS section.  This function determines the additional amount
  1821. *  of memory required for the common symbols.
  1822. *  
  1823. */
  1825. LOCAL ULONG pecoffTotalCommons
  1826.     (
  1827.     SYMENT *pSym, /* pointer to external symbols */
  1828.     int nEnts, /* # of entries in symbol table */
  1829.     ULONG startAddr /* address to start from */
  1830.     )
  1831.     {
  1832.     int ix;
  1833.     ULONG alignBss; /* next boundry for common entry */
  1834.     int nbytes; /* bytes for alignment + data */
  1835.     int totalBytes = 0; /* total additional count for bss */
  1836.     int auxEnts = 0;                    /* auxiliary symbol entries to skip */
  1838.     /* calculate room for external commons in bss */
  1840.     alignBss = startAddr;
  1841.     for (ix = 0; ix < nEnts; ix++, pSym++)
  1842. {
  1843.         if (auxEnts)                    /* if this is an auxiliary entry */
  1844.             {
  1845.             auxEnts--;
  1846.             continue;                   /* skip it */
  1847.             }
  1848.         auxEnts = pSym->n_numaux;       /* # of aux entries for this symbol */
  1850. if (PECOFF_COMM(pSym))
  1851.     {
  1852.             nbytes = dataAlign(pSym->U_SYM_VALUE, alignBss)
  1853.                     + pSym->U_SYM_VALUE;
  1854.             totalBytes += nbytes;
  1855.             alignBss += nbytes;
  1856.             }
  1857. }
  1858.     return(totalBytes);
  1859.     }
  1861. /*******************************************************************************
  1862. *
  1863. *  dataAlign - determine address alignment for a data operand in memory
  1864. * 
  1865. *  The address of a data operand must be correctly aligned for data access.
  1866. *  This is architecture dependent. 
  1867. *  Generally, data operands are aligned on 'natural' boundaries as follows:
  1868. *          bytes on byte boundaries (they already are)
  1869. *          half-word operands on half-word boundaries
  1870. *          word operands on word boundaries
  1871. *          double-word operands on double-word boundaries
  1872. *
  1873. *  However, if a structure of size = 7 had to be aligned, it would need
  1874. *  to be aligned on a boundary that is a multiple of 4 bytes.
  1875. *
  1876. *  RETURNS:
  1877. * nbytes - number of bytes to be added to the address to obtain the
  1878. *                 correct alignment for the data
  1879. */
  1881. LOCAL ULONG dataAlign
  1882.     (
  1883.     ULONG size,                         /* size of data to be aligned */
  1884.     ULONG addr                         /* next possible address for data */
  1885.     )
  1886.     {
  1887.     ULONG nbytes;                 /* # bytes for alignment */
  1888.     int align;                        /* address should be multiple of align */
  1890.     if (size <= 1)
  1891.         align = 1;
  1892.     else if (size < 4)
  1893.         align = 2;
  1894.     else if (size < 8)
  1895.         align = 4;
  1896.     else if (size < 16)
  1897.         align = 8;
  1898.     else
  1899.         align = MAX_ALIGNMENT;          /* max required alignment */
  1901.     nbytes = addr % align;
  1902.     if (nbytes != 0)                    /* if not on correct boundary */
  1903.         nbytes = align - nbytes;
  1905.     return(nbytes);
  1906.     }
  1908. /*******************************************************************************
  1909. *
  1910. * bootPecoffModule - load an object module into memory
  1911. *
  1912. * This routine loads an object module in PECOFF format from the specified
  1913. * file, and places the code, data, and BSS at the locations specified within
  1914. * the file.  The entry point of the module is returned in <pEntry>.  This 
  1915. * routine is generally used for bootstrap loading.
  1916. *
  1917. * RETURNS:
  1918. * OK, or
  1919. * ERROR if the routine cannot read the file
  1920. *
  1921. * SEE ALSO: loadModuleAt()
  1922. */
  1924. STATUS bootPecoffModule
  1925.     (
  1926.     int fd, /* fd from which to read load module */
  1927.     FUNCPTR *pEntry /* entry point of module */
  1928.     )
  1929.     {
  1930.     FILHDR hdr; /* module's PECOFF header */
  1931.     PEOPTION optHdr;              /* module's PECOFF optional header */
  1932.     int nBytes;
  1933.     char tempBuf[MAX_SCNS * SCNHSZ];
  1934.     int tablesAreLE;
  1936.     /* read object module header */
  1938.     if (pecoffHdrRead (fd, &hdr, &tablesAreLE) != OK)
  1939. return (ERROR);
  1941.     /*  read in optional header */
  1943.     if (pecoffOpthdrRead (fd, &optHdr, tablesAreLE) != OK)
  1944. return (ERROR);
  1946.     /*  Read until start of text
  1947.      *
  1948.      *  Section headers aren't needed, but this is the easiest way to
  1949.      *  read passed them.
  1950.      */
  1951.     if (pecoffSecHdrRead (fd, (SCNHDR *)tempBuf, &hdr, tablesAreLE) != OK)
  1952. {
  1953. return(ERROR);
  1954. }
  1956.     printf ("%d", (int)optHdr.tsize);
  1957.     nBytes = fioRead (fd, (char *) optHdr.text_start, (int) optHdr.tsize);
  1958.     if (nBytes < optHdr.tsize)
  1959.         return (ERROR);
  1961.     printf (" + %d", (int)optHdr.dsize);
  1962.     nBytes = fioRead (fd, (char *) optHdr.data_start, (int) optHdr.dsize);
  1963.     if (nBytes < optHdr.dsize)
  1964.         return (ERROR);
  1966.     printf (" + %dn", (int)optHdr.bsize);
  1968.     /*  bss is zeroed by vxWorks startup code. 
  1969.      */
  1971.     *pEntry = (FUNCPTR) optHdr.entry;
  1972.     return (OK);
  1973.     }
  1975. /******************************************************************************
  1976. *
  1977. * bootPecoffInit - Initialize the system for pecoff load modules
  1978. *
  1979. * This routine initialized VxWorks to use the PECOFF format for
  1980. * boot loading modules.
  1981. *
  1982. * RETURNS:
  1983. * OK, or
  1984. * ERROR if XXX
  1985. *
  1986. * SEE ALSO: loadModuleAt()
  1987. */
  1988. STATUS bootPecoffInit
  1989.     (
  1990.     )
  1991.     {
  1992.     /* XXX check for installed ? */
  1993.     bootLoadRoutine = bootPecoffModule;
  1994.     return (OK);
  1995.     }
  1997. #endif /* CPU==SIMNT */