ConvertStandardToLLVM.h

Go to the documentation of this file.

//===- ConvertStandardToLLVM.h - Convert to the LLVM dialect ----*- C++ -*-===//
//
// Part of the MLIR 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
//
//===----------------------------------------------------------------------===//
//
// Provides a dialect conversion targeting the LLVM IR dialect.  By default, it
// converts Standard ops and types and provides hooks for dialect-specific
// extensions to the conversion.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H
#define MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H

#include "mlir/Transforms/DialectConversion.h"

namespace llvm {
class IntegerType;
class LLVMContext;
class Module;
class Type;
} // namespace llvm

namespace mlir {

class UnrankedMemRefType;

namespace LLVM {
class LLVMDialect;
class LLVMType;
} // namespace LLVM

class LLVMTypeConverter : public TypeConverter {
public:
  using TypeConverter::convertType;

  LLVMTypeConverter(MLIRContext *ctx);

  Type convertType(Type t) override;

  LLVM::LLVMType convertFunctionSignature(FunctionType type, bool isVariadic,
                                          SignatureConversion &result);

  Type packFunctionResults(ArrayRef<Type> types);

  llvm::LLVMContext &getLLVMContext();

  LLVM::LLVMDialect *getDialect() { return llvmDialect; }

  SmallVector<Value, 4> promoteMemRefDescriptors(Location loc,
                                                 ValueRange opOperands,
                                                 ValueRange operands,
                                                 OpBuilder &builder);

  Value promoteOneMemRefDescriptor(Location loc, Value operand,
                                   OpBuilder &builder);

protected:
  llvm::Module *module;
  LLVM::LLVMDialect *llvmDialect;

private:
  Type convertStandardType(Type type);

  // Convert a function type.  The arguments and results are converted one by
  // one.  Additionally, if the function returns more than one value, pack the
  // results into an LLVM IR structure type so that the converted function type
  // returns at most one result.
  Type convertFunctionType(FunctionType type);

  // Convert the index type.  Uses llvmModule data layout to create an integer
  // of the pointer bitwidth.
  Type convertIndexType(IndexType type);

  // Convert an integer type `i*` to `!llvm<"i*">`.
  Type convertIntegerType(IntegerType type);

  // Convert a floating point type: `f16` to `!llvm.half`, `f32` to
  // `!llvm.float` and `f64` to `!llvm.double`.  `bf16` is not supported
  // by LLVM.
  Type convertFloatType(FloatType type);

  // Convert a memref type into an LLVM type that captures the relevant data.
  // For statically-shaped memrefs, the resulting type is a pointer to the
  // (converted) memref element type. For dynamically-shaped memrefs, the
  // resulting type is an LLVM structure type that contains:
  //   1. a pointer to the (converted) memref element type
  //   2. as many index types as memref has dynamic dimensions.
  Type convertMemRefType(MemRefType type);

  // Convert an unranked memref type to an LLVM type that captures the
  // runtime rank and a pointer to the static ranked memref desc
  Type convertUnrankedMemRefType(UnrankedMemRefType type);

  // Convert a 1D vector type into an LLVM vector type.
  Type convertVectorType(VectorType type);

  // Get the LLVM representation of the index type based on the bitwidth of the
  // pointer as defined by the data layout of the module.
  LLVM::LLVMType getIndexType();

  // Extract an LLVM IR dialect type.
  LLVM::LLVMType unwrap(Type type);
};

class StructBuilder {
public:
  explicit StructBuilder(Value v);
  static StructBuilder undef(OpBuilder &builder, Location loc,
                             Type descriptorType);

  /*implicit*/ operator Value() { return value; }

protected:
  // LLVM value
  Value value;
  // Cached struct type.
  Type structType;

protected:
  Value extractPtr(OpBuilder &builder, Location loc, unsigned pos);
  void setPtr(OpBuilder &builder, Location loc, unsigned pos, Value ptr);
};
class MemRefDescriptor : public StructBuilder {
public:
  explicit MemRefDescriptor(Value descriptor);
  static MemRefDescriptor undef(OpBuilder &builder, Location loc,
                                Type descriptorType);
  static MemRefDescriptor fromStaticShape(OpBuilder &builder, Location loc,
                                          LLVMTypeConverter &typeConverter,
                                          MemRefType type, Value memory);

  Value allocatedPtr(OpBuilder &builder, Location loc);
  void setAllocatedPtr(OpBuilder &builder, Location loc, Value ptr);

  Value alignedPtr(OpBuilder &builder, Location loc);

  void setAlignedPtr(OpBuilder &builder, Location loc, Value ptr);

  Value offset(OpBuilder &builder, Location loc);

  void setOffset(OpBuilder &builder, Location loc, Value offset);
  void setConstantOffset(OpBuilder &builder, Location loc, uint64_t offset);

  Value size(OpBuilder &builder, Location loc, unsigned pos);

  void setSize(OpBuilder &builder, Location loc, unsigned pos, Value size);
  void setConstantSize(OpBuilder &builder, Location loc, unsigned pos,
                       uint64_t size);

  Value stride(OpBuilder &builder, Location loc, unsigned pos);

  void setStride(OpBuilder &builder, Location loc, unsigned pos, Value stride);
  void setConstantStride(OpBuilder &builder, Location loc, unsigned pos,
                         uint64_t stride);

  LLVM::LLVMType getElementType();

private:
  // Cached index type.
  Type indexType;
};

class UnrankedMemRefDescriptor : public StructBuilder {
public:
  explicit UnrankedMemRefDescriptor(Value descriptor);
  static UnrankedMemRefDescriptor undef(OpBuilder &builder, Location loc,
                                        Type descriptorType);

  Value rank(OpBuilder &builder, Location loc);
  void setRank(OpBuilder &builder, Location loc, Value value);
  Value memRefDescPtr(OpBuilder &builder, Location loc);
  void setMemRefDescPtr(OpBuilder &builder, Location loc, Value value);
};
class LLVMOpLowering : public ConversionPattern {
public:
  LLVMOpLowering(StringRef rootOpName, MLIRContext *context,
                 LLVMTypeConverter &lowering, PatternBenefit benefit = 1);

protected:
  // Back-reference to the lowering class, used to call type and function
  // conversions accounting for potential extensions.
  LLVMTypeConverter &lowering;
};

} // namespace mlir

#endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVM_H