[Courgette] Fix ELF reference sorting.

courgette/disassembler_elf_32.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "courgette/disassembler_elf_32.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/bind.h"
@@ skipping 163 matching lines @@
     return false;
 
   PrecomputeLabels(program);
   RemoveUnusedRel32Locations(program);
 
   if (!program->GenerateInstructions(
           base::Bind(&DisassemblerElf32::ParseFile, base::Unretained(this)))) {
     return false;
   }
 
-  // Finally sort rel32 locations.
-  std::sort(rel32_locations_.begin(),
-            rel32_locations_.end(),
-            TypedRVA::IsLessThanByRVA);
-  DCHECK(rel32_locations_.empty() ||
-         rel32_locations_.back()->rva() != kUnassignedRVA);
-
   program->DefaultAssignIndexes();
   return true;
 }
 
 CheckBool DisassemblerElf32::IsValidTargetRVA(RVA rva) const {
   if (rva == kUnassignedRVA)
     return false;
 
   // |rva| is valid if it's contained in any program segment.
   for (Elf32_Half segment_id = 0; segment_id < ProgramSegmentHeaderCount();
@@ skipping 176 matching lines @@
     if (section_name != ".text")
       continue;
 
     found_rel32 = true;
     if (!ParseRel32RelocsFromSection(section_header))
       return false;
   }
   if (!found_rel32)
     VLOG(1) << "Warning: Found no rel32 addresses. Missing .text section?";
 
+  std::sort(rel32_locations_.begin(), rel32_locations_.end(),
+            TypedRVA::IsLessThanByRVA);
+  DCHECK(rel32_locations_.empty() ||
+         rel32_locations_.back()->rva() != kUnassignedRVA);
+
   return true;
 }
 
 RvaVisitor* DisassemblerElf32::CreateAbs32TargetRvaVisitor() {
   return new RvaVisitor_Abs32(abs32_locations_, *this);
 }
 
 RvaVisitor* DisassemblerElf32::CreateRel32TargetRvaVisitor() {
   return new Elf32RvaVisitor_Rel32(rel32_locations_);
 }
@@ skipping 14 matching lines @@
     }
   }
   rel32_locations_.resize(std::distance(rel32_locations_.begin(), tail_it));
 }
 
 CheckBool DisassemblerElf32::ParseFile(AssemblyProgram* program,
                                        InstructionReceptor* receptor) const {
   // Walk all the bytes in the file, whether or not in a section.
   FileOffset file_offset = 0;
 
-  std::vector<FileOffset> abs_offsets;
-
   // File parsing follows file offset order, and we visit abs32 and rel32
   // locations in lockstep. Therefore we need to extract and sort file offsets
-  // of all abs32 and rel32 locations.
+  // of all abs32 and rel32 locations. For abs32, we copy the offsets to a new
+  // array.
+  std::vector<FileOffset> abs_offsets;
   if (!RVAsToFileOffsets(abs32_locations_, &abs_offsets))
     return false;
-  std::sort(abs32_locations_.begin(), abs32_locations_.end());
+  std::sort(abs_offsets.begin(), abs_offsets.end());
 
+  // For rel32, TypedRVA (rather than raw offset) is stored, so sort-by-offset
+  // is performed in place to save memory. At the end of function we will
+  // sort-by-RVA.
   if (!RVAsToFileOffsets(&rel32_locations_))
     return false;
   std::sort(rel32_locations_.begin(),
             rel32_locations_.end(),
             TypedRVA::IsLessThanByFileOffset);
 
   std::vector<FileOffset>::iterator current_abs_offset = abs_offsets.begin();
   std::vector<FileOffset>::iterator end_abs_offset = abs_offsets.end();
 
   std::vector<std::unique_ptr<TypedRVA>>::iterator current_rel =
@@ skipping 49 matching lines @@
                   << section_header->sh_type;
         }
         break;
     }
   }
 
   // Rest of the file past the last section
   if (!ParseSimpleRegion(file_offset, length(), receptor))
     return false;
 
+  // Restore original rel32 location order and sort by RVA order.
+  std::sort(rel32_locations_.begin(), rel32_locations_.end(),
+            TypedRVA::IsLessThanByRVA);
+
   // Make certain we consume all of the relocations as expected
   return (current_abs_offset == end_abs_offset);
 }
 
 CheckBool DisassemblerElf32::ParseProgbitsSection(
     const Elf32_Shdr* section_header,
     std::vector<FileOffset>::iterator* current_abs_offset,
     std::vector<FileOffset>::iterator end_abs_offset,
     std::vector<std::unique_ptr<TypedRVA>>::iterator* current_rel,
     std::vector<std::unique_ptr<TypedRVA>>::iterator end_rel,
@@ skipping 112 matching lines @@
         case SHT_PROGBITS:
           return true;
       }
     }
   }
 
   return false;
 }
 
 }  // namespace courgette