[llvm] r322789 - [MachineOutliner] Add DISubprograms to outlined functions.
David Blaikie via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 18 09:08:15 PST 2018
I'm not sure why we'd ever need to create a new CU.
Outlining, if I understand it - is the act of taking a chunk of a function
and pulling it out into a new function? (because, say, it's cold) - or can
this optimization also do commoning between functions? (finding that two
functions have some chunk that's the same)
In the first case, even if there are multiple CUs, seems reasonable to use
the CU of the original function, if any. (if the original function had no
debug info, neither should the new function)
If an outlined section of code has been commoned from a bunch of other
functions, yeah, that's trickier... - I'm still not sure I'd want to
introduce a new CU for it (that'd get pretty messy when it comes to things
like Fission/split DWARF, for example - which only really supports one CU
(& we just barely slip by in ThinLTO with this for reasons I can go into if
anyone's curious)).
I'd be more inclined to pick a CU from any of the subprograms that the code
was outlined from.
On Thu, Jan 18, 2018 at 9:03 AM Jessica Paquette <jpaquette at apple.com>
wrote:
> Extending DIBuilder sounds good to me.
>
> If I understand correctly, what we’re talking about here is
>
> 1. Check if the module contains more than one CU
> 2. If true, then create a new CU for the outlined functions
> 3. If false, then use the existing CU
>
> This is pretty doable in the outliner. The only thing I can see that’d
> have to change is the modification to DIBuillder.
>
> - Jessica
>
>
> > On Jan 18, 2018, at 8:45 AM, Robinson, Paul <paul.robinson at sony.com>
> wrote:
> >
> >
> >
> >> -----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
> >>>
> >
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20180118/ee6dc2af/attachment.html>
More information about the llvm-commits
mailing list