forked from OSchip/llvm-project
MergeFunctions: Preserve debug info in thunks, under option -mergefunc-preserve-debug-info
Summary: Under option -mergefunc-preserve-debug-info we: - Do not create a new function for a thunk. - Retain the debug info for a thunk's parameters (and associated instructions for the debug info) from the entry block. Note: -debug will display the algorithm at work. - Create debug-info for the call (to the shared implementation) made by a thunk and its return value. - Erase the rest of the function, retaining the (minimally sized) entry block to create a thunk. - Preserve a thunk's call site to point to the thunk even when both occur within the same translation unit, to aid debugability. Note that this behaviour differs from the underlying -mergefunc implementation which modifies the thunk's call site to point to the shared implementation when both occur within the same translation unit. Reviewers: echristo, eeckstein, dblaikie, aprantl, friss Reviewed By: aprantl Subscribers: davide, fhahn, jfb, mehdi_amini, llvm-commits Differential Revision: https://reviews.llvm.org/D28075 llvm-svn: 292702
This commit is contained in:
Anmol P. Paralkar
parent
ba4041ac4f
commit
910dc8de3f
|
|
@ -96,8 +96,10 @@
|
|||
#include "llvm/IR/CallSite.h"
|
||||
#include "llvm/IR/Constants.h"
|
||||
#include "llvm/IR/DataLayout.h"
|
||||
#include "llvm/IR/DebugInfo.h"
|
||||
#include "llvm/IR/IRBuilder.h"
|
||||
#include "llvm/IR/Instructions.h"
|
||||
#include "llvm/IR/IntrinsicInst.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/IR/ValueHandle.h"
|
||||
|
|
@ -127,6 +129,26 @@ static cl::opt<unsigned> NumFunctionsForSanityCheck(
|
|||
"'0' disables this check. Works only with '-debug' key."),
|
||||
cl::init(0), cl::Hidden);
|
||||
|
||||
// Under option -mergefunc-preserve-debug-info we:
|
||||
// - Do not create a new function for a thunk.
|
||||
// - Retain the debug info for a thunk's parameters (and associated
|
||||
// instructions for the debug info) from the entry block.
|
||||
// Note: -debug will display the algorithm at work.
|
||||
// - Create debug-info for the call (to the shared implementation) made by
|
||||
// a thunk and its return value.
|
||||
// - Erase the rest of the function, retaining the (minimally sized) entry
|
||||
// block to create a thunk.
|
||||
// - Preserve a thunk's call site to point to the thunk even when both occur
|
||||
// within the same translation unit, to aid debugability. Note that this
|
||||
// behaviour differs from the underlying -mergefunc implementation which
|
||||
// modifies the thunk's call site to point to the shared implementation
|
||||
// when both occur within the same translation unit.
|
||||
static cl::opt<bool>
|
||||
MergeFunctionsPDI("mergefunc-preserve-debug-info", cl::Hidden,
|
||||
cl::init(false),
|
||||
cl::desc("Preserve debug info in thunk when mergefunc "
|
||||
"transformations are made."));
|
||||
|
||||
namespace {
|
||||
|
||||
class FunctionNode {
|
||||
|
|
@ -215,8 +237,21 @@ private:
|
|||
/// Replace G with a thunk or an alias to F. Deletes G.
|
||||
void writeThunkOrAlias(Function *F, Function *G);
|
||||
|
||||
/// Replace G with a simple tail call to bitcast(F). Also replace direct uses
|
||||
/// of G with bitcast(F). Deletes G.
|
||||
/// Fill PDIUnrelatedWL with instructions from the entry block that are
|
||||
/// unrelated to parameter related debug info.
|
||||
void filterInstsUnrelatedToPDI(BasicBlock *GEntryBlock,
|
||||
std::vector<Instruction *> &PDIUnrelatedWL);
|
||||
|
||||
/// Erase the rest of the CFG (i.e. barring the entry block).
|
||||
void eraseTail(Function *G);
|
||||
|
||||
/// Erase the instructions in PDIUnrelatedWL as they are unrelated to the
|
||||
/// parameter debug info, from the entry block.
|
||||
void eraseInstsUnrelatedToPDI(std::vector<Instruction *> &PDIUnrelatedWL);
|
||||
|
||||
/// Replace G with a simple tail call to bitcast(F). Also (unless
|
||||
/// MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
|
||||
/// delete G.
|
||||
void writeThunk(Function *F, Function *G);
|
||||
|
||||
/// Replace G with an alias to F. Deletes G.
|
||||
|
|
@ -461,51 +496,242 @@ static Value *createCast(IRBuilder<> &Builder, Value *V, Type *DestTy) {
|
|||
return Builder.CreateBitCast(V, DestTy);
|
||||
}
|
||||
|
||||
// Replace G with a simple tail call to bitcast(F). Also replace direct uses
|
||||
// of G with bitcast(F). Deletes G.
|
||||
// Erase the instructions in PDIUnrelatedWL as they are unrelated to the
|
||||
// parameter debug info, from the entry block.
|
||||
void MergeFunctions::eraseInstsUnrelatedToPDI(
|
||||
std::vector<Instruction *> &PDIUnrelatedWL) {
|
||||
|
||||
DEBUG(dbgs() << " Erasing instructions (in reverse order of appearance in "
|
||||
"entry block) unrelated to parameter debug info from entry "
|
||||
"block: {\n");
|
||||
while (!PDIUnrelatedWL.empty()) {
|
||||
Instruction *I = PDIUnrelatedWL.back();
|
||||
DEBUG(dbgs() << " Deleting Instruction: ");
|
||||
DEBUG(I->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
I->eraseFromParent();
|
||||
PDIUnrelatedWL.pop_back();
|
||||
}
|
||||
DEBUG(dbgs() << " } // Done erasing instructions unrelated to parameter "
|
||||
"debug info from entry block. \n");
|
||||
}
|
||||
|
||||
// Reduce G to its entry block.
|
||||
void MergeFunctions::eraseTail(Function *G) {
|
||||
|
||||
std::vector<BasicBlock *> WorklistBB;
|
||||
for (Function::iterator BBI = std::next(G->begin()), BBE = G->end();
|
||||
BBI != BBE; ++BBI) {
|
||||
BBI->dropAllReferences();
|
||||
WorklistBB.push_back(&*BBI);
|
||||
}
|
||||
while (!WorklistBB.empty()) {
|
||||
BasicBlock *BB = WorklistBB.back();
|
||||
BB->eraseFromParent();
|
||||
WorklistBB.pop_back();
|
||||
}
|
||||
}
|
||||
|
||||
// We are interested in the following instructions from the entry block as being
|
||||
// related to parameter debug info:
|
||||
// - @llvm.dbg.declare
|
||||
// - stores from the incoming parameters to locations on the stack-frame
|
||||
// - allocas that create these locations on the stack-frame
|
||||
// - @llvm.dbg.value
|
||||
// - the entry block's terminator
|
||||
// The rest are unrelated to debug info for the parameters; fill up
|
||||
// PDIUnrelatedWL with such instructions.
|
||||
void MergeFunctions::filterInstsUnrelatedToPDI(
|
||||
BasicBlock *GEntryBlock, std::vector<Instruction *> &PDIUnrelatedWL) {
|
||||
|
||||
std::set<Instruction *> PDIRelated;
|
||||
for (BasicBlock::iterator BI = GEntryBlock->begin(), BIE = GEntryBlock->end();
|
||||
BI != BIE; ++BI) {
|
||||
if (auto *DVI = dyn_cast<DbgValueInst>(&*BI)) {
|
||||
DEBUG(dbgs() << " Deciding: ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
DILocalVariable *DILocVar = DVI->getVariable();
|
||||
if (DILocVar->isParameter()) {
|
||||
DEBUG(dbgs() << " Include (parameter): ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIRelated.insert(&*BI);
|
||||
} else {
|
||||
DEBUG(dbgs() << " Delete (!parameter): ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
} else if (auto *DDI = dyn_cast<DbgDeclareInst>(&*BI)) {
|
||||
DEBUG(dbgs() << " Deciding: ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
DILocalVariable *DILocVar = DDI->getVariable();
|
||||
if (DILocVar->isParameter()) {
|
||||
DEBUG(dbgs() << " Parameter: ");
|
||||
DEBUG(DILocVar->print(dbgs()));
|
||||
AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress());
|
||||
if (AI) {
|
||||
DEBUG(dbgs() << " Processing alloca users: ");
|
||||
DEBUG(dbgs() << "\n");
|
||||
for (User *U : AI->users()) {
|
||||
if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
|
||||
if (Value *Arg = SI->getValueOperand()) {
|
||||
if (dyn_cast<Argument>(Arg)) {
|
||||
DEBUG(dbgs() << " Include: ");
|
||||
DEBUG(AI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIRelated.insert(AI);
|
||||
DEBUG(dbgs() << " Include (parameter): ");
|
||||
DEBUG(SI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIRelated.insert(SI);
|
||||
DEBUG(dbgs() << " Include: ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIRelated.insert(&*BI);
|
||||
} else {
|
||||
DEBUG(dbgs() << " Delete (!parameter): ");
|
||||
DEBUG(SI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
DEBUG(dbgs() << " Defer: ");
|
||||
DEBUG(U->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
DEBUG(dbgs() << " Delete (alloca NULL): ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
} else {
|
||||
DEBUG(dbgs() << " Delete (!parameter): ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
} else if (dyn_cast<TerminatorInst>(BI) == GEntryBlock->getTerminator()) {
|
||||
DEBUG(dbgs() << " Will Include Terminator: ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIRelated.insert(&*BI);
|
||||
} else {
|
||||
DEBUG(dbgs() << " Defer: ");
|
||||
DEBUG(BI->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
}
|
||||
DEBUG(dbgs()
|
||||
<< " Report parameter debug info related/related instructions: {\n");
|
||||
for (BasicBlock::iterator BI = GEntryBlock->begin(), BE = GEntryBlock->end();
|
||||
BI != BE; ++BI) {
|
||||
|
||||
Instruction *I = &*BI;
|
||||
if (PDIRelated.find(I) == PDIRelated.end()) {
|
||||
DEBUG(dbgs() << " !PDIRelated: ");
|
||||
DEBUG(I->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
PDIUnrelatedWL.push_back(I);
|
||||
} else {
|
||||
DEBUG(dbgs() << " PDIRelated: ");
|
||||
DEBUG(I->print(dbgs()));
|
||||
DEBUG(dbgs() << "\n");
|
||||
}
|
||||
}
|
||||
DEBUG(dbgs() << " }\n");
|
||||
}
|
||||
|
||||
// Replace G with a simple tail call to bitcast(F). Also (unless
|
||||
// MergeFunctionsPDI holds) replace direct uses of G with bitcast(F),
|
||||
// delete G. Under MergeFunctionsPDI, we use G itself for creating
|
||||
// the thunk as we preserve the debug info (and associated instructions)
|
||||
// from G's entry block pertaining to G's incoming arguments which are
|
||||
// passed on as corresponding arguments in the call that G makes to F.
|
||||
// For better debugability, under MergeFunctionsPDI, we do not modify G's
|
||||
// call sites to point to F even when within the same translation unit.
|
||||
void MergeFunctions::writeThunk(Function *F, Function *G) {
|
||||
if (!G->isInterposable()) {
|
||||
// Redirect direct callers of G to F.
|
||||
if (!G->isInterposable() && !MergeFunctionsPDI) {
|
||||
// Redirect direct callers of G to F. (See note on MergeFunctionsPDI
|
||||
// above).
|
||||
replaceDirectCallers(G, F);
|
||||
}
|
||||
|
||||
// If G was internal then we may have replaced all uses of G with F. If so,
|
||||
// stop here and delete G. There's no need for a thunk.
|
||||
if (G->hasLocalLinkage() && G->use_empty()) {
|
||||
// stop here and delete G. There's no need for a thunk. (See note on
|
||||
// MergeFunctionsPDI above).
|
||||
if (G->hasLocalLinkage() && G->use_empty() && !MergeFunctionsPDI) {
|
||||
G->eraseFromParent();
|
||||
return;
|
||||
}
|
||||
|
||||
Function *NewG = Function::Create(G->getFunctionType(), G->getLinkage(), "",
|
||||
G->getParent());
|
||||
BasicBlock *BB = BasicBlock::Create(F->getContext(), "", NewG);
|
||||
IRBuilder<> Builder(BB);
|
||||
BasicBlock *GEntryBlock = nullptr;
|
||||
std::vector<Instruction *> PDIUnrelatedWL;
|
||||
BasicBlock *BB = nullptr;
|
||||
Function *NewG = nullptr;
|
||||
if (MergeFunctionsPDI) {
|
||||
DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) Do not create a new "
|
||||
"function as thunk; retain original: "
|
||||
<< G->getName() << "()\n");
|
||||
GEntryBlock = &G->getEntryBlock();
|
||||
DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) filter parameter related "
|
||||
"debug info for "
|
||||
<< G->getName() << "() {\n");
|
||||
filterInstsUnrelatedToPDI(GEntryBlock, PDIUnrelatedWL);
|
||||
GEntryBlock->getTerminator()->eraseFromParent();
|
||||
BB = GEntryBlock;
|
||||
} else {
|
||||
NewG = Function::Create(G->getFunctionType(), G->getLinkage(), "",
|
||||
G->getParent());
|
||||
BB = BasicBlock::Create(F->getContext(), "", NewG);
|
||||
}
|
||||
|
||||
IRBuilder<> Builder(BB);
|
||||
Function *H = MergeFunctionsPDI ? G : NewG;
|
||||
SmallVector<Value *, 16> Args;
|
||||
unsigned i = 0;
|
||||
FunctionType *FFTy = F->getFunctionType();
|
||||
for (Argument & AI : NewG->args()) {
|
||||
for (Argument & AI : H->args()) {
|
||||
Args.push_back(createCast(Builder, &AI, FFTy->getParamType(i)));
|
||||
++i;
|
||||
}
|
||||
|
||||
CallInst *CI = Builder.CreateCall(F, Args);
|
||||
ReturnInst *RI = nullptr;
|
||||
CI->setTailCall();
|
||||
CI->setCallingConv(F->getCallingConv());
|
||||
CI->setAttributes(F->getAttributes());
|
||||
if (NewG->getReturnType()->isVoidTy()) {
|
||||
Builder.CreateRetVoid();
|
||||
if (H->getReturnType()->isVoidTy()) {
|
||||
RI = Builder.CreateRetVoid();
|
||||
} else {
|
||||
Builder.CreateRet(createCast(Builder, CI, NewG->getReturnType()));
|
||||
RI = Builder.CreateRet(createCast(Builder, CI, H->getReturnType()));
|
||||
}
|
||||
|
||||
NewG->copyAttributesFrom(G);
|
||||
NewG->takeName(G);
|
||||
removeUsers(G);
|
||||
G->replaceAllUsesWith(NewG);
|
||||
G->eraseFromParent();
|
||||
if (MergeFunctionsPDI) {
|
||||
DISubprogram *DIS = G->getSubprogram();
|
||||
if (DIS) {
|
||||
DebugLoc CIDbgLoc = DebugLoc::get(DIS->getScopeLine(), 0, DIS);
|
||||
DebugLoc RIDbgLoc = DebugLoc::get(DIS->getScopeLine(), 0, DIS);
|
||||
CI->setDebugLoc(CIDbgLoc);
|
||||
RI->setDebugLoc(RIDbgLoc);
|
||||
} else {
|
||||
DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) No DISubprogram for "
|
||||
<< G->getName() << "()\n");
|
||||
}
|
||||
eraseTail(G);
|
||||
eraseInstsUnrelatedToPDI(PDIUnrelatedWL);
|
||||
DEBUG(dbgs() << "} // End of parameter related debug info filtering for: "
|
||||
<< G->getName() << "()\n");
|
||||
} else {
|
||||
NewG->copyAttributesFrom(G);
|
||||
NewG->takeName(G);
|
||||
removeUsers(G);
|
||||
G->replaceAllUsesWith(NewG);
|
||||
G->eraseFromParent();
|
||||
}
|
||||
|
||||
DEBUG(dbgs() << "writeThunk: " << NewG->getName() << '\n');
|
||||
DEBUG(dbgs() << "writeThunk: " << H->getName() << '\n');
|
||||
++NumThunksWritten;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,223 @@
|
|||
; RUN: opt -O0 -S -mergefunc -mergefunc-preserve-debug-info < %s | FileCheck %s --check-prefix=OPTIMIZATION_LEVEL_0
|
||||
; RUN: opt -O2 -S -mergefunc -mergefunc-preserve-debug-info < %s | FileCheck %s --check-prefix=OPTIMIZATION_LEVEL_2
|
||||
|
||||
; Preserve debug info in thunks under -mergefunc -mergefunc-preserve-debug-info
|
||||
;
|
||||
; We test that:
|
||||
; At -O0 we have preserved the generated @llvm.dbg.declare debug intrinsics.
|
||||
; At -O2 we have preserved the generated @llvm.dbg.value debug intrinsics.
|
||||
; At -O0, stores from the incoming parameters to locations on the stack-frame
|
||||
; and allocas that create these locations on the stack-frame are preserved.
|
||||
; Debug info got generated for the call made by the thunk and for its return value.
|
||||
; The foregoing is the only content of a thunk's entry block.
|
||||
; A thunk makes a tail call to the shared implementation.
|
||||
; A thunk's call site is preserved to point to the thunk (with only -mergefunc the
|
||||
; call site is modified to point to the shared implementation) when both occur
|
||||
; within the same translation unit.
|
||||
|
||||
; The source code that was used to test and generate this LLVM IR is:
|
||||
;
|
||||
; int maxA(int x, int y) {
|
||||
; int i, m, j;
|
||||
; if (x > y)
|
||||
; m = x;
|
||||
; else
|
||||
; m = y;
|
||||
; return m;
|
||||
; }
|
||||
;
|
||||
; int maxB(int x, int y) {
|
||||
; int i, m, j;
|
||||
; if (x > y)
|
||||
; m = x;
|
||||
; else
|
||||
; m = y;
|
||||
; return m;
|
||||
; }
|
||||
;
|
||||
; void f(void) {
|
||||
;
|
||||
; maxA(3, 4);
|
||||
; maxB(1, 9);
|
||||
; }
|
||||
|
||||
; Function Attrs: nounwind uwtable
|
||||
define i32 @maxA(i32 %x, i32 %y) !dbg !6 {
|
||||
entry:
|
||||
%x.addr = alloca i32, align 4
|
||||
%y.addr = alloca i32, align 4
|
||||
%i = alloca i32, align 4
|
||||
%m = alloca i32, align 4
|
||||
%j = alloca i32, align 4
|
||||
store i32 %x, i32* %x.addr, align 4
|
||||
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !11, metadata !12), !dbg !13
|
||||
store i32 %y, i32* %y.addr, align 4
|
||||
call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !14, metadata !12), !dbg !15
|
||||
call void @llvm.dbg.declare(metadata i32* %i, metadata !16, metadata !12), !dbg !17
|
||||
call void @llvm.dbg.declare(metadata i32* %m, metadata !18, metadata !12), !dbg !19
|
||||
call void @llvm.dbg.declare(metadata i32* %j, metadata !20, metadata !12), !dbg !21
|
||||
%0 = load i32, i32* %x.addr, align 4, !dbg !22
|
||||
%1 = load i32, i32* %y.addr, align 4, !dbg !24
|
||||
%cmp = icmp sgt i32 %0, %1, !dbg !25
|
||||
br i1 %cmp, label %if.then, label %if.else, !dbg !26
|
||||
|
||||
if.then: ; preds = %entry
|
||||
%2 = load i32, i32* %x.addr, align 4, !dbg !27
|
||||
store i32 %2, i32* %m, align 4, !dbg !28
|
||||
br label %if.end, !dbg !29
|
||||
|
||||
if.else: ; preds = %entry
|
||||
%3 = load i32, i32* %y.addr, align 4, !dbg !30
|
||||
store i32 %3, i32* %m, align 4, !dbg !31
|
||||
br label %if.end
|
||||
|
||||
if.end: ; preds = %if.else, %if.then
|
||||
%4 = load i32, i32* %m, align 4, !dbg !32
|
||||
ret i32 %4, !dbg !33
|
||||
}
|
||||
|
||||
; Function Attrs: nounwind readnone
|
||||
declare void @llvm.dbg.declare(metadata, metadata, metadata)
|
||||
|
||||
; Function Attrs: nounwind uwtable
|
||||
define i32 @maxB(i32 %x, i32 %y) !dbg !34 {
|
||||
|
||||
; OPTIMIZATION_LEVEL_0: define i32 @maxB(i32 %x, i32 %y)
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: entry:
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: %x.addr = alloca i32, align 4
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: %y.addr = alloca i32, align 4
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: store i32 %x, i32* %x.addr, align 4
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !{{[0-9]+}}, metadata !{{[0-9]+}}), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: store i32 %y, i32* %y.addr, align 4
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !{{[0-9]+}}, metadata !{{[0-9]+}}), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: %0 = tail call i32 @maxA(i32 %x, i32 %y), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: ret i32 %0, !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: }
|
||||
|
||||
; OPTIMIZATION_LEVEL_2: define i32 @maxB(i32 %x, i32 %y)
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: entry:
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: tail call void @llvm.dbg.value(metadata i32 %x, i64 0, metadata !{{[0-9]+}}, metadata !{{[0-9]+}}), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: tail call void @llvm.dbg.value(metadata i32 %y, i64 0, metadata !{{[0-9]+}}, metadata !{{[0-9]+}}), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: %0 = tail call i32 @maxA(i32 %x, i32 %y) #{{[0-9]+}}, !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: ret i32 %0, !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: }
|
||||
|
||||
entry:
|
||||
%x.addr = alloca i32, align 4
|
||||
%y.addr = alloca i32, align 4
|
||||
%i = alloca i32, align 4
|
||||
%m = alloca i32, align 4
|
||||
%j = alloca i32, align 4
|
||||
store i32 %x, i32* %x.addr, align 4
|
||||
call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !35, metadata !12), !dbg !36
|
||||
store i32 %y, i32* %y.addr, align 4
|
||||
call void @llvm.dbg.declare(metadata i32* %y.addr, metadata !37, metadata !12), !dbg !38
|
||||
call void @llvm.dbg.declare(metadata i32* %i, metadata !39, metadata !12), !dbg !40
|
||||
call void @llvm.dbg.declare(metadata i32* %m, metadata !41, metadata !12), !dbg !42
|
||||
call void @llvm.dbg.declare(metadata i32* %j, metadata !43, metadata !12), !dbg !44
|
||||
%0 = load i32, i32* %x.addr, align 4, !dbg !45
|
||||
%1 = load i32, i32* %y.addr, align 4, !dbg !47
|
||||
%cmp = icmp sgt i32 %0, %1, !dbg !48
|
||||
br i1 %cmp, label %if.then, label %if.else, !dbg !49
|
||||
|
||||
if.then: ; preds = %entry
|
||||
%2 = load i32, i32* %x.addr, align 4, !dbg !50
|
||||
store i32 %2, i32* %m, align 4, !dbg !51
|
||||
br label %if.end, !dbg !52
|
||||
|
||||
if.else: ; preds = %entry
|
||||
%3 = load i32, i32* %y.addr, align 4, !dbg !53
|
||||
store i32 %3, i32* %m, align 4, !dbg !54
|
||||
br label %if.end
|
||||
|
||||
if.end: ; preds = %if.else, %if.then
|
||||
%4 = load i32, i32* %m, align 4, !dbg !55
|
||||
ret i32 %4, !dbg !56
|
||||
}
|
||||
|
||||
; Function Attrs: nounwind uwtable
|
||||
define void @f() !dbg !57 {
|
||||
entry:
|
||||
|
||||
; OPTIMIZATION_LEVEL_0: define void @f()
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: entry:
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: %call = call i32 @maxA(i32 3, i32 4), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: %call1 = call i32 @maxB(i32 1, i32 9), !dbg !{{[0-9]+}}
|
||||
; OPTIMIZATION_LEVEL_0-NEXT: ret void, !dbg !{{[0-9]+}}
|
||||
|
||||
; OPTIMIZATION_LEVEL_2: define void @f()
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: entry:
|
||||
; OPTIMIZATION_LEVEL_2-NEXT: ret void, !dbg !{{[0-9]+}}
|
||||
|
||||
%call = call i32 @maxA(i32 3, i32 4), !dbg !60
|
||||
%call1 = call i32 @maxB(i32 1, i32 9), !dbg !61
|
||||
ret void, !dbg !62
|
||||
}
|
||||
|
||||
!llvm.dbg.cu = !{!0}
|
||||
!llvm.module.flags = !{!3, !4}
|
||||
!llvm.ident = !{!5}
|
||||
|
||||
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
|
||||
!1 = !DIFile(filename: "mergefunc-preserve-debug-info.c", directory: "")
|
||||
!2 = !{}
|
||||
!3 = !{i32 2, !"Dwarf Version", i32 4}
|
||||
!4 = !{i32 2, !"Debug Info Version", i32 3}
|
||||
!5 = !{!""}
|
||||
!6 = distinct !DISubprogram(name: "maxA", scope: !7, file: !7, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
|
||||
!7 = !DIFile(filename: "./mergefunc-preserve-debug-info.c", directory: "")
|
||||
!8 = !DISubroutineType(types: !9)
|
||||
!9 = !{!10, !10, !10}
|
||||
!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
||||
!11 = !DILocalVariable(name: "x", arg: 1, scope: !6, file: !7, line: 1, type: !10)
|
||||
!12 = !DIExpression()
|
||||
!13 = !DILocation(line: 1, column: 14, scope: !6)
|
||||
!14 = !DILocalVariable(name: "y", arg: 2, scope: !6, file: !7, line: 1, type: !10)
|
||||
!15 = !DILocation(line: 1, column: 21, scope: !6)
|
||||
!16 = !DILocalVariable(name: "i", scope: !6, file: !7, line: 2, type: !10)
|
||||
!17 = !DILocation(line: 2, column: 7, scope: !6)
|
||||
!18 = !DILocalVariable(name: "m", scope: !6, file: !7, line: 2, type: !10)
|
||||
!19 = !DILocation(line: 2, column: 10, scope: !6)
|
||||
!20 = !DILocalVariable(name: "j", scope: !6, file: !7, line: 2, type: !10)
|
||||
!21 = !DILocation(line: 2, column: 13, scope: !6)
|
||||
!22 = !DILocation(line: 3, column: 7, scope: !23)
|
||||
!23 = distinct !DILexicalBlock(scope: !6, file: !7, line: 3, column: 7)
|
||||
!24 = !DILocation(line: 3, column: 11, scope: !23)
|
||||
!25 = !DILocation(line: 3, column: 9, scope: !23)
|
||||
!26 = !DILocation(line: 3, column: 7, scope: !6)
|
||||
!27 = !DILocation(line: 4, column: 9, scope: !23)
|
||||
!28 = !DILocation(line: 4, column: 7, scope: !23)
|
||||
!29 = !DILocation(line: 4, column: 5, scope: !23)
|
||||
!30 = !DILocation(line: 6, column: 9, scope: !23)
|
||||
!31 = !DILocation(line: 6, column: 7, scope: !23)
|
||||
!32 = !DILocation(line: 7, column: 10, scope: !6)
|
||||
!33 = !DILocation(line: 7, column: 3, scope: !6)
|
||||
!34 = distinct !DISubprogram(name: "maxB", scope: !7, file: !7, line: 10, type: !8, isLocal: false, isDefinition: true, scopeLine: 10, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
|
||||
!35 = !DILocalVariable(name: "x", arg: 1, scope: !34, file: !7, line: 10, type: !10)
|
||||
!36 = !DILocation(line: 10, column: 14, scope: !34)
|
||||
!37 = !DILocalVariable(name: "y", arg: 2, scope: !34, file: !7, line: 10, type: !10)
|
||||
!38 = !DILocation(line: 10, column: 21, scope: !34)
|
||||
!39 = !DILocalVariable(name: "i", scope: !34, file: !7, line: 11, type: !10)
|
||||
!40 = !DILocation(line: 11, column: 7, scope: !34)
|
||||
!41 = !DILocalVariable(name: "m", scope: !34, file: !7, line: 11, type: !10)
|
||||
!42 = !DILocation(line: 11, column: 10, scope: !34)
|
||||
!43 = !DILocalVariable(name: "j", scope: !34, file: !7, line: 11, type: !10)
|
||||
!44 = !DILocation(line: 11, column: 13, scope: !34)
|
||||
!45 = !DILocation(line: 12, column: 7, scope: !46)
|
||||
!46 = distinct !DILexicalBlock(scope: !34, file: !7, line: 12, column: 7)
|
||||
!47 = !DILocation(line: 12, column: 11, scope: !46)
|
||||
!48 = !DILocation(line: 12, column: 9, scope: !46)
|
||||
!49 = !DILocation(line: 12, column: 7, scope: !34)
|
||||
!50 = !DILocation(line: 13, column: 9, scope: !46)
|
||||
!51 = !DILocation(line: 13, column: 7, scope: !46)
|
||||
!52 = !DILocation(line: 13, column: 5, scope: !46)
|
||||
!53 = !DILocation(line: 15, column: 9, scope: !46)
|
||||
!54 = !DILocation(line: 15, column: 7, scope: !46)
|
||||
!55 = !DILocation(line: 16, column: 10, scope: !34)
|
||||
!56 = !DILocation(line: 16, column: 3, scope: !34)
|
||||
!57 = distinct !DISubprogram(name: "f", scope: !7, file: !7, line: 19, type: !58, isLocal: false, isDefinition: true, scopeLine: 19, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
|
||||
!58 = !DISubroutineType(types: !59)
|
||||
!59 = !{null}
|
||||
!60 = !DILocation(line: 21, column: 3, scope: !57)
|
||||
!61 = !DILocation(line: 22, column: 3, scope: !57)
|
||||
!62 = !DILocation(line: 23, column: 1, scope: !57)
|
||||
Loading…
Reference in New Issue