[llvm] r322789 - [MachineOutliner] Add DISubprograms to outlined functions.

Thu Jan 18 08:23:26 PST 2018

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

> 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
> 