From 9fb0025f7084db14d16fe5cbe1d799f4ee0020af Mon Sep 17 00:00:00 2001 From: Alok Kumar Sharma Date: Thu, 25 Mar 2021 16:34:57 +0530 Subject: [PATCH] [DebugInfo] Upgrade DISubragne::count to accept DIExpression also This is needed for Fortran assumed shape arrays whose dimensions are defined as, - 'count' is taken from array descriptor passed as parameter by caller, access from descriptor is defined by type DIExpression. - 'lowerBound' is defined by callee. The current alternate way represents using upperBound in place of count, where upperBound is calculated in callee in a temp variable using lowerBound and count Representation with count (DIExpression) is not only clearer as compared to upperBound (DIVariable) but it has another advantage that variable count is accessed by being parameter has better chance of survival at higher optimization level than upperBound being local variable. Reviewed By: aprantl Differential Revision: https://reviews.llvm.org/D99335 --- llvm/include/llvm/IR/DebugInfoMetadata.h | 3 +- llvm/lib/AsmParser/LLParser.cpp | 6 +-- llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp | 16 +++---- llvm/lib/IR/AsmWriter.cpp | 13 +++--- llvm/lib/IR/DebugInfoMetadata.cpp | 24 +++++++---- llvm/lib/IR/Verifier.cpp | 6 ++- .../DebugInfo/fortranSubrangeCountExpr.ll | 42 +++++++++++++++++++ .../Verifier/invalid-disubrange-count-node.ll | 2 +- 8 files changed, 79 insertions(+), 33 deletions(-) create mode 100644 llvm/test/DebugInfo/fortranSubrangeCountExpr.ll diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h index 90b77c15c658..cdadc68164ce 100644 --- a/llvm/include/llvm/IR/DebugInfoMetadata.h +++ b/llvm/include/llvm/IR/DebugInfoMetadata.h @@ -335,10 +335,9 @@ public: Metadata *getRawStride() const { return getOperand(3).get(); } - typedef PointerUnion CountType; typedef PointerUnion BoundType; - CountType getCount() const; + BoundType getCount() const; BoundType getLowerBound() const; diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index ee84424b31f6..d69ac7289fe4 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -4716,11 +4716,6 @@ bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) { Metadata *LowerBound = nullptr; Metadata *UpperBound = nullptr; Metadata *Stride = nullptr; - if (count.isMDSignedField()) - Count = ConstantAsMetadata::get(ConstantInt::getSigned( - Type::getInt64Ty(Context), count.getMDSignedValue())); - else if (count.isMDField()) - Count = count.getMDFieldValue(); auto convToMetadata = [&](MDSignedOrMDField Bound) -> Metadata * { if (Bound.isMDSignedField()) @@ -4731,6 +4726,7 @@ bool LLParser::parseDISubrange(MDNode *&Result, bool IsDistinct) { return nullptr; }; + Count = convToMetadata(count); LowerBound = convToMetadata(lowerBound); UpperBound = convToMetadata(upperBound); Stride = convToMetadata(stride); diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp index 093ab8ee0072..90484f1f6065 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp @@ -1313,9 +1313,6 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, // Count == -1 then the array is unbounded and we do not emit // DW_AT_lower_bound and DW_AT_count attributes. int64_t DefaultLowerBound = getDefaultLowerBound(); - int64_t Count = -1; - if (auto *CI = SR->getCount().dyn_cast()) - Count = CI->getSExtValue(); auto AddBoundTypeEntry = [&](dwarf::Attribute Attr, DISubrange::BoundType Bound) -> void { @@ -1329,19 +1326,18 @@ void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR, DwarfExpr.addExpression(BE); addBlock(DW_Subrange, Attr, DwarfExpr.finalize()); } else if (auto *BI = Bound.dyn_cast()) { - if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || - BI->getSExtValue() != DefaultLowerBound) + if (Attr == dwarf::DW_AT_count) { + if (BI->getSExtValue() != -1) + addUInt(DW_Subrange, Attr, None, BI->getSExtValue()); + } else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 || + BI->getSExtValue() != DefaultLowerBound) addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue()); } }; AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->getLowerBound()); - if (auto *CV = SR->getCount().dyn_cast()) { - if (auto *CountVarDIE = getDIE(CV)) - addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE); - } else if (Count != -1) - addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count); + AddBoundTypeEntry(dwarf::DW_AT_count, SR->getCount()); AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->getUpperBound()); diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp index 91f8939a8ffa..d5f8f3bdc1da 100644 --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -1889,11 +1889,14 @@ static void writeDISubrange(raw_ostream &Out, const DISubrange *N, const Module *Context) { Out << "!DISubrange("; MDFieldPrinter Printer(Out, TypePrinter, Machine, Context); - if (auto *CE = N->getCount().dyn_cast()) - Printer.printInt("count", CE->getSExtValue(), /* ShouldSkipZero */ false); - else - Printer.printMetadata("count", N->getCount().dyn_cast(), - /*ShouldSkipNull */ true); + + auto *Count = N->getRawCountNode(); + if (auto *CE = dyn_cast_or_null(Count)) { + auto *CV = cast(CE->getValue()); + Printer.printInt("count", CV->getSExtValue(), + /* ShouldSkipZero */ false); + } else + Printer.printMetadata("count", Count, /*ShouldSkipNull */ true); // A lowerBound of constant 0 should not be skipped, since it is different // from an unspecified lower bound (= nullptr). diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp index 706395239cf4..f003ec9557c7 100644 --- a/llvm/lib/IR/DebugInfoMetadata.cpp +++ b/llvm/lib/IR/DebugInfoMetadata.cpp @@ -359,17 +359,25 @@ DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DISubrange, Ops); } -DISubrange::CountType DISubrange::getCount() const { - if (!getRawCountNode()) - return CountType(); +DISubrange::BoundType DISubrange::getCount() const { + Metadata *CB = getRawCountNode(); + if (!CB) + return BoundType(); - if (auto *MD = dyn_cast(getRawCountNode())) - return CountType(cast(MD->getValue())); + assert((isa(CB) || isa(CB) || + isa(CB)) && + "Count must be signed constant or DIVariable or DIExpression"); - if (auto *DV = dyn_cast(getRawCountNode())) - return CountType(DV); + if (auto *MD = dyn_cast(CB)) + return BoundType(cast(MD->getValue())); - return CountType(); + if (auto *MD = dyn_cast(CB)) + return BoundType(MD); + + if (auto *MD = dyn_cast(CB)) + return BoundType(MD); + + return BoundType(); } DISubrange::BoundType DISubrange::getLowerBound() const { diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index 84f95f726b8e..536f80880a2f 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -922,8 +922,10 @@ void Verifier::visitDISubrange(const DISubrange &N) { "Subrange must contain count or upperBound", &N); AssertDI(!N.getRawCountNode() || !N.getRawUpperBound(), "Subrange can have any one of count or upperBound", &N); - AssertDI(!N.getRawCountNode() || N.getCount(), - "Count must either be a signed constant or a DIVariable", &N); + auto *CBound = N.getRawCountNode(); + AssertDI(!CBound || isa(CBound) || + isa(CBound) || isa(CBound), + "Count must be signed constant or DIVariable or DIExpression", &N); auto Count = N.getCount(); AssertDI(!Count || !Count.is() || Count.get()->getSExtValue() >= -1, diff --git a/llvm/test/DebugInfo/fortranSubrangeCountExpr.ll b/llvm/test/DebugInfo/fortranSubrangeCountExpr.ll new file mode 100644 index 000000000000..6c8a3f273e6a --- /dev/null +++ b/llvm/test/DebugInfo/fortranSubrangeCountExpr.ll @@ -0,0 +1,42 @@ +;; This test checks DISubrange count bound for DIExpression +; REQUIRES: x86_64-linux + +; RUN: %llc_dwarf %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s + +;; Test whether bounds are generated correctly. +; CHECK-LABEL: DW_TAG_array_type +; CHECK: DW_TAG_subrange_type +; CHECK: DW_AT_lower_bound (DW_OP_push_object_address, DW_OP_plus_uconst 0x50, DW_OP_deref) +; CHECK-NEXT: DW_AT_count (DW_OP_push_object_address, DW_OP_plus_uconst 0x58, DW_OP_deref) + +; ModuleID = 'fortsubrange.modified.strategy3check-in.ll' +source_filename = "fortsubrange.ll" + +define void @MAIN_() !dbg !5 { +L.entry: + %"arr$sd1_349" = alloca [16 x i64], align 8 + call void @llvm.dbg.declare(metadata [16 x i64]* %"arr$sd1_349", metadata !8, metadata !DIExpression()), !dbg !13 + ret void, !dbg !14 +} + +; Function Attrs: nounwind readnone speculatable willreturn +declare void @llvm.dbg.declare(metadata, metadata, metadata) + +!llvm.module.flags = !{!0, !1} +!llvm.dbg.cu = !{!2} + +!0 = !{i32 2, !"Dwarf Version", i32 4} +!1 = !{i32 2, !"Debug Info Version", i32 3} +!2 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, retainedTypes: !4, globals: !4, imports: !4) +!3 = !DIFile(filename: "fortsubrange.f90", directory: "/dir") +!4 = !{} +!5 = distinct !DISubprogram(name: "main", scope: !2, file: !3, line: 1, type: !6, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !2) +!6 = !DISubroutineType(cc: DW_CC_program, types: !7) +!7 = !{null} +!8 = !DILocalVariable(name: "arr", scope: !5, file: !3, type: !9) +!9 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, size: 32, align: 32, elements: !11) +!10 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed) +!11 = !{!12} +!12 = !DISubrange(count: !DIExpression(DW_OP_push_object_address, DW_OP_plus_uconst, 88, DW_OP_deref), lowerBound: !DIExpression(DW_OP_push_object_address, DW_OP_plus_uconst, 80, DW_OP_deref)) +!13 = !DILocation(line: 0, scope: !5) +!14 = !DILocation(line: 6, column: 1, scope: !5) diff --git a/llvm/test/Verifier/invalid-disubrange-count-node.ll b/llvm/test/Verifier/invalid-disubrange-count-node.ll index c1a2c17a1946..45dfccd636fd 100644 --- a/llvm/test/Verifier/invalid-disubrange-count-node.ll +++ b/llvm/test/Verifier/invalid-disubrange-count-node.ll @@ -33,5 +33,5 @@ declare void @llvm.dbg.declare(metadata, metadata, metadata) #1 !19 = !DILocalVariable(name: "vla", scope: !7, file: !1, line: 21, type: !20) !20 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, align: 32, elements: !21) !21 = !{!22} -; CHECK: Count must either be a signed constant or a DIVariable +; CHECK: Count must be signed constant or DIVariable or DIExpression !22 = !DISubrange(count: !17)