[ImportVerilog] [SROA] [Mem2Reg][Canonicalizers]Support Passes for Nested Type

include/circt/Dialect/Moore/MooreOps.td

@@ -186,6 +186,7 @@ def ProcedureOp : MooreOp<"procedure", [
 //===----------------------------------------------------------------------===//
 
 def VariableOp : MooreOp<"variable", [
+  DeclareOpInterfaceMethods<DestructurableAllocationOpInterface>,
   DeclareOpInterfaceMethods<PromotableAllocationOpInterface>,
   DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>,
   OptionalTypesMatchWith<"initial value and variable types match",
@@ -412,6 +413,7 @@ def ConstantOp : MooreOp<"constant", [Pure]> {
   let results = (outs IntType:$result);
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
+  let hasFolder = 1;
   let builders = [
     OpBuilder<(ins "IntType":$type, "const APInt &":$value)>,
     OpBuilder<(ins "IntType":$type, "int64_t":$value)>,
@@ -965,7 +967,7 @@ def ExtractRefOp : MooreOp<"extract_ref"> {
   }];
 }
 
-def StructCreateOp : MooreOp<"struct_create", [SameOperandsAndResultType]> {
+def StructCreateOp : MooreOp<"struct_create", [Pure]> {
   let summary = "Struct Create operation";
   let description = [{
     A structure represents a collection of data types
@@ -990,15 +992,18 @@ def StructCreateOp : MooreOp<"struct_create", [SameOperandsAndResultType]> {
     ```
     See IEEE 1800-2017 § 7.2. "Structures".
   }];
-  let arguments = (ins UnpackedType:$input);
-  let results = (outs UnpackedType:$result);
-  let hasCustomAssemblyFormat = 1;
+  let arguments = (ins Variadic<UnpackedType>:$input);
+  let results = (outs RefType:$result);
   let assemblyFormat = [{
-  $input attr-dict `:` type($input)
+    $input attr-dict `:` type($input) `->` type($result)
   }];
+  let hasVerifier = 1;
+  let hasFolder = 1;
 }
 
-def StructExtractOp : MooreOp<"struct_extract"> {
+def StructExtractOp : MooreOp<"struct_extract", [
+  DeclareOpInterfaceMethods<DestructurableAccessorOpInterface>
+]> {
   let summary = "Struct Extract operation";
   let description = [{
     Structures can be converted to bits preserving the bit pattern.
@@ -1026,16 +1031,29 @@ def StructExtractOp : MooreOp<"struct_extract"> {
     ```
     See IEEE 1800-2017 § 7.2.1 "Assigning to structures".
   }];
-  let arguments = (ins StrAttr:$memberName, UnpackedType:$input);
+  let arguments = (ins StrAttr:$fieldName, Arg<RefType, "", [MemRead]>:$input);
   let results = (outs UnpackedType:$result);
   let assemblyFormat = [{
-  $input `,`   $memberName  attr-dict `:`
-  type($input) `->`
-  type($result)
+    $input `,` $fieldName attr-dict `:` type($input) `->` type($result)
+  }];
+  let hasVerifier = 1;
+  let hasFolder = 1;
+}
+
+def StructExtractRefOp : MooreOp<"struct_extract_ref", [
+  DeclareOpInterfaceMethods<DestructurableAccessorOpInterface>
+]> {
+  let summary = "Struct Extract operation";
+  let arguments = (ins StrAttr:$fieldName, RefType:$input);
+  let results = (outs RefType:$result);
+  let assemblyFormat = [{
+    $input `,` $fieldName attr-dict `:`
+    type($input) `->` type($result)
   }];
+  let hasVerifier = 1;
 }
 
-def StructInjectOp : MooreOp<"struct_inject"> {
+def StructInjectOp : MooreOp<"struct_inject", [Pure]>  {
   let summary = "Struct Field operation";
   let description = [{
     A structure can be assigned as a whole and passed to
@@ -1059,16 +1077,16 @@ def StructInjectOp : MooreOp<"struct_inject"> {
     ```
     See IEEE 1800-2017 § 7.2. "Assigning to structures".
   }];
-  let arguments = (ins UnpackedType:$LHS, StrAttr:$memberName,
-  UnpackedType:$RHS);
-  let results = (outs UnpackedType:$result);
-  let assemblyFormat = [{
-    $LHS `,`   $memberName `,` $RHS
-    attr-dict `:` type($LHS) type($RHS) `->` type($result)
-  }];
+  let arguments = (ins  RefType:$input, StrAttr:$fieldName,
+  UnpackedType:$newValue);
+  let results = (outs RefType:$result);
+  let hasCustomAssemblyFormat = 1;
+  let hasVerifier = 1;
+  let hasFolder = 1;
+  let hasCanonicalizeMethod = true;
 }
 
-def UnionCreateOp : MooreOp<"union_create"> {
+def UnionCreateOp : MooreOp<"union_create", [Pure]> {
   let summary = "Union Create operation";
   let description = [{
     A union is a data type that represents a single piece
@@ -1093,12 +1111,12 @@ def UnionCreateOp : MooreOp<"union_create"> {
     ```
     See IEEE 1800-2017 § 7.3 "Unions"
   }];
-  let arguments = (ins StrAttr:$unionName, UnpackedType:$input);
+  let arguments = (ins UnpackedType:$input, StrAttr:$fieldName);
   let results = (outs UnpackedType:$result);
   let assemblyFormat = [{
-  $unionName `,` $input attr-dict `:`
-  type($input) `->` type($result)
+    $input attr-dict `:` type($input) `->` type($result)
   }];
+  let hasVerifier = 1;
 }
 
 def UnionExtractOp : MooreOp<"union_extract"> {
@@ -1124,17 +1142,29 @@ def UnionExtractOp : MooreOp<"union_extract"> {
     ```
     See IEEE 1800-2017 § 7.3.1 "Packed unions"
   }];
-  let arguments = (ins StrAttr:$memberName, UnpackedType:$input);
+  let arguments = (ins StrAttr:$fieldName, UnpackedType:$input);
   let results = (outs UnpackedType:$result);
   let assemblyFormat = [{
-  $input `,`   $memberName  attr-dict `:`
-  type($input) `->` type($result)
+    $input `,`   $fieldName  attr-dict `:`
+    type($input) `->` type($result)
   }];
+  let hasVerifier = 1;
+}
+
+def UnionExtractRefOp : MooreOp<"union_extract_ref"> {
+  let summary = "Union Extract operation";
+  let arguments = (ins StrAttr:$fieldName, RefType:$input);
+  let results = (outs RefType:$result);
+  let assemblyFormat = [{
+    $input `,`   $fieldName  attr-dict `:`
+    type($input) `->` type($result)
+  }];
+  let hasVerifier = 1;
 }
 
 def ConditionalOp : MooreOp<"conditional",[
   RecursiveMemoryEffects,
-  NoRegionArguments, 
+  NoRegionArguments,
   SingleBlockImplicitTerminator<"moore::YieldOp">
 ]> {
   let summary = "Conditional operation";
@@ -1174,8 +1204,8 @@ def ConditionalOp : MooreOp<"conditional",[
 }
 
 def YieldOp : MooreOp<"yield", [
-  Pure, 
-  Terminator, 
+  Pure,
+  Terminator,
   HasParent<"ConditionalOp">
 ]> {
   let summary = "conditional yield and termination operation";

include/circt/Dialect/Moore/MooreTypes.h

@@ -18,6 +18,7 @@
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/Types.h"
+#include "mlir/Interfaces/MemorySlotInterfaces.h"
 #include <variant>
 
 namespace circt {

include/circt/Dialect/Moore/MooreTypes.td

@@ -16,6 +16,7 @@
 include "circt/Dialect/Moore/MooreDialect.td"
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/EnumAttr.td"
+include "mlir/Interfaces/MemorySlotInterfaces.td"
 
 class MooreTypeDef<string name, list<Trait> traits = [],
                    string baseCppClass = "::mlir::Type">
@@ -284,9 +285,16 @@ class StructLikeType<
   let assemblyFormat = [{
     `<` custom<Members>($members) `>`
   }];
+  let extraClassDeclaration = [{
+    std::optional<DenseMap<Attribute, Type>> getSubelementIndexMap();
+    Type getTypeAtIndex(Attribute index);
+    std::optional<uint32_t> getFieldIndex(StringAttr nameField);
+  }];
 }
 
-def StructType : StructLikeType<"Struct", [], "moore::PackedType"> {
+def StructType : StructLikeType<"Struct", [
+  DeclareTypeInterfaceMethods<DestructurableTypeInterface
+>], "moore::PackedType"> {
   let mnemonic = "struct";
   let summary = "a packed struct type";
   let description = [{
@@ -296,7 +304,9 @@ def StructType : StructLikeType<"Struct", [], "moore::PackedType"> {
 }
 
 def UnpackedStructType : StructLikeType<
-  "UnpackedStruct", [], "moore::UnpackedType"
+  "UnpackedStruct", [
+  DeclareTypeInterfaceMethods<DestructurableTypeInterface
+>], "moore::UnpackedType"
 > {
   let mnemonic = "ustruct";
   let summary = "an unpacked struct type";
@@ -305,7 +315,9 @@ def UnpackedStructType : StructLikeType<
   }];
 }
 
-def UnionType : StructLikeType<"Union", [], "moore::PackedType"> {
+def UnionType : StructLikeType<"Union", [
+  DeclareTypeInterfaceMethods<DestructurableTypeInterface
+>], "moore::PackedType"> {
   let mnemonic = "union";
   let summary = "a packed union type";
   let description = [{
@@ -316,7 +328,9 @@ def UnionType : StructLikeType<"Union", [], "moore::PackedType"> {
 
 
 def UnpackedUnionType : StructLikeType<
-  "UnpackedUnion", [], "moore::UnpackedType"
+  "UnpackedUnion", [
+  DeclareTypeInterfaceMethods<DestructurableTypeInterface
+>], "moore::UnpackedType"
 > {
   let mnemonic = "uunion";
   let summary = "an unpacked union type";
@@ -329,7 +343,9 @@ def UnpackedUnionType : StructLikeType<
 // Reference type wrapper
 //===----------------------------------------------------------------------===//
 
-def RefType : MooreTypeDef<"Ref", [], "moore::UnpackedType">{
+def RefType : MooreTypeDef<"Ref", [
+  DeclareTypeInterfaceMethods<DestructurableTypeInterface
+>], "moore::UnpackedType">{
   let mnemonic = "ref";
   let description = [{
     A wrapper is used to wrap any SystemVerilog type. It's aimed to work for
@@ -352,6 +368,9 @@ def RefType : MooreTypeDef<"Ref", [], "moore::UnpackedType">{
     std::optional<unsigned> getBitSize() {
       return getNestedType().getBitSize();
     };
+    std::optional<DenseMap<Attribute, Type>> getSubelementIndexMap();
+    Type getTypeAtIndex(Attribute index);
+    std::optional<uint32_t> getFieldIndex(StringAttr nameField);
   }];
 }
 

lib/Conversion/ImportVerilog/Expressions.cpp

@@ -99,6 +99,16 @@ struct RvalueExprVisitor {
       return {};
     }
 
+    if (auto refOp = lhs.getDefiningOp<moore::StructExtractRefOp>()) {
+      auto input = refOp.getInput();
+      if (isa<moore::SVModuleOp>(input.getDefiningOp()->getParentOp())) {
+        refOp.getInputMutable();
+        refOp->erase();
+        builder.create<moore::StructInjectOp>(loc, input.getType(), input,
+                                              refOp.getFieldNameAttr(), rhs);
+        return rhs;
+      }
+    }
     if (expr.isNonBlocking())
       builder.create<moore::NonBlockingAssignOp>(loc, lhs, rhs);
     else
@@ -461,7 +471,7 @@ struct RvalueExprVisitor {
   Value visit(const slang::ast::MemberAccessExpression &expr) {
     auto type = context.convertType(*expr.type);
     auto valueType = expr.value().type;
-    auto value = context.convertRvalueExpression(expr.value());
+    auto value = context.convertLvalueExpression(expr.value());
     if (!type || !value)
       return {};
     if (valueType->isStruct()) {
@@ -472,7 +482,9 @@ struct RvalueExprVisitor {
       return builder.create<moore::UnionExtractOp>(
           loc, type, builder.getStringAttr(expr.member.name), value);
     }
-    llvm_unreachable("unsupported symbol kind");
+    mlir::emitError(loc, "expression of type ")
+        << value.getType() << " cannot be accessed";
+    return {};
   }
 
   // Handle set membership operator.
@@ -653,6 +665,27 @@ struct LvalueExprVisitor {
         lowBit);
   }
 
+  Value visit(const slang::ast::MemberAccessExpression &expr) {
+    auto type = context.convertType(*expr.type);
+    auto valueType = expr.value().type;
+    auto value = context.convertLvalueExpression(expr.value());
+    if (!type || !value)
+      return {};
+    if (valueType->isStruct()) {
+      return builder.create<moore::StructExtractRefOp>(
+          loc, moore::RefType::get(cast<moore::UnpackedType>(type)),
+          builder.getStringAttr(expr.member.name), value);
+    }
+    if (valueType->isPackedUnion() || valueType->isUnpackedUnion()) {
+      return builder.create<moore::UnionExtractRefOp>(
+          loc, moore::RefType::get(cast<moore::UnpackedType>(type)),
+          builder.getStringAttr(expr.member.name), value);
+    }
+    mlir::emitError(loc, "expression of type ")
+        << value.getType() << " cannot be accessed";
+    return {};
+  }
+
   // Handle range bits selections.
   Value visit(const slang::ast::RangeSelectExpression &expr) {
     auto type = context.convertType(*expr.type);

lib/Conversion/ImportVerilog/Structure.cpp

@@ -322,6 +322,17 @@ struct MemberVisitor {
     if (!lhs || !rhs)
       return failure();
 
+    if (auto refOp = lhs.getDefiningOp<moore::StructExtractRefOp>()) {
+      auto input = refOp.getInput();
+      if (isa<moore::SVModuleOp>(input.getDefiningOp()->getParentOp())) {
+        refOp.getInputMutable();
+        refOp->erase();
+        builder.create<moore::StructInjectOp>(loc, input.getType(), input,
+                                              refOp.getFieldNameAttr(), rhs);
+        return success();
+      }
+    }
+
     builder.create<moore::ContinuousAssignOp>(loc, lhs, rhs);
     return success();
   }