[RTG] Add label visibility API (#8140)

include/circt-c/Dialect/RTG.h

@@ -58,6 +58,28 @@ MLIR_CAPI_EXPORTED MlirType rtgDictTypeGet(MlirContext ctxt,
                                            MlirAttribute const *entryNames,
                                            MlirType const *entryTypes);
 
+//===----------------------------------------------------------------------===//
+// Attribute API.
+//===----------------------------------------------------------------------===//
+
+enum RTGLabelVisibility {
+  RTG_LABEL_VISIBILITY_LOCAL,
+  RTG_LABEL_VISIBILITY_GLOBAL,
+  RTG_LABEL_VISIBILITY_EXTERNAL
+};
+typedef enum RTGLabelVisibility RTGLabelVisibility;
+
+/// If the attribute is an RTG label visibility.
+MLIR_CAPI_EXPORTED bool rtgAttrIsALabelVisibilityAttr(MlirAttribute attr);
+
+/// Get the RTG label visibility from the attribute.
+MLIR_CAPI_EXPORTED RTGLabelVisibility
+rtgLabelVisibilityAttrGetValue(MlirAttribute attr);
+
+/// Creates an RTG label visibility attribute in the context.
+MLIR_CAPI_EXPORTED MlirAttribute
+rtgLabelVisibilityAttrGet(MlirContext ctxt, RTGLabelVisibility visibility);
+
 #ifdef __cplusplus
 }
 #endif

integration_test/Bindings/Python/dialects/rtg.py

@@ -180,3 +180,20 @@ with Context() as ctx, Location.unknown():
     rtgtest.ImmediateOp(rtgtest.Imm32Attr.get(3))
 
   print(m)
+
+with Context() as ctx, Location.unknown():
+  circt.register_dialects(ctx)
+  m = Module.create()
+  with InsertionPoint(m.body):
+    seq = rtg.SequenceOp('seq')
+    block = Block.create_at_start(seq.bodyRegion, [])
+    with InsertionPoint(block):
+      l = rtg.label_decl("label", [])
+      visibility = rtg.LabelVisibilityAttr.get(rtg.GLOBAL)
+      rtg.label(visibility, l)
+      assert visibility.value == rtg.GLOBAL
+
+  # CHECK: rtg.sequence @seq
+  # CHECK: rtg.label_decl "label"
+  # CHECK: rtg.label global {{%.+}}
+  print(m)

lib/Bindings/Python/RTGModule.cpp

@@ -72,4 +72,22 @@ void circt::python::populateDialectRTGSubmodule(nb::module_ &m) {
           nb::arg("self"), nb::arg("ctxt") = nullptr,
           nb::arg("entries") =
               std::vector<std::pair<MlirAttribute, MlirType>>());
+
+  nb::enum_<RTGLabelVisibility>(m, "LabelVisibility")
+      .value("LOCAL", RTG_LABEL_VISIBILITY_LOCAL)
+      .value("GLOBAL", RTG_LABEL_VISIBILITY_GLOBAL)
+      .value("EXTERNAL", RTG_LABEL_VISIBILITY_EXTERNAL)
+      .export_values();
+
+  mlir_attribute_subclass(m, "LabelVisibilityAttr",
+                          rtgAttrIsALabelVisibilityAttr)
+      .def_classmethod(
+          "get",
+          [](nb::object cls, RTGLabelVisibility visibility, MlirContext ctxt) {
+            return cls(rtgLabelVisibilityAttrGet(ctxt, visibility));
+          },
+          nb::arg("self"), nb::arg("visibility"), nb::arg("ctxt") = nullptr)
+      .def_property_readonly("value", [](MlirAttribute self) {
+        return rtgLabelVisibilityAttrGetValue(self);
+      });
 }

lib/CAPI/Dialect/RTG.cpp

@@ -82,3 +82,40 @@ MlirType rtgDictTypeGet(MlirContext ctxt, intptr_t numEntries,
   }
   return wrap(DictType::get(unwrap(ctxt), entries));
 }
+
+//===----------------------------------------------------------------------===//
+// Attribute API.
+//===----------------------------------------------------------------------===//
+
+bool rtgAttrIsALabelVisibilityAttr(MlirAttribute attr) {
+  return isa<LabelVisibilityAttr>(unwrap(attr));
+}
+
+RTGLabelVisibility rtgLabelVisibilityAttrGetValue(MlirAttribute attr) {
+  auto convert = [](LabelVisibility visibility) {
+    switch (visibility) {
+    case LabelVisibility::local:
+      return RTG_LABEL_VISIBILITY_LOCAL;
+    case LabelVisibility::global:
+      return RTG_LABEL_VISIBILITY_GLOBAL;
+    case LabelVisibility::external:
+      return RTG_LABEL_VISIBILITY_EXTERNAL;
+    }
+  };
+  return convert(cast<LabelVisibilityAttr>(unwrap(attr)).getValue());
+}
+
+MlirAttribute rtgLabelVisibilityAttrGet(MlirContext ctxt,
+                                        RTGLabelVisibility visibility) {
+  auto convert = [](RTGLabelVisibility visibility) {
+    switch (visibility) {
+    case RTG_LABEL_VISIBILITY_LOCAL:
+      return LabelVisibility::local;
+    case RTG_LABEL_VISIBILITY_GLOBAL:
+      return LabelVisibility::global;
+    case RTG_LABEL_VISIBILITY_EXTERNAL:
+      return LabelVisibility::external;
+    }
+  };
+  return wrap(LabelVisibilityAttr::get(unwrap(ctxt), convert(visibility)));
+}

test/CAPI/rtg.c

@@ -75,6 +75,29 @@ static void testDictType(MlirContext ctx) {
   mlirTypeDump(emptyDictTy);
 }
 
+static void testLabelVisibilityAttr(MlirContext ctx) {
+  MlirAttribute labelVisibility =
+      rtgLabelVisibilityAttrGet(ctx, RTG_LABEL_VISIBILITY_GLOBAL);
+
+  // CHECK: is_label_visibility
+  fprintf(stderr, rtgAttrIsALabelVisibilityAttr(labelVisibility)
+                      ? "is_label_visibility\n"
+                      : "isnot_label_visibility\n");
+
+  // CHECK: global_label
+  switch (rtgLabelVisibilityAttrGetValue(labelVisibility)) {
+  case RTG_LABEL_VISIBILITY_LOCAL:
+    fprintf(stderr, "local_label\n");
+    break;
+  case RTG_LABEL_VISIBILITY_GLOBAL:
+    fprintf(stderr, "global_label\n");
+    break;
+  case RTG_LABEL_VISIBILITY_EXTERNAL:
+    fprintf(stderr, "external_label\n");
+    break;
+  }
+}
+
 int main(int argc, char **argv) {
   MlirContext ctx = mlirContextCreate();
   mlirDialectHandleLoadDialect(mlirGetDialectHandle__rtg__(), ctx);
@@ -85,6 +108,8 @@ int main(int argc, char **argv) {
   testBagType(ctx);
   testDictType(ctx);
 
+  testLabelVisibilityAttr(ctx);
+
   mlirContextDestroy(ctx);
 
   return 0;