[Moore][ImportVerilog] Add SystemVerilog string.getc builtin

Author: TaoBi22

include/circt/Dialect/Moore/MooreOps.td

@@ -2553,5 +2553,14 @@ def StringToLowerOp : StringBuiltin<"tolower"> {
   let assemblyFormat = "$str attr-dict";
 }
 
+def StringGetCOp : StringBuiltin<"getc"> {
+  let summary = "Get a character from a string";
+  let description = [{
+    Returns the character at the specified index in the given string.
+  }];
+  let arguments = (ins StringType:$str, TwoValuedI32:$index);
+  let results = (outs TwoValuedI8:$result);
+  let assemblyFormat = "$str `[` $index `]` attr-dict";
+}
 
 #endif // CIRCT_DIALECT_MOORE_MOOREOPS

include/circt/Dialect/Moore/MooreTypes.td

@@ -521,6 +521,13 @@ def TwoValuedI32 : MooreType<CPred<[{
   let builderCall = "IntType::getInt($_builder.getContext(), 32)";
 }
 
+// A 32-bit two-valued integer.
+def TwoValuedI8 : MooreType<CPred<[{
+    moore::isIntType($_self, 8, moore::Domain::TwoValued)
+  }]>, "8-bit two-valued integer type", "moore::IntType"> {
+  let builderCall = "IntType::getInt($_builder.getContext(), 8)";
+}
+
 // A 32-bit real value.
 def RealF32 : MooreType<CPred<[{
     moore::isRealType($_self, 32)

lib/Conversion/ImportVerilog/Expressions.cpp

@@ -1417,6 +1417,7 @@ struct RvalueExprVisitor : public ExprVisitor {
 
     FailureOr<Value> result;
     Value value;
+    Value value2;
 
     // $sformatf() and $sformat look like system tasks, but we handle string
     // formatting differently from expression evaluation, so handle them
@@ -1451,6 +1452,14 @@ struct RvalueExprVisitor : public ExprVisitor {
       result = context.convertSystemCallArity1(subroutine, loc, value);
       break;
 
+    case (2):
+      value = context.convertRvalueExpression(*args[0]);
+      value2 = context.convertRvalueExpression(*args[1]);
+      if (!value || !value2)
+        return {};
+      result = context.convertSystemCallArity2(subroutine, loc, value, value2);
+      break;
+
     default:
       break;
     }
@@ -2517,6 +2526,20 @@ Context::convertSystemCallArity1(const slang::ast::SystemSubroutine &subroutine,
   return systemCallRes();
 }
 
+FailureOr<Value>
+Context::convertSystemCallArity2(const slang::ast::SystemSubroutine &subroutine,
+                                 Location loc, Value value1, Value value2) {
+  auto systemCallRes =
+      llvm::StringSwitch<std::function<FailureOr<Value>()>>(subroutine.name)
+          .Case("getc",
+                [&]() -> Value {
+                  return moore::StringGetCOp::create(builder, loc, value1,
+                                                     value2);
+                })
+          .Default([&]() -> Value { return {}; });
+  return systemCallRes();
+}
+
 // Resolve any (possibly nested) SymbolRefAttr to an op from the root.
 static mlir::Operation *resolve(Context &context, mlir::SymbolRefAttr sym) {
   return context.symbolTable.lookupNearestSymbolFrom(context.intoModuleOp, sym);

lib/Conversion/ImportVerilog/ImportVerilogInternals.h

@@ -238,6 +238,11 @@ struct Context {
   convertSystemCallArity1(const slang::ast::SystemSubroutine &subroutine,
                           Location loc, Value value);
 
+  /// Convert system function calls with arity-2.
+  FailureOr<Value>
+  convertSystemCallArity2(const slang::ast::SystemSubroutine &subroutine,
+                          Location loc, Value value1, Value value2);
+
   /// Convert system function calls within properties and assertion with a
   /// single argument.
   FailureOr<Value> convertAssertionSystemCallArity1(

test/Conversion/ImportVerilog/builtins.sv

@@ -9,6 +9,7 @@ function void dummyA(int x); endfunction
 function void dummyB(real x); endfunction
 function void dummyC(shortreal x); endfunction
 function void dummyD(string x); endfunction
+function void dummyE(byte x); endfunction
 
 // IEEE 1800-2017 § 20.2 "Simulation control system tasks"
 // CHECK-LABEL: func.func private @SimulationControlBuiltins(
@@ -386,11 +387,14 @@ endmodule
 
 // CHECK-LABEL: func.func private @StringBuiltins(
 // CHECK-SAME: [[STR:%.+]]: !moore.string
-function void StringBuiltins(string string_in);
+// CHECK-SAME: [[INT:%.+]]: !moore.i32
+function void StringBuiltins(string string_in, int int_in);
   // CHECK: [[LEN:%.+]] = moore.string.len [[STR]]
   dummyA(string_in.len());
   // CHECK: [[LEN:%.+]] = moore.string.toupper [[STR]]
   dummyD(string_in.toupper());
   // CHECK: [[LEN:%.+]] = moore.string.tolower [[STR]]
   dummyD(string_in.tolower());
+  // CHECK: [[CHAR:%.+]] = moore.string.getc [[STR]]{{\[}}[[INT]]]
+  dummyE(string_in.getc(int_in));
 endfunction