llvm/lib/ExecutionEngine/Orc/Mangling.cpp

   1 //===----------- Mangling.cpp -- Name Mangling Utilities for ORC ----------===//
   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 #include "llvm/ExecutionEngine/Orc/Mangling.h"
  10 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
  11 #include "llvm/IR/Constants.h"
  12 #include "llvm/IR/Mangler.h"
  13 #include "llvm/Object/MachO.h"
  14 #include "llvm/Object/ObjectFile.h"
  15 #include "llvm/Support/Debug.h"
  16
  17 #define DEBUG_TYPE "orc"
  18
  19 namespace llvm {
  20 namespace orc {
  21
  22 MangleAndInterner::MangleAndInterner(ExecutionSession &ES, const DataLayout &DL)
  23     : ES(ES), DL(DL) {}
  24
  25 SymbolStringPtr MangleAndInterner::operator()(StringRef Name) {
  26   std::string MangledName;
  27   {
  28     raw_string_ostream MangledNameStream(MangledName);
  29     Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
  30   }
  31   return ES.intern(MangledName);
  32 }
  33
  34 void IRSymbolMapper::add(ExecutionSession &ES, const ManglingOptions &MO,
  35                          ArrayRef<GlobalValue *> GVs,
  36                          SymbolFlagsMap &SymbolFlags,
  37                          SymbolNameToDefinitionMap *SymbolToDefinition) {
  38   if (GVs.empty())
  39     return;
  40
  41   MangleAndInterner Mangle(ES, GVs[0]->getParent()->getDataLayout());
  42   for (auto *G : GVs) {
  43     assert(G && "GVs cannot contain null elements");
  44     if (!G->hasName() || G->isDeclaration() || G->hasLocalLinkage() ||
  45         G->hasAvailableExternallyLinkage() || G->hasAppendingLinkage())
  46       continue;
  47
  48     if (G->isThreadLocal() && MO.EmulatedTLS) {
  49       auto *GV = cast<GlobalVariable>(G);
  50
  51       auto Flags = JITSymbolFlags::fromGlobalValue(*GV);
  52
  53       auto EmuTLSV = Mangle(("__emutls_v." + GV->getName()).str());
  54       SymbolFlags[EmuTLSV] = Flags;
  55       if (SymbolToDefinition)
  56         (*SymbolToDefinition)[EmuTLSV] = GV;
  57
  58       // If this GV has a non-zero initializer we'll need to emit an
  59       // __emutls.t symbol too.
  60       if (GV->hasInitializer()) {
  61         const auto *InitVal = GV->getInitializer();
  62
  63         // Skip zero-initializers.
  64         if (isa<ConstantAggregateZero>(InitVal))
  65           continue;
  66         const auto *InitIntValue = dyn_cast<ConstantInt>(InitVal);
  67         if (InitIntValue && InitIntValue->isZero())
  68           continue;
  69
  70         auto EmuTLST = Mangle(("__emutls_t." + GV->getName()).str());
  71         SymbolFlags[EmuTLST] = Flags;
  72         if (SymbolToDefinition)
  73           (*SymbolToDefinition)[EmuTLST] = GV;
  74       }
  75       continue;
  76     }
  77
  78     // Otherwise we just need a normal linker mangling.
  79     auto MangledName = Mangle(G->getName());
  80     SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(*G);
  81     if (SymbolToDefinition)
  82       (*SymbolToDefinition)[MangledName] = G;
  83   }
  84 }
  85
  86 Expected<std::pair<SymbolFlagsMap, SymbolStringPtr>>
  87 getObjectSymbolInfo(ExecutionSession &ES, MemoryBufferRef ObjBuffer) {
  88   auto Obj = object::ObjectFile::createObjectFile(ObjBuffer);
  89
  90   if (!Obj)
  91     return Obj.takeError();
  92
  93   bool IsMachO = isa<object::MachOObjectFile>(Obj->get());
  94
  95   SymbolFlagsMap SymbolFlags;
  96   for (auto &Sym : (*Obj)->symbols()) {
  97     Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
  98     if (!SymFlagsOrErr)
  99       // TODO: Test this error.
 100       return SymFlagsOrErr.takeError();
 101
 102     // Skip symbols not defined in this object file.
 103     if (*SymFlagsOrErr & object::BasicSymbolRef::SF_Undefined)
 104       continue;
 105
 106     // Skip symbols that are not global.
 107     if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global))
 108       continue;
 109
 110     // Skip symbols that have type SF_File.
 111     if (auto SymType = Sym.getType()) {
 112       if (*SymType == object::SymbolRef::ST_File)
 113         continue;
 114     } else
 115       return SymType.takeError();
 116
 117     auto Name = Sym.getName();
 118     if (!Name)
 119       return Name.takeError();
 120     auto InternedName = ES.intern(*Name);
 121     auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
 122     if (!SymFlags)
 123       return SymFlags.takeError();
 124
 125     // Strip the 'exported' flag from MachO linker-private symbols.
 126     if (IsMachO && Name->startswith("l"))
 127       *SymFlags &= ~JITSymbolFlags::Exported;
 128
 129     SymbolFlags[InternedName] = std::move(*SymFlags);
 130   }
 131
 132   SymbolStringPtr InitSymbol;
 133
 134   size_t Counter = 0;
 135   auto AddInitSymbol = [&]() {
 136     while (true) {
 137       std::string InitSymString;
 138       raw_string_ostream(InitSymString)
 139           << "$." << ObjBuffer.getBufferIdentifier() << ".__inits."
 140           << Counter++;
 141       InitSymbol = ES.intern(InitSymString);
 142       if (SymbolFlags.count(InitSymbol))
 143         continue;
 144       SymbolFlags[InitSymbol] = JITSymbolFlags::MaterializationSideEffectsOnly;
 145       return;
 146     }
 147   };
 148
 149   if (IsMachO) {
 150     auto &MachOObj = cast<object::MachOObjectFile>(*Obj->get());
 151     for (auto &Sec : MachOObj.sections()) {
 152       auto SecType = MachOObj.getSectionType(Sec);
 153       if ((SecType & MachO::SECTION_TYPE) == MachO::S_MOD_INIT_FUNC_POINTERS) {
 154         AddInitSymbol();
 155         break;
 156       }
 157       auto SegName =
 158           MachOObj.getSectionFinalSegmentName(Sec.getRawDataRefImpl());
 159       auto SecName = cantFail(MachOObj.getSectionName(Sec.getRawDataRefImpl()));
 160       if (MachOPlatform::isInitializerSection(SegName, SecName)) {
 161         AddInitSymbol();
 162         break;
 163       }
 164     }
 165   }
 166
 167   return std::make_pair(std::move(SymbolFlags), std::move(InitSymbol));
 168 }
 169
 170 } // End namespace orc.
 171 } // End namespace llvm.