diff --git a/components/libc/libdl/arch/riscv.c b/components/libc/libdl/arch/riscv.c new file mode 100644 index 0000000000000000000000000000000000000000..33cae28d1694a7196ebdb7b03574868f4c3d16bf --- /dev/null +++ b/components/libc/libdl/arch/riscv.c @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021/04/23 chunyexixiaoyu first version + + */ + +#include "../dlmodule.h" +#include "../dlelf.h" + +#if (__riscv_xlen == 64) +#define R_RISCV_NONE 0 +#define R_RISCV_32 1 +#define R_RISCV_64 2 +#define R_RISCV_RELATIVE 3 +#define R_RISCV_COPY 4 +#define R_RISCV_JUMP_SLOT 5 +#define R_RISCV_TLS_DTPMOD32 6 +#define R_RISCV_TLS_DTPMOD64 7 +#define R_RISCV_TLS_DTPREL32 8 +#define R_RISCV_TLS_DTPREL64 9 +#define R_RISCV_TLS_TPREL32 10 +#define R_RISCV_TLS_TPREL64 11 + +int dlmodule_relocate(struct rt_dlmodule *module, Elf_Rel *rel, Elf_Addr sym_val) +{ + Elf64_Addr *where, tmp; + Elf64_Sword addend, offset; + rt_uint64_t upper, lower, sign, j1, j2; + + where = (Elf64_Addr *)((rt_uint8_t *)module->mem_space + + rel->r_offset + - module->vstart_addr); + switch (ELF64_R_TYPE(rel->r_info)) + { + case R_RISCV_NONE: + break; + case R_RISCV_64: + *where = (Elf64_Addr)(sym_val + rel->r_addend); + RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_64: %x -> %x\n",where, *where)); + break; + case R_RISCV_RELATIVE: + *where = (Elf64_Addr)((rt_uint8_t *)module->mem_space - module->vstart_addr + rel->r_addend); + RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_RELATIVE: %x -> %x\n",where, *where)); + break; + case R_RISCV_JUMP_SLOT: + *where = (Elf64_Addr)sym_val; + RT_DEBUG_LOG(RT_DEBUG_MODULE, ("R_RISCV_JUMP_SLOT: %x -> %x\n",where, *where)); + break; + default: + RT_DEBUG_LOG(RT_DEBUG_MODULE, ("__riscv__ELF: invalid relocate TYPE %d\n", ELF64_R_TYPE(rel->r_info))); + return -1; + } + return 0; +} +#endif diff --git a/components/libc/libdl/dlelf.c b/components/libc/libdl/dlelf.c index f573122a485b4d0221b8495680020383412752ff..418ad7539aa5e3b6f69de0bf45957a92ee07b0bd 100644 --- a/components/libc/libdl/dlelf.c +++ b/components/libc/libdl/dlelf.c @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2018/08/29 Bernard first version + * 2021/04/23 chunyexixiaoyu distinguish 32-bit and 64-bit */ #include "dlmodule.h" @@ -18,8 +19,8 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_ptr) { rt_bool_t linked = RT_FALSE; - rt_uint32_t index, module_size = 0; - Elf32_Addr vstart_addr, vend_addr; + rt_ubase_t index, module_size = 0; + Elf_Addr vstart_addr, vend_addr; rt_bool_t has_vstart; RT_ASSERT(module_ptr != RT_NULL); @@ -53,7 +54,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt has_vstart = RT_TRUE; if (vend_addr < vstart_addr) { - rt_kprintf("invalid elf: segment %d: p_vaddr: %d, p_memsz: %d\n", + LOG_E("invalid elf: segment %d: p_vaddr: %d, p_memsz: %d\n", index, phdr[index].p_vaddr, phdr[index].p_memsz); return RT_NULL; } @@ -62,7 +63,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt { if (phdr[index].p_vaddr < vend_addr) { - rt_kprintf("invalid elf: segment should be sorted and not overlapped\n"); + LOG_E("invalid elf: segment should be sorted and not overlapped\n"); return RT_NULL; } if (phdr[index].p_vaddr > vend_addr + 16) @@ -74,7 +75,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt vend_addr = phdr[index].p_vaddr + phdr[index].p_memsz; if (vend_addr < phdr[index].p_vaddr) { - rt_kprintf("invalid elf: " + LOG_E("invalid elf: " "segment %d address overflow\n", index); return RT_NULL; } @@ -85,7 +86,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt LOG_D("module size: %d, vstart_addr: 0x%p", module_size, vstart_addr); if (module_size == 0) { - rt_kprintf("Module: size error\n"); + LOG_E("Module: size error\n"); return -RT_ERROR; } @@ -96,7 +97,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt module->mem_space = rt_malloc(module_size); if (module->mem_space == RT_NULL) { - rt_kprintf("Module: allocate space failed.\n"); + LOG_E("Module: allocate space failed.\n"); return -RT_ERROR; } module->mem_size = module_size; @@ -119,42 +120,49 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt /* handle relocation section */ for (index = 0; index < elf_module->e_shnum; index ++) { - rt_uint32_t i, nr_reloc; - Elf32_Sym *symtab; - Elf32_Rel *rel; + rt_ubase_t i, nr_reloc; + Elf_Sym *symtab; + Elf_Rel *rel; rt_uint8_t *strtab; static rt_bool_t unsolved = RT_FALSE; - + #if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32)) if (!IS_REL(shdr[index])) continue; + #elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) + if (!IS_RELA(shdr[index])) + continue; + #endif /* get relocate item */ - rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); + rel = (Elf_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); /* locate .rel.plt and .rel.dyn section */ - symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr + + symtab = (Elf_Sym *)((rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset); strtab = (rt_uint8_t *)module_ptr + shdr[shdr[shdr[index].sh_link].sh_link].sh_offset; - nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel)); + nr_reloc = (rt_ubase_t)(shdr[index].sh_size / sizeof(Elf_Rel)); /* relocate every items */ for (i = 0; i < nr_reloc; i ++) { - Elf32_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)]; - + #if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32)) + Elf_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)]; + #elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) + Elf_Sym *sym = &symtab[ELF64_R_SYM(rel->r_info)]; + #endif LOG_D("relocate symbol %s shndx %d", strtab + sym->st_name, sym->st_shndx); if ((sym->st_shndx != SHT_NULL) ||(ELF_ST_BIND(sym->st_info) == STB_LOCAL)) { - Elf32_Addr addr; + Elf_Addr addr; - addr = (Elf32_Addr)(module->mem_space + sym->st_value - vstart_addr); + addr = (Elf_Addr)(module->mem_space + sym->st_value - vstart_addr); dlmodule_relocate(module, rel, addr); } else if (!linked) { - Elf32_Addr addr; + Elf_Addr addr; LOG_D("relocate symbol: %s", strtab + sym->st_name); /* need to resolve symbol in kernel symbol table */ @@ -191,13 +199,13 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt if (index != elf_module->e_shnum) { int i, count = 0; - Elf32_Sym *symtab = RT_NULL; + Elf_Sym *symtab = RT_NULL; rt_uint8_t *strtab = RT_NULL; - symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); + symtab = (Elf_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); strtab = (rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset; - for (i = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++) + for (i = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++) { if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) && (ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC)) @@ -207,7 +215,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt module->symtab = (struct rt_module_symtab *)rt_malloc (count * sizeof(struct rt_module_symtab)); module->nsym = count; - for (i = 0, count = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++) + for (i = 0, count = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++) { rt_size_t length; @@ -231,7 +239,7 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt rt_uint32_t flag = 0; rt_uint16_t priority; rt_uint32_t stacksize; - for (i = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++) + for (i = 0; i < shdr[index].sh_size / sizeof(Elf_Sym); i++) { if (((flag & 0x01) == 0) && (rt_strcmp((const char *)(strtab + symtab[i].st_name), "dlmodule_thread_priority") == 0)) @@ -267,8 +275,8 @@ rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_pt rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr) { - rt_uint32_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0; - rt_uint32_t module_addr = 0, module_size = 0; + rt_ubase_t index, rodata_addr = 0, bss_addr = 0, data_addr = 0; + rt_ubase_t module_addr = 0, module_size = 0; rt_uint8_t *ptr, *strtab, *shstrab; /* get the ELF image size */ @@ -306,7 +314,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module module->mem_space = rt_malloc(module_size); if (module->mem_space == RT_NULL) { - rt_kprintf("Module: allocate space failed.\n"); + LOG_E("Module: allocate space failed.\n"); return -RT_ERROR; } module->mem_size = module_size; @@ -367,35 +375,45 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module /* handle relocation section */ for (index = 0; index < elf_module->e_shnum; index ++) { - rt_uint32_t i, nr_reloc; - Elf32_Sym *symtab; - Elf32_Rel *rel; + rt_ubase_t i, nr_reloc; + Elf_Sym *symtab; + Elf_Rel *rel; + #if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32)) if (!IS_REL(shdr[index])) continue; + #elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) + if (!IS_RELA(shdr[index])) + continue; + #endif + /* get relocate item */ - rel = (Elf32_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); + rel = (Elf_Rel *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset); /* locate .dynsym and .dynstr */ - symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr + + symtab = (Elf_Sym *)((rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset); strtab = (rt_uint8_t *)module_ptr + shdr[shdr[shdr[index].sh_link].sh_link].sh_offset; shstrab = (rt_uint8_t *)module_ptr + shdr[elf_module->e_shstrndx].sh_offset; - nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel)); + nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf_Rel)); /* relocate every items */ for (i = 0; i < nr_reloc; i ++) { - Elf32_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)]; + #if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32)) + Elf_Sym *sym = &symtab[ELF32_R_SYM(rel->r_info)]; + #elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) + Elf_Sym *sym = &symtab[ELF64_R_SYM(rel->r_info)]; + #endif LOG_D("relocate symbol: %s", strtab + sym->st_name); if (sym->st_shndx != STN_UNDEF) { - Elf32_Addr addr = 0; + Elf_Addr addr = 0; if ((ELF_ST_TYPE(sym->st_info) == STT_SECTION) || (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)) @@ -405,28 +423,28 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module { /* relocate rodata section */ LOG_D("rodata"); - addr = (Elf32_Addr)(rodata_addr + sym->st_value); + addr = (Elf_Addr)(rodata_addr + sym->st_value); } else if (rt_strncmp((const char *) (shstrab + shdr[sym->st_shndx].sh_name), ELF_BSS, 5) == 0) { /* relocate bss section */ LOG_D("bss"); - addr = (Elf32_Addr)bss_addr + sym->st_value; + addr = (Elf_Addr)bss_addr + sym->st_value; } else if (rt_strncmp((const char *)(shstrab + shdr[sym->st_shndx].sh_name), ELF_DATA, 6) == 0) { /* relocate data section */ LOG_D("data"); - addr = (Elf32_Addr)data_addr + sym->st_value; + addr = (Elf_Addr)data_addr + sym->st_value; } if (addr != 0) dlmodule_relocate(module, rel, addr); } else if (ELF_ST_TYPE(sym->st_info) == STT_FUNC) { - addr = (Elf32_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); + addr = (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); /* relocate function */ dlmodule_relocate(module, rel, addr); @@ -436,14 +454,14 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module { /* relocate function */ dlmodule_relocate(module, rel, - (Elf32_Addr)((rt_uint8_t *) + (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value)); } else { - Elf32_Addr addr; + Elf_Addr addr; if (ELF32_R_TYPE(rel->r_info) != R_ARM_V4BX) { @@ -451,7 +469,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module /* need to resolve symbol in kernel symbol table */ addr = dlmodule_symbol_find((const char *)(strtab + sym->st_name)); - if (addr != (Elf32_Addr)RT_NULL) + if (addr != (Elf_Addr)RT_NULL) { dlmodule_relocate(module, rel, addr); LOG_D("symbol addr 0x%x", addr); @@ -462,7 +480,7 @@ rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module } else { - addr = (Elf32_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); + addr = (Elf_Addr)((rt_uint8_t *) module->mem_space - module_addr + sym->st_value); dlmodule_relocate(module, rel, addr); } } diff --git a/components/libc/libdl/dlelf.h b/components/libc/libdl/dlelf.h index ad9e2cdade74b8260ad31a54ae04c91dd144e34e..540fe2c8aa5990171cfa5513d329770fb7cfb3e4 100644 --- a/components/libc/libdl/dlelf.h +++ b/components/libc/libdl/dlelf.h @@ -6,6 +6,7 @@ * Change Logs: * Date Author Notes * 2018/08/29 Bernard first version + * 2021/04/23 chunyexixiaoyu distinguish 32-bit and 64-bit */ #ifndef DL_ELF_H__ @@ -19,6 +20,21 @@ typedef rt_int32_t Elf32_Sword; /* Signed large integer */ typedef rt_uint32_t Elf32_Word; /* Unsigned large integer */ typedef rt_uint16_t Elf32_Half; /* Unsigned medium integer */ +typedef rt_uint64_t Elf64_Addr; +typedef rt_uint16_t Elf64_Half; +typedef rt_int16_t Elf64_SHalf; +typedef rt_uint64_t Elf64_Off; +typedef rt_int32_t Elf64_Sword; +typedef rt_uint32_t Elf64_Word; +typedef rt_uint64_t Elf64_Xword; +typedef rt_int64_t Elf64_Sxword; +typedef uint16_t Elf64_Section; + + + + + + /* e_ident[] magic number */ #define ELFMAG0 0x7f /* e_ident[EI_MAG0] */ #define ELFMAG1 'E' /* e_ident[EI_MAG1] */ @@ -75,6 +91,25 @@ typedef struct elfhdr header string table" entry offset */ } Elf32_Ehdr; + +typedef struct elf64_hdr { + unsigned char e_ident[EI_NIDENT]; /* ELF Identification */ + Elf64_Half e_type; /* object file type */ + Elf64_Half e_machine; /* machine */ + Elf64_Word e_version; /* object file version */ + Elf64_Addr e_entry; /* virtual entry point */ + Elf64_Off e_phoff; /* program header table offset */ + Elf64_Off e_shoff; /* section header table offset */ + Elf64_Word e_flags; /* processor-specific flags */ + Elf64_Half e_ehsize; /* ELF header size */ + Elf64_Half e_phentsize; /* program header entry size */ + Elf64_Half e_phnum; /* number of program header entries */ + Elf64_Half e_shentsize; /* section header entry size */ + Elf64_Half e_shnum; /* number of section header entries */ + Elf64_Half e_shstrndx; /* section header table's "section + header string table" entry offset */ +} Elf64_Ehdr; + /* Section Header */ typedef struct { @@ -91,6 +126,21 @@ typedef struct Elf32_Word sh_entsize; /* section entry size */ } Elf32_Shdr; +typedef struct +{ + Elf64_Word sh_name; /* Section name (string tbl index) */ + Elf64_Word sh_type; /* Section type */ + Elf64_Xword sh_flags; /* Section flags */ + Elf64_Addr sh_addr; /* Section virtual addr at execution */ + Elf64_Off sh_offset; /* Section file offset */ + Elf64_Xword sh_size; /* Section size in bytes */ + Elf64_Word sh_link; /* Link to another section */ + Elf64_Word sh_info; /* Additional section information */ + Elf64_Xword sh_addralign; /* Section alignment */ + Elf64_Xword sh_entsize; /* Entry size if section holds table */ +} Elf64_Shdr; + + /* Section names */ #define ELF_BSS ".bss" /* uninitialized data */ #define ELF_DATA ".data" /* initialized data */ @@ -126,6 +176,19 @@ typedef struct elf32_sym Elf32_Half st_shndx; /* section header index */ } Elf32_Sym; + +typedef struct +{ + Elf64_Word st_name; /* Symbol name (string tbl index) */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf64_Section st_shndx; /* Section index */ + Elf64_Addr st_value; /* Symbol value */ + Elf64_Xword st_size; /* Symbol size */ +} Elf64_Sym; + + + #define STB_LOCAL 0 /* BIND */ #define STB_GLOBAL 1 #define STB_WEAK 2 @@ -160,6 +223,12 @@ typedef struct Elf32_Word r_info; /* symbol table index and type */ } Elf32_Rel; +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ +} Elf64_Rel; + /* Relocation entry with explicit addend */ typedef struct { @@ -168,11 +237,24 @@ typedef struct Elf32_Sword r_addend; } Elf32_Rela; +typedef struct +{ + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ + Elf64_Sxword r_addend; /* Addend */ +} Elf64_Rela; + /* Extract relocation info - r_info */ #define ELF32_R_SYM(i) ((i) >> 8) #define ELF32_R_TYPE(i) ((unsigned char) (i)) #define ELF32_R_INFO(s,t) (((s) << 8) + (unsigned char)(t)) + + +#define ELF64_R_SYM(i) ((i) >> 32) +#define ELF64_R_TYPE(i) ((i) & 0xffffffff) +#define ELF64_R_INFO(sym,type) ((((Elf64_Xword) (sym)) << 32) + (type)) + /* * Relocation type for arm */ @@ -219,6 +301,23 @@ typedef struct Elf32_Word p_align; /* memory alignment */ } Elf32_Phdr; + +typedef struct +{ + Elf64_Word p_type; /* Segment type */ + Elf64_Word p_flags; /* Segment flags */ + Elf64_Off p_offset; /* Segment file offset */ + Elf64_Addr p_vaddr; /* Segment virtual address */ + Elf64_Addr p_paddr; /* Segment physical address */ + Elf64_Xword p_filesz; /* Segment size in file */ + Elf64_Xword p_memsz; /* Segment size in memory */ + Elf64_Xword p_align; /* Segment alignment */ +} Elf64_Phdr; + + + + + /* p_type */ #define PT_NULL 0 #define PT_LOAD 1 @@ -273,13 +372,27 @@ typedef struct #define IS_AX(s) ((s.sh_flags & SHF_ALLOC) && (s.sh_flags & SHF_EXECINSTR)) #define IS_AW(s) ((s.sh_flags & SHF_ALLOC) && (s.sh_flags & SHF_WRITE)) +#if (defined(__arm__) || defined(__i386__) || (__riscv_xlen == 32)) #define elf_module ((Elf32_Ehdr *)module_ptr) #define shdr ((Elf32_Shdr *)((rt_uint8_t *)module_ptr + elf_module->e_shoff)) #define phdr ((Elf32_Phdr *)((rt_uint8_t *)module_ptr + elf_module->e_phoff)) +typedef Elf32_Sym Elf_Sym; +typedef Elf32_Rel Elf_Rel; +typedef Elf32_Addr Elf_Addr; +#elif (defined(__aarch64__) || defined(__x86_64__) || (__riscv_xlen == 64)) +#define elf_module ((Elf64_Ehdr *)module_ptr) +#define shdr ((Elf64_Shdr *)((rt_uint8_t *)module_ptr + elf_module->e_shoff)) +#define phdr ((Elf64_Phdr *)((rt_uint8_t *)module_ptr + elf_module->e_phoff)) + +typedef Elf64_Sym Elf_Sym; +typedef Elf64_Rela Elf_Rel; +typedef Elf64_Addr Elf_Addr; +#endif +int dlmodule_relocate(struct rt_dlmodule *module, Elf_Rel *rel, Elf_Addr sym_val); rt_err_t dlmodule_load_shared_object(struct rt_dlmodule* module, void *module_ptr); rt_err_t dlmodule_load_relocated_object(struct rt_dlmodule* module, void *module_ptr); -int dlmodule_relocate(struct rt_dlmodule *module, Elf32_Rel *rel, Elf32_Addr sym_val); + #endif diff --git a/components/libc/libdl/dlmodule.c b/components/libc/libdl/dlmodule.c index c4bbb26b37d7b414360b51de1ae3597ebca67a88..044c05a9942dc1b21523c1b19773bd56ecc5a8ca 100644 --- a/components/libc/libdl/dlmodule.c +++ b/components/libc/libdl/dlmodule.c @@ -464,7 +464,7 @@ struct rt_dlmodule* dlmodule_load(const char* filename) } /* check ELF class */ - if (elf_module->e_ident[EI_CLASS] != ELFCLASS32) + if ((elf_module->e_ident[EI_CLASS] != ELFCLASS32)&&(elf_module->e_ident[EI_CLASS] != ELFCLASS64)) { rt_kprintf("Module: ELF class error\n"); goto __exit;