2230bf99c7
The LLVM dialect type system has been closed until now, i.e. did not support types from other dialects inside containers. While this has had obvious benefits of deriving from a common base class, it has led to some simple types being almost identical with the built-in types, namely integer and floating point types. This in turn has led to a lot of larger-scale complexity: simple types must still be converted, numerous operations that correspond to LLVM IR intrinsics are replicated to produce versions operating on either LLVM dialect or built-in types leading to quasi-duplicate dialects, lowering to the LLVM dialect is essentially required to be one-shot because of type conversion, etc. In this light, it is reasonable to trade off some local complexity in the internal implementation of LLVM dialect types for removing larger-scale system complexity. Previous commits to the LLVM dialect type system have adapted the API to support types from other dialects. Replace LLVMIntegerType with the built-in IntegerType plus additional checks that such types are signless (these are isolated in a utility function that replaced `isa<LLVMType>` and in the parser). Temporarily keep the possibility to parse `!llvm.i32` as a synonym for `i32`, but add a deprecation notice. Reviewed By: mehdi_amini, silvas, antiagainst Differential Revision: https://reviews.llvm.org/D94178
79 lines
2.7 KiB
C++
79 lines
2.7 KiB
C++
//===- IndexIntrinsicsOpLowering.h - GPU IndexOps Lowering class *- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#ifndef MLIR_CONVERSION_GPUCOMMON_INDEXINTRINSICSOPLOWERING_H_
|
|
#define MLIR_CONVERSION_GPUCOMMON_INDEXINTRINSICSOPLOWERING_H_
|
|
|
|
#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
|
|
#include "mlir/Dialect/GPU/GPUDialect.h"
|
|
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
|
|
namespace mlir {
|
|
|
|
// Rewriting that replaces Op with XOp, YOp, or ZOp depending on the dimension
|
|
// that Op operates on. Op is assumed to return an `std.index` value and
|
|
// XOp, YOp and ZOp are assumed to return an `llvm.i32` value. Depending on
|
|
// `indexBitwidth`, sign-extend or truncate the resulting value to match the
|
|
// bitwidth expected by the consumers of the value.
|
|
template <typename Op, typename XOp, typename YOp, typename ZOp>
|
|
struct GPUIndexIntrinsicOpLowering : public ConvertOpToLLVMPattern<Op> {
|
|
private:
|
|
enum dimension { X = 0, Y = 1, Z = 2, invalid };
|
|
unsigned indexBitwidth;
|
|
|
|
static dimension dimensionToIndex(Op op) {
|
|
return StringSwitch<dimension>(op.dimension())
|
|
.Case("x", X)
|
|
.Case("y", Y)
|
|
.Case("z", Z)
|
|
.Default(invalid);
|
|
}
|
|
|
|
public:
|
|
explicit GPUIndexIntrinsicOpLowering(LLVMTypeConverter &typeConverter)
|
|
: ConvertOpToLLVMPattern<Op>(typeConverter),
|
|
indexBitwidth(typeConverter.getIndexTypeBitwidth()) {}
|
|
|
|
// Convert the kernel arguments to an LLVM type, preserve the rest.
|
|
LogicalResult
|
|
matchAndRewrite(Op op, ArrayRef<Value> operands,
|
|
ConversionPatternRewriter &rewriter) const override {
|
|
auto loc = op->getLoc();
|
|
MLIRContext *context = rewriter.getContext();
|
|
Value newOp;
|
|
switch (dimensionToIndex(op)) {
|
|
case X:
|
|
newOp = rewriter.create<XOp>(loc, IntegerType::get(context, 32));
|
|
break;
|
|
case Y:
|
|
newOp = rewriter.create<YOp>(loc, IntegerType::get(context, 32));
|
|
break;
|
|
case Z:
|
|
newOp = rewriter.create<ZOp>(loc, IntegerType::get(context, 32));
|
|
break;
|
|
default:
|
|
return failure();
|
|
}
|
|
|
|
if (indexBitwidth > 32) {
|
|
newOp = rewriter.create<LLVM::SExtOp>(
|
|
loc, IntegerType::get(context, indexBitwidth), newOp);
|
|
} else if (indexBitwidth < 32) {
|
|
newOp = rewriter.create<LLVM::TruncOp>(
|
|
loc, IntegerType::get(context, indexBitwidth), newOp);
|
|
}
|
|
|
|
rewriter.replaceOp(op, {newOp});
|
|
return success();
|
|
}
|
|
};
|
|
|
|
} // namespace mlir
|
|
|
|
#endif // MLIR_CONVERSION_GPUCOMMON_INDEXINTRINSICSOPLOWERING_H_
|