DataLayoutImporter.h

Go to the documentation of this file.

//===- DataLayoutImporter.h - LLVM to MLIR data layout conversion -*- 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
//
//===----------------------------------------------------------------------===//
//
// This file implements the translation between the LLVMIR data layout and the
// corresponding MLIR representation.
//
//===----------------------------------------------------------------------===//
 
#ifndef MLIR_TARGET_LLVMIR_DATALAYOUTIMPORTER_H
#define MLIR_TARGET_LLVMIR_DATALAYOUTIMPORTER_H
 
#include "mlir/Dialect/LLVMIR/LLVMTypes.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/Interfaces/DataLayoutInterfaces.h"
#include "llvm/ADT/MapVector.h"
 
namespace llvm {
class StringRef;
class DataLayout;
} // namespace llvm
 
namespace mlir {
class FloatType;
class MLIRContext;
class Operation;
 
namespace LLVM {
class LLVMFuncOp;
 
namespace detail {
 
/// Returns a supported MLIR floating point type of the given bit width or
/// null if the bit width is not supported.
FloatType getFloatType(MLIRContext *context, unsigned width);
 
/// Helper class that translates an LLVM data layout string to an MLIR data
/// layout specification. Only integer, float, pointer, alloca memory space,
/// stack alignment, and endianness entries are translated. The class also
/// returns all entries from the default data layout specification found in the
/// language reference (https://llvm.org/docs/LangRef.html#data-layout) if they
/// are not overwritten by the provided data layout.
class DataLayoutImporter {
public:
  DataLayoutImporter(MLIRContext *context, StringRef dataLayoutStr)
      : dataLayoutStr(dataLayoutStr), context(context) {
    // Translate the `dataLayoutStr`. First, append the default data layout
    // string specified in the language reference
    // (https://llvm.org/docs/LangRef.html#data-layout) to the supplied string.
    // The translation then parses the string and ignores the default value if a
    // specific kind occurs in both strings. Additionally, the following default
    // values exist:
    // - non-default address space pointer specifications default to the default
    //   address space pointer specification
    // - the alloca address space defaults to the default address space.
    dataLayoutSpec = dataLayoutSpecFromDataLayoutStr();
  }
 
  /// Returns the MLIR data layout specification translated from the LLVM
  /// data layout.
  DataLayoutSpecInterface getDataLayoutSpec() const { return dataLayoutSpec; }
 
  /// Returns the last data layout token that has been processed before
  /// the data layout translation failed.
  StringRef getLastToken() const { return lastToken; }
 
  /// Returns the data layout tokens that have not been handled during the
  /// data layout translation.
  ArrayRef<StringRef> getUnhandledTokens() const { return unhandledTokens; }
 
private:
  /// Translate the LLVM data layout string to an MLIR data layout
  /// specification.
  DataLayoutSpecInterface dataLayoutSpecFromDataLayoutStr();
 
  /// Tries to parse the letter only prefix that identifies the specification
  /// and removes the consumed characters from the beginning of the string.
  FailureOr<StringRef> tryToParseAlphaPrefix(StringRef &token) const;
 
  /// Tries to parse an integer parameter and removes the integer from the
  /// beginning of the string.
  FailureOr<uint64_t> tryToParseInt(StringRef &token) const;
 
  /// Tries to parse an integer parameter array.
  FailureOr<SmallVector<uint64_t>> tryToParseIntList(StringRef token) const;
 
  /// Tries to parse the parameters of a type alignment entry.
  FailureOr<DenseIntElementsAttr> tryToParseAlignment(StringRef token) const;
 
  /// Tries to parse the parameters of a pointer alignment entry.
  FailureOr<DenseIntElementsAttr>
  tryToParsePointerAlignment(StringRef token) const;
 
  /// Adds a type alignment entry if there is none yet.
  LogicalResult tryToEmplaceAlignmentEntry(Type type, StringRef token);
 
  /// Adds a pointer alignment entry if there is none yet.
  LogicalResult tryToEmplacePointerAlignmentEntry(LLVMPointerType type,
                                                  StringRef token);
 
  /// Adds an endianness entry if there is none yet.
  LogicalResult tryToEmplaceEndiannessEntry(StringRef endianness,
                                            StringRef token);
 
  /// Adds an alloca address space entry if there is none yet.
  LogicalResult tryToEmplaceAddrSpaceEntry(StringRef token,
                                           llvm::StringLiteral spaceKey);
 
  /// Adds an mangling mode entry if there is none yet.
  LogicalResult tryToEmplaceManglingModeEntry(StringRef token,
                                              llvm::StringLiteral manglingKey);
 
  /// Adds a stack alignment entry if there is none yet.
  LogicalResult tryToEmplaceStackAlignmentEntry(StringRef token);
 
  /// Adds a function pointer alignment entry if there is none yet.
  LogicalResult
  tryToEmplaceFunctionPointerAlignmentEntry(StringRef fnPtrAlignEntry,
                                            StringRef token);
 
  /// Adds legal int widths entry if there is none yet.
  LogicalResult tryToEmplaceLegalIntWidthsEntry(StringRef token);
 
  std::string dataLayoutStr = {};
  DataLayoutSpecInterface dataLayoutSpec;
 
  StringRef lastToken = {};
  SmallVector<StringRef> unhandledTokens;
  llvm::MapVector<StringAttr, DataLayoutEntryInterface> keyEntries;
  llvm::MapVector<TypeAttr, DataLayoutEntryInterface> typeEntries;
  MLIRContext *context;
};
 
} // namespace detail
} // namespace LLVM
} // namespace mlir
 
#endif // MLIR_TARGET_LLVMIR_DATALAYOUTIMPORTER_H