CloneModule: Handling cloning ifuncs

[arsenm]

Summary

This is tested in a future llvm-reduce patch.

[aeubanks]

wrong patch uploaded? this is the same as D138524

[arsenm]

correct patch

[aeubanks]

looks fine, but even though the other patch indirectly tests this, can you add to llvm/unittests/Transforms/Utils/CloningTest.cpp?

[arsenm]

Add unit test

[arsenm]

f0693277c7cbe982bcfa5d1a8a9540807f6ec314

llvm/lib/Transforms/Utils/CloneModule.cpp

for (const GlobalAlias &I : M.aliases()) {
     }
     auto *GA = GlobalAlias::create(I.getValueType(),
                                    I.getType()->getPointerAddressSpace(),
                                    I.getLinkage(), I.getName(), New.get());
     GA->copyAttributesFrom(&I);
     VMap[&I] = GA;
   }
 
+  for (const GlobalIFunc &I : M.ifuncs()) {
+    // Defer setting the resolver function until after functions are cloned.
+    auto *GI =
+        GlobalIFunc::create(I.getValueType(), I.getAddressSpace(),
+                            I.getLinkage(), I.getName(), nullptr, New.get());
+    GI->copyAttributesFrom(&I);
+    VMap[&I] = GI;
+  }
+
   // Now that all of the things that global variable initializer can refer to
   // have been created, loop through and copy the global variable referrers
   // over...  We also set the attributes on the global now.
   //
   for (const GlobalVariable &G : M.globals()) {
     GlobalVariable *GV = cast<GlobalVariable>(VMap[&G]);
 
     SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
for (const GlobalAlias &I : M.aliases()) {
     // We already dealt with undefined aliases above.
     if (!ShouldCloneDefinition(&I))
       continue;
     GlobalAlias *GA = cast<GlobalAlias>(VMap[&I]);
     if (const Constant *C = I.getAliasee())
       GA->setAliasee(MapValue(C, VMap));
   }
 
+  for (const GlobalIFunc &I : M.ifuncs()) {
+    GlobalIFunc *GI = cast<GlobalIFunc>(VMap[&I]);
+    if (const Constant *Resolver = I.getResolver())
+      GI->setResolver(MapValue(Resolver, VMap));
+  }
+
   // And named metadata....
   for (const NamedMDNode &NMD : M.named_metadata()) {
     NamedMDNode *NewNMD = New->getOrInsertNamedMetadata(NMD.getName());
     for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
       NewNMD->addOperand(MapMetadata(NMD.getOperand(i), VMap));
   }
 
   return New;

llvm/unittests/Transforms/Utils/CloningTest.cpp

void CreateOldModule() {
     CD->setSelectionKind(Comdat::ExactMatch);
 
     auto GV = new GlobalVariable(
         *OldM, Type::getInt32Ty(C), false, GlobalValue::ExternalLinkage,
         ConstantInt::get(Type::getInt32Ty(C), 1), "gv");
     GV->addMetadata(LLVMContext::MD_type, *MDNode::get(C, {}));
     GV->setComdat(CD);
 
+    // Add ifuncs
+    {
+      const unsigned AddrSpace = 123;
+      auto *FuncPtrTy = Type::getInt8Ty(C)->getPointerTo(123);
+      auto *FuncTy = FunctionType::get(FuncPtrTy, false);
+
+      auto *ResolverF = Function::Create(FuncTy, GlobalValue::PrivateLinkage,
+                                         AddrSpace, "resolver", OldM);
+      BasicBlock *ResolverBody = BasicBlock::Create(C, "", ResolverF);
+      ReturnInst::Create(C, ConstantPointerNull::get(FuncPtrTy), ResolverBody);
+
+      GlobalIFunc *GI = GlobalIFunc::create(FuncTy, AddrSpace,
+                                            GlobalValue::LinkOnceODRLinkage,
+                                            "an_ifunc", ResolverF, OldM);
+      GI->setVisibility(GlobalValue::ProtectedVisibility);
+    }
+
     {
       // Add an empty compile unit first that isn't otherwise referenced, to
       // confirm that compile units get cloned in the correct order.
       DIBuilder EmptyBuilder(*OldM);
       auto *File = EmptyBuilder.createFile("empty.c", "/file/dir/");
       (void)EmptyBuilder.createCompileUnit(dwarf::DW_LANG_C99, File,
                                            "EmptyUnit", false, "", 0);
       EmptyBuilder.finalize();
TEST_F(CloneModule, Comdat) {
   auto *CD = NewGV->getComdat();
   ASSERT_NE(nullptr, CD);
   EXPECT_EQ("comdat", CD->getName());
   EXPECT_EQ(Comdat::ExactMatch, CD->getSelectionKind());
 
   Function *NewF = NewM->getFunction("f");
   EXPECT_EQ(CD, NewF->getComdat());
 }
+
+TEST_F(CloneModule, IFunc) {
+  ASSERT_EQ(1u, NewM->ifunc_size());
+
+  const GlobalIFunc &IFunc = *NewM->ifunc_begin();
+  EXPECT_EQ("an_ifunc", IFunc.getName());
+  EXPECT_EQ(GlobalValue::LinkOnceODRLinkage, IFunc.getLinkage());
+  EXPECT_EQ(GlobalValue::ProtectedVisibility, IFunc.getVisibility());
+  EXPECT_EQ(123u, IFunc.getAddressSpace());
+
+  const Function *Resolver = IFunc.getResolverFunction();
+  ASSERT_NE(nullptr, Resolver);
+  EXPECT_EQ("resolver", Resolver->getName());
+  EXPECT_EQ(GlobalValue::PrivateLinkage, Resolver->getLinkage());
+}
 }