[Moore] Add builtin for $urandom (llvm#8968)

Author: MoritzScherer

include/circt/Dialect/Moore/MooreOps.td

@@ -1741,6 +1741,26 @@ def FormatRealOp : MooreOp<"fmt.real", [Pure]> {
 class Builtin<string mnemonic, list<Trait> traits = []> :
     MooreOp<"builtin." # mnemonic, traits>;
 
+//===----------------------------------------------------------------------===//
+// Pseudo-Random Generators
+//===----------------------------------------------------------------------===//
+
+def UrandomBIOp : Builtin<"urandom"> {
+  let summary = "Generate a pseudo-random unsigned integer (optionally seeded)";
+  let description = [{
+    Corresponds to the `$urandom` system function. Returns a 32-bit
+    pseudo-random integer. The seed is optional; when provided, it initializes
+    the generator. If not provided, treat it as 0 in semantics/lowering.
+
+    See IEEE 1800-2023 § 18.13 "Random number system functions and methods".
+  }];
+
+  // Optional positional attribute for the seed
+  let arguments = (ins Optional<TwoValuedI32>:$seed);
+  let results = (outs TwoValuedI32:$result);
+  let assemblyFormat = "($seed^)? attr-dict";
+}
+
 //===----------------------------------------------------------------------===//
 // Simulation Control Builtins
 //===----------------------------------------------------------------------===//

include/circt/Dialect/Moore/MooreTypes.td

@@ -483,6 +483,13 @@ def FourValuedI64 : MooreType<CPred<[{
   let builderCall = "IntType::getLogic($_builder.getContext(), 64)";
 }
 
+// A 32-bit two-valued integer.
+def TwoValuedI32 : MooreType<CPred<[{
+    moore::isIntType($_self, 32, moore::Domain::TwoValued)
+  }]>, "32-bit two-valued integer type", "moore::IntType"> {
+  let builderCall = "IntType::getInt($_builder.getContext(), 32)";
+}
+
 /// A packed or unpacked array type with a fixed size.
 def AnyStaticArrayType : MooreType<
   Or<[ArrayType.predicate, UnpackedArrayType.predicate]>,

lib/Conversion/ImportVerilog/Expressions.cpp

@@ -984,17 +984,29 @@ struct RvalueExprVisitor : public ExprVisitor {
     const auto &subroutine = *info.subroutine;
     auto args = expr.arguments();
 
-    if (args.size() == 1) {
-      auto value = context.convertRvalueExpression(*args[0]);
+    FailureOr<Value> result;
+    Value value;
+
+    switch (args.size()) {
+    case (0):
+      result = context.convertSystemCallArity0(subroutine, loc);
+      break;
+
+    case (1):
+      value = context.convertRvalueExpression(*args[0]);
       if (!value)
         return {};
-      auto result = context.convertSystemCallArity1(subroutine, loc, value);
-      if (failed(result))
-        return {};
-      if (*result)
-        return *result;
+      result = context.convertSystemCallArity1(subroutine, loc, value);
+      break;
+
+    default:
+      break;
     }
 
+    if (failed(result))
+      return {};
+    if (*result)
+      return *result;
     mlir::emitError(loc) << "unsupported system call `" << subroutine.name
                          << "`";
     return {};
@@ -1572,6 +1584,20 @@ Value Context::materializeConversion(Type type, Value value, bool isSigned,
   return value;
 }
 
+FailureOr<Value>
+Context::convertSystemCallArity0(const slang::ast::SystemSubroutine &subroutine,
+                                 Location loc) {
+
+  auto systemCallRes =
+      llvm::StringSwitch<std::function<FailureOr<Value>()>>(subroutine.name)
+          .Case("$urandom",
+                [&]() -> Value {
+                  return moore::UrandomBIOp::create(builder, loc, nullptr);
+                })
+          .Default([&]() -> Value { return {}; });
+  return systemCallRes();
+}
+
 FailureOr<Value>
 Context::convertSystemCallArity1(const slang::ast::SystemSubroutine &subroutine,
                                  Location loc, Value value) {
@@ -1661,6 +1687,10 @@ Context::convertSystemCallArity1(const slang::ast::SystemSubroutine &subroutine,
                 [&]() -> Value {
                   return moore::AtanhBIOp::create(builder, loc, value);
                 })
+          .Case("$urandom",
+                [&]() -> Value {
+                  return moore::UrandomBIOp::create(builder, loc, value);
+                })
           .Default([&]() -> Value { return {}; });
   return systemCallRes();
 }

lib/Conversion/ImportVerilog/ImportVerilogInternals.h

@@ -181,6 +181,11 @@ struct Context {
       moore::IntFormat defaultFormat = moore::IntFormat::Decimal,
       bool appendNewline = false);
 
+  /// Convert system function calls only have arity-0.
+  FailureOr<Value>
+  convertSystemCallArity0(const slang::ast::SystemSubroutine &subroutine,
+                          Location loc);
+
   /// Convert system function calls only have arity-1.
   FailureOr<Value>
   convertSystemCallArity1(const slang::ast::SystemSubroutine &subroutine,

test/Conversion/ImportVerilog/builtins.sv

@@ -263,3 +263,14 @@ function void MathBuiltins(int x, logic [41:0] y, real r);
   // CHECK:  moore.builtin.atanh [[R]] : real
   dummyB($atanh(r));
 endfunction
+
+// CHECK-LABEL: func.func private @RandomBuiltins(
+// CHECK-SAME: [[X:%.+]]: !moore.i32
+function RandomBuiltins(int x);
+   // CHECK: [[RAND0:%.+]] = moore.builtin.urandom
+   // CHECK-NEXT: call @dummyA([[RAND0]]) : (!moore.i32) -> ()
+   dummyA($urandom());
+    // CHECK: [[RAND1:%.+]] = moore.builtin.urandom [[X]]
+    // CHECK-NEXT: call @dummyA([[RAND1]]) : (!moore.i32) -> ()
+   dummyA($urandom(x));
+endfunction