[llvm] [BPF] Handle unreachable with a kfunc call (PR #131731)

[via llvm-commits]

================
@@ -726,6 +733,38 @@ SDValue BPFTargetLowering::LowerATOMIC_LOAD_STORE(SDValue Op,
   return Op;
 }
 
+SDValue BPFTargetLowering::LowerTRAP(SDValue Op, SelectionDAG &DAG) const {
+  MachineFunction &MF = DAG.getMachineFunction();
+  Function &F = MF.getFunction();
+  if (F.hasFnAttribute(Attribute::Naked))
+    return Op;
+
+  TargetLowering::CallLoweringInfo CLI(DAG);
+  SmallVector<SDValue> InVals;
+  SDNode *N = Op.getNode();
+  SDLoc DL(N);
+
+  Module *M = MF.getFunction().getParent();
+  FunctionType *FT = FunctionType::get(Type::getVoidTy(M->getContext()), false);
+  Function *UnreachableHelper = M->getFunction("__unreachable_helper");
+  if (!UnreachableHelper) {
+    Function *NewF = Function::Create(FT, GlobalValue::ExternalWeakLinkage,
+                                      "__unreachable_helper", M);
+    NewF->setDSOLocal(true);
+    NewF->setCallingConv(CallingConv::C);
----------------
eddyz87 wrote:

I see, my example was broken because of calls to `bar()` that needed stack spill, sorry about that.
If changed to something like  [this](https://github.com/user-attachments/files/19399316/test6.ll.txt), there are no spills generated. But this makes me wonder how does it work:

```
$ llc -debug-only=isel -mtriple=bpfel -mcpu=v3 < test6.ll
...
*** MachineFunction at end of ISel ***
# Machine code for function foo: IsSSA, TracksLiveness
Function Live Ins: $w1 in %9, $r3 in %11

bb.0.entry:
  successors: %bb.2(0x80000000), %bb.1(0x00000000); %bb.2(100.00%), %bb.1(0.00%)
  liveins: $w1, $r3
  %11:gpr = COPY $r3
  %9:gpr32 = COPY $w1
  %0:gpr32 = LDW32 %11:gpr, 0 :: (volatile load (s32) from %ir.ap1)
  %1:gpr32 = LDW32 %11:gpr, 4 :: (volatile load (s32) from %ir.bp)
  %2:gpr32 = LDW32 %11:gpr, 8 :: (volatile load (s32) from %ir.cp)
  %3:gpr32 = LDW32 %11:gpr, 12 :: (volatile load (s32) from %ir.dp)
  %4:gpr32 = LDW32 %11:gpr, 16 :: (volatile load (s32) from %ir.ep)
  %5:gpr32 = LDW32 %11:gpr, 20 :: (volatile load (s32) from %ir.fp)
  %6:gpr32 = LDW32 %11:gpr, 24 :: (volatile load (s32) from %ir.gp)
  %7:gpr32 = LDW32 %11:gpr, 28 :: (volatile load (s32) from %ir.hp)
  %8:gpr32 = LDW32 %11:gpr, 32 :: (volatile load (s32) from %ir.kp)
  %12:gpr32 = AND_ri_32 %9:gpr32(tied-def 0), 1
  JNE_ri_32 killed %12:gpr32, 0, %bb.2
  JMP %bb.1

bb.1.flabel:
; predecessors: %bb.0

  ADJCALLSTACKDOWN 0, 0, implicit-def dead $r11, implicit $r11
  JAL &__unreachable_helper, <regmask $r6 $r7 $r8 $r9 $r10 $w6 $w7 $w8 $w9 $w10>, implicit $r11, implicit-def $r11
  ADJCALLSTACKUP 0, 0, implicit-def dead $r11, implicit $r11

bb.2.tlabel:
; predecessors: %bb.0

  %13:gpr32 = ADD_rr_32 %0:gpr32(tied-def 0), %1:gpr32
  %14:gpr32 = ADD_rr_32 %13:gpr32(tied-def 0), %2:gpr32
  %15:gpr32 = ADD_rr_32 %14:gpr32(tied-def 0), %3:gpr32
  %16:gpr32 = ADD_rr_32 %15:gpr32(tied-def 0), %4:gpr32
  %17:gpr32 = ADD_rr_32 %16:gpr32(tied-def 0), %5:gpr32
  %18:gpr32 = ADD_rr_32 %17:gpr32(tied-def 0), %6:gpr32
  %19:gpr32 = ADD_rr_32 %18:gpr32(tied-def 0), %7:gpr32
  %20:gpr32 = ADD_rr_32 %19:gpr32(tied-def 0), %8:gpr32
  ADJCALLSTACKDOWN 0, 0, implicit-def dead $r11, implicit $r11
  $w1 = COPY %20:gpr32
  JAL @buz, <regmask $r6 $r7 $r8 $r9 $r10 $w6 $w7 $w8 $w9 $w10>, implicit $r11, implicit $w1, implicit-def $r11
  ADJCALLSTACKUP 0, 0, implicit-def dead $r11, implicit $r11
  RET
...
```

Note that basic block `bb.1.flabel` does not have terminator after the `__unreachable_helper` call. Is it ok?
Is it necessary to mark to add `CLI.DoesNotReturn = true` in `LowerTRAP`?


https://github.com/llvm/llvm-project/pull/131731