[CrossDSOCFI] Change the pass so that it doesn't require doInitialization()

[davide]

Summary

Chandler tells me that the equivalent of doInitialization in the new PM is the constructor.
This one, though, doesn't access to the module. I think that for this particular pass doInitialization() can be avoided, so I tried to modify it accordingly. Please let me know if I missed something obvious as I'm not familiar at all with this pass.

[davide]

ping.

[pcc]

I think this patch needs to be refreshed.

lib/Transforms/IPO/CrossDSOCFI.cpp

53 ↗

(On Diff #60775)

Remove this line.

[davide]

Rebased now that Peter patches landed upstream

[pcc]

LGTM

lib/Transforms/IPO/CrossDSOCFI.cpp

49 ↗

(On Diff #63152)

Remove this field.

llvm/trunk/lib/Transforms/IPO/CrossDSOCFI.cpp

 namespace {
 
 struct CrossDSOCFI : public ModulePass {
   static char ID;
   CrossDSOCFI() : ModulePass(ID) {
     initializeCrossDSOCFIPass(*PassRegistry::getPassRegistry());
   }
 
-  Module *M;
   MDNode *VeryLikelyWeights;
 
   ConstantInt *extractNumericTypeId(MDNode *MD);
-  void buildCFICheck();
-
-  bool doInitialization(Module &M) override;
+  void buildCFICheck(Module &M);
   bool runOnModule(Module &M) override;
 };
 
 } // anonymous namespace
 
 INITIALIZE_PASS_BEGIN(CrossDSOCFI, "cross-dso-cfi", "Cross-DSO CFI", false,
                       false)
 INITIALIZE_PASS_END(CrossDSOCFI, "cross-dso-cfi", "Cross-DSO CFI", false, false)
 char CrossDSOCFI::ID = 0;
 
 ModulePass *llvm::createCrossDSOCFIPass() { return new CrossDSOCFI; }
 
-bool CrossDSOCFI::doInitialization(Module &Mod) {
-  M = &Mod;
-  VeryLikelyWeights =
-      MDBuilder(M->getContext()).createBranchWeights((1U << 20) - 1, 1);
-
-  return false;
-}
-
 /// Extracts a numeric type identifier from an MDNode containing type metadata.
 ConstantInt *CrossDSOCFI::extractNumericTypeId(MDNode *MD) {
   // This check excludes vtables for classes inside anonymous namespaces.
   auto TM = dyn_cast<ValueAsMetadata>(MD->getOperand(1));
   if (!TM)
     return nullptr;
   auto C = dyn_cast_or_null<ConstantInt>(TM->getValue());
   if (!C) return nullptr;
   // We are looking for i64 constants.
   if (C->getBitWidth() != 64) return nullptr;
 
   return C;
 }
 
 /// buildCFICheck - emits __cfi_check for the current module.
-void CrossDSOCFI::buildCFICheck() {
+void CrossDSOCFI::buildCFICheck(Module &M) {
   // FIXME: verify that __cfi_check ends up near the end of the code section,
   // but before the jump slots created in LowerTypeTests.
   llvm::DenseSet<uint64_t> TypeIds;
   SmallVector<MDNode *, 2> Types;
-  for (GlobalObject &GO : M->global_objects()) {
+  for (GlobalObject &GO : M.global_objects()) {
     Types.clear();
     GO.getMetadata(LLVMContext::MD_type, Types);
     for (MDNode *Type : Types) {
       // Sanity check. GO must not be a function declaration.
       assert(!isa<Function>(&GO) || !cast<Function>(&GO)->isDeclaration());
 
       if (ConstantInt *TypeId = extractNumericTypeId(Type))
         TypeIds.insert(TypeId->getZExtValue());
     }
   }
 
-  LLVMContext &Ctx = M->getContext();
-  Constant *C = M->getOrInsertFunction(
+  LLVMContext &Ctx = M.getContext();
+  Constant *C = M.getOrInsertFunction(
       "__cfi_check", Type::getVoidTy(Ctx), Type::getInt64Ty(Ctx),
       Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx), nullptr);
   Function *F = dyn_cast<Function>(C);
   F->setAlignment(4096);
   auto args = F->arg_begin();
   Value &CallSiteTypeId = *(args++);
   CallSiteTypeId.setName("CallSiteTypeId");
   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, "fail", F);
   IRBuilder<> IRBFail(TrapBB);
-  Constant *CFICheckFailFn = M->getOrInsertFunction(
+  Constant *CFICheckFailFn = M.getOrInsertFunction(
       "__cfi_check_fail", Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx),
       Type::getInt8PtrTy(Ctx), nullptr);
   IRBFail.CreateCall(CFICheckFailFn, {&CFICheckFailData, &Addr});
   IRBFail.CreateBr(ExitBB);
 
   IRBuilder<> IRBExit(ExitBB);
   IRBExit.CreateRetVoid();
 
   IRBuilder<> IRB(BB);
   SwitchInst *SI = IRB.CreateSwitch(&CallSiteTypeId, TrapBB, TypeIds.size());
   for (uint64_t TypeId : TypeIds) {
     ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId);
     BasicBlock *TestBB = BasicBlock::Create(Ctx, "test", F);
     IRBuilder<> IRBTest(TestBB);
-    Function *BitsetTestFn = Intrinsic::getDeclaration(M, Intrinsic::type_test);
+    Function *BitsetTestFn = Intrinsic::getDeclaration(&M, Intrinsic::type_test);
 
     Value *Test = IRBTest.CreateCall(
         BitsetTestFn, {&Addr, MetadataAsValue::get(
                                   Ctx, ConstantAsMetadata::get(CaseTypeId))});
     BranchInst *BI = IRBTest.CreateCondBr(Test, ExitBB, TrapBB);
     BI->setMetadata(LLVMContext::MD_prof, VeryLikelyWeights);
 
     SI->addCase(CaseTypeId, TestBB);
     ++NumTypeIds;
   }
 }
 
 bool CrossDSOCFI::runOnModule(Module &M) {
   if (skipModule(M))
     return false;
 
+  VeryLikelyWeights =
+    MDBuilder(M.getContext()).createBranchWeights((1U << 20) - 1, 1);
   if (M.getModuleFlag("Cross-DSO CFI") == nullptr)
     return false;
-  buildCFICheck();
+  buildCFICheck(M);
   return true;
 }