1 // elfcpp_internal.h -- internals for elfcpp -*- C++ -*- 2 3 // Copyright (C) 2006-2016 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of elfcpp. 7 8 // This program is free software; you can redistribute it and/or 9 // modify it under the terms of the GNU Library General Public License 10 // as published by the Free Software Foundation; either version 2, or 11 // (at your option) any later version. 12 13 // In addition to the permissions in the GNU Library General Public 14 // License, the Free Software Foundation gives you unlimited 15 // permission to link the compiled version of this file into 16 // combinations with other programs, and to distribute those 17 // combinations without any restriction coming from the use of this 18 // file. (The Library Public License restrictions do apply in other 19 // respects; for example, they cover modification of the file, and 20 /// distribution when not linked into a combined executable.) 21 22 // This program is distributed in the hope that it will be useful, but 23 // WITHOUT ANY WARRANTY; without even the implied warranty of 24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 25 // Library General Public License for more details. 26 27 // You should have received a copy of the GNU Library General Public 28 // License along with this program; if not, write to the Free Software 29 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 30 // 02110-1301, USA. 31 32 // This is included by elfcpp.h, the external interface, but holds 33 // information which we want to keep private. 34 35 #ifndef ELFCPP_INTERNAL_H 36 #define ELFCPP_INTERNAL_H 37 38 namespace elfcpp 39 { 40 41 namespace internal 42 { 43 44 // The ELF file header. 45 46 template<int size> 47 struct Ehdr_data 48 { 49 unsigned char e_ident[EI_NIDENT]; 50 Elf_Half e_type; 51 Elf_Half e_machine; 52 Elf_Word e_version; 53 typename Elf_types<size>::Elf_Addr e_entry; 54 typename Elf_types<size>::Elf_Off e_phoff; 55 typename Elf_types<size>::Elf_Off e_shoff; 56 Elf_Word e_flags; 57 Elf_Half e_ehsize; 58 Elf_Half e_phentsize; 59 Elf_Half e_phnum; 60 Elf_Half e_shentsize; 61 Elf_Half e_shnum; 62 Elf_Half e_shstrndx; 63 }; 64 65 // An ELF section header. 66 67 template<int size> 68 struct Shdr_data 69 { 70 Elf_Word sh_name; 71 Elf_Word sh_type; 72 typename Elf_types<size>::Elf_WXword sh_flags; 73 typename Elf_types<size>::Elf_Addr sh_addr; 74 typename Elf_types<size>::Elf_Off sh_offset; 75 typename Elf_types<size>::Elf_WXword sh_size; 76 Elf_Word sh_link; 77 Elf_Word sh_info; 78 typename Elf_types<size>::Elf_WXword sh_addralign; 79 typename Elf_types<size>::Elf_WXword sh_entsize; 80 }; 81 82 // An ELF compression header. 83 84 template<int size> 85 struct Chdr_data; 86 87 template<> 88 struct Chdr_data<32> 89 { 90 Elf_Word ch_type; 91 Elf_Word ch_size; 92 Elf_Word ch_addralign; 93 }; 94 95 template<> 96 struct Chdr_data<64> 97 { 98 Elf_Word ch_type; 99 Elf_Word ch_reserved; 100 Elf_Xword ch_size; 101 Elf_Xword ch_addralign; 102 }; 103 104 // An ELF segment header. We use template specialization for the 105 // 32-bit and 64-bit versions because the fields are in a different 106 // order. 107 108 template<int size> 109 struct Phdr_data; 110 111 template<> 112 struct Phdr_data<32> 113 { 114 Elf_Word p_type; 115 Elf_types<32>::Elf_Off p_offset; 116 Elf_types<32>::Elf_Addr p_vaddr; 117 Elf_types<32>::Elf_Addr p_paddr; 118 Elf_Word p_filesz; 119 Elf_Word p_memsz; 120 Elf_Word p_flags; 121 Elf_Word p_align; 122 }; 123 124 template<> 125 struct Phdr_data<64> 126 { 127 Elf_Word p_type; 128 Elf_Word p_flags; 129 Elf_types<64>::Elf_Off p_offset; 130 Elf_types<64>::Elf_Addr p_vaddr; 131 Elf_types<64>::Elf_Addr p_paddr; 132 Elf_Xword p_filesz; 133 Elf_Xword p_memsz; 134 Elf_Xword p_align; 135 }; 136 137 // An ELF symbol table entry. We use template specialization for the 138 // 32-bit and 64-bit versions because the fields are in a different 139 // order. 140 141 template<int size> 142 struct Sym_data; 143 144 template<> 145 struct Sym_data<32> 146 { 147 Elf_Word st_name; 148 Elf_types<32>::Elf_Addr st_value; 149 Elf_Word st_size; 150 unsigned char st_info; 151 unsigned char st_other; 152 Elf_Half st_shndx; 153 }; 154 155 template<> 156 struct Sym_data<64> 157 { 158 Elf_Word st_name; 159 unsigned char st_info; 160 unsigned char st_other; 161 Elf_Half st_shndx; 162 Elf_types<64>::Elf_Addr st_value; 163 Elf_Xword st_size; 164 }; 165 166 // ELF relocation table entries. 167 168 template<int size> 169 struct Rel_data 170 { 171 typename Elf_types<size>::Elf_Addr r_offset; 172 typename Elf_types<size>::Elf_WXword r_info; 173 }; 174 175 template<int size> 176 struct Rela_data 177 { 178 typename Elf_types<size>::Elf_Addr r_offset; 179 typename Elf_types<size>::Elf_WXword r_info; 180 typename Elf_types<size>::Elf_Swxword r_addend; 181 }; 182 183 template<int size> 184 struct Relr_data 185 { 186 typename Elf_types<size>::Elf_WXword r_data; 187 }; 188 189 // MIPS-64 has a non-standard layout for relocations. 190 191 struct Mips64_rel_data 192 { 193 Elf_types<64>::Elf_Addr r_offset; 194 Elf_Word r_sym; 195 unsigned char r_ssym; 196 unsigned char r_type3; 197 unsigned char r_type2; 198 unsigned char r_type; 199 }; 200 201 struct Mips64_rela_data 202 { 203 Elf_types<64>::Elf_Addr r_offset; 204 Elf_Word r_sym; 205 unsigned char r_ssym; 206 unsigned char r_type3; 207 unsigned char r_type2; 208 unsigned char r_type; 209 Elf_types<64>::Elf_Swxword r_addend; 210 }; 211 212 // An entry in the ELF SHT_DYNAMIC section aka PT_DYNAMIC segment. 213 214 template<int size> 215 struct Dyn_data 216 { 217 typename Elf_types<size>::Elf_Swxword d_tag; 218 typename Elf_types<size>::Elf_WXword d_val; 219 }; 220 221 // An entry in a SHT_GNU_verdef section. This structure is the same 222 // in 32-bit and 64-bit ELF files. 223 224 struct Verdef_data 225 { 226 // Version number of structure (VER_DEF_*). 227 Elf_Half vd_version; 228 // Bit flags (VER_FLG_*). 229 Elf_Half vd_flags; 230 // Version index. 231 Elf_Half vd_ndx; 232 // Number of auxiliary Verdaux entries. 233 Elf_Half vd_cnt; 234 // Hash of name. 235 Elf_Word vd_hash; 236 // Byte offset to first Verdaux entry. 237 Elf_Word vd_aux; 238 // Byte offset to next Verdef entry. 239 Elf_Word vd_next; 240 }; 241 242 // An auxiliary entry in a SHT_GNU_verdef section. This structure is 243 // the same in 32-bit and 64-bit ELF files. 244 245 struct Verdaux_data 246 { 247 // Offset in string table of version name. 248 Elf_Word vda_name; 249 // Byte offset to next Verdaux entry. 250 Elf_Word vda_next; 251 }; 252 253 // An entry in a SHT_GNU_verneed section. This structure is the same 254 // in 32-bit and 64-bit ELF files. 255 256 struct Verneed_data 257 { 258 // Version number of structure (VER_NEED_*). 259 Elf_Half vn_version; 260 // Number of auxiliary Vernaux entries. 261 Elf_Half vn_cnt; 262 // Offset in string table of library name. 263 Elf_Word vn_file; 264 // Byte offset to first Vernaux entry. 265 Elf_Word vn_aux; 266 // Byt eoffset to next Verneed entry. 267 Elf_Word vn_next; 268 }; 269 270 // An auxiliary entry in a SHT_GNU_verneed section. This structure is 271 // the same in 32-bit and 64-bit ELF files. 272 273 struct Vernaux_data 274 { 275 // Hash of dependency name. 276 Elf_Word vna_hash; 277 // Bit flags (VER_FLG_*). 278 Elf_Half vna_flags; 279 // Version index used in SHT_GNU_versym entries. 280 Elf_Half vna_other; 281 // Offset in string table of version name. 282 Elf_Word vna_name; 283 // Byte offset to next Vernaux entry. 284 Elf_Word vna_next; 285 }; 286 287 } // End namespace internal. 288 289 } // End namespace elfcpp. 290 291 #endif // !defined(ELFCPP_INTERNAL_H) 292