From: Jeremy Morse Date: Mon, 29 Nov 2021 22:06:46 +0000 (+0000) Subject: [DebugInfo][InstrRef] Add indirection from dbg.declare in SelectionDAG X-Git-Tag: upstream/15.0.7~24562 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a20987adf4f80e2657eb3032a5a91e13f58106a0;p=platform%2Fupstream%2Fllvm.git [DebugInfo][InstrRef] Add indirection from dbg.declare in SelectionDAG Usually dbg.declares get translated into either entries in an MF side-table, or a DBG_VALUE on entry to the function with IsIndirect set (including in instruction referencing mode). Much rarer is a dbg.declare attached to a non-argument value, such as in the test added in this patch where there's a variable-length-array. Such dbg.declares become SDDbgValue nodes with InIndirect=true. As it happens, we weren't correctly emitting DBG_INSTR_REFs with the additional indirection. This patch adds the extra indirection, encoded as adding an additional DW_OP_deref to the expression. Differential Revision: https://reviews.llvm.org/D114440 --- diff --git a/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp b/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp index c1bb654..331e032 100644 --- a/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp @@ -765,7 +765,7 @@ InstrEmitter::EmitDbgInstrRef(SDDbgValue *SD, assert(!SD->isVariadic()); SDDbgOperand DbgOperand = SD->getLocationOps()[0]; MDNode *Var = SD->getVariable(); - MDNode *Expr = SD->getExpression(); + DIExpression *Expr = (DIExpression*)SD->getExpression(); DebugLoc DL = SD->getDebugLoc(); const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_INSTR_REF); @@ -775,6 +775,13 @@ InstrEmitter::EmitDbgInstrRef(SDDbgValue *SD, DbgOperand.getKind() == SDDbgOperand::CONST) return EmitDbgValueFromSingleOp(SD, VRBaseMap); + // Immediately fold any indirectness from the LLVM-IR intrinsic into the + // expression: + if (SD->isIndirect()) { + std::vector Elts = {dwarf::DW_OP_deref}; + Expr = DIExpression::append(Expr, Elts); + } + // It may not be immediately possible to identify the MachineInstr that // defines a VReg, it can depend for example on the order blocks are // emitted in. When this happens, or when further analysis is needed later, diff --git a/llvm/test/DebugInfo/X86/instr-ref-dbg-declare.ll b/llvm/test/DebugInfo/X86/instr-ref-dbg-declare.ll new file mode 100644 index 0000000..7536a71 --- /dev/null +++ b/llvm/test/DebugInfo/X86/instr-ref-dbg-declare.ll @@ -0,0 +1,112 @@ +; RUN: llc %s -stop-before=finalize-isel -o - \ +; RUN: -experimental-debug-variable-locations=true \ +; RUN: | FileCheck %s + +;; Copy of DebugInfo/COFF/types-array-advanced.ll. This features a dbg.declare +;; of something (dynamic alloca) that isn't an argument, causing a SDDbgValue +;; with the indirect flag set to be emitted. Test that it's preserved in +;; instruction referencing mode -- we don't have an IsIndirect flag on +;; DBG_INSTR_REF, so it gets encoded as an additional DW_OP_deref. +;; +;; NB: the original test has an additional spurious DW_OP_deref in the +;; dbg.declare's arguments, which is preserved here, translating to two derefs. + +; CHECK: DBG_INSTR_REF 1, 2, !{{[0-9]+}}, !DIExpression(DW_OP_deref, DW_OP_deref) + +source_filename = "test/DebugInfo/COFF/types-array-advanced.ll" +target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" +target triple = "i686-pc-windows-msvc18.0.31101" + +%struct.incomplete_struct = type { i32 } + +@"\01?multi_dim_arr@@3PAY146DA" = global [2 x [5 x [7 x i8]]] zeroinitializer, align 1, !dbg !0 +@"\01?p_incomplete_struct_arr@@3PAY02Uincomplete_struct@@A" = global [3 x i8]* null, align 4, !dbg !6 +@"\01?incomplete_struct_arr@@3PAUincomplete_struct@@A" = global [3 x %struct.incomplete_struct] zeroinitializer, align 4, !dbg !16 +@"\01?typedef_arr@@3SDHD" = constant [4 x i32] zeroinitializer, align 4, !dbg !18 + +; Function Attrs: nounwind +define void @"\01?foo@@YAXH@Z"(i32 %x) #0 !dbg !35 { +entry: + %x.addr = alloca i32, align 4 + %saved_stack = alloca i8*, align 4 + store i32 %x, i32* %x.addr, align 4 + %0 = load i32, i32* %x.addr, align 4, !dbg !41 + %1 = call i8* @llvm.stacksave(), !dbg !42 + store i8* %1, i8** %saved_stack, align 4, !dbg !42 + %vla = alloca i32, i32 %0, align 4, !dbg !42 + ;; This dbg.declare turns into a DBG_INSTR_REF, rather than an argument + ;; DBG_VALUE. It needs to keep the extra indirectness. + call void @llvm.dbg.declare(metadata i32* %vla, metadata !43, metadata !47), !dbg !48 + %arrayidx = getelementptr inbounds i32, i32* %vla, i32 0, !dbg !49 + store i32 0, i32* %arrayidx, align 4, !dbg !50 + %2 = load i8*, i8** %saved_stack, align 4, !dbg !51 + call void @llvm.stackrestore(i8* %2), !dbg !51 + ret void, !dbg !51 +} + +; Function Attrs: nounwind readnone +declare void @llvm.dbg.declare(metadata, metadata, metadata) + +; Function Attrs: nounwind +declare i8* @llvm.stacksave() + +; Function Attrs: nounwind +declare void @llvm.stackrestore(i8*) + +!llvm.dbg.cu = !{!2} +!llvm.module.flags = !{!32, !33} +!llvm.ident = !{!34} + +!0 = distinct !DIGlobalVariableExpression(var: !1, expr: !DIExpression()) +!1 = !DIGlobalVariable(name: "multi_dim_arr", linkageName: "\01?multi_dim_arr@@3PAY146DA", scope: !2, file: !3, line: 1, type: !26, isLocal: false, isDefinition: true) +!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 3.9.0 (trunk 273874)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5) +!3 = !DIFile(filename: "t.cpp", directory: "/") +!4 = !{} +!5 = !{!0, !6, !16, !18} +!6 = distinct !DIGlobalVariableExpression(var: !7, expr: !DIExpression()) +!7 = !DIGlobalVariable(name: "p_incomplete_struct_arr", linkageName: "\01?p_incomplete_struct_arr@@3PAY02Uincomplete_struct@@A", scope: !2, file: !3, line: 3, type: !8, isLocal: false, isDefinition: true) +!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 32, align: 32) +!9 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, elements: !14) +!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "incomplete_struct", file: !3, line: 4, size: 32, align: 32, elements: !11, identifier: ".?AUincomplete_struct@@") +!11 = !{!12} +!12 = !DIDerivedType(tag: DW_TAG_member, name: "s1", scope: !10, file: !3, line: 5, baseType: !13, size: 32, align: 32) +!13 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed) +!14 = !{!15} +!15 = !DISubrange(count: 3) +!16 = distinct !DIGlobalVariableExpression(var: !17, expr: !DIExpression()) +!17 = !DIGlobalVariable(name: "incomplete_struct_arr", linkageName: "\01?incomplete_struct_arr@@3PAUincomplete_struct@@A", scope: !2, file: !3, line: 6, type: !9, isLocal: false, isDefinition: true) +!18 = distinct !DIGlobalVariableExpression(var: !19, expr: !DIExpression()) +!19 = !DIGlobalVariable(name: "typedef_arr", linkageName: "\01?typedef_arr@@3SDHD", scope: !2, file: !3, line: 14, type: !20, isLocal: false, isDefinition: true) +!20 = !DICompositeType(tag: DW_TAG_array_type, baseType: !21, size: 128, align: 32, elements: !24) +!21 = !DIDerivedType(tag: DW_TAG_typedef, name: "T_INT", file: !3, line: 13, baseType: !22) +!22 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !23) +!23 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !13) +!24 = !{!25} +!25 = !DISubrange(count: 4) +!26 = !DICompositeType(tag: DW_TAG_array_type, baseType: !27, size: 560, align: 8, elements: !28) +!27 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char) +!28 = !{!29, !30, !31} +!29 = !DISubrange(count: 2) +!30 = !DISubrange(count: 5) +!31 = !DISubrange(count: 7) +!32 = !{i32 2, !"CodeView", i32 1} +!33 = !{i32 2, !"Debug Info Version", i32 3} +!34 = !{!"clang version 3.9.0 (trunk 273874)"} +!35 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAXH@Z", scope: !3, file: !3, line: 8, type: !36, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: false, unit: !2, retainedNodes: !4) +!36 = !DISubroutineType(types: !37) +!37 = !{null, !13} +!38 = !DILocalVariable(name: "x", arg: 1, scope: !35, file: !3, line: 8, type: !13) +!39 = !DIExpression() +!40 = !DILocation(line: 8, column: 14, scope: !35) +!41 = !DILocation(line: 9, column: 21, scope: !35) +!42 = !DILocation(line: 9, column: 4, scope: !35) +!43 = !DILocalVariable(name: "dyn_size_arr", scope: !35, file: !3, line: 9, type: !44) +!44 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, align: 32, elements: !45) +!45 = !{!46} +!46 = !DISubrange(count: -1) +!47 = !DIExpression(DW_OP_deref) +!48 = !DILocation(line: 9, column: 8, scope: !35) +!49 = !DILocation(line: 10, column: 4, scope: !35) +!50 = !DILocation(line: 10, column: 20, scope: !35) +!51 = !DILocation(line: 11, column: 1, scope: !35) +