| diff -urN modutils-2.4.27.0.orig/depmod/depmod.c modutils-2.4.27.0/depmod/depmod.c |
| --- modutils-2.4.27.0.orig/depmod/depmod.c 2005-09-29 18:14:05.000000000 -0600 |
| +++ modutils-2.4.27.0/depmod/depmod.c 2005-09-29 18:12:36.000000000 -0600 |
| @@ -274,7 +274,6 @@ |
| |
| extern int quick; /* Option -A */ |
| |
| - |
| /* |
| * Create a symbol definition. |
| * Add defined symbol to the head of the list of defined symbols. |
| @@ -556,6 +555,13 @@ |
| if (!in_range(f, m_size, ref_pci, sizeof(pci_device_size))) |
| return; |
| memcpy(&pci_device_size, (char *)image + ref_pci - f->baseaddr, sizeof(pci_device_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + pci_device_size = bswap_32(pci_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + pci_device_size = bswap_64(pci_device_size); |
| + } |
| + } |
| } |
| else |
| pci_device_size = sizeof(pci_device); |
| @@ -573,6 +579,14 @@ |
| memset(&pci_device, 0, sizeof(pci_device)); |
| memcpy(&pci_device, (char *)image + ref_pci - f->baseaddr, pci_device_size); |
| ref_pci += pci_device_size; |
| + if (byteswap==1) { |
| + pci_device.vendor = bswap_32(pci_device.vendor); |
| + pci_device.device = bswap_32(pci_device.device); |
| + pci_device.subvendor = bswap_32(pci_device.subvendor); |
| + pci_device.subdevice = bswap_32(pci_device.subdevice); |
| + pci_device.class = bswap_32(pci_device.class); |
| + pci_device.class_mask = bswap_32(pci_device.class_mask); |
| + } |
| if (!pci_device.vendor) |
| break; |
| mod->pci_device = xrealloc(mod->pci_device, ++(mod->n_pci_device)*sizeof(*(mod->pci_device))); |
| @@ -594,6 +608,13 @@ |
| if (!in_range(f, m_size, ref_isapnp, sizeof(isapnp_device_size))) |
| return; |
| memcpy(&isapnp_device_size, (char *)image + ref_isapnp - f->baseaddr, sizeof(isapnp_device_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + isapnp_device_size = bswap_32(isapnp_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + isapnp_device_size = bswap_64(isapnp_device_size); |
| + } |
| + } |
| ref_ref_isapnp = obj_symbol_final_value(f, obj_find_symbol(f, "__module_isapnp_device_table")); |
| if (!in_range(f, m_size, ref_ref_isapnp, sizeof(ref_isapnp))) |
| return; |
| @@ -608,6 +629,12 @@ |
| memset(&isapnp_device, 0, sizeof(isapnp_device)); |
| memcpy(&isapnp_device, (char *)image + ref_isapnp - f->baseaddr, isapnp_device_size); |
| ref_isapnp += isapnp_device_size; |
| + if (byteswap==1) { |
| + isapnp_device.card_vendor = bswap_16(isapnp_device.card_vendor); |
| + isapnp_device.card_device = bswap_16(isapnp_device.card_device); |
| + isapnp_device.vendor = bswap_16(isapnp_device.vendor); |
| + isapnp_device.function = bswap_16(isapnp_device.function); |
| + } |
| if (!isapnp_device.card_vendor) |
| break; |
| mod->isapnp_device = xrealloc(mod->isapnp_device, ++(mod->n_isapnp_device)*sizeof(*(mod->isapnp_device))); |
| @@ -629,6 +656,13 @@ |
| if (!in_range(f, m_size, ref_isapnp, sizeof(isapnp_card_size))) |
| return; |
| memcpy(&isapnp_card_size, (char *)image + ref_isapnp - f->baseaddr, sizeof(isapnp_card_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + isapnp_card_size = bswap_32(isapnp_card_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + isapnp_card_size = bswap_64(isapnp_card_size); |
| + } |
| + } |
| ref_ref_isapnp = obj_symbol_final_value(f, obj_find_symbol(f, "__module_isapnp_card_table")); |
| if (!in_range(f, m_size, ref_ref_isapnp, sizeof(ref_isapnp))) |
| return; |
| @@ -642,6 +676,11 @@ |
| memset(&isapnp_card, 0, sizeof(isapnp_card)); |
| memcpy(&isapnp_card, (char *)image + ref_isapnp - f->baseaddr, isapnp_card_size); |
| ref_isapnp += isapnp_card_size; |
| + if (byteswap==1) { |
| + isapnp_card.card_vendor = bswap_16(isapnp_card.card_vendor); |
| + isapnp_card.card_device = bswap_16(isapnp_card.card_device); |
| + // Fixme -- iterate over all devs fixing up vendor and function |
| + } |
| if (!isapnp_card.card_vendor) |
| break; |
| mod->isapnp_card = xrealloc(mod->isapnp_card, ++(mod->n_isapnp_card)*sizeof(*(mod->isapnp_card))); |
| @@ -659,11 +698,25 @@ |
| struct usb_device_id usb_device, *latest; |
| ElfW(Addr) ref_usb, ref_ref_usb; |
| unsigned tgt_long usb_device_size; |
| - ref_usb = obj_symbol_final_value(f, obj_find_symbol(f, "__module_usb_device_size")); |
| + struct obj_symbol *sym; |
| + sym = obj_find_symbol(f, "__module_usb_device_size"); |
| + if (!sym) |
| + return; |
| + ref_usb = obj_symbol_final_value(f, sym); |
| if (!in_range(f, m_size, ref_usb, sizeof(usb_device_size))) |
| return; |
| memcpy(&usb_device_size, (char *)image + ref_usb - f->baseaddr, sizeof(usb_device_size)); |
| - ref_ref_usb = obj_symbol_final_value(f, obj_find_symbol(f, "__module_usb_device_table")); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + usb_device_size = bswap_32(usb_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + usb_device_size = bswap_64(usb_device_size); |
| + } |
| + } |
| + sym = obj_find_symbol(f, "__module_usb_device_table"); |
| + if (!sym) |
| + return; |
| + ref_ref_usb = obj_symbol_final_value(f, sym); |
| if (!in_range(f, m_size, ref_ref_usb, sizeof(ref_usb))) |
| return; |
| memcpy(&ref_usb, (char *)image + ref_ref_usb - f->baseaddr, sizeof(ref_usb)); |
| @@ -677,6 +730,13 @@ |
| memset(&usb_device, 0, sizeof(usb_device)); |
| memcpy(&usb_device, (char *)image + ref_usb - f->baseaddr, usb_device_size); |
| ref_usb += usb_device_size; |
| + if (byteswap==1) { |
| + usb_device.match_flags = bswap_16(usb_device.match_flags); |
| + usb_device.idVendor = bswap_16(usb_device.idVendor); |
| + usb_device.idProduct = bswap_16(usb_device.idProduct); |
| + usb_device.bcdDevice_lo = bswap_16(usb_device.bcdDevice_lo); |
| + usb_device.bcdDevice_hi = bswap_16(usb_device.bcdDevice_hi); |
| + } |
| if (!usb_device.idVendor && !usb_device.bDeviceClass && |
| !usb_device.bInterfaceClass && !usb_device.driver_info) |
| break; |
| @@ -699,6 +759,13 @@ |
| if (!in_range(f, m_size, ref_parport, sizeof(parport_device_size))) |
| return; |
| memcpy(&parport_device_size, (char *)image + ref_parport - f->baseaddr, sizeof(parport_device_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + parport_device_size = bswap_32(parport_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + parport_device_size = bswap_64(parport_device_size); |
| + } |
| + } |
| ref_ref_parport = obj_symbol_final_value(f, obj_find_symbol(f, "__module_parport_device_table")); |
| if (!in_range(f, m_size, ref_ref_parport, sizeof(ref_parport))) |
| return; |
| @@ -713,6 +780,14 @@ |
| memset(&parport_device, 0, sizeof(parport_device)); |
| memcpy(&parport_device, (char *)image + ref_parport - f->baseaddr, parport_device_size); |
| ref_parport += parport_device_size; |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + parport_device.pattern = bswap_32(parport_device.pattern); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + parport_device.pattern = bswap_64(parport_device.pattern); |
| +#endif |
| + } |
| if (!parport_device.pattern) |
| break; |
| mod->parport_device = xrealloc(mod->parport_device, ++(mod->n_parport_device)*sizeof(*(mod->parport_device))); |
| @@ -737,6 +812,13 @@ |
| if (!in_range(f, m_size, ref_pnpbios, sizeof(pnpbios_device_size))) |
| return; |
| memcpy(&pnpbios_device_size, (char *)image + ref_pnpbios - f->baseaddr, sizeof(pnpbios_device_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + pnpbios_device_size = bswap_32(pnpbios_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + pnpbios_device_size = bswap_64(pnpbios_device_size); |
| + } |
| + } |
| ref_ref_pnpbios = obj_symbol_final_value(f, obj_find_symbol(f, "__module_pnpbios_device_table")); |
| if (!in_range(f, m_size, ref_ref_pnpbios, sizeof(ref_pnpbios))) |
| return; |
| @@ -751,6 +833,9 @@ |
| memset(&pnpbios_device, 0, sizeof(pnpbios_device)); |
| memcpy(&pnpbios_device, (char *)image + ref_pnpbios - f->baseaddr, pnpbios_device_size); |
| ref_pnpbios += pnpbios_device_size; |
| + //if (byteswap==1) { |
| + // looks like there is nothing to do here... |
| + //} |
| if (!pnpbios_device.id[0]) |
| break; |
| mod->pnpbios_device = xrealloc(mod->pnpbios_device, ++(mod->n_pnpbios_device)*sizeof(*(mod->pnpbios_device))); |
| @@ -772,6 +857,13 @@ |
| if (!in_range(f, m_size, ref_ieee1394, sizeof(ieee1394_device_size))) |
| return; |
| memcpy(&ieee1394_device_size, (char *)image + ref_ieee1394 - f->baseaddr, sizeof(ieee1394_device_size)); |
| + if (byteswap==1) { |
| + if (sizeof(unsigned tgt_long) == 4) { |
| + ieee1394_device_size = bswap_32(ieee1394_device_size); |
| + } else if (sizeof(unsigned tgt_long) == 8) { |
| + ieee1394_device_size = bswap_64(ieee1394_device_size); |
| + } |
| + } |
| ref_ref_ieee1394 = obj_symbol_final_value(f, obj_find_symbol(f, "__module_ieee1394_device_table")); |
| if (!in_range(f, m_size, ref_ref_ieee1394, sizeof(ref_ieee1394))) |
| return; |
| @@ -786,6 +878,13 @@ |
| memset(&ieee1394_device, 0, sizeof(ieee1394_device)); |
| memcpy(&ieee1394_device, (char *)image + ref_ieee1394 - f->baseaddr, ieee1394_device_size); |
| ref_ieee1394 += ieee1394_device_size; |
| + if (byteswap==1) { |
| + ieee1394_device.match_flags = bswap_32(ieee1394_device.match_flags); |
| + ieee1394_device.vendor_id = bswap_32(ieee1394_device.vendor_id); |
| + ieee1394_device.model_id = bswap_32(ieee1394_device.model_id); |
| + ieee1394_device.specifier_id = bswap_32(ieee1394_device.specifier_id); |
| + ieee1394_device.version = bswap_32(ieee1394_device.version); |
| + } |
| if (ieee1394_device.match_flags == 0) |
| break; |
| mod->ieee1394_device = xrealloc(mod->ieee1394_device, ++(mod->n_ieee1394_device)*sizeof(*(mod->ieee1394_device))); |
| diff -urN modutils-2.4.27.0.orig/include/obj.h modutils-2.4.27.0/include/obj.h |
| --- modutils-2.4.27.0.orig/include/obj.h 2003-10-26 19:34:46.000000000 -0700 |
| +++ modutils-2.4.27.0/include/obj.h 2005-09-29 17:53:53.000000000 -0600 |
| @@ -28,6 +28,8 @@ |
| |
| #include <stdio.h> |
| #include <sys/types.h> |
| +#include <endian.h> |
| +#include <byteswap.h> |
| #include <elf.h> |
| #include ELF_MACHINE_H |
| #include "module.h" |
| @@ -299,4 +301,6 @@ |
| |
| int obj_gpl_license(struct obj_file *, const char **); |
| |
| +extern int byteswap; |
| + |
| #endif /* obj.h */ |
| diff -urN modutils-2.4.27.0.orig/obj/obj_common.c modutils-2.4.27.0/obj/obj_common.c |
| --- modutils-2.4.27.0.orig/obj/obj_common.c 2002-02-28 17:39:06.000000000 -0700 |
| +++ modutils-2.4.27.0/obj/obj_common.c 2005-09-29 17:53:44.000000000 -0600 |
| @@ -28,6 +28,8 @@ |
| #include <util.h> |
| #include <module.h> |
| |
| +int byteswap; |
| + |
| /*======================================================================*/ |
| |
| /* Standard ELF hash function. */ |
| diff -urN modutils-2.4.27.0.orig/util/modstat.c modutils-2.4.27.0/util/modstat.c |
| --- modutils-2.4.27.0.orig/util/modstat.c 2002-11-24 21:01:57.000000000 -0700 |
| +++ modutils-2.4.27.0/util/modstat.c 2005-09-29 14:41:13.000000000 -0600 |
| @@ -408,6 +408,7 @@ |
| |
| int get_kernel_info(int type) |
| { |
| +#if 0 |
| k_new_syscalls = !query_module(NULL, 0, NULL, 0, NULL); |
| |
| #ifdef COMPAT_2_0 |
| @@ -416,4 +417,7 @@ |
| #endif /* COMPAT_2_0 */ |
| |
| return new_get_kernel_info(type); |
| +#else |
| + return 1; |
| +#endif |
| } |
| --- modutils-2.4.27/obj/obj_ppc.c.orig 2005-10-24 11:54:44.000000000 -0600 |
| +++ modutils-2.4.27/obj/obj_ppc.c 2005-10-24 11:55:54.000000000 -0600 |
| @@ -20,6 +20,8 @@ |
| along with this program; if not, write to the Free Software Foundation, |
| Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| |
| +#include <string.h> |
| +#include <stdlib.h> |
| #include <stddef.h> |
| #include <module.h> |
| #include <obj.h> |
| @@ -255,7 +257,9 @@ |
| archdata_sec->header.sh_size = 0; |
| sec = obj_find_section(f, "__ftr_fixup"); |
| if (sec) { |
| - ad = (struct archdata *) (archdata_sec->contents) = xmalloc(sizeof(*ad)); |
| + struct archdata * ad; |
| + archdata_sec->contents = xmalloc(sizeof(*ad)); |
| + ad = (struct archdata *) (archdata_sec->contents); |
| memset(ad, 0, sizeof(*ad)); |
| archdata_sec->header.sh_size = sizeof(*ad); |
| ad->__start___ftr_fixup = sec->header.sh_addr; |
| --- modutils-2.4.27/obj/obj_load.c.orig 2006-01-10 06:10:37.000000000 -0700 |
| +++ modutils-2.4.27/obj/obj_load.c 2006-01-10 06:10:47.000000000 -0700 |
| @@ -62,13 +62,61 @@ |
| error("%s is not an ELF file", filename); |
| return NULL; |
| } |
| + |
| + /* Check if the target endianness matches the host's endianness */ |
| + byteswap = 0; |
| +#if __BYTE_ORDER == __LITTLE_ENDIAN |
| + if (f->header.e_ident[5] == ELFDATA2MSB) { |
| + /* Ick -- we will have to byte-swap everything */ |
| + byteswap = 1; |
| + } |
| +#elif __BYTE_ORDER == __BIG_ENDIAN |
| + if (f->header.e_ident[5] == ELFDATA2LSB) { |
| + byteswap = 1; |
| + } |
| +#else |
| +#error Unknown host byte order! |
| +#endif |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + f->header.e_type=bswap_16(f->header.e_type); |
| + f->header.e_machine=bswap_16(f->header.e_machine); |
| + f->header.e_version=bswap_32(f->header.e_version); |
| + f->header.e_entry=bswap_32(f->header.e_entry); |
| + f->header.e_phoff=bswap_32(f->header.e_phoff); |
| + f->header.e_shoff=bswap_32(f->header.e_shoff); |
| + f->header.e_flags=bswap_32(f->header.e_flags); |
| + f->header.e_ehsize=bswap_16(f->header.e_ehsize); |
| + f->header.e_phentsize=bswap_16(f->header.e_phentsize); |
| + f->header.e_phnum=bswap_16(f->header.e_phnum); |
| + f->header.e_shentsize=bswap_16(f->header.e_shentsize); |
| + f->header.e_shnum=bswap_16(f->header.e_shnum); |
| + f->header.e_shstrndx=bswap_16(f->header.e_shstrndx); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + f->header.e_type=bswap_32(f->header.e_type); |
| + f->header.e_machine=bswap_32(f->header.e_machine); |
| + f->header.e_version=bswap_64(f->header.e_version); |
| + f->header.e_entry=bswap_64(f->header.e_entry); |
| + f->header.e_phoff=bswap_64(f->header.e_phoff); |
| + f->header.e_shoff=bswap_64(f->header.e_shoff); |
| + f->header.e_flags=bswap_64(f->header.e_flags); |
| + f->header.e_ehsize=bswap_32(f->header.e_ehsize); |
| + f->header.e_phentsize=bswap_32(f->header.e_phentsize); |
| + f->header.e_phnum=bswap_32(f->header.e_phnum); |
| + f->header.e_shentsize=bswap_32(f->header.e_shentsize); |
| + f->header.e_shnum=bswap_32(f->header.e_shnum); |
| + f->header.e_shstrndx=bswap_32(f->header.e_shstrndx); |
| +#endif |
| + } |
| + |
| if (f->header.e_ident[EI_CLASS] != ELFCLASSM |
| || f->header.e_ident[EI_DATA] != ELFDATAM |
| || f->header.e_ident[EI_VERSION] != EV_CURRENT |
| || !MATCH_MACHINE(f->header.e_machine)) |
| { |
| - error("ELF file %s not for this architecture", filename); |
| - return NULL; |
| + error("WARNING: ELF file %s not for this architecture", filename); |
| + //return NULL; |
| } |
| if (f->header.e_type != e_type && e_type != ET_NONE) |
| { |
| @@ -116,6 +164,33 @@ |
| { |
| struct obj_section *sec; |
| |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + section_headers[i].sh_name=bswap_32(section_headers[i].sh_name); |
| + section_headers[i].sh_type=bswap_32(section_headers[i].sh_type); |
| + section_headers[i].sh_flags=bswap_32(section_headers[i].sh_flags); |
| + section_headers[i].sh_addr=bswap_32(section_headers[i].sh_addr); |
| + section_headers[i].sh_offset=bswap_32(section_headers[i].sh_offset); |
| + section_headers[i].sh_size=bswap_32(section_headers[i].sh_size); |
| + section_headers[i].sh_link=bswap_32(section_headers[i].sh_link); |
| + section_headers[i].sh_info=bswap_32(section_headers[i].sh_info); |
| + section_headers[i].sh_addralign=bswap_32(section_headers[i].sh_addralign); |
| + section_headers[i].sh_entsize=bswap_32(section_headers[i].sh_entsize); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + section_headers[i].sh_name=bswap_64(section_headers[i].sh_name); |
| + section_headers[i].sh_type=bswap_64(section_headers[i].sh_type); |
| + section_headers[i].sh_flags=bswap_64(section_headers[i].sh_flags); |
| + section_headers[i].sh_addr=bswap_64(section_headers[i].sh_addr); |
| + section_headers[i].sh_offset=bswap_64(section_headers[i].sh_offset); |
| + section_headers[i].sh_size=bswap_64(section_headers[i].sh_size); |
| + section_headers[i].sh_link=bswap_64(section_headers[i].sh_link); |
| + section_headers[i].sh_info=bswap_64(section_headers[i].sh_info); |
| + section_headers[i].sh_addralign=bswap_64(section_headers[i].sh_addralign); |
| + section_headers[i].sh_entsize=bswap_64(section_headers[i].sh_entsize); |
| +#endif |
| + } |
| + |
| f->sections[i] = sec = arch_new_section(); |
| memset(sec, 0, sizeof(*sec)); |
| |
| @@ -223,6 +298,20 @@ |
| nsym = sec->header.sh_size / sizeof(ElfW(Sym)); |
| strtab = f->sections[sec->header.sh_link]->contents; |
| sym = (ElfW(Sym) *) sec->contents; |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + sym->st_name = bswap_32(sym->st_name); |
| + sym->st_value = bswap_32(sym->st_value); |
| + sym->st_size = bswap_32(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + sym->st_name = bswap_64(sym->st_name); |
| + sym->st_value = bswap_64(sym->st_value); |
| + sym->st_size = bswap_64(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| + } |
| |
| /* Allocate space for a table of local symbols. */ |
| j = f->local_symtab_size = sec->header.sh_info; |
| @@ -233,6 +322,22 @@ |
| for (j = 1, ++sym; j < nsym; ++j, ++sym) |
| { |
| const char *name; |
| + |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + sym->st_name = bswap_32(sym->st_name); |
| + sym->st_value = bswap_32(sym->st_value); |
| + sym->st_size = bswap_32(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + sym->st_name = bswap_64(sym->st_name); |
| + sym->st_value = bswap_64(sym->st_value); |
| + sym->st_size = bswap_64(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| + } |
| + |
| if (sym->st_name) |
| name = strtab+sym->st_name; |
| else |
| @@ -298,9 +403,26 @@ |
| { |
| struct obj_symbol *intsym; |
| unsigned long symndx; |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + rel->r_offset = bswap_32(rel->r_offset); |
| + rel->r_info = bswap_32(rel->r_info); |
| +#if Elf32_RelM != Elf32_Rel |
| + rel->r_addend = bswap_32(rel->r_addend); |
| +#endif |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + rel->r_offset = bswap_64(rel->r_offset); |
| + rel->r_info = bswap_64(rel->r_info); |
| +#if Elf32_RelM != Elf32_Rel |
| + rel->r_addend = bswap_64(rel->r_addend); |
| +#endif |
| +#endif |
| + } |
| symndx = ELFW(R_SYM)(rel->r_info); |
| if (symndx) |
| { |
| + ElfW(Sym) *sym; |
| if (symndx >= nsyms) |
| { |
| error("%s: Bad symbol index: %08lx >= %08lx", |
| @@ -308,7 +430,22 @@ |
| continue; |
| } |
| |
| - obj_find_relsym(intsym, f, f, rel, (ElfW(Sym) *)(symtab->contents), strtab); |
| + sym = (ElfW(Sym) *)(symtab->contents); |
| + if (byteswap==1) { |
| +#if ELFCLASSM == ELFCLASS32 |
| + sym->st_name = bswap_32(sym->st_name); |
| + sym->st_value = bswap_32(sym->st_value); |
| + sym->st_size = bswap_32(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| +#if ELFCLASSM == ELFCLASS64 |
| + sym->st_name = bswap_64(sym->st_name); |
| + sym->st_value = bswap_64(sym->st_value); |
| + sym->st_size = bswap_64(sym->st_size); |
| + sym->st_shndx = bswap_16(sym->st_shndx); |
| +#endif |
| + } |
| + obj_find_relsym(intsym, f, f, rel, sym, strtab); |
| intsym->r_type = ELFW(R_TYPE)(rel->r_info); |
| } |
| } |
| --- modutils-2.4.27/obj/obj_reloc.c.orig 2003-10-26 18:25:08.000000000 -0800 |
| +++ modutils-2.4.27/obj/obj_reloc.c 2006-06-20 17:47:11.000000000 -0700 |
| @@ -331,6 +331,18 @@ |
| value += rel->r_addend; |
| #endif |
| |
| + /* Byte swap if necessary. For some archs, other adjustments may |
| + need to be done in arch_apply_relocation. */ |
| + if (byteswap==1) |
| + { |
| + if (sizeof(unsigned tgt_long) == 4) |
| + *(tgt_long *)(targsec->contents + rel->r_offset) = |
| + bswap_32(*(tgt_long *)(targsec->contents + rel->r_offset)); |
| + else if (sizeof(unsigned tgt_long) == 8) |
| + *(tgt_long *)(targsec->contents + rel->r_offset) = |
| + bswap_64(*(tgt_long *)(targsec->contents + rel->r_offset)); |
| + } |
| + |
| /* Do it! */ |
| switch (arch_apply_relocation(f,targsec,symsec,intsym,rel,value)) |
| { |
| --- odutils-2.4.27.0.orig/include/module.h.orig 2006-01-10 08:15:09.000000000 -0700 |
| +++ odutils-2.4.27.0/include/module.h 2006-01-10 08:15:13.000000000 -0700 |
| @@ -88,16 +88,34 @@ |
| /* For sizeof() which are related to the module platform and not to the |
| environment isnmod is running in, use sizeof_xx instead of sizeof(xx). */ |
| |
| -#define tgt_sizeof_char sizeof(char) |
| -#define tgt_sizeof_short sizeof(short) |
| -#define tgt_sizeof_int sizeof(int) |
| -#define tgt_sizeof_long sizeof(long) |
| -#define tgt_sizeof_char_p sizeof(char *) |
| -#define tgt_sizeof_void_p sizeof(void *) |
| -#define tgt_long long |
| +#include <stdint.h> |
| + |
| +#if ELFCLASSM == ELFCLASS32 |
| + |
| +#define tgt_sizeof_char 1 |
| +#define tgt_sizeof_short 2 |
| +#define tgt_sizeof_int 4 |
| +#define tgt_sizeof_long 4 |
| +#define tgt_sizeof_char_p 4 |
| +#define tgt_sizeof_void_p 4 |
| +#define tgt_long int |
| #define tgt_long_fmt "l" |
| #define tgt_strtoul strtoul |
| |
| +#else |
| + |
| +#define tgt_sizeof_char 1 |
| +#define tgt_sizeof_short 2 |
| +#define tgt_sizeof_int 4 |
| +#define tgt_sizeof_long 8 |
| +#define tgt_sizeof_char_p 8 |
| +#define tgt_sizeof_void_p 8 |
| +#define tgt_long long |
| +#define tgt_long_fmt "ll" |
| +#define tgt_strtoul strtoull |
| + |
| +#endif |
| + |
| /* This assumes that long long on a 32 bit system is equivalent to long on the |
| * equivalent 64 bit system. Also that void and char pointers are 8 bytes on |
| * all 64 bit systems. Add per system tweaks if it ever becomes necessary. |