1//===- UBToLLVM.cpp - UB to LLVM dialect conversion -----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir/Conversion/UBToLLVM/UBToLLVM.h"
10
11#include "mlir/Conversion/ConvertToLLVM/ToLLVMInterface.h"
12#include "mlir/Conversion/LLVMCommon/ConversionTarget.h"
13#include "mlir/Conversion/LLVMCommon/Pattern.h"
14#include "mlir/Dialect/LLVMIR/LLVMConstantOps.h"
15#include "mlir/Dialect/LLVMIR/LLVMTerminatorOps.h"
16#include "mlir/Dialect/UB/IR/UBOps.h"
17#include "mlir/IR/TypeUtilities.h"
18#include "mlir/Pass/Pass.h"
19
20namespace mlir {
21#define GEN_PASS_DEF_UBTOLLVMCONVERSIONPASS
22#include "mlir/Conversion/Passes.h.inc"
23} // namespace mlir
24
25using namespace mlir;
26
27//===----------------------------------------------------------------------===//
28// PoisonOpLowering
29//===----------------------------------------------------------------------===//
30
31namespace {
32struct PoisonOpLowering : public ConvertOpToLLVMPattern<ub::PoisonOp> {
33 using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
34
35 LogicalResult
36 matchAndRewrite(ub::PoisonOp op, OpAdaptor adaptor,
37 ConversionPatternRewriter &rewriter) const override;
38};
39} // namespace
40
41LogicalResult
42PoisonOpLowering::matchAndRewrite(ub::PoisonOp op, OpAdaptor adaptor,
43 ConversionPatternRewriter &rewriter) const {
44 if (!isa<ub::PoisonAttr>(Val: op.getValue())) {
45 return rewriter.notifyMatchFailure(op, reasonCallback: [&](Diagnostic &diag) {
46 diag << "pattern can only convert op with '"
47 << ub::PoisonAttr::getMnemonic() << "' poison value";
48 });
49 }
50
51 Type resType = getTypeConverter()->convertType(t: op.getType());
52 if (!resType) {
53 return rewriter.notifyMatchFailure(op, reasonCallback: [&](Diagnostic &diag) {
54 diag << "failed to convert result type " << op.getType();
55 });
56 }
57
58 rewriter.replaceOpWithNewOp<LLVM::PoisonOp>(op, args&: resType);
59 return success();
60}
61
62//===----------------------------------------------------------------------===//
63// UnreachableOpLowering
64//===----------------------------------------------------------------------===//
65
66namespace {
67struct UnreachableOpLowering
68 : public ConvertOpToLLVMPattern<ub::UnreachableOp> {
69 using ConvertOpToLLVMPattern::ConvertOpToLLVMPattern;
70
71 LogicalResult
72 matchAndRewrite(ub::UnreachableOp op, OpAdaptor adaptor,
73 ConversionPatternRewriter &rewriter) const override;
74};
75} // namespace
76LogicalResult
77
78UnreachableOpLowering::matchAndRewrite(
79 ub::UnreachableOp op, OpAdaptor adaptor,
80 ConversionPatternRewriter &rewriter) const {
81 rewriter.replaceOpWithNewOp<LLVM::UnreachableOp>(op);
82 return success();
83}
84
85//===----------------------------------------------------------------------===//
86// Pass Definition
87//===----------------------------------------------------------------------===//
88
89namespace {
90struct UBToLLVMConversionPass
91 : public impl::UBToLLVMConversionPassBase<UBToLLVMConversionPass> {
92 using Base::Base;
93
94 void runOnOperation() override {
95 LLVMConversionTarget target(getContext());
96 RewritePatternSet patterns(&getContext());
97
98 LowerToLLVMOptions options(&getContext());
99 if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
100 options.overrideIndexBitwidth(bitwidth: indexBitwidth);
101
102 LLVMTypeConverter converter(&getContext(), options);
103 mlir::ub::populateUBToLLVMConversionPatterns(converter, patterns);
104
105 if (failed(Result: applyPartialConversion(op: getOperation(), target,
106 patterns: std::move(patterns))))
107 signalPassFailure();
108 }
109};
110} // namespace
111
112//===----------------------------------------------------------------------===//
113// Pattern Population
114//===----------------------------------------------------------------------===//
115
116void mlir::ub::populateUBToLLVMConversionPatterns(
117 const LLVMTypeConverter &converter, RewritePatternSet &patterns) {
118 patterns.add<PoisonOpLowering, UnreachableOpLowering>(arg: converter);
119}
120
121//===----------------------------------------------------------------------===//
122// ConvertToLLVMPatternInterface implementation
123//===----------------------------------------------------------------------===//
124
125namespace {
126/// Implement the interface to convert UB to LLVM.
127struct UBToLLVMDialectInterface : public ConvertToLLVMPatternInterface {
128 UBToLLVMDialectInterface(Dialect *dialect)
129 : ConvertToLLVMPatternInterface(dialect) {}
130
131 void loadDependentDialects(MLIRContext *context) const final {
132 context->loadDialect<LLVM::LLVMDialect>();
133 }
134
135 /// Hook for derived dialect interface to provide conversion patterns
136 /// and mark dialect legal for the conversion target.
137 void populateConvertToLLVMConversionPatterns(
138 ConversionTarget &target, LLVMTypeConverter &typeConverter,
139 RewritePatternSet &patterns) const final {
140 ub::populateUBToLLVMConversionPatterns(converter: typeConverter, patterns);
141 }
142};
143} // namespace
144
145void mlir::ub::registerConvertUBToLLVMInterface(DialectRegistry &registry) {
146 registry.addExtension(extensionFn: +[](MLIRContext *ctx, ub::UBDialect *dialect) {
147 dialect->addInterfaces<UBToLLVMDialectInterface>();
148 });
149}
150