Index: llvm/trunk/lib/Transforms/IPO/MergeFunctions.cpp =================================================================== --- llvm/trunk/lib/Transforms/IPO/MergeFunctions.cpp +++ llvm/trunk/lib/Transforms/IPO/MergeFunctions.cpp @@ -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 @@ "'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 + 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 @@ /// 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 &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 &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 @@ 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 &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 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 &PDIUnrelatedWL) { + + std::set PDIRelated; + for (BasicBlock::iterator BI = GEntryBlock->begin(), BIE = GEntryBlock->end(); + BI != BIE; ++BI) { + if (auto *DVI = dyn_cast(&*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(&*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(DDI->getAddress()); + if (AI) { + DEBUG(dbgs() << " Processing alloca users: "); + DEBUG(dbgs() << "\n"); + for (User *U : AI->users()) { + if (StoreInst *SI = dyn_cast(U)) { + if (Value *Arg = SI->getValueOperand()) { + if (dyn_cast(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(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 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 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; } Index: llvm/trunk/test/Transforms/MergeFunc/mergefunc-preserve-debug-info.ll =================================================================== --- llvm/trunk/test/Transforms/MergeFunc/mergefunc-preserve-debug-info.ll +++ llvm/trunk/test/Transforms/MergeFunc/mergefunc-preserve-debug-info.ll @@ -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)