[ClR] Set optnone attrbiute for functions.

Summary:
Setting the Optnone attribute for CIR functions and progating it all the way down to LLVM IR for those not supposed to be optimized.

Author: htyu

clang/include/clang/CIR/Dialect/IR/CIRAttrs.td

@@ -26,6 +26,14 @@ class CIR_Attr<string name, string attrMnemonic, list<Trait> traits = []>
   let mnemonic = attrMnemonic;
 }
 
+class CIR_Unit_Attr<string name, string attrMnemonic, list<Trait> traits = []>
+    : CIR_Attr<name, attrMnemonic, traits> {
+  let returnType = "bool";
+  let defaultValue = "false";
+  let valueType = NoneType;
+  let isOptional = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // NullAttr
 //===----------------------------------------------------------------------===//
@@ -351,4 +359,13 @@ def ASTFunctionDeclAttr : ASTDecl<"FunctionDecl", "fndecl">;
 def ASTVarDeclAttr : ASTDecl<"VarDecl", "vardecl">;
 def ASTRecordDeclAttr : ASTDecl<"RecordDecl", "recdecl">;
 
+
+def OptnoneAttr : CIR_Unit_Attr<"Optnone", "optnone"> {
+  let storageType = [{ OptnoneAttr }];
+}
+
+def NoInlineAttr : CIR_Attr<"NoInline",  "noInline">  {
+  let storageType = [{ NoInlineAttr }];
+}
+
 #endif // MLIR_CIR_DIALECT_CIR_ATTRS

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -1664,6 +1664,9 @@ CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
         builder.getContext(), mlir::cir::GlobalLinkageKind::ExternalLinkage));
     mlir::SymbolTable::setSymbolVisibility(
         f, mlir::SymbolTable::Visibility::Private);
+
+    setCodegenAttributesForFunc(f, FD);
+
     if (!curCGF)
       theModule.push_back(f);
   }
@@ -1689,6 +1692,27 @@ mlir::Location CIRGenModule::getLocForFunction(const clang::FunctionDecl *FD) {
   return theModule->getLoc();
 }
 
+void CIRGenModule::setCodegenAttributesForFunc(FuncOp f,
+                                         const clang::FunctionDecl *FD) {
+  llvm::SmallVector<mlir::Attribute, 4> attrs;
+
+  // Track whether we need to add the optnone attribute,
+  // starting with the default for this optimization level.
+  bool ShouldAddOptNone =
+      !codeGenOpts.DisableO0ImplyOptNone && codeGenOpts.OptimizationLevel == 0;
+  ShouldAddOptNone &= !FD->hasAttr<MinSizeAttr>();
+  ShouldAddOptNone &= !FD->hasAttr<AlwaysInlineAttr>();
+
+  if ((ShouldAddOptNone || FD->hasAttr<OptimizeNoneAttr>())) {
+    attrs.push_back(mlir::cir::OptnoneAttr::get(builder.getContext()));
+
+    // OptimizeNone implies noinline; we should not be inlining such functions.
+    attrs.push_back(mlir::cir::NoInlineAttr::get(builder.getContext()));
+  }
+
+  f->setAttr("cir.funcAttr", mlir::ArrayAttr::get(builder.getContext(), attrs));
+}
+
 /// If the specified mangled name is not in the module,
 /// create and return a CIR Function with the specified type. If there is
 /// something in the module with the specified name, return it potentially

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -518,6 +518,9 @@ class CIRGenModule : public CIRGenTypeCache {
 
   mlir::Location getLocForFunction(const clang::FunctionDecl *FD);
 
+  void setCodegenAttributesForFunc(mlir::cir::FuncOp f,
+                             const clang::FunctionDecl *FD);
+
   // TODO: CodeGen also passes an AttributeList here. We'll have to match that
   // in CIR
   mlir::cir::FuncOp

clang/lib/CIR/Lowering/DirectToLLVM/LowerAttrToLLVMIR.cpp

@@ -10,8 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/DialectRegistry.h"
 #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h"
+#include "mlir/Target/LLVMIR/ModuleTranslation.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Passes.h"
 
@@ -34,6 +37,20 @@ class CIRDialectLLVMIRTranslationInterface
   amendOperation(mlir::Operation *op, mlir::NamedAttribute attribute,
                  mlir::LLVM::ModuleTranslation &moduleTranslation) const final {
     // TODO: Implement this
+    auto func = dyn_cast<mlir::LLVM::LLVMFuncOp>(op);
+    if (!func)
+      return mlir::success();
+    llvm::Function *llvmFunc = moduleTranslation.lookupFunction(func.getName());
+    if (attribute.getName() == "cir.funcAttr") {
+      auto arrayAttr = attribute.getValue().dyn_cast<mlir::ArrayAttr>();
+      assert(arrayAttr && " cir.funcAttr should be an array.");
+      for (auto attr : arrayAttr) {
+        if (auto optnone = attr.dyn_cast<mlir::cir::OptnoneAttr>())
+          llvmFunc->addFnAttr(llvm::Attribute::OptimizeNone);
+        else if (auto optnone = attr.dyn_cast<mlir::cir::NoInlineAttr>())
+          llvmFunc->addFnAttr(llvm::Attribute::NoInline);
+      }
+    }
     return mlir::success();
   }
 };

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -655,6 +655,28 @@ class CIRFuncLowering : public mlir::OpConversionPattern<mlir::cir::FuncOp> {
 public:
   using OpConversionPattern<mlir::cir::FuncOp>::OpConversionPattern;
 
+  /// Returns the name used for the linkage attribute. This *must* correspond to
+  /// the name of the attribute in ODS.
+  static StringRef getLinkageAttrNameString() { return "linkage"; }
+
+  /// Only retain those attributes that are not constructed by
+  /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
+  /// attributes.
+  static void filterFuncAttributes(mlir::cir::FuncOp func,
+                            bool filterArgAndResAttrs,
+                            SmallVectorImpl<mlir::NamedAttribute> &result) {
+    for (const auto &attr : func->getAttrs()) {
+      if (attr.getName() == mlir::SymbolTable::getSymbolAttrName() ||
+          attr.getName() == func.getFunctionTypeAttrName() ||
+          attr.getName() == getLinkageAttrNameString() ||
+          (filterArgAndResAttrs &&
+           (attr.getName() == func.getArgAttrsAttrName() ||
+            attr.getName() == func.getResAttrsAttrName())))
+        continue;
+      result.push_back(attr);
+    }
+  }
+
   mlir::LogicalResult
   matchAndRewrite(mlir::cir::FuncOp op, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
@@ -690,9 +712,14 @@ class CIRFuncLowering : public mlir::OpConversionPattern<mlir::cir::FuncOp> {
       Loc = FusedLoc.getLocations()[0];
     }
     assert(Loc.isa<mlir::FileLineColLoc>() && "expected single location here");
+
     auto linkage = convertLinkage(op.getLinkage());
-    auto fn = rewriter.create<mlir::LLVM::LLVMFuncOp>(Loc, op.getName(),
-                                                      llvmFnTy, linkage);
+    SmallVector<mlir::NamedAttribute, 4> attributes;
+    filterFuncAttributes(op, /*filterArgAndResAttrs=*/false, attributes);
+
+    auto fn = rewriter.create<mlir::LLVM::LLVMFuncOp>(
+        Loc, op.getName(), llvmFnTy, linkage, false, mlir::LLVM::CConv::C,
+        attributes);
 
     rewriter.inlineRegionBefore(op.getBody(), fn.getBody(), fn.end());
     if (failed(rewriter.convertRegionTypes(&fn.getBody(), *typeConverter,

clang/test/CIR/CodeGen/optnone.cpp

@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -O0 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR-O0
+// RUN: %clang_cc1 -O0 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM-O0
+
+// RUN: %clang_cc1 -O2 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-cir %s -o %t2.cir
+// RUN: FileCheck --input-file=%t2.cir %s -check-prefix=CIR-O2
+// RUN: %clang_cc1 -O2 -triple x86_64-unknown-linux-gnu -fclangir-enable -emit-llvm %s -o %t2.ll
+// RUN: FileCheck --input-file=%t2.ll %s -check-prefix=LLVM-O2
+
+int s0(int a, int b) {
+  int x = a + b;
+  if (x > 0)
+    x = 0;
+  else
+    x = 1;
+  return x;
+}
+
+// CIR-O0:   cir.func @_Z2s0ii(%arg0:{{.*}}, %arg1:{{.*}} -> {{.*}} attributes {cir.funcAttr = [#cir.optnone, #cir.noInline]}
+// CIR-O2-NOT:   cir.func @_Z2s0ii(%arg0:{{.*}}, %arg1:{{.*}} -> {{.*}} attributes {cir.funcAttr = [#cir.optnone, #cir.noInline]}
+
+// LLVM-O0: define i32 @_Z2s0ii(i32 %0, i32 %1) #[[#ATTR:]]
+// LLVM-O0: attributes #[[#ATTR]] = { noinline optnone }
+// LLVM-O2-NOT: attributes #[[#]] = { noinline optnone }