[llvm] r322789 - [MachineOutliner] Add DISubprograms to outlined functions.
Jessica Paquette via llvm-commits
llvm-commits at lists.llvm.org
Thu Jan 18 09:03:53 PST 2018
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
>>>
>
More information about the llvm-commits
mailing list