1 // copyright (c) 2017-2021 hors<horsicq@gmail.com> 2 // 3 // Permission is hereby granted, free of charge, to any person obtaining a copy 4 // of this software and associated documentation files (the "Software"), to deal 5 // in the Software without restriction, including without limitation the rights 6 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 // copies of the Software, and to permit persons to whom the Software is 8 // furnished to do so, subject to the following conditions: 9 10 // The above copyright notice and this permission notice shall be included in all 11 // copies or substantial portions of the Software. 12 13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 19 // SOFTWARE. 20 // 21 #include "elf_defs.h" 22 23 namespace N_Elf_Ehdr 24 { 25 const FW_DEF::HEADER_RECORD records32[]= 26 { 27 {ei_mag, "ei_mag", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+0, 4, "uint32 LE", FW_DEF::VAL_TYPE_DATA}, 28 {ei_class, "ei_class", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+4, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 29 {ei_data, "ei_data", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+5, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 30 {ei_version, "ei_version", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+6, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 31 {ei_osabi, "ei_osabi", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+7, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 32 {ei_abiversion, "ei_abiversion", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+8, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 33 {ei_pad_0, "ei_pad_0", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+9, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 34 {ei_pad_1, "ei_pad_1", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+10, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 35 {ei_pad_2, "ei_pad_2", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+11, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 36 {ei_pad_3, "ei_pad_3", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+12, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 37 {ei_pad_4, "ei_pad_4", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+13, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 38 {ei_pad_5, "ei_pad_5", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+14, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 39 {ei_pad_6, "ei_pad_6", offsetof(XELF_DEF::Elf32_Ehdr,e_ident)+15, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 40 {e_type, "e_type", offsetof(XELF_DEF::Elf32_Ehdr,e_type), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 41 {e_machine, "e_machine", offsetof(XELF_DEF::Elf32_Ehdr,e_machine), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 42 {e_version, "e_version", offsetof(XELF_DEF::Elf32_Ehdr,e_version), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 43 {e_entry, "e_entry", offsetof(XELF_DEF::Elf32_Ehdr,e_entry), 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 44 {e_phoff, "e_phoff", offsetof(XELF_DEF::Elf32_Ehdr,e_phoff), 4, "Elf32_Off", FW_DEF::VAL_TYPE_RELADDRESS}, 45 {e_shoff, "e_shoff", offsetof(XELF_DEF::Elf32_Ehdr,e_shoff), 4, "Elf32_Off", FW_DEF::VAL_TYPE_RELADDRESS}, 46 {e_flags, "e_flags", offsetof(XELF_DEF::Elf32_Ehdr,e_flags), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 47 {e_ehsize, "e_ehsize", offsetof(XELF_DEF::Elf32_Ehdr,e_ehsize), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 48 {e_phentsize, "e_phentsize", offsetof(XELF_DEF::Elf32_Ehdr,e_phentsize), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 49 {e_phnum, "e_phnum", offsetof(XELF_DEF::Elf32_Ehdr,e_phnum), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 50 {e_shentsize, "e_shentsize", offsetof(XELF_DEF::Elf32_Ehdr,e_shentsize), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 51 {e_shnum, "e_shnum", offsetof(XELF_DEF::Elf32_Ehdr,e_shnum), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 52 {e_shstrndx, "e_shstrndx", offsetof(XELF_DEF::Elf32_Ehdr,e_shstrndx), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 53 }; 54 const FW_DEF::HEADER_RECORD records64[]= 55 { 56 {ei_mag, "ei_mag", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+0, 4, "uint32 LE", FW_DEF::VAL_TYPE_DATA}, 57 {ei_class, "ei_class", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+4, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 58 {ei_data, "ei_data", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+5, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 59 {ei_version, "ei_version", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+6, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 60 {ei_osabi, "ei_osabi", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+7, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 61 {ei_abiversion, "ei_abiversion", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+8, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 62 {ei_pad_0, "ei_pad_0", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+9, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 63 {ei_pad_1, "ei_pad_1", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+10, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 64 {ei_pad_2, "ei_pad_2", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+11, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 65 {ei_pad_3, "ei_pad_3", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+12, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 66 {ei_pad_4, "ei_pad_4", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+13, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 67 {ei_pad_5, "ei_pad_5", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+14, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 68 {ei_pad_6, "ei_pad_6", offsetof(XELF_DEF::Elf64_Ehdr,e_ident)+15, 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 69 {e_type, "e_type", offsetof(XELF_DEF::Elf64_Ehdr,e_type), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 70 {e_machine, "e_machine", offsetof(XELF_DEF::Elf64_Ehdr,e_machine), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 71 {e_version, "e_version", offsetof(XELF_DEF::Elf64_Ehdr,e_version), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 72 {e_entry, "e_entry", offsetof(XELF_DEF::Elf64_Ehdr,e_entry), 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 73 {e_phoff, "e_phoff", offsetof(XELF_DEF::Elf64_Ehdr,e_phoff), 8, "Elf64_Off", FW_DEF::VAL_TYPE_RELADDRESS}, 74 {e_shoff, "e_shoff", offsetof(XELF_DEF::Elf64_Ehdr,e_shoff), 8, "Elf64_Off", FW_DEF::VAL_TYPE_RELADDRESS}, 75 {e_flags, "e_flags", offsetof(XELF_DEF::Elf64_Ehdr,e_flags), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 76 {e_ehsize, "e_ehsize", offsetof(XELF_DEF::Elf64_Ehdr,e_ehsize), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 77 {e_phentsize, "e_phentsize", offsetof(XELF_DEF::Elf64_Ehdr,e_phentsize), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 78 {e_phnum, "e_phnum", offsetof(XELF_DEF::Elf64_Ehdr,e_phnum), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 79 {e_shentsize, "e_shentsize", offsetof(XELF_DEF::Elf64_Ehdr,e_shentsize), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 80 {e_shnum, "e_shnum", offsetof(XELF_DEF::Elf64_Ehdr,e_shnum), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 81 {e_shstrndx, "e_shstrndx", offsetof(XELF_DEF::Elf64_Ehdr,e_shstrndx), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 82 }; 83 } 84 85 namespace N_Elf_Shdr 86 { 87 const FW_DEF::HEADER_RECORD records32[]= 88 { 89 {sh_name, "sh_name", offsetof(XELF_DEF::Elf32_Shdr,sh_name), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 90 {sh_type, "sh_type", offsetof(XELF_DEF::Elf32_Shdr,sh_type), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 91 {sh_flags, "sh_flags", offsetof(XELF_DEF::Elf32_Shdr,sh_flags), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 92 {sh_addr, "sh_addr", offsetof(XELF_DEF::Elf32_Shdr,sh_addr), 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 93 {sh_offset, "sh_offset", offsetof(XELF_DEF::Elf32_Shdr,sh_offset), 4, "Elf32_Off", FW_DEF::VAL_TYPE_OFFSET}, 94 {sh_size, "sh_size", offsetof(XELF_DEF::Elf32_Shdr,sh_size), 4, "Elf32_Word", FW_DEF::VAL_TYPE_SIZE}, 95 {sh_link, "sh_link", offsetof(XELF_DEF::Elf32_Shdr,sh_link), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 96 {sh_info, "sh_info", offsetof(XELF_DEF::Elf32_Shdr,sh_info), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 97 {sh_addralign, "sh_addralign", offsetof(XELF_DEF::Elf32_Shdr,sh_addralign), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 98 {sh_entsize, "sh_entsize", offsetof(XELF_DEF::Elf32_Shdr,sh_entsize), 4, "Elf32_Word", FW_DEF::VAL_TYPE_SIZE}, 99 }; 100 const FW_DEF::HEADER_RECORD records64[]= 101 { 102 {sh_name, "sh_name", offsetof(XELF_DEF::Elf64_Shdr,sh_name), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 103 {sh_type, "sh_type", offsetof(XELF_DEF::Elf64_Shdr,sh_type), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 104 {sh_flags, "sh_flags", offsetof(XELF_DEF::Elf64_Shdr,sh_flags), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 105 {sh_addr, "sh_addr", offsetof(XELF_DEF::Elf64_Shdr,sh_addr), 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 106 {sh_offset, "sh_offset", offsetof(XELF_DEF::Elf64_Shdr,sh_offset), 8, "Elf64_Off", FW_DEF::VAL_TYPE_OFFSET}, 107 {sh_size, "sh_size", offsetof(XELF_DEF::Elf64_Shdr,sh_size), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_SIZE}, 108 {sh_link, "sh_link", offsetof(XELF_DEF::Elf64_Shdr,sh_link), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 109 {sh_info, "sh_info", offsetof(XELF_DEF::Elf64_Shdr,sh_info), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 110 {sh_addralign, "sh_addralign", offsetof(XELF_DEF::Elf64_Shdr,sh_addralign), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 111 {sh_entsize, "sh_entsize", offsetof(XELF_DEF::Elf64_Shdr,sh_entsize), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_SIZE}, 112 }; 113 } 114 115 namespace N_Elf_Phdr32 116 { 117 const FW_DEF::HEADER_RECORD records[]= 118 { 119 {p_type, "p_type", offsetof(XELF_DEF::Elf32_Phdr,p_type), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 120 {p_offset, "p_offset", offsetof(XELF_DEF::Elf32_Phdr,p_offset), 4, "Elf32_Off", FW_DEF::VAL_TYPE_OFFSET}, 121 {p_vaddr, "p_vaddr", offsetof(XELF_DEF::Elf32_Phdr,p_vaddr), 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 122 {p_paddr, "p_paddr", offsetof(XELF_DEF::Elf32_Phdr,p_paddr), 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 123 {p_filesz, "p_filesz", offsetof(XELF_DEF::Elf32_Phdr,p_filesz), 4, "Elf32_Word", FW_DEF::VAL_TYPE_SIZE}, 124 {p_memsz, "p_memsz", offsetof(XELF_DEF::Elf32_Phdr,p_memsz), 4, "Elf32_Word", FW_DEF::VAL_TYPE_SIZE}, 125 {p_flags, "p_flags", offsetof(XELF_DEF::Elf32_Phdr,p_flags), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 126 {p_align, "p_align", offsetof(XELF_DEF::Elf32_Phdr,p_align), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 127 }; 128 } 129 130 namespace N_Elf_Phdr64 131 { 132 const FW_DEF::HEADER_RECORD records[]= 133 { 134 {p_type, "p_type", offsetof(XELF_DEF::Elf64_Phdr,p_type), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 135 {p_flags, "p_flags", offsetof(XELF_DEF::Elf64_Phdr,p_flags), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 136 {p_offset, "p_offset", offsetof(XELF_DEF::Elf64_Phdr,p_offset), 8, "Elf64_Off", FW_DEF::VAL_TYPE_OFFSET}, 137 {p_vaddr, "p_vaddr", offsetof(XELF_DEF::Elf64_Phdr,p_vaddr), 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 138 {p_paddr, "p_paddr", offsetof(XELF_DEF::Elf64_Phdr,p_paddr), 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 139 {p_filesz, "p_filesz", offsetof(XELF_DEF::Elf64_Phdr,p_filesz), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_SIZE}, 140 {p_memsz, "p_memsz", offsetof(XELF_DEF::Elf64_Phdr,p_memsz), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_SIZE}, 141 {p_align, "p_align", offsetof(XELF_DEF::Elf64_Phdr,p_align), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 142 }; 143 } 144 145 namespace N_Elf_DynamicArrayTags 146 { 147 const FW_DEF::HEADER_RECORD records32[]= 148 { 149 {d_tag, "d_tag", 0, 4, "Elf32_SWord", FW_DEF::VAL_TYPE_DATA}, 150 {d_value, "d_value", 4, 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 151 }; 152 const FW_DEF::HEADER_RECORD records64[]= 153 { 154 {d_tag, "d_tag", 0, 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 155 {d_value, "d_value", 8, 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 156 }; 157 } 158 159 namespace N_ELF_LIBRARIES 160 { 161 const FW_DEF::HEADER_RECORD records[]= 162 { 163 {library_name, QObject::tr("Library name"), 0, 0, "", FW_DEF::VAL_TYPE_DATA}, 164 }; 165 } 166 167 namespace N_ELF_INTERPRETER 168 { 169 const FW_DEF::HEADER_RECORD records[]= 170 { 171 {interpreter, QObject::tr("Interpreter"), 0, -1, "Ansi string", FW_DEF::VAL_TYPE_TEXT}, 172 }; 173 } 174 175 namespace N_ELF_NOTES 176 { 177 const FW_DEF::HEADER_RECORD records[]= 178 { 179 {type, QObject::tr("Type"), 0, -1, "", FW_DEF::VAL_TYPE_DATA}, 180 {name, QObject::tr("Name"), 0, -1, "", FW_DEF::VAL_TYPE_DATA}, 181 }; 182 } 183 184 namespace N_ELF_RUNPATH 185 { 186 const FW_DEF::HEADER_RECORD records[]= 187 { 188 {runpath, "runpath", 0, -1, "Ansi string", FW_DEF::VAL_TYPE_TEXT}, 189 }; 190 } 191 192 namespace N_Elf32_Sym 193 { 194 const FW_DEF::HEADER_RECORD records[]= 195 { 196 {st_name, "st_name", offsetof(XELF_DEF::Elf32_Sym,st_name), 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 197 {st_value, "st_value", offsetof(XELF_DEF::Elf32_Sym,st_value), 4, "Elf32_Addr", FW_DEF::VAL_TYPE_DATA}, 198 {st_size, "st_size", offsetof(XELF_DEF::Elf32_Sym,st_size), 4, "Elf32_Word", FW_DEF::VAL_TYPE_SIZE}, 199 {st_info, "st_info", offsetof(XELF_DEF::Elf32_Sym,st_info), 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 200 {st_other, "st_other", offsetof(XELF_DEF::Elf32_Sym,st_other), 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 201 {st_shndx, "st_shndx", offsetof(XELF_DEF::Elf32_Sym,st_shndx), 2, "Elf32_Half", FW_DEF::VAL_TYPE_DATA}, 202 }; 203 } 204 205 namespace N_Elf64_Sym 206 { 207 const FW_DEF::HEADER_RECORD records[]= 208 { 209 {st_name, "st_name", offsetof(XELF_DEF::Elf64_Sym,st_name), 4, "Elf64_Word", FW_DEF::VAL_TYPE_DATA}, 210 {st_info, "st_info", offsetof(XELF_DEF::Elf64_Sym,st_info), 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 211 {st_other, "st_other", offsetof(XELF_DEF::Elf64_Sym,st_other), 1, "unsigned char", FW_DEF::VAL_TYPE_DATA}, 212 {st_shndx, "st_shndx", offsetof(XELF_DEF::Elf64_Sym,st_shndx), 2, "Elf64_Half", FW_DEF::VAL_TYPE_DATA}, 213 {st_value, "st_value", offsetof(XELF_DEF::Elf64_Sym,st_value), 8, "Elf64_Addr", FW_DEF::VAL_TYPE_DATA}, 214 {st_size, "st_size", offsetof(XELF_DEF::Elf64_Sym,st_size), 8, "Elf64_Xword", FW_DEF::VAL_TYPE_SIZE}, 215 }; 216 } 217 218 namespace N_Elf_Rela 219 { 220 const FW_DEF::HEADER_RECORD records32[]= 221 { 222 {r_offset, "r_offset", 0, 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 223 {r_info, "r_info", 4, 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 224 {r_addend, "r_addend", 8, 4, "Elf32_Sword", FW_DEF::VAL_TYPE_DATA}, 225 }; 226 const FW_DEF::HEADER_RECORD records64[]= 227 { 228 {r_offset, "r_offset", 0, 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 229 {r_info, "r_info", 8, 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 230 {r_addend, "r_addend", 16, 8, "Elf64_Sxword", FW_DEF::VAL_TYPE_DATA}, 231 }; 232 } 233 234 namespace N_Elf_Rel 235 { 236 const FW_DEF::HEADER_RECORD records32[]= 237 { 238 {r_offset, "r_offset", 0, 4, "Elf32_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 239 {r_info, "r_info", 4, 4, "Elf32_Word", FW_DEF::VAL_TYPE_DATA}, 240 }; 241 const FW_DEF::HEADER_RECORD records64[]= 242 { 243 {r_offset, "r_offset", 0, 8, "Elf64_Addr", FW_DEF::VAL_TYPE_ADDRESS}, 244 {r_info, "r_info", 8, 8, "Elf64_Xword", FW_DEF::VAL_TYPE_DATA}, 245 }; 246 } 247