[ImportVerilog] Add global variable support (#9176)

fabianschuiki · web-flow · commit a04eac902a4a · 2025-11-03T17:31:48.000-08:00
Add new `moore.global_variable` and `moore.get_global_variable` ops to
the Moore dialect, which define global variables as a symbol and return
a reference to a global variable given its symbol, respectively.

Add support for variables at the root level and within packages in SV
inputs. Both of these get converted to `moore.global_variable`s. When
referring to a global variable by name, create `get_global_variable` ops
to resolve the symbol name to a `!moore.ref&lt;T&gt;` which can then be read.

Lowering to the core dialects is not yet supported. We very likely need
an equivalent global signal construct in LLHD.
diff --git a/include/circt/Dialect/Moore/MooreOps.td b/include/circt/Dialect/Moore/MooreOps.td
@@ -325,6 +325,50 @@ def ReadOp : MooreOp<"read", [
   }];
 }
 
+def GlobalVariableOp : MooreOp<"global_variable", [
+  IsolatedFromAbove,
+  NoRegionArguments,
+  SingleBlock,
+  Symbol,
+]> {
+  let summary = "A global variable declaration";
+  let description = [{
+    Defines a global or package variable.
+
+    See IEEE 1800-2017 § 6.8 "Variable declarations".
+  }];
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<UnpackedType>:$type
+  );
+  let regions = (region MaxSizedRegion<1>:$initRegion);
+  let assemblyFormat = [{
+    $sym_name attr-dict `:` $type (`init` $initRegion^)?
+  }];
+  let hasRegionVerifier = 1;
+  let extraClassDeclaration = [{
+    Block *getInitBlock();
+  }];
+}
+
+def GetGlobalVariableOp : MooreOp<"get_global_variable", [
+  DeclareOpInterfaceMethods<SymbolUserOpInterface>,
+  Pure,
+]> {
+  let summary = "Get a reference to a global variable";
+  let arguments = (ins FlatSymbolRefAttr:$global_name);
+  let results = (outs RefType:$result);
+  let assemblyFormat = [{
+    $global_name attr-dict `:` type($result)
+  }];
+  let builders = [
+    OpBuilder<(ins "moore::GlobalVariableOp":$global), [{
+      build($_builder, $_state,
+        RefType::get(global.getType()), global.getSymName());
+    }]>,
+  ];
+}
+
 //===----------------------------------------------------------------------===//
 // Assignments
 //===----------------------------------------------------------------------===//
@@ -1778,7 +1822,7 @@ def ConditionalOp : MooreOp<"conditional",[
 def YieldOp : MooreOp<"yield", [
   Pure,
   Terminator,
-  HasParent<"ConditionalOp">
+  ParentOneOf<["ConditionalOp", "GlobalVariableOp"]>,
 ]> {
   let summary = "conditional yield and termination operation";
   let description = [{
diff --git a/lib/Conversion/ImportVerilog/Expressions.cpp b/lib/Conversion/ImportVerilog/Expressions.cpp
@@ -429,6 +429,7 @@ struct RvalueExprVisitor : public ExprVisitor {
 
   // Handle named values, such as references to declared variables.
   Value visit(const slang::ast::NamedValueExpression &expr) {
+    // Handle local variables.
     if (auto value = context.valueSymbols.lookup(&expr.symbol)) {
       if (isa<moore::RefType>(value.getType())) {
         auto readOp = moore::ReadOp::create(builder, loc, value);
@@ -439,6 +440,12 @@ struct RvalueExprVisitor : public ExprVisitor {
       return value;
     }
 
+    // Handle global variables.
+    if (auto globalOp = context.globalVariables.lookup(&expr.symbol)) {
+      auto value = moore::GetGlobalVariableOp::create(builder, loc, globalOp);
+      return moore::ReadOp::create(builder, loc, value);
+    }
+
     // We're reading a class property.
     if (auto *const property =
             expr.symbol.as_if<slang::ast::ClassPropertySymbol>()) {
@@ -1813,8 +1820,14 @@ struct LvalueExprVisitor : public ExprVisitor {
 
   // Handle named values, such as references to declared variables.
   Value visit(const slang::ast::NamedValueExpression &expr) {
+    // Handle local variables.
     if (auto value = context.valueSymbols.lookup(&expr.symbol))
       return value;
+
+    // Handle global variables.
+    if (auto globalOp = context.globalVariables.lookup(&expr.symbol))
+      return moore::GetGlobalVariableOp::create(builder, loc, globalOp);
+
     auto d = mlir::emitError(loc, "unknown name `") << expr.symbol.name << "`";
     d.attachNote(context.convertLocation(expr.symbol.location))
         << "no lvalue generated for " << slang::ast::toString(expr.symbol.kind);
@@ -1823,9 +1836,14 @@ struct LvalueExprVisitor : public ExprVisitor {
 
   // Handle hierarchical values, such as `Top.sub.var = x`.
   Value visit(const slang::ast::HierarchicalValueExpression &expr) {
+    // Handle local variables.
     if (auto value = context.valueSymbols.lookup(&expr.symbol))
       return value;
 
+    // Handle global variables.
+    if (auto globalOp = context.globalVariables.lookup(&expr.symbol))
+      return moore::GetGlobalVariableOp::create(builder, loc, globalOp);
+
     // Emit an error for those hierarchical values not recorded in the
     // `valueSymbols`.
     auto d = mlir::emitError(loc, "unknown hierarchical name `")
diff --git a/lib/Conversion/ImportVerilog/ImportVerilogInternals.h b/lib/Conversion/ImportVerilog/ImportVerilogInternals.h
@@ -122,6 +122,7 @@ struct Context {
   LogicalResult finalizeFunctionBodyCaptures(FunctionLowering &lowering);
   LogicalResult convertClassDeclaration(const slang::ast::ClassType &classdecl);
   ClassLowering *declareClass(const slang::ast::ClassType &cls);
+  LogicalResult convertGlobalVariable(const slang::ast::VariableSymbol &var);
 
   /// Checks whether one class (actualTy) is derived from another class
   /// (baseTy). True if it's a subclass, false otherwise.
@@ -285,6 +286,14 @@ struct Context {
   using ValueSymbolScope = ValueSymbols::ScopeTy;
   ValueSymbols valueSymbols;
 
+  /// A table of defined global variables that may be referred to by name in
+  /// expressions.
+  DenseMap<const slang::ast::ValueSymbol *, moore::GlobalVariableOp>
+      globalVariables;
+  /// A list of global variables that still need their initializers to be
+  /// converted.
+  SmallVector<const slang::ast::ValueSymbol *> globalVariableWorklist;
+
   /// Collect all hierarchical names used for the per module/instance.
   DenseMap<const slang::ast::InstanceBodySymbol *, SmallVector<HierPathInfo>>
       hierPaths;
diff --git a/lib/Conversion/ImportVerilog/Structure.cpp b/lib/Conversion/ImportVerilog/Structure.cpp
@@ -148,6 +148,11 @@ struct RootVisitor : public BaseVisitor {
     return context.convertFunction(subroutine);
   }
 
+  // Handle global variables.
+  LogicalResult visit(const slang::ast::VariableSymbol &var) {
+    return context.convertGlobalVariable(var);
+  }
+
   // Emit an error for all other members.
   template <typename T>
   LogicalResult visit(T &&node) {
@@ -172,6 +177,11 @@ struct PackageVisitor : public BaseVisitor {
     return context.convertFunction(subroutine);
   }
 
+  // Handle global variables.
+  LogicalResult visit(const slang::ast::VariableSymbol &var) {
+    return context.convertGlobalVariable(var);
+  }
+
   /// Emit an error for all other members.
   template <typename T>
   LogicalResult visit(T &&node) {
@@ -701,6 +711,20 @@ LogicalResult Context::convertCompilation() {
       return failure();
   }
 
+  // Convert the initializers of global variables.
+  for (auto *var : globalVariableWorklist) {
+    auto varOp = globalVariables.at(var);
+    auto &block = varOp.getInitRegion().emplaceBlock();
+    OpBuilder::InsertionGuard guard(builder);
+    builder.setInsertionPointToEnd(&block);
+    auto value =
+        convertRvalueExpression(*var->getInitializer(), varOp.getType());
+    if (!value)
+      return failure();
+    moore::YieldOp::create(builder, varOp.getLoc(), value);
+  }
+  globalVariableWorklist.clear();
+
   return success();
 }
 
@@ -1676,3 +1700,43 @@ Context::convertClassDeclaration(const slang::ast::ClassType &classdecl) {
 
   return success();
 }
+
+/// Convert a variable to a `moore.global_variable` operation.
+LogicalResult
+Context::convertGlobalVariable(const slang::ast::VariableSymbol &var) {
+  auto loc = convertLocation(var.location);
+
+  // Pick an insertion point for this variable according to the source file
+  // location.
+  OpBuilder::InsertionGuard g(builder);
+  auto it = orderedRootOps.upper_bound(var.location);
+  if (it == orderedRootOps.end())
+    builder.setInsertionPointToEnd(intoModuleOp.getBody());
+  else
+    builder.setInsertionPoint(it->second);
+
+  // Prefix the variable name with the surrounding namespace to create somewhat
+  // sane names in the IR.
+  SmallString<64> symName;
+  guessNamespacePrefix(var.getParentScope()->asSymbol(), symName);
+  symName += var.name;
+
+  // Determine the type of the variable.
+  auto type = convertType(var.getType());
+  if (!type)
+    return failure();
+
+  // Create the variable op itself.
+  auto varOp = moore::GlobalVariableOp::create(builder, loc, symName,
+                                               cast<moore::UnpackedType>(type));
+  orderedRootOps.insert({var.location, varOp});
+  globalVariables.insert({&var, varOp});
+
+  // If the variable has an initializer expression, remember it for later such
+  // that we can convert the initializers once we have seen all global
+  // variables.
+  if (var.getInitializer())
+    globalVariableWorklist.push_back(&var);
+
+  return success();
+}
diff --git a/lib/Dialect/Moore/MooreOps.cpp b/lib/Dialect/Moore/MooreOps.cpp
@@ -536,6 +536,54 @@ LogicalResult AssignedVariableOp::canonicalize(AssignedVariableOp op,
   return failure();
 }
 
+//===----------------------------------------------------------------------===//
+// GlobalVariableOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult GlobalVariableOp::verifyRegions() {
+  if (auto *block = getInitBlock()) {
+    auto &terminator = block->back();
+    if (!isa<YieldOp>(terminator))
+      return emitOpError() << "must have a 'moore.yield' terminator";
+  }
+  return success();
+}
+
+Block *GlobalVariableOp::getInitBlock() {
+  if (getInitRegion().empty())
+    return nullptr;
+  return &getInitRegion().front();
+}
+
+//===----------------------------------------------------------------------===//
+// GetGlobalVariableOp
+//===----------------------------------------------------------------------===//
+
+LogicalResult
+GetGlobalVariableOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
+  // Resolve the target symbol.
+  auto *symbol =
+      symbolTable.lookupNearestSymbolFrom(*this, getGlobalNameAttr());
+  if (!symbol)
+    return emitOpError() << "references unknown symbol " << getGlobalNameAttr();
+
+  // Check that the symbol is a global variable.
+  auto var = dyn_cast<GlobalVariableOp>(symbol);
+  if (!var)
+    return emitOpError() << "must reference a 'moore.global_variable', but "
+                         << getGlobalNameAttr() << " is a '"
+                         << symbol->getName() << "'";
+
+  // Check that the types match.
+  auto expType = var.getType();
+  auto actType = getType().getNestedType();
+  if (expType != actType)
+    return emitOpError() << "returns a " << actType << " reference, but "
+                         << getGlobalNameAttr() << " is of type " << expType;
+
+  return success();
+}
+
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
@@ -1027,22 +1075,21 @@ LogicalResult UnionExtractRefOp::verify() {
 //===----------------------------------------------------------------------===//
 
 LogicalResult YieldOp::verify() {
-  // Check that YieldOp's parent operation is ConditionalOp.
-  auto cond = dyn_cast<ConditionalOp>(*(*this).getParentOp());
-  if (!cond) {
-    emitOpError("must have a conditional parent");
-    return failure();
+  Type expType;
+  auto *parentOp = getOperation()->getParentOp();
+  if (auto cond = dyn_cast<ConditionalOp>(parentOp)) {
+    expType = cond.getType();
+  } else if (auto varOp = dyn_cast<GlobalVariableOp>(parentOp)) {
+    expType = varOp.getType();
+  } else {
+    llvm_unreachable("all in ParentOneOf handled");
   }
 
-  // Check that the operand matches the parent operation's result.
-  auto condType = cond.getType();
-  auto yieldType = getOperand().getType();
-  if (condType != yieldType) {
-    emitOpError("yield type must match conditional. Expected ")
-        << condType << ", but got " << yieldType << ".";
-    return failure();
+  auto actType = getOperand().getType();
+  if (expType != actType) {
+    return emitOpError() << "yields " << actType << ", but parent expects "
+                         << expType;
   }
-
   return success();
 }
 
diff --git a/test/Conversion/ImportVerilog/basic.sv b/test/Conversion/ImportVerilog/basic.sv
@@ -3715,3 +3715,21 @@ module RejectInnerCapture(input bit u, output bit v);
     foo = a;
   endfunction
 endmodule
+
+// CHECK-LABEL: moore.global_variable @rootGlobal1 : !moore.i42
+bit [41:0] rootGlobal1;
+// CHECK-LABEL: moore.global_variable @rootGlobal2 : !moore.i42 init {
+// CHECK-NEXT: [[TMP1:%.+]] = moore.get_global_variable @"PackageGlobal::packageGlobal2" : <i42>
+// CHECK-NEXT: [[TMP2:%.+]] = moore.read [[TMP1]] : <i42>
+// CHECK-NEXT: moore.yield [[TMP2]] : i42
+bit [41:0] rootGlobal2 = PackageGlobal::packageGlobal2;
+
+package PackageGlobal;
+  // CHECK-LABEL: moore.global_variable @"PackageGlobal::packageGlobal1" : !moore.i42
+  bit [41:0] packageGlobal1;
+  // CHECK-LABEL: moore.global_variable @"PackageGlobal::packageGlobal2" : !moore.i42 init {
+  // CHECK-NEXT: [[TMP1:%.+]] = moore.get_global_variable @"PackageGlobal::packageGlobal1" : <i42>
+  // CHECK-NEXT: [[TMP2:%.+]] = moore.read [[TMP1]] : <i42>
+  // CHECK-NEXT: moore.yield [[TMP2]] : i42
+  bit [41:0] packageGlobal2 = packageGlobal1;
+endpackage
diff --git a/test/Dialect/Moore/basic.mlir b/test/Dialect/Moore/basic.mlir
@@ -471,18 +471,35 @@ func.func @TimeConversion(%arg0: !moore.time, %arg1: !moore.l64) {
 
 // CHECK-LABEL: func.func @RealConversion32(%arg0: !moore.f32, %arg1: !moore.i42)
 func.func @RealConversion32(%arg0: !moore.f32, %arg1: !moore.i42) {
-  // CHECK: %0 = moore.real_to_int %arg0 : f32 -> i42
+  // CHECK: moore.real_to_int %arg0 : f32 -> i42
   %0 = moore.real_to_int %arg0 : f32 -> i42
-  // CHECK: %1 = moore.int_to_real %arg1 : i42 -> f32
+  // CHECK: moore.int_to_real %arg1 : i42 -> f32
   %1 = moore.int_to_real %arg1 : i42 -> f32
   return
 }
 
 // CHECK-LABEL: func.func @RealConversion64(%arg0: !moore.f64, %arg1: !moore.i42)
 func.func @RealConversion64(%arg0: !moore.f64, %arg1: !moore.i42) {
-  // CHECK: %0 = moore.real_to_int %arg0 : f64 -> i42
+  // CHECK: moore.real_to_int %arg0 : f64 -> i42
   %0 = moore.real_to_int %arg0 : f64 -> i42
-  // CHECK: %1 = moore.int_to_real %arg1 : i42 -> f64
+  // CHECK: moore.int_to_real %arg1 : i42 -> f64
   %1 = moore.int_to_real %arg1 : i42 -> f64
   return
 }
+
+// CHECK-LABEL: moore.global_variable @GlobalVar1 : !moore.i42
+moore.global_variable @GlobalVar1 : !moore.i42
+
+// CHECK: moore.get_global_variable @GlobalVar1 : <i42>
+moore.get_global_variable @GlobalVar1 : <i42>
+
+// CHECK-LABEL: moore.global_variable @GlobalVar2 : !moore.i42
+moore.global_variable @GlobalVar2 : !moore.i42 init {
+  // CHECK-NEXT: moore.constant
+  %0 = moore.constant 9001 : i42
+  // CHECK-NEXT: moore.yield
+  moore.yield %0 : !moore.i42
+}
+
+// CHECK: moore.get_global_variable @GlobalVar2 : <i42>
+moore.get_global_variable @GlobalVar2 : <i42>
diff --git a/test/Dialect/Moore/errors.mlir b/test/Dialect/Moore/errors.mlir
