This is an archive of the discontinued LLVM Phabricator instance.

Differential D14007

Load elimination based on new 'InvarantInfo' property for global variables.
Needs ReviewPublic

Authored by lvoufo on Oct 22 2015, 9:25 PM.

Details

Reviewers
• dberlin
nlewycky
Summary

Extend D14003, D14004, D14005 and D14006 with handling of global variables:
GlobalOpt scans static constructors to mark allocated 'writeonce' memory prior to evaluating the constructors.

This patch also includes new test cases, which are essentially adapted from the test case in D14006 for "fully global" and "partially global" test cases.

This patch is a break-down of (corrected) D13606.

Diff Detail

Event Timeline

lvoufo updated this revision to Diff 38206.Oct 22 2015, 9:25 PM
lvoufo retitled this revision from to Load elimination based on new 'InvarantInfo' property for global variables..
lvoufo updated this object.
lvoufo added reviewers: • dberlin, reames, nlewycky.
lvoufo added a subscriber: llvm-commits.
lvoufo mentioned this in D13606: [Introduction] Redundant load reduction with invariant intrinsics.Oct 22 2015, 9:35 PM
lvoufo added a parent revision: D14006: Add a test case for --gvn and --instcombine extended with load elimination based on new 'InvarantInfo' property..
lvoufo mentioned this in D13619: [Extension] Optimizing const member objects..Oct 23 2015, 3:30 PM
nlewycky edited edge metadata.Nov 8 2015, 4:06 PM

I've been thinking about this patch and I don't understand what change you're trying to make at a high level.

Here's a hypothesis about how to support invariant intrinsics in globalopt: ignore them entirely. GlobalOpt evaluates each instruction in turn, following from caller into the body of a callee. If it can't see any instruction at any time, it aborts the whole chain of evaluation. The point of 'invariant' intrinsics is to mark that an *opaque* callee will not mutate memory, but globalopt never takes any action when given an opaque callee. Therefore, there is nothing to support here, we just need to silently ignore the invariant intrinsics. Does that sound right?

lib/Transforms/IPO/GlobalOpt.cpp
2704–2705

CallSite CS(CurInst);
if (!CS) continue;

reames resigned from this revision.Apr 18 2016, 4:56 PM
reames removed a reviewer: reames.

Revision Contents

PathSize
lib/
Transforms/
IPO/
75 lines
test/
Transforms/
LoadElim/
341 lines
327 lines

Diff 38206

lib/Transforms/IPO/GlobalOpt.cpp

Show First 20 Lines • Show All 2,160 Lines • ▼ Show 20 Lines
namespace { namespace {
/// Evaluator - This class evaluates LLVM IR, producing the Constant /// Evaluator - This class evaluates LLVM IR, producing the Constant
/// representing each SSA instruction. Changes to global variables are stored /// representing each SSA instruction. Changes to global variables are stored
/// in a mapping that can be iterated over after the evaluation is complete. /// in a mapping that can be iterated over after the evaluation is complete.
/// Once an evaluation call fails, the evaluation object should not be reused. /// Once an evaluation call fails, the evaluation object should not be reused.
class Evaluator { class Evaluator {
public: public:
Evaluator(const DataLayout &DL, const TargetLibraryInfo *TLI) Evaluator(const DataLayout &DL, const TargetLibraryInfo *TLI,
: DL(DL), TLI(TLI) { InvariantInfo &InvInfo)
: DL(DL), TLI(TLI), InvInfo(InvInfo) {
ValueStack.emplace_back(); ValueStack.emplace_back();
} }
~Evaluator() { ~Evaluator() {
for (auto &Tmp : AllocaTmps) for (auto &Tmp : AllocaTmps)
// If there are still users of the alloca, the program is doing something // If there are still users of the alloca, the program is doing something
// silly, e.g. storing the address of the alloca somewhere and using it // silly, e.g. storing the address of the alloca somewhere and using it
// later. Since this is undefined, we'll just make it be null. // later. Since this is undefined, we'll just make it be null.
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesprivate:
SmallPtrSet<GlobalVariable*, 8> Invariants; SmallPtrSet<GlobalVariable*, 8> Invariants;
/// SimpleConstants - These are constants we have checked and know to be /// SimpleConstants - These are constants we have checked and know to be
/// simple enough to live in a static initializer of a global. /// simple enough to live in a static initializer of a global.
SmallPtrSet<Constant*, 8> SimpleConstants; SmallPtrSet<Constant*, 8> SimpleConstants;
const DataLayout &DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
InvariantInfo &InvInfo;
}; };
} // anonymous namespace } // anonymous namespace
/// ComputeLoadResult - Return the value that would be computed by a load from /// ComputeLoadResult - Return the value that would be computed by a load from
/// P after the stores reflected by 'memory' have been performed. If we can't /// P after the stores reflected by 'memory' have been performed. If we can't
/// decide, return null. /// decide, return null.
Constant *Evaluator::ComputeLoadResult(Constant *P) { Constant *Evaluator::ComputeLoadResult(Constant *P) {
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Lines if (StoreInst *SI = dyn_cast<StoreInst>(CurInst)) {
Value *PtrArg = getVal(II->getArgOperand(1)); Value *PtrArg = getVal(II->getArgOperand(1));
Value *Ptr = PtrArg->stripPointerCasts(); Value *Ptr = PtrArg->stripPointerCasts();
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) { if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Ptr)) {
Type *ElemTy = cast<PointerType>(GV->getType())->getElementType(); Type *ElemTy = cast<PointerType>(GV->getType())->getElementType();
if (!Size->isAllOnesValue() && if (!Size->isAllOnesValue() &&
Size->getValue().getLimitedValue() >= Size->getValue().getLimitedValue() >=
DL.getTypeStoreSize(ElemTy)) { DL.getTypeStoreSize(ElemTy)) {
Invariants.insert(GV); Invariants.insert(GV);
DEBUG(dbgs() << "Found a global var that is an invariant: " << *GV DEBUG(dbgs()
<< "Found a global var that is an invariant (constant): "
<< *GV << "\n");
} else if (InvInfo.GetStartInstruction(GV)) {
DEBUG(dbgs() << "Found a global var that is writeonce: " << *GV
<< "\n"); << "\n");
} else { } else {
DEBUG(dbgs() << "Found a global var, but can not treat it as an " DEBUG(dbgs() << "Found a global var, but can not treat it as an "
"invariant.\n"); "invariant.\n");
} }
} }
// Continue even if we do nothing. // Continue even if we do nothing.
++CurInst; ++CurInst;
continue; continue;
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines for (CurInst = NextBB->begin();
(PN = dyn_cast<PHINode>(CurInst)); ++CurInst) (PN = dyn_cast<PHINode>(CurInst)); ++CurInst)
setVal(PN, getVal(PN->getIncomingValueForBlock(CurBB))); setVal(PN, getVal(PN->getIncomingValueForBlock(CurBB)));
// Advance to the next block. // Advance to the next block.
CurBB = NextBB; CurBB = NextBB;
} }
} }
static void processInvariantIntrinsics(InvariantInfo &InvInfo, BasicBlock *BB);
static void processInvariantIntrinsics(InvariantInfo &InvInfo, Function *F) {
for (Function::iterator BB = F->begin(), BE = F->end(); BB != BE; ++BB)
processInvariantIntrinsics(InvInfo, BB);
}
void processInvariantIntrinsics(InvariantInfo &InvInfo, BasicBlock *BB) {
// Scan the block to process invariant intrinsics, tracing whatever
// call chain that can be traced.
BasicBlock::iterator CurInst = BB->begin();
while (CurInst) {
if (isa<CallInst>(CurInst) || isa<InvokeInst>(CurInst)) {
CallSite CS(CurInst);
nlewyckyUnsubmitted
Not Done
ReplyInline Actions

CallSite CS(CurInst);
if (!CS) continue;

nlewycky: CallSite CS(CurInst); if (!CS) continue;
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(CurInst))
processInvariantIntrinsic(II, InvInfo);
// Ignore debug info, inline asm, intrinsics, ...
if (isa<DbgInfoIntrinsic>(CS.getInstruction()) ||
isa<InlineAsm>(CS.getCalledValue()) ||
dyn_cast<IntrinsicInst>(CS.getInstruction())) {
++CurInst;
continue;
}
Function *Callee = CS.getCalledFunction();
if (Callee && !Callee->isDeclaration())
processInvariantIntrinsics(InvInfo, Callee);
if (InvokeInst *II = dyn_cast<InvokeInst>(CurInst)) {
for (unsigned i = 0; i < II->getNumSuccessors(); ++i)
processInvariantIntrinsics(InvInfo, II->getSuccessor(i));
break;
}
} else if (TerminatorInst *TI = dyn_cast<TerminatorInst>(CurInst)) {
for (unsigned i = 0; i < TI->getNumSuccessors(); ++i)
processInvariantIntrinsics(InvInfo, TI->getSuccessor(i));
break;
}
++CurInst;
}
}
/// EvaluateStaticConstructor - Evaluate static constructors in the function, if /// EvaluateStaticConstructor - Evaluate static constructors in the function, if
/// we can. Return true if we can, false otherwise. /// we can. Return true if we can, false otherwise.
static bool EvaluateStaticConstructor(Function *F, const DataLayout &DL, static bool EvaluateStaticConstructor(Function *F, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI,
InvariantInfo &InvInfo) {
// Scan the Function's blocks to process invariant (start) intrinsics.
// This will mark writeonce global variables as written, and is necessary to
// do here because EvaluateBlock(), via EvaluateFunction() (below), could
// exit before processing the invariant intrinsic call, e.g., if a call to
// a function declaration that we cannot constant fold occurs before the
// intrinsic call.
processInvariantIntrinsics(InvInfo, F);
// Call the function. // Call the function.
Evaluator Eval(DL, TLI); Evaluator Eval(DL, TLI, InvInfo);
Constant *RetValDummy; Constant *RetValDummy;
bool EvalSuccess = Eval.EvaluateFunction(F, RetValDummy, bool EvalSuccess = Eval.EvaluateFunction(F, RetValDummy,
SmallVector<Constant*, 0>()); SmallVector<Constant*, 0>());
if (EvalSuccess) { if (EvalSuccess) {
++NumCtorsEvaluated; ++NumCtorsEvaluated;
// We succeeded at evaluation: commit the result. // We succeeded at evaluation: commit the result.
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Linesbool GlobalOpt::OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn) {
return Changed; return Changed;
} }
bool GlobalOpt::runOnModule(Module &M) { bool GlobalOpt::runOnModule(Module &M) {
bool Changed = false; bool Changed = false;
auto &DL = M.getDataLayout(); auto &DL = M.getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
auto &InvInfo = M.getInvariantInfo();
bool LocalChange = true; bool LocalChange = true;
while (LocalChange) { while (LocalChange) {
LocalChange = false; LocalChange = false;
NotDiscardableComdats.clear(); NotDiscardableComdats.clear();
for (const GlobalVariable &GV : M.globals()) for (const GlobalVariable &GV : M.globals())
if (const Comdat *C = GV.getComdat()) if (const Comdat *C = GV.getComdat())
if (!GV.isDiscardableIfUnused() || !GV.use_empty()) if (!GV.isDiscardableIfUnused() || !GV.use_empty())
NotDiscardableComdats.insert(C); NotDiscardableComdats.insert(C);
for (Function &F : M) for (Function &F : M)
if (const Comdat *C = F.getComdat()) if (const Comdat *C = F.getComdat())
if (!F.isDefTriviallyDead()) if (!F.isDefTriviallyDead())
NotDiscardableComdats.insert(C); NotDiscardableComdats.insert(C);
for (GlobalAlias &GA : M.aliases()) for (GlobalAlias &GA : M.aliases())
if (const Comdat *C = GA.getComdat()) if (const Comdat *C = GA.getComdat())
if (!GA.isDiscardableIfUnused() || !GA.use_empty()) if (!GA.isDiscardableIfUnused() || !GA.use_empty())
NotDiscardableComdats.insert(C); NotDiscardableComdats.insert(C);
// Delete functions that are trivially dead, ccc -> fastcc // Delete functions that are trivially dead, ccc -> fastcc
LocalChange |= OptimizeFunctions(M); LocalChange |= OptimizeFunctions(M);
// Optimize global_ctors list. // Optimize global_ctors list.
LocalChange |= optimizeGlobalCtorsList(M, [&](Function *F) { LocalChange |= optimizeGlobalCtorsList(M, [&](Function *F) {
return EvaluateStaticConstructor(F, DL, TLI); return EvaluateStaticConstructor(F, DL, TLI, InvInfo);
}); });
// Optimize non-address-taken globals. // Optimize non-address-taken globals.
LocalChange |= OptimizeGlobalVars(M); LocalChange |= OptimizeGlobalVars(M);
// Resolve aliases, when possible. // Resolve aliases, when possible.
LocalChange |= OptimizeGlobalAliases(M); LocalChange |= OptimizeGlobalAliases(M);
Show All 15 Lines

test/Transforms/LoadElim/global-local-vars.ll

  • This file was added.
;; NOTE: The CHECKLOAD-* prefixes indicate occurences of redundant loads in the output.
;; The CHECK-* prefixes indicate removal of redundant loads in the output. (ALL == 4-5A1-5A2-5B)
;; * When the available load scan limit is 6, -instcombine does not
;; eliminate some redundant loads that either it would eliminate
;; with a load scan limit of 8, or -gvn would eliminate.
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-5B --check-prefix=CHECKLOAD-4-5A
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
;; * Adding '-inline -early-cse' enables a few more load eliminations,
;; but does not merge the same loads into the store as per local vars.
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -inline -early-cse -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -inline -early-cse -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -inline -early-cse -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -inline -early-cse -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-ALL
;; * When the load scan limit is 8,
;; '-functionattrs -tailcallelim -instcombine' may be as good as '-gvn'.
;; But the same can't be said when the limit is 6.
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -functionattrs -tailcallelim -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -functionattrs -tailcallelim -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-4-5A-5B1 --check-prefix=CHECKLOAD-5B2
%struct.A = type { i32 }
@_ZL1i = internal global %struct.A zeroinitializer
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_global_local, i8* null }]
;; Example 2: Unnecessary stores and loads.
;; void ex2() {
;; const Type i(one());
;; const Type j = i; // Note: i == j, &i != &j ==> No store.
;; bar(i); // First load.
;; foo(&i); // Does not change i, nor j.
;; bar(j); // No load; Reuse i location.
;; }
define void @_Z3ex2v() {
; CHECK: @_Z3ex2v(
entry:
%j = alloca %struct.A
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%0 = bitcast %struct.A* %j to i8*
call void @llvm.lifetime.start(i64 4, i8* %0)
%1 = bitcast %struct.A* %j to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%2 = bitcast %struct.A* %j to i8*
%3 = call {}* @llvm.invariant.start(i64 4, i8* %2)
; CHECK-NOT: call {{.*}}@llvm.invariant.start(i64 {{[0-9]+}}, i8*
%4 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%5 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %5)
call void @_Z3fooPK1A(%struct.A* @_ZL1i)
%6 = bitcast %struct.A* %agg.tmp1 to i8*
%7 = bitcast %struct.A* %j to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %6, i8* %7, i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%8 = load i32, i32* %coerce.dive2
; CHECK-NOT: load i32, i32*
call void @_Z3bar1A(i32 %8)
call void @llvm.invariant.end({}* %3, i64 4, i8* %2)
; CHECK-NOT: call {{.*}}@llvm.invariant.end({{.*}}, i64 {{[0-9]+}}, i8*
%9 = bitcast %struct.A* %j to i8*
call void @llvm.lifetime.end(i64 4, i8* %9)
ret void
}
;; Example 3: Necessary stores and loads.
;; void ex3() {
;; const Type i(1);
;; Type k = i; // Note: i == k, &i != &k ==> Keep store.
;; bar(i); // First load.
;; foo(&k); // Does not change i; May change k.
;; bar(k); // Keep load.
;; }
define void @_Z3ex3v() {
; CHECK: @_Z3ex3v(
entry:
%k = alloca %struct.A
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%0 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.start(i64 4, i8* %0)
%1 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%2 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%3 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
call void @_Z3fooPK1A(%struct.A* %k)
%4 = bitcast %struct.A* %agg.tmp1 to i8*
%5 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %5, i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%6 = load i32, i32* %coerce.dive2
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %6)
%7 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.end(i64 4, i8* %7)
ret void
}
;; Example 4: Smart stores and loads.
;; void ex4() {
;; const Type i(one());
;; Type k = i; // Note: i == k, &i != &k ==> May keep store.
;; bar(i); // First load.
;; foo(&i); // Does not change i, nor k.
;; bar(k); // No load; Reuse i location.
;; foo(&k); // Does not change i; May change k.
;; bar(k); // Keep load.
;; }
define void @_Z3ex4v() {
; CHECK: @_Z3ex4v(
entry:
%k = alloca %struct.A
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%0 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.start(i64 4, i8* %0)
%1 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%2 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%3 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
call void @_Z3fooPK1A(%struct.A* @_ZL1i)
%4 = bitcast %struct.A* %agg.tmp1 to i8*
%5 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %5, i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%6 = load i32, i32* %coerce.dive2
; CHECKLOAD-4-5A1: load i32, i32*
; CHECKLOAD-4-5A: load i32, i32*
; CHECK-4-5A1-5B-NOT: load i32, i32*
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %6)
call void @_Z3fooPK1A(%struct.A* %k)
%7 = bitcast %struct.A* %agg.tmp3 to i8*
%8 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %7, i8* %8, i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%9 = load i32, i32* %coerce.dive4
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %9)
%10 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.end(i64 4, i8* %10)
ret void
}
;; Example 5: Duplicate and smart loads (and stores).
;; void ex5a() {
;; const Type i(one());
;; Type k = i; // Note: i == k, &i != &k ==> May keep store.
;; bar(i); // First load.
;; bar(k); // No load; Reuse i location.
;; foo2(&k, &i); // Does not change i; May change k.
;; bar(i); // No load.
;; bar(k); // Keep load.
;; }
define void @_Z4ex5av() {
; CHECK: @_Z4ex5av(
entry:
%k = alloca %struct.A
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%agg.tmp5 = alloca %struct.A
%0 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.start(i64 4, i8* %0)
%1 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%2 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%3 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
%4 = bitcast %struct.A* %agg.tmp1 to i8*
%5 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* %5, i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%6 = load i32, i32* %coerce.dive2
; CHECKLOAD-4-5A1: load i32, i32*
; CHECKLOAD-4-5A: load i32, i32*
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %6)
call void @_Z4foo2PK1AS1_(%struct.A* %k, %struct.A* @_ZL1i)
%7 = bitcast %struct.A* %agg.tmp3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %7, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%8 = load i32, i32* %coerce.dive4
; CHECKLOAD-4-5A: load i32, i32*
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %8)
%9 = bitcast %struct.A* %agg.tmp5 to i8*
%10 = bitcast %struct.A* %k to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %9, i8* %10, i64 4, i32 4, i1 false)
%coerce.dive6 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp5, i32 0, i32 0
%11 = load i32, i32* %coerce.dive6
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %11)
%12 = bitcast %struct.A* %k to i8*
call void @llvm.lifetime.end(i64 4, i8* %12)
ret void
}
;; Example 5: Duplicate and smart loads (and stores).
;; void ex5b() {
;; const Type i(one());
;; const Type j = i; // Note: i == j, &i != &j ==> No store.
;; bar(i); // First load.
;; bar(j); // No load; Reuse i location.
;; foo2(&j, &i); // Does not change i, nor j.
;; bar(i); // No load.
;; bar(j); // No load; Reuse i location.
;; }
define void @_Z4ex5bv() {
; CHECK: @_Z4ex5bv(
entry:
%j = alloca %struct.A
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%agg.tmp5 = alloca %struct.A
%0 = bitcast %struct.A* %j to i8*
call void @llvm.lifetime.start(i64 4, i8* %0)
%1 = bitcast %struct.A* %j to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%2 = bitcast %struct.A* %j to i8*
; CHECK-4-5A1-5B: load i32, i32*
; CHECK-5A2-5B: load i32, i32*
; CHECK-ALL: load i32, i32*
%3 = call {}* @llvm.invariant.start(i64 4, i8* %2)
; CHECK: call {{.*}}@llvm.invariant.start(i64 {{[0-9]+}}, i8*
%4 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%5 = load i32, i32* %coerce.dive
; CHECK-5B: load i32, i32*
call void @_Z3bar1A(i32 %5)
%6 = bitcast %struct.A* %agg.tmp1 to i8*
%7 = bitcast %struct.A* %j to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %6, i8* %7, i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%8 = load i32, i32* %coerce.dive2
; CHECK-NOT: load i32, i32*
call void @_Z3bar1A(i32 %8)
call void @_Z4foo2PK1AS1_(%struct.A* %j, %struct.A* @_ZL1i)
%9 = bitcast %struct.A* %agg.tmp3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %9, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%10 = load i32, i32* %coerce.dive4
; CHECK-4-5A1-5B-NOT: load i32, i32*
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %10)
%11 = bitcast %struct.A* %agg.tmp5 to i8*
%12 = bitcast %struct.A* %j to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %11, i8* %12, i64 4, i32 4, i1 false)
%coerce.dive6 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp5, i32 0, i32 0
%13 = load i32, i32* %coerce.dive6
; CHECKLOAD-5B2: load i32, i32*
; CHECK-4-5A1-5B-NOT: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %13)
call void @llvm.invariant.end({}* %3, i64 4, i8* %2)
; CHECK: call {{.*}}@llvm.invariant.end({{.*}}, i64 {{[0-9]+}}, i8*
%14 = bitcast %struct.A* %j to i8*
call void @llvm.lifetime.end(i64 4, i8* %14)
ret void
}
define internal void @__cxx_global_var_init() {
entry:
%call = call i32 @_Z3onev()
call void @_ZN1AC1Ei(%struct.A* @_ZL1i, i32 %call)
; CHECKINL: store i32 {{.*}}, i32*
%0 = call {}* @llvm.invariant.start(i64 4, i8* bitcast (%struct.A* @_ZL1i to i8*))
; CHECK: call {{.*}}@llvm.invariant.start(i64 {{[0-9]+}}, i8*
ret void
}
declare i32 @_Z3onev()
declare void @_Z3bar1A(i32)
declare void @_Z3fooPK1A(%struct.A*)
declare void @_Z4foo2PK1AS1_(%struct.A*, %struct.A*)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1)
declare {}* @llvm.invariant.start(i64, i8* nocapture)
declare void @llvm.invariant.end({}*, i64, i8* nocapture)
declare void @llvm.lifetime.start(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture)
define internal void @_GLOBAL__sub_I_global_local() {
entry:
call void @__cxx_global_var_init()
ret void
}
define linkonce_odr void @_ZN1AC1Ei(%struct.A* %this, i32 %a) {
entry:
%this.addr = alloca %struct.A*
%a.addr = alloca i32
store %struct.A* %this, %struct.A** %this.addr
store i32 %a, i32* %a.addr
%this1 = load %struct.A*, %struct.A** %this.addr
%0 = load i32, i32* %a.addr
call void @_ZN1AC2Ei(%struct.A* %this1, i32 %0)
ret void
}
define linkonce_odr void @_ZN1AC2Ei(%struct.A* %this, i32 %a) {
entry:
%this.addr = alloca %struct.A*
%a.addr = alloca i32
store %struct.A* %this, %struct.A** %this.addr
store i32 %a, i32* %a.addr
%this1 = load %struct.A*, %struct.A** %this.addr
%a2 = getelementptr inbounds %struct.A, %struct.A* %this1, i32 0, i32 0
%0 = load i32, i32* %a.addr
store i32 %0, i32* %a2
ret void
}

test/Transforms/LoadElim/global-vars.ll

  • This file was added.
;; NOTE: The CHECKLOAD-* prefixes indicate occurences of redundant loads in the output,
;; expected when the loads are not from global variables.
;; The CHECK-* prefixes indicate removal of redundant loads in the output,
;; expected when the loads are not from global variables.
;; (ALL == 4-5A1-5A2-5B)
;; * When the available load scan limit is 6, -instcombine does not
;; eliminate some redundant loads that either it would eliminate
;; with a load scan limit of 8, or -gvn would eliminate.
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
;; * Adding '-inline -early-cse' enables a few more load eliminations,
;; but does not merge the same loads into the store as per local vars.
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -inline -early-cse -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -inline -early-cse -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -inline -early-cse -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-5A2-5B --check-prefix=CHECKLOAD-4-5A1
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -inline -early-cse -gvn -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKINL --check-prefix=CHECK-ALL
;; * When the load scan limit is 8,
;; '-functionattrs -tailcallelim -instcombine' may be as good as '-gvn'.
;; But the same can't be said when the limit is 6.
; RUN: opt < %s -globalopt -available-load-scan-limit=8 -instcombine -functionattrs -tailcallelim -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ALL
; RUN: opt < %s -globalopt -available-load-scan-limit=6 -instcombine -functionattrs -tailcallelim -instcombine -S | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-4-5A-5B1 --check-prefix=CHECKLOAD-5B2
%struct.A = type { i32 }
@_ZL1i = internal global %struct.A zeroinitializer
@k = global %struct.A zeroinitializer
@_ZL1j = internal global %struct.A zeroinitializer
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @_GLOBAL__sub_I_global, i8* null }]
;; Example 1: Duplicate loads.
;; void ex1() {
;; const Type i(one());
;; bar(i); // First load.
;; foo(&i); // Does not change i.
;; bar(i); // No load.
;; }
define void @_Z3ex1v() {
; CHECK: @_Z3ex1v(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %1)
call void @_Z3fooPK1A(%struct.A* @_ZL1i)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECK-NOT: load i32, i32*
call void @_Z3bar1A(i32 %3)
ret void
}
;; Example 2: Unnecessary stores and loads.
;; void ex2() {
;; const Type i(one());
;; const Type j = i; // Note: i == j, &i != &j ==> No store.
;; bar(i); // First load.
;; foo(&i); // Does not change i, nor j.
;; bar(j); // No load; Reuse i location.
;; }
define void @_Z3ex2v() {
; CHECK: @_Z3ex2v(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %1)
call void @_Z3fooPK1A(%struct.A* @_ZL1i)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1j to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
ret void
}
;; Example 3: Necessary stores and loads.
;; void ex3() {
;; const Type i(1);
;; Type k = i; // Note: i == k, &i != &k ==> Keep store.
;; bar(i); // First load.
;; foo(&k); // Does not change i; May change k.
;; bar(k); // Keep load.
;; }
define void @_Z3ex3v() {
; CHECK: @_Z3ex3v(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %1)
call void @_Z3fooPK1A(%struct.A* @k)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @k to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
ret void
}
;; Example 4: Smart stores and loads.
;; void ex4() {
;; const Type i(one());
;; Type k = i; // Note: i == k, &i != &k ==> May keep store.
;; bar(i); // First load.
;; foo(&i); // Does not change i, nor k.
;; bar(k); // No load; Reuse i location.
;; foo(&k); // Does not change i; May change k.
;; bar(k); // Keep load.
;; }
define void @_Z3ex4v() {
; CHECK: @_Z3ex4v(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %1)
call void @_Z3fooPK1A(%struct.A* @_ZL1i)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @k to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECKLOAD-4-5A1: load i32, i32*
; CHECK-4-5A-5B1: load i32, i32*
; CHECK-ALL: load i32, i32*
call void @_Z3bar1A(i32 %3)
call void @_Z3fooPK1A(%struct.A* @k)
%4 = bitcast %struct.A* %agg.tmp3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* bitcast (%struct.A* @k to i8*), i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%5 = load i32, i32* %coerce.dive4
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %5)
ret void
}
;; Example 5: Duplicate and smart loads (and stores).
;; void ex5a() {
;; const Type i(one());
;; Type k = i; // Note: i == k, &i != &k ==> May keep store.
;; bar(i); // First load.
;; bar(k); // No load; Reuse i location.
;; foo2(&k, &i); // Does not change i; May change k.
;; bar(i); // No load.
;; bar(k); // Keep load.
;; }
define void @_Z4ex5av() {
; CHECK: @_Z4ex5av(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%agg.tmp5 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %1)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @k to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECKLOAD-4-5A1: load i32, i32*
; CHECK-4-5A-5B1: load i32, i32*
; CHECK-ALL: load i32, i32*
call void @_Z3bar1A(i32 %3)
call void @_Z4foo2PK1AS1_(%struct.A* @k, %struct.A* @_ZL1i)
%4 = bitcast %struct.A* %agg.tmp3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%5 = load i32, i32* %coerce.dive4
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %5)
%6 = bitcast %struct.A* %agg.tmp5 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %6, i8* bitcast (%struct.A* @k to i8*), i64 4, i32 4, i1 false)
%coerce.dive6 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp5, i32 0, i32 0
%7 = load i32, i32* %coerce.dive6
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %7)
ret void
}
;; Example 5: Duplicate and smart loads (and stores).
;; void ex5b() {
;; const Type i(one());
;; const Type j = i; // Note: i == j, &i != &j ==> No store.
;; bar(i); // First load.
;; bar(j); // No load; Reuse i location.
;; foo2(&j, &i); // Does not change i, nor j.
;; bar(i); // No load.
;; bar(j); // No load; Reuse i location.
;; }
define void @_Z4ex5bv() {
; CHECK: @_Z4ex5bv(
entry:
%agg.tmp = alloca %struct.A
%agg.tmp1 = alloca %struct.A
%agg.tmp3 = alloca %struct.A
%agg.tmp5 = alloca %struct.A
%0 = bitcast %struct.A* %agg.tmp to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %0, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive = getelementptr inbounds %struct.A, %struct.A* %agg.tmp, i32 0, i32 0
%1 = load i32, i32* %coerce.dive
; CHECK-5A2-5B: load i32, i32*
; CHECK-ALL: load i32, i32*
call void @_Z3bar1A(i32 %1)
%2 = bitcast %struct.A* %agg.tmp1 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %2, i8* bitcast (%struct.A* @_ZL1j to i8*), i64 4, i32 4, i1 false)
%coerce.dive2 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp1, i32 0, i32 0
%3 = load i32, i32* %coerce.dive2
; CHECK: load i32, i32*
call void @_Z3bar1A(i32 %3)
call void @_Z4foo2PK1AS1_(%struct.A* @_ZL1j, %struct.A* @_ZL1i)
%4 = bitcast %struct.A* %agg.tmp3 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %4, i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%coerce.dive4 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp3, i32 0, i32 0
%5 = load i32, i32* %coerce.dive4
; CHECK-4-5A-5B1-NOT: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %5)
%6 = bitcast %struct.A* %agg.tmp5 to i8*
call void @llvm.memcpy.p0i8.p0i8.i64(i8* %6, i8* bitcast (%struct.A* @_ZL1j to i8*), i64 4, i32 4, i1 false)
%coerce.dive6 = getelementptr inbounds %struct.A, %struct.A* %agg.tmp5, i32 0, i32 0
%7 = load i32, i32* %coerce.dive6
; CHECKLOAD-5B2: load i32, i32*
; CHECK-5A2-5B-NOT: load i32, i32*
; CHECK-ALL-NOT: load i32, i32*
call void @_Z3bar1A(i32 %7)
ret void
}
define internal void @__cxx_global_var_init() {
entry:
%call = call i32 @_Z3onev()
call void @_ZN1AC1Ei(%struct.A* @_ZL1i, i32 %call)
; CHECKINL: store i32 {{.*}}, i32*
%0 = call {}* @llvm.invariant.start(i64 4, i8* bitcast (%struct.A* @_ZL1i to i8*))
; CHECK: call {{.*}}@llvm.invariant.start(i64 {{[0-9]+}}, i8*
ret void
}
define internal void @__cxx_global_var_init.2() {
entry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast (%struct.A* @_ZL1j to i8*), i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
%0 = call {}* @llvm.invariant.start(i64 4, i8* bitcast (%struct.A* @_ZL1j to i8*))
; CHECK: call {{.*}}@llvm.invariant.start(i64 {{[0-9]+}}, i8*
ret void
}
declare i32 @_Z3onev()
declare void @_Z3bar1A(i32)
declare void @_Z3fooPK1A(%struct.A*)
declare void @_Z4foo2PK1AS1_(%struct.A*, %struct.A*)
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1)
declare {}* @llvm.invariant.start(i64, i8* nocapture)
declare void @llvm.invariant.end({}*, i64, i8* nocapture)
declare void @llvm.lifetime.start(i64, i8* nocapture)
declare void @llvm.lifetime.end(i64, i8* nocapture)
define internal void @_GLOBAL__sub_I_global() {
entry:
call void @__cxx_global_var_init()
call void @__cxx_global_var_init.2()
call void @__cxx_global_var_init.1()
ret void
}
define internal void @__cxx_global_var_init.1() {
entry:
call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast (%struct.A* @k to i8*), i8* bitcast (%struct.A* @_ZL1i to i8*), i64 4, i32 4, i1 false)
ret void
}
define linkonce_odr void @_ZN1AC1Ei(%struct.A* %this, i32 %a) {
entry:
%this.addr = alloca %struct.A*
%a.addr = alloca i32
store %struct.A* %this, %struct.A** %this.addr
store i32 %a, i32* %a.addr
%this1 = load %struct.A*, %struct.A** %this.addr
%0 = load i32, i32* %a.addr
call void @_ZN1AC2Ei(%struct.A* %this1, i32 %0)
ret void
}
define linkonce_odr void @_ZN1AC2Ei(%struct.A* %this, i32 %a) {
entry:
%this.addr = alloca %struct.A*
%a.addr = alloca i32
store %struct.A* %this, %struct.A** %this.addr
store i32 %a, i32* %a.addr
%this1 = load %struct.A*, %struct.A** %this.addr
%a2 = getelementptr inbounds %struct.A, %struct.A* %this1, i32 0, i32 0
%0 = load i32, i32* %a.addr
store i32 %0, i32* %a2
ret void
}