| File: | src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/CodeGen/GlobalMerge.cpp |
| Warning: | line 631, column 29 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===- GlobalMerge.cpp - Internal globals merging -------------------------===// | |||
| 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 pass merges globals with internal linkage into one. This way all the | |||
| 10 | // globals which were merged into a biggest one can be addressed using offsets | |||
| 11 | // from the same base pointer (no need for separate base pointer for each of the | |||
| 12 | // global). Such a transformation can significantly reduce the register pressure | |||
| 13 | // when many globals are involved. | |||
| 14 | // | |||
| 15 | // For example, consider the code which touches several global variables at | |||
| 16 | // once: | |||
| 17 | // | |||
| 18 | // static int foo[N], bar[N], baz[N]; | |||
| 19 | // | |||
| 20 | // for (i = 0; i < N; ++i) { | |||
| 21 | // foo[i] = bar[i] * baz[i]; | |||
| 22 | // } | |||
| 23 | // | |||
| 24 | // On ARM the addresses of 3 arrays should be kept in the registers, thus | |||
| 25 | // this code has quite large register pressure (loop body): | |||
| 26 | // | |||
| 27 | // ldr r1, [r5], #4 | |||
| 28 | // ldr r2, [r6], #4 | |||
| 29 | // mul r1, r2, r1 | |||
| 30 | // str r1, [r0], #4 | |||
| 31 | // | |||
| 32 | // Pass converts the code to something like: | |||
| 33 | // | |||
| 34 | // static struct { | |||
| 35 | // int foo[N]; | |||
| 36 | // int bar[N]; | |||
| 37 | // int baz[N]; | |||
| 38 | // } merged; | |||
| 39 | // | |||
| 40 | // for (i = 0; i < N; ++i) { | |||
| 41 | // merged.foo[i] = merged.bar[i] * merged.baz[i]; | |||
| 42 | // } | |||
| 43 | // | |||
| 44 | // and in ARM code this becomes: | |||
| 45 | // | |||
| 46 | // ldr r0, [r5, #40] | |||
| 47 | // ldr r1, [r5, #80] | |||
| 48 | // mul r0, r1, r0 | |||
| 49 | // str r0, [r5], #4 | |||
| 50 | // | |||
| 51 | // note that we saved 2 registers here almostly "for free". | |||
| 52 | // | |||
| 53 | // However, merging globals can have tradeoffs: | |||
| 54 | // - it confuses debuggers, tools, and users | |||
| 55 | // - it makes linker optimizations less useful (order files, LOHs, ...) | |||
| 56 | // - it forces usage of indexed addressing (which isn't necessarily "free") | |||
| 57 | // - it can increase register pressure when the uses are disparate enough. | |||
| 58 | // | |||
| 59 | // We use heuristics to discover the best global grouping we can (cf cl::opts). | |||
| 60 | // | |||
| 61 | // ===---------------------------------------------------------------------===// | |||
| 62 | ||||
| 63 | #include "llvm/ADT/BitVector.h" | |||
| 64 | #include "llvm/ADT/DenseMap.h" | |||
| 65 | #include "llvm/ADT/SmallPtrSet.h" | |||
| 66 | #include "llvm/ADT/SmallVector.h" | |||
| 67 | #include "llvm/ADT/Statistic.h" | |||
| 68 | #include "llvm/ADT/StringRef.h" | |||
| 69 | #include "llvm/ADT/Triple.h" | |||
| 70 | #include "llvm/ADT/Twine.h" | |||
| 71 | #include "llvm/CodeGen/Passes.h" | |||
| 72 | #include "llvm/IR/BasicBlock.h" | |||
| 73 | #include "llvm/IR/Constants.h" | |||
| 74 | #include "llvm/IR/DataLayout.h" | |||
| 75 | #include "llvm/IR/DerivedTypes.h" | |||
| 76 | #include "llvm/IR/Function.h" | |||
| 77 | #include "llvm/IR/GlobalAlias.h" | |||
| 78 | #include "llvm/IR/GlobalValue.h" | |||
| 79 | #include "llvm/IR/GlobalVariable.h" | |||
| 80 | #include "llvm/IR/Instruction.h" | |||
| 81 | #include "llvm/IR/Module.h" | |||
| 82 | #include "llvm/IR/Type.h" | |||
| 83 | #include "llvm/IR/Use.h" | |||
| 84 | #include "llvm/IR/User.h" | |||
| 85 | #include "llvm/InitializePasses.h" | |||
| 86 | #include "llvm/MC/SectionKind.h" | |||
| 87 | #include "llvm/Pass.h" | |||
| 88 | #include "llvm/Support/Casting.h" | |||
| 89 | #include "llvm/Support/CommandLine.h" | |||
| 90 | #include "llvm/Support/Debug.h" | |||
| 91 | #include "llvm/Support/raw_ostream.h" | |||
| 92 | #include "llvm/Target/TargetLoweringObjectFile.h" | |||
| 93 | #include "llvm/Target/TargetMachine.h" | |||
| 94 | #include <algorithm> | |||
| 95 | #include <cassert> | |||
| 96 | #include <cstddef> | |||
| 97 | #include <cstdint> | |||
| 98 | #include <string> | |||
| 99 | #include <vector> | |||
| 100 | ||||
| 101 | using namespace llvm; | |||
| 102 | ||||
| 103 | #define DEBUG_TYPE"global-merge" "global-merge" | |||
| 104 | ||||
| 105 | // FIXME: This is only useful as a last-resort way to disable the pass. | |||
| 106 | static cl::opt<bool> | |||
| 107 | EnableGlobalMerge("enable-global-merge", cl::Hidden, | |||
| 108 | cl::desc("Enable the global merge pass"), | |||
| 109 | cl::init(true)); | |||
| 110 | ||||
| 111 | static cl::opt<unsigned> | |||
| 112 | GlobalMergeMaxOffset("global-merge-max-offset", cl::Hidden, | |||
| 113 | cl::desc("Set maximum offset for global merge pass"), | |||
| 114 | cl::init(0)); | |||
| 115 | ||||
| 116 | static cl::opt<bool> GlobalMergeGroupByUse( | |||
| 117 | "global-merge-group-by-use", cl::Hidden, | |||
| 118 | cl::desc("Improve global merge pass to look at uses"), cl::init(true)); | |||
| 119 | ||||
| 120 | static cl::opt<bool> GlobalMergeIgnoreSingleUse( | |||
| 121 | "global-merge-ignore-single-use", cl::Hidden, | |||
| 122 | cl::desc("Improve global merge pass to ignore globals only used alone"), | |||
| 123 | cl::init(true)); | |||
| 124 | ||||
| 125 | static cl::opt<bool> | |||
| 126 | EnableGlobalMergeOnConst("global-merge-on-const", cl::Hidden, | |||
| 127 | cl::desc("Enable global merge pass on constants"), | |||
| 128 | cl::init(false)); | |||
| 129 | ||||
| 130 | // FIXME: this could be a transitional option, and we probably need to remove | |||
| 131 | // it if only we are sure this optimization could always benefit all targets. | |||
| 132 | static cl::opt<cl::boolOrDefault> | |||
| 133 | EnableGlobalMergeOnExternal("global-merge-on-external", cl::Hidden, | |||
| 134 | cl::desc("Enable global merge pass on external linkage")); | |||
| 135 | ||||
| 136 | STATISTIC(NumMerged, "Number of globals merged")static llvm::Statistic NumMerged = {"global-merge", "NumMerged" , "Number of globals merged"}; | |||
| 137 | ||||
| 138 | namespace { | |||
| 139 | ||||
| 140 | class GlobalMerge : public FunctionPass { | |||
| 141 | const TargetMachine *TM = nullptr; | |||
| 142 | ||||
| 143 | // FIXME: Infer the maximum possible offset depending on the actual users | |||
| 144 | // (these max offsets are different for the users inside Thumb or ARM | |||
| 145 | // functions), see the code that passes in the offset in the ARM backend | |||
| 146 | // for more information. | |||
| 147 | unsigned MaxOffset; | |||
| 148 | ||||
| 149 | /// Whether we should try to optimize for size only. | |||
| 150 | /// Currently, this applies a dead simple heuristic: only consider globals | |||
| 151 | /// used in minsize functions for merging. | |||
| 152 | /// FIXME: This could learn about optsize, and be used in the cost model. | |||
| 153 | bool OnlyOptimizeForSize = false; | |||
| 154 | ||||
| 155 | /// Whether we should merge global variables that have external linkage. | |||
| 156 | bool MergeExternalGlobals = false; | |||
| 157 | ||||
| 158 | bool IsMachO; | |||
| 159 | ||||
| 160 | bool doMerge(SmallVectorImpl<GlobalVariable*> &Globals, | |||
| 161 | Module &M, bool isConst, unsigned AddrSpace) const; | |||
| 162 | ||||
| 163 | /// Merge everything in \p Globals for which the corresponding bit | |||
| 164 | /// in \p GlobalSet is set. | |||
| 165 | bool doMerge(const SmallVectorImpl<GlobalVariable *> &Globals, | |||
| 166 | const BitVector &GlobalSet, Module &M, bool isConst, | |||
| 167 | unsigned AddrSpace) const; | |||
| 168 | ||||
| 169 | /// Check if the given variable has been identified as must keep | |||
| 170 | /// \pre setMustKeepGlobalVariables must have been called on the Module that | |||
| 171 | /// contains GV | |||
| 172 | bool isMustKeepGlobalVariable(const GlobalVariable *GV) const { | |||
| 173 | return MustKeepGlobalVariables.count(GV); | |||
| 174 | } | |||
| 175 | ||||
| 176 | /// Collect every variables marked as "used" or used in a landing pad | |||
| 177 | /// instruction for this Module. | |||
| 178 | void setMustKeepGlobalVariables(Module &M); | |||
| 179 | ||||
| 180 | /// Collect every variables marked as "used" | |||
| 181 | void collectUsedGlobalVariables(Module &M, StringRef Name); | |||
| 182 | ||||
| 183 | /// Keep track of the GlobalVariable that must not be merged away | |||
| 184 | SmallPtrSet<const GlobalVariable *, 16> MustKeepGlobalVariables; | |||
| 185 | ||||
| 186 | public: | |||
| 187 | static char ID; // Pass identification, replacement for typeid. | |||
| 188 | ||||
| 189 | explicit GlobalMerge() | |||
| 190 | : FunctionPass(ID), MaxOffset(GlobalMergeMaxOffset) { | |||
| 191 | initializeGlobalMergePass(*PassRegistry::getPassRegistry()); | |||
| 192 | } | |||
| 193 | ||||
| 194 | explicit GlobalMerge(const TargetMachine *TM, unsigned MaximalOffset, | |||
| 195 | bool OnlyOptimizeForSize, bool MergeExternalGlobals) | |||
| 196 | : FunctionPass(ID), TM(TM), MaxOffset(MaximalOffset), | |||
| 197 | OnlyOptimizeForSize(OnlyOptimizeForSize), | |||
| 198 | MergeExternalGlobals(MergeExternalGlobals) { | |||
| 199 | initializeGlobalMergePass(*PassRegistry::getPassRegistry()); | |||
| 200 | } | |||
| 201 | ||||
| 202 | bool doInitialization(Module &M) override; | |||
| 203 | bool runOnFunction(Function &F) override; | |||
| 204 | bool doFinalization(Module &M) override; | |||
| 205 | ||||
| 206 | StringRef getPassName() const override { return "Merge internal globals"; } | |||
| 207 | ||||
| 208 | void getAnalysisUsage(AnalysisUsage &AU) const override { | |||
| 209 | AU.setPreservesCFG(); | |||
| 210 | FunctionPass::getAnalysisUsage(AU); | |||
| 211 | } | |||
| 212 | }; | |||
| 213 | ||||
| 214 | } // end anonymous namespace | |||
| 215 | ||||
| 216 | char GlobalMerge::ID = 0; | |||
| 217 | ||||
| 218 | INITIALIZE_PASS(GlobalMerge, DEBUG_TYPE, "Merge global variables", false, false)static void *initializeGlobalMergePassOnce(PassRegistry & Registry) { PassInfo *PI = new PassInfo( "Merge global variables" , "global-merge", &GlobalMerge::ID, PassInfo::NormalCtor_t (callDefaultCtor<GlobalMerge>), false, false); Registry .registerPass(*PI, true); return PI; } static llvm::once_flag InitializeGlobalMergePassFlag; void llvm::initializeGlobalMergePass (PassRegistry &Registry) { llvm::call_once(InitializeGlobalMergePassFlag , initializeGlobalMergePassOnce, std::ref(Registry)); } | |||
| 219 | ||||
| 220 | bool GlobalMerge::doMerge(SmallVectorImpl<GlobalVariable*> &Globals, | |||
| 221 | Module &M, bool isConst, unsigned AddrSpace) const { | |||
| 222 | auto &DL = M.getDataLayout(); | |||
| 223 | // FIXME: Find better heuristics | |||
| 224 | llvm::stable_sort( | |||
| 225 | Globals, [&DL](const GlobalVariable *GV1, const GlobalVariable *GV2) { | |||
| 226 | // We don't support scalable global variables. | |||
| 227 | return DL.getTypeAllocSize(GV1->getValueType()).getFixedSize() < | |||
| 228 | DL.getTypeAllocSize(GV2->getValueType()).getFixedSize(); | |||
| 229 | }); | |||
| 230 | ||||
| 231 | // If we want to just blindly group all globals together, do so. | |||
| 232 | if (!GlobalMergeGroupByUse) { | |||
| 233 | BitVector AllGlobals(Globals.size()); | |||
| 234 | AllGlobals.set(); | |||
| 235 | return doMerge(Globals, AllGlobals, M, isConst, AddrSpace); | |||
| 236 | } | |||
| 237 | ||||
| 238 | // If we want to be smarter, look at all uses of each global, to try to | |||
| 239 | // discover all sets of globals used together, and how many times each of | |||
| 240 | // these sets occurred. | |||
| 241 | // | |||
| 242 | // Keep this reasonably efficient, by having an append-only list of all sets | |||
| 243 | // discovered so far (UsedGlobalSet), and mapping each "together-ness" unit of | |||
| 244 | // code (currently, a Function) to the set of globals seen so far that are | |||
| 245 | // used together in that unit (GlobalUsesByFunction). | |||
| 246 | // | |||
| 247 | // When we look at the Nth global, we know that any new set is either: | |||
| 248 | // - the singleton set {N}, containing this global only, or | |||
| 249 | // - the union of {N} and a previously-discovered set, containing some | |||
| 250 | // combination of the previous N-1 globals. | |||
| 251 | // Using that knowledge, when looking at the Nth global, we can keep: | |||
| 252 | // - a reference to the singleton set {N} (CurGVOnlySetIdx) | |||
| 253 | // - a list mapping each previous set to its union with {N} (EncounteredUGS), | |||
| 254 | // if it actually occurs. | |||
| 255 | ||||
| 256 | // We keep track of the sets of globals used together "close enough". | |||
| 257 | struct UsedGlobalSet { | |||
| 258 | BitVector Globals; | |||
| 259 | unsigned UsageCount = 1; | |||
| 260 | ||||
| 261 | UsedGlobalSet(size_t Size) : Globals(Size) {} | |||
| 262 | }; | |||
| 263 | ||||
| 264 | // Each set is unique in UsedGlobalSets. | |||
| 265 | std::vector<UsedGlobalSet> UsedGlobalSets; | |||
| 266 | ||||
| 267 | // Avoid repeating the create-global-set pattern. | |||
| 268 | auto CreateGlobalSet = [&]() -> UsedGlobalSet & { | |||
| 269 | UsedGlobalSets.emplace_back(Globals.size()); | |||
| 270 | return UsedGlobalSets.back(); | |||
| 271 | }; | |||
| 272 | ||||
| 273 | // The first set is the empty set. | |||
| 274 | CreateGlobalSet().UsageCount = 0; | |||
| 275 | ||||
| 276 | // We define "close enough" to be "in the same function". | |||
| 277 | // FIXME: Grouping uses by function is way too aggressive, so we should have | |||
| 278 | // a better metric for distance between uses. | |||
| 279 | // The obvious alternative would be to group by BasicBlock, but that's in | |||
| 280 | // turn too conservative.. | |||
| 281 | // Anything in between wouldn't be trivial to compute, so just stick with | |||
| 282 | // per-function grouping. | |||
| 283 | ||||
| 284 | // The value type is an index into UsedGlobalSets. | |||
| 285 | // The default (0) conveniently points to the empty set. | |||
| 286 | DenseMap<Function *, size_t /*UsedGlobalSetIdx*/> GlobalUsesByFunction; | |||
| 287 | ||||
| 288 | // Now, look at each merge-eligible global in turn. | |||
| 289 | ||||
| 290 | // Keep track of the sets we already encountered to which we added the | |||
| 291 | // current global. | |||
| 292 | // Each element matches the same-index element in UsedGlobalSets. | |||
| 293 | // This lets us efficiently tell whether a set has already been expanded to | |||
| 294 | // include the current global. | |||
| 295 | std::vector<size_t> EncounteredUGS; | |||
| 296 | ||||
| 297 | for (size_t GI = 0, GE = Globals.size(); GI != GE; ++GI) { | |||
| 298 | GlobalVariable *GV = Globals[GI]; | |||
| 299 | ||||
| 300 | // Reset the encountered sets for this global... | |||
| 301 | std::fill(EncounteredUGS.begin(), EncounteredUGS.end(), 0); | |||
| 302 | // ...and grow it in case we created new sets for the previous global. | |||
| 303 | EncounteredUGS.resize(UsedGlobalSets.size()); | |||
| 304 | ||||
| 305 | // We might need to create a set that only consists of the current global. | |||
| 306 | // Keep track of its index into UsedGlobalSets. | |||
| 307 | size_t CurGVOnlySetIdx = 0; | |||
| 308 | ||||
| 309 | // For each global, look at all its Uses. | |||
| 310 | for (auto &U : GV->uses()) { | |||
| 311 | // This Use might be a ConstantExpr. We're interested in Instruction | |||
| 312 | // users, so look through ConstantExpr... | |||
| 313 | Use *UI, *UE; | |||
| 314 | if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U.getUser())) { | |||
| 315 | if (CE->use_empty()) | |||
| 316 | continue; | |||
| 317 | UI = &*CE->use_begin(); | |||
| 318 | UE = nullptr; | |||
| 319 | } else if (isa<Instruction>(U.getUser())) { | |||
| 320 | UI = &U; | |||
| 321 | UE = UI->getNext(); | |||
| 322 | } else { | |||
| 323 | continue; | |||
| 324 | } | |||
| 325 | ||||
| 326 | // ...to iterate on all the instruction users of the global. | |||
| 327 | // Note that we iterate on Uses and not on Users to be able to getNext(). | |||
| 328 | for (; UI != UE; UI = UI->getNext()) { | |||
| 329 | Instruction *I = dyn_cast<Instruction>(UI->getUser()); | |||
| 330 | if (!I) | |||
| 331 | continue; | |||
| 332 | ||||
| 333 | Function *ParentFn = I->getParent()->getParent(); | |||
| 334 | ||||
| 335 | // If we're only optimizing for size, ignore non-minsize functions. | |||
| 336 | if (OnlyOptimizeForSize && !ParentFn->hasMinSize()) | |||
| 337 | continue; | |||
| 338 | ||||
| 339 | size_t UGSIdx = GlobalUsesByFunction[ParentFn]; | |||
| 340 | ||||
| 341 | // If this is the first global the basic block uses, map it to the set | |||
| 342 | // consisting of this global only. | |||
| 343 | if (!UGSIdx) { | |||
| 344 | // If that set doesn't exist yet, create it. | |||
| 345 | if (!CurGVOnlySetIdx) { | |||
| 346 | CurGVOnlySetIdx = UsedGlobalSets.size(); | |||
| 347 | CreateGlobalSet().Globals.set(GI); | |||
| 348 | } else { | |||
| 349 | ++UsedGlobalSets[CurGVOnlySetIdx].UsageCount; | |||
| 350 | } | |||
| 351 | ||||
| 352 | GlobalUsesByFunction[ParentFn] = CurGVOnlySetIdx; | |||
| 353 | continue; | |||
| 354 | } | |||
| 355 | ||||
| 356 | // If we already encountered this BB, just increment the counter. | |||
| 357 | if (UsedGlobalSets[UGSIdx].Globals.test(GI)) { | |||
| 358 | ++UsedGlobalSets[UGSIdx].UsageCount; | |||
| 359 | continue; | |||
| 360 | } | |||
| 361 | ||||
| 362 | // If not, the previous set wasn't actually used in this function. | |||
| 363 | --UsedGlobalSets[UGSIdx].UsageCount; | |||
| 364 | ||||
| 365 | // If we already expanded the previous set to include this global, just | |||
| 366 | // reuse that expanded set. | |||
| 367 | if (size_t ExpandedIdx = EncounteredUGS[UGSIdx]) { | |||
| 368 | ++UsedGlobalSets[ExpandedIdx].UsageCount; | |||
| 369 | GlobalUsesByFunction[ParentFn] = ExpandedIdx; | |||
| 370 | continue; | |||
| 371 | } | |||
| 372 | ||||
| 373 | // If not, create a new set consisting of the union of the previous set | |||
| 374 | // and this global. Mark it as encountered, so we can reuse it later. | |||
| 375 | GlobalUsesByFunction[ParentFn] = EncounteredUGS[UGSIdx] = | |||
| 376 | UsedGlobalSets.size(); | |||
| 377 | ||||
| 378 | UsedGlobalSet &NewUGS = CreateGlobalSet(); | |||
| 379 | NewUGS.Globals.set(GI); | |||
| 380 | NewUGS.Globals |= UsedGlobalSets[UGSIdx].Globals; | |||
| 381 | } | |||
| 382 | } | |||
| 383 | } | |||
| 384 | ||||
| 385 | // Now we found a bunch of sets of globals used together. We accumulated | |||
| 386 | // the number of times we encountered the sets (i.e., the number of blocks | |||
| 387 | // that use that exact set of globals). | |||
| 388 | // | |||
| 389 | // Multiply that by the size of the set to give us a crude profitability | |||
| 390 | // metric. | |||
| 391 | llvm::stable_sort(UsedGlobalSets, | |||
| 392 | [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) { | |||
| 393 | return UGS1.Globals.count() * UGS1.UsageCount < | |||
| 394 | UGS2.Globals.count() * UGS2.UsageCount; | |||
| 395 | }); | |||
| 396 | ||||
| 397 | // We can choose to merge all globals together, but ignore globals never used | |||
| 398 | // with another global. This catches the obviously non-profitable cases of | |||
| 399 | // having a single global, but is aggressive enough for any other case. | |||
| 400 | if (GlobalMergeIgnoreSingleUse) { | |||
| 401 | BitVector AllGlobals(Globals.size()); | |||
| 402 | for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) { | |||
| 403 | const UsedGlobalSet &UGS = UsedGlobalSets[e - i - 1]; | |||
| 404 | if (UGS.UsageCount == 0) | |||
| 405 | continue; | |||
| 406 | if (UGS.Globals.count() > 1) | |||
| 407 | AllGlobals |= UGS.Globals; | |||
| 408 | } | |||
| 409 | return doMerge(Globals, AllGlobals, M, isConst, AddrSpace); | |||
| 410 | } | |||
| 411 | ||||
| 412 | // Starting from the sets with the best (=biggest) profitability, find a | |||
| 413 | // good combination. | |||
| 414 | // The ideal (and expensive) solution can only be found by trying all | |||
| 415 | // combinations, looking for the one with the best profitability. | |||
| 416 | // Don't be smart about it, and just pick the first compatible combination, | |||
| 417 | // starting with the sets with the best profitability. | |||
| 418 | BitVector PickedGlobals(Globals.size()); | |||
| 419 | bool Changed = false; | |||
| 420 | ||||
| 421 | for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) { | |||
| 422 | const UsedGlobalSet &UGS = UsedGlobalSets[e - i - 1]; | |||
| 423 | if (UGS.UsageCount == 0) | |||
| 424 | continue; | |||
| 425 | if (PickedGlobals.anyCommon(UGS.Globals)) | |||
| 426 | continue; | |||
| 427 | PickedGlobals |= UGS.Globals; | |||
| 428 | // If the set only contains one global, there's no point in merging. | |||
| 429 | // Ignore the global for inclusion in other sets though, so keep it in | |||
| 430 | // PickedGlobals. | |||
| 431 | if (UGS.Globals.count() < 2) | |||
| 432 | continue; | |||
| 433 | Changed |= doMerge(Globals, UGS.Globals, M, isConst, AddrSpace); | |||
| 434 | } | |||
| 435 | ||||
| 436 | return Changed; | |||
| 437 | } | |||
| 438 | ||||
| 439 | bool GlobalMerge::doMerge(const SmallVectorImpl<GlobalVariable *> &Globals, | |||
| 440 | const BitVector &GlobalSet, Module &M, bool isConst, | |||
| 441 | unsigned AddrSpace) const { | |||
| 442 | assert(Globals.size() > 1)((void)0); | |||
| 443 | ||||
| 444 | Type *Int32Ty = Type::getInt32Ty(M.getContext()); | |||
| 445 | Type *Int8Ty = Type::getInt8Ty(M.getContext()); | |||
| 446 | auto &DL = M.getDataLayout(); | |||
| 447 | ||||
| 448 | LLVM_DEBUG(dbgs() << " Trying to merge set, starts with #"do { } while (false) | |||
| 449 | << GlobalSet.find_first() << "\n")do { } while (false); | |||
| 450 | ||||
| 451 | bool Changed = false; | |||
| 452 | ssize_t i = GlobalSet.find_first(); | |||
| 453 | while (i != -1) { | |||
| 454 | ssize_t j = 0; | |||
| 455 | uint64_t MergedSize = 0; | |||
| 456 | std::vector<Type*> Tys; | |||
| 457 | std::vector<Constant*> Inits; | |||
| 458 | std::vector<unsigned> StructIdxs; | |||
| 459 | ||||
| 460 | bool HasExternal = false; | |||
| 461 | StringRef FirstExternalName; | |||
| 462 | Align MaxAlign; | |||
| 463 | unsigned CurIdx = 0; | |||
| 464 | for (j = i; j != -1; j = GlobalSet.find_next(j)) { | |||
| 465 | Type *Ty = Globals[j]->getValueType(); | |||
| 466 | ||||
| 467 | // Make sure we use the same alignment AsmPrinter would use. | |||
| 468 | Align Alignment = DL.getPreferredAlign(Globals[j]); | |||
| 469 | unsigned Padding = alignTo(MergedSize, Alignment) - MergedSize; | |||
| 470 | MergedSize += Padding; | |||
| 471 | MergedSize += DL.getTypeAllocSize(Ty); | |||
| 472 | if (MergedSize > MaxOffset) { | |||
| 473 | break; | |||
| 474 | } | |||
| 475 | if (Padding) { | |||
| 476 | Tys.push_back(ArrayType::get(Int8Ty, Padding)); | |||
| 477 | Inits.push_back(ConstantAggregateZero::get(Tys.back())); | |||
| 478 | ++CurIdx; | |||
| 479 | } | |||
| 480 | Tys.push_back(Ty); | |||
| 481 | Inits.push_back(Globals[j]->getInitializer()); | |||
| 482 | StructIdxs.push_back(CurIdx++); | |||
| 483 | ||||
| 484 | MaxAlign = std::max(MaxAlign, Alignment); | |||
| 485 | ||||
| 486 | if (Globals[j]->hasExternalLinkage() && !HasExternal) { | |||
| 487 | HasExternal = true; | |||
| 488 | FirstExternalName = Globals[j]->getName(); | |||
| 489 | } | |||
| 490 | } | |||
| 491 | ||||
| 492 | // Exit early if there is only one global to merge. | |||
| 493 | if (Tys.size() < 2) { | |||
| 494 | i = j; | |||
| 495 | continue; | |||
| 496 | } | |||
| 497 | ||||
| 498 | // If merged variables doesn't have external linkage, we needn't to expose | |||
| 499 | // the symbol after merging. | |||
| 500 | GlobalValue::LinkageTypes Linkage = HasExternal | |||
| 501 | ? GlobalValue::ExternalLinkage | |||
| 502 | : GlobalValue::InternalLinkage; | |||
| 503 | // Use a packed struct so we can control alignment. | |||
| 504 | StructType *MergedTy = StructType::get(M.getContext(), Tys, true); | |||
| 505 | Constant *MergedInit = ConstantStruct::get(MergedTy, Inits); | |||
| 506 | ||||
| 507 | // On Darwin external linkage needs to be preserved, otherwise | |||
| 508 | // dsymutil cannot preserve the debug info for the merged | |||
| 509 | // variables. If they have external linkage, use the symbol name | |||
| 510 | // of the first variable merged as the suffix of global symbol | |||
| 511 | // name. This avoids a link-time naming conflict for the | |||
| 512 | // _MergedGlobals symbols. | |||
| 513 | Twine MergedName = | |||
| 514 | (IsMachO && HasExternal) | |||
| 515 | ? "_MergedGlobals_" + FirstExternalName | |||
| 516 | : "_MergedGlobals"; | |||
| 517 | auto MergedLinkage = IsMachO ? Linkage : GlobalValue::PrivateLinkage; | |||
| 518 | auto *MergedGV = new GlobalVariable( | |||
| 519 | M, MergedTy, isConst, MergedLinkage, MergedInit, MergedName, nullptr, | |||
| 520 | GlobalVariable::NotThreadLocal, AddrSpace); | |||
| 521 | ||||
| 522 | MergedGV->setAlignment(MaxAlign); | |||
| 523 | MergedGV->setSection(Globals[i]->getSection()); | |||
| 524 | ||||
| 525 | const StructLayout *MergedLayout = DL.getStructLayout(MergedTy); | |||
| 526 | for (ssize_t k = i, idx = 0; k != j; k = GlobalSet.find_next(k), ++idx) { | |||
| 527 | GlobalValue::LinkageTypes Linkage = Globals[k]->getLinkage(); | |||
| 528 | std::string Name(Globals[k]->getName()); | |||
| 529 | GlobalValue::VisibilityTypes Visibility = Globals[k]->getVisibility(); | |||
| 530 | GlobalValue::DLLStorageClassTypes DLLStorage = | |||
| 531 | Globals[k]->getDLLStorageClass(); | |||
| 532 | ||||
| 533 | // Copy metadata while adjusting any debug info metadata by the original | |||
| 534 | // global's offset within the merged global. | |||
| 535 | MergedGV->copyMetadata(Globals[k], | |||
| 536 | MergedLayout->getElementOffset(StructIdxs[idx])); | |||
| 537 | ||||
| 538 | Constant *Idx[2] = { | |||
| 539 | ConstantInt::get(Int32Ty, 0), | |||
| 540 | ConstantInt::get(Int32Ty, StructIdxs[idx]), | |||
| 541 | }; | |||
| 542 | Constant *GEP = | |||
| 543 | ConstantExpr::getInBoundsGetElementPtr(MergedTy, MergedGV, Idx); | |||
| 544 | Globals[k]->replaceAllUsesWith(GEP); | |||
| 545 | Globals[k]->eraseFromParent(); | |||
| 546 | ||||
| 547 | // When the linkage is not internal we must emit an alias for the original | |||
| 548 | // variable name as it may be accessed from another object. On non-Mach-O | |||
| 549 | // we can also emit an alias for internal linkage as it's safe to do so. | |||
| 550 | // It's not safe on Mach-O as the alias (and thus the portion of the | |||
| 551 | // MergedGlobals variable) may be dead stripped at link time. | |||
| 552 | if (Linkage != GlobalValue::InternalLinkage || !IsMachO) { | |||
| 553 | GlobalAlias *GA = GlobalAlias::create(Tys[StructIdxs[idx]], AddrSpace, | |||
| 554 | Linkage, Name, GEP, &M); | |||
| 555 | GA->setVisibility(Visibility); | |||
| 556 | GA->setDLLStorageClass(DLLStorage); | |||
| 557 | } | |||
| 558 | ||||
| 559 | NumMerged++; | |||
| 560 | } | |||
| 561 | Changed = true; | |||
| 562 | i = j; | |||
| 563 | } | |||
| 564 | ||||
| 565 | return Changed; | |||
| 566 | } | |||
| 567 | ||||
| 568 | void GlobalMerge::collectUsedGlobalVariables(Module &M, StringRef Name) { | |||
| 569 | // Extract global variables from llvm.used array | |||
| 570 | const GlobalVariable *GV = M.getGlobalVariable(Name); | |||
| 571 | if (!GV || !GV->hasInitializer()) return; | |||
| 572 | ||||
| 573 | // Should be an array of 'i8*'. | |||
| 574 | const ConstantArray *InitList = cast<ConstantArray>(GV->getInitializer()); | |||
| 575 | ||||
| 576 | for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) | |||
| 577 | if (const GlobalVariable *G = | |||
| 578 | dyn_cast<GlobalVariable>(InitList->getOperand(i)->stripPointerCasts())) | |||
| 579 | MustKeepGlobalVariables.insert(G); | |||
| 580 | } | |||
| 581 | ||||
| 582 | void GlobalMerge::setMustKeepGlobalVariables(Module &M) { | |||
| 583 | collectUsedGlobalVariables(M, "llvm.used"); | |||
| 584 | collectUsedGlobalVariables(M, "llvm.compiler.used"); | |||
| 585 | ||||
| 586 | for (Function &F : M) { | |||
| 587 | for (BasicBlock &BB : F) { | |||
| 588 | Instruction *Pad = BB.getFirstNonPHI(); | |||
| 589 | if (!Pad->isEHPad()) | |||
| 590 | continue; | |||
| 591 | ||||
| 592 | // Keep globals used by landingpads and catchpads. | |||
| 593 | for (const Use &U : Pad->operands()) { | |||
| 594 | if (const GlobalVariable *GV = | |||
| 595 | dyn_cast<GlobalVariable>(U->stripPointerCasts())) | |||
| 596 | MustKeepGlobalVariables.insert(GV); | |||
| 597 | } | |||
| 598 | } | |||
| 599 | } | |||
| 600 | } | |||
| 601 | ||||
| 602 | bool GlobalMerge::doInitialization(Module &M) { | |||
| 603 | if (!EnableGlobalMerge) | |||
| ||||
| 604 | return false; | |||
| 605 | ||||
| 606 | IsMachO = Triple(M.getTargetTriple()).isOSBinFormatMachO(); | |||
| 607 | ||||
| 608 | auto &DL = M.getDataLayout(); | |||
| 609 | DenseMap<std::pair<unsigned, StringRef>, SmallVector<GlobalVariable *, 16>> | |||
| 610 | Globals, ConstGlobals, BSSGlobals; | |||
| 611 | bool Changed = false; | |||
| 612 | setMustKeepGlobalVariables(M); | |||
| 613 | ||||
| 614 | // Grab all non-const globals. | |||
| 615 | for (auto &GV : M.globals()) { | |||
| 616 | // Merge is safe for "normal" internal or external globals only | |||
| 617 | if (GV.isDeclaration() || GV.isThreadLocal() || GV.hasImplicitSection()) | |||
| 618 | continue; | |||
| 619 | ||||
| 620 | // It's not safe to merge globals that may be preempted | |||
| 621 | if (TM && !TM->shouldAssumeDSOLocal(M, &GV)) | |||
| 622 | continue; | |||
| 623 | ||||
| 624 | if (!(MergeExternalGlobals && GV.hasExternalLinkage()) && | |||
| 625 | !GV.hasInternalLinkage()) | |||
| 626 | continue; | |||
| 627 | ||||
| 628 | PointerType *PT = dyn_cast<PointerType>(GV.getType()); | |||
| 629 | assert(PT && "Global variable is not a pointer!")((void)0); | |||
| 630 | ||||
| 631 | unsigned AddressSpace = PT->getAddressSpace(); | |||
| ||||
| 632 | StringRef Section = GV.getSection(); | |||
| 633 | ||||
| 634 | // Ignore all 'special' globals. | |||
| 635 | if (GV.getName().startswith("llvm.") || | |||
| 636 | GV.getName().startswith(".llvm.")) | |||
| 637 | continue; | |||
| 638 | ||||
| 639 | // Ignore all "required" globals: | |||
| 640 | if (isMustKeepGlobalVariable(&GV)) | |||
| 641 | continue; | |||
| 642 | ||||
| 643 | Type *Ty = GV.getValueType(); | |||
| 644 | if (DL.getTypeAllocSize(Ty) < MaxOffset) { | |||
| 645 | if (TM && | |||
| 646 | TargetLoweringObjectFile::getKindForGlobal(&GV, *TM).isBSS()) | |||
| 647 | BSSGlobals[{AddressSpace, Section}].push_back(&GV); | |||
| 648 | else if (GV.isConstant()) | |||
| 649 | ConstGlobals[{AddressSpace, Section}].push_back(&GV); | |||
| 650 | else | |||
| 651 | Globals[{AddressSpace, Section}].push_back(&GV); | |||
| 652 | } | |||
| 653 | } | |||
| 654 | ||||
| 655 | for (auto &P : Globals) | |||
| 656 | if (P.second.size() > 1) | |||
| 657 | Changed |= doMerge(P.second, M, false, P.first.first); | |||
| 658 | ||||
| 659 | for (auto &P : BSSGlobals) | |||
| 660 | if (P.second.size() > 1) | |||
| 661 | Changed |= doMerge(P.second, M, false, P.first.first); | |||
| 662 | ||||
| 663 | if (EnableGlobalMergeOnConst) | |||
| 664 | for (auto &P : ConstGlobals) | |||
| 665 | if (P.second.size() > 1) | |||
| 666 | Changed |= doMerge(P.second, M, true, P.first.first); | |||
| 667 | ||||
| 668 | return Changed; | |||
| 669 | } | |||
| 670 | ||||
| 671 | bool GlobalMerge::runOnFunction(Function &F) { | |||
| 672 | return false; | |||
| 673 | } | |||
| 674 | ||||
| 675 | bool GlobalMerge::doFinalization(Module &M) { | |||
| 676 | MustKeepGlobalVariables.clear(); | |||
| 677 | return false; | |||
| 678 | } | |||
| 679 | ||||
| 680 | Pass *llvm::createGlobalMergePass(const TargetMachine *TM, unsigned Offset, | |||
| 681 | bool OnlyOptimizeForSize, | |||
| 682 | bool MergeExternalByDefault) { | |||
| 683 | bool MergeExternal = (EnableGlobalMergeOnExternal == cl::BOU_UNSET) ? | |||
| 684 | MergeExternalByDefault : (EnableGlobalMergeOnExternal == cl::BOU_TRUE); | |||
| 685 | return new GlobalMerge(TM, Offset, OnlyOptimizeForSize, MergeExternal); | |||
| 686 | } |
| 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 "llvm/Support/MD5.h" |
| 28 | #include <cassert> |
| 29 | #include <cstdint> |
| 30 | #include <string> |
| 31 | |
| 32 | namespace llvm { |
| 33 | |
| 34 | class Comdat; |
| 35 | class ConstantRange; |
| 36 | class Error; |
| 37 | class GlobalObject; |
| 38 | class Module; |
| 39 | |
| 40 | namespace Intrinsic { |
| 41 | typedef unsigned ID; |
| 42 | } // end namespace Intrinsic |
| 43 | |
| 44 | class GlobalValue : public Constant { |
| 45 | public: |
| 46 | /// An enumeration for the kinds of linkage for global values. |
| 47 | enum LinkageTypes { |
| 48 | ExternalLinkage = 0,///< Externally visible function |
| 49 | AvailableExternallyLinkage, ///< Available for inspection, not emission. |
| 50 | LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline) |
| 51 | LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent. |
| 52 | WeakAnyLinkage, ///< Keep one copy of named function when linking (weak) |
| 53 | WeakODRLinkage, ///< Same, but only replaced by something equivalent. |
| 54 | AppendingLinkage, ///< Special purpose, only applies to global arrays |
| 55 | InternalLinkage, ///< Rename collisions when linking (static functions). |
| 56 | PrivateLinkage, ///< Like Internal, but omit from symbol table. |
| 57 | ExternalWeakLinkage,///< ExternalWeak linkage description. |
| 58 | CommonLinkage ///< Tentative definitions. |
| 59 | }; |
| 60 | |
| 61 | /// An enumeration for the kinds of visibility of global values. |
| 62 | enum VisibilityTypes { |
| 63 | DefaultVisibility = 0, ///< The GV is visible |
| 64 | HiddenVisibility, ///< The GV is hidden |
| 65 | ProtectedVisibility ///< The GV is protected |
| 66 | }; |
| 67 | |
| 68 | /// Storage classes of global values for PE targets. |
| 69 | enum DLLStorageClassTypes { |
| 70 | DefaultStorageClass = 0, |
| 71 | DLLImportStorageClass = 1, ///< Function to be imported from DLL |
| 72 | DLLExportStorageClass = 2 ///< Function to be accessible from DLL. |
| 73 | }; |
| 74 | |
| 75 | protected: |
| 76 | GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps, |
| 77 | LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace) |
| 78 | : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps), |
| 79 | ValueType(Ty), Visibility(DefaultVisibility), |
| 80 | UnnamedAddrVal(unsigned(UnnamedAddr::None)), |
| 81 | DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal), |
| 82 | HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false), |
| 83 | IntID((Intrinsic::ID)0U), Parent(nullptr) { |
| 84 | setLinkage(Linkage); |
| 85 | setName(Name); |
| 86 | } |
| 87 | |
| 88 | Type *ValueType; |
| 89 | |
| 90 | static const unsigned GlobalValueSubClassDataBits = 16; |
| 91 | |
| 92 | // All bitfields use unsigned as the underlying type so that MSVC will pack |
| 93 | // them. |
| 94 | unsigned Linkage : 4; // The linkage of this global |
| 95 | unsigned Visibility : 2; // The visibility style of this global |
| 96 | unsigned UnnamedAddrVal : 2; // This value's address is not significant |
| 97 | unsigned DllStorageClass : 2; // DLL storage class |
| 98 | |
| 99 | unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is |
| 100 | // the desired model? |
| 101 | |
| 102 | /// True if the function's name starts with "llvm.". This corresponds to the |
| 103 | /// value of Function::isIntrinsic(), which may be true even if |
| 104 | /// Function::intrinsicID() returns Intrinsic::not_intrinsic. |
| 105 | unsigned HasLLVMReservedName : 1; |
| 106 | |
| 107 | /// If true then there is a definition within the same linkage unit and that |
| 108 | /// definition cannot be runtime preempted. |
| 109 | unsigned IsDSOLocal : 1; |
| 110 | |
| 111 | /// True if this symbol has a partition name assigned (see |
| 112 | /// https://lld.llvm.org/Partitions.html). |
| 113 | unsigned HasPartition : 1; |
| 114 | |
| 115 | private: |
| 116 | // Give subclasses access to what otherwise would be wasted padding. |
| 117 | // (16 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1) == 32. |
| 118 | unsigned SubClassData : GlobalValueSubClassDataBits; |
| 119 | |
| 120 | friend class Constant; |
| 121 | |
| 122 | void destroyConstantImpl(); |
| 123 | Value *handleOperandChangeImpl(Value *From, Value *To); |
| 124 | |
| 125 | /// Returns true if the definition of this global may be replaced by a |
| 126 | /// differently optimized variant of the same source level function at link |
| 127 | /// time. |
| 128 | bool mayBeDerefined() const { |
| 129 | switch (getLinkage()) { |
| 130 | case WeakODRLinkage: |
| 131 | case LinkOnceODRLinkage: |
| 132 | case AvailableExternallyLinkage: |
| 133 | return true; |
| 134 | |
| 135 | case WeakAnyLinkage: |
| 136 | case LinkOnceAnyLinkage: |
| 137 | case CommonLinkage: |
| 138 | case ExternalWeakLinkage: |
| 139 | case ExternalLinkage: |
| 140 | case AppendingLinkage: |
| 141 | case InternalLinkage: |
| 142 | case PrivateLinkage: |
| 143 | return isInterposable(); |
| 144 | } |
| 145 | |
| 146 | llvm_unreachable("Fully covered switch above!")__builtin_unreachable(); |
| 147 | } |
| 148 | |
| 149 | protected: |
| 150 | /// The intrinsic ID for this subclass (which must be a Function). |
| 151 | /// |
| 152 | /// This member is defined by this class, but not used for anything. |
| 153 | /// Subclasses can use it to store their intrinsic ID, if they have one. |
| 154 | /// |
| 155 | /// This is stored here to save space in Function on 64-bit hosts. |
| 156 | Intrinsic::ID IntID; |
| 157 | |
| 158 | unsigned getGlobalValueSubClassData() const { |
| 159 | return SubClassData; |
| 160 | } |
| 161 | void setGlobalValueSubClassData(unsigned V) { |
| 162 | assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit")((void)0); |
| 163 | SubClassData = V; |
| 164 | } |
| 165 | |
| 166 | Module *Parent; // The containing module. |
| 167 | |
| 168 | // Used by SymbolTableListTraits. |
| 169 | void setParent(Module *parent) { |
| 170 | Parent = parent; |
| 171 | } |
| 172 | |
| 173 | ~GlobalValue() { |
| 174 | removeDeadConstantUsers(); // remove any dead constants using this. |
| 175 | } |
| 176 | |
| 177 | public: |
| 178 | enum ThreadLocalMode { |
| 179 | NotThreadLocal = 0, |
| 180 | GeneralDynamicTLSModel, |
| 181 | LocalDynamicTLSModel, |
| 182 | InitialExecTLSModel, |
| 183 | LocalExecTLSModel |
| 184 | }; |
| 185 | |
| 186 | GlobalValue(const GlobalValue &) = delete; |
| 187 | |
| 188 | unsigned getAddressSpace() const; |
| 189 | |
| 190 | enum class UnnamedAddr { |
| 191 | None, |
| 192 | Local, |
| 193 | Global, |
| 194 | }; |
| 195 | |
| 196 | bool hasGlobalUnnamedAddr() const { |
| 197 | return getUnnamedAddr() == UnnamedAddr::Global; |
| 198 | } |
| 199 | |
| 200 | /// Returns true if this value's address is not significant in this module. |
| 201 | /// This attribute is intended to be used only by the code generator and LTO |
| 202 | /// to allow the linker to decide whether the global needs to be in the symbol |
| 203 | /// table. It should probably not be used in optimizations, as the value may |
| 204 | /// have uses outside the module; use hasGlobalUnnamedAddr() instead. |
| 205 | bool hasAtLeastLocalUnnamedAddr() const { |
| 206 | return getUnnamedAddr() != UnnamedAddr::None; |
| 207 | } |
| 208 | |
| 209 | UnnamedAddr getUnnamedAddr() const { |
| 210 | return UnnamedAddr(UnnamedAddrVal); |
| 211 | } |
| 212 | void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); } |
| 213 | |
| 214 | static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) { |
| 215 | if (A == UnnamedAddr::None || B == UnnamedAddr::None) |
| 216 | return UnnamedAddr::None; |
| 217 | if (A == UnnamedAddr::Local || B == UnnamedAddr::Local) |
| 218 | return UnnamedAddr::Local; |
| 219 | return UnnamedAddr::Global; |
| 220 | } |
| 221 | |
| 222 | bool hasComdat() const { return getComdat() != nullptr; } |
| 223 | const Comdat *getComdat() const; |
| 224 | Comdat *getComdat() { |
| 225 | return const_cast<Comdat *>( |
| 226 | static_cast<const GlobalValue *>(this)->getComdat()); |
| 227 | } |
| 228 | |
| 229 | VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); } |
| 230 | bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; } |
| 231 | bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; } |
| 232 | bool hasProtectedVisibility() const { |
| 233 | return Visibility == ProtectedVisibility; |
| 234 | } |
| 235 | void setVisibility(VisibilityTypes V) { |
| 236 | assert((!hasLocalLinkage() || V == DefaultVisibility) &&((void)0) |
| 237 | "local linkage requires default visibility")((void)0); |
| 238 | Visibility = V; |
| 239 | if (isImplicitDSOLocal()) |
| 240 | setDSOLocal(true); |
| 241 | } |
| 242 | |
| 243 | /// If the value is "Thread Local", its value isn't shared by the threads. |
| 244 | bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; } |
| 245 | void setThreadLocal(bool Val) { |
| 246 | setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal); |
| 247 | } |
| 248 | void setThreadLocalMode(ThreadLocalMode Val) { |
| 249 | assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal)((void)0); |
| 250 | ThreadLocal = Val; |
| 251 | } |
| 252 | ThreadLocalMode getThreadLocalMode() const { |
| 253 | return static_cast<ThreadLocalMode>(ThreadLocal); |
| 254 | } |
| 255 | |
| 256 | DLLStorageClassTypes getDLLStorageClass() const { |
| 257 | return DLLStorageClassTypes(DllStorageClass); |
| 258 | } |
| 259 | bool hasDLLImportStorageClass() const { |
| 260 | return DllStorageClass == DLLImportStorageClass; |
| 261 | } |
| 262 | bool hasDLLExportStorageClass() const { |
| 263 | return DllStorageClass == DLLExportStorageClass; |
| 264 | } |
| 265 | void setDLLStorageClass(DLLStorageClassTypes C) { DllStorageClass = C; } |
| 266 | |
| 267 | bool hasSection() const { return !getSection().empty(); } |
| 268 | StringRef getSection() const; |
| 269 | |
| 270 | /// Global values are always pointers. |
| 271 | PointerType *getType() const { return cast<PointerType>(User::getType()); } |
| 272 | |
| 273 | Type *getValueType() const { return ValueType; } |
| 274 | |
| 275 | bool isImplicitDSOLocal() const { |
| 276 | return hasLocalLinkage() || |
| 277 | (!hasDefaultVisibility() && !hasExternalWeakLinkage()); |
| 278 | } |
| 279 | |
| 280 | void setDSOLocal(bool Local) { IsDSOLocal = Local; } |
| 281 | |
| 282 | bool isDSOLocal() const { |
| 283 | return IsDSOLocal; |
| 284 | } |
| 285 | |
| 286 | bool hasPartition() const { |
| 287 | return HasPartition; |
| 288 | } |
| 289 | StringRef getPartition() const; |
| 290 | void setPartition(StringRef Part); |
| 291 | |
| 292 | static LinkageTypes getLinkOnceLinkage(bool ODR) { |
| 293 | return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage; |
| 294 | } |
| 295 | static LinkageTypes getWeakLinkage(bool ODR) { |
| 296 | return ODR ? WeakODRLinkage : WeakAnyLinkage; |
| 297 | } |
| 298 | |
| 299 | static bool isExternalLinkage(LinkageTypes Linkage) { |
| 300 | return Linkage == ExternalLinkage; |
| 301 | } |
| 302 | static bool isAvailableExternallyLinkage(LinkageTypes Linkage) { |
| 303 | return Linkage == AvailableExternallyLinkage; |
| 304 | } |
| 305 | static bool isLinkOnceODRLinkage(LinkageTypes Linkage) { |
| 306 | return Linkage == LinkOnceODRLinkage; |
| 307 | } |
| 308 | static bool isLinkOnceLinkage(LinkageTypes Linkage) { |
| 309 | return Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage; |
| 310 | } |
| 311 | static bool isWeakAnyLinkage(LinkageTypes Linkage) { |
| 312 | return Linkage == WeakAnyLinkage; |
| 313 | } |
| 314 | static bool isWeakODRLinkage(LinkageTypes Linkage) { |
| 315 | return Linkage == WeakODRLinkage; |
| 316 | } |
| 317 | static bool isWeakLinkage(LinkageTypes Linkage) { |
| 318 | return isWeakAnyLinkage(Linkage) || isWeakODRLinkage(Linkage); |
| 319 | } |
| 320 | static bool isAppendingLinkage(LinkageTypes Linkage) { |
| 321 | return Linkage == AppendingLinkage; |
| 322 | } |
| 323 | static bool isInternalLinkage(LinkageTypes Linkage) { |
| 324 | return Linkage == InternalLinkage; |
| 325 | } |
| 326 | static bool isPrivateLinkage(LinkageTypes Linkage) { |
| 327 | return Linkage == PrivateLinkage; |
| 328 | } |
| 329 | static bool isLocalLinkage(LinkageTypes Linkage) { |
| 330 | return isInternalLinkage(Linkage) || isPrivateLinkage(Linkage); |
| 331 | } |
| 332 | static bool isExternalWeakLinkage(LinkageTypes Linkage) { |
| 333 | return Linkage == ExternalWeakLinkage; |
| 334 | } |
| 335 | static bool isCommonLinkage(LinkageTypes Linkage) { |
| 336 | return Linkage == CommonLinkage; |
| 337 | } |
| 338 | static bool isValidDeclarationLinkage(LinkageTypes Linkage) { |
| 339 | return isExternalWeakLinkage(Linkage) || isExternalLinkage(Linkage); |
| 340 | } |
| 341 | |
| 342 | /// Whether the definition of this global may be replaced by something |
| 343 | /// non-equivalent at link time. For example, if a function has weak linkage |
| 344 | /// then the code defining it may be replaced by different code. |
| 345 | static bool isInterposableLinkage(LinkageTypes Linkage) { |
| 346 | switch (Linkage) { |
| 347 | case WeakAnyLinkage: |
| 348 | case LinkOnceAnyLinkage: |
| 349 | case CommonLinkage: |
| 350 | case ExternalWeakLinkage: |
| 351 | return true; |
| 352 | |
| 353 | case AvailableExternallyLinkage: |
| 354 | case LinkOnceODRLinkage: |
| 355 | case WeakODRLinkage: |
| 356 | // The above three cannot be overridden but can be de-refined. |
| 357 | |
| 358 | case ExternalLinkage: |
| 359 | case AppendingLinkage: |
| 360 | case InternalLinkage: |
| 361 | case PrivateLinkage: |
| 362 | return false; |
| 363 | } |
| 364 | llvm_unreachable("Fully covered switch above!")__builtin_unreachable(); |
| 365 | } |
| 366 | |
| 367 | /// Whether the definition of this global may be discarded if it is not used |
| 368 | /// in its compilation unit. |
| 369 | static bool isDiscardableIfUnused(LinkageTypes Linkage) { |
| 370 | return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage) || |
| 371 | isAvailableExternallyLinkage(Linkage); |
| 372 | } |
| 373 | |
| 374 | /// Whether the definition of this global may be replaced at link time. NB: |
| 375 | /// Using this method outside of the code generators is almost always a |
| 376 | /// mistake: when working at the IR level use isInterposable instead as it |
| 377 | /// knows about ODR semantics. |
| 378 | static bool isWeakForLinker(LinkageTypes Linkage) { |
| 379 | return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage || |
| 380 | Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage || |
| 381 | Linkage == CommonLinkage || Linkage == ExternalWeakLinkage; |
| 382 | } |
| 383 | |
| 384 | /// Return true if the currently visible definition of this global (if any) is |
| 385 | /// exactly the definition we will see at runtime. |
| 386 | /// |
| 387 | /// Non-exact linkage types inhibits most non-inlining IPO, since a |
| 388 | /// differently optimized variant of the same function can have different |
| 389 | /// observable or undefined behavior than in the variant currently visible. |
| 390 | /// For instance, we could have started with |
| 391 | /// |
| 392 | /// void foo(int *v) { |
| 393 | /// int t = 5 / v[0]; |
| 394 | /// (void) t; |
| 395 | /// } |
| 396 | /// |
| 397 | /// and "refined" it to |
| 398 | /// |
| 399 | /// void foo(int *v) { } |
| 400 | /// |
| 401 | /// However, we cannot infer readnone for `foo`, since that would justify |
| 402 | /// DSE'ing a store to `v[0]` across a call to `foo`, which can cause |
| 403 | /// undefined behavior if the linker replaces the actual call destination with |
| 404 | /// the unoptimized `foo`. |
| 405 | /// |
| 406 | /// Inlining is okay across non-exact linkage types as long as they're not |
| 407 | /// interposable (see \c isInterposable), since in such cases the currently |
| 408 | /// visible variant is *a* correct implementation of the original source |
| 409 | /// function; it just isn't the *only* correct implementation. |
| 410 | bool isDefinitionExact() const { |
| 411 | return !mayBeDerefined(); |
| 412 | } |
| 413 | |
| 414 | /// Return true if this global has an exact defintion. |
| 415 | bool hasExactDefinition() const { |
| 416 | // While this computes exactly the same thing as |
| 417 | // isStrongDefinitionForLinker, the intended uses are different. This |
| 418 | // function is intended to help decide if specific inter-procedural |
| 419 | // transforms are correct, while isStrongDefinitionForLinker's intended use |
| 420 | // is in low level code generation. |
| 421 | return !isDeclaration() && isDefinitionExact(); |
| 422 | } |
| 423 | |
| 424 | /// Return true if this global's definition can be substituted with an |
| 425 | /// *arbitrary* definition at link time or load time. We cannot do any IPO or |
| 426 | /// inlining across interposable call edges, since the callee can be |
| 427 | /// replaced with something arbitrary. |
| 428 | bool isInterposable() const; |
| 429 | bool canBenefitFromLocalAlias() const; |
| 430 | |
| 431 | bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); } |
| 432 | bool hasAvailableExternallyLinkage() const { |
| 433 | return isAvailableExternallyLinkage(getLinkage()); |
| 434 | } |
| 435 | bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); } |
| 436 | bool hasLinkOnceODRLinkage() const { |
| 437 | return isLinkOnceODRLinkage(getLinkage()); |
| 438 | } |
| 439 | bool hasWeakLinkage() const { return isWeakLinkage(getLinkage()); } |
| 440 | bool hasWeakAnyLinkage() const { return isWeakAnyLinkage(getLinkage()); } |
| 441 | bool hasWeakODRLinkage() const { return isWeakODRLinkage(getLinkage()); } |
| 442 | bool hasAppendingLinkage() const { return isAppendingLinkage(getLinkage()); } |
| 443 | bool hasInternalLinkage() const { return isInternalLinkage(getLinkage()); } |
| 444 | bool hasPrivateLinkage() const { return isPrivateLinkage(getLinkage()); } |
| 445 | bool hasLocalLinkage() const { return isLocalLinkage(getLinkage()); } |
| 446 | bool hasExternalWeakLinkage() const { |
| 447 | return isExternalWeakLinkage(getLinkage()); |
| 448 | } |
| 449 | bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); } |
| 450 | bool hasValidDeclarationLinkage() const { |
| 451 | return isValidDeclarationLinkage(getLinkage()); |
| 452 | } |
| 453 | |
| 454 | void setLinkage(LinkageTypes LT) { |
| 455 | if (isLocalLinkage(LT)) |
| 456 | Visibility = DefaultVisibility; |
| 457 | Linkage = LT; |
| 458 | if (isImplicitDSOLocal()) |
| 459 | setDSOLocal(true); |
| 460 | } |
| 461 | LinkageTypes getLinkage() const { return LinkageTypes(Linkage); } |
| 462 | |
| 463 | bool isDiscardableIfUnused() const { |
| 464 | return isDiscardableIfUnused(getLinkage()); |
| 465 | } |
| 466 | |
| 467 | bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); } |
| 468 | |
| 469 | protected: |
| 470 | /// Copy all additional attributes (those not needed to create a GlobalValue) |
| 471 | /// from the GlobalValue Src to this one. |
| 472 | void copyAttributesFrom(const GlobalValue *Src); |
| 473 | |
| 474 | public: |
| 475 | /// If the given string begins with the GlobalValue name mangling escape |
| 476 | /// character '\1', drop it. |
| 477 | /// |
| 478 | /// This function applies a specific mangling that is used in PGO profiles, |
| 479 | /// among other things. If you're trying to get a symbol name for an |
| 480 | /// arbitrary GlobalValue, this is not the function you're looking for; see |
| 481 | /// Mangler.h. |
| 482 | static StringRef dropLLVMManglingEscape(StringRef Name) { |
| 483 | if (!Name.empty() && Name[0] == '\1') |
| 484 | return Name.substr(1); |
| 485 | return Name; |
| 486 | } |
| 487 | |
| 488 | /// Return the modified name for a global value suitable to be |
| 489 | /// used as the key for a global lookup (e.g. profile or ThinLTO). |
| 490 | /// The value's original name is \c Name and has linkage of type |
| 491 | /// \c Linkage. The value is defined in module \c FileName. |
| 492 | static std::string getGlobalIdentifier(StringRef Name, |
| 493 | GlobalValue::LinkageTypes Linkage, |
| 494 | StringRef FileName); |
| 495 | |
| 496 | /// Return the modified name for this global value suitable to be |
| 497 | /// used as the key for a global lookup (e.g. profile or ThinLTO). |
| 498 | std::string getGlobalIdentifier() const; |
| 499 | |
| 500 | /// Declare a type to represent a global unique identifier for a global value. |
| 501 | /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact |
| 502 | /// unique way to identify a symbol. |
| 503 | using GUID = uint64_t; |
| 504 | |
| 505 | /// Return a 64-bit global unique ID constructed from global value name |
| 506 | /// (i.e. returned by getGlobalIdentifier()). |
| 507 | static GUID getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); } |
| 508 | |
| 509 | /// Return a 64-bit global unique ID constructed from global value name |
| 510 | /// (i.e. returned by getGlobalIdentifier()). |
| 511 | GUID getGUID() const { return getGUID(getGlobalIdentifier()); } |
| 512 | |
| 513 | /// @name Materialization |
| 514 | /// Materialization is used to construct functions only as they're needed. |
| 515 | /// This |
| 516 | /// is useful to reduce memory usage in LLVM or parsing work done by the |
| 517 | /// BitcodeReader to load the Module. |
| 518 | /// @{ |
| 519 | |
| 520 | /// If this function's Module is being lazily streamed in functions from disk |
| 521 | /// or some other source, this method can be used to check to see if the |
| 522 | /// function has been read in yet or not. |
| 523 | bool isMaterializable() const; |
| 524 | |
| 525 | /// Make sure this GlobalValue is fully read. |
| 526 | Error materialize(); |
| 527 | |
| 528 | /// @} |
| 529 | |
| 530 | /// Return true if the primary definition of this global value is outside of |
| 531 | /// the current translation unit. |
| 532 | bool isDeclaration() const; |
| 533 | |
| 534 | bool isDeclarationForLinker() const { |
| 535 | if (hasAvailableExternallyLinkage()) |
| 536 | return true; |
| 537 | |
| 538 | return isDeclaration(); |
| 539 | } |
| 540 | |
| 541 | /// Returns true if this global's definition will be the one chosen by the |
| 542 | /// linker. |
| 543 | /// |
| 544 | /// NB! Ideally this should not be used at the IR level at all. If you're |
| 545 | /// interested in optimization constraints implied by the linker's ability to |
| 546 | /// choose an implementation, prefer using \c hasExactDefinition. |
| 547 | bool isStrongDefinitionForLinker() const { |
| 548 | return !(isDeclarationForLinker() || isWeakForLinker()); |
| 549 | } |
| 550 | |
| 551 | const GlobalObject *getBaseObject() const; |
| 552 | GlobalObject *getBaseObject() { |
| 553 | return const_cast<GlobalObject *>( |
| 554 | static_cast<const GlobalValue *>(this)->getBaseObject()); |
| 555 | } |
| 556 | |
| 557 | /// Returns whether this is a reference to an absolute symbol. |
| 558 | bool isAbsoluteSymbolRef() const; |
| 559 | |
| 560 | /// If this is an absolute symbol reference, returns the range of the symbol, |
| 561 | /// otherwise returns None. |
| 562 | Optional<ConstantRange> getAbsoluteSymbolRange() const; |
| 563 | |
| 564 | /// This method unlinks 'this' from the containing module, but does not delete |
| 565 | /// it. |
| 566 | void removeFromParent(); |
| 567 | |
| 568 | /// This method unlinks 'this' from the containing module and deletes it. |
| 569 | void eraseFromParent(); |
| 570 | |
| 571 | /// Get the module that this global value is contained inside of... |
| 572 | Module *getParent() { return Parent; } |
| 573 | const Module *getParent() const { return Parent; } |
| 574 | |
| 575 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 576 | static bool classof(const Value *V) { |
| 577 | return V->getValueID() == Value::FunctionVal || |
| 578 | V->getValueID() == Value::GlobalVariableVal || |
| 579 | V->getValueID() == Value::GlobalAliasVal || |
| 580 | V->getValueID() == Value::GlobalIFuncVal; |
| 581 | } |
| 582 | |
| 583 | /// True if GV can be left out of the object symbol table. This is the case |
| 584 | /// for linkonce_odr values whose address is not significant. While legal, it |
| 585 | /// is not normally profitable to omit them from the .o symbol table. Using |
| 586 | /// this analysis makes sense when the information can be passed down to the |
| 587 | /// linker or we are in LTO. |
| 588 | bool canBeOmittedFromSymbolTable() const; |
| 589 | }; |
| 590 | |
| 591 | } // end namespace llvm |
| 592 | |
| 593 | #endif // LLVM_IR_GLOBALVALUE_H |
| 1 | //===-- llvm/GlobalVariable.h - GlobalVariable class ------------*- 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 contains the declaration of the GlobalVariable class, which |
| 10 | // represents a single global variable (or constant) in the VM. |
| 11 | // |
| 12 | // Global variables are constant pointers that refer to hunks of space that are |
| 13 | // allocated by either the VM, or by the linker in a static compiler. A global |
| 14 | // variable may have an initial value, which is copied into the executables .data |
| 15 | // area. Global Constants are required to have initializers. |
| 16 | // |
| 17 | //===----------------------------------------------------------------------===// |
| 18 | |
| 19 | #ifndef LLVM_IR_GLOBALVARIABLE_H |
| 20 | #define LLVM_IR_GLOBALVARIABLE_H |
| 21 | |
| 22 | #include "llvm/ADT/Twine.h" |
| 23 | #include "llvm/ADT/ilist_node.h" |
| 24 | #include "llvm/IR/Attributes.h" |
| 25 | #include "llvm/IR/GlobalObject.h" |
| 26 | #include "llvm/IR/OperandTraits.h" |
| 27 | #include "llvm/IR/Value.h" |
| 28 | #include <cassert> |
| 29 | #include <cstddef> |
| 30 | |
| 31 | namespace llvm { |
| 32 | |
| 33 | class Constant; |
| 34 | class Module; |
| 35 | |
| 36 | template <typename ValueSubClass> class SymbolTableListTraits; |
| 37 | class DIGlobalVariable; |
| 38 | class DIGlobalVariableExpression; |
| 39 | |
| 40 | class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> { |
| 41 | friend class SymbolTableListTraits<GlobalVariable>; |
| 42 | |
| 43 | AttributeSet Attrs; |
| 44 | bool isConstantGlobal : 1; // Is this a global constant? |
| 45 | bool isExternallyInitializedConstant : 1; // Is this a global whose value |
| 46 | // can change from its initial |
| 47 | // value before global |
| 48 | // initializers are run? |
| 49 | |
| 50 | public: |
| 51 | /// GlobalVariable ctor - If a parent module is specified, the global is |
| 52 | /// automatically inserted into the end of the specified modules global list. |
| 53 | GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage, |
| 54 | Constant *Initializer = nullptr, const Twine &Name = "", |
| 55 | ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0, |
| 56 | bool isExternallyInitialized = false); |
| 57 | /// GlobalVariable ctor - This creates a global and inserts it before the |
| 58 | /// specified other global. |
| 59 | GlobalVariable(Module &M, Type *Ty, bool isConstant, LinkageTypes Linkage, |
| 60 | Constant *Initializer, const Twine &Name = "", |
| 61 | GlobalVariable *InsertBefore = nullptr, |
| 62 | ThreadLocalMode = NotThreadLocal, |
| 63 | Optional<unsigned> AddressSpace = None, |
| 64 | bool isExternallyInitialized = false); |
| 65 | GlobalVariable(const GlobalVariable &) = delete; |
| 66 | GlobalVariable &operator=(const GlobalVariable &) = delete; |
| 67 | |
| 68 | ~GlobalVariable() { |
| 69 | dropAllReferences(); |
| 70 | } |
| 71 | |
| 72 | // allocate space for exactly one operand |
| 73 | void *operator new(size_t s) { |
| 74 | return User::operator new(s, 1); |
| 75 | } |
| 76 | |
| 77 | // delete space for exactly one operand as created in the corresponding new operator |
| 78 | void operator delete(void *ptr){ |
| 79 | assert(ptr != nullptr && "must not be nullptr")((void)0); |
| 80 | User *Obj = static_cast<User *>(ptr); |
| 81 | // Number of operands can be set to 0 after construction and initialization. Make sure |
| 82 | // that number of operands is reset to 1, as this is needed in User::operator delete |
| 83 | Obj->setGlobalVariableNumOperands(1); |
| 84 | User::operator delete(Obj); |
| 85 | } |
| 86 | |
| 87 | /// Provide fast operand accessors |
| 88 | DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value)public: inline Value *getOperand(unsigned) const; inline void setOperand(unsigned, Value*); inline op_iterator op_begin(); inline const_op_iterator op_begin() const; inline op_iterator op_end(); inline const_op_iterator op_end() const; protected : template <int> inline Use &Op(); template <int > inline const Use &Op() const; public: inline unsigned getNumOperands() const; |
| 89 | |
| 90 | /// Definitions have initializers, declarations don't. |
| 91 | /// |
| 92 | inline bool hasInitializer() const { return !isDeclaration(); } |
| 93 | |
| 94 | /// hasDefinitiveInitializer - Whether the global variable has an initializer, |
| 95 | /// and any other instances of the global (this can happen due to weak |
| 96 | /// linkage) are guaranteed to have the same initializer. |
| 97 | /// |
| 98 | /// Note that if you want to transform a global, you must use |
| 99 | /// hasUniqueInitializer() instead, because of the *_odr linkage type. |
| 100 | /// |
| 101 | /// Example: |
| 102 | /// |
| 103 | /// @a = global SomeType* null - Initializer is both definitive and unique. |
| 104 | /// |
| 105 | /// @b = global weak SomeType* null - Initializer is neither definitive nor |
| 106 | /// unique. |
| 107 | /// |
| 108 | /// @c = global weak_odr SomeType* null - Initializer is definitive, but not |
| 109 | /// unique. |
| 110 | inline bool hasDefinitiveInitializer() const { |
| 111 | return hasInitializer() && |
| 112 | // The initializer of a global variable may change to something arbitrary |
| 113 | // at link time. |
| 114 | !isInterposable() && |
| 115 | // The initializer of a global variable with the externally_initialized |
| 116 | // marker may change at runtime before C++ initializers are evaluated. |
| 117 | !isExternallyInitialized(); |
| 118 | } |
| 119 | |
| 120 | /// hasUniqueInitializer - Whether the global variable has an initializer, and |
| 121 | /// any changes made to the initializer will turn up in the final executable. |
| 122 | inline bool hasUniqueInitializer() const { |
| 123 | return |
| 124 | // We need to be sure this is the definition that will actually be used |
| 125 | isStrongDefinitionForLinker() && |
| 126 | // It is not safe to modify initializers of global variables with the |
| 127 | // external_initializer marker since the value may be changed at runtime |
| 128 | // before C++ initializers are evaluated. |
| 129 | !isExternallyInitialized(); |
| 130 | } |
| 131 | |
| 132 | /// getInitializer - Return the initializer for this global variable. It is |
| 133 | /// illegal to call this method if the global is external, because we cannot |
| 134 | /// tell what the value is initialized to! |
| 135 | /// |
| 136 | inline const Constant *getInitializer() const { |
| 137 | assert(hasInitializer() && "GV doesn't have initializer!")((void)0); |
| 138 | return static_cast<Constant*>(Op<0>().get()); |
| 139 | } |
| 140 | inline Constant *getInitializer() { |
| 141 | assert(hasInitializer() && "GV doesn't have initializer!")((void)0); |
| 142 | return static_cast<Constant*>(Op<0>().get()); |
| 143 | } |
| 144 | /// setInitializer - Sets the initializer for this global variable, removing |
| 145 | /// any existing initializer if InitVal==NULL. If this GV has type T*, the |
| 146 | /// initializer must have type T. |
| 147 | void setInitializer(Constant *InitVal); |
| 148 | |
| 149 | /// If the value is a global constant, its value is immutable throughout the |
| 150 | /// runtime execution of the program. Assigning a value into the constant |
| 151 | /// leads to undefined behavior. |
| 152 | /// |
| 153 | bool isConstant() const { return isConstantGlobal; } |
| 154 | void setConstant(bool Val) { isConstantGlobal = Val; } |
| 155 | |
| 156 | bool isExternallyInitialized() const { |
| 157 | return isExternallyInitializedConstant; |
| 158 | } |
| 159 | void setExternallyInitialized(bool Val) { |
| 160 | isExternallyInitializedConstant = Val; |
| 161 | } |
| 162 | |
| 163 | /// copyAttributesFrom - copy all additional attributes (those not needed to |
| 164 | /// create a GlobalVariable) from the GlobalVariable Src to this one. |
| 165 | void copyAttributesFrom(const GlobalVariable *Src); |
| 166 | |
| 167 | /// removeFromParent - This method unlinks 'this' from the containing module, |
| 168 | /// but does not delete it. |
| 169 | /// |
| 170 | void removeFromParent(); |
| 171 | |
| 172 | /// eraseFromParent - This method unlinks 'this' from the containing module |
| 173 | /// and deletes it. |
| 174 | /// |
| 175 | void eraseFromParent(); |
| 176 | |
| 177 | /// Drop all references in preparation to destroy the GlobalVariable. This |
| 178 | /// drops not only the reference to the initializer but also to any metadata. |
| 179 | void dropAllReferences(); |
| 180 | |
| 181 | /// Attach a DIGlobalVariableExpression. |
| 182 | void addDebugInfo(DIGlobalVariableExpression *GV); |
| 183 | |
| 184 | /// Fill the vector with all debug info attachements. |
| 185 | void getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const; |
| 186 | |
| 187 | /// Add attribute to this global. |
| 188 | void addAttribute(Attribute::AttrKind Kind) { |
| 189 | Attrs = Attrs.addAttribute(getContext(), Kind); |
| 190 | } |
| 191 | |
| 192 | /// Add attribute to this global. |
| 193 | void addAttribute(StringRef Kind, StringRef Val = StringRef()) { |
| 194 | Attrs = Attrs.addAttribute(getContext(), Kind, Val); |
| 195 | } |
| 196 | |
| 197 | /// Return true if the attribute exists. |
| 198 | bool hasAttribute(Attribute::AttrKind Kind) const { |
| 199 | return Attrs.hasAttribute(Kind); |
| 200 | } |
| 201 | |
| 202 | /// Return true if the attribute exists. |
| 203 | bool hasAttribute(StringRef Kind) const { |
| 204 | return Attrs.hasAttribute(Kind); |
| 205 | } |
| 206 | |
| 207 | /// Return true if any attributes exist. |
| 208 | bool hasAttributes() const { |
| 209 | return Attrs.hasAttributes(); |
| 210 | } |
| 211 | |
| 212 | /// Return the attribute object. |
| 213 | Attribute getAttribute(Attribute::AttrKind Kind) const { |
| 214 | return Attrs.getAttribute(Kind); |
| 215 | } |
| 216 | |
| 217 | /// Return the attribute object. |
| 218 | Attribute getAttribute(StringRef Kind) const { |
| 219 | return Attrs.getAttribute(Kind); |
| 220 | } |
| 221 | |
| 222 | /// Return the attribute set for this global |
| 223 | AttributeSet getAttributes() const { |
| 224 | return Attrs; |
| 225 | } |
| 226 | |
| 227 | /// Return attribute set as list with index. |
| 228 | /// FIXME: This may not be required once ValueEnumerators |
| 229 | /// in bitcode-writer can enumerate attribute-set. |
| 230 | AttributeList getAttributesAsList(unsigned index) const { |
| 231 | if (!hasAttributes()) |
| 232 | return AttributeList(); |
| 233 | std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}}; |
| 234 | return AttributeList::get(getContext(), AS); |
| 235 | } |
| 236 | |
| 237 | /// Set attribute list for this global |
| 238 | void setAttributes(AttributeSet A) { |
| 239 | Attrs = A; |
| 240 | } |
| 241 | |
| 242 | /// Check if section name is present |
| 243 | bool hasImplicitSection() const { |
| 244 | return getAttributes().hasAttribute("bss-section") || |
| 245 | getAttributes().hasAttribute("data-section") || |
| 246 | getAttributes().hasAttribute("relro-section") || |
| 247 | getAttributes().hasAttribute("rodata-section"); |
| 248 | } |
| 249 | |
| 250 | // Methods for support type inquiry through isa, cast, and dyn_cast: |
| 251 | static bool classof(const Value *V) { |
| 252 | return V->getValueID() == Value::GlobalVariableVal; |
| 253 | } |
| 254 | }; |
| 255 | |
| 256 | template <> |
| 257 | struct OperandTraits<GlobalVariable> : |
| 258 | public OptionalOperandTraits<GlobalVariable> { |
| 259 | }; |
| 260 | |
| 261 | DEFINE_TRANSPARENT_OPERAND_ACCESSORS(GlobalVariable, Value)GlobalVariable::op_iterator GlobalVariable::op_begin() { return OperandTraits<GlobalVariable>::op_begin(this); } GlobalVariable ::const_op_iterator GlobalVariable::op_begin() const { return OperandTraits<GlobalVariable>::op_begin(const_cast< GlobalVariable*>(this)); } GlobalVariable::op_iterator GlobalVariable ::op_end() { return OperandTraits<GlobalVariable>::op_end (this); } GlobalVariable::const_op_iterator GlobalVariable::op_end () const { return OperandTraits<GlobalVariable>::op_end (const_cast<GlobalVariable*>(this)); } Value *GlobalVariable ::getOperand(unsigned i_nocapture) const { ((void)0); return cast_or_null <Value>( OperandTraits<GlobalVariable>::op_begin( const_cast<GlobalVariable*>(this))[i_nocapture].get()); } void GlobalVariable::setOperand(unsigned i_nocapture, Value *Val_nocapture) { ((void)0); OperandTraits<GlobalVariable >::op_begin(this)[i_nocapture] = Val_nocapture; } unsigned GlobalVariable::getNumOperands() const { return OperandTraits <GlobalVariable>::operands(this); } template <int Idx_nocapture > Use &GlobalVariable::Op() { return this->OpFrom< Idx_nocapture>(this); } template <int Idx_nocapture> const Use &GlobalVariable::Op() const { return this-> OpFrom<Idx_nocapture>(this); } |
| 262 | |
| 263 | } // end namespace llvm |
| 264 | |
| 265 | #endif // LLVM_IR_GLOBALVARIABLE_H |