LLVM 18.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"
19
20using 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())
30 if (!GV.hasLocalLinkage() && !GV.hasHiddenVisibility())
32
33 if (isa<Function>(GV))
35 else if (isa<GlobalAlias>(GV) &&
36 isa<Function>(cast<GlobalAlias>(GV).getAliasee()))
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))
47 }
48
49 return Flags;
50}
51
54 auto L = S->linkage();
56 Flags |= JITSymbolFlags::Weak;
61
62 if (isa<FunctionSummary>(S))
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)
80 if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_Exported)
82
83 auto SymbolType = Symbol.getType();
84 if (!SymbolType)
85 return SymbolType.takeError();
86
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());
100 if (*SymbolFlagsOrErr & object::BasicSymbolRef::SF_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}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Symbol * Sym
Definition: ELF_riscv.cpp:477
ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ARM-specific JIT symbol flags.
Definition: JITSymbol.h:211
static ARMJITSymbolFlags fromObjectSymbol(const object::SymbolRef &Symbol)
Definition: JITSymbol.cpp:94
Tagged union holding either a T or a Error.
Definition: Error.h:474
Error takeError()
Take ownership of the stored error.
Definition: Error.h:601
Function and variable summary information to aid decisions and implementation of importing.
GlobalValue::LinkageTypes linkage() const
Return linkage type recorded for this global value.
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:510
static bool isExternalWeakLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:407
bool hasLocalLinkage() const
Definition: GlobalValue.h:523
static bool isLinkOnceLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:383
bool hasHiddenVisibility() const
Definition: GlobalValue.h:246
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
static bool isCommonLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:410
static bool isExternalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:371
bool hasWeakLinkage() const
Definition: GlobalValue.h:517
bool hasCommonLinkage() const
Definition: GlobalValue.h:527
static bool isWeakLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:392
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:229
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
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
static JITSymbolFlags fromSummary(GlobalValueSummary *S)
Construct a JITSymbolFlags value based on the flags of the given global value summary.
Definition: JITSymbol.cpp:52
static JITSymbolFlags fromGlobalValue(const GlobalValue &GV)
Construct a JITSymbolFlags value based on the flags of the given global value.
Definition: JITSymbol.cpp:22
std::map< StringRef, JITEvaluatedSymbol > LookupResult
Definition: JITSymbol.h:374
std::set< StringRef > LookupSet
Definition: JITSymbol.h:373
virtual JITSymbol findSymbol(const std::string &Name)=0
This method returns the address of the specified function or variable.
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
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...
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
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:575
constexpr bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:134
char front() const
front - Get the first character in the string.
Definition: StringRef.h:140
bool startswith(StringRef Prefix) const
Definition: StringRef.h:261
bool hasName() const
Definition: Value.h:261
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: ObjectFile.h:168
unique_function is a type-erasing functor similar to std::function.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156