Courgette: Add static method QuickDetect() to optimize program detection.

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 <utility>
 
@@ skipping 25 matching lines @@
 
 DisassemblerElf32::Elf32RvaVisitor_Rel32::Elf32RvaVisitor_Rel32(
     const std::vector<std::unique_ptr<TypedRVA>>& rva_locations)
     : VectorRvaVisitor<std::unique_ptr<TypedRVA>>(rva_locations) {
 }
 
 RVA DisassemblerElf32::Elf32RvaVisitor_Rel32::Get() const {
   return (*it_)->rva() + (*it_)->relative_target();
 }
 
-DisassemblerElf32::DisassemblerElf32(const void* start, size_t length)
+DisassemblerElf32::DisassemblerElf32(const uint8_t* start, size_t length)
     : Disassembler(start, length),
       header_(nullptr),
       section_header_table_size_(0),
       program_header_table_(nullptr),
       program_header_table_size_(0),
-      default_string_section_(nullptr) {
-}
+      default_string_section_(nullptr) {}
 
 RVA DisassemblerElf32::FileOffsetToRVA(FileOffset offset) const {
   // File offsets can be 64-bit values, but we are dealing with 32-bit
   // executables and so only need to support 32-bit file sizes.
   uint32_t offset32 = static_cast<uint32_t>(offset);
 
   // Visit section headers ordered by file offset.
   for (Elf32_Half section_id : section_header_file_offset_order_) {
     const Elf32_Shdr* section_header = SectionHeader(section_id);
     // These can appear to have a size in the file, but don't.
@@ skipping 145 matching lines @@
     Elf32_Addr begin = segment_header->p_vaddr;
     Elf32_Addr end = segment_header->p_vaddr + segment_header->p_memsz;
 
     if (rva >= begin && rva < end)
       return true;
   }
 
   return false;
 }
 
+// static
+bool DisassemblerElf32::QuickDetect(const uint8_t* start,
+                                    size_t length,
+                                    e_machine_values elf_em) {
+  if (length < sizeof(Elf32_Ehdr))
+    return false;
+
+  const Elf32_Ehdr* header = reinterpret_cast<const Elf32_Ehdr*>(start);
+
+  // Have magic for ELF header?
+  if (header->e_ident[0] != 0x7f || header->e_ident[1] != 'E' ||
+      header->e_ident[2] != 'L' || header->e_ident[3] != 'F')
+    return false;
+
+  if (header->e_type != ET_EXEC && header->e_type != ET_DYN)
+    return false;
+  if (header->e_machine != elf_em)
+    return false;
+  if (header->e_version != 1)
+    return false;
+  if (header->e_shentsize != sizeof(Elf32_Shdr))
+    return false;
+
+  return true;
+}
+
 bool DisassemblerElf32::UpdateLength() {
   Elf32_Off result = 0;
 
   // Find the end of the last section
   for (Elf32_Half section_id = 0; section_id < SectionHeaderCount();
        ++section_id) {
     const Elf32_Shdr* section_header = SectionHeader(section_id);
 
     if (section_header->sh_type == SHT_NOBITS)
       continue;
@@ skipping 370 matching lines @@
     if (!ParseRel32RelocsFromSection(section_header))
       return false;
   }
   if (!found_rel32)
     VLOG(1) << "Warning: Found no rel32 addresses. Missing .text section?";
 
   return true;
 }
 
 }  // namespace courgette