[llvm] r322789 - [MachineOutliner] Add DISubprograms to outlined functions.
Robinson, Paul via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 18 08:45:12 PST 2018
> -----Original Message-----
> From: aprantl at apple.com [mailto:aprantl at apple.com]
> Sent: Thursday, January 18, 2018 8:23 AM
> To: Jessica Paquette
> Cc: Robinson, Paul; llvm-commits at lists.llvm.org; David Blaikie
> Subject: Re: [llvm] r322789 - [MachineOutliner] Add DISubprograms to
> outlined functions.
>
> We no longer record the list of DISubprograms in DICompileUnit, so
> creating a new DISubprogram and attaching it to an existing DICompileUnit
> is definitely possible, we just need to make sure the unit: field in the
> DISubprogram points to the right DICompileUnit.
>
> To do this you can either extend DIBuilder to take an optional CUNode in
> its constructor or add a setCompileUnit() method, or you could just create
> the DISubprogram node from scratch. Extending DIBuilder is the preferable
> approach as far as I'm concerned.
>
> -- adrian
+1 for extending DIBuilder.
A naïve way to spec what we'd like is: "if there's only one CU, use it."
But that's not really the correct spec. Really it's: "if all calls to
the outlined function come from the same CU, use that CU."
If there's only one CU in the module, then trivially all calls come from
the same CU; with LTO and multiple CUs, it would require more bookkeeping,
and an expedient thing to do is punt and put all outlined functions into
a new CU even if that isn't the most desirable thing.
I haven't looked at the outliner closely so I don't know whether it
already tracks enough information to make the more detailed spec really
doable. But please keep that goal in mind as you look at this.
Thanks,
--paulr
>
> > On Jan 17, 2018, at 9:52 PM, Jessica Paquette <jpaquette at apple.com>
> wrote:
> >
> > Hi Paul,
> >
> > I originally attempted to attach the functions to the existing CU in the
> module, but it seems that the DIBuilder interface doesn’t actually expose
> that functionality. As far as I can tell, the only way to attach a CU to
> the DIBuilder is through createCompileUnit. I found that if you skip that
> step and use use the existing CU that lives on the module, it won’t
> actually be attached to the DISubprogram when you emit it. As a result,
> instead of getting
> >
> > distinct !DISubprogram(name: "OUTLINED_FUNCTION_1”,… unit: !something,
> …)
> >
> > the unit field won’t exist at all.
> >
> > If there’s a way to attach the existing unit to the functions, I’d be
> happy to use that instead.
> >
> > - Jessica
> >
> >
> >> On Jan 17, 2018, at 6:05 PM, Robinson, Paul <paul.robinson at sony.com>
> wrote:
> >>
> >> Hi Jessica,
> >> Creating a whole new compilation unit for the outlined functions seems
> >> pretty extreme. For non-LTO compilations there should be only one; is
> >> there something keeping you from adding the functions to that CU? Or
> >> is that undesirable for some reason?
> >> Thanks,
> >> --paulr
> >>
> >>> -----Original Message-----
> >>> From: llvm-commits [mailto:llvm-commits-bounces at lists.llvm.org] On
> Behalf
> >>> Of Jessica Paquette via llvm-commits
> >>> Sent: Wednesday, January 17, 2018 4:01 PM
> >>> To: llvm-commits at lists.llvm.org
> >>> Subject: [llvm] r322789 - [MachineOutliner] Add DISubprograms to
> outlined
> >>> functions.
> >>>
> >>> Author: paquette
> >>> Date: Wed Jan 17 16:00:58 2018
> >>> New Revision: 322789
> >>>
> >>> URL: http://llvm.org/viewvc/llvm-project?rev=322789&view=rev
> >>> Log:
> >>> [MachineOutliner] Add DISubprograms to outlined functions.
> >>>
> >>> Before, it wasn't possible to get backtraces inside outlined
> functions.
> >>> This
> >>> commit adds DISubprograms to the IR functions created by the outliner
> >>> which
> >>> makes this possible. Also attached a test that ensures that the
> produced
> >>> debug information is correct. This is useful to users that want to
> debug
> >>> outlined code.
> >>>
> >>>
> >>> Added:
> >>> llvm/trunk/test/CodeGen/X86/machine-outliner-disubprogram.ll
> >>> Modified:
> >>> llvm/trunk/lib/CodeGen/MachineOutliner.cpp
> >>>
> >>> Modified: llvm/trunk/lib/CodeGen/MachineOutliner.cpp
> >>> URL: http://llvm.org/viewvc/llvm-
> >>>
> project/llvm/trunk/lib/CodeGen/MachineOutliner.cpp?rev=322789&r1=322788&r2
> >>> =322789&view=diff
> >>>
> ==========================================================================
> >>> ====
> >>> --- llvm/trunk/lib/CodeGen/MachineOutliner.cpp (original)
> >>> +++ llvm/trunk/lib/CodeGen/MachineOutliner.cpp Wed Jan 17 16:00:58
> 2018
> >>> @@ -66,6 +66,7 @@
> >>> #include "llvm/CodeGen/TargetInstrInfo.h"
> >>> #include "llvm/CodeGen/TargetRegisterInfo.h"
> >>> #include "llvm/CodeGen/TargetSubtargetInfo.h"
> >>> +#include "llvm/IR/DIBuilder.h"
> >>> #include "llvm/IR/IRBuilder.h"
> >>> #include "llvm/Support/Allocator.h"
> >>> #include "llvm/Support/Debug.h"
> >>> @@ -776,6 +777,9 @@ struct MachineOutliner : public ModulePa
> >>> /// linkonceodr linkage.
> >>> bool OutlineFromLinkOnceODRs = false;
> >>>
> >>> + // Collection of IR functions created by the outliner.
> >>> + std::vector<Function *> CreatedIRFunctions;
> >>> +
> >>> StringRef getPassName() const override { return "Machine Outliner"; }
> >>>
> >>> void getAnalysisUsage(AnalysisUsage &AU) const override {
> >>> @@ -1210,6 +1214,9 @@ MachineOutliner::createOutlinedFunction(
> >>> F->setLinkage(GlobalValue::PrivateLinkage);
> >>> F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
> >>>
> >>> + // Save F so that we can add debug info later if we need to.
> >>> + CreatedIRFunctions.push_back(F);
> >>> +
> >>> BasicBlock *EntryBB = BasicBlock::Create(C, "entry", F);
> >>> IRBuilder<> Builder(EntryBB);
> >>> Builder.CreateRetVoid();
> >>> @@ -1233,12 +1240,12 @@ MachineOutliner::createOutlinedFunction(
> >>> NewMI->dropMemRefs();
> >>>
> >>> // Don't keep debug information for outlined instructions.
> >>> - // FIXME: This means outlined functions are currently
> undebuggable.
> >>> NewMI->setDebugLoc(DebugLoc());
> >>> MBB.insert(MBB.end(), NewMI);
> >>> }
> >>>
> >>> TII.insertOutlinerEpilogue(MBB, MF, OF.MInfo);
> >>> +
> >>> return &MF;
> >>> }
> >>>
> >>> @@ -1379,5 +1386,43 @@ bool MachineOutliner::runOnModule(Module
> >>> pruneOverlaps(CandidateList, FunctionList, Mapper, MaxCandidateLen,
> >>> *TII);
> >>>
> >>> // Outline each of the candidates and return true if something was
> >>> outlined.
> >>> - return outline(M, CandidateList, FunctionList, Mapper);
> >>> + bool OutlinedSomething = outline(M, CandidateList, FunctionList,
> >>> Mapper);
> >>> +
> >>> + // If we have a compile unit, and we've outlined something, then
> set
> >>> debug
> >>> + // information on the outlined function.
> >>> + if (M.debug_compile_units_begin() != M.debug_compile_units_end() &&
> >>> + OutlinedSomething) {
> >>> + std::unique_ptr<DIBuilder> DB = llvm::make_unique<DIBuilder>(M);
> >>> +
> >>> + // Create a compile unit for the outlined function.
> >>> + DICompileUnit *MCU = *M.debug_compile_units_begin();
> >>> + DIFile *Unit = DB->createFile(M.getName(), "/");
> >>> + DB->createCompileUnit(MCU->getSourceLanguage(), Unit, "machine-
> >>> outliner",
> >>> + true, "", MCU->getRuntimeVersion(),
> >>> StringRef(),
> >>> + DICompileUnit::DebugEmissionKind::NoDebug);
> >>> +
> >>> + // Walk over each IR function we created in the outliner and
> create
> >>> + // DISubprograms for each function.
> >>> + for (Function *F : CreatedIRFunctions) {
> >>> + DISubprogram *SP = DB->createFunction(
> >>> + Unit /* Context */, F->getName(),
> >>> + StringRef() /* Empty linkage name. */, Unit /* File */,
> >>> + 0 /* Line numbers don't matter*/,
> >>> + DB->createSubroutineType(DB->getOrCreateTypeArray(None)),
> /*
> >>> void */
> >>> + false, true, 0, /* Line in scope doesn't matter*/
> >>> + DINode::DIFlags::FlagArtificial /* Compiler-generated code.
> */,
> >>> + true /* Outlined code is optimized code by definition. */);
> >>> +
> >>> + // Don't add any new variables to the subprogram.
> >>> + DB->finalizeSubprogram(SP);
> >>> +
> >>> + // Attach subprogram to the function.
> >>> + F->setSubprogram(SP);
> >>> + }
> >>> +
> >>> + // We're done with the DIBuilder.
> >>> + DB->finalize();
> >>> + }
> >>> +
> >>> + return OutlinedSomething;
> >>> }
> >>>
> >>> Added: llvm/trunk/test/CodeGen/X86/machine-outliner-disubprogram.ll
> >>> URL: http://llvm.org/viewvc/llvm-
> >>> project/llvm/trunk/test/CodeGen/X86/machine-outliner-
> >>> disubprogram.ll?rev=322789&view=auto
> >>>
> ==========================================================================
> >>> ====
> >>> --- llvm/trunk/test/CodeGen/X86/machine-outliner-disubprogram.ll
> (added)
> >>> +++ llvm/trunk/test/CodeGen/X86/machine-outliner-disubprogram.ll Wed
> Jan
> >>> 17 16:00:58 2018
> >>> @@ -0,0 +1,219 @@
> >>> +; Ensure that we can correctly emit a compile unit for outlined
> functions
> >>> and
> >>> +; that we correctly emit DISubprograms for those functions.
> >>> +; Also make sure that the DISubprograms reference the generated unit.
> >>> +; make sure that if there are two outlined functions in the program,
> >>> +; RUN: llc %s -enable-machine-outliner -mtriple=x86_64-apple-darwin -
> o
> >>> d.out -print-after=machine-outliner
> >>> +define void @f6() #0 !dbg !8 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !11,
> metadata
> >>> !DIExpression()), !dbg !13
> >>> + store i32 16, i32* %dog, align 4, !dbg !13
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !14,
> metadata
> >>> !DIExpression()), !dbg !15
> >>> + store i32 32, i32* %cat, align 4, !dbg !15
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !16,
> >>> metadata !DIExpression()), !dbg !17
> >>> + store i32 48, i32* %pangolin, align 4, !dbg !17
> >>> + ret void, !dbg !18
> >>> +}
> >>> +
> >>> +declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
> >>> +
> >>> +define void @f5() #0 !dbg !19 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !20,
> metadata
> >>> !DIExpression()), !dbg !21
> >>> + store i32 16, i32* %dog, align 4, !dbg !21
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !22,
> metadata
> >>> !DIExpression()), !dbg !23
> >>> + store i32 32, i32* %cat, align 4, !dbg !23
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !24,
> >>> metadata !DIExpression()), !dbg !25
> >>> + store i32 48, i32* %pangolin, align 4, !dbg !25
> >>> + ret void, !dbg !26
> >>> +}
> >>> +
> >>> +define void @f4() #0 !dbg !27 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !28,
> metadata
> >>> !DIExpression()), !dbg !29
> >>> + store i32 16, i32* %dog, align 4, !dbg !29
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !30,
> metadata
> >>> !DIExpression()), !dbg !31
> >>> + store i32 32, i32* %cat, align 4, !dbg !31
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !32,
> >>> metadata !DIExpression()), !dbg !33
> >>> + store i32 48, i32* %pangolin, align 4, !dbg !33
> >>> + ret void, !dbg !34
> >>> +}
> >>> +
> >>> +define i32 @f1() #0 !dbg !35 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !38,
> metadata
> >>> !DIExpression()), !dbg !39
> >>> + store i32 1, i32* %dog, align 4, !dbg !39
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !40,
> metadata
> >>> !DIExpression()), !dbg !41
> >>> + store i32 2, i32* %cat, align 4, !dbg !41
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !42,
> >>> metadata !DIExpression()), !dbg !43
> >>> + store i32 3, i32* %pangolin, align 4, !dbg !43
> >>> + store i32 16, i32* %dog, align 4, !dbg !44
> >>> + %0 = load i32, i32* %dog, align 4, !dbg !45
> >>> + ret i32 %0, !dbg !46
> >>> +}
> >>> +
> >>> +define i32 @f2() #0 !dbg !47 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !48,
> metadata
> >>> !DIExpression()), !dbg !49
> >>> + store i32 1, i32* %dog, align 4, !dbg !49
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !50,
> metadata
> >>> !DIExpression()), !dbg !51
> >>> + store i32 2, i32* %cat, align 4, !dbg !51
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !52,
> >>> metadata !DIExpression()), !dbg !53
> >>> + store i32 3, i32* %pangolin, align 4, !dbg !53
> >>> + store i32 16, i32* %dog, align 4, !dbg !54
> >>> + %0 = load i32, i32* %dog, align 4, !dbg !55
> >>> + ret i32 %0, !dbg !56
> >>> +}
> >>> +
> >>> +define i32 @f3() #0 !dbg !57 {
> >>> +entry:
> >>> + %dog = alloca i32, align 4
> >>> + %cat = alloca i32, align 4
> >>> + %pangolin = alloca i32, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %dog, metadata !58,
> metadata
> >>> !DIExpression()), !dbg !59
> >>> + store i32 1, i32* %dog, align 4, !dbg !59
> >>> + call void @llvm.dbg.declare(metadata i32* %cat, metadata !60,
> metadata
> >>> !DIExpression()), !dbg !61
> >>> + store i32 2, i32* %cat, align 4, !dbg !61
> >>> + call void @llvm.dbg.declare(metadata i32* %pangolin, metadata !62,
> >>> metadata !DIExpression()), !dbg !63
> >>> + store i32 3, i32* %pangolin, align 4, !dbg !63
> >>> + store i32 16, i32* %dog, align 4, !dbg !64
> >>> + %0 = load i32, i32* %dog, align 4, !dbg !65
> >>> + ret i32 %0, !dbg !66
> >>> +}
> >>> +
> >>> +define i32 @main() #0 !dbg !67 {
> >>> +entry:
> >>> + %retval = alloca i32, align 4
> >>> + %a = alloca i32, align 4
> >>> + store i32 0, i32* %retval, align 4
> >>> + call void @llvm.dbg.declare(metadata i32* %a, metadata !68,
> metadata
> >>> !DIExpression()), !dbg !69
> >>> + store i32 4, i32* %a, align 4, !dbg !69
> >>> + %call = call i32 @f1() #2, !dbg !70
> >>> + %call1 = call i32 @f2() #2, !dbg !71
> >>> + %call2 = call i32 @f3() #2, !dbg !72
> >>> + ret i32 0, !dbg !73
> >>> +}
> >>> +
> >>> +; CHECK [[UNIT:![0-9]+]] = distinct !DICompileUnit
> >>> +; CHECK-SAME: file: [[FILE:![0-9]+]],
> >>> +; CHECK-SAME: producer: "machine-outliner",
> >>> +; CHECK-SAME: isOptimized: true, runtimeVersion: 0, emissionKind:
> NoDebug
> >>> +
> >>> +; CHECK: distinct !DISubprogram(name: "OUTLINED_FUNCTION_1",
> >>> +; CHECK-SAME: scope: [[FILE]],
> >>> +; CHECK-SAME: file: [[FILE]],
> >>> +; CHECK-SAME: type: [[TYPE:![0-9]+]],
> >>> +; CHECK-SAME: isLocal: false,
> >>> +; CHECK-SAME: isDefinition: true,
> >>> +; CHECK-SAME: flags: DIFlagArtificial,
> >>> +; CHECK-SAME: isOptimized: true,
> >>> +; CHECK-SAME: unit: [[UNIT]],
> >>> +; CHECK-SAME: variables: [[VARS:![0-9]+]]
> >>> +
> >>> +; CHECK: distinct !DISubprogram(name: "OUTLINED_FUNCTION_1",
> >>> +; CHECK-SAME: scope: [[FILE]],
> >>> +; CHECK-SAME: file: [[FILE]],
> >>> +; CHECK-SAME: type: [[TYPE]],
> >>> +; CHECK-SAME: isLocal: false,
> >>> +; CHECK-SAME: isDefinition: true,
> >>> +; CHECK-SAME: flags: DIFlagArtificial,
> >>> +; CHECK-SAME: isOptimized: true,
> >>> +; CHECK-SAME: unit: [[UNIT]],
> >>> +; CHECK-SAME: variables: [[VARS]]
> >>> +
> >>> +attributes #0 = { noinline noredzone nounwind optnone ssp uwtable
> "no-
> >>> frame-pointer-elim"="true" }
> >>> +attributes #1 = { nounwind readnone speculatable }
> >>> +attributes #2 = { noredzone }
> >>> +
> >>> +!llvm.dbg.cu = !{!0}
> >>> +!llvm.module.flags = !{!3, !4, !5, !6}
> >>> +!llvm.ident = !{!7}
> >>> +
> >>> +!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1,
> producer:
> >>> "clang", isOptimized: false, runtimeVersion: 0, emissionKind:
> FullDebug,
> >>> enums: !2)
> >>> +!1 = !DIFile(filename: "test.c", directory: "/")
> >>> +!2 = !{}
> >>> +!3 = !{i32 2, !"Dwarf Version", i32 4}
> >>> +!4 = !{i32 2, !"Debug Info Version", i32 3}
> >>> +!5 = !{i32 1, !"wchar_size", i32 4}
> >>> +!6 = !{i32 7, !"PIC Level", i32 2}
> >>> +!7 = !{!"clang"}
> >>> +!8 = distinct !DISubprogram(name: "f6", scope: !1, file: !1, line: 3,
> >>> type: !9, isLocal: false, isDefinition: true, scopeLine: 3,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!9 = !DISubroutineType(types: !10)
> >>> +!10 = !{null}
> >>> +!11 = !DILocalVariable(name: "dog", scope: !8, file: !1, line: 4,
> type:
> >>> !12)
> >>> +!12 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
> >>> +!13 = !DILocation(line: 4, column: 16, scope: !8)
> >>> +!14 = !DILocalVariable(name: "cat", scope: !8, file: !1, line: 5,
> type:
> >>> !12)
> >>> +!15 = !DILocation(line: 5, column: 16, scope: !8)
> >>> +!16 = !DILocalVariable(name: "pangolin", scope: !8, file: !1, line:
> 6,
> >>> type: !12)
> >>> +!17 = !DILocation(line: 6, column: 16, scope: !8)
> >>> +!18 = !DILocation(line: 7, column: 1, scope: !8)
> >>> +!19 = distinct !DISubprogram(name: "f5", scope: !1, file: !1, line:
> 9,
> >>> type: !9, isLocal: false, isDefinition: true, scopeLine: 9,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!20 = !DILocalVariable(name: "dog", scope: !19, file: !1, line: 10,
> type:
> >>> !12)
> >>> +!21 = !DILocation(line: 10, column: 16, scope: !19)
> >>> +!22 = !DILocalVariable(name: "cat", scope: !19, file: !1, line: 11,
> type:
> >>> !12)
> >>> +!23 = !DILocation(line: 11, column: 16, scope: !19)
> >>> +!24 = !DILocalVariable(name: "pangolin", scope: !19, file: !1, line:
> 12,
> >>> type: !12)
> >>> +!25 = !DILocation(line: 12, column: 16, scope: !19)
> >>> +!26 = !DILocation(line: 13, column: 1, scope: !19)
> >>> +!27 = distinct !DISubprogram(name: "f4", scope: !1, file: !1, line:
> 15,
> >>> type: !9, isLocal: false, isDefinition: true, scopeLine: 15,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!28 = !DILocalVariable(name: "dog", scope: !27, file: !1, line: 16,
> type:
> >>> !12)
> >>> +!29 = !DILocation(line: 16, column: 16, scope: !27)
> >>> +!30 = !DILocalVariable(name: "cat", scope: !27, file: !1, line: 17,
> type:
> >>> !12)
> >>> +!31 = !DILocation(line: 17, column: 16, scope: !27)
> >>> +!32 = !DILocalVariable(name: "pangolin", scope: !27, file: !1, line:
> 18,
> >>> type: !12)
> >>> +!33 = !DILocation(line: 18, column: 16, scope: !27)
> >>> +!34 = !DILocation(line: 19, column: 1, scope: !27)
> >>> +!35 = distinct !DISubprogram(name: "f1", scope: !1, file: !1, line:
> 21,
> >>> type: !36, isLocal: false, isDefinition: true, scopeLine: 21,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!36 = !DISubroutineType(types: !37)
> >>> +!37 = !{!12}
> >>> +!38 = !DILocalVariable(name: "dog", scope: !35, file: !1, line: 22,
> type:
> >>> !12)
> >>> +!39 = !DILocation(line: 22, column: 16, scope: !35)
> >>> +!40 = !DILocalVariable(name: "cat", scope: !35, file: !1, line: 23,
> type:
> >>> !12)
> >>> +!41 = !DILocation(line: 23, column: 16, scope: !35)
> >>> +!42 = !DILocalVariable(name: "pangolin", scope: !35, file: !1, line:
> 24,
> >>> type: !12)
> >>> +!43 = !DILocation(line: 24, column: 16, scope: !35)
> >>> +!44 = !DILocation(line: 25, column: 7, scope: !35)
> >>> +!45 = !DILocation(line: 26, column: 10, scope: !35)
> >>> +!46 = !DILocation(line: 26, column: 3, scope: !35)
> >>> +!47 = distinct !DISubprogram(name: "f2", scope: !1, file: !1, line:
> 29,
> >>> type: !36, isLocal: false, isDefinition: true, scopeLine: 29,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!48 = !DILocalVariable(name: "dog", scope: !47, file: !1, line: 30,
> type:
> >>> !12)
> >>> +!49 = !DILocation(line: 30, column: 16, scope: !47)
> >>> +!50 = !DILocalVariable(name: "cat", scope: !47, file: !1, line: 31,
> type:
> >>> !12)
> >>> +!51 = !DILocation(line: 31, column: 16, scope: !47)
> >>> +!52 = !DILocalVariable(name: "pangolin", scope: !47, file: !1, line:
> 32,
> >>> type: !12)
> >>> +!53 = !DILocation(line: 32, column: 16, scope: !47)
> >>> +!54 = !DILocation(line: 33, column: 7, scope: !47)
> >>> +!55 = !DILocation(line: 34, column: 10, scope: !47)
> >>> +!56 = !DILocation(line: 34, column: 3, scope: !47)
> >>> +!57 = distinct !DISubprogram(name: "f3", scope: !1, file: !1, line:
> 37,
> >>> type: !36, isLocal: false, isDefinition: true, scopeLine: 37,
> isOptimized:
> >>> false, unit: !0, variables: !2)
> >>> +!58 = !DILocalVariable(name: "dog", scope: !57, file: !1, line: 38,
> type:
> >>> !12)
> >>> +!59 = !DILocation(line: 38, column: 16, scope: !57)
> >>> +!60 = !DILocalVariable(name: "cat", scope: !57, file: !1, line: 39,
> type:
> >>> !12)
> >>> +!61 = !DILocation(line: 39, column: 16, scope: !57)
> >>> +!62 = !DILocalVariable(name: "pangolin", scope: !57, file: !1, line:
> 40,
> >>> type: !12)
> >>> +!63 = !DILocation(line: 40, column: 16, scope: !57)
> >>> +!64 = !DILocation(line: 41, column: 7, scope: !57)
> >>> +!65 = !DILocation(line: 42, column: 10, scope: !57)
> >>> +!66 = !DILocation(line: 42, column: 3, scope: !57)
> >>> +!67 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line:
> 45,
> >>> type: !36, isLocal: false, isDefinition: true, scopeLine: 45, flags:
> >>> DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
> >>> +!68 = !DILocalVariable(name: "a", scope: !67, file: !1, line: 46,
> type:
> >>> !12)
> >>> +!69 = !DILocation(line: 46, column: 16, scope: !67)
> >>> +!70 = !DILocation(line: 47, column: 3, scope: !67)
> >>> +!71 = !DILocation(line: 48, column: 3, scope: !67)
> >>> +!72 = !DILocation(line: 49, column: 3, scope: !67)
> >>> +!73 = !DILocation(line: 51, column: 3, scope: !67)
> >>>
> >>>
> >>> _______________________________________________
> >>> llvm-commits mailing list
> >>> llvm-commits at lists.llvm.org
> >>> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
> >
More information about the llvm-commits
mailing list