EmitC: Add emitc.global and emitc.get_global (#145) (llvm#88701)

This adds
- `emitc.global` and `emitc.get_global` ops to model global variables
similar to how `memref.global` and `memref.get_global` work.
- translation of those ops to C++
- lowering of `memref.global` and `memref.get_global` into those ops

---------

Co-authored-by: Simon Camphausen <[email protected]>

Author: mgehre-amd

mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

@@ -1020,7 +1020,7 @@ def EmitC_GlobalOp : EmitC_Op<"global", [Symbol]> {
     The `emitc.global` operation declares or defines a named global variable.
     The backing memory for the variable is allocated statically and is
     described by the type of the variable.
-    Optionally, and `initial_value` can be provided.
+    Optionally, an `initial_value` can be provided.
     Internal linkage can be specified using the `staticSpecifier` unit attribute
     and external linkage can be specified using the `externSpecifier` unit attribute.
     Note that the default linkage without those two keywords depends on whether
@@ -1047,14 +1047,14 @@ def EmitC_GlobalOp : EmitC_Op<"global", [Symbol]> {
   let arguments = (ins SymbolNameAttr:$sym_name,
                        TypeAttr:$type,
                        OptionalAttr<EmitC_OpaqueOrTypedAttr>:$initial_value,
-                       UnitAttr:$externSpecifier,
-                       UnitAttr:$staticSpecifier,
-                       UnitAttr:$constSpecifier);
+                       UnitAttr:$extern_specifier,
+                       UnitAttr:$static_specifier,
+                       UnitAttr:$const_specifier);
 
   let assemblyFormat = [{
-       (`extern` $externSpecifier^)?
-       (`static` $staticSpecifier^)?
-       (`const` $constSpecifier^)?
+       (`extern` $extern_specifier^)?
+       (`static` $static_specifier^)?
+       (`const` $const_specifier^)?
        $sym_name
        `:` custom<EmitCGlobalOpTypeAndInitialValue>($type, $initial_value)
        attr-dict

mlir/lib/Conversion/MemRefToEmitC/MemRefToEmitC.cpp

@@ -81,14 +81,18 @@ struct ConvertGlobal final : public OpConversionPattern<memref::GlobalOp> {
           op.getLoc(),
           "only public and private visibility is currently supported");
     }
-    // We are explicit in specifier the linkage because the default linkage
+    // We are explicit in specifing the linkage because the default linkage
     // for constants is different in C and C++.
     bool staticSpecifier = visibility == SymbolTable::Visibility::Private;
     bool externSpecifier = !staticSpecifier;
 
+    Attribute initialValue = operands.getInitialValueAttr();
+    if (isa_and_present<UnitAttr>(initialValue))
+      initialValue = {};
+
     rewriter.replaceOpWithNewOp<emitc::GlobalOp>(
-        op, operands.getSymName(), resultTy, operands.getInitialValueAttr(),
-        externSpecifier, staticSpecifier, operands.getConstant());
+        op, operands.getSymName(), resultTy, initialValue, externSpecifier,
+        staticSpecifier, operands.getConstant());
     return success();
   }
 };

mlir/lib/Dialect/EmitC/IR/EmitC.cpp

@@ -1015,16 +1015,18 @@ parseEmitCGlobalOpTypeAndInitialValue(OpAsmParser &parser, TypeAttr &typeAttr,
   if (parser.parseAttribute(initialValue, getInitializerTypeForGlobal(type)))
     return failure();
 
-  if (!llvm::isa<ElementsAttr, IntegerAttr, FloatAttr>(initialValue))
+  if (!llvm::isa<ElementsAttr, IntegerAttr, FloatAttr, emitc::OpaqueAttr>(
+          initialValue))
     return parser.emitError(parser.getNameLoc())
-           << "initial value should be a unit, integer, float or elements "
+           << "initial value should be a integer, float, elements or opaque "
               "attribute";
   return success();
 }
 
 LogicalResult GlobalOp::verify() {
-  // Verify that the initial value, if present, is either a unit attribute or
-  // an elements attribute.
+  if (!isSupportedEmitCType(getType())) {
+    return emitOpError("expected valid emitc type");
+  }
   if (getInitialValue().has_value()) {
     Attribute initValue = getInitialValue().value();
     // Check that the type of the initial value is compatible with the type of
@@ -1050,10 +1052,9 @@ LogicalResult GlobalOp::verify() {
         return emitOpError("initial value expected to be of type ")
                << getType() << ", but was of type " << floatAttr.getType();
       }
-    } else {
-      return emitOpError(
-                 "initial value should be a unit, integer, float or elements "
-                 "attribute, but got ")
+    } else if (!isa<emitc::OpaqueAttr>(initValue)) {
+      return emitOpError("initial value should be a integer, float, elements "
+                         "or opaque attribute, but got ")
              << initValue;
     }
   }

mlir/lib/Target/Cpp/TranslateToCpp.cpp

@@ -1417,7 +1417,7 @@ LogicalResult CppEmitter::emitGlobalVariable(GlobalOp op) {
   }
 
   std::optional<Attribute> initialValue = op.getInitialValue();
-  if (initialValue && !isa<UnitAttr>(*initialValue)) {
+  if (initialValue) {
     os << " = ";
     if (failed(emitAttribute(op->getLoc(), *initialValue)))
       return failure();

mlir/test/Conversion/MemRefToEmitC/memref-to-emitc.mlir

@@ -36,6 +36,8 @@ module @globals {
   // CHECK: emitc.global static const @internal_global : !emitc.array<3x7xf32> = dense<4.000000e+00>
   memref.global @public_global : memref<3x7xf32>
   // CHECK: emitc.global extern @public_global : !emitc.array<3x7xf32>
+  memref.global @uninitialized_global : memref<3x7xf32> = uninitialized
+  // CHECK: emitc.global extern @uninitialized_global : !emitc.array<3x7xf32>
 
   func.func @use_global() {
     // CHECK: emitc.get_global @public_global : !emitc.array<3x7xf32>

mlir/test/Dialect/EmitC/ops.mlir

@@ -242,6 +242,6 @@ emitc.global const @myconstant : !emitc.array<2xi16> = dense<2>
 
 func.func @use_global(%i: index) -> f32 {
   %0 = emitc.get_global @myglobal : !emitc.array<2xf32>
-  %1 = emitc.subscript %0[%i] : <2xf32>, index
+  %1 = emitc.subscript %0[%i] : (!emitc.array<2xf32>, index) -> f32
   return %1 : f32
 }

mlir/test/Target/Cpp/global.mlir

@@ -25,9 +25,12 @@ emitc.global static @static_var : f32
 emitc.global static @static_const : f32 = 3.0
 // CHECK: static float static_const = 3.000000000e+00f;
 
+emitc.global @opaque_init : !emitc.opaque<"char"> = #emitc.opaque<"CHAR_MIN">
+// CHECK: char opaque_init = CHAR_MIN;
+
 func.func @use_global(%i: index) -> f32 {
   %0 = emitc.get_global @myglobal : !emitc.array<2xf32>
-  %1 = emitc.subscript %0[%i] : <2xf32>, index
+  %1 = emitc.subscript %0[%i] : (!emitc.array<2xf32>, index) -> f32
   return %1 : f32
   // CHECK-LABEL: use_global
   // CHECK-SAME: (size_t [[V1:.*]])