[IRSim][IROutliner] Adding DebugInfo handling for IR outlined functions.

[AndrewLitteken]

Summary

Including debug instructions from different places in the program could cause issues with debuggers. This makes sure that any debug information about original location in outlined functions is stripped accordingly, and adds new debug information to the outlined functions.

Tests Changed:

• llvm/test/Transforms/IROutliner/legal-debug.ll

New Tests:

• llvm/test/DebugInfo/AArch64/ir-outliner.ll

[jroelofs]

I know almost nothing about how DebugInfo is represented in llvm/dwarf, but is there not a way to represent what this transformation is doing in DI? It's always a little sad when you have to drop it, since doing so makes the debug experience worse.

llvm/lib/Transforms/IPO/IROutliner.cpp

408

is the StringRef() ctor call necessary?

447

where does moveFunctionData get called with MoveDebug set the other way?

[AndrewLitteken]

Updating for string refs.

[vsk]

CodeExtractor contains a utility to fix up debug info after extraction occurs (I believe it's called fixupDebugInfoPostExtraction). It's solving the same problem - is there any way to generalize/reuse that logic?

llvm/test/DebugInfo/AArch64/ir-outliner.ll

2

Please validate the debug info metadata in the IR after -iroutliner runs. Validating the final DWARF production is nice, but checking the IR takes precedent (why? well DWARF may not represent everything we care about at the IR level, and DWARF isn't the only debug info format llvm supports).

[AndrewLitteken]

In D87302#2277131, @vsk wrote:

CodeExtractor contains a utility to fix up debug info after extraction occurs (I believe it's called fixupDebugInfoPostExtraction). It's solving the same problem - is there any way to generalize/reuse that logic?

I believe it already uses it since the CodeExtractor is used to create the new functions in each case, but this is mainly for the function that moves them all together. The problem is that fixupDebugInfoPostExtraction transfers the information from the original function, which would not be correct in this case since we are merging the information from several different code locations into one. This also addresses @jroelofs disappointment, but since I'm not aware of any mechanism to say that one particular line in IR is from two different source code locations, I think it has to be dropped altogether for correctness.

Right now the current mechanism in lldb is simply skipping over the section of code, which isn't ideal, but it is consistent.

[vsk]

In D87302#2476048, @AndrewLitteken wrote:

In D87302#2277131, @vsk wrote:

CodeExtractor contains a utility to fix up debug info after extraction occurs (I believe it's called fixupDebugInfoPostExtraction). It's solving the same problem - is there any way to generalize/reuse that logic?

I believe it already uses it since the CodeExtractor is used to create the new functions in each case, but this is mainly for the function that moves them all together. The problem is that fixupDebugInfoPostExtraction transfers the information from the original function, which would not be correct in this case since we are merging the information from several different code locations into one. This also addresses @jroelofs disappointment, but since I'm not aware of any mechanism to say that one particular line in IR is from two different source code locations, I think it has to be dropped altogether for correctness.

I see, thanks for explaining.

Right now the current mechanism in lldb is simply skipping over the section of code, which isn't ideal, but it is consistent.

Sgtm, please carry on!

[AndrewLitteken]

This updates the diff with all the recent IROutliner updates, and adds testing for verifying the IR DebugInfo.

[AndrewLitteken]

@vsk Is there other verification that needs to happen to the outlined IR code besides just making sure with Filecheck that it is correct?

[vsk]

No, that looks reasonable to me. (Although, it is unfortunate that update_test_checks.py hardcodes metadata numbers: this creates more of a maintenance burden than is ideal. It'd be nice to revamp the way the script emits metadata check lines, but that's outside the scope of this patch.)

[AndrewLitteken]

Is this good to land then?

[AndrewLitteken]

Just bumping this again, is this good to land?

[jroelofs]

LGTM

[djtodoro]

In D87302#2275050, @jroelofs wrote:

I know almost nothing about how DebugInfo is represented in llvm/dwarf, but is there not a way to represent what this transformation is doing in DI? It's always a little sad when you have to drop it, since doing so makes the debug experience worse.

I know a bit more about llvm di/dwarf, but I am also wondering if there is an idea on how to improve this in terms of Debug Info. In order to support Debug Info for Inlined functions, DWARF was extended to meet the requirements. I guess this will need something like that -- on both MIR and IR versions of the pass. Any thoughts about this?

Other than the comment for the test, this looks reasonable to me.

llvm/test/DebugInfo/AArch64/ir-outliner.ll

170

It is bad practice to hardcode metadata numbers in tests since they change, so please make it more flexible by using regular expressions and the check variables.

[AndrewLitteken]

In D87302#2809796, @djtodoro wrote:

I guess this will need something like that -- on both MIR and IR versions of the pass. Any thoughts about this?

I think that's certainly possible. If there was a way in the debug info to say that a specific section of IR is from Section A of the program if called from location A, Section B if called from location B etc that would solve the problem. I don't know enough about DebugInfo to really say how difficult that would be though.

[jmorse]

Hi,

In D87302#2810683, @AndrewLitteken wrote:

I think that's certainly possible. If there was a way in the debug info to say that a specific section of IR is from Section A of the program if called from location A, Section B if called from location B etc that would solve the problem. I don't know enough about DebugInfo to really say how difficult that would be though.

Not a super-DWARF-expert, but I don't believe this can be expressed in DWARF today. It's certainly a significant limitation -- there are numerous scenarios where we "common" instructions together, and drop the line number, because it now reflects operations from multiple parts of program. And none of those line numbers are appropriate to present in isolation.

(It certainly isn't supported by LLVM debuginfo; I've no knowledge of what's supported by the CodeView file format).

[dblaikie]

Does the outliner only run for commoning code, or can it run on a single function (for hot/cold reasons, or anything else)?

BUt yeah, in the commoning case, DWARF (& LLVM IR) have no way to represent this situation and dropping the location is the best tool we have at the moment. It's discussed here: https://llvm.org/docs/HowToUpdateDebugInfo.html#when-to-drop-an-instruction-location

llvm/lib/Transforms/IPO/IROutliner.cpp

383

Side note: This seems surprising to me - do any other passes create functions with plain names like this? I'd expect anything being created would use something like the C++ reserved identifier namespace (double leading underscore or leading underscore and uppercase).

[paquette]

In D87302#2811182, @dblaikie wrote:

Does the outliner only run for commoning code, or can it run on a single function (for hot/cold reasons, or anything else)?

BUt yeah, in the commoning case, DWARF (& LLVM IR) have no way to represent this situation and dropping the location is the best tool we have at the moment. It's discussed here: https://llvm.org/docs/HowToUpdateDebugInfo.html#when-to-drop-an-instruction-location

Right now, it's module-only. A single-function outlining pass would be pretty useful though. (E.g. for matching outlinable patterns stored off somewhere else.)

Anyway, as for debug info with outlining, yeah, I think that would need a DWARF extension. (@aprantl might be interested in that topic?) I think that discussion is probably better-suited to an email thread on a few mailing lists though. :)

For the sake of this patch, @AndrewLitteken, I think all you need to do is tidy up the testcase like @djtodoro suggested. (Does update_test_checks.py hardcode metadata stuff like this?)

[paquette]

llvm/lib/Transforms/IPO/IROutliner.cpp

383

The MachineOutliner does this as well. It generally works okay because of the linkage type on the functions. It's not ideal though. IIRC there was a EuroLLVM talk planned prior to covid which had a better naming scheme.

I think @plotfi was helping upstream some of those patches?

[plotfi]

llvm/lib/Transforms/IPO/IROutliner.cpp

383

I was working on a pass for redoing address offset calculations done by GEPs so that more of the offset calculation will have increased IR and MIR similarity, but I don't think the size reduction was significant and there were also some weird pathological cases too. I gave up on it though.

[AndrewLitteken]

Remade tests with regexed metadata information.

[djtodoro]

the tests look good to me now, thanks! (some nits included)

llvm/lib/Transforms/IPO/IROutliner.cpp

447

can we use some early exits here?

468

Is this clang-formatted?

[AndrewLitteken]

llvm/lib/Transforms/IPO/IROutliner.cpp

447

I've reversed the logic so that we check for not a call instruction first, then act on that to decrease the indentation.

468

Most of it is, but this crept in under the radar

[djtodoro]

lgtm, thanks!

llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp

1989 ↗

(On Diff #351881)

I guess this test wasn't intentional? :)

[AndrewLitteken]

llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp

1989 ↗

(On Diff #351881)

Ah yeah, I'll make sure to remove it before committing it

[vzakhari]

llvm/lib/Transforms/IPO/IROutliner.cpp

475

Since DebugInsts does not get reset for each basic block, we may try to erase instructions that have already been erased. This triggers on my change to preserve the topological order for the return blocks created by CodeExtractor. @AndrewLitteken, do you mind if I move the declaration of DebugInsts into the CurrBB loop body as a part of my change?

llvm/lib/Transforms/IPO/IROutliner.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/IROutliner.h"
 #include "llvm/Analysis/IRSimilarityIdentifier.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/Attributes.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/DIBuilder.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/IPO.h"
 #include <map>
 #include <set>
 #include <vector>
void OutlinableGroup::collectGVNStoreSets(Module &M) {
 
   // We are adding an extracted argument to decide between which output path
   // to use in the basic block.  It is used in a switch statement and only
   // needs to be an integer.
   if (OutputGVNCombinations.size() > 1)
     ArgumentTypes.push_back(Type::getInt32Ty(M.getContext()));
 }
 
+/// Get the subprogram if it exists for one of the outlined regions.
+///
+/// \param [in] Group - The set of regions to find a subprogram for.
+/// \returns the subprogram if it exists, or nullptr.
+static DISubprogram *getSubprogramOrNull(OutlinableGroup &Group) {
+  for (OutlinableRegion *OS : Group.Regions)
+    if (Function *F = OS->Call->getFunction())
+      if (DISubprogram *SP = F->getSubprogram())
+        return SP;
+
+  return nullptr;
+}
+
 Function *IROutliner::createFunction(Module &M, OutlinableGroup &Group,
                                      unsigned FunctionNameSuffix) {
   assert(!Group.OutlinedFunction && "Function is already defined!");
 
   Group.OutlinedFunctionType = FunctionType::get(
       Type::getVoidTy(M.getContext()), Group.ArgumentTypes, false);
 
   // These functions will only be called from within the same module, so
   // we can set an internal linkage.
   Group.OutlinedFunction = Function::Create(
       Group.OutlinedFunctionType, GlobalValue::InternalLinkage,
       "outlined_ir_func_" + std::to_string(FunctionNameSuffix), M);
 
   // Transfer the swifterr attribute to the correct function parameter.
   if (Group.SwiftErrorArgument.hasValue())
     Group.OutlinedFunction->addParamAttr(Group.SwiftErrorArgument.getValue(),
                                          Attribute::SwiftError);
 
   Group.OutlinedFunction->addFnAttr(Attribute::OptimizeForSize);
   Group.OutlinedFunction->addFnAttr(Attribute::MinSize);
 
+  // If there's a DISubprogram associated with this outlined function, then
+  // emit debug info for the outlined function.
+  if (DISubprogram *SP = getSubprogramOrNull(Group)) {
+    Function *F = Group.OutlinedFunction;
+    // We have a DISubprogram. Get its DICompileUnit.
+    DICompileUnit *CU = SP->getUnit();
+    DIBuilder DB(M, true, CU);
+    DIFile *Unit = SP->getFile();
+    Mangler Mg;
+    // Get the mangled name of the function for the linkage name.
+    std::string Dummy;
+    llvm::raw_string_ostream MangledNameStream(Dummy);
+    Mg.getNameWithPrefix(MangledNameStream, F, false);
+
+    DISubprogram *OutlinedSP = DB.createFunction(
+        Unit /* Context */, F->getName(), MangledNameStream.str(),
+        Unit /* File */,
+        0 /* Line 0 is reserved for compiler-generated code. */,
+        DB.createSubroutineType(DB.getOrCreateTypeArray(None)), /* void type */
+        0, /* Line 0 is reserved for compiler-generated code. */
+        DINode::DIFlags::FlagArtificial /* Compiler-generated code. */,
+        /* Outlined code is optimized code by definition. */
+        DISubprogram::SPFlagDefinition | DISubprogram::SPFlagOptimized);
+
+    // Don't add any new variables to the subprogram.
+    DB.finalizeSubprogram(OutlinedSP);
+
+    // Attach subprogram to the function.
+    F->setSubprogram(OutlinedSP);
+    // We're done with the DIBuilder.
+    DB.finalize();
+  }
+
   return Group.OutlinedFunction;
 }
 
 /// Move each BasicBlock in \p Old to \p New.
 ///
-/// \param [in] Old - the function to move the basic blocks from.
+/// \param [in] Old - The function to move the basic blocks from.
 /// \param [in] New - The function to move the basic blocks to.
 /// \returns the first return block for the function in New.
 static BasicBlock *moveFunctionData(Function &Old, Function &New) {
   Function::iterator CurrBB, NextBB, FinalBB;
   BasicBlock *NewEnd = nullptr;
   std::vector<Instruction *> DebugInsts;
   for (CurrBB = Old.begin(), FinalBB = Old.end(); CurrBB != FinalBB;
        CurrBB = NextBB) {
     NextBB = std::next(CurrBB);
     CurrBB->removeFromParent();
     CurrBB->insertInto(&New);
     Instruction *I = CurrBB->getTerminator();
     if (isa<ReturnInst>(I))
       NewEnd = &(*CurrBB);
+
+    for (Instruction &Val : *CurrBB) {
+      // We must handle the scoping of called functions differently than
+      // other outlined instructions.
+      if (!isa<CallInst>(&Val)) {
+        // Remove the debug information for outlined functions.
+        Val.setDebugLoc(DebugLoc());
+        continue;
+      }
+
+      // From this point we are only handling call instructions.
+      CallInst *CI = cast<CallInst>(&Val);
+
+      // We add any debug statements here, to be removed after.  Since the
+      // instructions originate from many different locations in the program,
+      // it will cause incorrect reporting from a debugger if we keep the
+      // same debug instructions.
+      if (isa<DbgInfoIntrinsic>(CI)) {
+        DebugInsts.push_back(&Val);
+        continue;
+      }
+
+      // Edit the scope of called functions inside of outlined functions.
+      if (DISubprogram *SP = New.getSubprogram()) {
+        DILocation *DI = DILocation::get(New.getContext(), 0, 0, SP);
+        Val.setDebugLoc(DI);
+      }
+    }
+
+    for (Instruction *I : DebugInsts)
+      I->eraseFromParent();
   }
 
   assert(NewEnd && "No return instruction for new function?");
   return NewEnd;
 }
 
 /// Find the the constants that will need to be lifted into arguments
 /// as they are not the same in each instance of the region.

llvm/test/DebugInfo/AArch64/ir-outliner.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -verify -iroutliner -ir-outlining-no-cost < %s | \
+; RUN: llc -filetype=obj -mtriple=aarch64-- | llvm-dwarfdump - | FileCheck %s
+
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck -check-prefix=IRDEBUG %s
+
+; Ensure that the IR Outliner produces valid DWARF debug information when
+; creating outlined functions.
+
+; CHECK: DW_TAG_compile_unit
+; CHECK-DAG: DW_AT_name ("outline_debug1")
+
+; Check the high address of bar. This is one past the end of bar. It should be
+; the beginning of the outlined function.
+; CHECK:      DW_AT_high_pc ([[ONE_PAST_BAR:0x[a-f0-9]+]])
+; CHECK-NEXT: DW_AT_frame_base  (DW_OP_reg31 WSP)
+; CHECK-NEXT: DW_AT_linkage_name  ("outline_debug2")
+; CHECK-NEXT: DW_AT_name  ("outline_debug2")
+
+; Check the outlined function's DWARF.
+; CHECK-DAG:  DW_TAG_subprogram
+; CHECK-NEXT: DW_AT_low_pc  ([[ONE_PAST_BAR]])
+; CHECK-NEXT: DW_AT_high_pc (0x{{[0-9a-f]+}})
+; CHECK-NEXT: DW_AT_frame_base  (DW_OP_reg31 WSP)
+; CHECK-NEXT: DW_AT_linkage_name ("[[NAME:outlined_ir_func_[0-9]+]]")
+; CHECK-NEXT: DW_AT_name  ("[[NAME]]")
+; CHECK-NEXT: DW_AT_artificial  (true)
+; CHECK-NEXT: DW_AT_external  (true)
 
-; This test looks ahecks that debug info is extracted along with the other
-; instructions.
-
-define void @function1() !dbg !6 {
-; CHECK-LABEL: @function1(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG17:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META9:metadata !.*]], metadata !DIExpression()), [[DBG17]]
-; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG18:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META11:metadata !.*]], metadata !DIExpression()), [[DBG18]]
-; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG19:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META12:metadata !.*]], metadata !DIExpression()), [[DBG19]]
-; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG20:!dbg !.*]]
-; CHECK-NEXT:    ret void, [[DBG21:!dbg !.*]]
-;
+define void @outline_debug1() !dbg !6 {
 entry:
   %a = alloca i32, align 4, !dbg !17
   call void @llvm.dbg.value(metadata i32* %a, metadata !9, metadata !DIExpression()), !dbg !17
   %b = alloca i32, align 4, !dbg !18
   call void @llvm.dbg.value(metadata i32* %b, metadata !11, metadata !DIExpression()), !dbg !18
   %c = alloca i32, align 4, !dbg !19
   call void @llvm.dbg.value(metadata i32* %c, metadata !12, metadata !DIExpression()), !dbg !19
   store i32 2, i32* %a, align 4, !dbg !20
   store i32 3, i32* %b, align 4, !dbg !21
   store i32 4, i32* %c, align 4, !dbg !22
   %al = load i32, i32* %a, align 4, !dbg !23
   call void @llvm.dbg.value(metadata i32 %al, metadata !13, metadata !DIExpression()), !dbg !23
   %bl = load i32, i32* %b, align 4, !dbg !24
   call void @llvm.dbg.value(metadata i32 %bl, metadata !15, metadata !DIExpression()), !dbg !24
   %cl = load i32, i32* %c, align 4, !dbg !25
   call void @llvm.dbg.value(metadata i32 %cl, metadata !16, metadata !DIExpression()), !dbg !25
   ret void, !dbg !26
 }
 
-define void @function2() !dbg !27 {
-; CHECK-LABEL: @function2(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG30:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META24:metadata !.*]], metadata !DIExpression()), [[DBG30]]
-; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG31:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META25:metadata !.*]], metadata !DIExpression()), [[DBG31]]
-; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG32:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META26:metadata !.*]], metadata !DIExpression()), [[DBG32]]
-; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG33:!dbg !.*]]
-; CHECK-NEXT:    ret void, [[DBG34:!dbg !.*]]
-;
+define void @outline_debug2() !dbg !27 {
 entry:
   %a = alloca i32, align 4, !dbg !35
   call void @llvm.dbg.value(metadata i32* %a, metadata !29, metadata !DIExpression()), !dbg !35
   %b = alloca i32, align 4, !dbg !36
   call void @llvm.dbg.value(metadata i32* %b, metadata !30, metadata !DIExpression()), !dbg !36
   %c = alloca i32, align 4, !dbg !37
   call void @llvm.dbg.value(metadata i32* %c, metadata !31, metadata !DIExpression()), !dbg !37
   store i32 2, i32* %a, align 4, !dbg !38

 
 attributes #0 = { nounwind readnone speculatable willreturn }
 
 !llvm.dbg.cu = !{!0}
 !llvm.debugify = !{!3, !4}
 !llvm.module.flags = !{!5}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "debugify", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
-!1 = !DIFile(filename: "legal-debug.ll", directory: "/")
+!1 = !DIFile(filename: "llvm/test/DebugInfo/ir-outliner.ll", directory: "/")
 !2 = !{}
 !3 = !{i32 20}
 !4 = !{i32 12}
 !5 = !{i32 2, !"Debug Info Version", i32 3}
-!6 = distinct !DISubprogram(name: "function1", linkageName: "function1", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
+!6 = distinct !DISubprogram(name: "outline_debug1", linkageName: "outline_debug1", scope: null, file: !1, line: 1, type: !7, scopeLine: 1, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !8)
 !7 = !DISubroutineType(types: !2)
 !8 = !{!9, !11, !12, !13, !15, !16}
 !9 = !DILocalVariable(name: "1", scope: !6, file: !1, line: 1, type: !10)
 !10 = !DIBasicType(name: "ty64", size: 64, encoding: DW_ATE_unsigned)
 !11 = !DILocalVariable(name: "2", scope: !6, file: !1, line: 2, type: !10)
 !12 = !DILocalVariable(name: "3", scope: !6, file: !1, line: 3, type: !10)
 !13 = !DILocalVariable(name: "4", scope: !6, file: !1, line: 7, type: !14)
 !14 = !DIBasicType(name: "ty32", size: 32, encoding: DW_ATE_unsigned)
 !15 = !DILocalVariable(name: "5", scope: !6, file: !1, line: 8, type: !14)
 !16 = !DILocalVariable(name: "6", scope: !6, file: !1, line: 9, type: !14)
 !17 = !DILocation(line: 1, column: 1, scope: !6)
 !18 = !DILocation(line: 2, column: 1, scope: !6)
 !19 = !DILocation(line: 3, column: 1, scope: !6)
 !20 = !DILocation(line: 4, column: 1, scope: !6)
 !21 = !DILocation(line: 5, column: 1, scope: !6)
 !22 = !DILocation(line: 6, column: 1, scope: !6)
 !23 = !DILocation(line: 7, column: 1, scope: !6)
 !24 = !DILocation(line: 8, column: 1, scope: !6)
 !25 = !DILocation(line: 9, column: 1, scope: !6)
 !26 = !DILocation(line: 10, column: 1, scope: !6)
-!27 = distinct !DISubprogram(name: "function2", linkageName: "function2", scope: null, file: !1, line: 11, type: !7, scopeLine: 11, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !28)
+!27 = distinct !DISubprogram(name: "outline_debug2", linkageName: "outline_debug2", scope: null, file: !1, line: 11, type: !7, scopeLine: 11, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !28)
 !28 = !{!29, !30, !31, !32, !33, !34}
 !29 = !DILocalVariable(name: "7", scope: !27, file: !1, line: 11, type: !10)
 !30 = !DILocalVariable(name: "8", scope: !27, file: !1, line: 12, type: !10)
 !31 = !DILocalVariable(name: "9", scope: !27, file: !1, line: 13, type: !10)
 !32 = !DILocalVariable(name: "10", scope: !27, file: !1, line: 17, type: !14)
 !33 = !DILocalVariable(name: "11", scope: !27, file: !1, line: 18, type: !14)
 !34 = !DILocalVariable(name: "12", scope: !27, file: !1, line: 19, type: !14)
 !35 = !DILocation(line: 11, column: 1, scope: !27)
 !36 = !DILocation(line: 12, column: 1, scope: !27)
 !37 = !DILocation(line: 13, column: 1, scope: !27)
 !38 = !DILocation(line: 14, column: 1, scope: !27)
 !39 = !DILocation(line: 15, column: 1, scope: !27)
 !40 = !DILocation(line: 16, column: 1, scope: !27)
 !41 = !DILocation(line: 17, column: 1, scope: !27)
 !42 = !DILocation(line: 18, column: 1, scope: !27)
 !43 = !DILocation(line: 19, column: 1, scope: !27)
 !44 = !DILocation(line: 20, column: 1, scope: !27)
+
+; IRDEBUG-LABEL: @outline_debug1(
+; IRDEBUG-NEXT:  entry:
+; IRDEBUG-NEXT:    [[A:%.*]] = alloca i32, align 4, !dbg [[DBG17:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META9:![0-9]+]], metadata !DIExpression()), !dbg [[DBG17]]
+; IRDEBUG-NEXT:    [[B:%.*]] = alloca i32, align 4, !dbg [[DBG18:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META11:![0-9]+]], metadata !DIExpression()), !dbg [[DBG18]]
+; IRDEBUG-NEXT:    [[C:%.*]] = alloca i32, align 4, !dbg [[DBG19:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META12:![0-9]+]], metadata !DIExpression()), !dbg [[DBG19]]
+; IRDEBUG-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG20:![0-9]+]]
+; IRDEBUG-NEXT:    ret void, !dbg [[DBG21:![0-9]+]]
+;
+;
+; IRDEBUG-LABEL: @outline_debug2(
+; IRDEBUG-NEXT:  entry:
+; IRDEBUG-NEXT:    [[A:%.*]] = alloca i32, align 4, !dbg [[DBG30:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META24:![0-9]+]], metadata !DIExpression()), !dbg [[DBG30]]
+; IRDEBUG-NEXT:    [[B:%.*]] = alloca i32, align 4, !dbg [[DBG31:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META25:![0-9]+]], metadata !DIExpression()), !dbg [[DBG31]]
+; IRDEBUG-NEXT:    [[C:%.*]] = alloca i32, align 4, !dbg [[DBG32:![0-9]+]]
+; IRDEBUG-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META26:![0-9]+]], metadata !DIExpression()), !dbg [[DBG32]]
+; IRDEBUG-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG33:![0-9]+]]
+; IRDEBUG-NEXT:    ret void, !dbg [[DBG34:![0-9]+]]
+;
+;
+; IRDEBUG: @outlined_ir_func_0(i32* [[TMP0:%.*]], i32* [[TMP1:%.*]], i32*  [[TMP2:%.*]])
+; IRDEBUG:       entry_to_outline:
+; IRDEBUG-NEXT:    store i32 2, i32* [[TMP0]], align 4
+; IRDEBUG-NEXT:    store i32 3, i32* [[TMP1]], align 4
+; IRDEBUG-NEXT:    store i32 4, i32* [[TMP2]], align 4
+; IRDEBUG-NEXT:    [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
+; IRDEBUG-NEXT:    [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
+; IRDEBUG-NEXT:    [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; IRDEBUG-NEXT:    br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+;

llvm/test/Transforms/IROutliner/legal-debug.ll

-; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
 ; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
 
-; This test looks ahecks that debug info is extracted along with the other
-; instructions.
+; This test checks that debug info is recognized as able to be extracted along
+; with the other instructions, but is not included in the consolidated function.
 
 define void @function1() !dbg !6 {
-; CHECK-LABEL: @function1(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG17:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META9:metadata !.*]], metadata !DIExpression()), [[DBG17]]
-; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG18:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META11:metadata !.*]], metadata !DIExpression()), [[DBG18]]
-; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG19:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META12:metadata !.*]], metadata !DIExpression()), [[DBG19]]
-; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG20:!dbg !.*]]
-; CHECK-NEXT:    ret void, [[DBG21:!dbg !.*]]
-;
 entry:
   %a = alloca i32, align 4, !dbg !17
   call void @llvm.dbg.value(metadata i32* %a, metadata !9, metadata !DIExpression()), !dbg !17
   %b = alloca i32, align 4, !dbg !18
   call void @llvm.dbg.value(metadata i32* %b, metadata !11, metadata !DIExpression()), !dbg !18
   %c = alloca i32, align 4, !dbg !19
   call void @llvm.dbg.value(metadata i32* %c, metadata !12, metadata !DIExpression()), !dbg !19
   store i32 2, i32* %a, align 4, !dbg !20
   store i32 3, i32* %b, align 4, !dbg !21
   store i32 4, i32* %c, align 4, !dbg !22
   %al = load i32, i32* %a, align 4, !dbg !23
   call void @llvm.dbg.value(metadata i32 %al, metadata !13, metadata !DIExpression()), !dbg !23
   %bl = load i32, i32* %b, align 4, !dbg !24
   call void @llvm.dbg.value(metadata i32 %bl, metadata !15, metadata !DIExpression()), !dbg !24
   %cl = load i32, i32* %c, align 4, !dbg !25
   call void @llvm.dbg.value(metadata i32 %cl, metadata !16, metadata !DIExpression()), !dbg !25
   ret void, !dbg !26
 }
 
 define void @function2() !dbg !27 {
-; CHECK-LABEL: @function2(
-; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, [[DBG30:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], [[META24:metadata !.*]], metadata !DIExpression()), [[DBG30]]
-; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, [[DBG31:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], [[META25:metadata !.*]], metadata !DIExpression()), [[DBG31]]
-; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, [[DBG32:!dbg !.*]]
-; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], [[META26:metadata !.*]], metadata !DIExpression()), [[DBG32]]
-; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), [[DBG33:!dbg !.*]]
-; CHECK-NEXT:    ret void, [[DBG34:!dbg !.*]]
-;
 entry:
   %a = alloca i32, align 4, !dbg !35
   call void @llvm.dbg.value(metadata i32* %a, metadata !29, metadata !DIExpression()), !dbg !35
   %b = alloca i32, align 4, !dbg !36
   call void @llvm.dbg.value(metadata i32* %b, metadata !30, metadata !DIExpression()), !dbg !36
   %c = alloca i32, align 4, !dbg !37
   call void @llvm.dbg.value(metadata i32* %c, metadata !31, metadata !DIExpression()), !dbg !37
   store i32 2, i32* %a, align 4, !dbg !38
   store i32 3, i32* %b, align 4, !dbg !39
   store i32 4, i32* %c, align 4, !dbg !40
   %al = load i32, i32* %a, align 4, !dbg !41
   call void @llvm.dbg.value(metadata i32 %al, metadata !32, metadata !DIExpression()), !dbg !41
   %bl = load i32, i32* %b, align 4, !dbg !42
   call void @llvm.dbg.value(metadata i32 %bl, metadata !33, metadata !DIExpression()), !dbg !42
   %cl = load i32, i32* %c, align 4, !dbg !43
   call void @llvm.dbg.value(metadata i32 %cl, metadata !34, metadata !DIExpression()), !dbg !43
   ret void, !dbg !44
 }
 
+
 ; Function Attrs: nounwind readnone speculatable willreturn
 declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 
 attributes #0 = { nounwind readnone speculatable willreturn }
 
 !llvm.dbg.cu = !{!0}
 !llvm.debugify = !{!3, !4}
 !llvm.module.flags = !{!5}

 !37 = !DILocation(line: 13, column: 1, scope: !27)
 !38 = !DILocation(line: 14, column: 1, scope: !27)
 !39 = !DILocation(line: 15, column: 1, scope: !27)
 !40 = !DILocation(line: 16, column: 1, scope: !27)
 !41 = !DILocation(line: 17, column: 1, scope: !27)
 !42 = !DILocation(line: 18, column: 1, scope: !27)
 !43 = !DILocation(line: 19, column: 1, scope: !27)
 !44 = !DILocation(line: 20, column: 1, scope: !27)
+; CHECK-LABEL: @function1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, !dbg [[DBG17:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META9:![0-9]+]], metadata !DIExpression()), !dbg [[DBG17]]
+; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, !dbg [[DBG18:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META11:![0-9]+]], metadata !DIExpression()), !dbg [[DBG18]]
+; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, !dbg [[DBG19:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META12:![0-9]+]], metadata !DIExpression()), !dbg [[DBG19]]
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG20:![0-9]+]]
+; CHECK-NEXT:    ret void, !dbg [[DBG21:![0-9]+]]
+;
+;
+; CHECK-LABEL: @function2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[A:%.*]] = alloca i32, align 4, !dbg [[DBG30:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[A]], metadata [[META24:![0-9]+]], metadata !DIExpression()), !dbg [[DBG30]]
+; CHECK-NEXT:    [[B:%.*]] = alloca i32, align 4, !dbg [[DBG31:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[B]], metadata [[META25:![0-9]+]], metadata !DIExpression()), !dbg [[DBG31]]
+; CHECK-NEXT:    [[C:%.*]] = alloca i32, align 4, !dbg [[DBG32:![0-9]+]]
+; CHECK-NEXT:    call void @llvm.dbg.value(metadata i32* [[C]], metadata [[META26:![0-9]+]], metadata !DIExpression()), !dbg [[DBG32]]
+; CHECK-NEXT:    call void @outlined_ir_func_0(i32* [[A]], i32* [[B]], i32* [[C]]), !dbg [[DBG33:![0-9]+]]
+; CHECK-NEXT:    ret void, !dbg [[DBG34:![0-9]+]]
+;
+;
+; CHECK: @outlined_ir_func_0(i32* [[TMP0:%.*]], i32* [[TMP1:%.*]], i32*  [[TMP2:%.*]])
+; CHECK:       entry_to_outline:
+; CHECK-NEXT:    store i32 2, i32* [[TMP0]], align 4
+; CHECK-NEXT:    store i32 3, i32* [[TMP1]], align 4
+; CHECK-NEXT:    store i32 4, i32* [[TMP2]], align 4
+; CHECK-NEXT:    [[AL:%.*]] = load i32, i32* [[TMP0]], align 4
+; CHECK-NEXT:    [[BL:%.*]] = load i32, i32* [[TMP1]], align 4
+; CHECK-NEXT:    [[CL:%.*]] = load i32, i32* [[TMP2]], align 4
+; CHECK-NEXT:    br label [[ENTRY_AFTER_OUTLINE_EXITSTUB:%.*]]
+;