[CIR] Add code generation options to lowering context

Lancern · Lancern · commit aaae2e580171 · 2024-11-27T01:02:33.000+08:00
This patch adds `clang::CodeGenOptions` to the lowering context. Similar to
`clang::LangOptions`, the code generation options are currently set to the
default values when initializing the lowering context.

Besides, this patch also adds a new attribute `#cir.opt_level`. The attribute is
a module-level attribute and it holds the optimization level (e.g. -O1, -Oz,
etc.). The attribute is consumed when initializing the lowering context to
populate the OptimizationLevel and the OptimizeSize field in the code generation
options. CIRGen is updated to attach this attribute to the module op.
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td
@@ -73,6 +73,25 @@ def LangAttr : CIR_Attr<"Lang", "lang"> {
   let genVerifyDecl = 0;
 }
 
+//===----------------------------------------------------------------------===//
+// OptLevelAttr
+//===----------------------------------------------------------------------===//
+
+def CIR_OptLevelAttr : CIR_Attr<"OptLevel", "opt_level"> {
+  let summary = "A module-level attribute that holds the optimization level";
+  let description = [{
+    The `#cir.opt_level` attribute holds the optimization level of the module.
+    This attribute is attached to the module operation during CIRGen.
+  }];
+
+  let parameters = (ins "unsigned":$optLevel, "unsigned":$optSizeLevel);
+
+  let assemblyFormat = [{
+    `<` `opt_level` `=` $optLevel `,` `opt_size` `=` $optSizeLevel `>`
+  }];
+  let genVerifyDecl = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // BoolAttr
 //===----------------------------------------------------------------------===//
diff --git a/clang/include/clang/CIR/Dialect/IR/CIRDialect.td b/clang/include/clang/CIR/Dialect/IR/CIRDialect.td
@@ -37,6 +37,7 @@ def CIR_Dialect : Dialect {
     static llvm::StringRef getSOBAttrName() { return "cir.sob"; }
     static llvm::StringRef getLangAttrName() { return "cir.lang"; }
     static llvm::StringRef getTripleAttrName() { return "cir.triple"; }
+    static llvm::StringRef getOptLevelAttrName() { return "cir.opt_level"; }
 
     static llvm::StringRef getGlobalCtorsAttrName() { return "cir.global_ctors"; }
     static llvm::StringRef getGlobalDtorsAttrName() { return "cir.global_dtors"; }
diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h
@@ -379,6 +379,11 @@ struct MissingFeatures {
   // just yet. Right now, it only instantiates the default lang options.
   static bool langOpts() { return false; }
 
+  // CodeGenOpts may affect lowering, but we do not carry this information into
+  // CIR just yet. Right now, it only instantiates the default code generation
+  // options.
+  static bool codeGenOpts() { return false; }
+
   // Several type qualifiers are not yet supported in CIR, but important when
   // evaluating ABI-specific lowering.
   static bool qualifiedTypes() { return false; }
diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp
@@ -192,6 +192,10 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &context,
                      cir::LangAttr::get(&context, lang));
   theModule->setAttr(cir::CIRDialect::getTripleAttrName(),
                      builder.getStringAttr(getTriple().str()));
+  if (CGO.OptimizationLevel > 0 || CGO.OptimizeSize > 0)
+    theModule->setAttr(cir::CIRDialect::getOptLevelAttrName(),
+                       cir::OptLevelAttr::get(&context, CGO.OptimizationLevel,
+                                              CGO.OptimizeSize));
   // Set the module name to be the name of the main file. TranslationUnitDecl
   // often contains invalid source locations and isn't a reliable source for the
   // module location.
diff --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp
@@ -214,6 +214,23 @@ void LangAttr::print(AsmPrinter &printer) const {
   printer << "<" << getLang().getValue() << '>';
 }
 
+//===----------------------------------------------------------------------===//
+// OptLevelAttr definitions
+//===----------------------------------------------------------------------===//
+
+LogicalResult OptLevelAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                   unsigned optLevel, unsigned optSizeLevel) {
+  if (optLevel > 3) {
+    emitError() << "invalid optimization level";
+    return failure();
+  }
+  if (optSizeLevel > 2) {
+    emitError() << "invalid size optimization level";
+    return failure();
+  }
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // ConstPtrAttr definitions
 //===----------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRLowerContext.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRLowerContext.cpp
@@ -19,12 +19,15 @@
 #include "clang/CIR/MissingFeatures.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cmath>
+#include <utility>
 
 namespace cir {
 
 CIRLowerContext::CIRLowerContext(mlir::ModuleOp module,
-                                 clang::LangOptions LOpts)
-    : MLIRCtx(module.getContext()), LangOpts(LOpts) {}
+                                 clang::LangOptions LOpts,
+                                 clang::CodeGenOptions CGOpts)
+    : MLIRCtx(module.getContext()), LangOpts(std::move(LOpts)),
+      CodeGenOpts(std::move(CGOpts)) {}
 
 CIRLowerContext::~CIRLowerContext() {}
 
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRLowerContext.h b/clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRLowerContext.h
@@ -44,14 +44,18 @@ class CIRLowerContext : public llvm::RefCountedBase<CIRLowerContext> {
   /// this ASTContext object.
   clang::LangOptions LangOpts;
 
+  /// Options for code generation.
+  clang::CodeGenOptions CodeGenOpts;
+
   //===--------------------------------------------------------------------===//
   //                         Built-in Types
   //===--------------------------------------------------------------------===//
 
   mlir::Type CharTy;
 
 public:
-  CIRLowerContext(mlir::ModuleOp module, clang::LangOptions LOpts);
+  CIRLowerContext(mlir::ModuleOp module, clang::LangOptions LOpts,
+                  clang::CodeGenOptions CGOpts);
   CIRLowerContext(const CIRLowerContext &) = delete;
   CIRLowerContext &operator=(const CIRLowerContext &) = delete;
   ~CIRLowerContext();
@@ -73,6 +77,8 @@ class CIRLowerContext : public llvm::RefCountedBase<CIRLowerContext> {
 
   const clang::LangOptions &getLangOpts() const { return LangOpts; }
 
+  const clang::CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }
+
   mlir::MLIRContext *getMLIRContext() const { return MLIRCtx; }
 
   //===--------------------------------------------------------------------===//
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp
@@ -26,6 +26,7 @@
 #include "mlir/Support/LogicalResult.h"
 #include "clang/CIR/Target/AArch64.h"
 #include "llvm/Support/ErrorHandling.h"
+#include <utility>
 
 using MissingFeatures = cir::MissingFeatures;
 using AArch64ABIKind = cir::AArch64ABIKind;
@@ -86,11 +87,14 @@ createTargetLoweringInfo(LowerModule &LM) {
   }
 }
 
-LowerModule::LowerModule(clang::LangOptions opts, mlir::ModuleOp &module,
+LowerModule::LowerModule(clang::LangOptions langOpts,
+                         clang::CodeGenOptions codeGenOpts,
+                         mlir::ModuleOp &module,
                          std::unique_ptr<clang::TargetInfo> target,
                          mlir::PatternRewriter &rewriter)
-    : context(module, opts), module(module), Target(std::move(target)),
-      ABI(createCXXABI(*this)), types(*this), rewriter(rewriter) {
+    : context(module, std::move(langOpts), std::move(codeGenOpts)),
+      module(module), Target(std::move(target)), ABI(createCXXABI(*this)),
+      types(*this), rewriter(rewriter) {
   context.initBuiltinTypes(*Target);
 }
 
@@ -238,8 +242,20 @@ createLowerModule(mlir::ModuleOp module, mlir::PatternRewriter &rewriter) {
   cir_cconv_assert(!cir::MissingFeatures::langOpts());
   clang::LangOptions langOpts;
 
-  return std::make_unique<LowerModule>(langOpts, module, std::move(targetInfo),
-                                       rewriter);
+  // FIXME(cir): This just uses the default code generation options. We need to
+  // account for custom options.
+  cir_cconv_assert(!cir::MissingFeatures::codeGenOpts());
+  clang::CodeGenOptions codeGenOpts;
+
+  if (auto optLevelAttr = mlir::cast_if_present<cir::OptLevelAttr>(
+          module->getAttr(cir::CIRDialect::getOptLevelAttrName()))) {
+    codeGenOpts.OptimizationLevel = optLevelAttr.getOptLevel();
+    codeGenOpts.OptimizeSize = optLevelAttr.getOptSizeLevel();
+  }
+
+  return std::make_unique<LowerModule>(std::move(langOpts),
+                                       std::move(codeGenOpts), module,
+                                       std::move(targetInfo), rewriter);
 }
 
 } // namespace cir
diff --git a/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.h b/clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.h
@@ -42,8 +42,8 @@ class LowerModule {
   mlir::PatternRewriter &rewriter;
 
 public:
-  LowerModule(clang::LangOptions opts, mlir::ModuleOp &module,
-              std::unique_ptr<clang::TargetInfo> target,
+  LowerModule(clang::LangOptions langOpts, clang::CodeGenOptions codeGenOpts,
+              mlir::ModuleOp &module, std::unique_ptr<clang::TargetInfo> target,
               mlir::PatternRewriter &rewriter);
   ~LowerModule() = default;
 
diff --git a/clang/test/CIR/CodeGen/optimization-attr.cpp b/clang/test/CIR/CodeGen/optimization-attr.cpp
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O0 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-O0 %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O1 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-O1 %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O2 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-O2 %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -O3 -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-O3 %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Os -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-Os %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -Oz -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir --check-prefix=CHECK-Oz %s
+
+void foo() {}
+
+// CHECK-O0: module
+// CHECK-O0-NOT: cir.opt_level
+
+// CHECK-O1: module
+// CHECK-O1: cir.opt_level = #cir.opt_level<opt_level = 1, opt_size = 0>
+
+// CHECK-O2: module
+// CHECK-O2: cir.opt_level = #cir.opt_level<opt_level = 2, opt_size = 0>
+
+// CHECK-O3: module
+// CHECK-O3: cir.opt_level = #cir.opt_level<opt_level = 3, opt_size = 0>
+
+// CHECK-Os: module
+// CHECK-Os: cir.opt_level = #cir.opt_level<opt_level = 2, opt_size = 1>
+
+// CHECK-Oz: module
+// CHECK-Oz: cir.opt_level = #cir.opt_level<opt_level = 2, opt_size = 2>
