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