RTGOps.cpp

Go to the documentation of this file.

//===- RTGOps.cpp - Implement the RTG operations --------------------------===//
//
// 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 RTG ops.
//
//===----------------------------------------------------------------------===//
 
#include "circt/Dialect/RTG/IR/RTGOps.h"
#include "circt/Dialect/RTG/IR/RTGAttributes.h"
#include "circt/Support/ParsingUtils.h"
#include "mlir/IR/Builders.h"
#include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/Matchers.h"
#include "mlir/IR/PatternMatch.h"
#include "llvm/ADT/SmallString.h"
 
using namespace mlir;
using namespace circt;
using namespace rtg;
 
//===----------------------------------------------------------------------===//
// ConstantOp
//===----------------------------------------------------------------------===//
 
LogicalResult
ConstantOp::inferReturnTypes(MLIRContext *context, std::optional<Location> loc,
                             ValueRange operands, DictionaryAttr attributes,
                             PropertyRef properties, RegionRange regions,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
  inferredReturnTypes.push_back(
      properties.as<Properties *>()->getValue().getType());
  return success();
}
 
OpFoldResult ConstantOp::fold(FoldAdaptor adaptor) { return getValueAttr(); }
 
void ConstantOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  if (auto reg = dyn_cast<rtg::RegisterAttrInterface>(getValueAttr())) {
    setNameFn(getResult(), reg.getRegisterAssembly());
    return;
  }
}
 
//===----------------------------------------------------------------------===//
// SequenceOp
//===----------------------------------------------------------------------===//
 
LogicalResult SequenceOp::verifyRegions() {
  if (TypeRange(getSequenceType().getElementTypes()) !=
      getBody()->getArgumentTypes())
    return emitOpError("sequence type does not match block argument types");
 
  return success();
}
 
ParseResult SequenceOp::parse(OpAsmParser &parser, OperationState &result) {
  // Parse the name as a symbol.
  if (parser.parseSymbolName(
          result.getOrAddProperties<SequenceOp::Properties>().sym_name))
    return failure();
 
  // Parse the function signature.
  SmallVector<OpAsmParser::Argument> arguments;
  if (parser.parseArgumentList(arguments, OpAsmParser::Delimiter::Paren,
                               /*allowType=*/true, /*allowAttrs=*/true))
    return failure();
 
  SmallVector<Type> argTypes;
  SmallVector<Location> argLocs;
  argTypes.reserve(arguments.size());
  argLocs.reserve(arguments.size());
  for (auto &arg : arguments) {
    argTypes.push_back(arg.type);
    argLocs.push_back(arg.sourceLoc ? *arg.sourceLoc : result.location);
  }
  Type type = SequenceType::get(result.getContext(), argTypes);
  result.getOrAddProperties<SequenceOp::Properties>().sequenceType =
      TypeAttr::get(type);
 
  auto loc = parser.getCurrentLocation();
  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
    return failure();
  if (failed(verifyInherentAttrs(result.name, result.attributes, [&]() {
        return parser.emitError(loc)
               << "'" << result.name.getStringRef() << "' op ";
      })))
    return failure();
 
  std::unique_ptr<Region> bodyRegionRegion = std::make_unique<Region>();
  if (parser.parseRegion(*bodyRegionRegion, arguments))
    return failure();
 
  if (bodyRegionRegion->empty()) {
    bodyRegionRegion->emplaceBlock();
    bodyRegionRegion->addArguments(argTypes, argLocs);
  }
  result.addRegion(std::move(bodyRegionRegion));
 
  return success();
}
 
void SequenceOp::print(OpAsmPrinter &p) {
  p << ' ';
  p.printSymbolName(getSymNameAttr().getValue());
  p << "(";
  llvm::interleaveComma(getBody()->getArguments(), p,
                        [&](auto arg) { p.printRegionArgument(arg); });
  p << ")";
  p.printOptionalAttrDictWithKeyword(
      (*this)->getAttrs(), {getSymNameAttrName(), getSequenceTypeAttrName()});
  p << ' ';
  p.printRegion(getBodyRegion(), /*printEntryBlockArgs=*/false);
}
 
StringAttr SequenceOp::getNameAttr() { return getSymNameAttr(); }
 
void SequenceOp::setName(StringAttr name) { setSymNameAttr(name); }
 
mlir::SymbolTable::Visibility SequenceOp::getVisibility() {
  return mlir::SymbolTable::Visibility::Private;
}
 
void SequenceOp::setVisibility(mlir::SymbolTable::Visibility visibility) {
  // Do nothing, always private.
  assert(false && "cannot change visibility of sequence");
}
 
//===----------------------------------------------------------------------===//
// GetSequenceOp
//===----------------------------------------------------------------------===//
 
LogicalResult
GetSequenceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  SequenceOp seq =
      symbolTable.lookupNearestSymbolFrom<SequenceOp>(*this, getSequenceAttr());
  if (!seq)
    return emitOpError()
           << "'" << getSequence()
           << "' does not reference a valid 'rtg.sequence' operation";
 
  if (seq.getSequenceType() != getType())
    return emitOpError("referenced 'rtg.sequence' op's type does not match");
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// SubstituteSequenceOp
//===----------------------------------------------------------------------===//
 
LogicalResult SubstituteSequenceOp::verify() {
  if (getReplacements().empty())
    return emitOpError("must at least have one replacement value");
 
  if (getReplacements().size() >
      getSequence().getType().getElementTypes().size())
    return emitOpError(
        "must not have more replacement values than sequence arguments");
 
  if (getReplacements().getTypes() !=
      getSequence().getType().getElementTypes().take_front(
          getReplacements().size()))
    return emitOpError("replacement types must match the same number of "
                       "sequence argument types from the front");
 
  return success();
}
 
LogicalResult SubstituteSequenceOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  ArrayRef<Type> argTypes =
      cast<SequenceType>(operands[0].getType()).getElementTypes();
  auto seqType =
      SequenceType::get(context, argTypes.drop_front(operands.size() - 1));
  inferredReturnTypes.push_back(seqType);
  return success();
}
 
ParseResult SubstituteSequenceOp::parse(::mlir::OpAsmParser &parser,
                                        ::mlir::OperationState &result) {
  OpAsmParser::UnresolvedOperand sequenceRawOperand;
  SmallVector<OpAsmParser::UnresolvedOperand, 4> replacementsOperands;
  Type sequenceRawType;
 
  if (parser.parseOperand(sequenceRawOperand) || parser.parseLParen())
    return failure();
 
  auto replacementsOperandsLoc = parser.getCurrentLocation();
  if (parser.parseOperandList(replacementsOperands) || parser.parseRParen() ||
      parser.parseColon() || parser.parseType(sequenceRawType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  if (!isa<SequenceType>(sequenceRawType))
    return parser.emitError(parser.getNameLoc())
           << "'sequence' must be handle to a sequence or sequence family, but "
              "got "
           << sequenceRawType;
 
  if (parser.resolveOperand(sequenceRawOperand, sequenceRawType,
                            result.operands))
    return failure();
 
  if (parser.resolveOperands(replacementsOperands,
                             cast<SequenceType>(sequenceRawType)
                                 .getElementTypes()
                                 .take_front(replacementsOperands.size()),
                             replacementsOperandsLoc, result.operands))
    return failure();
 
  SmallVector<Type> inferredReturnTypes;
  if (failed(inferReturnTypes(
          parser.getContext(), result.location, result.operands,
          result.attributes.getDictionary(parser.getContext()),
          result.getRawProperties(), result.regions, inferredReturnTypes)))
    return failure();
 
  result.addTypes(inferredReturnTypes);
  return success();
}
 
void SubstituteSequenceOp::print(OpAsmPrinter &p) {
  p << ' ' << getSequence() << "(" << getReplacements()
    << ") : " << getSequence().getType();
  p.printOptionalAttrDict((*this)->getAttrs(), {});
}
 
//===----------------------------------------------------------------------===//
// InterleaveSequencesOp
//===----------------------------------------------------------------------===//
 
LogicalResult InterleaveSequencesOp::verify() {
  if (getSequences().empty())
    return emitOpError("must have at least one sequence in the list");
 
  return success();
}
 
OpFoldResult InterleaveSequencesOp::fold(FoldAdaptor adaptor) {
  if (getSequences().size() == 1)
    return getSequences()[0];
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// SetCreateOp
//===----------------------------------------------------------------------===//
 
ParseResult SetCreateOp::parse(OpAsmParser &parser, OperationState &result) {
  llvm::SmallVector<OpAsmParser::UnresolvedOperand, 16> operands;
  Type elemType;
 
  if (parser.parseOperandList(operands) ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(elemType))
    return failure();
 
  result.addTypes({SetType::get(result.getContext(), elemType)});
 
  for (auto operand : operands)
    if (parser.resolveOperand(operand, elemType, result.operands))
      return failure();
 
  return success();
}
 
void SetCreateOp::print(OpAsmPrinter &p) {
  p << " ";
  p.printOperands(getElements());
  p.printOptionalAttrDict((*this)->getAttrs());
  p << " : " << getSet().getType().getElementType();
}
 
LogicalResult SetCreateOp::verify() {
  if (getElements().size() > 0) {
    // We only need to check the first element because of the `SameTypeOperands`
    // trait.
    if (getElements()[0].getType() != getSet().getType().getElementType())
      return emitOpError() << "operand types must match set element type";
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// SetCartesianProductOp
//===----------------------------------------------------------------------===//
 
LogicalResult SetCartesianProductOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  if (operands.empty()) {
    if (loc)
      return mlir::emitError(*loc) << "at least one set must be provided";
    return failure();
  }
 
  SmallVector<Type> elementTypes;
  for (auto operand : operands)
    elementTypes.push_back(cast<SetType>(operand.getType()).getElementType());
  inferredReturnTypes.push_back(
      SetType::get(rtg::TupleType::get(context, elementTypes)));
  return success();
}
 
//===----------------------------------------------------------------------===//
// BagCreateOp
//===----------------------------------------------------------------------===//
 
ParseResult BagCreateOp::parse(OpAsmParser &parser, OperationState &result) {
  llvm::SmallVector<OpAsmParser::UnresolvedOperand, 16> elementOperands,
      multipleOperands;
  Type elemType;
 
  if (!parser.parseOptionalLParen()) {
    while (true) {
      OpAsmParser::UnresolvedOperand elementOperand, multipleOperand;
      if (parser.parseOperand(multipleOperand) || parser.parseKeyword("x") ||
          parser.parseOperand(elementOperand))
        return failure();
 
      elementOperands.push_back(elementOperand);
      multipleOperands.push_back(multipleOperand);
 
      if (parser.parseOptionalComma()) {
        if (parser.parseRParen())
          return failure();
        break;
      }
    }
  }
 
  if (parser.parseColon() || parser.parseType(elemType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  result.addTypes({BagType::get(result.getContext(), elemType)});
 
  for (auto operand : elementOperands)
    if (parser.resolveOperand(operand, elemType, result.operands))
      return failure();
 
  for (auto operand : multipleOperands)
    if (parser.resolveOperand(operand, IndexType::get(result.getContext()),
                              result.operands))
      return failure();
 
  return success();
}
 
void BagCreateOp::print(OpAsmPrinter &p) {
  p << " ";
  if (!getElements().empty())
    p << "(";
  llvm::interleaveComma(llvm::zip(getElements(), getMultiples()), p,
                        [&](auto elAndMultiple) {
                          auto [el, multiple] = elAndMultiple;
                          p << multiple << " x " << el;
                        });
  if (!getElements().empty())
    p << ")";
 
  p << " : " << getBag().getType().getElementType();
  p.printOptionalAttrDict((*this)->getAttrs());
}
 
LogicalResult BagCreateOp::verify() {
  if (!llvm::all_equal(getElements().getTypes()))
    return emitOpError() << "types of all elements must match";
 
  if (getElements().size() > 0)
    if (getElements()[0].getType() != getBag().getType().getElementType())
      return emitOpError() << "operand types must match bag element type";
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// TupleCreateOp
//===----------------------------------------------------------------------===//
 
LogicalResult TupleCreateOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  SmallVector<Type> elementTypes;
  for (auto operand : operands)
    elementTypes.push_back(operand.getType());
  inferredReturnTypes.push_back(rtg::TupleType::get(context, elementTypes));
  return success();
}
 
//===----------------------------------------------------------------------===//
// TupleExtractOp
//===----------------------------------------------------------------------===//
 
LogicalResult TupleExtractOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  assert(operands.size() == 1 && "must have exactly one operand");
 
  auto tupleTy = dyn_cast<rtg::TupleType>(operands[0].getType());
  size_t idx = properties.as<Properties *>()->getIndex().getInt();
  if (!tupleTy) {
    if (loc)
      return mlir::emitError(*loc) << "only RTG tuples are supported";
    return failure();
  }
 
  if (tupleTy.getFieldTypes().size() <= idx) {
    if (loc)
      return mlir::emitError(*loc)
             << "index (" << idx
             << ") must be smaller than number of elements in tuple ("
             << tupleTy.getFieldTypes().size() << ")";
    return failure();
  }
 
  inferredReturnTypes.push_back(tupleTy.getFieldTypes()[idx]);
  return success();
}
 
//===----------------------------------------------------------------------===//
// ConstraintOp
//===----------------------------------------------------------------------===//
 
LogicalResult ConstraintOp::canonicalize(ConstraintOp op,
                                         PatternRewriter &rewriter) {
  if (mlir::matchPattern(op.getCondition(), mlir::m_One())) {
    rewriter.eraseOp(op);
    return success();
  }
 
  return failure();
}
 
//===----------------------------------------------------------------------===//
// VirtualRegisterOp
//===----------------------------------------------------------------------===//
 
LogicalResult VirtualRegisterOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  auto allowedRegs = properties.as<Properties *>()->getAllowedRegs();
  inferredReturnTypes.push_back(allowedRegs.getType());
  return success();
}
 
//===----------------------------------------------------------------------===//
// RegisterToIndexOp
//===----------------------------------------------------------------------===//
 
OpFoldResult RegisterToIndexOp::fold(FoldAdaptor adaptor) {
  if (auto reg = dyn_cast_or_null<rtg::RegisterAttrInterface>(adaptor.getReg()))
    return IntegerAttr::get(IndexType::get(getContext()), reg.getClassIndex());
 
  if (auto indexToRegOp = getReg().getDefiningOp<IndexToRegisterOp>())
    return indexToRegOp.getIndex();
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// IndexToRegisterOp
//===----------------------------------------------------------------------===//
 
LogicalResult IndexToRegisterOp::verify() {
  // Check if the index is a constant and if it's within valid range
  APInt indexValue;
  if (matchPattern(getIndex(), m_ConstantInt(&indexValue))) {
    if (indexValue.uge(getType().getRegisterClassSize())) {
      SmallString<16> indexStr;
      indexValue.toString(indexStr, 10, false);
      return emitOpError() << "index " << indexStr
                           << " is out of range for register class "
                           << getReg().getType();
    }
  }
 
  return success();
}
 
OpFoldResult IndexToRegisterOp::fold(FoldAdaptor adaptor) {
  if (auto indexAttr = dyn_cast_or_null<IntegerAttr>(adaptor.getIndex()))
    return getType().getRegisterAttrForClassIndex(
        getContext(), indexAttr.getValue().getZExtValue());
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// ContextSwitchOp
//===----------------------------------------------------------------------===//
 
LogicalResult ContextSwitchOp::verify() {
  auto elementTypes = getSequence().getType().getElementTypes();
  if (elementTypes.size() != 3)
    return emitOpError("sequence type must have exactly 3 element types");
 
  if (getFrom().getType() != elementTypes[0])
    return emitOpError(
        "first sequence element type must match 'from' attribute type");
 
  if (getTo().getType() != elementTypes[1])
    return emitOpError(
        "second sequence element type must match 'to' attribute type");
 
  auto seqTy = dyn_cast<SequenceType>(elementTypes[2]);
  if (!seqTy || !seqTy.getElementTypes().empty())
    return emitOpError(
        "third sequence element type must be a fully substituted sequence");
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// TestOp
//===----------------------------------------------------------------------===//
 
LogicalResult TestOp::verifyRegions() {
  if (!getTargetType().entryTypesMatch(getBody()->getArgumentTypes()))
    return emitOpError("argument types must match dict entry types");
 
  return success();
}
 
LogicalResult TestOp::verify() {
  if (getTemplateName().empty())
    return emitOpError("template name must not be empty");
 
  return success();
}
 
LogicalResult TestOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  if (!getTargetAttr())
    return success();
 
  auto target =
      symbolTable.lookupNearestSymbolFrom<TargetOp>(*this, getTargetAttr());
  if (!target)
    return emitOpError()
           << "'" << *getTarget()
           << "' does not reference a valid 'rtg.target' operation";
 
  // Check if target is a subtype of test requirements
  // Since entries are sorted by name, we can do this in a single pass
  size_t targetIdx = 0;
  auto targetEntries = target.getTarget().getEntries();
  for (auto testEntry : getTargetType().getEntries()) {
    // Find the matching entry in target entries.
    while (targetIdx < targetEntries.size() &&
           targetEntries[targetIdx].name.getValue() < testEntry.name.getValue())
      targetIdx++;
 
    // Check if we found a matching entry with the same name and type
    if (targetIdx >= targetEntries.size() ||
        targetEntries[targetIdx].name != testEntry.name ||
        targetEntries[targetIdx].type != testEntry.type) {
      return emitOpError("referenced 'rtg.target' op's type is invalid: "
                         "missing entry called '")
             << testEntry.name.getValue() << "' of type " << testEntry.type;
    }
  }
 
  return success();
}
 
ParseResult TestOp::parse(OpAsmParser &parser, OperationState &result) {
  // Parse the name as a symbol.
  StringAttr symNameAttr;
  if (parser.parseSymbolName(symNameAttr))
    return failure();
 
  result.getOrAddProperties<TestOp::Properties>().sym_name = symNameAttr;
 
  // Parse the function signature.
  SmallVector<OpAsmParser::Argument> arguments;
  SmallVector<StringAttr> names;
 
  auto parseOneArgument = [&]() -> ParseResult {
    std::string name;
    if (parser.parseKeywordOrString(&name) || parser.parseEqual() ||
        parser.parseArgument(arguments.emplace_back(), /*allowType=*/true,
                             /*allowAttrs=*/true))
      return failure();
 
    names.push_back(StringAttr::get(result.getContext(), name));
    return success();
  };
  if (parser.parseCommaSeparatedList(OpAsmParser::Delimiter::Paren,
                                     parseOneArgument, " in argument list"))
    return failure();
 
  SmallVector<Type> argTypes;
  SmallVector<DictEntry> entries;
  SmallVector<Location> argLocs;
  argTypes.reserve(arguments.size());
  argLocs.reserve(arguments.size());
  for (auto [name, arg] : llvm::zip(names, arguments)) {
    argTypes.push_back(arg.type);
    argLocs.push_back(arg.sourceLoc ? *arg.sourceLoc : result.location);
    entries.push_back({name, arg.type});
  }
  auto emitError = [&]() -> InFlightDiagnostic {
    return parser.emitError(parser.getCurrentLocation());
  };
  Type type = DictType::getChecked(emitError, result.getContext(),
                                   ArrayRef<DictEntry>(entries));
  if (!type)
    return failure();
  result.getOrAddProperties<TestOp::Properties>().targetType =
      TypeAttr::get(type);
 
  std::string templateName;
  if (!parser.parseOptionalKeyword("template")) {
    auto loc = parser.getCurrentLocation();
    if (parser.parseString(&templateName))
      return failure();
 
    if (templateName.empty())
      return parser.emitError(loc, "template name must not be empty");
  }
 
  StringAttr templateNameAttr = symNameAttr;
  if (!templateName.empty())
    templateNameAttr = StringAttr::get(result.getContext(), templateName);
 
  StringAttr targetName;
  if (!parser.parseOptionalKeyword("target"))
    if (parser.parseSymbolName(targetName))
      return failure();
 
  result.getOrAddProperties<TestOp::Properties>().templateName =
      templateNameAttr;
  result.getOrAddProperties<TestOp::Properties>().target = targetName;
 
  auto loc = parser.getCurrentLocation();
  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
    return failure();
  if (failed(verifyInherentAttrs(result.name, result.attributes, [&]() {
        return parser.emitError(loc)
               << "'" << result.name.getStringRef() << "' op ";
      })))
    return failure();
 
  std::unique_ptr<Region> bodyRegionRegion = std::make_unique<Region>();
  if (parser.parseRegion(*bodyRegionRegion, arguments))
    return failure();
 
  if (bodyRegionRegion->empty()) {
    bodyRegionRegion->emplaceBlock();
    bodyRegionRegion->addArguments(argTypes, argLocs);
  }
  result.addRegion(std::move(bodyRegionRegion));
 
  return success();
}
 
void TestOp::print(OpAsmPrinter &p) {
  p << ' ';
  p.printSymbolName(getSymNameAttr().getValue());
  p << "(";
  SmallString<32> resultNameStr;
  llvm::interleaveComma(
      llvm::zip(getTargetType().getEntries(), getBody()->getArguments()), p,
      [&](auto entryAndArg) {
        auto [entry, arg] = entryAndArg;
        p << entry.name.getValue() << " = ";
        p.printRegionArgument(arg);
      });
  p << ")";
 
  if (getSymNameAttr() != getTemplateNameAttr())
    p << " template " << getTemplateNameAttr();
 
  if (getTargetAttr()) {
    p << " target ";
    p.printSymbolName(getTargetAttr().getValue());
  }
 
  p.printOptionalAttrDictWithKeyword(
      (*this)->getAttrs(), {getSymNameAttrName(), getTargetTypeAttrName(),
                            getTargetAttrName(), getTemplateNameAttrName()});
  p << ' ';
  p.printRegion(getBodyRegion(), /*printEntryBlockArgs=*/false);
}
 
void TestOp::getAsmBlockArgumentNames(Region &region,
                                      OpAsmSetValueNameFn setNameFn) {
  for (auto [entry, arg] :
       llvm::zip(getTargetType().getEntries(), region.getArguments()))
    setNameFn(arg, entry.name.getValue());
}
 
//===----------------------------------------------------------------------===//
// TargetOp
//===----------------------------------------------------------------------===//
 
LogicalResult TargetOp::verifyRegions() {
  if (!getTarget().entryTypesMatch(
          getBody()->getTerminator()->getOperandTypes()))
    return emitOpError("terminator operand types must match dict entry types");
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// ValidateOp
//===----------------------------------------------------------------------===//
 
LogicalResult ValidateOp::verify() {
  if (!getRef().getType().isValidContentType(getValue().getType()))
    return emitOpError(
        "result type must be a valid content type for the ref value");
 
  return success();
}
 
bool ValidateOp::isSourceRegister(unsigned index) {
  if (index == 0)
    return isa<RegisterTypeInterface>(getRef().getType());
  return false;
}
 
bool ValidateOp::isDestinationRegister(unsigned index) { return false; }
 
//===----------------------------------------------------------------------===//
// ArrayCreateOp
//===----------------------------------------------------------------------===//
 
LogicalResult ArrayCreateOp::verify() {
  if (!getElements().empty() &&
      getElements()[0].getType() != getType().getElementType())
    return emitOpError("operand types must match array element type, expected ")
           << getType().getElementType() << " but got "
           << getElements()[0].getType();
 
  return success();
}
 
ParseResult ArrayCreateOp::parse(OpAsmParser &parser, OperationState &result) {
  SmallVector<OpAsmParser::UnresolvedOperand> operands;
  Type elementType;
 
  if (parser.parseOperandList(operands) || parser.parseColon() ||
      parser.parseType(elementType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  if (failed(parser.resolveOperands(operands, elementType, result.operands)))
    return failure();
 
  result.addTypes(ArrayType::get(elementType));
 
  return success();
}
 
void ArrayCreateOp::print(OpAsmPrinter &p) {
  p << ' ';
  p.printOperands(getElements());
  p << " : " << getType().getElementType();
  p.printOptionalAttrDict((*this)->getAttrs(), {});
}
 
//===----------------------------------------------------------------------===//
// ArrayAppendOp
//===----------------------------------------------------------------------===//
 
LogicalResult ArrayAppendOp::canonicalize(ArrayAppendOp op,
                                          PatternRewriter &rewriter) {
  auto createOp = op.getArray().getDefiningOp<ArrayCreateOp>();
  if (!createOp)
    return failure();
 
  SmallVector<Value> newElements(createOp.getElements());
  newElements.push_back(op.getElement());
  rewriter.replaceOpWithNewOp<ArrayCreateOp>(op, op.getType(), newElements);
  return success();
}
 
//===----------------------------------------------------------------------===//
// MemoryBlockDeclareOp
//===----------------------------------------------------------------------===//
 
LogicalResult MemoryBlockDeclareOp::verify() {
  if (getBaseAddress().getBitWidth() != getType().getAddressWidth())
    return emitOpError(
        "base address width must match memory block address width");
 
  if (getEndAddress().getBitWidth() != getType().getAddressWidth())
    return emitOpError(
        "end address width must match memory block address width");
 
  if (getBaseAddress().ugt(getEndAddress()))
    return emitOpError(
        "base address must be smaller than or equal to the end address");
 
  return success();
}
 
ParseResult MemoryBlockDeclareOp::parse(OpAsmParser &parser,
                                        OperationState &result) {
  SmallVector<OpAsmParser::UnresolvedOperand> operands;
  MemoryBlockType memoryBlockType;
  APInt start, end;
 
  if (parser.parseLSquare())
    return failure();
 
  auto startLoc = parser.getCurrentLocation();
  if (parser.parseInteger(start))
    return failure();
 
  if (parser.parseMinus())
    return failure();
 
  auto endLoc = parser.getCurrentLocation();
  if (parser.parseInteger(end) || parser.parseRSquare() ||
      parser.parseColonType(memoryBlockType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  auto width = memoryBlockType.getAddressWidth();
  auto adjustAPInt = [&](APInt value, llvm::SMLoc loc) -> FailureOr<APInt> {
    if (value.getBitWidth() > width) {
      if (!value.isIntN(width))
        return parser.emitError(
                   loc,
                   "address out of range for memory block with address width ")
               << width;
 
      return value.trunc(width);
    }
 
    if (value.getBitWidth() < width)
      return value.zext(width);
 
    return value;
  };
 
  auto startRes = adjustAPInt(start, startLoc);
  auto endRes = adjustAPInt(end, endLoc);
  if (failed(startRes) || failed(endRes))
    return failure();
 
  auto intType = IntegerType::get(result.getContext(), width);
  result.addAttribute(getBaseAddressAttrName(result.name),
                      IntegerAttr::get(intType, *startRes));
  result.addAttribute(getEndAddressAttrName(result.name),
                      IntegerAttr::get(intType, *endRes));
 
  result.addTypes(memoryBlockType);
  return success();
}
 
void MemoryBlockDeclareOp::print(OpAsmPrinter &p) {
  SmallVector<char> str;
  getBaseAddress().toString(str, 16, false, false, false);
  p << " [0x" << str;
  p << " - 0x";
  str.clear();
  getEndAddress().toString(str, 16, false, false, false);
  p << str << "] : " << getType();
  p.printOptionalAttrDict((*this)->getAttrs(),
                          {getBaseAddressAttrName(), getEndAddressAttrName()});
}
 
//===----------------------------------------------------------------------===//
// MemoryBaseAddressOp
//===----------------------------------------------------------------------===//
 
LogicalResult MemoryBaseAddressOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  if (operands.empty())
    return failure();
  auto memTy = dyn_cast<MemoryType>(operands[0].getType());
  if (!memTy)
    return failure();
  inferredReturnTypes.push_back(
      IntegerType::get(context, memTy.getAddressWidth()));
  return success();
}
 
//===----------------------------------------------------------------------===//
// ConcatImmediateOp
//===----------------------------------------------------------------------===//
 
LogicalResult ConcatImmediateOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> loc, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  if (operands.empty()) {
    if (loc)
      return mlir::emitError(*loc) << "at least one operand must be provided";
    return failure();
  }
 
  unsigned totalWidth = 0;
  for (auto operand : operands) {
    auto immType = dyn_cast<IntegerType>(operand.getType());
    if (!immType) {
      if (loc)
        return mlir::emitError(*loc)
               << "all operands must be of immediate type";
      return failure();
    }
    totalWidth += immType.getWidth();
  }
 
  inferredReturnTypes.push_back(IntegerType::get(context, totalWidth));
  return success();
}
 
OpFoldResult ConcatImmediateOp::fold(FoldAdaptor adaptor) {
  // concat(x) -> x
  if (getOperands().size() == 1)
    return getOperands()[0];
 
  // If all operands are constants, fold into a single constant
  if (llvm::all_of(adaptor.getOperands(), [](Attribute attr) {
        return isa_and_nonnull<IntegerAttr>(attr);
      })) {
    auto result = APInt::getZeroWidth();
    for (auto attr : adaptor.getOperands())
      result = result.concat(cast<IntegerAttr>(attr).getValue());
 
    return IntegerAttr::get(
        IntegerType::get(getContext(), result.getBitWidth()), result);
  }
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// SliceImmediateOp
//===----------------------------------------------------------------------===//
 
LogicalResult SliceImmediateOp::verify() {
  auto srcWidth = getInput().getType().getWidth();
  auto dstWidth = getResult().getType().getWidth();
 
  if (getLowBit() >= srcWidth)
    return emitOpError("from bit too large for input (got ")
           << getLowBit() << ", but input width is " << srcWidth << ")";
 
  if (srcWidth - getLowBit() < dstWidth)
    return emitOpError("slice does not fit in input (trying to extract ")
           << dstWidth << " bits starting at index " << getLowBit()
           << ", but only " << (srcWidth - getLowBit())
           << " bits are available)";
 
  return success();
}
 
OpFoldResult SliceImmediateOp::fold(FoldAdaptor adaptor) {
  if (auto inputAttr = dyn_cast_or_null<IntegerAttr>(adaptor.getInput())) {
    auto resultWidth = getType().getWidth();
    APInt sliced = inputAttr.getValue().extractBits(resultWidth, getLowBit());
    return IntegerAttr::get(
        IntegerType::get(getContext(), sliced.getBitWidth()), sliced);
  }
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// StringConcatOp
//===----------------------------------------------------------------------===//
 
OpFoldResult StringConcatOp::fold(FoldAdaptor adaptor) {
  SmallString<32> result;
  for (auto attr : adaptor.getStrings()) {
    auto stringAttr = dyn_cast_or_null<StringAttr>(attr);
    if (!stringAttr)
      return {};
 
    result += stringAttr.getValue();
  }
 
  return StringAttr::get(result, StringType::get(getContext()));
}
 
//===----------------------------------------------------------------------===//
// IntFormatOp
//===----------------------------------------------------------------------===//
 
OpFoldResult IntFormatOp::fold(FoldAdaptor adaptor) {
  auto intAttr = dyn_cast_or_null<IntegerAttr>(adaptor.getValue());
  if (!intAttr)
    return {};
  if (!intAttr.getType().isIndex())
    return {};
  return StringAttr::get(Twine(intAttr.getValue().getZExtValue()),
                         StringType::get(getContext()));
}
 
//===----------------------------------------------------------------------===//
// ImmediateFormatOp
//===----------------------------------------------------------------------===//
 
OpFoldResult ImmediateFormatOp::fold(FoldAdaptor adaptor) {
  auto immAttr = dyn_cast_or_null<IntegerAttr>(adaptor.getValue());
  if (!immAttr)
    return {};
  SmallString<16> strBuf("0x");
  immAttr.getValue().toString(strBuf, 16, /*Signed=*/false);
  return StringAttr::get(strBuf, StringType::get(getContext()));
}
 
//===----------------------------------------------------------------------===//
// RegisterFormatOp
//===----------------------------------------------------------------------===//
 
OpFoldResult RegisterFormatOp::fold(FoldAdaptor adaptor) {
  auto regAttr = dyn_cast_or_null<RegisterAttrInterface>(adaptor.getValue());
  if (!regAttr)
    return {};
  return StringAttr::get(regAttr.getRegisterAssembly(),
                         StringType::get(getContext()));
}
 
//===----------------------------------------------------------------------===//
// StringToLabelOp
//===----------------------------------------------------------------------===//
 
OpFoldResult StringToLabelOp::fold(FoldAdaptor adaptor) {
  if (auto stringAttr = dyn_cast_or_null<StringAttr>(adaptor.getString()))
    return LabelAttr::get(getContext(), stringAttr.getValue());
 
  return {};
}
 
//===----------------------------------------------------------------------===//
// StringToASCIIArrayOp
//===----------------------------------------------------------------------===//
 
LogicalResult StringToASCIIArrayOp::canonicalize(StringToASCIIArrayOp op,
                                                 PatternRewriter &rewriter) {
  auto constOp = op.getString().getDefiningOp<ConstantOp>();
  if (!constOp)
    return failure();
 
  auto strAttr = dyn_cast<StringAttr>(constOp.getValue());
  if (!strAttr)
    return failure();
 
  auto i8Ty = rewriter.getIntegerType(8);
  SmallVector<Value> bytes;
  bytes.reserve(strAttr.getValue().size());
  for (unsigned char c : strAttr.getValue())
    bytes.push_back(ConstantOp::create(rewriter, op.getLoc(),
                                       rewriter.getIntegerAttr(i8Ty, c)));
 
  rewriter.replaceOpWithNewOp<ArrayCreateOp>(op, op.getType(), bytes);
  return success();
}
 
//===----------------------------------------------------------------------===//
// WithHandlersOp (algebraic effects)
//===----------------------------------------------------------------------===//
 
ParseResult WithHandlersOp::parse(OpAsmParser &parser, OperationState &result) {
  // Syntax:
  //   rtg.with_handlers {
  //     handle @effect(arg: type, ...) { region }
  //     ...
  //     do { region }
  //   }
  SmallVector<Attribute> effectSymbols;
  SmallVector<std::unique_ptr<Region>> handlerRegions;
 
  if (parser.parseLBrace())
    return failure();
 
  while (true) {
    // Stop when we see the 'do' keyword.
    if (succeeded(parser.parseOptionalKeyword("do")))
      break;
 
    // 'handle' keyword
    if (parser.parseKeyword("handle"))
      return failure();
 
    // @effect-symbol
    FlatSymbolRefAttr sym;
    if (parser.parseAttribute(sym))
      return failure();
    effectSymbols.push_back(sym);
 
    // (arg: type, ...)  — these become the entry block args of the handler.
    SmallVector<OpAsmParser::Argument> args;
    if (parser.parseArgumentList(args, OpAsmParser::Delimiter::Paren,
                                 /*allowType=*/true))
      return failure();
 
    // { handler-body }
    auto handler = std::make_unique<Region>();
    if (parser.parseRegion(*handler, args))
      return failure();
    if (handler->empty())
      handler->emplaceBlock();
    handlerRegions.push_back(std::move(handler));
  }
 
  // Set property (inherent attribute)
  auto &props = result.getOrAddProperties<WithHandlersOp::Properties>();
  props.effects = ArrayAttr::get(parser.getContext(), effectSymbols);
 
  // Parse the do-body region (the 'do' keyword was already consumed above).
  Region *body = result.addRegion();
  if (parser.parseRegion(*body))
    return failure();
  if (body->empty())
    body->emplaceBlock();
 
  // Move handler regions into the op (body is region[0], handlers follow).
  for (auto &h : handlerRegions) {
    Region *hr = result.addRegion();
    hr->takeBody(*h);
  }
 
  if (parser.parseRBrace() || parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  return success();
}
 
void WithHandlersOp::print(OpAsmPrinter &printer) {
  printer << " {";
  printer.increaseIndent();
  for (auto [symAttr, handlerRegion] :
       llvm::zip(getEffects(), getHandlerRegions())) {
    printer.printNewline();
    printer << "handle " << symAttr << "(";
    bool first = true;
    for (BlockArgument arg : handlerRegion.front().getArguments()) {
      if (!first)
        printer << ", ";
      first = false;
      printer.printRegionArgument(arg);
    }
    printer << ") ";
    printer.printRegion(handlerRegion, /*printEntryBlockArgs=*/false);
  }
  printer.printNewline();
  printer << "do ";
  printer.printRegion(getBody());
  printer.decreaseIndent();
  printer.printNewline();
  printer << "}";
  // effects is a property (inherent), print discardable attributes only
  printer.printOptionalAttrDict(
      (*this)->getDiscardableAttrDictionary().getValue());
}
 
LogicalResult WithHandlersOp::verify() {
  auto effects = getEffects();
  if (effects.size() != getHandlerRegions().size())
    return emitOpError("effects.size() (")
           << effects.size() << ") != handlerRegions.size() ("
           << getHandlerRegions().size() << ")";
 
  llvm::SmallDenseSet<StringAttr> seen;
  for (auto attr : effects) {
    auto sym = cast<FlatSymbolRefAttr>(attr).getAttr();
    if (!seen.insert(sym).second)
      return emitOpError("duplicate handler for effect '")
             << sym.getValue() << "'";
  }
  return success();
}
 
LogicalResult
WithHandlersOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto moduleOp = (*this)->getParentOfType<ModuleOp>();
  if (!moduleOp)
    return emitOpError("must be inside a module");
 
  for (auto [idx, symAttr] : llvm::enumerate(getEffects())) {
    auto ref = dyn_cast<FlatSymbolRefAttr>(symAttr);
    if (!ref)
      return emitOpError("effects[") << idx << "] is not a symbol reference";
 
    auto decl = symbolTable.lookupNearestSymbolFrom<EffectOp>(moduleOp, ref);
    if (!decl)
      return emitOpError("unresolved effect symbol '") << ref.getValue() << "'";
 
    // Verify handler region block argument types.
    Region &handlerRegion = getHandlerRegions()[idx];
    if (handlerRegion.empty())
      return emitOpError("handler region ") << idx << " is empty";
 
    Block &handlerBlock = handlerRegion.front();
    FunctionType ft = decl.getFunctionType();
    auto inputTypes = ft.getInputs();
    auto resultTypes = ft.getResults();
 
    // Expected: input types + continuation<result>
    Type resumeType =
        resultTypes.empty() ? NoneType::get(getContext()) : resultTypes[0];
    size_t expectedArgs = inputTypes.size() + 1;
 
    if (handlerBlock.getNumArguments() != expectedArgs)
      return emitOpError("handler region ")
             << idx << " expects " << expectedArgs << " block args but has "
             << handlerBlock.getNumArguments();
 
    for (auto [argIdx, argType] : llvm::enumerate(inputTypes)) {
      if (handlerBlock.getArgument(argIdx).getType() != argType)
        return emitOpError("handler region ")
               << idx << " block arg " << argIdx << " has type "
               << handlerBlock.getArgument(argIdx).getType() << " but expected "
               << argType;
    }
 
    auto contTy = ContinuationType::get(getContext(), resumeType);
    if (handlerBlock.getArgument(inputTypes.size()).getType() != contTy)
      return emitOpError("handler region ")
             << idx << " continuation arg has type "
             << handlerBlock.getArgument(inputTypes.size()).getType()
             << " but expected " << contTy;
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// PerformOp
//===----------------------------------------------------------------------===//
 
ParseResult PerformOp::parse(OpAsmParser &parser, OperationState &result) {
  // Parse: @effect `(` operands `)` `:` `(` inputTypes `)` `->` resultType
  FlatSymbolRefAttr effectAttr;
  if (parser.parseAttribute(effectAttr))
    return failure();
  result.getOrAddProperties<PerformOp::Properties>().effect = effectAttr;
 
  SmallVector<OpAsmParser::UnresolvedOperand> operands;
  if (parser.parseOperandList(operands, OpAsmParser::Delimiter::Paren))
    return failure();
 
  if (parser.parseColon())
    return failure();
 
  SmallVector<Type> operandTypes;
  if (parser.parseLParen())
    return failure();
  if (succeeded(parser.parseOptionalRParen())) {
    // empty operand list
  } else {
    if (parser.parseTypeList(operandTypes) || parser.parseRParen())
      return failure();
  }
 
  if (parser.parseArrow())
    return failure();
 
  Type resultType;
  if (parser.parseType(resultType))
    return failure();
 
  if (parser.resolveOperands(operands, operandTypes,
                             parser.getCurrentLocation(), result.operands))
    return failure();
 
  if (!isa<NoneType>(resultType))
    result.addTypes(resultType);
 
  if (parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  return success();
}
 
void PerformOp::print(OpAsmPrinter &printer) {
  printer << " " << getEffectAttr() << "(";
  llvm::interleaveComma(getOperands(), printer, [&](Value v) { printer << v; });
  printer << ") : (";
  llvm::interleaveComma(getOperands(), printer,
                        [&](Value v) { printer << v.getType(); });
  printer << ") -> ";
  if (getResult())
    printer << getResult().getType();
  else
    printer << NoneType::get(getContext());
  // effect is a property (inherent), print discardable attributes only
  printer.printOptionalAttrDict(
      (*this)->getDiscardableAttrDictionary().getValue());
}
 
void PerformOp::getEffects(
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
        &effects) {
  effects.emplace_back(MemoryEffects::Write::get(), MutResource::get());
}
 
LogicalResult PerformOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto moduleOp = (*this)->getParentOfType<ModuleOp>();
  if (!moduleOp)
    return emitOpError("must be inside a module");
 
  auto decl =
      symbolTable.lookupNearestSymbolFrom<EffectOp>(moduleOp, getEffectAttr());
  if (!decl)
    return emitOpError("unresolved effect symbol '") << getEffect() << "'";
 
  FunctionType ft = decl.getFunctionType();
  auto inputTypes = ft.getInputs();
  auto resultTypes = ft.getResults();
 
  if (getOperands().size() != inputTypes.size())
    return emitOpError("effect '")
           << getEffect() << "' expects " << inputTypes.size()
           << " inputs but got " << getOperands().size();
 
  for (auto [idx, opType, declType] :
       llvm::enumerate(getOperandTypes(), inputTypes)) {
    if (opType != declType)
      return emitOpError("operand ") << idx << " has type " << opType
                                     << " but effect declares " << declType;
  }
 
  if (resultTypes.empty()) {
    if (getResult())
      return emitOpError("effect '")
             << getEffect() << "' returns none but perform has a result";
  } else {
    if (!getResult())
      return emitOpError("effect '")
             << getEffect() << "' returns " << resultTypes[0]
             << " but perform has no result";
    if (getResult().getType() != resultTypes[0])
      return emitOpError("result type ")
             << getResult().getType() << " does not match effect result type "
             << resultTypes[0];
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// ResumeOp
//===----------------------------------------------------------------------===//
 
void ResumeOp::getEffects(
    SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
        &effects) {
  effects.emplace_back(MemoryEffects::Write::get(), MutResource::get());
}
 
LogicalResult ResumeOp::verify() {
  auto contTy = cast<ContinuationType>(getContinuation().getType());
  Type resumeType = contTy.getResumeType();
 
  if (isa<NoneType>(resumeType)) {
    if (getValue())
      return emitOpError(
          "continuation expects none but resume provides a value");
  } else {
    if (!getValue())
      return emitOpError("continuation expects ")
             << resumeType << " but resume provides no value";
    if (getValue().getType() != resumeType)
      return emitOpError("resume value type ")
             << getValue().getType()
             << " does not match continuation resume type " << resumeType;
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// TableGen generated logic.
//===----------------------------------------------------------------------===//
 
#define GET_OP_CLASSES
#include "circt/Dialect/RTG/IR/RTG.cpp.inc"