Return the whole map

Author: Jaddyen

mlir/include/mlir/Dialect/EmitC/Transforms/Passes.td

@@ -79,15 +79,9 @@ def AddReflectionMapPass : Pass<"add-reflection-map", "ModuleOp"> {
         emitc.class @MyClass {
           emitc.field @fieldName0 : !emitc.array<1xf32> {emitc.field_ref = ["another_feature"]}
           emitc.field @fieldName1 : !emitc.array<1xf32> {emitc.field_ref = ["some_feature"]}
-          emitc.func @getBufferForName(%name : !emitc.opaque<"std::string_view">) -> !emitc.opaque<"char*"> {
+          emitc.func @getFeatures() {
             %0 = "emitc.constant"() <{value = #emitc.opaque<"{  { \22another_feature\22, reinterpret_cast<char*>(&fieldName0) },  { \22some_feature\22, reinterpret_cast<char*>(&fieldName1) } }">}> : () -> !emitc.opaque<"const std::map<std::string, char*>">
-            %1 = call_opaque "find"(%0, %arg0) : (!emitc.opaque<"const std::map<std::string, char*>">, !emitc.opaque<"std::string_view">) -> !emitc.opaque<"std::map<std::string, char*>::const_iterator">
-            %2 = call_opaque "end"(%0) : (!emitc.opaque<"const std::map<std::string, char*>">) -> !emitc.opaque<"std::map<std::string, char*>::const_iterator">
-            %3 = call_opaque "operator=="(%1, %2) : (!emitc.opaque<"std::map<std::string, char*>::const_iterator">, !emitc.opaque<"std::map<std::string, char*>::const_iterator">) -> i1
-            %4 = "emitc.constant"() <{value = #emitc.opaque<"nullptr">}> : () -> !emitc.opaque<"char">
-            %5 = call_opaque "second"(%1) : (!emitc.opaque<"std::map<std::string, char*>::const_iterator">) -> !emitc.opaque<"char">
-            %6 = conditional %3, %4, %5 : !emitc.opaque<"char">
-            return %6 : !emitc.opaque<"char">
+            return %0 : !emitc.opaque<"const std::map<std::string, char*>">
           }
           emitc.func @execute() { ... }
         }

mlir/include/mlir/Dialect/EmitC/Transforms/Transforms.h

@@ -31,6 +31,10 @@ void populateExpressionPatterns(RewritePatternSet &patterns);
 /// Populates 'patterns' with func-related patterns.
 void populateFuncPatterns(RewritePatternSet &patterns);
 
+/// Populates `patterns` with patterns to add reflection map for EmitC classes.
+void populateAddReflectionMapPatterns(RewritePatternSet &patterns,
+                                      StringRef namedAttribute);
+
 } // namespace emitc
 } // namespace mlir
 

mlir/lib/Dialect/EmitC/Transforms/AddReflectionMap.cpp

@@ -80,29 +80,11 @@ class AddReflectionMapClass : public OpRewritePattern<emitc::ClassOp> {
 
   LogicalResult matchAndRewrite(mlir::emitc::ClassOp classOp,
                                 PatternRewriter &rewriter) const override {
-    mlir::MLIRContext *context = rewriter.getContext();
-    emitc::OpaqueType stringViewType =
-        mlir::emitc::OpaqueType::get(rewriter.getContext(), "std::string_view");
-    emitc::OpaqueType charType =
-        mlir::emitc::OpaqueType::get(rewriter.getContext(), "char");
-    emitc::OpaqueType mapType = mlir::emitc::OpaqueType::get(
-        rewriter.getContext(), "const std::map<std::string, char*>");
-
-    FunctionType funcType =
-        rewriter.getFunctionType({stringViewType}, {charType});
-    emitc::FuncOp executeFunc =
-        classOp.lookupSymbol<mlir::emitc::FuncOp>("execute");
-    if (executeFunc)
-      rewriter.setInsertionPoint(executeFunc);
-    else
-      classOp.emitError() << "ClassOp must contain a function named 'execute' "
-                             "to add reflection map";
+    MLIRContext *context = rewriter.getContext();
 
-    emitc::FuncOp getBufferFunc = rewriter.create<mlir::emitc::FuncOp>(
-        classOp.getLoc(), "getBufferForName", funcType);
-
-    Block *funcBody = getBufferFunc.addEntryBlock();
-    rewriter.setInsertionPointToStart(funcBody);
+    // Define the opaque types
+    emitc::OpaqueType mapType = mlir::emitc::OpaqueType::get(
+        context, "const std::map<std::string, char*>");
 
     // Collect all field names
     std::vector<std::pair<std::string, std::string>> fieldNames;
@@ -138,35 +120,35 @@ class AddReflectionMapClass : public OpRewritePattern<emitc::ClassOp> {
       if (i < fieldNames.size() - 1)
         mapInitializer += ", ";
     }
-    mapInitializer += " }}";
+    mapInitializer += " }";
 
-    emitc::OpaqueType iteratorType = mlir::emitc::OpaqueType::get(
-        context, "std::map<std::string, char*>::const_iterator");
+    emitc::FuncOp executeFunc =
+        classOp.lookupSymbol<mlir::emitc::FuncOp>("execute");
+    if (executeFunc)
+      rewriter.setInsertionPoint(executeFunc);
+    else
+      classOp.emitError() << "ClassOp must contain a function named 'execute' "
+                             "to add reflection map";
+
+    emitc::OpaqueType returnType = mlir::emitc::OpaqueType::get(
+        context, "const std::map<std::string, char*>");
+
+    // Create the getFeatures function
+    emitc::FuncOp getFeaturesFunc = rewriter.create<mlir::emitc::FuncOp>(
+        classOp.getLoc(), "getFeatures",
+        rewriter.getFunctionType({}, {returnType}));
+
+    // Add the body of the getFeatures function
+    Block *funcBody = getFeaturesFunc.addEntryBlock();
+    rewriter.setInsertionPointToStart(funcBody);
 
+    // Create the constant map
     emitc::ConstantOp bufferMap = rewriter.create<emitc::ConstantOp>(
         classOp.getLoc(), mapType,
         emitc::OpaqueAttr::get(context, mapInitializer));
 
-    mlir::Value nameArg = getBufferFunc.getArgument(0);
-    emitc::CallOpaqueOp it = rewriter.create<emitc::CallOpaqueOp>(
-        classOp.getLoc(), iteratorType, rewriter.getStringAttr("find"),
-        mlir::ValueRange{bufferMap.getResult(), nameArg});
-    emitc::CallOpaqueOp endIt = rewriter.create<emitc::CallOpaqueOp>(
-        classOp.getLoc(), iteratorType, rewriter.getStringAttr("end"),
-        bufferMap.getResult());
-    emitc::CallOpaqueOp isEnd = rewriter.create<emitc::CallOpaqueOp>(
-        classOp.getLoc(), rewriter.getI1Type(),
-        "operator==", mlir::ValueRange{it.getResult(0), endIt.getResult(0)});
-    emitc::ConstantOp nullPtr = rewriter.create<emitc::ConstantOp>(
-        classOp.getLoc(), charType, emitc::OpaqueAttr::get(context, "nullptr"));
-    emitc::CallOpaqueOp second = rewriter.create<emitc::CallOpaqueOp>(
-        classOp.getLoc(), charType, "second", it.getResult(0));
-
-    emitc::ConditionalOp result = rewriter.create<emitc::ConditionalOp>(
-        classOp.getLoc(), charType, isEnd.getResult(0), nullPtr.getResult(),
-        second.getResult(0));
-
-    rewriter.create<emitc::ReturnOp>(classOp.getLoc(), result.getResult());
+    rewriter.create<mlir::emitc::ReturnOp>(classOp.getLoc(),
+                                           bufferMap.getResult());
 
     return success();
   }