[CIR] Add code generation options to lowering context

This PR 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 PR also adds a new attribute `#cir.opt_info`. The attribute is a
module-level attribute and it holds optimization information such as the
optimization level. The attribute is consumed when initializing the lowering
context to populate the code generation options. CIRGen is updated to generate
and attach this attribute to the module op.

Author: Lancern

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

@@ -73,6 +73,54 @@ def LangAttr : CIR_Attr<"Lang", "lang"> {
   let genVerifyDecl = 0;
 }
 
+//===----------------------------------------------------------------------===//
+// OptInfoAttr
+//===----------------------------------------------------------------------===//
+
+def CIR_OptInfoAttr : CIR_Attr<"OptInfo", "opt_info"> {
+  let summary =
+    "A module-level attribute that holds the optimization information";
+  let description = [{
+    The `#cir.opt_info` attribute holds the optimization related information.
+    Currently this attribute is a module-level attribute that gets attached to
+    the module operation during CIRGen.
+
+    The `level` parameter gives the optimization level. It must be an integer
+    between 0 and 3, inclusive. It corresponds to the `OptimizationLevel` field
+    within the `clang::CodeGenOptions` structure.
+
+    The `size` parameter gives the code size optimization level. It must be an
+    integer between 0 and 2, inclusive. It corresponds to the `OptimizeSize`
+    field within the `clang::CodeGenOptions` structure.
+
+    The `level` and `size` parameters correspond to the optimization level
+    command line options passed to clang driver. The table below lists the
+    current correspondance relationship:
+
+    | Flag             | `level` | `size` |
+    |------------------|---------|--------|
+    | `-O0` or nothing | 0       | 0      |
+    | `-O1`            | 1       | 0      |
+    | `-O2`            | 2       | 0      |
+    | `-O3`            | 3       | 0      |
+    | `-Os`            | 2       | 1      |
+    | `-Oz`            | 2       | 2      |
+
+    Examples:
+
+    ```mlir
+    #cir.opt_info<level = 2, size = 0>  // -O2
+    ```
+  }];
+
+  let parameters = (ins "unsigned":$level, "unsigned":$size);
+
+  let assemblyFormat = [{
+    `<` `level` `=` $level `,` `size` `=` $size `>`
+  }];
+  let genVerifyDecl = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // BoolAttr
 //===----------------------------------------------------------------------===//
@@ -311,7 +359,7 @@ def ComplexAttr : CIR_Attr<"Complex", "complex", [TypedAttrInterface]> {
     contains values of the same CIR type.
   }];
 
-  let parameters = (ins 
+  let parameters = (ins
     AttributeSelfTypeParameter<"", "cir::ComplexType">:$type,
     "mlir::TypedAttr":$real, "mlir::TypedAttr":$imag);
 

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 getOptInfoAttrName() { return "cir.opt_info"; }
 
     static llvm::StringRef getGlobalCtorsAttrName() { return "cir.global_ctors"; }
     static llvm::StringRef getGlobalDtorsAttrName() { return "cir.global_dtors"; }

clang/include/clang/CIR/MissingFeatures.h

@@ -377,6 +377,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; }

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::getOptInfoAttrName(),
+                       cir::OptInfoAttr::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.

clang/lib/CIR/Dialect/IR/CIRAttrs.cpp

@@ -214,6 +214,23 @@ void LangAttr::print(AsmPrinter &printer) const {
   printer << "<" << getLang().getValue() << '>';
 }
 
+//===----------------------------------------------------------------------===//
+// OptInfoAttr definitions
+//===----------------------------------------------------------------------===//
+
+LogicalResult OptInfoAttr::verify(function_ref<InFlightDiagnostic()> emitError,
+                                  unsigned level, unsigned size) {
+  if (level > 3) {
+    emitError() << "optimization level must be between 0 and 3 inclusive";
+    return failure();
+  }
+  if (size > 2) {
+    emitError() << "size optimization level must be between 0 and 2 inclusive";
+    return failure();
+  }
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // ConstPtrAttr definitions
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/TargetLowering/CIRLowerContext.cpp

@@ -23,8 +23,10 @@
 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() {}
 

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; }
 
   //===--------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/TargetLowering/LowerModule.cpp

@@ -86,11 +86,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 +241,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 optInfo = mlir::cast_if_present<cir::OptInfoAttr>(
+          module->getAttr(cir::CIRDialect::getOptInfoAttrName()))) {
+    codeGenOpts.OptimizationLevel = optInfo.getLevel();
+    codeGenOpts.OptimizeSize = optInfo.getSize();
+  }
+
+  return std::make_unique<LowerModule>(std::move(langOpts),
+                                       std::move(codeGenOpts), module,
+                                       std::move(targetInfo), rewriter);
 }
 
 } // namespace cir

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;
 

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_info
+
+// CHECK-O1: module
+// CHECK-O1: cir.opt_info = #cir.opt_info<level = 1, size = 0>
+
+// CHECK-O2: module
+// CHECK-O2: cir.opt_info = #cir.opt_info<level = 2, size = 0>
+
+// CHECK-O3: module
+// CHECK-O3: cir.opt_info = #cir.opt_info<level = 3, size = 0>
+
+// CHECK-Os: module
+// CHECK-Os: cir.opt_info = #cir.opt_info<level = 2, size = 1>
+
+// CHECK-Oz: module
+// CHECK-Oz: cir.opt_info = #cir.opt_info<level = 2, size = 2>