Preserve compilation time failure for __builtin_trap()

Without this patch, the code having __builtin_trap() will survive
compilation and the error will be reported in kernel bpf verification.

  $ cat test_trap.c
  int buz(int p) { __builtin_trap(); return 0; }
  $ clang --target=bpf -O2 -g -c test_trap.c
  $

One way to resolve the issue is to utilize the clang option
'-ftrap-function=[name]' ([1]) to trigger compile time failure. For example,

  $ cat test_trap.c
  int buz(int p) { __builtin_trap(); return 0; }
  $ clang --target=bpf -O2 -ftrap-function=__undefined_trap -g -c test_trap.c
  test_trap.c:1:18: error: A call to built-in function '__undefined_trap' is not supported.
      1 | int buz(int p) { __builtin_trap(); return 0; }
        |                  ^
  1 error generated.
  $

Basically, a user provided option can enable compilation failure.

But compiler can automate this. If user does not have '-ftrap-funciton=[name]'
option, compiler can provide a default unimplemented trap function and
that will trigger the compilation failure.

So with this patch, for the same above source code, we have
  $ clang --target=bpf -O2 -g -c test_trap.c
  test_trap.c:1:18: error: A call to built-in function '__bpf_unimpl_trap_func' is not supported.
      1 | int buz(int p) { __builtin_trap(); return 0; }
        |                  ^
  1 error generated.
  $

  [1] https://clang.llvm.org/docs/UsersManual.html

Author: Yonghong Song

llvm/lib/Target/BPF/BPFCheckAndAdjustIR.cpp

@@ -26,6 +26,7 @@
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/IntrinsicsBPF.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
@@ -55,6 +56,7 @@ class BPFCheckAndAdjustIR final : public ModulePass {
   bool sinkMinMax(Module &M);
   bool removeGEPBuiltins(Module &M);
   bool insertASpaceCasts(Module &M);
+  bool adjustTrapFunc(Module &M);
 };
 } // End anonymous namespace
 
@@ -527,12 +529,43 @@ bool BPFCheckAndAdjustIR::insertASpaceCasts(Module &M) {
   return Changed;
 }
 
+static const char *BPF_UNIMPL_TRAP_FUNC = "__bpf_unimpl_trap_func";
+
+bool BPFCheckAndAdjustIR::adjustTrapFunc(Module &M) {
+  bool Changed = false;
+  for (Function &F : M) {
+    for (BasicBlock &BB : F) {
+      for (Instruction &I : BB) {
+        auto *II = dyn_cast<IntrinsicInst>(&I);
+        if (!II)
+          continue;
+        if (II->getIntrinsicID() != Intrinsic::trap)
+          continue;
+        AttributeList Attrs = II->getAttributes();
+        StringRef TrapFuncName =
+            Attrs.getFnAttr("trap-func-name").getValueAsString();
+        if (TrapFuncName.empty()) {
+          AttributeList NewAttrs =
+              Attrs.removeFnAttribute(F.getContext(), "trap-func-name");
+          NewAttrs = NewAttrs.addFnAttribute(F.getContext(), "trap-func-name",
+                                             BPF_UNIMPL_TRAP_FUNC);
+          II->setAttributes(NewAttrs);
+          Changed = true;
+        }
+      }
+    }
+  }
+
+  return Changed;
+}
+
 bool BPFCheckAndAdjustIR::adjustIR(Module &M) {
   bool Changed = removePassThroughBuiltin(M);
   Changed = removeCompareBuiltin(M) || Changed;
   Changed = sinkMinMax(M) || Changed;
   Changed = removeGEPBuiltins(M) || Changed;
   Changed = insertASpaceCasts(M) || Changed;
+  Changed = adjustTrapFunc(M) || Changed;
   return Changed;
 }