[SelectionDAG][DebugInfo] Use entry-values to recover variables values

[djtodoro]

Summary

Use the entry values to salvage some params dbg.values. It is based on D87233.

[aprantl]

I think this looks mostly good.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

710–727

Can you add a comment that explains what's happening here?

718

Would ValueMap.lookup() work here?

[djtodoro]

@aprantl thanks for your comments.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

710–727

Sure.

718

It'd work, thanks.

[djtodoro]

• addressing comments
• refactoring
• fixing tests
• adding RegState::Debug to the Reg from the dbg_value

[djtodoro]

• Rebase

[aprantl]

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

80

Nit: remove ArgValueMap -. This used to be part of the comment style, but is completely redundant in non-ancient versions of Doxygen.

[Orlando]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

I think this we should only be doing this for immutable parameters (and mutable parameters which are never assigned to), right?

I.e. the entry_value of a parameter register is only a valid location for a parameter variable if that variable is never assigned another value.

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

We are expressing the modification in terms of its entry value here.

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

As far as I understand, we want to recover variables by describing them in relation to the initial values of the parameters. In that case, it only makes sense to consider variables whose values can be expressed in relation to that; this may include variables that aren't parameters themselves, and may exclude dbg.values for parameters. For example:

void foo(int param) {
  int x = param + 2;
  param = SomeInt();
  ...
}

In this example it should be possible to describe x in terms of param's initial value, while param itself could not be described by an entry value after its assignment within the function. In that case, I believe it would make more sense to look for dbg.values that use a parameter Value, or can be expressed in terms of one, rather than using DILocalVariable::isParameter. Does that seem correct, or have I misunderstood the work or the purpose of this block?

[djtodoro]

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

80

Thanks, sure.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Hi @StephenTozer.
Yes, but is a more complex use case, so we do not cover it (yet). There is a TODO marker within the findEntryValue() for that.
The debug entry values feature is complex, relying on various things, so we've initially implemented the support for simple registers locations as entry values of *unmodified* parameters *only*, during the LiveDebugValues phase. Currently, we are extending the support onto IR level, for some (simple) cases, but there is space for improvements for sure, since the potential goes beyond the current usage.

718

I think this we should only be doing this for immutable parameters (and mutable parameters which are never assigned to), right?

I.e. the entry_value of a parameter register is only a valid location for a parameter variable if that variable is never assigned another value.

Hi @Orlando.
I might have needed to add some more context here. You are right, and all of that has been already checked within the main debug-entry-values place of the production, within LiveDebugValues. We perform analysis there, and at the moment, use entry values for unmodified params (since it is the basic case). There is space for improvements, by using the entry values for describing/expressing the modification in terms of its entry value, but we do not support it (yet), there.

On the IR level, at the moment, we are trying to extend this support for unused arguments, since it seems to be safe/simple use case. First place for that is the DeadArgElimination pass, and we are working on sorting out all the pieces for that purpose (but it takes some additional magic in order to get it working for both callee and caller sides). The next spot this could be used is here, where we also have unused parameters, that are not being copied into any register, so the SelectionDAG marks them as invalid/unable to track it location anymore. Please comment on this, since I might have missed something.

[djtodoro]

• addressing comment

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Not handling the x case is fine then, since it will be much easier to get the basic change completed and then extend it to cover more cases later. I'm still not sure how this new extension avoids the second case however. Because we only use the variable to determine what entry value (if any) to produce, this code would still produce entry value DBG_VALUEs for a parameter even after an assignment to that parameter. Is there anything I've missed that would prevent us producing invalid entry values right here, such as for param's post-assignment value in the example code above?

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Probably we need some additional/stronger statements here. Can you please share the test case, so I can reproduce it?

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

statements -- in the code/extension implementation terms

[Orlando]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Hi @Orlando.
I might have needed to add some more context here. You are right, and all of that has been already checked within the main debug-entry-values place of the production, within LiveDebugValues. We perform analysis there, and at the moment, use entry values for unmodified params (since it is the basic case). There is space for improvements, by using the entry values for describing/expressing the modification in terms of its entry value, but we do not support it (yet), there.

On the IR level, at the moment, we are trying to extend this support for unused arguments, since it seems to be safe/simple use case. First place for that is the DeadArgElimination pass, and we are working on sorting out all the pieces for that purpose (but it takes some additional magic in order to get it working for both callee and caller sides). The next spot this could be used is here, where we also have unused parameters, that are not being copied into any register, so the SelectionDAG marks them as invalid/unable to track it location anymore. Please comment on this, since I might have missed something.

Thank you for this explanation, it has helped me understand.

The significance of ArgValueMap - in filtering the invalidated SDDbgValues for parameter variables down to just those using argument values - hadn't quite hit me until now, but looking again this all makes sense to me now.

I'm not really familiar with how LiveDebugValues handles entry_values currently. I'll take a close look soon as I can though as I'm interested in keeping up with this work!

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

No problem, thanks for your comments!

I've described the intention of this patch, but I might have missed some pieces, so I think we'll cover that with more tests (e.g. with the one @StephenTozer will provide).

[dstenb]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

I don't want to derail this discussion, but I just wanted to add that when I played around with this patch I encountered cases where we incorrectly emit entry values, even after the parameter has been modified, on trunk without this patch. I wrote a PR for that: https://bugs.llvm.org/show_bug.cgi?id=47628.

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

incorrect_entry-value_isel.ll2 KBDownload

Here is a test case which demonstrates the behaviour I'm talking about. I think the easiest way to summarize the underlying issue is that you're using the DILocalVariable to determine what entry value we should emit, if any. This is incorrect: it makes no fundamental difference whether or not the variable we're describing is a parameter, what matters is whether we use one of the SSA parameters. It might make more sense to track this information in the SDDbgValue directly, but in any case we can't rely on the variable to give us that information.

Full disclosure, I've also discussed this with Orlando directly, and he retracts his comment about ArgValueMap solving the issue; since EntryValue is equal to the parameter value for the variable rather than the current dbg.value.

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

Oh... it makes sense to me. Thanks! I've tried a few tests, and it all seemed to be working fine...

I'll try to propose a solution for this. I think it would be nice if we can make it working outside of the SelectionDAG (like a general solution for IR), and that is why I thought the variable would be enough/nice way to implement it, but it may not be sufficient...

[StephenTozer]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

My suggestion would be to use the SSA values. The properties of SSA form ensure that whenever we have a reference to an SSA value %param that is a parameter to a function, that value will be available as an entry value. This information should be readily available throughout IR. Once we get to ISel it gets a bit more complicated, but since each dbg.value is associated with a SDDbgValue it should be possible to store some identifying information in the SDDbgValue that can be referred back to here.

My naive thought is that you could simply store a Value* or Value Handle pointing to the original instruction, and use that instead of findEntryValue. If this doesn't work, it may be possible to store some information externally, as with ArgValueMap, that can be combined with the identifier to find the corresponding Entry Value (if any).

[djtodoro]

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

718

At first, I proposed/thought extending the instructions with some kind of a pointer to the Value, but it seemed to be too much work (since there would be handling of such info throughout the pipeline, etc.).
Let me think about it, and there might be some combination of this approach and the ideas shared that potentially could solve the problem.

[djtodoro]

• Use 2 extra arguments from llvm.dbg.value()
• Handle modified params

[djtodoro]

This needs to be tested more (so it is not for the final commit (yet)). I believe this triggers some asserts, but (at least) we are covering the cases we want.

[StephenTozer]

LGTM, this new approach looks solid. As per usual, wait for further approval from someone with more authority in this area.

llvm/include/llvm/CodeGen/SelectionDAG.h

1477 ↗

(On Diff #296163)

Nit, I think the "v" should be uppercase.

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

711

Double semi-colon here.

728–730

Minor: Comment could do with a small rewrite, something like "must generate an undef" -> "must generate a DBG_VALUE that is either undef, or an entry value if one is available"

llvm/lib/CodeGen/SelectionDAG/SDNodeDbgValue.h

68–69 ↗

(On Diff #296163)

Nit, this can be put in the initializer list.

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

5475–5477

Perhaps instead of simply making this a condition, there should be an assert here that V doesn't already exist in ArgValueMap? I can't think of any case where it would already be there that wouldn't be an error, since I don't think we would ever call this twice for the same Value.

llvm/test/DebugInfo/X86/entry-val-invalidated-node-modifed-param-with-add.ll

1–3 ↗

(On Diff #296163)

Personally I think it'd probably be best to specify the DWARF version in this, so that this test doesn't break if the default becomes 5 (or already is in a clone repo). It might be better to simply update the test if/when that happens though, I don't have especially strong opinions about it. Alternatively you could simply regex it as DW_OP{{(_GNU)?}}_entry_value; also not sure whether or not this approach would be preferred.

llvm/test/DebugInfo/X86/entry-values-for-isel-invalidated-nodes.ll

2–5

Repeat of above comment about DWARF version.

[djtodoro]

@StephenTozer Thanks for your comments. I'll address them and refactor the patch a bit, as soon as I catch some time to address some issues with the first patch from the stack.

[djtodoro]

• Use the entry values for local vars as well

llvm/include/llvm/CodeGen/FunctionLoweringInfo.h

public:
   /// MBBMap - A mapping from LLVM basic blocks to their machine code entry.
   DenseMap<const BasicBlock*, MachineBasicBlock *> MBBMap;
 
   /// ValueMap - Since we emit code for the function a basic block at a time,
   /// we must remember which virtual registers hold the values for
   /// cross-basic-block values.
   DenseMap<const Value *, Register> ValueMap;
 
+  /// A mapping from the argument values to their virtual registers.
+  DenseMap<const Value *, Register> ArgValueMap;
+
   /// VirtReg2Value map is needed by the Divergence Analysis driven
   /// instruction selection. It is reverted ValueMap. It is computed
   /// in lazy style - on demand. It is used to get the Value corresponding
   /// to the live in virtual register and is called from the
   /// TargetLowerinInfo::isSDNodeSourceOfDivergence.
   DenseMap<Register, const Value*> VirtReg2Value;
 
   /// This method is called from TargetLowerinInfo::isSDNodeSourceOfDivergence

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.h

 public:
   /// CountResults - The results of target nodes have register or immediate
   /// operands first, then an optional chain, and optional flag operands
   /// (which do not go into the machine instrs.)
   static unsigned CountResults(SDNode *Node);
 
   /// EmitDbgValue - Generate machine instruction for a dbg_value node.
   ///
-  MachineInstr *EmitDbgValue(SDDbgValue *SD,
-                             DenseMap<SDValue, Register> &VRBaseMap);
+  MachineInstr *
+  EmitDbgValue(SDDbgValue *SD, DenseMap<SDValue, Register> &VRBaseMap,
+               DenseMap<const Value *, Register> *ArgValueMap = nullptr);
 
   /// Generate machine instruction for a dbg_label node.
   MachineInstr *EmitDbgLabel(SDDbgLabel *SD);
 
   /// EmitNode - Generate machine code for a node and needed dependencies.
   ///
   void EmitNode(SDNode *Node, bool IsClone, bool IsCloned,
                 DenseMap<SDValue, Register> &VRBaseMap) {

llvm/lib/CodeGen/SelectionDAG/InstrEmitter.cpp

 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Target/TargetMachine.h"
+#include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 #define DEBUG_TYPE "instr-emitter"
 
 /// MinRCSize - Smallest register class we allow when constraining virtual
 /// registers.  If satisfying all register class constraints would require
 /// using a smaller register class, emit a COPY to a new virtual register
 /// instead.
void InstrEmitter::EmitRegSequence(SDNode *Node,
   (void)isNew; // Silence compiler warning.
   assert(isNew && "Node emitted out of order - early");
 }
 
 /// EmitDbgValue - Generate machine instruction for a dbg_value node.
 ///
 MachineInstr *
 InstrEmitter::EmitDbgValue(SDDbgValue *SD,
-                           DenseMap<SDValue, Register> &VRBaseMap) {
+                           DenseMap<SDValue, Register> &VRBaseMap,
+                           DenseMap<const Value *, Register> *ArgValueMap) {
   MDNode *Var = SD->getVariable();
   MDNode *Expr = SD->getExpression();
   DebugLoc DL = SD->getDebugLoc();
   assert(cast<DILocalVariable>(Var)->isValidLocationForIntrinsic(DL) &&
          "Expected inlined-at fields to agree");
 
   SD->setIsEmitted();
 
   if (SD->isInvalidated()) {
+    Register Reg = 0;
+    Value *EntryValue = nullptr;
+
+    // It the node has been invalidated, try to salvage the value
+    // if an entry value is available for the variable. Entry values
+    // act as backups here, and it will end up in an expression with
+    // a DW_OP_entry_value.
+    if (cast<DILocalVariable>(Var)->isParameter())
+      EntryValue =
+          findEntryValue(cast<DILocalVariable>(Var), MF->getFunction());
+
+    if (EntryValue && ArgValueMap) {
+      if ((Reg = ArgValueMap->lookup(EntryValue)))
+        Expr = DIExpression::prepend(cast<DIExpression>(Expr),
+                                     DIExpression::EntryValue);
+    }
+
     // An invalidated SDNode must generate an undef DBG_VALUE: although the
     // original value is no longer computed, earlier DBG_VALUEs live ranges
     // must not leak into later code.
     auto MIB = BuildMI(*MF, DL, TII->get(TargetOpcode::DBG_VALUE));
-    MIB.addReg(0U);
+    MIB.addReg(Reg, RegState::Debug);
     MIB.addReg(0U, RegState::Debug);
     MIB.addMetadata(Var);
     MIB.addMetadata(Expr);
     return &*MIB;
   }
 
   if (SD->getKind() == SDDbgValue::FRAMEIX) {
     // Stack address; this needs to be lowered in target-dependent fashion.

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGFast.cpp

 //
 class ScheduleDAGLinearize : public ScheduleDAGSDNodes {
 public:
   ScheduleDAGLinearize(MachineFunction &mf) : ScheduleDAGSDNodes(mf) {}
 
   void Schedule() override;
 
   MachineBasicBlock *
-    EmitSchedule(MachineBasicBlock::iterator &InsertPos) override;
+  EmitSchedule(MachineBasicBlock::iterator &InsertPos,
+               DenseMap<const Value *, Register> & /*ArgValueMap*/) override;
 
 private:
   std::vector<SDNode*> Sequence;
   DenseMap<SDNode*, SDNode*> GluedMap;  // Cache glue to its user
 
   void ScheduleNode(SDNode *N);
 };
 } // end anonymous namespace
for (unsigned i = 0, e = Glues.size(); i != e; ++i) {
     GUser->setNodeId(UDegree + Degree);
     Glue->setNodeId(1);
   }
 
   Sequence.reserve(DAGSize);
   ScheduleNode(DAG->getRoot().getNode());
 }
 
-MachineBasicBlock*
-ScheduleDAGLinearize::EmitSchedule(MachineBasicBlock::iterator &InsertPos) {
+MachineBasicBlock *ScheduleDAGLinearize::EmitSchedule(
+    MachineBasicBlock::iterator &InsertPos,
+    DenseMap<const Value *, Register> & /*ArgValueMap*/) {
   InstrEmitter Emitter(BB, InsertPos);
   DenseMap<SDValue, Register> VRBaseMap;
 
   LLVM_DEBUG({ dbgs() << "\n*** Final schedule ***\n"; });
 
   unsigned NumNodes = Sequence.size();
   MachineBasicBlock *BB = Emitter.getBlock();
   for (unsigned i = 0; i != NumNodes; ++i) {

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h

public:
 
     /// VerifyScheduledSequence - Verify that all SUnits are scheduled and
     /// consistent with the Sequence of scheduled instructions.
     void VerifyScheduledSequence(bool isBottomUp);
 
     /// EmitSchedule - Insert MachineInstrs into the MachineBasicBlock
     /// according to the order specified in Sequence.
     ///
-    virtual MachineBasicBlock*
-    EmitSchedule(MachineBasicBlock::iterator &InsertPos);
+    virtual MachineBasicBlock *
+    EmitSchedule(MachineBasicBlock::iterator &InsertPos,
+                 DenseMap<const Value *, Register> &ArgValueMap);
 
     void dumpNode(const SUnit &SU) const override;
     void dump() const override;
     void dumpSchedule() const;
 
     std::string getGraphNodeLabel(const SUnit *SU) const override;
 
     std::string getDAGName() const override;

llvm/lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp

EmitPhysRegCopy(SUnit *SU, DenseMap<SUnit*, Register> &VRBaseMap,
   }
 }
 
 /// EmitSchedule - Emit the machine code in scheduled order. Return the new
 /// InsertPos and MachineBasicBlock that contains this insertion
 /// point. ScheduleDAGSDNodes holds a BB pointer for convenience, but this does
 /// not necessarily refer to returned BB. The emitter may split blocks.
 MachineBasicBlock *ScheduleDAGSDNodes::
-EmitSchedule(MachineBasicBlock::iterator &InsertPos) {
+EmitSchedule(MachineBasicBlock::iterator &InsertPos,
+             DenseMap<const Value *, Register> &ValueMap) {
   InstrEmitter Emitter(BB, InsertPos);
   DenseMap<SDValue, Register> VRBaseMap;
   DenseMap<SUnit*, Register> CopyVRBaseMap;
   SmallVector<std::pair<unsigned, MachineInstr*>, 32> Orders;
   SmallSet<Register, 8> Seen;
   bool HasDbg = DAG->hasDebugValues();
 
   // Emit a node, and determine where its first instruction is for debuginfo.
for (unsigned i = 0, e = Orders.size(); i != e && DI != DE; ++i) {
       // Insert all SDDbgValue's whose order(s) are before "Order".
       assert(MI);
       for (; DI != DE; ++DI) {
         if ((*DI)->getOrder() < LastOrder || (*DI)->getOrder() >= Order)
           break;
         if ((*DI)->isEmitted())
           continue;
 
-        MachineInstr *DbgMI = Emitter.EmitDbgValue(*DI, VRBaseMap);
+        MachineInstr *DbgMI = Emitter.EmitDbgValue(*DI, VRBaseMap, &ValueMap);
         if (DbgMI) {
           if (!LastOrder)
             // Insert to start of the BB (after PHIs).
             BB->insert(BBBegin, DbgMI);
           else {
             // Insert at the instruction, which may be in a different
             // block, if the block was split by a custom inserter.
             MachineBasicBlock::iterator Pos = MI;

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

if (Reg && Reg.isVirtual()) {
       Register PR = RegInfo.getLiveInPhysReg(Reg);
       if (PR)
         Reg = PR;
     }
     if (Reg) {
       Op = MachineOperand::CreateReg(Reg, false);
       IsIndirect = IsDbgDeclare;
     }
+
+    // Map the register into the Value, so it can be used for debug
+    // info recovering.
+    if (FuncInfo.ArgValueMap.find(V) == FuncInfo.ArgValueMap.end())
+      FuncInfo.ArgValueMap[V] = Reg;
   }
 
   if (!Op && N.getNode()) {
     // Check if frame index is available.
     SDValue LCandidate = peekThroughBitcasts(N);
     if (LoadSDNode *LNode = dyn_cast<LoadSDNode>(LCandidate.getNode()))
       if (FrameIndexSDNode *FINode =
           dyn_cast<FrameIndexSDNode>(LNode->getBasePtr().getNode()))

llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

#endif
   // inserted into.
   MachineBasicBlock *FirstMBB = FuncInfo->MBB, *LastMBB;
   {
     NamedRegionTimer T("emit", "Instruction Creation", GroupName,
                        GroupDescription, TimePassesIsEnabled);
 
     // FuncInfo->InsertPt is passed by reference and set to the end of the
     // scheduled instructions.
-    LastMBB = FuncInfo->MBB = Scheduler->EmitSchedule(FuncInfo->InsertPt);
+    LastMBB = FuncInfo->MBB =
+        Scheduler->EmitSchedule(FuncInfo->InsertPt, FuncInfo->ArgValueMap);
   }
 
   // If the block was split, make sure we update any references that are used to
   // update PHI nodes later on.
   if (FirstMBB != LastMBB)
     SDB->UpdateSplitBlock(FirstMBB, LastMBB);
 
   // Free the scheduler state.

llvm/test/DebugInfo/X86/entry-values-for-isel-invalidated-nodes.ll

+; RUN: llc < %s -O2 -stop-before=finalize-isel | FileCheck %s
+; RUN: llc -O2 %s -o %t -filetype=obj
+; RUN: llvm-dwarfdump %t | FileCheck %s --check-prefix=CHECK-DWARFDUMP
+
+; C producer:
+; void f1(int);
+; void f2(int i) {
+;    f1(1);
+;    i = i + 5;
+;    f1(3);
+; }
+; $ clang -g -O2 test.c -S -emit-llvm
+
+; CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression()
+; CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1, DW_OP_plus_uconst, 5, DW_OP_stack_value)
+
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_stack_value
+; CHECK-DWARFDUMP: DW_OP_GNU_entry_value(DW_OP_reg5 RDI), DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_plus_uconst 0x5, DW_OP_stack_value
+
+; ModuleID = 'test.c'
+source_filename = "test.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: nounwind uwtable
+define dso_local void @f2(i32 %i) local_unnamed_addr !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression()), !dbg !13
+  tail call void @f1(i32 1), !dbg !14
+  call void @llvm.dbg.value(metadata i32 %i, metadata !12, metadata !DIExpression(DW_OP_plus_uconst, 5, DW_OP_stack_value)), !dbg !13
+  tail call void @f1(i32 3), !dbg !15
+  ret void, !dbg !16
+}
+
+declare !dbg !17 dso_local void @f1(i32) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 12.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "/dir")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 12.0.0"}
+!7 = distinct !DISubprogram(name: "f2", scope: !1, file: !1, line: 2, type: !8, scopeLine: 2, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{!12}
+!12 = !DILocalVariable(name: "i", arg: 1, scope: !7, file: !1, line: 2, type: !10)
+!13 = !DILocation(line: 0, scope: !7)
+!14 = !DILocation(line: 3, column: 3, scope: !7)
+!15 = !DILocation(line: 5, column: 3, scope: !7)
+!16 = !DILocation(line: 6, column: 1, scope: !7)
+!17 = !DISubprogram(name: "f1", scope: !1, file: !1, line: 1, type: !8, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)