✨ Add Constant Propagation #1845
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,109 @@ | ||
| /* | ||
| * Copyright (c) 2023 - 2026 Chair for Design Automation, TUM | ||
| * Copyright (c) 2025 - 2026 Munich Quantum Software Company GmbH | ||
| * All rights reserved. | ||
| * | ||
| * SPDX-License-Identifier: MIT | ||
| * | ||
| * Licensed under the MIT License | ||
| */ | ||
|
|
||
| #pragma once | ||
|
|
||
| #ifndef MQT_CORE_CLASSICALARITHOPERATION_H | ||
| #define MQT_CORE_CLASSICALARITHOPERATION_H | ||
|
|
||
| #include "mlir/Dialect/QCO/IR/QCOOps.h" | ||
| #include "mlir/Dialect/QCO/Utils/Drivers.h" | ||
|
|
||
| #include <mlir/Dialect/Arith/IR/Arith.h> | ||
| #include <mlir/IR/BuiltinTypes.h> | ||
| #include <mlir/IR/Operation.h> | ||
|
|
||
| #include <cmath> | ||
| #include <stdexcept> | ||
|
|
||
| /** | ||
| * This file provides information of available arith operations. It calculates | ||
| * the result of valid arith operations. Operations are only valid with one to | ||
| * two operands, not if they are applied to sequences. | ||
| */ | ||
| inline int64_t getArithIntegerOpResult(mlir::Operation* operation, | ||
| int64_t value1, int64_t value2 = 0, | ||
| int64_t value3 = 0) { | ||
|
|
||
| for (mlir::Value operand : operation->getOperands()) { | ||
| if (isa<mlir::VectorType>(operand.getType())) { | ||
| throw std::runtime_error( | ||
| "Constant propagation does not support vectors as classical types."); | ||
| } | ||
| } | ||
|
|
||
| return mlir::TypeSwitch<mlir::Operation*, int64_t>(operation) | ||
| .Case<mlir::arith::AddIOp>([&](auto) { return value1 + value2; }) | ||
| .Case<mlir::arith::AndIOp>([&](auto) { return value1 & value2; }) | ||
| .Case<mlir::arith::CeilDivSIOp>([&](auto) { | ||
| // Division that rounds to positive infinity | ||
| return ceil(1.0 * value1 / value2); | ||
| }) | ||
| .Case<mlir::arith::DivSIOp>([&](auto) { | ||
| // Division that rounds towards zero | ||
| return value1 / value2; | ||
| }) | ||
| .Case<mlir::arith::FloorDivSIOp>([&](auto) { | ||
| // Division that rounds to negative infinity | ||
| return floor(1.0 * value1 / value2); | ||
| }) | ||
| .Case<mlir::arith::MaxSIOp>( | ||
| [&](auto) { return value1 > value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MinSIOp>( | ||
| [&](auto) { return value1 < value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MulIOp>([&](auto) { return value1 * value2; }) | ||
| .Case<mlir::arith::OrIOp>([&](auto) { return value1 | value2; }) | ||
| .Case<mlir::arith::RemSIOp>( | ||
| [&](auto) { return remainder(value1, value2); }) | ||
| .Case<mlir::arith::ShLIOp>([&](auto) { return value1 << value2; }) | ||
| .Case<mlir::arith::ShRSIOp>([&](auto) { return value1 >> value2; }) | ||
| .Case<mlir::arith::SubIOp>([&](auto) { return value1 - value2; }) | ||
| .Case<mlir::arith::XOrIOp>([&](auto) { return value1 ^ value2; }) | ||
| .Case<mlir::arith::SelectOp>( | ||
| [&](auto) { return value1 == 0 ? value3 : value2; }) | ||
| .Default([&](auto) -> int64_t { | ||
| throw std::runtime_error("Unsupported integer operation in " | ||
| "mlir::qco::classicalarithoperation"); | ||
| }); | ||
| } | ||
|
|
||
| inline double getArithDoubleOpResult(mlir::Operation* operation, double value1, | ||
| double value2 = 0.0) { | ||
|
|
||
| for (mlir::Value operand : operation->getOperands()) { | ||
| if (isa<mlir::VectorType>(operand.getType())) { | ||
| throw std::runtime_error( | ||
| "Constant propagation does not support vectors as classical types."); | ||
| } | ||
| } | ||
|
|
||
| return mlir::TypeSwitch<mlir::Operation*, double>(operation) | ||
| .Case<mlir::arith::AddFOp>([&](auto) { return value1 + value2; }) | ||
| .Case<mlir::arith::DivFOp>([&](auto) { return value1 / value2; }) | ||
| .Case<mlir::arith::MaximumFOp>( | ||
| [&](auto) { return value1 > value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MaxNumFOp>( | ||
| [&](auto) { return value1 > value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MinimumFOp>( | ||
| [&](auto) { return value1 < value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MinNumFOp>( | ||
| [&](auto) { return value1 < value2 ? value1 : value2; }) | ||
| .Case<mlir::arith::MulFOp>([&](auto) { return value1 * value2; }) | ||
| .Case<mlir::arith::NegFOp>([&](auto) { return -value1; }) | ||
| .Case<mlir::arith::RemFOp>( | ||
| [&](auto) { return remainder(value1, value2); }) | ||
| .Case<mlir::arith::SubFOp>([&](auto) { return value1 - value2; }) | ||
| .Default([&](auto) -> double { | ||
| throw std::runtime_error("Unsupported floating-point operation in " | ||
| "mlir::qco::classicalarithoperation"); | ||
| }); | ||
| } | ||
|
Comment on lines
+31
to
+107
Contributor
There was a problem hiding this comment. 🎯 Functional Correctness | 🔴 Critical | 🏗️ Heavy lift 🧩 Analysis chain🌐 Web query:
💡 Result: The MLIR 'arith' dialect defines basic arithmetic operations that operate on scalars (integers or floating-point), as well as vectors and tensors of these types [1]. Unless otherwise stated, these operations use two's complement representation for integers and propagate poison values [1]. If any input is poison, the result is poison [1]. arith.remsi (Signed Integer Division Remainder) This operation performs a signed integer remainder [2][3]. It treats the leading bit as a sign bit (e.g., 6 % -2 = 0) [2][3]. Division by zero is undefined behavior [2][3]. For vector and tensor types, if any element is divided by zero, the behavior is undefined [2][3]. arith.remf (Floating-Point Remainder) This operation performs a floating-point remainder, with semantics matching the llvm.frem instruction [4]. The sign of the result always matches the sign of the dividend (the left-hand side operand) [4]. arith.ceildivsi (Signed Integer Ceil Division) This performs signed integer division rounded towards positive infinity (e.g., 7 / -2 = -3) [5]. arith.floordivsi (Signed Integer Floor Division) This performs signed integer division rounded towards negative infinity (e.g., 5 / -2 = -3) [5][6]. arith.maximumf (Floating-Point Maximum) Returns the maximum of two arguments, treating -0.0 as less than +0.0 [2][5]. If either argument is NaN, the result is NaN [2][5]. arith.maxnumf (Floating-Point Maximum) Returns the maximum of two arguments [2][5]. If the arguments are -0.0 and +0.0, the result is either value [2][5]. If one argument is NaN, the result is the other argument [2][5]. Note on Integer Bit Widths: These operations are polymorphic and accept integers of any bit width (e.g., i8, i16, i32, i64) as defined in the MLIR type system [1][2]. The specific behavior, such as two's complement arithmetic and overflow behavior, applies generically across these widths [1]. Note on Poison: Unless otherwise specified, all operations in the arith dialect propagate poison values, meaning that if any of the inputs are poison, the output is also poison [1]. For structured types (vector/tensor), this propagation occurs element-wise [1]. Citations:
🏁 Script executed: #!/bin/bash
set -euo pipefail
# Map the target header and nearby symbols.
ast-grep outline mlir/include/mlir/Dialect/QCO/Transforms/Optimizations/ConstantPropagation/ClassicalArithOperation.h --view expanded || true
echo
echo "=== File excerpt ==="
sed -n '1,220p' mlir/include/mlir/Dialect/QCO/Transforms/Optimizations/ConstantPropagation/ClassicalArithOperation.h
echo
echo "=== Call sites for helpers ==="
rg -n "getArith(Integer|Double)OpResult|maximumf|maxnumf|remsi|remf|ceildivsi|floordivsi" mlir -g '!**/build/**'Repository: munich-quantum-toolkit/core Length of output: 5551 Use MLIR folding/APInt/APFloat here instead of native C++ arithmetic.
🤖 Prompt for AI Agents |
||
|
|
||
| #endif // MQT_CORE_MQT_CORE_CLASSICALARITHOPERATION_H | ||
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
📐 Maintainability & Code Quality | 🟡 Minor | ⚡ Quick win
Fix the author attribution markup.
Line 16 is missing the closing
**, so the contributor attribution renders incorrectly.Proposed fix
📝 Committable suggestion
🤖 Prompt for AI Agents