/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/GlobalMerge.cpp

Bug Summary

File:	llvm/lib/CodeGen/GlobalMerge.cpp
Warning:	line 631, column 29 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name GlobalMerge.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/GlobalMerge.cpp

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/lib/CodeGen/GlobalMerge.cpp

→

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// ===---------------------------------------------------------------------===//

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>

101using namespace llvm;

103#define DEBUG_TYPE"global-merge" "global-merge"

105// FIXME: This is only useful as a last-resort way to disable the pass.
106static cl::opt<bool>
107EnableGlobalMerge("enable-global-merge", cl::Hidden,
                cl::desc("Enable the global merge pass"),
                cl::init(true));

111static cl::opt<unsigned>
112GlobalMergeMaxOffset("global-merge-max-offset", cl::Hidden,
                   cl::desc("Set maximum offset for global merge pass"),
                   cl::init(0));

116static cl::opt<bool> GlobalMergeGroupByUse(
  "global-merge-group-by-use", cl::Hidden,
  cl::desc("Improve global merge pass to look at uses"), cl::init(true));

120static cl::opt<bool> GlobalMergeIgnoreSingleUse(
  "global-merge-ignore-single-use", cl::Hidden,
  cl::desc("Improve global merge pass to ignore globals only used alone"),
  cl::init(true));

125static cl::opt<bool>
126EnableGlobalMergeOnConst("global-merge-on-const", cl::Hidden,
                       cl::desc("Enable global merge pass on constants"),
                       cl::init(false));

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.
132static cl::opt<cl::boolOrDefault>
133EnableGlobalMergeOnExternal("global-merge-on-external", cl::Hidden,
   cl::desc("Enable global merge pass on external linkage"));

136STATISTIC(NumMerged, "Number of globals merged")static llvm::Statistic NumMerged = {"global-merge", "NumMerged"
, "Number of globals merged"};

138namespace {

class GlobalMerge : public FunctionPass {
  const TargetMachine *TM = nullptr;

  // FIXME: Infer the maximum possible offset depending on the actual users
  // (these max offsets are different for the users inside Thumb or ARM
  // functions), see the code that passes in the offset in the ARM backend
  // for more information.
  unsigned MaxOffset;

  /// Whether we should try to optimize for size only.
  /// Currently, this applies a dead simple heuristic: only consider globals
  /// used in minsize functions for merging.
  /// FIXME: This could learn about optsize, and be used in the cost model.
  bool OnlyOptimizeForSize = false;

  /// Whether we should merge global variables that have external linkage.
  bool MergeExternalGlobals = false;

  bool IsMachO;

  bool doMerge(SmallVectorImpl<GlobalVariable*> &Globals,
               Module &M, bool isConst, unsigned AddrSpace) const;

  /// Merge everything in \p Globals for which the corresponding bit
  /// in \p GlobalSet is set.
  bool doMerge(const SmallVectorImpl<GlobalVariable *> &Globals,
               const BitVector &GlobalSet, Module &M, bool isConst,
               unsigned AddrSpace) const;

  /// Check if the given variable has been identified as must keep
  /// \pre setMustKeepGlobalVariables must have been called on the Module that
  ///      contains GV
  bool isMustKeepGlobalVariable(const GlobalVariable *GV) const {
    return MustKeepGlobalVariables.count(GV);
  }

  /// Collect every variables marked as "used" or used in a landing pad
  /// instruction for this Module.
  void setMustKeepGlobalVariables(Module &M);

  /// Collect every variables marked as "used"
  void collectUsedGlobalVariables(Module &M, StringRef Name);

  /// Keep track of the GlobalVariable that must not be merged away
  SmallPtrSet<const GlobalVariable *, 16> MustKeepGlobalVariables;

public:
  static char ID;             // Pass identification, replacement for typeid.

  explicit GlobalMerge()
      : FunctionPass(ID), MaxOffset(GlobalMergeMaxOffset) {
    initializeGlobalMergePass(*PassRegistry::getPassRegistry());
  }

  explicit GlobalMerge(const TargetMachine *TM, unsigned MaximalOffset,
                       bool OnlyOptimizeForSize, bool MergeExternalGlobals)
      : FunctionPass(ID), TM(TM), MaxOffset(MaximalOffset),
        OnlyOptimizeForSize(OnlyOptimizeForSize),
        MergeExternalGlobals(MergeExternalGlobals) {
    initializeGlobalMergePass(*PassRegistry::getPassRegistry());
  }

  bool doInitialization(Module &M) override;
  bool runOnFunction(Function &F) override;
  bool doFinalization(Module &M) override;

  StringRef getPassName() const override { return "Merge internal globals"; }

  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.setPreservesCFG();
    FunctionPass::getAnalysisUsage(AU);
  }
};

214} // end anonymous namespace

216char GlobalMerge::ID = 0;

218INITIALIZE_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)); }

220bool GlobalMerge::doMerge(SmallVectorImpl<GlobalVariable*> &Globals,
                        Module &M, bool isConst, unsigned AddrSpace) const {
auto &DL = M.getDataLayout();
// FIXME: Find better heuristics
llvm::stable_sort(
    Globals, [&DL](const GlobalVariable *GV1, const GlobalVariable *GV2) {
      // We don't support scalable global variables.
      return DL.getTypeAllocSize(GV1->getValueType()).getFixedSize() <
             DL.getTypeAllocSize(GV2->getValueType()).getFixedSize();
    });

// If we want to just blindly group all globals together, do so.
if (!GlobalMergeGroupByUse) {
  BitVector AllGlobals(Globals.size());
  AllGlobals.set();
  return doMerge(Globals, AllGlobals, M, isConst, AddrSpace);
}

// If we want to be smarter, look at all uses of each global, to try to
// discover all sets of globals used together, and how many times each of
// these sets occurred.
//
// Keep this reasonably efficient, by having an append-only list of all sets
// discovered so far (UsedGlobalSet), and mapping each "together-ness" unit of
// code (currently, a Function) to the set of globals seen so far that are
// used together in that unit (GlobalUsesByFunction).
//
// When we look at the Nth global, we know that any new set is either:
// - the singleton set {N}, containing this global only, or
// - the union of {N} and a previously-discovered set, containing some
//   combination of the previous N-1 globals.
// Using that knowledge, when looking at the Nth global, we can keep:
// - a reference to the singleton set {N} (CurGVOnlySetIdx)
// - a list mapping each previous set to its union with {N} (EncounteredUGS),
//   if it actually occurs.

// We keep track of the sets of globals used together "close enough".
struct UsedGlobalSet {
  BitVector Globals;
  unsigned UsageCount = 1;

  UsedGlobalSet(size_t Size) : Globals(Size) {}
};

// Each set is unique in UsedGlobalSets.
std::vector<UsedGlobalSet> UsedGlobalSets;

// Avoid repeating the create-global-set pattern.
auto CreateGlobalSet = [&]() -> UsedGlobalSet & {
  UsedGlobalSets.emplace_back(Globals.size());
  return UsedGlobalSets.back();
};

// The first set is the empty set.
CreateGlobalSet().UsageCount = 0;

// We define "close enough" to be "in the same function".
// FIXME: Grouping uses by function is way too aggressive, so we should have
// a better metric for distance between uses.
// The obvious alternative would be to group by BasicBlock, but that's in
// turn too conservative..
// Anything in between wouldn't be trivial to compute, so just stick with
// per-function grouping.

// The value type is an index into UsedGlobalSets.
// The default (0) conveniently points to the empty set.
DenseMap<Function *, size_t /*UsedGlobalSetIdx*/> GlobalUsesByFunction;

// Now, look at each merge-eligible global in turn.

// Keep track of the sets we already encountered to which we added the
// current global.
// Each element matches the same-index element in UsedGlobalSets.
// This lets us efficiently tell whether a set has already been expanded to
// include the current global.
std::vector<size_t> EncounteredUGS;

for (size_t GI = 0, GE = Globals.size(); GI != GE; ++GI) {
  GlobalVariable *GV = Globals[GI];

  // Reset the encountered sets for this global...
  std::fill(EncounteredUGS.begin(), EncounteredUGS.end(), 0);
  // ...and grow it in case we created new sets for the previous global.
  EncounteredUGS.resize(UsedGlobalSets.size());

  // We might need to create a set that only consists of the current global.
  // Keep track of its index into UsedGlobalSets.
  size_t CurGVOnlySetIdx = 0;

  // For each global, look at all its Uses.
  for (auto &U : GV->uses()) {
    // This Use might be a ConstantExpr.  We're interested in Instruction
    // users, so look through ConstantExpr...
    Use *UI, *UE;
    if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U.getUser())) {
      if (CE->use_empty())
        continue;
      UI = &*CE->use_begin();
      UE = nullptr;
    } else if (isa<Instruction>(U.getUser())) {
      UI = &U;
      UE = UI->getNext();
    } else {
      continue;
    }

    // ...to iterate on all the instruction users of the global.
    // Note that we iterate on Uses and not on Users to be able to getNext().
    for (; UI != UE; UI = UI->getNext()) {
      Instruction *I = dyn_cast<Instruction>(UI->getUser());
      if (!I)
        continue;

      Function *ParentFn = I->getParent()->getParent();

      // If we're only optimizing for size, ignore non-minsize functions.
      if (OnlyOptimizeForSize && !ParentFn->hasMinSize())
        continue;

      size_t UGSIdx = GlobalUsesByFunction[ParentFn];

      // If this is the first global the basic block uses, map it to the set
      // consisting of this global only.
      if (!UGSIdx) {
        // If that set doesn't exist yet, create it.
        if (!CurGVOnlySetIdx) {
          CurGVOnlySetIdx = UsedGlobalSets.size();
          CreateGlobalSet().Globals.set(GI);
        } else {
          ++UsedGlobalSets[CurGVOnlySetIdx].UsageCount;
        }

        GlobalUsesByFunction[ParentFn] = CurGVOnlySetIdx;
        continue;
      }

      // If we already encountered this BB, just increment the counter.
      if (UsedGlobalSets[UGSIdx].Globals.test(GI)) {
        ++UsedGlobalSets[UGSIdx].UsageCount;
        continue;
      }

      // If not, the previous set wasn't actually used in this function.
      --UsedGlobalSets[UGSIdx].UsageCount;

      // If we already expanded the previous set to include this global, just
      // reuse that expanded set.
      if (size_t ExpandedIdx = EncounteredUGS[UGSIdx]) {
        ++UsedGlobalSets[ExpandedIdx].UsageCount;
        GlobalUsesByFunction[ParentFn] = ExpandedIdx;
        continue;
      }

      // If not, create a new set consisting of the union of the previous set
      // and this global.  Mark it as encountered, so we can reuse it later.
      GlobalUsesByFunction[ParentFn] = EncounteredUGS[UGSIdx] =
          UsedGlobalSets.size();

      UsedGlobalSet &NewUGS = CreateGlobalSet();
      NewUGS.Globals.set(GI);
      NewUGS.Globals |= UsedGlobalSets[UGSIdx].Globals;
    }
  }
}

// Now we found a bunch of sets of globals used together.  We accumulated
// the number of times we encountered the sets (i.e., the number of blocks
// that use that exact set of globals).
//
// Multiply that by the size of the set to give us a crude profitability
// metric.
llvm::stable_sort(UsedGlobalSets,
                  [](const UsedGlobalSet &UGS1, const UsedGlobalSet &UGS2) {
                    return UGS1.Globals.count() * UGS1.UsageCount <
                           UGS2.Globals.count() * UGS2.UsageCount;
                  });

// We can choose to merge all globals together, but ignore globals never used
// with another global.  This catches the obviously non-profitable cases of
// having a single global, but is aggressive enough for any other case.
if (GlobalMergeIgnoreSingleUse) {
  BitVector AllGlobals(Globals.size());
  for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) {
    const UsedGlobalSet &UGS = UsedGlobalSets[e - i - 1];
    if (UGS.UsageCount == 0)
      continue;
    if (UGS.Globals.count() > 1)
      AllGlobals |= UGS.Globals;
  }
  return doMerge(Globals, AllGlobals, M, isConst, AddrSpace);
}

// Starting from the sets with the best (=biggest) profitability, find a
// good combination.
// The ideal (and expensive) solution can only be found by trying all
// combinations, looking for the one with the best profitability.
// Don't be smart about it, and just pick the first compatible combination,
// starting with the sets with the best profitability.
BitVector PickedGlobals(Globals.size());
bool Changed = false;

for (size_t i = 0, e = UsedGlobalSets.size(); i != e; ++i) {
  const UsedGlobalSet &UGS = UsedGlobalSets[e - i - 1];
  if (UGS.UsageCount == 0)
    continue;
  if (PickedGlobals.anyCommon(UGS.Globals))
    continue;
  PickedGlobals |= UGS.Globals;
  // If the set only contains one global, there's no point in merging.
  // Ignore the global for inclusion in other sets though, so keep it in
  // PickedGlobals.
  if (UGS.Globals.count() < 2)
    continue;
  Changed |= doMerge(Globals, UGS.Globals, M, isConst, AddrSpace);
}

return Changed;
437}

439bool GlobalMerge::doMerge(const SmallVectorImpl<GlobalVariable *> &Globals,
                        const BitVector &GlobalSet, Module &M, bool isConst,
                        unsigned AddrSpace) const {
assert(Globals.size() > 1)(static_cast<void> (0));

Type *Int32Ty = Type::getInt32Ty(M.getContext());
Type *Int8Ty = Type::getInt8Ty(M.getContext());
auto &DL = M.getDataLayout();

LLVM_DEBUG(dbgs() << " Trying to merge set, starts with #"do { } while (false)
                  << GlobalSet.find_first() << "\n")do { } while (false);

bool Changed = false;
ssize_t i = GlobalSet.find_first();
while (i != -1) {
  ssize_t j = 0;
  uint64_t MergedSize = 0;
  std::vector<Type*> Tys;
  std::vector<Constant*> Inits;
  std::vector<unsigned> StructIdxs;

  bool HasExternal = false;
  StringRef FirstExternalName;
  Align MaxAlign;
  unsigned CurIdx = 0;
  for (j = i; j != -1; j = GlobalSet.find_next(j)) {
    Type *Ty = Globals[j]->getValueType();

    // Make sure we use the same alignment AsmPrinter would use.
    Align Alignment = DL.getPreferredAlign(Globals[j]);
    unsigned Padding = alignTo(MergedSize, Alignment) - MergedSize;
    MergedSize += Padding;
    MergedSize += DL.getTypeAllocSize(Ty);
    if (MergedSize > MaxOffset) {
      break;
    }
    if (Padding) {
      Tys.push_back(ArrayType::get(Int8Ty, Padding));
      Inits.push_back(ConstantAggregateZero::get(Tys.back()));
      ++CurIdx;
    }
    Tys.push_back(Ty);
    Inits.push_back(Globals[j]->getInitializer());
    StructIdxs.push_back(CurIdx++);

    MaxAlign = std::max(MaxAlign, Alignment);

    if (Globals[j]->hasExternalLinkage() && !HasExternal) {
      HasExternal = true;
      FirstExternalName = Globals[j]->getName();
    }
  }

  // Exit early if there is only one global to merge.
  if (Tys.size() < 2) {
    i = j;
    continue;
  }

  // If merged variables doesn't have external linkage, we needn't to expose
  // the symbol after merging.
  GlobalValue::LinkageTypes Linkage = HasExternal
                                          ? GlobalValue::ExternalLinkage
                                          : GlobalValue::InternalLinkage;
  // Use a packed struct so we can control alignment.
  StructType *MergedTy = StructType::get(M.getContext(), Tys, true);
  Constant *MergedInit = ConstantStruct::get(MergedTy, Inits);

  // On Darwin external linkage needs to be preserved, otherwise
  // dsymutil cannot preserve the debug info for the merged
  // variables.  If they have external linkage, use the symbol name
  // of the first variable merged as the suffix of global symbol
  // name.  This avoids a link-time naming conflict for the
  // _MergedGlobals symbols.
  Twine MergedName =
      (IsMachO && HasExternal)
          ? "_MergedGlobals_" + FirstExternalName
          : "_MergedGlobals";
  auto MergedLinkage = IsMachO ? Linkage : GlobalValue::PrivateLinkage;
  auto *MergedGV = new GlobalVariable(
      M, MergedTy, isConst, MergedLinkage, MergedInit, MergedName, nullptr,
      GlobalVariable::NotThreadLocal, AddrSpace);

  MergedGV->setAlignment(MaxAlign);
  MergedGV->setSection(Globals[i]->getSection());

  const StructLayout *MergedLayout = DL.getStructLayout(MergedTy);
  for (ssize_t k = i, idx = 0; k != j; k = GlobalSet.find_next(k), ++idx) {
    GlobalValue::LinkageTypes Linkage = Globals[k]->getLinkage();
    std::string Name(Globals[k]->getName());
    GlobalValue::VisibilityTypes Visibility = Globals[k]->getVisibility();
    GlobalValue::DLLStorageClassTypes DLLStorage =
        Globals[k]->getDLLStorageClass();

    // Copy metadata while adjusting any debug info metadata by the original
    // global's offset within the merged global.
    MergedGV->copyMetadata(Globals[k],
                           MergedLayout->getElementOffset(StructIdxs[idx]));

    Constant *Idx[2] = {
        ConstantInt::get(Int32Ty, 0),
        ConstantInt::get(Int32Ty, StructIdxs[idx]),
    };
    Constant *GEP =
        ConstantExpr::getInBoundsGetElementPtr(MergedTy, MergedGV, Idx);
    Globals[k]->replaceAllUsesWith(GEP);
    Globals[k]->eraseFromParent();

    // When the linkage is not internal we must emit an alias for the original
    // variable name as it may be accessed from another object. On non-Mach-O
    // we can also emit an alias for internal linkage as it's safe to do so.
    // It's not safe on Mach-O as the alias (and thus the portion of the
    // MergedGlobals variable) may be dead stripped at link time.
    if (Linkage != GlobalValue::InternalLinkage || !IsMachO) {
      GlobalAlias *GA = GlobalAlias::create(Tys[StructIdxs[idx]], AddrSpace,
                                            Linkage, Name, GEP, &M);
      GA->setVisibility(Visibility);
      GA->setDLLStorageClass(DLLStorage);
    }

    NumMerged++;
  }
  Changed = true;
  i = j;
}

return Changed;
566}

568void GlobalMerge::collectUsedGlobalVariables(Module &M, StringRef Name) {
// Extract global variables from llvm.used array
const GlobalVariable *GV = M.getGlobalVariable(Name);
if (!GV || !GV->hasInitializer()) return;

// Should be an array of 'i8*'.
const ConstantArray *InitList = cast<ConstantArray>(GV->getInitializer());

for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i)
  if (const GlobalVariable *G =
      dyn_cast<GlobalVariable>(InitList->getOperand(i)->stripPointerCasts()))
    MustKeepGlobalVariables.insert(G);
580}

582void GlobalMerge::setMustKeepGlobalVariables(Module &M) {
collectUsedGlobalVariables(M, "llvm.used");
collectUsedGlobalVariables(M, "llvm.compiler.used");

for (Function &F : M) {
  for (BasicBlock &BB : F) {
    Instruction *Pad = BB.getFirstNonPHI();
    if (!Pad->isEHPad())
      continue;

    // Keep globals used by landingpads and catchpads.
    for (const Use &U : Pad->operands()) {
      if (const GlobalVariable *GV =
              dyn_cast<GlobalVariable>(U->stripPointerCasts()))
        MustKeepGlobalVariables.insert(GV);
    }
  }
}
600}

602bool GlobalMerge::doInitialization(Module &M) {
if (!EnableGlobalMerge)
1
Assuming the condition is false→
2
←
Taking false branch→
  return false;

IsMachO = Triple(M.getTargetTriple()).isOSBinFormatMachO();

auto &DL = M.getDataLayout();
DenseMap<std::pair<unsigned, StringRef>, SmallVector<GlobalVariable *, 16>>
    Globals, ConstGlobals, BSSGlobals;
bool Changed = false;
setMustKeepGlobalVariables(M);

// Grab all non-const globals.
for (auto &GV : M.globals()) {
  // Merge is safe for "normal" internal or external globals only
  if (GV.isDeclaration() || GV.isThreadLocal() || GV.hasImplicitSection())
3
←
Assuming the condition is false→
4
←
Calling 'GlobalValue::isThreadLocal'→
7
←
Returning from 'GlobalValue::isThreadLocal'→
8
←
Calling 'GlobalVariable::hasImplicitSection'→
13
←
Returning from 'GlobalVariable::hasImplicitSection'→
14
←
Assuming the condition is false→
    continue;

  // It's not safe to merge globals that may be preempted
  if (TM && !TM->shouldAssumeDSOLocal(M, &GV))
15
←
Assuming field 'TM' is null→
    continue;

  if (!(MergeExternalGlobals && GV.hasExternalLinkage()) &&
16
←
Assuming field 'MergeExternalGlobals' is false→
24
←
Taking false branch→
      !GV.hasInternalLinkage())
17
←
Calling 'GlobalValue::hasInternalLinkage'→
23
←
Returning from 'GlobalValue::hasInternalLinkage'→
    continue;

  PointerType *PT = dyn_cast<PointerType>(GV.getType());
25
←
Assuming the object is not a 'PointerType'→
26
←
'PT' initialized to a null pointer value→
  assert(PT && "Global variable is not a pointer!")(static_cast<void> (0));

  unsigned AddressSpace = PT->getAddressSpace();
27
←
Called C++ object pointer is null
  StringRef Section = GV.getSection();

  // Ignore all 'special' globals.
  if (GV.getName().startswith("llvm.") ||
      GV.getName().startswith(".llvm."))
    continue;

  // Ignore all "required" globals:
  if (isMustKeepGlobalVariable(&GV))
    continue;

  Type *Ty = GV.getValueType();
  if (DL.getTypeAllocSize(Ty) < MaxOffset) {
    if (TM &&
        TargetLoweringObjectFile::getKindForGlobal(&GV, *TM).isBSS())
      BSSGlobals[{AddressSpace, Section}].push_back(&GV);
    else if (GV.isConstant())
      ConstGlobals[{AddressSpace, Section}].push_back(&GV);
    else
      Globals[{AddressSpace, Section}].push_back(&GV);
  }
}

for (auto &P : Globals)
  if (P.second.size() > 1)
    Changed |= doMerge(P.second, M, false, P.first.first);

for (auto &P : BSSGlobals)
  if (P.second.size() > 1)
    Changed |= doMerge(P.second, M, false, P.first.first);

if (EnableGlobalMergeOnConst)
  for (auto &P : ConstGlobals)
    if (P.second.size() > 1)
      Changed |= doMerge(P.second, M, true, P.first.first);

return Changed;
669}

671bool GlobalMerge::runOnFunction(Function &F) {
return false;
673}

675bool GlobalMerge::doFinalization(Module &M) {
MustKeepGlobalVariables.clear();
return false;
678}

680Pass *llvm::createGlobalMergePass(const TargetMachine *TM, unsigned Offset,
                                bool OnlyOptimizeForSize,
                                bool MergeExternalByDefault) {
bool MergeExternal = (EnableGlobalMergeOnExternal == cl::BOU_UNSET) ?
  MergeExternalByDefault : (EnableGlobalMergeOnExternal == cl::BOU_TRUE);
return new GlobalMerge(TM, Offset, OnlyOptimizeForSize, MergeExternal);
686}

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/GlobalValue.h

→

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//===----------------------------------------------------------------------===//

17#ifndef LLVM_IR_GLOBALVALUE_H
18#define LLVM_IR_GLOBALVALUE_H

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>

32namespace llvm {

34class Comdat;
35class ConstantRange;
36class Error;
37class GlobalObject;
38class Module;

40namespace Intrinsic {
41typedef unsigned ID;
42} // end namespace Intrinsic

44class GlobalValue : public Constant {
45public:
/// An enumeration for the kinds of linkage for global values.
enum LinkageTypes {
  ExternalLinkage = 0,///< Externally visible function
  AvailableExternallyLinkage, ///< Available for inspection, not emission.
  LinkOnceAnyLinkage, ///< Keep one copy of function when linking (inline)
  LinkOnceODRLinkage, ///< Same, but only replaced by something equivalent.
  WeakAnyLinkage,     ///< Keep one copy of named function when linking (weak)
  WeakODRLinkage,     ///< Same, but only replaced by something equivalent.
  AppendingLinkage,   ///< Special purpose, only applies to global arrays
  InternalLinkage,    ///< Rename collisions when linking (static functions).
  PrivateLinkage,     ///< Like Internal, but omit from symbol table.
  ExternalWeakLinkage,///< ExternalWeak linkage description.
  CommonLinkage       ///< Tentative definitions.
};

/// An enumeration for the kinds of visibility of global values.
enum VisibilityTypes {
  DefaultVisibility = 0,  ///< The GV is visible
  HiddenVisibility,       ///< The GV is hidden
  ProtectedVisibility     ///< The GV is protected
};

/// Storage classes of global values for PE targets.
enum DLLStorageClassTypes {
  DefaultStorageClass   = 0,
  DLLImportStorageClass = 1, ///< Function to be imported from DLL
  DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
};

75protected:
GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
            LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
    : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
      ValueType(Ty), Visibility(DefaultVisibility),
      UnnamedAddrVal(unsigned(UnnamedAddr::None)),
      DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
      HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false),
      IntID((Intrinsic::ID)0U), Parent(nullptr) {
  setLinkage(Linkage);
  setName(Name);
}

Type *ValueType;

static const unsigned GlobalValueSubClassDataBits = 16;

// All bitfields use unsigned as the underlying type so that MSVC will pack
// them.
unsigned Linkage : 4;       // The linkage of this global
unsigned Visibility : 2;    // The visibility style of this global
unsigned UnnamedAddrVal : 2; // This value's address is not significant
unsigned DllStorageClass : 2; // DLL storage class

unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                          // the desired model?

/// True if the function's name starts with "llvm.".  This corresponds to the
/// value of Function::isIntrinsic(), which may be true even if
/// Function::intrinsicID() returns Intrinsic::not_intrinsic.
unsigned HasLLVMReservedName : 1;

/// If true then there is a definition within the same linkage unit and that
/// definition cannot be runtime preempted.
unsigned IsDSOLocal : 1;

/// True if this symbol has a partition name assigned (see
/// https://lld.llvm.org/Partitions.html).
unsigned HasPartition : 1;

115private:
// Give subclasses access to what otherwise would be wasted padding.
// (16 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1) == 32.
unsigned SubClassData : GlobalValueSubClassDataBits;

friend class Constant;

void destroyConstantImpl();
Value *handleOperandChangeImpl(Value *From, Value *To);

/// Returns true if the definition of this global may be replaced by a
/// differently optimized variant of the same source level function at link
/// time.
bool mayBeDerefined() const {
  switch (getLinkage()) {
  case WeakODRLinkage:
  case LinkOnceODRLinkage:
  case AvailableExternallyLinkage:
    return true;

  case WeakAnyLinkage:
  case LinkOnceAnyLinkage:
  case CommonLinkage:
  case ExternalWeakLinkage:
  case ExternalLinkage:
  case AppendingLinkage:
  case InternalLinkage:
  case PrivateLinkage:
    return isInterposable();
  }

  llvm_unreachable("Fully covered switch above!")__builtin_unreachable();
}

149protected:
/// The intrinsic ID for this subclass (which must be a Function).
///
/// This member is defined by this class, but not used for anything.
/// Subclasses can use it to store their intrinsic ID, if they have one.
///
/// This is stored here to save space in Function on 64-bit hosts.
Intrinsic::ID IntID;

unsigned getGlobalValueSubClassData() const {
  return SubClassData;
}
void setGlobalValueSubClassData(unsigned V) {
  assert(V < (1 << GlobalValueSubClassDataBits) && "It will not fit")(static_cast<void> (0));
  SubClassData = V;
}

Module *Parent;             // The containing module.

// Used by SymbolTableListTraits.
void setParent(Module *parent) {
  Parent = parent;
}

~GlobalValue() {
  removeDeadConstantUsers();   // remove any dead constants using this.
}

177public:
enum ThreadLocalMode {
  NotThreadLocal = 0,
  GeneralDynamicTLSModel,
  LocalDynamicTLSModel,
  InitialExecTLSModel,
  LocalExecTLSModel
};

GlobalValue(const GlobalValue &) = delete;

unsigned getAddressSpace() const;

enum class UnnamedAddr {
  None,
  Local,
  Global,
};

bool hasGlobalUnnamedAddr() const {
  return getUnnamedAddr() == UnnamedAddr::Global;
}

/// Returns true if this value's address is not significant in this module.
/// This attribute is intended to be used only by the code generator and LTO
/// to allow the linker to decide whether the global needs to be in the symbol
/// table. It should probably not be used in optimizations, as the value may
/// have uses outside the module; use hasGlobalUnnamedAddr() instead.
bool hasAtLeastLocalUnnamedAddr() const {
  return getUnnamedAddr() != UnnamedAddr::None;
}

UnnamedAddr getUnnamedAddr() const {
  return UnnamedAddr(UnnamedAddrVal);
}
void setUnnamedAddr(UnnamedAddr Val) { UnnamedAddrVal = unsigned(Val); }

static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B) {
  if (A == UnnamedAddr::None || B == UnnamedAddr::None)
    return UnnamedAddr::None;
  if (A == UnnamedAddr::Local || B == UnnamedAddr::Local)
    return UnnamedAddr::Local;
  return UnnamedAddr::Global;
}

bool hasComdat() const { return getComdat() != nullptr; }
const Comdat *getComdat() const;
Comdat *getComdat() {
  return const_cast<Comdat *>(
                         static_cast<const GlobalValue *>(this)->getComdat());
}

VisibilityTypes getVisibility() const { return VisibilityTypes(Visibility); }
bool hasDefaultVisibility() const { return Visibility == DefaultVisibility; }
bool hasHiddenVisibility() const { return Visibility == HiddenVisibility; }
bool hasProtectedVisibility() const {
  return Visibility == ProtectedVisibility;
}
void setVisibility(VisibilityTypes V) {
  assert((!hasLocalLinkage() || V == DefaultVisibility) &&(static_cast<void> (0))
         "local linkage requires default visibility")(static_cast<void> (0));
  Visibility = V;
  if (isImplicitDSOLocal())
    setDSOLocal(true);
}

/// If the value is "Thread Local", its value isn't shared by the threads.
bool isThreadLocal() const { return getThreadLocalMode() != NotThreadLocal; }
5
←
Assuming the condition is false→
6
←
Returning zero, which participates in a condition later→
void setThreadLocal(bool Val) {
  setThreadLocalMode(Val ? GeneralDynamicTLSModel : NotThreadLocal);
}
void setThreadLocalMode(ThreadLocalMode Val) {
  assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal)(static_cast<void> (0));
  ThreadLocal = Val;
}
ThreadLocalMode getThreadLocalMode() const {
  return static_cast<ThreadLocalMode>(ThreadLocal);
}

DLLStorageClassTypes getDLLStorageClass() const {
  return DLLStorageClassTypes(DllStorageClass);
}
bool hasDLLImportStorageClass() const {
  return DllStorageClass == DLLImportStorageClass;
}
bool hasDLLExportStorageClass() const {
  return DllStorageClass == DLLExportStorageClass;
}
void setDLLStorageClass(DLLStorageClassTypes C) { DllStorageClass = C; }

bool hasSection() const { return !getSection().empty(); }
StringRef getSection() const;

/// Global values are always pointers.
PointerType *getType() const { return cast<PointerType>(User::getType()); }

Type *getValueType() const { return ValueType; }

bool isImplicitDSOLocal() const {
  return hasLocalLinkage() ||
         (!hasDefaultVisibility() && !hasExternalWeakLinkage());
}

void setDSOLocal(bool Local) { IsDSOLocal = Local; }

bool isDSOLocal() const {
  return IsDSOLocal;
}

bool hasPartition() const {
  return HasPartition;
}
StringRef getPartition() const;
void setPartition(StringRef Part);

static LinkageTypes getLinkOnceLinkage(bool ODR) {
  return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
}
static LinkageTypes getWeakLinkage(bool ODR) {
  return ODR ? WeakODRLinkage : WeakAnyLinkage;
}

static bool isExternalLinkage(LinkageTypes Linkage) {
  return Linkage == ExternalLinkage;
}
static bool isAvailableExternallyLinkage(LinkageTypes Linkage) {
  return Linkage == AvailableExternallyLinkage;
}
static bool isLinkOnceODRLinkage(LinkageTypes Linkage) {
  return Linkage == LinkOnceODRLinkage;
}
static bool isLinkOnceLinkage(LinkageTypes Linkage) {
  return Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage;
}
static bool isWeakAnyLinkage(LinkageTypes Linkage) {
  return Linkage == WeakAnyLinkage;
}
static bool isWeakODRLinkage(LinkageTypes Linkage) {
  return Linkage == WeakODRLinkage;
}
static bool isWeakLinkage(LinkageTypes Linkage) {
  return isWeakAnyLinkage(Linkage) || isWeakODRLinkage(Linkage);
}
static bool isAppendingLinkage(LinkageTypes Linkage) {
  return Linkage == AppendingLinkage;
}
static bool isInternalLinkage(LinkageTypes Linkage) {
  return Linkage == InternalLinkage;
19
←
Assuming 'Linkage' is equal to InternalLinkage→
20
←
Returning the value 1, which participates in a condition later→
}
static bool isPrivateLinkage(LinkageTypes Linkage) {
  return Linkage == PrivateLinkage;
}
static bool isLocalLinkage(LinkageTypes Linkage) {
  return isInternalLinkage(Linkage) || isPrivateLinkage(Linkage);
}
static bool isExternalWeakLinkage(LinkageTypes Linkage) {
  return Linkage == ExternalWeakLinkage;
}
static bool isCommonLinkage(LinkageTypes Linkage) {
  return Linkage == CommonLinkage;
}
static bool isValidDeclarationLinkage(LinkageTypes Linkage) {
  return isExternalWeakLinkage(Linkage) || isExternalLinkage(Linkage);
}

/// Whether the definition of this global may be replaced by something
/// non-equivalent at link time. For example, if a function has weak linkage
/// then the code defining it may be replaced by different code.
static bool isInterposableLinkage(LinkageTypes Linkage) {
  switch (Linkage) {
  case WeakAnyLinkage:
  case LinkOnceAnyLinkage:
  case CommonLinkage:
  case ExternalWeakLinkage:
    return true;

  case AvailableExternallyLinkage:
  case LinkOnceODRLinkage:
  case WeakODRLinkage:
  // The above three cannot be overridden but can be de-refined.

  case ExternalLinkage:
  case AppendingLinkage:
  case InternalLinkage:
  case PrivateLinkage:
    return false;
  }
  llvm_unreachable("Fully covered switch above!")__builtin_unreachable();
}

/// Whether the definition of this global may be discarded if it is not used
/// in its compilation unit.
static bool isDiscardableIfUnused(LinkageTypes Linkage) {
  return isLinkOnceLinkage(Linkage) || isLocalLinkage(Linkage) ||
         isAvailableExternallyLinkage(Linkage);
}

/// Whether the definition of this global may be replaced at link time.  NB:
/// Using this method outside of the code generators is almost always a
/// mistake: when working at the IR level use isInterposable instead as it
/// knows about ODR semantics.
static bool isWeakForLinker(LinkageTypes Linkage)  {
  return Linkage == WeakAnyLinkage || Linkage == WeakODRLinkage ||
         Linkage == LinkOnceAnyLinkage || Linkage == LinkOnceODRLinkage ||
         Linkage == CommonLinkage || Linkage == ExternalWeakLinkage;
}

/// Return true if the currently visible definition of this global (if any) is
/// exactly the definition we will see at runtime.
///
/// Non-exact linkage types inhibits most non-inlining IPO, since a
/// differently optimized variant of the same function can have different
/// observable or undefined behavior than in the variant currently visible.
/// For instance, we could have started with
///
///   void foo(int *v) {
///     int t = 5 / v[0];
///     (void) t;
///   }
///
/// and "refined" it to
///
///   void foo(int *v) { }
///
/// However, we cannot infer readnone for `foo`, since that would justify
/// DSE'ing a store to `v[0]` across a call to `foo`, which can cause
/// undefined behavior if the linker replaces the actual call destination with
/// the unoptimized `foo`.
///
/// Inlining is okay across non-exact linkage types as long as they're not
/// interposable (see \c isInterposable), since in such cases the currently
/// visible variant is *a* correct implementation of the original source
/// function; it just isn't the *only* correct implementation.
bool isDefinitionExact() const {
  return !mayBeDerefined();
}

/// Return true if this global has an exact defintion.
bool hasExactDefinition() const {
  // While this computes exactly the same thing as
  // isStrongDefinitionForLinker, the intended uses are different.  This
  // function is intended to help decide if specific inter-procedural
  // transforms are correct, while isStrongDefinitionForLinker's intended use
  // is in low level code generation.
  return !isDeclaration() && isDefinitionExact();
}

/// Return true if this global's definition can be substituted with an
/// *arbitrary* definition at link time or load time. We cannot do any IPO or
/// inlining across interposable call edges, since the callee can be
/// replaced with something arbitrary.
bool isInterposable() const;
bool canBenefitFromLocalAlias() const;

bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
bool hasAvailableExternallyLinkage() const {
  return isAvailableExternallyLinkage(getLinkage());
}
bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); }
bool hasLinkOnceODRLinkage() const {
  return isLinkOnceODRLinkage(getLinkage());
}
bool hasWeakLinkage() const { return isWeakLinkage(getLinkage()); }
bool hasWeakAnyLinkage() const { return isWeakAnyLinkage(getLinkage()); }
bool hasWeakODRLinkage() const { return isWeakODRLinkage(getLinkage()); }
bool hasAppendingLinkage() const { return isAppendingLinkage(getLinkage()); }
bool hasInternalLinkage() const { return isInternalLinkage(getLinkage()); }
18
←
Calling 'GlobalValue::isInternalLinkage'→
21
←
Returning from 'GlobalValue::isInternalLinkage'→
22
←
Returning the value 1, which participates in a condition later→
bool hasPrivateLinkage() const { return isPrivateLinkage(getLinkage()); }
bool hasLocalLinkage() const { return isLocalLinkage(getLinkage()); }
bool hasExternalWeakLinkage() const {
  return isExternalWeakLinkage(getLinkage());
}
bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
bool hasValidDeclarationLinkage() const {
  return isValidDeclarationLinkage(getLinkage());
}

void setLinkage(LinkageTypes LT) {
  if (isLocalLinkage(LT))
    Visibility = DefaultVisibility;
  Linkage = LT;
  if (isImplicitDSOLocal())
    setDSOLocal(true);
}
LinkageTypes getLinkage() const { return LinkageTypes(Linkage); }

bool isDiscardableIfUnused() const {
  return isDiscardableIfUnused(getLinkage());
}

bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }

469protected:
/// Copy all additional attributes (those not needed to create a GlobalValue)
/// from the GlobalValue Src to this one.
void copyAttributesFrom(const GlobalValue *Src);

474public:
/// If the given string begins with the GlobalValue name mangling escape
/// character '\1', drop it.
///
/// This function applies a specific mangling that is used in PGO profiles,
/// among other things. If you're trying to get a symbol name for an
/// arbitrary GlobalValue, this is not the function you're looking for; see
/// Mangler.h.
static StringRef dropLLVMManglingEscape(StringRef Name) {
  if (!Name.empty() && Name[0] == '\1')
    return Name.substr(1);
  return Name;
}

/// Return the modified name for a global value suitable to be
/// used as the key for a global lookup (e.g. profile or ThinLTO).
/// The value's original name is \c Name and has linkage of type
/// \c Linkage. The value is defined in module \c FileName.
static std::string getGlobalIdentifier(StringRef Name,
                                       GlobalValue::LinkageTypes Linkage,
                                       StringRef FileName);

/// Return the modified name for this global value suitable to be
/// used as the key for a global lookup (e.g. profile or ThinLTO).
std::string getGlobalIdentifier() const;

/// Declare a type to represent a global unique identifier for a global value.
/// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
/// unique way to identify a symbol.
using GUID = uint64_t;

/// Return a 64-bit global unique ID constructed from global value name
/// (i.e. returned by getGlobalIdentifier()).
static GUID getGUID(StringRef GlobalName) { return MD5Hash(GlobalName); }

/// Return a 64-bit global unique ID constructed from global value name
/// (i.e. returned by getGlobalIdentifier()).
GUID getGUID() const { return getGUID(getGlobalIdentifier()); }

/// @name Materialization
/// Materialization is used to construct functions only as they're needed.
/// This
/// is useful to reduce memory usage in LLVM or parsing work done by the
/// BitcodeReader to load the Module.
/// @{

/// If this function's Module is being lazily streamed in functions from disk
/// or some other source, this method can be used to check to see if the
/// function has been read in yet or not.
bool isMaterializable() const;

/// Make sure this GlobalValue is fully read.
Error materialize();

528/// @}

/// Return true if the primary definition of this global value is outside of
/// the current translation unit.
bool isDeclaration() const;

bool isDeclarationForLinker() const {
  if (hasAvailableExternallyLinkage())
    return true;

  return isDeclaration();
}

/// Returns true if this global's definition will be the one chosen by the
/// linker.
///
/// NB! Ideally this should not be used at the IR level at all.  If you're
/// interested in optimization constraints implied by the linker's ability to
/// choose an implementation, prefer using \c hasExactDefinition.
bool isStrongDefinitionForLinker() const {
  return !(isDeclarationForLinker() || isWeakForLinker());
}

const GlobalObject *getBaseObject() const;
GlobalObject *getBaseObject() {
  return const_cast<GlobalObject *>(
                     static_cast<const GlobalValue *>(this)->getBaseObject());
}

/// Returns whether this is a reference to an absolute symbol.
bool isAbsoluteSymbolRef() const;

/// If this is an absolute symbol reference, returns the range of the symbol,
/// otherwise returns None.
Optional<ConstantRange> getAbsoluteSymbolRange() const;

/// This method unlinks 'this' from the containing module, but does not delete
/// it.
void removeFromParent();

/// This method unlinks 'this' from the containing module and deletes it.
void eraseFromParent();

/// Get the module that this global value is contained inside of...
Module *getParent() { return Parent; }
const Module *getParent() const { return Parent; }

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V) {
  return V->getValueID() == Value::FunctionVal ||
         V->getValueID() == Value::GlobalVariableVal ||
         V->getValueID() == Value::GlobalAliasVal ||
         V->getValueID() == Value::GlobalIFuncVal;
}

/// True if GV can be left out of the object symbol table. This is the case
/// for linkonce_odr values whose address is not significant. While legal, it
/// is not normally profitable to omit them from the .o symbol table. Using
/// this analysis makes sense when the information can be passed down to the
/// linker or we are in LTO.
bool canBeOmittedFromSymbolTable() const;
589};

591} // end namespace llvm

593#endif // LLVM_IR_GLOBALVALUE_H

←

/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include/llvm/IR/GlobalVariable.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//===----------------------------------------------------------------------===//

19#ifndef LLVM_IR_GLOBALVARIABLE_H
20#define LLVM_IR_GLOBALVARIABLE_H

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>

31namespace llvm {

33class Constant;
34class Module;

36template <typename ValueSubClass> class SymbolTableListTraits;
37class DIGlobalVariable;
38class DIGlobalVariableExpression;

40class GlobalVariable : public GlobalObject, public ilist_node<GlobalVariable> {
friend class SymbolTableListTraits<GlobalVariable>;

AttributeSet Attrs;
bool isConstantGlobal : 1;                   // Is this a global constant?
bool isExternallyInitializedConstant : 1;    // Is this a global whose value
                                             // can change from its initial
                                             // value before global
                                             // initializers are run?

50public:
/// GlobalVariable ctor - If a parent module is specified, the global is
/// automatically inserted into the end of the specified modules global list.
GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
               Constant *Initializer = nullptr, const Twine &Name = "",
               ThreadLocalMode = NotThreadLocal, unsigned AddressSpace = 0,
               bool isExternallyInitialized = false);
/// GlobalVariable ctor - This creates a global and inserts it before the
/// specified other global.
GlobalVariable(Module &M, Type *Ty, bool isConstant, LinkageTypes Linkage,
               Constant *Initializer, const Twine &Name = "",
               GlobalVariable *InsertBefore = nullptr,
               ThreadLocalMode = NotThreadLocal,
               Optional<unsigned> AddressSpace = None,
               bool isExternallyInitialized = false);
GlobalVariable(const GlobalVariable &) = delete;
GlobalVariable &operator=(const GlobalVariable &) = delete;

~GlobalVariable() {
  dropAllReferences();
}

// allocate space for exactly one operand
void *operator new(size_t s) {
  return User::operator new(s, 1);
}

// delete space for exactly one operand as created in the corresponding new operator
void operator delete(void *ptr){
  assert(ptr != nullptr && "must not be nullptr")(static_cast<void> (0));
  User *Obj = static_cast<User *>(ptr);
  // Number of operands can be set to 0 after construction and initialization. Make sure
  // that number of operands is reset to 1, as this is needed in User::operator delete
  Obj->setGlobalVariableNumOperands(1);
  User::operator delete(Obj);
}

/// Provide fast operand accessors
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;

/// Definitions have initializers, declarations don't.
///
inline bool hasInitializer() const { return !isDeclaration(); }

/// hasDefinitiveInitializer - Whether the global variable has an initializer,
/// and any other instances of the global (this can happen due to weak
/// linkage) are guaranteed to have the same initializer.
///
/// Note that if you want to transform a global, you must use
/// hasUniqueInitializer() instead, because of the *_odr linkage type.
///
/// Example:
///
/// @a = global SomeType* null - Initializer is both definitive and unique.
///
/// @b = global weak SomeType* null - Initializer is neither definitive nor
/// unique.
///
/// @c = global weak_odr SomeType* null - Initializer is definitive, but not
/// unique.
inline bool hasDefinitiveInitializer() const {
  return hasInitializer() &&
    // The initializer of a global variable may change to something arbitrary
    // at link time.
    !isInterposable() &&
    // The initializer of a global variable with the externally_initialized
    // marker may change at runtime before C++ initializers are evaluated.
    !isExternallyInitialized();
}

/// hasUniqueInitializer - Whether the global variable has an initializer, and
/// any changes made to the initializer will turn up in the final executable.
inline bool hasUniqueInitializer() const {
  return
      // We need to be sure this is the definition that will actually be used
      isStrongDefinitionForLinker() &&
      // It is not safe to modify initializers of global variables with the
      // external_initializer marker since the value may be changed at runtime
      // before C++ initializers are evaluated.
      !isExternallyInitialized();
}

/// getInitializer - Return the initializer for this global variable.  It is
/// illegal to call this method if the global is external, because we cannot
/// tell what the value is initialized to!
///
inline const Constant *getInitializer() const {
  assert(hasInitializer() && "GV doesn't have initializer!")(static_cast<void> (0));
  return static_cast<Constant*>(Op<0>().get());
}
inline Constant *getInitializer() {
  assert(hasInitializer() && "GV doesn't have initializer!")(static_cast<void> (0));
  return static_cast<Constant*>(Op<0>().get());
}
/// setInitializer - Sets the initializer for this global variable, removing
/// any existing initializer if InitVal==NULL.  If this GV has type T*, the
/// initializer must have type T.
void setInitializer(Constant *InitVal);

/// If the value is a global constant, its value is immutable throughout the
/// runtime execution of the program.  Assigning a value into the constant
/// leads to undefined behavior.
///
bool isConstant() const { return isConstantGlobal; }
void setConstant(bool Val) { isConstantGlobal = Val; }

bool isExternallyInitialized() const {
  return isExternallyInitializedConstant;
}
void setExternallyInitialized(bool Val) {
  isExternallyInitializedConstant = Val;
}

/// copyAttributesFrom - copy all additional attributes (those not needed to
/// create a GlobalVariable) from the GlobalVariable Src to this one.
void copyAttributesFrom(const GlobalVariable *Src);

/// removeFromParent - This method unlinks 'this' from the containing module,
/// but does not delete it.
///
void removeFromParent();

/// eraseFromParent - This method unlinks 'this' from the containing module
/// and deletes it.
///
void eraseFromParent();

/// Drop all references in preparation to destroy the GlobalVariable. This
/// drops not only the reference to the initializer but also to any metadata.
void dropAllReferences();

/// Attach a DIGlobalVariableExpression.
void addDebugInfo(DIGlobalVariableExpression *GV);

/// Fill the vector with all debug info attachements.
void getDebugInfo(SmallVectorImpl<DIGlobalVariableExpression *> &GVs) const;

/// Add attribute to this global.
void addAttribute(Attribute::AttrKind Kind) {
  Attrs = Attrs.addAttribute(getContext(), Kind);
}

/// Add attribute to this global.
void addAttribute(StringRef Kind, StringRef Val = StringRef()) {
  Attrs = Attrs.addAttribute(getContext(), Kind, Val);
}

/// Return true if the attribute exists.
bool hasAttribute(Attribute::AttrKind Kind) const {
  return Attrs.hasAttribute(Kind);
}

/// Return true if the attribute exists.
bool hasAttribute(StringRef Kind) const {
  return Attrs.hasAttribute(Kind);
}

/// Return true if any attributes exist.
bool hasAttributes() const {
  return Attrs.hasAttributes();
}

/// Return the attribute object.
Attribute getAttribute(Attribute::AttrKind Kind) const {
  return Attrs.getAttribute(Kind);
}

/// Return the attribute object.
Attribute getAttribute(StringRef Kind) const {
  return Attrs.getAttribute(Kind);
}

/// Return the attribute set for this global
AttributeSet getAttributes() const {
  return Attrs;
}

/// Return attribute set as list with index.
/// FIXME: This may not be required once ValueEnumerators
/// in bitcode-writer can enumerate attribute-set.
AttributeList getAttributesAsList(unsigned index) const {
  if (!hasAttributes())
    return AttributeList();
  std::pair<unsigned, AttributeSet> AS[1] = {{index, Attrs}};
  return AttributeList::get(getContext(), AS);
}

/// Set attribute list for this global
void setAttributes(AttributeSet A) {
  Attrs = A;
}

/// Check if section name is present
bool hasImplicitSection() const {
  return getAttributes().hasAttribute("bss-section") ||
9
←
Assuming the condition is false→
12
←
Returning value, which participates in a condition later→
         getAttributes().hasAttribute("data-section") ||
10
←
Assuming the condition is false→
         getAttributes().hasAttribute("relro-section") ||
11
←
Assuming the condition is false→
         getAttributes().hasAttribute("rodata-section");
}

// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V) {
  return V->getValueID() == Value::GlobalVariableVal;
}
254};

256template <>
257struct OperandTraits<GlobalVariable> :
public OptionalOperandTraits<GlobalVariable> {
259};

261DEFINE_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 { (static_cast<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) { (static_cast<
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); }

263} // end namespace llvm

265#endif // LLVM_IR_GLOBALVARIABLE_H