[ImportVerilog][Moore] Add support for %t format specifier, introduce moore.fmt.time (llvm#8979)

This PR adds support for using the %t format specifier in format strings 
by mapping them to the newly introduced `moore.fmt.time` / 
`moore::TimeFormatOp` in the ImportVerilog string formatter.

According to the system verilog spec IEEE 1800-2023 § 20.4.3 
"$timeformat", the exact formatting for any time value is dictated by 
the last $timeformat system task invoked within the scope or parent 
scopes of the format string, or alternatively, by a mix of constant 
default values and

The smallest time precision argument of all the timescale compiler
directives in the source description. Because of the formatting relying
on context (who came up with this anyway? seems like a bad idea), and
use of $timeformat is permitted in conditional settings, meaning it
can't always be determined statically, I decided to not add a format
attribute to moore::FormatTimeOp. I only added the width attribute,
which may be defined in the formatter expression, e.g. %4t. Instead the
semantics for implementing moore.fmt.time should rely on querying some
global state that models the configuration set by the latest
$timeformat system call within the scope.

What's not fully clear to me is whether the System Verilog spec allows
non-"time typed" values to be formatted with %t; I didn't find an
explicit description of allowed values, but all examples in the spec I
could find explicitly use the return value of a time-typed system task
(e.g. $time) or a time-type parameter (e.g. parameter time _time =
100ns;). While it seems reasonable to suppose that also integer values
are allowed (per the spec $time returns a 64-bit integer representing
time), some examples in the doc also allow the use of $realtime
(which returns a real value) with %t, so potentially any numeric value
is allowed? In either case I didn't add this in the current
implementation and instead only allow TimeType values, which in the
context of Moore looked like the sanest option to me. Maybe someone has
a clearer view on this.

Author: MoritzScherer

include/circt/Dialect/Moore/MooreOps.td

@@ -1734,6 +1734,27 @@ def FormatRealOp : MooreOp<"fmt.real", [Pure]> {
   }];
 }
 
+def FormatTimeOp : MooreOp<"fmt.time", [Pure]> {
+  let summary = "Format a time value";
+  let description = [{
+  Format a time value as a string according to the format specified by the most recent
+  invocation of `$timeformat`.
+
+  See IEEE 1800-2023 § 21.2.1.1 "Format specifications" and
+  IEEE 1800-2023 § 20.4.3 "$timeformat".
+  }];
+  let arguments = (ins
+  TimeType:$value,
+  OptionalAttr<I32Attr>:$width
+  );
+  let results = (outs FormatStringType:$result);
+  let assemblyFormat = [{
+      $value
+      (`,` `width` $width^)?
+      attr-dict
+  }];
+}
+
 //===----------------------------------------------------------------------===//
 // Builtin System Tasks and Functions
 //===----------------------------------------------------------------------===//

lib/Conversion/ImportVerilog/FormatStrings.cpp

@@ -135,6 +135,9 @@ struct FormatStringParser {
     case 'f':
       return emitReal(arg, options, RealFormat::Float);
 
+    case 't':
+      return emitTime(arg, options);
+
     case 's':
       // Simplified handling for literals.
       if (auto *lit = arg.as_if<slang::ast::StringLiteral>()) {
@@ -207,6 +210,36 @@ struct FormatStringParser {
     return success();
   }
 
+  // Format an integer with the %t specifier according to IEEE 1800-2023
+  // § 20.4.3 "$timeformat"
+  LogicalResult emitTime(const slang::ast::Expression &arg,
+                         const FormatOptions &options) {
+
+    // Only handle `TimeType` values.
+    auto value = context.convertRvalueExpression(
+        arg, moore::TimeType::get(context.getContext()));
+    if (!value)
+      return failure();
+
+    mlir::IntegerAttr width = nullptr;
+    if (options.width) {
+      mlir::Type i32Ty =
+          mlir::IntegerType::get(context.getContext(), /*width=*/32);
+      width = mlir::IntegerAttr::get(i32Ty, options.width.value());
+    }
+
+    // Delegate actual formatting to `moore.fmt.time`, annotate width if
+    // provided
+    if (width) {
+      fragments.push_back(
+          moore::FormatTimeOp::create(builder, loc, value, width));
+    } else {
+      fragments.push_back(moore::FormatTimeOp::create(builder, loc, value));
+    }
+
+    return success();
+  }
+
   /// Emit an expression argument with the appropriate default formatting.
   LogicalResult emitDefault(const slang::ast::Expression &expr) {
     FormatOptions options;

test/Conversion/ImportVerilog/basic.sv

@@ -3174,3 +3174,25 @@ function automatic int unsigned returnParameterArrayElement (int idx);
   return ParameterArray[idx];
 endfunction
 
+// CHECK-LABEL: func.func private @TimeFormat(
+function void TimeFormat();
+  // CHECK: [[TIME:%.+]] = moore.constant_time 100000000 fs
+  localparam time TestTime = 100ns;
+  // CHECK-NEXT: [[FMT:%.+]] = moore.fmt.time [[TIME]]
+  // CHECK-NEXT: [[LINEBREAK:%.+]] = moore.fmt.literal "\0A"
+  // CHECK-NEXT: [[CONCAT:%.+]] = moore.fmt.concat ([[FMT]], [[LINEBREAK]])
+  // CHECK-NEXT: moore.builtin.display [[CONCAT]]
+  $display("%t", TestTime);
+  // CHECK: [[SIMTIME:%.+]] = moore.builtin.time
+  // CHECK-NEXT: [[FMT2:%.+]] = moore.fmt.time [[SIMTIME]]
+  // CHECK-NEXT: [[LINEBREAK2:%.+]] = moore.fmt.literal "\0A"
+  // CHECK-NEXT: [[CONCAT2:%.+]] = moore.fmt.concat ([[FMT2]], [[LINEBREAK2]])
+  // CHECK-NEXT: moore.builtin.display [[CONCAT2]]
+  $display("%t", $time());
+  // CHECK: [[SIMTIME3:%.+]] = moore.builtin.time
+  // CHECK-NEXT: [[FMT3:%.+]] = moore.fmt.time [[SIMTIME3]], width 4
+  // CHECK-NEXT: [[LINEBREAK3:%.+]] = moore.fmt.literal "\0A"
+  // CHECK-NEXT: [[CONCAT3:%.+]] = moore.fmt.concat ([[FMT3]], [[LINEBREAK3]])
+  // CHECK-NEXT: moore.builtin.display [[CONCAT3]]
+  $display("%4t", $time());
+endfunction