summaryrefslogtreecommitdiff
path: root/hw/xfree86/loader/coffloader.c
diff options
context:
space:
mode:
Diffstat (limited to 'hw/xfree86/loader/coffloader.c')
-rw-r--r--hw/xfree86/loader/coffloader.c1459
1 files changed, 726 insertions, 733 deletions
diff --git a/hw/xfree86/loader/coffloader.c b/hw/xfree86/loader/coffloader.c
index 7a1ef28ad..b2fbfcf14 100644
--- a/hw/xfree86/loader/coffloader.c
+++ b/hw/xfree86/loader/coffloader.c
@@ -1,4 +1,4 @@
-/* $XFree86: xc/programs/Xserver/hw/xfree86/loader/coffloader.c,v 1.18 2002/09/16 18:06:10 eich Exp $ */
+/* $XFree86: xc/programs/Xserver/hw/xfree86/loader/coffloader.c,v 1.21 2003/10/15 17:40:15 dawes Exp $ */
/*
*
@@ -48,63 +48,66 @@
#include "coffloader.h"
#include "compiler.h"
-/*
-#ifndef LDTEST
+
+#ifndef LOADERDEBUG
+#define LOADERDEBUG 0
+#endif
+
+#if LOADERDEBUG
#define COFFDEBUG ErrorF
#endif
-*/
/*
* This structure contains all of the information about a module
* that has been loaded.
*/
-typedef struct {
- int handle;
- long module; /* Id of the module used to find inter module calls */
- int fd;
- loader_funcs *funcs;
- FILHDR *header; /* file header */
- AOUTHDR *optheader; /* optional file header */
- unsigned short numsh;
- SCNHDR *sections; /* Start address of the section table */
- int secsize; /* size of the section table */
- unsigned char **saddr;/* Start addresss of the sections table */
- unsigned char **reladdr;/* Start addresss of the relocation table */
- unsigned char *strtab; /* Start address of the string table */
- int strsize; /* size of the string table */
- unsigned char *text; /* Start address of the .text section */
- int txtndx; /* index of the .text section */
- long txtaddr; /* offset of the .text section */
- int txtsize; /* size of the .text section */
- int txtrelsize; /* size of the .rel.text section */
- unsigned char *data; /* Start address of the .data section */
- int datndx; /* index of the .data section */
- long dataddr; /* offset of the .data section */
- int datsize; /* size of the .data section */
- int datrelsize; /* size of the .rel.data section */
- unsigned char *bss; /* Start address of the .bss section */
- int bssndx; /* index of the .bss section */
- long bssaddr; /* offset of the .bss section */
- int bsssize; /* size of the .bss section */
- SYMENT *symtab; /* Start address of the .symtab section */
- int symndx; /* index of the .symtab section */
- int symsize; /* size of the .symtab section */
- unsigned char *common; /* Start address of the .common section */
- int comsize; /* size of the .common section */
- long toc; /* Offset of the TOC csect */
- unsigned char *tocaddr; /* Address of the TOC csect */
- } COFFModuleRec, *COFFModulePtr;
+typedef struct {
+ int handle;
+ long module; /* Id of the module used to find inter module calls */
+ int fd;
+ loader_funcs *funcs;
+ FILHDR *header; /* file header */
+ AOUTHDR *optheader; /* optional file header */
+ unsigned short numsh;
+ SCNHDR *sections; /* Start address of the section table */
+ int secsize; /* size of the section table */
+ unsigned char **saddr; /* Start addresss of the sections table */
+ unsigned char **reladdr; /* Start addresss of the relocation table */
+ unsigned char *strtab; /* Start address of the string table */
+ int strsize; /* size of the string table */
+ unsigned char *text; /* Start address of the .text section */
+ int txtndx; /* index of the .text section */
+ long txtaddr; /* offset of the .text section */
+ int txtsize; /* size of the .text section */
+ int txtrelsize; /* size of the .rel.text section */
+ unsigned char *data; /* Start address of the .data section */
+ int datndx; /* index of the .data section */
+ long dataddr; /* offset of the .data section */
+ int datsize; /* size of the .data section */
+ int datrelsize; /* size of the .rel.data section */
+ unsigned char *bss; /* Start address of the .bss section */
+ int bssndx; /* index of the .bss section */
+ long bssaddr; /* offset of the .bss section */
+ int bsssize; /* size of the .bss section */
+ SYMENT *symtab; /* Start address of the .symtab section */
+ int symndx; /* index of the .symtab section */
+ int symsize; /* size of the .symtab section */
+ unsigned char *common; /* Start address of the .common section */
+ int comsize; /* size of the .common section */
+ long toc; /* Offset of the TOC csect */
+ unsigned char *tocaddr; /* Address of the TOC csect */
+} COFFModuleRec, *COFFModulePtr;
/*
* If any relocation is unable to be satisfied, then put it on a list
* to try later after more modules have been loaded.
*/
typedef struct _coff_reloc {
- COFFModulePtr file;
- RELOC *rel;
- int secndx;
- struct _coff_reloc *next;
+ COFFModulePtr file;
+ RELOC *rel;
+ int secndx;
+ struct _coff_reloc *next;
} COFFRelocRec;
/*
@@ -116,10 +119,10 @@ typedef struct _coff_reloc {
*/
typedef struct _coff_COMMON {
- SYMENT *sym;
- int index;
- struct _coff_COMMON *next;
- } COFFCommonRec;
+ SYMENT *sym;
+ int index;
+ struct _coff_COMMON *next;
+} COFFCommonRec;
static COFFCommonPtr listCOMMON = NULL;
@@ -140,36 +143,30 @@ static COFFRelocPtr COFFCollectRelocations(COFFModulePtr);
* Utility Functions
*/
-
static int
-COFFhashCleanOut(voidptr, item)
-void *voidptr;
-itemPtr item ;
+COFFhashCleanOut(void *voidptr, itemPtr item)
{
- COFFModulePtr module = (COFFModulePtr) voidptr;
- return ( module->handle == item->handle ) ;
-}
+ COFFModulePtr module = (COFFModulePtr) voidptr;
+ return (module->handle == item->handle);
+}
/*
* Manage listResolv
*/
static COFFRelocPtr
-COFFDelayRelocation(cofffile,secndx,rel)
-COFFModulePtr cofffile;
-int secndx;
-RELOC *rel;
+COFFDelayRelocation(COFFModulePtr cofffile, int secndx, RELOC *rel)
{
COFFRelocPtr reloc;
if ((reloc = xf86loadermalloc(sizeof(COFFRelocRec))) == NULL) {
- ErrorF( "COFFDelayRelocation() Unable to allocate memory!!!!\n" );
+ ErrorF("COFFDelayRelocation() Unable to allocate memory!!!!\n");
return 0;
}
- reloc->file=cofffile;
- reloc->secndx=secndx;
- reloc->rel=rel;
+ reloc->file = cofffile;
+ reloc->secndx = secndx;
+ reloc->rel = rel;
reloc->next = 0;
return reloc;
@@ -180,83 +177,80 @@ RELOC *rel;
*/
static COFFCommonPtr
-COFFAddCOMMON(sym,index)
-SYMENT *sym;
-int index;
+COFFAddCOMMON(SYMENT *sym, int index)
{
COFFCommonPtr common;
if ((common = xf86loadermalloc(sizeof(COFFCommonRec))) == NULL) {
- ErrorF( "COFFAddCOMMON() Unable to allocate memory!!!!\n" );
+ ErrorF("COFFAddCOMMON() Unable to allocate memory!!!!\n");
return 0;
}
- common->sym=sym;
- common->index=index;
- common->next=0;
+ common->sym = sym;
+ common->index = index;
+ common->next = 0;
return common;
}
static LOOKUP *
-COFFCreateCOMMON(cofffile)
-COFFModulePtr cofffile;
+COFFCreateCOMMON(COFFModulePtr cofffile)
{
- int numsyms=0,size=0,l=0;
- int offset=0;
- LOOKUP *lookup;
+ int numsyms = 0, size = 0, l = 0;
+ int offset = 0;
+ LOOKUP *lookup;
COFFCommonPtr common;
if (listCOMMON == NULL)
return NULL;
- common=listCOMMON;
+ common = listCOMMON;
for (common = listCOMMON; common; common = common->next) {
/* Ensure long word alignment */
- if( common->sym->n_value != 2
- && common->sym->n_value != 1) /* But not for short and char ;-)(mr)*/
- if( common->sym->n_value%4 != 0 )
- common->sym->n_value+= 4-(common->sym->n_value%4);
+ if (common->sym->n_value != 2 && common->sym->n_value != 1) /* But not for short and char ;-)(mr) */
+ if (common->sym->n_value % 4 != 0)
+ common->sym->n_value += 4 - (common->sym->n_value % 4);
/* accumulate the sizes */
- size+=common->sym->n_value;
+ size += common->sym->n_value;
numsyms++;
}
#ifdef COFFDEBUG
COFFDEBUG("COFFCreateCOMMON() %d entries (%d bytes) of COMMON data\n",
- numsyms, size );
+ numsyms, size);
#endif
- if ((lookup = xf86loadermalloc((numsyms+1)*sizeof(LOOKUP))) == NULL) {
- ErrorF( "COFFCreateCOMMON() Unable to allocate memory!!!!\n" );
- return NULL;
+ if ((lookup = xf86loadermalloc((numsyms + 1) * sizeof(LOOKUP))) == NULL) {
+ ErrorF("COFFCreateCOMMON() Unable to allocate memory!!!!\n");
+ return NULL;
}
- cofffile->comsize=size;
- if ((cofffile->common = xf86loadercalloc(1,size)) == NULL) {
- ErrorF( "COFFCreateCOMMON() Unable to allocate memory!!!!\n" );
- return NULL;
+ cofffile->comsize = size;
+ if ((cofffile->common = xf86loadercalloc(1, size)) == NULL) {
+ ErrorF("COFFCreateCOMMON() Unable to allocate memory!!!!\n");
+ return NULL;
}
/* Traverse the common list and create a lookup table with all the
* common symbols. Destroy the common list in the process.
* See also ResolveSymbols.
*/
- while(listCOMMON) {
- common=listCOMMON;
- lookup[l].symName=COFFGetSymbolName(cofffile,common->index);
- lookup[l].offset=(funcptr)(cofffile->common+offset);
+ while (listCOMMON) {
+ common = listCOMMON;
+ lookup[l].symName = COFFGetSymbolName(cofffile, common->index);
+ lookup[l].offset = (funcptr) (cofffile->common + offset);
#ifdef COFFDEBUG
- COFFDEBUG("Adding %x %s\n", lookup[l].offset, lookup[l].symName );
+ COFFDEBUG("Adding %p %s\n", (void *)lookup[l].offset,
+ lookup[l].symName);
#endif
- listCOMMON=common->next;
- offset+=common->sym->n_value;
- xf86loaderfree(common);
- l++;
+ listCOMMON = common->next;
+ offset += common->sym->n_value;
+ xf86loaderfree(common);
+ l++;
}
/* listCOMMON == NULL */
- lookup[l].symName=NULL; /* Terminate the list */
+ lookup[l].symName = NULL; /* Terminate the list */
return lookup;
}
@@ -268,68 +262,62 @@ COFFModulePtr cofffile;
* Get symbol name
*/
static char *
-COFFGetSymbolName(cofffile, index)
-COFFModulePtr cofffile;
-int index;
+COFFGetSymbolName(COFFModulePtr cofffile, int index)
{
- char *name;
- SYMENT *sym;
+ char *name;
+ SYMENT *sym;
- sym=(SYMENT *)(((unsigned char *)cofffile->symtab)+(index*SYMESZ));
+ sym = (SYMENT *) (((unsigned char *)cofffile->symtab) + (index * SYMESZ));
#ifdef COFFDEBUG
- COFFDEBUG("COFFGetSymbolName(%x,%x) %x",cofffile, index, sym->n_zeroes );
+ COFFDEBUG("COFFGetSymbolName(%p,%x) %lx", (void *)cofffile, index,
+ sym->n_zeroes);
#endif
name = xf86loadermalloc(sym->n_zeroes ? SYMNMLEN + 1
- : strlen((const char *)&cofffile->strtab[(int)sym->n_offset-4]) + 1);
+ : strlen((const char *)&cofffile->
+ strtab[(int)sym->n_offset - 4]) + 1);
if (!name)
FatalError("COFFGetSymbolName: Out of memory\n");
- if( sym->n_zeroes )
- {
- strncpy(name,sym->n_name,SYMNMLEN);
- name[SYMNMLEN]='\000';
- }
- else {
- strcpy(name, (const char *)&cofffile->strtab[(int)sym->n_offset-4]);
- }
+ if (sym->n_zeroes) {
+ strncpy(name, sym->n_name, SYMNMLEN);
+ name[SYMNMLEN] = '\000';
+ } else {
+ strcpy(name, (const char *)&cofffile->strtab[(int)sym->n_offset - 4]);
+ }
#ifdef COFFDEBUG
- COFFDEBUG(" %s\n", name );
+ COFFDEBUG(" %s\n", name);
#endif
return name;
}
static SYMENT *
-COFFGetSymbol(file, index)
-COFFModulePtr file;
-int index;
+COFFGetSymbol(COFFModulePtr file, int index)
{
- return (SYMENT *)(((unsigned char *)file->symtab)+(index*SYMESZ));
+ return (SYMENT *) (((unsigned char *)file->symtab) + (index * SYMESZ));
}
static unsigned char *
-COFFGetSymbolValue(cofffile, index)
-COFFModulePtr cofffile;
-int index;
+COFFGetSymbolValue(COFFModulePtr cofffile, int index)
{
- unsigned char *symval=0; /* value of the indicated symbol */
+ unsigned char *symval = 0; /* value of the indicated symbol */
itemPtr symbol; /* name/value of symbol */
- char *symname;
+ char *symname;
- symname=COFFGetSymbolName(cofffile, index);
+ symname = COFFGetSymbolName(cofffile, index);
#ifdef COFFDEBUG
- COFFDEBUG("COFFGetSymbolValue() for %s=", symname );
+ COFFDEBUG("COFFGetSymbolValue() for %s=", symname);
#endif
symbol = LoaderHashFind(symname);
- if( symbol )
- symval=(unsigned char *)symbol->address;
+ if (symbol)
+ symval = (unsigned char *)symbol->address;
#ifdef COFFDEBUG
- COFFDEBUG("%x\n", symval );
+ COFFDEBUG("%p\n", symval);
#endif
xf86loaderfree(symname);
@@ -343,22 +331,20 @@ int index;
* same module as the calling function.
*/
static unsigned char *
-COFFGetSymbolGlinkValue(cofffile, index)
-COFFModulePtr cofffile;
-int index;
+COFFGetSymbolGlinkValue(COFFModulePtr cofffile, int index)
{
- unsigned char *symval=0; /* value of the indicated symbol */
+ unsigned char *symval = 0; /* value of the indicated symbol */
itemPtr symbol; /* name/value of symbol */
- char *name;
+ char *name;
- name=COFFGetSymbolName(cofffile, index);
+ name = COFFGetSymbolName(cofffile, index);
#ifdef COFFDEBUG
- COFFDEBUG("COFFGetSymbolGlinkValue() for %s=", name );
+ COFFDEBUG("COFFGetSymbolGlinkValue() for %s=", name);
#endif
- symbol = LoaderHashFind(name+1); /* Eat the '.' so we get the
- Function descriptor instead */
+ symbol = LoaderHashFind(name + 1); /* Eat the '.' so we get the
+ * Function descriptor instead */
/* Here we are building up a glink function that will change the TOC
* pointer before calling a function that resides in a different module.
@@ -373,26 +359,27 @@ int index;
7 00000018 4e800420 bctr # branch to it
*/
- if( symbol ) {
- symval=(unsigned char *)&symbol->code.glink;
+ if (symbol) {
+ symval = (unsigned char *)&symbol->code.glink;
#ifdef COFFDEBUG
- COFFDEBUG("%x\n", symval );
- COFFDEBUG("glink_%s=%x\n", name,symval );
-#endif
- symbol->code.glink[ 0]=0x3d80; /* lis r12 */
- symbol->code.glink[ 1]=((unsigned long)symbol->address&0xffff0000)>>16;
- symbol->code.glink[ 2]=0x618c; /* ori r12 */
- symbol->code.glink[ 3]=((unsigned long)symbol->address&0x0000ffff);
- symbol->code.glink[ 4]=0x9041; /* st r2,20(r1) */
- symbol->code.glink[ 5]=0x0014;
- symbol->code.glink[ 6]=0x804c; /* l r2,0(r12) */
- symbol->code.glink[ 7]=0x0000;
- symbol->code.glink[ 8]=0x7c49; /* mtctr r2 */
- symbol->code.glink[ 9]=0x03a6;
- symbol->code.glink[10]=0x804c; /* l r2,4(r12) */
- symbol->code.glink[11]=0x0004;
- symbol->code.glink[12]=0x4e80; /* bctr */
- symbol->code.glink[13]=0x0420;
+ COFFDEBUG("%x\n", symval);
+ COFFDEBUG("glink_%s=%x\n", name, symval);
+#endif
+ symbol->code.glink[0] = 0x3d80; /* lis r12 */
+ symbol->code.glink[1] =
+ ((unsigned long)symbol->address & 0xffff0000) >> 16;
+ symbol->code.glink[2] = 0x618c; /* ori r12 */
+ symbol->code.glink[3] = ((unsigned long)symbol->address & 0x0000ffff);
+ symbol->code.glink[4] = 0x9041; /* st r2,20(r1) */
+ symbol->code.glink[5] = 0x0014;
+ symbol->code.glink[6] = 0x804c; /* l r2,0(r12) */
+ symbol->code.glink[7] = 0x0000;
+ symbol->code.glink[8] = 0x7c49; /* mtctr r2 */
+ symbol->code.glink[9] = 0x03a6;
+ symbol->code.glink[10] = 0x804c; /* l r2,4(r12) */
+ symbol->code.glink[11] = 0x0004;
+ symbol->code.glink[12] = 0x4e80; /* bctr */
+ symbol->code.glink[13] = 0x0420;
ppc_flush_icache(&symbol->code.glink[0]);
ppc_flush_icache(&symbol->code.glink[12]);
}
@@ -406,17 +393,15 @@ int index;
* Fix all of the relocation for the given section.
*/
static COFFRelocPtr
-COFF_RelocateEntry(cofffile, secndx, rel)
-COFFModulePtr cofffile;
-int secndx; /* index of the target section */
-RELOC *rel;
+COFF_RelocateEntry(COFFModulePtr cofffile, int secndx, RELOC *rel)
{
- SYMENT *symbol; /* value of the indicated symbol */
+ SYMENT *symbol; /* value of the indicated symbol */
unsigned long *dest32; /* address of the place being modified */
+
#if defined(__powerpc__)
unsigned short *dest16; /* address of the place being modified */
- itemPtr symitem; /* symbol structure from has table */
- char *name;
+ itemPtr symitem; /* symbol structure from has table */
+ char *name;
#endif
unsigned char *symval; /* value of the indicated symbol */
@@ -431,386 +416,401 @@ RELOC *rel;
*/
#ifdef COFFDEBUG
- COFFDEBUG("%x %d %o ",
- rel->r_vaddr,rel->r_symndx,rel->r_type );
+ COFFDEBUG("%lx %ld %o ", (unsigned long)rel->r_vaddr,
+ rel->r_symndx, rel->r_type);
#if defined(__powerpc__)
COFFDEBUG("[%x %x %x] ",
- RELOC_RSIGN(*rel), RELOC_RFIXUP(*rel), RELOC_RLEN(*rel));
+ RELOC_RSIGN(*rel), RELOC_RFIXUP(*rel), RELOC_RLEN(*rel));
#endif
#endif
- symbol=COFFGetSymbol(cofffile,rel->r_symndx);
+ symbol = COFFGetSymbol(cofffile, rel->r_symndx);
#ifdef COFFDEBUG
- COFFDEBUG("%d %x %d-%d\n", symbol->n_sclass, symbol->n_value, symbol->n_scnum, secndx );
+ COFFDEBUG("%d %lx %d-%d\n", symbol->n_sclass, symbol->n_value,
+ symbol->n_scnum, secndx);
#endif
/*
* Check to see if the relocation offset is part of the .text segment.
* If not, we must change the offset to be relative to the .data section
* which is NOT contiguous.
- */
- switch(secndx+1) { /* change the bias */
+ */
+ switch (secndx + 1) { /* change the bias */
case N_TEXT:
- if( (long)rel->r_vaddr < cofffile->txtaddr ||
- (long)rel->r_vaddr > (long)(cofffile->txtaddr+cofffile->txtsize) ) {
- FatalError("Relocation against N_TEXT not in .text section\n");
+ if ((long)rel->r_vaddr < cofffile->txtaddr ||
+ (long)rel->r_vaddr >
+ (long)(cofffile->txtaddr + cofffile->txtsize)) {
+ FatalError("Relocation against N_TEXT not in .text section\n");
}
- dest32=(unsigned long *)((long)(cofffile->saddr[secndx])+
- ((unsigned char *)rel->r_vaddr-cofffile->txtaddr));
+ dest32 = (unsigned long *)((long)(cofffile->saddr[secndx]) +
+ ((unsigned char *)rel->r_vaddr -
+ cofffile->txtaddr));
break;
case N_DATA:
- if( (long)rel->r_vaddr < cofffile->dataddr ||
- (long)rel->r_vaddr > (long)(cofffile->dataddr+cofffile->datsize) ) {
- FatalError("Relocation against N_DATA not in .data section\n");
+ if ((long)rel->r_vaddr < cofffile->dataddr ||
+ (long)rel->r_vaddr >
+ (long)(cofffile->dataddr + cofffile->datsize)) {
+ FatalError("Relocation against N_DATA not in .data section\n");
}
- dest32=(unsigned long *)((long)(cofffile->saddr[secndx])+
- ((unsigned char *)rel->r_vaddr-cofffile->dataddr));
+ dest32 = (unsigned long *)((long)(cofffile->saddr[secndx]) +
+ ((unsigned char *)rel->r_vaddr -
+ cofffile->dataddr));
break;
case N_BSS:
- if( (long)rel->r_vaddr < cofffile->bssaddr ||
- (long)rel->r_vaddr > (long)(cofffile->bssaddr+cofffile->bsssize) ) {
- FatalError("Relocation against N_TEXT not in .bss section\n");
+ if ((long)rel->r_vaddr < cofffile->bssaddr ||
+ (long)rel->r_vaddr >
+ (long)(cofffile->bssaddr + cofffile->bsssize)) {
+ FatalError("Relocation against N_TEXT not in .bss section\n");
}
- dest32=(unsigned long *)((long)(cofffile->saddr[secndx])+
- ((unsigned char *)rel->r_vaddr-cofffile->bssaddr));
+ dest32 = (unsigned long *)((long)(cofffile->saddr[secndx]) +
+ ((unsigned char *)rel->r_vaddr -
+ cofffile->bssaddr));
break;
default:
- FatalError("Relocation against unknown section %d\n", secndx );
+ FatalError("Relocation against unknown section %d\n", secndx);
}
- if( symbol->n_sclass == 0 )
- {
- symval=(unsigned char *)(symbol->n_value+(*dest32)-symbol->n_type);
+ if (symbol->n_sclass == 0) {
+ symval = (unsigned char *)(symbol->n_value + (*dest32) -
+ symbol->n_type);
#ifdef COFFDEBUG
- COFFDEBUG( "symbol->n_sclass==0\n" );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
+ COFFDEBUG("symbol->n_sclass==0\n");
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
#endif
- *dest32=(unsigned long)symval;
- return 0;
- }
+ *dest32 = (unsigned long)symval;
+ return 0;
+ }
- switch( rel->r_type )
- {
+ switch (rel->r_type) {
#if defined(i386)
- case R_DIR32:
- symval=COFFGetSymbolValue(cofffile, rel->r_symndx);
- if( symval ) {
+ case R_DIR32:
+ symval = COFFGetSymbolValue(cofffile, rel->r_symndx);
+ if (symval) {
#ifdef COFFDEBUG
- char *namestr;
- COFFDEBUG( "R_DIR32 %s\n",
- namestr=COFFGetSymbolName(cofffile,rel->r_symndx) );
- xf86loaderfree(namestr);
- COFFDEBUG( "txtsize=%x\t", cofffile->txtsize );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)(symval+(*dest32)-symbol->n_value);
- } else {
- switch( symbol->n_scnum ) {
- case N_UNDEF:
+ char *namestr;
+
+ COFFDEBUG("R_DIR32 %s\n",
+ namestr = COFFGetSymbolName(cofffile, rel->r_symndx));
+ xf86loaderfree(namestr);
+ COFFDEBUG("txtsize=%x\t", cofffile->txtsize);
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
+#endif
+ *dest32 = (unsigned long)(symval + (*dest32) - symbol->n_value);
+ } else {
+ switch (symbol->n_scnum) {
+ case N_UNDEF:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_UNDEF\n" );
+ COFFDEBUG("R_DIR32 N_UNDEF\n");
#endif
- return COFFDelayRelocation(cofffile,secndx,rel);
- case N_ABS:
+ return COFFDelayRelocation(cofffile, secndx, rel);
+ case N_ABS:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_ABS\n" );
+ COFFDEBUG("R_DIR32 N_ABS\n");
#endif
- return 0;
- case N_DEBUG:
+ return 0;
+ case N_DEBUG:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_DEBUG\n" );
+ COFFDEBUG("R_DIR32 N_DEBUG\n");
#endif
- return 0;
- case N_COMMENT:
+ return 0;
+ case N_COMMENT:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_COMMENT\n" );
+ COFFDEBUG("R_DIR32 N_COMMENT\n");
#endif
- return 0;
- case N_TEXT:
+ return 0;
+ case N_TEXT:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_TEXT\n" );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- (unsigned long)(cofffile->saddr[N_TEXT-1]));
- break;
- case N_DATA:
+ COFFDEBUG("R_DIR32 N_TEXT\n");
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ (unsigned long)(cofffile->
+ saddr[N_TEXT - 1]));
+ break;
+ case N_DATA:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_DATA\n" );
- COFFDEBUG( "txtsize=%x\t", cofffile->txtsize );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- ((unsigned long)(cofffile->saddr[N_DATA-1]))-
- cofffile->dataddr);
- break;
- case N_BSS:
+ COFFDEBUG("R_DIR32 N_DATA\n");
+ COFFDEBUG("txtsize=%x\t", cofffile->txtsize);
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ ((unsigned long)(cofffile->
+ saddr[N_DATA -
+ 1])) -
+ cofffile->dataddr);
+ break;
+ case N_BSS:
#ifdef COFFDEBUG
- COFFDEBUG( "R_DIR32 N_BSS\n" );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- (unsigned long)(cofffile->saddr[N_BSS-1])-
- (cofffile->bssaddr));
- break;
- default:
- ErrorF("R_DIR32 with unexpected section %d\n",
- symbol->n_scnum );
- }
-
+ COFFDEBUG("R_DIR32 N_BSS\n");
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ (unsigned long)(cofffile->
+ saddr[N_BSS - 1]) -
+ (cofffile->bssaddr));
+ break;
+ default:
+ ErrorF("R_DIR32 with unexpected section %d\n",
+ symbol->n_scnum);
}
+
+ }
#ifdef COFFDEBUG
- COFFDEBUG( "*dest32=%8.8x\n", *dest32 );
+ COFFDEBUG("*dest32=%8.8lx\n", *dest32);
#endif
+ break;
+ case R_PCRLONG:
+ if (symbol->n_scnum == N_TEXT)
break;
- case R_PCRLONG:
- if( symbol->n_scnum == N_TEXT )
- break;
- symval=COFFGetSymbolValue(cofffile, rel->r_symndx);
+ symval = COFFGetSymbolValue(cofffile, rel->r_symndx);
#ifdef COFFDEBUG
- COFFDEBUG( "R_PCRLONG ");
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
+ COFFDEBUG("R_PCRLONG ");
+ COFFDEBUG("dest32=%p\t", (void *)dest32);
+ COFFDEBUG("symval=%p\t", symval);
+ COFFDEBUG("*dest32=%8.8lx\t", *dest32);
#endif
- if( symval == 0 ) {
+ if (symval == 0) {
#ifdef COFFDEBUG
- char *name;
- COFFDEBUG( "***Unable to resolve symbol %s\n",
- name=COFFGetSymbolName(cofffile,rel->r_symndx) );
- xf86loaderfree(name);
+ char *name;
+
+ COFFDEBUG("***Unable to resolve symbol %s\n",
+ name = COFFGetSymbolName(cofffile, rel->r_symndx));
+ xf86loaderfree(name);
#endif
- return COFFDelayRelocation(cofffile,secndx,rel);
- }
- *dest32=(unsigned long)(symval-((long)dest32+sizeof(long)));
+ return COFFDelayRelocation(cofffile, secndx, rel);
+ }
+ *dest32 = (unsigned long)(symval - ((long)dest32 + sizeof(long)));
#ifdef COFFDEBUG
- COFFDEBUG( "*dest32=%8.8x\n", *dest32 );
+ COFFDEBUG("*dest32=%8.8lx\n", *dest32);
#endif
- break;
- case R_ABS:
- /*
- * Nothing to really do here.
- * Usually, a dummy relocation for .file
- */
- break;
+ break;
+ case R_ABS:
+ /*
+ * Nothing to really do here.
+ * Usually, a dummy relocation for .file
+ */
+ break;
#endif /* i386 */
#if defined(__powerpc__)
- case R_POS:
- /*
- * Positive Relocation
- */
- if( RELOC_RLEN(*rel) != 0x1f )
- FatalError("R_POS with size != 32 bits" );
- symval=COFFGetSymbolValue(cofffile, rel->r_symndx);
- if( symval ) {
+ case R_POS:
+ /*
+ * Positive Relocation
+ */
+ if (RELOC_RLEN(*rel) != 0x1f)
+ FatalError("R_POS with size != 32 bits");
+ symval = COFFGetSymbolValue(cofffile, rel->r_symndx);
+ if (symval) {
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS ");
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
+ COFFDEBUG("R_POS ");
+ COFFDEBUG("dest32=%x\t", dest32);
+ COFFDEBUG("symval=%x\t", symval);
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
#endif
- *dest32=(unsigned long)(symval+(*dest32)-symbol->n_value);
- ppc_flush_icache(dest32);
- } else {
- switch( symbol->n_scnum ) {
- case N_UNDEF:
+ *dest32 = (unsigned long)(symval + (*dest32) - symbol->n_value);
+ ppc_flush_icache(dest32);
+ } else {
+ switch (symbol->n_scnum) {
+ case N_UNDEF:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_UNDEF\n" );
+ COFFDEBUG("R_POS N_UNDEF\n");
#endif
- return COFFDelayRelocation(cofffile,secndx,rel);
- case N_ABS:
+ return COFFDelayRelocation(cofffile, secndx, rel);
+ case N_ABS:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_ABS\n" );
+ COFFDEBUG("R_POS N_ABS\n");
#endif
- return 0;
- case N_DEBUG:
+ return 0;
+ case N_DEBUG:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_DEBUG\n" );
+ COFFDEBUG("R_POS N_DEBUG\n");
#endif
- return 0;
- case N_COMMENT:
+ return 0;
+ case N_COMMENT:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_COMMENT\n" );
+ COFFDEBUG("R_POS N_COMMENT\n");
#endif
- return 0;
- case N_TEXT:
+ return 0;
+ case N_TEXT:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_TEXT\n" );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- ((unsigned long)(cofffile->saddr[N_TEXT-1]))-
- cofffile->txtaddr);
- ppc_flush_icache(dest32);
- break;
- case N_DATA:
+ COFFDEBUG("R_POS N_TEXT\n");
+ COFFDEBUG("dest32=%x\t", dest32);
+ COFFDEBUG("symval=%x\t", symval);
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ ((unsigned long)(cofffile->
+ saddr[N_TEXT -
+ 1])) -
+ cofffile->txtaddr);
+ ppc_flush_icache(dest32);
+ break;
+ case N_DATA:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_DATA\n" );
- COFFDEBUG( "txtsize=%x\t", cofffile->txtsize );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- ((unsigned long)(cofffile->saddr[N_DATA-1]))-
- cofffile->dataddr);
- ppc_flush_icache(dest32);
- break;
- case N_BSS:
+ COFFDEBUG("R_POS N_DATA\n");
+ COFFDEBUG("txtsize=%x\t", cofffile->txtsize);
+ COFFDEBUG("dest32=%x\t", dest32);
+ COFFDEBUG("symval=%x\t", symval);
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ ((unsigned long)(cofffile->
+ saddr[N_DATA -
+ 1])) -
+ cofffile->dataddr);
+ ppc_flush_icache(dest32);
+ break;
+ case N_BSS:
#ifdef COFFDEBUG
- COFFDEBUG( "R_POS N_BSS\n" );
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- *dest32=(unsigned long)((*dest32)+
- (unsigned long)(cofffile->saddr[N_BSS-1])-
- (cofffile->bssaddr));
- ppc_flush_icache(dest32);
- break;
- default:
- ErrorF("R_POS with unexpected section %d\n",
- symbol->n_scnum );
- }
+ COFFDEBUG("R_POS N_BSS\n");
+ COFFDEBUG("dest32=%x\t", dest32);
+ COFFDEBUG("symval=%x\t", symval);
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
+#endif
+ *dest32 = (unsigned long)((*dest32) +
+ (unsigned long)(cofffile->
+ saddr[N_BSS - 1]) -
+ (cofffile->bssaddr));
+ ppc_flush_icache(dest32);
+ break;
+ default:
+ ErrorF("R_POS with unexpected section %d\n", symbol->n_scnum);
}
+ }
#ifdef COFFDEBUG
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
- COFFDEBUG( "\n" );
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
+ COFFDEBUG("\n");
#endif
- break;
- case R_TOC:
- /*
- * Relative to TOC
- */
- {
- dest16=(unsigned short *)dest32;
- if( RELOC_RLEN(*rel) != 0x0f )
- FatalError("R_TOC with size != 16 bits" );
+ break;
+ case R_TOC:
+ /*
+ * Relative to TOC
+ */
+ {
+ dest16 = (unsigned short *)dest32;
+ if (RELOC_RLEN(*rel) != 0x0f)
+ FatalError("R_TOC with size != 16 bits");
#ifdef COFFDEBUG
- COFFDEBUG( "R_TOC ");
- COFFDEBUG( "dest16=%x\t", dest16 );
- COFFDEBUG( "symbol=%x\t", symbol );
- COFFDEBUG( "symbol->n_value=%x\t", symbol->n_value );
- COFFDEBUG( "cofffile->toc=%x\t", cofffile->toc );
- COFFDEBUG( "*dest16=%8.8x\t", *dest16 );
-#endif
- *dest16=(unsigned long)((symbol->n_value-cofffile->toc));
+ COFFDEBUG("R_TOC ");
+ COFFDEBUG("dest16=%x\t", dest16);
+ COFFDEBUG("symbol=%x\t", symbol);
+ COFFDEBUG("symbol->n_value=%x\t", symbol->n_value);
+ COFFDEBUG("cofffile->toc=%x\t", cofffile->toc);
+ COFFDEBUG("*dest16=%8.8x\t", *dest16);
+#endif
+ *dest16 = (unsigned long)((symbol->n_value - cofffile->toc));
ppc_flush_icache(dest16);
- }
+ }
#ifdef COFFDEBUG
- COFFDEBUG( "*dest16=%8.8x\t", *dest16 );
- COFFDEBUG( "\n" );
+ COFFDEBUG("*dest16=%8.8x\t", *dest16);
+ COFFDEBUG("\n");
#endif
- break;
- case R_BR:
- /*
- * Branch relative to self, non-modifiable
- */
-
- if( RELOC_RLEN(*rel) != 0x19 )
- FatalError("R_BR with size != 24 bits" );
- name = COFFGetSymbolName(cofffile, rel->r_symndx);
+ break;
+ case R_BR:
+ /*
+ * Branch relative to self, non-modifiable
+ */
+
+ if (RELOC_RLEN(*rel) != 0x19)
+ FatalError("R_BR with size != 24 bits");
+ name = COFFGetSymbolName(cofffile, rel->r_symndx);
+ symitem = LoaderHashFind(name);
+ if (symitem == 0) {
+ name++;
symitem = LoaderHashFind(name);
- if( symitem == 0 ) {
- name++;
- symitem = LoaderHashFind(name);
- }
- if( symitem && cofffile->module != symitem->module ) {
+ }
+ if (symitem && cofffile->module != symitem->module) {
#ifdef COFFDEBUG
- COFFDEBUG("Symbol module %d != file module %d\n",
- symitem->module, cofffile->module );
+ COFFDEBUG("Symbol module %d != file module %d\n",
+ symitem->module, cofffile->module);
#endif
- symval=COFFGetSymbolGlinkValue(cofffile, rel->r_symndx);
- }
- else
- symval=COFFGetSymbolValue(cofffile, rel->r_symndx);
- if( symval == 0 ) {
+ symval = COFFGetSymbolGlinkValue(cofffile, rel->r_symndx);
+ } else
+ symval = COFFGetSymbolValue(cofffile, rel->r_symndx);
+ if (symval == 0) {
#ifdef COFFDEBUG
- char *name;
- COFFDEBUG( "***Unable to resolve symbol %s\n",
- name=COFFGetSymbolName(cofffile,rel->r_symndx) );
- xf86loaderfree(name);
+ char *name;
+
+ COFFDEBUG("***Unable to resolve symbol %s\n",
+ name = COFFGetSymbolName(cofffile, rel->r_symndx));
+ xf86loaderfree(name);
#endif
- return COFFDelayRelocation(cofffile,secndx,rel);
- }
+ return COFFDelayRelocation(cofffile, secndx, rel);
+ }
#ifdef COFFDEBUG
- COFFDEBUG( "R_BR ");
- COFFDEBUG( "dest32=%x\t", dest32 );
- COFFDEBUG( "symval=%x\t", symval );
- COFFDEBUG( "*dest32=%8.8x\t", *dest32 );
-#endif
- {
- unsigned long val;
- val=((unsigned long)symval-(unsigned long)dest32);
+ COFFDEBUG("R_BR ");
+ COFFDEBUG("dest32=%x\t", dest32);
+ COFFDEBUG("symval=%x\t", symval);
+ COFFDEBUG("*dest32=%8.8x\t", *dest32);
+#endif
+ {
+ unsigned long val;
+
+ val = ((unsigned long)symval - (unsigned long)dest32);
#ifdef COFFDEBUG
- COFFDEBUG( "val=%8.8x\n", val );
+ COFFDEBUG("val=%8.8x\n", val);
#endif
- val = val>>2;
- if( (val & 0x3f000000) != 0x3f000000 &&
- (val & 0x3f000000) != 0x00000000 ) {
- FatalError( "R_BR offset %x too large\n", val<<2 );
- break;
- }
- val &= 0x00ffffff;
+ val = val >> 2;
+ if ((val & 0x3f000000) != 0x3f000000 &&
+ (val & 0x3f000000) != 0x00000000) {
+ FatalError("R_BR offset %x too large\n", val << 2);
+ break;
+ }
+ val &= 0x00ffffff;
#ifdef COFFDEBUG
- COFFDEBUG( "val=%8.8x\n", val );
-#endif
- /*
- * The address part contains the offset to the beginning
- * of the .text section. Disreguard this since we have
- * calculated the correct offset already.
- */
- (*dest32)=((*dest32)&0xfc000003)|(val<<2);
+ COFFDEBUG("val=%8.8x\n", val);
+#endif
+ /*
+ * The address part contains the offset to the beginning
+ * of the .text section. Disreguard this since we have
+ * calculated the correct offset already.
+ */
+ (*dest32) = ((*dest32) & 0xfc000003) | (val << 2);
#ifdef COFFDEBUG
- COFFDEBUG( "*dest32=%8.8x\n", *dest32 );
+ COFFDEBUG("*dest32=%8.8x\n", *dest32);
#endif
- if( cofffile->module != symitem->module ) {
- (*++dest32)=0x80410014; /* lwz r2,20(r1) */
- }
- ppc_flush_icache(--dest32);
+ if (cofffile->module != symitem->module) {
+ (*++dest32) = 0x80410014; /* lwz r2,20(r1) */
}
+ ppc_flush_icache(--dest32);
+ }
- break;
+ break;
#endif /* __powerpc__ */
- default:
- ErrorF(
- "COFF_RelocateEntry() Unsupported relocation type %o\n",
- rel->r_type );
- break;
- }
+ default:
+ ErrorF("COFF_RelocateEntry() Unsupported relocation type %o\n",
+ rel->r_type);
+ break;
+ }
return 0;
}
static COFFRelocPtr
-COFFCollectRelocations(cofffile)
-COFFModulePtr cofffile;
+COFFCollectRelocations(COFFModulePtr cofffile)
{
- unsigned short i,j;
- RELOC *rel;
- SCNHDR *sec;
+ unsigned short i, j;
+ RELOC *rel;
+ SCNHDR *sec;
COFFRelocPtr reloc_head = NULL;
COFFRelocPtr tmp;
- for(i=0; i<cofffile->numsh; i++ ) {
- if( cofffile->saddr[i] == NULL )
- continue; /* Section not loaded!! */
- sec=&(cofffile->sections[i]);
- for(j=0;j<sec->s_nreloc;j++) {
- rel=(RELOC *)(cofffile->reladdr[i]+(j*RELSZ));
- tmp = COFFDelayRelocation(cofffile,i,rel);
+ for (i = 0; i < cofffile->numsh; i++) {
+ if (cofffile->saddr[i] == NULL)
+ continue; /* Section not loaded!! */
+ sec = &(cofffile->sections[i]);
+ for (j = 0; j < sec->s_nreloc; j++) {
+ rel = (RELOC *) (cofffile->reladdr[i] + (j * RELSZ));
+ tmp = COFFDelayRelocation(cofffile, i, rel);
tmp->next = reloc_head;
reloc_head = tmp;
}
@@ -826,199 +826,191 @@ COFFModulePtr cofffile;
*/
static LOOKUP *
-COFF_GetSymbols(cofffile)
-COFFModulePtr cofffile;
+COFF_GetSymbols(COFFModulePtr cofffile)
{
- SYMENT *sym;
- AUXENT *aux=NULL;
- int i, l, numsyms;
- LOOKUP *lookup, *lookup_common, *p;
- char *symname;
+ SYMENT *sym;
+ AUXENT *aux = NULL;
+ int i, l, numsyms;
+ LOOKUP *lookup, *lookup_common, *p;
+ char *symname;
/*
* Load the symbols into memory
*/
- numsyms=cofffile->header->f_nsyms;
+ numsyms = cofffile->header->f_nsyms;
#ifdef COFFDEBUG
- COFFDEBUG("COFF_GetSymbols(): %d symbols\n", numsyms );
+ COFFDEBUG("COFF_GetSymbols(): %d symbols\n", numsyms);
#endif
- cofffile->symsize=(numsyms*SYMESZ);
- cofffile->symtab=(SYMENT *)_LoaderFileToMem(cofffile->fd,cofffile->header->f_symptr,
- (numsyms*SYMESZ),"symbols");
+ cofffile->symsize = (numsyms * SYMESZ);
+ cofffile->symtab =
+ (SYMENT *) _LoaderFileToMem(cofffile->fd,
+ cofffile->header->f_symptr,
+ (numsyms * SYMESZ), "symbols");
- if ((lookup = xf86loadermalloc((numsyms+1)*sizeof(LOOKUP))) == NULL)
+ if ((lookup = xf86loadermalloc((numsyms + 1) * sizeof(LOOKUP))) == NULL)
return NULL;
- for(i=0,l=0; i<numsyms; i++)
- {
- sym=(SYMENT *)(((unsigned char *)cofffile->symtab)+(i*SYMESZ));
- symname=COFFGetSymbolName(cofffile,i);
- if( sym->n_numaux > 0 )
- aux=(AUXENT *)(((unsigned char *)cofffile->symtab)+((i+1)*SYMESZ));
- else
- aux=NULL;
+ for (i = 0, l = 0; i < numsyms; i++) {
+ sym = (SYMENT *) (((unsigned char *)cofffile->symtab) + (i * SYMESZ));
+ symname = COFFGetSymbolName(cofffile, i);
+ if (sym->n_numaux > 0)
+ aux = (AUXENT *) (((unsigned char *)cofffile->symtab) +
+ ((i + 1) * SYMESZ));
+ else
+ aux = NULL;
#ifdef COFFDEBUG
- COFFDEBUG("\t%d %d %x %x %d %d %s\n",
- i, sym->n_scnum, sym->n_value, sym->n_type,
- sym->n_sclass, sym->n_numaux, symname );
- if( aux )
- COFFDEBUG("aux=\t%d %x %x %x %x %x %x\n",
- aux->x_scnlen, aux->x_parmhash, aux->x_snhash,
- aux->x_smtyp, aux->x_smclas, aux->x_stab,
- aux->x_snstab );
-#endif
- i+=sym->n_numaux;
- /*
- * check for TOC csect before discarding C_HIDEXT below
- */
- if( aux && aux->x_smclas == XMC_TC0 ) {
- if( sym->n_scnum != N_DATA )
- FatalError("TOC not in N_DATA section");
- cofffile->toc=sym->n_value;
- cofffile->tocaddr=(cofffile->saddr[sym->n_scnum-1]+
- sym->n_value-(cofffile->dataddr));
+ COFFDEBUG("\t%d %d %lx %x %d %d %s\n",
+ i, sym->n_scnum, sym->n_value, sym->n_type,
+ sym->n_sclass, sym->n_numaux, symname);
+ if (aux)
+ COFFDEBUG("aux=\t%ld %lx %x %x %x %lx %x\n",
+ aux->x_scnlen, aux->x_parmhash, aux->x_snhash,
+ aux->x_smtyp, aux->x_smclas, aux->x_stab,
+ aux->x_snstab);
+#endif
+ i += sym->n_numaux;
+ /*
+ * check for TOC csect before discarding C_HIDEXT below
+ */
+ if (aux && aux->x_smclas == XMC_TC0) {
+ if (sym->n_scnum != N_DATA)
+ FatalError("TOC not in N_DATA section");
+ cofffile->toc = sym->n_value;
+ cofffile->tocaddr = (cofffile->saddr[sym->n_scnum - 1] +
+ sym->n_value - (cofffile->dataddr));
#ifdef COFFDEBUG
- COFFDEBUG("TOC=%x\n", cofffile->toc );
- COFFDEBUG("TOCaddr=%x\n", cofffile->tocaddr );
+ COFFDEBUG("TOC=%lx\n", cofffile->toc);
+ COFFDEBUG("TOCaddr=%p\n", cofffile->tocaddr);
#endif
- continue;
- }
- if( sym->n_sclass == C_HIDEXT ) {
+ continue;
+ }
+ if (sym->n_sclass == C_HIDEXT) {
/*
&& aux && !(aux->x_smclas == XMC_DS
&& aux->x_smtyp == XTY_SD) ) ) {
*/
#ifdef COFFDEBUG
- COFFDEBUG("Skipping C_HIDEXT class symbol %s\n", symname );
+ COFFDEBUG("Skipping C_HIDEXT class symbol %s\n", symname);
#endif
- continue;
- }
- switch( sym->n_scnum )
- {
- case N_UNDEF:
- if( sym->n_value != 0 ) {
- char *name;
- COFFCommonPtr tmp;
-
- name = COFFGetSymbolName(cofffile,i);
+ continue;
+ }
+ switch (sym->n_scnum) {
+ case N_UNDEF:
+ if (sym->n_value != 0) {
+ char *name;
+ COFFCommonPtr tmp;
+
+ name = COFFGetSymbolName(cofffile, i);
#ifdef COFFDEBUG
- COFFDEBUG("Adding COMMON space for %s\n", name);
-#endif
- if(!LoaderHashFind(name)) {
- tmp = COFFAddCOMMON(sym,i);
- if (tmp) {
- tmp->next = listCOMMON;
- listCOMMON = tmp;
- }
- }
- xf86loaderfree(name);
+ COFFDEBUG("Adding COMMON space for %s\n", name);
+#endif
+ if (!LoaderHashFind(name)) {
+ tmp = COFFAddCOMMON(sym, i);
+ if (tmp) {
+ tmp->next = listCOMMON;
+ listCOMMON = tmp;
}
- xf86loaderfree(symname);
- break;
- case N_ABS:
- case N_DEBUG:
- case N_COMMENT:
+ }
+ xf86loaderfree(name);
+ }
+ xf86loaderfree(symname);
+ break;
+ case N_ABS:
+ case N_DEBUG:
+ case N_COMMENT:
#ifdef COFFDEBUG
- COFFDEBUG("Freeing %s, section %d\n",
- symname, sym->n_scnum );
-#endif
- xf86loaderfree(symname);
- break;
- case N_TEXT:
- if( (sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
- && cofffile->saddr[sym->n_scnum-1]) {
- lookup[l].symName=symname;
- lookup[l].offset=(funcptr)
- (cofffile->saddr[sym->n_scnum-1]+
- sym->n_value-cofffile->txtaddr);
+ COFFDEBUG("Freeing %s, section %d\n", symname, sym->n_scnum);
+#endif
+ xf86loaderfree(symname);
+ break;
+ case N_TEXT:
+ if ((sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
+ && cofffile->saddr[sym->n_scnum - 1]) {
+ lookup[l].symName = symname;
+ lookup[l].offset = (funcptr)
+ (cofffile->saddr[sym->n_scnum - 1] +
+ sym->n_value - cofffile->txtaddr);
#ifdef COFFDEBUG
- COFFDEBUG("Adding %x %s\n",
- lookup[l].offset, lookup[l].symName );
+ COFFDEBUG("Adding %p %s\n",
+ (void *)lookup[l].offset, lookup[l].symName);
#endif
- l++;
- }
- else {
+ l++;
+ } else {
#ifdef COFFDEBUG
- COFFDEBUG( "TEXT Section not loaded %d\n",
- sym->n_scnum-1 );
+ COFFDEBUG("TEXT Section not loaded %d\n", sym->n_scnum - 1);
#endif
- xf86loaderfree(symname);
- }
- break;
- case N_DATA:
- /*
- * Note: COFF expects .data to be contiguous with
- * .data, so that offsets for .data are relative to
- * .text. We need to adjust for this, and make them
- * relative to .data so that the relocation can be
- * properly applied. This is needed becasue we allocate
- * .data seperately from .text.
- */
- if( (sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
- && cofffile->saddr[sym->n_scnum-1]) {
- lookup[l].symName=symname;
- lookup[l].offset=(funcptr)
- (cofffile->saddr[sym->n_scnum-1]+
- sym->n_value-cofffile->dataddr);
+ xf86loaderfree(symname);
+ }
+ break;
+ case N_DATA:
+ /*
+ * Note: COFF expects .data to be contiguous with
+ * .data, so that offsets for .data are relative to
+ * .text. We need to adjust for this, and make them
+ * relative to .data so that the relocation can be
+ * properly applied. This is needed becasue we allocate
+ * .data seperately from .text.
+ */
+ if ((sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
+ && cofffile->saddr[sym->n_scnum - 1]) {
+ lookup[l].symName = symname;
+ lookup[l].offset = (funcptr)
+ (cofffile->saddr[sym->n_scnum - 1] +
+ sym->n_value - cofffile->dataddr);
#ifdef COFFDEBUG
- COFFDEBUG("Adding %x %s\n",
- lookup[l].offset, lookup[l].symName );
+ COFFDEBUG("Adding %p %s\n",
+ (void *)lookup[l].offset, lookup[l].symName);
#endif
- l++;
- }
- else {
+ l++;
+ } else {
#ifdef COFFDEBUG
- COFFDEBUG( "DATA Section not loaded %d\n",
- sym->n_scnum-1 );
+ COFFDEBUG("DATA Section not loaded %d\n", sym->n_scnum - 1);
#endif
- xf86loaderfree(symname);
- }
- break;
- case N_BSS:
- /*
- * Note: COFF expects .bss to be contiguous with
- * .data, so that offsets for .bss are relative to
- * .text. We need to adjust for this, and make them
- * relative to .bss so that the relocation can be
- * properly applied. This is needed becasue we allocate
- * .bss seperately from .text and .data.
- */
- if( (sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
- && cofffile->saddr[sym->n_scnum-1]) {
- lookup[l].symName=symname;
- lookup[l].offset=(funcptr)
- (cofffile->saddr[sym->n_scnum-1]+
- sym->n_value-cofffile->bssaddr);
+ xf86loaderfree(symname);
+ }
+ break;
+ case N_BSS:
+ /*
+ * Note: COFF expects .bss to be contiguous with
+ * .data, so that offsets for .bss are relative to
+ * .text. We need to adjust for this, and make them
+ * relative to .bss so that the relocation can be
+ * properly applied. This is needed becasue we allocate
+ * .bss seperately from .text and .data.
+ */
+ if ((sym->n_sclass == C_EXT || sym->n_sclass == C_HIDEXT)
+ && cofffile->saddr[sym->n_scnum - 1]) {
+ lookup[l].symName = symname;
+ lookup[l].offset = (funcptr)
+ (cofffile->saddr[sym->n_scnum - 1] +
+ sym->n_value - cofffile->bssaddr);
#ifdef COFFDEBUG
- COFFDEBUG("Adding %x %s\n",
- lookup[l].offset, lookup[l].symName );
+ COFFDEBUG("Adding %p %s\n",
+ (void *)lookup[l].offset, lookup[l].symName);
#endif
- l++;
- }
- else {
+ l++;
+ } else {
#ifdef COFFDEBUG
- COFFDEBUG( "BSS Section not loaded %d\n",
- sym->n_scnum-1 );
+ COFFDEBUG("BSS Section not loaded %d\n", sym->n_scnum - 1);
#endif
- xf86loaderfree(symname);
- }
- break;
- default:
- ErrorF("Unknown Section number %d\n", sym->n_scnum );
- xf86loaderfree(symname);
- break;
- }
+ xf86loaderfree(symname);
+ }
+ break;
+ default:
+ ErrorF("Unknown Section number %d\n", sym->n_scnum);
+ xf86loaderfree(symname);
+ break;
}
+ }
- lookup[l].symName=NULL; /* Terminate the list */
+ lookup[l].symName = NULL; /* Terminate the list */
lookup_common = COFFCreateCOMMON(cofffile);
if (lookup_common) {
- for (i = 0, p = lookup_common; p->symName; i++, p++)
- ;
- memcpy(&(lookup[l]), lookup_common, i * sizeof (LOOKUP));
+ for (i = 0, p = lookup_common; p->symName; i++, p++) ;
+ memcpy(&(lookup[l]), lookup_common, i * sizeof(LOOKUP));
xf86loaderfree(lookup_common);
l += i;
@@ -1030,10 +1022,11 @@ COFFModulePtr cofffile;
*/
for (i = 0, p = lookup; p->symName; i++, p++) {
while (p->symName && (!strcmp(lookup[i].symName, ".text")
- || !strcmp(lookup[i].symName, ".data")
- || !strcmp(lookup[i].symName, ".bss")
+ || !strcmp(lookup[i].symName, ".data")
+ || !strcmp(lookup[i].symName, ".bss")
)) {
- memmove(&(lookup[i]), &(lookup[i+1]), (l-- - i) * sizeof (LOOKUP));
+ memmove(&(lookup[i]), &(lookup[i + 1]),
+ (l-- - i) * sizeof(LOOKUP));
}
}
@@ -1052,94 +1045,95 @@ COFFModulePtr cofffile;
* Do the work required to load each section into memory.
*/
static void
-COFFCollectSections(cofffile)
-COFFModulePtr cofffile;
+COFFCollectSections(COFFModulePtr cofffile)
{
- unsigned short i;
+ unsigned short i;
/*
* Find and identify all of the Sections
*/
#ifdef COFFDEBUG
- COFFDEBUG("COFFCollectSections(): %d sections\n", cofffile->numsh );
+ COFFDEBUG("COFFCollectSections(): %d sections\n", cofffile->numsh);
#endif
- for( i=0; i<cofffile->numsh; i++) {
+ for (i = 0; i < cofffile->numsh; i++) {
#ifdef COFFDEBUG
- COFFDEBUG("%d %s\n", i, cofffile->sections[i].s_name );
+ COFFDEBUG("%d %s\n", i, cofffile->sections[i].s_name);
#endif
/* .text */
- if( strcmp(cofffile->sections[i].s_name,
- ".text" ) == 0 ) {
- cofffile->text=_LoaderFileToMem(cofffile->fd,
- SecOffset(i),SecSize(i),".text");
- cofffile->saddr[i]=cofffile->text;
- cofffile->txtndx=i;
- cofffile->txtaddr=SecAddr(i);
- cofffile->txtsize=SecSize(i);
- cofffile->txtrelsize=RelSize(i);
- cofffile->reladdr[i]=_LoaderFileToMem(cofffile->fd,
- RelOffset(i), RelSize(i),".rel.text");
+ if (strcmp(cofffile->sections[i].s_name, ".text") == 0) {
+ cofffile->text = _LoaderFileToMem(cofffile->fd,
+ SecOffset(i), SecSize(i),
+ ".text");
+ cofffile->saddr[i] = cofffile->text;
+ cofffile->txtndx = i;
+ cofffile->txtaddr = SecAddr(i);
+ cofffile->txtsize = SecSize(i);
+ cofffile->txtrelsize = RelSize(i);
+ cofffile->reladdr[i] = _LoaderFileToMem(cofffile->fd,
+ RelOffset(i), RelSize(i),
+ ".rel.text");
#ifdef COFFDEBUG
- COFFDEBUG(".text starts at %x (%x bytes)\n", cofffile->text, cofffile->txtsize );
+ COFFDEBUG(".text starts at %p (%x bytes)\n", cofffile->text,
+ cofffile->txtsize);
#endif
continue;
}
/* .data */
- if( strcmp(cofffile->sections[i].s_name,
- ".data" ) == 0 ) {
- cofffile->data=_LoaderFileToMem(cofffile->fd,
- SecOffset(i),SecSize(i),".data");
- cofffile->saddr[i]=cofffile->data;
- cofffile->datndx=i;
- cofffile->dataddr=SecAddr(i);
- cofffile->datsize=SecSize(i);
- cofffile->datrelsize=RelSize(i);
- cofffile->reladdr[i]=_LoaderFileToMem(cofffile->fd,
- RelOffset(i), RelSize(i),".rel.data");
+ if (strcmp(cofffile->sections[i].s_name, ".data") == 0) {
+ cofffile->data = _LoaderFileToMem(cofffile->fd,
+ SecOffset(i), SecSize(i),
+ ".data");
+ cofffile->saddr[i] = cofffile->data;
+ cofffile->datndx = i;
+ cofffile->dataddr = SecAddr(i);
+ cofffile->datsize = SecSize(i);
+ cofffile->datrelsize = RelSize(i);
+ cofffile->reladdr[i] = _LoaderFileToMem(cofffile->fd,
+ RelOffset(i), RelSize(i),
+ ".rel.data");
#ifdef COFFDEBUG
- COFFDEBUG(".data starts at %x (%x bytes)\n", cofffile->data, cofffile->datsize );
+ COFFDEBUG(".data starts at %p (%x bytes)\n", cofffile->data,
+ cofffile->datsize);
#endif
continue;
}
/* .bss */
- if( strcmp(cofffile->sections[i].s_name,
- ".bss" ) == 0 ) {
- if( SecSize(i) )
- cofffile->bss=xf86loadercalloc(1,SecSize(i));
+ if (strcmp(cofffile->sections[i].s_name, ".bss") == 0) {
+ if (SecSize(i))
+ cofffile->bss = xf86loadercalloc(1, SecSize(i));
else
- cofffile->bss=NULL;
- cofffile->saddr[i]=cofffile->bss;
- cofffile->bssndx=i;
- cofffile->bssaddr=SecAddr(i);
- cofffile->bsssize=SecSize(i);
+ cofffile->bss = NULL;
+ cofffile->saddr[i] = cofffile->bss;
+ cofffile->bssndx = i;
+ cofffile->bssaddr = SecAddr(i);
+ cofffile->bsssize = SecSize(i);
#ifdef COFFDEBUG
- COFFDEBUG(".bss starts at %x (%x bytes)\n", cofffile->bss, cofffile->bsssize );
+ COFFDEBUG(".bss starts at %p (%x bytes)\n", cofffile->bss,
+ cofffile->bsssize);
#endif
continue;
}
/* .comment */
- if( strncmp(cofffile->sections[i].s_name,
- ".comment",strlen(".comment") ) == 0 ) {
+ if (strncmp(cofffile->sections[i].s_name,
+ ".comment", strlen(".comment")) == 0) {
continue;
}
/* .stab */
- if( strcmp(cofffile->sections[i].s_name,
- ".stab" ) == 0 ) {
+ if (strcmp(cofffile->sections[i].s_name, ".stab") == 0) {
continue;
}
/* .stabstr */
- if( strcmp(cofffile->sections[i].s_name,
- ".stabstr" ) == 0 ) {
+ if (strcmp(cofffile->sections[i].s_name, ".stabstr") == 0) {
continue;
}
/* .stab.* */
- if( strncmp(cofffile->sections[i].s_name,
- ".stab.", strlen(".stab.") ) == 0 ) {
+ if (strncmp(cofffile->sections[i].s_name,
+ ".stab.", strlen(".stab.")) == 0) {
continue;
}
- ErrorF("COFF: Not loading %s\n", cofffile->sections[i].s_name );
+ ErrorF("COFF: Not loading %s\n", cofffile->sections[i].s_name);
}
}
@@ -1147,52 +1141,54 @@ COFFModulePtr cofffile;
* Public API for the COFF implementation of the loader.
*/
void *
-COFFLoadModule(modrec, cofffd, ppLookup)
-loaderPtr modrec;
-int cofffd;
-LOOKUP **ppLookup;
+COFFLoadModule(loaderPtr modrec, int cofffd, LOOKUP **ppLookup)
{
- COFFModulePtr cofffile;
+ COFFModulePtr cofffile;
FILHDR *header;
- int stroffset; /* offset of string table */
+ int stroffset; /* offset of string table */
COFFRelocPtr coff_reloc, tail;
- void *v;
+ void *v;
#ifdef COFFDEBUG
- COFFDEBUG("COFFLoadModule(%s,%x,%x)\n",modrec->name,modrec->handle,cofffd);
+ COFFDEBUG("COFFLoadModule(%s,%x,%x)\n", modrec->name, modrec->handle,
+ cofffd);
#endif
- if ((cofffile = xf86loadercalloc(1,sizeof(COFFModuleRec))) == NULL) {
- ErrorF( "Unable to allocate COFFModuleRec\n" );
+ if ((cofffile = xf86loadercalloc(1, sizeof(COFFModuleRec))) == NULL) {
+ ErrorF("Unable to allocate COFFModuleRec\n");
return NULL;
}
- cofffile->handle=modrec->handle;
- cofffile->module=modrec->module;
- cofffile->fd=cofffd;
- v=cofffile->funcs=modrec->funcs;
+ cofffile->handle = modrec->handle;
+ cofffile->module = modrec->module;
+ cofffile->fd = cofffd;
+ v = cofffile->funcs = modrec->funcs;
/*
* Get the COFF header
*/
- cofffile->header=(FILHDR *)_LoaderFileToMem(cofffd,0,sizeof(FILHDR),"header");
- header=(FILHDR *)cofffile->header;
+ cofffile->header =
+ (FILHDR *) _LoaderFileToMem(cofffd, 0, sizeof(FILHDR), "header");
+ header = (FILHDR *) cofffile->header;
- if( header->f_symptr == 0 || header->f_nsyms == 0 ) {
+ if (header->f_symptr == 0 || header->f_nsyms == 0) {
ErrorF("No symbols found in module\n");
- _LoaderFreeFileMem(header,sizeof(FILHDR));
+ _LoaderFreeFileMem(header, sizeof(FILHDR));
xf86loaderfree(cofffile);
return NULL;
}
/*
* Get the section table
*/
- cofffile->numsh=header->f_nscns;
- cofffile->secsize=(header->f_nscns*SCNHSZ);
- cofffile->sections=(SCNHDR *)_LoaderFileToMem(cofffd,FILHSZ+header->f_opthdr,
- cofffile->secsize, "sections");
- cofffile->saddr=xf86loadercalloc(cofffile->numsh, sizeof(unsigned char *));
- cofffile->reladdr=xf86loadercalloc(cofffile->numsh, sizeof(unsigned char *));
+ cofffile->numsh = header->f_nscns;
+ cofffile->secsize = (header->f_nscns * SCNHSZ);
+ cofffile->sections =
+ (SCNHDR *) _LoaderFileToMem(cofffd, FILHSZ + header->f_opthdr,
+ cofffile->secsize, "sections");
+ cofffile->saddr =
+ xf86loadercalloc(cofffile->numsh, sizeof(unsigned char *));
+ cofffile->reladdr =
+ xf86loadercalloc(cofffile->numsh, sizeof(unsigned char *));
/*
* Load the optional header if we need it ?????
@@ -1206,13 +1202,14 @@ LOOKUP **ppLookup;
/*
* load the string table (must be done before we process symbols).
*/
- stroffset=header->f_symptr+(header->f_nsyms*SYMESZ);
+ stroffset = header->f_symptr + (header->f_nsyms * SYMESZ);
- _LoaderFileRead(cofffd,stroffset,&(cofffile->strsize),sizeof(int));
+ _LoaderFileRead(cofffd, stroffset, &(cofffile->strsize), sizeof(int));
- stroffset+=4; /* Move past the size */
- cofffile->strsize-=sizeof(int); /* size includes itself, so reduce by 4 */
- cofffile->strtab=_LoaderFileToMem(cofffd,stroffset,cofffile->strsize,"strings");
+ stroffset += 4; /* Move past the size */
+ cofffile->strsize -= sizeof(int); /* size includes itself, so reduce by 4 */
+ cofffile->strtab =
+ _LoaderFileToMem(cofffd, stroffset, cofffile->strsize, "strings");
/*
* add symbols
@@ -1224,8 +1221,7 @@ LOOKUP **ppLookup;
*/
coff_reloc = COFFCollectRelocations(cofffile);
if (coff_reloc) {
- for (tail = coff_reloc; tail->next; tail = tail->next)
- ;
+ for (tail = coff_reloc; tail->next; tail = tail->next) ;
tail->next = _LoaderGetRelocations(v)->coff_reloc;
_LoaderGetRelocations(v)->coff_reloc = coff_reloc;
}
@@ -1234,8 +1230,7 @@ LOOKUP **ppLookup;
}
void
-COFFResolveSymbols(mod)
-void *mod;
+COFFResolveSymbols(void *mod)
{
COFFRelocPtr newlist, p, tmp;
@@ -1243,7 +1238,7 @@ void *mod;
* which we failed to relocate. Destroy the old list in the process.
*/
newlist = 0;
- for (p = _LoaderGetRelocations(mod)->coff_reloc; p; ) {
+ for (p = _LoaderGetRelocations(mod)->coff_reloc; p;) {
tmp = COFF_RelocateEntry(p->file, p->secndx, p->rel);
if (tmp) {
/* Failed to relocate. Keep it in the list. */
@@ -1258,53 +1253,51 @@ void *mod;
}
int
-COFFCheckForUnresolved( mod)
-void *mod;
+COFFCheckForUnresolved(void *mod)
{
- char *name;
+ char *name;
COFFRelocPtr crel;
int flag, fatalsym = 0;
if ((crel = _LoaderGetRelocations(mod)->coff_reloc) == NULL)
return 0;
- while( crel )
- {
+ while (crel) {
name = COFFGetSymbolName(crel->file, crel->rel->r_symndx);
- flag = _LoaderHandleUnresolved(name,
- _LoaderHandleToName(crel->file->handle));
- if (flag) fatalsym = 1;
+ flag = _LoaderHandleUnresolved(name,
+ _LoaderHandleToName(crel->file->
+ handle));
+ if (flag)
+ fatalsym = 1;
xf86loaderfree(name);
- crel=crel->next;
- }
+ crel = crel->next;
+ }
return fatalsym;
}
void
-COFFUnloadModule(modptr)
-void *modptr;
+COFFUnloadModule(void *modptr)
{
- COFFModulePtr cofffile = (COFFModulePtr)modptr;
- COFFRelocPtr relptr, reltptr, *brelptr;
+ COFFModulePtr cofffile = (COFFModulePtr) modptr;
+ COFFRelocPtr relptr, reltptr, *brelptr;
/*
* Delete any unresolved relocations
*/
- relptr=_LoaderGetRelocations(cofffile->funcs)->coff_reloc;
- brelptr=&(_LoaderGetRelocations(cofffile->funcs)->coff_reloc);
-
- while(relptr) {
- if( relptr->file == cofffile ) {
- *brelptr=relptr->next; /* take it out of the list */
- reltptr=relptr; /* save pointer to this node */
- relptr=relptr->next; /* advance the pointer */
- xf86loaderfree(reltptr); /* free the node */
+ relptr = _LoaderGetRelocations(cofffile->funcs)->coff_reloc;
+ brelptr = &(_LoaderGetRelocations(cofffile->funcs)->coff_reloc);
+
+ while (relptr) {
+ if (relptr->file == cofffile) {
+ *brelptr = relptr->next; /* take it out of the list */
+ reltptr = relptr; /* save pointer to this node */
+ relptr = relptr->next; /* advance the pointer */
+ xf86loaderfree(reltptr); /* free the node */
+ } else {
+ brelptr = &(relptr->next);
+ relptr = relptr->next; /* advance the pointer */
}
- else {
- brelptr=&(relptr->next);
- relptr=relptr->next; /* advance the pointer */
- }
}
/*
@@ -1318,22 +1311,22 @@ void *modptr;
*/
#define CheckandFree(ptr,size) if(ptr) _LoaderFreeFileMem((ptr),(size))
- CheckandFree(cofffile->strtab,cofffile->strsize);
- CheckandFree(cofffile->symtab,cofffile->symsize);
- CheckandFree(cofffile->text,cofffile->txtsize);
- CheckandFree(cofffile->reladdr[cofffile->txtndx],cofffile->txtrelsize);
- CheckandFree(cofffile->data,cofffile->datsize);
- CheckandFree(cofffile->reladdr[cofffile->datndx],cofffile->datrelsize);
- CheckandFree(cofffile->bss,cofffile->bsssize);
- if( cofffile->common )
+ CheckandFree(cofffile->strtab, cofffile->strsize);
+ CheckandFree(cofffile->symtab, cofffile->symsize);
+ CheckandFree(cofffile->text, cofffile->txtsize);
+ CheckandFree(cofffile->reladdr[cofffile->txtndx], cofffile->txtrelsize);
+ CheckandFree(cofffile->data, cofffile->datsize);
+ CheckandFree(cofffile->reladdr[cofffile->datndx], cofffile->datrelsize);
+ CheckandFree(cofffile->bss, cofffile->bsssize);
+ if (cofffile->common)
xf86loaderfree(cofffile->common);
/*
* Free the section table, and section pointer array
*/
- _LoaderFreeFileMem(cofffile->sections,cofffile->secsize);
+ _LoaderFreeFileMem(cofffile->sections, cofffile->secsize);
xf86loaderfree(cofffile->saddr);
xf86loaderfree(cofffile->reladdr);
- _LoaderFreeFileMem(cofffile->header,sizeof(FILHDR));
+ _LoaderFreeFileMem(cofffile->header, sizeof(FILHDR));
/*
* Free the COFFModuleRec
*/
@@ -1345,14 +1338,14 @@ void *modptr;
char *
COFFAddressToSection(void *modptr, unsigned long address)
{
- COFFModulePtr cofffile = (COFFModulePtr)modptr;
+ COFFModulePtr cofffile = (COFFModulePtr) modptr;
int i;
- for( i=1; i<cofffile->numsh; i++) {
- if( address >= (unsigned long)cofffile->saddr[i] &&
- address <= (unsigned long)cofffile->saddr[i]+SecSize(i) ) {
- return cofffile->sections[i].s_name;
- }
- }
-return NULL;
+ for (i = 1; i < cofffile->numsh; i++) {
+ if (address >= (unsigned long)cofffile->saddr[i] &&
+ address <= (unsigned long)cofffile->saddr[i] + SecSize(i)) {
+ return cofffile->sections[i].s_name;
+ }
+ }
+ return NULL;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-21 20:53:54 +0000