[llvm] [BPF] Handle unreachable with a unimplemented 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);
----------------
yonghong-song wrote:

I did some experiment with 10 local variables around the code, something like
```
<some other codes>
int a, b, c, d, e, f, g, h;
a = ip6->priority; b = ip6->version; c = ip6->payload_len; d = ip6->nexhdr;
e = ip6->hop_limit; f = ip6->flow_lbl[0]; g = ip6->flow_lbl[1]; h = ip6->lbl[2];
<some code which eventually becomes bpf_reachable>
bpf_printk("...", a, b, c, d, e, f, g, h);
```
During IR optimizations, at some point, it becomes
```
<some other codes>
int a, b, c, d, e, f, g, h;
a = ip6->priority; b = ip6->version; c = ip6->payload_len; d = ip6->nexhdr;
e = ip6->hop_limit; f = ip6->flow_lbl[0]; g = ip6->flow_lbl[1]; h = ip6->lbl[2];
unreachable
```
And further optimization it becomes
```
<some other codes>
unreachable
```
So in practice, we won't have heavy register pressure around 'unreachable' insn. So I think calling convention C should be okay.

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