[163] | 1 | /* |
---|
| 2 | This file is part of Libelfpp. |
---|
| 3 | |
---|
| 4 | Libelfpp is free software: you can redistribute it and/or modify |
---|
| 5 | it under the terms of the GNU Lesser General Public License as |
---|
| 6 | published by the Free Software Foundation, either version 3 of the |
---|
| 7 | License, or (at your option) any later version. |
---|
| 8 | |
---|
| 9 | Libelfpp is distributed in the hope that it will be useful, but |
---|
| 10 | WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
---|
| 12 | General Public License for more details. |
---|
| 13 | |
---|
| 14 | You should have received a copy of the GNU Lesser General Public |
---|
| 15 | License along with Libelfpp. If not, see |
---|
| 16 | <http://www.gnu.org/licenses/>. |
---|
| 17 | |
---|
| 18 | Copyright (c) Alexandre Becoulet <alexandre.becoulet@free.fr> |
---|
| 19 | */ |
---|
| 20 | |
---|
| 21 | #include <stdexcept> |
---|
| 22 | #include <iostream> |
---|
| 23 | #include <cassert> |
---|
| 24 | #include <algorithm> |
---|
| 25 | #include <cstring> |
---|
| 26 | |
---|
| 27 | #include <dpp/foreach> |
---|
| 28 | |
---|
| 29 | #include <elfpp/access> |
---|
| 30 | #include <elfpp/object> |
---|
| 31 | #include <elfpp/section> |
---|
| 32 | #include <elfpp/symbol> |
---|
| 33 | #include <elfpp/reloc> |
---|
| 34 | #include <elfpp/segment> |
---|
| 35 | |
---|
| 36 | namespace elfpp |
---|
| 37 | { |
---|
| 38 | |
---|
| 39 | template <typename bits_t, int width> |
---|
| 40 | void elfn_access<bits_t, width>::load_symtab(object &obj) |
---|
| 41 | { |
---|
| 42 | section &table = obj.get_section(".symtab"); |
---|
| 43 | |
---|
| 44 | if (table.get_type() != SHT_SYMTAB) |
---|
| 45 | throw std::runtime_error("not a symbol table section"); |
---|
| 46 | |
---|
| 47 | // get symbol table content |
---|
| 48 | elf_sym_t *symtab = (elf_sym_t*)table.get_content(); |
---|
| 49 | size_t count = table.get_size() / sizeof (elf_sym_t); |
---|
| 50 | |
---|
| 51 | // get symbol string section |
---|
| 52 | section &strtab = *table.get_link(); |
---|
| 53 | const char *symstr = (char*)strtab.get_content(); |
---|
| 54 | |
---|
| 55 | // create symbol objects from table |
---|
| 56 | obj.symidx_.resize(count); |
---|
| 57 | |
---|
| 58 | for (unsigned int i = 1; i < count; i++) |
---|
| 59 | { |
---|
| 60 | unsigned int idx = swap(symtab[i].st_shndx); |
---|
| 61 | |
---|
| 62 | symbol *sym = new symbol(symstr + swap(symtab[i].st_name)); |
---|
| 63 | |
---|
| 64 | obj.symidx_[i] = sym; |
---|
| 65 | |
---|
| 66 | sym->set_value(swap(symtab[i].st_value)); |
---|
| 67 | sym->set_size(swap(symtab[i].st_size)); |
---|
| 68 | sym->set_info(symtab[i].st_info); |
---|
| 69 | sym->set_other(symtab[i].st_other); |
---|
| 70 | |
---|
| 71 | if (idx > 0 && idx < SHN_LORESERVE) |
---|
| 72 | { |
---|
| 73 | section *symsec = obj.secidx_.at(idx); |
---|
| 74 | if (!symsec) |
---|
| 75 | continue; |
---|
| 76 | |
---|
| 77 | sym->set_section(*symsec); |
---|
| 78 | symsec->add_symbol(*sym); |
---|
| 79 | |
---|
| 80 | if (obj.type_ != ET_REL) |
---|
| 81 | sym->set_value(sym->get_value() - symsec->get_vaddr()); |
---|
| 82 | |
---|
| 83 | if (symsec && sym->get_size() > 0 && symsec->get_type() != SHT_NOBITS) |
---|
| 84 | { |
---|
| 85 | if (symsec->get_size() < sym->get_value()) |
---|
| 86 | std::cerr << "elfpp: symbol value above section size " << sym->get_name() |
---|
| 87 | << ":" << std::hex << sym->get_value() << std::endl; |
---|
| 88 | // else |
---|
| 89 | // sym->set_content(symsec->get_content() + sym->get_value()); |
---|
| 90 | } |
---|
| 91 | } |
---|
| 92 | else |
---|
| 93 | { |
---|
| 94 | sym->set_section_ndx(idx); |
---|
| 95 | obj.add_symbol(*sym); |
---|
| 96 | } |
---|
| 97 | } |
---|
| 98 | |
---|
| 99 | // discard symbol table sections |
---|
| 100 | delete &table; |
---|
| 101 | delete &strtab; |
---|
| 102 | } |
---|
| 103 | |
---|
| 104 | template <typename bits_t, int width> |
---|
| 105 | void elfn_access<bits_t, width>::load_addend(const object &obj, reloc &r, const elf_rel_t *reltab, |
---|
| 106 | size_t count, int index, uint8_t *data) |
---|
| 107 | { |
---|
| 108 | // r->set_addend(rel_read(obj, type, sec->get_content() + ro)); |
---|
| 109 | uint64_t offset = swap(reltab[index].r_offset); |
---|
| 110 | r.set_offset(offset); |
---|
| 111 | |
---|
| 112 | switch (obj.machine_) |
---|
| 113 | { |
---|
| 114 | case EM_MIPS: |
---|
| 115 | switch (r.get_type()) |
---|
| 116 | { |
---|
| 117 | case R_MIPS_26: |
---|
| 118 | r.set_addend((swap(*(uint32_t*)(data + offset)) & 0x3ffffff) << 2); |
---|
| 119 | return; |
---|
| 120 | |
---|
| 121 | case R_MIPS_32: |
---|
| 122 | r.set_addend(swap(*(uint32_t*)(data + offset))); |
---|
| 123 | return; |
---|
| 124 | |
---|
| 125 | case R_MIPS_HI16: { |
---|
| 126 | int32_t value = (swap(*(uint32_t*)(data + offset)) & 0xffff) << 16; |
---|
| 127 | // get next LO16 relocation |
---|
| 128 | for (index++; index < (int)count && rel_type(swap(reltab[index].r_info)) != R_MIPS_LO16; index++) |
---|
| 129 | ; |
---|
| 130 | if (index != (int)count) |
---|
| 131 | { |
---|
| 132 | offset = swap(reltab[index].r_offset); |
---|
| 133 | value += (int16_t)swap(*(uint32_t*)(data + offset)); |
---|
| 134 | r.set_addend(value); |
---|
| 135 | } |
---|
| 136 | else |
---|
| 137 | { |
---|
| 138 | std::cerr << "elfpp: can not find matching LO16 relocation" << std::endl; |
---|
| 139 | } |
---|
| 140 | return; |
---|
| 141 | } |
---|
| 142 | |
---|
| 143 | case R_MIPS_LO16: { |
---|
| 144 | int32_t value = (int16_t)swap(*(uint32_t*)(data + offset)); |
---|
| 145 | // get prev HI16 relocation if any |
---|
| 146 | if (index > 0 && rel_type(swap(reltab[index - 1].r_info)) == R_MIPS_HI16) |
---|
| 147 | { |
---|
| 148 | offset = swap(reltab[index - 1].r_offset); |
---|
| 149 | value += (swap(*(uint32_t*)(data + offset)) & 0xffff) << 16; |
---|
| 150 | } |
---|
| 151 | r.set_addend(value); |
---|
| 152 | return; |
---|
| 153 | } |
---|
| 154 | |
---|
| 155 | default: ; |
---|
| 156 | } |
---|
| 157 | break; |
---|
| 158 | |
---|
| 159 | case EM_ARM: |
---|
| 160 | switch (r.get_type()) |
---|
| 161 | { |
---|
| 162 | case R_ARM_PC24: |
---|
| 163 | r.set_addend(((swap(*(uint32_t*)(data + offset)) & 0xffffff) << 2) + 8); |
---|
| 164 | return; |
---|
| 165 | |
---|
| 166 | case R_ARM_ABS32: |
---|
| 167 | r.set_addend(swap(*(uint32_t*)(data + offset))); |
---|
| 168 | return; |
---|
| 169 | |
---|
| 170 | default: ; |
---|
| 171 | } |
---|
| 172 | break; |
---|
| 173 | |
---|
| 174 | default: ; |
---|
| 175 | } |
---|
| 176 | |
---|
| 177 | std::cerr << "elfpp: unhandled relocation (machine=" << obj.machine_ |
---|
| 178 | << ", type=" << r.get_type() << ")" << std::endl; |
---|
| 179 | return; |
---|
| 180 | } |
---|
| 181 | |
---|
| 182 | template <typename bits_t, int width> |
---|
| 183 | void elfn_access<bits_t, width>::rel_write(const object &obj, enum reloc_e type, void *data, int64_t value) |
---|
| 184 | { |
---|
| 185 | uint32_t mask; |
---|
| 186 | |
---|
| 187 | switch (obj.machine_) |
---|
| 188 | { |
---|
| 189 | case EM_MIPS: |
---|
| 190 | switch (type) |
---|
| 191 | { |
---|
| 192 | case R_MIPS_26: |
---|
| 193 | mask = 0x3ffffff; |
---|
| 194 | if (value & 0x3) |
---|
| 195 | std::cerr << "elfpp: R_MIPS_26 relocation with 2 LSB set" << std::endl; |
---|
| 196 | value >>= 2; |
---|
| 197 | goto done; |
---|
| 198 | |
---|
| 199 | case R_MIPS_32: |
---|
| 200 | mask = 0xffffffff; |
---|
| 201 | goto done; |
---|
| 202 | |
---|
| 203 | case R_MIPS_HI16: |
---|
| 204 | mask = 0xffff; |
---|
| 205 | value >>= 16; |
---|
| 206 | goto done; |
---|
| 207 | |
---|
| 208 | case R_MIPS_LO16: |
---|
| 209 | mask = 0xffff; |
---|
| 210 | goto done; |
---|
| 211 | |
---|
| 212 | default: ; |
---|
| 213 | } |
---|
| 214 | break; |
---|
| 215 | |
---|
| 216 | case EM_ARM: |
---|
| 217 | switch (type) |
---|
| 218 | { |
---|
| 219 | case R_ARM_PC24: |
---|
| 220 | mask = 0x00ffffff; |
---|
| 221 | value = (value - 8) >> 2; |
---|
| 222 | goto done; |
---|
| 223 | |
---|
| 224 | case R_ARM_ABS32: |
---|
| 225 | mask = 0xffffffff; |
---|
| 226 | goto done; |
---|
| 227 | |
---|
| 228 | default: ; |
---|
| 229 | } |
---|
| 230 | break; |
---|
| 231 | |
---|
| 232 | default: ; |
---|
| 233 | } |
---|
| 234 | |
---|
| 235 | std::cerr << "elfpp: unhandled relocation (machine=" << obj.machine_ << ", type=" << type << ")" << std::endl; |
---|
| 236 | return; |
---|
| 237 | |
---|
| 238 | done: |
---|
| 239 | *(uint32_t*)data = swap(mask & value) | (*(uint32_t*)data & swap(~mask)); |
---|
| 240 | } |
---|
| 241 | |
---|
| 242 | template <typename bits_t, int width> |
---|
| 243 | void elfn_access<bits_t, width>::load_reltab(object &obj) |
---|
| 244 | { |
---|
| 245 | // load all reloaction table sections |
---|
| 246 | |
---|
| 247 | if (obj.type_ != ET_REL) |
---|
| 248 | return; |
---|
| 249 | |
---|
| 250 | FOREACH2(relsec, obj.get_section_table()) |
---|
| 251 | { |
---|
| 252 | switch (relsec->get_type()) |
---|
| 253 | { |
---|
| 254 | case SHT_REL: { |
---|
| 255 | elf_rel_t *reltab = (elf_rel_t*)relsec->get_content(); |
---|
| 256 | size_t count = relsec->get_size() / sizeof (elf_rel_t); |
---|
| 257 | obj.rel_with_addend_ = false; |
---|
| 258 | |
---|
| 259 | for (unsigned int i = 0; i < count; i++) |
---|
| 260 | { |
---|
| 261 | if (!rel_sym(swap(reltab[i].r_info))) |
---|
| 262 | continue; |
---|
| 263 | |
---|
| 264 | reloc *r = new reloc(); |
---|
| 265 | |
---|
| 266 | section *sec = relsec->get_info(); |
---|
| 267 | symbol *sym = obj.symidx_.at(rel_sym(swap(reltab[i].r_info))); |
---|
| 268 | assert(sym); |
---|
| 269 | |
---|
| 270 | r->set_symbol(sym); |
---|
| 271 | r->set_section(sec); |
---|
| 272 | |
---|
| 273 | reloc_e type = rel_type(swap(reltab[i].r_info)); |
---|
| 274 | r->set_type(type); |
---|
| 275 | load_addend(obj, *r, reltab, count, i, sec->get_content()); |
---|
| 276 | } |
---|
| 277 | |
---|
| 278 | // std::cerr << "elfpp: relocation " << i << " offset " << ro << " out of section" << std::endl; |
---|
| 279 | |
---|
| 280 | delete &*relsec; |
---|
| 281 | break; |
---|
| 282 | } |
---|
| 283 | |
---|
| 284 | case SHT_RELA: { |
---|
| 285 | elf_rela_t *reltab = (elf_rela_t*)relsec->get_content(); |
---|
| 286 | size_t count = relsec->get_size() / sizeof (elf_rela_t); |
---|
| 287 | obj.rel_with_addend_ = true; |
---|
| 288 | |
---|
| 289 | for (unsigned int i = 0; i < count; i++) |
---|
| 290 | { |
---|
| 291 | if (!rel_sym(swap(reltab[i].r_info))) |
---|
| 292 | continue; |
---|
| 293 | |
---|
| 294 | reloc *r = new reloc(); |
---|
| 295 | |
---|
| 296 | section *sec = relsec->get_info(); |
---|
| 297 | symbol *sym = obj.symidx_[rel_sym(swap(reltab[i].r_info))]; |
---|
| 298 | assert(sym); |
---|
| 299 | |
---|
| 300 | r->set_symbol(sym); |
---|
| 301 | r->set_section(sec); |
---|
| 302 | |
---|
| 303 | r->set_type(rel_type(swap(reltab[i].r_info))); |
---|
| 304 | uint32_t ro = swap(reltab[i].r_offset); |
---|
| 305 | r->set_offset(ro); |
---|
| 306 | r->set_addend(swap(reltab[i].r_addend)); |
---|
| 307 | } |
---|
| 308 | |
---|
| 309 | delete &*relsec; |
---|
| 310 | break; |
---|
| 311 | } |
---|
| 312 | |
---|
| 313 | default: |
---|
| 314 | break; |
---|
| 315 | } |
---|
| 316 | |
---|
| 317 | } |
---|
| 318 | |
---|
| 319 | obj.generate_symtab_ = true; |
---|
| 320 | } |
---|
| 321 | |
---|
| 322 | static bool sort_predicate(const symbol *a, const symbol *b) |
---|
| 323 | { |
---|
| 324 | return a->get_info() < b->get_info(); |
---|
| 325 | } |
---|
| 326 | |
---|
| 327 | template <typename bits_t, int width> |
---|
| 328 | void elfn_access<bits_t, width>::save_symtab(object &obj) |
---|
| 329 | { |
---|
| 330 | size_t shnum = 1; |
---|
| 331 | |
---|
| 332 | // renumber current section table |
---|
| 333 | FOREACH(s, obj.get_section_table()) |
---|
| 334 | s->index_ = shnum++; |
---|
| 335 | |
---|
| 336 | // create symbol and associated string sections |
---|
| 337 | section *symtab = new section(obj, SHT_SYMTAB); |
---|
| 338 | section *strtab = new section(obj, SHT_STRTAB); |
---|
| 339 | std::string str(1, '\0'); |
---|
| 340 | |
---|
| 341 | symtab->set_name(".symtab"); |
---|
| 342 | symtab->set_entsize(sizeof (elf_sym_t)); |
---|
| 343 | symtab->set_link(strtab); |
---|
| 344 | |
---|
| 345 | strtab->set_name(".strtab"); |
---|
| 346 | strtab->set_flags(SHF_STRINGS); |
---|
| 347 | |
---|
| 348 | obj.add_section(*symtab); |
---|
| 349 | obj.add_section(*strtab); |
---|
| 350 | |
---|
| 351 | // prepare sorted symbol array |
---|
| 352 | |
---|
| 353 | unsigned int i = 0; |
---|
| 354 | std::vector<symbol *> table; |
---|
| 355 | |
---|
| 356 | table.resize(obj.get_symbol_table().size()); |
---|
| 357 | |
---|
| 358 | FOREACH(sym, obj.get_symbol_table()) |
---|
| 359 | table[i++] = sym->second; |
---|
| 360 | |
---|
| 361 | FOREACH(sec, obj.get_section_table()) |
---|
| 362 | { |
---|
| 363 | table.resize(i + sec->get_symbol_table().size()); |
---|
| 364 | |
---|
| 365 | FOREACH(sym, sec->get_symbol_table()) |
---|
| 366 | table[i++] = sym->second; |
---|
| 367 | } |
---|
| 368 | |
---|
| 369 | sort(table.begin(), table.end(), sort_predicate); |
---|
| 370 | |
---|
| 371 | for (i = 0; i < table.size(); i++) |
---|
| 372 | { |
---|
| 373 | if (ELF_ST_BIND(table[i]->get_info()) != STB_LOCAL) |
---|
| 374 | break; |
---|
| 375 | } |
---|
| 376 | |
---|
| 377 | symtab->set_info_last(i + 1); |
---|
| 378 | |
---|
| 379 | // generate symbol table section content |
---|
| 380 | |
---|
| 381 | std::vector<reloc*> reloclist[shnum]; |
---|
| 382 | elf_sym_t symdata[table.size() + 1]; |
---|
| 383 | i = 1; |
---|
| 384 | |
---|
| 385 | std::memset(symdata, 0, sizeof(elf_sym_t)); |
---|
| 386 | |
---|
| 387 | FOREACH(sym_, table) |
---|
| 388 | { |
---|
| 389 | elf_sym_t &ent = symdata[i]; |
---|
| 390 | symbol *sym = *sym_; |
---|
| 391 | |
---|
| 392 | swap(&ent.st_name, str.size()); |
---|
| 393 | str.append(sym->get_name().c_str(), sym->get_name().size() + 1); |
---|
| 394 | swap(&ent.st_value, sym->get_value()); |
---|
| 395 | swap(&ent.st_size, sym->get_size()); |
---|
| 396 | ent.st_info = sym->get_info(); |
---|
| 397 | ent.st_other = sym->get_other(); |
---|
| 398 | |
---|
| 399 | FOREACH(rel, sym->reloc_tab_) |
---|
| 400 | reloclist[rel->get_section()->index_].push_back(&*rel); |
---|
| 401 | |
---|
| 402 | if (sym->get_section()) |
---|
| 403 | swap(&ent.st_shndx, sym->get_section()->index_); |
---|
| 404 | else |
---|
| 405 | swap(&ent.st_shndx, sym->get_section_ndx()); |
---|
| 406 | |
---|
| 407 | sym->index_ = i++; |
---|
| 408 | } |
---|
| 409 | |
---|
| 410 | strtab->set_size(str.size()); |
---|
| 411 | std::memcpy(strtab->get_content(), str.data(), str.size()); |
---|
| 412 | |
---|
| 413 | symtab->set_size(sizeof(symdata)); |
---|
| 414 | std::memcpy(symtab->get_content(), symdata, sizeof(symdata)); |
---|
| 415 | |
---|
| 416 | // generate relocation table |
---|
| 417 | |
---|
| 418 | FOREACH(sec, obj.get_section_table()) |
---|
| 419 | { |
---|
| 420 | if (!sec->index_) |
---|
| 421 | continue; |
---|
| 422 | |
---|
| 423 | std::vector<reloc*> &rl = reloclist[sec->index_]; |
---|
| 424 | |
---|
| 425 | if (rl.empty()) |
---|
| 426 | continue; |
---|
| 427 | |
---|
| 428 | section *reltab = new section(obj, obj.rel_with_addend_ ? SHT_RELA : SHT_REL); |
---|
| 429 | |
---|
| 430 | reltab->set_entsize(sizeof (elf_rel_t)); |
---|
| 431 | reltab->set_link(symtab); |
---|
| 432 | reltab->set_info(&*sec); |
---|
| 433 | |
---|
| 434 | obj.add_section(*reltab); |
---|
| 435 | |
---|
| 436 | if (obj.rel_with_addend_) |
---|
| 437 | { |
---|
| 438 | elf_rela_t reldata[rl.size()]; |
---|
| 439 | |
---|
| 440 | reltab->set_name(".rela" + sec->get_name()); |
---|
| 441 | i = 0; |
---|
| 442 | |
---|
| 443 | FOREACH(rel_, rl) |
---|
| 444 | { |
---|
| 445 | reloc *rel = *rel_; |
---|
| 446 | |
---|
| 447 | if (symbol *ms = rel->get_mangled_symbol()) |
---|
| 448 | swap(&reldata[i].r_offset, ms->get_value() + rel->get_offset()); |
---|
| 449 | else |
---|
| 450 | swap(&reldata[i].r_offset, rel->get_offset()); |
---|
| 451 | |
---|
| 452 | swap(&reldata[i].r_info, rel_info(rel->get_symbol()->index_, rel->get_type())); |
---|
| 453 | swap(&reldata[i].r_addend, rel->get_addend()); |
---|
| 454 | i++; |
---|
| 455 | } |
---|
| 456 | |
---|
| 457 | reltab->set_size(sizeof(reldata)); |
---|
| 458 | std::memcpy(reltab->get_content(), reldata, sizeof(reldata)); |
---|
| 459 | } |
---|
| 460 | else |
---|
| 461 | { |
---|
| 462 | elf_rel_t reldata[rl.size()]; |
---|
| 463 | |
---|
| 464 | reltab->set_name(".rel" + sec->get_name()); |
---|
| 465 | i = 0; |
---|
| 466 | |
---|
| 467 | FOREACH(rel_, rl) |
---|
| 468 | { |
---|
| 469 | reloc *rel = *rel_; |
---|
| 470 | |
---|
| 471 | uint64_t ro = rel->get_offset(); |
---|
| 472 | if (symbol *ms = rel->get_mangled_symbol()) |
---|
| 473 | { |
---|
| 474 | // relocation offset is relative to mangled symbol value |
---|
| 475 | if (ro < ms->get_size()) |
---|
| 476 | rel_write(obj, rel->get_type(), ms->get_content() + ro, rel->get_addend()); |
---|
| 477 | else |
---|
| 478 | std::cerr << "elfpp: relocation offset above mangled symbol size" << std::endl; |
---|
| 479 | ro += ms->get_value(); |
---|
| 480 | } |
---|
| 481 | else |
---|
| 482 | { |
---|
| 483 | // relocation offset is relative to mangled section |
---|
| 484 | if (ro < sec->get_size()) |
---|
| 485 | rel_write(obj, rel->get_type(), sec->get_content() + ro, rel->get_addend()); |
---|
| 486 | else |
---|
| 487 | std::cerr << "elfpp: relocation offset above section size" << std::endl; |
---|
| 488 | } |
---|
| 489 | |
---|
| 490 | swap(&reldata[i].r_offset, ro); |
---|
| 491 | |
---|
| 492 | swap(&reldata[i].r_info, rel_info(rel->get_symbol()->index_, rel->get_type())); |
---|
| 493 | i++; |
---|
| 494 | } |
---|
| 495 | |
---|
| 496 | reltab->set_size(sizeof(reldata)); |
---|
| 497 | std::memcpy(reltab->get_content(), reldata, sizeof(reldata)); |
---|
| 498 | } |
---|
| 499 | |
---|
| 500 | } |
---|
| 501 | } |
---|
| 502 | |
---|
| 503 | template <typename bits_t, int width> |
---|
| 504 | void elfn_access<bits_t, width>::read(object &obj, FILE *file) |
---|
| 505 | { |
---|
| 506 | // read file header |
---|
| 507 | |
---|
| 508 | elf_hdr_t head_; |
---|
| 509 | |
---|
| 510 | fseek(file, 0, SEEK_SET); |
---|
| 511 | if (fread(&head_, sizeof (head_), 1, file) != 1) |
---|
| 512 | throw std::runtime_error("unable to read file"); |
---|
| 513 | |
---|
| 514 | obj.word_width_ = (ei_class_e)head_.e_ident[EI_CLASS]; |
---|
| 515 | obj.byteorder_ = byteorder_ = (ei_data_e)head_.e_ident[EI_DATA]; |
---|
| 516 | obj.os_abi_ = (ei_osabi_e)head_.e_ident[EI_OSABI]; |
---|
| 517 | obj.abi_ver_ = head_.e_ident[EI_ABIVERSION]; |
---|
| 518 | obj.type_ = (e_type_e)swap(head_.e_type); |
---|
| 519 | obj.machine_ = (e_machine_e)swap(head_.e_machine); |
---|
| 520 | obj.entry_ = swap(head_.e_entry); |
---|
| 521 | obj.flags_ = swap(head_.e_flags); |
---|
| 522 | |
---|
| 523 | // read segment table |
---|
| 524 | size_t phnum = swap(head_.e_phnum); |
---|
| 525 | elf_phdr_t phdr[phnum]; |
---|
| 526 | |
---|
| 527 | fseek(file, swap(head_.e_phoff), SEEK_SET); |
---|
| 528 | if (fread(phdr, sizeof (elf_phdr_t), phnum, file) != phnum) |
---|
| 529 | throw std::runtime_error("unable to read file"); |
---|
| 530 | |
---|
| 531 | // create segment objects |
---|
| 532 | |
---|
| 533 | for (unsigned int i = 0; i < phnum; i++) |
---|
| 534 | { |
---|
| 535 | segment *s = new segment(obj); |
---|
| 536 | |
---|
| 537 | s->set_type((p_type_e)swap(phdr[i].p_type)); |
---|
| 538 | s->set_file_offset(swap(phdr[i].p_offset)); |
---|
| 539 | s->set_vaddr(swap(phdr[i].p_vaddr)); |
---|
| 540 | s->set_paddr(swap(phdr[i].p_paddr)); |
---|
| 541 | s->set_mem_size(swap(phdr[i].p_memsz)); |
---|
| 542 | s->set_file_size(swap(phdr[i].p_filesz)); |
---|
| 543 | s->set_flags((p_flags_e)swap(phdr[i].p_flags)); |
---|
| 544 | s->set_align(swap(phdr[i].p_align)); |
---|
| 545 | |
---|
| 546 | obj.add_segment(*s); |
---|
| 547 | } |
---|
| 548 | |
---|
| 549 | // read section table |
---|
| 550 | size_t shnum = swap(head_.e_shnum); |
---|
| 551 | elf_shdr_t shdr[shnum]; |
---|
| 552 | obj.secidx_.resize(shnum); |
---|
| 553 | |
---|
| 554 | fseek(file, swap(head_.e_shoff), SEEK_SET); |
---|
| 555 | |
---|
| 556 | if (fread(shdr, sizeof (elf_shdr_t), shnum, file) != shnum) |
---|
| 557 | throw std::runtime_error("unable to read file"); |
---|
| 558 | |
---|
| 559 | // create section objects |
---|
| 560 | |
---|
| 561 | for (unsigned int i = 1; i < shnum; i++) |
---|
| 562 | { |
---|
| 563 | sh_type_e type = (sh_type_e)swap(shdr[i].sh_type); |
---|
| 564 | |
---|
| 565 | section *s = new section(obj, type); |
---|
| 566 | off_t offset = swap(shdr[i].sh_offset); |
---|
| 567 | |
---|
| 568 | obj.secidx_[i] = s; |
---|
| 569 | s->index_ = i; |
---|
| 570 | |
---|
| 571 | s->set_flags((sh_flags_e)swap(shdr[i].sh_flags)); |
---|
| 572 | s->set_vaddr(swap(shdr[i].sh_addr)); |
---|
| 573 | s->set_file_offset(offset); |
---|
| 574 | s->set_size(swap(shdr[i].sh_size)); |
---|
| 575 | s->set_align(swap(shdr[i].sh_addralign)); |
---|
| 576 | s->set_entsize(swap(shdr[i].sh_entsize)); |
---|
| 577 | |
---|
| 578 | if (type != SHT_NOBITS && s->get_size()) |
---|
| 579 | { |
---|
| 580 | fseek(file, offset, SEEK_SET); |
---|
| 581 | if (fread(s->get_content(), s->get_size(), 1, file) != 1) |
---|
| 582 | throw std::runtime_error("unable to read file"); |
---|
| 583 | } |
---|
| 584 | |
---|
| 585 | obj.add_section(*s); |
---|
| 586 | } |
---|
| 587 | |
---|
| 588 | // update sections links |
---|
| 589 | |
---|
| 590 | for (unsigned int i = 1; i < shnum; i++) |
---|
| 591 | { |
---|
| 592 | section &s = *obj.secidx_[i]; |
---|
| 593 | |
---|
| 594 | unsigned int link = swap(shdr[i].sh_link); |
---|
| 595 | |
---|
| 596 | if (link) |
---|
| 597 | s.set_link(obj.secidx_.at(link)); |
---|
| 598 | |
---|
| 599 | unsigned int info = swap(shdr[i].sh_info); |
---|
| 600 | |
---|
| 601 | switch (s.type_) |
---|
| 602 | { |
---|
| 603 | case SHT_REL: |
---|
| 604 | case SHT_RELA: |
---|
| 605 | if (info) |
---|
| 606 | s.set_info(obj.secidx_.at(info)); |
---|
| 607 | break; |
---|
| 608 | |
---|
| 609 | case SHT_DYNSYM: |
---|
| 610 | case SHT_SYMTAB: |
---|
| 611 | s.set_info_last(info); |
---|
| 612 | break; |
---|
| 613 | |
---|
| 614 | default: |
---|
| 615 | ; |
---|
| 616 | } |
---|
| 617 | } |
---|
| 618 | |
---|
| 619 | // set sections names |
---|
| 620 | |
---|
| 621 | unsigned int shstrndx = swap(head_.e_shstrndx); |
---|
| 622 | |
---|
| 623 | if (shstrndx != SHN_UNDEF) |
---|
| 624 | { |
---|
| 625 | section &shstr = *obj.secidx_.at(shstrndx); |
---|
| 626 | const char *str = (char*)shstr.get_content(); |
---|
| 627 | |
---|
| 628 | for (unsigned int i = 1; i < shnum; i++) |
---|
| 629 | obj.secidx_[i]->set_name(str + swap(shdr[i].sh_name)); |
---|
| 630 | |
---|
| 631 | delete &shstr; |
---|
| 632 | } |
---|
| 633 | |
---|
| 634 | } |
---|
| 635 | |
---|
| 636 | template <typename bits_t, int width> |
---|
| 637 | void elfn_access<bits_t, width>::create_segments(object &obj) |
---|
| 638 | { |
---|
| 639 | p_flags_e flag; |
---|
| 640 | |
---|
| 641 | |
---|
| 642 | FOREACH(sec, obj.get_section_table()) |
---|
| 643 | { |
---|
| 644 | segment *s = new segment(obj); |
---|
| 645 | |
---|
[171] | 646 | if(!(sec->get_flags() & elfpp::SHF_ALLOC)) |
---|
| 647 | { |
---|
| 648 | s->set_type(PT_NULL); |
---|
| 649 | continue; |
---|
| 650 | } |
---|
| 651 | |
---|
| 652 | s->set_type(PT_LOAD); |
---|
| 653 | s->set_file_offset(0);//done while writing section in file |
---|
| 654 | #ifdef MEMO_DEBUG |
---|
| 655 | std::cout << "seg building (" << std::hex << sec->get_vaddr() << ") for: " << *sec << std::endl; |
---|
| 656 | #endif |
---|
| 657 | s->set_vaddr(sec->get_vaddr()); |
---|
| 658 | s->set_paddr(sec->get_vaddr()); |
---|
[163] | 659 | |
---|
[171] | 660 | s->set_mem_size(sec->get_size()); |
---|
| 661 | s->set_file_size(sec->get_size()); |
---|
[163] | 662 | |
---|
[171] | 663 | flag = PF_R ;//ALLOC ==> read ? |
---|
| 664 | flag = flag | (p_flags_e)(sec->get_flags() & SHF_WRITE)? PF_W : PF_R ; |
---|
| 665 | flag = flag | (p_flags_e)(sec->get_flags() & SHF_EXECINSTR)? PF_X : PF_R ; |
---|
| 666 | s->set_flags(flag); |
---|
| 667 | s->set_align(0);//FIXME! |
---|
[163] | 668 | |
---|
[171] | 669 | #ifdef MEMO_DEBUG |
---|
| 670 | std::cout <<"New segment " << s->get_file_size() << std::endl; |
---|
| 671 | #endif |
---|
| 672 | obj.add_segment(*s); |
---|
[163] | 673 | } |
---|
| 674 | } |
---|
| 675 | |
---|
| 676 | template <typename bits_t, int width> |
---|
| 677 | void elfn_access<bits_t, width>::write(object &obj, FILE *file) |
---|
| 678 | { |
---|
| 679 | byteorder_ = obj.byteorder_; |
---|
| 680 | |
---|
| 681 | if (obj.generate_symtab_) |
---|
| 682 | save_symtab(obj); |
---|
| 683 | |
---|
[171] | 684 | // create all segments |
---|
| 685 | |
---|
[163] | 686 | create_segments(obj); |
---|
| 687 | |
---|
| 688 | // write symbol contents |
---|
| 689 | |
---|
| 690 | FOREACH(sec, obj.get_section_table()) |
---|
| 691 | { |
---|
| 692 | if (sec->get_type() == SHT_NOBITS) |
---|
| 693 | continue; |
---|
| 694 | |
---|
| 695 | FOREACH(sym_, sec->get_symbol_table()) |
---|
| 696 | { |
---|
| 697 | symbol *sym = sym_->second; |
---|
| 698 | |
---|
| 699 | if (!sym->get_content()) |
---|
| 700 | continue; |
---|
| 701 | |
---|
| 702 | if (sec->get_size() < sym->get_value() + sym->get_size()) |
---|
| 703 | sec->set_size(sym->get_value() + sym->get_size()); |
---|
| 704 | |
---|
| 705 | std::memcpy(sec->get_content() + sym->get_value(), sym->get_content(), sym->get_size()); |
---|
| 706 | } |
---|
| 707 | } |
---|
| 708 | |
---|
| 709 | elf_hdr_t head; |
---|
| 710 | |
---|
| 711 | // create a new section name section |
---|
| 712 | |
---|
| 713 | section *shstrtab = new section(obj, SHT_STRTAB); |
---|
| 714 | shstrtab->set_name(".shstrtab"); |
---|
| 715 | shstrtab->set_flags(SHF_STRINGS); |
---|
| 716 | obj.add_section(*shstrtab); |
---|
| 717 | |
---|
| 718 | size_t shnum = 1; |
---|
| 719 | |
---|
| 720 | FOREACH(s, obj.get_section_table()) |
---|
| 721 | s->index_ = shnum++; |
---|
| 722 | |
---|
| 723 | std::string strtab(1, '\0'); |
---|
| 724 | unsigned int stridx[shnum]; |
---|
| 725 | |
---|
| 726 | stridx[0] = 0; |
---|
| 727 | |
---|
| 728 | FOREACH(s, obj.get_section_table()) |
---|
| 729 | { |
---|
| 730 | stridx[s->index_] = strtab.size(); |
---|
| 731 | strtab.append(s->get_name().c_str(), s->get_name().size() + 1); |
---|
| 732 | } |
---|
| 733 | |
---|
| 734 | shstrtab->set_size(strtab.size()); |
---|
| 735 | std::memcpy(shstrtab->get_content(), strtab.data(), strtab.size()); |
---|
| 736 | |
---|
| 737 | size_t phnum = shnum;//FIXME!:only relevent section |
---|
| 738 | // update header |
---|
| 739 | |
---|
| 740 | std::memset(head.e_ident, 0, sizeof(head.e_ident)); |
---|
| 741 | std::memcpy(head.e_ident, ELFMAG, 4); |
---|
| 742 | head.e_ident[EI_CLASS] = obj.word_width_; |
---|
| 743 | head.e_ident[EI_DATA] = byteorder_; |
---|
| 744 | head.e_ident[EI_VERSION] = EV_CURRENT; |
---|
| 745 | head.e_ident[EI_OSABI] = obj.os_abi_; |
---|
| 746 | head.e_ident[EI_ABIVERSION] = obj.abi_ver_; |
---|
| 747 | |
---|
| 748 | swap(&head.e_type, obj.type_); |
---|
| 749 | swap(&head.e_machine, obj.machine_); |
---|
| 750 | swap(&head.e_version, EV_CURRENT); |
---|
| 751 | swap(&head.e_entry, obj.entry_); |
---|
| 752 | swap(&head.e_phoff, sizeof (elf_hdr_t)); |
---|
| 753 | swap(&head.e_shoff, sizeof (elf_hdr_t)+ (sizeof(elf_phdr_t)*phnum));//! |
---|
| 754 | swap(&head.e_flags, obj.flags_); |
---|
| 755 | swap(&head.e_ehsize, sizeof (elf_hdr_t)); |
---|
| 756 | swap(&head.e_phentsize, sizeof (elf_phdr_t)); |
---|
| 757 | swap(&head.e_phnum, phnum); |
---|
| 758 | swap(&head.e_shentsize, sizeof (elf_shdr_t)); |
---|
| 759 | swap(&head.e_shnum, shnum); |
---|
| 760 | swap(&head.e_shstrndx, shstrtab->index_); |
---|
| 761 | |
---|
| 762 | // update section table |
---|
| 763 | |
---|
| 764 | elf_shdr_t shdr[shnum]; |
---|
| 765 | |
---|
| 766 | std::memset(shdr, 0, sizeof(shdr)); |
---|
| 767 | |
---|
| 768 | FOREACH(s, obj.get_section_table()) |
---|
| 769 | { |
---|
| 770 | unsigned int i = s->index_; |
---|
| 771 | |
---|
| 772 | swap(&shdr[i].sh_name, stridx[i]); |
---|
| 773 | |
---|
| 774 | swap(&shdr[i].sh_type, s->get_type()); |
---|
| 775 | swap(&shdr[i].sh_flags, s->get_flags()); |
---|
| 776 | swap(&shdr[i].sh_addr, s->get_vaddr()); |
---|
| 777 | |
---|
| 778 | |
---|
| 779 | swap(&shdr[i].sh_size, s->get_size()); |
---|
| 780 | if (s->get_link()) |
---|
| 781 | swap(&shdr[i].sh_link, s->get_link()->index_); |
---|
| 782 | |
---|
| 783 | switch (s->get_type()) |
---|
| 784 | { |
---|
| 785 | case SHT_REL: |
---|
| 786 | case SHT_RELA: |
---|
| 787 | assert(s->get_info()); |
---|
| 788 | swap(&shdr[i].sh_info, s->get_info()->index_); |
---|
| 789 | break; |
---|
| 790 | |
---|
| 791 | case SHT_DYNSYM: |
---|
| 792 | case SHT_SYMTAB: |
---|
| 793 | swap(&shdr[i].sh_info, s->get_info_last()); |
---|
| 794 | default: |
---|
| 795 | break; |
---|
| 796 | } |
---|
| 797 | |
---|
| 798 | swap(&shdr[i].sh_addralign, s->get_align()); |
---|
| 799 | swap(&shdr[i].sh_entsize, s->get_entsize()); |
---|
| 800 | } |
---|
| 801 | |
---|
| 802 | // update program header |
---|
| 803 | elf_phdr_t phdr[phnum]; |
---|
| 804 | |
---|
| 805 | std::memset(phdr, 0, sizeof(phdr)); |
---|
| 806 | |
---|
[171] | 807 | unsigned int i = 1;//to keep the same order as sections |
---|
[163] | 808 | FOREACH(s, obj.get_segment_table()) |
---|
| 809 | { |
---|
| 810 | |
---|
| 811 | swap(&phdr[i].p_type, s->get_type()); |
---|
| 812 | swap(&phdr[i].p_flags, s->get_flags()); |
---|
| 813 | swap(&phdr[i].p_vaddr, s->get_vaddr()); |
---|
| 814 | swap(&phdr[i].p_paddr, s->get_paddr()); |
---|
| 815 | |
---|
| 816 | |
---|
| 817 | swap(&phdr[i].p_filesz, s->get_file_size()); |
---|
| 818 | swap(&phdr[i].p_memsz, s->get_mem_size()); |
---|
| 819 | |
---|
| 820 | |
---|
| 821 | swap(&phdr[i].p_align, s->get_align()); |
---|
[171] | 822 | //note: offset done while writing sections |
---|
[163] | 823 | i++; |
---|
| 824 | } |
---|
| 825 | //assert((i == phnum)and (i == shnum)); |
---|
| 826 | |
---|
| 827 | // write header to file |
---|
| 828 | |
---|
| 829 | fseek(file, 0, SEEK_SET); |
---|
| 830 | if (fwrite(&head, sizeof(head), 1, file) != 1) |
---|
| 831 | throw std::runtime_error("unable to write header to file"); |
---|
| 832 | |
---|
| 833 | fseek(file, sizeof(phdr)+sizeof(shdr), SEEK_CUR); |
---|
| 834 | |
---|
| 835 | // write sections to file |
---|
| 836 | |
---|
| 837 | FOREACH(s, obj.get_section_table()) |
---|
| 838 | { |
---|
[171] | 839 | if (s->get_type() == SHT_NOBITS) |
---|
| 840 | continue; |
---|
[163] | 841 | |
---|
[171] | 842 | #ifdef MEMO_DEBUG |
---|
| 843 | std::cout << "offset: " << ftell(file) << " for " << *s << std::endl; |
---|
| 844 | std::cout << std::hex << "paddr: " << phdr[s->index_].p_paddr << ", sect vaddr: " << s->get_vaddr() << "/" <<shdr[s->index_].sh_addr << std::endl; |
---|
| 845 | #endif |
---|
[163] | 846 | swap(&shdr[s->index_].sh_offset, ftell(file)); |
---|
| 847 | swap(&phdr[s->index_].p_offset, ftell(file)); |
---|
| 848 | if (s->get_size() && fwrite(s->get_content(), s->get_size(), 1, file) != 1) |
---|
| 849 | throw std::runtime_error("unable to write section to file"); |
---|
| 850 | } |
---|
| 851 | |
---|
| 852 | // write program header to file |
---|
| 853 | |
---|
| 854 | fseek(file, sizeof(head), SEEK_SET); |
---|
| 855 | if (fwrite(phdr, sizeof(phdr), 1, file) != 1) |
---|
| 856 | throw std::runtime_error("unable to write section table to file"); |
---|
| 857 | |
---|
| 858 | // write section table to file |
---|
| 859 | |
---|
| 860 | //toDO:assert(cur_seek == phnum*sizeof(ph_t)+...) |
---|
| 861 | //fseek(file, sizeof(phdr)+sizeof(head), SEEK_CUR); |
---|
| 862 | if (fwrite(shdr, sizeof(shdr), 1, file) != 1) |
---|
| 863 | throw std::runtime_error("unable to write section table to file"); |
---|
| 864 | |
---|
| 865 | } |
---|
| 866 | |
---|
| 867 | template class elfn_access<elf32_bits_s, 32>; |
---|
| 868 | template class elfn_access<elf64_bits_s, 64>; |
---|
| 869 | |
---|
| 870 | } |
---|
| 871 | |
---|