LCOV - code coverage report
Current view: top level - lib/Object - ELFObjectFile.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 134 169 79.3 %
Date: 2018-09-23 13:06:45 Functions: 11 12 91.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ELFObjectFile.cpp - ELF object file implementation -----------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // Part of the ELFObjectFile class implementation.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/Object/ELFObjectFile.h"
      15             : #include "llvm/ADT/Triple.h"
      16             : #include "llvm/BinaryFormat/ELF.h"
      17             : #include "llvm/MC/MCInstrAnalysis.h"
      18             : #include "llvm/MC/SubtargetFeature.h"
      19             : #include "llvm/Object/ELF.h"
      20             : #include "llvm/Object/ELFTypes.h"
      21             : #include "llvm/Object/Error.h"
      22             : #include "llvm/Support/ARMAttributeParser.h"
      23             : #include "llvm/Support/ARMBuildAttributes.h"
      24             : #include "llvm/Support/Endian.h"
      25             : #include "llvm/Support/ErrorHandling.h"
      26             : #include "llvm/Support/MathExtras.h"
      27             : #include "llvm/Support/TargetRegistry.h"
      28             : #include <algorithm>
      29             : #include <cstddef>
      30             : #include <cstdint>
      31             : #include <memory>
      32             : #include <string>
      33             : #include <system_error>
      34             : #include <utility>
      35             : 
      36             : using namespace llvm;
      37             : using namespace object;
      38             : 
      39       19197 : ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
      40       19197 :     : ObjectFile(Type, Source) {}
      41             : 
      42             : template <class ELFT>
      43             : static Expected<std::unique_ptr<ELFObjectFile<ELFT>>>
      44        6254 : createPtr(MemoryBufferRef Object) {
      45       12508 :   auto Ret = ELFObjectFile<ELFT>::create(Object);
      46        6254 :   if (Error E = Ret.takeError())
      47             :     return std::move(E);
      48             :   return make_unique<ELFObjectFile<ELFT>>(std::move(*Ret));
      49             : }
      50         226 : 
      51         452 : Expected<std::unique_ptr<ObjectFile>>
      52         226 : ObjectFile::createELFObjectFile(MemoryBufferRef Obj) {
      53             :   std::pair<unsigned char, unsigned char> Ident =
      54             :       getElfArchType(Obj.getBuffer());
      55             :   std::size_t MaxAlignment =
      56        4617 :       1ULL << countTrailingZeros(uintptr_t(Obj.getBufferStart()));
      57        9234 : 
      58        4617 :   if (MaxAlignment < 2)
      59             :     return createError("Insufficient alignment");
      60             : 
      61             :   if (Ident.first == ELF::ELFCLASS32) {
      62         278 :     if (Ident.second == ELF::ELFDATA2LSB)
      63         556 :       return createPtr<ELF32LE>(Obj);
      64         278 :     else if (Ident.second == ELF::ELFDATA2MSB)
      65             :       return createPtr<ELF32BE>(Obj);
      66             :     else
      67             :       return createError("Invalid ELF data");
      68        1133 :   } else if (Ident.first == ELF::ELFCLASS64) {
      69        2266 :     if (Ident.second == ELF::ELFDATA2LSB)
      70        1133 :       return createPtr<ELF64LE>(Obj);
      71             :     else if (Ident.second == ELF::ELFDATA2MSB)
      72             :       return createPtr<ELF64BE>(Obj);
      73             :     else
      74             :       return createError("Invalid ELF data");
      75             :   }
      76        6257 :   return createError("Invalid ELF class");
      77             : }
      78             : 
      79             : SubtargetFeatures ELFObjectFileBase::getMIPSFeatures() const {
      80        6257 :   SubtargetFeatures Features;
      81             :   unsigned PlatformFlags = getPlatformFlags();
      82        6257 : 
      83           1 :   switch (PlatformFlags & ELF::EF_MIPS_ARCH) {
      84             :   case ELF::EF_MIPS_ARCH_1:
      85        6256 :     break;
      86        1411 :   case ELF::EF_MIPS_ARCH_2:
      87        2266 :     Features.AddFeature("mips2");
      88         278 :     break;
      89         556 :   case ELF::EF_MIPS_ARCH_3:
      90             :     Features.AddFeature("mips3");
      91           0 :     break;
      92        4845 :   case ELF::EF_MIPS_ARCH_4:
      93        4844 :     Features.AddFeature("mips4");
      94        9234 :     break;
      95         227 :   case ELF::EF_MIPS_ARCH_5:
      96         452 :     Features.AddFeature("mips5");
      97             :     break;
      98           1 :   case ELF::EF_MIPS_ARCH_32:
      99             :     Features.AddFeature("mips32");
     100           1 :     break;
     101             :   case ELF::EF_MIPS_ARCH_64:
     102             :     Features.AddFeature("mips64");
     103         114 :     break;
     104         114 :   case ELF::EF_MIPS_ARCH_32R2:
     105         114 :     Features.AddFeature("mips32r2");
     106             :     break;
     107         114 :   case ELF::EF_MIPS_ARCH_64R2:
     108             :     Features.AddFeature("mips64r2");
     109             :     break;
     110             :   case ELF::EF_MIPS_ARCH_32R6:
     111           0 :     Features.AddFeature("mips32r6");
     112           0 :     break;
     113             :   case ELF::EF_MIPS_ARCH_64R6:
     114           0 :     Features.AddFeature("mips64r6");
     115           0 :     break;
     116             :   default:
     117           0 :     llvm_unreachable("Unknown EF_MIPS_ARCH value");
     118           0 :   }
     119             : 
     120           0 :   switch (PlatformFlags & ELF::EF_MIPS_MACH) {
     121           0 :   case ELF::EF_MIPS_MACH_NONE:
     122             :     // No feature associated with this value.
     123          56 :     break;
     124          56 :   case ELF::EF_MIPS_MACH_OCTEON:
     125             :     Features.AddFeature("cnmips");
     126          22 :     break;
     127          22 :   default:
     128             :     llvm_unreachable("Unknown EF_MIPS_ARCH value");
     129          10 :   }
     130          10 : 
     131             :   if (PlatformFlags & ELF::EF_MIPS_ARCH_ASE_M16)
     132           8 :     Features.AddFeature("mips16");
     133           8 :   if (PlatformFlags & ELF::EF_MIPS_MICROMIPS)
     134             :     Features.AddFeature("micromips");
     135          14 : 
     136          14 :   return Features;
     137             : }
     138           3 : 
     139           3 : SubtargetFeatures ELFObjectFileBase::getARMFeatures() const {
     140           0 :   SubtargetFeatures Features;
     141           0 :   ARMAttributeParser Attributes;
     142             :   std::error_code EC = getBuildAttributes(Attributes);
     143             :   if (EC)
     144         114 :     return SubtargetFeatures();
     145             : 
     146             :   // both ARMv7-M and R have to support thumb hardware div
     147             :   bool isV7 = false;
     148             :   if (Attributes.hasAttribute(ARMBuildAttrs::CPU_arch))
     149           0 :     isV7 = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch)
     150           0 :       == ARMBuildAttrs::v7;
     151           0 : 
     152           0 :   if (Attributes.hasAttribute(ARMBuildAttrs::CPU_arch_profile)) {
     153             :     switch(Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile)) {
     154             :     case ARMBuildAttrs::ApplicationProfile:
     155         114 :       Features.AddFeature("aclass");
     156           0 :       break;
     157         114 :     case ARMBuildAttrs::RealTimeProfile:
     158          25 :       Features.AddFeature("rclass");
     159             :       if (isV7)
     160         114 :         Features.AddFeature("hwdiv");
     161             :       break;
     162             :     case ARMBuildAttrs::MicroControllerProfile:
     163         184 :       Features.AddFeature("mclass");
     164         184 :       if (isV7)
     165             :         Features.AddFeature("hwdiv");
     166         184 :       break;
     167         184 :     }
     168           0 :   }
     169             : 
     170             :   if (Attributes.hasAttribute(ARMBuildAttrs::THUMB_ISA_use)) {
     171             :     switch(Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use)) {
     172             :     default:
     173         119 :       break;
     174             :     case ARMBuildAttrs::Not_Allowed:
     175             :       Features.AddFeature("thumb", false);
     176             :       Features.AddFeature("thumb2", false);
     177          98 :       break;
     178             :     case ARMBuildAttrs::AllowThumb32:
     179          93 :       Features.AddFeature("thumb2");
     180          93 :       break;
     181             :     }
     182           2 :   }
     183           2 : 
     184           2 :   if (Attributes.hasAttribute(ARMBuildAttrs::FP_arch)) {
     185             :     switch(Attributes.getAttributeValue(ARMBuildAttrs::FP_arch)) {
     186             :     default:
     187           3 :       break;
     188           3 :     case ARMBuildAttrs::Not_Allowed:
     189           2 :       Features.AddFeature("vfp2", false);
     190             :       Features.AddFeature("vfp3", false);
     191             :       Features.AddFeature("vfp4", false);
     192             :       break;
     193             :     case ARMBuildAttrs::AllowFPv2:
     194             :       Features.AddFeature("vfp2");
     195         114 :       break;
     196             :     case ARMBuildAttrs::AllowFPv3A:
     197             :     case ARMBuildAttrs::AllowFPv3B:
     198             :       Features.AddFeature("vfp3");
     199           0 :       break;
     200           0 :     case ARMBuildAttrs::AllowFPv4A:
     201           0 :     case ARMBuildAttrs::AllowFPv4B:
     202             :       Features.AddFeature("vfp4");
     203          95 :       break;
     204          95 :     }
     205             :   }
     206             : 
     207             :   if (Attributes.hasAttribute(ARMBuildAttrs::Advanced_SIMD_arch)) {
     208             :     switch(Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch)) {
     209          98 :     default:
     210             :       break;
     211             :     case ARMBuildAttrs::Not_Allowed:
     212             :       Features.AddFeature("neon", false);
     213           3 :       Features.AddFeature("fp16", false);
     214           3 :       break;
     215           3 :     case ARMBuildAttrs::AllowNeon:
     216           3 :       Features.AddFeature("neon");
     217             :       break;
     218           1 :     case ARMBuildAttrs::AllowNeon2:
     219           1 :       Features.AddFeature("neon");
     220             :       Features.AddFeature("fp16");
     221             :       break;
     222          90 :     }
     223          90 :   }
     224             : 
     225             :   if (Attributes.hasAttribute(ARMBuildAttrs::DIV_use)) {
     226           3 :     switch(Attributes.getAttributeValue(ARMBuildAttrs::DIV_use)) {
     227           3 :     default:
     228             :       break;
     229             :     case ARMBuildAttrs::DisallowDIV:
     230             :       Features.AddFeature("hwdiv", false);
     231             :       Features.AddFeature("hwdiv-arm", false);
     232          91 :       break;
     233             :     case ARMBuildAttrs::AllowDIVExt:
     234             :       Features.AddFeature("hwdiv");
     235             :       Features.AddFeature("hwdiv-arm");
     236           0 :       break;
     237           0 :     }
     238           0 :   }
     239             : 
     240          88 :   return Features;
     241          88 : }
     242             : 
     243           3 : SubtargetFeatures ELFObjectFileBase::getRISCVFeatures() const {
     244           3 :   SubtargetFeatures Features;
     245           3 :   unsigned PlatformFlags = getPlatformFlags();
     246             : 
     247             :   if (PlatformFlags & ELF::EF_RISCV_RVC) {
     248             :     Features.AddFeature("c");
     249             :   }
     250           3 : 
     251             :   return Features;
     252             : }
     253             : 
     254           0 : SubtargetFeatures ELFObjectFileBase::getFeatures() const {
     255           0 :   switch (getEMachine()) {
     256           0 :   case ELF::EM_MIPS:
     257             :     return getMIPSFeatures();
     258           3 :   case ELF::EM_ARM:
     259           3 :     return getARMFeatures();
     260           3 :   case ELF::EM_RISCV:
     261             :     return getRISCVFeatures();
     262             :   default:
     263             :     return SubtargetFeatures();
     264             :   }
     265             : }
     266             : 
     267           0 : // FIXME Encode from a tablegen description or target parser.
     268           0 : void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
     269           0 :   if (TheTriple.getSubArch() != Triple::NoSubArch)
     270             :     return;
     271           0 : 
     272           0 :   ARMAttributeParser Attributes;
     273             :   std::error_code EC = getBuildAttributes(Attributes);
     274             :   if (EC)
     275           0 :     return;
     276             : 
     277             :   std::string Triple;
     278        1411 :   // Default to ARM, but use the triple if it's been set.
     279        1411 :   if (TheTriple.isThumb())
     280         114 :     Triple = "thumb";
     281         114 :   else
     282         184 :     Triple = "arm";
     283         184 : 
     284           0 :   if (Attributes.hasAttribute(ARMBuildAttrs::CPU_arch)) {
     285           0 :     switch(Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch)) {
     286             :     case ARMBuildAttrs::v4:
     287        1113 :       Triple += "v4";
     288             :       break;
     289             :     case ARMBuildAttrs::v4T:
     290             :       Triple += "v4t";
     291             :       break;
     292         204 :     case ARMBuildAttrs::v5T:
     293         204 :       Triple += "v5t";
     294         154 :       break;
     295             :     case ARMBuildAttrs::v5TE:
     296             :       Triple += "v5te";
     297          50 :       break;
     298          50 :     case ARMBuildAttrs::v5TEJ:
     299             :       Triple += "v5tej";
     300             :       break;
     301             :     case ARMBuildAttrs::v6:
     302             :       Triple += "v6";
     303             :       break;
     304             :     case ARMBuildAttrs::v6KZ:
     305             :       Triple += "v6kz";
     306             :       break;
     307             :     case ARMBuildAttrs::v6T2:
     308             :       Triple += "v6t2";
     309          26 :       break;
     310             :     case ARMBuildAttrs::v6K:
     311             :       Triple += "v6k";
     312             :       break;
     313             :     case ARMBuildAttrs::v7:
     314             :       Triple += "v7";
     315             :       break;
     316             :     case ARMBuildAttrs::v6_M:
     317             :       Triple += "v6m";
     318             :       break;
     319             :     case ARMBuildAttrs::v6S_M:
     320             :       Triple += "v6sm";
     321             :       break;
     322             :     case ARMBuildAttrs::v7E_M:
     323             :       Triple += "v7em";
     324             :       break;
     325             :     }
     326             :   }
     327             :   if (!isLittleEndian())
     328             :     Triple += "eb";
     329             : 
     330             :   TheTriple.setArchName(Triple);
     331             : }
     332             : 
     333             : std::vector<std::pair<DataRefImpl, uint64_t>>
     334             : ELFObjectFileBase::getPltAddresses() const {
     335             :   std::string Err;
     336             :   const auto Triple = makeTriple();
     337             :   const auto *T = TargetRegistry::lookupTarget(Triple.str(), Err);
     338             :   if (!T)
     339             :     return {};
     340             :   uint64_t JumpSlotReloc = 0;
     341             :   switch (Triple.getArch()) {
     342             :     case Triple::x86:
     343             :       JumpSlotReloc = ELF::R_386_JUMP_SLOT;
     344             :       break;
     345             :     case Triple::x86_64:
     346             :       JumpSlotReloc = ELF::R_X86_64_JUMP_SLOT;
     347             :       break;
     348             :     case Triple::aarch64:
     349             :       JumpSlotReloc = ELF::R_AARCH64_JUMP_SLOT;
     350             :       break;
     351          50 :     default:
     352             :       return {};
     353             :   }
     354          50 :   std::unique_ptr<const MCInstrInfo> MII(T->createMCInstrInfo());
     355             :   std::unique_ptr<const MCInstrAnalysis> MIA(
     356             :       T->createMCInstrAnalysis(MII.get()));
     357             :   if (!MIA)
     358          97 :     return {};
     359             :   Optional<SectionRef> Plt = None, RelaPlt = None, GotPlt = None;
     360          97 :   for (const SectionRef &Section : sections()) {
     361          97 :     StringRef Name;
     362          97 :     if (Section.getName(Name))
     363             :       continue;
     364             :     if (Name == ".plt")
     365          97 :       Plt = Section;
     366             :     else if (Name == ".rela.plt" || Name == ".rel.plt")
     367             :       RelaPlt = Section;
     368             :     else if (Name == ".got.plt")
     369             :       GotPlt = Section;
     370             :   }
     371             :   if (!Plt || !RelaPlt || !GotPlt)
     372          11 :     return {};
     373             :   StringRef PltContents;
     374          11 :   if (Plt->getContents(PltContents))
     375             :     return {};
     376             :   ArrayRef<uint8_t> PltBytes((const uint8_t *)PltContents.data(),
     377             :                              Plt->getSize());
     378          50 :   auto PltEntries = MIA->findPltEntries(Plt->getAddress(), PltBytes,
     379             :                                         GotPlt->getAddress(), Triple);
     380          50 :   // Build a map from GOT entry virtual address to PLT entry virtual address.
     381          50 :   DenseMap<uint64_t, uint64_t> GotToPlt;
     382             :   for (const auto &Entry : PltEntries)
     383             :     GotToPlt.insert(std::make_pair(Entry.second, Entry.first));
     384         875 :   // Find the relocations in the dynamic relocation table that point to
     385         825 :   // locations in the GOT for which we know the corresponding PLT entry.
     386         825 :   std::vector<std::pair<DataRefImpl, uint64_t>> Result;
     387           0 :   for (const auto &Relocation : RelaPlt->relocations()) {
     388             :     if (Relocation.getType() != JumpSlotReloc)
     389             :       continue;
     390             :     auto PltEntryIter = GotToPlt.find(Relocation.getOffset());
     391             :     if (PltEntryIter != GotToPlt.end())
     392             :       Result.push_back(std::make_pair(
     393             :           Relocation.getSymbol()->getRawDataRefImpl(), PltEntryIter->second));
     394             :   }
     395          50 :   return Result;
     396             : }

Generated by: LCOV version 1.13