Line data Source code
1 : //===-- llvm/GlobalValue.h - Class to represent a global value --*- C++ -*-===//
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 : // This file is a common base class of all globally definable objects. As such,
10 : // it is subclassed by GlobalVariable, GlobalAlias and by Function. This is
11 : // used because you can do certain things with these global objects that you
12 : // can't do to anything else. For example, use the address of one as a
13 : // constant.
14 : //
15 : //===----------------------------------------------------------------------===//
16 :
17 : #ifndef LLVM_IR_GLOBALVALUE_H
18 : #define LLVM_IR_GLOBALVALUE_H
19 :
20 : #include "llvm/ADT/StringRef.h"
21 : #include "llvm/ADT/Twine.h"
22 : #include "llvm/IR/Constant.h"
23 : #include "llvm/IR/DerivedTypes.h"
24 : #include "llvm/IR/Value.h"
25 : #include "llvm/Support/Casting.h"
26 : #include "llvm/Support/ErrorHandling.h"
27 : #include <cassert>
28 : #include <cstdint>
29 : #include <string>
30 :
31 : namespace llvm {
32 :
33 : class Comdat;
34 : class ConstantRange;
35 : class DataLayout;
36 : class Error;
37 : class GlobalObject;
38 : class Module;
39 :
40 : namespace Intrinsic {
41 : typedef unsigned ID;
42 : } // end namespace Intrinsic
43 :
44 : // Choose ';' as the delimiter. ':' was used once but it doesn't work well for
45 : // Objective-C functions which commonly have :'s in their names.
46 : inline constexpr char GlobalIdentifierDelimiter = ';';
47 :
48 : class GlobalValue : public Constant {
49 : public:
50 : /// An enumeration for the kinds of linkage for global values.
51 : enum LinkageTypes {
52 : ExternalLinkage = 0,///< Externally visible function
53 : AvailableExternallyLinkage, ///< Available for inspection, not emission.
54 : LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline)
55 : LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent.
56 : WeakAnyLinkage, ///< Keep one copy of named function when linking (weak)
57 : WeakODRLinkage, ///< Same, but only replaced by something equivalent.
58 : AppendingLinkage, ///< Special purpose, only applies to global arrays
59 : InternalLinkage, ///< Rename collisions when linking (static functions).
60 : PrivateLinkage, ///< Like Internal, but omit from symbol table.
61 : ExternalWeakLinkage,///< ExternalWeak linkage description.
62 : CommonLinkage ///< Tentative definitions.
63 : };
64 :
65 : /// An enumeration for the kinds of visibility of global values.
66 : enum VisibilityTypes {
67 : DefaultVisibility = 0, ///< The GV is visible
68 : HiddenVisibility, ///< The GV is hidden
69 : ProtectedVisibility ///< The GV is protected
70 : };
71 :
72 : /// Storage classes of global values for PE targets.
73 : enum DLLStorageClassTypes {
74 : DefaultStorageClass = 0,
75 : DLLImportStorageClass = 1, ///< Function to be imported from DLL
76 : DLLExportStorageClass = 2 ///< Function to be accessible from DLL.
77 : };
78 :
79 : protected:
80 : GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
81 : LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
82 : : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
83 : ValueType(Ty), Visibility(DefaultVisibility),
84 : UnnamedAddrVal(unsigned(UnnamedAddr::None)),
85 : DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
86 : HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false),
87 : HasSanitizerMetadata(false) {
88 : setLinkage(Linkage);
89 : setName(Name);
90 : }
91 :
92 : Type *ValueType;
93 :
94 : static const unsigned GlobalValueSubClassDataBits = 15;
95 :
96 : // All bitfields use unsigned as the underlying type so that MSVC will pack
97 : // them.
98 : unsigned Linkage : 4; // The linkage of this global
99 : unsigned Visibility : 2; // The visibility style of this global
100 : unsigned UnnamedAddrVal : 2; // This value's address is not significant
101 : unsigned DllStorageClass : 2; // DLL storage class
102 :
103 : unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
104 : // the desired model?
105 :
106 : /// True if the function's name starts with "llvm.". This corresponds to the
107 : /// value of Function::isIntrinsic(), which may be true even if
108 : /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
109 : unsigned HasLLVMReservedName : 1;
110 :
111 : /// If true then there is a definition within the same linkage unit and that
112 : /// definition cannot be runtime preempted.
113 : unsigned IsDSOLocal : 1;
114 :
115 : /// True if this symbol has a partition name assigned (see
116 : /// https://lld.llvm.org/Partitions.html).
117 : unsigned HasPartition : 1;
118 :
119 : /// True if this symbol has sanitizer metadata available. Should only happen
120 : /// if sanitizers were enabled when building the translation unit which
121 : /// contains this GV.
122 : unsigned HasSanitizerMetadata : 1;
123 :
124 : private:
125 : // Give subclasses access to what otherwise would be wasted padding.
126 : // (15 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1 + 1) == 32.
127 : unsigned SubClassData : GlobalValueSubClassDataBits;
128 :
129 : friend class Constant;
130 :
131 : void destroyConstantImpl();
132 : Value *handleOperandChangeImpl(Value *From, Value *To);
133 :
134 : /// Returns true if the definition of this global may be replaced by a
135 : /// differently optimized variant of the same source level function at link
136 : /// time.
137 : bool mayBeDerefined() const {
138 : switch (getLinkage()) {
139 : case WeakODRLinkage:
140 : case LinkOnceODRLinkage:
141 : case AvailableExternallyLinkage:
142 : return true;
143 :
144 : case WeakAnyLinkage:
145 : case LinkOnceAnyLinkage:
146 : case CommonLinkage:
147 : case ExternalWeakLinkage:
148 : case ExternalLinkage:
149 : case AppendingLinkage:
150 : case InternalLinkage:
151 : case PrivateLinkage:
152 : // Optimizations may assume builtin semantics for functions defined as
153 : // nobuiltin due to attributes at call-sites. To avoid applying IPO based
154 : // on nobuiltin semantics, treat such function definitions as maybe
155 : // derefined.
156 : return isInterposable() || isNobuiltinFnDef();
157 : }
158 :
159 : llvm_unreachable("Fully covered switch above!");
160 : }
161 :
162 : /// Returns true if the global is a function definition with the nobuiltin
163 : /// attribute.
164 : bool isNobuiltinFnDef() const;
165 :
166 : protected:
167 : /// The intrinsic ID for this subclass (which must be a Function).
168 : ///
169 : /// This member is defined by this class, but not used for anything.
170 : /// Subclasses can use it to store their intrinsic ID, if they have one.
171 : ///
172 : /// This is stored here to save space in Function on 64-bit hosts.
173 : Intrinsic::ID IntID = (Intrinsic::ID)0U;
174 :
175 : unsigned getGlobalValueSubClassData() const {
176 : return SubClassData;
177 : }
178 : void setGlobalValueSubClassData(unsigned V) {
179 : assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit");
180 : SubClassData = V;
181 : }
182 :
183 : Module *Parent = nullptr; // The containing module.
184 :
185 : // Used by SymbolTableListTraits.
186 : void setParent(Module *parent) {
187 : Parent = parent;
188 : }
189 :
190 : ~GlobalValue() {
191 : removeDeadConstantUsers(); // remove any dead constants using this.
192 : }
193 :
194 : public:
195 : enum ThreadLocalMode {
196 : NotThreadLocal = 0,
197 : GeneralDynamicTLSModel,
198 : LocalDynamicTLSModel,
199 : InitialExecTLSModel,
200 : LocalExecTLSModel
201 : };
202 :
203 : GlobalValue(const GlobalValue &) = delete;
204 :
205 : unsigned getAddressSpace() const {
206 : return getType()->getAddressSpace();
207 : }
208 :
209 : enum class UnnamedAddr {
210 : None,
211 : Local,
212 : Global,
213 : };
214 :
215 : bool hasGlobalUnnamedAddr() const {
216 : return getUnnamedAddr() == UnnamedAddr::Global;
217 : }
218 :
219 : /// Returns true if this value's address is not significant in this module.
220 : /// This attribute is intended to be used only by the code generator and LTO
221 : /// to allow the linker to decide whether the global needs to be in the symbol
222 : /// table. It should probably not be used in optimizations, as the value may
223 : /// have uses outside the module; use hasGlobalUnnamedAddr() instead.
224 : bool hasAtLeastLocalUnnamedAddr() const {
225 : return getUnnamedAddr() != UnnamedAddr::None;
226 : }
227 :
228 : UnnamedAddr getUnnamedAddr() const {
229 : return UnnamedAddr(UnnamedAddrVal);
230 : }
231 : void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); }
232 :
233 : static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) {
234 : if (A == UnnamedAddr::None || B == UnnamedAddr::None)
235 : return UnnamedAddr::None;
236 : if (A == UnnamedAddr::Local || B == UnnamedAddr::Local)
237 : return UnnamedAddr::Local;
238 : return UnnamedAddr::Global;
239 : }
240 :
241 : bool hasComdat() const { return getComdat() != nullptr; }
242 : const Comdat *getComdat() const;
243 : Comdat *getComdat() {
244 : return const_cast<Comdat *>(
245 : static_cast<const GlobalValue *>(this)->getComdat());
246 : }
247 :
248 : VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
249 1579 : bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
250 : bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
251 : bool hasProtectedVisibility() const {
252 : return Visibility == ProtectedVisibility;
253 : }
254 : void setVisibility(VisibilityTypes V) {
255 : assert((!hasLocalLinkage() || V == DefaultVisibility) &&
256 : "local linkage requires default visibility");
257 : Visibility = V;
258 : if (isImplicitDSOLocal())
259 : setDSOLocal(true);
260 : }
261 :
262 : /// If the value is "Thread Local", its value isn't shared by the threads.
263 14690 : bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; }
264 : void setThreadLocal(bool Val) {
265 : setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal);
266 : }
267 : void setThreadLocalMode(ThreadLocalMode Val) {
268 : assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);
269 : ThreadLocal = Val;
270 : }
271 14690 : ThreadLocalMode getThreadLocalMode() const {
272 14690 : return static_cast<ThreadLocalMode>(ThreadLocal);
273 : }
274 :
275 : DLLStorageClassTypes getDLLStorageClass() const {
276 : return DLLStorageClassTypes(DllStorageClass);
277 : }
278 : bool hasDLLImportStorageClass() const {
279 : return DllStorageClass == DLLImportStorageClass;
280 : }
281 : bool hasDLLExportStorageClass() const {
282 : return DllStorageClass == DLLExportStorageClass;
283 : }
284 : void setDLLStorageClass(DLLStorageClassTypes C) {
285 : assert((!hasLocalLinkage() || C == DefaultStorageClass) &&
286 : "local linkage requires DefaultStorageClass");
287 : DllStorageClass = C;
288 : }
289 :
290 : bool hasSection() const { return !getSection().empty(); }
291 : StringRef getSection() const;
292 :
293 : /// Global values are always pointers.
294 : PointerType *getType() const { return cast<PointerType>(User::getType()); }
295 :
296 89812 : Type *getValueType() const { return ValueType; }
297 :
298 1579 : bool isImplicitDSOLocal() const {
299 3158 : return hasLocalLinkage() ||
300 3158 : (!hasDefaultVisibility() && !hasExternalWeakLinkage());
301 : }
302 :
303 0 : void setDSOLocal(bool Local) { IsDSOLocal = Local; }
304 :
305 : bool isDSOLocal() const {
306 : return IsDSOLocal;
307 : }
308 :
309 : bool hasPartition() const {
310 : return HasPartition;
311 : }
312 : StringRef getPartition() const;
313 : void setPartition(StringRef Part);
314 :
315 : // ASan, HWASan and Memtag sanitizers have some instrumentation that applies
316 : // specifically to global variables.
317 : struct SanitizerMetadata {
318 : SanitizerMetadata()
319 : : NoAddress(false), NoHWAddress(false),
320 : Memtag(false), IsDynInit(false) {}
321 : // For ASan and HWASan, this instrumentation is implicitly applied to all
322 : // global variables when built with -fsanitize=*. What we need is a way to
323 : // persist the information that a certain global variable should *not* have
324 : // sanitizers applied, which occurs if:
325 : // 1. The global variable is in the sanitizer ignore list, or
326 : // 2. The global variable is created by the sanitizers itself for internal
327 : // usage, or
328 : // 3. The global variable has __attribute__((no_sanitize("..."))) or
329 : // __attribute__((disable_sanitizer_instrumentation)).
330 : //
331 : // This is important, a some IR passes like GlobalMerge can delete global
332 : // variables and replace them with new ones. If the old variables were
333 : // marked to be unsanitized, then the new ones should also be.
334 : unsigned NoAddress : 1;
335 : unsigned NoHWAddress : 1;
336 :
337 : // Memtag sanitization works differently: sanitization is requested by clang
338 : // when `-fsanitize=memtag-globals` is provided, and the request can be
339 : // denied (and the attribute removed) by the AArch64 global tagging pass if
340 : // it can't be fulfilled (e.g. the global variable is a TLS variable).
341 : // Memtag sanitization has to interact with other parts of LLVM (like
342 : // supressing certain optimisations, emitting assembly directives, or
343 : // creating special relocation sections).
344 : //
345 : // Use `GlobalValue::isTagged()` to check whether tagging should be enabled
346 : // for a global variable.
347 : unsigned Memtag : 1;
348 :
349 : // ASan-specific metadata. Is this global variable dynamically initialized
350 : // (from a C++ language perspective), and should therefore be checked for
351 : // ODR violations.
352 : unsigned IsDynInit : 1;
353 : };
354 :
355 : bool hasSanitizerMetadata() const { return HasSanitizerMetadata; }
356 : const SanitizerMetadata &getSanitizerMetadata() const;
357 : // Note: Not byref as it's a POD and otherwise it's too easy to call
358 : // G.setSanitizerMetadata(G2.getSanitizerMetadata()), and the argument becomes
359 : // dangling when the backing storage allocates the metadata for `G`, as the
360 : // storage is shared between `G1` and `G2`.
361 : void setSanitizerMetadata(SanitizerMetadata Meta);
362 : void removeSanitizerMetadata();
363 : void setNoSanitizeMetadata();
364 :
365 : bool isTagged() const {
366 : return hasSanitizerMetadata() && getSanitizerMetadata().Memtag;
367 : }
368 :
369 : static LinkageTypes getLinkOnceLinkage(bool ODR) {
370 : return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
371 : }
372 : static LinkageTypes getWeakLinkage(bool ODR) {
373 : return ODR ? WeakODRLinkage : WeakAnyLinkage;
374 : }
375 :
376 26680 : static bool isExternalLinkage(LinkageTypes Linkage) {
377 26680 : return Linkage == ExternalLinkage;
378 : }
379 18619 : static bool isAvailableExternallyLinkage(LinkageTypes Linkage) {
380 18619 : return Linkage == AvailableExternallyLinkage;
381 : }
382 : static bool isLinkOnceAnyLinkage(LinkageTypes Linkage) {
383 : return Linkage == LinkOnceAnyLinkage;
384 : }
385 : static bool isLinkOnceODRLinkage(LinkageTypes Linkage) {
386 : return Linkage == LinkOnceODRLinkage;
387 : }
388 : static bool isLinkOnceLinkage(LinkageTypes Linkage) {
389 : return isLinkOnceAnyLinkage(Linkage) || isLinkOnceODRLinkage(Linkage);
390 : }
391 : static bool isWeakAnyLinkage(LinkageTypes Linkage) {
392 : return Linkage == WeakAnyLinkage;
393 : }
394 : static bool isWeakODRLinkage(LinkageTypes Linkage) {
395 : return Linkage == WeakODRLinkage;
396 : }
397 : static bool isWeakLinkage(LinkageTypes Linkage) {
398 : return isWeakAnyLinkage(Linkage) || isWeakODRLinkage(Linkage);
399 : }
400 : static bool isAppendingLinkage(LinkageTypes Linkage) {
401 : return Linkage == AppendingLinkage;
402 : }
403 3158 : static bool isInternalLinkage(LinkageTypes Linkage) {
404 3158 : return Linkage == InternalLinkage;
405 : }
406 3158 : static bool isPrivateLinkage(LinkageTypes Linkage) {
407 3158 : return Linkage == PrivateLinkage;
408 : }
409 3158 : static bool isLocalLinkage(LinkageTypes Linkage) {
410 3158 : return isInternalLinkage(Linkage) || isPrivateLinkage(Linkage);
411 : }
412 0 : static bool isExternalWeakLinkage(LinkageTypes Linkage) {
413 0 : return Linkage == ExternalWeakLinkage;
414 : }
415 : static bool isCommonLinkage(LinkageTypes Linkage) {
416 : return Linkage == CommonLinkage;
417 : }
418 : static bool isValidDeclarationLinkage(LinkageTypes Linkage) {
419 : return isExternalWeakLinkage(Linkage) || isExternalLinkage(Linkage);
420 : }
421 :
422 : /// Whether the definition of this global may be replaced by something
423 : /// non-equivalent at link time. For example, if a function has weak linkage
424 : /// then the code defining it may be replaced by different code.
425 : static bool isInterposableLinkage(LinkageTypes Linkage) {
426 : switch (Linkage) {
427 : case WeakAnyLinkage:
428 : case LinkOnceAnyLinkage:
429 : case CommonLinkage:
430 : case ExternalWeakLinkage:
431 : return true;
432 :
433 : case AvailableExternallyLinkage:
434 : case LinkOnceODRLinkage:
435 : case WeakODRLinkage:
436 : // The above three cannot be overridden but can be de-refined.
437 :
438 : case ExternalLinkage:
439 : case AppendingLinkage:
440 : case InternalLinkage:
441 : case PrivateLinkage:
442 : return false;
443 : }
444 : llvm_unreachable("Fully covered switch above!");
445 : }
446 :
447 : /// Whether the definition of this global may be discarded if it is not used
448 : /// in its compilation unit.
449 : static bool isDiscardableIfUnused(LinkageTypes Linkage) {
450 : return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage) ||
451 : isAvailableExternallyLinkage(Linkage);
452 : }
453 :
454 : /// Whether the definition of this global may be replaced at link time. NB:
455 : /// Using this method outside of the code generators is almost always a
456 : /// mistake: when working at the IR level use isInterposable instead as it
457 : /// knows about ODR semantics.
458 : static bool isWeakForLinker(LinkageTypes Linkage) {
459 : return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage ||
460 : Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage ||
461 : Linkage == CommonLinkage || Linkage == ExternalWeakLinkage;
462 : }
463 :
464 : /// Return true if the currently visible definition of this global (if any) is
465 : /// exactly the definition we will see at runtime.
466 : ///
467 : /// Non-exact linkage types inhibits most non-inlining IPO, since a
468 : /// differently optimized variant of the same function can have different
469 : /// observable or undefined behavior than in the variant currently visible.
470 : /// For instance, we could have started with
471 : ///
472 : /// void foo(int *v) {
473 : /// int t = 5 / v[0];
474 : /// (void) t;
475 : /// }
476 : ///
477 : /// and "refined" it to
478 : ///
479 : /// void foo(int *v) { }
480 : ///
481 : /// However, we cannot infer readnone for `foo`, since that would justify
482 : /// DSE'ing a store to `v[0]` across a call to `foo`, which can cause
483 : /// undefined behavior if the linker replaces the actual call destination with
484 : /// the unoptimized `foo`.
485 : ///
486 : /// Inlining is okay across non-exact linkage types as long as they're not
487 : /// interposable (see \c isInterposable), since in such cases the currently
488 : /// visible variant is *a* correct implementation of the original source
489 : /// function; it just isn't the *only* correct implementation.
490 : bool isDefinitionExact() const {
491 : return !mayBeDerefined();
492 : }
493 :
494 : /// Return true if this global has an exact defintion.
495 : bool hasExactDefinition() const {
496 : // While this computes exactly the same thing as
497 : // isStrongDefinitionForLinker, the intended uses are different. This
498 : // function is intended to help decide if specific inter-procedural
499 : // transforms are correct, while isStrongDefinitionForLinker's intended use
500 : // is in low level code generation.
501 : return !isDeclaration() && isDefinitionExact();
502 : }
503 :
504 : /// Return true if this global's definition can be substituted with an
505 : /// *arbitrary* definition at link time or load time. We cannot do any IPO or
506 : /// inlining across interposable call edges, since the callee can be
507 : /// replaced with something arbitrary.
508 : bool isInterposable() const;
509 : bool canBenefitFromLocalAlias() const;
510 :
511 26680 : bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
512 18619 : bool hasAvailableExternallyLinkage() const {
513 18619 : return isAvailableExternallyLinkage(getLinkage());
514 : }
515 : bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); }
516 : bool hasLinkOnceAnyLinkage() const {
517 : return isLinkOnceAnyLinkage(getLinkage());
518 : }
519 : bool hasLinkOnceODRLinkage() const {
520 : return isLinkOnceODRLinkage(getLinkage());
521 : }
522 : bool hasWeakLinkage() const { return isWeakLinkage(getLinkage()); }
523 : bool hasWeakAnyLinkage() const { return isWeakAnyLinkage(getLinkage()); }
524 : bool hasWeakODRLinkage() const { return isWeakODRLinkage(getLinkage()); }
525 : bool hasAppendingLinkage() const { return isAppendingLinkage(getLinkage()); }
526 : bool hasInternalLinkage() const { return isInternalLinkage(getLinkage()); }
527 : bool hasPrivateLinkage() const { return isPrivateLinkage(getLinkage()); }
528 1579 : bool hasLocalLinkage() const { return isLocalLinkage(getLinkage()); }
529 0 : bool hasExternalWeakLinkage() const {
530 0 : return isExternalWeakLinkage(getLinkage());
531 : }
532 : bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
533 : bool hasValidDeclarationLinkage() const {
534 : return isValidDeclarationLinkage(getLinkage());
535 : }
536 :
537 1579 : void setLinkage(LinkageTypes LT) {
538 1579 : if (isLocalLinkage(LT)) {
539 0 : Visibility = DefaultVisibility;
540 0 : DllStorageClass = DefaultStorageClass;
541 : }
542 1579 : Linkage = LT;
543 1579 : if (isImplicitDSOLocal())
544 0 : setDSOLocal(true);
545 1579 : }
546 46878 : LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }
547 :
548 : bool isDiscardableIfUnused() const {
549 : return isDiscardableIfUnused(getLinkage());
550 : }
551 :
552 : bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }
553 :
554 : protected:
555 : /// Copy all additional attributes (those not needed to create a GlobalValue)
556 : /// from the GlobalValue Src to this one.
557 : void copyAttributesFrom(const GlobalValue *Src);
558 :
559 : public:
560 : /// If the given string begins with the GlobalValue name mangling escape
561 : /// character '\1', drop it.
562 : ///
563 : /// This function applies a specific mangling that is used in PGO profiles,
564 : /// among other things. If you're trying to get a symbol name for an
565 : /// arbitrary GlobalValue, this is not the function you're looking for; see
566 : /// Mangler.h.
567 : static StringRef dropLLVMManglingEscape(StringRef Name) {
568 : Name.consume_front("\1");
569 : return Name;
570 : }
571 :
572 : /// Return the modified name for a global value suitable to be
573 : /// used as the key for a global lookup (e.g. profile or ThinLTO).
574 : /// The value's original name is \c Name and has linkage of type
575 : /// \c Linkage. The value is defined in module \c FileName.
576 : static std::string getGlobalIdentifier(StringRef Name,
577 : GlobalValue::LinkageTypes Linkage,
578 : StringRef FileName);
579 :
580 : /// Return the modified name for this global value suitable to be
581 : /// used as the key for a global lookup (e.g. profile or ThinLTO).
582 : std::string getGlobalIdentifier() const;
583 :
584 : /// Declare a type to represent a global unique identifier for a global value.
585 : /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
586 : /// unique way to identify a symbol.
587 : using GUID = uint64_t;
588 :
589 : /// Return a 64-bit global unique ID constructed from global value name
590 : /// (i.e. returned by getGlobalIdentifier()).
591 : static GUID getGUID(StringRef GlobalName);
592 :
593 : /// Return a 64-bit global unique ID constructed from global value name
594 : /// (i.e. returned by getGlobalIdentifier()).
595 : GUID getGUID() const { return getGUID(getGlobalIdentifier()); }
596 :
597 : /// @name Materialization
598 : /// Materialization is used to construct functions only as they're needed.
599 : /// This
600 : /// is useful to reduce memory usage in LLVM or parsing work done by the
601 : /// BitcodeReader to load the Module.
602 : /// @{
603 :
604 : /// If this function's Module is being lazily streamed in functions from disk
605 : /// or some other source, this method can be used to check to see if the
606 : /// function has been read in yet or not.
607 : bool isMaterializable() const;
608 :
609 : /// Make sure this GlobalValue is fully read.
610 : Error materialize();
611 :
612 : /// @}
613 :
614 : /// Return true if the primary definition of this global value is outside of
615 : /// the current translation unit.
616 : bool isDeclaration() const;
617 :
618 : bool isDeclarationForLinker() const {
619 : if (hasAvailableExternallyLinkage())
620 : return true;
621 :
622 : return isDeclaration();
623 : }
624 :
625 : /// Returns true if this global's definition will be the one chosen by the
626 : /// linker.
627 : ///
628 : /// NB! Ideally this should not be used at the IR level at all. If you're
629 : /// interested in optimization constraints implied by the linker's ability to
630 : /// choose an implementation, prefer using \c hasExactDefinition.
631 : bool isStrongDefinitionForLinker() const {
632 : return !(isDeclarationForLinker() || isWeakForLinker());
633 : }
634 :
635 : const GlobalObject *getAliaseeObject() const;
636 : GlobalObject *getAliaseeObject() {
637 : return const_cast<GlobalObject *>(
638 : static_cast<const GlobalValue *>(this)->getAliaseeObject());
639 : }
640 :
641 : /// Returns whether this is a reference to an absolute symbol.
642 : bool isAbsoluteSymbolRef() const;
643 :
644 : /// If this is an absolute symbol reference, returns the range of the symbol,
645 : /// otherwise returns std::nullopt.
646 : std::optional<ConstantRange> getAbsoluteSymbolRange() const;
647 :
648 : /// This method unlinks 'this' from the containing module, but does not delete
649 : /// it.
650 : void removeFromParent();
651 :
652 : /// This method unlinks 'this' from the containing module and deletes it.
653 : void eraseFromParent();
654 :
655 : /// Get the module that this global value is contained inside of...
656 : Module *getParent() { return Parent; }
657 : const Module *getParent() const { return Parent; }
658 :
659 : /// Get the data layout of the module this global belongs to.
660 : ///
661 : /// Requires the global to have a parent module.
662 : const DataLayout &getDataLayout() const;
663 :
664 : // Methods for support type inquiry through isa, cast, and dyn_cast:
665 : static bool classof(const Value *V) {
666 : return V->getValueID() == Value::FunctionVal ||
667 : V->getValueID() == Value::GlobalVariableVal ||
668 : V->getValueID() == Value::GlobalAliasVal ||
669 : V->getValueID() == Value::GlobalIFuncVal;
670 : }
671 :
672 : /// True if GV can be left out of the object symbol table. This is the case
673 : /// for linkonce_odr values whose address is not significant. While legal, it
674 : /// is not normally profitable to omit them from the .o symbol table. Using
675 : /// this analysis makes sense when the information can be passed down to the
676 : /// linker or we are in LTO.
677 : bool canBeOmittedFromSymbolTable() const;
678 : };
679 :
680 : } // end namespace llvm
681 :
682 : #endif // LLVM_IR_GLOBALVALUE_H
|
