FIRRTLOps.cpp

Go to the documentation of this file.

//===- FIRRTLOps.cpp - Implement the FIRRTL 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 implement the FIRRTL ops.
//
//===----------------------------------------------------------------------===//
 
#include "circt/Dialect/FIRRTL/FIRRTLOps.h"
#include "circt/Dialect/FIRRTL/AnnotationDetails.h"
#include "circt/Dialect/FIRRTL/CHIRRTLDialect.h"
#include "circt/Dialect/FIRRTL/FIRRTLAnnotations.h"
#include "circt/Dialect/FIRRTL/FIRRTLAttributes.h"
#include "circt/Dialect/FIRRTL/FIRRTLInstanceImplementation.h"
#include "circt/Dialect/FIRRTL/FIRRTLOpInterfaces.h"
#include "circt/Dialect/FIRRTL/FIRRTLTypes.h"
#include "circt/Dialect/FIRRTL/FIRRTLUtils.h"
#include "circt/Dialect/FIRRTL/FIRRTLVisitors.h"
#include "circt/Dialect/FIRRTL/FieldRefCache.h"
#include "circt/Dialect/FIRRTL/LayerSet.h"
#include "circt/Dialect/HW/HWAttributes.h"
#include "circt/Dialect/HW/HWTypes.h"
#include "circt/Support/CustomDirectiveImpl.h"
#include "circt/Support/Utils.h"
#include "mlir/IR/BuiltinTypes.h"
#include "mlir/IR/Diagnostics.h"
#include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/PatternMatch.h"
#include "mlir/IR/SymbolTable.h"
#include "mlir/Interfaces/FunctionImplementation.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/FormatVariadic.h"
 
using llvm::SmallDenseSet;
using mlir::RegionRange;
using namespace circt;
using namespace firrtl;
using namespace chirrtl;
 
//===----------------------------------------------------------------------===//
// Utilities
//===----------------------------------------------------------------------===//
 
/// Emit an error if optional location is non-null, return null of return type.
template <typename RetTy = FIRRTLType, typename... Args>
static RetTy emitInferRetTypeError(std::optional<Location> loc,
                                   const Twine &message, Args &&...args) {
  if (loc)
    (mlir::emitError(*loc, message) << ... << std::forward<Args>(args));
  return {};
}
 
bool firrtl::isDuplexValue(Value val) {
  // Block arguments are not duplex values.
  while (Operation *op = val.getDefiningOp()) {
    auto isDuplex =
        TypeSwitch<Operation *, std::optional<bool>>(op)
            .Case<SubfieldOp, SubindexOp, SubaccessOp>([&val](auto op) {
              val = op.getInput();
              return std::nullopt;
            })
            .Case<RegOp, RegResetOp, WireOp>([](auto) { return true; })
            .Default([](auto) { return false; });
    if (isDuplex)
      return *isDuplex;
  }
  return false;
}
 
SmallVector<std::pair<circt::FieldRef, circt::FieldRef>>
MemOp::computeDataFlow() {
  // If read result has non-zero latency, then no combinational dependency
  // exists.
  if (getReadLatency() > 0)
    return {};
  SmallVector<std::pair<circt::FieldRef, circt::FieldRef>> deps;
  // Add a dependency from the enable and address fields to the data field.
  for (auto memPort : getResults())
    if (auto type = type_dyn_cast<BundleType>(memPort.getType())) {
      auto enableFieldId = type.getFieldID((unsigned)ReadPortSubfield::en);
      auto addressFieldId = type.getFieldID((unsigned)ReadPortSubfield::addr);
      auto dataFieldId = type.getFieldID((unsigned)ReadPortSubfield::data);
      deps.emplace_back(
          FieldRef(memPort, static_cast<unsigned>(dataFieldId)),
          FieldRef(memPort, static_cast<unsigned>(enableFieldId)));
      deps.emplace_back(
          FieldRef(memPort, static_cast<unsigned>(dataFieldId)),
          FieldRef(memPort, static_cast<unsigned>(addressFieldId)));
    }
  return deps;
}
 
/// Return the kind of port this is given the port type from a 'mem' decl.
static MemOp::PortKind getMemPortKindFromType(FIRRTLType type) {
  constexpr unsigned int addr = 1 << 0;
  constexpr unsigned int en = 1 << 1;
  constexpr unsigned int clk = 1 << 2;
  constexpr unsigned int data = 1 << 3;
  constexpr unsigned int mask = 1 << 4;
  constexpr unsigned int rdata = 1 << 5;
  constexpr unsigned int wdata = 1 << 6;
  constexpr unsigned int wmask = 1 << 7;
  constexpr unsigned int wmode = 1 << 8;
  constexpr unsigned int def = 1 << 9;
  // Get the kind of port based on the fields of the Bundle.
  auto portType = type_dyn_cast<BundleType>(type);
  if (!portType)
    return MemOp::PortKind::Debug;
  unsigned fields = 0;
  // Get the kind of port based on the fields of the Bundle.
  for (auto elem : portType.getElements()) {
    fields |= llvm::StringSwitch<unsigned>(elem.name.getValue())
                  .Case("addr", addr)
                  .Case("en", en)
                  .Case("clk", clk)
                  .Case("data", data)
                  .Case("mask", mask)
                  .Case("rdata", rdata)
                  .Case("wdata", wdata)
                  .Case("wmask", wmask)
                  .Case("wmode", wmode)
                  .Default(def);
  }
  if (fields == (addr | en | clk | data))
    return MemOp::PortKind::Read;
  if (fields == (addr | en | clk | data | mask))
    return MemOp::PortKind::Write;
  if (fields == (addr | en | clk | wdata | wmask | rdata | wmode))
    return MemOp::PortKind::ReadWrite;
  return MemOp::PortKind::Debug;
}
 
Flow firrtl::swapFlow(Flow flow) {
  switch (flow) {
  case Flow::None:
    return Flow::None;
  case Flow::Source:
    return Flow::Sink;
  case Flow::Sink:
    return Flow::Source;
  case Flow::Duplex:
    return Flow::Duplex;
  }
  // Unreachable but silences warning
  llvm_unreachable("Unsupported Flow type.");
}
 
const char *toString(Flow flow) {
  switch (flow) {
  case Flow::None:
    return "no flow";
  case Flow::Source:
    return "source flow";
  case Flow::Sink:
    return "sink flow";
  case Flow::Duplex:
    return "duplex flow";
  }
  // Unreachable but silences warning
  llvm_unreachable("Unsupported Flow type.");
}
 
Flow firrtl::foldFlow(Value val, Flow accumulatedFlow) {
 
  if (auto blockArg = dyn_cast<BlockArgument>(val)) {
    auto *op = val.getParentBlock()->getParentOp();
    if (auto moduleLike = dyn_cast<FModuleLike>(op)) {
      auto direction = moduleLike.getPortDirection(blockArg.getArgNumber());
      if (direction == Direction::Out)
        return swapFlow(accumulatedFlow);
    }
    return accumulatedFlow;
  }
 
  Operation *op = val.getDefiningOp();
 
  return TypeSwitch<Operation *, Flow>(op)
      .Case<SubfieldOp, OpenSubfieldOp>([&](auto op) {
        return foldFlow(op.getInput(), op.isFieldFlipped()
                                           ? swapFlow(accumulatedFlow)
                                           : accumulatedFlow);
      })
      .Case<SubindexOp, SubaccessOp, OpenSubindexOp, RefSubOp>(
          [&](auto op) { return foldFlow(op.getInput(), accumulatedFlow); })
      // Registers, Wires, and behavioral memory ports are always Duplex.
      .Case<RegOp, RegResetOp, WireOp, MemoryPortOp>(
          [](auto) { return Flow::Duplex; })
      .Case<InstanceOp, InstanceChoiceOp>([&](auto inst) {
        auto resultNo = cast<OpResult>(val).getResultNumber();
        if (inst.getPortDirection(resultNo) == Direction::Out)
          return accumulatedFlow;
        return swapFlow(accumulatedFlow);
      })
      .Case<MemOp>([&](auto op) {
        // only debug ports with RefType have source flow.
        if (type_isa<RefType>(val.getType()))
          return Flow::Source;
        return swapFlow(accumulatedFlow);
      })
      .Case<ObjectSubfieldOp>([&](ObjectSubfieldOp op) {
        auto input = op.getInput();
        auto *inputOp = input.getDefiningOp();
 
        // We are directly accessing a port on a local declaration.
        if (auto objectOp = dyn_cast_or_null<ObjectOp>(inputOp)) {
          auto classType = input.getType();
          auto direction = classType.getElement(op.getIndex()).direction;
          if (direction == Direction::In)
            return Flow::Sink;
          return Flow::Source;
        }
 
        // We are accessing a remote object. Input ports on remote objects are
        // inaccessible, and thus have Flow::None. Walk backwards through the
        // chain of subindexes, to detect if we have indexed through an input
        // port. At the end, either we did index through an input port, or the
        // entire path was through output ports with source flow.
        while (true) {
          auto classType = input.getType();
          auto direction = classType.getElement(op.getIndex()).direction;
          if (direction == Direction::In)
            return Flow::None;
 
          op = dyn_cast_or_null<ObjectSubfieldOp>(inputOp);
          if (op) {
            input = op.getInput();
            inputOp = input.getDefiningOp();
            continue;
          }
 
          return accumulatedFlow;
        };
      })
      // Anything else acts like a universal source.
      .Default([&](auto) { return accumulatedFlow; });
}
 
// TODO: This is doing the same walk as foldFlow.  These two functions can be
// combined and return a (flow, kind) product.
DeclKind firrtl::getDeclarationKind(Value val) {
  Operation *op = val.getDefiningOp();
  if (!op)
    return DeclKind::Port;
 
  return TypeSwitch<Operation *, DeclKind>(op)
      .Case<InstanceOp>([](auto) { return DeclKind::Instance; })
      .Case<SubfieldOp, SubindexOp, SubaccessOp, OpenSubfieldOp, OpenSubindexOp,
            RefSubOp>([](auto op) { return getDeclarationKind(op.getInput()); })
      .Default([](auto) { return DeclKind::Other; });
}
 
size_t firrtl::getNumPorts(Operation *op) {
  if (auto module = dyn_cast<FModuleLike>(op))
    return module.getNumPorts();
  return op->getNumResults();
}
 
/// Check whether an operation has a `DontTouch` annotation, or a symbol that
/// should prevent certain types of canonicalizations.
bool firrtl::hasDontTouch(Operation *op) {
  return op->getAttr(hw::InnerSymbolTable::getInnerSymbolAttrName()) ||
         AnnotationSet(op).hasDontTouch();
}
 
/// Check whether a block argument ("port") or the operation defining a value
/// has a `DontTouch` annotation, or a symbol that should prevent certain types
/// of canonicalizations.
bool firrtl::hasDontTouch(Value value) {
  if (auto *op = value.getDefiningOp())
    return hasDontTouch(op);
  auto arg = dyn_cast<BlockArgument>(value);
  auto module = dyn_cast<FModuleOp>(arg.getOwner()->getParentOp());
  if (!module)
    return false;
  return (module.getPortSymbolAttr(arg.getArgNumber())) ||
         AnnotationSet::forPort(module, arg.getArgNumber()).hasDontTouch();
}
 
/// Get a special name to use when printing the entry block arguments of the
/// region contained by an operation in this dialect.
void getAsmBlockArgumentNamesImpl(Operation *op, mlir::Region &region,
                                  OpAsmSetValueNameFn setNameFn) {
  if (region.empty())
    return;
  auto *parentOp = op;
  auto *block = &region.front();
  // Check to see if the operation containing the arguments has 'firrtl.name'
  // attributes for them.  If so, use that as the name.
  auto argAttr = parentOp->getAttrOfType<ArrayAttr>("portNames");
  // Do not crash on invalid IR.
  if (!argAttr || argAttr.size() != block->getNumArguments())
    return;
 
  for (size_t i = 0, e = block->getNumArguments(); i != e; ++i) {
    auto str = cast<StringAttr>(argAttr[i]).getValue();
    if (!str.empty())
      setNameFn(block->getArgument(i), str);
  }
}
 
/// A forward declaration for `NameKind` attribute parser.
static ParseResult parseNameKind(OpAsmParser &parser,
                                 firrtl::NameKindEnumAttr &result);
 
//===----------------------------------------------------------------------===//
// Layer Verification Utilities
//===----------------------------------------------------------------------===//
 
/// Get the ambient layers active at the given op.
static LayerSet getAmbientLayersAt(Operation *op) {
  // Crawl through the parent ops, accumulating all ambient layers at the given
  // operation.
  LayerSet result;
  for (; op != nullptr; op = op->getParentOp()) {
    if (auto module = dyn_cast<FModuleLike>(op)) {
      auto layers = module.getLayersAttr().getAsRange<SymbolRefAttr>();
      result.insert(layers.begin(), layers.end());
      break;
    }
    if (auto layerblock = dyn_cast<LayerBlockOp>(op)) {
      result.insert(layerblock.getLayerName());
      continue;
    }
  }
  return result;
}
 
/// Get the ambient layer requirements at the definition site of the value.
static LayerSet getAmbientLayersFor(Value value) {
  return getAmbientLayersAt(getFieldRefFromValue(value).getDefiningOp());
}
 
/// Get the effective layer requirements for the given value.
/// The effective layers for a value is the union of
///   - the ambient layers for the cannonical storage location.
///   - any explicit layer annotations in the value's type.
static LayerSet getLayersFor(Value value) {
  auto result = getAmbientLayersFor(value);
  if (auto type = dyn_cast<RefType>(value.getType()))
    if (auto layer = type.getLayer())
      result.insert(type.getLayer());
  return result;
}
 
/// Check that the source layer is compatible with the destination layer.
/// Either the source and destination are identical, or the source-layer
/// is a parent of the destination. For example `A` is compatible with `A.B.C`,
/// because any definition valid in `A` is also valid in `A.B.C`.
static bool isLayerCompatibleWith(mlir::SymbolRefAttr srcLayer,
                                  mlir::SymbolRefAttr dstLayer) {
  // A non-colored probe may be cast to any colored probe.
  if (!srcLayer)
    return true;
 
  // A colored probe cannot be cast to an uncolored probe.
  if (!dstLayer)
    return false;
 
  // Return true if the srcLayer is a prefix of the dstLayer.
  if (srcLayer.getRootReference() != dstLayer.getRootReference())
    return false;
 
  auto srcNames = srcLayer.getNestedReferences();
  auto dstNames = dstLayer.getNestedReferences();
  if (dstNames.size() < srcNames.size())
    return false;
 
  return llvm::all_of(llvm::zip_first(srcNames, dstNames),
                      [](auto x) { return std::get<0>(x) == std::get<1>(x); });
}
 
/// Check that the source layer is present in the destination layers.
static bool isLayerCompatibleWith(SymbolRefAttr srcLayer,
                                  const LayerSet &dstLayers) {
  // fast path: the required layer is directly listed in the provided layers.
  if (dstLayers.contains(srcLayer))
    return true;
 
  // Slow path: the required layer is not directly listed in the provided
  // layers, but the layer may still be provided by a nested layer.
  return any_of(dstLayers, [=](SymbolRefAttr dstLayer) {
    return isLayerCompatibleWith(srcLayer, dstLayer);
  });
}
 
/// Check that the source layers are all present in the destination layers.
/// True if all source layers are present in the destination.
/// Outputs the set of source layers that are missing in the destination.
static bool isLayerSetCompatibleWith(const LayerSet &src, const LayerSet &dst,
                                     SmallVectorImpl<SymbolRefAttr> &missing) {
  for (auto srcLayer : src)
    if (!isLayerCompatibleWith(srcLayer, dst))
      missing.push_back(srcLayer);
 
  llvm::sort(missing, LayerSetCompare());
  return missing.empty();
}
 
static LogicalResult checkLayerCompatibility(
    Operation *op, const LayerSet &src, const LayerSet &dst,
    const Twine &errorMsg,
    const Twine &noteMsg = Twine("missing layer requirements")) {
  SmallVector<SymbolRefAttr> missing;
  if (isLayerSetCompatibleWith(src, dst, missing))
    return success();
  interleaveComma(missing, op->emitOpError(errorMsg).attachNote()
                               << noteMsg << ": ");
  return failure();
}
 
//===----------------------------------------------------------------------===//
// CircuitOp
//===----------------------------------------------------------------------===//
 
void CircuitOp::build(OpBuilder &builder, OperationState &result,
                      StringAttr name, ArrayAttr annotations) {
  // Add an attribute for the name.
  result.getOrAddProperties<Properties>().setName(name);
 
  if (!annotations)
    annotations = builder.getArrayAttr({});
  result.getOrAddProperties<Properties>().setAnnotations(annotations);
 
  // Create a region and a block for the body.
  Region *bodyRegion = result.addRegion();
  Block *body = new Block();
  bodyRegion->push_back(body);
}
 
static ParseResult parseCircuitOpAttrs(OpAsmParser &parser,
                                       NamedAttrList &resultAttrs) {
  auto result = parser.parseOptionalAttrDictWithKeyword(resultAttrs);
  if (!resultAttrs.get("annotations"))
    resultAttrs.append("annotations", parser.getBuilder().getArrayAttr({}));
 
  return result;
}
 
static void printCircuitOpAttrs(OpAsmPrinter &p, Operation *op,
                                DictionaryAttr attr) {
  // "name" is always elided.
  SmallVector<StringRef> elidedAttrs = {"name"};
  // Elide "annotations" if it doesn't exist or if it is empty
  auto annotationsAttr = op->getAttrOfType<ArrayAttr>("annotations");
  if (annotationsAttr.empty())
    elidedAttrs.push_back("annotations");
 
  p.printOptionalAttrDictWithKeyword(op->getAttrs(), elidedAttrs);
}
 
LogicalResult CircuitOp::verifyRegions() {
  StringRef main = getName();
 
  // Check that the circuit has a non-empty name.
  if (main.empty()) {
    emitOpError("must have a non-empty name");
    return failure();
  }
 
  mlir::SymbolTable symtbl(getOperation());
 
  auto *mainModule = symtbl.lookup(main);
  if (!mainModule)
    return emitOpError().append(
        "does not contain module with same name as circuit");
  if (!isa<FModuleLike>(mainModule))
    return mainModule->emitError(
        "entity with name of circuit must be a module");
  if (symtbl.getSymbolVisibility(mainModule) !=
      mlir::SymbolTable::Visibility::Public)
    return mainModule->emitError("main module must be public");
 
  // Store a mapping of defname to either the first external module
  // that defines it or, preferentially, the first external module
  // that defines it and has no parameters.
  llvm::DenseMap<Attribute, FExtModuleOp> defnameMap;
 
  auto verifyExtModule = [&](FExtModuleOp extModule) -> LogicalResult {
    if (!extModule)
      return success();
 
    auto defname = extModule.getDefnameAttr();
    if (!defname)
      return success();
 
    // Check that this extmodule's defname does not conflict with
    // the symbol name of any module.
    if (auto collidingModule = symtbl.lookup<FModuleOp>(defname.getValue()))
      return extModule.emitOpError()
          .append("attribute 'defname' with value ", defname,
                  " conflicts with the name of another module in the circuit")
          .attachNote(collidingModule.getLoc())
          .append("previous module declared here");
 
    // Find an optional extmodule with a defname collision. Update
    // the defnameMap if this is the first extmodule with that
    // defname or if the current extmodule takes no parameters and
    // the collision does. The latter condition improves later
    // extmodule verification as checking against a parameterless
    // module is stricter.
    FExtModuleOp collidingExtModule;
    if (auto &value = defnameMap[defname]) {
      collidingExtModule = value;
      if (!value.getParameters().empty() && extModule.getParameters().empty())
        value = extModule;
    } else {
      value = extModule;
      // Go to the next extmodule if no extmodule with the same
      // defname was found.
      return success();
    }
 
    // Check that the number of ports is exactly the same.
    SmallVector<PortInfo> ports = extModule.getPorts();
    SmallVector<PortInfo> collidingPorts = collidingExtModule.getPorts();
 
    if (ports.size() != collidingPorts.size())
      return extModule.emitOpError()
          .append("with 'defname' attribute ", defname, " has ", ports.size(),
                  " ports which is different from a previously defined "
                  "extmodule with the same 'defname' which has ",
                  collidingPorts.size(), " ports")
          .attachNote(collidingExtModule.getLoc())
          .append("previous extmodule definition occurred here");
 
    // Check that ports match for name and type. Since parameters
    // *might* affect widths, ignore widths if either module has
    // parameters. Note that this allows for misdetections, but
    // has zero false positives.
    for (auto p : llvm::zip(ports, collidingPorts)) {
      StringAttr aName = std::get<0>(p).name, bName = std::get<1>(p).name;
      Type aType = std::get<0>(p).type, bType = std::get<1>(p).type;
 
      if (aName != bName)
        return extModule.emitOpError()
            .append("with 'defname' attribute ", defname,
                    " has a port with name ", aName,
                    " which does not match the name of the port in the same "
                    "position of a previously defined extmodule with the same "
                    "'defname', expected port to have name ",
                    bName)
            .attachNote(collidingExtModule.getLoc())
            .append("previous extmodule definition occurred here");
 
      if (!extModule.getParameters().empty() ||
          !collidingExtModule.getParameters().empty()) {
        // Compare base types as widthless, others must match.
        if (auto base = type_dyn_cast<FIRRTLBaseType>(aType))
          aType = base.getWidthlessType();
        if (auto base = type_dyn_cast<FIRRTLBaseType>(bType))
          bType = base.getWidthlessType();
      }
      if (aType != bType)
        return extModule.emitOpError()
            .append("with 'defname' attribute ", defname,
                    " has a port with name ", aName,
                    " which has a different type ", aType,
                    " which does not match the type of the port in the same "
                    "position of a previously defined extmodule with the same "
                    "'defname', expected port to have type ",
                    bType)
            .attachNote(collidingExtModule.getLoc())
            .append("previous extmodule definition occurred here");
    }
    return success();
  };
 
  SmallVector<FModuleOp, 1> dutModules;
  for (auto &op : *getBodyBlock()) {
    // Verify modules.
    if (auto moduleOp = dyn_cast<FModuleOp>(op)) {
      if (AnnotationSet(moduleOp).hasAnnotation(markDUTAnnoClass))
        dutModules.push_back(moduleOp);
      continue;
    }
 
    // Verify external modules.
    if (auto extModule = dyn_cast<FExtModuleOp>(op)) {
      if (verifyExtModule(extModule).failed())
        return failure();
    }
  }
 
  // Error if there is more than one design-under-test.
  if (dutModules.size() > 1) {
    auto diag = dutModules[0]->emitOpError()
                << "is annotated as the design-under-test (DUT), but other "
                   "modules are also annotated";
    for (auto moduleOp : ArrayRef(dutModules).drop_front())
      diag.attachNote(moduleOp.getLoc()) << "is also annotated as the DUT";
    return failure();
  }
 
  return success();
}
 
Block *CircuitOp::getBodyBlock() { return &getBody().front(); }
 
//===----------------------------------------------------------------------===//
// FExtModuleOp and FModuleOp
//===----------------------------------------------------------------------===//
 
static SmallVector<PortInfo> getPortImpl(FModuleLike module) {
  SmallVector<PortInfo> results;
  results.reserve(module.getNumPorts());
  ArrayRef<Attribute> domains = module.getDomainInfo();
  for (unsigned i = 0, e = module.getNumPorts(); i < e; ++i) {
    results.push_back({module.getPortNameAttr(i), module.getPortType(i),
                       module.getPortDirection(i), module.getPortSymbolAttr(i),
                       module.getPortLocation(i),
                       AnnotationSet::forPort(module, i),
                       domains.empty() ? Attribute{} : domains[i]});
  }
  return results;
}
 
SmallVector<PortInfo> FModuleOp::getPorts() { return ::getPortImpl(*this); }
 
SmallVector<PortInfo> FExtModuleOp::getPorts() { return ::getPortImpl(*this); }
 
SmallVector<PortInfo> FIntModuleOp::getPorts() { return ::getPortImpl(*this); }
 
SmallVector<PortInfo> FMemModuleOp::getPorts() { return ::getPortImpl(*this); }
 
static hw::ModulePort::Direction dirFtoH(Direction dir) {
  if (dir == Direction::In)
    return hw::ModulePort::Direction::Input;
  if (dir == Direction::Out)
    return hw::ModulePort::Direction::Output;
  assert(0 && "invalid direction");
  abort();
}
 
static SmallVector<hw::PortInfo> getPortListImpl(FModuleLike module) {
  SmallVector<hw::PortInfo> results;
  auto aname = StringAttr::get(module.getContext(),
                               hw::HWModuleLike::getPortSymbolAttrName());
  auto emptyDict = DictionaryAttr::get(module.getContext());
  for (unsigned i = 0, e = getNumPorts(module); i < e; ++i) {
    auto sym = module.getPortSymbolAttr(i);
    results.push_back(
        {{module.getPortNameAttr(i), module.getPortType(i),
          dirFtoH(module.getPortDirection(i))},
         i,
         sym ? DictionaryAttr::get(
                   module.getContext(),
                   ArrayRef<mlir::NamedAttribute>{NamedAttribute{aname, sym}})
             : emptyDict,
         module.getPortLocation(i)});
  }
  return results;
}
 
SmallVector<::circt::hw::PortInfo> FModuleOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
SmallVector<::circt::hw::PortInfo> FExtModuleOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
SmallVector<::circt::hw::PortInfo> FIntModuleOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
SmallVector<::circt::hw::PortInfo> FMemModuleOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
static hw::PortInfo getPortImpl(FModuleLike module, size_t idx) {
  auto sym = module.getPortSymbolAttr(idx);
  auto attrs = sym ? DictionaryAttr::getWithSorted(
                         module.getContext(),
                         ArrayRef(mlir::NamedAttribute(
                             hw::HWModuleLike::getPortSymbolAttrName(), sym)))
                   : DictionaryAttr::get(module.getContext());
  return {{module.getPortNameAttr(idx), module.getPortType(idx),
           dirFtoH(module.getPortDirection(idx))},
          idx,
          attrs,
          module.getPortLocation(idx)};
}
 
::circt::hw::PortInfo FModuleOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
::circt::hw::PortInfo FExtModuleOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
::circt::hw::PortInfo FIntModuleOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
::circt::hw::PortInfo FMemModuleOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
// Return the port with the specified name.
BlockArgument FModuleOp::getArgument(size_t portNumber) {
  return getBodyBlock()->getArgument(portNumber);
}
 
/// Return an updated domain info Attribute with domain indices updated based on
/// port insertions.
static Attribute fixDomainInfoInsertions(MLIRContext *context,
                                         Attribute domainInfoAttr,
                                         ArrayRef<unsigned> indexMap) {
  // This is a domain type port.  Return the original domain info unmodified.
  auto di = dyn_cast_or_null<ArrayAttr>(domainInfoAttr);
  if (!di || di.empty())
    return domainInfoAttr;
 
  // This is a non-domain type port.  Update any indeices referenced.
  SmallVector<Attribute> domainInfo;
  for (auto attr : di) {
    auto oldIdx = cast<IntegerAttr>(attr).getUInt();
    auto newIdx = indexMap[oldIdx];
    if (oldIdx == newIdx)
      domainInfo.push_back(attr);
    else
      domainInfo.push_back(IntegerAttr::get(
          IntegerType::get(context, 32, IntegerType::Unsigned), newIdx));
  }
  return ArrayAttr::get(context, domainInfo);
}
 
/// Inserts the given ports. The insertion indices are expected to be in order.
/// Insertion occurs in-order, such that ports with the same insertion index
/// appear in the module in the same order they appeared in the list.
static void insertPorts(FModuleLike op,
                        ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  if (ports.empty())
    return;
  unsigned oldNumArgs = op.getNumPorts();
  unsigned newNumArgs = oldNumArgs + ports.size();
 
  // Build a map from old port indices to new indices.
  SmallVector<unsigned> indexMap(oldNumArgs);
  size_t inserted = 0;
  for (size_t i = 0; i < oldNumArgs; ++i) {
    while (inserted < ports.size() && ports[inserted].first == i)
      ++inserted;
    indexMap[i] = i + inserted;
  }
 
  // Add direction markers and names for new ports.
  auto existingDirections = op.getPortDirectionsAttr();
  ArrayRef<Attribute> existingNames = op.getPortNames();
  ArrayRef<Attribute> existingTypes = op.getPortTypes();
  ArrayRef<Attribute> existingLocs = op.getPortLocations();
  assert(existingDirections.size() == oldNumArgs);
  assert(existingNames.size() == oldNumArgs);
  assert(existingTypes.size() == oldNumArgs);
  assert(existingLocs.size() == oldNumArgs);
 
  SmallVector<bool> newDirections;
  SmallVector<Attribute> newNames, newTypes, newDomains, newAnnos, newSyms,
      newLocs;
  newDirections.reserve(newNumArgs);
  newNames.reserve(newNumArgs);
  newTypes.reserve(newNumArgs);
  newDomains.reserve(newNumArgs);
  newAnnos.reserve(newNumArgs);
  newSyms.reserve(newNumArgs);
  newLocs.reserve(newNumArgs);
 
  auto emptyArray = ArrayAttr::get(op.getContext(), {});
 
  unsigned oldIdx = 0;
  auto migrateOldPorts = [&](unsigned untilOldIdx) {
    while (oldIdx < oldNumArgs && oldIdx < untilOldIdx) {
      newDirections.push_back(existingDirections[oldIdx]);
      newNames.push_back(existingNames[oldIdx]);
      newTypes.push_back(existingTypes[oldIdx]);
      newDomains.push_back(fixDomainInfoInsertions(
          op.getContext(), op.getDomainInfoAttrForPort(oldIdx), indexMap));
      newAnnos.push_back(op.getAnnotationsAttrForPort(oldIdx));
      newSyms.push_back(op.getPortSymbolAttr(oldIdx));
      newLocs.push_back(existingLocs[oldIdx]);
      ++oldIdx;
    }
  };
 
  for (auto [idx, port] : ports) {
    migrateOldPorts(idx);
    newDirections.push_back(direction::unGet(port.direction));
    newNames.push_back(port.name);
    newTypes.push_back(TypeAttr::get(port.type));
    newDomains.push_back(fixDomainInfoInsertions(
        op.getContext(),
        port.domains ? port.domains : ArrayAttr::get(op.getContext(), {}),
        indexMap));
    auto annos = port.annotations.getArrayAttr();
    newAnnos.push_back(annos ? annos : emptyArray);
    newSyms.push_back(port.sym);
    newLocs.push_back(port.loc);
    ++inserted;
  }
  migrateOldPorts(oldNumArgs);
 
  // The lack of *any* port annotations is represented by an empty
  // `portAnnotations` array as a shorthand.
  if (llvm::all_of(newAnnos, [](Attribute attr) {
        return cast<ArrayAttr>(attr).empty();
      }))
    newAnnos.clear();
 
  // The lack of *any* domains is also represented by an empty `domainInfo`
  // attribute.
  if (llvm::all_of(newDomains, [](Attribute attr) {
        if (!attr)
          return true;
        if (auto arrayAttr = dyn_cast<ArrayAttr>(attr))
          return arrayAttr.empty();
        return false;
      }))
    newDomains.clear();
 
  // Apply these changed markers.
  op->setAttr("portDirections",
              direction::packAttribute(op.getContext(), newDirections));
  op->setAttr("portNames", ArrayAttr::get(op.getContext(), newNames));
  op->setAttr("portTypes", ArrayAttr::get(op.getContext(), newTypes));
  op->setAttr("domainInfo", ArrayAttr::get(op.getContext(), newDomains));
  op->setAttr("portAnnotations", ArrayAttr::get(op.getContext(), newAnnos));
  FModuleLike::fixupPortSymsArray(newSyms, op.getContext());
  op.setPortSymbols(newSyms);
  op->setAttr("portLocations", ArrayAttr::get(op.getContext(), newLocs));
}
 
// Return an Attribute with updated port domain information based on information
// about which ports have been deleted.  This is necessary because the port
// domain storage uses an integer to indicate the index of a domain port with
// which it is associated.
//
// Note: this will _always_ return one-entry-per-port.  While this is not
// required for FModuleLike, InstanceOps have this restriction.
static ArrayAttr fixDomainInfoDeletions(MLIRContext *context,
                                        ArrayAttr domainInfoAttr,
                                        const llvm::BitVector &portIndices,
                                        bool supportsEmptyAttr) {
  if (supportsEmptyAttr && domainInfoAttr.empty())
    return domainInfoAttr;
 
  // Build a map from old port indices to new indices.
  SmallVector<unsigned> indexMap(portIndices.size());
  size_t deleted = 0;
  for (size_t i = 0, e = portIndices.size(); i != e; ++i) {
    indexMap[i] = i - deleted;
    if (portIndices[i])
      ++deleted;
  }
 
  // Return a cached empty ArrayAttr.
  ArrayAttr eEmpty;
  auto getEmpty = [&]() {
    if (!eEmpty)
      eEmpty = ArrayAttr::get(context, {});
    return eEmpty;
  };
 
  // Update the domain indices.
  SmallVector<Attribute> newDomainInfo;
  newDomainInfo.reserve(portIndices.size() - portIndices.count());
  for (size_t i = 0, e = portIndices.size(); i != e; ++i) {
    // If this port is deleted, then do nothing.
    if (portIndices.test(i))
      continue;
    // If there is no domain info, then add an empty attribute.
    if (domainInfoAttr.empty()) {
      newDomainInfo.push_back(getEmpty());
      continue;
    }
    auto attr = domainInfoAttr[i];
    // If this is a Domain Type (indicating domain kind) or an empty domain.
    auto domains = dyn_cast<ArrayAttr>(attr);
    if (!domains || domains.empty()) {
      newDomainInfo.push_back(attr);
      continue;
    }
    // This contains indexes to domain ports.  Update them.
    SmallVector<Attribute> newDomains;
    for (auto domain : domains) {
      // If the domain port was deleted, drop the association.
      auto oldIdx = cast<IntegerAttr>(domain).getUInt();
      if (portIndices.test(oldIdx))
        continue;
      // If the new index is the same, do nothing.
      auto newIdx = indexMap[oldIdx];
      if (oldIdx == newIdx) {
        newDomains.push_back(domain);
        continue;
      }
      // Update the index.
      newDomains.push_back(IntegerAttr::get(
          IntegerType::get(context, 32, IntegerType::Unsigned), newIdx));
    }
    newDomainInfo.push_back(ArrayAttr::get(context, newDomains));
  }
 
  return ArrayAttr::get(context, newDomainInfo);
}
 
/// Erases the ports that have their corresponding bit set in `portIndices`.
static void erasePorts(FModuleLike op, const llvm::BitVector &portIndices) {
  if (portIndices.none())
    return;
 
  // Drop the direction markers for dead ports.
  ArrayRef<bool> portDirections = op.getPortDirectionsAttr().asArrayRef();
  ArrayRef<Attribute> portNames = op.getPortNames();
  ArrayRef<Attribute> portTypes = op.getPortTypes();
  ArrayRef<Attribute> portAnnos = op.getPortAnnotations();
  ArrayRef<Attribute> portSyms = op.getPortSymbols();
  ArrayRef<Attribute> portLocs = op.getPortLocations();
  ArrayRef<Attribute> portDomains = op.getDomainInfo();
  (void)portDomains;
  auto numPorts = op.getNumPorts();
  (void)numPorts;
  assert(portDirections.size() == numPorts);
  assert(portNames.size() == numPorts);
  assert(portAnnos.size() == numPorts || portAnnos.empty());
  assert(portTypes.size() == numPorts);
  assert(portSyms.size() == numPorts || portSyms.empty());
  assert(portLocs.size() == numPorts);
  assert(portDomains.size() == numPorts || portDomains.empty());
 
  SmallVector<bool> newPortDirections =
      removeElementsAtIndices<bool>(portDirections, portIndices);
  SmallVector<Attribute> newPortNames, newPortTypes, newPortAnnos, newPortSyms,
      newPortLocs;
  newPortNames = removeElementsAtIndices(portNames, portIndices);
  newPortTypes = removeElementsAtIndices(portTypes, portIndices);
  newPortAnnos = removeElementsAtIndices(portAnnos, portIndices);
  newPortSyms = removeElementsAtIndices(portSyms, portIndices);
  newPortLocs = removeElementsAtIndices(portLocs, portIndices);
 
  op->setAttr("portDirections",
              direction::packAttribute(op.getContext(), newPortDirections));
  op->setAttr("portNames", ArrayAttr::get(op.getContext(), newPortNames));
  op->setAttr("portAnnotations", ArrayAttr::get(op.getContext(), newPortAnnos));
  op->setAttr("portTypes", ArrayAttr::get(op.getContext(), newPortTypes));
  FModuleLike::fixupPortSymsArray(newPortSyms, op.getContext());
  op->setAttr("portSymbols", ArrayAttr::get(op.getContext(), newPortSyms));
  op->setAttr("portLocations", ArrayAttr::get(op.getContext(), newPortLocs));
  op->setAttr("domainInfo",
              fixDomainInfoDeletions(op.getContext(), op.getDomainInfoAttr(),
                                     portIndices, /*supportsEmptyAttr=*/true));
}
 
void FExtModuleOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
}
 
void FIntModuleOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
}
 
void FMemModuleOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
}
 
void FModuleOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
  getBodyBlock()->eraseArguments(portIndices);
}
 
/// Inserts the given ports. The insertion indices are expected to be in order.
/// Insertion occurs in-order, such that ports with the same insertion index
/// appear in the module in the same order they appeared in the list.
void FModuleOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
 
  // Insert the block arguments.
  auto *body = getBodyBlock();
  for (size_t i = 0, e = ports.size(); i < e; ++i) {
    // Block arguments are inserted one at a time, so for each argument we
    // insert we have to increase the index by 1.
    auto &[index, port] = ports[i];
    body->insertArgument(index + i, port.type, port.loc);
  }
}
 
void FExtModuleOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
}
 
void FIntModuleOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
}
 
/// Inserts the given ports. The insertion indices are expected to be in order.
/// Insertion occurs in-order, such that ports with the same insertion index
/// appear in the module in the same order they appeared in the list.
void FMemModuleOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
}
 
template <typename OpTy>
void buildModuleLike(OpBuilder &builder, OperationState &result,
                     StringAttr name, ArrayRef<PortInfo> ports) {
  // Add an attribute for the name.
  auto &properties = result.getOrAddProperties<typename OpTy::Properties>();
  properties.setSymName(name);
 
  // Record the names of the arguments if present.
  SmallVector<Direction, 4> portDirections;
  SmallVector<Attribute, 4> portNames, portTypes, portSyms, portLocs,
      portDomains;
  portDirections.reserve(ports.size());
  portNames.reserve(ports.size());
  portTypes.reserve(ports.size());
  portSyms.reserve(ports.size());
  portLocs.reserve(ports.size());
  portDomains.reserve(ports.size());
 
  for (const auto &port : ports) {
    portDirections.push_back(port.direction);
    portNames.push_back(port.name);
    portTypes.push_back(TypeAttr::get(port.type));
    portSyms.push_back(port.sym);
    portLocs.push_back(port.loc);
    portDomains.push_back(port.domains);
  }
  if (llvm::all_of(portDomains, [](Attribute attr) {
        if (!attr)
          return true;
        if (auto arrayAttr = dyn_cast<ArrayAttr>(attr))
          return arrayAttr.empty();
        return false;
      }))
    portDomains.clear();
 
  FModuleLike::fixupPortSymsArray(portSyms, builder.getContext());
 
  // Both attributes are added, even if the module has no ports.
  properties.setPortDirections(
      direction::packAttribute(builder.getContext(), portDirections));
  properties.setPortNames(builder.getArrayAttr(portNames));
  properties.setPortTypes(builder.getArrayAttr(portTypes));
  properties.setPortSymbols(builder.getArrayAttr(portSyms));
  properties.setPortLocations(builder.getArrayAttr(portLocs));
  properties.setDomainInfo(builder.getArrayAttr(portDomains));
 
  result.addRegion();
}
 
template <typename OpTy>
static void buildModule(OpBuilder &builder, OperationState &result,
                        StringAttr name, ArrayRef<PortInfo> ports,
                        ArrayAttr annotations, ArrayAttr layers) {
  buildModuleLike<OpTy>(builder, result, name, ports);
  auto &properties = result.getOrAddProperties<typename OpTy::Properties>();
  // Annotations.
  if (!annotations)
    annotations = builder.getArrayAttr({});
  properties.setAnnotations(annotations);
 
  // Port annotations. lack of *any* port annotations is represented by an empty
  // `portAnnotations` array as a shorthand.
  SmallVector<Attribute, 4> portAnnotations;
  for (const auto &port : ports)
    portAnnotations.push_back(port.annotations.getArrayAttr());
  if (llvm::all_of(portAnnotations, [](Attribute attr) {
        return cast<ArrayAttr>(attr).empty();
      }))
    portAnnotations.clear();
  properties.setPortAnnotations(builder.getArrayAttr(portAnnotations));
 
  // Layers.
  if (!layers)
    layers = builder.getArrayAttr({});
  properties.setLayers(layers);
}
 
template <typename OpTy>
static void buildClass(OpBuilder &builder, OperationState &result,
                       StringAttr name, ArrayRef<PortInfo> ports) {
  return buildModuleLike<OpTy>(builder, result, name, ports);
}
 
void FModuleOp::build(OpBuilder &builder, OperationState &result,
                      StringAttr name, ConventionAttr convention,
                      ArrayRef<PortInfo> ports, ArrayAttr annotations,
                      ArrayAttr layers) {
  buildModule<FModuleOp>(builder, result, name, ports, annotations, layers);
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setConvention(convention);
 
  // Create a region and a block for the body.
  auto *bodyRegion = result.regions[0].get();
  Block *body = new Block();
  bodyRegion->push_back(body);
 
  // Add arguments to the body block.
  for (auto &elt : ports)
    body->addArgument(elt.type, elt.loc);
}
 
void FExtModuleOp::build(OpBuilder &builder, OperationState &result,
                         StringAttr name, ConventionAttr convention,
                         ArrayRef<PortInfo> ports, ArrayAttr knownLayers,
                         StringRef defnameAttr, ArrayAttr annotations,
                         ArrayAttr parameters, ArrayAttr layers,
                         ArrayAttr externalRequirements) {
  buildModule<FExtModuleOp>(builder, result, name, ports, annotations, layers);
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setConvention(convention);
  if (!knownLayers)
    knownLayers = builder.getArrayAttr({});
  properties.setKnownLayers(knownLayers);
  if (!defnameAttr.empty())
    properties.setDefname(builder.getStringAttr(defnameAttr));
  if (!parameters)
    parameters = builder.getArrayAttr({});
  properties.setParameters(parameters);
  if (externalRequirements)
    properties.setExternalRequirements(externalRequirements);
}
 
void FIntModuleOp::build(OpBuilder &builder, OperationState &result,
                         StringAttr name, ArrayRef<PortInfo> ports,
                         StringRef intrinsicNameStr, ArrayAttr annotations,
                         ArrayAttr parameters, ArrayAttr layers) {
  buildModule<FIntModuleOp>(builder, result, name, ports, annotations, layers);
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setIntrinsic(builder.getStringAttr(intrinsicNameStr));
  if (!parameters)
    parameters = builder.getArrayAttr({});
  properties.setParameters(parameters);
}
 
void FMemModuleOp::build(OpBuilder &builder, OperationState &result,
                         StringAttr name, ArrayRef<PortInfo> ports,
                         uint32_t numReadPorts, uint32_t numWritePorts,
                         uint32_t numReadWritePorts, uint32_t dataWidth,
                         uint32_t maskBits, uint32_t readLatency,
                         uint32_t writeLatency, uint64_t depth, RUWBehavior ruw,
                         ArrayAttr annotations, ArrayAttr layers) {
  auto *context = builder.getContext();
  buildModule<FMemModuleOp>(builder, result, name, ports, annotations, layers);
  auto ui32Type = IntegerType::get(context, 32, IntegerType::Unsigned);
  auto ui64Type = IntegerType::get(context, 64, IntegerType::Unsigned);
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setNumReadPorts(IntegerAttr::get(ui32Type, numReadPorts));
  properties.setNumWritePorts(IntegerAttr::get(ui32Type, numWritePorts));
  properties.setNumReadWritePorts(
      IntegerAttr::get(ui32Type, numReadWritePorts));
  properties.setDataWidth(IntegerAttr::get(ui32Type, dataWidth));
  properties.setMaskBits(IntegerAttr::get(ui32Type, maskBits));
  properties.setReadLatency(IntegerAttr::get(ui32Type, readLatency));
  properties.setWriteLatency(IntegerAttr::get(ui32Type, writeLatency));
  properties.setDepth(IntegerAttr::get(ui64Type, depth));
  properties.setExtraPorts(ArrayAttr::get(context, {}));
  properties.setRuw(RUWBehaviorAttr::get(context, ruw));
}
 
/// Print a list of module ports in the following form:
///   in x: !firrtl.uint<1> [{class = "DontTouch}], out "_port": !firrtl.uint<2>
///
/// When there is no block specified, the port names print as MLIR identifiers,
/// wrapping in quotes if not legal to print as-is. When there is no block
/// specified, this function always return false, indicating that there was no
/// issue printing port names.
///
/// If there is a block specified, then port names will be printed as SSA
/// values.  If there is a reason the printed SSA values can't match the true
/// port name, then this function will return true.  When this happens, the
/// caller should print the port names as a part of the `attr-dict`.
static bool
printModulePorts(OpAsmPrinter &p, Block *block, ArrayRef<bool> portDirections,
                 ArrayRef<Attribute> portNames, ArrayRef<Attribute> portTypes,
                 ArrayRef<Attribute> portAnnotations,
                 ArrayRef<Attribute> portSyms, ArrayRef<Attribute> portLocs,
                 ArrayRef<Attribute> domainInfo) {
  // When printing port names as SSA values, we can fail to print them
  // identically.
  bool printedNamesDontMatch = false;
 
  mlir::OpPrintingFlags flags;
 
  // Return an SSA name for an argument.
  DenseMap<unsigned, std::string> ssaNames;
  auto getSsaName = [&](unsigned idx) -> StringRef {
    // We already computed this name.  Return it.
    auto itr = ssaNames.find(idx);
    if (itr != ssaNames.end())
      return itr->getSecond();
 
    // Compute the name, insert it, and return it.
    if (block) {
      SmallString<32> resultNameStr;
      // Get the printed format for the argument name.
      llvm::raw_svector_ostream tmpStream(resultNameStr);
      p.printOperand(block->getArgument(idx), tmpStream);
      // If the name wasn't printable in a way that agreed with portName, make
      // sure to print out an explicit portNames attribute.
      auto portName = cast<StringAttr>(portNames[idx]).getValue();
      if (tmpStream.str().drop_front() != portName)
        printedNamesDontMatch = true;
      return ssaNames.insert({idx, tmpStream.str().str()}).first->getSecond();
    }
 
    auto name = cast<StringAttr>(portNames[idx]).getValue();
    return ssaNames.insert({idx, name.str()}).first->getSecond();
  };
 
  // If we are printing the ports as block arguments the op must have a first
  // block.
  p << '(';
  for (unsigned i = 0, e = portTypes.size(); i < e; ++i) {
    if (i > 0)
      p << ", ";
 
    // Print the port direction.
    p << direction::get(portDirections[i]) << " ";
 
    // Print the port name.  If there is a valid block, we print it as a block
    // argument.
    auto portType = cast<TypeAttr>(portTypes[i]).getValue();
    if (block) {
      p << getSsaName(i);
    } else {
      p.printKeywordOrString(getSsaName(i));
    }
 
    // Print the port type.
    p << ": ";
    p.printType(portType);
 
    // Print the optional port symbol.
    if (!portSyms.empty()) {
      if (!cast<hw::InnerSymAttr>(portSyms[i]).empty()) {
        p << " sym ";
        cast<hw::InnerSymAttr>(portSyms[i]).print(p);
      }
    }
 
    // Print domain associations.
    // Domain information is now stored in the DomainType itself, not in
    // domainInfo. The domainInfo array only contains associations
    // (ArrayAttr<IntegerAttr>).
    if (!domainInfo.empty()) {
      auto domains = cast<ArrayAttr>(domainInfo[i]);
      if (!domains.empty()) {
        p << " domains [";
        llvm::interleaveComma(domains, p, [&](Attribute attr) {
          p << getSsaName(cast<IntegerAttr>(attr).getUInt());
        });
        p << "]";
      }
    }
 
    // Print the port specific annotations. The port annotations array will be
    // empty if there are none.
    if (!portAnnotations.empty() &&
        !cast<ArrayAttr>(portAnnotations[i]).empty()) {
      p << " ";
      p.printAttribute(portAnnotations[i]);
    }
 
    // Print the port location.
    // TODO: `printOptionalLocationSpecifier` will emit aliases for locations,
    // even if they are not printed.  This will have to be fixed upstream.  For
    // now, use what was specified on the command line.
    if (flags.shouldPrintDebugInfo() && !portLocs.empty())
      p.printOptionalLocationSpecifier(cast<LocationAttr>(portLocs[i]));
  }
 
  p << ')';
  return printedNamesDontMatch;
}
 
/// Parse a list of module ports.  If port names are SSA identifiers, then this
/// will populate `entryArgs`.
static ParseResult parseModulePorts(
    OpAsmParser &parser, bool hasSSAIdentifiers, bool supportsSymbols,
    bool supportsDomains, SmallVectorImpl<OpAsmParser::Argument> &entryArgs,
    SmallVectorImpl<Direction> &portDirections,
    SmallVectorImpl<Attribute> &portNames,
    SmallVectorImpl<Attribute> &portTypes,
    SmallVectorImpl<Attribute> &portAnnotations,
    SmallVectorImpl<Attribute> &portSyms, SmallVectorImpl<Attribute> &portLocs,
    SmallVectorImpl<Attribute> &domains) {
  auto *context = parser.getContext();
 
  // Mapping of domain name to port index.
  DenseMap<Attribute, size_t> domainIndex;
 
  // Mapping of port index to domain names and source locators.
  using DomainAndLoc = std::pair<Attribute, llvm::SMLoc>;
  DenseMap<size_t, SmallVector<DomainAndLoc>> domainStrings;
 
  auto parseArgument = [&]() -> ParseResult {
    // Parse port direction.
    if (succeeded(parser.parseOptionalKeyword("out")))
      portDirections.push_back(Direction::Out);
    else if (succeeded(parser.parseKeyword("in", " or 'out'")))
      portDirections.push_back(Direction::In);
    else
      return failure();
 
    // This is the location or the port declaration in the IR.  If there is no
    // other location information, we use this to point to the MLIR.
    llvm::SMLoc irLoc;
    auto portIdx = portNames.size();
 
    if (hasSSAIdentifiers) {
      OpAsmParser::Argument arg;
      if (parser.parseArgument(arg))
        return failure();
      entryArgs.push_back(arg);
 
      // The name of an argument is of the form "%42" or "%id", and since
      // parsing succeeded, we know it always has one character.
      assert(arg.ssaName.name.size() > 1 && arg.ssaName.name[0] == '%' &&
             "Unknown MLIR name");
      if (isdigit(arg.ssaName.name[1]))
        portNames.push_back(StringAttr::get(context, ""));
      else
        portNames.push_back(
            StringAttr::get(context, arg.ssaName.name.drop_front()));
 
      // Store the location of the SSA name.
      irLoc = arg.ssaName.location;
 
    } else {
      // Parse the port name.
      irLoc = parser.getCurrentLocation();
      std::string portName;
      if (parser.parseKeywordOrString(&portName))
        return failure();
      portNames.push_back(StringAttr::get(context, portName));
    }
 
    // Parse the port type.
    Type portType;
    if (parser.parseColonType(portType))
      return failure();
    portTypes.push_back(TypeAttr::get(portType));
    if (isa<DomainType>(portType))
      domainIndex[portNames.back()] = portIdx;
 
    if (hasSSAIdentifiers)
      entryArgs.back().type = portType;
 
    // Parse the optional port symbol.
    if (supportsSymbols) {
      hw::InnerSymAttr innerSymAttr;
      if (succeeded(parser.parseOptionalKeyword("sym"))) {
        NamedAttrList dummyAttrs;
        if (parser.parseCustomAttributeWithFallback(
                innerSymAttr, ::mlir::Type{},
                hw::InnerSymbolTable::getInnerSymbolAttrName(), dummyAttrs)) {
          return ::mlir::failure();
        }
      }
      portSyms.push_back(innerSymAttr);
    }
 
    // Parse optional port domain associations if they exist. Domain
    // information is now stored in the DomainType itself, so we only parse
    // associations here.
    Attribute domainInfo = ArrayAttr::get(context, {});
    if (supportsDomains) {
      if (auto domainType = dyn_cast<DomainType>(portType)) {
        // Domain type ports have no associations stored in domainInfo.
        domainInfo = ArrayAttr::get(context, {});
      } else if (succeeded(parser.parseOptionalKeyword("domains"))) {
        auto result = parser.parseCommaSeparatedList(
            OpAsmParser::Delimiter::Square, [&]() -> ParseResult {
              StringAttr argName;
              if (hasSSAIdentifiers) {
                OpAsmParser::Argument arg;
                if (parser.parseArgument(arg))
                  return failure();
                argName =
                    StringAttr::get(context, arg.ssaName.name.drop_front());
              } else {
                std::string portName;
                if (parser.parseKeywordOrString(&portName))
                  return failure();
                argName = StringAttr::get(context, portName);
              }
              domainStrings[portIdx].push_back({argName, irLoc});
              return success();
            });
        if (failed(result))
          return failure();
        // Set to nullptr to indicate this needs to be filled in later from
        // domainStrings.
        domainInfo = nullptr;
      }
    }
    domains.push_back(domainInfo);
 
    // Parse the port annotations.
    ArrayAttr annos;
    auto parseResult = parser.parseOptionalAttribute(annos);
    if (!parseResult.has_value())
      annos = parser.getBuilder().getArrayAttr({});
    else if (failed(*parseResult))
      return failure();
    portAnnotations.push_back(annos);
 
    // Parse the optional port location.
    std::optional<Location> maybeLoc;
    if (failed(parser.parseOptionalLocationSpecifier(maybeLoc)))
      return failure();
    Location loc = maybeLoc ? *maybeLoc : parser.getEncodedSourceLoc(irLoc);
    portLocs.push_back(loc);
    if (hasSSAIdentifiers)
      entryArgs.back().sourceLoc = loc;
 
    return success();
  };
 
  // Parse all ports, in two phases.  First, parse all the ports and build up
  // the information about what domains exist and the _names_ of domains
  // associated with ports.  After this, the domain information is only
  // populated for domain ports.  All associations are null.
  if (failed(parser.parseCommaSeparatedList(OpAsmParser::Delimiter::Paren,
                                            parseArgument)))
    return failure();
 
  // Second, for non-domain ports, convert the domain names to domain indices
  // and update the domain information.
  for (auto [portIdx, domainInfo] : llvm::enumerate(domains)) {
    // Domain ports _already_ have domain info.  Skip them.
    if (domainInfo)
      continue;
    // Convert domain names to domain indices for non-domain ports.
    SmallVector<Attribute> portDomains;
    for (auto [domainName, loc] : domainStrings[portIdx]) {
      auto index = domainIndex.find(domainName);
      if (index == domainIndex.end()) {
        parser.emitError(loc) << "domain name '" << domainName << "' not found";
        return failure();
      }
      portDomains.push_back(IntegerAttr::get(
          IntegerType::get(context, 32, IntegerType::Unsigned), index->second));
    }
    domains[portIdx] = parser.getBuilder().getArrayAttr(portDomains);
  }
 
  return success();
}
 
/// Print a paramter list for a module or instance.
static void printParameterList(OpAsmPrinter &p, Operation *op,
                               ArrayAttr parameters) {
  if (!parameters || parameters.empty())
    return;
 
  p << '<';
  llvm::interleaveComma(parameters, p, [&](Attribute param) {
    auto paramAttr = cast<ParamDeclAttr>(param);
    p << paramAttr.getName().getValue() << ": " << paramAttr.getType();
    if (auto value = paramAttr.getValue()) {
      p << " = ";
      p.printAttributeWithoutType(value);
    }
  });
  p << '>';
}
 
template <typename ModuleTy>
static void printFModuleLikeOp(OpAsmPrinter &p, FModuleLike op) {
  p << " ";
 
  // Print the visibility of the module.
  StringRef visibilityAttrName =
      mlir::SymbolOpInterface::getDefaultVisibilityAttrName();
  if (auto visibility = op->getAttrOfType<StringAttr>(visibilityAttrName))
    p << visibility.getValue() << ' ';
 
  // Print the operation and the function name.
  p.printSymbolName(cast<mlir::SymbolOpInterface>(op.getOperation()).getName());
 
  // Print the parameter list (if non-empty).
  printParameterList(p, op, op->getAttrOfType<ArrayAttr>("parameters"));
 
  // Both modules and external modules have a body, but it is always empty for
  // external modules.
  Block *body = nullptr;
  if (!op->getRegion(0).empty())
    body = &op->getRegion(0).front();
 
  auto needPortNamesAttr = printModulePorts(
      p, body, op.getPortDirectionsAttr(), op.getPortNames(), op.getPortTypes(),
      op.getPortAnnotations(), op.getPortSymbols(), op.getPortLocations(),
      op.getDomainInfo());
 
  SmallVector<StringRef, 13> omittedAttrs = {
      ModuleTy::getSymNameAttrName(op->getName()),
      "portDirections",
      "portTypes",
      "portAnnotations",
      "portSymbols",
      "portLocations",
      "parameters",
      visibilityAttrName,
      "domainInfo"};
 
  if (op.getConvention() == Convention::Internal)
    omittedAttrs.push_back("convention");
 
  // We can omit the portNames if they were able to be printed as properly as
  // block arguments.
  if (!needPortNamesAttr)
    omittedAttrs.push_back("portNames");
 
  // If there are no annotations we can omit the empty array.
  if (op->getAttrOfType<ArrayAttr>("annotations").empty())
    omittedAttrs.push_back("annotations");
 
  // If there are no known layers, then omit the empty array.
  if (auto knownLayers = op->getAttrOfType<ArrayAttr>("knownLayers"))
    if (knownLayers.empty())
      omittedAttrs.push_back("knownLayers");
 
  // If there are no enabled layers, then omit the empty array.
  if (auto layers = op->getAttrOfType<ArrayAttr>("layers"))
    if (layers.empty())
      omittedAttrs.push_back("layers");
 
  // If there are no external requirements, then omit the empty array.
  if (auto extReqs = op->getAttrOfType<ArrayAttr>("externalRequirements"))
    if (extReqs.empty())
      omittedAttrs.push_back("externalRequirements");
 
  p.printOptionalAttrDictWithKeyword(op->getAttrs(), omittedAttrs);
}
 
void FExtModuleOp::print(OpAsmPrinter &p) {
  printFModuleLikeOp<FExtModuleOp>(p, *this);
}
 
void FIntModuleOp::print(OpAsmPrinter &p) {
  printFModuleLikeOp<FIntModuleOp>(p, *this);
}
 
void FMemModuleOp::print(OpAsmPrinter &p) {
  printFModuleLikeOp<FMemModuleOp>(p, *this);
}
 
void FModuleOp::print(OpAsmPrinter &p) {
  printFModuleLikeOp<FModuleOp>(p, *this);
 
  // Print the body if this is not an external function. Since this block does
  // not have terminators, printing the terminator actually just prints the last
  // operation.
  Region &fbody = getBody();
  if (!fbody.empty()) {
    p << " ";
    p.printRegion(fbody, /*printEntryBlockArgs=*/false,
                  /*printBlockTerminators=*/true);
  }
}
 
/// Parse an parameter list if present.
/// module-parameter-list ::= `<` parameter-decl (`,` parameter-decl)* `>`
/// parameter-decl ::= identifier `:` type
/// parameter-decl ::= identifier `:` type `=` attribute
///
static ParseResult
parseOptionalParameters(OpAsmParser &parser,
                        SmallVectorImpl<Attribute> &parameters) {
 
  return parser.parseCommaSeparatedList(
      OpAsmParser::Delimiter::OptionalLessGreater, [&]() {
        std::string name;
        Type type;
        Attribute value;
 
        if (parser.parseKeywordOrString(&name) || parser.parseColonType(type))
          return failure();
 
        // Parse the default value if present.
        if (succeeded(parser.parseOptionalEqual())) {
          if (parser.parseAttribute(value, type))
            return failure();
        }
 
        auto &builder = parser.getBuilder();
        parameters.push_back(ParamDeclAttr::get(
            builder.getContext(), builder.getStringAttr(name), type, value));
        return success();
      });
}
 
/// Shim to use with assemblyFormat, custom<ParameterList>.
static ParseResult parseParameterList(OpAsmParser &parser,
                                      ArrayAttr &parameters) {
  SmallVector<Attribute> parseParameters;
  if (failed(parseOptionalParameters(parser, parseParameters)))
    return failure();
 
  parameters = ArrayAttr::get(parser.getContext(), parseParameters);
 
  return success();
}
 
template <typename Properties, typename = void>
struct HasParameters : std::false_type {};
 
template <typename Properties>
struct HasParameters<
    Properties, std::void_t<decltype(std::declval<Properties>().parameters)>>
    : std::true_type {};
 
template <typename OpTy>
static ParseResult parseFModuleLikeOp(OpAsmParser &parser,
                                      OperationState &result,
                                      bool hasSSAIdentifiers) {
  auto *context = result.getContext();
  auto &builder = parser.getBuilder();
  using Properties = typename OpTy::Properties;
  auto &properties = result.getOrAddProperties<Properties>();
 
  // TODO: this should be using properties.
  // Parse the visibility attribute.
  (void)mlir::impl::parseOptionalVisibilityKeyword(parser, result.attributes);
 
  // Parse the name as a symbol.
  StringAttr nameAttr;
  if (parser.parseSymbolName(nameAttr))
    return failure();
  properties.setSymName(nameAttr);
 
  // Parse optional parameters.
  if constexpr (HasParameters<Properties>::value) {
    SmallVector<Attribute, 4> parameters;
    if (parseOptionalParameters(parser, parameters))
      return failure();
    properties.setParameters(builder.getArrayAttr(parameters));
  }
 
  // Parse the module ports.
  SmallVector<OpAsmParser::Argument> entryArgs;
  SmallVector<Direction, 4> portDirections;
  SmallVector<Attribute, 4> portNames;
  SmallVector<Attribute, 4> portTypes;
  SmallVector<Attribute, 4> portAnnotations;
  SmallVector<Attribute, 4> portSyms;
  SmallVector<Attribute, 4> portLocs;
  SmallVector<Attribute, 4> domains;
  if (parseModulePorts(parser, hasSSAIdentifiers, /*supportsSymbols=*/true,
                       /*supportsDomains=*/true, entryArgs, portDirections,
                       portNames, portTypes, portAnnotations, portSyms,
                       portLocs, domains))
    return failure();
 
  // If module attributes are present, parse them.
  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
    return failure();
 
  assert(portNames.size() == portTypes.size());
 
  // Record the argument and result types as an attribute.  This is necessary
  // for external modules.
 
  // Add port directions.
  properties.setPortDirections(
      direction::packAttribute(context, portDirections));
 
  // Add port names.
  properties.setPortNames(builder.getArrayAttr(portNames));
 
  // Add the port types.
  properties.setPortTypes(ArrayAttr::get(context, portTypes));
 
  // Add the port annotations.
  // If there are no portAnnotations, don't add the attribute.
  if (llvm::any_of(portAnnotations, [&](Attribute anno) {
        return !cast<ArrayAttr>(anno).empty();
      }))
    properties.setPortAnnotations(ArrayAttr::get(context, portAnnotations));
  else
    properties.setPortAnnotations(builder.getArrayAttr({}));
 
  // Add port symbols.
  FModuleLike::fixupPortSymsArray(portSyms, builder.getContext());
  properties.setPortSymbols(builder.getArrayAttr(portSyms));
 
  // Add port locations.
  properties.setPortLocations(ArrayAttr::get(context, portLocs));
 
  // The annotations attribute is always present, but not printed when empty.
  properties.setAnnotations(builder.getArrayAttr({}));
 
  // Add domains.  Use an empty array if none are set.
  if (llvm::all_of(domains, [&](Attribute attr) {
        auto arrayAttr = dyn_cast<ArrayAttr>(attr);
        return arrayAttr && arrayAttr.empty();
      }))
    properties.setDomainInfo(ArrayAttr::get(context, {}));
  else
    properties.setDomainInfo(ArrayAttr::get(context, domains));
 
  // Parse the optional function body.
  auto *body = result.addRegion();
 
  if (hasSSAIdentifiers) {
    if (parser.parseRegion(*body, entryArgs))
      return failure();
    if (body->empty())
      body->push_back(new Block());
  }
  return success();
}
 
ParseResult FModuleOp::parse(OpAsmParser &parser, OperationState &result) {
  if (parseFModuleLikeOp<FModuleOp>(parser, result,
                                    /*hasSSAIdentifiers=*/true))
    return failure();
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setConvention(
      ConventionAttr::get(result.getContext(), Convention::Internal));
  properties.setLayers(ArrayAttr::get(parser.getContext(), {}));
  return success();
}
 
ParseResult FExtModuleOp::parse(OpAsmParser &parser, OperationState &result) {
  if (parseFModuleLikeOp<FExtModuleOp>(parser, result,
                                       /*hasSSAIdentifiers=*/false))
    return failure();
  auto &properties = result.getOrAddProperties<Properties>();
  properties.setConvention(
      ConventionAttr::get(result.getContext(), Convention::Internal));
  properties.setKnownLayers(ArrayAttr::get(result.getContext(), {}));
  return success();
}
 
ParseResult FIntModuleOp::parse(OpAsmParser &parser, OperationState &result) {
  return parseFModuleLikeOp<FIntModuleOp>(parser, result,
                                          /*hasSSAIdentifiers=*/false);
}
 
ParseResult FMemModuleOp::parse(OpAsmParser &parser, OperationState &result) {
  return parseFModuleLikeOp<FMemModuleOp>(parser, result,
                                          /*hasSSAIdentifiers=*/false);
}
 
LogicalResult FModuleOp::verify() {
  // Verify the block arguments.
  auto *body = getBodyBlock();
  auto portTypes = getPortTypes();
  auto portLocs = getPortLocations();
  auto numPorts = portTypes.size();
 
  // Verify that we have the correct number of block arguments.
  if (body->getNumArguments() != numPorts)
    return emitOpError("entry block must have ")
           << numPorts << " arguments to match module signature";
 
  // Verify the block arguments' types and locations match our attributes.
  for (auto [arg, type, loc] : zip(body->getArguments(), portTypes, portLocs)) {
    if (arg.getType() != cast<TypeAttr>(type).getValue())
      return emitOpError("block argument types should match signature types");
    if (arg.getLoc() != cast<LocationAttr>(loc))
      return emitOpError(
          "block argument locations should match signature locations");
  }
 
  return success();
}
 
LogicalResult FExtModuleOp::verify() {
  auto params = getParameters();
 
  auto checkParmValue = [&](Attribute elt) -> bool {
    auto param = cast<ParamDeclAttr>(elt);
    auto value = param.getValue();
    if (isa<IntegerAttr, StringAttr, FloatAttr, hw::ParamVerbatimAttr>(value))
      return true;
    emitError() << "has unknown extmodule parameter value '"
                << param.getName().getValue() << "' = " << value;
    return false;
  };
 
  if (!llvm::all_of(params, checkParmValue))
    return failure();
 
  // Verify that any mentioned layers are marked as known.
  LayerSet known;
  known.insert_range(getKnownLayersAttr().getAsRange<SymbolRefAttr>());
 
  LayerSet referenced;
  referenced.insert_range(getLayersAttr().getAsRange<SymbolRefAttr>());
  for (auto attr : getPortTypes()) {
    auto type = cast<TypeAttr>(attr).getValue();
    if (auto refType = type_dyn_cast<RefType>(type))
      if (auto layer = refType.getLayer())
        referenced.insert(layer);
  }
 
  return checkLayerCompatibility(getOperation(), referenced, known,
                                 "references unknown layers", "unknown layers");
}
 
LogicalResult FIntModuleOp::verify() {
  auto params = getParameters();
  if (params.empty())
    return success();
 
  auto checkParmValue = [&](Attribute elt) -> bool {
    auto param = cast<ParamDeclAttr>(elt);
    auto value = param.getValue();
    if (isa<IntegerAttr, StringAttr, FloatAttr>(value))
      return true;
    emitError() << "has unknown intmodule parameter value '"
                << param.getName().getValue() << "' = " << value;
    return false;
  };
 
  if (!llvm::all_of(params, checkParmValue))
    return failure();
 
  return success();
}
 
static LogicalResult verifyProbeType(RefType refType, Location loc,
                                     CircuitOp circuitOp,
                                     SymbolTableCollection &symbolTable,
                                     Twine start) {
  auto layer = refType.getLayer();
  if (!layer)
    return success();
  auto *layerOp = symbolTable.lookupSymbolIn(circuitOp, layer);
  if (!layerOp)
    return emitError(loc) << start << " associated with layer '" << layer
                          << "', but this layer was not defined";
  if (!isa<LayerOp>(layerOp)) {
    auto diag = emitError(loc)
                << start << " associated with layer '" << layer
                << "', but symbol '" << layer << "' does not refer to a '"
                << LayerOp::getOperationName() << "' op";
    return diag.attachNote(layerOp->getLoc()) << "symbol refers to this op";
  }
  return success();
}
 
static LogicalResult verifyPortSymbolUses(FModuleLike module,
                                          SymbolTableCollection &symbolTable) {
  // verify types in ports.
  auto circuitOp = module->getParentOfType<CircuitOp>();
  for (size_t i = 0, e = module.getNumPorts(); i < e; ++i) {
    auto type = module.getPortType(i);
 
    if (auto refType = type_dyn_cast<RefType>(type)) {
      if (failed(verifyProbeType(
              refType, module.getPortLocation(i), circuitOp, symbolTable,
              Twine("probe port '") + module.getPortName(i) + "' is")))
        return failure();
      continue;
    }
 
    if (auto classType = dyn_cast<ClassType>(type)) {
      auto className = classType.getNameAttr();
      auto classOp = dyn_cast_or_null<ClassLike>(
          symbolTable.lookupSymbolIn(circuitOp, className));
      if (!classOp)
        return module.emitOpError() << "references unknown class " << className;
 
      // verify that the result type agrees with the class definition.
      if (failed(classOp.verifyType(classType,
                                    [&]() { return module.emitOpError(); })))
        return failure();
      continue;
    }
 
    if (auto domainType = dyn_cast<DomainType>(type)) {
      if (failed(
              domainType.verifySymbolUses(module.getOperation(), symbolTable)))
        return failure();
      continue;
    }
  }
 
  return success();
}
 
LogicalResult FModuleOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  if (failed(verifyPortSymbolUses(*this, symbolTable)))
    return failure();
 
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  for (auto layer : getLayers()) {
    if (!symbolTable.lookupSymbolIn(circuitOp, cast<SymbolRefAttr>(layer)))
      return emitOpError() << "enables undefined layer '" << layer << "'";
  }
 
  return success();
}
 
LogicalResult
FExtModuleOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  if (failed(verifyPortSymbolUses(*this, symbolTable)))
    return failure();
 
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  for (auto layer : getKnownLayersAttr().getAsRange<SymbolRefAttr>()) {
    if (!symbolTable.lookupSymbolIn(circuitOp, layer))
      return emitOpError() << "knows undefined layer '" << layer << "'";
  }
  for (auto layer : getLayersAttr().getAsRange<SymbolRefAttr>()) {
    if (!symbolTable.lookupSymbolIn(circuitOp, layer))
      return emitOpError() << "enables undefined layer '" << layer << "'";
  }
 
  return success();
}
 
LogicalResult
FIntModuleOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  return verifyPortSymbolUses(*this, symbolTable);
}
 
LogicalResult
FMemModuleOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  return verifyPortSymbolUses(*this, symbolTable);
}
 
void FModuleOp::getAsmBlockArgumentNames(mlir::Region &region,
                                         mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
void FExtModuleOp::getAsmBlockArgumentNames(
    mlir::Region &region, mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
StringAttr FExtModuleOp::getExtModuleNameAttr() {
  if (auto defnameAttr = getDefnameAttr(); defnameAttr && !defnameAttr.empty())
    return defnameAttr;
  return getNameAttr();
}
 
StringRef FExtModuleOp::getExtModuleName() {
  if (auto defname = getDefname(); defname && !defname->empty())
    return *defname;
  return getName();
}
 
void FIntModuleOp::getAsmBlockArgumentNames(
    mlir::Region &region, mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
void FMemModuleOp::getAsmBlockArgumentNames(
    mlir::Region &region, mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
ArrayAttr FMemModuleOp::getParameters() { return {}; }
 
ArrayAttr FModuleOp::getParameters() { return {}; }
 
Convention FIntModuleOp::getConvention() { return Convention::Internal; }
 
ConventionAttr FIntModuleOp::getConventionAttr() {
  return ConventionAttr::get(getContext(), getConvention());
}
 
Convention FMemModuleOp::getConvention() { return Convention::Internal; }
 
ConventionAttr FMemModuleOp::getConventionAttr() {
  return ConventionAttr::get(getContext(), getConvention());
}
 
//===----------------------------------------------------------------------===//
// ClassLike Helpers
//===----------------------------------------------------------------------===//
 
LogicalResult firrtl::detail::verifyTypeAgainstClassLike(
    ClassLike classOp, ClassType type,
    function_ref<InFlightDiagnostic()> emitError) {
  // This check is probably not required, but done for sanity.
  auto name = type.getNameAttr().getAttr();
  auto expectedName = classOp.getModuleNameAttr();
  if (name != expectedName)
    return emitError() << "type has wrong name, got " << name << ", expected "
                       << expectedName;
 
  auto elements = type.getElements();
  auto numElements = elements.size();
  auto expectedNumElements = classOp.getNumPorts();
  if (numElements != expectedNumElements)
    return emitError() << "has wrong number of ports, got " << numElements
                       << ", expected " << expectedNumElements;
 
  auto portNames = classOp.getPortNames();
  auto portDirections = classOp.getPortDirections();
  auto portTypes = classOp.getPortTypes();
 
  for (unsigned i = 0; i < numElements; ++i) {
    auto element = elements[i];
 
    auto name = element.name;
    auto expectedName = portNames[i];
    if (name != expectedName)
      return emitError() << "port #" << i << " has wrong name, got " << name
                         << ", expected " << expectedName;
 
    auto direction = element.direction;
    auto expectedDirection = Direction(portDirections[i]);
    if (direction != expectedDirection)
      return emitError() << "port " << name << " has wrong direction, got "
                         << direction::toString(direction) << ", expected "
                         << direction::toString(expectedDirection);
 
    auto type = element.type;
    auto expectedType = cast<TypeAttr>(portTypes[i]).getValue();
    if (type != expectedType)
      return emitError() << "port " << name << " has wrong type, got " << type
                         << ", expected " << expectedType;
  }
 
  return success();
}
 
ClassType firrtl::detail::getInstanceTypeForClassLike(ClassLike classOp) {
  auto n = classOp.getNumPorts();
  SmallVector<ClassElement> elements;
  elements.reserve(n);
  for (size_t i = 0; i < n; ++i)
    elements.push_back({classOp.getPortNameAttr(i), classOp.getPortType(i),
                        classOp.getPortDirection(i)});
  auto name = FlatSymbolRefAttr::get(classOp.getModuleNameAttr());
  return ClassType::get(name, elements);
}
 
template <typename OpTy>
ParseResult parseClassLike(OpAsmParser &parser, OperationState &result,
                           bool hasSSAIdentifiers) {
  auto *context = result.getContext();
  auto &builder = parser.getBuilder();
  auto &properties = result.getOrAddProperties<typename OpTy::Properties>();
 
  // TODO: this should use properties.
  // Parse the visibility attribute.
  (void)mlir::impl::parseOptionalVisibilityKeyword(parser, result.attributes);
 
  // Parse the name as a symbol.
  StringAttr nameAttr;
  if (parser.parseSymbolName(nameAttr))
    return failure();
  properties.setSymName(nameAttr);
 
  // Parse the module ports.
  SmallVector<OpAsmParser::Argument> entryArgs;
  SmallVector<Direction, 4> portDirections;
  SmallVector<Attribute, 4> portNames;
  SmallVector<Attribute, 4> portTypes;
  SmallVector<Attribute, 4> portAnnotations;
  SmallVector<Attribute, 4> portSyms;
  SmallVector<Attribute, 4> portLocs;
  SmallVector<Attribute, 4> domains;
  if (parseModulePorts(parser, hasSSAIdentifiers,
                       /*supportsSymbols=*/false, /*supportsDomains=*/false,
                       entryArgs, portDirections, portNames, portTypes,
                       portAnnotations, portSyms, portLocs, domains))
    return failure();
 
  // Ports on ClassLike ops cannot have annotations
  for (auto annos : portAnnotations)
    if (!cast<ArrayAttr>(annos).empty())
      return failure();
 
  // If attributes are present, parse them.
  if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
    return failure();
 
  assert(portNames.size() == portTypes.size());
 
  // Record the argument and result types as an attribute.  This is necessary
  // for external modules.
 
  // Add port directions.
  properties.setPortDirections(
      direction::packAttribute(context, portDirections));
 
  // Add port names.
  properties.setPortNames(builder.getArrayAttr(portNames));
 
  // Add the port types.
  properties.setPortTypes(builder.getArrayAttr(portTypes));
 
  // Add the port symbols.
  FModuleLike::fixupPortSymsArray(portSyms, builder.getContext());
  properties.setPortSymbols(builder.getArrayAttr(portSyms));
 
  // Add port locations.
  properties.setPortLocations(ArrayAttr::get(context, portLocs));
 
  // Notably missing compared to other FModuleLike, we do not track port
  // annotations, nor port symbols, on classes.
 
  // Add the region (unused by extclass).
  auto *bodyRegion = result.addRegion();
 
  if (hasSSAIdentifiers) {
    if (parser.parseRegion(*bodyRegion, entryArgs))
      return failure();
    if (bodyRegion->empty())
      bodyRegion->push_back(new Block());
  }
 
  return success();
}
 
template <typename ClassTy>
static void printClassLike(OpAsmPrinter &p, ClassLike op) {
  p << ' ';
 
  // Print the visibility of the class.
  StringRef visibilityAttrName =
      mlir::SymbolOpInterface::getDefaultVisibilityAttrName();
  if (auto visibility = op->getAttrOfType<StringAttr>(visibilityAttrName))
    p << visibility.getValue() << ' ';
 
  // Print the class name.
  p.printSymbolName(cast<mlir::SymbolOpInterface>(op.getOperation()).getName());
 
  // Both classes and external classes have a body, but it is always empty for
  // external classes.
  Region &region = op->getRegion(0);
  Block *body = nullptr;
  if (!region.empty())
    body = &region.front();
 
  auto needPortNamesAttr = printModulePorts(
      p, body, op.getPortDirectionsAttr(), op.getPortNames(), op.getPortTypes(),
      {}, op.getPortSymbols(), op.getPortLocations(), {});
 
  // Print the attr-dict.
  SmallVector<StringRef, 8> omittedAttrs = {
      ClassTy::getSymNameAttrName(op->getName()),
      "portNames",
      "portTypes",
      "portDirections",
      "portSymbols",
      "portLocations",
      visibilityAttrName,
      "domainInfo"};
 
  // We can omit the portNames if they were able to be printed as properly as
  // block arguments.
  if (!needPortNamesAttr)
    omittedAttrs.push_back("portNames");
 
  p.printOptionalAttrDictWithKeyword(op->getAttrs(), omittedAttrs);
 
  // print the body if it exists.
  if (!region.empty()) {
    p << " ";
    auto printEntryBlockArgs = false;
    auto printBlockTerminators = false;
    p.printRegion(region, printEntryBlockArgs, printBlockTerminators);
  }
}
 
//===----------------------------------------------------------------------===//
// ClassOp
//===----------------------------------------------------------------------===//
 
void ClassOp::build(OpBuilder &builder, OperationState &result, StringAttr name,
                    ArrayRef<PortInfo> ports) {
  assert(
      llvm::all_of(ports,
                   [](const auto &port) { return port.annotations.empty(); }) &&
      "class ports may not have annotations");
 
  buildClass<ClassOp>(builder, result, name, ports);
 
  // Create a region and a block for the body.
  auto *bodyRegion = result.regions[0].get();
  Block *body = new Block();
  bodyRegion->push_back(body);
 
  // Add arguments to the body block.
  for (auto &elt : ports)
    body->addArgument(elt.type, elt.loc);
}
 
void ClassOp::build(::mlir::OpBuilder &odsBuilder,
                    ::mlir::OperationState &odsState, Twine name,
                    mlir::ArrayRef<mlir::StringRef> fieldNames,
                    mlir::ArrayRef<mlir::Type> fieldTypes) {
 
  SmallVector<PortInfo, 10> ports;
  ports.reserve(fieldNames.size() * 2);
  for (auto [fieldName, fieldType] : llvm::zip(fieldNames, fieldTypes)) {
    ports.emplace_back(odsBuilder.getStringAttr(fieldName + "_in"), fieldType,
                       Direction::In);
    ports.emplace_back(odsBuilder.getStringAttr(fieldName), fieldType,
                       Direction::Out);
  }
  build(odsBuilder, odsState, odsBuilder.getStringAttr(name), ports);
  // Create a region and a block for the body.
  auto &body = odsState.regions[0]->getBlocks().front();
  auto prevLoc = odsBuilder.saveInsertionPoint();
  odsBuilder.setInsertionPointToEnd(&body);
  auto args = body.getArguments();
  auto loc = odsState.location;
  for (unsigned i = 0, e = ports.size(); i != e; i += 2)
    PropAssignOp::create(odsBuilder, loc, args[i + 1], args[i]);
 
  odsBuilder.restoreInsertionPoint(prevLoc);
}
void ClassOp::print(OpAsmPrinter &p) {
  printClassLike<ClassOp>(p, cast<ClassLike>(getOperation()));
}
 
ParseResult ClassOp::parse(OpAsmParser &parser, OperationState &result) {
  auto hasSSAIdentifiers = true;
  return parseClassLike<ClassOp>(parser, result, hasSSAIdentifiers);
}
 
LogicalResult ClassOp::verify() {
  for (auto operand : getBodyBlock()->getArguments()) {
    auto type = operand.getType();
    if (!isa<PropertyType>(type)) {
      emitOpError("ports on a class must be properties");
      return failure();
    }
  }
 
  return success();
}
 
LogicalResult
ClassOp::verifySymbolUses(::mlir::SymbolTableCollection &symbolTable) {
  return verifyPortSymbolUses(cast<FModuleLike>(getOperation()), symbolTable);
}
 
void ClassOp::getAsmBlockArgumentNames(mlir::Region &region,
                                       mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
SmallVector<PortInfo> ClassOp::getPorts() {
  return ::getPortImpl(cast<FModuleLike>((Operation *)*this));
}
 
void ClassOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
  getBodyBlock()->eraseArguments(portIndices);
}
 
void ClassOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
}
 
Convention ClassOp::getConvention() { return Convention::Internal; }
 
ConventionAttr ClassOp::getConventionAttr() {
  return ConventionAttr::get(getContext(), getConvention());
}
 
ArrayAttr ClassOp::getParameters() { return {}; }
 
ArrayAttr ClassOp::getPortAnnotationsAttr() {
  return ArrayAttr::get(getContext(), {});
}
 
ArrayRef<Attribute> ClassOp::getPortAnnotations() { return {}; }
 
void ClassOp::setPortAnnotationsAttr(ArrayAttr annotations) {
  llvm_unreachable("classes do not support annotations");
}
 
ArrayAttr ClassOp::getLayersAttr() { return ArrayAttr::get(getContext(), {}); }
 
ArrayRef<Attribute> ClassOp::getLayers() { return {}; }
 
SmallVector<::circt::hw::PortInfo> ClassOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
::circt::hw::PortInfo ClassOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
BlockArgument ClassOp::getArgument(size_t portNumber) {
  return getBodyBlock()->getArgument(portNumber);
}
 
bool ClassOp::canDiscardOnUseEmpty() {
  // ClassOps are referenced by ClassTypes, and these uses are not
  // discoverable by the symbol infrastructure. Return false here to prevent
  // passes like symbolDCE from removing our classes.
  return false;
}
 
//===----------------------------------------------------------------------===//
// ExtClassOp
//===----------------------------------------------------------------------===//
 
void ExtClassOp::build(OpBuilder &builder, OperationState &result,
                       StringAttr name, ArrayRef<PortInfo> ports) {
  assert(
      llvm::all_of(ports,
                   [](const auto &port) { return port.annotations.empty(); }) &&
      "class ports may not have annotations");
  buildClass<ExtClassOp>(builder, result, name, ports);
}
 
void ExtClassOp::print(OpAsmPrinter &p) {
  printClassLike<ExtClassOp>(p, cast<ClassLike>(getOperation()));
}
 
ParseResult ExtClassOp::parse(OpAsmParser &parser, OperationState &result) {
  auto hasSSAIdentifiers = false;
  return parseClassLike<ExtClassOp>(parser, result, hasSSAIdentifiers);
}
 
LogicalResult
ExtClassOp::verifySymbolUses(::mlir::SymbolTableCollection &symbolTable) {
  return verifyPortSymbolUses(cast<FModuleLike>(getOperation()), symbolTable);
}
 
void ExtClassOp::getAsmBlockArgumentNames(mlir::Region &region,
                                          mlir::OpAsmSetValueNameFn setNameFn) {
  getAsmBlockArgumentNamesImpl(getOperation(), region, setNameFn);
}
 
SmallVector<PortInfo> ExtClassOp::getPorts() {
  return ::getPortImpl(cast<FModuleLike>((Operation *)*this));
}
 
void ExtClassOp::erasePorts(const llvm::BitVector &portIndices) {
  ::erasePorts(cast<FModuleLike>((Operation *)*this), portIndices);
}
 
void ExtClassOp::insertPorts(ArrayRef<std::pair<unsigned, PortInfo>> ports) {
  ::insertPorts(cast<FModuleLike>((Operation *)*this), ports);
}
 
Convention ExtClassOp::getConvention() { return Convention::Internal; }
 
ConventionAttr ExtClassOp::getConventionAttr() {
  return ConventionAttr::get(getContext(), getConvention());
}
 
ArrayAttr ExtClassOp::getLayersAttr() {
  return ArrayAttr::get(getContext(), {});
}
 
ArrayRef<Attribute> ExtClassOp::getLayers() { return {}; }
 
ArrayAttr ExtClassOp::getParameters() { return {}; }
 
ArrayAttr ExtClassOp::getPortAnnotationsAttr() {
  return ArrayAttr::get(getContext(), {});
}
 
ArrayRef<Attribute> ExtClassOp::getPortAnnotations() { return {}; }
 
void ExtClassOp::setPortAnnotationsAttr(ArrayAttr annotations) {
  llvm_unreachable("classes do not support annotations");
}
 
SmallVector<::circt::hw::PortInfo> ExtClassOp::getPortList() {
  return ::getPortListImpl(*this);
}
 
::circt::hw::PortInfo ExtClassOp::getPort(size_t idx) {
  return ::getPortImpl(*this, idx);
}
 
bool ExtClassOp::canDiscardOnUseEmpty() {
  // ClassOps are referenced by ClassTypes, and these uses are not
  // discovereable by the symbol infrastructure. Return false here to prevent
  // passes like symbolDCE from removing our classes.
  return false;
}
 
//===----------------------------------------------------------------------===//
// InstanceOp
//===----------------------------------------------------------------------===//
 
void InstanceOp::build(
    OpBuilder &builder, OperationState &result, TypeRange resultTypes,
    StringRef moduleName, StringRef name, NameKindEnum nameKind,
    ArrayRef<Direction> portDirections, ArrayRef<Attribute> portNames,
    ArrayRef<Attribute> domainInfo, ArrayRef<Attribute> annotations,
    ArrayRef<Attribute> portAnnotations, ArrayRef<Attribute> layers,
    bool lowerToBind, bool doNotPrint, StringAttr innerSym) {
  build(builder, result, resultTypes, moduleName, name, nameKind,
        portDirections, portNames, domainInfo, annotations, portAnnotations,
        layers, lowerToBind, doNotPrint,
        innerSym ? hw::InnerSymAttr::get(innerSym) : hw::InnerSymAttr());
}
 
void InstanceOp::build(
    OpBuilder &builder, OperationState &result, TypeRange resultTypes,
    StringRef moduleName, StringRef name, NameKindEnum nameKind,
    ArrayRef<Direction> portDirections, ArrayRef<Attribute> portNames,
    ArrayRef<Attribute> domainInfo, ArrayRef<Attribute> annotations,
    ArrayRef<Attribute> portAnnotations, ArrayRef<Attribute> layers,
    bool lowerToBind, bool doNotPrint, hw::InnerSymAttr innerSym) {
  result.addTypes(resultTypes);
  result.getOrAddProperties<Properties>().setModuleName(
      SymbolRefAttr::get(builder.getContext(), moduleName));
  result.getOrAddProperties<Properties>().setName(builder.getStringAttr(name));
  result.getOrAddProperties<Properties>().setPortDirections(
      direction::packAttribute(builder.getContext(), portDirections));
  result.getOrAddProperties<Properties>().setPortNames(
      builder.getArrayAttr(portNames));
 
  if (domainInfo.empty()) {
    SmallVector<Attribute, 16> domainInfoVec(resultTypes.size(),
                                             builder.getArrayAttr({}));
    result.getOrAddProperties<Properties>().setDomainInfo(
        builder.getArrayAttr(domainInfoVec));
  } else {
    assert(domainInfo.size() == resultTypes.size());
    result.getOrAddProperties<Properties>().setDomainInfo(
        builder.getArrayAttr(domainInfo));
  }
 
  result.getOrAddProperties<Properties>().setAnnotations(
      builder.getArrayAttr(annotations));
  result.getOrAddProperties<Properties>().setLayers(
      builder.getArrayAttr(layers));
  if (lowerToBind)
    result.getOrAddProperties<Properties>().setLowerToBind(
        builder.getUnitAttr());
  if (doNotPrint)
    result.getOrAddProperties<Properties>().setDoNotPrint(
        builder.getUnitAttr());
  if (innerSym)
    result.getOrAddProperties<Properties>().setInnerSym(innerSym);
 
  result.getOrAddProperties<Properties>().setNameKind(
      NameKindEnumAttr::get(builder.getContext(), nameKind));
 
  if (portAnnotations.empty()) {
    SmallVector<Attribute, 16> portAnnotationsVec(resultTypes.size(),
                                                  builder.getArrayAttr({}));
    result.getOrAddProperties<Properties>().setPortAnnotations(
        builder.getArrayAttr(portAnnotationsVec));
  } else {
    assert(portAnnotations.size() == resultTypes.size());
    result.getOrAddProperties<Properties>().setPortAnnotations(
        builder.getArrayAttr(portAnnotations));
  }
}
 
void InstanceOp::build(OpBuilder &builder, OperationState &result,
                       FModuleLike module, StringRef name,
                       NameKindEnum nameKind, ArrayRef<Attribute> annotations,
                       ArrayRef<Attribute> portAnnotations, bool lowerToBind,
                       bool doNotPrint, hw::InnerSymAttr innerSym) {
 
  // Gather the result types.
  SmallVector<Type> resultTypes;
  resultTypes.reserve(module.getNumPorts());
  llvm::transform(
      module.getPortTypes(), std::back_inserter(resultTypes),
      [](Attribute typeAttr) { return cast<TypeAttr>(typeAttr).getValue(); });
 
  // The storage for annotations and domains on the module uses an empty array
  // if there are no annotations or domains.  However, the instance op always
  // stores one-array-per-port.  Do this massaging here.
  ArrayAttr portAnnotationsAttr;
  if (portAnnotations.empty()) {
    portAnnotationsAttr = builder.getArrayAttr(SmallVector<Attribute, 16>(
        resultTypes.size(), builder.getArrayAttr({})));
  } else {
    portAnnotationsAttr = builder.getArrayAttr(portAnnotations);
  }
  ArrayAttr domainInfoAttr = module.getDomainInfoAttr();
  if (domainInfoAttr.empty()) {
    domainInfoAttr = builder.getArrayAttr(SmallVector<Attribute, 16>(
        resultTypes.size(), builder.getArrayAttr({})));
  }
 
  return build(
      builder, result, resultTypes,
      SymbolRefAttr::get(builder.getContext(), module.getModuleNameAttr()),
      builder.getStringAttr(name),
      NameKindEnumAttr::get(builder.getContext(), nameKind),
      module.getPortDirectionsAttr(), module.getPortNamesAttr(), domainInfoAttr,
      builder.getArrayAttr(annotations), portAnnotationsAttr,
      module.getLayersAttr(), lowerToBind ? builder.getUnitAttr() : UnitAttr(),
      doNotPrint ? builder.getUnitAttr() : UnitAttr(), innerSym);
}
 
void InstanceOp::build(OpBuilder &builder, OperationState &odsState,
                       ArrayRef<PortInfo> ports, StringRef moduleName,
                       StringRef name, NameKindEnum nameKind,
                       ArrayRef<Attribute> annotations,
                       ArrayRef<Attribute> layers, bool lowerToBind,
                       bool doNotPrint, hw::InnerSymAttr innerSym) {
  // Gather the result types.
  SmallVector<Type> newResultTypes;
  SmallVector<Direction> newPortDirections;
  SmallVector<Attribute> newPortNames, newPortAnnotations, newDomainInfo;
  newResultTypes.reserve(ports.size());
  newPortDirections.reserve(ports.size());
  newPortNames.reserve(ports.size());
  newPortAnnotations.reserve(ports.size());
  newDomainInfo.reserve(ports.size());
 
  for (auto &p : ports) {
    newResultTypes.push_back(p.type);
    newPortDirections.push_back(p.direction);
    newPortNames.push_back(p.name);
    newPortAnnotations.push_back(p.annotations.getArrayAttr());
    if (p.domains)
      newDomainInfo.push_back(p.domains);
    else
      newDomainInfo.push_back(builder.getArrayAttr({}));
  }
 
  return build(builder, odsState, newResultTypes, moduleName, name, nameKind,
               newPortDirections, newPortNames, newDomainInfo, annotations,
               newPortAnnotations, layers, lowerToBind, doNotPrint, innerSym);
}
 
LogicalResult InstanceOp::verify() {
  // The instance may only be instantiated under its required layers.
  auto ambientLayers = getAmbientLayersAt(getOperation());
  SmallVector<SymbolRefAttr> missingLayers;
  for (auto layer : getLayersAttr().getAsRange<SymbolRefAttr>())
    if (!isLayerCompatibleWith(layer, ambientLayers))
      missingLayers.push_back(layer);
 
  if (missingLayers.empty())
    return success();
 
  auto diag =
      emitOpError("ambient layers are insufficient to instantiate module");
  auto &note = diag.attachNote();
  note << "missing layer requirements: ";
  interleaveComma(missingLayers, note);
  return failure();
}
 
static void replaceUsesRespectingInsertedPorts(
    Operation *op1, Operation *op2,
    ArrayRef<std::pair<unsigned, PortInfo>> insertions) {
  assert(op1 != op2);
  size_t n = insertions.size();
  size_t inserted = 0;
  for (size_t i = 0, e = op1->getNumResults(); i < e; ++i) {
    while (inserted < n) {
      auto &[index, portInfo] = insertions[inserted];
      if (i < index)
        break;
      ++inserted;
    }
    auto r1 = op1->getResult(i);
    auto r2 = op2->getResult(i + inserted);
    r1.replaceAllUsesWith(r2);
  }
}
 
static void replaceUsesRespectingErasedPorts(Operation *op1, Operation *op2,
                                             const llvm::BitVector &erasures) {
  assert(op1 != op2);
  size_t erased = 0;
  for (size_t i = 0, e = op1->getNumResults(); i < e; ++i) {
    auto r1 = op1->getResult(i);
    if (erasures[i]) {
      assert(r1.use_empty() && "removed instance port has uses");
      ++erased;
      continue;
    }
    auto r2 = op2->getResult(i - erased);
    r1.replaceAllUsesWith(r2);
  }
}
 
FInstanceLike
InstanceOp::cloneWithErasedPorts(const llvm::BitVector &erasures) {
  assert(erasures.size() >= getNumResults() &&
         "erasures is not at least as large as getNumResults()");
 
  SmallVector<Type> newResultTypes = removeElementsAtIndices<Type>(
      SmallVector<Type>(result_type_begin(), result_type_end()), erasures);
  SmallVector<Direction> newPortDirections = removeElementsAtIndices<Direction>(
      direction::unpackAttribute(getPortDirectionsAttr()), erasures);
  SmallVector<Attribute> newPortNames =
      removeElementsAtIndices(getPortNames().getValue(), erasures);
  SmallVector<Attribute> newPortAnnotations =
      removeElementsAtIndices(getPortAnnotations().getValue(), erasures);
  ArrayAttr newDomainInfo =
      fixDomainInfoDeletions(getContext(), getDomainInfoAttr(), erasures,
                             /*supportsEmptyAttr=*/false);
 
  OpBuilder builder(*this);
  auto clone = InstanceOp::create(
      builder, getLoc(), newResultTypes, getModuleName(), getName(),
      getNameKind(), newPortDirections, newPortNames, newDomainInfo.getValue(),
      getAnnotations().getValue(), newPortAnnotations, getLayers(),
      getLowerToBind(), getDoNotPrint(), getInnerSymAttr());
 
  if (auto outputFile = (*this)->getAttr("output_file"))
    clone->setAttr("output_file", outputFile);
 
  return clone;
}
 
FInstanceLike InstanceOp::cloneWithErasedPortsAndReplaceUses(
    const llvm::BitVector &erasures) {
  auto clone = cloneWithErasedPorts(erasures);
  replaceUsesRespectingErasedPorts(getOperation(), clone, erasures);
  return clone;
}
 
ArrayAttr InstanceOp::getPortAnnotation(unsigned portIdx) {
  assert(portIdx < getNumResults() &&
         "index should be smaller than result number");
  return cast<ArrayAttr>(getPortAnnotations()[portIdx]);
}
 
void InstanceOp::setAllPortAnnotations(ArrayRef<Attribute> annotations) {
  assert(annotations.size() == getNumResults() &&
         "number of annotations is not equal to result number");
  (*this)->setAttr("portAnnotations",
                   ArrayAttr::get(getContext(), annotations));
}
 
FInstanceLike InstanceOp::cloneWithInsertedPorts(
    ArrayRef<std::pair<unsigned, PortInfo>> insertions) {
  auto *context = getContext();
  auto empty = ArrayAttr::get(context, {});
 
  auto oldPortCount = getNumResults();
  auto numInsertions = insertions.size();
  auto newPortCount = oldPortCount + numInsertions;
 
  SmallVector<Direction> newPortDirections;
  SmallVector<Attribute> newPortNames;
  SmallVector<Type> newPortTypes;
  SmallVector<Attribute> newPortAnnos;
  SmallVector<Attribute> newDomainInfo;
 
  newPortDirections.reserve(newPortCount);
  newPortNames.reserve(newPortCount);
  newPortTypes.reserve(newPortCount);
  newPortAnnos.reserve(newPortCount);
  newDomainInfo.reserve(newPortCount);
 
  // Build the complete index map from old port indices to new port indices
  // before processing any ports. This is necessary so that
  // fixDomainInfoInsertions can correctly update domain references for newly
  // inserted ports.
  SmallVector<unsigned> indexMap(oldPortCount);
  size_t inserted = 0;
  for (size_t i = 0; i < oldPortCount; ++i) {
    while (inserted < numInsertions && insertions[inserted].first <= i)
      ++inserted;
    indexMap[i] = i + inserted;
  }
 
  // Now process the ports, using the complete indexMap.
  inserted = 0;
  for (size_t i = 0; i < oldPortCount; ++i) {
    while (inserted < numInsertions) {
      auto &[index, info] = insertions[inserted];
      if (index > i)
        break;
 
      auto domains = fixDomainInfoInsertions(
          context, info.domains ? info.domains : empty, indexMap);
      newPortDirections.push_back(info.direction);
      newPortNames.push_back(info.name);
      newPortTypes.push_back(info.type);
      newPortAnnos.push_back(info.annotations.getArrayAttr());
      newDomainInfo.push_back(domains);
      ++inserted;
    }
 
    newPortDirections.push_back(getPortDirection(i));
    newPortNames.push_back(getPortNameAttr(i));
    newPortTypes.push_back(getType(i));
    newPortAnnos.push_back(getPortAnnotation(i));
    auto domains =
        fixDomainInfoInsertions(context, getDomainInfo()[i], indexMap);
    newDomainInfo.push_back(domains);
  }
 
  while (inserted < numInsertions) {
    auto &[index, info] = insertions[inserted];
    auto domains = fixDomainInfoInsertions(
        context, info.domains ? info.domains : empty, indexMap);
    newPortDirections.push_back(info.direction);
    newPortNames.push_back(info.name);
    newPortTypes.push_back(info.type);
    newPortAnnos.push_back(info.annotations.getArrayAttr());
    newDomainInfo.push_back(domains);
    ++inserted;
  }
 
  OpBuilder builder(*this);
  auto clone = InstanceOp::create(
      builder, getLoc(), newPortTypes, getModuleName(), getName(),
      getNameKind(), newPortDirections, newPortNames, newDomainInfo,
      getAnnotations().getValue(), newPortAnnos, getLayers(), getLowerToBind(),
      getDoNotPrint(), getInnerSymAttr());
 
  if (auto outputFile = (*this)->getAttr("output_file"))
    clone->setAttr("output_file", outputFile);
 
  return clone;
}
 
FInstanceLike InstanceOp::cloneWithInsertedPortsAndReplaceUses(
    ArrayRef<std::pair<unsigned, PortInfo>> insertions) {
  auto clone = cloneWithInsertedPorts(insertions);
  replaceUsesRespectingInsertedPorts(getOperation(), clone, insertions);
  return clone;
}
 
LogicalResult InstanceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  return instance_like_impl::verifyReferencedModule(*this, symbolTable,
                                                    getModuleNameAttr());
}
 
StringRef InstanceOp::getInstanceName() { return getName(); }
 
StringAttr InstanceOp::getInstanceNameAttr() { return getNameAttr(); }
 
void InstanceOp::print(OpAsmPrinter &p) {
  // Print the instance name.
  p << " ";
  p.printKeywordOrString(getName());
  if (auto attr = getInnerSymAttr()) {
    p << " sym ";
    p.printSymbolName(attr.getSymName());
  }
  if (getNameKindAttr().getValue() != NameKindEnum::DroppableName)
    p << ' ' << stringifyNameKindEnum(getNameKindAttr().getValue());
 
  // Print the attr-dict.
  SmallVector<StringRef, 10> omittedAttrs = {
      "moduleName", "name",      "portDirections",
      "portNames",  "portTypes", "portAnnotations",
      "inner_sym",  "nameKind",  "domainInfo"};
  if (getAnnotations().empty())
    omittedAttrs.push_back("annotations");
  if (getLayers().empty())
    omittedAttrs.push_back("layers");
  p.printOptionalAttrDict((*this)->getAttrs(), omittedAttrs);
 
  // Print the module name.
  p << " ";
  p.printSymbolName(getModuleName());
 
  // Collect all the result types as TypeAttrs for printing.
  SmallVector<Attribute> portTypes;
  portTypes.reserve(getNumResults());
  llvm::transform(getResultTypes(), std::back_inserter(portTypes),
                  &TypeAttr::get);
  // This needs to be passed domain information.
  printModulePorts(p, /*block=*/nullptr, getPortDirectionsAttr(),
                   getPortNames().getValue(), portTypes,
                   getPortAnnotations().getValue(), {}, {},
                   getDomainInfo().getValue());
}
 
ParseResult InstanceOp::parse(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
 
  std::string name;
  hw::InnerSymAttr innerSymAttr;
  FlatSymbolRefAttr moduleName;
  SmallVector<OpAsmParser::Argument> entryArgs;
  SmallVector<Direction, 4> portDirections;
  SmallVector<Attribute, 4> portNames;
  SmallVector<Attribute, 4> portTypes;
  SmallVector<Attribute, 4> portAnnotations;
  SmallVector<Attribute, 4> portSyms;
  SmallVector<Attribute, 4> portLocs;
  SmallVector<Attribute, 4> domains;
  NameKindEnumAttr nameKind;
 
  if (parser.parseKeywordOrString(&name))
    return failure();
  if (succeeded(parser.parseOptionalKeyword("sym"))) {
    if (parser.parseCustomAttributeWithFallback(
            innerSymAttr, ::mlir::Type{},
            hw::InnerSymbolTable::getInnerSymbolAttrName(),
            result.attributes)) {
      return ::mlir::failure();
    }
  }
  if (parseNameKind(parser, nameKind) ||
      parser.parseOptionalAttrDict(result.attributes) ||
      parser.parseAttribute(moduleName) ||
      parseModulePorts(parser, /*hasSSAIdentifiers=*/false,
                       /*supportsSymbols=*/false, /*supportsDomains=*/true,
                       entryArgs, portDirections, portNames, portTypes,
                       portAnnotations, portSyms, portLocs, domains))
    return failure();
 
  // Add the attributes. We let attributes defined in the attr-dict override
  // attributes parsed out of the module signature.
 
  properties.setModuleName(moduleName);
  properties.setName(StringAttr::get(context, name));
  properties.setNameKind(nameKind);
  properties.setPortDirections(
      direction::packAttribute(context, portDirections));
  properties.setPortNames(ArrayAttr::get(context, portNames));
  properties.setPortAnnotations(ArrayAttr::get(context, portAnnotations));
 
  // Annotations, layers, and LowerToBind are omitted in the printed format
  // if they are empty, empty, and false (respectively).
  properties.setAnnotations(parser.getBuilder().getArrayAttr({}));
  properties.setLayers(parser.getBuilder().getArrayAttr({}));
 
  // Add domain information.
  properties.setDomainInfo(ArrayAttr::get(context, domains));
 
  // Add result types.
  result.types.reserve(portTypes.size());
  llvm::transform(
      portTypes, std::back_inserter(result.types),
      [](Attribute typeAttr) { return cast<TypeAttr>(typeAttr).getValue(); });
 
  return success();
}
 
void InstanceOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  StringRef base = getName();
  if (base.empty())
    base = "inst";
 
  for (size_t i = 0, e = (*this)->getNumResults(); i != e; ++i) {
    setNameFn(getResult(i), (base + "_" + getPortName(i)).str());
  }
}
 
std::optional<size_t> InstanceOp::getTargetResultIndex() {
  // Inner symbols on instance operations target the op not any result.
  return std::nullopt;
}
 
// -----------------------------------------------------------------------------
// InstanceChoiceOp
// -----------------------------------------------------------------------------
 
void InstanceChoiceOp::build(
    OpBuilder &builder, OperationState &result, FModuleLike defaultModule,
    ArrayRef<std::pair<OptionCaseOp, FModuleLike>> cases, StringRef name,
    NameKindEnum nameKind, ArrayRef<Attribute> annotations,
    ArrayRef<Attribute> portAnnotations, StringAttr innerSym,
    FlatSymbolRefAttr instanceMacro) {
  // Gather the result types.
  SmallVector<Type> resultTypes;
  for (Attribute portType : defaultModule.getPortTypes())
    resultTypes.push_back(cast<TypeAttr>(portType).getValue());
 
  // Create the port annotations.
  ArrayAttr portAnnotationsAttr;
  if (portAnnotations.empty()) {
    portAnnotationsAttr = builder.getArrayAttr(SmallVector<Attribute, 16>(
        resultTypes.size(), builder.getArrayAttr({})));
  } else {
    portAnnotationsAttr = builder.getArrayAttr(portAnnotations);
  }
 
  // Create the domain info attribute.
  ArrayAttr domainInfoAttr = defaultModule.getDomainInfoAttr();
  if (domainInfoAttr.empty()) {
    domainInfoAttr = builder.getArrayAttr(SmallVector<Attribute, 16>(
        resultTypes.size(), builder.getArrayAttr({})));
  }
 
  // Gather the module & case names.
  SmallVector<Attribute> moduleNames, caseNames;
  moduleNames.push_back(SymbolRefAttr::get(defaultModule.getModuleNameAttr()));
  for (auto [caseOption, caseModule] : cases) {
    auto caseGroup = caseOption->getParentOfType<OptionOp>();
    caseNames.push_back(SymbolRefAttr::get(caseGroup.getSymNameAttr(),
                                           {SymbolRefAttr::get(caseOption)}));
    moduleNames.push_back(SymbolRefAttr::get(caseModule.getModuleNameAttr()));
  }
 
  return build(builder, result, resultTypes, builder.getArrayAttr(moduleNames),
               builder.getArrayAttr(caseNames), builder.getStringAttr(name),
               NameKindEnumAttr::get(builder.getContext(), nameKind),
               defaultModule.getPortDirectionsAttr(),
               defaultModule.getPortNamesAttr(), domainInfoAttr,
               builder.getArrayAttr(annotations), portAnnotationsAttr,
               defaultModule.getLayersAttr(),
               innerSym ? hw::InnerSymAttr::get(innerSym) : hw::InnerSymAttr(),
               instanceMacro);
}
 
void InstanceChoiceOp::build(OpBuilder &builder, OperationState &odsState,
                             ArrayRef<PortInfo> ports, ArrayAttr moduleNames,
                             ArrayAttr caseNames, StringRef name,
                             NameKindEnum nameKind, ArrayAttr annotations,
                             ArrayAttr layers, hw::InnerSymAttr innerSym,
                             FlatSymbolRefAttr instanceMacro) {
  // Gather the result types and port information from PortInfo.
  SmallVector<Type> newResultTypes;
  SmallVector<bool> newPortDirections;
  SmallVector<Attribute> newPortNames, newPortAnnotations, newDomainInfo;
  newPortDirections.reserve(ports.size());
  newResultTypes.reserve(ports.size());
  newPortAnnotations.reserve(ports.size());
  newDomainInfo.reserve(ports.size());
  newPortNames.reserve(ports.size());
  for (auto &p : ports) {
    newResultTypes.push_back(p.type);
    // Convert Direction to bool (true = output, false = input)
    newPortDirections.push_back(p.direction == Direction::Out);
    newPortNames.push_back(p.name);
    newPortAnnotations.push_back(p.annotations.getArrayAttr());
    if (p.domains)
      newDomainInfo.push_back(p.domains);
    else
      newDomainInfo.push_back(builder.getArrayAttr({}));
  }
 
  return build(builder, odsState, newResultTypes, moduleNames, caseNames, name,
               nameKind, newPortDirections, builder.getArrayAttr(newPortNames),
               builder.getArrayAttr(newDomainInfo), annotations,
               builder.getArrayAttr(newPortAnnotations), layers.getValue(),
               innerSym, instanceMacro);
}
 
std::optional<size_t> InstanceChoiceOp::getTargetResultIndex() {
  return std::nullopt;
}
 
StringRef InstanceChoiceOp::getInstanceName() { return getName(); }
 
StringAttr InstanceChoiceOp::getInstanceNameAttr() { return getNameAttr(); }
 
ArrayAttr InstanceChoiceOp::getReferencedModuleNamesAttr() {
  // Convert FlatSymbolRefAttr array to StringAttr array
  auto moduleNames = getModuleNamesAttr();
  SmallVector<Attribute> moduleNameStrings;
  moduleNameStrings.reserve(moduleNames.size());
  for (auto moduleName : moduleNames)
    moduleNameStrings.push_back(cast<FlatSymbolRefAttr>(moduleName).getAttr());
 
  return ArrayAttr::get(getContext(), moduleNameStrings);
}
 
void InstanceChoiceOp::print(OpAsmPrinter &p) {
  // Print the instance name.
  p << " ";
  p.printKeywordOrString(getName());
  if (auto attr = getInnerSymAttr()) {
    p << " sym ";
    p.printSymbolName(attr.getSymName());
  }
  if (getNameKindAttr().getValue() != NameKindEnum::DroppableName)
    p << ' ' << stringifyNameKindEnum(getNameKindAttr().getValue());
 
  // Print the attr-dict.
  SmallVector<StringRef, 11> omittedAttrs = {
      "moduleNames",     "caseNames", "name",
      "portDirections",  "portNames", "portTypes",
      "portAnnotations", "inner_sym", "nameKind",
      "domainInfo"};
  if (getAnnotations().empty())
    omittedAttrs.push_back("annotations");
  if (getLayers().empty())
    omittedAttrs.push_back("layers");
  p.printOptionalAttrDict((*this)->getAttrs(), omittedAttrs);
 
  // Print the module name.
  p << ' ';
 
  auto moduleNames = getModuleNamesAttr();
  auto caseNames = getCaseNamesAttr();
 
  p.printSymbolName(cast<FlatSymbolRefAttr>(moduleNames[0]).getValue());
 
  p << " alternatives ";
  p.printSymbolName(
      cast<SymbolRefAttr>(caseNames[0]).getRootReference().getValue());
  p << " { ";
  for (size_t i = 0, n = caseNames.size(); i < n; ++i) {
    if (i != 0)
      p << ", ";
 
    auto symbol = cast<SymbolRefAttr>(caseNames[i]);
    p.printSymbolName(symbol.getNestedReferences()[0].getValue());
    p << " -> ";
    p.printSymbolName(cast<FlatSymbolRefAttr>(moduleNames[i + 1]).getValue());
  }
 
  p << " } ";
 
  // Collect all the result types as TypeAttrs for printing.
  SmallVector<Attribute> portTypes;
  portTypes.reserve(getNumResults());
  llvm::transform(getResultTypes(), std::back_inserter(portTypes),
                  &TypeAttr::get);
  printModulePorts(p, /*block=*/nullptr, getPortDirectionsAttr(),
                   getPortNames().getValue(), portTypes,
                   getPortAnnotations().getValue(), {}, {},
                   getDomainInfo().getValue());
}
 
ParseResult InstanceChoiceOp::parse(OpAsmParser &parser,
                                    OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
 
  std::string name;
  hw::InnerSymAttr innerSymAttr;
  SmallVector<Attribute> moduleNames;
  SmallVector<Attribute> caseNames;
  SmallVector<OpAsmParser::Argument> entryArgs;
  SmallVector<Direction, 4> portDirections;
  SmallVector<Attribute, 4> portNames;
  SmallVector<Attribute, 4> portTypes;
  SmallVector<Attribute, 4> portAnnotations;
  SmallVector<Attribute, 4> portSyms;
  SmallVector<Attribute, 4> portLocs;
  SmallVector<Attribute, 4> domains;
  NameKindEnumAttr nameKind;
 
  if (parser.parseKeywordOrString(&name))
    return failure();
  if (succeeded(parser.parseOptionalKeyword("sym"))) {
    if (parser.parseCustomAttributeWithFallback(
            innerSymAttr, Type{},
            hw::InnerSymbolTable::getInnerSymbolAttrName(),
            result.attributes)) {
      return failure();
    }
  }
  if (parseNameKind(parser, nameKind) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
 
  FlatSymbolRefAttr defaultModuleName;
  if (parser.parseAttribute(defaultModuleName))
    return failure();
  moduleNames.push_back(defaultModuleName);
 
  // alternatives { @opt::@case -> @target, ... }
  {
    FlatSymbolRefAttr optionName;
    if (parser.parseKeyword("alternatives") ||
        parser.parseAttribute(optionName) || parser.parseLBrace())
      return failure();
 
    FlatSymbolRefAttr moduleName;
    StringAttr caseName;
    while (succeeded(parser.parseOptionalSymbolName(caseName))) {
      if (parser.parseArrow() || parser.parseAttribute(moduleName))
        return failure();
      moduleNames.push_back(moduleName);
      caseNames.push_back(SymbolRefAttr::get(
          optionName.getAttr(), {FlatSymbolRefAttr::get(caseName)}));
      if (failed(parser.parseOptionalComma()))
        break;
    }
    if (parser.parseRBrace())
      return failure();
  }
 
  if (parseModulePorts(parser, /*hasSSAIdentifiers=*/false,
                       /*supportsSymbols=*/false, /*supportsDomains=*/true,
                       entryArgs, portDirections, portNames, portTypes,
                       portAnnotations, portSyms, portLocs, domains))
    return failure();
 
  // Add the attributes. We let attributes defined in the attr-dict override
  // attributes parsed out of the module signature.
  properties.setModuleNames(ArrayAttr::get(context, moduleNames));
  properties.setCaseNames(ArrayAttr::get(context, caseNames));
  properties.setName(StringAttr::get(context, name));
  properties.setNameKind(nameKind);
  properties.setPortDirections(
      direction::packAttribute(context, portDirections));
  properties.setPortNames(ArrayAttr::get(context, portNames));
  properties.setDomainInfo(ArrayAttr::get(context, domains));
  properties.setPortAnnotations(ArrayAttr::get(context, portAnnotations));
 
  // Annotations, layers, and LowerToBind are omitted in the printed format if
  // they are empty, empty, and false (respectively).
  properties.setAnnotations(parser.getBuilder().getArrayAttr({}));
  properties.setLayers(parser.getBuilder().getArrayAttr({}));
 
  // Add result types.
  result.types.reserve(portTypes.size());
  llvm::transform(
      portTypes, std::back_inserter(result.types),
      [](Attribute typeAttr) { return cast<TypeAttr>(typeAttr).getValue(); });
 
  return success();
}
 
void InstanceChoiceOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  StringRef base = getName().empty() ? "inst" : getName();
  for (auto [result, name] : llvm::zip(getResults(), getPortNames()))
    setNameFn(result, (base + "_" + cast<StringAttr>(name).getValue()).str());
}
 
LogicalResult InstanceChoiceOp::verify() {
  if (getCaseNamesAttr().empty())
    return emitOpError() << "must have at least one case";
  if (getModuleNamesAttr().size() != getCaseNamesAttr().size() + 1)
    return emitOpError() << "number of referenced modules does not match the "
                            "number of options";
 
  // The modules may only be instantiated under their required layers (which
  // are the same for all modules).
  auto ambientLayers = getAmbientLayersAt(getOperation());
  SmallVector<SymbolRefAttr> missingLayers;
  for (auto layer : getLayersAttr().getAsRange<SymbolRefAttr>())
    if (!isLayerCompatibleWith(layer, ambientLayers))
      missingLayers.push_back(layer);
 
  if (missingLayers.empty())
    return success();
 
  auto diag =
      emitOpError("ambient layers are insufficient to instantiate module");
  auto &note = diag.attachNote();
  note << "missing layer requirements: ";
  interleaveComma(missingLayers, note);
  return failure();
}
 
LogicalResult
InstanceChoiceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto caseNames = getCaseNamesAttr();
  for (auto moduleName : getModuleNamesAttr()) {
    auto moduleNameRef = cast<FlatSymbolRefAttr>(moduleName);
    if (failed(instance_like_impl::verifyReferencedModule(*this, symbolTable,
                                                          moduleNameRef)))
      return failure();
 
    // Check that the referenced module is not an intmodule.
    auto referencedModule =
        symbolTable.lookupNearestSymbolFrom<FModuleLike>(*this, moduleNameRef);
    if (isa<FIntModuleOp>(referencedModule))
      return emitOpError("intmodule must be instantiated with instance op, "
                         "not via 'firrtl.instance_choice'");
  }
 
  auto root = cast<SymbolRefAttr>(caseNames[0]).getRootReference();
  for (size_t i = 0, n = caseNames.size(); i < n; ++i) {
    auto ref = cast<SymbolRefAttr>(caseNames[i]);
    auto refRoot = ref.getRootReference();
    if (ref.getRootReference() != root)
      return emitOpError() << "case " << ref
                           << " is not in the same option group as "
                           << caseNames[0];
 
    if (!symbolTable.lookupNearestSymbolFrom<OptionOp>(*this, refRoot))
      return emitOpError() << "option " << refRoot << " does not exist";
 
    if (!symbolTable.lookupNearestSymbolFrom<OptionCaseOp>(*this, ref))
      return emitOpError() << "option " << refRoot
                           << " does not contain option case " << ref;
  }
 
  if (auto instanceMacro = getInstanceMacroAttr())
    if (!symbolTable.lookupNearestSymbolFrom(*this, instanceMacro))
      return emitOpError() << "instance_macro " << instanceMacro
                           << " does not exist";
 
  return success();
}
 
FlatSymbolRefAttr
InstanceChoiceOp::getTargetOrDefaultAttr(OptionCaseOp option) {
  auto caseNames = getCaseNamesAttr();
  for (size_t i = 0, n = caseNames.size(); i < n; ++i) {
    StringAttr caseSym = cast<SymbolRefAttr>(caseNames[i]).getLeafReference();
    if (caseSym == option.getSymName())
      return cast<FlatSymbolRefAttr>(getModuleNamesAttr()[i + 1]);
  }
  return getDefaultTargetAttr();
}
 
SmallVector<std::pair<SymbolRefAttr, FlatSymbolRefAttr>, 1>
InstanceChoiceOp::getTargetChoices() {
  auto caseNames = getCaseNamesAttr();
  auto moduleNames = getModuleNamesAttr();
  SmallVector<std::pair<SymbolRefAttr, FlatSymbolRefAttr>, 1> choices;
  for (size_t i = 0; i < caseNames.size(); ++i) {
    choices.emplace_back(cast<SymbolRefAttr>(caseNames[i]),
                         cast<FlatSymbolRefAttr>(moduleNames[i + 1]));
  }
 
  return choices;
}
 
FInstanceLike InstanceChoiceOp::cloneWithInsertedPorts(
    ArrayRef<std::pair<unsigned, PortInfo>> insertions) {
  auto *context = getContext();
  auto empty = ArrayAttr::get(context, {});
 
  auto oldPortCount = getNumResults();
  auto numInsertions = insertions.size();
  auto newPortCount = oldPortCount + numInsertions;
 
  SmallVector<Direction> newPortDirections;
  SmallVector<Attribute> newPortNames;
  SmallVector<Type> newPortTypes;
  SmallVector<Attribute> newPortAnnos;
  SmallVector<Attribute> newDomainInfo;
 
  newPortDirections.reserve(newPortCount);
  newPortNames.reserve(newPortCount);
  newPortTypes.reserve(newPortCount);
  newPortAnnos.reserve(newPortCount);
  newDomainInfo.reserve(newPortCount);
 
  // Build the complete index map from old port indices to new port indices
  // before processing any ports. This is necessary so that
  // fixDomainInfoInsertions can correctly update domain references for newly
  // inserted ports.
  SmallVector<unsigned> indexMap(oldPortCount);
  size_t inserted = 0;
  for (size_t i = 0; i < oldPortCount; ++i) {
    while (inserted < numInsertions && insertions[inserted].first <= i)
      ++inserted;
    indexMap[i] = i + inserted;
  }
 
  // Now process the ports, using the complete indexMap.
  inserted = 0;
  for (size_t i = 0; i < oldPortCount; ++i) {
    while (inserted < numInsertions) {
      auto &[index, info] = insertions[inserted];
      if (i < index)
        break;
 
      auto domains = fixDomainInfoInsertions(
          context, info.domains ? info.domains : empty, indexMap);
      newPortDirections.push_back(info.direction);
      newPortNames.push_back(info.name);
      newPortTypes.push_back(info.type);
      newPortAnnos.push_back(info.annotations.getArrayAttr());
      newDomainInfo.push_back(domains);
      ++inserted;
    }
 
    newPortDirections.push_back(getPortDirection(i));
    newPortNames.push_back(getPortNameAttr(i));
    newPortTypes.push_back(getType(i));
    newPortAnnos.push_back(getPortAnnotations()[i]);
    auto domains =
        fixDomainInfoInsertions(context, getDomainInfo()[i], indexMap);
    newDomainInfo.push_back(domains);
  }
 
  while (inserted < numInsertions) {
    auto &[index, info] = insertions[inserted];
    auto domains = fixDomainInfoInsertions(
        context, info.domains ? info.domains : empty, indexMap);
    newPortDirections.push_back(info.direction);
    newPortNames.push_back(info.name);
    newPortTypes.push_back(info.type);
    newPortAnnos.push_back(info.annotations.getArrayAttr());
    newDomainInfo.push_back(domains);
    ++inserted;
  }
 
  OpBuilder builder(*this);
  auto clone = InstanceChoiceOp::create(
      builder, getLoc(), newPortTypes, getModuleNames(), getCaseNames(),
      getName(), getNameKind(),
      direction::packAttribute(context, newPortDirections),
      ArrayAttr::get(context, newPortNames),
      ArrayAttr::get(context, newDomainInfo), getAnnotationsAttr(),
      ArrayAttr::get(context, newPortAnnos), getLayers(), getInnerSymAttr(),
      getInstanceMacroAttr());
 
  if (auto outputFile = (*this)->getAttr("output_file"))
    clone->setAttr("output_file", outputFile);
 
  return clone;
}
 
FInstanceLike InstanceChoiceOp::cloneWithInsertedPortsAndReplaceUses(
    ArrayRef<std::pair<unsigned, PortInfo>> insertions) {
  auto clone = cloneWithInsertedPorts(insertions);
  replaceUsesRespectingInsertedPorts(getOperation(), clone, insertions);
  return clone;
}
 
FInstanceLike
InstanceChoiceOp::cloneWithErasedPorts(const llvm::BitVector &erasures) {
  assert(erasures.size() >= getNumResults() &&
         "erasures is not at least as large as getNumResults()");
 
  SmallVector<Type> newResultTypes = removeElementsAtIndices<Type>(
      SmallVector<Type>(result_type_begin(), result_type_end()), erasures);
  SmallVector<Direction> newPortDirections = removeElementsAtIndices<Direction>(
      direction::unpackAttribute(getPortDirectionsAttr()), erasures);
  SmallVector<Attribute> newPortNames =
      removeElementsAtIndices(getPortNames().getValue(), erasures);
  SmallVector<Attribute> newPortAnnotations =
      removeElementsAtIndices(getPortAnnotations().getValue(), erasures);
  ArrayAttr newPortDomains =
      fixDomainInfoDeletions(getContext(), getDomainInfoAttr(), erasures,
                             /*supportsEmptyAttr=*/false);
 
  OpBuilder builder(*this);
  auto clone = InstanceChoiceOp::create(
      builder, getLoc(), newResultTypes, getModuleNames(), getCaseNames(),
      getName(), getNameKind(),
      direction::packAttribute(getContext(), newPortDirections),
      ArrayAttr::get(getContext(), newPortNames), newPortDomains,
      getAnnotationsAttr(), ArrayAttr::get(getContext(), newPortAnnotations),
      getLayers(), getInnerSymAttr(), getInstanceMacroAttr());
 
  if (auto outputFile = (*this)->getAttr("output_file"))
    clone->setAttr("output_file", outputFile);
 
  return clone;
}
 
FInstanceLike InstanceChoiceOp::cloneWithErasedPortsAndReplaceUses(
    const llvm::BitVector &erasures) {
  auto clone = cloneWithErasedPorts(erasures);
  replaceUsesRespectingErasedPorts(getOperation(), clone, erasures);
  return clone;
}
 
//===----------------------------------------------------------------------===//
// MemOp
//===----------------------------------------------------------------------===//
 
ArrayAttr MemOp::getPortAnnotation(unsigned portIdx) {
  assert(portIdx < getNumResults() &&
         "index should be smaller than result number");
  return cast<ArrayAttr>(getPortAnnotations()[portIdx]);
}
 
void MemOp::setAllPortAnnotations(ArrayRef<Attribute> annotations) {
  assert(annotations.size() == getNumResults() &&
         "number of annotations is not equal to result number");
  (*this)->setAttr("portAnnotations",
                   ArrayAttr::get(getContext(), annotations));
}
 
// Get the number of read, write and read-write ports.
void MemOp::getNumPorts(size_t &numReadPorts, size_t &numWritePorts,
                        size_t &numReadWritePorts, size_t &numDbgsPorts) {
  numReadPorts = 0;
  numWritePorts = 0;
  numReadWritePorts = 0;
  numDbgsPorts = 0;
  for (size_t i = 0, e = getNumResults(); i != e; ++i) {
    auto portKind = getPortKind(i);
    if (portKind == MemOp::PortKind::Debug)
      ++numDbgsPorts;
    else if (portKind == MemOp::PortKind::Read)
      ++numReadPorts;
    else if (portKind == MemOp::PortKind::Write) {
      ++numWritePorts;
    } else
      ++numReadWritePorts;
  }
}
 
/// Verify the correctness of a MemOp.
LogicalResult MemOp::verify() {
 
  // Store the port names as we find them. This lets us check quickly
  // for uniqueneess.
  llvm::SmallDenseSet<Attribute, 8> portNamesSet;
 
  // Store the previous data type. This lets us check that the data
  // type is consistent across all ports.
  FIRRTLType oldDataType;
 
  for (size_t i = 0, e = getNumResults(); i != e; ++i) {
    auto portName = getPortNameAttr(i);
 
    // Get a bundle type representing this port, stripping an outer
    // flip if it exists.  If this is not a bundle<> or
    // flip<bundle<>>, then this is an error.
    BundleType portBundleType =
        type_dyn_cast<BundleType>(getResult(i).getType());
 
    // Require that all port names are unique.
    if (!portNamesSet.insert(portName).second) {
      emitOpError() << "has non-unique port name " << portName;
      return failure();
    }
 
    // Determine the kind of the memory.  If the kind cannot be
    // determined, then it's indicative of the wrong number of fields
    // in the type (but we don't know any more just yet).
 
    auto elt = getPortNamed(portName);
    if (!elt) {
      emitOpError() << "could not get port with name " << portName;
      return failure();
    }
    auto firrtlType = type_cast<FIRRTLType>(elt.getType());
    MemOp::PortKind portKind = getMemPortKindFromType(firrtlType);
 
    if (portKind == MemOp::PortKind::Debug &&
        !type_isa<RefType>(getResult(i).getType()))
      return emitOpError() << "has an invalid type on port " << portName
                           << " (expected Read/Write/ReadWrite/Debug)";
    if (type_isa<RefType>(firrtlType) && e == 1)
      return emitOpError()
             << "cannot have only one port of debug type. Debug port can only "
                "exist alongside other read/write/read-write port";
 
    // Safely search for the "data" field, erroring if it can't be
    // found.
    FIRRTLBaseType dataType;
    if (portKind == MemOp::PortKind::Debug) {
      auto resType = type_cast<RefType>(getResult(i).getType());
      if (!(resType && type_isa<FVectorType>(resType.getType())))
        return emitOpError() << "debug ports must be a RefType of FVectorType";
      dataType = type_cast<FVectorType>(resType.getType()).getElementType();
    } else {
      auto dataTypeOption = portBundleType.getElement("data");
      if (!dataTypeOption && portKind == MemOp::PortKind::ReadWrite)
        dataTypeOption = portBundleType.getElement("wdata");
      if (!dataTypeOption) {
        emitOpError() << "has no data field on port " << portName
                      << " (expected to see \"data\" for a read or write "
                         "port or \"rdata\" for a read/write port)";
        return failure();
      }
      dataType = dataTypeOption->type;
      // Read data is expected to ba a flip.
      if (portKind == MemOp::PortKind::Read) {
        // FIXME error on missing bundle flip
      }
    }
 
    // Error if the data type isn't passive.
    if (!dataType.isPassive()) {
      emitOpError() << "has non-passive data type on port " << portName
                    << " (memory types must be passive)";
      return failure();
    }
 
    // Error if the data type contains analog types.
    if (dataType.containsAnalog()) {
      emitOpError() << "has a data type that contains an analog type on port "
                    << portName
                    << " (memory types cannot contain analog types)";
      return failure();
    }
 
    // Check that the port type matches the kind that we determined
    // for this port.  This catches situations of extraneous port
    // fields beind included or the fields being named incorrectly.
    FIRRTLType expectedType =
        getTypeForPort(getDepth(), dataType, portKind,
                       dataType.isGround() ? getMaskBits() : 0);
    // Compute the original port type as portBundleType may have
    // stripped outer flip information.
    auto originalType = getResult(i).getType();
    if (originalType != expectedType) {
      StringRef portKindName;
      switch (portKind) {
      case MemOp::PortKind::Read:
        portKindName = "read";
        break;
      case MemOp::PortKind::Write:
        portKindName = "write";
        break;
      case MemOp::PortKind::ReadWrite:
        portKindName = "readwrite";
        break;
      case MemOp::PortKind::Debug:
        portKindName = "dbg";
        break;
      }
      emitOpError() << "has an invalid type for port " << portName
                    << " of determined kind \"" << portKindName
                    << "\" (expected " << expectedType << ", but got "
                    << originalType << ")";
      return failure();
    }
 
    // Error if the type of the current port was not the same as the
    // last port, but skip checking the first port.
    if (oldDataType && oldDataType != dataType) {
      emitOpError() << "port " << getPortNameAttr(i)
                    << " has a different type than port "
                    << getPortNameAttr(i - 1) << " (expected " << oldDataType
                    << ", but got " << dataType << ")";
      return failure();
    }
 
    oldDataType = dataType;
  }
 
  auto maskWidth = getMaskBits();
 
  auto dataWidth = getDataType().getBitWidthOrSentinel();
  if (dataWidth > 0 && maskWidth > (size_t)dataWidth)
    return emitOpError("the mask width cannot be greater than "
                       "data width");
 
  if (getPortAnnotations().size() != getNumResults())
    return emitOpError("the number of result annotations should be "
                       "equal to the number of results");
 
  return success();
}
 
static size_t getAddressWidth(size_t depth) {
  return std::max(1U, llvm::Log2_64_Ceil(depth));
}
 
size_t MemOp::getAddrBits() { return getAddressWidth(getDepth()); }
 
FIRRTLType MemOp::getTypeForPort(uint64_t depth, FIRRTLBaseType dataType,
                                 PortKind portKind, size_t maskBits) {
 
  auto *context = dataType.getContext();
  if (portKind == PortKind::Debug)
    return RefType::get(FVectorType::get(dataType, depth));
  FIRRTLBaseType maskType;
  // maskBits not specified (==0), then get the mask type from the dataType.
  if (maskBits == 0)
    maskType = dataType.getMaskType();
  else
    maskType = UIntType::get(context, maskBits);
 
  auto getId = [&](StringRef name) -> StringAttr {
    return StringAttr::get(context, name);
  };
 
  SmallVector<BundleType::BundleElement, 7> portFields;
 
  auto addressType = UIntType::get(context, getAddressWidth(depth));
 
  portFields.push_back({getId("addr"), false, addressType});
  portFields.push_back({getId("en"), false, UIntType::get(context, 1)});
  portFields.push_back({getId("clk"), false, ClockType::get(context)});
 
  switch (portKind) {
  case PortKind::Read:
    portFields.push_back({getId("data"), true, dataType});
    break;
 
  case PortKind::Write:
    portFields.push_back({getId("data"), false, dataType});
    portFields.push_back({getId("mask"), false, maskType});
    break;
 
  case PortKind::ReadWrite:
    portFields.push_back({getId("rdata"), true, dataType});
    portFields.push_back({getId("wmode"), false, UIntType::get(context, 1)});
    portFields.push_back({getId("wdata"), false, dataType});
    portFields.push_back({getId("wmask"), false, maskType});
    break;
  default:
    llvm::report_fatal_error("memory port kind not handled");
    break;
  }
 
  return BundleType::get(context, portFields);
}
 
/// Return the name and kind of ports supported by this memory.
SmallVector<MemOp::NamedPort> MemOp::getPorts() {
  SmallVector<MemOp::NamedPort> result;
  // Each entry in the bundle is a port.
  for (size_t i = 0, e = getNumResults(); i != e; ++i) {
    // Each port is a bundle.
    auto portType = type_cast<FIRRTLType>(getResult(i).getType());
    result.push_back({getPortNameAttr(i), getMemPortKindFromType(portType)});
  }
  return result;
}
 
/// Return the kind of the specified port.
MemOp::PortKind MemOp::getPortKind(StringRef portName) {
  return getMemPortKindFromType(
      type_cast<FIRRTLType>(getPortNamed(portName).getType()));
}
 
/// Return the kind of the specified port number.
MemOp::PortKind MemOp::getPortKind(size_t resultNo) {
  return getMemPortKindFromType(
      type_cast<FIRRTLType>(getResult(resultNo).getType()));
}
 
/// Return the number of bits in the mask for the memory.
size_t MemOp::getMaskBits() {
 
  for (auto res : getResults()) {
    if (type_isa<RefType>(res.getType()))
      continue;
    auto firstPortType = type_cast<FIRRTLBaseType>(res.getType());
    if (getMemPortKindFromType(firstPortType) == PortKind::Read ||
        getMemPortKindFromType(firstPortType) == PortKind::Debug)
      continue;
 
    FIRRTLBaseType mType;
    for (auto t : type_cast<BundleType>(firstPortType.getPassiveType())) {
      if (t.name.getValue().contains("mask"))
        mType = t.type;
    }
    if (type_isa<UIntType>(mType))
      return mType.getBitWidthOrSentinel();
  }
  // Mask of zero bits means, either there are no write/readwrite ports or the
  // mask is of aggregate type.
  return 0;
}
 
/// Return the data-type field of the memory, the type of each element.
FIRRTLBaseType MemOp::getDataType() {
  assert(getNumResults() != 0 && "Mems with no read/write ports are illegal");
 
  if (auto refType = type_dyn_cast<RefType>(getResult(0).getType()))
    return type_cast<FVectorType>(refType.getType()).getElementType();
  auto firstPortType = type_cast<FIRRTLBaseType>(getResult(0).getType());
 
  StringRef dataFieldName = "data";
  if (getMemPortKindFromType(firstPortType) == PortKind::ReadWrite)
    dataFieldName = "rdata";
 
  return type_cast<BundleType>(firstPortType.getPassiveType())
      .getElementType(dataFieldName);
}
 
StringAttr MemOp::getPortNameAttr(size_t resultNo) {
  return cast<StringAttr>(getPortNames()[resultNo]);
}
 
FIRRTLBaseType MemOp::getPortType(size_t resultNo) {
  return type_cast<FIRRTLBaseType>(getResults()[resultNo].getType());
}
 
Value MemOp::getPortNamed(StringAttr name) {
  auto namesArray = getPortNames();
  for (size_t i = 0, e = namesArray.size(); i != e; ++i) {
    if (namesArray[i] == name) {
      assert(i < getNumResults() && " names array out of sync with results");
      return getResult(i);
    }
  }
  return Value();
}
 
// Extract all the relevant attributes from the MemOp and return the FirMemory.
FirMemory MemOp::getSummary() {
  auto op = *this;
  size_t numReadPorts = 0;
  size_t numWritePorts = 0;
  size_t numReadWritePorts = 0;
  llvm::SmallDenseMap<Value, unsigned> clockToLeader;
  SmallVector<int32_t> writeClockIDs;
 
  for (size_t i = 0, e = op.getNumResults(); i != e; ++i) {
    auto portKind = op.getPortKind(i);
    if (portKind == MemOp::PortKind::Read)
      ++numReadPorts;
    else if (portKind == MemOp::PortKind::Write) {
      for (auto *a : op.getResult(i).getUsers()) {
        auto subfield = dyn_cast<SubfieldOp>(a);
        if (!subfield || subfield.getFieldIndex() != 2)
          continue;
        auto clockPort = a->getResult(0);
        for (auto *b : clockPort.getUsers()) {
          if (auto connect = dyn_cast<FConnectLike>(b)) {
            if (connect.getDest() == clockPort) {
              auto result =
                  clockToLeader.insert({circt::firrtl::getModuleScopedDriver(
                                            connect.getSrc(), true, true, true),
                                        numWritePorts});
              if (result.second) {
                writeClockIDs.push_back(numWritePorts);
              } else {
                writeClockIDs.push_back(result.first->second);
              }
            }
          }
        }
        break;
      }
      ++numWritePorts;
    } else
      ++numReadWritePorts;
  }
 
  size_t width = 0;
  if (auto widthV = getBitWidth(op.getDataType()))
    width = *widthV;
  else
    op.emitError("'firrtl.mem' should have simple type and known width");
  MemoryInitAttr init = op->getAttrOfType<MemoryInitAttr>("init");
  StringAttr modName;
  if (op->hasAttr("modName"))
    modName = op->getAttrOfType<StringAttr>("modName");
  else {
    SmallString<8> clocks;
    for (auto a : writeClockIDs)
      clocks.append(Twine((char)(a + 'a')).str());
    SmallString<32> initStr;
    // If there is a file initialization, then come up with a decent
    // representation for this.  Use the filename, but only characters
    // [a-zA-Z0-9] and the bool/hex and inline booleans.
    if (init) {
      for (auto c : init.getFilename().getValue())
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
            (c >= '0' && c <= '9'))
          initStr.push_back(c);
      initStr.push_back('_');
      initStr.push_back(init.getIsBinary() ? 't' : 'f');
      initStr.push_back('_');
      initStr.push_back(init.getIsInline() ? 't' : 'f');
    }
    modName = StringAttr::get(
        op->getContext(),
        llvm::formatv(
            "{0}FIRRTLMem_{1}_{2}_{3}_{4}_{5}_{6}_{7}_{8}_{9}_{10}{11}{12}",
            op.getPrefix().value_or(""), numReadPorts, numWritePorts,
            numReadWritePorts, (size_t)width, op.getDepth(),
            op.getReadLatency(), op.getWriteLatency(), op.getMaskBits(),
            (unsigned)op.getRuw(), (unsigned)seq::WUW::PortOrder,
            clocks.empty() ? "" : "_" + clocks, init ? initStr.str() : ""));
  }
  return {numReadPorts,
          numWritePorts,
          numReadWritePorts,
          (size_t)width,
          op.getDepth(),
          op.getReadLatency(),
          op.getWriteLatency(),
          op.getMaskBits(),
          *seq::symbolizeRUW(unsigned(op.getRuw())),
          seq::WUW::PortOrder,
          writeClockIDs,
          modName,
          op.getMaskBits() > 1,
          init,
          op.getPrefixAttr(),
          op.getLoc()};
}
 
void MemOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  StringRef base = getName();
  if (base.empty())
    base = "mem";
 
  for (size_t i = 0, e = (*this)->getNumResults(); i != e; ++i) {
    setNameFn(getResult(i), (base + "_" + getPortName(i)).str());
  }
}
 
std::optional<size_t> MemOp::getTargetResultIndex() {
  // Inner symbols on memory operations target the op not any result.
  return std::nullopt;
}
 
// Construct name of the module which will be used for the memory definition.
StringAttr FirMemory::getFirMemoryName() const { return modName; }
 
/// Helper for naming forceable declarations (and their optional ref result).
static void forceableAsmResultNames(Forceable op, StringRef name,
                                    OpAsmSetValueNameFn setNameFn) {
  if (name.empty())
    return;
  setNameFn(op.getDataRaw(), name);
  if (op.isForceable())
    setNameFn(op.getDataRef(), (name + "_ref").str());
}
 
void NodeOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  return forceableAsmResultNames(*this, getName(), setNameFn);
}
 
LogicalResult NodeOp::inferReturnTypes(
    mlir::MLIRContext *context, std::optional<mlir::Location> location,
    ::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes,
    ::mlir::PropertyRef properties, ::mlir::RegionRange regions,
    ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
  if (operands.empty())
    return failure();
  Adaptor adaptor(operands, attributes, properties, regions);
  inferredReturnTypes.push_back(adaptor.getInput().getType());
  if (adaptor.getForceable()) {
    auto forceableType = firrtl::detail::getForceableResultType(
        true, adaptor.getInput().getType());
    if (!forceableType) {
      if (location)
        ::mlir::emitError(*location, "cannot force a node of type ")
            << operands[0].getType();
      return failure();
    }
    inferredReturnTypes.push_back(forceableType);
  }
  return success();
}
 
std::optional<size_t> NodeOp::getTargetResultIndex() { return 0; }
 
void RegOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  return forceableAsmResultNames(*this, getName(), setNameFn);
}
 
std::optional<size_t> RegOp::getTargetResultIndex() { return 0; }
 
SmallVector<std::pair<circt::FieldRef, circt::FieldRef>>
RegOp::computeDataFlow() {
  // A register does't have any combinational dataflow.
  return {};
}
 
/// Verify that an optional `initial` time-zero value attribute is a constant of
/// the correct ground type. The attribute's bit width and signedness must match
/// the register's declared ground type.
static LogicalResult verifyInitialAttr(Operation *op, FIRRTLBaseType regType,
                                       IntegerAttr initial) {
  if (!initial)
    return success();
 
  // Aggregate register support is deferred; require a ground type.
  auto intType = type_dyn_cast<IntType>(regType);
  if (!intType)
    return op->emitError(
        "'initial' value is only supported on ground-type registers");
 
  // The width of the attribute must match the register's declared width.
  auto width = intType.getWidthOrSentinel();
  if (width != -1 && (int)initial.getValue().getBitWidth() != width)
    return op->emitError("'initial' value bitwidth (")
           << initial.getValue().getBitWidth()
           << ") doesn't match register type width (" << width << ")";
 
  // The sign of the attribute's integer type must match the register type sign.
  auto attrType = type_cast<IntegerType>(initial.getType());
  if (attrType.isSignless() || attrType.isSigned() != intType.isSigned())
    return op->emitError("'initial' value has wrong sign");
 
  return success();
}
 
LogicalResult RegOp::verify() {
  return verifyInitialAttr(*this, getResult().getType(), getInitialAttr());
}
 
LogicalResult RegResetOp::verify() {
  auto reset = getResetValue();
 
  FIRRTLBaseType resetType = reset.getType();
  FIRRTLBaseType regType = getResult().getType();
 
  // The type of the initialiser must be equivalent to the register type.
  if (!areTypesEquivalent(regType, resetType))
    return emitError("type mismatch between register ")
           << regType << " and reset value " << resetType;
 
  return verifyInitialAttr(*this, regType, getInitialAttr());
}
 
std::optional<size_t> RegResetOp::getTargetResultIndex() { return 0; }
 
void RegResetOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  return forceableAsmResultNames(*this, getName(), setNameFn);
}
 
//===----------------------------------------------------------------------===//
// FormalOp
//===----------------------------------------------------------------------===//
 
LogicalResult
FormalOp::verifySymbolUses(mlir::SymbolTableCollection &symbolTable) {
  auto *op = symbolTable.lookupNearestSymbolFrom(*this, getModuleNameAttr());
  if (!op)
    return emitOpError() << "targets unknown module " << getModuleNameAttr();
 
  if (!isa<FModuleLike>(op)) {
    auto d = emitOpError() << "target " << getModuleNameAttr()
                           << " is not a module";
    d.attachNote(op->getLoc()) << "target defined here";
    return d;
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// SimulationOp
//===----------------------------------------------------------------------===//
 
LogicalResult
SimulationOp::verifySymbolUses(mlir::SymbolTableCollection &symbolTable) {
  auto *op = symbolTable.lookupNearestSymbolFrom(*this, getModuleNameAttr());
  if (!op)
    return emitOpError() << "targets unknown module " << getModuleNameAttr();
 
  auto complain = [&] {
    auto d = emitOpError() << "target " << getModuleNameAttr() << " ";
    d.attachNote(op->getLoc()) << "target defined here";
    return d;
  };
 
  auto module = dyn_cast<FModuleLike>(op);
  if (!module)
    return complain() << "is not a module";
 
  auto numPorts = module.getNumPorts();
  if (numPorts < 4)
    return complain() << "must have at least 4 ports, got " << numPorts
                      << " instead";
 
  // Check ports 0-3 for expected hardware ports: clock, init, done, success.
  auto checkPort = [&](unsigned idx, StringRef expName, Direction expDir,
                       llvm::function_ref<bool(Type)> checkType,
                       StringRef expType) {
    auto name = module.getPortNameAttr(idx);
    if (name != expName) {
      complain() << "port " << idx << " must be called \"" << expName
                 << "\", got " << name << " instead";
      return false;
    }
    if (auto dir = module.getPortDirection(idx); dir != expDir) {
      auto stringify = [](Direction dir) {
        return dir == Direction::In ? "an input" : "an output";
      };
      complain() << "port " << name << " must be " << stringify(expDir)
                 << ", got " << stringify(dir) << " instead";
      return false;
    }
    if (auto type = module.getPortType(idx); !checkType(type)) {
      complain() << "port " << name << " must be a '!firrtl." << expType
                 << "', got " << type << " instead";
      return false;
    }
    return true;
  };
 
  auto isClock = [](Type type) { return isa<ClockType>(type); };
  auto isBool = [](Type type) {
    if (auto uintType = dyn_cast<UIntType>(type))
      return uintType.getWidth() == 1;
    return false;
  };
 
  if (!checkPort(0, "clock", Direction::In, isClock, "clock") ||
      !checkPort(1, "init", Direction::In, isBool, "uint<1>") ||
      !checkPort(2, "done", Direction::Out, isBool, "uint<1>") ||
      !checkPort(3, "success", Direction::Out, isBool, "uint<1>"))
    return failure();
 
  // Additional non-hardware ports are allowed.
  for (unsigned i = 4; i < numPorts; ++i) {
    auto type = module.getPortType(i);
    auto firrtlType = type_dyn_cast<FIRRTLType>(type);
    if (!firrtlType || hasHardwareElements(firrtlType))
      return complain() << "port " << i << " contains hardware types: " << type;
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// WireOp
//===----------------------------------------------------------------------===//
 
void WireOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  return forceableAsmResultNames(*this, getName(), setNameFn);
}
 
SmallVector<std::pair<circt::FieldRef, circt::FieldRef>>
RegResetOp::computeDataFlow() {
  // A register does't have any combinational dataflow.
  return {};
}
 
std::optional<size_t> WireOp::getTargetResultIndex() { return 0; }
 
LogicalResult WireOp::verify() {
  // A wire of domain type must not have domain associations.
  if (type_isa<DomainType>(getResult().getType()) && !getDomains().empty())
    return emitOpError("of domain type must not have domain associations");
 
  // Early exist if no domains.
  auto domains = getDomains();
  if (!domains.size())
    return success();
 
  // Check if any associated domains have the same kind.  If they do, emit an
  // error on the op and a note on each of the values that have the same kind.
  //
  // Use a two-phase approach where when a new domain is found, record it in
  // `domainInfo`.  Then, if a collision is found, report an error, add a note
  // for the original value, and a note for the colliding value.  For each
  // subsequent collision, add a note.
  //
  // Note: choose a different `N` for the `SmallMapVector` if we add more
  // domains than clock and power.
  using oldValueAndDiag = std::pair<Value, std::unique_ptr<InFlightDiagnostic>>;
  llvm::SmallMapVector<SymbolRefAttr, oldValueAndDiag, 2> domainInfo;
  bool hasErrors = false;
  for (auto domain : domains) {
    auto domainType = cast<DomainType>(domain.getType());
    auto domainName = domainType.getName();
 
    // Record a domain kind and the association value.
    auto [it, inserted] =
        domainInfo.try_emplace(domainName, std::make_pair(domain, nullptr));
 
    // We haven't seen this domain kind before.  No error (yet).
    if (inserted)
      continue;
 
    // We have seen this domain kind before.
    auto &[value, diag] = it->second;
 
    // We haven't generated an error yet.  Generate an error and a note for the
    // first value.  Extend the lifetime of the diagnostic so that we can keep
    // adding notes to it.
    if (!diag) {
      diag = std::make_unique<InFlightDiagnostic>(
          emitOpError() << "associated with multiple operands of '"
                        << domainName.getValue() << "' kind");
      diag->attachNote(value.getLoc()) << "first domain operand here";
      hasErrors = true;
    }
 
    // Add a note for the current colliding value.
    diag->attachNote(domain.getLoc())
        << "additional colliding domain operand here";
  }
 
  // No errors, we're done.
  if (!hasErrors)
    return success();
 
  // Diagnostics are emitted when the diagnostic is destroyed.  Early delete the
  // diagnostics in insertion order to prevent these being deleted in
  // determinstic reverse order when the `SmallVector` that backs the
  // `MapVector` is destroyed.  This improves the error quality by keeping
  // things aligned with how a user would read the MLIR.
  for (auto &[_, diag] : domainInfo.values())
    diag.reset();
 
  return failure();
}
 
LogicalResult WireOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  if (auto refType = type_dyn_cast<RefType>(getType(0)))
    return verifyProbeType(
        refType, getLoc(), getOperation()->getParentOfType<CircuitOp>(),
        symbolTable, Twine("'") + getOperationName() + "' op is");
 
  if (auto domainType = type_dyn_cast<DomainType>(getType(0)))
    return domainType.verifySymbolUses(getOperation(), symbolTable);
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// ContractOp
//===----------------------------------------------------------------------===//
 
LogicalResult ContractOp::verify() {
  if (getBody().getArgumentTypes() != getInputs().getType())
    return emitOpError("result types and region argument types must match");
  return success();
}
 
//===----------------------------------------------------------------------===//
// OptionCaseOp
//===----------------------------------------------------------------------===//
 
LogicalResult
OptionCaseOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto caseMacro = getCaseMacroAttr();
  if (!caseMacro)
    return success();
 
  // Verify that the referenced macro exists in the circuit.
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  auto *refOp = symbolTable.lookupSymbolIn(circuitOp, caseMacro);
  if (!refOp)
    return emitOpError("case_macro references an undefined symbol: ")
           << caseMacro;
 
  if (!isa<sv::MacroDeclOp>(refOp))
    return emitOpError("case_macro must reference a macro declaration");
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// ObjectOp
//===----------------------------------------------------------------------===//
 
void ObjectOp::build(OpBuilder &builder, OperationState &state, ClassLike klass,
                     StringRef name) {
  build(builder, state, klass.getInstanceType(),
        StringAttr::get(builder.getContext(), name));
}
 
LogicalResult ObjectOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  auto classType = getType();
  auto className = classType.getNameAttr();
 
  // verify that the class exists.
  auto classOp = dyn_cast_or_null<ClassLike>(
      symbolTable.lookupSymbolIn(circuitOp, className));
  if (!classOp)
    return emitOpError() << "references unknown class " << className;
 
  // verify that the result type agrees with the class definition.
  if (failed(classOp.verifyType(classType, [&]() { return emitOpError(); })))
    return failure();
 
  return success();
}
 
StringAttr ObjectOp::getClassNameAttr() {
  return getType().getNameAttr().getAttr();
}
 
StringRef ObjectOp::getClassName() { return getType().getName(); }
 
ClassLike ObjectOp::getReferencedClass(const SymbolTable &symbolTable) {
  auto symRef = getType().getNameAttr();
  return symbolTable.lookup<ClassLike>(symRef.getLeafReference());
}
 
Operation *ObjectOp::getReferencedOperation(const SymbolTable &symtbl) {
  return getReferencedClass(symtbl);
}
 
StringRef ObjectOp::getInstanceName() { return getName(); }
 
StringAttr ObjectOp::getInstanceNameAttr() { return getNameAttr(); }
 
StringAttr ObjectOp::getReferencedModuleNameAttr() {
  return getClassNameAttr();
}
 
void ObjectOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  setNameFn(getResult(), getName());
}
 
//===----------------------------------------------------------------------===//
// Statements
//===----------------------------------------------------------------------===//
 
LogicalResult AttachOp::verify() {
  // All known widths must match.
  std::optional<int32_t> commonWidth;
  for (auto operand : getOperands()) {
    auto thisWidth = type_cast<AnalogType>(operand.getType()).getWidth();
    if (!thisWidth)
      continue;
    if (!commonWidth) {
      commonWidth = thisWidth;
      continue;
    }
    if (commonWidth != thisWidth)
      return emitOpError("is inavlid as not all known operand widths match");
  }
  return success();
}
 
/// Check if the source and sink are of appropriate flow.
static LogicalResult checkConnectFlow(Operation *connect) {
  Value dst = connect->getOperand(0);
  Value src = connect->getOperand(1);
 
  // TODO: Relax this to allow reads from output ports,
  // instance/memory input ports.
  auto srcFlow = foldFlow(src);
  if (!isValidSrc(srcFlow)) {
    // A sink that is a port output or instance input used as a source is okay,
    // as long as it is not a property.
    auto kind = getDeclarationKind(src);
    if (isa<PropertyType>(src.getType()) ||
        (kind != DeclKind::Port && kind != DeclKind::Instance)) {
      auto srcRef = getFieldRefFromValue(src, /*lookThroughCasts=*/true);
      auto [srcName, rootKnown] = getFieldName(srcRef);
      auto diag = emitError(connect->getLoc());
      diag << "connect has invalid flow: the source expression ";
      if (rootKnown)
        diag << "\"" << srcName << "\" ";
      diag << "has " << toString(srcFlow) << ", expected source or duplex flow";
      return diag.attachNote(srcRef.getLoc()) << "the source was defined here";
    }
  }
 
  auto dstFlow = foldFlow(dst);
  if (!isValidDst(dstFlow)) {
    auto dstRef = getFieldRefFromValue(dst, /*lookThroughCasts=*/true);
    auto [dstName, rootKnown] = getFieldName(dstRef);
    auto diag = emitError(connect->getLoc());
    diag << "connect has invalid flow: the destination expression ";
    if (rootKnown)
      diag << "\"" << dstName << "\" ";
    diag << "has " << toString(dstFlow) << ", expected sink or duplex flow";
    return diag.attachNote(dstRef.getLoc())
           << "the destination was defined here";
  }
  return success();
}
 
// NOLINTBEGIN(misc-no-recursion)
/// Checks if the type has any 'const' leaf elements . If `isFlip` is `true`,
/// the `const` leaf is not considered to be driven.
static bool isConstFieldDriven(FIRRTLBaseType type, bool isFlip = false,
                               bool outerTypeIsConst = false) {
  auto typeIsConst = outerTypeIsConst || type.isConst();
 
  if (typeIsConst && type.isPassive())
    return !isFlip;
 
  if (auto bundleType = type_dyn_cast<BundleType>(type))
    return llvm::any_of(bundleType.getElements(), [&](auto &element) {
      return isConstFieldDriven(element.type, isFlip ^ element.isFlip,
                                typeIsConst);
    });
 
  if (auto vectorType = type_dyn_cast<FVectorType>(type))
    return isConstFieldDriven(vectorType.getElementType(), isFlip, typeIsConst);
 
  if (typeIsConst)
    return !isFlip;
  return false;
}
// NOLINTEND(misc-no-recursion)
 
/// Checks that connections to 'const' destinations are not dependent on
/// non-'const' conditions in when blocks.
static LogicalResult checkConnectConditionality(FConnectLike connect) {
  auto dest = connect.getDest();
  auto destType = type_dyn_cast<FIRRTLBaseType>(dest.getType());
  auto src = connect.getSrc();
  auto srcType = type_dyn_cast<FIRRTLBaseType>(src.getType());
  if (!destType || !srcType)
    return success();
 
  auto destRefinedType = destType;
  auto srcRefinedType = srcType;
 
  /// Looks up the value's defining op until the defining op is null or a
  /// declaration of the value. If a SubAccessOp is encountered with a 'const'
  /// input, `originalFieldType` is made 'const'.
  auto findFieldDeclarationRefiningFieldType =
      [](Value value, FIRRTLBaseType &originalFieldType) -> Value {
    while (auto *definingOp = value.getDefiningOp()) {
      bool shouldContinue = true;
      TypeSwitch<Operation *>(definingOp)
          .Case<SubfieldOp, SubindexOp>([&](auto op) { value = op.getInput(); })
          .Case<SubaccessOp>([&](SubaccessOp op) {
            if (op.getInput()
                    .getType()
                    .base()
                    .getElementTypePreservingConst()
                    .isConst())
              originalFieldType = originalFieldType.getConstType(true);
            value = op.getInput();
          })
          .Default([&](Operation *) { shouldContinue = false; });
      if (!shouldContinue)
        break;
    }
    return value;
  };
 
  auto destDeclaration =
      findFieldDeclarationRefiningFieldType(dest, destRefinedType);
  auto srcDeclaration =
      findFieldDeclarationRefiningFieldType(src, srcRefinedType);
 
  auto checkConstConditionality = [&](Value value, FIRRTLBaseType type,
                                      Value declaration) -> LogicalResult {
    auto *declarationBlock = declaration.getParentBlock();
    auto *block = connect->getBlock();
    while (block && block != declarationBlock) {
      auto *parentOp = block->getParentOp();
 
      if (auto whenOp = dyn_cast<WhenOp>(parentOp);
          whenOp && !whenOp.getCondition().getType().isConst()) {
        if (type.isConst())
          return connect.emitOpError()
                 << "assignment to 'const' type " << type
                 << " is dependent on a non-'const' condition";
        return connect->emitOpError()
               << "assignment to nested 'const' member of type " << type
               << " is dependent on a non-'const' condition";
      }
 
      block = parentOp->getBlock();
    }
    return success();
  };
 
  auto emitSubaccessError = [&] {
    return connect.emitError(
        "assignment to non-'const' subaccess of 'const' type is disallowed");
  };
 
  // Check destination if it contains 'const' leaves
  if (destRefinedType.containsConst() && isConstFieldDriven(destRefinedType)) {
    // Disallow assignment to non-'const' subaccesses of 'const' types
    if (destType != destRefinedType)
      return emitSubaccessError();
 
    if (failed(checkConstConditionality(dest, destType, destDeclaration)))
      return failure();
  }
 
  // Check source if it contains 'const' 'flip' leaves
  if (srcRefinedType.containsConst() &&
      isConstFieldDriven(srcRefinedType, /*isFlip=*/true)) {
    // Disallow assignment to non-'const' subaccesses of 'const' types
    if (srcType != srcRefinedType)
      return emitSubaccessError();
    if (failed(checkConstConditionality(src, srcType, srcDeclaration)))
      return failure();
  }
 
  return success();
}
 
/// Returns success if the given connect is the sole driver of its dest operand.
/// Returns failure if there are other connects driving the dest.
static LogicalResult checkSingleConnect(FConnectLike connect) {
  // For now, refs and domains can't be in bundles so this is sufficient. This
  // is insufficient for properties, and insufficient before
  // lower-open-aggregates has run. In the future, need to ensure no other
  // define's to same "fieldSource". (When aggregates can have references, we
  // can define a reference within, but this must be unique.  Checking this here
  // may be expensive, consider adding something to FModuleLike's to check it
  // there instead)
  auto dest = connect.getDest();
  for (auto *user : dest.getUsers()) {
    if (auto c = dyn_cast<FConnectLike>(user);
        c && c.getDest() == dest && c != connect) {
      auto diag = connect.emitError("destination cannot be driven by multiple "
                                    "operations");
      diag.attachNote(c->getLoc()) << "other driver is here";
      return failure();
    }
  }
  return success();
}
 
LogicalResult ConnectOp::verify() {
  auto dstType = getDest().getType();
  auto srcType = getSrc().getType();
  auto dstBaseType = type_dyn_cast<FIRRTLBaseType>(dstType);
  auto srcBaseType = type_dyn_cast<FIRRTLBaseType>(srcType);
  if (!dstBaseType || !srcBaseType) {
    if (dstType != srcType)
      return emitError("may not connect different non-base types");
  } else {
    // Analog types cannot be connected and must be attached.
    if (dstBaseType.containsAnalog() || srcBaseType.containsAnalog())
      return emitError("analog types may not be connected");
 
    // Destination and source types must be equivalent.
    if (!areTypesEquivalent(dstBaseType, srcBaseType))
      return emitError("type mismatch between destination ")
             << dstBaseType << " and source " << srcBaseType;
 
    // Truncation is banned in a connection: destination bit width must be
    // greater than or equal to source bit width.
    if (!isTypeLarger(dstBaseType, srcBaseType))
      return emitError("destination ")
             << dstBaseType << " is not as wide as the source " << srcBaseType;
  }
 
  // Check that the flows make sense.
  if (failed(checkConnectFlow(*this)))
    return failure();
 
  if (failed(checkConnectConditionality(*this)))
    return failure();
 
  return success();
}
 
LogicalResult MatchingConnectOp::verify() {
  if (auto type = type_dyn_cast<FIRRTLType>(getDest().getType())) {
    auto baseType = type_cast<FIRRTLBaseType>(type);
 
    // Analog types cannot be connected and must be attached.
    if (baseType && baseType.containsAnalog())
      return emitError("analog types may not be connected");
 
    // The anonymous types of operands must be equivalent.
    assert(areAnonymousTypesEquivalent(cast<FIRRTLBaseType>(getSrc().getType()),
                                       baseType) &&
           "`SameAnonTypeOperands` trait should have already rejected "
           "structurally non-equivalent types");
  }
 
  // Check that the flows make sense.
  if (failed(checkConnectFlow(*this)))
    return failure();
 
  if (failed(checkConnectConditionality(*this)))
    return failure();
 
  return success();
}
 
LogicalResult RefDefineOp::verify() {
  if (failed(checkConnectFlow(*this)))
    return failure();
 
  if (failed(checkSingleConnect(*this)))
    return failure();
 
  if (auto *op = getDest().getDefiningOp()) {
    // TODO: Make ref.sub only source flow?
    if (isa<RefSubOp>(op))
      return emitError(
          "destination reference cannot be a sub-element of a reference");
    if (isa<RefCastOp>(op)) // Source flow, check anyway for now.
      return emitError(
          "destination reference cannot be a cast of another reference");
  }
 
  // This define is only enabled when its ambient layers are active. Check
  // that whenever the destination's layer requirements are met, that this
  // op is enabled.
  auto ambientLayers = getAmbientLayersAt(getOperation());
  auto dstLayers = getLayersFor(getDest());
  SmallVector<SymbolRefAttr> missingLayers;
 
  return checkLayerCompatibility(getOperation(), ambientLayers, dstLayers,
                                 "has more layer requirements than destination",
                                 "additional layers required");
}
 
LogicalResult PropAssignOp::verify() {
  if (failed(checkConnectFlow(*this)))
    return failure();
 
  if (failed(checkSingleConnect(*this)))
    return failure();
 
  return success();
}
 
LogicalResult PropertyAssertOp::verify() {
  // Static evaluation: if the condition is a known constant false, the
  // assertion is trivially violated and we can report an error immediately.
  if (auto *defOp = getCondition().getDefiningOp())
    if (auto boolConst = dyn_cast<BoolConstantOp>(defOp))
      if (!boolConst.getValue())
        return emitOpError("property assertion is statically false");
  return success();
}
 
static FlatSymbolRefAttr getDomainTypeName(Value value) {
  auto domainType = dyn_cast<DomainType>(value.getType());
  if (!domainType)
    return {};
 
  // Domain information is now stored in the type itself
  return domainType.getName();
}
 
LogicalResult DomainDefineOp::verify() {
  if (failed(checkConnectFlow(*this)))
    return failure();
 
  if (failed(checkSingleConnect(*this)))
    return failure();
 
  auto dst = getDest();
  auto src = getSrc();
 
  // As wires cannot have domain information, don't do any checking when a wire
  // is involved.  This weakens the verification.
  //
  // TOOD: Remove this by adding Domain Info to wires [1].
  //
  // [1] https://github.com/llvm/circt/issues/9398
  if (auto *srcDefOp = src.getDefiningOp())
    if (isa<WireOp>(srcDefOp))
      return success();
  if (auto *dstDefOp = dst.getDefiningOp())
    if (isa<WireOp>(dstDefOp))
      return success();
 
  auto dstDomain = getDomainTypeName(dst);
  if (!dstDomain)
    return emitError("could not determine domain-type of destination");
 
  auto srcDomain = getDomainTypeName(src);
  if (!srcDomain)
    return emitError("could not determine domain-type of source");
 
  if (dstDomain != srcDomain) {
    auto diag = emitError()
                << "source domain type " << srcDomain
                << " does not match destination domain type " << dstDomain;
    return diag;
  }
 
  return success();
}
 
void WhenOp::createElseRegion() {
  assert(!hasElseRegion() && "already has an else region");
  getElseRegion().push_back(new Block());
}
 
void WhenOp::build(OpBuilder &builder, OperationState &result, Value condition,
                   bool withElseRegion, std::function<void()> thenCtor,
                   std::function<void()> elseCtor) {
  OpBuilder::InsertionGuard guard(builder);
  result.addOperands(condition);
 
  // Create "then" region.
  builder.createBlock(result.addRegion());
  if (thenCtor)
    thenCtor();
 
  // Create "else" region.
  Region *elseRegion = result.addRegion();
  if (withElseRegion) {
    builder.createBlock(elseRegion);
    if (elseCtor)
      elseCtor();
  }
}
 
//===----------------------------------------------------------------------===//
// MatchOp
//===----------------------------------------------------------------------===//
 
LogicalResult MatchOp::verify() {
  FEnumType type = getInput().getType();
 
  // Make sure that the number of tags matches the number of regions.
  auto numCases = getTags().size();
  auto numRegions = getNumRegions();
  if (numRegions != numCases)
    return emitOpError("expected ")
           << numRegions << " tags but got " << numCases;
 
  auto numTags = type.getNumElements();
 
  SmallDenseSet<int64_t> seen;
  for (const auto &[tag, region] : llvm::zip(getTags(), getRegions())) {
    auto tagIndex = size_t(cast<IntegerAttr>(tag).getInt());
 
    // Ensure that the block has a single argument.
    if (region.getNumArguments() != 1)
      return emitOpError("region should have exactly one argument");
 
    // Make sure that it is a valid tag.
    if (tagIndex >= numTags)
      return emitOpError("the tag index ")
             << tagIndex << " is out of the range of valid tags in " << type;
 
    // Make sure we have not already matched this tag.
    auto [it, inserted] = seen.insert(tagIndex);
    if (!inserted)
      return emitOpError("the tag ") << type.getElementNameAttr(tagIndex)
                                     << " is matched more than once";
 
    // Check that the block argument type matches the tag's type.
    auto expectedType = type.getElementTypePreservingConst(tagIndex);
    auto regionType = region.getArgument(0).getType();
    if (regionType != expectedType)
      return emitOpError("region type ")
             << regionType << " does not match the expected type "
             << expectedType;
  }
 
  // Check that the match statement is exhaustive.
  for (size_t i = 0, e = type.getNumElements(); i < e; ++i)
    if (!seen.contains(i))
      return emitOpError("missing case for tag ") << type.getElementNameAttr(i);
 
  return success();
}
 
void MatchOp::print(OpAsmPrinter &p) {
  auto input = getInput();
  FEnumType type = input.getType();
  auto regions = getRegions();
  p << " " << input << " : " << type;
  SmallVector<StringRef> elided = {"tags"};
  p.printOptionalAttrDictWithKeyword((*this)->getAttrs(), elided);
  p << " {";
  p.increaseIndent();
  for (const auto &[tag, region] : llvm::zip(getTags(), regions)) {
    p.printNewline();
    p << "case ";
    p.printKeywordOrString(
        type.getElementName(cast<IntegerAttr>(tag).getInt()));
    p << "(";
    p.printRegionArgument(region.front().getArgument(0), /*attrs=*/{},
                          /*omitType=*/true);
    p << ") ";
    p.printRegion(region, /*printEntryBlockArgs=*/false);
  }
  p.decreaseIndent();
  p.printNewline();
  p << "}";
}
 
ParseResult MatchOp::parse(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
  OpAsmParser::UnresolvedOperand input;
  if (parser.parseOperand(input) || parser.parseColon())
    return failure();
 
  auto loc = parser.getCurrentLocation();
  Type type;
  if (parser.parseType(type))
    return failure();
  auto enumType = type_dyn_cast<FEnumType>(type);
  if (!enumType)
    return parser.emitError(loc, "expected enumeration type but got") << type;
 
  if (parser.resolveOperand(input, type, result.operands) ||
      parser.parseOptionalAttrDictWithKeyword(result.attributes) ||
      parser.parseLBrace())
    return failure();
 
  auto i32Type = IntegerType::get(context, 32);
  SmallVector<Attribute> tags;
  while (true) {
    // Stop parsing when we don't find another "case" keyword.
    if (failed(parser.parseOptionalKeyword("case")))
      break;
 
    // Parse the tag and region argument.
    auto nameLoc = parser.getCurrentLocation();
    std::string name;
    OpAsmParser::Argument arg;
    auto *region = result.addRegion();
    if (parser.parseKeywordOrString(&name) || parser.parseLParen() ||
        parser.parseArgument(arg) || parser.parseRParen())
      return failure();
 
    // Figure out the enum index of the tag.
    auto index = enumType.getElementIndex(name);
    if (!index)
      return parser.emitError(nameLoc, "the tag \"")
             << name << "\" is not a member of the enumeration " << enumType;
    tags.push_back(IntegerAttr::get(i32Type, *index));
 
    // Parse the region.
    arg.type = enumType.getElementTypePreservingConst(*index);
    if (parser.parseRegion(*region, arg))
      return failure();
  }
  properties.setTags(ArrayAttr::get(context, tags));
 
  return parser.parseRBrace();
}
 
void MatchOp::build(OpBuilder &builder, OperationState &result, Value input,
                    ArrayAttr tags,
                    MutableArrayRef<std::unique_ptr<Region>> regions) {
  auto &properties = result.getOrAddProperties<Properties>();
  result.addOperands(input);
  properties.setTags(tags);
  result.addRegions(regions);
}
 
//===----------------------------------------------------------------------===//
// Expressions
//===----------------------------------------------------------------------===//
 
/// Return true if the specified operation is a firrtl expression.
bool firrtl::isExpression(Operation *op) {
  struct IsExprClassifier : public ExprVisitor<IsExprClassifier, bool> {
    bool visitInvalidExpr(Operation *op) { return false; }
    bool visitUnhandledExpr(Operation *op) { return true; }
  };
 
  return IsExprClassifier().dispatchExprVisitor(op);
}
 
void InvalidValueOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  // Set invalid values to have a distinct name.
  std::string name;
  if (auto ty = type_dyn_cast<IntType>(getType())) {
    const char *base = ty.isSigned() ? "invalid_si" : "invalid_ui";
    auto width = ty.getWidthOrSentinel();
    if (width == -1)
      name = base;
    else
      name = (Twine(base) + Twine(width)).str();
  } else if (auto ty = type_dyn_cast<AnalogType>(getType())) {
    auto width = ty.getWidthOrSentinel();
    if (width == -1)
      name = "invalid_analog";
    else
      name = ("invalid_analog" + Twine(width)).str();
  } else if (type_isa<AsyncResetType>(getType()))
    name = "invalid_asyncreset";
  else if (type_isa<ResetType>(getType()))
    name = "invalid_reset";
  else if (type_isa<ClockType>(getType()))
    name = "invalid_clock";
  else
    name = "invalid";
 
  setNameFn(getResult(), name);
}
 
void ConstantOp::print(OpAsmPrinter &p) {
  p << " ";
  p.printAttributeWithoutType(getValueAttr());
  p << " : ";
  p.printType(getType());
  p.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});
}
 
ParseResult ConstantOp::parse(OpAsmParser &parser, OperationState &result) {
  auto &properties = result.getOrAddProperties<Properties>();
  // Parse the constant value, without knowing its width.
  APInt value;
  auto loc = parser.getCurrentLocation();
  auto valueResult = parser.parseOptionalInteger(value);
  if (!valueResult.has_value())
    return parser.emitError(loc, "expected integer value");
 
  // Parse the result firrtl integer type.
  IntType resultType;
  if (failed(*valueResult) || parser.parseColonType(resultType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
  result.addTypes(resultType);
 
  // Now that we know the width and sign of the result type, we can munge the
  // APInt as appropriate.
  if (resultType.hasWidth()) {
    auto width = (unsigned)resultType.getWidthOrSentinel();
    if (width > value.getBitWidth()) {
      // sext is always safe here, even for unsigned values, because the
      // parseOptionalInteger method will return something with a zero in the
      // top bits if it is a positive number.
      value = value.sext(width);
    } else if (width < value.getBitWidth()) {
      // The parser can return an unnecessarily wide result with leading
      // zeros. This isn't a problem, but truncating off bits is bad.
      unsigned neededBits = value.isNegative() ? value.getSignificantBits()
                                               : value.getActiveBits();
      if (width < neededBits)
        return parser.emitError(loc, "constant out of range for result type ")
               << resultType;
      value = value.trunc(width);
    }
  }
 
  auto intType = parser.getBuilder().getIntegerType(value.getBitWidth(),
                                                    resultType.isSigned());
  auto valueAttr = parser.getBuilder().getIntegerAttr(intType, value);
  properties.setValue(valueAttr);
  return success();
}
 
LogicalResult ConstantOp::verify() {
  // If the result type has a bitwidth, then the attribute must match its width.
  IntType intType = getType();
  auto width = intType.getWidthOrSentinel();
  if (width != -1 && (int)getValue().getBitWidth() != width)
    return emitError(
        "firrtl.constant attribute bitwidth doesn't match return type");
 
  // The sign of the attribute's integer type must match our integer type sign.
  auto attrType = type_cast<IntegerType>(getValueAttr().getType());
  if (attrType.isSignless() || attrType.isSigned() != intType.isSigned())
    return emitError("firrtl.constant attribute has wrong sign");
 
  return success();
}
 
/// Build a ConstantOp from an APInt and a FIRRTL type, handling the attribute
/// formation for the 'value' attribute.
void ConstantOp::build(OpBuilder &builder, OperationState &result, IntType type,
                       const APInt &value) {
  int32_t width = type.getWidthOrSentinel();
  (void)width;
  assert((width == -1 || (int32_t)value.getBitWidth() == width) &&
         "incorrect attribute bitwidth for firrtl.constant");
 
  auto attr =
      IntegerAttr::get(type.getContext(), APSInt(value, !type.isSigned()));
  return build(builder, result, type, attr);
}
 
/// Build a ConstantOp from an APSInt, handling the attribute formation for the
/// 'value' attribute and inferring the FIRRTL type.
void ConstantOp::build(OpBuilder &builder, OperationState &result,
                       const APSInt &value) {
  auto attr = IntegerAttr::get(builder.getContext(), value);
  auto type =
      IntType::get(builder.getContext(), value.isSigned(), value.getBitWidth());
  return build(builder, result, type, attr);
}
 
void ConstantOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  // For constants in particular, propagate the value into the result name to
  // make it easier to read the IR.
  IntType intTy = getType();
  assert(intTy);
 
  // Otherwise, build a complex name with the value and type.
  SmallString<32> specialNameBuffer;
  llvm::raw_svector_ostream specialName(specialNameBuffer);
  specialName << 'c';
  getValue().print(specialName, /*isSigned:*/ intTy.isSigned());
 
  specialName << (intTy.isSigned() ? "_si" : "_ui");
  auto width = intTy.getWidthOrSentinel();
  if (width != -1)
    specialName << width;
  setNameFn(getResult(), specialName.str());
}
 
void SpecialConstantOp::print(OpAsmPrinter &p) {
  p << " ";
  // SpecialConstant uses a BoolAttr, and we want to print `true` as `1`.
  p << static_cast<unsigned>(getValue());
  p << " : ";
  p.printType(getType());
  p.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});
}
 
ParseResult SpecialConstantOp::parse(OpAsmParser &parser,
                                     OperationState &result) {
  auto &properties = result.getOrAddProperties<Properties>();
  // Parse the constant value.  SpecialConstant uses bool attributes, but it
  // prints as an integer.
  APInt value;
  auto loc = parser.getCurrentLocation();
  auto valueResult = parser.parseOptionalInteger(value);
  if (!valueResult.has_value())
    return parser.emitError(loc, "expected integer value");
 
  // Clocks and resets can only be 0 or 1.
  if (value != 0 && value != 1)
    return parser.emitError(loc, "special constants can only be 0 or 1.");
 
  // Parse the result firrtl type.
  Type resultType;
  if (failed(*valueResult) || parser.parseColonType(resultType) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
  result.addTypes(resultType);
 
  // Create the attribute.
  auto valueAttr = parser.getBuilder().getBoolAttr(value == 1);
  properties.setValue(valueAttr);
  return success();
}
 
void SpecialConstantOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  SmallString<32> specialNameBuffer;
  llvm::raw_svector_ostream specialName(specialNameBuffer);
  specialName << 'c';
  specialName << static_cast<unsigned>(getValue());
  auto type = getType();
  if (type_isa<ClockType>(type)) {
    specialName << "_clock";
  } else if (type_isa<ResetType>(type)) {
    specialName << "_reset";
  } else if (type_isa<AsyncResetType>(type)) {
    specialName << "_asyncreset";
  }
  setNameFn(getResult(), specialName.str());
}
 
// Checks that an array attr representing an aggregate constant has the correct
// shape.  This recurses on the type.
static bool checkAggConstant(Operation *op, Attribute attr,
                             FIRRTLBaseType type) {
  if (type.isGround()) {
    if (!isa<IntegerAttr>(attr)) {
      op->emitOpError("Ground type is not an integer attribute");
      return false;
    }
    return true;
  }
  auto attrlist = dyn_cast<ArrayAttr>(attr);
  if (!attrlist) {
    op->emitOpError("expected array attribute for aggregate constant");
    return false;
  }
  if (auto array = type_dyn_cast<FVectorType>(type)) {
    if (array.getNumElements() != attrlist.size()) {
      op->emitOpError("array attribute (")
          << attrlist.size() << ") has wrong size for vector constant ("
          << array.getNumElements() << ")";
      return false;
    }
    return llvm::all_of(attrlist, [&array, op](Attribute attr) {
      return checkAggConstant(op, attr, array.getElementType());
    });
  }
  if (auto bundle = type_dyn_cast<BundleType>(type)) {
    if (bundle.getNumElements() != attrlist.size()) {
      op->emitOpError("array attribute (")
          << attrlist.size() << ") has wrong size for bundle constant ("
          << bundle.getNumElements() << ")";
      return false;
    }
    for (size_t i = 0; i < bundle.getNumElements(); ++i) {
      if (bundle.getElement(i).isFlip) {
        op->emitOpError("Cannot have constant bundle type with flip");
        return false;
      }
      if (!checkAggConstant(op, attrlist[i], bundle.getElement(i).type))
        return false;
    }
    return true;
  }
  op->emitOpError("Unknown aggregate type");
  return false;
}
 
LogicalResult AggregateConstantOp::verify() {
  if (checkAggConstant(getOperation(), getFields(), getType()))
    return success();
  return failure();
}
 
Attribute AggregateConstantOp::getAttributeFromFieldID(uint64_t fieldID) {
  FIRRTLBaseType type = getType();
  Attribute value = getFields();
  while (fieldID != 0) {
    if (auto bundle = type_dyn_cast<BundleType>(type)) {
      auto index = bundle.getIndexForFieldID(fieldID);
      fieldID -= bundle.getFieldID(index);
      type = bundle.getElementType(index);
      value = cast<ArrayAttr>(value)[index];
    } else {
      auto vector = type_cast<FVectorType>(type);
      auto index = vector.getIndexForFieldID(fieldID);
      fieldID -= vector.getFieldID(index);
      type = vector.getElementType();
      value = cast<ArrayAttr>(value)[index];
    }
  }
  return value;
}
 
LogicalResult FIntegerConstantOp::verify() {
  auto i = getValueAttr();
  if (!i.getType().isSignedInteger())
    return emitOpError("value must be signed");
  return success();
}
 
void FIntegerConstantOp::print(OpAsmPrinter &p) {
  p << " ";
  p.printAttributeWithoutType(getValueAttr());
  p.printOptionalAttrDict((*this)->getAttrs(), /*elidedAttrs=*/{"value"});
}
 
ParseResult FIntegerConstantOp::parse(OpAsmParser &parser,
                                      OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
  APInt value;
  if (parser.parseInteger(value) ||
      parser.parseOptionalAttrDict(result.attributes))
    return failure();
  result.addTypes(FIntegerType::get(context));
  auto intType =
      IntegerType::get(context, value.getBitWidth(), IntegerType::Signed);
  auto valueAttr = parser.getBuilder().getIntegerAttr(intType, value);
  properties.setValue(valueAttr);
  return success();
}
 
ParseResult ListCreateOp::parse(OpAsmParser &parser, OperationState &result) {
  llvm::SmallVector<OpAsmParser::UnresolvedOperand, 16> operands;
  ListType type;
 
  if (parser.parseOperandList(operands) ||
      parser.parseOptionalAttrDict(result.attributes) ||
      parser.parseColonType(type))
    return failure();
  result.addTypes(type);
 
  return parser.resolveOperands(operands, type.getElementType(),
                                result.operands);
}
 
void ListCreateOp::print(OpAsmPrinter &p) {
  p << " ";
  p.printOperands(getElements());
  p.printOptionalAttrDict((*this)->getAttrs());
  p << " : " << getType();
}
 
LogicalResult ListCreateOp::verify() {
  if (getElements().empty())
    return success();
 
  auto elementType = getElements().front().getType();
  auto listElementType = getType().getElementType();
  if (elementType != listElementType)
    return emitOpError("has elements of type ")
           << elementType << " instead of " << listElementType;
 
  return success();
}
 
LogicalResult BundleCreateOp::verify() {
  BundleType resultType = getType();
  if (resultType.getNumElements() != getFields().size())
    return emitOpError("number of fields doesn't match type");
  for (size_t i = 0; i < resultType.getNumElements(); ++i)
    if (!areTypesConstCastable(
            resultType.getElementTypePreservingConst(i),
            type_cast<FIRRTLBaseType>(getOperand(i).getType())))
      return emitOpError("type of element doesn't match bundle for field ")
             << resultType.getElement(i).name;
  // TODO: check flow
  return success();
}
 
LogicalResult VectorCreateOp::verify() {
  FVectorType resultType = getType();
  if (resultType.getNumElements() != getFields().size())
    return emitOpError("number of fields doesn't match type");
  auto elemTy = resultType.getElementTypePreservingConst();
  for (size_t i = 0; i < resultType.getNumElements(); ++i)
    if (!areTypesConstCastable(
            elemTy, type_cast<FIRRTLBaseType>(getOperand(i).getType())))
      return emitOpError("type of element doesn't match vector element");
  // TODO: check flow
  return success();
}
 
LogicalResult
UnknownValueOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  // Unknown values of non-class type don't need to be verified.
  auto classType = dyn_cast<ClassType>(getType());
  if (!classType)
    return success();
 
  auto className = classType.getNameAttr();
  // Verify that the symbol exists.
  Operation *op = symbolTable.lookupNearestSymbolFrom(*this, className);
  if (!op)
    return emitOpError() << "refers to non-existent class ("
                         << className.getAttr() << ")";
 
  // Verify that the symbol is on a classlike.
  if (!isa<ClassLike>(op))
    return emitOpError() << "refers to a non-class type ("
                         << className.getAttr() << ")";
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// FEnumCreateOp
//===----------------------------------------------------------------------===//
 
LogicalResult FEnumCreateOp::verify() {
  FEnumType resultType = getResult().getType();
  auto elementIndex = resultType.getElementIndex(getFieldName());
  if (!elementIndex)
    return emitOpError("label ")
           << getFieldName() << " is not a member of the enumeration type "
           << resultType;
  if (!areTypesConstCastable(
          resultType.getElementTypePreservingConst(*elementIndex),
          getInput().getType()))
    return emitOpError("type of element doesn't match enum element");
  return success();
}
 
void FEnumCreateOp::print(OpAsmPrinter &printer) {
  printer << ' ';
  printer.printKeywordOrString(getFieldName());
  printer << '(' << getInput() << ')';
  SmallVector<StringRef> elidedAttrs = {"fieldIndex"};
  printer.printOptionalAttrDictWithKeyword((*this)->getAttrs(), elidedAttrs);
  printer << " : ";
  printer.printFunctionalType(ArrayRef<Type>{getInput().getType()},
                              ArrayRef<Type>{getResult().getType()});
}
 
ParseResult FEnumCreateOp::parse(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  mlir::FunctionType functionType;
  if (parser.parseKeywordOrString(&fieldName) || parser.parseLParen() ||
      parser.parseOperand(input) || parser.parseRParen() ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(functionType))
    return failure();
 
  if (functionType.getNumInputs() != 1)
    return parser.emitError(parser.getNameLoc(), "single input type required");
  if (functionType.getNumResults() != 1)
    return parser.emitError(parser.getNameLoc(), "single result type required");
 
  auto inputType = functionType.getInput(0);
  if (parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  auto outputType = functionType.getResult(0);
  auto enumType = type_dyn_cast<FEnumType>(outputType);
  if (!enumType)
    return parser.emitError(parser.getNameLoc(),
                            "output must be enum type, got ")
           << outputType;
  auto fieldIndex = enumType.getElementIndex(fieldName);
  if (!fieldIndex)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field " + fieldName + " in enum type ")
           << enumType;
 
  properties.setFieldIndex(
      IntegerAttr::get(IntegerType::get(context, 32), *fieldIndex));
 
  result.addTypes(enumType);
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// IsTagOp
//===----------------------------------------------------------------------===//
 
LogicalResult IsTagOp::verify() {
  if (getFieldIndex() >= getInput().getType().base().getNumElements())
    return emitOpError("element index is greater than the number of fields in "
                       "the bundle type");
  return success();
}
 
void IsTagOp::print(::mlir::OpAsmPrinter &printer) {
  printer << ' ' << getInput() << ' ';
  printer.printKeywordOrString(getFieldName());
  SmallVector<::llvm::StringRef, 1> elidedAttrs = {"fieldIndex"};
  printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
  printer << " : " << getInput().getType();
}
 
ParseResult IsTagOp::parse(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
  auto &properties = result.getOrAddProperties<Properties>();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  Type inputType;
  if (parser.parseOperand(input) || parser.parseKeywordOrString(&fieldName) ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(inputType))
    return failure();
 
  if (parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  auto enumType = type_dyn_cast<FEnumType>(inputType);
  if (!enumType)
    return parser.emitError(parser.getNameLoc(),
                            "input must be enum type, got ")
           << inputType;
  auto fieldIndex = enumType.getElementIndex(fieldName);
  if (!fieldIndex)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field " + fieldName + " in enum type ")
           << enumType;
 
  properties.setFieldIndex(
      IntegerAttr::get(IntegerType::get(context, 32), *fieldIndex));
 
  result.addTypes(UIntType::get(context, 1, /*isConst=*/false));
 
  return success();
}
 
FIRRTLType IsTagOp::inferReturnType(ValueRange operands, DictionaryAttr attrs,
                                    PropertyRef properties,
                                    mlir::RegionRange regions,
                                    std::optional<Location> loc) {
  Adaptor adaptor(operands, attrs, properties, regions);
  return UIntType::get(attrs.getContext(), 1,
                       isConst(adaptor.getInput().getType()));
}
 
template <typename OpTy>
ParseResult parseSubfieldLikeOp(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  Type inputType;
  if (parser.parseOperand(input) || parser.parseLSquare() ||
      parser.parseKeywordOrString(&fieldName) || parser.parseRSquare() ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(inputType))
    return failure();
 
  if (parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  auto bundleType = type_dyn_cast<typename OpTy::InputType>(inputType);
  if (!bundleType)
    return parser.emitError(parser.getNameLoc(),
                            "input must be bundle type, got ")
           << inputType;
  auto fieldIndex = bundleType.getElementIndex(fieldName);
  if (!fieldIndex)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field " + fieldName + " in bundle type ")
           << bundleType;
 
  result.getOrAddProperties<typename OpTy::Properties>().setFieldIndex(
      IntegerAttr::get(IntegerType::get(context, 32), *fieldIndex));
 
  auto type = OpTy::inferReturnType(inputType, *fieldIndex, {});
  if (!type)
    return failure();
  result.addTypes(type);
 
  return success();
}
 
ParseResult SubtagOp::parse(OpAsmParser &parser, OperationState &result) {
  auto *context = parser.getContext();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  Type inputType;
  if (parser.parseOperand(input) || parser.parseLSquare() ||
      parser.parseKeywordOrString(&fieldName) || parser.parseRSquare() ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(inputType))
    return failure();
 
  if (parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  auto enumType = type_dyn_cast<FEnumType>(inputType);
  if (!enumType)
    return parser.emitError(parser.getNameLoc(),
                            "input must be enum type, got ")
           << inputType;
  auto fieldIndex = enumType.getElementIndex(fieldName);
  if (!fieldIndex)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field " + fieldName + " in enum type ")
           << enumType;
 
  result.getOrAddProperties<Properties>().setFieldIndex(
      IntegerAttr::get(IntegerType::get(context, 32), *fieldIndex));
 
  SmallVector<Type> inferredReturnTypes;
  if (failed(SubtagOp::inferReturnTypes(
          context, result.location, result.operands,
          result.attributes.getDictionary(context), result.getRawProperties(),
          result.regions, inferredReturnTypes)))
    return failure();
  result.addTypes(inferredReturnTypes);
 
  return success();
}
 
ParseResult SubfieldOp::parse(OpAsmParser &parser, OperationState &result) {
  return parseSubfieldLikeOp<SubfieldOp>(parser, result);
}
ParseResult OpenSubfieldOp::parse(OpAsmParser &parser, OperationState &result) {
  return parseSubfieldLikeOp<OpenSubfieldOp>(parser, result);
}
 
template <typename OpTy>
static void printSubfieldLikeOp(OpTy op, ::mlir::OpAsmPrinter &printer) {
  printer << ' ' << op.getInput() << '[';
  printer.printKeywordOrString(op.getFieldName());
  printer << ']';
  ::llvm::SmallVector<::llvm::StringRef, 2> elidedAttrs;
  elidedAttrs.push_back("fieldIndex");
  printer.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
  printer << " : " << op.getInput().getType();
}
void SubfieldOp::print(::mlir::OpAsmPrinter &printer) {
  return printSubfieldLikeOp<SubfieldOp>(*this, printer);
}
void OpenSubfieldOp::print(::mlir::OpAsmPrinter &printer) {
  return printSubfieldLikeOp<OpenSubfieldOp>(*this, printer);
}
 
void SubtagOp::print(::mlir::OpAsmPrinter &printer) {
  printer << ' ' << getInput() << '[';
  printer.printKeywordOrString(getFieldName());
  printer << ']';
  ::llvm::SmallVector<::llvm::StringRef, 2> elidedAttrs;
  elidedAttrs.push_back("fieldIndex");
  printer.printOptionalAttrDict((*this)->getAttrs(), elidedAttrs);
  printer << " : " << getInput().getType();
}
 
template <typename OpTy>
static LogicalResult verifySubfieldLike(OpTy op) {
  if (op.getFieldIndex() >=
      firrtl::type_cast<typename OpTy::InputType>(op.getInput().getType())
          .getNumElements())
    return op.emitOpError("subfield element index is greater than the number "
                          "of fields in the bundle type");
  return success();
}
LogicalResult SubfieldOp::verify() {
  return verifySubfieldLike<SubfieldOp>(*this);
}
LogicalResult OpenSubfieldOp::verify() {
  return verifySubfieldLike<OpenSubfieldOp>(*this);
}
 
LogicalResult SubtagOp::verify() {
  if (getFieldIndex() >= getInput().getType().base().getNumElements())
    return emitOpError("subfield element index is greater than the number "
                       "of fields in the bundle type");
  return success();
}
 
/// Return true if the specified operation has a constant value. This trivially
/// checks for `firrtl.constant` and friends, but also looks through subaccesses
/// and correctly handles wires driven with only constant values.
bool firrtl::isConstant(Operation *op) {
  // Worklist of ops that need to be examined that should all be constant in
  // order for the input operation to be constant.
  SmallVector<Operation *, 8> worklist({op});
 
  // Mutable state indicating if this op is a constant.  Assume it is a constant
  // and look for counterexamples.
  bool constant = true;
 
  // While we haven't found a counterexample and there are still ops in the
  // worklist, pull ops off the worklist.  If it provides a counterexample, set
  // the `constant` to false (and exit on the next loop iteration).  Otherwise,
  // look through the op or spawn off more ops to look at.
  while (constant && !(worklist.empty()))
    TypeSwitch<Operation *>(worklist.pop_back_val())
        .Case<NodeOp, AsSIntPrimOp, AsUIntPrimOp>([&](auto op) {
          if (auto definingOp = op.getInput().getDefiningOp())
            worklist.push_back(definingOp);
          constant = false;
        })
        .Case<WireOp, SubindexOp, SubfieldOp>([&](auto op) {
          for (auto &use : op.getResult().getUses())
            worklist.push_back(use.getOwner());
        })
        .Case<ConstantOp, SpecialConstantOp, AggregateConstantOp>([](auto) {})
        .Default([&](auto) { constant = false; });
 
  return constant;
}
 
/// Return true if the specified value is a constant. This trivially checks for
/// `firrtl.constant` and friends, but also looks through subaccesses and
/// correctly handles wires driven with only constant values.
bool firrtl::isConstant(Value value) {
  if (auto *op = value.getDefiningOp())
    return isConstant(op);
  return false;
}
 
LogicalResult ConstCastOp::verify() {
  if (!areTypesConstCastable(getResult().getType(), getInput().getType()))
    return emitOpError() << getInput().getType()
                         << " is not 'const'-castable to "
                         << getResult().getType();
  return success();
}
 
FIRRTLType SubfieldOp::inferReturnType(Type type, uint32_t fieldIndex,
                                       std::optional<Location> loc) {
  auto inType = type_cast<BundleType>(type);
 
  if (fieldIndex >= inType.getNumElements())
    return emitInferRetTypeError(loc,
                                 "subfield element index is greater than the "
                                 "number of fields in the bundle type");
 
  // SubfieldOp verifier checks that the field index is valid with number of
  // subelements.
  return inType.getElementTypePreservingConst(fieldIndex);
}
 
FIRRTLType OpenSubfieldOp::inferReturnType(Type type, uint32_t fieldIndex,
                                           std::optional<Location> loc) {
  auto inType = type_cast<OpenBundleType>(type);
 
  if (fieldIndex >= inType.getNumElements())
    return emitInferRetTypeError(loc,
                                 "subfield element index is greater than the "
                                 "number of fields in the bundle type");
 
  // OpenSubfieldOp verifier checks that the field index is valid with number of
  // subelements.
  return inType.getElementTypePreservingConst(fieldIndex);
}
 
bool SubfieldOp::isFieldFlipped() {
  BundleType bundle = getInput().getType();
  return bundle.getElement(getFieldIndex()).isFlip;
}
bool OpenSubfieldOp::isFieldFlipped() {
  auto bundle = getInput().getType();
  return bundle.getElement(getFieldIndex()).isFlip;
}
 
FIRRTLType SubindexOp::inferReturnType(Type type, uint32_t fieldIndex,
                                       std::optional<Location> loc) {
  if (auto vectorType = type_dyn_cast<FVectorType>(type)) {
    if (fieldIndex < vectorType.getNumElements())
      return vectorType.getElementTypePreservingConst();
    return emitInferRetTypeError(loc, "out of range index '", fieldIndex,
                                 "' in vector type ", type);
  }
  return emitInferRetTypeError(loc, "subindex requires vector operand");
}
 
FIRRTLType OpenSubindexOp::inferReturnType(Type type, uint32_t fieldIndex,
                                           std::optional<Location> loc) {
  if (auto vectorType = type_dyn_cast<OpenVectorType>(type)) {
    if (fieldIndex < vectorType.getNumElements())
      return vectorType.getElementTypePreservingConst();
    return emitInferRetTypeError(loc, "out of range index '", fieldIndex,
                                 "' in vector type ", type);
  }
 
  return emitInferRetTypeError(loc, "subindex requires vector operand");
}
 
FIRRTLType SubtagOp::inferReturnType(ValueRange operands, DictionaryAttr attrs,
                                     PropertyRef properties,
                                     mlir::RegionRange regions,
                                     std::optional<Location> loc) {
  Adaptor adaptor(operands, attrs, properties, regions);
  auto inType = type_cast<FEnumType>(adaptor.getInput().getType());
  auto fieldIndex = adaptor.getFieldIndex();
 
  if (fieldIndex >= inType.getNumElements())
    return emitInferRetTypeError(loc,
                                 "subtag element index is greater than the "
                                 "number of fields in the enum type");
 
  // SubtagOp verifier checks that the field index is valid with number of
  // subelements.
  auto elementType = inType.getElement(fieldIndex).type;
  return elementType.getConstType(elementType.isConst() || inType.isConst());
}
 
FIRRTLType SubaccessOp::inferReturnType(Type inType, Type indexType,
                                        std::optional<Location> loc) {
  if (!type_isa<UIntType>(indexType))
    return emitInferRetTypeError(loc, "subaccess index must be UInt type, not ",
                                 indexType);
 
  if (auto vectorType = type_dyn_cast<FVectorType>(inType)) {
    if (isConst(indexType))
      return vectorType.getElementTypePreservingConst();
    return vectorType.getElementType().getAllConstDroppedType();
  }
 
  return emitInferRetTypeError(loc, "subaccess requires vector operand, not ",
                               inType);
}
 
FIRRTLType TagExtractOp::inferReturnType(FIRRTLType input,
                                         std::optional<Location> loc) {
  auto inType = type_cast<FEnumType>(input);
  return UIntType::get(inType.getContext(), inType.getTagWidth());
}
 
ParseResult MultibitMuxOp::parse(OpAsmParser &parser, OperationState &result) {
  OpAsmParser::UnresolvedOperand index;
  SmallVector<OpAsmParser::UnresolvedOperand, 16> inputs;
  Type indexType, elemType;
 
  if (parser.parseOperand(index) || parser.parseComma() ||
      parser.parseOperandList(inputs) ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(indexType) || parser.parseComma() ||
      parser.parseType(elemType))
    return failure();
 
  if (parser.resolveOperand(index, indexType, result.operands))
    return failure();
 
  result.addTypes(elemType);
 
  return parser.resolveOperands(inputs, elemType, result.operands);
}
 
void MultibitMuxOp::print(OpAsmPrinter &p) {
  p << " " << getIndex() << ", ";
  p.printOperands(getInputs());
  p.printOptionalAttrDict((*this)->getAttrs());
  p << " : " << getIndex().getType() << ", " << getType();
}
 
FIRRTLType MultibitMuxOp::inferReturnType(ValueRange operands,
                                          DictionaryAttr attrs,
                                          PropertyRef properties,
                                          mlir::RegionRange regions,
                                          std::optional<Location> loc) {
  if (operands.size() < 2)
    return emitInferRetTypeError(loc, "at least one input is required");
 
  // Check all mux inputs have the same type.
  if (!llvm::all_of(operands.drop_front(2), [&](auto op) {
        return operands[1].getType() == op.getType();
      }))
    return emitInferRetTypeError(loc, "all inputs must have the same type");
 
  return type_cast<FIRRTLType>(operands[1].getType());
}
 
//===----------------------------------------------------------------------===//
// ObjectSubfieldOp
//===----------------------------------------------------------------------===//
 
LogicalResult ObjectSubfieldOp::inferReturnTypes(
    MLIRContext *context, std::optional<mlir::Location> location,
    ValueRange operands, DictionaryAttr attributes, PropertyRef properties,
    RegionRange regions, llvm::SmallVectorImpl<Type> &inferredReturnTypes) {
  auto type =
      inferReturnType(operands, attributes, properties, regions, location);
  if (!type)
    return failure();
  inferredReturnTypes.push_back(type);
  return success();
}
 
Type ObjectSubfieldOp::inferReturnType(Type inType, uint32_t fieldIndex,
                                       std::optional<Location> loc) {
  auto classType = dyn_cast<ClassType>(inType);
  if (!classType)
    return emitInferRetTypeError(loc, "base object is not a class");
 
  if (classType.getNumElements() <= fieldIndex)
    return emitInferRetTypeError(loc, "element index is greater than the "
                                      "number of fields in the object");
  return classType.getElement(fieldIndex).type;
}
 
void ObjectSubfieldOp::print(OpAsmPrinter &p) {
  auto input = getInput();
  auto classType = input.getType();
  p << ' ' << input << "[";
  p.printKeywordOrString(classType.getElement(getIndex()).name);
  p << "]";
  p.printOptionalAttrDict((*this)->getAttrs(), std::array{StringRef("index")});
  p << " : " << classType;
}
 
ParseResult ObjectSubfieldOp::parse(OpAsmParser &parser,
                                    OperationState &result) {
  auto *context = parser.getContext();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  ClassType inputType;
  if (parser.parseOperand(input) || parser.parseLSquare() ||
      parser.parseKeywordOrString(&fieldName) || parser.parseRSquare() ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(inputType) ||
      parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  auto index = inputType.getElementIndex(fieldName);
  if (!index)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field " + fieldName + " in class type ")
           << inputType;
  result.getOrAddProperties<Properties>().setIndex(
      IntegerAttr::get(IntegerType::get(context, 32), *index));
 
  SmallVector<Type> inferredReturnTypes;
  if (failed(inferReturnTypes(context, result.location, result.operands,
                              result.attributes.getDictionary(context),
                              result.getRawProperties(), result.regions,
                              inferredReturnTypes)))
    return failure();
  result.addTypes(inferredReturnTypes);
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// Binary Primitives
//===----------------------------------------------------------------------===//
 
/// If LHS and RHS are both UInt or SInt types, the return true and fill in the
/// width of them if known.  If unknown, return -1 for the widths.
/// The constness of the result is also returned, where if both lhs and rhs are
/// const, then the result is const.
///
/// On failure, this reports and error and returns false.  This function should
/// not be used if you don't want an error reported.
static bool isSameIntTypeKind(Type lhs, Type rhs, int32_t &lhsWidth,
                              int32_t &rhsWidth, bool &isConstResult,
                              std::optional<Location> loc) {
  // Must have two integer types with the same signedness.
  auto lhsi = type_dyn_cast<IntType>(lhs);
  auto rhsi = type_dyn_cast<IntType>(rhs);
  if (!lhsi || !rhsi || lhsi.isSigned() != rhsi.isSigned()) {
    if (loc) {
      if (lhsi && !rhsi)
        mlir::emitError(*loc, "second operand must be an integer type, not ")
            << rhs;
      else if (!lhsi && rhsi)
        mlir::emitError(*loc, "first operand must be an integer type, not ")
            << lhs;
      else if (!lhsi && !rhsi)
        mlir::emitError(*loc, "operands must be integer types, not ")
            << lhs << " and " << rhs;
      else
        mlir::emitError(*loc, "operand signedness must match");
    }
    return false;
  }
 
  lhsWidth = lhsi.getWidthOrSentinel();
  rhsWidth = rhsi.getWidthOrSentinel();
  isConstResult = lhsi.isConst() && rhsi.isConst();
  return true;
}
 
LogicalResult impl::verifySameOperandsIntTypeKind(Operation *op) {
  assert(op->getNumOperands() == 2 &&
         "SameOperandsIntTypeKind on non-binary op");
  int32_t lhsWidth, rhsWidth;
  bool isConstResult;
  return success(isSameIntTypeKind(op->getOperand(0).getType(),
                                   op->getOperand(1).getType(), lhsWidth,
                                   rhsWidth, isConstResult, op->getLoc()));
}
 
FIRRTLType impl::inferAddSubResult(FIRRTLType lhs, FIRRTLType rhs,
                                   std::optional<Location> loc) {
  int32_t lhsWidth, rhsWidth, resultWidth = -1;
  bool isConstResult = false;
  if (!isSameIntTypeKind(lhs, rhs, lhsWidth, rhsWidth, isConstResult, loc))
    return {};
 
  if (lhsWidth != -1 && rhsWidth != -1)
    resultWidth = std::max(lhsWidth, rhsWidth) + 1;
  return IntType::get(lhs.getContext(), type_isa<SIntType>(lhs), resultWidth,
                      isConstResult);
}
 
FIRRTLType MulPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                      std::optional<Location> loc) {
  int32_t lhsWidth, rhsWidth, resultWidth = -1;
  bool isConstResult = false;
  if (!isSameIntTypeKind(lhs, rhs, lhsWidth, rhsWidth, isConstResult, loc))
    return {};
 
  if (lhsWidth != -1 && rhsWidth != -1)
    resultWidth = lhsWidth + rhsWidth;
 
  return IntType::get(lhs.getContext(), type_isa<SIntType>(lhs), resultWidth,
                      isConstResult);
}
 
FIRRTLType DivPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                      std::optional<Location> loc) {
  int32_t lhsWidth, rhsWidth;
  bool isConstResult = false;
  if (!isSameIntTypeKind(lhs, rhs, lhsWidth, rhsWidth, isConstResult, loc))
    return {};
 
  // For unsigned, the width is the width of the numerator on the LHS.
  if (type_isa<UIntType>(lhs))
    return UIntType::get(lhs.getContext(), lhsWidth, isConstResult);
 
  // For signed, the width is the width of the numerator on the LHS, plus 1.
  int32_t resultWidth = lhsWidth != -1 ? lhsWidth + 1 : -1;
  return SIntType::get(lhs.getContext(), resultWidth, isConstResult);
}
 
FIRRTLType RemPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                      std::optional<Location> loc) {
  int32_t lhsWidth, rhsWidth, resultWidth = -1;
  bool isConstResult = false;
  if (!isSameIntTypeKind(lhs, rhs, lhsWidth, rhsWidth, isConstResult, loc))
    return {};
 
  if (lhsWidth != -1 && rhsWidth != -1)
    resultWidth = std::min(lhsWidth, rhsWidth);
  return IntType::get(lhs.getContext(), type_isa<SIntType>(lhs), resultWidth,
                      isConstResult);
}
 
FIRRTLType impl::inferBitwiseResult(FIRRTLType lhs, FIRRTLType rhs,
                                    std::optional<Location> loc) {
  int32_t lhsWidth, rhsWidth, resultWidth = -1;
  bool isConstResult = false;
  if (!isSameIntTypeKind(lhs, rhs, lhsWidth, rhsWidth, isConstResult, loc))
    return {};
 
  if (lhsWidth != -1 && rhsWidth != -1) {
    resultWidth = std::max(lhsWidth, rhsWidth);
    if (lhsWidth == resultWidth && lhs.isConst() == isConstResult &&
        isa<UIntType>(lhs))
      return lhs;
    if (rhsWidth == resultWidth && rhs.isConst() == isConstResult &&
        isa<UIntType>(rhs))
      return rhs;
  }
  return UIntType::get(lhs.getContext(), resultWidth, isConstResult);
}
 
FIRRTLType impl::inferElementwiseResult(FIRRTLType lhs, FIRRTLType rhs,
                                        std::optional<Location> loc) {
  if (!type_isa<FVectorType>(lhs) || !type_isa<FVectorType>(rhs))
    return {};
 
  auto lhsVec = type_cast<FVectorType>(lhs);
  auto rhsVec = type_cast<FVectorType>(rhs);
 
  if (lhsVec.getNumElements() != rhsVec.getNumElements())
    return {};
 
  auto elemType =
      impl::inferBitwiseResult(lhsVec.getElementTypePreservingConst(),
                               rhsVec.getElementTypePreservingConst(), loc);
  if (!elemType)
    return {};
  auto elemBaseType = type_cast<FIRRTLBaseType>(elemType);
  return FVectorType::get(elemBaseType, lhsVec.getNumElements(),
                          lhsVec.isConst() && rhsVec.isConst() &&
                              elemBaseType.isConst());
}
 
FIRRTLType impl::inferComparisonResult(FIRRTLType lhs, FIRRTLType rhs,
                                       std::optional<Location> loc) {
  return UIntType::get(lhs.getContext(), 1, isConst(lhs) && isConst(rhs));
}
 
FIRRTLType CatPrimOp::inferReturnType(ValueRange operands, DictionaryAttr attrs,
                                      PropertyRef properties,
                                      mlir::RegionRange regions,
                                      std::optional<Location> loc) {
  // If no operands, return a 0-bit UInt
  if (operands.empty())
    return UIntType::get(attrs.getContext(), 0);
 
  // Check that all operands are Int types with same signedness
  bool isSigned = type_isa<SIntType>(operands[0].getType());
  for (auto operand : operands) {
    auto type = type_dyn_cast<IntType>(operand.getType());
    if (!type)
      return emitInferRetTypeError(loc, "all operands must be Int type");
    if (type.isSigned() != isSigned)
      return emitInferRetTypeError(loc,
                                   "all operands must have same signedness");
  }
 
  // Calculate the total width and determine if result is const
  int32_t resultWidth = 0;
  bool isConstResult = true;
 
  for (auto operand : operands) {
    auto type = type_cast<IntType>(operand.getType());
    int32_t width = type.getWidthOrSentinel();
 
    // If any width is unknown, the result width is unknown
    if (width == -1) {
      resultWidth = -1;
    }
 
    if (resultWidth != -1)
      resultWidth += width;
 
    // Result is const only if all operands are const
    isConstResult &= type.isConst();
  }
 
  // Create and return the result type
  return UIntType::get(attrs.getContext(), resultWidth, isConstResult);
}
 
FIRRTLType DShlPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                       std::optional<Location> loc) {
  auto lhsi = type_dyn_cast<IntType>(lhs);
  auto rhsui = type_dyn_cast<UIntType>(rhs);
  if (!rhsui || !lhsi)
    return emitInferRetTypeError(
        loc, "first operand should be integer, second unsigned int");
 
  // If the left or right has unknown result type, then the operation does
  // too.
  auto width = lhsi.getWidthOrSentinel();
  if (width == -1 || !rhsui.getWidth().has_value()) {
    width = -1;
  } else {
    auto amount = *rhsui.getWidth();
    if (amount >= 32)
      return emitInferRetTypeError(loc,
                                   "shift amount too large: second operand of "
                                   "dshl is wider than 31 bits");
    int64_t newWidth = (int64_t)width + ((int64_t)1 << amount) - 1;
    if (newWidth > INT32_MAX)
      return emitInferRetTypeError(
          loc, "shift amount too large: first operand shifted by maximum "
               "amount exceeds maximum width");
    width = newWidth;
  }
  return IntType::get(lhs.getContext(), lhsi.isSigned(), width,
                      lhsi.isConst() && rhsui.isConst());
}
 
FIRRTLType DShlwPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                        std::optional<Location> loc) {
  auto lhsi = type_dyn_cast<IntType>(lhs);
  auto rhsu = type_dyn_cast<UIntType>(rhs);
  if (!lhsi || !rhsu)
    return emitInferRetTypeError(
        loc, "first operand should be integer, second unsigned int");
  return lhsi.getConstType(lhsi.isConst() && rhsu.isConst());
}
 
FIRRTLType DShrPrimOp::inferReturnType(FIRRTLType lhs, FIRRTLType rhs,
                                       std::optional<Location> loc) {
  auto lhsi = type_dyn_cast<IntType>(lhs);
  auto rhsu = type_dyn_cast<UIntType>(rhs);
  if (!lhsi || !rhsu)
    return emitInferRetTypeError(
        loc, "first operand should be integer, second unsigned int");
  return lhsi.getConstType(lhsi.isConst() && rhsu.isConst());
}
 
//===----------------------------------------------------------------------===//
// Unary Primitives
//===----------------------------------------------------------------------===//
 
FIRRTLType SizeOfIntrinsicOp::inferReturnType(FIRRTLType input,
                                              std::optional<Location> loc) {
  return UIntType::get(input.getContext(), 32);
}
 
FIRRTLType AsSIntPrimOp::inferReturnType(FIRRTLType input,
                                         std::optional<Location> loc) {
  auto base = type_dyn_cast<FIRRTLBaseType>(input);
  if (!base)
    return emitInferRetTypeError(loc, "operand must be a scalar base type");
  int32_t width = base.getBitWidthOrSentinel();
  if (width == -2)
    return emitInferRetTypeError(loc, "operand must be a scalar type");
  return SIntType::get(input.getContext(), width, base.isConst());
}
 
FIRRTLType AsUIntPrimOp::inferReturnType(FIRRTLType input,
                                         std::optional<Location> loc) {
  auto base = type_dyn_cast<FIRRTLBaseType>(input);
  if (!base)
    return emitInferRetTypeError(loc, "operand must be a scalar base type");
  int32_t width = base.getBitWidthOrSentinel();
  if (width == -2)
    return emitInferRetTypeError(loc, "operand must be a scalar type");
  return UIntType::get(input.getContext(), width, base.isConst());
}
 
FIRRTLType AsAsyncResetPrimOp::inferReturnType(FIRRTLType input,
                                               std::optional<Location> loc) {
  auto base = type_dyn_cast<FIRRTLBaseType>(input);
  if (!base)
    return emitInferRetTypeError(loc,
                                 "operand must be single bit scalar base type");
  int32_t width = base.getBitWidthOrSentinel();
  if (width == -2 || width == 0 || width > 1)
    return emitInferRetTypeError(loc, "operand must be single bit scalar type");
  return AsyncResetType::get(input.getContext(), base.isConst());
}
 
FIRRTLType AsResetPrimOp::inferReturnType(FIRRTLType input,
                                          std::optional<Location> loc) {
  auto base = type_dyn_cast<FIRRTLBaseType>(input);
  if (!base)
    return emitInferRetTypeError(loc, "operand must be a scalar base type");
  return ResetType::get(input.getContext(), base.isConst());
}
 
FIRRTLType AsClockPrimOp::inferReturnType(FIRRTLType input,
                                          std::optional<Location> loc) {
  return ClockType::get(input.getContext(), isConst(input));
}
 
FIRRTLType CvtPrimOp::inferReturnType(FIRRTLType input,
                                      std::optional<Location> loc) {
  if (auto uiType = type_dyn_cast<UIntType>(input)) {
    auto width = uiType.getWidthOrSentinel();
    if (width != -1)
      ++width;
    return SIntType::get(input.getContext(), width, uiType.isConst());
  }
 
  if (type_isa<SIntType>(input))
    return input;
 
  return emitInferRetTypeError(loc, "operand must have integer type");
}
 
FIRRTLType NegPrimOp::inferReturnType(FIRRTLType input,
                                      std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (!inputi)
    return emitInferRetTypeError(loc, "operand must have integer type");
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1)
    ++width;
  return SIntType::get(input.getContext(), width, inputi.isConst());
}
 
FIRRTLType NotPrimOp::inferReturnType(FIRRTLType input,
                                      std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (!inputi)
    return emitInferRetTypeError(loc, "operand must have integer type");
  if (isa<UIntType>(inputi))
    return inputi;
  return UIntType::get(input.getContext(), inputi.getWidthOrSentinel(),
                       inputi.isConst());
}
 
FIRRTLType impl::inferReductionResult(FIRRTLType input,
                                      std::optional<Location> loc) {
  return UIntType::get(input.getContext(), 1, isConst(input));
}
 
//===----------------------------------------------------------------------===//
// Other Operations
//===----------------------------------------------------------------------===//
 
FIRRTLType BitsPrimOp::inferReturnType(FIRRTLType input, int64_t high,
                                       int64_t low,
                                       std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (!inputi)
    return emitInferRetTypeError(
        loc, "input type should be the int type but got ", input);
 
  // High must be >= low and both most be non-negative.
  if (high < low)
    return emitInferRetTypeError(
        loc, "high must be equal or greater than low, but got high = ", high,
        ", low = ", low);
 
  if (low < 0)
    return emitInferRetTypeError(loc, "low must be non-negative but got ", low);
 
  // If the input has staticly known width, check it.  Both and low must be
  // strictly less than width.
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1 && high >= width)
    return emitInferRetTypeError(
        loc,
        "high must be smaller than the width of input, but got high = ", high,
        ", width = ", width);
 
  return UIntType::get(input.getContext(), high - low + 1, inputi.isConst());
}
 
FIRRTLType HeadPrimOp::inferReturnType(FIRRTLType input, int64_t amount,
                                       std::optional<Location> loc) {
 
  auto inputi = type_dyn_cast<IntType>(input);
  if (amount < 0 || !inputi)
    return emitInferRetTypeError(
        loc, "operand must have integer type and amount must be >= 0");
 
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1 && amount > width)
    return emitInferRetTypeError(loc, "amount larger than input width");
 
  return UIntType::get(input.getContext(), amount, inputi.isConst());
}
 
/// Infer the result type for a multiplexer given its two operand types, which
/// may be aggregates.
///
/// This essentially performs a pairwise comparison of fields and elements, as
/// follows:
/// - Identical operands inferred to their common type
/// - Integer operands inferred to the larger one if both have a known width, a
///   widthless integer otherwise.
/// - Vectors inferred based on the element type.
/// - Bundles inferred in a pairwise fashion based on the field types.
static FIRRTLBaseType inferMuxReturnType(FIRRTLBaseType high,
                                         FIRRTLBaseType low,
                                         bool isConstCondition,
                                         std::optional<Location> loc) {
  // If the types are identical we're done.
  if (high == low)
    return isConstCondition ? low : low.getAllConstDroppedType();
 
  // The base types need to be equivalent.
  if (high.getTypeID() != low.getTypeID())
    return emitInferRetTypeError<FIRRTLBaseType>(
        loc, "incompatible mux operand types, true value type: ", high,
        ", false value type: ", low);
 
  bool outerTypeIsConst = isConstCondition && low.isConst() && high.isConst();
 
  // Two different Int types can be compatible.  If either has unknown width,
  // then return it.  If both are known but different width, then return the
  // larger one.
  if (type_isa<IntType>(low)) {
    int32_t highWidth = high.getBitWidthOrSentinel();
    int32_t lowWidth = low.getBitWidthOrSentinel();
    if (lowWidth == -1)
      return low.getConstType(outerTypeIsConst);
    if (highWidth == -1)
      return high.getConstType(outerTypeIsConst);
    return (lowWidth > highWidth ? low : high).getConstType(outerTypeIsConst);
  }
 
  // Two different Enum types can be compatible if one is the constant version
  // of the other.
  auto highEnum = type_dyn_cast<FEnumType>(high);
  auto lowEnum = type_dyn_cast<FEnumType>(low);
  if (lowEnum && highEnum) {
    if (lowEnum.getNumElements() != highEnum.getNumElements())
      return emitInferRetTypeError<FIRRTLBaseType>(
          loc, "incompatible mux operand types, true value type: ", high,
          ", false value type: ", low);
    SmallVector<FEnumType::EnumElement> elements;
    for (auto [high, low] : llvm::zip_equal(highEnum, lowEnum)) {
      // Variants should have the same name and value.
      if (high.name != low.name || high.value != low.value)
        return emitInferRetTypeError<FIRRTLBaseType>(
            loc, "incompatible mux operand types, true value type: ", highEnum,
            ", false value type: ", lowEnum);
      // Enumerations can only have constant variants only if the whole
      // enumeration is constant, so this logic can differ a bit from bundles.
      auto inner =
          inferMuxReturnType(high.type, low.type, isConstCondition, loc);
      if (!inner)
        return {};
      elements.emplace_back(high.name, high.value, inner);
    }
    return FEnumType::get(high.getContext(), elements, outerTypeIsConst);
  }
 
  // Infer vector types by comparing the element types.
  auto highVector = type_dyn_cast<FVectorType>(high);
  auto lowVector = type_dyn_cast<FVectorType>(low);
  if (highVector && lowVector &&
      highVector.getNumElements() == lowVector.getNumElements()) {
    auto inner = inferMuxReturnType(highVector.getElementTypePreservingConst(),
                                    lowVector.getElementTypePreservingConst(),
                                    isConstCondition, loc);
    if (!inner)
      return {};
    return FVectorType::get(inner, lowVector.getNumElements(),
                            outerTypeIsConst);
  }
 
  // Infer bundle types by inferring names in a pairwise fashion.
  auto highBundle = type_dyn_cast<BundleType>(high);
  auto lowBundle = type_dyn_cast<BundleType>(low);
  if (highBundle && lowBundle) {
    auto highElements = highBundle.getElements();
    auto lowElements = lowBundle.getElements();
    size_t numElements = highElements.size();
 
    SmallVector<BundleType::BundleElement> newElements;
    if (numElements == lowElements.size()) {
      bool failed = false;
      for (size_t i = 0; i < numElements; ++i) {
        if (highElements[i].name != lowElements[i].name ||
            highElements[i].isFlip != lowElements[i].isFlip) {
          failed = true;
          break;
        }
        auto element = highElements[i];
        element.type = inferMuxReturnType(
            highBundle.getElementTypePreservingConst(i),
            lowBundle.getElementTypePreservingConst(i), isConstCondition, loc);
        if (!element.type)
          return {};
        newElements.push_back(element);
      }
      if (!failed)
        return BundleType::get(low.getContext(), newElements, outerTypeIsConst);
    }
    return emitInferRetTypeError<FIRRTLBaseType>(
        loc, "incompatible mux operand bundle fields, true value type: ", high,
        ", false value type: ", low);
  }
 
  // If we arrive here the types of the two mux arms are fundamentally
  // incompatible.
  return emitInferRetTypeError<FIRRTLBaseType>(
      loc, "invalid mux operand types, true value type: ", high,
      ", false value type: ", low);
}
 
FIRRTLType MuxPrimOp::inferReturnType(FIRRTLType sel, FIRRTLType high,
                                      FIRRTLType low,
                                      std::optional<Location> loc) {
  auto highType = type_dyn_cast<FIRRTLBaseType>(high);
  auto lowType = type_dyn_cast<FIRRTLBaseType>(low);
  if (!highType || !lowType)
    return emitInferRetTypeError(loc, "operands must be base type");
  return inferMuxReturnType(highType, lowType, isConst(sel), loc);
}
 
FIRRTLType Mux2CellIntrinsicOp::inferReturnType(ValueRange operands,
                                                DictionaryAttr attrs,
                                                PropertyRef properties,
                                                mlir::RegionRange regions,
                                                std::optional<Location> loc) {
  auto highType = type_dyn_cast<FIRRTLBaseType>(operands[1].getType());
  auto lowType = type_dyn_cast<FIRRTLBaseType>(operands[2].getType());
  if (!highType || !lowType)
    return emitInferRetTypeError(loc, "operands must be base type");
  return inferMuxReturnType(highType, lowType, isConst(operands[0].getType()),
                            loc);
}
 
FIRRTLType Mux4CellIntrinsicOp::inferReturnType(ValueRange operands,
                                                DictionaryAttr attrs,
                                                PropertyRef properties,
                                                mlir::RegionRange regions,
                                                std::optional<Location> loc) {
  SmallVector<FIRRTLBaseType> types;
  FIRRTLBaseType result;
  for (unsigned i = 1; i < 5; i++) {
    types.push_back(type_dyn_cast<FIRRTLBaseType>(operands[i].getType()));
    if (!types.back())
      return emitInferRetTypeError(loc, "operands must be base type");
    if (result) {
      result = inferMuxReturnType(result, types.back(),
                                  isConst(operands[0].getType()), loc);
      if (!result)
        return result;
    } else {
      result = types.back();
    }
  }
  return result;
}
 
FIRRTLType PadPrimOp::inferReturnType(FIRRTLType input, int64_t amount,
                                      std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (amount < 0 || !inputi)
    return emitInferRetTypeError(
        loc, "pad input must be integer and amount must be >= 0");
 
  int32_t width = inputi.getWidthOrSentinel();
  if (width == -1)
    return inputi;
 
  width = std::max<int32_t>(width, amount);
  return IntType::get(input.getContext(), inputi.isSigned(), width,
                      inputi.isConst());
}
 
FIRRTLType ShlPrimOp::inferReturnType(FIRRTLType input, int64_t amount,
                                      std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (amount < 0 || !inputi)
    return emitInferRetTypeError(
        loc, "shl input must be integer and amount must be >= 0");
 
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1)
    width += amount;
 
  return IntType::get(input.getContext(), inputi.isSigned(), width,
                      inputi.isConst());
}
 
FIRRTLType ShrPrimOp::inferReturnType(FIRRTLType input, int64_t amount,
                                      std::optional<Location> loc) {
  auto inputi = type_dyn_cast<IntType>(input);
  if (amount < 0 || !inputi)
    return emitInferRetTypeError(
        loc, "shr input must be integer and amount must be >= 0");
 
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1) {
    // UInt saturates at 0 bits, SInt at 1 bit
    int32_t minWidth = inputi.isUnsigned() ? 0 : 1;
    width = std::max<int32_t>(minWidth, width - amount);
  }
 
  return IntType::get(input.getContext(), inputi.isSigned(), width,
                      inputi.isConst());
}
 
FIRRTLType TailPrimOp::inferReturnType(FIRRTLType input, int64_t amount,
                                       std::optional<Location> loc) {
 
  auto inputi = type_dyn_cast<IntType>(input);
  if (amount < 0 || !inputi)
    return emitInferRetTypeError(
        loc, "tail input must be integer and amount must be >= 0");
 
  int32_t width = inputi.getWidthOrSentinel();
  if (width != -1) {
    if (width < amount)
      return emitInferRetTypeError(
          loc, "amount must be less than or equal operand width");
    width -= amount;
  }
 
  return IntType::get(input.getContext(), false, width, inputi.isConst());
}
 
//===----------------------------------------------------------------------===//
// VerbatimExprOp
//===----------------------------------------------------------------------===//
 
void VerbatimExprOp::getAsmResultNames(
    function_ref<void(Value, StringRef)> setNameFn) {
  // If the text is macro like, then use a pretty name.  We only take the
  // text up to a weird character (like a paren) and currently ignore
  // parenthesized expressions.
  auto isOkCharacter = [](char c) { return llvm::isAlnum(c) || c == '_'; };
  auto name = getText();
  // Ignore a leading ` in macro name.
  if (name.starts_with("`"))
    name = name.drop_front();
  name = name.take_while(isOkCharacter);
  if (!name.empty())
    setNameFn(getResult(), name);
}
 
//===----------------------------------------------------------------------===//
// VerbatimWireOp
//===----------------------------------------------------------------------===//
 
void VerbatimWireOp::getAsmResultNames(
    function_ref<void(Value, StringRef)> setNameFn) {
  // If the text is macro like, then use a pretty name.  We only take the
  // text up to a weird character (like a paren) and currently ignore
  // parenthesized expressions.
  auto isOkCharacter = [](char c) { return llvm::isAlnum(c) || c == '_'; };
  auto name = getText();
  // Ignore a leading ` in macro name.
  if (name.starts_with("`"))
    name = name.drop_front();
  name = name.take_while(isOkCharacter);
  if (!name.empty())
    setNameFn(getResult(), name);
}
 
//===----------------------------------------------------------------------===//
// DPICallIntrinsicOp
//===----------------------------------------------------------------------===//
 
static bool isTypeAllowedForDPI(Operation *op, Type type) {
  return !type.walk([&](firrtl::IntType intType) -> mlir::WalkResult {
                auto width = intType.getWidth();
                if (width < 0) {
                  op->emitError() << "unknown width is not allowed for DPI";
                  return WalkResult::interrupt();
                }
                if (width == 1 || width == 8 || width == 16 || width == 32 ||
                    width >= 64)
                  return WalkResult::advance();
                op->emitError()
                    << "integer types used by DPI functions must have a "
                       "specific bit width; "
                       "it must be equal to 1(bit), 8(byte), 16(shortint), "
                       "32(int), 64(longint) "
                       "or greater than 64, but got "
                    << intType;
                return WalkResult::interrupt();
              })
              .wasInterrupted();
}
 
LogicalResult DPICallIntrinsicOp::verify() {
  if (auto inputNames = getInputNames()) {
    if (getInputs().size() != inputNames->size())
      return emitError() << "inputNames has " << inputNames->size()
                         << " elements but there are " << getInputs().size()
                         << " input arguments";
  }
  if (auto outputName = getOutputName())
    if (getNumResults() == 0)
      return emitError() << "output name is given but there is no result";
 
  auto checkType = [this](Type type) {
    return isTypeAllowedForDPI(*this, type);
  };
  return success(llvm::all_of(this->getResultTypes(), checkType) &&
                 llvm::all_of(this->getOperandTypes(), checkType));
}
 
SmallVector<std::pair<circt::FieldRef, circt::FieldRef>>
DPICallIntrinsicOp::computeDataFlow() {
  if (getClock())
    return {};
 
  SmallVector<std::pair<circt::FieldRef, circt::FieldRef>> deps;
 
  for (auto operand : getOperands()) {
    auto type = type_cast<FIRRTLBaseType>(operand.getType());
    auto baseFieldRef = getFieldRefFromValue(operand);
    SmallVector<circt::FieldRef> operandFields;
    walkGroundTypes(
        type, [&](uint64_t dstIndex, FIRRTLBaseType t, bool dstIsFlip) {
          operandFields.push_back(baseFieldRef.getSubField(dstIndex));
        });
 
    // Record operand -> result dependency.
    for (auto result : getResults())
      walkGroundTypes(
          type, [&](uint64_t dstIndex, FIRRTLBaseType t, bool dstIsFlip) {
            for (auto field : operandFields)
              deps.emplace_back(circt::FieldRef(result, dstIndex), field);
          });
  }
  return deps;
}
 
//===----------------------------------------------------------------------===//
// Conversions to/from structs in the standard dialect.
//===----------------------------------------------------------------------===//
 
LogicalResult HWStructCastOp::verify() {
  // We must have a bundle and a struct, with matching pairwise fields
  BundleType bundleType;
  hw::StructType structType;
  if ((bundleType = type_dyn_cast<BundleType>(getOperand().getType()))) {
    structType = dyn_cast<hw::StructType>(getType());
    if (!structType)
      return emitError("result type must be a struct");
  } else if ((bundleType = type_dyn_cast<BundleType>(getType()))) {
    structType = dyn_cast<hw::StructType>(getOperand().getType());
    if (!structType)
      return emitError("operand type must be a struct");
  } else {
    return emitError("either source or result type must be a bundle type");
  }
 
  auto firFields = bundleType.getElements();
  auto hwFields = structType.getElements();
  if (firFields.size() != hwFields.size())
    return emitError("bundle and struct have different number of fields");
 
  for (size_t findex = 0, fend = firFields.size(); findex < fend; ++findex) {
    if (firFields[findex].name.getValue() != hwFields[findex].name)
      return emitError("field names don't match '")
             << firFields[findex].name.getValue() << "', '"
             << hwFields[findex].name.getValue() << "'";
    int64_t firWidth =
        FIRRTLBaseType(firFields[findex].type).getBitWidthOrSentinel();
    int64_t hwWidth = hw::getBitWidth(hwFields[findex].type);
    if (firWidth > 0 && hwWidth > 0 && firWidth != hwWidth)
      return emitError("size of field '")
             << hwFields[findex].name.getValue() << "' don't match " << firWidth
             << ", " << hwWidth;
  }
 
  return success();
}
 
LogicalResult BitCastOp::verify() {
  auto inTypeBits = getBitWidth(getInput().getType(), /*ignoreFlip=*/true);
  auto resTypeBits = getBitWidth(getType());
  if (inTypeBits.has_value() && resTypeBits.has_value()) {
    // Bitwidths must match for valid bit
    if (*inTypeBits == *resTypeBits) {
      // non-'const' cannot be casted to 'const'
      if (containsConst(getType()) && !isConst(getOperand().getType()))
        return emitError("cannot cast non-'const' input type ")
               << getOperand().getType() << " to 'const' result type "
               << getType();
      return success();
    }
    return emitError("the bitwidth of input (")
           << *inTypeBits << ") and result (" << *resTypeBits
           << ") don't match";
  }
  if (!inTypeBits.has_value())
    return emitError("bitwidth cannot be determined for input operand type ")
           << getInput().getType();
  return emitError("bitwidth cannot be determined for result type ")
         << getType();
}
 
//===----------------------------------------------------------------------===//
// Custom attr-dict Directive that Elides Annotations
//===----------------------------------------------------------------------===//
 
/// Parse an optional attribute dictionary, adding an empty 'annotations'
/// attribute if not specified.
static ParseResult parseElideAnnotations(OpAsmParser &parser,
                                         NamedAttrList &resultAttrs) {
  auto result = parser.parseOptionalAttrDict(resultAttrs);
  if (!resultAttrs.get("annotations"))
    resultAttrs.append("annotations", parser.getBuilder().getArrayAttr({}));
 
  return result;
}
 
static void printElideAnnotations(OpAsmPrinter &p, Operation *op,
                                  DictionaryAttr attr,
                                  ArrayRef<StringRef> extraElides = {}) {
  SmallVector<StringRef> elidedAttrs(extraElides.begin(), extraElides.end());
  // Elide "annotations" if it is empty.
  if (op->getAttrOfType<ArrayAttr>("annotations").empty())
    elidedAttrs.push_back("annotations");
  // Elide "nameKind".
  elidedAttrs.push_back("nameKind");
 
  p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
}
 
/// Parse an optional attribute dictionary, adding empty 'annotations' and
/// 'portAnnotations' attributes if not specified.
static ParseResult parseElidePortAnnotations(OpAsmParser &parser,
                                             NamedAttrList &resultAttrs) {
  auto result = parseElideAnnotations(parser, resultAttrs);
 
  if (!resultAttrs.get("portAnnotations")) {
    SmallVector<Attribute, 16> portAnnotations(
        parser.getNumResults(), parser.getBuilder().getArrayAttr({}));
    resultAttrs.append("portAnnotations",
                       parser.getBuilder().getArrayAttr(portAnnotations));
  }
  return result;
}
 
// Elide 'annotations' and 'portAnnotations' attributes if they are empty.
static void printElidePortAnnotations(OpAsmPrinter &p, Operation *op,
                                      DictionaryAttr attr,
                                      ArrayRef<StringRef> extraElides = {}) {
  SmallVector<StringRef, 2> elidedAttrs(extraElides.begin(), extraElides.end());
 
  if (llvm::all_of(op->getAttrOfType<ArrayAttr>("portAnnotations"),
                   [&](Attribute a) { return cast<ArrayAttr>(a).empty(); }))
    elidedAttrs.push_back("portAnnotations");
  printElideAnnotations(p, op, attr, elidedAttrs);
}
 
//===----------------------------------------------------------------------===//
// NameKind Custom Directive
//===----------------------------------------------------------------------===//
 
static ParseResult parseNameKind(OpAsmParser &parser,
                                 firrtl::NameKindEnumAttr &result) {
  StringRef keyword;
 
  if (!parser.parseOptionalKeyword(&keyword,
                                   {"interesting_name", "droppable_name"})) {
    auto kind = symbolizeNameKindEnum(keyword);
    result = NameKindEnumAttr::get(parser.getContext(), kind.value());
    return success();
  }
 
  // Default is droppable name.
  result =
      NameKindEnumAttr::get(parser.getContext(), NameKindEnum::DroppableName);
  return success();
}
 
static void printNameKind(OpAsmPrinter &p, Operation *op,
                          firrtl::NameKindEnumAttr attr,
                          ArrayRef<StringRef> extraElides = {}) {
  if (attr.getValue() != NameKindEnum::DroppableName)
    p << " " << stringifyNameKindEnum(attr.getValue());
}
 
//===----------------------------------------------------------------------===//
// ImplicitSSAName Custom Directive
//===----------------------------------------------------------------------===//
 
static ParseResult parseFIRRTLImplicitSSAName(OpAsmParser &parser,
                                              NamedAttrList &resultAttrs) {
  if (parseElideAnnotations(parser, resultAttrs))
    return failure();
  inferImplicitSSAName(parser, resultAttrs);
  return success();
}
 
static void printFIRRTLImplicitSSAName(OpAsmPrinter &p, Operation *op,
                                       DictionaryAttr attrs) {
  SmallVector<StringRef, 4> elides;
  elides.push_back(hw::InnerSymbolTable::getInnerSymbolAttrName());
  elides.push_back(Forceable::getForceableAttrName());
  elideImplicitSSAName(p, op, attrs, elides);
  printElideAnnotations(p, op, attrs, elides);
}
 
//===----------------------------------------------------------------------===//
// FieldsFromDomain Custom Directive
//===----------------------------------------------------------------------===//
 
static ParseResult parseFieldsFromDomain(
    OpAsmParser &parser,
    SmallVectorImpl<OpAsmParser::UnresolvedOperand> &fieldValues,
    SmallVectorImpl<Type> &fieldTypes, Type &resultType) {
  // Parse the domain type.
  if (parser.parseType(resultType))
    return failure();
 
  auto domainType = dyn_cast<DomainType>(resultType);
  if (!domainType)
    return parser.emitError(parser.getCurrentLocation(),
                            "expected domain type");
 
  // Extract the field types from the domain type.
  auto fields = domainType.getFields();
 
  // Validate that the number of field values matches the domain.
  if (fieldValues.size() != fields.size())
    return parser.emitError(parser.getCurrentLocation(),
                            "number of field values (" +
                                Twine(fieldValues.size()) +
                                ") does not match domain field count (" +
                                Twine(fields.size()) + ")");
 
  // Populate the field types from the domain definition.
  fieldTypes.reserve(fields.size());
  for (auto field : fields)
    fieldTypes.push_back(cast<DomainFieldAttr>(field).getType());
 
  return success();
}
 
static void printFieldsFromDomain(OpAsmPrinter &p, Operation *op,
                                  OperandRange fieldValues,
                                  TypeRange fieldTypes, Type resultType) {
  p << resultType;
}
 
//===----------------------------------------------------------------------===//
// MemOp Custom attr-dict Directive
//===----------------------------------------------------------------------===//
 
static ParseResult parseMemOp(OpAsmParser &parser, NamedAttrList &resultAttrs) {
  return parseElidePortAnnotations(parser, resultAttrs);
}
 
/// Always elide "ruw" and elide "annotations" if it exists or if it is empty.
static void printMemOp(OpAsmPrinter &p, Operation *op, DictionaryAttr attr) {
  // "ruw" and "inner_sym" is always elided.
  printElidePortAnnotations(p, op, attr, {"ruw", "inner_sym"});
}
 
//===----------------------------------------------------------------------===//
// ClassInterface custom directive
//===----------------------------------------------------------------------===//
 
static ParseResult parseClassInterface(OpAsmParser &parser, Type &result) {
  ClassType type;
  if (ClassType::parseInterface(parser, type))
    return failure();
  result = type;
  return success();
}
 
static void printClassInterface(OpAsmPrinter &p, Operation *, ClassType type) {
  type.printInterface(p);
}
 
//===----------------------------------------------------------------------===//
// Miscellaneous custom elision logic.
//===----------------------------------------------------------------------===//
 
static ParseResult parseElideEmptyName(OpAsmParser &p,
                                       NamedAttrList &resultAttrs) {
  auto result = p.parseOptionalAttrDict(resultAttrs);
  if (!resultAttrs.get("name"))
    resultAttrs.append("name", p.getBuilder().getStringAttr(""));
 
  return result;
}
 
static void printElideEmptyName(OpAsmPrinter &p, Operation *op,
                                DictionaryAttr attr,
                                ArrayRef<StringRef> extraElides = {}) {
  SmallVector<StringRef> elides(extraElides.begin(), extraElides.end());
  if (op->getAttrOfType<StringAttr>("name").getValue().empty())
    elides.push_back("name");
 
  p.printOptionalAttrDict(op->getAttrs(), elides);
}
 
static ParseResult parsePrintfAttrs(OpAsmParser &p,
                                    NamedAttrList &resultAttrs) {
  return parseElideEmptyName(p, resultAttrs);
}
 
static void printPrintfAttrs(OpAsmPrinter &p, Operation *op,
                             DictionaryAttr attr) {
  printElideEmptyName(p, op, attr, {"formatString"});
}
 
static ParseResult parseFPrintfAttrs(OpAsmParser &p,
                                     NamedAttrList &resultAttrs) {
  return parseElideEmptyName(p, resultAttrs);
}
 
static void printFPrintfAttrs(OpAsmPrinter &p, Operation *op,
                              DictionaryAttr attr) {
  printElideEmptyName(p, op, attr,
                      {"formatString", "outputFile", "operandSegmentSizes"});
}
 
static ParseResult parseStopAttrs(OpAsmParser &p, NamedAttrList &resultAttrs) {
  return parseElideEmptyName(p, resultAttrs);
}
 
static void printStopAttrs(OpAsmPrinter &p, Operation *op,
                           DictionaryAttr attr) {
  printElideEmptyName(p, op, attr, {"exitCode"});
}
 
static ParseResult parseVerifAttrs(OpAsmParser &p, NamedAttrList &resultAttrs) {
  return parseElideEmptyName(p, resultAttrs);
}
 
static void printVerifAttrs(OpAsmPrinter &p, Operation *op,
                            DictionaryAttr attr) {
  printElideEmptyName(p, op, attr, {"message"});
}
 
//===----------------------------------------------------------------------===//
// Various namers.
//===----------------------------------------------------------------------===//
 
static void genericAsmResultNames(Operation *op,
                                  OpAsmSetValueNameFn setNameFn) {
  // Many firrtl dialect operations have an optional 'name' attribute.  If
  // present, use it.
  if (op->getNumResults() == 1)
    if (auto nameAttr = op->getAttrOfType<StringAttr>("name"))
      setNameFn(op->getResult(0), nameAttr.getValue());
}
 
void AddPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void AndPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void AndRPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SizeOfIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void AsAsyncResetPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void AsResetPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void AsClockPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void AsSIntPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void AsUIntPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void BitsPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void CatPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void CvtPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void DShlPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void DShlwPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void DShrPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void DivPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void EQPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void GEQPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void GTPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void GenericIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void HeadPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IntegerAddOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IntegerMulOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IntegerShrOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IntegerShlOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void BoolAndOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void BoolOrOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void BoolXorOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IsTagOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void IsXIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void PlusArgsValueIntrinsicOp::getAsmResultNames(
    OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void PlusArgsTestIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void LEQPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void LTPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void MulPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void MultibitMuxOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void MuxPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void Mux4CellIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void Mux2CellIntrinsicOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void NEQPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void NegPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void NotPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void OrPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void OrRPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void PadPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void RemPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void ShlPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
void ShrPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SubPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SubaccessOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SubfieldOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void OpenSubfieldOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SubtagOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void SubindexOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void OpenSubindexOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void TagExtractOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void TailPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void XorPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void XorRPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void UninferredResetCastOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void ConstCastOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void ElementwiseXorPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void ElementwiseOrPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void ElementwiseAndPrimOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
//===----------------------------------------------------------------------===//
// RefOps
//===----------------------------------------------------------------------===//
 
void RefCastOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void RefResolveOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void RefSendOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void RefSubOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
void RWProbeOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
FIRRTLType RefResolveOp::inferReturnType(ValueRange operands,
                                         DictionaryAttr attrs,
                                         PropertyRef properties,
                                         mlir::RegionRange regions,
                                         std::optional<Location> loc) {
  Type inType = operands[0].getType();
  auto inRefType = type_dyn_cast<RefType>(inType);
  if (!inRefType)
    return emitInferRetTypeError(
        loc, "ref.resolve operand must be ref type, not ", inType);
  return inRefType.getType();
}
 
FIRRTLType RefSendOp::inferReturnType(ValueRange operands, DictionaryAttr attrs,
                                      PropertyRef properties,
                                      mlir::RegionRange regions,
                                      std::optional<Location> loc) {
  Type inType = operands[0].getType();
  auto inBaseType = type_dyn_cast<FIRRTLBaseType>(inType);
  if (!inBaseType)
    return emitInferRetTypeError(
        loc, "ref.send operand must be base type, not ", inType);
  return RefType::get(inBaseType.getPassiveType());
}
 
FIRRTLType RefSubOp::inferReturnType(Type type, uint32_t fieldIndex,
                                     std::optional<Location> loc) {
  auto refType = type_dyn_cast<RefType>(type);
  if (!refType)
    return emitInferRetTypeError(loc, "input must be of reference type");
  auto inType = refType.getType();
 
  // TODO: Determine ref.sub + rwprobe behavior, test.
  // Probably best to demote to non-rw, but that has implications
  // for any LowerTypes behavior being relied on.
  // Allow for now, as need to LowerTypes things generally.
  if (auto vectorType = type_dyn_cast<FVectorType>(inType)) {
    if (fieldIndex < vectorType.getNumElements())
      return RefType::get(
          vectorType.getElementType().getConstType(
              vectorType.isConst() || vectorType.getElementType().isConst()),
          refType.getForceable(), refType.getLayer());
    return emitInferRetTypeError(loc, "out of range index '", fieldIndex,
                                 "' in RefType of vector type ", refType);
  }
  if (auto bundleType = type_dyn_cast<BundleType>(inType)) {
    if (fieldIndex >= bundleType.getNumElements()) {
      return emitInferRetTypeError(loc,
                                   "subfield element index is greater than "
                                   "the number of fields in the bundle type");
    }
    return RefType::get(
        bundleType.getElement(fieldIndex)
            .type.getConstType(
                bundleType.isConst() ||
                bundleType.getElement(fieldIndex).type.isConst()),
        refType.getForceable(), refType.getLayer());
  }
 
  return emitInferRetTypeError(
      loc, "ref.sub op requires a RefType of vector or bundle base type");
}
 
LogicalResult RefCastOp::verify() {
  auto srcLayers = getLayersFor(getInput());
  auto dstLayers = getLayersFor(getResult());
  return checkLayerCompatibility(
      getOperation(), srcLayers, dstLayers,
      "cannot discard layer requirements of input reference",
      "discarding layer requirements");
}
 
LogicalResult RefResolveOp::verify() {
  auto srcLayers = getLayersFor(getRef());
  auto dstLayers = getAmbientLayersAt(getOperation());
  return checkLayerCompatibility(
      getOperation(), srcLayers, dstLayers,
      "ambient layers are insufficient to resolve reference");
}
 
LogicalResult RWProbeOp::verifyInnerRefs(hw::InnerRefNamespace &ns) {
  auto targetRef = getTarget();
  if (targetRef.getModule() !=
      (*this)->getParentOfType<FModuleLike>().getModuleNameAttr())
    return emitOpError() << "has non-local target";
 
  auto target = ns.lookup(targetRef);
  if (!target)
    return emitOpError() << "has target that cannot be resolved: " << targetRef;
 
  auto checkFinalType = [&](auto type, Location loc) -> LogicalResult {
    // Determine final type.
    mlir::Type fType =
        hw::FieldIdImpl::getFinalTypeByFieldID(type, target.getField());
    // Check.
    auto baseType = type_dyn_cast<FIRRTLBaseType>(fType);
    if (!baseType || baseType.getPassiveType() != getType().getType()) {
      auto diag = emitOpError("has type mismatch: target resolves to ")
                  << fType << " instead of expected " << getType().getType();
      diag.attachNote(loc) << "target resolves here";
      return diag;
    }
    return success();
  };
  if (target.isPort()) {
    auto mod = cast<FModuleLike>(target.getOp());
    return checkFinalType(mod.getPortType(target.getPort()),
                          mod.getPortLocation(target.getPort()));
  }
  hw::InnerSymbolOpInterface symOp =
      cast<hw::InnerSymbolOpInterface>(target.getOp());
  if (!symOp.getTargetResult())
    return emitOpError("has target that cannot be probed")
        .attachNote(symOp.getLoc())
        .append("target resolves here");
  auto *ancestor =
      symOp.getTargetResult().getParentBlock()->findAncestorOpInBlock(**this);
  if (!ancestor || !symOp->isBeforeInBlock(ancestor))
    return emitOpError("is not dominated by target")
        .attachNote(symOp.getLoc())
        .append("target here");
  return checkFinalType(symOp.getTargetResult().getType(), symOp.getLoc());
}
 
LogicalResult RefForceOp::verify() {
  auto ambientLayers = getAmbientLayersAt(getOperation());
  auto destLayers = getLayersFor(getDest());
  return checkLayerCompatibility(
      getOperation(), destLayers, ambientLayers,
      "has insufficient ambient layers to force its reference");
}
 
LogicalResult RefForceInitialOp::verify() {
  auto ambientLayers = getAmbientLayersAt(getOperation());
  auto destLayers = getLayersFor(getDest());
  return checkLayerCompatibility(
      getOperation(), destLayers, ambientLayers,
      "has insufficient ambient layers to force its reference");
}
 
LogicalResult RefReleaseOp::verify() {
  auto ambientLayers = getAmbientLayersAt(getOperation());
  auto destLayers = getLayersFor(getDest());
  return checkLayerCompatibility(
      getOperation(), destLayers, ambientLayers,
      "has insufficient ambient layers to release its reference");
}
 
LogicalResult RefReleaseInitialOp::verify() {
  auto ambientLayers = getAmbientLayersAt(getOperation());
  auto destLayers = getLayersFor(getDest());
  return checkLayerCompatibility(
      getOperation(), destLayers, ambientLayers,
      "has insufficient ambient layers to release its reference");
}
 
LogicalResult XMRRefOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto *target = symbolTable.lookupNearestSymbolFrom(*this, getRefAttr());
  if (!target)
    return emitOpError("has an invalid symbol reference");
 
  if (!isa<hw::HierPathOp>(target))
    return emitOpError("does not target a hierpath op");
 
  // TODO: Verify that the target's type matches the type of this op.
  return success();
}
 
LogicalResult XMRDerefOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto *target = symbolTable.lookupNearestSymbolFrom(*this, getRefAttr());
  if (!target)
    return emitOpError("has an invalid symbol reference");
 
  if (!isa<hw::HierPathOp>(target))
    return emitOpError("does not target a hierpath op");
 
  // TODO: Verify that the target's type matches the type of this op.
  return success();
}
 
//===----------------------------------------------------------------------===//
// Layer Block Operations
//===----------------------------------------------------------------------===//
 
LogicalResult LayerBlockOp::verify() {
  auto layerName = getLayerName();
  auto *parentOp = (*this)->getParentOp();
 
  // Get parent operation that isn't a when or match.
  while (isa<WhenOp, MatchOp>(parentOp))
    parentOp = parentOp->getParentOp();
 
  // Verify the correctness of the symbol reference.  Only verify that this
  // layer block makes sense in its parent module or layer block.
  auto nestedReferences = layerName.getNestedReferences();
  if (nestedReferences.empty()) {
    if (!isa<FModuleOp>(parentOp)) {
      auto diag = emitOpError() << "has an un-nested layer symbol, but does "
                                   "not have a 'firrtl.module' op as a parent";
      return diag.attachNote(parentOp->getLoc())
             << "illegal parent op defined here";
    }
  } else {
    auto parentLayerBlock = dyn_cast<LayerBlockOp>(parentOp);
    if (!parentLayerBlock) {
      auto diag = emitOpError()
                  << "has a nested layer symbol, but does not have a '"
                  << getOperationName() << "' op as a parent'";
      return diag.attachNote(parentOp->getLoc())
             << "illegal parent op defined here";
    }
    auto parentLayerBlockName = parentLayerBlock.getLayerName();
    if (parentLayerBlockName.getRootReference() !=
            layerName.getRootReference() ||
        parentLayerBlockName.getNestedReferences() !=
            layerName.getNestedReferences().drop_back()) {
      auto diag = emitOpError() << "is nested under an illegal layer block";
      return diag.attachNote(parentLayerBlock->getLoc())
             << "illegal parent layer block defined here";
    }
  }
 
  // Verify the body of the region.
  FieldRefCache fieldRefCache;
  auto result = getBody(0)->walk<mlir::WalkOrder::PreOrder>(
      [&](Operation *op) -> WalkResult {
        // Skip nested layer blocks.  Those will be verified separately.
        if (isa<LayerBlockOp>(op))
          return WalkResult::skip();
 
        // Check all the operands of each op to make sure that only legal things
        // are captured.
        for (auto operand : op->getOperands()) {
          // Any value captured from the current layer block is fine.
          if (auto *definingOp = operand.getDefiningOp())
            if (getOperation()->isAncestor(definingOp))
              continue;
 
          auto type = operand.getType();
 
          // Capture of a non-base type, e.g., reference, is allowed.
          if (isa<PropertyType>(type)) {
            auto diag = emitOpError() << "captures a property operand";
            diag.attachNote(operand.getLoc()) << "operand is defined here";
            diag.attachNote(op->getLoc()) << "operand is used here";
            return WalkResult::interrupt();
          }
        }
 
        // Ensure that the layer block does not drive any sinks outside.
        if (auto connect = dyn_cast<FConnectLike>(op)) {
          // ref.define is allowed to drive probes outside the layerblock.
          if (isa<RefDefineOp>(connect))
            return WalkResult::advance();
 
          // Verify that connects only drive values declared in the layer block.
          // If we see a non-passive connect destination, then verify that the
          // source is in the same layer block so that the source is not driven.
          auto dest =
              fieldRefCache.getFieldRefFromValue(connect.getDest()).getValue();
          bool passive = true;
          if (auto type =
                  type_dyn_cast<FIRRTLBaseType>(connect.getDest().getType()))
            passive = type.isPassive();
          // TODO: Improve this verifier.  This is intentionally _not_ verifying
          // a non-passive ConnectLike because it is hugely annoying to do
          // so---it requires a full understanding of if the connect is driving
          // destination-to-source, source-to-destination, or bi-directionally
          // which requires deep inspection of the type.  Eventually, the FIRRTL
          // pass pipeline will remove all flips (e.g., canonicalize connect to
          // matchingconnect) and this hole won't exist.
          if (!passive)
            return WalkResult::advance();
 
          if (isAncestorOfValueOwner(getOperation(), dest))
            return WalkResult::advance();
 
          auto diag =
              connect.emitOpError()
              << "connects to a destination which is defined outside its "
                 "enclosing layer block";
          diag.attachNote(getLoc()) << "enclosing layer block is defined here";
          diag.attachNote(dest.getLoc()) << "destination is defined here";
          return WalkResult::interrupt();
        }
 
        return WalkResult::advance();
      });
 
  return failure(result.wasInterrupted());
}
 
LogicalResult
LayerBlockOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto layerOp =
      symbolTable.lookupNearestSymbolFrom<LayerOp>(*this, getLayerNameAttr());
  if (!layerOp) {
    return emitOpError("invalid symbol reference");
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// Format String operations
//===----------------------------------------------------------------------===//
 
void TimeOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  setNameFn(getResult(), "time");
}
 
void HierarchicalModuleNameOp::getAsmResultNames(
    OpAsmSetValueNameFn setNameFn) {
  setNameFn(getResult(), "hierarchicalmodulename");
}
 
ParseResult FPrintFOp::parse(::mlir::OpAsmParser &parser,
                             ::mlir::OperationState &result) {
  // Parse required clock and condition operands
  OpAsmParser::UnresolvedOperand clock, cond;
  if (parser.parseOperand(clock) || parser.parseComma() ||
      parser.parseOperand(cond) || parser.parseComma())
    return failure();
 
  auto parseFormatString =
      [&parser](llvm::SMLoc &loc, StringAttr &result,
                SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands)
      -> ParseResult {
    loc = parser.getCurrentLocation();
    // NOTE: Don't use parseAttribute. "format_string" : !firrtl.clock is
    // considered as a typed attr.
    std::string resultStr;
    if (parser.parseString(&resultStr))
      return failure();
    result = parser.getBuilder().getStringAttr(resultStr);
 
    // This is an optional
    if (parser.parseOperandList(operands, AsmParser::Delimiter::OptionalParen))
      return failure();
    return success();
  };
 
  // Parse output file and format string substitutions
  SmallVector<OpAsmParser::UnresolvedOperand> outputFileSubstitutions,
      substitutions;
  llvm::SMLoc outputFileLoc, formatStringLoc;
 
  if (parseFormatString(
          outputFileLoc,
          result.getOrAddProperties<FPrintFOp::Properties>().outputFile,
          outputFileSubstitutions) ||
      parser.parseComma() ||
      parseFormatString(
          formatStringLoc,
          result.getOrAddProperties<FPrintFOp::Properties>().formatString,
          substitutions))
    return failure();
 
  if (parseFPrintfAttrs(parser, result.attributes))
    return failure();
 
  // Parse types
  Type clockType, condType;
  SmallVector<Type> restTypes;
 
  if (parser.parseColon() || parser.parseType(clockType) ||
      parser.parseComma() || parser.parseType(condType))
    return failure();
 
  if (succeeded(parser.parseOptionalComma())) {
    if (parser.parseTypeList(restTypes))
      return failure();
  }
 
  // Set operand segment sizes
  result.getOrAddProperties<FPrintFOp::Properties>().operandSegmentSizes = {
      1, 1, static_cast<int32_t>(outputFileSubstitutions.size()),
      static_cast<int32_t>(substitutions.size())};
 
  // Resolve all operands
  if (parser.resolveOperand(clock, clockType, result.operands) ||
      parser.resolveOperand(cond, condType, result.operands) ||
      parser.resolveOperands(
          outputFileSubstitutions,
          ArrayRef(restTypes).take_front(outputFileSubstitutions.size()),
          outputFileLoc, result.operands) ||
      parser.resolveOperands(
          substitutions,
          ArrayRef(restTypes).drop_front(outputFileSubstitutions.size()),
          formatStringLoc, result.operands))
    return failure();
 
  return success();
}
 
void FPrintFOp::print(OpAsmPrinter &p) {
  p << " " << getClock() << ", " << getCond() << ", ";
  p.printAttributeWithoutType(getOutputFileAttr());
  if (!getOutputFileSubstitutions().empty()) {
    p << "(";
    p.printOperands(getOutputFileSubstitutions());
    p << ")";
  }
  p << ", ";
  p.printAttributeWithoutType(getFormatStringAttr());
  if (!getSubstitutions().empty()) {
    p << "(";
    p.printOperands(getSubstitutions());
    p << ")";
  }
  printFPrintfAttrs(p, *this, (*this)->getAttrDictionary());
  p << " : " << getClock().getType() << ", " << getCond().getType();
  if (!getOutputFileSubstitutions().empty() || !getSubstitutions().empty()) {
    for (auto type : getOperands().drop_front(2).getTypes()) {
      p << ", ";
      p.printType(type);
    }
  }
}
 
//===----------------------------------------------------------------------===//
// FFlushOp
//===----------------------------------------------------------------------===//
 
LogicalResult FFlushOp::verify() {
  if (!getOutputFileAttr() && !getOutputFileSubstitutions().empty())
    return emitOpError("substitutions without output file are not allowed");
  return success();
}
 
//===----------------------------------------------------------------------===//
// BindOp
//===----------------------------------------------------------------------===//
 
LogicalResult BindOp::verifyInnerRefs(hw::InnerRefNamespace &ns) {
  auto ref = getInstanceAttr();
  auto target = ns.lookup(ref);
  if (!target)
    return emitError() << "target " << ref << " cannot be resolved";
 
  if (!target.isOpOnly())
    return emitError() << "target " << ref << " is not an operation";
 
  auto instance = dyn_cast<InstanceOp>(target.getOp());
  if (!instance)
    return emitError() << "target " << ref << " is not an instance";
 
  if (!instance.getDoNotPrint())
    return emitError() << "target " << ref << " is not marked doNotPrint";
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// Domain operations
//===----------------------------------------------------------------------===//
 
void DomainCreateAnonOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
LogicalResult
DomainCreateAnonOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  auto domainAttr = getDomainAttr();
 
  auto *symbol = symbolTable.lookupSymbolIn(circuitOp, domainAttr);
  if (!symbol)
    return emitOpError() << "references undefined symbol '" << domainAttr
                         << "'";
 
  if (!isa<DomainOp>(symbol))
    return emitOpError() << "references symbol '" << domainAttr
                         << "' which is not a domain";
 
  // Verify that the result type matches the domain definition
  auto domainType = getResult().getType();
  return domainType.verifySymbolUses(getOperation(), symbolTable);
}
 
void DomainCreateOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
  genericAsmResultNames(*this, setNameFn);
}
 
LogicalResult
DomainCreateOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
  auto circuitOp = getOperation()->getParentOfType<CircuitOp>();
  auto domainAttr = getDomainAttr();
 
  auto *symbol = symbolTable.lookupSymbolIn(circuitOp, domainAttr);
  if (!symbol)
    return emitOpError() << "references undefined symbol '" << domainAttr
                         << "'";
 
  if (!isa<DomainOp>(symbol))
    return emitOpError() << "references symbol '" << domainAttr
                         << "' which is not a domain";
 
  // Verify that the result type matches the domain definition
  auto domainType = getResult().getType();
  return domainType.verifySymbolUses(getOperation(), symbolTable);
}
 
LogicalResult DomainCreateOp::verify() {
  // Get the field definitions from the result type
  auto domainType = getResult().getType();
  auto fields = domainType.getFields();
  auto fieldValues = getFieldValues();
 
  // Check that the number of field values matches the number of fields
  if (fieldValues.size() != fields.size())
    return emitOpError() << "has " << fieldValues.size()
                         << " field value(s) but domain '"
                         << domainType.getName() << "' expects "
                         << fields.size() << " field(s)";
 
  // Check that each field value type matches the corresponding field type
  for (size_t i = 0; i < fields.size(); ++i) {
    auto fieldAttr = cast<DomainFieldAttr>(fields[i]);
    auto expectedType = fieldAttr.getType();
    auto actualType = fieldValues[i].getType();
 
    if (expectedType == actualType)
      continue;
 
    return emitOpError() << "field value " << i << " has type " << actualType
                         << " but domain field '" << fieldAttr.getName()
                         << "' expects type " << expectedType;
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// DomainSubfieldOp
//===----------------------------------------------------------------------===//
 
StringAttr DomainSubfieldOp::getFieldName() {
  auto domainType = getInput().getType();
  auto fields = domainType.getFields();
  auto index = getFieldIndex();
 
  if (index >= fields.size())
    return {};
 
  return cast<DomainFieldAttr>(fields[index]).getName();
}
 
Type DomainSubfieldOp::inferReturnType(Type inType, uint32_t fieldIndex,
                                       std::optional<Location> loc) {
  auto domainType = dyn_cast<DomainType>(inType);
  if (!domainType)
    return emitInferRetTypeError(loc, "base value is not a domain");
 
  auto fields = domainType.getFields();
  if (fieldIndex >= fields.size())
    return emitInferRetTypeError(
        loc, "field index ", fieldIndex,
        +" is greater than the number of fields in the domain");
 
  return cast<DomainFieldAttr>(fields[fieldIndex]).getType();
}
 
Type DomainSubfieldOp::inferReturnType(ValueRange operands,
                                       mlir::DictionaryAttr attrs,
                                       mlir::PropertyRef properties,
                                       mlir::RegionRange regions,
                                       std::optional<Location> loc) {
  Adaptor adaptor(operands, attrs, properties, regions);
  return inferReturnType(adaptor.getInput().getType(), adaptor.getFieldIndex(),
                         loc);
}
 
DomainSubfieldOp DomainSubfieldOp::create(OpBuilder &builder, Type resultType,
                                          Value base, unsigned fieldIndex) {
  OperationState state(builder.getUnknownLoc(),
                       DomainSubfieldOp::getOperationName());
  state.addOperands(base);
  state.addAttribute("fieldIndex", builder.getI32IntegerAttr(fieldIndex));
  state.addTypes(resultType);
  return cast<DomainSubfieldOp>(builder.create(state));
}
 
LogicalResult DomainSubfieldOp::inferReturnTypes(
    MLIRContext *context, std::optional<Location> location, ValueRange operands,
    DictionaryAttr attributes, PropertyRef properties, RegionRange regions,
    SmallVectorImpl<Type> &inferredReturnTypes) {
  Adaptor adaptor(operands, attributes, properties, regions);
  auto resultType = inferReturnType(adaptor.getInput().getType(),
                                    adaptor.getFieldIndex(), location);
  if (!resultType)
    return failure();
  inferredReturnTypes.push_back(resultType);
  return success();
}
 
void DomainSubfieldOp::print(OpAsmPrinter &p) {
  p << ' ' << getInput() << "[";
  p.printKeywordOrString(getFieldName());
  p << "]";
  p.printOptionalAttrDict((*this)->getAttrs(), {"fieldIndex"});
  p << " : " << getInput().getType();
}
 
ParseResult DomainSubfieldOp::parse(OpAsmParser &parser,
                                    OperationState &result) {
  auto *context = parser.getContext();
 
  OpAsmParser::UnresolvedOperand input;
  std::string fieldName;
  DomainType inputType;
 
  if (parser.parseOperand(input) || parser.parseLSquare() ||
      parser.parseKeywordOrString(&fieldName) || parser.parseRSquare() ||
      parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
      parser.parseType(inputType) ||
      parser.resolveOperand(input, inputType, result.operands))
    return failure();
 
  // Find the field index for the field name using DomainType helper
  auto fieldIndex = inputType.getFieldIndex(fieldName);
  if (!fieldIndex)
    return parser.emitError(parser.getNameLoc(),
                            "unknown field '" + fieldName + "' in domain type");
 
  // Add the field index attribute
  result.addAttribute(
      "fieldIndex",
      IntegerAttr::get(IntegerType::get(context, 32), *fieldIndex));
 
  // Infer the result type
  auto resultType = inferReturnType(inputType, *fieldIndex, std::nullopt);
  if (!resultType)
    return failure();
 
  result.addTypes(resultType);
  return success();
}
 
//===----------------------------------------------------------------------===//
// TblGen Generated Logic.
//===----------------------------------------------------------------------===//
 
// Provide the autogenerated implementation guts for the Op classes.
#define GET_OP_CLASSES
#include "circt/Dialect/FIRRTL/FIRRTL.cpp.inc"