[InstrRef][X86] Drop debug instruction numbers from x87 instructions

[jmorse]

Summary

Avoid a crash when using instruction referencing if x87 floating point instructions are used. These instructions are significantly mutated when they're rewritten from referring to registers, to referring to floating-point-stack positions. As a result, their operands are re-ordered, and (InstrRef) LiveDebugValues asserts when it sees a DBG_INSTR_REF referring to a non-reg non-def register operand.

To fix this, I'm just dropping the instruction numbers, and thus variable locations. This avoids the crash -- we could try and record the substitution from fp-register operand to floating-point-stack-position but then... what would we do with the floating point stack position? They shift position throughout the program, and an additional dataflow analysis would be needed to work out how to refer to them correctly.

Instead, take the pragmatic approach that VarLoc LiveDebugvalues / variable locations does, and drop the lot of them. This isn't a coverage regression at all, because all DBG_VALUEs of, for example, $fp0, don't make it to the output file because they're pseudo-registers with no DWARF register number. I'll open a PR for poor x87 variable location support, however I suspect interest is limited.

This patch adds a "dropDebugNumber" helper to MachineInstr, the idea being that it's (sort-of) self documenting what's going on. The attached test case covers all six call sites that I add in the x86-codegen pass.

[StephenTozer]

Quick question: Do call instructions need to be handled here? I tried modifying the C source to have a variable directly assigned from a call instruction:

d = ext();
a *= d;

Then with the following command line (I don't know if there's a way to pass experimental-debug-variable-locations directly to clang), the call+instruction reference appear as in the below block: clang -m32 -g -O2 test.c -S -emit-llvm -o - | llc -experimental-debug-variable-locations -stop-before=x86-codegen -o test.mir

CALLpcrel32 @ext, csr_32, implicit $esp, implicit $ssp, implicit-def $esp, implicit-def $ssp, implicit-def $fp0, debug-instr-number 6, debug-location !23
ADJCALLSTACKUP32 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !23
DBG_INSTR_REF 6, 6, !19, !DIExpression(), debug-location !21

If I understand the syntax correctly, this means that the DBG_INSTR_REF is referring to $fp0 in the call instruction. Finally, running llc test.mir -experimental-debug-variable-locations -run-pass=x86-codegen -o - translates this to the following:

CALLpcrel32 @ext, csr_32, implicit $esp, implicit $ssp, implicit-def $esp, implicit-def $ssp, debug-instr-number 6, debug-location !23
ADJCALLSTACKUP32 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !23
DBG_INSTR_REF 6, 6, !19, !DIExpression(), debug-location !21

If I've understood correctly, the DBG_INSTR_REF now refers to a non-existent operand, while the call instruction still has a debug-instr-number attached. I'd assume that this is an issue given the other areas handled by this patch, does this need handling here?

Edit: Just an extra point, the only other place that looked like it wasn't being handled was return instructions, but I'm assuming that we would never use a return instruction for a debug instruction reference.

llvm/include/llvm/CodeGen/MachineInstr.h

475

👍

llvm/test/DebugInfo/MIR/InstrRef/x86-fp-stackifier-drop-locations.mir

85

Nit, remove git+commit reference.

[djtodoro]

Hi @jmorse,

Thanks for this. It looks reasonable, but I was wondering if there is an automatic way for ensuring that when deletion of an operand occurs, there is no dangling debug ref to it. It seems like a good candidate for an assertion somehow? I guess we should be aware that this feature will be used for some downstream targets as well, so we need to provide some kind of mechanism for them in order to keep things valid, any thoughts?

Best,
Djordje

[jmorse]

Stephen wrote:

Quick question: Do call instructions need to be handled here? I tried modifying the C source to have a variable directly assigned from a call instruction:

Erk, that's right, those should indeed have instruction numbers dropped, it's being mutated and the operands don't mean the same things any more. This revision adds another drop call, and labels a call in the MIR with a debug-instr-number, to be dropped.

I suppose it's possible that, if a function returns more than one value, that we could un-necessarily drop non-float variable information where it could have been preserved. As far as I understand it, LLVM doesn't support multiple return values though.

[jmorse]

(Possibly, this should end up on the mailing list),

In D105657#2886802, @djtodoro wrote:

Thanks for this. It looks reasonable, but I was wondering if there is an automatic way for ensuring that when deletion of an operand occurs, there is no dangling debug ref to it. It seems like a good candidate for an assertion somehow?

That definitely makes sense for things like RemoveOperand -- it's going to cause all other operands to be re-numbered, thus breaking many connections between DBG_INSTR_REFs and the instruction. I'll try putting a dropDebugNumber into RemoveOperand and see if it affects variable coverage. (I think this patch will still be sufficient).

NB: This particular patch was generated by an assertion firing, while building a large codebase InstrRefBasedLDV followed a chain of substitutions back to an operand that wasn't a register def, and asserted. This won't catch everything, but at least caught this.

I guess we should be aware that this feature will be used for some downstream targets as well, so we need to provide some kind of mechanism for them in order to keep things valid, any thoughts?

Downstream targets are inevitably going to need some modifications to be correct, as with this patch; I should add something to SourceLevelDebugging.rst to document what the update rules are for debug-instr-numbers. I think the extra instrumentation is necessary to improve past what DBG_VALUEs can currently provide.

Unfortunately I don't think there's any way of proving or ensuring the debug-info is always correct, because proving that two functions are identical is generally undecidable. There's always going to be a small chance of an un-instrumented optimisation out there subtly modifying an instruction in a way that makes it calculate a different value, and where debug-info should be dropped, but isn't. I think we have to accept this as a good trade-off in risk: right now, register coalescing causes large numbers of DBG_VALUEs to point at the wrong value, and there's no good way to fix it, wheras with debug-instr-number there's always a safe option of dropping.

[StephenTozer]

LGTM. Documenting the update rules for instruction referencing debug values seems important, but doesn't need to be tied to this patch in particular I think.

[djtodoro]

In D105657#2887180, @jmorse wrote:

(Possibly, this should end up on the mailing list),

+1

In D105657#2886802, @djtodoro wrote:

Thanks for this. It looks reasonable, but I was wondering if there is an automatic way for ensuring that when deletion of an operand occurs, there is no dangling debug ref to it. It seems like a good candidate for an assertion somehow?

That definitely makes sense for things like RemoveOperand -- it's going to cause all other operands to be re-numbered, thus breaking many connections between DBG_INSTR_REFs and the instruction. I'll try putting a dropDebugNumber into RemoveOperand and see if it affects variable coverage. (I think this patch will still be sufficient).

Thanks!

NB: This particular patch was generated by an assertion firing, while building a large codebase InstrRefBasedLDV followed a chain of substitutions back to an operand that wasn't a register def, and asserted. This won't catch everything, but at least caught this.

I guess we should be aware that this feature will be used for some downstream targets as well, so we need to provide some kind of mechanism for them in order to keep things valid, any thoughts?

Downstream targets are inevitably going to need some modifications to be correct, as with this patch; I should add something to SourceLevelDebugging.rst to document what the update rules are for debug-instr-numbers. I think the extra instrumentation is necessary to improve past what DBG_VALUEs can currently provide.

Unfortunately I don't think there's any way of proving or ensuring the debug-info is always correct, because proving that two functions are identical is generally undecidable. There's always going to be a small chance of an un-instrumented optimisation out there subtly modifying an instruction in a way that makes it calculate a different value, and where debug-info should be dropped, but isn't. I think we have to accept this as a good trade-off in risk: right now, register coalescing causes large numbers of DBG_VALUEs to point at the wrong value, and there's no good way to fix it, wheras with debug-instr-number there's always a safe option of dropping.

I agree and good documentation is the right way to proceed with this.

llvm/include/llvm/CodeGen/MachineInstr.h

public:
   /// Examine the instruction number of this MachineInstr. May be zero if
   /// it hasn't been assigned a number yet.
   unsigned peekDebugInstrNum() const { return DebugInstrNum; }
 
   /// Set instruction number of this MachineInstr. Avoid using unless you're
   /// deserializing this information.
   void setDebugInstrNum(unsigned Num) { DebugInstrNum = Num; }
 
+  /// Drop any variable location debugging information associated with this
+  /// instruction. Use when an instruction is modified in such a way that it no
+  /// longer defines the value it used to. Variable locations using that value
+  /// will be dropped.
+  void dropDebugNumber() { DebugInstrNum = 0; }
+
   /// Emit an error referring to the source location of this instruction.
   /// This should only be used for inline assembly that is somehow
   /// impossible to compile. Other errors should have been handled much
   /// earlier.
   ///
   /// If this method returns, the caller should try to recover from the error.
   void emitError(StringRef Msg) const;
 

llvm/lib/Target/X86/X86FloatingPoint.cpp

void FPS::popStackAfter(MachineBasicBlock::iterator &I) {
   popReg();
 
   // Check to see if there is a popping version of this instruction...
   int Opcode = Lookup(PopTable, I->getOpcode());
   if (Opcode != -1) {
     I->setDesc(TII->get(Opcode));
     if (Opcode == X86::FCOMPP || Opcode == X86::UCOM_FPPr)
       I->RemoveOperand(0);
+    MI.dropDebugNumber();
   } else {    // Insert an explicit pop
     I = BuildMI(*MBB, ++I, dl, TII->get(X86::ST_FPrr)).addReg(X86::ST0);
   }
 }
 
 /// freeStackSlotAfter - Free the specified register from the register stack, so
 /// that it is no longer in a register.  If the register is currently at the top
 /// of the stack, we just pop the current instruction, otherwise we store the
#endif
   // Reset the FP Stack - It is required because of possible leftovers from
   // passed arguments. The caller should assume that the FP stack is
   // returned empty (unless the callee returns values on FP stack).
   while (StackTop > 0)
     popReg();
 
   for (unsigned I = 0; I < N; ++I)
     pushReg(N - I - 1);
+
+  // Drop all variable values defined by this call -- we can't track them
+  // once they've been stackified.
+  I->dropDebugNumber();
 }
 
 /// If RET has an FP register use operand, pass the first one in ST(0) and
 /// the second one in ST(1).
 void FPS::handleReturn(MachineBasicBlock::iterator &I) {
   MachineInstr &MI = *I;
 
   // Find the register operands.
void FPS::handleZeroArgFP(MachineBasicBlock::iterator &I) {
   // Change from the pseudo instruction to the concrete instruction.
   MI.RemoveOperand(0); // Remove the explicit ST(0) operand
   MI.setDesc(TII->get(getConcreteOpcode(MI.getOpcode())));
   MI.addOperand(
       MachineOperand::CreateReg(X86::ST0, /*isDef*/ true, /*isImp*/ true));
 
   // Result gets pushed on the stack.
   pushReg(DestReg);
+
+  MI.dropDebugNumber();
 }
 
 /// handleOneArgFP - fst <mem>, ST(0)
 ///
 void FPS::handleOneArgFP(MachineBasicBlock::iterator &I) {
   MachineInstr &MI = *I;
   unsigned NumOps = MI.getDesc().getNumOperands();
   assert((NumOps == X86::AddrNumOperands + 1 || NumOps == 1) &&
if (MI.getOpcode() == X86::IST_FP64m || MI.getOpcode() == X86::ISTT_FP16m ||
       MI.getOpcode() == X86::ISTT_FP32m || MI.getOpcode() == X86::ISTT_FP64m ||
       MI.getOpcode() == X86::ST_FP80m) {
     if (StackTop == 0)
       report_fatal_error("Stack empty??");
     --StackTop;
   } else if (KillsSrc) { // Last use of operand?
     popStackAfter(I);
   }
+
+  MI.dropDebugNumber();
 }
 
 
 /// handleOneArgFPRW: Handle instructions that read from the top of stack and
 /// replace the value with a newly computed value.  These instructions may have
 /// non-fp operands after their FP operands.
 ///
 ///  Examples:
if (KillsSrc) {
     // of the stack.
     duplicateToTop(Reg, getFPReg(MI.getOperand(0)), I);
   }
 
   // Change from the pseudo instruction to the concrete instruction.
   MI.RemoveOperand(1); // Drop the source operand.
   MI.RemoveOperand(0); // Drop the destination operand.
   MI.setDesc(TII->get(getConcreteOpcode(MI.getOpcode())));
+  MI.dropDebugNumber();
 }
 
 
 //===----------------------------------------------------------------------===//
 // Define tables of various ways to map pseudo instructions
 //
 
 // ForwardST0Table - Map: A = B op C  into: ST(0) = ST(0) op ST(i)
void FPS::handleCompareFP(MachineBasicBlock::iterator &I) {
   // Make sure the first operand is on the top of stack, the other one can be
   // anywhere.
   moveToTop(Op0, I);
 
   // Change from the pseudo instruction to the concrete instruction.
   MI.getOperand(0).setReg(getSTReg(Op1));
   MI.RemoveOperand(1);
   MI.setDesc(TII->get(getConcreteOpcode(MI.getOpcode())));
+  MI.dropDebugNumber();
 
   // If any of the operands are killed by this instruction, free them.
   if (KillsOp0) freeStackSlotAfter(I, Op0);
   if (KillsOp1 && Op0 != Op1) freeStackSlotAfter(I, Op1);
 }
 
 /// handleCondMovFP - Handle two address conditional move instructions.  These
 /// instructions move a st(i) register to st(0) iff a condition is true.  These
void FPS::handleCondMovFP(MachineBasicBlock::iterator &I) {
   moveToTop(Op0, I);
 
   // Change the second operand to the stack register that the operand is in.
   // Change from the pseudo instruction to the concrete instruction.
   MI.RemoveOperand(0);
   MI.RemoveOperand(1);
   MI.getOperand(0).setReg(getSTReg(Op1));
   MI.setDesc(TII->get(getConcreteOpcode(MI.getOpcode())));
+  MI.dropDebugNumber();
 
   // If we kill the second operand, make sure to pop it from the stack.
   if (Op0 != Op1 && KillsOp1) {
     // Get this value off of the register stack.
     freeStackSlotAfter(I, Op1);
   }
 }
 

llvm/lib/Target/X86/X86InstrInfo.cpp

case X86::SUB8rr: {
     case X86::SUB32ri8:  NewOpcode = X86::CMP32ri8;  break;
     case X86::SUB16ri:   NewOpcode = X86::CMP16ri;   break;
     case X86::SUB16ri8:  NewOpcode = X86::CMP16ri8;  break;
     case X86::SUB8ri:    NewOpcode = X86::CMP8ri;    break;
     }
     CmpInstr.setDesc(get(NewOpcode));
     CmpInstr.RemoveOperand(0);
     // Mutating this instruction invalidates any debug data associated with it.
-    CmpInstr.setDebugInstrNum(0);
+    CmpInstr.dropDebugNumber();
     // Fall through to optimize Cmp if Cmp is CMPrr or CMPri.
     if (NewOpcode == X86::CMP64rm || NewOpcode == X86::CMP32rm ||
         NewOpcode == X86::CMP16rm || NewOpcode == X86::CMP8rm)
       return false;
   }
   }
 
   // Get the unique definition of SrcReg.

llvm/test/DebugInfo/MIR/InstrRef/x86-fp-stackifier-drop-locations.mir

+# RUN: llc %s -run-pass=x86-codegen -o - -experimental-debug-variable-locations | FileCheck %s
+#
+# The x87 FP instructions below have debug instr numbers attached -- but the
+# operands get rewritten when it's converted to stack-form. Rather than trying
+# to recover from this, drop any instruction numbers.
+#
+# CHECK-NOT: debug-instr-number
+# CHECK:     ADD_F64m
+# CHECK-NOT: debug-instr-number
+#
+# Original program, command line 'clang ./test.c -O2 -g -m32 -o out.o -c'
+#
+# long double ext();
+# 
+# long double glob = 1.234;
+# 
+# long double foo(long double a, long double b, long double c) {
+#   a += b;
+#   b += c;
+#   a *= ext();
+#   b /= ext();
+#   if (a < 5.0)
+#     a += glob;
+#   return a - b;
+# }
+# 
+
+--- |
+  ; ModuleID = 'out.ll'
+  source_filename = "./test.c"
+  target datalayout = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-f64:32:64-f80:32-n8:16:32-S128"
+  target triple = "i386-unknown-linux-gnu"
+  
+  @glob = dso_local local_unnamed_addr global x86_fp80 0xK3FFF9DF3B645A1CAC000, align 4, !dbg !0
+  
+  ; Function Attrs: nounwind
+  define dso_local x86_fp80 @foo(x86_fp80 %a, x86_fp80 %b, x86_fp80 %c) local_unnamed_addr !dbg !13 {
+  entry:
+    call void @llvm.dbg.value(metadata x86_fp80 %a, metadata !17, metadata !DIExpression()), !dbg !20
+    call void @llvm.dbg.value(metadata x86_fp80 %b, metadata !18, metadata !DIExpression()), !dbg !20
+    call void @llvm.dbg.value(metadata x86_fp80 %c, metadata !19, metadata !DIExpression()), !dbg !20
+    %add = fadd x86_fp80 %a, %b, !dbg !21
+    call void @llvm.dbg.value(metadata x86_fp80 %add, metadata !17, metadata !DIExpression()), !dbg !20
+    call void @llvm.dbg.value(metadata x86_fp80 undef, metadata !18, metadata !DIExpression()), !dbg !20
+    %call = tail call x86_fp80 bitcast (x86_fp80 (...)* @ext to x86_fp80 ()*)() #3, !dbg !22
+    %mul = fmul x86_fp80 %add, %call, !dbg !23
+    call void @llvm.dbg.value(metadata x86_fp80 %mul, metadata !17, metadata !DIExpression()), !dbg !20
+    %call2 = tail call x86_fp80 bitcast (x86_fp80 (...)* @ext to x86_fp80 ()*)() #3, !dbg !24
+    call void @llvm.dbg.value(metadata x86_fp80 undef, metadata !18, metadata !DIExpression()), !dbg !20
+    %cmp = fcmp olt x86_fp80 %mul, 0xK4001A000000000000000, !dbg !25
+    %0 = load x86_fp80, x86_fp80* @glob, align 4, !dbg !27
+    %add3 = fadd x86_fp80 %mul, %0, !dbg !27
+    %a.addr.0 = select i1 %cmp, x86_fp80 %add3, x86_fp80 %mul, !dbg !27
+    %add1 = fadd x86_fp80 %b, %c, !dbg !28
+    call void @llvm.dbg.value(metadata x86_fp80 %add1, metadata !18, metadata !DIExpression()), !dbg !20
+    %div = fdiv x86_fp80 %add1, %call2, !dbg !29
+    call void @llvm.dbg.value(metadata x86_fp80 %div, metadata !18, metadata !DIExpression()), !dbg !20
+    call void @llvm.dbg.value(metadata x86_fp80 %a.addr.0, metadata !17, metadata !DIExpression()), !dbg !20
+    %sub = fsub x86_fp80 %a.addr.0, %div, !dbg !30
+    ret x86_fp80 %sub, !dbg !31
+  }
+  
+  declare dso_local x86_fp80 @ext(...) local_unnamed_addr
+  
+  ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+  
+  !llvm.dbg.cu = !{!2}
+  !llvm.module.flags = !{!8, !9, !10, !11}
+  !llvm.ident = !{!12}
+  
+  !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+  !1 = distinct !DIGlobalVariable(name: "glob", scope: !2, file: !6, line: 3, type: !7, isLocal: false, isDefinition: true)
+  !2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+  !3 = !DIFile(filename: "test.c", directory: "/fast/fs/build34llvm4")
+  !4 = !{}
+  !5 = !{!0}
+  !6 = !DIFile(filename: "./test.c", directory: ".")
+  !7 = !DIBasicType(name: "long double", size: 96, encoding: DW_ATE_float)
+  !8 = !{i32 1, !"NumRegisterParameters", i32 0}
+  !9 = !{i32 7, !"Dwarf Version", i32 4}
+  !10 = !{i32 2, !"Debug Info Version", i32 3}
+  !11 = !{i32 1, !"wchar_size", i32 4}
+  !12 = !{!"clang"}
+  !13 = distinct !DISubprogram(name: "foo", scope: !6, file: !6, line: 5, type: !14, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+  !14 = !DISubroutineType(types: !15)
+  !15 = !{!7, !7, !7, !7}
+  !16 = !{!17, !18, !19}
+  !17 = !DILocalVariable(name: "a", arg: 1, scope: !13, file: !6, line: 5, type: !7)
+  !18 = !DILocalVariable(name: "b", arg: 2, scope: !13, file: !6, line: 5, type: !7)
+  !19 = !DILocalVariable(name: "c", arg: 3, scope: !13, file: !6, line: 5, type: !7)
+  !20 = !DILocation(line: 0, scope: !13)
+  !21 = !DILocation(line: 6, column: 5, scope: !13)
+  !22 = !DILocation(line: 8, column: 8, scope: !13)
+  !23 = !DILocation(line: 8, column: 5, scope: !13)
+  !24 = !DILocation(line: 9, column: 8, scope: !13)
+  !25 = !DILocation(line: 10, column: 9, scope: !26)
+  !26 = distinct !DILexicalBlock(scope: !13, file: !6, line: 10, column: 7)
+  !27 = !DILocation(line: 10, column: 7, scope: !13)
+  !28 = !DILocation(line: 7, column: 5, scope: !13)
+  !29 = !DILocation(line: 9, column: 5, scope: !13)
+  !30 = !DILocation(line: 12, column: 12, scope: !13)
+  !31 = !DILocation(line: 12, column: 3, scope: !13)
+
+...
+---
+name:            foo
+alignment:       16
+tracksRegLiveness: true
+frameInfo:
+  hasCalls:        true
+fixedStack:
+  - { id: 0, type: default, offset: 24, size: 10, alignment: 8, stack-id: default, 
+      isImmutable: true, isAliased: false, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+  - { id: 1, type: default, offset: 12, size: 10, alignment: 4, stack-id: default, 
+      isImmutable: true, isAliased: false, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+  - { id: 2, type: default, offset: 0, size: 10, alignment: 16, stack-id: default, 
+      isImmutable: true, isAliased: false, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+stack:
+  - { id: 0, name: '', type: spill-slot, offset: 0, size: 10, alignment: 4, 
+      stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+  - { id: 1, name: '', type: spill-slot, offset: 0, size: 10, alignment: 4, 
+      stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+  - { id: 2, name: '', type: spill-slot, offset: 0, size: 10, alignment: 4, 
+      stack-id: default, callee-saved-register: '', callee-saved-restored: true, 
+      debug-info-variable: '', debug-info-expression: '', debug-info-location: '' }
+callSites:       []
+debugValueSubstitutions: []
+constants:
+  - id:              0
+    value:           'float 5.000000e+00'
+    alignment:       4
+    isTargetSpecific: false
+machineFunctionInfo: {}
+body:             |
+  bb.0.entry:
+    renamable $fp0 = nofpexcept LD_Fp80m %fixed-stack.0, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 1 :: (load (s80) from %fixed-stack.0, align 8)
+    ST_FpP80m %stack.0, 1, $noreg, 0, $noreg, killed renamable $fp0, implicit-def $fpsw, implicit $fpcw, debug-instr-number 2 :: (store (s80) into %stack.0, align 4)
+    renamable $fp1 = nofpexcept LD_Fp80m %fixed-stack.1, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 3 :: (load (s80) from %fixed-stack.1, align 4)
+    ST_FpP80m %stack.1, 1, $noreg, 0, $noreg, renamable $fp1, implicit-def $fpsw, implicit $fpcw, debug-instr-number 4 :: (store (s80) into %stack.1, align 4)
+    renamable $fp0 = nofpexcept LD_Fp80m %fixed-stack.2, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 5 :: (load (s80) from %fixed-stack.2, align 16)
+    renamable $fp0 = nofpexcept ADD_Fp80 killed renamable $fp0, killed renamable $fp1, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 6, debug-location !21
+    ST_FpP80m %stack.2, 1, $noreg, 0, $noreg, killed renamable $fp0, implicit-def $fpsw, implicit $fpcw, debug-instr-number 7 :: (store (s80) into %stack.2, align 4)
+    ADJCALLSTACKDOWN32 0, 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !22
+    CALLpcrel32 @ext, csr_32, implicit $esp, implicit $ssp, implicit-def $esp, implicit-def $ssp, implicit-def $fp0, debug-instr-number 100, debug-location !22
+    ADJCALLSTACKUP32 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !22
+    renamable $fp1 = LD_Fp80m %stack.2, 1, $noreg, 0, $noreg, implicit-def $fpsw, implicit $fpcw :: (load (s80) from %stack.2, align 4)
+    renamable $fp0 = nofpexcept MUL_Fp80 killed renamable $fp1, killed renamable $fp0, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 8, debug-location !23
+    ST_FpP80m %stack.2, 1, $noreg, 0, $noreg, killed renamable $fp0, implicit-def $fpsw, implicit $fpcw, debug-instr-number 9 :: (store (s80) into %stack.2, align 4)
+    ADJCALLSTACKDOWN32 0, 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !24
+    CALLpcrel32 @ext, csr_32, implicit $esp, implicit $ssp, implicit-def $esp, implicit-def $ssp, implicit-def $fp0, debug-location !24
+    ADJCALLSTACKUP32 0, 0, implicit-def dead $esp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $esp, implicit $ssp, debug-location !24
+    renamable $fp1 = nofpexcept LD_Fp32m80 $noreg, 1, $noreg, %const.0, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 10 :: (load (s32) from constant-pool)
+    renamable $fp2 = LD_Fp80m %stack.2, 1, $noreg, 0, $noreg, implicit-def $fpsw, implicit $fpcw, debug-instr-number 11 :: (load (s80) from %stack.2, align 4)
+    nofpexcept UCOM_FpIr80 killed renamable $fp1, renamable $fp2, implicit-def $eflags, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 12, debug-location !25
+    renamable $fp1 = nofpexcept LD_Fp80m $noreg, 1, $noreg, @glob, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 13, debug-location !27 :: (dereferenceable load (s80) from @glob, align 4)
+    renamable $fp1 = nofpexcept ADD_Fp80 renamable $fp2, killed renamable $fp1, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 14, debug-location !27
+    renamable $fp2 = CMOVNBE_Fp80 killed renamable $fp2, killed renamable $fp1, implicit-def dead $fpsw, implicit killed $eflags, debug-instr-number 15, debug-location !27
+    renamable $fp3 = COPY killed renamable $fp2
+    renamable $fp1 = LD_Fp80m %stack.0, 1, $noreg, 0, $noreg, implicit-def $fpsw, implicit $fpcw, debug-instr-number 16 :: (load (s80) from %stack.0, align 4)
+    renamable $fp2 = LD_Fp80m %stack.1, 1, $noreg, 0, $noreg, implicit-def $fpsw, implicit $fpcw, debug-instr-number 17 :: (load (s80) from %stack.1, align 4)
+    renamable $fp1 = nofpexcept ADD_Fp80 killed renamable $fp2, killed renamable $fp1, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 18, debug-location !28
+    renamable $fp0 = nofpexcept DIV_Fp80 killed renamable $fp1, killed renamable $fp0, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 19, debug-location !29
+    renamable $fp0 = nofpexcept SUB_Fp80 killed renamable $fp3, killed renamable $fp0, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 20, debug-location !30
+    ;; Edited in:
+    renamable $fp0 = ADD_Fp64m killed renamable $fp0, killed $esp, 1, $noreg, 0, $noreg, implicit-def dead $fpsw, implicit $fpcw, debug-instr-number 21,  :: (load (s64) from `i32 *undef`)
+    RET 0, killed renamable $fp0, debug-location !31
+
+...