breakpad/linux-x86/include/breakpad/common/linux/synth_elf.h

// -*- mode: C++ -*-

// Copyright (c) 2011, Google Inc.
// 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 Google Inc. 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 AND 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.

// Original author: Ted Mielczarek <ted.mielczarek@gmail.com>

// synth_elf.h: Interface to synth_elf::ELF: fake ELF generator.

#ifndef COMMON_LINUX_SYNTH_ELF_H_
#define COMMON_LINUX_SYNTH_ELF_H_

#include "common/test_assembler.h"

#include <list>
#include <vector>
#include <map>
#include <string>
#include <utility>

#include "common/using_std_string.h"

namespace google_breakpad {
namespace synth_elf {

using std::list;
using std::vector;
using std::map;
using std::pair;
using test_assembler::Endianness;
using test_assembler::kLittleEndian;
using test_assembler::kUnsetEndian;
using test_assembler::Label;
using test_assembler::Section;

// String tables are common in ELF headers, so subclass Section
// to make them easy to generate.
class StringTable : public Section {
public:
  StringTable(Endianness endianness = kUnsetEndian)
  : Section(endianness) {
    start() = 0;
    empty_string = Add("");
  }

  // Add the string s to the string table, and return
  // a label containing the offset into the string table
  // at which it was added.
  Label Add(const string& s) {
    if (strings_.find(s) != strings_.end())
      return strings_[s];

    Label string_label(Here());
    AppendCString(s);
    strings_[s] = string_label;
    return string_label;
  }

  // All StringTables contain an empty string as their first
  // entry.
  Label empty_string;

  // Avoid inserting duplicate strings.
  map<string,Label> strings_;
};

// A Section representing an entire ELF file.
class ELF : public Section {
 public:
  ELF(uint16_t machine,    // EM_386, etc
      uint8_t file_class,  // ELFCLASS{32,64}
      Endianness endianness = kLittleEndian);

  // Add the Section section to the section header table and append it
  // to the file. Returns the index of the section in the section
  // header table.
  int AddSection(const string& name, const Section& section,
                 uint32_t type, uint32_t flags = 0, uint64_t addr = 0,
                 uint32_t link = 0, uint64_t entsize = 0, uint64_t offset = 0);
                  
  // Add a segment containing from section index start to section index end.
  // The indexes must have been gotten from AddSection.
  void AddSegment(int start, int end, uint32_t type, uint32_t flags = 0);

  // Write out all data. GetContents may be used after this.
  void Finish();

 private:
  // Size of an address, in bytes.
  const size_t addr_size_;

  // Offset to the program header table.
  Label program_header_label_;
  // Number of entries in the program header table.
  int program_count_;
  Label program_count_label_;
  // The program header table itself.
  Section program_header_table_;

  // Offset to the section header table.
  Label section_header_label_;
  // Number of entries in the section header table.
  int section_count_;
  Label section_count_label_;
  // The section header table itself.
  Section section_header_table_;

  // Index of the section header string table in the section
  // header table.
  Label section_header_string_index_;
  // Section containing the names of section header table entries.
  StringTable section_header_strings_;

  // Record of an added section
  struct ElfSection : public Section {
    ElfSection(const Section& section, uint32_t type, uint32_t addr,
               uint32_t offset, Label offset_label, uint32_t size)
    : Section(section), type_(type), addr_(addr), offset_(offset)
    , offset_label_(offset_label), size_(size) {
    }

    uint32_t type_;
    uint32_t addr_;
    uint32_t offset_;
    Label offset_label_;
    uint32_t size_;
  };

  vector<ElfSection> sections_;

  void AppendSection(ElfSection &section);
};

// A class to build .symtab or .dynsym sections.
class SymbolTable : public Section {
 public:
  // table is the StringTable that contains symbol names. The caller
  // must ensure that it remains alive for the life of the
  // SymbolTable.
  SymbolTable(Endianness endianness, size_t addr_size, StringTable& table);

  // Add an Elf32_Sym.
  void AddSymbol(const string& name, uint32_t value,
                 uint32_t size, unsigned info, uint16_t shndx);
  // Add an Elf64_Sym.
  void AddSymbol(const string& name, uint64_t value,
                 uint64_t size, unsigned info, uint16_t shndx);

 private:
  size_t addr_size_;
  StringTable& table_;
};

// A class for note sections
class Notes : public Section {
public:
  Notes(Endianness endianness)
  : Section(endianness) {
  }

  // Add a note.
  void AddNote(int type, const string &name, const uint8_t* desc_bytes,
               size_t desc_size);
};

}  // namespace synth_elf
}  // namespace google_breakpad

#endif  // COMMON_LINUX_SYNTH_ELF_H_