diff options
Diffstat (limited to 'hw/xfree86/loader/coffloader.c')
| -rw-r--r-- | hw/xfree86/loader/coffloader.c | 1358 |
1 files changed, 1358 insertions, 0 deletions
diff --git a/hw/xfree86/loader/coffloader.c b/hw/xfree86/loader/coffloader.c new file mode 100644 index 000000000..7a1ef28ad --- /dev/null +++ b/hw/xfree86/loader/coffloader.c @@ -0,0 +1,1358 @@ +/* $XFree86: xc/programs/Xserver/hw/xfree86/loader/coffloader.c,v 1.18 2002/09/16 18:06:10 eich Exp $ */ + +/* + * + * Copyright 1995,96 by Metro Link, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Metro Link, Inc. not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Metro Link, Inc. makes no + * representations about the suitability of this software for any purpose. + * It is provided "as is" without express or implied warranty. + * + * METRO LINK, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL METRO LINK, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ +#include <sys/types.h> +#include <unistd.h> +#include <stdlib.h> +#ifdef __QNX__ +#include <fcntl.h> +#else +#include <sys/fcntl.h> +#endif +#include <sys/stat.h> + +#ifdef DBMALLOC +#include <debug/malloc.h> +#define Xalloc(size) malloc(size) +#define Xcalloc(size) calloc(1,(size)) +#define Xfree(size) free(size) +#endif + +#include "Xos.h" +#include "os.h" +#include "coff.h" + +#include "sym.h" +#include "loader.h" +#include "coffloader.h" + +#include "compiler.h" +/* +#ifndef LDTEST +#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; + +/* + * 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; +} COFFRelocRec; + +/* + * Symbols with a section number of 0 (N_UNDEF) but a value of non-zero + * need to have space allocated for them. + * + * Gather all of these symbols together, and allocate one chunk when we + * are done. + */ + +typedef struct _coff_COMMON { + SYMENT *sym; + int index; + struct _coff_COMMON *next; + } COFFCommonRec; + +static COFFCommonPtr listCOMMON = NULL; + +/* Prototypes for static functions */ +static int COFFhashCleanOut(void *, itemPtr); +static char *COFFGetSymbolName(COFFModulePtr, int); +static COFFCommonPtr COFFAddCOMMON(SYMENT *, int); +static LOOKUP *COFFCreateCOMMON(COFFModulePtr); +static COFFRelocPtr COFFDelayRelocation(COFFModulePtr, int, RELOC *); +static SYMENT *COFFGetSymbol(COFFModulePtr, int); +static unsigned char *COFFGetSymbolValue(COFFModulePtr, int); +static COFFRelocPtr COFF_RelocateEntry(COFFModulePtr, int, RELOC *); +static LOOKUP *COFF_GetSymbols(COFFModulePtr); +static void COFFCollectSections(COFFModulePtr); +static COFFRelocPtr COFFCollectRelocations(COFFModulePtr); + +/* + * Utility Functions + */ + + +static int +COFFhashCleanOut(voidptr, item) +void *voidptr; +itemPtr item ; +{ + COFFModulePtr module = (COFFModulePtr) voidptr; + return ( module->handle == item->handle ) ; +} + + +/* + * Manage listResolv + */ +static COFFRelocPtr +COFFDelayRelocation(cofffile,secndx,rel) +COFFModulePtr cofffile; +int secndx; +RELOC *rel; +{ + COFFRelocPtr reloc; + + if ((reloc = xf86loadermalloc(sizeof(COFFRelocRec))) == NULL) { + ErrorF( "COFFDelayRelocation() Unable to allocate memory!!!!\n" ); + return 0; + } + + reloc->file=cofffile; + reloc->secndx=secndx; + reloc->rel=rel; + reloc->next = 0; + + return reloc; +} + +/* + * Manage listCOMMON + */ + +static COFFCommonPtr +COFFAddCOMMON(sym,index) +SYMENT *sym; +int index; +{ + COFFCommonPtr common; + + if ((common = xf86loadermalloc(sizeof(COFFCommonRec))) == NULL) { + ErrorF( "COFFAddCOMMON() Unable to allocate memory!!!!\n" ); + return 0; + } + common->sym=sym; + common->index=index; + common->next=0; + + return common; +} + +static LOOKUP * +COFFCreateCOMMON(cofffile) +COFFModulePtr cofffile; +{ + int numsyms=0,size=0,l=0; + int offset=0; + LOOKUP *lookup; + COFFCommonPtr common; + + if (listCOMMON == NULL) + return NULL; + + 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); + + /* accumulate the sizes */ + size+=common->sym->n_value; + numsyms++; + } + +#ifdef COFFDEBUG + COFFDEBUG("COFFCreateCOMMON() %d entries (%d bytes) of COMMON data\n", + numsyms, size ); +#endif + + 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; + } + + /* 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); +#ifdef COFFDEBUG + COFFDEBUG("Adding %x %s\n", lookup[l].offset, lookup[l].symName ); +#endif + listCOMMON=common->next; + offset+=common->sym->n_value; + xf86loaderfree(common); + l++; + } + /* listCOMMON == NULL */ + + lookup[l].symName=NULL; /* Terminate the list */ + return lookup; +} + +/* + * Symbol Table + */ + +/* + * Get symbol name + */ +static char * +COFFGetSymbolName(cofffile, index) +COFFModulePtr cofffile; +int index; +{ + char *name; + SYMENT *sym; + + sym=(SYMENT *)(((unsigned char *)cofffile->symtab)+(index*SYMESZ)); + +#ifdef COFFDEBUG + COFFDEBUG("COFFGetSymbolName(%x,%x) %x",cofffile, index, sym->n_zeroes ); +#endif + + name = xf86loadermalloc(sym->n_zeroes ? SYMNMLEN + 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]); + } +#ifdef COFFDEBUG + COFFDEBUG(" %s\n", name ); +#endif + return name; +} + +static SYMENT * +COFFGetSymbol(file, index) +COFFModulePtr file; +int index; +{ + return (SYMENT *)(((unsigned char *)file->symtab)+(index*SYMESZ)); +} + +static unsigned char * +COFFGetSymbolValue(cofffile, index) +COFFModulePtr cofffile; +int index; +{ + unsigned char *symval=0; /* value of the indicated symbol */ + itemPtr symbol; /* name/value of symbol */ + char *symname; + + symname=COFFGetSymbolName(cofffile, index); + +#ifdef COFFDEBUG + COFFDEBUG("COFFGetSymbolValue() for %s=", symname ); +#endif + + symbol = LoaderHashFind(symname); + + if( symbol ) + symval=(unsigned char *)symbol->address; + +#ifdef COFFDEBUG + COFFDEBUG("%x\n", symval ); +#endif + + xf86loaderfree(symname); + return symval; +} + +#if defined(__powerpc__) +/* + * This function returns the address of the glink routine for a symbol. This + * address is used in cases where the function being called is not in the + * same module as the calling function. + */ +static unsigned char * +COFFGetSymbolGlinkValue(cofffile, index) +COFFModulePtr cofffile; +int index; +{ + unsigned char *symval=0; /* value of the indicated symbol */ + itemPtr symbol; /* name/value of symbol */ + char *name; + + name=COFFGetSymbolName(cofffile, index); + +#ifdef COFFDEBUG + COFFDEBUG("COFFGetSymbolGlinkValue() for %s=", name ); +#endif + + 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. + * The following code is being used to implement this. + + 1 00000000 3d80xxxx lis r12,hi16(funcdesc) + 2 00000004 618cxxxx ori r12,r12,lo16(funcdesc) + 3 00000008 90410014 st r2,20(r1) # save old TOC pointer + 4 0000000c 804c0000 l r2,0(r12) # Get address of functions + 5 00000010 7c4903a6 mtctr r2 # load destination address + 6 00000014 804c0004 l r2,4(r12) # get TOC of function + 7 00000018 4e800420 bctr # branch to it + + */ + 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; + ppc_flush_icache(&symbol->code.glink[0]); + ppc_flush_icache(&symbol->code.glink[12]); + } + + xf86loaderfree(name); + return symval; +} +#endif /* __powerpc__ */ + +/* + * 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; +{ + 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; +#endif + unsigned char *symval; /* value of the indicated symbol */ + +/* + * Note: Section numbers are 1 biased, while the cofffile->saddr[] array + * of pointer is 0 biased, so alway have to account for the difference. + */ + +/* + * Reminder: secndx is the section to which the relocation is applied. + * symbol->n_scnum is the section in which the symbol value resides. + */ + +#ifdef COFFDEBUG + COFFDEBUG("%x %d %o ", + 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)); +#endif +#endif + symbol=COFFGetSymbol(cofffile,rel->r_symndx); +#ifdef COFFDEBUG + COFFDEBUG("%d %x %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 */ + 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"); + } + 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"); + } + 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"); + } + dest32=(unsigned long *)((long)(cofffile->saddr[secndx])+ + ((unsigned char *)rel->r_vaddr-cofffile->bssaddr)); + break; + default: + FatalError("Relocation against unknown section %d\n", secndx ); + } + + 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 ); +#endif + *dest32=(unsigned long)symval; + return 0; + } + + switch( rel->r_type ) + { +#if defined(i386) + 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: +#ifdef COFFDEBUG + COFFDEBUG( "R_DIR32 N_UNDEF\n" ); +#endif + return COFFDelayRelocation(cofffile,secndx,rel); + case N_ABS: +#ifdef COFFDEBUG + COFFDEBUG( "R_DIR32 N_ABS\n" ); +#endif + return 0; + case N_DEBUG: +#ifdef COFFDEBUG + COFFDEBUG( "R_DIR32 N_DEBUG\n" ); +#endif + return 0; + case N_COMMENT: +#ifdef COFFDEBUG + COFFDEBUG( "R_DIR32 N_COMMENT\n" ); +#endif + 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: +#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: +#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 ); + } + + } +#ifdef COFFDEBUG + COFFDEBUG( "*dest32=%8.8x\n", *dest32 ); +#endif + break; + case R_PCRLONG: + if( symbol->n_scnum == N_TEXT ) + break; + + 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 ); +#endif + if( symval == 0 ) { +#ifdef COFFDEBUG + 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))); + +#ifdef COFFDEBUG + COFFDEBUG( "*dest32=%8.8x\n", *dest32 ); +#endif + 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 ) { +#ifdef COFFDEBUG + 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: +#ifdef COFFDEBUG + COFFDEBUG( "R_POS N_UNDEF\n" ); +#endif + return COFFDelayRelocation(cofffile,secndx,rel); + case N_ABS: +#ifdef COFFDEBUG + COFFDEBUG( "R_POS N_ABS\n" ); +#endif + return 0; + case N_DEBUG: +#ifdef COFFDEBUG + COFFDEBUG( "R_POS N_DEBUG\n" ); +#endif + return 0; + case N_COMMENT: +#ifdef COFFDEBUG + COFFDEBUG( "R_POS N_COMMENT\n" ); +#endif + 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: +#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: +#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 ); + } + } +#ifdef COFFDEBUG + 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" ); +#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)); + ppc_flush_icache(dest16); + } +#ifdef COFFDEBUG + 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); + symitem = LoaderHashFind(name); + if( symitem == 0 ) { + name++; + symitem = LoaderHashFind(name); + } + if( symitem && cofffile->module != symitem->module ) { +#ifdef COFFDEBUG + 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 ) { +#ifdef COFFDEBUG + char *name; + COFFDEBUG( "***Unable to resolve symbol %s\n", + name=COFFGetSymbolName(cofffile,rel->r_symndx) ); + xf86loaderfree(name); +#endif + 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); +#ifdef COFFDEBUG + 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; +#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); +#ifdef COFFDEBUG + COFFDEBUG( "*dest32=%8.8x\n", *dest32 ); +#endif + if( cofffile->module != symitem->module ) { + (*++dest32)=0x80410014; /* lwz r2,20(r1) */ + } + ppc_flush_icache(--dest32); + } + + break; +#endif /* __powerpc__ */ + default: + ErrorF( + "COFF_RelocateEntry() Unsupported relocation type %o\n", + rel->r_type ); + break; + } + return 0; +} + +static COFFRelocPtr +COFFCollectRelocations(cofffile) +COFFModulePtr cofffile; +{ + 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); + tmp->next = reloc_head; + reloc_head = tmp; + } + } + + return reloc_head; +} + +/* + * COFF_GetSymbols() + * + * add the symbols to the symbol table maintained by the loader. + */ + +static LOOKUP * +COFF_GetSymbols(cofffile) +COFFModulePtr cofffile; +{ + 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; + +#ifdef COFFDEBUG + 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"); + + 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; +#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)); +#ifdef COFFDEBUG + COFFDEBUG("TOC=%x\n", cofffile->toc ); + COFFDEBUG("TOCaddr=%x\n", cofffile->tocaddr ); +#endif + 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 ); +#endif + 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); + } + 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); +#ifdef COFFDEBUG + COFFDEBUG("Adding %x %s\n", + lookup[l].offset, lookup[l].symName ); +#endif + l++; + } + else { +#ifdef COFFDEBUG + 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); +#ifdef COFFDEBUG + COFFDEBUG("Adding %x %s\n", + lookup[l].offset, lookup[l].symName ); +#endif + l++; + } + else { +#ifdef COFFDEBUG + 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); +#ifdef COFFDEBUG + COFFDEBUG("Adding %x %s\n", + lookup[l].offset, lookup[l].symName ); +#endif + l++; + } + else { +#ifdef COFFDEBUG + 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; + } + } + + 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)); + + xf86loaderfree(lookup_common); + l += i; + lookup[l].symName = NULL; + } + +/* + * remove the COFF symbols that will show up in every module + */ + 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") + )) { + memmove(&(lookup[i]), &(lookup[i+1]), (l-- - i) * sizeof (LOOKUP)); + } + } + + return lookup; +} + +#define SecOffset(index) cofffile->sections[index].s_scnptr +#define SecSize(index) cofffile->sections[index].s_size +#define SecAddr(index) cofffile->sections[index].s_paddr +#define RelOffset(index) cofffile->sections[index].s_relptr +#define RelSize(index) (cofffile->sections[index].s_nreloc*RELSZ) + +/* + * COFFCollectSections + * + * Do the work required to load each section into memory. + */ +static void +COFFCollectSections(cofffile) +COFFModulePtr cofffile; +{ + unsigned short i; + +/* + * Find and identify all of the Sections + */ + +#ifdef COFFDEBUG + COFFDEBUG("COFFCollectSections(): %d sections\n", cofffile->numsh ); +#endif + + for( i=0; i<cofffile->numsh; i++) { +#ifdef COFFDEBUG + 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"); +#ifdef COFFDEBUG + COFFDEBUG(".text starts at %x (%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"); +#ifdef COFFDEBUG + COFFDEBUG(".data starts at %x (%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)); + else + 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 ); +#endif + continue; + } + /* .comment */ + if( strncmp(cofffile->sections[i].s_name, + ".comment",strlen(".comment") ) == 0 ) { + continue; + } + /* .stab */ + if( strcmp(cofffile->sections[i].s_name, + ".stab" ) == 0 ) { + continue; + } + /* .stabstr */ + if( strcmp(cofffile->sections[i].s_name, + ".stabstr" ) == 0 ) { + continue; + } + /* .stab.* */ + if( strncmp(cofffile->sections[i].s_name, + ".stab.", strlen(".stab.") ) == 0 ) { + continue; + } + ErrorF("COFF: Not loading %s\n", cofffile->sections[i].s_name ); + } +} + +/* + * Public API for the COFF implementation of the loader. + */ +void * +COFFLoadModule(modrec, cofffd, ppLookup) +loaderPtr modrec; +int cofffd; +LOOKUP **ppLookup; +{ + COFFModulePtr cofffile; + FILHDR *header; + int stroffset; /* offset of string table */ + COFFRelocPtr coff_reloc, tail; + void *v; + +#ifdef COFFDEBUG + 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" ); + return NULL; + } + + 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; + + if( header->f_symptr == 0 || header->f_nsyms == 0 ) { + ErrorF("No symbols found in module\n"); + _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 *)); + +/* + * Load the optional header if we need it ????? + */ + +/* + * Load the rest of the desired sections + */ + COFFCollectSections(cofffile); + +/* + * load the string table (must be done before we process symbols). + */ + stroffset=header->f_symptr+(header->f_nsyms*SYMESZ); + + _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"); + +/* + * add symbols + */ + *ppLookup = COFF_GetSymbols(cofffile); + +/* + * Do relocations + */ + coff_reloc = COFFCollectRelocations(cofffile); + if (coff_reloc) { + for (tail = coff_reloc; tail->next; tail = tail->next) + ; + tail->next = _LoaderGetRelocations(v)->coff_reloc; + _LoaderGetRelocations(v)->coff_reloc = coff_reloc; + } + + return (void *)cofffile; +} + +void +COFFResolveSymbols(mod) +void *mod; +{ + COFFRelocPtr newlist, p, tmp; + + /* Try to relocate everything. Build a new list containing entries + * which we failed to relocate. Destroy the old list in the process. + */ + newlist = 0; + 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. */ + tmp->next = newlist; + newlist = tmp; + } + tmp = p; + p = p->next; + xf86loaderfree(tmp); + } + _LoaderGetRelocations(mod)->coff_reloc = newlist; +} + +int +COFFCheckForUnresolved( mod) +void *mod; +{ + char *name; + COFFRelocPtr crel; + int flag, fatalsym = 0; + + if ((crel = _LoaderGetRelocations(mod)->coff_reloc) == NULL) + return 0; + + while( crel ) + { + name = COFFGetSymbolName(crel->file, crel->rel->r_symndx); + flag = _LoaderHandleUnresolved(name, + _LoaderHandleToName(crel->file->handle)); + if (flag) fatalsym = 1; + xf86loaderfree(name); + crel=crel->next; + } + return fatalsym; +} + +void +COFFUnloadModule(modptr) +void *modptr; +{ + 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 */ + } + else { + brelptr=&(relptr->next); + relptr=relptr->next; /* advance the pointer */ + } + } + +/* + * Delete any symbols in the symbols table. + */ + + LoaderHashTraverse((void *)cofffile, COFFhashCleanOut); + +/* + * Free the sections that were allocated. + */ +#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 ) + xf86loaderfree(cofffile->common); +/* + * Free the section table, and section pointer array + */ + _LoaderFreeFileMem(cofffile->sections,cofffile->secsize); + xf86loaderfree(cofffile->saddr); + xf86loaderfree(cofffile->reladdr); + _LoaderFreeFileMem(cofffile->header,sizeof(FILHDR)); +/* + * Free the COFFModuleRec + */ + xf86loaderfree(cofffile); + + return; +} + +char * +COFFAddressToSection(void *modptr, unsigned long address) +{ + 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; +} |