Use Module level target-abi to assign target features for codegenerated functions.

llvm/include/llvm/IR/Function.h

@@ -190,6 +190,8 @@ class LLVM_ABI Function : public GlobalObject, public ilist_node<Function> {
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N, Module &M);
 
+  StringRef getDefaultTargetFeatures(const StringRef TargetABI);
+
   /// Creates a function with some attributes recorded in llvm.module.flags
   /// and the LLVMContext applied.
   ///

llvm/include/llvm/IR/Module.h

@@ -1065,6 +1065,9 @@ class LLVM_ABI Module {
 
   /// Set the target variant version build SDK version metadata.
   void setDarwinTargetVariantSDKVersion(VersionTuple Version);
+
+  /// Returns target-abi from MDString, null if target-abi is absent.
+  StringRef getTargetABIFromMD();
 };
 
 /// Given "llvm.used" or "llvm.compiler.used" as a global name, collect the

llvm/lib/IR/Function.cpp

@@ -48,6 +48,7 @@
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ModRef.h"
+#include "llvm/TargetParser/Triple.h"
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -387,6 +388,26 @@ Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
   return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
 }
 
+StringRef Function::getDefaultTargetFeatures(const StringRef TargetABI) {
+  Triple T(getParent()->getTargetTriple());
+  StringRef Attr = "";
+  if (T.isRISCV64()) {
+    if (TargetABI.equals_insensitive("lp64d"))
+      Attr = "+d";
+    else if (TargetABI.equals_insensitive("lp64f"))
+      Attr = "+f";
+  } else if (T.isRISCV32()) {
+    if (TargetABI.equals_insensitive("ilp32d"))
+      Attr = "+d";
+    else if (TargetABI.equals_insensitive("ilp32f"))
+      Attr = "+f";
+  } else if (T.isARM() || T.isThumb()) {
+    Attr = "+thumb-mode";
+  }
+
+  return Attr;
+}
+
 Function *Function::createWithDefaultAttr(FunctionType *Ty,
                                           LinkageTypes Linkage,
                                           unsigned AddrSpace, const Twine &N,

llvm/lib/IR/Module.cpp

@@ -915,3 +915,11 @@ VersionTuple Module::getDarwinTargetVariantSDKVersion() const {
 void Module::setDarwinTargetVariantSDKVersion(VersionTuple Version) {
   addSDKVersionMD(Version, *this, "darwin.target_variant.SDK Version");
 }
+
+StringRef Module::getTargetABIFromMD() {
+  StringRef TargetABI = "";
+  if (auto *TargetABIMD =
+          dyn_cast_or_null<MDString>(getModuleFlag("target-abi")))
+    TargetABI = TargetABIMD->getString();
+  return TargetABI;
+}

llvm/lib/Transforms/IPO/CrossDSOCFI.cpp

@@ -86,14 +86,20 @@ void CrossDSOCFI::buildCFICheck(Module &M) {
       "__cfi_check", Type::getVoidTy(Ctx), Type::getInt64Ty(Ctx),
       PointerType::getUnqual(Ctx), PointerType::getUnqual(Ctx));
   Function *F = cast<Function>(C.getCallee());
+  std::string DefaultFeatures =
+      F->getContext().getDefaultTargetFeatures().str();
   // Take over the existing function. The frontend emits a weak stub so that the
   // linker knows about the symbol; this pass replaces the function body.
   F->deleteBody();
   F->setAlignment(Align(4096));
 
-  Triple T(M.getTargetTriple());
-  if (T.isARM() || T.isThumb())
-    F->addFnAttr("target-features", "+thumb-mode");
+  // Set existing target-features.
+  if (!DefaultFeatures.empty())
+    F->addFnAttr("target-features", DefaultFeatures);
+
+  DefaultFeatures = F->getDefaultTargetFeatures(M.getTargetABIFromMD());
+  if (!DefaultFeatures.empty())
+    F->addFnAttr("target-features", DefaultFeatures);
 
   auto args = F->arg_begin();
   Value &CallSiteTypeId = *(args++);

llvm/test/Transforms/CrossDSOCFI/riscv.ll

@@ -0,0 +1,19 @@
+; RUN: opt -S -passes=cross-dso-cfi < %s | FileCheck --check-prefix=RISCV64 %s
+
+target datalayout = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
+target triple = "riscv64-unknown-linux-gnu"
+
+define signext i8 @f() !type !0 !type !1 {
+entry:
+  ret i8 1
+}
+
+!llvm.module.flags = !{!2, !3}
+
+!0 = !{i64 0, !"_ZTSFcvE"}
+!1 = !{i64 0, i64 111}
+!2 = !{i32 4, !"Cross-DSO CFI", i32 1}
+!3 = !{i32 1, !"target-abi", !"lp64d"}
+
+; RISCV64: define void @__cfi_check({{.*}} #[[A:.*]] align 4096
+; RISCV64: attributes #[[A]] = { {{.*}}"target-features"="+d"