base/debug/test_elf_image_builder.cc

// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "base/debug/test_elf_image_builder.h"

#include <cstring>
#include <string_view>
#include <type_traits>
#include <utility>

#include "base/bits.h"
#include "base/check.h"
#include "base/notreached.h"
#include "build/build_config.h"

#if __SIZEOF_POINTER__ == 4
using Dyn = Elf32_Dyn;
using Nhdr = Elf32_Nhdr;
using Shdr = Elf32_Shdr;
#else
using Dyn = Elf64_Dyn;
using Nhdr = Elf64_Nhdr;
using Shdr = Elf64_Shdr;
#endif

namespace base {

namespace {
// Sizes/alignments to use in the ELF image.
static constexpr size_t kPageSize = 4096;
static constexpr size_t kPhdrAlign = 0x4;
static constexpr size_t kNoteAlign = 0x4;
static constexpr size_t kLoadAlign = 0x1000;
static constexpr size_t kDynamicAlign = 0x4;
}  // namespace

struct TestElfImageBuilder::LoadSegment {
  Word flags;
  Word size;
};

TestElfImage::TestElfImage(std::vector<uint8_t> buffer, const void* elf_start)
    : buffer_(std::move(buffer)), elf_start_(elf_start) {}

TestElfImage::~TestElfImage() = default;

TestElfImage::TestElfImage(TestElfImage&&) = default;

TestElfImage& TestElfImage::operator=(TestElfImage&&) = default;

TestElfImageBuilder::TestElfImageBuilder(MappingType mapping_type)
    : mapping_type_(mapping_type) {}

TestElfImageBuilder::~TestElfImageBuilder() = default;

TestElfImageBuilder& TestElfImageBuilder::AddLoadSegment(Word flags,
                                                         size_t size) {
  load_segments_.push_back({flags, static_cast<Word>(size)});
  return *this;
}

TestElfImageBuilder& TestElfImageBuilder::AddNoteSegment(
    Word type,
    std::string_view name,
    span<const uint8_t> desc) {
  const size_t name_with_null_size = name.size() + 1;
  std::vector<uint8_t> buffer(
      sizeof(Nhdr) + bits::AlignUp(name_with_null_size, size_t{4}) +
          bits::AlignUp(desc.size(), size_t{4}),
      '\0');
  uint8_t* loc = &buffer.front();
  Nhdr nhdr;
  nhdr.n_namesz = name_with_null_size;
  nhdr.n_descsz = desc.size();
  nhdr.n_type = type;
  loc = AppendHdr(nhdr, loc);

  memcpy(loc, name.data(), name.size());
  *(loc + name.size()) = '\0';
  loc += bits::AlignUp(name_with_null_size, size_t{4});

  memcpy(loc, &desc.front(), desc.size());
  loc += bits::AlignUp(desc.size(), size_t{4});

  DCHECK_EQ(&buffer.front() + buffer.size(), loc);

  note_contents_.push_back(std::move(buffer));

  return *this;
}

TestElfImageBuilder& TestElfImageBuilder::AddSoName(std::string_view soname) {
  DCHECK(!soname_.has_value());
  soname_.emplace(soname);
  return *this;
}

struct TestElfImageBuilder::ImageMeasures {
  size_t phdrs_required;
  size_t note_start;
  size_t note_size;
  std::vector<size_t> load_segment_start;
  size_t dynamic_start;
  size_t strtab_start;
  size_t total_size;
};

Addr TestElfImageBuilder::GetVirtualAddressForOffset(
    Off offset,
    const uint8_t* elf_start) const {
  switch (mapping_type_) {
    case RELOCATABLE:
      return static_cast<Addr>(offset);

    case RELOCATABLE_WITH_BIAS:
      return static_cast<Addr>(offset + kLoadBias);

    case NON_RELOCATABLE:
      return reinterpret_cast<Addr>(elf_start + offset);
  }
}

TestElfImageBuilder::ImageMeasures TestElfImageBuilder::MeasureSizesAndOffsets()
    const {
  ImageMeasures measures;

  measures.phdrs_required = 1 + load_segments_.size();
  if (!note_contents_.empty()) {
    ++measures.phdrs_required;
  }
  if (soname_.has_value()) {
    ++measures.phdrs_required;
  }

  // The current offset into the image, where the next bytes are to be written.
  // Starts after the ELF header.
  size_t offset = sizeof(Ehdr);

  // Add space for the program header table.
  offset = bits::AlignUp(offset, kPhdrAlign);
  offset += sizeof(Phdr) * measures.phdrs_required;

  // Add space for the notes.
  measures.note_start = offset;
  if (!note_contents_.empty()) {
    offset = bits::AlignUp(offset, kNoteAlign);
  }
  for (const std::vector<uint8_t>& contents : note_contents_) {
    offset += contents.size();
  }
  measures.note_size = offset - measures.note_start;

  // Add space for the load segments.
  for (auto it = load_segments_.begin(); it != load_segments_.end(); ++it) {
    // The first non PT_PHDR program header is expected to be a PT_LOAD and
    // start at the already-aligned start of the ELF header.
    if (it == load_segments_.begin()) {
      measures.load_segment_start.push_back(0);
    } else {
      offset = bits::AlignUp(offset, kLoadAlign);
      measures.load_segment_start.push_back(offset);
    }
    offset += it->size;
  }

  // Add space for the dynamic segment.
  measures.dynamic_start = bits::AlignUp(offset, kDynamicAlign);
  offset += sizeof(Dyn) * (soname_ ? 2 : 1);
  measures.strtab_start = offset;

  // Add space for the string table.
  ++offset;  // The first string table byte holds a null character.
  if (soname_) {
    offset += soname_->size() + 1;
  }

  measures.total_size = offset;

  return measures;
}

TestElfImage TestElfImageBuilder::Build() {
  ImageMeasures measures = MeasureSizesAndOffsets();

  // Write the ELF contents into |buffer|. Extends the buffer back to the 0
  // address in the case of load bias, so that the memory between the 0 address
  // and the image start is zero-initialized.
  const size_t load_bias =
      mapping_type_ == RELOCATABLE_WITH_BIAS ? kLoadBias : 0;
  std::vector<uint8_t> buffer(load_bias + (kPageSize - 1) + measures.total_size,
                              '\0');
  uint8_t* const elf_start =
      bits::AlignUp(&buffer.front() + load_bias, kPageSize);
  uint8_t* loc = elf_start;

  // Add the ELF header.
  loc = AppendHdr(CreateEhdr(measures.phdrs_required), loc);

  // Add the program header table.
  loc = bits::AlignUp(loc, kPhdrAlign);
  loc = AppendHdr(
      CreatePhdr(PT_PHDR, PF_R, kPhdrAlign, loc - elf_start,
                 GetVirtualAddressForOffset(loc - elf_start, elf_start),
                 sizeof(Phdr) * measures.phdrs_required),
      loc);
  for (size_t i = 0; i < load_segments_.size(); ++i) {
    const LoadSegment& load_segment = load_segments_[i];
    size_t size = load_segment.size;
    // The first non PT_PHDR program header is expected to be a PT_LOAD and
    // encompass all the preceding headers.
    if (i == 0) {
      size += loc - elf_start;
    }