LLVM  11.0.0git
JITSymbol.cpp
Go to the documentation of this file.
1 //===----------- JITSymbol.cpp - JITSymbol class 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 // JITSymbol class implementation plus helper functions.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/IR/Function.h"
15 #include "llvm/IR/GlobalAlias.h"
16 #include "llvm/IR/GlobalValue.h"
18 #include "llvm/Object/ObjectFile.h"
19 
20 using namespace llvm;
21 
23  assert(GV.hasName() && "Can't get flags for anonymous symbol");
24 
26  if (GV.hasWeakLinkage() || GV.hasLinkOnceLinkage())
27  Flags |= JITSymbolFlags::Weak;
28  if (GV.hasCommonLinkage())
29  Flags |= JITSymbolFlags::Common;
30  if (!GV.hasLocalLinkage() && !GV.hasHiddenVisibility())
31  Flags |= JITSymbolFlags::Exported;
32 
33  if (isa<Function>(GV))
34  Flags |= JITSymbolFlags::Callable;
35  else if (isa<GlobalAlias>(GV) &&
36  isa<Function>(cast<GlobalAlias>(GV).getAliasee()))
37  Flags |= JITSymbolFlags::Callable;
38 
39  // Check for a linker-private-global-prefix on the symbol name, in which
40  // case it must be marked as non-exported.
41  if (auto *M = GV.getParent()) {
42  const auto &DL = M->getDataLayout();
43  StringRef LPGP = DL.getLinkerPrivateGlobalPrefix();
44  if (!LPGP.empty() && GV.getName().front() == '\01' &&
45  GV.getName().substr(1).startswith(LPGP))
46  Flags &= ~JITSymbolFlags::Exported;
47  }
48 
49  return Flags;
50 }
51 
54  auto L = S->linkage();
56  Flags |= JITSymbolFlags::Weak;
58  Flags |= JITSymbolFlags::Common;
60  Flags |= JITSymbolFlags::Exported;
61 
62  if (isa<FunctionSummary>(S))
63  Flags |= JITSymbolFlags::Callable;
64 
65  return Flags;
66 }
67 
70  Expected<uint32_t> SymbolFlagsOrErr = Symbol.getFlags();
71  if (!SymbolFlagsOrErr)
72  // TODO: Test this error.
73  return SymbolFlagsOrErr.takeError();
74 
76  if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Weak)
77  Flags |= JITSymbolFlags::Weak;
78  if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Common)
79  Flags |= JITSymbolFlags::Common;
80  if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Exported)
81  Flags |= JITSymbolFlags::Exported;
82 
83  auto SymbolType = Symbol.getType();
84  if (!SymbolType)
85  return SymbolType.takeError();
86 
88  Flags |= JITSymbolFlags::Callable;
89 
90  return Flags;
91 }
92 
95  Expected<uint32_t> SymbolFlagsOrErr = Symbol.getFlags();
96  if (!SymbolFlagsOrErr)
97  // TODO: Actually report errors helpfully.
98  report_fatal_error(SymbolFlagsOrErr.takeError());
99  ARMJITSymbolFlags Flags;
100  if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Thumb)
101  Flags |= ARMJITSymbolFlags::Thumb;
102  return Flags;
103 }
104 
105 /// Performs lookup by, for each symbol, first calling
106 /// findSymbolInLogicalDylib and if that fails calling
107 /// findSymbol.
109  OnResolvedFunction OnResolved) {
111  for (auto &Symbol : Symbols) {
112  std::string SymName = Symbol.str();
113  if (auto Sym = findSymbolInLogicalDylib(SymName)) {
114  if (auto AddrOrErr = Sym.getAddress())
115  Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
116  else {
117  OnResolved(AddrOrErr.takeError());
118  return;
119  }
120  } else if (auto Err = Sym.takeError()) {
121  OnResolved(std::move(Err));
122  return;
123  } else {
124  // findSymbolInLogicalDylib failed. Lets try findSymbol.
125  if (auto Sym = findSymbol(SymName)) {
126  if (auto AddrOrErr = Sym.getAddress())
127  Result[Symbol] = JITEvaluatedSymbol(*AddrOrErr, Sym.getFlags());
128  else {
129  OnResolved(AddrOrErr.takeError());
130  return;
131  }
132  } else if (auto Err = Sym.takeError()) {
133  OnResolved(std::move(Err));
134  return;
135  } else {
136  OnResolved(make_error<StringError>("Symbol not found: " + Symbol,
138  return;
139  }
140  }
141  }
142 
143  OnResolved(std::move(Result));
144 }
145 
146 /// Performs flags lookup by calling findSymbolInLogicalDylib and
147 /// returning the flags value for that symbol.
151 
152  for (auto &Symbol : Symbols) {
153  std::string SymName = Symbol.str();
154  if (auto Sym = findSymbolInLogicalDylib(SymName)) {
155  // If there's an existing def but it is not strong, then the caller is
156  // responsible for it.
157  if (!Sym.getFlags().isStrong())
158  Result.insert(Symbol);
159  } else if (auto Err = Sym.takeError())
160  return std::move(Err);
161  else {
162  // If there is no existing definition then the caller is responsible for
163  // it.
164  Result.insert(Symbol);
165  }
166  }
167 
168  return std::move(Result);
169 }
Expected< uint32_t > getFlags() const
Get symbol flags (bitwise OR of SymbolRef::Flags)
Definition: SymbolicFile.h:198
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
static JITSymbolFlags fromGlobalValue(const GlobalValue &GV)
Construct a JITSymbolFlags value based on the flags of the given global value.
Definition: JITSymbol.cpp:22
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static bool isExternalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:299
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:289
Expected< LookupSet > getResponsibilitySet(const LookupSet &Symbols) final
Performs flags lookup by calling findSymbolInLogicalDylib and returning the flags value for that symb...
Definition: JITSymbol.cpp:149
GlobalValue::LinkageTypes linkage() const
Return linkage type recorded for this global value.
static bool isCommonLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:335
static Expected< JITSymbolFlags > fromObjectSymbol(const object::SymbolRef &Symbol)
Construct a JITSymbolFlags value based on the flags of the given libobject symbol.
Definition: JITSymbol.cpp:69
Error takeError()
Take ownership of the stored error.
Definition: Error.h:557
std::set< StringRef > LookupSet
Definition: JITSymbol.h:373
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:308
virtual JITSymbol findSymbol(const std::string &Name)=0
This method returns the address of the specified function or variable.
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
LLVM_NODISCARD StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:612
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:156
bool hasCommonLinkage() const
Definition: GlobalValue.h:449
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:435
bool hasName() const
Definition: Value.h:250
static JITSymbolFlags fromSummary(GlobalValueSummary *S)
Construct a JITSymbolFlags value based on the flags of the given global value summary.
Definition: JITSymbol.cpp:52
virtual JITSymbol findSymbolInLogicalDylib(const std::string &Name)=0
This method returns the address of the specified symbol if it exists within the logical dynamic libra...
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
Function and variable summary information to aid decisions and implementation of importing.
bool hasWeakLinkage() const
Definition: GlobalValue.h:439
static bool isWeakLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:317
Expected< SymbolRef::Type > getType() const
Definition: ObjectFile.h:408
unique_function is a type-erasing functor similar to std::function.
static bool isExternalWeakLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:332
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:229
bool hasHiddenVisibility() const
Definition: GlobalValue.h:231
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:164
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:270
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM_NODISCARD char front() const
front - Get the first character in the string.
Definition: StringRef.h:164
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
std::map< StringRef, JITEvaluatedSymbol > LookupResult
Definition: JITSymbol.h:374
ARM-specific JIT symbol flags.
Definition: JITSymbol.h:211
static ARMJITSymbolFlags fromObjectSymbol(const object::SymbolRef &Symbol)
Definition: JITSymbol.cpp:94
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
void lookup(const LookupSet &Symbols, OnResolvedFunction OnResolved) final
Performs lookup by, for each symbol, first calling findSymbolInLogicalDylib and if that fails calling...
Definition: JITSymbol.cpp:108
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL