dialect design

This work proposes a modular framework for random program generation targeting compiler intermediate representations (IRs), addressing the high complexity and effort traditionally required to develop such generators. By decoupling language-specific constructs from generic generation logic, the framework significantly lowers the barrier to implementing new IR-aware generators. Built upon the MLIR infrastructure, it integrates modular design, randomized program synthesis, differential testing, and fuzzing to enable rapid adaptation across diverse IRs. The authors demonstrate the approach’s effectiveness and generality by developing generators for MLIR’s built-in dialects, WebAssembly, and DaCe within a single week, uncovering 9, 15, and 774 distinct bug-triggering test cases, respectively. These results substantiate the framework’s capacity to facilitate efficient and scalable compiler testing.

Abstract transformers in compiler static analysis often struggle to simultaneously ensure correctness, precision, and efficiency. Method: This paper introduces the first fully automated synthesis framework for integer abstract domains in MLIR—requiring no human-provided sketches. It decomposes complex transformer synthesis into constructing intersections of elementary transformers and achieves end-to-end automation via progressive precision refinement. The approach employs a non-relational abstraction model and reduces verification to an SMT-decidable fragment for formal, sound validation of all synthesized transformers. Contribution/Results: Experiments show that the synthesized transformers cover numerous LLVM instructions long missing from existing static analyzers; 17% surpass the precision of current LLVM implementations. This significantly improves both the reliability of static analysis and the breadth of IR coverage.

This work addresses the prevailing lack of systematic understanding of foundational formal theories in current AI compiler design, which hinders rigorous evaluation of the completeness and desirability of intermediate representations and compilation abstractions. For the first time, it systematically establishes precise correspondences between core mechanisms of MLIR—such as term rewriting systems, refinement calculi, and abstract interpretation—and classical formal theories. By grounding compiler abstractions in formal semantics, the paper clarifies the theoretical underpinnings of these constructs, articulates a precise notion of “design completeness,” and provides assessable criteria and guiding principles to navigate trade-offs between engineering pragmatism and theoretical ideals.

This work addresses the lack of a unified framework in existing domain-specific language (DSL) compilers, which leads to redundant development, maintenance challenges, and difficulty meeting production-grade requirements. The paper presents the first fully MLIR-based NumPy-like DSL, featuring native implementation of both front-end parsing and semantic analysis within MLIR. It introduces a novel dialect-agnostic type checker and a parallelism-first lowering strategy that seamlessly integrates with MLIR’s dataflow dialects. By doing so, this approach not only advances the standardization of DSLs within the MLIR ecosystem but also demonstrates strong performance on real-world Fortran applications in domains such as weather modeling and computational fluid dynamics.

This work proposes a hybrid concrete-symbolic interpretation method to efficiently verify semantic equivalence between original and optimized programs in MLIR, ensuring the correctness of optimization transformations. The approach supports diverse syntactic, scheduling, and memory representations and theoretically achieves linear-time complexity for equivalence checking. Building upon this method, the authors develop a formal verifier for a subset of MLIR and successfully apply it to the AMD MLIR-AIR and MLIR-AIE toolchains as well as the standard mlir-opt infrastructure. Evaluation across hundreds of benchmark variants demonstrates the verifier’s effectiveness in validating optimization pipelines, significantly enhancing the reliability of compiler optimizations within the MLIR ecosystem.

Large language models (LLMs) excel at function-level code generation but struggle with repository-scale system synthesis due to the ambiguity and unverifiability of natural language prompts, leading to significantly degraded output quality. To address this limitation, this work proposes Structured Specification-Driven Engineering (SSDE), a novel paradigm that, for the first time, leverages structured artifacts as inputs to guide LLMs in generating high-quality, verifiable repository-level code. The feasibility of SSDE is demonstrated through the successful automatic generation of MVC-architected business logic across three real-world software systems. These results highlight SSDE’s potential for large-scale software automation while also uncovering critical challenges and charting promising directions for future research.

This work addresses the challenge of preserving and verifying structural correctness—such as dimensional consistency, stratification, escape properties, and numeric representations—during compilation of ML-family languages. To this end, it introduces an internal scaffolding mechanism based on fixed-point combinators, integrating closed negative types and fractional types to encode program semantic structure into MLIR intermediate representations at the middle end of compilation. Leveraging categorical constructions, the approach enables accompanying verification without requiring developers to explicitly engage with category theory, thereby ensuring structural integrity throughout the entire compilation pipeline. By exploiting MLIR’s dialect system, attribute infrastructure, and static single-assignment form, proof artifacts remain amenable to continuous toolchain validation as code is progressively lowered, achieving, for the first time, end-to-end verifiable preservation of structural properties.

This work addresses the challenge of automating library API migration in the absence of real-world migration examples. To overcome this limitation, the authors propose a novel unsupervised approach that leverages large language models (LLMs) to generate initial migration examples without requiring labeled data. These examples are then generalized by an intelligent agent into structured, testable code transformation rules, which are integrated into the PolyglotPiranha framework for execution. This study represents the first integration of LLMs’ zero-shot generation capabilities with programmatic code transformation tools. The method successfully synthesizes reusable and generalizable migration scripts across multiple Python library migration tasks, significantly enhancing the feasibility and practicality of API migration in fully unsupervised settings.

Existing direct code-to-code transformation approaches often suffer from semantic drift, implicit behavioral changes, and loss of traceability. To address these issues, this work proposes a specification-based Code2Text2Code refactoring framework that first translates source code into a neutral textual specification before generating target code. The approach integrates abstract syntax tree (AST) and dependency graph analysis, semantic-aware code chunking, retrieval-augmented generation, and DSPy-based prompt tuning, further enhanced by iterative validation and graph-based formal verification. This pipeline ensures high-fidelity semantic preservation and controllable evolution during code transformation. Experimental results demonstrate that the proposed method significantly reduces transformation loss and substantially improves semantic consistency, interface stability, and cross-language traceability of the refactored code.

Traditional compilers face limitations in applying equality saturation–based optimizations due to their reliance on a single abstraction level and their inability to preserve discovered equivalences across subsequent compiler transformations, leading to phase-ordering problems. This work proposes natively embedding e-graphs into the compiler’s intermediate representation (IR), introducing eqsat as a first-class dialect within MLIR. This design enables the persistent maintenance of equality saturation state throughout the compilation pipeline and supports interleaved execution with other transformations. Implemented within the xDSL framework, the approach unifies equality saturation optimization across multiple IR abstraction levels, significantly enhancing both the power and flexibility of compiler optimizations.