SimTypes.cpp

Go to the documentation of this file.

//===- SimTypes.cpp -------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
 
#include "circt/Dialect/Sim/SimTypes.h"
#include "circt/Dialect/HW/HWTypes.h"
#include "circt/Dialect/Sim/SimDialect.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/TypeSwitch.h"
 
// Include the generated enum definitions (DPIDirection).
#include "circt/Dialect/Sim/SimEnums.h.inc"
 
using namespace circt;
using namespace sim;
using namespace mlir;
 
//===----------------------------------------------------------------------===//
// DPIDirection helpers
//===----------------------------------------------------------------------===//
 
StringRef sim::stringifyDPIDirectionKeyword(DPIDirection dir) {
  switch (dir) {
  case DPIDirection::Input:
    return "in";
  case DPIDirection::Output:
    return "out";
  case DPIDirection::InOut:
    return "inout";
  case DPIDirection::Return:
    return "return";
  case DPIDirection::Ref:
    return "ref";
  }
  llvm_unreachable("unknown DPIDirection");
}
 
std::optional<DPIDirection> sim::parseDPIDirectionKeyword(StringRef keyword) {
  return llvm::StringSwitch<std::optional<DPIDirection>>(keyword)
      .Case("in", DPIDirection::Input)
      .Case("out", DPIDirection::Output)
      .Case("inout", DPIDirection::InOut)
      .Case("return", DPIDirection::Return)
      .Case("ref", DPIDirection::Ref)
      .Default(std::nullopt);
}
 
bool sim::isCallOperandDir(DPIDirection dir) {
  return dir == DPIDirection::Input || dir == DPIDirection::InOut ||
         dir == DPIDirection::Ref;
}
 
#define GET_TYPEDEF_CLASSES
#include "circt/Dialect/Sim/SimTypes.cpp.inc"
 
void SimDialect::registerTypes() {
  addTypes<
#define GET_TYPEDEF_LIST
#include "circt/Dialect/Sim/SimTypes.cpp.inc"
      >();
}
 
//===----------------------------------------------------------------------===//
// DPIFunctionType storage
//===----------------------------------------------------------------------===//
 
sim::detail::DPIFunctionTypeStorage::DPIFunctionTypeStorage(
    ArrayRef<DPIArgument> dpiArgs)
    : arguments(dpiArgs) {
  for (auto [idx, a] : llvm::enumerate(arguments)) {
    if (a.dir == DPIDirection::Input || a.dir == DPIDirection::InOut ||
        a.dir == DPIDirection::Ref)
      inputToAbs.push_back(idx);
    if (a.dir == DPIDirection::Output || a.dir == DPIDirection::InOut ||
        a.dir == DPIDirection::Return)
      resultToAbs.push_back(idx);
  }
}
 
sim::detail::DPIFunctionTypeStorage *
sim::detail::DPIFunctionTypeStorage::construct(TypeStorageAllocator &allocator,
                                               const KeyTy &key) {
  auto *storage = new (allocator.allocate<DPIFunctionTypeStorage>())
      DPIFunctionTypeStorage(key);
  // Compute and cache the MLIR FunctionType.
  SmallVector<Type> inputs, results;
  for (auto &arg : storage->arguments) {
    if (arg.dir == DPIDirection::Input || arg.dir == DPIDirection::InOut ||
        arg.dir == DPIDirection::Ref)
      inputs.push_back(arg.type);
    if (arg.dir == DPIDirection::Output || arg.dir == DPIDirection::InOut ||
        arg.dir == DPIDirection::Return)
      results.push_back(arg.type);
  }
  MLIRContext *ctx = nullptr;
  if (!storage->arguments.empty()) {
    ctx = storage->arguments[0].type.getContext();
    assert(ctx && "DPIArgument types must have a valid MLIRContext");
  }
  if (ctx)
    storage->cachedFuncType = FunctionType::get(ctx, inputs, results);
  return storage;
}
 
//===----------------------------------------------------------------------===//
// DPIFunctionType methods
//===----------------------------------------------------------------------===//
 
ArrayRef<DPIArgument> DPIFunctionType::getArguments() const {
  return getImpl()->getArguments();
}
 
size_t DPIFunctionType::getNumArguments() const {
  return getImpl()->arguments.size();
}
 
SmallVector<DPIArgument> DPIFunctionType::getInputArguments() const {
  SmallVector<DPIArgument> result;
  for (auto idx : getImpl()->inputToAbs)
    result.push_back(getImpl()->arguments[idx]);
  return result;
}
 
SmallVector<DPIArgument> DPIFunctionType::getResultArguments() const {
  SmallVector<DPIArgument> result;
  for (auto idx : getImpl()->resultToAbs)
    result.push_back(getImpl()->arguments[idx]);
  return result;
}
 
const DPIArgument *DPIFunctionType::getReturnArgument() const {
  auto &args = getImpl()->arguments;
  if (!args.empty() && args.back().dir == DPIDirection::Return)
    return &args.back();
  return nullptr;
}
 
FunctionType DPIFunctionType::getFunctionType() const {
  auto cached = getImpl()->getCachedFunctionType();
  if (cached)
    return cached;
  // Empty argument list — context unavailable during storage construction.
  return FunctionType::get(getContext(), {}, {});
}
 
LogicalResult
DPIFunctionType::verify(function_ref<InFlightDiagnostic()> emitError) const {
  auto dpiArgs = getArguments();
  unsigned returnCount = 0;
  for (auto [i, arg] : llvm::enumerate(dpiArgs)) {
    if (arg.dir == DPIDirection::Return) {
      ++returnCount;
      if (i != dpiArgs.size() - 1)
        return emitError() << "'return' argument must be the last argument";
    }
  }
  if (returnCount > 1)
    return emitError() << "must have at most one 'return' argument";
  return success();
}
 
//===----------------------------------------------------------------------===//
// DPIFunctionType parser/printer
//===----------------------------------------------------------------------===//
 
/// Parse: !sim.dpi_functy<input "a" : i32, output "b" : i32>
Type DPIFunctionType::parse(AsmParser &parser) {
  SmallVector<DPIArgument> args;
  if (parser.parseLess())
    return {};
 
  // Handle empty argument list.
  if (succeeded(parser.parseOptionalGreater()))
    return get(parser.getContext(), args);
 
  auto parseOneArg = [&]() -> ParseResult {
    StringRef dirKeyword;
    if (parser.parseKeyword(&dirKeyword))
      return failure();
    auto dir = parseDPIDirectionKeyword(dirKeyword);
    if (!dir) {
      parser.emitError(parser.getCurrentLocation(),
                       "expected DPI argument direction keyword");
      return failure();
    }
    std::string name;
    if (parser.parseString(&name))
      return failure();
    Type type;
    if (parser.parseColonType(type))
      return failure();
    args.push_back({StringAttr::get(parser.getContext(), name), type, *dir});
    return success();
  };
 
  if (parser.parseCommaSeparatedList(parseOneArg) || parser.parseGreater())
    return {};
  return get(parser.getContext(), args);
}
 
/// Print: !sim.dpi_functy<input "a" : i32, output "b" : i32>
void DPIFunctionType::print(AsmPrinter &printer) const {
  printer << '<';
  llvm::interleaveComma(getArguments(), printer, [&](const DPIArgument &arg) {
    printer << stringifyDPIDirectionKeyword(arg.dir) << ' ';
    printer << '"' << arg.name.getValue() << '"';
    printer << " : ";
    printer.printType(arg.type);
  });
  printer << '>';
}
 
//===----------------------------------------------------------------------===//
// VariantType
//===----------------------------------------------------------------------===//
 
/// Parse: !sim.variant<a: i32, b: i8>
Type VariantType::parse(AsmParser &p) {
  SmallVector<Alternative, 4> alternatives;
  SmallVector<std::pair<llvm::SMLoc, StringAttr>> duplicates;
  auto parseResult = parseFieldList(p, alternatives, duplicates);
  for (auto [loc, name] : duplicates)
    p.emitError(loc) << "duplicate alternative name '" << name.getValue()
                     << "' in sim.variant type";
  if (failed(parseResult) || !duplicates.empty())
    return Type();
  return get(p.getContext(), alternatives);
}
 
/// Print: !sim.variant<a: i32, b: i8>
void VariantType::print(AsmPrinter &p) const {
  printFieldList(p, getAlternatives());
}
 
LogicalResult VariantType::verify(function_ref<InFlightDiagnostic()> emitError,
                                  ArrayRef<Alternative> alternatives) {
  llvm::SmallDenseSet<StringAttr> nameSet;
  LogicalResult result = success();
  nameSet.reserve(alternatives.size());
  for (const auto &alternative : alternatives)
    if (!nameSet.insert(alternative.name).second) {
      result = failure();
      emitError() << "duplicate alternative name '"
                  << alternative.name.getValue() << "' in sim.variant type";
    }
  return result;
}
 
std::optional<uint32_t> VariantType::getAlternativeIndex(StringAttr name) {
  ArrayRef<Alternative> alternatives = getAlternatives();
  for (size_t idx = 0, numAlternatives = alternatives.size();
       idx < numAlternatives; ++idx)
    if (alternatives[idx].name == name)
      return idx;
  return {};
}
 
std::optional<uint32_t> VariantType::getAlternativeIndex(StringRef name) {
  return getAlternativeIndex(StringAttr::get(getContext(), name));
}
 
VariantType::Alternative VariantType::getAlternative(StringRef name) {
  if (auto index = getAlternativeIndex(name))
    return getAlternatives()[*index];
  return Alternative();
}
 
Type VariantType::getAlternativeType(StringRef name) {
  return getAlternative(name).type;
}