xref: /aosp_15_r20/external/pigweed/pw_elf/reader.cc (revision 61c4878ac05f98d0ceed94b57d316916de578985)

// Copyright 2024 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.

#include "pw_elf/reader.h"

#include "pw_bytes/endian.h"
#include "pw_log/log.h"
#include "pw_status/try.h"

namespace pw::elf {
namespace {

using ElfIdent = std::array<unsigned char, EI_NIDENT>;

Result<pw::endian> ElfIdentGetEndian(const ElfIdent& e_ident) {
  switch (e_ident[EI_DATA]) {
    case ELFDATA2LSB:
      // Encoding ELFDATA2LSB specifies 2's complement values, with the least
      // significant byte occupying the lowest address.
      return pw::endian::little;
    case ELFDATA2MSB:
      // Encoding ELFDATA2MSB specifies 2's complement values, with the most
      // significant byte occupying the lowest address.
      return pw::endian::big;
    default:
      return Status::OutOfRange();
  }
}

enum class ElfClass {
  kElf32,
  kElf64,
};

Result<ElfClass> ElfIdentGetElfClass(const ElfIdent& e_ident) {
  switch (e_ident[EI_CLASS]) {
    case ELFCLASS32:
      return ElfClass::kElf32;
    case ELFCLASS64:
      return ElfClass::kElf64;
    default:
      return Status::OutOfRange();
  }
}

Result<internal::ElfReaderImpls> MakeReaderImpl(
    ElfClass elf_class, stream::SeekableReader& stream) {
  switch (elf_class) {
    case ElfClass::kElf32:
      return internal::ElfReaderImpl32::FromStream(stream);
#if UINTPTR_MAX == UINT64_MAX
    case ElfClass::kElf64:
      return internal::ElfReaderImpl64::FromStream(stream);
#endif
    default:
      return Status::Unimplemented();
  }
}

}  // namespace

Result<ElfReader> ElfReader::FromStream(stream::SeekableReader& stream) {
  PW_TRY(stream.Seek(0));

  // Read the e_ident field of the ELF header.
  PW_TRY_ASSIGN(ElfIdent e_ident, internal::ReadObject<ElfIdent>(stream));
  PW_TRY(stream.Seek(0));

  // Validate e_ident.
  if (!(e_ident[EI_MAG0] == ELFMAG0 && e_ident[EI_MAG1] == ELFMAG1 &&
        e_ident[EI_MAG2] == ELFMAG2 && e_ident[EI_MAG3] == ELFMAG3)) {
    PW_LOG_ERROR("Invalid ELF magic bytes");
    return Status::DataLoss();
  }

  auto endian = ElfIdentGetEndian(e_ident);
  if (!endian.ok()) {
    return Status::DataLoss();
  }
  if (endian.value() != pw::endian::native) {
    // Only native endian is supported.
    PW_LOG_ERROR("Non-native ELF endian not supported");
    return Status::Unimplemented();
  }

  auto elf_class = ElfIdentGetElfClass(e_ident);
  if (!elf_class.ok()) {
    return Status::DataLoss();
  }

  PW_TRY_ASSIGN(auto impl, MakeReaderImpl(elf_class.value(), stream));
  return ElfReader(std::move(impl));
}

Result<std::vector<std::byte>> ElfReader::ReadSection(std::string_view name) {
  StatusWithSize size = SeekToSection(name);
  if (!size.ok()) {
    return size.status();
  }

  std::vector<std::byte> data;
  data.resize(size.size());
  PW_TRY(stream().ReadExact(data));

  return data;
}

namespace internal {

// TODO(jrreinhart): Move to pw_stream
Result<std::string> ReadNullTermString(stream::Reader& stream) {
  std::string result;
  while (true) {
    PW_TRY_ASSIGN(char c, ReadObject<char>(stream));
    if (c == '\0') {
      break;
    }
    result += c;
  }
  return result;
}

}  // namespace internal
}  // namespace pw::elf