URL
https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k
[/] [or1k/] [trunk/] [ecos-2.0/] [packages/] [redboot/] [v2_0/] [include/] [elf.h] - Rev 1773
Go to most recent revision | Compare with Previous | Blame | View Log
#ifndef CYGONCE_REDBOOT_ELF_H #define CYGONCE_REDBOOT_ELF_H //========================================================================== // // elf.h // // ELF file format definitions // //========================================================================== //####ECOSGPLCOPYRIGHTBEGIN#### // ------------------------------------------- // This file is part of eCos, the Embedded Configurable Operating System. // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. // // eCos is free software; you can redistribute it and/or modify it under // the terms of the GNU General Public License as published by the Free // Software Foundation; either version 2 or (at your option) any later version. // // eCos is distributed in the hope that it will be useful, but WITHOUT ANY // WARRANTY; without even the implied warranty of MERCHANTABILITY or // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License along // with eCos; if not, write to the Free Software Foundation, Inc., // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. // // As a special exception, if other files instantiate templates or use macros // or inline functions from this file, or you compile this file and link it // with other works to produce a work based on this file, this file does not // by itself cause the resulting work to be covered by the GNU General Public // License. However the source code for this file must still be made available // in accordance with section (3) of the GNU General Public License. // // This exception does not invalidate any other reasons why a work based on // this file might be covered by the GNU General Public License. // // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. // at http://sources.redhat.com/ecos/ecos-license/ // ------------------------------------------- //####ECOSGPLCOPYRIGHTEND#### //========================================================================== //#####DESCRIPTIONBEGIN#### // // Author(s): nickg // Contributors: nickg // Date: 2000-11-15 // Purpose: Define ELF file format // Description: The types defined here describe the ELF file format. // // Usage: #include <cyg/loader/elf.h> // //####DESCRIPTIONEND#### // //========================================================================== // // Quite a lot of this file was taken from the BSD exec_elf.h header file. // Hence we should show you this... // /* $OpenBSD: exec_elf.h,v 1.20 1999/09/19 16:16:49 kstailey Exp $ */ /* * Copyright (c) 1995, 1996 Erik Theisen. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ //========================================================================== #include <cyg/infra/cyg_type.h> // ------------------------------------------------------------------------- // Basic types: typedef cyg_uint32 Elf32_Addr; typedef cyg_uint32 Elf32_Off; typedef cyg_uint16 Elf32_Half; typedef cyg_uint32 Elf32_Word; typedef cyg_int32 Elf32_Sword; typedef cyg_uint64 Elf64_Addr; typedef cyg_uint64 Elf64_Off; typedef cyg_uint16 Elf64_Half; typedef cyg_uint32 Elf64_Word; typedef cyg_int32 Elf64_Sword; typedef cyg_uint64 Elf64_Xword; typedef cyg_int64 Elf64_Sxword; // ------------------------------------------------------------------------- // ELF header #define EI_NIDENT 16 typedef struct { unsigned char e_ident[EI_NIDENT]; Elf32_Half e_type; Elf32_Half e_machine; Elf32_Word e_version; Elf32_Addr e_entry; Elf32_Off e_phoff; Elf32_Off e_shoff; Elf32_Word e_flags; Elf32_Half e_ehsize; Elf32_Half e_phentsize; Elf32_Half e_phnum; Elf32_Half e_shentsize; Elf32_Half e_shnum; Elf32_Half e_shtrndx; } Elf32_Ehdr; typedef struct { unsigned char e_ident[EI_NIDENT]; Elf64_Half e_type; Elf64_Half e_machine; Elf64_Word e_version; Elf64_Addr e_entry; Elf64_Off e_phoff; Elf64_Off e_shoff; Elf64_Word e_flags; Elf64_Half e_ehsize; Elf64_Half e_phentsize; Elf64_Half e_phnum; Elf64_Half e_shentsize; Elf64_Half e_shnum; Elf64_Half e_shtrndx; } Elf64_Ehdr; // ------------------------------------------------------------------------- /* e_ident[] identification indexes */ #define EI_MAG0 0 /* file ID */ #define EI_MAG1 1 /* file ID */ #define EI_MAG2 2 /* file ID */ #define EI_MAG3 3 /* file ID */ #define EI_CLASS 4 /* file class */ #define EI_DATA 5 /* data encoding */ #define EI_VERSION 6 /* ELF header version */ #define EI_OSABI 7 /* Operating system/ABI identification */ #define EI_ABIVERSION 8 /* ABI version */ #define EI_PAD 9 /* start of pad bytes */ // ------------------------------------------------------------------------- /* e_ident[] magic number */ #define ELFMAG0 0x7f /* e_ident[EI_MAG0] */ #define ELFMAG1 'E' /* e_ident[EI_MAG1] */ #define ELFMAG2 'L' /* e_ident[EI_MAG2] */ #define ELFMAG3 'F' /* e_ident[EI_MAG3] */ #define ELFMAG "\177ELF" /* magic */ #define SELFMAG 4 /* size of magic */ // ------------------------------------------------------------------------- /* e_ident[] file class */ #define ELFCLASSNONE 0 /* invalid */ #define ELFCLASS32 1 /* 32-bit objs */ #define ELFCLASS64 2 /* 64-bit objs */ #define ELFCLASSNUM 3 /* number of classes */ // ------------------------------------------------------------------------- /* e_ident[] data encoding */ #define ELFDATANONE 0 /* invalid */ #define ELFDATA2LSB 1 /* Little-Endian */ #define ELFDATA2MSB 2 /* Big-Endian */ #define ELFDATANUM 3 /* number of data encode defines */ // ------------------------------------------------------------------------- /* e_ident */ #define IS_ELF(ehdr) ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \ (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \ (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \ (ehdr).e_ident[EI_MAG3] == ELFMAG3) // ------------------------------------------------------------------------- /* e_type */ #define ET_NONE 0 /* No file type */ #define ET_REL 1 /* relocatable file */ #define ET_EXEC 2 /* executable file */ #define ET_DYN 3 /* shared object file */ #define ET_CORE 4 /* core file */ #define ET_NUM 5 /* number of types */ #define ET_LOOS 0xfe00 /* Operating system-specific */ #define ET_HIOS 0xfeff /* Operating system-specific */ #define ET_LOPROC 0xff00 /* reserved range for processor */ #define ET_HIPROC 0xffff /* specific e_type */ // ------------------------------------------------------------------------- /* e_machine */ // The following values taken from 22 June 2000 SysV ABI spec, updated with // extra values from binutils elf/common.h. #define EM_NONE 0 // No machine #define EM_M32 1 // AT&T WE 32100 #define EM_SPARC 2 // SPARC #define EM_386 3 // Intel 80386 #define EM_68K 4 // Motorola 68000 #define EM_88K 5 // Motorola 88000 #define EM_860 7 // Intel 80860 #define EM_MIPS 8 // MIPS I Architecture #define EM_S370 9 // IBM System/370 Processor #define EM_MIPS_RS3_LE 10 // MIPS RS3000 Little-endian #define EM_PARISC 15 // Hewlett-Packard PA-RISC #define EM_VPP500 17 // Fujitsu VPP500 #define EM_SPARC32PLUS 18 // Enhanced instruction set SPARC #define EM_960 19 // Intel 80960 #define EM_PPC 20 // PowerPC #define EM_PPC64 21 // 64-bit PowerPC #define EM_V800 36 // NEC V800 #define EM_FR20 37 // Fujitsu FR20 #define EM_RH32 38 // TRW RH-32 #define EM_RCE 39 // Motorola RCE #define EM_ARM 40 // Advanced RISC Machines ARM #define EM_ALPHA 41 // Digital Alpha #define EM_SH 42 // Hitachi SH #define EM_SPARCV9 43 // SPARC Version 9 #define EM_TRICORE 44 // Siemens Tricore embedded processor #define EM_ARC 45 // Argonaut RISC Core, Argonaut Technologies Inc. #define EM_H8_300 46 // Hitachi H8/300 #define EM_H8_300H 47 // Hitachi H8/300H #define EM_H8S 48 // Hitachi H8S #define EM_H8_500 49 // Hitachi H8/500 #define EM_IA_64 50 // Intel IA-64 processor architecture #define EM_MIPS_X 51 // Stanford MIPS-X #define EM_COLDFIRE 52 // Motorola ColdFire #define EM_68HC12 53 // Motorola M68HC12 #define EM_MMA 54 // Fujitsu MMA Multimedia Accelerator #define EM_PCP 55 // Siemens PCP #define EM_NCPU 56 // Sony nCPU embedded RISC processor #define EM_NDR1 57 // Denso NDR1 microprocessor #define EM_STARCORE 58 // Motorola Star*Core processor #define EM_ME16 59 // Toyota ME16 processor #define EM_ST100 60 // STMicroelectronics ST100 processor #define EM_TINYJ 61 // Advanced Logic Corp. TinyJ embedded processor family #define EM_FX66 66 // Siemens FX66 microcontroller #define EM_ST9PLUS 67 // STMicroelectronics ST9+ 8/16 bit microcontroller #define EM_ST7 68 // STMicroelectronics ST7 8-bit microcontroller #define EM_68HC16 69 // Motorola MC68HC16 Microcontroller #define EM_68HC11 70 // Motorola MC68HC11 Microcontroller #define EM_68HC08 71 // Motorola MC68HC08 Microcontroller #define EM_68HC05 72 // Motorola MC68HC05 Microcontroller #define EM_SVX 73 // Silicon Graphics SVx #define EM_ST19 74 // STMicroelectronics ST19 8-bit microcontroller #define EM_VAX 75 // Digital VAX #define EM_CRIS 76 // Axis Communications 32-bit embedded processor #define EM_JAVELIN 77 // Infineon Technologies 32-bit embedded processor #define EM_FIREPATH 78 // Element 14 64-bit DSP Processor #define EM_ZSP 79 // LSI Logic 16-bit DSP Processor #define EM_MMIX 80 // Donald Knuth's educational 64-bit processor #define EM_HUANY 81 // Harvard University machine-independent object files #define EM_PRISM 82 // SiTera Prism /* Cygnus PowerPC ELF backend. Written in the absence of an ABI. */ #define EM_CYGNUS_POWERPC 0x9025 /* Old version of Sparc v9, from before the ABI; this should be removed shortly. */ #define EM_OLD_SPARCV9 11 /* Old version of PowerPC, this should be removed shortly. */ #define EM_PPC_OLD 17 /* Cygnus ARC ELF backend. Written in the absence of an ABI. */ #define EM_CYGNUS_ARC 0x9040 /* Cygnus M32R ELF backend. Written in the absence of an ABI. */ #define EM_CYGNUS_M32R 0x9041 /* Alpha backend magic number. Written in the absence of an ABI. */ //#define EM_ALPHA 0x9026 /* D10V backend magic number. Written in the absence of an ABI. */ #define EM_CYGNUS_D10V 0x7650 /* D30V backend magic number. Written in the absence of an ABI. */ #define EM_CYGNUS_D30V 0x7676 /* V850 backend magic number. Written in the absense of an ABI. */ #define EM_CYGNUS_V850 0x9080 /* mn10200 and mn10300 backend magic numbers. Written in the absense of an ABI. */ #define EM_CYGNUS_MN10200 0xdead #define EM_CYGNUS_MN10300 0xbeef /* FR30 magic number - no EABI available. */ #define EM_CYGNUS_FR30 0x3330 /* AVR magic number Written in the absense of an ABI. */ #define EM_AVR 0x1057 // ------------------------------------------------------------------------- /* Version */ #define EV_NONE 0 /* Invalid */ #define EV_CURRENT 1 /* Current */ #define EV_NUM 2 /* number of versions */ // ------------------------------------------------------------------------- /* Section Header */ typedef struct { Elf32_Word sh_name; /* name - index into section header string table section */ Elf32_Word sh_type; /* type */ Elf32_Word sh_flags; /* flags */ Elf32_Addr sh_addr; /* address */ Elf32_Off sh_offset; /* file offset */ Elf32_Word sh_size; /* section size */ Elf32_Word sh_link; /* section header table index link */ Elf32_Word sh_info; /* extra information */ Elf32_Word sh_addralign; /* address alignment */ Elf32_Word sh_entsize; /* section entry size */ } Elf32_Shdr; typedef struct { Elf64_Word sh_name; /* section name */ Elf64_Word sh_type; /* section type */ Elf64_Xword sh_flags; /* section flags */ Elf64_Addr sh_addr; /* virtual address */ Elf64_Off sh_offset; /* file offset */ Elf64_Xword sh_size; /* section size */ Elf64_Word sh_link; /* link to another */ Elf64_Word sh_info; /* misc info */ Elf64_Xword sh_addralign; /* memory alignment */ Elf64_Xword sh_entsize; /* table entry size */ } Elf64_Shdr; // ------------------------------------------------------------------------- /* Special Section Indexes */ #define SHN_UNDEF 0 /* undefined */ #define SHN_LORESERVE 0xff00 /* lower bounds of reserved indexes */ #define SHN_LOPROC 0xff00 /* reserved range for processor */ #define SHN_HIPROC 0xff1f /* specific section indexes */ #define SHN_LOOS 0xff20 /* reserved range for operating */ #define SHN_HIOS 0xff3f /* system specific section indexes */ #define SHN_ABS 0xfff1 /* absolute value */ #define SHN_COMMON 0xfff2 /* common symbol */ #define SHN_XINDEX 0xffff /* escape value for oversize index */ #define SHN_HIRESERVE 0xffff /* upper bounds of reserved indexes */ // ------------------------------------------------------------------------- /* sh_type */ #define SHT_NULL 0 /* inactive */ #define SHT_PROGBITS 1 /* program defined information */ #define SHT_SYMTAB 2 /* symbol table section */ #define SHT_STRTAB 3 /* string table section */ #define SHT_RELA 4 /* relocation section with addends*/ #define SHT_HASH 5 /* symbol hash table section */ #define SHT_DYNAMIC 6 /* dynamic section */ #define SHT_NOTE 7 /* note section */ #define SHT_NOBITS 8 /* no space section */ #define SHT_REL 9 /* relation section without addends */ #define SHT_SHLIB 10 /* reserved - purpose unknown */ #define SHT_DYNSYM 11 /* dynamic symbol table section */ #define SHT_INIT_ARRAY 14 /* init procedure array */ #define SHT_FINI_ARRAY 15 /* fini procedure array */ #define SHT_PREINIT_ARRAY 16 /* preinit procedure array */ #define SHT_GROUP 17 /* section group */ #define SHT_SYMTAB_SHNDX 18 /* oversize index table */ #define SHT_NUM 19 /* number of section types */ #define SHT_LOOS 0x60000000 /* reserved range for O/S */ #define SHT_HIOS 0x6fffffff /* specific section header types */ #define SHT_LOPROC 0x70000000 /* reserved range for processor */ #define SHT_HIPROC 0x7fffffff /* specific section header types */ #define SHT_LOUSER 0x80000000 /* reserved range for application */ #define SHT_HIUSER 0xffffffff /* specific indexes */ // ------------------------------------------------------------------------- /* Section names */ #define ELF_BSS ".bss" /* uninitialized data */ #define ELF_DATA ".data" /* initialized data */ #define ELF_DEBUG ".debug" /* debug */ #define ELF_DYNAMIC ".dynamic" /* dynamic linking information */ #define ELF_DYNSTR ".dynstr" /* dynamic string table */ #define ELF_DYNSYM ".dynsym" /* dynamic symbol table */ #define ELF_FINI ".fini" /* termination code */ #define ELF_GOT ".got" /* global offset table */ #define ELF_HASH ".hash" /* symbol hash table */ #define ELF_INIT ".init" /* initialization code */ #define ELF_REL_DATA ".rel.data" /* relocation data */ #define ELF_REL_FINI ".rel.fini" /* relocation termination code */ #define ELF_REL_INIT ".rel.init" /* relocation initialization code */ #define ELF_REL_DYN ".rel.dyn" /* relocaltion dynamic link info */ #define ELF_REL_RODATA ".rel.rodata" /* relocation read-only data */ #define ELF_REL_TEXT ".rel.text" /* relocation code */ #define ELF_RODATA ".rodata" /* read-only data */ #define ELF_SHSTRTAB ".shstrtab" /* section header string table */ #define ELF_STRTAB ".strtab" /* string table */ #define ELF_SYMTAB ".symtab" /* symbol table */ #define ELF_TEXT ".text" /* code */ // ------------------------------------------------------------------------- /* Section Attribute Flags - sh_flags */ #define SHF_WRITE 0x001 /* Writable */ #define SHF_ALLOC 0x002 /* occupies memory */ #define SHF_EXECINSTR 0x004 /* executable */ #define SHF_MERGE 0x010 /* merge data */ #define SHF_STRINGS 0x020 /* contains strings */ #define SHF_INFO_LINK 0x040 /* link in sh_info field */ #define SHF_LINK_ORDER 0x080 /* preserve link order */ #define SHF_OS_NONCONFORMING 0x100 /* special OS-specific */ /* processing needed */ #define SHF_GROUP 0x200 /* member of group */ #define SHF_MASKOS 0x0ff00000 /* reserved bits for OS */ /* specific section attributes */ #define SHF_MASKPROC 0xf0000000 /* reserved bits for processor */ /* specific section attributes */ // ------------------------------------------------------------------------- /* Symbol Table Entry */ typedef struct { Elf32_Word st_name; /* name - index into string table */ Elf32_Addr st_value; /* symbol value */ Elf32_Word st_size; /* symbol size */ unsigned char st_info; /* type and binding */ unsigned char st_other; /* visibility */ Elf32_Half st_shndx; /* section header index */ } Elf32_Sym; typedef struct { Elf64_Word st_name; /* Symbol name index in str table */ unsigned char st_info; /* type / binding attrs */ unsigned char st_other; /* visibility */ Elf64_Half st_shndx; /* section index of symbol */ Elf64_Addr st_value; /* value of symbol */ Elf64_Xword st_size; /* size of symbol */ } Elf64_Sym; // ------------------------------------------------------------------------- /* Symbol table index */ #define STN_UNDEF 0 /* undefined */ /* Extract symbol info - st_info */ #define ELF32_ST_BIND(x) ((x) >> 4) #define ELF32_ST_TYPE(x) (((unsigned int) x) & 0xf) #define ELF32_ST_INFO(b,t) (((b) << 4) + ((t) & 0xf)) #define ELF64_ST_BIND(x) ((x) >> 4) #define ELF64_ST_TYPE(x) (((unsigned int) x) & 0xf) #define ELF64_ST_INFO(b,t) (((b) << 4) + ((t) & 0xf)) #define ELF32_ST_VISIBILITY(o) ((o)&0x3) #define ELF64_ST_VISIBILITY(o) ((o)&0x3) // ------------------------------------------------------------------------- /* Symbol Binding - ELF32_ST_BIND - st_info */ #define STB_LOCAL 0 /* Local symbol */ #define STB_GLOBAL 1 /* Global symbol */ #define STB_WEAK 2 /* like global - lower precedence */ #define STB_NUM 3 /* number of symbol bindings */ #define STB_LOOS 10 /* reserved range for OS */ #define STB_HIOS 12 /* specific symbol bindings */ #define STB_LOPROC 13 /* reserved range for processor */ #define STB_HIPROC 15 /* specific symbol bindings */ // ------------------------------------------------------------------------- /* Symbol type - ELF32_ST_TYPE - st_info */ #define STT_NOTYPE 0 /* not specified */ #define STT_OBJECT 1 /* data object */ #define STT_FUNC 2 /* function */ #define STT_SECTION 3 /* section */ #define STT_FILE 4 /* file */ #define STT_COMMON 5 /* common block */ #define STT_NUM 6 /* number of symbol types */ #define STT_LOOS 10 /* reserved range for OS */ #define STT_HIOS 12 /* specific symbol types */ #define STT_LOPROC 13 /* reserved range for processor */ #define STT_HIPROC 15 /* specific symbol types */ // ------------------------------------------------------------------------- // symbol visibility in st_other #define STV_DEFAULT 0 /* default to binding type */ #define STV_INTERNAL 1 /* processor specific */ #define STV_HIDDEN 2 /* invisible */ #define STV_PROTECTED 3 /* non-premptable */ // ------------------------------------------------------------------------- // 32 bit relocation records /* Relocation entry with implicit addend */ typedef struct { Elf32_Addr r_offset; /* offset of relocation */ Elf32_Word r_info; /* symbol table index and type */ } Elf32_Rel; /* Relocation entry with explicit addend */ typedef struct { Elf32_Addr r_offset; /* offset of relocation */ Elf32_Word r_info; /* symbol table index and type */ Elf32_Sword r_addend; } Elf32_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)) // ------------------------------------------------------------------------- // 64 bit equivalents of above structures and macros. typedef struct { Elf64_Addr r_offset; /* where to do it */ Elf64_Xword r_info; /* index & type of relocation */ } Elf64_Rel; typedef struct { Elf64_Addr r_offset; /* where to do it */ Elf64_Xword r_info; /* index & type of relocation */ Elf64_Sxword r_addend; /* adjustment value */ } Elf64_RelA; #define ELF64_R_SYM(info) ((info) >> 32) #define ELF64_R_TYPE(info) ((info) & 0xFFFFFFFF) #define ELF64_R_INFO(s,t) (((s) << 32) + (u_int32_t)(t)) // ------------------------------------------------------------------------- /* Program Header */ typedef struct { Elf32_Word p_type; /* segment type */ Elf32_Off p_offset; /* segment offset */ Elf32_Addr p_vaddr; /* virtual address of segment */ Elf32_Addr p_paddr; /* physical address - ignored? */ Elf32_Word p_filesz; /* number of bytes in file for seg. */ Elf32_Word p_memsz; /* number of bytes in mem. for seg. */ Elf32_Word p_flags; /* flags */ Elf32_Word p_align; /* memory alignment */ } Elf32_Phdr; typedef struct { Elf64_Word p_type; /* entry type */ Elf64_Word p_flags; /* flags */ Elf64_Off p_offset; /* offset */ Elf64_Addr p_vaddr; /* virtual address */ Elf64_Addr p_paddr; /* physical address */ Elf64_Xword p_filesz; /* file size */ Elf64_Xword p_memsz; /* memory size */ Elf64_Xword p_align; /* memory & file alignment */ } Elf64_Phdr; // ------------------------------------------------------------------------- /* Segment types - p_type */ #define PT_NULL 0 /* unused */ #define PT_LOAD 1 /* loadable segment */ #define PT_DYNAMIC 2 /* dynamic linking section */ #define PT_INTERP 3 /* the RTLD */ #define PT_NOTE 4 /* auxiliary information */ #define PT_SHLIB 5 /* reserved - purpose undefined */ #define PT_PHDR 6 /* program header */ #define PT_NUM 7 /* Number of segment types */ #define PT_LOOS 0x60000000 /* reserved range for OS */ #define PT_HIOS 0x6fffffff /* specific segment types */ #define PT_LOPROC 0x70000000 /* reserved range for processor */ #define PT_HIPROC 0x7fffffff /* specific segment types */ // ------------------------------------------------------------------------- /* Segment flags - p_flags */ #define PF_X 0x1 /* Executable */ #define PF_W 0x2 /* Writable */ #define PF_R 0x4 /* Readable */ #define PF_MASKOS 0x0ff00000 /* reserved bits for OS */ /* specific segment flags */ #define PF_MASKPROC 0xf0000000 /* reserved bits for processor */ /* specific segment flags */ // ------------------------------------------------------------------------- /* Dynamic structure */ typedef struct { Elf32_Sword d_tag; /* controls meaning of d_val */ union { Elf32_Word d_val; /* Multiple meanings - see d_tag */ Elf32_Addr d_ptr; /* program virtual address */ } d_un; } Elf32_Dyn; extern Elf32_Dyn _DYNAMIC[]; /* XXX not 64-bit clean */ typedef struct { Elf64_Sxword d_tag; /* controls meaning of d_val */ union { Elf64_Xword d_val; Elf64_Addr d_ptr; } d_un; } Elf64_Dyn; // ------------------------------------------------------------------------- /* Dynamic Array Tags - d_tag */ #define DT_NULL 0 /* marks end of _DYNAMIC array */ #define DT_NEEDED 1 /* string table offset of needed lib */ #define DT_PLTRELSZ 2 /* size of relocation entries in PLT */ #define DT_PLTGOT 3 /* address PLT/GOT */ #define DT_HASH 4 /* address of symbol hash table */ #define DT_STRTAB 5 /* address of string table */ #define DT_SYMTAB 6 /* address of symbol table */ #define DT_RELA 7 /* address of relocation table */ #define DT_RELASZ 8 /* size of relocation table */ #define DT_RELAENT 9 /* size of relocation entry */ #define DT_STRSZ 10 /* size of string table */ #define DT_SYMENT 11 /* size of symbol table entry */ #define DT_INIT 12 /* address of initialization func. */ #define DT_FINI 13 /* address of termination function */ #define DT_SONAME 14 /* string table offset of shared obj */ #define DT_RPATH 15 /* string table offset of library search path */ #define DT_SYMBOLIC 16 /* start sym search in shared obj. */ #define DT_REL 17 /* address of rel. tbl. w addends */ #define DT_RELSZ 18 /* size of DT_REL relocation table */ #define DT_RELENT 19 /* size of DT_REL relocation entry */ #define DT_PLTREL 20 /* PLT referenced relocation entry */ #define DT_DEBUG 21 /* bugger */ #define DT_TEXTREL 22 /* Allow rel. mod. to unwritable seg */ #define DT_JMPREL 23 /* add. of PLT's relocation entries */ #define DT_BIND_NOW 24 /* Bind now regardless of env setting */ #define DT_INIT_ARRAY 25 /* init array address */ #define DT_FINI_ARRAY 26 /* fini array address */ #define DT_INIT_ARRAYSZ 27 /* init array size */ #define DT_FINI_ARRAYSZ 28 /* fini array size */ #define DT_RUNPATH 29 /* library search path */ #define DT_FLAGS 30 /* flags */ #define DT_ENCODING 32 /* encoding rules start here */ #define DT_PREINIT_ARRAY 32 /* preinit array address */ #define DT_PREINIT_ARRAYSZ 33 /* preinit array size */ #define DT_NUM 26 /* Number used. */ #define DT_LOOS 0x60000000 /* reserved range for OS */ #define DT_HIOS 0x6fffffff /* specific dynamic array tags */ #define DT_LOPROC 0x70000000 /* reserved range for processor */ #define DT_HIPROC 0x7fffffff /* specific dynamic array tags */ // ------------------------------------------------------------------------- // Values for DT_FLAGS entry #define DF_ORIGIN 0x1 /* Uses $ORIGIN substitution string */ #define DF_SYMBOLIC 0x2 /* search for symbols here first */ #define DF_TEXTREL 0x4 /* text may be relocatable */ #define DF_BIND_NOW 0x8 /* bind references now, dammit */ // ------------------------------------------------------------------------- /* Note Definitions */ typedef struct { Elf32_Word namesz; Elf32_Word descsz; Elf32_Word type; } Elf32_Note; typedef struct { Elf64_Word namesz; Elf64_Word descsz; Elf64_Word type; } Elf64_Note; // ------------------------------------------------------------------------- // Hash table structure // The same structure is used by both 32 and 64 bit formats typedef struct { Elf32_Word nbucket; /* number of buckets */ Elf32_Word nchain; /* number of chains */ /* The buckets follow this structure in memory and the chains follow those. */ } Elf_Hash; // ------------------------------------------------------------------------- #endif // ifndef CYGONCE_REDBOOT_ELF_H // EOF elf.h
Go to most recent revision | Compare with Previous | Blame | View Log