[mlir][math] Add vector support for math-to-apfloat #172715
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
from
16036e6 to
53490a8
Compare
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
from
53490a8 to
b3c8b87
Compare
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
from
b3c8b87 to
ddbcffa
Compare
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
2 times, most recently
from
cd6093b to
102d672
Compare
Member
|
@llvm/pr-subscribers-mlir-math @llvm/pr-subscribers-mlir Author: Maksim Levental (makslevental) ChangesThis PR adds vector type support to TODO: add lit tests Patch is 34.25 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/172715.diff 7 Files Affected:
diff --git a/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.h b/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.h
index 6702aca045ba4..2dacc2e11b049 100644
--- a/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.h
+++ b/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.h
@@ -9,6 +9,7 @@
#ifndef MLIR_CONVERSION_ARITHANDMATHTOAPFLOAT_ARITHTOAPFLOAT_H
#define MLIR_CONVERSION_ARITHANDMATHTOAPFLOAT_ARITHTOAPFLOAT_H
+#include "llvm/ADT/SmallVector.h"
#include <memory>
namespace mlir {
diff --git a/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/MathToAPFloat.h b/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/MathToAPFloat.h
index 6cb44c89ecebb..06548c250a27b 100644
--- a/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/MathToAPFloat.h
+++ b/mlir/include/mlir/Conversion/ArithAndMathToAPFloat/MathToAPFloat.h
@@ -9,6 +9,7 @@
#ifndef MLIR_CONVERSION_ARITHANDMATHTOAPFLOAT_MATHTOAPFLOAT_H
#define MLIR_CONVERSION_ARITHANDMATHTOAPFLOAT_MATHTOAPFLOAT_H
+#include "llvm/ADT/SmallVector.h"
#include <memory>
namespace mlir {
diff --git a/mlir/include/mlir/Conversion/Passes.td b/mlir/include/mlir/Conversion/Passes.td
index 7f24e58671aab..fb2860bee6d43 100644
--- a/mlir/include/mlir/Conversion/Passes.td
+++ b/mlir/include/mlir/Conversion/Passes.td
@@ -198,6 +198,10 @@ def ArithToAPFloatConversionPass
calls (APFloatWrappers.cpp). APFloat is a software implementation of
floating-point arithmetic operations.
}];
+ let options = [
+ ListOption<"sourceTypeStrs", "source-types", "std::string",
+ "MLIR types without arithmetic support on a given target">,
+ ];
let dependentDialects = ["arith::ArithDialect", "func::FuncDialect",
"vector::VectorDialect"];
}
@@ -787,6 +791,10 @@ def MathToAPFloatConversionPass
calls (APFloatWrappers.cpp). APFloat is a software implementation of
floating-point mathmetic operations.
}];
+ let options = [
+ ListOption<"sourceTypeStrs", "source-types", "std::string",
+ "MLIR types without arithmetic support on a given target">,
+ ];
let dependentDialects = ["math::MathDialect", "func::FuncDialect"];
}
diff --git a/mlir/lib/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.cpp b/mlir/lib/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.cpp
index 813a854f2fc97..52eb32de6586b 100644
--- a/mlir/lib/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.cpp
+++ b/mlir/lib/Conversion/ArithAndMathToAPFloat/ArithToAPFloat.cpp
@@ -46,86 +46,20 @@ lookupOrCreateBinaryFn(OpBuilder &b, SymbolOpInterface symTable, StringRef name,
{i32Type, i64Type, i64Type}, symbolTables);
}
-/// Given two operands of vector type and vector result type (with the same
-/// shape), call the given function for each pair of scalar operands and
-/// package the result into a vector. If the given operands and result type are
-/// not vectors, call the function directly. The second operand is optional.
-template <typename Fn, typename... Values>
-static Value forEachScalarValue(RewriterBase &rewriter, Location loc,
- Value operand1, Value operand2, Type resultType,
- Fn fn) {
- auto vecTy1 = dyn_cast<VectorType>(operand1.getType());
- if (operand2) {
- // Sanity check: Operand types must match.
- assert(vecTy1 == dyn_cast<VectorType>(operand2.getType()) &&
- "expected same vector types");
- }
- if (!vecTy1) {
- // Not a vector. Call the function directly.
- return fn(operand1, operand2, resultType);
- }
-
- // Prepare scalar operands.
- ResultRange sclars1 =
- vector::ToElementsOp::create(rewriter, loc, operand1)->getResults();
- SmallVector<Value> scalars2;
- if (!operand2) {
- // No second operand. Create a vector of empty values.
- scalars2.assign(vecTy1.getNumElements(), Value());
- } else {
- llvm::append_range(
- scalars2,
- vector::ToElementsOp::create(rewriter, loc, operand2)->getResults());
- }
-
- // Call the function for each pair of scalar operands.
- auto resultVecType = cast<VectorType>(resultType);
- SmallVector<Value> results;
- for (auto [scalar1, scalar2] : llvm::zip_equal(sclars1, scalars2)) {
- Value result = fn(scalar1, scalar2, resultVecType.getElementType());
- results.push_back(result);
- }
-
- // Package the results into a vector.
- return vector::FromElementsOp::create(
- rewriter, loc,
- vecTy1.cloneWith(/*shape=*/std::nullopt, results.front().getType()),
- results);
-}
-
-/// Check preconditions for the conversion:
-/// 1. All operands / results must be integers or floats (or vectors thereof).
-/// 2. The bitwidth of the operands / results must be <= 64.
-static LogicalResult checkPreconditions(RewriterBase &rewriter, Operation *op) {
- for (Value value : llvm::concat<Value>(op->getOperands(), op->getResults())) {
- Type type = value.getType();
- if (auto vecTy = dyn_cast<VectorType>(type)) {
- type = vecTy.getElementType();
- }
- if (!type.isIntOrFloat()) {
- return rewriter.notifyMatchFailure(
- op, "only integers and floats (or vectors thereof) are supported");
- }
- if (type.getIntOrFloatBitWidth() > 64)
- return rewriter.notifyMatchFailure(op,
- "bitwidth > 64 bits is not supported");
- }
- return success();
-}
-
/// Rewrite a binary arithmetic operation to an APFloat function call.
template <typename OpTy>
struct BinaryArithOpToAPFloatConversion final : OpRewritePattern<OpTy> {
BinaryArithOpToAPFloatConversion(MLIRContext *context,
const char *APFloatName,
SymbolOpInterface symTable,
+ ArrayRef<Type> sourceTypes,
PatternBenefit benefit = 1)
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
- APFloatName(APFloatName) {};
+ APFloatName(APFloatName), sourceTypes(sourceTypes) {};
LogicalResult matchAndRewrite(OpTy op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -170,17 +104,19 @@ struct BinaryArithOpToAPFloatConversion final : OpRewritePattern<OpTy> {
SymbolOpInterface symTable;
const char *APFloatName;
+ ArrayRef<Type> sourceTypes;
};
template <typename OpTy>
struct FpToFpConversion final : OpRewritePattern<OpTy> {
FpToFpConversion(MLIRContext *context, SymbolOpInterface symTable,
- PatternBenefit benefit = 1)
- : OpRewritePattern<OpTy>(context, benefit), symTable(symTable) {}
+ ArrayRef<Type> sourceTypes, PatternBenefit benefit = 1)
+ : OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
+ sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(OpTy op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -227,18 +163,20 @@ struct FpToFpConversion final : OpRewritePattern<OpTy> {
}
SymbolOpInterface symTable;
+ ArrayRef<Type> sourceTypes;
};
template <typename OpTy>
struct FpToIntConversion final : OpRewritePattern<OpTy> {
FpToIntConversion(MLIRContext *context, SymbolOpInterface symTable,
- bool isUnsigned, PatternBenefit benefit = 1)
+ bool isUnsigned, ArrayRef<Type> sourceTypes,
+ PatternBenefit benefit = 1)
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
- isUnsigned(isUnsigned) {}
+ isUnsigned(isUnsigned), sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(OpTy op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -289,18 +227,20 @@ struct FpToIntConversion final : OpRewritePattern<OpTy> {
SymbolOpInterface symTable;
bool isUnsigned;
+ ArrayRef<Type> sourceTypes;
};
template <typename OpTy>
struct IntToFpConversion final : OpRewritePattern<OpTy> {
IntToFpConversion(MLIRContext *context, SymbolOpInterface symTable,
- bool isUnsigned, PatternBenefit benefit = 1)
+ bool isUnsigned, ArrayRef<Type> sourceTypes,
+ PatternBenefit benefit = 1)
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
- isUnsigned(isUnsigned) {}
+ isUnsigned(isUnsigned), sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(OpTy op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -361,16 +301,19 @@ struct IntToFpConversion final : OpRewritePattern<OpTy> {
SymbolOpInterface symTable;
bool isUnsigned;
+ ArrayRef<Type> sourceTypes;
};
struct CmpFOpToAPFloatConversion final : OpRewritePattern<arith::CmpFOp> {
CmpFOpToAPFloatConversion(MLIRContext *context, SymbolOpInterface symTable,
+ ArrayRef<Type> sourceTypes,
PatternBenefit benefit = 1)
- : OpRewritePattern<arith::CmpFOp>(context, benefit), symTable(symTable) {}
+ : OpRewritePattern<arith::CmpFOp>(context, benefit), symTable(symTable),
+ sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(arith::CmpFOp op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -512,16 +455,19 @@ struct CmpFOpToAPFloatConversion final : OpRewritePattern<arith::CmpFOp> {
}
SymbolOpInterface symTable;
+ ArrayRef<Type> sourceTypes;
};
struct NegFOpToAPFloatConversion final : OpRewritePattern<arith::NegFOp> {
NegFOpToAPFloatConversion(MLIRContext *context, SymbolOpInterface symTable,
+ ArrayRef<Type> sourceTypes,
PatternBenefit benefit = 1)
- : OpRewritePattern<arith::NegFOp>(context, benefit), symTable(symTable) {}
+ : OpRewritePattern<arith::NegFOp>(context, benefit), symTable(symTable),
+ sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(arith::NegFOp op,
PatternRewriter &rewriter) const override {
- if (failed(checkPreconditions(rewriter, op)))
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
return failure();
// Get APFloat function from runtime library.
@@ -564,6 +510,7 @@ struct NegFOpToAPFloatConversion final : OpRewritePattern<arith::NegFOp> {
}
SymbolOpInterface symTable;
+ ArrayRef<Type> sourceTypes;
};
namespace {
@@ -577,36 +524,46 @@ struct ArithToAPFloatConversionPass final
void ArithToAPFloatConversionPass::runOnOperation() {
MLIRContext *context = &getContext();
RewritePatternSet patterns(context);
- patterns.add<BinaryArithOpToAPFloatConversion<arith::AddFOp>>(context, "add",
- getOperation());
+
+ FailureOr<SmallVector<Type>> sourceTypes =
+ parseSourceTypes(llvm::to_vector(sourceTypeStrs), context);
+ if (failed(sourceTypes))
+ return signalPassFailure();
+
+ patterns.add<BinaryArithOpToAPFloatConversion<arith::AddFOp>>(
+ context, "add", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::SubFOp>>(
- context, "subtract", getOperation());
+ context, "subtract", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::MulFOp>>(
- context, "multiply", getOperation());
+ context, "multiply", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::DivFOp>>(
- context, "divide", getOperation());
+ context, "divide", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::RemFOp>>(
- context, "remainder", getOperation());
+ context, "remainder", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::MinNumFOp>>(
- context, "minnum", getOperation());
+ context, "minnum", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::MaxNumFOp>>(
- context, "maxnum", getOperation());
+ context, "maxnum", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::MinimumFOp>>(
- context, "minimum", getOperation());
+ context, "minimum", getOperation(), *sourceTypes);
patterns.add<BinaryArithOpToAPFloatConversion<arith::MaximumFOp>>(
- context, "maximum", getOperation());
+ context, "maximum", getOperation(), *sourceTypes);
patterns
.add<FpToFpConversion<arith::ExtFOp>, FpToFpConversion<arith::TruncFOp>,
CmpFOpToAPFloatConversion, NegFOpToAPFloatConversion>(
- context, getOperation());
+ context, getOperation(), *sourceTypes);
patterns.add<FpToIntConversion<arith::FPToSIOp>>(context, getOperation(),
- /*isUnsigned=*/false);
+ /*isUnsigned=*/false,
+ *sourceTypes);
patterns.add<FpToIntConversion<arith::FPToUIOp>>(context, getOperation(),
- /*isUnsigned=*/true);
+ /*isUnsigned=*/true,
+ *sourceTypes);
patterns.add<IntToFpConversion<arith::SIToFPOp>>(context, getOperation(),
- /*isUnsigned=*/false);
+ /*isUnsigned=*/false,
+ *sourceTypes);
patterns.add<IntToFpConversion<arith::UIToFPOp>>(context, getOperation(),
- /*isUnsigned=*/true);
+ /*isUnsigned=*/true,
+ *sourceTypes);
LogicalResult result = success();
ScopedDiagnosticHandler scopedHandler(context, [&result](Diagnostic &diag) {
if (diag.getSeverity() == DiagnosticSeverity::Error) {
diff --git a/mlir/lib/Conversion/ArithAndMathToAPFloat/MathToAPFloat.cpp b/mlir/lib/Conversion/ArithAndMathToAPFloat/MathToAPFloat.cpp
index 784028f5cf2eb..b5e15e5c42bed 100644
--- a/mlir/lib/Conversion/ArithAndMathToAPFloat/MathToAPFloat.cpp
+++ b/mlir/lib/Conversion/ArithAndMathToAPFloat/MathToAPFloat.cpp
@@ -28,21 +28,15 @@ using namespace mlir::func;
struct AbsFOpToAPFloatConversion final : OpRewritePattern<math::AbsFOp> {
AbsFOpToAPFloatConversion(MLIRContext *context, SymbolOpInterface symTable,
+ ArrayRef<Type> sourceTypes,
PatternBenefit benefit = 1)
- : OpRewritePattern<math::AbsFOp>(context, benefit), symTable(symTable) {}
+ : OpRewritePattern<math::AbsFOp>(context, benefit), symTable(symTable),
+ sourceTypes(sourceTypes) {}
LogicalResult matchAndRewrite(math::AbsFOp op,
PatternRewriter &rewriter) const override {
- // Cast operands to 64-bit integers.
- auto operand = op.getOperand();
- auto floatTy = dyn_cast<FloatType>(operand.getType());
- if (!floatTy)
- return rewriter.notifyMatchFailure(op,
- "only scalar FloatTypes supported");
- if (floatTy.getIntOrFloatBitWidth() > 64) {
- return rewriter.notifyMatchFailure(op,
- "bitwidth > 64 bits is not supported");
- }
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
+ return failure();
// Get APFloat function from runtime library.
auto i32Type = IntegerType::get(symTable->getContext(), 32);
auto i64Type = IntegerType::get(symTable->getContext(), 64);
@@ -52,49 +46,50 @@ struct AbsFOpToAPFloatConversion final : OpRewritePattern<math::AbsFOp> {
return fn;
Location loc = op.getLoc();
rewriter.setInsertionPoint(op);
- auto intWType = rewriter.getIntegerType(floatTy.getWidth());
- Value operandBits = arith::ExtUIOp::create(
- rewriter, loc, i64Type,
- arith::BitcastOp::create(rewriter, loc, intWType, operand));
-
- // Call APFloat function.
- Value semValue = getAPFloatSemanticsValue(rewriter, loc, floatTy);
- SmallVector<Value> params = {semValue, operandBits};
- Value negatedBits = func::CallOp::create(rewriter, loc, TypeRange(i64Type),
- SymbolRefAttr::get(*fn), params)
- ->getResult(0);
-
- // Truncate result to the original width.
- Value truncatedBits =
- arith::TruncIOp::create(rewriter, loc, intWType, negatedBits);
- rewriter.replaceOp(
- op, arith::BitcastOp::create(rewriter, loc, floatTy, truncatedBits));
+ // Scalarize and convert to APFloat runtime calls.
+ Value repl = forEachScalarValue(
+ rewriter, loc, op.getOperand(), /*operand2=*/Value(), op.getType(),
+ [&](Value operand, Value, Type resultType) {
+ auto floatTy = cast<FloatType>(operand.getType());
+ auto intWType = rewriter.getIntegerType(floatTy.getWidth());
+ Value operandBits = arith::ExtUIOp::create(
+ rewriter, loc, i64Type,
+ arith::BitcastOp::create(rewriter, loc, intWType, operand));
+ // Call APFloat function.
+ Value semValue = getAPFloatSemanticsValue(rewriter, loc, floatTy);
+ SmallVector<Value> params = {semValue, operandBits};
+ Value negatedBits =
+ func::CallOp::create(rewriter, loc, TypeRange(i64Type),
+ SymbolRefAttr::get(*fn), params)
+ ->getResult(0);
+ // Truncate result to the original width.
+ auto truncatedBits =
+ arith::TruncIOp::create(rewriter, loc, intWType, negatedBits);
+ return arith::BitcastOp::create(rewriter, loc, floatTy,
+ truncatedBits);
+ });
+
+ rewriter.replaceOp(op, repl);
return success();
}
SymbolOpInterface symTable;
+ ArrayRef<Type> sourceTypes;
};
template <typename OpTy>
struct IsOpToAPFloatConversion final : OpRewritePattern<OpTy> {
IsOpToAPFloatConversion(MLIRContext *context, const char *APFloatName,
SymbolOpInterface symTable,
+ ArrayRef<Type> sourceTypes,
PatternBenefit benefit = 1)
: OpRewritePattern<OpTy>(context, benefit), symTable(symTable),
- APFloatName(APFloatName) {};
+ APFloatName(APFloatName), sourceTypes(sourceTypes) {};
LogicalResult matchAndRewrite(OpTy op,
PatternRewriter &rewriter) const override {
- // Cast operands to 64-bit integers.
- auto operand = op.getOperand();
- auto floatTy = dyn_cast<FloatType>(operand.getType());
- if (!floatTy)
- return rewriter.notifyMatchFailure(op,
- "only scalar FloatTypes supported");
- if (floatTy.getIntOrFloatBitWidth() > 64) {
- return rewriter.notifyMatchFailure(op,
- "bitwidth > 64 bits is not supported");
- }
+ if (failed(checkPreconditions(rewriter, op, sourceTypes)))
+ return failure();
// Get APFloat function from runtime library.
auto i1 = IntegerType::get(symTable->getContext(), 1);
auto i32Type = IntegerType::get(symTable->getContext(), 32);
@@ -...
[truncated]
|
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
from
102d672 to
acf7738
Compare
krzysz00
reviewed
Jan 10, 2026
Contributor
krzysz00
left a comment
krzysz00
left a comment
There was a problem hiding this comment.
My one concern is that you're storing ArrayRef, which will have lifetime issues - I'd copy those into a SmallVector instead
Overall, seems like a good extension.
Member
matthias-springer
left a comment
matthias-springer
left a comment
There was a problem hiding this comment.
Looks good overall!
| /// shape), call the given function for each pair of scalar operands and | ||
| /// package the result into a vector. If the given operands and result type are | ||
| /// not vectors, call the function directly. The second operand is optional. | ||
| template <typename Fn, typename... Values> |
Member
There was a problem hiding this comment.
typename... Values is unused? (This seems already redundant in the original code.)
| template <typename Fn, typename... Values> | ||
| Value forEachScalarValue(mlir::RewriterBase &rewriter, Location loc, | ||
| Value operand1, Value operand2, Type resultType, | ||
| Fn fn) { |
Member
There was a problem hiding this comment.
Now that this is in a header file, maybe it makes sense to pass a function pointer instead of templatizing the function? Then the implementation could be in the .cpp file. Not sure if it's really better, just an idea...
Contributor
Author
There was a problem hiding this comment.
i opted for not extending forEachScalarValue and therefore being able to use llvm::function_ref and being able to move the impl into Util.cpp
| return arith::BitcastOp::create(rewriter, loc, floatTy, trunc); | ||
| }; | ||
|
|
||
| if (VectorType vecTy1 = dyn_cast<VectorType>(op.getA().getType())) { |
Member
There was a problem hiding this comment.
Can forEachScalarValue be used here? It is unused at the moment, but I wrote typename... Values to support an arbitrary number of operands. Seems like I abandoned that implementation for some reason...
Contributor
Author
There was a problem hiding this comment.
easier to just one-off here (not many 3+ operand ops to handle...)
| floating-point arithmetic operations. | ||
| }]; | ||
| let options = [ | ||
| ListOption<"sourceTypeStrs", "source-types", "std::string", |
Member
There was a problem hiding this comment.
I would split this PR into two: one that adds source-types and one that adds vector support.
Member
Either that or document somewhere (pattern constructor?) that the lifetime of data must last at least until the last pattern application. (As long as we don't expose these patterns through public |
makslevental
force-pushed
the
users/makslevental/vectormathapfloat
branch
from
d947dcd to
982454b
Compare
Contributor
Author
I don't think this is a big deal - the backing for the |
Contributor
Author
|
@matthias-springer @krzysz00 this is now done/actually ready to review |
…-obj' into users/makslevental/vectormathapfloat
matthias-springer
approved these changes
Jan 16, 2026
makslevental
added a commit
that referenced
this pull request
Jan 16, 2026
makslevental
added a commit
that referenced
this pull request
Jan 16, 2026
makslevental
added a commit
that referenced
this pull request
Jan 16, 2026
makslevental
added a commit
that referenced
this pull request
Jan 16, 2026
Contributor
|
I think this commit broke one of our bots. The bot does not listen to MLIR changes (apologies, I'll make it listen) so it did only break after this patch found its way into Seems like a missing link dependency. Bot: https://lab.llvm.org/buildbot/#/builders/206/builds/12012/steps/7/logs/stdio Error |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/203/builds/34447 Here is the relevant piece of the build log for the reference |
Contributor
Author
|
Fixed already here #176462 |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/205/builds/33232 Here is the relevant piece of the build log for the reference |
|
LLVM Buildbot has detected a new failure on builder Full details are available at: https://lab.llvm.org/buildbot/#/builders/204/builds/33253 Here is the relevant piece of the build log for the reference |
Priyanshu3820
pushed a commit
to Priyanshu3820/llvm-project
that referenced
this pull request
Jan 18, 2026
This PR adds vector type support to `math-to-apfloat`.
Priyanshu3820
pushed a commit
to Priyanshu3820/llvm-project
that referenced
this pull request
Jan 18, 2026
BStott6
pushed a commit
to BStott6/llvm-project
that referenced
this pull request
Jan 22, 2026
This PR adds vector type support to `math-to-apfloat`.
BStott6
pushed a commit
to BStott6/llvm-project
that referenced
this pull request
Jan 22, 2026
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
7 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR adds vector type support to
math-to-apfloat. It also addssupported-types(matching the convention/semantics for the pass arg established by-arith-emulate-unsupported-floats) pass arguments to botharith-to-apfloatandmath-to-apfloatto filter down which types will be converted. Note, by default (i.e., emptysupported-types) allfptypes will be converted (i.e.,empty->convert all).