[RISCV] Do not outline CFI instructions when they are needed in EH

[• pcwang-thead]

Summary

We saw a failure caused by unwinding with incomplete CFIs, so we
can't outline CFI instructions when they are needed in EH.

[• pcwang-thead]

Rebase on precommit test D123364.

[luismarques]

We this change we now don't have any tests that show a difference compared with just if (MI.isPosition()) return outliner::InstrType::Illegal;
Please add a test that showcases that new, more fined grained, outlining criteria for position instructions.

[• pcwang-thead]

In D122634#3441112, @luismarques wrote:

We this change we now don't have any tests that show a difference compared with just if (MI.isPosition()) return outliner::InstrType::Illegal;
Please add a test that showcases that new, more fined grained, outlining criteria for position instructions.

Thanks for your advice, but what I changed in this patch is just the way to handle CFIs when unwinding is needed.
The original code is:

if (MI.isPosition()) {
    // We can manually strip out CFI instructions later.
    if (MI.isCFIInstruction())
      return outliner::InstrType::Invisible;
    return outliner::InstrType::Illegal;
}

These conditions existed since the first version of outlining implementation (D66210), so we won't see any differences of position instructions even if I added some tests in this patch.

[luismarques]

In D122634#3447432, @pcwang-thead wrote:

These conditions existed since the first version of outlining implementation (D66210), so we won't see any differences of position instructions even if I added some tests in this patch.

It's been a few days since my original comment so I may be misremembering the details but here's my perspective:

• Before your patch we had test coverage that showed the difference between a plain if (MI.isPosition()) return outliner::InstrType::Illegal; and the then-current implementation.
• With this patch we no longer have.
• With this patch you are asserting that we want something more fine-grained than just "don't outline positions". Then let's have test coverage for that more fine-grained condition checking.

Also, in general, I'm in favor of the position that when you touch things you should take the opportunity to address closely related issues, within reason. That's always a tricky balance, and I don't know what the LLVM project policy is for that fine line, but it seems like something that we should strive for :)

[• pcwang-thead]

Rebase on new test.

[• pcwang-thead]

In D122634#3451886, @luismarques wrote:

In D122634#3447432, @pcwang-thead wrote:

These conditions existed since the first version of outlining implementation (D66210), so we won't see any differences of position instructions even if I added some tests in this patch.

It's been a few days since my original comment so I may be misremembering the details but here's my perspective:

• Before your patch we had test coverage that showed the difference between a plain if (MI.isPosition()) return outliner::InstrType::Illegal; and the then-current implementation.
• With this patch we no longer have.
• With this patch you are asserting that we want something more fine-grained than just "don't outline positions". Then let's have test coverage for that more fine-grained condition checking.

Also, in general, I'm in favor of the position that when you touch things you should take the opportunity to address closely related issues, within reason. That's always a tricky balance, and I don't know what the LLVM project policy is for that fine line, but it seems like something that we should strive for :)

Thank you for your explanation, I misunderstood what you meant :)

So I added some more fine-grained tests in D123364:

• machine-outliner-cfi.mir shows how we treat CFIs if there is no EH.
• machine-outliner-throw.ll shows how we treat CFIs if unwinding is needed.
• machine-outliner-position.mir shows that position instructions(which are labels) are illegal to outline.

Are there some other things that I should pay attention to?

[luismarques]

LGTM. Thanks!

[• pcwang-thead]

Rebase on fixed tests.

[• pcwang-thead]

Trigger buildbot.

llvm/lib/Target/RISCV/RISCVInstrInfo.cpp

RISCVInstrInfo::getOutliningType(MachineBasicBlock::iterator &MBBI,
   MachineBasicBlock *MBB = MI.getParent();
   const TargetRegisterInfo *TRI =
       MBB->getParent()->getSubtarget().getRegisterInfo();
 
   // Positions generally can't safely be outlined.
   if (MI.isPosition()) {
     // We can manually strip out CFI instructions later.
     if (MI.isCFIInstruction())
-      return outliner::InstrType::Invisible;
+      // If current function has exception handling code, we can't outline &
+      // strip these CFI instructions since it may break .eh_frame section
+      // needed in unwinding.
+      return MI.getMF()->getFunction().needsUnwindTableEntry()
+                 ? outliner::InstrType::Illegal
+                 : outliner::InstrType::Invisible;
 
     return outliner::InstrType::Illegal;
   }
 
   // Don't trust the user to write safe inline assembly.
   if (MI.isInlineAsm())
     return outliner::InstrType::Illegal;
 

llvm/test/CodeGen/RISCV/machine-outliner-throw.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -verify-machineinstrs -enable-machine-outliner -mattr=+m -mtriple=riscv64 < %s | FileCheck %s
 
 ; Ensure that we won't outline CFIs when they are needed in unwinding.
 
 define i32 @func1(i32 %x) #0 {
 ; CHECK-LABEL: func1:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    call t0, OUTLINED_FUNCTION_0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    mulw a0, a0, a0
+; CHECK-NEXT:    addiw s0, a0, 1
+; CHECK-NEXT:    li a0, 4
 ; CHECK-NEXT:    call __cxa_allocate_exception@plt
 ; CHECK-NEXT:    sw s0, 0(a0)
 ; CHECK-NEXT:    lui a1, %hi(_ZTIi)
 ; CHECK-NEXT:    addi a1, a1, %lo(_ZTIi)
 ; CHECK-NEXT:    li a2, 0
 ; CHECK-NEXT:    call __cxa_throw@plt
 entry:
   %mul = mul i32 %x, %x
   %add = add i32 %mul, 1
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   %0 = bitcast i8* %exception to i32*
   store i32 %add, i32* %0
   tail call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
 define i32 @func2(i32 %x) #0 {
 ; CHECK-LABEL: func2:
 ; CHECK:       # %bb.0: # %entry
-; CHECK-NEXT:    call t0, OUTLINED_FUNCTION_0
+; CHECK-NEXT:    addi sp, sp, -16
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; CHECK-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; CHECK-NEXT:    .cfi_offset ra, -8
+; CHECK-NEXT:    .cfi_offset s0, -16
+; CHECK-NEXT:    mulw a0, a0, a0
+; CHECK-NEXT:    addiw s0, a0, 1
+; CHECK-NEXT:    li a0, 4
 ; CHECK-NEXT:    call __cxa_allocate_exception@plt
 ; CHECK-NEXT:    sw s0, 0(a0)
 ; CHECK-NEXT:    lui a1, %hi(_ZTIi)
 ; CHECK-NEXT:    addi a1, a1, %lo(_ZTIi)
 ; CHECK-NEXT:    li a2, 0
 ; CHECK-NEXT:    call __cxa_throw@plt
 entry:
   %mul = mul i32 %x, %x
   %add = add i32 %mul, 1
   %exception = tail call i8* @__cxa_allocate_exception(i64 4)
   %0 = bitcast i8* %exception to i32*
   store i32 %add, i32* %0
   tail call void @__cxa_throw(i8* %exception, i8* bitcast (i8** @_ZTIi to i8*), i8* null)
   unreachable
 }
 
-; CHECK-LABEL: OUTLINED_FUNCTION_0:
-; CHECK:       # %bb.0:
-; CHECK-NEXT:    addi sp, sp, -16
-; CHECK-NEXT:    sd ra, 8(sp)
-; CHECK-NEXT:    sd s0, 0(sp)
-; CHECK-NEXT:    mulw a0, a0, a0
-; CHECK-NEXT:    addiw s0, a0, 1
-; CHECK-NEXT:    li a0, 4
-
 @_ZTIi = external constant i8*
 declare i8* @__cxa_allocate_exception(i64)
 declare void @__cxa_throw(i8*, i8*, i8*)
 
 attributes #0 = { minsize noreturn }