ELF.cpp

Go to the documentation of this file.

//===- llvm/BinaryFormat/ELF.cpp - The ELF format ---------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/ADT/Enum.h"
#include "llvm/ADT/StringSwitch.h"
 
using namespace llvm;
using namespace ELF;
 
constexpr EnumStringDef<uint16_t> ElfMachineArchDefs[] = {
#define ELF_MACHINE(em, num, arch, gnuname) {{arch}, em},
#include "llvm/BinaryFormat/ELF.def"
};
constexpr auto ElfMachineArchs = BUILD_ENUM_STRINGS(ElfMachineArchDefs);
 
/// Convert an architecture name into ELF's e_machine value.
uint16_t ELF::convertArchNameToEMachine(StringRef Arch) {
  std::string LowerArch = Arch.lower();
  if (const auto *E = EnumStrings(ElfMachineArchs).fromString(LowerArch))
    return E->value();
  return EM_NONE;
}
 
uint16_t ELF::convertTripleArchTypeToEMachine(Triple::ArchType ArchType) {
  switch (ArchType) {
  case Triple::UnknownArch:
  default:
    return EM_NONE;
 
  case Triple::arm:
  case Triple::armeb:
  case Triple::thumb:
  case Triple::thumbeb:
    return EM_ARM;
  case Triple::aarch64:
  case Triple::aarch64_be:
  case Triple::aarch64_32:
    return EM_AARCH64;
  case Triple::arc:
    return EM_ARC;
  case Triple::avr:
    return EM_AVR;
  case Triple::bpfel:
  case Triple::bpfeb:
    return EM_BPF;
  case Triple::csky:
    return EM_CSKY;
  case Triple::hexagon:
    return EM_HEXAGON;
  case Triple::loongarch32:
  case Triple::loongarch64:
    return EM_LOONGARCH;
  case Triple::m68k:
    return EM_68K;
  case Triple::mips:
  case Triple::mipsel:
  case Triple::mips64:
  case Triple::mips64el:
    return EM_MIPS;
  case Triple::msp430:
    return EM_MSP430;
  case Triple::ppc:
  case Triple::ppcle:
    return EM_PPC;
  case Triple::ppc64:
  case Triple::ppc64le:
    return EM_PPC;
  case Triple::riscv32:
  case Triple::riscv64:
    return EM_RISCV;
  case Triple::sparc:
  case Triple::sparcel:
    return EM_SPARC;
  case Triple::sparcv9:
    return EM_SPARCV9;
  case Triple::systemz:
    return EM_S390;
  case Triple::x86:
    return EM_386;
  case Triple::x86_64:
    return EM_X86_64;
  case Triple::xcore:
    return EM_XCORE;
  case Triple::xtensa:
    return EM_XTENSA;
  }
}
 
/// Convert an ELF's e_machine value into an architecture name.
StringRef ELF::convertEMachineToArchName(uint16_t EMachine) {
  if (StringRef S = EnumStrings(ElfMachineArchs).toString(EMachine); !S.empty())
    return S;
  return "None";
}
 
uint8_t ELF::convertNameToOSABI(StringRef Name) {
  return StringSwitch<uint16_t>(Name)
      .StartsWith("hpux", ELFOSABI_HPUX)
      .StartsWith("netbsd", ELFOSABI_NETBSD)
      .StartsWith("gnu", ELFOSABI_GNU)
      .StartsWith("hurd", ELFOSABI_HURD)
      .StartsWith("solaris", ELFOSABI_SOLARIS)
      .StartsWith("aix", ELFOSABI_AIX)
      .StartsWith("irix", ELFOSABI_IRIX)
      .StartsWith("freebsd", ELFOSABI_FREEBSD)
      .StartsWith("tru64", ELFOSABI_TRU64)
      .StartsWith("modesto", ELFOSABI_MODESTO)
      .StartsWith("openbsd", ELFOSABI_OPENBSD)
      .StartsWith("openvms", ELFOSABI_OPENVMS)
      .StartsWith("nsk", ELFOSABI_NSK)
      .StartsWith("aros", ELFOSABI_AROS)
      .StartsWith("fenixos", ELFOSABI_FENIXOS)
      .StartsWith("cloudabi", ELFOSABI_CLOUDABI)
      .StartsWith("cuda", ELFOSABI_CUDA)
      .StartsWith("amdhsa", ELFOSABI_AMDGPU_HSA)
      .StartsWith("amdpal", ELFOSABI_AMDGPU_PAL)
      .StartsWith("mesa3d", ELFOSABI_AMDGPU_MESA3D)
      .StartsWith("arm", ELFOSABI_ARM)
      .StartsWith("standalone", ELFOSABI_STANDALONE)
      .StartsWith("none", ELFOSABI_NONE)
      .Default(ELFOSABI_NONE);
}
 
StringRef ELF::convertOSABIToName(uint8_t OSABI) {
  switch (OSABI) {
  case ELFOSABI_HPUX:
    return "hpux";
  case ELFOSABI_NETBSD:
    return "netbsd";
  case ELFOSABI_GNU:
    return "gnu";
  case ELFOSABI_HURD:
    return "hurd";
  case ELFOSABI_SOLARIS:
    return "solaris";
  case ELFOSABI_AIX:
    return "aix";
  case ELFOSABI_IRIX:
    return "irix";
  case ELFOSABI_FREEBSD:
    return "freebsd";
  case ELFOSABI_TRU64:
    return "tru64";
  case ELFOSABI_MODESTO:
    return "modesto";
  case ELFOSABI_OPENBSD:
    return "openbsd";
  case ELFOSABI_OPENVMS:
    return "openvms";
  case ELFOSABI_NSK:
    return "nsk";
  case ELFOSABI_AROS:
    return "aros";
  case ELFOSABI_FENIXOS:
    return "fenixos";
  case ELFOSABI_CLOUDABI:
    return "cloudabi";
  case ELFOSABI_CUDA:
    return "cuda";
  case ELFOSABI_AMDGPU_HSA:
    return "amdhsa";
  case ELFOSABI_AMDGPU_PAL:
    return "amdpal";
  case ELFOSABI_AMDGPU_MESA3D:
    return "mesa3d";
  case ELFOSABI_ARM:
    return "arm";
  case ELFOSABI_STANDALONE:
    return "standalone";
  default:
    return "none";
  }
}