57539418ba
Fixes issue #61981 by adjusting variable location offsets (in the DIExpression) when splitting allocas. Patch [4/4] to fix structured bindings in SROA. NOTE: There's still a bug in mem2reg which generates incorrect locations in some situations: if the variable fragment has an offset into the new (split) alloca, mem2reg will fail to convert that into a bit shift (the location contains a garbage offset). That's not addressed here. insertNewDbgInst - Now takes the address-expression and FragmentInfo as separate parameters because unlike dbg_declares dbg_assigns want those to go to different places. dbg_assign records put the variable fragment info in the value expression only (whereas dbg_declare has only one expression so puts it there - ideally this information wouldn't live in DIExpression, but that's another issue). MigrateOne - Modified to correctly compute the necessary offsets and fragment adjustments. The previous implementation produced bogus locations for variables with non-zero offsets. The changes replace most of the body of this lambda, so it might be easier to review in a split-diff view and focus on the change as a whole than to compare it to the old implementation. This uses calculateFragmentIntersect and extractLeadingOffset added in previous patches in this series, and createOrReplaceFragment described below. createOrReplaceFragment - Similar to DIExpression::createFragmentExpression except for 3 important distinctions: 1. The new fragment isn't relative to an existing fragment. 2. There are no checks on the the operation types because it is assumed the location this expression is computing is not implicit (i.e., it's always safe to create a fragment because arithmetic operations apply to the address computation, not to an implicit value computation). 3. Existing extract_bits are modified independetly of fragment changes using \p BitExtractOffset. A change to the fragment offset or size may affect a bit extract. But a bit extract offset can change independently of the fragment dimensions. Returns the new expression, or nullptr if one couldn't be created. Ideally this is only used to signal that a bit-extract has become zero-sized (and thus the new debug record has no size and can be dropped), however, it fails for other reasons too - see the FIXME below. FIXME: To keep the scope of this change focused on non-bitfield structured bindings the function bails in situations that DIExpression::createFragmentExpression fails. E.g. when fragment and bit extract sizes differ. These limitations can be removed in the future.
276 lines
16 KiB
LLVM
276 lines
16 KiB
LLVM
; RUN: opt %s -passes=sroa -S | FileCheck %s --check-prefixes=COMMON,OLD
|
|
; RUN: opt %s -passes=declare-to-assign,sroa -S | FileCheck %s --check-prefixes=COMMON,NEW
|
|
|
|
;; C++17 source:
|
|
;; struct two { int a, b; } gt;
|
|
;; int fun1() {
|
|
;; auto [x, y] = gt;
|
|
;; return x + y;
|
|
;; }
|
|
;;
|
|
;; struct four { two a, b; } gf;
|
|
;; int fun2() {
|
|
;; auto [x, y] = gf;
|
|
;; return x.a + y.b;
|
|
;; }
|
|
;; Plus some hand-written IR.
|
|
;;
|
|
;; Check that SROA understands how to split dbg.declares and dbg.assigns with
|
|
;; offsets into their storge (e.g., the second variable in a structured binding
|
|
;; is stored at an offset into the shared alloca).
|
|
;;
|
|
;; Additional notes:
|
|
;; We expect the same dbg.value intrinsics to come out of SROA whether assignment
|
|
;; tracking is enabled or not. However, the order of the debug intrinsics may
|
|
;; differ, and assignment tracking replaces some dbg.declares with dbg.assigns.
|
|
;;
|
|
;; Structured bindings produce an artificial variable that covers the entire
|
|
;; alloca. Although they add clutter to the test, they've been preserved in
|
|
;; order to increase coverage. These use the placehold name 'A' in comments and
|
|
;; checks.
|
|
|
|
%struct.two = type { i32, i32 }
|
|
%struct.four = type { %struct.two, %struct.two }
|
|
|
|
@gt = dso_local global %struct.two zeroinitializer, align 4, !dbg !0
|
|
@gf = dso_local global %struct.four zeroinitializer, align 4, !dbg !5
|
|
|
|
|
|
; COMMON-LABEL: @_Z4fun1v
|
|
; COMMON-NEXT: entry
|
|
;; 32 bit variable x (!27): value a_reg.
|
|
;;
|
|
;; 32 bit variable y (!28): value b_reg.
|
|
;;
|
|
;; 64 bit variable A (!29) bits [0, 32): value a_reg.
|
|
;; 64 bit variable A (!29) bits [32, 64): value b_reg.
|
|
|
|
; OLD-NEXT: %[[a_reg:.*]] = load i32, ptr @gt
|
|
; OLD-NEXT: #dbg_value(i32 %[[a_reg]], ![[x0:[0-9]+]], !DIExpression(),
|
|
; OLD-NEXT: #dbg_value(i32 %[[a_reg]], ![[A0:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
; OLD-NEXT: %[[b_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gt, i64 4)
|
|
; OLD-NEXT: #dbg_value(i32 %[[b_reg]], ![[y0:[0-9]+]], !DIExpression(),
|
|
; OLD-NEXT: #dbg_value(i32 %[[b_reg]], ![[A0]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
|
|
|
|
; NEW-NEXT: %[[a_reg:.*]] = load i32, ptr @gt
|
|
; NEW-NEXT: %[[b_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gt, i64 4)
|
|
; NEW-NEXT: #dbg_value(i32 %[[b_reg]], ![[y0:[0-9]+]], !DIExpression(),
|
|
; NEW-NEXT: #dbg_value(i32 %[[a_reg]], ![[A0:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
; NEW-NEXT: #dbg_value(i32 %[[b_reg]], ![[A0]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
|
|
; NEW-NEXT: #dbg_value(i32 %[[a_reg]], ![[x0:[0-9]+]], !DIExpression(),
|
|
define dso_local noundef i32 @_Z4fun1v() #0 !dbg !23 {
|
|
entry:
|
|
%0 = alloca %struct.two, align 4
|
|
#dbg_declare(ptr %0, !27, !DIExpression(), !31)
|
|
#dbg_declare(ptr %0, !28, !DIExpression(DW_OP_plus_uconst, 4), !31)
|
|
#dbg_declare(ptr %0, !29, !DIExpression(), !31)
|
|
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gt, i64 8, i1 false), !dbg !31
|
|
%a = getelementptr inbounds %struct.two, ptr %0, i32 0, i32 0, !dbg !31
|
|
%1 = load i32, ptr %a, align 4, !dbg !31
|
|
%b = getelementptr inbounds %struct.two, ptr %0, i32 0, i32 1, !dbg !31
|
|
%2 = load i32, ptr %b, align 4, !dbg !31
|
|
%add = add nsw i32 %1, %2, !dbg !31
|
|
ret i32 %add, !dbg !31
|
|
}
|
|
|
|
; COMMON-LABEL: _Z4fun2v()
|
|
; COMMON-NEXT: entry:
|
|
;; 64 bit variable x (!50) bits [0, 32): value aa_reg.
|
|
;; 64 bit variable x (!50) bits [32, 64): deref ab_ba_addr
|
|
;;
|
|
;; 64 bit variable y (!51) bits [0, 32): deref ab_ba_addr + 32
|
|
;; 64 bit variable y (!51) bits [32, 64): value bb_reg.
|
|
;;
|
|
;; 128 bit variable A (!52) bits [0, 32): value aa_reg
|
|
;; 128 bit variable A (!52) bits [32, 64): deref ab_ba_addr
|
|
;; 128 bit variable A (!52) bits [96, 128): value bb_reg
|
|
;;
|
|
;; NOTE: This 8 byte alloca contains x.b (4 bytes) and y.a (4 bytes).
|
|
; COMMON-NEXT: %[[ab_ba_addr:.*]] = alloca [8 x i8], align 4
|
|
; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[A1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 64),
|
|
; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[y1:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_LLVM_fragment, 0, 32),
|
|
; OLD-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[x1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
|
|
; OLD-NEXT: %[[aa_reg:.*]] = load i32, ptr @gf, align 4
|
|
; OLD-NEXT: #dbg_value(i32 %[[aa_reg]], ![[x1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
; OLD-NEXT: #dbg_value(i32 %[[aa_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
; OLD-NEXT: call void @llvm.memcpy{{.*}}(ptr align 4 %[[ab_ba_addr]], ptr align 4 getelementptr inbounds (i8, ptr @gf, i64 4), i64 8, i1 false)
|
|
; OLD-NEXT: %[[bb_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 12), align 4
|
|
; OLD-NEXT: #dbg_value(i32 %[[bb_reg]], ![[y1]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
|
|
; OLD-NEXT: #dbg_value(i32 %[[bb_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 96, 32),
|
|
|
|
; NEW-NEXT: #dbg_assign(i1 undef, ![[x1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32), ![[#]], ptr %[[ab_ba_addr]], !DIExpression(),
|
|
; NEW-NEXT: #dbg_assign(i1 undef, ![[A1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 64), ![[#]], ptr %[[ab_ba_addr]], !DIExpression(),
|
|
; NEW-NEXT: #dbg_declare(ptr %[[ab_ba_addr]], ![[y1:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 4, DW_OP_LLVM_fragment, 0, 32),
|
|
; NEW-NEXT: %[[aa_reg:.*]] = load i32, ptr @gf, align 4
|
|
; NEW-NEXT: llvm.memcpy{{.*}}(ptr align 4 %[[ab_ba_addr]], ptr align 4 getelementptr inbounds (i8, ptr @gf, i64 4), i64 8, i1 false){{.*}}, !DIAssignID ![[ID:[0-9]+]]
|
|
; NEW-NEXT: %[[bb_reg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 12), align 4
|
|
; NEW-NEXT: #dbg_value(i32 %[[bb_reg]], ![[y1:[0-9]+]], !DIExpression(DW_OP_LLVM_fragment, 32, 32),
|
|
; NEW-NEXT: #dbg_value(i32 %[[aa_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
; NEW-NEXT: #dbg_assign(i1 undef, ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 32, 64), ![[ID]], ptr %[[ab_ba_addr]], !DIExpression(),
|
|
; NEW-NEXT: #dbg_value(i32 %[[bb_reg]], ![[A1]], !DIExpression(DW_OP_LLVM_fragment, 96, 32),
|
|
; NEW-NEXT: #dbg_value(i32 %[[aa_reg]], ![[x1]], !DIExpression(DW_OP_LLVM_fragment, 0, 32),
|
|
define dso_local noundef i32 @_Z4fun2v() #0 !dbg !48 {
|
|
entry:
|
|
%0 = alloca %struct.four, align 4
|
|
#dbg_declare(ptr %0, !50, !DIExpression(), !54)
|
|
#dbg_declare(ptr %0, !51, !DIExpression(DW_OP_plus_uconst, 8), !54)
|
|
#dbg_declare(ptr %0, !52, !DIExpression(), !54)
|
|
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gf, i64 16, i1 false), !dbg !54
|
|
%a = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 0, !dbg !54
|
|
%a1 = getelementptr inbounds %struct.two, ptr %a, i32 0, i32 0, !dbg !54
|
|
%1 = load i32, ptr %a1, align 4, !dbg !54
|
|
%b = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 1, !dbg !54
|
|
%b2 = getelementptr inbounds %struct.two, ptr %b, i32 0, i32 1, !dbg !54
|
|
%2 = load i32, ptr %b2, align 4, !dbg !54
|
|
%add = add nsw i32 %1, %2, !dbg !54
|
|
ret i32 %add, !dbg !54
|
|
}
|
|
|
|
;; Hand-written part to test what happens when variables are smaller than the
|
|
;; new alloca slices (i.e., check offset rewriting works correctly). Note that
|
|
;; mem2reg incorrectly preserves the offest in the DIExpression of a variable
|
|
;; stuffed into the upper bits of a value (that is a bug), e.g. alloca+offset
|
|
;; becomes vreg+offest. It should either convert the offest to a shift, encode
|
|
;; the register-bit offest using DW_OP_bit_piece, or use the new
|
|
;; DW_OP_LLVM_extract_bits_[sz]ext operation.
|
|
; COMMON-LABEL: _Z4fun3v()
|
|
; COMMON-NEXT: entry:
|
|
;; 16 bit variable e (!61): value ve (upper bits)
|
|
;;
|
|
;; 16 bit variable f (!62): value vgf (lower bits)
|
|
;; 16 bit variable g (!63): value vgf (upper bits)
|
|
;;
|
|
;; 16 bit variable h (!64): deref dead_64_128
|
|
; COMMON-NEXT: %[[dead_64_128:.*]] = alloca %struct.two
|
|
; COMMON-NEXT: #dbg_declare(ptr %[[dead_64_128]], ![[h:[0-9]+]], !DIExpression(),
|
|
; COMMON-NEXT: %[[ve:.*]] = load i32, ptr @gf
|
|
;; FIXME: mem2reg bug - offset is incorrect - see comment above.
|
|
; COMMON-NEXT: #dbg_value(i32 %[[ve]], ![[e:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 2),
|
|
; COMMON-NEXT: %[[vfg:.*]] = load i32, ptr getelementptr inbounds (i8, ptr @gf, i64 4)
|
|
; COMMON-NEXT: #dbg_value(i32 %[[vfg]], ![[f:[0-9]+]], !DIExpression(),
|
|
;; FIXME: mem2reg bug - offset is incorrect - see comment above.
|
|
; COMMON-NEXT: #dbg_value(i32 %[[vfg]], ![[g:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 2),
|
|
define dso_local noundef i32 @_Z4fun3v() #0 !dbg !55 {
|
|
entry:
|
|
%0 = alloca %struct.four, align 4
|
|
#dbg_declare(ptr %0, !61, !DIExpression(DW_OP_plus_uconst, 2), !58)
|
|
#dbg_declare(ptr %0, !62, !DIExpression(DW_OP_plus_uconst, 4), !58)
|
|
#dbg_declare(ptr %0, !63, !DIExpression(DW_OP_plus_uconst, 6), !58)
|
|
#dbg_declare(ptr %0, !64, !DIExpression(DW_OP_plus_uconst, 8), !58)
|
|
call void @llvm.memcpy.p0.p0.i64(ptr align 4 %0, ptr align 4 @gf, i64 16, i1 false), !dbg !58
|
|
%1 = getelementptr inbounds %struct.four, ptr %0, i32 0, i32 0, !dbg !58
|
|
%2 = getelementptr inbounds %struct.two, ptr %1, i32 0, i32 1, !dbg !58
|
|
%3 = load i32, ptr %2, align 4, !dbg !58
|
|
ret i32 %3, !dbg !58
|
|
}
|
|
|
|
;; Check that DW_OP_extract_bits_[sz]ext compose with expression offsets and
|
|
;; that new fragments are not created. DW_OP_extract_bits_[sz]ext and fragments
|
|
;; don't compose currently (but could). There are checks that expressions with
|
|
;; bit extracts and fragments are dropped in SROA the test
|
|
;; in llvm/test/DebugInfo/Generic/sroa-extract-bits.ll. FIXME: Don't do that.
|
|
;;
|
|
;; Checks are inline for this one.
|
|
;;
|
|
;; %p alloca is 128 bits
|
|
;; SROA is going to split it in half, discard the lower bits, then split
|
|
;; the upper bits in half and discard the upper bits leaving us with
|
|
;; bits [64, 96) of the original alloca.
|
|
;;
|
|
; COMMON-LABEL: fun4
|
|
define dso_local noundef i32 @fun4(i64 %0) !dbg !65 {
|
|
entry:
|
|
%p = alloca [2 x i64]
|
|
%1 = getelementptr inbounds [2 x i64], ptr %p, i32 0, i32 1
|
|
store i64 %0, ptr %1
|
|
; COMMON: %p.sroa.0.8.extract.trunc = trunc i64 %0 to i32
|
|
;; Simple case - the expression offset (8 bytes) matches the offset of the
|
|
;; slice into the alloca, so can be discarded away entirely.
|
|
; COMMON-NEXT: #dbg_value(i32 %p.sroa.0.8.extract.trunc, ![[p:[0-9]+]], !DIExpression(DW_OP_LLVM_extract_bits_zext, 0, 32)
|
|
#dbg_declare(ptr %p, !67, !DIExpression(DW_OP_plus_uconst, 8, DW_OP_LLVM_extract_bits_zext, 0, 32), !66)
|
|
;; The expression offset is 6 bytes, with a bit-extract offset of 32 bits from
|
|
;; there for a total offset of 80 bits. SROA is going to split the alloca in
|
|
;; half (at bit 64). The new expression needs a final bit extract offset of
|
|
;; 80-64=16 bits applied to the mem2reg'd value.
|
|
; COMMON-NEXT: #dbg_value(i32 %p.sroa.0.8.extract.trunc, ![[q:[0-9]+]], !DIExpression(DW_OP_LLVM_extract_bits_zext, 16, 8)
|
|
#dbg_declare(ptr %p, !68, !DIExpression(DW_OP_plus_uconst, 6, DW_OP_LLVM_extract_bits_zext, 32, 8), !66)
|
|
;; FIXME: Just as in _Z4fun3v, the offset from the new alloca (2 bytes) is
|
|
;; correct but mem2reg needs to change it from an offset to a shift or
|
|
;; adjust the bit-extract (e.g., add the 2 byte offset to the existing 8 bit
|
|
;; offset for a 24 bit total bit-extract offset).
|
|
; COMMON-NEXT: #dbg_value(i32 %p.sroa.0.8.extract.trunc, ![[r:[0-9]+]], !DIExpression(DW_OP_plus_uconst, 2, DW_OP_LLVM_extract_bits_zext, 8, 8)
|
|
#dbg_declare(ptr %p, !69, !DIExpression(DW_OP_plus_uconst, 10, DW_OP_LLVM_extract_bits_zext, 8, 8), !66)
|
|
%2 = load i32, ptr %1, align 4
|
|
ret i32 %2
|
|
}
|
|
|
|
; COMMON-DAG: ![[x0]] = !DILocalVariable(name: "x",
|
|
; COMMON-DAG: ![[y0]] = !DILocalVariable(name: "y",
|
|
; COMMON-DAG: ![[A0]] = !DILocalVariable(scope:
|
|
|
|
; COMMON-DAG: ![[x1]] = !DILocalVariable(name: "x",
|
|
; COMMON-DAG: ![[y1]] = !DILocalVariable(name: "y",
|
|
; COMMON-DAG: ![[A1]] = !DILocalVariable(scope:
|
|
|
|
; COMMON-DAG: ![[e]] = !DILocalVariable(name: "e",
|
|
; COMMON-DAG: ![[f]] = !DILocalVariable(name: "f",
|
|
; COMMON-DAG: ![[g]] = !DILocalVariable(name: "g",
|
|
; COMMON-DAG: ![[h]] = !DILocalVariable(name: "h",
|
|
|
|
; COMMON-DAG: ![[p]] = !DILocalVariable(name: "p"
|
|
; COMMON-DAG: ![[q]] = !DILocalVariable(name: "q"
|
|
; COMMON-DAG: ![[r]] = !DILocalVariable(name: "r"
|
|
|
|
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg)
|
|
|
|
!llvm.dbg.cu = !{!2}
|
|
!llvm.module.flags = !{!16, !17}
|
|
!llvm.ident = !{!22}
|
|
|
|
!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
|
|
!1 = distinct !DIGlobalVariable(name: "gt", scope: !2, file: !3, line: 1, type: !10, isLocal: false, isDefinition: true)
|
|
!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 17.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
|
|
!3 = !DIFile(filename: "test.cpp", directory: "/")
|
|
!4 = !{!0, !5}
|
|
!5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())
|
|
!6 = distinct !DIGlobalVariable(name: "gf", scope: !2, file: !3, line: 7, type: !7, isLocal: false, isDefinition: true)
|
|
!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "four", file: !3, line: 7, size: 128, flags: DIFlagTypePassByValue, elements: !8, identifier: "_ZTS4four")
|
|
!8 = !{!9, !15}
|
|
!9 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !7, file: !3, line: 7, baseType: !10, size: 64)
|
|
!10 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "two", file: !3, line: 1, size: 64, flags: DIFlagTypePassByValue, elements: !11, identifier: "_ZTS3two")
|
|
!11 = !{!12, !14}
|
|
!12 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !10, file: !3, line: 1, baseType: !13, size: 32)
|
|
!13 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
|
|
!14 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !10, file: !3, line: 1, baseType: !13, size: 32, offset: 32)
|
|
!15 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !7, file: !3, line: 7, baseType: !10, size: 64, offset: 64)
|
|
!16 = !{i32 7, !"Dwarf Version", i32 5}
|
|
!17 = !{i32 2, !"Debug Info Version", i32 3}
|
|
!22 = !{!"clang version 17.0.0"}
|
|
!23 = distinct !DISubprogram(name: "fun1", linkageName: "_Z4fun1v", scope: !3, file: !3, line: 2, type: !24, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !26)
|
|
!24 = !DISubroutineType(types: !25)
|
|
!25 = !{!13}
|
|
!26 = !{!27, !28, !29}
|
|
!27 = !DILocalVariable(name: "x", scope: !23, file: !3, line: 3, type: !13)
|
|
!28 = !DILocalVariable(name: "y", scope: !23, file: !3, line: 3, type: !13)
|
|
!29 = !DILocalVariable(scope: !23, file: !3, line: 3, type: !10)
|
|
!31 = !DILocation(line: 3, column: 9, scope: !23)
|
|
!48 = distinct !DISubprogram(name: "fun2", linkageName: "_Z4fun2v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !49)
|
|
!49 = !{!50, !51, !52}
|
|
!50 = !DILocalVariable(name: "x", scope: !48, file: !3, line: 9, type: !10)
|
|
!51 = !DILocalVariable(name: "y", scope: !48, file: !3, line: 9, type: !10)
|
|
!52 = !DILocalVariable(scope: !48, file: !3, line: 9, type: !7)
|
|
!54 = !DILocation(line: 9, column: 9, scope: !48)
|
|
!55 = distinct !DISubprogram(name: "fun3", linkageName: "_Z4fun3v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !56)
|
|
!56 = !{}
|
|
!58 = !DILocation(line: 9, column: 9, scope: !55)
|
|
!60 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
|
|
!61 = !DILocalVariable(name: "e", scope: !55, file: !3, line: 9, type: !60)
|
|
!62 = !DILocalVariable(name: "f", scope: !55, file: !3, line: 9, type: !60)
|
|
!63 = !DILocalVariable(name: "g", scope: !55, file: !3, line: 9, type: !60)
|
|
!64 = !DILocalVariable(name: "h", scope: !55, file: !3, line: 9, type: !60)
|
|
!65 = distinct !DISubprogram(name: "fun4", linkageName: "_Z4fun4v", scope: !3, file: !3, line: 8, type: !24, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !56)
|
|
!66 = !DILocation(line: 9, column: 9, scope: !65)
|
|
!67 = !DILocalVariable(name: "p", scope: !65, file: !3, line: 9, type: !13)
|
|
!68 = !DILocalVariable(name: "q", scope: !65, file: !3, line: 9, type: !13)
|
|
!69 = !DILocalVariable(name: "r", scope: !65, file: !3, line: 9, type: !13)
|