1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "courgette/encoded_program.h" 6 7 #include <algorithm> 8 #include <map> 9 #include <string> 10 #include <vector> 11 12 #include "base/environment.h" 13 #include "base/logging.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/strings/string_util.h" 16 #include "base/strings/utf_string_conversions.h" 17 #include "courgette/courgette.h" 18 #include "courgette/disassembler_elf_32_arm.h" 19 #include "courgette/streams.h" 20 #include "courgette/types_elf.h" 21 22 namespace courgette { 23 24 // Stream indexes. 25 const int kStreamMisc = 0; 26 const int kStreamOps = 1; 27 const int kStreamBytes = 2; 28 const int kStreamAbs32Indexes = 3; 29 const int kStreamRel32Indexes = 4; 30 const int kStreamAbs32Addresses = 5; 31 const int kStreamRel32Addresses = 6; 32 const int kStreamCopyCounts = 7; 33 const int kStreamOriginAddresses = kStreamMisc; 34 35 const int kStreamLimit = 9; 36 37 // Constructor is here rather than in the header. Although the constructor 38 // appears to do nothing it is fact quite large because of the implicit calls to 39 // field constructors. Ditto for the destructor. 40 EncodedProgram::EncodedProgram() : image_base_(0) {} 41 EncodedProgram::~EncodedProgram() {} 42 43 // Serializes a vector of integral values using Varint32 coding. 44 template<typename V> 45 CheckBool WriteVector(const V& items, SinkStream* buffer) { 46 size_t count = items.size(); 47 bool ok = buffer->WriteSizeVarint32(count); 48 for (size_t i = 0; ok && i < count; ++i) { 49 COMPILE_ASSERT(sizeof(items[0]) <= sizeof(uint32), // NOLINT 50 T_must_fit_in_uint32); 51 ok = buffer->WriteSizeVarint32(items[i]); 52 } 53 return ok; 54 } 55 56 template<typename V> 57 bool ReadVector(V* items, SourceStream* buffer) { 58 uint32 count; 59 if (!buffer->ReadVarint32(&count)) 60 return false; 61 62 items->clear(); 63 64 bool ok = items->reserve(count); 65 for (size_t i = 0; ok && i < count; ++i) { 66 uint32 item; 67 ok = buffer->ReadVarint32(&item); 68 if (ok) 69 ok = items->push_back(static_cast<typename V::value_type>(item)); 70 } 71 72 return ok; 73 } 74 75 // Serializes a vector, using delta coding followed by Varint32 coding. 76 template<typename V> 77 CheckBool WriteU32Delta(const V& set, SinkStream* buffer) { 78 size_t count = set.size(); 79 bool ok = buffer->WriteSizeVarint32(count); 80 uint32 prev = 0; 81 for (size_t i = 0; ok && i < count; ++i) { 82 uint32 current = set[i]; 83 uint32 delta = current - prev; 84 ok = buffer->WriteVarint32(delta); 85 prev = current; 86 } 87 return ok; 88 } 89 90 template <typename V> 91 static CheckBool ReadU32Delta(V* set, SourceStream* buffer) { 92 uint32 count; 93 94 if (!buffer->ReadVarint32(&count)) 95 return false; 96 97 set->clear(); 98 bool ok = set->reserve(count); 99 uint32 prev = 0; 100 101 for (size_t i = 0; ok && i < count; ++i) { 102 uint32 delta; 103 ok = buffer->ReadVarint32(&delta); 104 if (ok) { 105 uint32 current = prev + delta; 106 ok = set->push_back(current); 107 prev = current; 108 } 109 } 110 111 return ok; 112 } 113 114 // Write a vector as the byte representation of the contents. 115 // 116 // (This only really makes sense for a type T that has sizeof(T)==1, otherwise 117 // serialized representation is not endian-agnostic. But it is useful to keep 118 // the possibility of a greater size for experiments comparing Varint32 encoding 119 // of a vector of larger integrals vs a plain form.) 120 // 121 template<typename V> 122 CheckBool WriteVectorU8(const V& items, SinkStream* buffer) { 123 size_t count = items.size(); 124 bool ok = buffer->WriteSizeVarint32(count); 125 if (count != 0 && ok) { 126 size_t byte_count = count * sizeof(typename V::value_type); 127 ok = buffer->Write(static_cast<const void*>(&items[0]), byte_count); 128 } 129 return ok; 130 } 131 132 template<typename V> 133 bool ReadVectorU8(V* items, SourceStream* buffer) { 134 uint32 count; 135 if (!buffer->ReadVarint32(&count)) 136 return false; 137 138 items->clear(); 139 bool ok = items->resize(count, 0); 140 if (ok && count != 0) { 141 size_t byte_count = count * sizeof(typename V::value_type); 142 return buffer->Read(static_cast<void*>(&((*items)[0])), byte_count); 143 } 144 return ok; 145 } 146 147 //////////////////////////////////////////////////////////////////////////////// 148 149 CheckBool EncodedProgram::DefineRel32Label(int index, RVA value) { 150 return DefineLabelCommon(&rel32_rva_, index, value); 151 } 152 153 CheckBool EncodedProgram::DefineAbs32Label(int index, RVA value) { 154 return DefineLabelCommon(&abs32_rva_, index, value); 155 } 156 157 static const RVA kUnassignedRVA = static_cast<RVA>(-1); 158 159 CheckBool EncodedProgram::DefineLabelCommon(RvaVector* rvas, 160 int index, 161 RVA rva) { 162 bool ok = true; 163 if (static_cast<int>(rvas->size()) <= index) 164 ok = rvas->resize(index + 1, kUnassignedRVA); 165 166 if (ok) { 167 DCHECK_EQ((*rvas)[index], kUnassignedRVA) 168 << "DefineLabel double assigned " << index; 169 (*rvas)[index] = rva; 170 } 171 172 return ok; 173 } 174 175 void EncodedProgram::EndLabels() { 176 FinishLabelsCommon(&abs32_rva_); 177 FinishLabelsCommon(&rel32_rva_); 178 } 179 180 void EncodedProgram::FinishLabelsCommon(RvaVector* rvas) { 181 // Replace all unassigned slots with the value at the previous index so they 182 // delta-encode to zero. (There might be better values than zero. The way to 183 // get that is have the higher level assembly program assign the unassigned 184 // slots.) 185 RVA previous = 0; 186 size_t size = rvas->size(); 187 for (size_t i = 0; i < size; ++i) { 188 if ((*rvas)[i] == kUnassignedRVA) 189 (*rvas)[i] = previous; 190 else 191 previous = (*rvas)[i]; 192 } 193 } 194 195 CheckBool EncodedProgram::AddOrigin(RVA origin) { 196 return ops_.push_back(ORIGIN) && origins_.push_back(origin); 197 } 198 199 CheckBool EncodedProgram::AddCopy(uint32 count, const void* bytes) { 200 const uint8* source = static_cast<const uint8*>(bytes); 201 202 bool ok = true; 203 204 // Fold adjacent COPY instructions into one. This nearly halves the size of 205 // an EncodedProgram with only COPY1 instructions since there are approx plain 206 // 16 bytes per reloc. This has a working-set benefit during decompression. 207 // For compression of files with large differences this makes a small (4%) 208 // improvement in size. For files with small differences this degrades the 209 // compressed size by 1.3% 210 if (!ops_.empty()) { 211 if (ops_.back() == COPY1) { 212 ops_.back() = COPY; 213 ok = copy_counts_.push_back(1); 214 } 215 if (ok && ops_.back() == COPY) { 216 copy_counts_.back() += count; 217 for (uint32 i = 0; ok && i < count; ++i) { 218 ok = copy_bytes_.push_back(source[i]); 219 } 220 return ok; 221 } 222 } 223 224 if (ok) { 225 if (count == 1) { 226 ok = ops_.push_back(COPY1) && copy_bytes_.push_back(source[0]); 227 } else { 228 ok = ops_.push_back(COPY) && copy_counts_.push_back(count); 229 for (uint32 i = 0; ok && i < count; ++i) { 230 ok = copy_bytes_.push_back(source[i]); 231 } 232 } 233 } 234 235 return ok; 236 } 237 238 CheckBool EncodedProgram::AddAbs32(int label_index) { 239 return ops_.push_back(ABS32) && abs32_ix_.push_back(label_index); 240 } 241 242 CheckBool EncodedProgram::AddRel32(int label_index) { 243 return ops_.push_back(REL32) && rel32_ix_.push_back(label_index); 244 } 245 246 CheckBool EncodedProgram::AddRel32ARM(uint16 op, int label_index) { 247 return ops_.push_back(static_cast<OP>(op)) && 248 rel32_ix_.push_back(label_index); 249 } 250 251 CheckBool EncodedProgram::AddPeMakeRelocs() { 252 return ops_.push_back(MAKE_PE_RELOCATION_TABLE); 253 } 254 255 CheckBool EncodedProgram::AddElfMakeRelocs() { 256 return ops_.push_back(MAKE_ELF_RELOCATION_TABLE); 257 } 258 259 CheckBool EncodedProgram::AddElfARMMakeRelocs() { 260 return ops_.push_back(MAKE_ELF_ARM_RELOCATION_TABLE); 261 } 262 263 void EncodedProgram::DebuggingSummary() { 264 VLOG(1) << "EncodedProgram Summary" 265 << "\n image base " << image_base_ 266 << "\n abs32 rvas " << abs32_rva_.size() 267 << "\n rel32 rvas " << rel32_rva_.size() 268 << "\n ops " << ops_.size() 269 << "\n origins " << origins_.size() 270 << "\n copy_counts " << copy_counts_.size() 271 << "\n copy_bytes " << copy_bytes_.size() 272 << "\n abs32_ix " << abs32_ix_.size() 273 << "\n rel32_ix " << rel32_ix_.size(); 274 } 275 276 //////////////////////////////////////////////////////////////////////////////// 277 278 // For algorithm refinement purposes it is useful to write subsets of the file 279 // format. This gives us the ability to estimate the entropy of the 280 // differential compression of the individual streams, which can provide 281 // invaluable insights. The default, of course, is to include all the streams. 282 // 283 enum FieldSelect { 284 INCLUDE_ABS32_ADDRESSES = 0x0001, 285 INCLUDE_REL32_ADDRESSES = 0x0002, 286 INCLUDE_ABS32_INDEXES = 0x0010, 287 INCLUDE_REL32_INDEXES = 0x0020, 288 INCLUDE_OPS = 0x0100, 289 INCLUDE_BYTES = 0x0200, 290 INCLUDE_COPY_COUNTS = 0x0400, 291 INCLUDE_MISC = 0x1000 292 }; 293 294 static FieldSelect GetFieldSelect() { 295 #if 1 296 // TODO(sra): Use better configuration. 297 scoped_ptr<base::Environment> env(base::Environment::Create()); 298 std::string s; 299 env->GetVar("A_FIELDS", &s); 300 if (!s.empty()) { 301 return static_cast<FieldSelect>(wcstoul(ASCIIToWide(s).c_str(), 0, 0)); 302 } 303 #endif 304 return static_cast<FieldSelect>(~0); 305 } 306 307 CheckBool EncodedProgram::WriteTo(SinkStreamSet* streams) { 308 FieldSelect select = GetFieldSelect(); 309 310 // The order of fields must be consistent in WriteTo and ReadFrom, regardless 311 // of the streams used. The code can be configured with all kStreamXXX 312 // constants the same. 313 // 314 // If we change the code to pipeline reading with assembly (to avoid temporary 315 // storage vectors by consuming operands directly from the stream) then we 316 // need to read the base address and the random access address tables first, 317 // the rest can be interleaved. 318 319 if (select & INCLUDE_MISC) { 320 // TODO(sra): write 64 bits. 321 if (!streams->stream(kStreamMisc)->WriteVarint32( 322 static_cast<uint32>(image_base_))) { 323 return false; 324 } 325 } 326 327 bool success = true; 328 329 if (select & INCLUDE_ABS32_ADDRESSES) { 330 success &= WriteU32Delta(abs32_rva_, 331 streams->stream(kStreamAbs32Addresses)); 332 } 333 334 if (select & INCLUDE_REL32_ADDRESSES) { 335 success &= WriteU32Delta(rel32_rva_, 336 streams->stream(kStreamRel32Addresses)); 337 } 338 339 if (select & INCLUDE_MISC) 340 success &= WriteVector(origins_, streams->stream(kStreamOriginAddresses)); 341 342 if (select & INCLUDE_OPS) { 343 // 5 for length. 344 success &= streams->stream(kStreamOps)->Reserve(ops_.size() + 5); 345 success &= WriteVector(ops_, streams->stream(kStreamOps)); 346 } 347 348 if (select & INCLUDE_COPY_COUNTS) 349 success &= WriteVector(copy_counts_, streams->stream(kStreamCopyCounts)); 350 351 if (select & INCLUDE_BYTES) 352 success &= WriteVectorU8(copy_bytes_, streams->stream(kStreamBytes)); 353 354 if (select & INCLUDE_ABS32_INDEXES) 355 success &= WriteVector(abs32_ix_, streams->stream(kStreamAbs32Indexes)); 356 357 if (select & INCLUDE_REL32_INDEXES) 358 success &= WriteVector(rel32_ix_, streams->stream(kStreamRel32Indexes)); 359 360 return success; 361 } 362 363 bool EncodedProgram::ReadFrom(SourceStreamSet* streams) { 364 // TODO(sra): read 64 bits. 365 uint32 temp; 366 if (!streams->stream(kStreamMisc)->ReadVarint32(&temp)) 367 return false; 368 image_base_ = temp; 369 370 if (!ReadU32Delta(&abs32_rva_, streams->stream(kStreamAbs32Addresses))) 371 return false; 372 if (!ReadU32Delta(&rel32_rva_, streams->stream(kStreamRel32Addresses))) 373 return false; 374 if (!ReadVector(&origins_, streams->stream(kStreamOriginAddresses))) 375 return false; 376 if (!ReadVector(&ops_, streams->stream(kStreamOps))) 377 return false; 378 if (!ReadVector(©_counts_, streams->stream(kStreamCopyCounts))) 379 return false; 380 if (!ReadVectorU8(©_bytes_, streams->stream(kStreamBytes))) 381 return false; 382 if (!ReadVector(&abs32_ix_, streams->stream(kStreamAbs32Indexes))) 383 return false; 384 if (!ReadVector(&rel32_ix_, streams->stream(kStreamRel32Indexes))) 385 return false; 386 387 // Check that streams have been completely consumed. 388 for (int i = 0; i < kStreamLimit; ++i) { 389 if (streams->stream(i)->Remaining() > 0) 390 return false; 391 } 392 393 return true; 394 } 395 396 // Safe, non-throwing version of std::vector::at(). Returns 'true' for success, 397 // 'false' for out-of-bounds index error. 398 template<typename V, typename T> 399 bool VectorAt(const V& v, size_t index, T* output) { 400 if (index >= v.size()) 401 return false; 402 *output = v[index]; 403 return true; 404 } 405 406 CheckBool EncodedProgram::EvaluateRel32ARM(OP op, 407 size_t& ix_rel32_ix, 408 RVA& current_rva, 409 SinkStream* output) { 410 switch (op & 0x0000F000) { 411 case REL32ARM8: { 412 uint32 index; 413 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 414 return false; 415 ++ix_rel32_ix; 416 RVA rva; 417 if (!VectorAt(rel32_rva_, index, &rva)) 418 return false; 419 uint32 decompressed_op; 420 if (!DisassemblerElf32ARM::Decompress(ARM_OFF8, 421 static_cast<uint16>(op), 422 static_cast<uint32>(rva - 423 current_rva), 424 &decompressed_op)) { 425 return false; 426 } 427 uint16 op16 = decompressed_op; 428 if (!output->Write(&op16, 2)) 429 return false; 430 current_rva += 2; 431 break; 432 } 433 case REL32ARM11: { 434 uint32 index; 435 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 436 return false; 437 ++ix_rel32_ix; 438 RVA rva; 439 if (!VectorAt(rel32_rva_, index, &rva)) 440 return false; 441 uint32 decompressed_op; 442 if (!DisassemblerElf32ARM::Decompress(ARM_OFF11, (uint16) op, 443 (uint32) (rva - current_rva), 444 &decompressed_op)) { 445 return false; 446 } 447 uint16 op16 = decompressed_op; 448 if (!output->Write(&op16, 2)) 449 return false; 450 current_rva += 2; 451 break; 452 } 453 case REL32ARM24: { 454 uint32 index; 455 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 456 return false; 457 ++ix_rel32_ix; 458 RVA rva; 459 if (!VectorAt(rel32_rva_, index, &rva)) 460 return false; 461 uint32 decompressed_op; 462 if (!DisassemblerElf32ARM::Decompress(ARM_OFF24, (uint16) op, 463 (uint32) (rva - current_rva), 464 &decompressed_op)) { 465 return false; 466 } 467 if (!output->Write(&decompressed_op, 4)) 468 return false; 469 current_rva += 4; 470 break; 471 } 472 case REL32ARM25: { 473 uint32 index; 474 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 475 return false; 476 ++ix_rel32_ix; 477 RVA rva; 478 if (!VectorAt(rel32_rva_, index, &rva)) 479 return false; 480 uint32 decompressed_op; 481 if (!DisassemblerElf32ARM::Decompress(ARM_OFF25, (uint16) op, 482 (uint32) (rva - current_rva), 483 &decompressed_op)) { 484 return false; 485 } 486 uint32 words = (decompressed_op << 16) | (decompressed_op >> 16); 487 if (!output->Write(&words, 4)) 488 return false; 489 current_rva += 4; 490 break; 491 } 492 case REL32ARM21: { 493 uint32 index; 494 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 495 return false; 496 ++ix_rel32_ix; 497 RVA rva; 498 if (!VectorAt(rel32_rva_, index, &rva)) 499 return false; 500 uint32 decompressed_op; 501 if (!DisassemblerElf32ARM::Decompress(ARM_OFF21, (uint16) op, 502 (uint32) (rva - current_rva), 503 &decompressed_op)) { 504 return false; 505 } 506 uint32 words = (decompressed_op << 16) | (decompressed_op >> 16); 507 if (!output->Write(&words, 4)) 508 return false; 509 current_rva += 4; 510 break; 511 } 512 default: 513 return false; 514 } 515 516 return true; 517 } 518 519 CheckBool EncodedProgram::AssembleTo(SinkStream* final_buffer) { 520 // For the most part, the assembly process walks the various tables. 521 // ix_mumble is the index into the mumble table. 522 size_t ix_origins = 0; 523 size_t ix_copy_counts = 0; 524 size_t ix_copy_bytes = 0; 525 size_t ix_abs32_ix = 0; 526 size_t ix_rel32_ix = 0; 527 528 RVA current_rva = 0; 529 530 bool pending_pe_relocation_table = false; 531 Elf32_Word pending_elf_relocation_table_type = 0; 532 SinkStream bytes_following_relocation_table; 533 534 SinkStream* output = final_buffer; 535 536 for (size_t ix_ops = 0; ix_ops < ops_.size(); ++ix_ops) { 537 OP op = ops_[ix_ops]; 538 539 switch (op) { 540 default: 541 if (!EvaluateRel32ARM(op, ix_rel32_ix, current_rva, output)) 542 return false; 543 break; 544 545 case ORIGIN: { 546 RVA section_rva; 547 if (!VectorAt(origins_, ix_origins, §ion_rva)) 548 return false; 549 ++ix_origins; 550 current_rva = section_rva; 551 break; 552 } 553 554 case COPY: { 555 uint32 count; 556 if (!VectorAt(copy_counts_, ix_copy_counts, &count)) 557 return false; 558 ++ix_copy_counts; 559 for (uint32 i = 0; i < count; ++i) { 560 uint8 b; 561 if (!VectorAt(copy_bytes_, ix_copy_bytes, &b)) 562 return false; 563 ++ix_copy_bytes; 564 if (!output->Write(&b, 1)) 565 return false; 566 } 567 current_rva += count; 568 break; 569 } 570 571 case COPY1: { 572 uint8 b; 573 if (!VectorAt(copy_bytes_, ix_copy_bytes, &b)) 574 return false; 575 ++ix_copy_bytes; 576 if (!output->Write(&b, 1)) 577 return false; 578 current_rva += 1; 579 break; 580 } 581 582 case REL32: { 583 uint32 index; 584 if (!VectorAt(rel32_ix_, ix_rel32_ix, &index)) 585 return false; 586 ++ix_rel32_ix; 587 RVA rva; 588 if (!VectorAt(rel32_rva_, index, &rva)) 589 return false; 590 uint32 offset = (rva - (current_rva + 4)); 591 if (!output->Write(&offset, 4)) 592 return false; 593 current_rva += 4; 594 break; 595 } 596 597 case ABS32: { 598 uint32 index; 599 if (!VectorAt(abs32_ix_, ix_abs32_ix, &index)) 600 return false; 601 ++ix_abs32_ix; 602 RVA rva; 603 if (!VectorAt(abs32_rva_, index, &rva)) 604 return false; 605 uint32 abs32 = static_cast<uint32>(rva + image_base_); 606 if (!abs32_relocs_.push_back(current_rva) || !output->Write(&abs32, 4)) 607 return false; 608 current_rva += 4; 609 break; 610 } 611 612 case MAKE_PE_RELOCATION_TABLE: { 613 // We can see the base relocation anywhere, but we only have the 614 // information to generate it at the very end. So we divert the bytes 615 // we are generating to a temporary stream. 616 if (pending_pe_relocation_table) // Can't have two base relocation 617 // tables. 618 return false; 619 620 pending_pe_relocation_table = true; 621 output = &bytes_following_relocation_table; 622 break; 623 // There is a potential problem *if* the instruction stream contains 624 // some REL32 relocations following the base relocation and in the same 625 // section. We don't know the size of the table, so 'current_rva' will 626 // be wrong, causing REL32 offsets to be miscalculated. This never 627 // happens; the base relocation table is usually in a section of its 628 // own, a data-only section, and following everything else in the 629 // executable except some padding zero bytes. We could fix this by 630 // emitting an ORIGIN after the MAKE_BASE_RELOCATION_TABLE. 631 } 632 633 case MAKE_ELF_ARM_RELOCATION_TABLE: { 634 // We can see the base relocation anywhere, but we only have the 635 // information to generate it at the very end. So we divert the bytes 636 // we are generating to a temporary stream. 637 if (pending_elf_relocation_table_type) // Can't have two relocation 638 // tables. 639 return false; 640 641 pending_elf_relocation_table_type = R_ARM_RELATIVE; 642 output = &bytes_following_relocation_table; 643 break; 644 } 645 646 case MAKE_ELF_RELOCATION_TABLE: { 647 // We can see the base relocation anywhere, but we only have the 648 // information to generate it at the very end. So we divert the bytes 649 // we are generating to a temporary stream. 650 if (pending_elf_relocation_table_type) // Can't have two relocation 651 // tables. 652 return false; 653 654 pending_elf_relocation_table_type = R_386_RELATIVE; 655 output = &bytes_following_relocation_table; 656 break; 657 } 658 } 659 } 660 661 if (pending_pe_relocation_table) { 662 if (!GeneratePeRelocations(final_buffer) || 663 !final_buffer->Append(&bytes_following_relocation_table)) 664 return false; 665 } 666 667 if (pending_elf_relocation_table_type) { 668 if (!GenerateElfRelocations(pending_elf_relocation_table_type, 669 final_buffer) || 670 !final_buffer->Append(&bytes_following_relocation_table)) 671 return false; 672 } 673 674 // Final verification check: did we consume all lists? 675 if (ix_copy_counts != copy_counts_.size()) 676 return false; 677 if (ix_copy_bytes != copy_bytes_.size()) 678 return false; 679 if (ix_abs32_ix != abs32_ix_.size()) 680 return false; 681 if (ix_rel32_ix != rel32_ix_.size()) 682 return false; 683 684 return true; 685 } 686 687 // RelocBlock has the layout of a block of relocations in the base relocation 688 // table file format. 689 // 690 struct RelocBlockPOD { 691 uint32 page_rva; 692 uint32 block_size; 693 uint16 relocs[4096]; // Allow up to one relocation per byte of a 4k page. 694 }; 695 696 COMPILE_ASSERT(offsetof(RelocBlockPOD, relocs) == 8, reloc_block_header_size); 697 698 class RelocBlock { 699 public: 700 RelocBlock() { 701 pod.page_rva = ~0; 702 pod.block_size = 8; 703 } 704 705 void Add(uint16 item) { 706 pod.relocs[(pod.block_size-8)/2] = item; 707 pod.block_size += 2; 708 } 709 710 CheckBool Flush(SinkStream* buffer) WARN_UNUSED_RESULT { 711 bool ok = true; 712 if (pod.block_size != 8) { 713 if (pod.block_size % 4 != 0) { // Pad to make size multiple of 4 bytes. 714 Add(0); 715 } 716 ok = buffer->Write(&pod, pod.block_size); 717 pod.block_size = 8; 718 } 719 return ok; 720 } 721 RelocBlockPOD pod; 722 }; 723 724 CheckBool EncodedProgram::GeneratePeRelocations(SinkStream* buffer) { 725 std::sort(abs32_relocs_.begin(), abs32_relocs_.end()); 726 727 RelocBlock block; 728 729 bool ok = true; 730 for (size_t i = 0; ok && i < abs32_relocs_.size(); ++i) { 731 uint32 rva = abs32_relocs_[i]; 732 uint32 page_rva = rva & ~0xFFF; 733 if (page_rva != block.pod.page_rva) { 734 ok &= block.Flush(buffer); 735 block.pod.page_rva = page_rva; 736 } 737 if (ok) 738 block.Add(0x3000 | (rva & 0xFFF)); 739 } 740 ok &= block.Flush(buffer); 741 return ok; 742 } 743 744 CheckBool EncodedProgram::GenerateElfRelocations(Elf32_Word r_info, 745 SinkStream* buffer) { 746 std::sort(abs32_relocs_.begin(), abs32_relocs_.end()); 747 748 Elf32_Rel relocation_block; 749 750 relocation_block.r_info = r_info; 751 752 bool ok = true; 753 for (size_t i = 0; ok && i < abs32_relocs_.size(); ++i) { 754 relocation_block.r_offset = abs32_relocs_[i]; 755 ok = buffer->Write(&relocation_block, sizeof(Elf32_Rel)); 756 } 757 758 return ok; 759 } 760 //////////////////////////////////////////////////////////////////////////////// 761 762 Status WriteEncodedProgram(EncodedProgram* encoded, SinkStreamSet* sink) { 763 if (!encoded->WriteTo(sink)) 764 return C_STREAM_ERROR; 765 return C_OK; 766 } 767 768 Status ReadEncodedProgram(SourceStreamSet* streams, EncodedProgram** output) { 769 EncodedProgram* encoded = new EncodedProgram(); 770 if (encoded->ReadFrom(streams)) { 771 *output = encoded; 772 return C_OK; 773 } 774 delete encoded; 775 return C_DESERIALIZATION_FAILED; 776 } 777 778 Status Assemble(EncodedProgram* encoded, SinkStream* buffer) { 779 bool assembled = encoded->AssembleTo(buffer); 780 if (assembled) 781 return C_OK; 782 return C_ASSEMBLY_FAILED; 783 } 784 785 void DeleteEncodedProgram(EncodedProgram* encoded) { 786 delete encoded; 787 } 788 789 } // end namespace 790