[cfi] Cross-DSO CFI diagnostic mode (llvm part)

[eugenis]

Summary

• __cfi_check gets a 3rd argument: ubsan handler data
• instead of trapping on failure, call __cfi_check_fail which must be present in the module (generated in the frontend).

[pcc]

It doesn't need to be done now, but I think we should consider moving most of the functionality from this pass to Clang. We could consider introducing an intrinsic that looks like this:

i1 @llvm.bitset.test.i64(i8* %addr, i64 %id)

Then Clang can emit a __cfi_check function with weak-odr linkage that uses this intrinsic.

lib/Transforms/IPO/CrossDSOCFI.cpp

116

Type::getInt8PtrTy

135

Use getOrCreateFunction, the function could be defined externally or have a different signature.

test/Transforms/CrossDSOCFI/basic.ll

16

CHECK-NEXT

[pcc]

LGTM

lib/Transforms/IPO/CrossDSOCFI.cpp

138

You no longer need to assert here.

[eugenis]

http://reviews.llvm.org/rL258746

lib/Transforms/IPO/CrossDSOCFI.cpp

void CrossDSOCFI::buildCFICheck() {
   if (BitSetNM)
     for (unsigned I = 0, E = BitSetNM->getNumOperands(); I != E; ++I)
       if (ConstantInt *TypeId = extractBitSetTypeId(BitSetNM->getOperand(I)))
         BitSetIds.insert(TypeId->getZExtValue());
 
   LLVMContext &Ctx = M->getContext();
   Constant *C = M->getOrInsertFunction(
       "__cfi_check",
-      FunctionType::get(
-          Type::getVoidTy(Ctx),
-          {Type::getInt64Ty(Ctx), PointerType::getUnqual(Type::getInt8Ty(Ctx))},
+      FunctionType::get(Type::getVoidTy(Ctx),
+                        {Type::getInt64Ty(Ctx),
+                         PointerType::getUnqual(Type::getInt8Ty(Ctx)),
+                         PointerType::getUnqual(Type::getInt8Ty(Ctx))},
                         false));
   Function *F = dyn_cast<Function>(C);
   F->setAlignment(4096);
   auto args = F->arg_begin();
-  Argument &CallSiteTypeId = *(args++);
+  Value &CallSiteTypeId = *(args++);
   CallSiteTypeId.setName("CallSiteTypeId");
-  Argument &Addr = *(args++);
+  Value &Addr = *(args++);
   Addr.setName("Addr");
+  Value &CFICheckFailData = *(args++);
+  CFICheckFailData.setName("CFICheckFailData");
   assert(args == F->arg_end());
 
   BasicBlock *BB = BasicBlock::Create(Ctx, "entry", F);
+  BasicBlock *ExitBB = BasicBlock::Create(Ctx, "exit", F);
 
-  BasicBlock *TrapBB = BasicBlock::Create(Ctx, "trap", F);
-  IRBuilder<> IRBTrap(TrapBB);
-  Function *TrapFn = Intrinsic::getDeclaration(M, Intrinsic::trap);
-  llvm::CallInst *TrapCall = IRBTrap.CreateCall(TrapFn);
-  TrapCall->setDoesNotReturn();
-  TrapCall->setDoesNotThrow();
-  IRBTrap.CreateUnreachable();
+  BasicBlock *TrapBB = BasicBlock::Create(Ctx, "fail", F);
+  IRBuilder<> IRBFail(TrapBB);
+  Function *CFICheckFailFn = M->getFunction("__cfi_check_fail");
+  assert(CFICheckFailFn || "Module is missing a __cfi_check_fail function");
+  IRBFail.CreateCall(CFICheckFailFn, {&CFICheckFailData, &Addr});
+  IRBFail.CreateBr(ExitBB);
 
-  BasicBlock *ExitBB = BasicBlock::Create(Ctx, "exit", F);
   IRBuilder<> IRBExit(ExitBB);
   IRBExit.CreateRetVoid();
 
   IRBuilder<> IRB(BB);
   SwitchInst *SI = IRB.CreateSwitch(&CallSiteTypeId, TrapBB, BitSetIds.size());
   for (uint64_t TypeId : BitSetIds) {
     ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId);
     BasicBlock *TestBB = BasicBlock::Create(Ctx, "test", F);

test/Transforms/CrossDSOCFI/basic.ll

 ; RUN: opt -S -cross-dso-cfi < %s | FileCheck %s
 
-; CHECK:     define void @__cfi_check(i64 %[[TYPE:.*]], i8* %[[ADDR:.*]]) align 4096
-; CHECK:     switch i64 %[[TYPE]], label %[[TRAP:.*]] [
+; CHECK:     define void @__cfi_check(i64 %[[TYPE:.*]], i8* %[[ADDR:.*]], i8* %[[DATA:.*]]) align 4096
+; CHECK:     switch i64 %[[TYPE]], label %[[FAIL:.*]] [
 ; CHECK-NEXT:   i64 111, label %[[L1:.*]]
 ; CHECK-NEXT:   i64 222, label %[[L2:.*]]
 ; CHECK-NEXT:   i64 333, label %[[L3:.*]]
 ; CHECK-NEXT:   i64 444, label %[[L4:.*]]
 ; CHECK-NEXT: {{]$}}
 
-; CHECK:     [[TRAP]]:
-; CHECK-NEXT:   call void @llvm.trap()
-; CHECK-MEXT:   unreachable
-
 ; CHECK:     [[EXIT:.*]]:
 ; CHECK-NEXT:   ret void
 
+; CHECK:     [[FAIL]]:
+; CHECK-NEXT:   call void @__cfi_check_fail(i8* %[[DATA]], i8* %[[ADDR]])
+; CHECK-MEXT:   br label %[[EXIT]]
+
 ; CHECK:     [[L1]]:
 ; CHECK-NEXT:   call i1 @llvm.bitset.test(i8* %[[ADDR]], metadata i64 111)
-; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[TRAP]]
+; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[FAIL]]
 
 ; CHECK:     [[L2]]:
 ; CHECK-NEXT:   call i1 @llvm.bitset.test(i8* %[[ADDR]], metadata i64 222)
-; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[TRAP]]
+; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[FAIL]]
 
 ; CHECK:     [[L3]]:
 ; CHECK-NEXT:   call i1 @llvm.bitset.test(i8* %[[ADDR]], metadata i64 333)
-; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[TRAP]]
+; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[FAIL]]
 
 ; CHECK:     [[L4]]:
 ; CHECK-NEXT:   call i1 @llvm.bitset.test(i8* %[[ADDR]], metadata i64 444)
-; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[TRAP]]
+; CHECK-NEXT:   br {{.*}} label %[[EXIT]], label %[[FAIL]]
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @_ZTV1A = constant i8 0
 @_ZTI1A = constant i8 0
 @_ZTS1A = constant i8 0
 @_ZTV1B = constant i8 0
entry:
   ret i32 4
 }
 
 define i32 @f22() {
 entry:
   ret i32 5
 }
 
+define weak_odr hidden void @__cfi_check_fail(i8*, i8*) {
+entry:
+  ret void
+}
+
 !llvm.bitsets = !{!0, !1, !2, !3, !4, !7, !8, !9, !10, !11, !12, !13, !14, !15}
 !llvm.module.flags = !{!17}
 
 !0 = !{!"_ZTSFcvE", i8 ()* @f11, i64 0}
 !1 = !{i64 111, i8 ()* @f11, i64 0}
 !2 = !{!"_ZTSFcvE", i8 ()* @f12, i64 0}
 !3 = !{i64 111, i8 ()* @f12, i64 0}
 !4 = !{!"_ZTSFcvE", i8 ()* @f13, i64 0}