diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h --- a/llvm/include/llvm/IR/DebugInfoMetadata.h +++ b/llvm/include/llvm/IR/DebugInfoMetadata.h @@ -3248,6 +3248,83 @@ } }; +/// Storage for identifying a potentially inlined instance of a variable, +/// or a fragment thereof. +class DebugVariable { + using FragmentInfo = DIExpression::FragmentInfo; + using OptFragmentInfo = Optional; + + const DILocalVariable *Variable; + OptFragmentInfo Fragment; + const DILocation *InlinedAt; + + /// Fragment that will overlap all other fragments. Used as default when + /// caller demands a fragment. + static const FragmentInfo DefaultFragment; + +public: + DebugVariable(const DILocalVariable *Var, OptFragmentInfo &&FragmentInfo, + const DILocation *InlinedAt) + : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {} + + DebugVariable(const DILocalVariable *Var, OptFragmentInfo &FragmentInfo, + const DILocation *InlinedAt) + : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {} + + DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr, + const DILocation *InlinedAt) + : DebugVariable(Var, DIExpr->getFragmentInfo(), InlinedAt) {} + + const DILocalVariable *getVar() const { return Variable; } + const OptFragmentInfo &getFragment() const { return Fragment; } + const DILocation *getInlinedAt() const { return InlinedAt; } + + const FragmentInfo getFragmentDefault() const { + return Fragment.getValueOr(DefaultFragment); + } + + static bool isFragmentDefault(const FragmentInfo &F) { + return F == DefaultFragment; + } + + bool operator==(const DebugVariable &Other) const { + return std::tie(Variable, Fragment, InlinedAt) == + std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); + } + + bool operator<(const DebugVariable &Other) const { + return std::tie(Variable, Fragment, InlinedAt) < + std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); + } +}; + +template <> struct DenseMapInfo { + using DV = DebugVariable; + using OptFragmentInfo = Optional; + using FragmentInfo = DIExpression::FragmentInfo; + + // Empty key: no key should be generated that has no DILocalVariable. + static inline DV getEmptyKey() { + return DV(nullptr, OptFragmentInfo(), nullptr); + } + + // Difference in tombstone is that the Optional is meaningful + static inline DV getTombstoneKey() { + return DV(nullptr, OptFragmentInfo({0, 0}), nullptr); + } + + static unsigned getHashValue(const DV &D) { + unsigned HV = 0; + const OptFragmentInfo &Fragment = D.getFragment(); + if (Fragment) + HV = DenseMapInfo::getHashValue(*Fragment); + + return hash_combine(D.getVar(), HV, D.getInlinedAt()); + } + + static bool isEqual(const DV &A, const DV &B) { return A == B; } +}; + } // end namespace llvm #undef DEFINE_MDNODE_GET_UNPACK_IMPL diff --git a/llvm/lib/CodeGen/LiveDebugValues.cpp b/llvm/lib/CodeGen/LiveDebugValues.cpp --- a/llvm/lib/CodeGen/LiveDebugValues.cpp +++ b/llvm/lib/CodeGen/LiveDebugValues.cpp @@ -123,60 +123,6 @@ using FragmentInfo = DIExpression::FragmentInfo; using OptFragmentInfo = Optional; - /// Storage for identifying a potentially inlined instance of a variable, - /// or a fragment thereof. - class DebugVariable { - const DILocalVariable *Variable; - OptFragmentInfo Fragment; - const DILocation *InlinedAt; - - /// Fragment that will overlap all other fragments. Used as default when - /// caller demands a fragment. - static const FragmentInfo DefaultFragment; - - public: - DebugVariable(const DILocalVariable *Var, OptFragmentInfo &&FragmentInfo, - const DILocation *InlinedAt) - : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {} - - DebugVariable(const DILocalVariable *Var, OptFragmentInfo &FragmentInfo, - const DILocation *InlinedAt) - : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {} - - DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr, - const DILocation *InlinedAt) - : DebugVariable(Var, DIExpr->getFragmentInfo(), InlinedAt) {} - - DebugVariable(const MachineInstr &MI) - : DebugVariable(MI.getDebugVariable(), - MI.getDebugExpression()->getFragmentInfo(), - MI.getDebugLoc()->getInlinedAt()) {} - - const DILocalVariable *getVar() const { return Variable; } - const OptFragmentInfo &getFragment() const { return Fragment; } - const DILocation *getInlinedAt() const { return InlinedAt; } - - const FragmentInfo getFragmentDefault() const { - return Fragment.getValueOr(DefaultFragment); - } - - static bool isFragmentDefault(FragmentInfo &F) { - return F == DefaultFragment; - } - - bool operator==(const DebugVariable &Other) const { - return std::tie(Variable, Fragment, InlinedAt) == - std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); - } - - bool operator<(const DebugVariable &Other) const { - return std::tie(Variable, Fragment, InlinedAt) < - std::tie(Other.Variable, Other.Fragment, Other.InlinedAt); - } - }; - - friend struct llvm::DenseMapInfo; - /// A pair of debug variable and value location. struct VarLoc { // The location at which a spilled variable resides. It consists of a @@ -221,8 +167,9 @@ VarLoc(const MachineInstr &MI, LexicalScopes &LS, VarLocKind K = InvalidKind) - : Var(MI), Expr(MI.getDebugExpression()), MI(MI), - UVS(MI.getDebugLoc(), LS) { + : Var(MI.getDebugVariable(), MI.getDebugExpression(), + MI.getDebugLoc()->getInlinedAt()), + Expr(MI.getDebugExpression()), MI(MI), UVS(MI.getDebugLoc(), LS) { static_assert((sizeof(Loc) == sizeof(uint64_t)), "hash does not cover all members of Loc"); assert(MI.isDebugValue() && "not a DBG_VALUE"); @@ -247,8 +194,9 @@ /// The constructor for spill locations. VarLoc(const MachineInstr &MI, unsigned SpillBase, int SpillOffset, LexicalScopes &LS, const MachineInstr &OrigMI) - : Var(MI), Expr(MI.getDebugExpression()), MI(OrigMI), - UVS(MI.getDebugLoc(), LS) { + : Var(MI.getDebugVariable(), MI.getDebugExpression(), + MI.getDebugLoc()->getInlinedAt()), + Expr(MI.getDebugExpression()), MI(OrigMI), UVS(MI.getDebugLoc(), LS) { assert(MI.isDebugValue() && "not a DBG_VALUE"); assert(MI.getNumOperands() == 4 && "malformed DBG_VALUE"); Kind = SpillLocKind; @@ -449,46 +397,10 @@ } // end anonymous namespace -namespace llvm { - -template <> struct DenseMapInfo { - using DV = LiveDebugValues::DebugVariable; - using OptFragmentInfo = LiveDebugValues::OptFragmentInfo; - using FragmentInfo = LiveDebugValues::FragmentInfo; - - // Empty key: no key should be generated that has no DILocalVariable. - static inline DV getEmptyKey() { - return DV(nullptr, OptFragmentInfo(), nullptr); - } - - // Difference in tombstone is that the Optional is meaningful - static inline DV getTombstoneKey() { - return DV(nullptr, OptFragmentInfo({0, 0}), nullptr); - } - - static unsigned getHashValue(const DV &D) { - unsigned HV = 0; - const OptFragmentInfo &Fragment = D.getFragment(); - if (Fragment) - HV = DenseMapInfo::getHashValue(*Fragment); - - return hash_combine(D.getVar(), HV, D.getInlinedAt()); - } - - static bool isEqual(const DV &A, const DV &B) { return A == B; } -}; - -} // namespace llvm - //===----------------------------------------------------------------------===// // Implementation //===----------------------------------------------------------------------===// -const DIExpression::FragmentInfo - LiveDebugValues::DebugVariable::DefaultFragment = { - std::numeric_limits::max(), - std::numeric_limits::min()}; - char LiveDebugValues::ID = 0; char &llvm::LiveDebugValuesID = LiveDebugValues::ID; @@ -674,7 +586,9 @@ unsigned LocId = VarLocIDs.insert(VL); // Close this variable's previous location range. - DebugVariable V(*DebugInstr); + DebugVariable V(DebugInstr->getDebugVariable(), + DebugInstr->getDebugExpression(), + DebugInstr->getDebugLoc()->getInlinedAt()); OpenRanges.erase(V); OpenRanges.insert(LocId, VL.Var); @@ -1018,7 +932,8 @@ void LiveDebugValues::accumulateFragmentMap(MachineInstr &MI, VarToFragments &SeenFragments, OverlapMap &OverlappingFragments) { - DebugVariable MIVar(MI); + DebugVariable MIVar(MI.getDebugVariable(), MI.getDebugExpression(), + MI.getDebugLoc()->getInlinedAt()); FragmentInfo ThisFragment = MIVar.getFragmentDefault(); // If this is the first sighting of this variable, then we are guaranteed diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp --- a/llvm/lib/IR/DebugInfoMetadata.cpp +++ b/llvm/lib/IR/DebugInfoMetadata.cpp @@ -23,6 +23,9 @@ using namespace llvm; +const DIExpression::FragmentInfo DebugVariable::DefaultFragment = { + std::numeric_limits::max(), std::numeric_limits::min()}; + DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, unsigned Column, ArrayRef MDs, bool ImplicitCode) diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp --- a/llvm/lib/Transforms/Utils/Local.cpp +++ b/llvm/lib/Transforms/Utils/Local.cpp @@ -1040,6 +1040,18 @@ assert(PN->use_empty() && "There shouldn't be any uses here!"); PN->eraseFromParent(); } + // If Succ has multiple predecessors, each debug intrinsic in BB may or may + // not be valid when we reach Succ, so the debug variable should be set + // undef since its value is unknown. + for (auto DI = BB->begin(); isa(DI); ++DI) + if (auto DVI = cast(DI)) { + Value *V = DVI->getVariableLocation(); + DVI->setArgOperand( + 0, MetadataAsValue::get( + DVI->getContext(), + ValueAsMetadata::get(UndefValue::get(V->getType())))); + DVI->moveBefore(Succ->getFirstNonPHI()); + } } // If the unconditional branch we replaced contains llvm.loop metadata, we diff --git a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp --- a/llvm/lib/Transforms/Utils/SimplifyCFG.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyCFG.cpp @@ -13,6 +13,7 @@ #include "llvm/ADT/APInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/MapVector.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SetOperations.h" @@ -37,6 +38,7 @@ #include "llvm/IR/ConstantRange.h" #include "llvm/IR/Constants.h" #include "llvm/IR/DataLayout.h" +#include "llvm/IR/DebugInfoMetadata.h" #include "llvm/IR/DerivedTypes.h" #include "llvm/IR/Function.h" #include "llvm/IR/GlobalValue.h" @@ -1247,14 +1249,40 @@ Instruction *I1 = &*BB1_Itr++, *I2 = &*BB2_Itr++; // Skip debug info if it is not identical. - DbgInfoIntrinsic *DBI1 = dyn_cast(I1); - DbgInfoIntrinsic *DBI2 = dyn_cast(I2); - if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { - while (isa(I1)) - I1 = &*BB1_Itr++; - while (isa(I2)) - I2 = &*BB2_Itr++; - } + + // If the terminator instruction is hoisted, and any variable locations have + // non-identical debug intrinsics, then those variable locations must be set + // as undef. + // FIXME: If each block contains identical debug variable intrinsics in a + // different order, they will be considered non-identical and be dropped. + MapVector UndefDVIs; + + auto SkipNonIdenticalDbgInfo = + [&BB1_Itr, &BB2_Itr, &UndefDVIs](Instruction *&I1, Instruction *&I2) { + DbgInfoIntrinsic *DBI1 = dyn_cast(I1); + DbgInfoIntrinsic *DBI2 = dyn_cast(I2); + if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { + while (isa(I1)) { + if (DbgVariableIntrinsic *DVI = dyn_cast(I1)) + UndefDVIs.insert( + {DebugVariable(DVI->getVariable(), DVI->getExpression(), + DVI->getDebugLoc()->getInlinedAt()), + DVI}); + I1 = &*BB1_Itr++; + } + while (isa(I2)) { + if (DbgVariableIntrinsic *DVI = dyn_cast(I2)) + UndefDVIs.insert( + {DebugVariable(DVI->getVariable(), DVI->getExpression(), + DVI->getDebugLoc()->getInlinedAt()), + DVI}); + I2 = &*BB2_Itr++; + } + } + }; + + SkipNonIdenticalDbgInfo(I1, I2); + // FIXME: Can we define a safety predicate for CallBr? if (isa(I1) || !I1->isIdenticalToWhenDefined(I2) || (isa(I1) && !isSafeToHoistInvoke(BB1, BB2, I1, I2)) || @@ -1327,15 +1355,7 @@ I1 = &*BB1_Itr++; I2 = &*BB2_Itr++; - // Skip debug info if it is not identical. - DbgInfoIntrinsic *DBI1 = dyn_cast(I1); - DbgInfoIntrinsic *DBI2 = dyn_cast(I2); - if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) { - while (isa(I1)) - I1 = &*BB1_Itr++; - while (isa(I2)) - I2 = &*BB2_Itr++; - } + SkipNonIdenticalDbgInfo(I1, I2); } while (I1->isIdenticalToWhenDefined(I2)); return true; @@ -1371,6 +1391,17 @@ } // Okay, it is safe to hoist the terminator. + for (auto DIVariableInst : UndefDVIs) { + DbgVariableIntrinsic *DVI = DIVariableInst.second; + DVI->moveBefore(BI); + if (Value *V = DVI->getVariableLocation()) { + DVI->setArgOperand( + 0, MetadataAsValue::get( + DVI->getContext(), + ValueAsMetadata::get(UndefValue::get(V->getType())))); + } + } + Instruction *NT = I1->clone(); BIParent->getInstList().insert(BI->getIterator(), NT); if (!NT->getType()->isVoidTy()) { diff --git a/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-else.ll b/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-else.ll new file mode 100644 --- /dev/null +++ b/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-else.ll @@ -0,0 +1,67 @@ +; RUN: opt -simplifycfg -S < %s | FileCheck %s +; Checks that when the if.then and if.else blocks are both eliminated by +; SimplifyCFG, as the common code is hoisted out, the variables with a +; dbg.value in either of those blocks are set undef just before the +; conditional branch instruction. + +define i32 @"?fn@@YAHH@Z"(i32 %foo) !dbg !8 { +; CHECK-LABEL: entry: +entry: + call void @llvm.dbg.value(metadata i32 %foo, metadata !13, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 0, metadata !14, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 0, metadata !15, metadata !DIExpression()), !dbg !16 + %cmp = icmp eq i32 %foo, 4, !dbg !17 +; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[BEARDS:![0-9]+]] +; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[BIRDS:![0-9]+]] + br i1 %cmp, label %if.then, label %if.else, !dbg !17 + +if.then: ; preds = %entry + call void @llvm.dbg.value(metadata i32 8, metadata !14, metadata !DIExpression()), !dbg !16 + br label %if.end, !dbg !18 + +if.else: ; preds = %entry + call void @llvm.dbg.value(metadata i32 4, metadata !14, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 8, metadata !15, metadata !DIExpression()), !dbg !16 + br label %if.end, !dbg !21 + +if.end: ; preds = %if.else, %if.then + %beards.0 = phi i32 [ 8, %if.then ], [ 4, %if.else ], !dbg !23 + call void @llvm.dbg.value(metadata i32 %beards.0, metadata !14, metadata !DIExpression()), !dbg !16 + ret i32 %beards.0, !dbg !24 +} + +declare void @llvm.dbg.value(metadata, metadata, metadata) + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!3, !4, !5, !6} +!llvm.ident = !{!7} + +; CHECK-LABEL: } +; CHECK: [[BEARDS]] = !DILocalVariable(name: "beards" +; CHECK: [[BIRDS]] = !DILocalVariable(name: "birds" + +!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 10.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None) +!1 = !DIFile(filename: "test.cpp", directory: "C:\5Cdev\5Cllvm-project", checksumkind: CSK_MD5, checksum: "64604a72fdf5b6db8aa2328236bedd6b") +!2 = !{} +!3 = !{i32 2, !"CodeView", i32 1} +!4 = !{i32 2, !"Debug Info Version", i32 3} +!5 = !{i32 1, !"wchar_size", i32 2} +!6 = !{i32 7, !"PIC Level", i32 2} +!7 = !{!"clang version 10.0.0 "} +!8 = distinct !DISubprogram(name: "fn", linkageName: "?fn@@YAHH@Z", scope: !1, file: !1, line: 1, type: !9, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) +!12 = !{!13, !14, !15} +!13 = !DILocalVariable(name: "foo", arg: 1, scope: !8, file: !1, line: 1, type: !11) +!14 = !DILocalVariable(name: "beards", scope: !8, file: !1, line: 2, type: !11) +!15 = !DILocalVariable(name: "birds", scope: !8, file: !1, line: 3, type: !11) +!16 = !DILocation(line: 0, scope: !8) +!17 = !DILocation(line: 5, scope: !8) +!18 = !DILocation(line: 8, scope: !19) +!19 = distinct !DILexicalBlock(scope: !20, file: !1, line: 5) +!20 = distinct !DILexicalBlock(scope: !8, file: !1, line: 5) +!21 = !DILocation(line: 11, scope: !22) +!22 = distinct !DILexicalBlock(scope: !20, file: !1, line: 8) +!23 = !DILocation(line: 0, scope: !20) +!24 = !DILocation(line: 13, scope: !8) diff --git a/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-empty.ll b/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-empty.ll new file mode 100644 --- /dev/null +++ b/llvm/test/Transforms/SimplifyCFG/hoist-dbgvalue-empty.ll @@ -0,0 +1,72 @@ +; RUN: opt -simplifycfg -S < %s | FileCheck %s +; Checks that when the if.then block is eliminated due to containing no +; instructions, the debug intrinsics are hoisted out of the block before its +; deletion. The hoisted intrinsics should have undef values as the branch +; behaviour is unknown to the intrinsics after hoisting. + +define dso_local i32 @"?fn@@YAHH@Z"(i32 %foo) local_unnamed_addr #0 !dbg !8 { +; CHECK-LABEL: entry: +entry: + call void @llvm.dbg.value(metadata i32 %foo, metadata !13, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 0, metadata !14, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 0, metadata !15, metadata !DIExpression()), !dbg !16 + %cmp = icmp eq i32 %foo, 4, !dbg !17 +; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[BEARDS:![0-9]+]] +; CHECK: call void @llvm.dbg.value(metadata i32 undef, metadata [[BIRDS:![0-9]+]] + br i1 %cmp, label %if.then, label %if.else, !dbg !17 +; CHECK-LABEL: if.else: + +if.then: ; preds = %entry + call void @llvm.dbg.value(metadata i32 8, metadata !14, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 3, metadata !15, metadata !DIExpression()), !dbg !16 + br label %if.end, !dbg !18 + +if.else: ; preds = %entry + call void @"?side@@YAXXZ"(), !dbg !21 + call void @llvm.dbg.value(metadata i32 4, metadata !14, metadata !DIExpression()), !dbg !16 + call void @llvm.dbg.value(metadata i32 6, metadata !15, metadata !DIExpression()), !dbg !16 + br label %if.end, !dbg !23 + +if.end: ; preds = %if.else, %if.then + %beards.0 = phi i32 [ 8, %if.then ], [ 4, %if.else ], !dbg !24 + call void @llvm.dbg.value(metadata i32 %beards.0, metadata !14, metadata !DIExpression()), !dbg !16 + ret i32 %beards.0, !dbg !25 +} + +declare dso_local void @"?side@@YAXXZ"() local_unnamed_addr + +declare void @llvm.dbg.value(metadata, metadata, metadata) + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!3, !4, !5, !6} +!llvm.ident = !{!7} + +; CHECK: [[BEARDS]] = !DILocalVariable(name: "beards" +; CHECK: [[BIRDS]] = !DILocalVariable(name: "birds" + +!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !1, producer: "clang version 10.0.0 ", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None) +!1 = !DIFile(filename: "test2.cpp", directory: "C:\5Cdev\5Cllvm-project", checksumkind: CSK_MD5, checksum: "8ac5d40fcc9914d6479c1a770dfdc176") +!2 = !{} +!3 = !{i32 2, !"CodeView", i32 1} +!4 = !{i32 2, !"Debug Info Version", i32 3} +!5 = !{i32 1, !"wchar_size", i32 2} +!6 = !{i32 7, !"PIC Level", i32 2} +!7 = !{!"clang version 10.0.0 "} +!8 = distinct !DISubprogram(name: "fn", linkageName: "?fn@@YAHH@Z", scope: !1, file: !1, line: 3, type: !9, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed) +!12 = !{!13, !14, !15} +!13 = !DILocalVariable(name: "foo", arg: 1, scope: !8, file: !1, line: 3, type: !11) +!14 = !DILocalVariable(name: "beards", scope: !8, file: !1, line: 4, type: !11) +!15 = !DILocalVariable(name: "birds", scope: !8, file: !1, line: 5, type: !11) +!16 = !DILocation(line: 0, scope: !8) +!17 = !DILocation(line: 7, scope: !8) +!18 = !DILocation(line: 10, scope: !19) +!19 = distinct !DILexicalBlock(scope: !20, file: !1, line: 7) +!20 = distinct !DILexicalBlock(scope: !8, file: !1, line: 7) +!21 = !DILocation(line: 11, scope: !22) +!22 = distinct !DILexicalBlock(scope: !20, file: !1, line: 10) +!23 = !DILocation(line: 14, scope: !22) +!24 = !DILocation(line: 0, scope: !20) +!25 = !DILocation(line: 16, scope: !8)