llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Andy Kaylor (andykaylor) <details> <summary>Changes</summary> This change introduces the cir-canonicalize pass. This is a simple cir-to-cir transformation that eliminates empty scopes and redundant branches. It will be expanded in future changes to simplify other redundant instruction sequences. MLIR verification and mlir-specific command-line option handling is also introduced here. --- Patch is 30.79 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/131891.diff 26 Files Affected: - (modified) clang/include/clang/Basic/DiagnosticFrontendKinds.td (+8) - (modified) clang/include/clang/CIR/CIRGenerator.h (+4) - (added) clang/include/clang/CIR/CIRToCIRPasses.h (+39) - (modified) clang/include/clang/CIR/Dialect/Passes.h (+1) - (modified) clang/include/clang/CIR/Dialect/Passes.td (+18) - (modified) clang/include/clang/CIR/MissingFeatures.h (+12) - (modified) clang/include/clang/Driver/Options.td (+12-2) - (modified) clang/include/clang/Frontend/FrontendOptions.h (+12-1) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+8) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.h (+2) - (modified) clang/lib/CIR/CodeGen/CIRGenerator.cpp (+2) - (added) clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp (+147) - (modified) clang/lib/CIR/Dialect/Transforms/CMakeLists.txt (+1) - (modified) clang/lib/CIR/FrontendAction/CIRGenAction.cpp (+29-1) - (modified) clang/lib/CIR/FrontendAction/CMakeLists.txt (+2) - (modified) clang/lib/CIR/Lowering/CIRPasses.cpp (+20-1) - (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (+2) - (modified) clang/lib/Driver/ToolChains/Clang.cpp (+9) - (modified) clang/lib/Frontend/CompilerInvocation.cpp (+8) - (modified) clang/lib/FrontendTool/CMakeLists.txt (+9) - (modified) clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp (+20) - (added) clang/test/CIR/Transforms/canonicalize.cir (+72) - (added) clang/test/CIR/mlirargs.c (+12) - (added) clang/test/CIR/mlprint.c (+14) - (modified) clang/tools/cir-opt/cir-opt.cpp (+4) - (modified) clang/tools/driver/cc1as_main.cpp (+1) ``````````diff diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td index 5a05f6c4e3e30..fcbbe4caf3c9d 100644 --- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td @@ -386,4 +386,12 @@ def warn_hlsl_langstd_minimal : Warning<"support for HLSL language version %0 is incomplete, " "recommend using %1 instead">, InGroup<HLSLDXCCompat>; + +// ClangIR frontend errors +def err_cir_to_cir_transform_failed : Error< + "CIR-to-CIR transformation failed">, DefaultFatal; + +def err_cir_verification_failed_pre_passes : Error< + "CIR module verification error before running CIR-to-CIR passes">, + DefaultFatal; } diff --git a/clang/include/clang/CIR/CIRGenerator.h b/clang/include/clang/CIR/CIRGenerator.h index 414eba80b88b8..883dce9deb8e3 100644 --- a/clang/include/clang/CIR/CIRGenerator.h +++ b/clang/include/clang/CIR/CIRGenerator.h @@ -55,6 +55,10 @@ class CIRGenerator : public clang::ASTConsumer { void Initialize(clang::ASTContext &astContext) override; bool HandleTopLevelDecl(clang::DeclGroupRef group) override; mlir::ModuleOp getModule() const; + mlir::MLIRContext &getMLIRContext() { return *mlirContext; }; + const mlir::MLIRContext &getMLIRContext() const { return *mlirContext; }; + + bool verifyModule() const; }; } // namespace cir diff --git a/clang/include/clang/CIR/CIRToCIRPasses.h b/clang/include/clang/CIR/CIRToCIRPasses.h new file mode 100644 index 0000000000000..361ebb9e9b840 --- /dev/null +++ b/clang/include/clang/CIR/CIRToCIRPasses.h @@ -0,0 +1,39 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file declares an interface for running CIR-to-CIR passes. +// +//===----------------------------------------------------------------------===// + +#ifndef CLANG_CIR_CIRTOCIRPASSES_H +#define CLANG_CIR_CIRTOCIRPASSES_H + +#include "mlir/Pass/Pass.h" + +#include <memory> + +namespace clang { +class ASTContext; +} + +namespace mlir { +class MLIRContext; +class ModuleOp; +} // namespace mlir + +namespace cir { + +// Run set of cleanup/prepare/etc passes CIR <-> CIR. +mlir::LogicalResult runCIRToCIRPasses(mlir::ModuleOp theModule, + mlir::MLIRContext &mlirCtx, + clang::ASTContext &astCtx, + bool enableVerifier); + +} // namespace cir + +#endif // CLANG_CIR_CIRTOCIRPASSES_H_ diff --git a/clang/include/clang/CIR/Dialect/Passes.h b/clang/include/clang/CIR/Dialect/Passes.h index b691849dfc563..aa84241bdecf0 100644 --- a/clang/include/clang/CIR/Dialect/Passes.h +++ b/clang/include/clang/CIR/Dialect/Passes.h @@ -20,6 +20,7 @@ class ASTContext; } namespace mlir { +std::unique_ptr<Pass> createCIRCanonicalizePass(); std::unique_ptr<Pass> createCIRFlattenCFGPass(); void populateCIRPreLoweringPasses(mlir::OpPassManager &pm); diff --git a/clang/include/clang/CIR/Dialect/Passes.td b/clang/include/clang/CIR/Dialect/Passes.td index 84b7ecba2630a..1d9707541e917 100644 --- a/clang/include/clang/CIR/Dialect/Passes.td +++ b/clang/include/clang/CIR/Dialect/Passes.td @@ -11,6 +11,24 @@ include "mlir/Pass/PassBase.td" +def CIRCanonicalize : Pass<"cir-canonicalize"> { + let summary = "Performs CIR canonicalization"; + let description = [{ + Perform canonicalizations on CIR and removes some redundant operations. + + This pass performs basic cleanup and canonicalization transformations that + hopefully do not affect CIR-to-source fidelity and high-level code analysis + passes too much. Example transformations performed in this pass include + empty scope cleanup, trivial try cleanup, redundant branch cleanup, etc. + Those more "heavyweight" transformations and those transformations that + could significantly affect CIR-to-source fidelity are performed in the + `cir-simplify` pass. + }]; + + let constructor = "mlir::createCIRCanonicalizePass()"; + let dependentDialects = ["cir::CIRDialect"]; +} + def CIRFlattenCFG : Pass<"cir-flatten-cfg"> { let summary = "Produces flatten CFG"; let description = [{ diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h index 6adff30f5c91a..52bf56727a51b 100644 --- a/clang/include/clang/CIR/MissingFeatures.h +++ b/clang/include/clang/CIR/MissingFeatures.h @@ -103,6 +103,18 @@ struct MissingFeatures { static bool scalableVectors() { return false; } static bool unsizedTypes() { return false; } static bool vectorType() { return false; } + + // Future CIR operations + static bool labelOp() { return false; } + static bool brCondOp() { return false; } + static bool switchOp() { return false; } + static bool tryOp() { return false; } + static bool unaryOp() { return false; } + static bool selectOp() { return false; } + static bool complexCreateOp() { return false; } + static bool complexRealOp() { return false; } + static bool complexImagOp() { return false; } + static bool callOp() { return false; } }; } // namespace cir diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 66ae8f1c7f064..75d00b5b32cd4 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -2978,6 +2978,15 @@ def fapple_link_rtlib : Flag<["-"], "fapple-link-rtlib">, Group<f_Group>, HelpText<"Force linking the clang builtins runtime library">; /// ClangIR-specific options - BEGIN +def clangir_disable_passes : Flag<["-"], "clangir-disable-passes">, + Visibility<[ClangOption, CC1Option]>, + HelpText<"Disable CIR transformations pipeline">, + MarshallingInfoFlag<FrontendOpts<"ClangIRDisablePasses">>; +def clangir_disable_verifier : Flag<["-"], "clangir-disable-verifier">, + Visibility<[ClangOption, CC1Option]>, + HelpText<"ClangIR: Disable MLIR module verifier">, + MarshallingInfoFlag<FrontendOpts<"ClangIRDisableCIRVerifier">>; + defm clangir : BoolFOption<"clangir", FrontendOpts<"UseClangIRPipeline">, DefaultFalse, PosFlag<SetTrue, [], [ClangOption, CC1Option], "Use the ClangIR pipeline to compile">, @@ -4822,8 +4831,9 @@ def : Joined<["-"], "mllvm=">, Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, Alias<mllvm>, HelpText<"Alias for -mllvm">, MetaVarName<"<arg>">; def mmlir : Separate<["-"], "mmlir">, - Visibility<[ClangOption, CLOption, FC1Option, FlangOption]>, - HelpText<"Additional arguments to forward to MLIR's option processing">; + Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>, + HelpText<"Additional arguments to forward to MLIR's option processing">, + MarshallingInfoStringVector<FrontendOpts<"MLIRArgs">>; def ffuchsia_api_level_EQ : Joined<["-"], "ffuchsia-api-level=">, Group<m_Group>, Visibility<[ClangOption, CC1Option]>, HelpText<"Set Fuchsia API level">, diff --git a/clang/include/clang/Frontend/FrontendOptions.h b/clang/include/clang/Frontend/FrontendOptions.h index 99b2d9a98ed1f..0e0cbaa537332 100644 --- a/clang/include/clang/Frontend/FrontendOptions.h +++ b/clang/include/clang/Frontend/FrontendOptions.h @@ -412,6 +412,12 @@ class FrontendOptions { LLVM_PREFERRED_TYPE(bool) unsigned UseClangIRPipeline : 1; + /// Disable Clang IR specific (CIR) passes + unsigned ClangIRDisablePasses : 1; + + /// Disable Clang IR (CIR) verifier + unsigned ClangIRDisableCIRVerifier : 1; + CodeCompleteOptions CodeCompleteOpts; /// Specifies the output format of the AST. @@ -488,6 +494,10 @@ class FrontendOptions { /// should only be used for debugging and experimental features. std::vector<std::string> LLVMArgs; + /// A list of arguments to forward to MLIR's option processing; this + /// should only be used for debugging and experimental features. + std::vector<std::string> MLIRArgs; + /// File name of the file that will provide record layouts /// (in the format produced by -fdump-record-layouts). std::string OverrideRecordLayoutsFile; @@ -533,7 +543,8 @@ class FrontendOptions { EmitExtensionSymbolGraphs(false), EmitSymbolGraphSymbolLabelsForTesting(false), EmitPrettySymbolGraphs(false), GenReducedBMI(false), - UseClangIRPipeline(false), TimeTraceGranularity(500), + UseClangIRPipeline(false), ClangIRDisablePasses(false), + ClangIRDisableCIRVerifier(false), TimeTraceGranularity(500), TimeTraceVerbose(false) {} /// getInputKindForExtension - Return the appropriate input kind for a file diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index 0e3e15ca2cadc..36bfc2cdf6f02 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp @@ -23,6 +23,7 @@ #include "mlir/IR/BuiltinOps.h" #include "mlir/IR/Location.h" #include "mlir/IR/MLIRContext.h" +#include "mlir/IR/Verifier.h" using namespace clang; using namespace clang::CIRGen; @@ -488,6 +489,13 @@ mlir::Type CIRGenModule::convertType(QualType type) { return genTypes.convertType(type); } +bool CIRGenModule::verifyModule() const { + // Verify the module after we have finished constructing it, this will + // check the structural properties of the IR and invoke any specific + // verifiers we have on the CIR operations. + return mlir::verify(theModule).succeeded(); +} + DiagnosticBuilder CIRGenModule::errorNYI(SourceLocation loc, llvm::StringRef feature) { unsigned diagID = diags.getCustomDiagID( diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h index 2a798f4cd56a9..734cafa2e07bb 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.h +++ b/clang/lib/CIR/CodeGen/CIRGenModule.h @@ -91,6 +91,8 @@ class CIRGenModule : public CIRGenTypeCache { void emitTopLevelDecl(clang::Decl *decl); + bool verifyModule() const; + /// Return the address of the given function. If funcType is non-null, then /// this function will use the specified type if it has to create it. // TODO: this is a bit weird as `GetAddr` given we give back a FuncOp? diff --git a/clang/lib/CIR/CodeGen/CIRGenerator.cpp b/clang/lib/CIR/CodeGen/CIRGenerator.cpp index 6fa31ab707139..33f0c292c7710 100644 --- a/clang/lib/CIR/CodeGen/CIRGenerator.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenerator.cpp @@ -40,6 +40,8 @@ void CIRGenerator::Initialize(ASTContext &astContext) { *mlirContext.get(), astContext, codeGenOpts, diags); } +bool CIRGenerator::verifyModule() const { return cgm->verifyModule(); } + mlir::ModuleOp CIRGenerator::getModule() const { return cgm->getModule(); } bool CIRGenerator::HandleTopLevelDecl(DeclGroupRef group) { diff --git a/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp new file mode 100644 index 0000000000000..8aa73ea5c1d2a --- /dev/null +++ b/clang/lib/CIR/Dialect/Transforms/CIRCanonicalize.cpp @@ -0,0 +1,147 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file implements pass that canonicalizes CIR operations, eliminating +// redundant branches, empty scopes, and other unnecessary operations. +// +//===----------------------------------------------------------------------===// + +#include "PassDetail.h" +#include "mlir/Dialect/Func/IR/FuncOps.h" +#include "mlir/IR/Block.h" +#include "mlir/IR/Operation.h" +#include "mlir/IR/PatternMatch.h" +#include "mlir/IR/Region.h" +#include "mlir/Support/LogicalResult.h" +#include "mlir/Transforms/GreedyPatternRewriteDriver.h" +#include "clang/CIR/Dialect/IR/CIRDialect.h" +#include "clang/CIR/Dialect/Passes.h" +#include "clang/CIR/MissingFeatures.h" + +using namespace mlir; +using namespace cir; + +namespace { + +/// Removes branches between two blocks if it is the only branch. +/// +/// From: +/// ^bb0: +/// cir.br ^bb1 +/// ^bb1: // pred: ^bb0 +/// cir.return +/// +/// To: +/// ^bb0: +/// cir.return +struct RemoveRedundantBranches : public OpRewritePattern<BrOp> { + using OpRewritePattern<BrOp>::OpRewritePattern; + + LogicalResult matchAndRewrite(BrOp op, + PatternRewriter &rewriter) const final { + Block *block = op.getOperation()->getBlock(); + Block *dest = op.getDest(); + + assert(!cir::MissingFeatures::labelOp()); + + // Single edge between blocks: merge it. + if (block->getNumSuccessors() == 1 && + dest->getSinglePredecessor() == block) { + rewriter.eraseOp(op); + rewriter.mergeBlocks(dest, block); + return success(); + } + + return failure(); + } +}; + +struct RemoveEmptyScope + : public OpRewritePattern<ScopeOp>::SplitMatchAndRewrite { + using SplitMatchAndRewrite::SplitMatchAndRewrite; + + LogicalResult match(ScopeOp op) const final { + // TODO: Remove this logic once CIR uses MLIR infrastructure to remove + // trivially dead operations + if (op.isEmpty()) { + return success(); + } + + Region *region = &(op.getScopeRegion()); // getRegions().front(); + if (region && region->getBlocks().front().getOperations().size() == 1) { + return success(isa<YieldOp>(region->getBlocks().front().front())); + } + + return failure(); + } + + void rewrite(ScopeOp op, PatternRewriter &rewriter) const final { + rewriter.eraseOp(op); + } +}; + +//===----------------------------------------------------------------------===// +// CIRCanonicalizePass +//===----------------------------------------------------------------------===// + +struct CIRCanonicalizePass : public CIRCanonicalizeBase<CIRCanonicalizePass> { + using CIRCanonicalizeBase::CIRCanonicalizeBase; + + // The same operation rewriting done here could have been performed + // by CanonicalizerPass (adding hasCanonicalizer for target Ops and + // implementing the same from above in CIRDialects.cpp). However, it's + // currently too aggressive for static analysis purposes, since it might + // remove things where a diagnostic can be generated. + // + // FIXME: perhaps we can add one more mode to GreedyRewriteConfig to + // disable this behavior. + void runOnOperation() override; +}; + +void populateCIRCanonicalizePatterns(RewritePatternSet &patterns) { + // clang-format off + patterns.add< + RemoveRedundantBranches, + RemoveEmptyScope + >(patterns.getContext()); + // clang-format on +} + +void CIRCanonicalizePass::runOnOperation() { + // Collect rewrite patterns. + RewritePatternSet patterns(&getContext()); + populateCIRCanonicalizePatterns(patterns); + + // Collect operations to apply patterns. + llvm::SmallVector<Operation *, 16> ops; + getOperation()->walk([&](Operation *op) { + assert(!cir::MissingFeatures::brCondOp()); + assert(!cir::MissingFeatures::switchOp()); + assert(!cir::MissingFeatures::tryOp()); + assert(!cir::MissingFeatures::unaryOp()); + assert(!cir::MissingFeatures::selectOp()); + assert(!cir::MissingFeatures::complexCreateOp()); + assert(!cir::MissingFeatures::complexRealOp()); + assert(!cir::MissingFeatures::complexImagOp()); + assert(!cir::MissingFeatures::callOp()); + // CastOp here is to perform a manual `fold` in + // applyOpPatternsGreedily + if (isa<BrOp, ScopeOp, CastOp>(op)) + ops.push_back(op); + }); + + // Apply patterns. + if (applyOpPatternsGreedily(ops, std::move(patterns)).failed()) + signalPassFailure(); +} + +} // namespace + +std::unique_ptr<Pass> mlir::createCIRCanonicalizePass() { + return std::make_unique<CIRCanonicalizePass>(); +} diff --git a/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt b/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt index aa27074cc6131..648666d2461de 100644 --- a/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt +++ b/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt @@ -1,4 +1,5 @@ add_clang_library(MLIRCIRTransforms + CIRCanonicalize.cpp FlattenCFG.cpp DEPENDS diff --git a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp index 0f686a36b982b..8ef2e8fe15db7 100644 --- a/clang/lib/CIR/FrontendAction/CIRGenAction.cpp +++ b/clang/lib/CIR/FrontendAction/CIRGenAction.cpp @@ -9,7 +9,9 @@ #include "clang/CIR/FrontendAction/CIRGenAction.h" #include "mlir/IR/MLIRContext.h" #include "mlir/IR/OwningOpRef.h" +#include "clang/Basic/DiagnosticFrontend.h" #include "clang/CIR/CIRGenerator.h" +#include "clang/CIR/CIRToCIRPasses.h" #include "clang/CIR/LowerToLLVM.h" #include "clang/CodeGen/BackendUtil.h" #include "clang/Frontend/CompilerInstance.h" @@ -59,6 +61,7 @@ class CIRGenConsumer : public clang::ASTConsumer { ASTContext *Context{nullptr}; IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; std::unique_ptr<CIRGenerator> Gen; + const FrontendOptions &FEOptions; public: CIRGenConsumer(CIRGenAction::OutputType Action, CompilerInstance &CI, @@ -66,7 +69,8 @@ class CIRGenConsumer : public clang::ASTConsumer { : Action(Action), CI(CI), OutputStream(std::move(OS)), FS(&CI.getVirtualFileSystem()), Gen(std::make_unique<CIRGenerator>(CI.getDiagnostics(), std::move(FS), - CI.getCodeGenOpts())) {} + CI.getCodeGenOpts())), + FEOptions(CI.getFrontendOpts()) {} void Initialize(ASTContext &Ctx) override { assert(!Context && "initialized multiple times"); @@ -81,7 +85,31 @@ class CIRGenConsumer : public clang::ASTConsumer { void HandleTranslationUnit(ASTContext &C) override { Gen->HandleTranslationUnit(C); + + if (!FEOptions.ClangIRDisableCIRVerifier) { + if (!Gen->verifyModule()) { + CI.getDiagnostics().Report( + diag::err_cir_verification_failed_pre_passes); + llvm::report_fatal_error( + "CIR codegen: module verification error before running CIR passes"); + return; + } + } + mlir::ModuleOp MlirModule = Gen->getModule(); + mlir::MLIRContext &MlirCtx = Gen->getMLIRContext(); + + if (!FEOptions.ClangIRDisablePasses) { + // Setup and run CIR pipeline. + std::string passOptParsingFailure; + if (runCIRToCIRPasses(MlirModule, MlirCtx, C, + !FEOptions.ClangIRDisableCIRVerifier) + .failed()) { + CI.getDiagnostics().Report(diag::err_cir_to_cir_transform_failed); + return; + } + } + switch (Action) { case CIRGenAction::OutputType::EmitCIR: if (OutputStream && MlirModule) { diff --git a/clang/lib/CIR/FrontendAction/CMakeLists.txt b/clang/lib/CIR/FrontendAction/CMakeLists.txt index 1ebac07f44662..50d6ea7108ce1 100644 --- a/clang/lib/CIR/FrontendAction/CMakeLists.txt +++ b/clang/lib/CIR/FrontendAction/CMakeLists.txt @@ -15,8 +15,10 @@ add_clang_library(clangCIRFrontendAction LINK_LIBS clangAST + clangBasic clangFrontend clangCIR + clangCIRLoweringCommon clangCIRLoweringDirectToLLVM clangCodeGen MLIRCIR diff --git a/clang/lib/CIR/Lowering/CIRPasses.cpp b/clang/lib/CIR/Lowering/CIRPasses.cpp index 235acbfee8967..1616ac6145151 100644 --- a/clang/lib/CIR/Lowering/CIRPasses.cpp +++ b/clang/lib/CIR/Lowering/CIRPasses.cpp @@ -11,9 +11,28 @@ //===----------------------------------------------------------------------===// // #include "clang/AST/ASTContext.h" +#include "mlir/IR/BuiltinOps.h" +#include "mlir/Pass/PassManager.h" #include "clang/CIR/Dialect/Passes.h" +#include "llvm/Support/TimeProfiler.h" -#include "mlir/Pass/PassManager.h" +namespace cir { +mlir::LogicalResult runCIRToCIRPasses(mlir::ModuleOp theModule, + mlir::MLIRContext &mlirContext, + clang::ASTContext &astContext, + bool enableVerifier) { + + llvm::TimeTraceScope scope("CIR To CIR Passes")... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/131891 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
