23#include "mlir/IR/Builders.h"
24#include "mlir/IR/PatternMatch.h"
25#include "mlir/Interfaces/FunctionImplementation.h"
26#include "llvm/ADT/BitVector.h"
27#include "llvm/ADT/SmallPtrSet.h"
28#include "llvm/ADT/StringSet.h"
37 case ModulePort::Direction::Input:
38 return ModulePort::Direction::Output;
39 case ModulePort::Direction::Output:
40 return ModulePort::Direction::Input;
41 case ModulePort::Direction::InOut:
42 return ModulePort::Direction::InOut;
44 llvm_unreachable(
"unknown PortDirection");
47bool hw::isValidIndexBitWidth(Value index, Value array) {
48 hw::ArrayType arrayType =
49 dyn_cast<hw::ArrayType>(hw::getCanonicalType(array.getType()));
50 assert(arrayType &&
"expected array type");
51 unsigned indexWidth = index.getType().getIntOrFloatBitWidth();
52 auto requiredWidth = llvm::Log2_64_Ceil(arrayType.getNumElements());
53 return requiredWidth == 0 ? (indexWidth == 0 || indexWidth == 1)
54 : indexWidth == requiredWidth;
47bool hw::isValidIndexBitWidth(Value index, Value array) {
…}
58bool hw::isCombinational(Operation *op) {
59 struct IsCombClassifier :
public TypeOpVisitor<IsCombClassifier, bool> {
64 return (op->getDialect() && op->getDialect()->getNamespace() ==
"comb") ||
58bool hw::isCombinational(Operation *op) {
…}
70 if (
auto structCreate = dyn_cast_or_null<StructCreateOp>(inputOp)) {
71 return structCreate.getOperand(fieldIndex);
75 if (
auto structInject = dyn_cast_or_null<StructInjectOp>(inputOp)) {
76 if (structInject.getFieldIndex() != fieldIndex)
78 return structInject.getNewValue();
84 ArrayRef<Attribute> attrs) {
86 return ArrayAttr::get(context, {});
89 if (a && !cast<DictionaryAttr>(a).empty()) {
94 return ArrayAttr::get(context, {});
95 return ArrayAttr::get(context, attrs);
101 OpAsmSetValueNameFn setNameFn) {
105 auto module = cast<HWModuleOp>(region.getParentOp());
107 auto *block = ®ion.front();
108 for (
size_t i = 0, e = block->getNumArguments(); i != e; ++i) {
109 auto name =
module.getInputName(i);
111 setNameFn(block->getArgument(i), name);
127LogicalResult hw::checkParameterInContext(
128 Attribute value, ArrayAttr moduleParameters,
130 bool disallowParamRefs) {
133 if (isa<IntegerAttr>(value) || isa<FloatAttr>(value) ||
134 isa<StringAttr>(value) || isa<ParamVerbatimAttr>(value))
138 if (
auto expr = dyn_cast<ParamExprAttr>(value)) {
139 for (
auto op : expr.getOperands())
148 if (
auto parameterRef = dyn_cast<ParamDeclRefAttr>(value)) {
149 auto nameAttr = parameterRef.getName();
153 if (disallowParamRefs) {
154 instanceError([&](
auto &diag) {
155 diag <<
"parameter " << nameAttr
156 <<
" cannot be used as a default value for a parameter";
163 for (
auto param : moduleParameters) {
164 auto paramAttr = cast<ParamDeclAttr>(param);
165 if (paramAttr.getName() != nameAttr)
169 if (paramAttr.getType() == parameterRef.getType())
172 instanceError([&](
auto &diag) {
173 diag <<
"parameter " << nameAttr <<
" used with type "
174 << parameterRef.getType() <<
"; should have type "
175 << paramAttr.getType();
181 instanceError([&](
auto &diag) {
182 diag <<
"use of unknown parameter " << nameAttr;
188 instanceError([&](
auto &diag) {
189 diag <<
"invalid parameter value " << value;
127LogicalResult hw::checkParameterInContext( {
…}
201LogicalResult hw::checkParameterInContext(Attribute value, Operation *module,
203 bool disallowParamRefs) {
205 [&](
const std::function<bool(InFlightDiagnostic &)> &fn) {
207 auto diag = usingOp->emitOpError();
209 diag.attachNote(module->getLoc()) <<
"module declared here";
214 module->getAttrOfType<ArrayAttr>(
"parameters"),
215 emitError, disallowParamRefs);
201LogicalResult hw::checkParameterInContext(Attribute value, Operation *module, {
…}
220bool hw::isValidParameterExpression(Attribute attr, Operation *module) {
220bool hw::isValidParameterExpression(Attribute attr, Operation *module) {
…}
229 for (
auto [i, barg] : llvm::enumerate(bodyRegion.getArguments())) {
262#include "circt/Dialect/HW/HWCanonicalization.cpp.inc"
269void ConstantOp::print(OpAsmPrinter &p) {
271 p.printAttribute(getValueAttr());
272 p.printOptionalAttrDict((*this)->getAttrs(), {
"value"});
275ParseResult ConstantOp::parse(OpAsmParser &parser, OperationState &result) {
276 IntegerAttr valueAttr;
278 if (parser.parseAttribute(valueAttr,
"value", result.attributes) ||
279 parser.parseOptionalAttrDict(result.attributes))
282 result.addTypes(valueAttr.getType());
286LogicalResult ConstantOp::verify() {
290 "hw.constant attribute bitwidth doesn't match return type");
297void ConstantOp::build(OpBuilder &builder, OperationState &result,
298 const APInt &value) {
300 auto type = IntegerType::get(builder.getContext(), value.getBitWidth());
301 auto attr = builder.getIntegerAttr(type, value);
302 return build(builder, result, type, attr);
307void ConstantOp::build(OpBuilder &builder, OperationState &result,
309 return build(builder, result, value.getType(), value);
316void ConstantOp::build(OpBuilder &builder, OperationState &result, Type type,
318 auto numBits = cast<IntegerType>(type).getWidth();
319 build(builder, result,
320 APInt(numBits, (uint64_t)value,
true,
324void ConstantOp::getAsmResultNames(
325 function_ref<
void(Value, StringRef)> setNameFn) {
326 auto intTy = getType();
327 auto intCst = getValue();
330 if (cast<IntegerType>(intTy).
getWidth() == 1)
331 return setNameFn(getResult(), intCst.isZero() ?
"false" :
"true");
334 SmallVector<char, 32> specialNameBuffer;
335 llvm::raw_svector_ostream specialName(specialNameBuffer);
336 specialName <<
'c' << intCst <<
'_' << intTy;
337 setNameFn(getResult(), specialName.str());
340OpFoldResult ConstantOp::fold(FoldAdaptor adaptor) {
341 assert(adaptor.getOperands().empty() &&
"constant has no operands");
342 return getValueAttr();
353 ArrayRef<StringRef> ignoredAttrs = {}) {
354 auto names = op.getAttributeNames();
355 llvm::SmallDenseSet<StringRef> nameSet;
356 nameSet.reserve(names.size() + ignoredAttrs.size());
357 nameSet.insert(names.begin(), names.end());
358 nameSet.insert(ignoredAttrs.begin(), ignoredAttrs.end());
359 return llvm::any_of(op->getAttrs(), [&](
auto namedAttr) {
360 return !nameSet.contains(namedAttr.getName());
364void WireOp::getAsmResultNames(OpAsmSetValueNameFn setNameFn) {
366 auto nameAttr = (*this)->getAttrOfType<StringAttr>(
"name");
367 if (nameAttr && !nameAttr.getValue().empty())
368 setNameFn(getResult(), nameAttr.getValue());
371std::optional<size_t> WireOp::getTargetResultIndex() {
return 0; }
373OpFoldResult WireOp::fold(FoldAdaptor adaptor) {
382LogicalResult WireOp::canonicalize(WireOp wire, PatternRewriter &rewriter) {
388 if (wire.getInnerSymAttr())
393 if (
auto *inputOp = wire.getInput().getDefiningOp())
395 rewriter.modifyOpInPlace(inputOp,
396 [&] { inputOp->setAttr(
"sv.namehint", name); });
398 rewriter.replaceOp(wire, wire.getInput());
408 if (
auto typeAlias = dyn_cast<TypeAliasType>(type))
409 type = typeAlias.getCanonicalType();
411 if (
auto structType = dyn_cast<StructType>(type)) {
412 auto arrayAttr = dyn_cast<ArrayAttr>(attr);
414 return op->emitOpError(
"expected array attribute for constant of type ")
416 if (structType.getElements().size() != arrayAttr.size())
417 return op->emitOpError(
"array attribute (")
418 << arrayAttr.size() <<
") has wrong size for struct constant ("
419 << structType.getElements().size() <<
")";
421 for (
auto [attr, fieldInfo] :
422 llvm::zip(arrayAttr.getValue(), structType.getElements())) {
426 }
else if (
auto arrayType = dyn_cast<ArrayType>(type)) {
427 auto arrayAttr = dyn_cast<ArrayAttr>(attr);
429 return op->emitOpError(
"expected array attribute for constant of type ")
431 if (arrayType.getNumElements() != arrayAttr.size())
432 return op->emitOpError(
"array attribute (")
433 << arrayAttr.size() <<
") has wrong size for array constant ("
434 << arrayType.getNumElements() <<
")";
437 for (
auto attr : arrayAttr.getValue()) {
441 }
else if (
auto arrayType = dyn_cast<UnpackedArrayType>(type)) {
442 auto arrayAttr = dyn_cast<ArrayAttr>(attr);
444 return op->emitOpError(
"expected array attribute for constant of type ")
447 if (arrayType.getNumElements() != arrayAttr.size())
448 return op->emitOpError(
"array attribute (")
450 <<
") has wrong size for unpacked array constant ("
451 << arrayType.getNumElements() <<
")";
453 for (
auto attr : arrayAttr.getValue()) {
457 }
else if (
auto enumType = dyn_cast<EnumType>(type)) {
458 auto stringAttr = dyn_cast<StringAttr>(attr);
460 return op->emitOpError(
"expected string attribute for constant of type ")
462 }
else if (
auto intType = dyn_cast<IntegerType>(type)) {
464 auto intAttr = dyn_cast<IntegerAttr>(attr);
466 return op->emitOpError(
"expected integer attribute for constant of type ")
469 if (intAttr.getValue().getBitWidth() != intType.getWidth())
470 return op->emitOpError(
"hw.constant attribute bitwidth "
471 "doesn't match return type");
472 }
else if (
auto typedAttr = dyn_cast<TypedAttr>(attr)) {
473 if (typedAttr.getType() != type)
474 return op->emitOpError(
"typed attr doesn't match the return type ")
477 return op->emitOpError(
"unknown element type ") << type;
482LogicalResult AggregateConstantOp::verify() {
486OpFoldResult AggregateConstantOp::fold(FoldAdaptor) {
return getFieldsAttr(); }
494 if (p.parseType(resultType) || p.parseEqual() ||
495 p.parseAttribute(value, resultType))
502 p << resultType <<
" = ";
503 p.printAttributeWithoutType(value);
506LogicalResult ParamValueOp::verify() {
512OpFoldResult ParamValueOp::fold(FoldAdaptor adaptor) {
513 assert(adaptor.getOperands().empty() &&
"hw.param.value has no operands");
514 return getValueAttr();
523 return isa<HWModuleLike, InstanceOp>(moduleOrInstance);
529 return TypeSwitch<Operation *, FunctionType>(moduleOrInstance)
530 .Case<InstanceOp, InstanceChoiceOp>([](
auto instance) {
531 SmallVector<Type> inputs(instance->getOperandTypes());
532 SmallVector<Type> results(instance->getResultTypes());
533 return FunctionType::get(instance->getContext(), inputs, results);
536 [](
auto mod) {
return mod.getHWModuleType().getFuncType(); })
537 .Default([](Operation *op) {
538 return cast<FunctionType>(
539 cast<mlir::FunctionOpInterface>(op).getFunctionType());
547 auto nameAttr =
module->getAttrOfType<StringAttr>("verilogName");
551 return module->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
554template <
typename ModuleTy>
556buildModule(OpBuilder &builder, OperationState &result, StringAttr name,
558 ArrayRef<NamedAttribute> attributes, StringAttr comment) {
559 using namespace mlir::function_interface_impl;
562 result.addAttribute(SymbolTable::getSymbolAttrName(), name);
564 SmallVector<Attribute> perPortAttrs;
565 SmallVector<ModulePort> portTypes;
567 for (
auto elt : ports) {
568 portTypes.push_back(elt);
569 llvm::SmallVector<NamedAttribute> portAttrs;
571 llvm::copy(elt.attrs, std::back_inserter(portAttrs));
572 perPortAttrs.push_back(builder.getDictionaryAttr(portAttrs));
577 parameters = builder.getArrayAttr({});
580 auto type = ModuleType::get(builder.getContext(), portTypes);
581 result.addAttribute(ModuleTy::getModuleTypeAttrName(result.name),
582 TypeAttr::get(type));
583 result.addAttribute(
"per_port_attrs",
585 result.addAttribute(
"parameters", parameters);
587 comment = builder.getStringAttr(
"");
588 result.addAttribute(
"comment", comment);
589 result.addAttributes(attributes);
556buildModule(OpBuilder &builder, OperationState &result, StringAttr name, {
…}
595 MLIRContext *context, ArrayRef<std::pair<unsigned, PortInfo>> insertArgs,
596 ArrayRef<unsigned> removeArgs, ArrayRef<Attribute> oldArgNames,
597 ArrayRef<Type> oldArgTypes, ArrayRef<Attribute> oldArgAttrs,
598 ArrayRef<Location> oldArgLocs, SmallVector<Attribute> &newArgNames,
599 SmallVector<Type> &newArgTypes, SmallVector<Attribute> &newArgAttrs,
600 SmallVector<Location> &newArgLocs, Block *body =
nullptr) {
605 assert(llvm::is_sorted(insertArgs,
606 [](
auto &a,
auto &b) {
return a.first < b.first; }) &&
607 "insertArgs must be in ascending order");
608 assert(llvm::is_sorted(removeArgs, [](
auto &a,
auto &b) {
return a < b; }) &&
609 "removeArgs must be in ascending order");
612 auto oldArgCount = oldArgTypes.size();
613 auto newArgCount = oldArgCount + insertArgs.size() - removeArgs.size();
614 assert((
int)newArgCount >= 0);
616 newArgNames.reserve(newArgCount);
617 newArgTypes.reserve(newArgCount);
618 newArgAttrs.reserve(newArgCount);
619 newArgLocs.reserve(newArgCount);
621 auto exportPortAttrName = StringAttr::get(context,
"hw.exportPort");
622 auto emptyDictAttr = DictionaryAttr::get(context, {});
623 auto unknownLoc = UnknownLoc::get(context);
625 BitVector erasedIndices;
627 erasedIndices.resize(oldArgCount + insertArgs.size());
629 for (
unsigned argIdx = 0, idx = 0; argIdx <= oldArgCount; ++argIdx, ++idx) {
631 while (!insertArgs.empty() && insertArgs[0].first == argIdx) {
632 auto port = insertArgs[0].second;
634 !isa<InOutType>(port.type))
635 port.type = InOutType::get(port.type);
636 auto sym = port.getSym();
638 (sym && !sym.empty())
639 ? DictionaryAttr::get(context, {{exportPortAttrName, sym}})
641 newArgNames.push_back(port.name);
642 newArgTypes.push_back(port.type);
643 newArgAttrs.push_back(attr);
644 insertArgs = insertArgs.drop_front();
645 LocationAttr loc = port.loc ? port.loc : unknownLoc;
646 newArgLocs.push_back(loc);
648 body->insertArgument(idx++, port.type, loc);
650 if (argIdx == oldArgCount)
654 bool removed =
false;
655 while (!removeArgs.empty() && removeArgs[0] == argIdx) {
656 removeArgs = removeArgs.drop_front();
662 erasedIndices.set(idx);
664 newArgNames.push_back(oldArgNames[argIdx]);
665 newArgTypes.push_back(oldArgTypes[argIdx]);
666 newArgAttrs.push_back(oldArgAttrs.empty() ? emptyDictAttr
667 : oldArgAttrs[argIdx]);
668 newArgLocs.push_back(oldArgLocs[argIdx]);
673 body->eraseArguments(erasedIndices);
675 assert(newArgNames.size() == newArgCount);
676 assert(newArgTypes.size() == newArgCount);
677 assert(newArgAttrs.size() == newArgCount);
678 assert(newArgLocs.size() == newArgCount);
692[[deprecated]]
static void
694 ArrayRef<std::pair<unsigned, PortInfo>> insertInputs,
695 ArrayRef<std::pair<unsigned, PortInfo>> insertOutputs,
696 ArrayRef<unsigned> removeInputs,
697 ArrayRef<unsigned> removeOutputs, Block *body =
nullptr) {
698 auto moduleOp = cast<HWModuleLike>(op);
699 auto *context = moduleOp.getContext();
702 auto oldArgNames = moduleOp.getInputNames();
703 auto oldArgTypes = moduleOp.getInputTypes();
704 auto oldArgAttrs = moduleOp.getAllInputAttrs();
705 auto oldArgLocs = moduleOp.getInputLocs();
707 auto oldResultNames = moduleOp.getOutputNames();
708 auto oldResultTypes = moduleOp.getOutputTypes();
709 auto oldResultAttrs = moduleOp.getAllOutputAttrs();
710 auto oldResultLocs = moduleOp.getOutputLocs();
713 SmallVector<Attribute> newArgNames, newResultNames;
714 SmallVector<Type> newArgTypes, newResultTypes;
715 SmallVector<Attribute> newArgAttrs, newResultAttrs;
716 SmallVector<Location> newArgLocs, newResultLocs;
719 oldArgTypes, oldArgAttrs, oldArgLocs, newArgNames,
720 newArgTypes, newArgAttrs, newArgLocs, body);
723 oldResultTypes, oldResultAttrs, oldResultLocs,
724 newResultNames, newResultTypes, newResultAttrs,
728 auto fnty = FunctionType::get(context, newArgTypes, newResultTypes);
730 moduleOp.setHWModuleType(modty);
731 moduleOp.setAllInputAttrs(newArgAttrs);
732 moduleOp.setAllOutputAttrs(newResultAttrs);
734 newArgLocs.append(newResultLocs.begin(), newResultLocs.end());
735 moduleOp.setAllPortLocs(newArgLocs);
738void HWModuleOp::build(OpBuilder &builder, OperationState &result,
740 ArrayAttr parameters,
741 ArrayRef<NamedAttribute> attributes, StringAttr comment,
742 bool shouldEnsureTerminator) {
743 buildModule<HWModuleOp>(builder, result, name, ports, parameters, attributes,
747 auto *bodyRegion = result.regions[0].get();
749 bodyRegion->push_back(body);
752 auto unknownLoc = builder.getUnknownLoc();
753 for (
auto port : ports.getInputs()) {
754 auto loc = port.loc ? Location(port.loc) : unknownLoc;
755 auto type = port.type;
756 if (port.isInOut() && !isa<InOutType>(type))
757 type = InOutType::get(type);
758 body->addArgument(type, loc);
762 auto unknownLocAttr = cast<LocationAttr>(unknownLoc);
763 SmallVector<Attribute> resultLocs;
764 for (
auto port : ports.getOutputs())
765 resultLocs.push_back(port.loc ? port.loc : unknownLocAttr);
766 result.addAttribute(
"result_locs", builder.getArrayAttr(resultLocs));
768 if (shouldEnsureTerminator)
769 HWModuleOp::ensureTerminator(*bodyRegion, builder, result.location);
772void HWModuleOp::build(OpBuilder &builder, OperationState &result,
773 StringAttr name, ArrayRef<PortInfo> ports,
774 ArrayAttr parameters,
775 ArrayRef<NamedAttribute> attributes,
776 StringAttr comment) {
777 build(builder, result, name,
ModulePortInfo(ports), parameters, attributes,
781void HWModuleOp::build(OpBuilder &builder, OperationState &odsState,
784 ArrayRef<NamedAttribute> attributes,
785 StringAttr comment) {
786 build(builder, odsState, name, ports, parameters, attributes, comment,
788 auto *bodyRegion = odsState.regions[0].get();
789 OpBuilder::InsertionGuard guard(builder);
791 builder.setInsertionPointToEnd(&bodyRegion->front());
792 modBuilder(builder, accessor);
794 llvm::SmallVector<Value> outputOperands = accessor.getOutputOperands();
795 builder.create<hw::OutputOp>(odsState.location, outputOperands);
798void HWModuleOp::modifyPorts(
799 ArrayRef<std::pair<unsigned, PortInfo>> insertInputs,
800 ArrayRef<std::pair<unsigned, PortInfo>> insertOutputs,
801 ArrayRef<unsigned> eraseInputs, ArrayRef<unsigned> eraseOutputs) {
809StringAttr HWModuleExternOp::getVerilogModuleNameAttr() {
810 if (
auto vName = getVerilogNameAttr())
813 return (*this)->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName());
816StringAttr HWModuleGeneratedOp::getVerilogModuleNameAttr() {
817 if (
auto vName = getVerilogNameAttr()) {
820 return (*this)->getAttrOfType<StringAttr>(
821 ::mlir::SymbolTable::getSymbolAttrName());
824void HWModuleExternOp::build(OpBuilder &builder, OperationState &result,
826 StringRef verilogName, ArrayAttr parameters,
827 ArrayRef<NamedAttribute> attributes) {
828 buildModule<HWModuleExternOp>(builder, result, name, ports, parameters,
832 LocationAttr unknownLoc = builder.getUnknownLoc();
833 SmallVector<Attribute> portLocs;
834 for (
auto elt : ports)
835 portLocs.push_back(elt.loc ? elt.loc : unknownLoc);
836 result.addAttribute(
"port_locs", builder.getArrayAttr(portLocs));
838 if (!verilogName.empty())
839 result.addAttribute(
"verilogName", builder.getStringAttr(verilogName));
842void HWModuleExternOp::build(OpBuilder &builder, OperationState &result,
843 StringAttr name, ArrayRef<PortInfo> ports,
844 StringRef verilogName, ArrayAttr parameters,
845 ArrayRef<NamedAttribute> attributes) {
846 build(builder, result, name,
ModulePortInfo(ports), verilogName, parameters,
850void HWModuleExternOp::modifyPorts(
851 ArrayRef<std::pair<unsigned, PortInfo>> insertInputs,
852 ArrayRef<std::pair<unsigned, PortInfo>> insertOutputs,
853 ArrayRef<unsigned> eraseInputs, ArrayRef<unsigned> eraseOutputs) {
858void HWModuleExternOp::appendOutputs(
859 ArrayRef<std::pair<StringAttr, Value>> outputs) {}
861void HWModuleGeneratedOp::build(OpBuilder &builder, OperationState &result,
862 FlatSymbolRefAttr genKind, StringAttr name,
864 StringRef verilogName, ArrayAttr parameters,
865 ArrayRef<NamedAttribute> attributes) {
866 buildModule<HWModuleGeneratedOp>(builder, result, name, ports, parameters,
869 LocationAttr unknownLoc = builder.getUnknownLoc();
870 SmallVector<Attribute> portLocs;
871 for (
auto elt : ports)
872 portLocs.push_back(elt.loc ? elt.loc : unknownLoc);
873 result.addAttribute(
"port_locs", builder.getArrayAttr(portLocs));
875 result.addAttribute(
"generatorKind", genKind);
876 if (!verilogName.empty())
877 result.addAttribute(
"verilogName", builder.getStringAttr(verilogName));
880void HWModuleGeneratedOp::build(OpBuilder &builder, OperationState &result,
881 FlatSymbolRefAttr genKind, StringAttr name,
882 ArrayRef<PortInfo> ports, StringRef verilogName,
883 ArrayAttr parameters,
884 ArrayRef<NamedAttribute> attributes) {
885 build(builder, result, genKind, name,
ModulePortInfo(ports), verilogName,
886 parameters, attributes);
889void HWModuleGeneratedOp::modifyPorts(
890 ArrayRef<std::pair<unsigned, PortInfo>> insertInputs,
891 ArrayRef<std::pair<unsigned, PortInfo>> insertOutputs,
892 ArrayRef<unsigned> eraseInputs, ArrayRef<unsigned> eraseOutputs) {
897void HWModuleGeneratedOp::appendOutputs(
898 ArrayRef<std::pair<StringAttr, Value>> outputs) {}
900static bool hasAttribute(StringRef name, ArrayRef<NamedAttribute> attrs) {
901 for (
auto &argAttr : attrs)
902 if (argAttr.getName() == name)
907template <
typename ModuleTy>
909 OperationState &result) {
911 using namespace mlir::function_interface_impl;
912 auto builder = parser.getBuilder();
913 auto loc = parser.getCurrentLocation();
916 (void)mlir::impl::parseOptionalVisibilityKeyword(parser, result.attributes);
920 if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
925 FlatSymbolRefAttr kindAttr;
926 if constexpr (std::is_same_v<ModuleTy, HWModuleGeneratedOp>) {
927 if (parser.parseComma() ||
928 parser.parseAttribute(kindAttr,
"generatorKind", result.attributes)) {
934 ArrayAttr parameters;
938 SmallVector<module_like_impl::PortParse> ports;
944 if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
948 parser.emitError(loc,
"explicit `parameters` attributes not allowed");
952 result.addAttribute(
"parameters", parameters);
953 result.addAttribute(ModuleTy::getModuleTypeAttrName(result.name), modType);
957 SmallVector<Attribute> attrs;
958 for (
auto &port : ports)
959 attrs.push_back(port.attrs ? port.attrs : builder.getDictionaryAttr({}));
961 auto nonEmptyAttrsFn = [](Attribute attr) {
962 return attr && !cast<DictionaryAttr>(attr).empty();
964 if (llvm::any_of(attrs, nonEmptyAttrsFn))
965 result.addAttribute(ModuleTy::getPerPortAttrsAttrName(result.name),
966 builder.getArrayAttr(attrs));
969 auto unknownLoc = builder.getUnknownLoc();
970 auto nonEmptyLocsFn = [unknownLoc](Attribute attr) {
971 return attr && cast<Location>(attr) != unknownLoc;
973 SmallVector<Attribute> locs;
974 StringAttr portLocsAttrName;
975 if constexpr (std::is_same_v<ModuleTy, HWModuleOp>) {
978 portLocsAttrName = ModuleTy::getResultLocsAttrName(result.name);
979 for (
auto &port : ports)
981 locs.push_back(port.sourceLoc ? Location(*port.sourceLoc) : unknownLoc);
984 portLocsAttrName = ModuleTy::getPortLocsAttrName(result.name);
985 for (
auto &port : ports)
986 locs.push_back(port.sourceLoc ? Location(*port.sourceLoc) : unknownLoc);
988 if (llvm::any_of(locs, nonEmptyLocsFn))
989 result.addAttribute(portLocsAttrName, builder.getArrayAttr(locs));
992 SmallVector<OpAsmParser::Argument, 4> entryArgs;
993 for (
auto &port : ports)
995 entryArgs.push_back(port);
998 auto *body = result.addRegion();
999 if (std::is_same_v<ModuleTy, HWModuleOp>) {
1000 if (parser.parseRegion(*body, entryArgs))
1003 HWModuleOp::ensureTerminator(*body, parser.getBuilder(), result.location);
1008ParseResult HWModuleOp::parse(OpAsmParser &parser, OperationState &result) {
1009 return parseHWModuleOp<HWModuleOp>(parser, result);
1012ParseResult HWModuleExternOp::parse(OpAsmParser &parser,
1013 OperationState &result) {
1014 return parseHWModuleOp<HWModuleExternOp>(parser, result);
1017ParseResult HWModuleGeneratedOp::parse(OpAsmParser &parser,
1018 OperationState &result) {
1019 return parseHWModuleOp<HWModuleGeneratedOp>(parser, result);
1023 if (
auto mod = dyn_cast<HWModuleLike>(op))
1024 return mod.getHWModuleType().getFuncType();
1025 return cast<FunctionType>(
1026 cast<mlir::FunctionOpInterface>(op).getFunctionType());
1029template <
typename ModuleTy>
1033 StringRef visibilityAttrName = SymbolTable::getVisibilityAttrName();
1034 if (
auto visibility = mod.getOperation()->template getAttrOfType<StringAttr>(
1035 visibilityAttrName))
1036 p << visibility.getValue() <<
' ';
1039 p.printSymbolName(SymbolTable::getSymbolName(mod.getOperation()).getValue());
1040 if (
auto gen = dyn_cast<HWModuleGeneratedOp>(mod.getOperation())) {
1042 p.printSymbolName(gen.getGeneratorKind());
1050 SmallVector<StringRef, 3> omittedAttrs;
1051 if (isa<HWModuleGeneratedOp>(mod.getOperation()))
1052 omittedAttrs.push_back(
"generatorKind");
1053 if constexpr (std::is_same_v<ModuleTy, HWModuleOp>)
1054 omittedAttrs.push_back(mod.getResultLocsAttrName());
1056 omittedAttrs.push_back(mod.getPortLocsAttrName());
1057 omittedAttrs.push_back(mod.getModuleTypeAttrName());
1058 omittedAttrs.push_back(mod.getPerPortAttrsAttrName());
1059 omittedAttrs.push_back(mod.getParametersAttrName());
1060 omittedAttrs.push_back(visibilityAttrName);
1062 mod.getOperation()->template getAttrOfType<StringAttr>(
"comment"))
1063 if (cmt.getValue().empty())
1064 omittedAttrs.push_back(
"comment");
1066 mlir::function_interface_impl::printFunctionAttributes(p, mod.getOperation(),
1070void HWModuleExternOp::print(OpAsmPrinter &p) {
printModuleOp(p, *
this); }
1071void HWModuleGeneratedOp::print(OpAsmPrinter &p) {
printModuleOp(p, *
this); }
1073void HWModuleOp::print(OpAsmPrinter &p) {
1077 Region &body = getBody();
1078 if (!body.empty()) {
1080 p.printRegion(body,
false,
1086 assert(isa<HWModuleLike>(module) &&
1087 "verifier hook should only be called on modules");
1089 SmallPtrSet<Attribute, 4> paramNames;
1092 for (
auto param :
module->getAttrOfType<ArrayAttr>("parameters")) {
1093 auto paramAttr = cast<ParamDeclAttr>(param);
1097 if (!paramNames.insert(paramAttr.getName()).second)
1098 return module->emitOpError("parameter ")
1099 << paramAttr << " has the same name as a previous parameter";
1102 auto value = paramAttr.getValue();
1106 auto typedValue = dyn_cast<TypedAttr>(value);
1108 return module->emitOpError("parameter ")
1109 << paramAttr << " should have a typed value; has value
" << value;
1111 if (typedValue.getType() != paramAttr.getType())
1112 return module->emitOpError("parameter
")
1113 << paramAttr << " should have type
" << paramAttr.getType()
1114 << "; has type
" << typedValue.getType();
1116 // Verify that this is a valid parameter value, disallowing parameter
1117 // references. We could allow parameters to refer to each other in the
1118 // future with lexical ordering if there is a need.
1119 if (failed(checkParameterInContext(value, module, module,
1120 /*disallowParamRefs=*/true)))
1126LogicalResult HWModuleOp::verify() {
1127 if (failed(verifyModuleCommon(*this)))
1130 auto type = getModuleType();
1131 auto *body = getBodyBlock();
1133 // Verify the number of block arguments.
1134 auto numInputs = type.getNumInputs();
1135 if (body->getNumArguments() != numInputs)
1136 return emitOpError("entry block must have
")
1137 << numInputs << " arguments to match
module signature";
1144std::pair<StringAttr, BlockArgument>
1145HWModuleOp::insertInput(
unsigned index, StringAttr name, Type ty) {
1149 for (
auto port : ports)
1150 ns.newName(port.name.getValue());
1151 auto nameAttr = StringAttr::get(getContext(), ns.
newName(name.getValue()));
1157 port.
name = nameAttr;
1164 return {nameAttr, body->getArgument(index)};
1167void HWModuleOp::insertOutputs(
unsigned index,
1168 ArrayRef<std::pair<StringAttr, Value>> outputs) {
1170 auto output = cast<OutputOp>(
getBodyBlock()->getTerminator());
1171 assert(index <= output->getNumOperands() &&
"invalid output index");
1174 SmallVector<std::pair<unsigned, PortInfo>> indexedNewPorts;
1175 for (
auto &[name, value] : outputs) {
1179 port.
type = value.getType();
1180 indexedNewPorts.emplace_back(index, port);
1186 for (
auto &[name, value] : outputs)
1187 output->insertOperands(index++, value);
1190void HWModuleOp::appendOutputs(ArrayRef<std::pair<StringAttr, Value>> outputs) {
1191 return insertOutputs(getNumOutputPorts(), outputs);
1194void HWModuleOp::getAsmBlockArgumentNames(mlir::Region ®ion,
1199void HWModuleExternOp::getAsmBlockArgumentNames(
1204template <
typename ModTy>
1206 auto locs =
module.getPortLocs();
1208 SmallVector<Location> retval;
1209 retval.reserve(locs->size());
1210 for (
auto l : *locs)
1211 retval.push_back(cast<Location>(l));
1213 assert(!locs->size() || locs->size() == module.getNumPorts());
1216 return SmallVector<Location>(module.getNumPorts(),
1217 UnknownLoc::get(module.getContext()));
1220SmallVector<Location> HWModuleOp::getAllPortLocs() {
1221 SmallVector<Location> portLocs;
1223 auto resultLocs = getResultLocsAttr();
1224 unsigned inputCount = 0;
1226 auto unknownLoc = UnknownLoc::get(getContext());
1228 for (
unsigned i = 0, e =
getNumPorts(); i < e; ++i) {
1229 if (modType.isOutput(i)) {
1230 auto loc = resultLocs
1232 resultLocs.getValue()[portLocs.size() - inputCount])
1234 portLocs.push_back(loc);
1236 auto loc = body ? body->getArgument(inputCount).getLoc() : unknownLoc;
1237 portLocs.push_back(loc);
1244SmallVector<Location> HWModuleExternOp::getAllPortLocs() {
1245 return ::getAllPortLocs(*
this);
1248SmallVector<Location> HWModuleGeneratedOp::getAllPortLocs() {
1249 return ::getAllPortLocs(*
this);
1252void HWModuleOp::setAllPortLocsAttrs(ArrayRef<Attribute> locs) {
1253 SmallVector<Attribute> resultLocs;
1254 unsigned inputCount = 0;
1257 for (
unsigned i = 0, e =
getNumPorts(); i < e; ++i) {
1258 if (modType.isOutput(i))
1259 resultLocs.push_back(locs[i]);
1261 body->getArgument(inputCount++).setLoc(cast<Location>(locs[i]));
1263 setResultLocsAttr(ArrayAttr::get(getContext(), resultLocs));
1266void HWModuleExternOp::setAllPortLocsAttrs(ArrayRef<Attribute> locs) {
1267 setPortLocsAttr(ArrayAttr::get(getContext(), locs));
1270void HWModuleGeneratedOp::setAllPortLocsAttrs(ArrayRef<Attribute> locs) {
1271 setPortLocsAttr(ArrayAttr::get(getContext(), locs));
1274template <
typename ModTy>
1276 auto numInputs =
module.getNumInputPorts();
1277 SmallVector<Attribute> argNames(names.begin(), names.begin() + numInputs);
1278 SmallVector<Attribute> resNames(names.begin() + numInputs, names.end());
1279 auto oldType =
module.getModuleType();
1280 SmallVector<ModulePort> newPorts(oldType.getPorts().begin(),
1281 oldType.getPorts().end());
1282 for (
size_t i = 0UL, e = newPorts.size(); i != e; ++i)
1283 newPorts[i].name = cast<StringAttr>(names[i]);
1284 auto newType = ModuleType::get(module.getContext(), newPorts);
1285 module.setModuleType(newType);
1288void HWModuleOp::setAllPortNames(ArrayRef<Attribute> names) {
1292void HWModuleExternOp::setAllPortNames(ArrayRef<Attribute> names) {
1296void HWModuleGeneratedOp::setAllPortNames(ArrayRef<Attribute> names) {
1300ArrayRef<Attribute> HWModuleOp::getAllPortAttrs() {
1301 auto attrs = getPerPortAttrs();
1302 if (attrs && !attrs->empty())
1303 return attrs->getValue();
1307ArrayRef<Attribute> HWModuleExternOp::getAllPortAttrs() {
1308 auto attrs = getPerPortAttrs();
1309 if (attrs && !attrs->empty())
1310 return attrs->getValue();
1314ArrayRef<Attribute> HWModuleGeneratedOp::getAllPortAttrs() {
1315 auto attrs = getPerPortAttrs();
1316 if (attrs && !attrs->empty())
1317 return attrs->getValue();
1321void HWModuleOp::setAllPortAttrs(ArrayRef<Attribute> attrs) {
1322 setPerPortAttrsAttr(
arrayOrEmpty(getContext(), attrs));
1325void HWModuleExternOp::setAllPortAttrs(ArrayRef<Attribute> attrs) {
1326 setPerPortAttrsAttr(
arrayOrEmpty(getContext(), attrs));
1329void HWModuleGeneratedOp::setAllPortAttrs(ArrayRef<Attribute> attrs) {
1330 setPerPortAttrsAttr(
arrayOrEmpty(getContext(), attrs));
1333void HWModuleOp::removeAllPortAttrs() {
1334 setPerPortAttrsAttr(ArrayAttr::get(getContext(), {}));
1337void HWModuleExternOp::removeAllPortAttrs() {
1338 setPerPortAttrsAttr(ArrayAttr::get(getContext(), {}));
1341void HWModuleGeneratedOp::removeAllPortAttrs() {
1342 setPerPortAttrsAttr(ArrayAttr::get(getContext(), {}));
1347template <
typename ModTy>
1349 auto argAttrs = mod.getAllInputAttrs();
1350 auto resAttrs = mod.getAllOutputAttrs();
1351 mod.setModuleTypeAttr(TypeAttr::get(type));
1352 unsigned newNumArgs = type.getNumInputs();
1353 unsigned newNumResults = type.getNumOutputs();
1355 auto emptyDict = DictionaryAttr::get(mod.getContext());
1356 argAttrs.resize(newNumArgs, emptyDict);
1357 resAttrs.resize(newNumResults, emptyDict);
1359 SmallVector<Attribute> attrs;
1360 attrs.append(argAttrs.begin(), argAttrs.end());
1361 attrs.append(resAttrs.begin(), resAttrs.end());
1364 return mod.removeAllPortAttrs();
1365 mod.setAllPortAttrs(attrs);
1368void HWModuleOp::setHWModuleType(ModuleType type) {
1369 return ::setHWModuleType(*
this, type);
1372void HWModuleExternOp::setHWModuleType(ModuleType type) {
1373 return ::setHWModuleType(*
this, type);
1376void HWModuleGeneratedOp::setHWModuleType(ModuleType type) {
1377 return ::setHWModuleType(*
this, type);
1382Operation *HWModuleGeneratedOp::getGeneratorKindOp() {
1383 auto topLevelModuleOp = (*this)->getParentOfType<ModuleOp>();
1384 return topLevelModuleOp.lookupSymbol(getGeneratorKind());
1388HWModuleGeneratedOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
1389 auto *referencedKind =
1390 symbolTable.lookupNearestSymbolFrom(*
this, getGeneratorKindAttr());
1392 if (referencedKind ==
nullptr)
1393 return emitError(
"Cannot find generator definition '")
1394 << getGeneratorKind() <<
"'";
1396 if (!isa<HWGeneratorSchemaOp>(referencedKind))
1397 return emitError(
"Symbol resolved to '")
1398 << referencedKind->getName()
1399 <<
"' which is not a HWGeneratorSchemaOp";
1401 auto referencedKindOp = dyn_cast<HWGeneratorSchemaOp>(referencedKind);
1402 auto paramRef = referencedKindOp.getRequiredAttrs();
1403 auto dict = (*this)->getAttrDictionary();
1404 for (
auto str : paramRef) {
1405 auto strAttr = dyn_cast<StringAttr>(str);
1407 return emitError(
"Unknown attribute type, expected a string");
1408 if (!dict.get(strAttr.getValue()))
1409 return emitError(
"Missing attribute '") << strAttr.getValue() <<
"'";
1415LogicalResult HWModuleGeneratedOp::verify() {
1419void HWModuleGeneratedOp::getAsmBlockArgumentNames(
1424LogicalResult HWModuleOp::verifyBody() {
return success(); }
1426template <
typename ModuleTy>
1428 auto modTy = mod.getHWModuleType();
1429 auto emptyDict = DictionaryAttr::get(mod.getContext());
1430 SmallVector<PortInfo> retval;
1431 auto locs = mod.getAllPortLocs();
1432 for (
unsigned i = 0, e = modTy.getNumPorts(); i < e; ++i) {
1433 LocationAttr loc = locs[i];
1434 DictionaryAttr attrs =
1435 dyn_cast_or_null<DictionaryAttr>(mod.getPortAttrs(i));
1438 retval.push_back({modTy.getPorts()[i],
1439 modTy.isOutput(i) ? modTy.getOutputIdForPortId(i)
1440 : modTy.getInputIdForPortId(i),
1446template <
typename ModuleTy>
1448 auto modTy = mod.getHWModuleType();
1449 auto emptyDict = DictionaryAttr::get(mod.getContext());
1450 LocationAttr loc = mod.getPortLoc(idx);
1451 DictionaryAttr attrs =
1452 dyn_cast_or_null<DictionaryAttr>(mod.getPortAttrs(idx));
1455 return {modTy.getPorts()[idx],
1456 modTy.isOutput(idx) ? modTy.getOutputIdForPortId(idx)
1457 : modTy.getInputIdForPortId(idx),
1466void InstanceOp::build(OpBuilder &builder, OperationState &result,
1467 Operation *module, StringAttr name,
1468 ArrayRef<Value> inputs, ArrayAttr parameters,
1469 InnerSymAttr innerSym) {
1471 parameters = builder.getArrayAttr({});
1473 auto mod = cast<hw::HWModuleLike>(module);
1474 auto argNames = builder.getArrayAttr(mod.getInputNames());
1475 auto resultNames = builder.getArrayAttr(mod.getOutputNames());
1480 ModuleType modType = mod.getHWModuleType();
1481 FailureOr<ModuleType> resolvedModType = modType.resolveParametricTypes(
1482 parameters, result.location,
false);
1483 if (succeeded(resolvedModType))
1484 modType = *resolvedModType;
1485 FunctionType funcType = resolvedModType->getFuncType();
1486 build(builder, result, funcType.getResults(), name,
1487 FlatSymbolRefAttr::get(SymbolTable::getSymbolName(module)), inputs,
1488 argNames, resultNames, parameters, innerSym, {});
1491std::optional<size_t> InstanceOp::getTargetResultIndex() {
1493 return std::nullopt;
1496LogicalResult InstanceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
1498 *
this, getModuleNameAttr(), getInputs(), getResultTypes(), getArgNames(),
1499 getResultNames(), getParameters(), symbolTable);
1502LogicalResult InstanceOp::verify() {
1503 auto module = (*this)->getParentOfType<HWModuleOp>();
1507 auto moduleParameters =
module->getAttrOfType<ArrayAttr>("parameters");
1509 [&](
const std::function<bool(InFlightDiagnostic &)> &fn) {
1510 auto diag = emitOpError();
1512 diag.attachNote(module->getLoc()) <<
"module declared here";
1515 getParameters(), moduleParameters, emitError);
1518ParseResult InstanceOp::parse(OpAsmParser &parser, OperationState &result) {
1519 StringAttr instanceNameAttr;
1520 InnerSymAttr innerSym;
1521 FlatSymbolRefAttr moduleNameAttr;
1522 SmallVector<OpAsmParser::UnresolvedOperand, 4> inputsOperands;
1523 SmallVector<Type, 1> inputsTypes, allResultTypes;
1524 ArrayAttr argNames, resultNames, parameters;
1525 auto noneType = parser.getBuilder().getType<NoneType>();
1527 if (parser.parseAttribute(instanceNameAttr, noneType,
"instanceName",
1531 if (succeeded(parser.parseOptionalKeyword(
"sym"))) {
1534 if (parser.parseCustomAttributeWithFallback(innerSym))
1539 llvm::SMLoc parametersLoc, inputsOperandsLoc;
1540 if (parser.parseAttribute(moduleNameAttr, noneType,
"moduleName",
1541 result.attributes) ||
1542 parser.getCurrentLocation(¶metersLoc) ||
1545 parser.resolveOperands(inputsOperands, inputsTypes, inputsOperandsLoc,
1547 parser.parseArrow() ||
1549 parser.parseOptionalAttrDict(result.attributes)) {
1553 result.addAttribute(
"argNames", argNames);
1554 result.addAttribute(
"resultNames", resultNames);
1555 result.addAttribute(
"parameters", parameters);
1556 result.addTypes(allResultTypes);
1560void InstanceOp::print(OpAsmPrinter &p) {
1562 p.printAttributeWithoutType(getInstanceNameAttr());
1563 if (
auto attr = getInnerSymAttr()) {
1568 p.printAttributeWithoutType(getModuleNameAttr());
1575 p.printOptionalAttrDict(
1576 (*this)->getAttrs(),
1578 InnerSymbolTable::getInnerSymbolAttrName(),
"moduleName",
1579 "argNames",
"resultNames",
"parameters"});
1586std::optional<size_t> InstanceChoiceOp::getTargetResultIndex() {
1588 return std::nullopt;
1592InstanceChoiceOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
1593 for (Attribute name : getModuleNamesAttr()) {
1595 *
this, cast<FlatSymbolRefAttr>(name), getInputs(), getResultTypes(),
1596 getArgNames(), getResultNames(), getParameters(), symbolTable))) {
1603LogicalResult InstanceChoiceOp::verify() {
1604 auto module = (*this)->getParentOfType<HWModuleOp>();
1608 auto moduleParameters =
module->getAttrOfType<ArrayAttr>("parameters");
1610 [&](
const std::function<bool(InFlightDiagnostic &)> &fn) {
1611 auto diag = emitOpError();
1613 diag.attachNote(module->getLoc()) <<
"module declared here";
1616 getParameters(), moduleParameters, emitError);
1619ParseResult InstanceChoiceOp::parse(OpAsmParser &parser,
1620 OperationState &result) {
1621 StringAttr optionNameAttr;
1622 StringAttr instanceNameAttr;
1623 InnerSymAttr innerSym;
1624 SmallVector<Attribute> moduleNames;
1625 SmallVector<Attribute> caseNames;
1626 SmallVector<OpAsmParser::UnresolvedOperand, 4> inputsOperands;
1627 SmallVector<Type, 1> inputsTypes, allResultTypes;
1628 ArrayAttr argNames, resultNames, parameters;
1629 auto noneType = parser.getBuilder().getType<NoneType>();
1631 if (parser.parseAttribute(instanceNameAttr, noneType,
"instanceName",
1635 if (succeeded(parser.parseOptionalKeyword(
"sym"))) {
1638 if (parser.parseCustomAttributeWithFallback(innerSym))
1643 if (parser.parseKeyword(
"option") ||
1644 parser.parseAttribute(optionNameAttr, noneType,
"optionName",
1648 FlatSymbolRefAttr defaultModuleName;
1649 if (parser.parseAttribute(defaultModuleName))
1651 moduleNames.push_back(defaultModuleName);
1653 while (succeeded(parser.parseOptionalKeyword(
"or"))) {
1654 FlatSymbolRefAttr moduleName;
1655 StringAttr targetName;
1656 if (parser.parseAttribute(moduleName) ||
1657 parser.parseOptionalKeyword(
"if") || parser.parseAttribute(targetName))
1659 moduleNames.push_back(moduleName);
1660 caseNames.push_back(targetName);
1663 llvm::SMLoc parametersLoc, inputsOperandsLoc;
1664 if (parser.getCurrentLocation(¶metersLoc) ||
1667 parser.resolveOperands(inputsOperands, inputsTypes, inputsOperandsLoc,
1669 parser.parseArrow() ||
1671 parser.parseOptionalAttrDict(result.attributes)) {
1675 result.addAttribute(
"moduleNames",
1676 ArrayAttr::get(parser.getContext(), moduleNames));
1677 result.addAttribute(
"caseNames",
1678 ArrayAttr::get(parser.getContext(), caseNames));
1679 result.addAttribute(
"argNames", argNames);
1680 result.addAttribute(
"resultNames", resultNames);
1681 result.addAttribute(
"parameters", parameters);
1682 result.addTypes(allResultTypes);
1686void InstanceChoiceOp::print(OpAsmPrinter &p) {
1688 p.printAttributeWithoutType(getInstanceNameAttr());
1689 if (
auto attr = getInnerSymAttr()) {
1693 p <<
" option " << getOptionNameAttr() <<
' ';
1695 auto moduleNames = getModuleNamesAttr();
1696 auto caseNames = getCaseNamesAttr();
1697 assert(moduleNames.size() == caseNames.size() + 1);
1699 p.printAttributeWithoutType(moduleNames[0]);
1700 for (
size_t i = 0, n = caseNames.size(); i < n; ++i) {
1702 p.printAttributeWithoutType(moduleNames[i + 1]);
1704 p.printAttributeWithoutType(caseNames[i]);
1713 p.printOptionalAttrDict(
1714 (*this)->getAttrs(),
1716 InnerSymbolTable::getInnerSymbolAttrName(),
1717 "moduleNames",
"caseNames",
"argNames",
"resultNames",
1718 "parameters",
"optionName"});
1721ArrayAttr InstanceChoiceOp::getReferencedModuleNamesAttr() {
1722 SmallVector<Attribute> moduleNames;
1723 for (Attribute attr : getModuleNamesAttr()) {
1724 moduleNames.push_back(cast<FlatSymbolRefAttr>(attr).getAttr());
1726 return ArrayAttr::get(getContext(), moduleNames);
1734LogicalResult OutputOp::verify() {
1738 if (
auto mod = dyn_cast<HWModuleOp>((*this)->getParentOp()))
1739 modType = mod.getHWModuleType();
1741 emitOpError(
"must have a module parent");
1744 auto modResults = modType.getOutputTypes();
1745 OperandRange outputValues = getOperands();
1746 if (modResults.size() != outputValues.size()) {
1747 emitOpError(
"must have same number of operands as region results.");
1752 for (
size_t i = 0, e = modResults.size(); i < e; ++i) {
1753 if (modResults[i] != outputValues[i].getType()) {
1754 emitOpError(
"output types must match module. In "
1756 << i <<
", expected " << modResults[i] <<
", but got "
1757 << outputValues[i].getType() <<
".";
1772 if (p.parseType(type))
1773 return p.emitError(p.getCurrentLocation(),
"Expected type");
1774 auto arrType = type_dyn_cast<ArrayType>(type);
1776 return p.emitError(p.getCurrentLocation(),
"Expected !hw.array type");
1778 unsigned idxWidth = llvm::Log2_64_Ceil(arrType.getNumElements());
1779 idxType = IntegerType::get(p.getBuilder().getContext(), idxWidth);
1785 p.printType(srcType);
1788ParseResult ArrayCreateOp::parse(OpAsmParser &parser, OperationState &result) {
1789 llvm::SMLoc inputOperandsLoc = parser.getCurrentLocation();
1790 llvm::SmallVector<OpAsmParser::UnresolvedOperand, 16> operands;
1793 if (parser.parseOperandList(operands) ||
1794 parser.parseOptionalAttrDict(result.attributes) || parser.parseColon() ||
1795 parser.parseType(elemType))
1798 if (operands.size() == 0)
1799 return parser.emitError(inputOperandsLoc,
1800 "Cannot construct an array of length 0");
1801 result.addTypes({ArrayType::get(elemType, operands.size())});
1803 for (
auto operand : operands)
1804 if (parser.resolveOperand(operand, elemType, result.operands))
1809void ArrayCreateOp::print(OpAsmPrinter &p) {
1811 p.printOperands(getInputs());
1812 p.printOptionalAttrDict((*this)->getAttrs());
1813 p <<
" : " << getInputs()[0].getType();
1816void ArrayCreateOp::build(OpBuilder &b, OperationState &state,
1817 ValueRange values) {
1818 assert(values.size() > 0 &&
"Cannot build array of zero elements");
1819 Type elemType = values[0].getType();
1822 [elemType](Value v) ->
bool {
return v.getType() == elemType; }) &&
1823 "All values must have same type.");
1824 build(b, state, ArrayType::get(elemType, values.size()), values);
1827LogicalResult ArrayCreateOp::verify() {
1828 unsigned returnSize = cast<ArrayType>(getType()).getNumElements();
1829 if (getInputs().size() != returnSize)
1834OpFoldResult ArrayCreateOp::fold(FoldAdaptor adaptor) {
1835 if (llvm::any_of(adaptor.getInputs(), [](Attribute attr) { return !attr; }))
1837 return ArrayAttr::get(getContext(), adaptor.getInputs());
1847 auto baseValue = constBase.getValue();
1848 auto indexValue = constIndex.getValue();
1850 unsigned bits = baseValue.getBitWidth();
1851 assert(bits == indexValue.getBitWidth() &&
"mismatched widths");
1853 if (bits < 64 && offset >= (1ull << bits))
1856 APInt baseExt = baseValue.zextOrTrunc(bits + 1);
1857 APInt indexExt = indexValue.zextOrTrunc(bits + 1);
1858 return baseExt + offset == indexExt;
1866 PatternRewriter &rewriter) {
1868 auto arrayTy = hw::type_cast<ArrayType>(op.getType());
1869 if (arrayTy.getNumElements() <= 1)
1871 auto elemTy = arrayTy.getElementType();
1880 SmallVector<Chunk> chunks;
1881 for (Value value : llvm::reverse(op.getInputs())) {
1882 auto get = value.getDefiningOp<
ArrayGetOp>();
1886 Value input = get.getInput();
1887 Value index = get.getIndex();
1888 if (!chunks.empty()) {
1889 auto &c = *chunks.rbegin();
1890 if (c.input == get.getInput() &&
isOffset(c.index, index, c.size)) {
1896 chunks.push_back(Chunk{input, index, 1});
1900 if (chunks.size() == 1) {
1901 auto &chunk = chunks[0];
1902 rewriter.replaceOp(op, rewriter.createOrFold<
ArraySliceOp>(
1903 op.getLoc(), arrayTy, chunk.input, chunk.index));
1909 if (chunks.size() * 2 < arrayTy.getNumElements()) {
1910 SmallVector<Value> slices;
1911 for (
auto &chunk : llvm::reverse(chunks)) {
1912 auto sliceTy = ArrayType::get(elemTy, chunk.size);
1914 op.getLoc(), sliceTy, chunk.input, chunk.index));
1916 rewriter.replaceOpWithNewOp<
ArrayConcatOp>(op, arrayTy, slices);
1924 PatternRewriter &rewriter) {
1930Value ArrayCreateOp::getUniformElement() {
1931 if (!getInputs().
empty() && llvm::all_equal(getInputs()))
1932 return getInputs()[0];
1937 auto idxOp = dyn_cast_or_null<ConstantOp>(value.getDefiningOp());
1939 return std::nullopt;
1940 APInt idxAttr = idxOp.getValue();
1941 if (idxAttr.getBitWidth() > 64)
1942 return std::nullopt;
1943 return idxAttr.getLimitedValue();
1946LogicalResult ArraySliceOp::verify() {
1947 unsigned inputSize =
1948 type_cast<ArrayType>(getInput().getType()).getNumElements();
1949 if (llvm::Log2_64_Ceil(inputSize) !=
1950 getLowIndex().getType().getIntOrFloatBitWidth())
1952 "ArraySlice: index width must match clog2 of array size");
1956OpFoldResult ArraySliceOp::fold(FoldAdaptor adaptor) {
1958 if (getType() == getInput().getType())
1963LogicalResult ArraySliceOp::canonicalize(
ArraySliceOp op,
1964 PatternRewriter &rewriter) {
1965 auto sliceTy = hw::type_cast<ArrayType>(op.getType());
1966 auto elemTy = sliceTy.getElementType();
1967 uint64_t sliceSize = sliceTy.getNumElements();
1971 if (sliceSize == 1) {
1973 auto get = rewriter.create<
ArrayGetOp>(op.getLoc(), op.getInput(),
1975 rewriter.replaceOpWithNewOp<
ArrayCreateOp>(op, op.getType(),
1984 auto inputOp = op.getInput().getDefiningOp();
1985 if (
auto inputSlice = dyn_cast_or_null<ArraySliceOp>(inputOp)) {
1987 if (inputSlice == op)
1990 auto inputIndex = inputSlice.getLowIndex();
1992 if (!inputOffsetOpt)
1995 uint64_t offset = *offsetOpt + *inputOffsetOpt;
1997 rewriter.create<
ConstantOp>(op.getLoc(), inputIndex.getType(), offset);
1998 rewriter.replaceOpWithNewOp<
ArraySliceOp>(op, op.getType(),
1999 inputSlice.getInput(), lowIndex);
2003 if (
auto inputCreate = dyn_cast_or_null<ArrayCreateOp>(inputOp)) {
2005 auto inputs = inputCreate.getInputs();
2007 uint64_t begin = inputs.size() - *offsetOpt - sliceSize;
2008 rewriter.replaceOpWithNewOp<
ArrayCreateOp>(op, op.getType(),
2009 inputs.slice(begin, sliceSize));
2013 if (
auto inputConcat = dyn_cast_or_null<ArrayConcatOp>(inputOp)) {
2015 SmallVector<Value> chunks;
2016 uint64_t sliceStart = *offsetOpt;
2017 for (
auto input :
llvm::reverse(inputConcat.getInputs())) {
2019 uint64_t inputSize =
2020 hw::type_cast<ArrayType>(input.getType()).getNumElements();
2021 if (inputSize == 0 || inputSize <= sliceStart) {
2022 sliceStart -= inputSize;
2027 uint64_t cutEnd = std::min(inputSize, sliceStart + sliceSize);
2028 uint64_t cutSize = cutEnd - sliceStart;
2029 assert(cutSize != 0 &&
"slice cannot be empty");
2031 if (cutSize == inputSize) {
2033 assert(sliceStart == 0 &&
"invalid cut size");
2034 chunks.push_back(input);
2037 unsigned width = inputSize == 1 ? 1 : llvm::Log2_64_Ceil(inputSize);
2039 op.getLoc(), rewriter.getIntegerType(width), sliceStart);
2041 op.getLoc(), hw::ArrayType::get(elemTy, cutSize), input, lowIndex));
2045 sliceSize -= cutSize;
2050 assert(chunks.size() > 0 &&
"missing sliced items");
2051 if (chunks.size() == 1)
2052 rewriter.replaceOp(op, chunks[0]);
2055 op, llvm::to_vector(llvm::reverse(chunks)));
2066 SmallVectorImpl<Type> &inputTypes,
2069 uint64_t resultSize = 0;
2071 auto parseElement = [&]() -> ParseResult {
2073 if (p.parseType(ty))
2075 auto arrTy = type_dyn_cast<ArrayType>(ty);
2077 return p.emitError(p.getCurrentLocation(),
"Expected !hw.array type");
2078 if (elemType && elemType != arrTy.getElementType())
2079 return p.emitError(p.getCurrentLocation(),
"Expected array element type ")
2082 elemType = arrTy.getElementType();
2083 inputTypes.push_back(ty);
2084 resultSize += arrTy.getNumElements();
2088 if (p.parseCommaSeparatedList(parseElement))
2091 resultType = ArrayType::get(elemType, resultSize);
2096 TypeRange inputTypes, Type resultType) {
2097 llvm::interleaveComma(inputTypes, p, [&p](Type t) { p << t; });
2100void ArrayConcatOp::build(OpBuilder &b, OperationState &state,
2101 ValueRange values) {
2102 assert(!values.empty() &&
"Cannot build array of zero elements");
2103 ArrayType arrayTy = cast<ArrayType>(values[0].getType());
2104 Type elemTy = arrayTy.getElementType();
2105 assert(llvm::all_of(values,
2106 [elemTy](Value v) ->
bool {
2107 return isa<ArrayType>(v.getType()) &&
2108 cast<ArrayType>(v.getType()).getElementType() ==
2111 "All values must be of ArrayType with the same element type.");
2113 uint64_t resultSize = 0;
2114 for (Value val : values)
2115 resultSize += cast<ArrayType>(val.getType()).getNumElements();
2116 build(b, state, ArrayType::get(elemTy, resultSize), values);
2119OpFoldResult ArrayConcatOp::fold(FoldAdaptor adaptor) {
2120 if (getInputs().size() == 1)
2121 return getInputs()[0];
2123 auto inputs = adaptor.getInputs();
2124 SmallVector<Attribute> array;
2125 for (
size_t i = 0, e = getNumOperands(); i < e; ++i) {
2128 llvm::copy(cast<ArrayAttr>(inputs[i]), std::back_inserter(array));
2130 return ArrayAttr::get(getContext(), array);
2135 for (
auto input : op.getInputs())
2139 SmallVector<Value> items;
2140 for (
auto input : op.getInputs()) {
2141 auto create = cast<ArrayCreateOp>(input.getDefiningOp());
2142 for (
auto item : create.getInputs())
2143 items.push_back(item);
2157 SmallVector<Location> locs;
2160 SmallVector<Value> items;
2161 std::optional<Slice> last;
2162 bool changed =
false;
2164 auto concatenate = [&] {
2169 items.push_back(last->op);
2177 auto loc = FusedLoc::get(op.getContext(), last->locs);
2178 auto origTy = hw::type_cast<ArrayType>(last->input.getType());
2179 auto arrayTy = ArrayType::get(origTy.getElementType(), last->size);
2181 loc, arrayTy, last->input, last->index));
2186 auto append = [&](Value op, Value input, Value index,
size_t size) {
2191 if (last->input == input &&
isOffset(last->index, index, last->size)) {
2194 last->locs.push_back(op.getLoc());
2199 last.emplace(Slice{input, index, size, op, {op.getLoc()}});
2202 for (
auto item : llvm::reverse(op.getInputs())) {
2204 auto size = hw::type_cast<ArrayType>(slice.getType()).getNumElements();
2205 append(item, slice.getInput(), slice.getLowIndex(), size);
2210 if (create.getInputs().size() == 1) {
2211 if (
auto get = create.getInputs()[0].getDefiningOp<
ArrayGetOp>()) {
2212 append(item, get.getInput(), get.getIndex(), 1);
2219 items.push_back(item);
2226 if (items.size() == 1) {
2227 rewriter.replaceOp(op, items[0]);
2229 std::reverse(items.begin(), items.end());
2236 PatternRewriter &rewriter) {
2252ParseResult EnumConstantOp::parse(OpAsmParser &parser, OperationState &result) {
2259 auto loc = parser.getEncodedSourceLoc(parser.getCurrentLocation());
2260 if (parser.parseKeyword(&field) || parser.parseColonType(type))
2263 auto fieldAttr = EnumFieldAttr::get(
2264 loc, StringAttr::get(parser.getContext(), field), type);
2269 result.addAttribute(
"field", fieldAttr);
2270 result.addTypes(type);
2275void EnumConstantOp::print(OpAsmPrinter &p) {
2276 p <<
" " << getField().getField().getValue() <<
" : "
2277 << getField().getType().getValue();
2280void EnumConstantOp::getAsmResultNames(
2281 function_ref<
void(Value, StringRef)> setNameFn) {
2282 setNameFn(getResult(), getField().getField().str());
2285void EnumConstantOp::build(OpBuilder &builder, OperationState &odsState,
2286 EnumFieldAttr field) {
2287 return build(builder, odsState, field.getType().getValue(), field);
2290OpFoldResult EnumConstantOp::fold(FoldAdaptor adaptor) {
2291 assert(adaptor.getOperands().empty() &&
"constant has no operands");
2292 return getFieldAttr();
2295LogicalResult EnumConstantOp::verify() {
2296 auto fieldAttr = getFieldAttr();
2297 auto fieldType = fieldAttr.getType().getValue();
2300 if (fieldType != getType())
2301 emitOpError(
"return type ")
2302 << getType() <<
" does not match attribute type " << fieldAttr;
2310LogicalResult EnumCmpOp::verify() {
2312 auto lhsType = type_cast<EnumType>(getLhs().getType());
2313 auto rhsType = type_cast<EnumType>(getRhs().getType());
2314 if (rhsType != lhsType)
2315 emitOpError(
"types do not match");
2323ParseResult StructCreateOp::parse(OpAsmParser &parser, OperationState &result) {
2324 llvm::SMLoc inputOperandsLoc = parser.getCurrentLocation();
2325 llvm::SmallVector<OpAsmParser::UnresolvedOperand, 4> operands;
2326 Type declOrAliasType;
2328 if (parser.parseLParen() || parser.parseOperandList(operands) ||
2329 parser.parseRParen() || parser.parseOptionalAttrDict(result.attributes) ||
2330 parser.parseColonType(declOrAliasType))
2333 auto declType = type_dyn_cast<StructType>(declOrAliasType);
2335 return parser.emitError(parser.getNameLoc(),
2336 "expected !hw.struct type or alias");
2338 llvm::SmallVector<Type, 4> structInnerTypes;
2339 declType.getInnerTypes(structInnerTypes);
2340 result.addTypes(declOrAliasType);
2342 if (parser.resolveOperands(operands, structInnerTypes, inputOperandsLoc,
2348void StructCreateOp::print(OpAsmPrinter &printer) {
2350 printer.printOperands(getInput());
2352 printer.printOptionalAttrDict((*this)->getAttrs());
2353 printer <<
" : " << getType();
2356LogicalResult StructCreateOp::verify() {
2357 auto elements = hw::type_cast<StructType>(getType()).getElements();
2359 if (elements.size() != getInput().size())
2360 return emitOpError(
"structure field count mismatch");
2362 for (
const auto &[field, value] :
llvm::zip(elements, getInput()))
2363 if (field.type != value.getType())
2364 return emitOpError(
"structure field `")
2365 << field.name <<
"` type does not match";
2370OpFoldResult StructCreateOp::fold(FoldAdaptor adaptor) {
2372 if (!getInput().
empty())
2373 if (
auto explodeOp = getInput()[0].getDefiningOp<StructExplodeOp>();
2374 explodeOp && getInput() == explodeOp.getResults() &&
2375 getResult().getType() == explodeOp.getInput().getType())
2376 return explodeOp.getInput();
2378 auto inputs = adaptor.getInput();
2379 if (llvm::any_of(inputs, [](Attribute attr) {
return !attr; }))
2381 return ArrayAttr::get(getContext(), inputs);
2388ParseResult StructExplodeOp::parse(OpAsmParser &parser,
2389 OperationState &result) {
2390 OpAsmParser::UnresolvedOperand operand;
2393 if (parser.parseOperand(operand) ||
2394 parser.parseOptionalAttrDict(result.attributes) ||
2395 parser.parseColonType(declType))
2397 auto structType = type_dyn_cast<StructType>(declType);
2399 return parser.emitError(parser.getNameLoc(),
2400 "invalid kind of type specified");
2402 llvm::SmallVector<Type, 4> structInnerTypes;
2403 structType.getInnerTypes(structInnerTypes);
2404 result.addTypes(structInnerTypes);
2406 if (parser.resolveOperand(operand, declType, result.operands))
2411void StructExplodeOp::print(OpAsmPrinter &printer) {
2413 printer.printOperand(getInput());
2414 printer.printOptionalAttrDict((*this)->getAttrs());
2415 printer <<
" : " << getInput().getType();
2418LogicalResult StructExplodeOp::fold(FoldAdaptor adaptor,
2419 SmallVectorImpl<OpFoldResult> &results) {
2420 auto input = adaptor.getInput();
2423 llvm::copy(cast<ArrayAttr>(input), std::back_inserter(results));
2427LogicalResult StructExplodeOp::canonicalize(StructExplodeOp op,
2428 PatternRewriter &rewriter) {
2429 auto *inputOp = op.getInput().getDefiningOp();
2430 auto elements = type_cast<StructType>(op.getInput().getType()).getElements();
2431 auto result = failure();
2432 auto opResults = op.getResults();
2433 for (uint32_t index = 0; index < elements.size(); index++) {
2435 rewriter.replaceAllUsesWith(opResults[index], foldResult);
2442void StructExplodeOp::getAsmResultNames(
2443 function_ref<
void(Value, StringRef)> setNameFn) {
2444 auto structType = type_cast<StructType>(getInput().getType());
2445 for (
auto [res, field] :
llvm::zip(getResults(), structType.getElements()))
2446 setNameFn(res, field.name.str());
2449void StructExplodeOp::build(OpBuilder &odsBuilder, OperationState &odsState,
2451 StructType inputType = dyn_cast<StructType>(input.getType());
2453 SmallVector<Type, 16> fieldTypes;
2454 for (
auto field : inputType.getElements())
2455 fieldTypes.push_back(field.type);
2456 build(odsBuilder, odsState, fieldTypes, input);
2465template <
typename AggregateOp,
typename AggregateType>
2467 AggregateType aggType,
2469 auto index = op.getFieldIndex();
2470 if (index >= aggType.getElements().size())
2471 return op.emitOpError() <<
"field index " << index
2472 <<
" exceeds element count of aggregate type";
2476 return op.emitOpError()
2477 <<
"type " << aggType.getElements()[index].type
2478 <<
" of accessed field in aggregate at index " << index
2479 <<
" does not match expected type " <<
elementType;
2484LogicalResult StructExtractOp::verify() {
2485 return verifyAggregateFieldIndexAndType<StructExtractOp, StructType>(
2486 *
this, getInput().getType(), getType());
2491template <
typename AggregateType>
2493 OpAsmParser::UnresolvedOperand operand;
2494 StringAttr fieldName;
2497 if (parser.parseOperand(operand) || parser.parseLSquare() ||
2498 parser.parseAttribute(fieldName) || parser.parseRSquare() ||
2499 parser.parseOptionalAttrDict(result.attributes) ||
2500 parser.parseColonType(declType))
2502 auto aggType = type_dyn_cast<AggregateType>(declType);
2504 return parser.emitError(parser.getNameLoc(),
2505 "invalid kind of type specified");
2507 auto fieldIndex = aggType.getFieldIndex(fieldName);
2509 parser.emitError(parser.getNameLoc(),
"field name '" +
2510 fieldName.getValue() +
2511 "' not found in aggregate type");
2516 IntegerAttr::get(IntegerType::get(parser.getContext(), 32), *fieldIndex);
2517 result.addAttribute(
"fieldIndex", indexAttr);
2518 Type resultType = aggType.getElements()[*fieldIndex].type;
2519 result.addTypes(resultType);
2521 if (parser.resolveOperand(operand, declType, result.operands))
2528template <
typename AggType>
2531 printer.printOperand(op.getInput());
2532 printer <<
"[\"" << op.getFieldName() <<
"\"]";
2533 printer.printOptionalAttrDict(op->getAttrs(), {
"fieldIndex"});
2534 printer <<
" : " << op.getInput().getType();
2537ParseResult StructExtractOp::parse(OpAsmParser &parser,
2538 OperationState &result) {
2539 return parseExtractOp<StructType>(parser, result);
2542void StructExtractOp::print(OpAsmPrinter &printer) {
2546void StructExtractOp::build(OpBuilder &builder, OperationState &odsState,
2547 Value input, StructType::FieldInfo field) {
2549 type_cast<StructType>(input.getType()).getFieldIndex(field.name);
2550 assert(fieldIndex.has_value() &&
"field name not found in aggregate type");
2551 build(builder, odsState, field.type, input, *fieldIndex);
2554void StructExtractOp::build(OpBuilder &builder, OperationState &odsState,
2555 Value input, StringAttr fieldName) {
2556 auto structType = type_cast<StructType>(input.getType());
2557 auto fieldIndex = structType.getFieldIndex(fieldName);
2558 assert(fieldIndex.has_value() &&
"field name not found in aggregate type");
2559 auto resultType = structType.getElements()[*fieldIndex].type;
2560 build(builder, odsState, resultType, input, *fieldIndex);
2563OpFoldResult StructExtractOp::fold(FoldAdaptor adaptor) {
2564 if (
auto constOperand = adaptor.getInput()) {
2566 auto operandAttr = llvm::cast<ArrayAttr>(constOperand);
2567 return operandAttr.getValue()[getFieldIndex()];
2570 if (
auto foldResult =
2577 PatternRewriter &rewriter) {
2578 auto inputOp = op.getInput().getDefiningOp();
2581 if (
auto structInject = dyn_cast_or_null<StructInjectOp>(inputOp)) {
2582 if (structInject.getFieldIndex() != op.getFieldIndex()) {
2584 op, op.getType(), structInject.getInput(), op.getFieldIndexAttr());
2592void StructExtractOp::getAsmResultNames(
2593 function_ref<
void(Value, StringRef)> setNameFn) {
2601void StructInjectOp::build(OpBuilder &builder, OperationState &odsState,
2602 Value input, StringAttr fieldName, Value newValue) {
2603 auto structType = type_cast<StructType>(input.getType());
2604 auto fieldIndex = structType.getFieldIndex(fieldName);
2605 assert(fieldIndex.has_value() &&
"field name not found in aggregate type");
2606 build(builder, odsState, input, *fieldIndex, newValue);
2609LogicalResult StructInjectOp::verify() {
2610 return verifyAggregateFieldIndexAndType<StructInjectOp, StructType>(
2611 *
this, getInput().getType(), getNewValue().getType());
2614ParseResult StructInjectOp::parse(OpAsmParser &parser, OperationState &result) {
2615 llvm::SMLoc inputOperandsLoc = parser.getCurrentLocation();
2616 OpAsmParser::UnresolvedOperand operand, val;
2617 StringAttr fieldName;
2620 if (parser.parseOperand(operand) || parser.parseLSquare() ||
2621 parser.parseAttribute(fieldName) || parser.parseRSquare() ||
2622 parser.parseComma() || parser.parseOperand(val) ||
2623 parser.parseOptionalAttrDict(result.attributes) ||
2624 parser.parseColonType(declType))
2626 auto structType = type_dyn_cast<StructType>(declType);
2628 return parser.emitError(inputOperandsLoc,
"invalid kind of type specified");
2630 auto fieldIndex = structType.getFieldIndex(fieldName);
2632 parser.emitError(parser.getNameLoc(),
"field name '" +
2633 fieldName.getValue() +
2634 "' not found in aggregate type");
2639 IntegerAttr::get(IntegerType::get(parser.getContext(), 32), *fieldIndex);
2640 result.addAttribute(
"fieldIndex", indexAttr);
2641 result.addTypes(declType);
2643 Type resultType = structType.getElements()[*fieldIndex].type;
2644 if (parser.resolveOperands({operand, val}, {declType, resultType},
2645 inputOperandsLoc, result.operands))
2650void StructInjectOp::print(OpAsmPrinter &printer) {
2652 printer.printOperand(getInput());
2654 printer.printOperand(getNewValue());
2655 printer.printOptionalAttrDict((*this)->getAttrs(), {
"fieldIndex"});
2656 printer <<
" : " << getInput().getType();
2659OpFoldResult StructInjectOp::fold(FoldAdaptor adaptor) {
2660 auto input = adaptor.getInput();
2661 auto newValue = adaptor.getNewValue();
2662 if (!input || !newValue)
2664 SmallVector<Attribute> array;
2665 llvm::copy(cast<ArrayAttr>(input), std::back_inserter(array));
2666 array[getFieldIndex()] = newValue;
2667 return ArrayAttr::get(getContext(), array);
2670LogicalResult StructInjectOp::canonicalize(StructInjectOp op,
2671 PatternRewriter &rewriter) {
2673 SmallPtrSet<Operation *, 4> injects;
2674 DenseMap<StringAttr, Value> fields;
2677 StructInjectOp inject = op;
2680 if (!injects.insert(inject).second)
2683 fields.try_emplace(inject.getFieldNameAttr(), inject.getNewValue());
2684 input = inject.getInput();
2685 inject = dyn_cast_or_null<StructInjectOp>(input.getDefiningOp());
2687 assert(input &&
"missing input to inject chain");
2689 auto ty = hw::type_cast<StructType>(op.getType());
2690 auto elements = ty.getElements();
2693 if (fields.size() == elements.size()) {
2694 SmallVector<Value> createFields;
2695 for (
const auto &field : elements) {
2696 auto it = fields.find(field.name);
2697 assert(it != fields.end() &&
"missing field");
2698 createFields.push_back(it->second);
2700 rewriter.replaceOpWithNewOp<
StructCreateOp>(op, ty, createFields);
2705 if (injects.size() == fields.size())
2709 for (uint32_t fieldIndex = 0; fieldIndex < elements.size(); fieldIndex++) {
2710 auto it = fields.find(elements[fieldIndex].name);
2711 if (it == fields.end())
2713 input = rewriter.create<StructInjectOp>(op.getLoc(), ty, input, fieldIndex,
2717 rewriter.replaceOp(op, input);
2725LogicalResult UnionCreateOp::verify() {
2726 return verifyAggregateFieldIndexAndType<UnionCreateOp, UnionType>(
2727 *
this, getType(), getInput().getType());
2730void UnionCreateOp::build(OpBuilder &builder, OperationState &odsState,
2731 Type unionType, StringAttr fieldName, Value input) {
2732 auto fieldIndex = type_cast<UnionType>(unionType).getFieldIndex(fieldName);
2733 assert(fieldIndex.has_value() &&
"field name not found in aggregate type");
2734 build(builder, odsState, unionType, *fieldIndex, input);
2737ParseResult UnionCreateOp::parse(OpAsmParser &parser, OperationState &result) {
2738 Type declOrAliasType;
2739 StringAttr fieldName;
2740 OpAsmParser::UnresolvedOperand input;
2741 llvm::SMLoc fieldLoc = parser.getCurrentLocation();
2743 if (parser.parseAttribute(fieldName) || parser.parseComma() ||
2744 parser.parseOperand(input) ||
2745 parser.parseOptionalAttrDict(result.attributes) ||
2746 parser.parseColonType(declOrAliasType))
2749 auto declType = type_dyn_cast<UnionType>(declOrAliasType);
2751 return parser.emitError(parser.getNameLoc(),
2752 "expected !hw.union type or alias");
2754 auto fieldIndex = declType.getFieldIndex(fieldName);
2756 parser.emitError(fieldLoc,
"cannot find union field '")
2757 << fieldName.getValue() <<
'\'';
2762 IntegerAttr::get(IntegerType::get(parser.getContext(), 32), *fieldIndex);
2763 result.addAttribute(
"fieldIndex", indexAttr);
2764 Type inputType = declType.getElements()[*fieldIndex].type;
2766 if (parser.resolveOperand(input, inputType, result.operands))
2768 result.addTypes({declOrAliasType});
2772void UnionCreateOp::print(OpAsmPrinter &printer) {
2774 printer.printOperand(getInput());
2775 printer.printOptionalAttrDict((*this)->getAttrs(), {
"fieldIndex"});
2776 printer <<
" : " << getType();
2783ParseResult UnionExtractOp::parse(OpAsmParser &parser, OperationState &result) {
2784 return parseExtractOp<UnionType>(parser, result);
2787void UnionExtractOp::print(OpAsmPrinter &printer) {
2791LogicalResult UnionExtractOp::inferReturnTypes(
2792 MLIRContext *context, std::optional<Location> loc, ValueRange operands,
2793 DictionaryAttr attrs, mlir::OpaqueProperties properties,
2794 mlir::RegionRange regions, SmallVectorImpl<Type> &results) {
2795 Adaptor adaptor(operands, attrs, properties, regions);
2796 auto unionElements =
2797 hw::type_cast<UnionType>((adaptor.getInput().getType())).getElements();
2798 unsigned fieldIndex = adaptor.getFieldIndexAttr().getValue().getZExtValue();
2799 if (fieldIndex >= unionElements.size()) {
2801 mlir::emitError(*loc,
"field index " + Twine(fieldIndex) +
2802 " exceeds element count of aggregate type");
2805 results.push_back(unionElements[fieldIndex].type);
2809void UnionExtractOp::build(OpBuilder &odsBuilder, OperationState &odsState,
2810 Value input, StringAttr fieldName) {
2811 auto unionType = type_cast<UnionType>(input.getType());
2812 auto fieldIndex = unionType.getFieldIndex(fieldName);
2813 assert(fieldIndex.has_value() &&
"field name not found in aggregate type");
2814 auto resultType = unionType.getElements()[*fieldIndex].type;
2815 build(odsBuilder, odsState, resultType, input, *fieldIndex);
2827OpFoldResult ArrayGetOp::fold(FoldAdaptor adaptor) {
2828 auto inputCst = dyn_cast_or_null<ArrayAttr>(adaptor.getInput());
2829 auto indexCst = dyn_cast_or_null<IntegerAttr>(adaptor.getIndex());
2834 auto indexVal = indexCst.getValue();
2835 if (indexVal.getBitWidth() < 64) {
2836 auto index = indexVal.getZExtValue();
2837 return inputCst[inputCst.size() - 1 - index];
2842 if (!inputCst.empty() && llvm::all_equal(inputCst))
2847 if (
auto bitcast = getInput().getDefiningOp<hw::BitcastOp>()) {
2848 auto intTy = dyn_cast<IntegerType>(getType());
2851 auto bitcastInputOp = bitcast.getInput().getDefiningOp<
hw::ConstantOp>();
2852 if (!bitcastInputOp)
2856 auto bitcastInputCst = bitcastInputOp.getValue();
2859 auto startIdx = indexCst.getValue().zext(bitcastInputCst.getBitWidth()) *
2860 getType().getIntOrFloatBitWidth();
2862 return IntegerAttr::get(intTy, bitcastInputCst.lshr(startIdx).trunc(
2863 intTy.getIntOrFloatBitWidth()));
2867 if (
auto inject = getInput().getDefiningOp<ArrayInjectOp>())
2868 if (getIndex() == inject.getIndex())
2869 return inject.getElement();
2871 auto inputCreate = getInput().getDefiningOp<
ArrayCreateOp>();
2875 if (
auto uniformValue = inputCreate.getUniformElement())
2876 return uniformValue;
2878 if (!indexCst || indexCst.getValue().getBitWidth() > 64)
2881 uint64_t index = indexCst.getValue().getLimitedValue();
2882 auto createInputs = inputCreate.getInputs();
2883 if (index >= createInputs.size())
2885 return createInputs[createInputs.size() - index - 1];
2888LogicalResult ArrayGetOp::canonicalize(
ArrayGetOp op,
2889 PatternRewriter &rewriter) {
2894 auto *inputOp = op.getInput().getDefiningOp();
2895 if (
auto inputSlice = dyn_cast_or_null<ArraySliceOp>(inputOp)) {
2897 auto offsetOp = inputSlice.getLowIndex();
2902 uint64_t offset = *offsetOpt + *idxOpt;
2904 rewriter.create<
ConstantOp>(op.getLoc(), offsetOp.getType(), offset);
2905 rewriter.replaceOpWithNewOp<
ArrayGetOp>(op, inputSlice.getInput(),
2910 if (
auto inputConcat = dyn_cast_or_null<ArrayConcatOp>(inputOp)) {
2912 uint64_t elemIndex = *idxOpt;
2913 for (
auto input :
llvm::reverse(inputConcat.getInputs())) {
2914 size_t size = hw::type_cast<ArrayType>(input.getType()).getNumElements();
2915 if (elemIndex >= size) {
2920 unsigned indexWidth = size == 1 ? 1 : llvm::Log2_64_Ceil(size);
2922 op.getLoc(), rewriter.getIntegerType(indexWidth), elemIndex);
2924 rewriter.replaceOpWithNewOp<
ArrayGetOp>(op, input, newIdxOp);
2933 if (
auto innerGet = dyn_cast_or_null<hw::ArrayGetOp>(inputOp)) {
2938 SmallVector<Value> newValues;
2939 for (
auto operand : create.getOperands())
2940 newValues.push_back(rewriter.createOrFold<
hw::
ArrayGetOp>(
2941 op.
getLoc(), operand, op.getIndex()));
2946 innerGet.getIndex());
2959OpFoldResult ArrayInjectOp::fold(FoldAdaptor adaptor) {
2960 auto inputAttr = dyn_cast_or_null<ArrayAttr>(adaptor.getInput());
2961 auto indexAttr = dyn_cast_or_null<IntegerAttr>(adaptor.getIndex());
2962 auto elementAttr = adaptor.getElement();
2965 if (inputAttr && indexAttr && elementAttr) {
2966 if (
auto index = indexAttr.getValue().tryZExtValue()) {
2967 if (*index < inputAttr.size()) {
2968 SmallVector<Attribute> elements(inputAttr.getValue());
2969 elements[inputAttr.size() - 1 - *index] = elementAttr;
2970 return ArrayAttr::get(getContext(), elements);
2978void ArrayInjectOp::getCanonicalizationPatterns(RewritePatternSet &
patterns,
2979 MLIRContext *context) {
2980 patterns.add<ArrayInjectToSameIndex>(context);
2987StringRef TypedeclOp::getPreferredName() {
2988 return getVerilogName().value_or(
getName());
2991Type TypedeclOp::getAliasType() {
2992 auto parentScope = cast<hw::TypeScopeOp>(getOperation()->getParentOp());
2993 return hw::TypeAliasType::get(
2994 SymbolRefAttr::get(parentScope.getSymNameAttr(),
2995 {FlatSymbolRefAttr::get(*this)}),
3003OpFoldResult BitcastOp::fold(FoldAdaptor) {
3006 if (getOperand().getType() == getType())
3007 return getOperand();
3012LogicalResult BitcastOp::canonicalize(
BitcastOp op, PatternRewriter &rewriter) {
3018 dyn_cast_or_null<BitcastOp>(op.getInput().getDefiningOp());
3021 auto bitcast = rewriter.createOrFold<
BitcastOp>(op.getLoc(), op.getType(),
3022 inputBitcast.getInput());
3023 rewriter.replaceOp(op, bitcast);
3027LogicalResult BitcastOp::verify() {
3029 return this->emitOpError(
"Bitwidth of input must match result");
3037bool HierPathOp::dropModule(StringAttr moduleToDrop) {
3038 SmallVector<Attribute, 4> newPath;
3039 bool updateMade =
false;
3040 for (
auto nameRef : getNamepath()) {
3042 if (
auto ref = dyn_cast<hw::InnerRefAttr>(nameRef)) {
3043 if (ref.getModule() == moduleToDrop)
3046 newPath.push_back(ref);
3048 if (cast<FlatSymbolRefAttr>(nameRef).getAttr() == moduleToDrop)
3051 newPath.push_back(nameRef);
3055 setNamepathAttr(ArrayAttr::get(getContext(), newPath));
3059bool HierPathOp::inlineModule(StringAttr moduleToDrop) {
3060 SmallVector<Attribute, 4> newPath;
3061 bool updateMade =
false;
3062 StringRef inlinedInstanceName =
"";
3063 for (
auto nameRef : getNamepath()) {
3065 if (
auto ref = dyn_cast<hw::InnerRefAttr>(nameRef)) {
3066 if (ref.getModule() == moduleToDrop) {
3067 inlinedInstanceName = ref.getName().getValue();
3069 }
else if (!inlinedInstanceName.empty()) {
3070 newPath.push_back(hw::InnerRefAttr::get(
3072 StringAttr::get(getContext(), inlinedInstanceName +
"_" +
3073 ref.getName().getValue())));
3074 inlinedInstanceName =
"";
3076 newPath.push_back(ref);
3078 if (cast<FlatSymbolRefAttr>(nameRef).getAttr() == moduleToDrop)
3081 newPath.push_back(nameRef);
3085 setNamepathAttr(ArrayAttr::get(getContext(), newPath));
3089bool HierPathOp::updateModule(StringAttr oldMod, StringAttr newMod) {
3090 SmallVector<Attribute, 4> newPath;
3091 bool updateMade =
false;
3092 for (
auto nameRef : getNamepath()) {
3094 if (
auto ref = dyn_cast<hw::InnerRefAttr>(nameRef)) {
3095 if (ref.getModule() == oldMod) {
3096 newPath.push_back(hw::InnerRefAttr::get(newMod, ref.getName()));
3099 newPath.push_back(ref);
3101 if (cast<FlatSymbolRefAttr>(nameRef).getAttr() == oldMod) {
3102 newPath.push_back(FlatSymbolRefAttr::get(newMod));
3105 newPath.push_back(nameRef);
3109 setNamepathAttr(ArrayAttr::get(getContext(), newPath));
3113bool HierPathOp::updateModuleAndInnerRef(
3114 StringAttr oldMod, StringAttr newMod,
3115 const llvm::DenseMap<StringAttr, StringAttr> &innerSymRenameMap) {
3116 auto fromRef = FlatSymbolRefAttr::get(oldMod);
3117 if (oldMod == newMod)
3120 auto namepathNew = getNamepath().getValue().vec();
3121 bool updateMade =
false;
3123 for (
auto &element : namepathNew) {
3124 if (
auto innerRef = dyn_cast<hw::InnerRefAttr>(element)) {
3125 if (innerRef.getModule() != oldMod)
3127 auto symName = innerRef.getName();
3130 auto to = innerSymRenameMap.find(symName);
3131 if (to != innerSymRenameMap.end())
3132 symName = to->second;
3134 element = hw::InnerRefAttr::get(newMod, symName);
3137 if (element != fromRef)
3141 element = FlatSymbolRefAttr::get(newMod);
3145 setNamepathAttr(ArrayAttr::get(getContext(), namepathNew));
3149bool HierPathOp::truncateAtModule(StringAttr atMod,
bool includeMod) {
3150 SmallVector<Attribute, 4> newPath;
3151 bool updateMade =
false;
3152 for (
auto nameRef : getNamepath()) {
3154 if (
auto ref = dyn_cast<hw::InnerRefAttr>(nameRef)) {
3155 if (ref.getModule() == atMod) {
3158 newPath.push_back(ref);
3160 newPath.push_back(ref);
3162 if (cast<FlatSymbolRefAttr>(nameRef).getAttr() == atMod && !includeMod)
3165 newPath.push_back(nameRef);
3171 setNamepathAttr(ArrayAttr::get(getContext(), newPath));
3176StringAttr HierPathOp::modPart(
unsigned i) {
3177 return TypeSwitch<Attribute, StringAttr>(getNamepath()[i])
3178 .Case<FlatSymbolRefAttr>([](
auto a) {
return a.getAttr(); })
3179 .Case<hw::InnerRefAttr>([](
auto a) {
return a.getModule(); });
3183StringAttr HierPathOp::root() {
3189bool HierPathOp::hasModule(StringAttr modName) {
3190 for (
auto nameRef : getNamepath()) {
3192 if (
auto ref = dyn_cast<hw::InnerRefAttr>(nameRef)) {
3193 if (ref.getModule() == modName)
3196 if (cast<FlatSymbolRefAttr>(nameRef).getAttr() == modName)
3204bool HierPathOp::hasInnerSym(StringAttr modName, StringAttr symName)
const {
3205 for (
auto nameRef : const_cast<HierPathOp *>(this)->getNamepath())
3206 if (auto ref = dyn_cast<
hw::InnerRefAttr>(nameRef))
3207 if (ref.
getName() == symName && ref.getModule() == modName)
3215StringAttr HierPathOp::refPart(
unsigned i) {
3216 return TypeSwitch<Attribute, StringAttr>(getNamepath()[i])
3217 .Case<FlatSymbolRefAttr>([](
auto a) {
return StringAttr({}); })
3218 .Case<hw::InnerRefAttr>([](
auto a) {
return a.getName(); });
3223StringAttr HierPathOp::ref() {
3225 return refPart(getNamepath().size() - 1);
3229StringAttr HierPathOp::leafMod() {
3231 return modPart(getNamepath().size() - 1);
3236bool HierPathOp::isModule() {
return !ref(); }
3240bool HierPathOp::isComponent() {
return (
bool)ref(); }
3256 ArrayAttr expectedModuleNames = {};
3257 auto checkExpectedModule = [&](Attribute name) -> LogicalResult {
3258 if (!expectedModuleNames)
3260 if (llvm::any_of(expectedModuleNames,
3261 [name](Attribute attr) {
return attr == name; }))
3263 auto diag = emitOpError() <<
"instance path is incorrect. Expected ";
3264 size_t n = expectedModuleNames.size();
3268 for (
size_t i = 0; i < n; ++i) {
3270 diag << ((i + 1 == n) ?
" or " :
", ");
3271 diag << cast<StringAttr>(expectedModuleNames[i]);
3273 diag <<
". Instead found: " << name;
3277 if (!getNamepath() || getNamepath().
empty())
3278 return emitOpError() <<
"the instance path cannot be empty";
3279 for (
unsigned i = 0, s = getNamepath().size() - 1; i < s; ++i) {
3280 hw::InnerRefAttr innerRef = dyn_cast<hw::InnerRefAttr>(getNamepath()[i]);
3282 return emitOpError()
3283 <<
"the instance path can only contain inner sym reference"
3284 <<
", only the leaf can refer to a module symbol";
3286 if (failed(checkExpectedModule(innerRef.getModule())))
3289 auto instOp = ns.
lookupOp<igraph::InstanceOpInterface>(innerRef);
3291 return emitOpError() <<
" module: " << innerRef.getModule()
3292 <<
" does not contain any instance with symbol: "
3293 << innerRef.getName();
3294 expectedModuleNames = instOp.getReferencedModuleNamesAttr();
3298 auto leafRef = getNamepath()[getNamepath().size() - 1];
3299 if (
auto innerRef = dyn_cast<hw::InnerRefAttr>(leafRef)) {
3300 if (!ns.
lookup(innerRef)) {
3301 return emitOpError() <<
" operation with symbol: " << innerRef
3302 <<
" was not found ";
3304 if (failed(checkExpectedModule(innerRef.getModule())))
3306 }
else if (failed(checkExpectedModule(
3307 cast<FlatSymbolRefAttr>(leafRef).getAttr()))) {
3313void HierPathOp::print(OpAsmPrinter &p) {
3317 StringRef visibilityAttrName = SymbolTable::getVisibilityAttrName();
3318 if (
auto visibility =
3319 getOperation()->getAttrOfType<StringAttr>(visibilityAttrName))
3320 p << visibility.getValue() <<
' ';
3322 p.printSymbolName(getSymName());
3324 llvm::interleaveComma(getNamepath().getValue(), p, [&](Attribute attr) {
3325 if (
auto ref = dyn_cast<hw::InnerRefAttr>(attr)) {
3326 p.printSymbolName(ref.getModule().getValue());
3328 p.printSymbolName(ref.getName().getValue());
3330 p.printSymbolName(cast<FlatSymbolRefAttr>(attr).getValue());
3334 p.printOptionalAttrDict(
3335 (*this)->getAttrs(),
3336 {SymbolTable::getSymbolAttrName(),
"namepath", visibilityAttrName});
3339ParseResult HierPathOp::parse(OpAsmParser &parser, OperationState &result) {
3341 (void)mlir::impl::parseOptionalVisibilityKeyword(parser, result.attributes);
3345 if (parser.parseSymbolName(symName, SymbolTable::getSymbolAttrName(),
3350 SmallVector<Attribute> namepath;
3351 if (parser.parseCommaSeparatedList(
3352 OpAsmParser::Delimiter::Square, [&]() -> ParseResult {
3353 auto loc = parser.getCurrentLocation();
3355 if (parser.parseAttribute(ref))
3359 auto pathLength = ref.getNestedReferences().size();
3360 if (pathLength == 0)
3362 FlatSymbolRefAttr::get(ref.getRootReference()));
3363 else if (pathLength == 1)
3364 namepath.push_back(hw::InnerRefAttr::get(ref.getRootReference(),
3365 ref.getLeafReference()));
3367 return parser.emitError(loc,
3368 "only one nested reference is allowed");
3372 result.addAttribute(
"namepath",
3373 ArrayAttr::get(parser.getContext(), namepath));
3375 if (parser.parseOptionalAttrDict(result.attributes))
3385void TriggeredOp::build(OpBuilder &builder, OperationState &odsState,
3386 EventControlAttr event, Value trigger,
3387 ValueRange inputs) {
3388 odsState.addOperands(trigger);
3389 odsState.addOperands(inputs);
3390 odsState.addAttribute(getEventAttrName(odsState.name), event);
3391 auto *r = odsState.addRegion();
3395 llvm::SmallVector<Location> argLocs;
3396 llvm::transform(inputs, std::back_inserter(argLocs),
3397 [&](Value v) {
return v.getLoc(); });
3398 b->addArguments(inputs.getTypes(), argLocs);
3406#define GET_OP_CLASSES
3407#include "circt/Dialect/HW/HW.cpp.inc"
assert(baseType &&"element must be base type")
static void buildModule(OpBuilder &builder, OperationState &result, StringAttr name, ArrayRef< PortInfo > ports, ArrayAttr annotations, ArrayAttr layers)
void getAsmBlockArgumentNamesImpl(Operation *op, mlir::Region ®ion, OpAsmSetValueNameFn setNameFn)
Get a special name to use when printing the entry block arguments of the region contained by an opera...
static LogicalResult verifyModuleCommon(HWModuleLike module)
static void printParamValue(OpAsmPrinter &p, Operation *, Attribute value, Type resultType)
static void printModuleOp(OpAsmPrinter &p, ModuleTy mod)
static bool flattenConcatOp(ArrayConcatOp op, PatternRewriter &rewriter)
static LogicalResult foldCreateToSlice(ArrayCreateOp op, PatternRewriter &rewriter)
static SmallVector< PortInfo > getPortList(ModuleTy &mod)
static ArrayAttr arrayOrEmpty(mlir::MLIRContext *context, ArrayRef< Attribute > attrs)
FunctionType getHWModuleOpType(Operation *op)
static void printExtractOp(OpAsmPrinter &printer, AggType op)
Use the same printer for both struct_extract and union_extract since the syntax is identical.
static void printArrayConcatTypes(OpAsmPrinter &p, Operation *, TypeRange inputTypes, Type resultType)
static ParseResult parseSliceTypes(OpAsmParser &p, Type &srcType, Type &idxType)
static void modifyModulePorts(Operation *op, ArrayRef< std::pair< unsigned, PortInfo > > insertInputs, ArrayRef< std::pair< unsigned, PortInfo > > insertOutputs, ArrayRef< unsigned > removeInputs, ArrayRef< unsigned > removeOutputs, Block *body=nullptr)
Insert and remove ports of a module.
static Value foldStructExtract(Operation *inputOp, uint32_t fieldIndex)
static bool hasAttribute(StringRef name, ArrayRef< NamedAttribute > attrs)
static void modifyModuleArgs(MLIRContext *context, ArrayRef< std::pair< unsigned, PortInfo > > insertArgs, ArrayRef< unsigned > removeArgs, ArrayRef< Attribute > oldArgNames, ArrayRef< Type > oldArgTypes, ArrayRef< Attribute > oldArgAttrs, ArrayRef< Location > oldArgLocs, SmallVector< Attribute > &newArgNames, SmallVector< Type > &newArgTypes, SmallVector< Attribute > &newArgAttrs, SmallVector< Location > &newArgLocs, Block *body=nullptr)
Internal implementation of argument/result insertion and removal on modules.
static bool mergeConcatSlices(ArrayConcatOp op, PatternRewriter &rewriter)
static SmallVector< Location > getAllPortLocs(ModTy module)
static ParseResult parseExtractOp(OpAsmParser &parser, OperationState &result)
Use the same parser for both struct_extract and union_extract since the syntax is identical.
static void setAllPortNames(ArrayRef< Attribute > names, ModTy module)
static void getAsmBlockArgumentNamesImpl(mlir::Region ®ion, OpAsmSetValueNameFn setNameFn)
Get a special name to use when printing the entry block arguments of the region contained by an opera...
static void setHWModuleType(ModTy &mod, ModuleType type)
static ParseResult parseParamValue(OpAsmParser &p, Attribute &value, Type &resultType)
static LogicalResult checkAttributes(Operation *op, Attribute attr, Type type)
static std::optional< uint64_t > getUIntFromValue(Value value)
static ParseResult parseHWModuleOp(OpAsmParser &parser, OperationState &result)
static LogicalResult verifyAggregateFieldIndexAndType(AggregateOp &op, AggregateType aggType, Type elementType)
Ensure an aggregate op's field index is within the bounds of the aggregate type and the accessed fiel...
static PortInfo getPort(ModuleTy &mod, size_t idx)
static void printSliceTypes(OpAsmPrinter &p, Operation *, Type srcType, Type idxType)
static bool hasAdditionalAttributes(Op op, ArrayRef< StringRef > ignoredAttrs={})
Check whether an operation has any additional attributes set beyond its standard list of attributes r...
static ParseResult parseArrayConcatTypes(OpAsmParser &p, SmallVectorImpl< Type > &inputTypes, Type &resultType)
static bool getFieldName(const FieldRef &fieldRef, SmallString< 32 > &string)
static InstancePath empty
static Location getLoc(DefSlot slot)
static StringAttr append(StringAttr base, const Twine &suffix)
Return a attribute with the specified suffix appended.
static Block * getBodyBlock(FModuleLike mod)
A namespace that is used to store existing names and generate new names in some scope within the IR.
StringRef newName(const Twine &name)
Return a unique name, derived from the input name, and add the new name to the internal namespace.
void setOutput(unsigned i, Value v)
Value getInput(unsigned i)
llvm::SmallVector< Value > outputOperands
llvm::SmallVector< Value > inputArgs
llvm::StringMap< unsigned > outputIdx
llvm::StringMap< unsigned > inputIdx
HWModulePortAccessor(Location loc, const ModulePortInfo &info, Region &bodyRegion)
static StringRef getInnerSymbolAttrName()
Return the name of the attribute used for inner symbol names.
This helps visit TypeOp nodes.
ResultType dispatchTypeOpVisitor(Operation *op, ExtraArgs... args)
ResultType visitUnhandledTypeOp(Operation *op, ExtraArgs... args)
This callback is invoked on any combinational operations that are not handled by the concrete visitor...
ResultType visitInvalidTypeOp(Operation *op, ExtraArgs... args)
This callback is invoked on any non-expression operations.
Direction get(bool isOutput)
Returns an output direction if isOutput is true, otherwise returns an input direction.
uint64_t getWidth(Type t)
size_t getNumPorts(Operation *op)
Return the number of ports in a module-like thing (modules, memories, etc)
ModuleType fnToMod(Operation *op, ArrayRef< Attribute > inputNames, ArrayRef< Attribute > outputNames)
LogicalResult verifyParameterStructure(ArrayAttr parameters, ArrayAttr moduleParameters, const EmitErrorFn &emitError)
Check that all the parameter values specified to the instance are structurally valid.
std::function< void(std::function< bool(InFlightDiagnostic &)>)> EmitErrorFn
Whenever the nested function returns true, a note referring to the referenced module is attached to t...
LogicalResult verifyInstanceOfHWModule(Operation *instance, FlatSymbolRefAttr moduleRef, OperandRange inputs, TypeRange results, ArrayAttr argNames, ArrayAttr resultNames, ArrayAttr parameters, SymbolTableCollection &symbolTable)
Combines verifyReferencedModule, verifyInputs, verifyOutputs, and verifyParameters.
StringAttr getName(ArrayAttr names, size_t idx)
Return the name at the specified index of the ArrayAttr or null if it cannot be determined.
ParseResult parseModuleSignature(OpAsmParser &parser, SmallVectorImpl< PortParse > &args, TypeAttr &modType)
New Style parsing.
void printModuleSignatureNew(OpAsmPrinter &p, Region &body, hw::ModuleType modType, ArrayRef< Attribute > portAttrs, ArrayRef< Location > locAttrs)
bool isOffset(Value base, Value index, uint64_t offset)
llvm::function_ref< void(OpBuilder &, HWModulePortAccessor &)> HWModuleBuilder
FunctionType getModuleType(Operation *module)
Return the signature for the specified module as a function type.
LogicalResult checkParameterInContext(Attribute value, Operation *module, Operation *usingOp, bool disallowParamRefs=false)
Check parameter specified by value to see if it is valid within the scope of the specified module mod...
int64_t getBitWidth(mlir::Type type)
Return the hardware bit width of a type.
bool isAnyModuleOrInstance(Operation *module)
TODO: Move all these functions to a hw::ModuleLike interface.
StringAttr getVerilogModuleNameAttr(Operation *module)
Returns the verilog module name attribute or symbol name of any module-like operations.
mlir::Type getCanonicalType(mlir::Type type)
The InstanceGraph op interface, see InstanceGraphInterface.td for more details.
ParseResult parseInputPortList(OpAsmParser &parser, SmallVectorImpl< OpAsmParser::UnresolvedOperand > &inputs, SmallVectorImpl< Type > &inputTypes, ArrayAttr &inputNames)
Parse a list of instance input ports.
void printOutputPortList(OpAsmPrinter &p, Operation *op, TypeRange resultTypes, ArrayAttr resultNames)
Print a list of instance output ports.
ParseResult parseOptionalParameterList(OpAsmParser &parser, ArrayAttr ¶meters)
Parse an parameter list if present.
void printOptionalParameterList(OpAsmPrinter &p, Operation *op, ArrayAttr parameters)
Print a parameter list for a module or instance.
StringRef chooseName(StringRef a, StringRef b)
Choose a good name for an item from two options.
void printInputPortList(OpAsmPrinter &p, Operation *op, OperandRange inputs, TypeRange inputTypes, ArrayAttr inputNames)
Print a list of instance input ports.
ParseResult parseOutputPortList(OpAsmParser &parser, SmallVectorImpl< Type > &resultTypes, ArrayAttr &resultNames)
Parse a list of instance output ports.
function_ref< void(Value, StringRef)> OpAsmSetValueNameFn
This class represents the namespace in which InnerRef's can be resolved.
InnerSymTarget lookup(hw::InnerRefAttr inner) const
Resolve the InnerRef to its target within this namespace, returning empty target if no such name exis...
Operation * lookupOp(hw::InnerRefAttr inner) const
Resolve the InnerRef to its target within this namespace, returning empty target if no such name exis...
This holds a decoded list of input/inout and output ports for a module or instance.
PortInfo & at(size_t idx)
size_t sizeOutputs() const
size_t sizeInputs() const
PortDirectionRange getOutputs()
This holds the name, type, direction of a module's ports.