examples/aarch32/disasm-a32.cc

// Copyright 2016, VIXL authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of ARM Limited nor the names of its contributors may be
//     used to endorse or promote products derived from this software without
//     specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// The example assumes support for ELF binaries.
#ifdef __linux__

extern "C" {
#include <elf.h>
#include <fcntl.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
}

#include <cerrno>
#include <iostream>
#include <map>
#include <string>

#include "globals-vixl.h"
#include "aarch32/disasm-aarch32.h"
#include "aarch32/instructions-aarch32.h"

class Symbol {
  Elf32_Addr addr_;
  int32_t offset_;
  uint32_t size_;
  int section_;
  std::string name_;

 public:
  Symbol(const char* name,
         Elf32_Addr addr,
         int32_t offset,
         uint32_t size,
         int section)
      : addr_(addr),
        offset_(offset),
        size_(size),
        section_(section),
        name_(name) {}
  Symbol(const Symbol& ref)
      : addr_(ref.addr_),
        offset_(ref.offset_),
        size_(ref.size_),
        section_(ref.section_),
        name_(ref.name_) {}

  Elf32_Addr GetAddress() const { return addr_; }
  Elf32_Addr GetMemoryAddress() const { return (addr_ & ~1) + offset_; }
  uint32_t GetSize() const { return size_; }
  const std::string& GetName() const { return name_; }
  int GetSection() const { return section_; }
};


class SymbolTable : public std::map<Elf32_Addr, Symbol> {
 public:
  void insert(const Symbol& sym) {
    VIXL_ASSERT(find(sym.GetAddress()) == end());
    std::map<Elf32_Addr, Symbol>::insert(
        std::make_pair(sym.GetMemoryAddress(), sym));
  }
};


class SectionLocator {
  const Elf32_Shdr* shdr_;
  int nsections_;
  const char* shstrtab_;

 public:
  explicit SectionLocator(const Elf32_Ehdr* ehdr) {
    shdr_ = reinterpret_cast<const Elf32_Shdr*>(
        reinterpret_cast<const char*>(ehdr) + ehdr->e_shoff);
    // shstrtab holds the section names as an offset in the file.
    shstrtab_ =
        reinterpret_cast<const char*>(ehdr) + shdr_[ehdr->e_shstrndx].sh_offset;
    nsections_ = ehdr->e_shnum;
  }

  const Elf32_Shdr* Locate(Elf32_Word type,
                           const std::string& section_name) const {
    for (int shnum = 1; shnum < nsections_; shnum++) {
      if ((shdr_[shnum].sh_type == type) &&
          std::string(shstrtab_ + shdr_[shnum].sh_name) == section_name) {
        return &shdr_[shnum];
      }
    }
    return NULL;
  }
};


template <typename VISITOR>
void LocateSymbols(const Elf32_Ehdr* ehdr,
                   const Elf32_Shdr* symtab,
                   const Elf32_Shdr* strtab,
                   VISITOR* visitor) {
  if ((symtab != NULL) && (strtab != NULL)) {
    const Elf32_Shdr* shdr = reinterpret_cast<const Elf32_Shdr*>(
        reinterpret_cast<const char*>(ehdr) + ehdr->e_shoff);

    const char* symnames =
        reinterpret_cast<const char*>(ehdr) + strtab->sh_offset;
    VIXL_CHECK(symnames != NULL);

    int nsym = symtab->sh_size / symtab->sh_entsize;
    const Elf32_Sym* sym = reinterpret_cast<const Elf32_Sym*>(
        reinterpret_cast<const char*>(ehdr) + symtab->sh_offset);
    for (int snum = 0; snum < nsym; snum++) {
      if ((sym[snum].st_shndx > 0) && (sym[snum].st_shndx < ehdr->e_shnum) &&
          (sym[snum].st_value != 0) &&
          (shdr[sym[snum].st_shndx].sh_type == SHT_PROGBITS) &&
          ((ELF32_ST_BIND(sym[snum].st_info) == STB_LOCAL) ||
           (ELF32_ST_BIND(sym[snum].st_info) == STB_GLOBAL)) &&
          (ELF32_ST_TYPE(sym[snum].st_info) == STT_FUNC)) {
        visitor->visit(symnames + sym[snum].st_name, sym[snum]);
      }
    }
  }
}


class DynamicSymbolVisitor {
  SymbolTable* symbols_;

 public:
  explicit DynamicSymbolVisitor(SymbolTable* symbols) : symbols_(symbols) {}
  void visit(const char* symname, const Elf32_Sym& sym) {
    symbols_->insert(
        Symbol(symname, sym.st_value, 0, sym.st_size, sym.st_shndx));
  }
};


class StaticSymbolVisitor {
  const Elf32_Ehdr* ehdr_;
  const Elf32_Shdr* shdr_;
  SymbolTable* symbols_;

 public:
  StaticSymbolVisitor(const Elf32_Ehdr* ehdr, SymbolTable* symbols)
      : ehdr_(ehdr),
        shdr_(reinterpret_cast<const Elf32_Shdr*>(
            reinterpret_cast<const char*>(ehdr) + ehdr->e_shoff)),
        symbols_(symbols) {}
  void visit(const char* symname, const Elf32_Sym& sym) {
    if (ehdr_->e_type == ET_REL) {
      symbols_->insert(Symbol(symname,
                              sym.st_value,
                              shdr_[sym.st_shndx].sh_offset,
                              sym.st_size,
                              sym.st_shndx));
    } else {
      symbols_->insert(
          Symbol(symname,
                 sym.st_value,
                 shdr_[sym.st_shndx].sh_offset - shdr_[sym.st_shndx].sh_addr,
                 sym.st_size,
                 sym.st_shndx));
    }
  }
};


void usage() {
  std::cout << "usage: disasm-a32 <file>\n"
               "where <file> is an ELF ARM binaryfile, either an executable, "
               "a shared object, or an object file."
            << std::endl;
}


int main(int argc, char** argv) {
  const int kErrorNotARMELF32 = -1;
  const int kErrorArguments = -2;
  if (argc < 2) {
    usage();
    return kErrorArguments;
  }

  const char* filename = argv[1];
  struct stat sb;


  if (lstat(filename, &sb) == -1) {
    std::cerr << "Cannot stat this file" << filename << std::endl;
    return errno;
  }

  if (S_ISLNK(sb.st_mode)) {
    static char linkname[4096];
    filename = realpath(argv[1], linkname);
    if (lstat(linkname, &sb) == -1) {
      std::cerr << "Cannot stat this file: " << linkname << std::endl;
      return errno;
    }
  }

  int elf_in;
  if ((elf_in = open(filename, O_RDONLY)) < 0) {
    std::cerr << "Cannot open: " << argv[1];
    if (filename != argv[1]) std::cerr << " aka " << filename;
    std::cerr << std::endl;
    return errno;
  }

  char* base_addr;
  VIXL_CHECK((base_addr = reinterpret_cast<char*>(
                  mmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, elf_in, 0))) !=
             0);

  const Elf32_Ehdr* ehdr = reinterpret_cast<const Elf32_Ehdr*>(base_addr);
  if ((ehdr->e_ident[0] != 0x7f) || (ehdr->e_ident[1] != 'E') ||
      (ehdr->e_ident[2] != 'L') || (ehdr->e_ident[3] != 'F') ||
      (ehdr->e_ehsize != sizeof(Elf32_Ehdr))) {
    std::cerr << "This file is not an 32-bit ELF file." << std::endl;
    munmap(base_addr, sb.st_size);
    return kErrorNotARMELF32;
  }

  if (ehdr->e_machine != EM_ARM) {
    std::cerr << "This file is not using the ARM isa." << std::endl;
    munmap(base_addr, sb.st_size);
    return kErrorNotARMELF32;
  }

  // shstrtab holds the section names as an offset in the file.
  const Elf32_Shdr* shdr =
      reinterpret_cast<const Elf32_Shdr*>(base_addr + ehdr->e_shoff);

  SectionLocator section_locator(ehdr);

  SymbolTable symbol_names;

  // Traverse the dynamic symbols defined in any text section
  DynamicSymbolVisitor dynamic_visitor(&symbol_names);
  LocateSymbols(ehdr,
                section_locator.Locate(SHT_DYNSYM, ".dynsym"),
                section_locator.Locate(SHT_STRTAB, ".dynstr"),
                &dynamic_visitor);

  // Traverse the static symbols defined in the any test section
  StaticSymbolVisitor static_visitor(ehdr, &symbol_names);
  LocateSymbols(ehdr,
                section_locator.Locate(SHT_SYMTAB, ".symtab"),
                section_locator.Locate(SHT_STRTAB, ".strtab"),
                &static_visitor);


  vixl::aarch32::PrintDisassembler dis(std::cout, 0);
  for (SymbolTable::iterator sres = symbol_names.begin();
       sres != symbol_names.end();
       sres++) {
    const Symbol& symbol = sres->second;
    uint32_t func_addr = symbol.GetAddress();
    uint32_t func_size = symbol.GetSize();
    if (func_size == 0) {
      SymbolTable::iterator next_func = sres;
      next_func++;
      if (next_func == symbol_names.end()) {
        const Elf32_Shdr& shndx = shdr[sres->second.GetSection()];
        func_size = (shndx.sh_offset + shndx.sh_size) - sres->first;
      } else {
        func_size = next_func->first - sres->first;
      }
    }

    std::cout << "--- " << symbol.GetName() << ":" << std::endl;
    if ((func_addr & 1) == 1) {
      func_addr &= ~1;
      dis.SetCodeAddress(func_addr);
      dis.DisassembleT32Buffer(reinterpret_cast<uint16_t*>(
                                   base_addr + symbol.GetMemoryAddress()),
                               func_size);
    } else {
      dis.SetCodeAddress(func_addr);
      dis.DisassembleA32Buffer(reinterpret_cast<uint32_t*>(
                                   base_addr + symbol.GetMemoryAddress()),
                               func_size);
    }
  }
  munmap(base_addr, sb.st_size);
  return 0;
}


#else

#include "globals-vixl.h"

// TODO: Implement this example for macOS.
int main(void) {
  VIXL_WARNING("This example has not been implemented for macOS.");
  return 0;
}

#endif  // __linux__