avoid re-initialization

Author: Jaddyen

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,10 @@ 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);
+    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;
@@ -129,44 +110,45 @@ class AddReflectionMapClass : public OpRewritePattern<emitc::ClassOp> {
       }
     });
 
+    // Construct the map initializer string
     std::string mapInitializer = "{ ";
     for (size_t i = 0; i < fieldNames.size(); ++i) {
       mapInitializer += " { \"" + fieldNames[i].first + "\", " +
                         "reinterpret_cast<char*>(&" + fieldNames[i].second +
-                        ")",
-          mapInitializer += " }";
+                        ")";
+      mapInitializer += " }";
       if (i < fieldNames.size() - 1)
         mapInitializer += ", ";
     }
     mapInitializer += " }";
 
-    emitc::OpaqueType iteratorType = mlir::emitc::OpaqueType::get(
-        context, "std::map<std::string, char*>::const_iterator");
+    emitc::OpaqueType returnType = mlir::emitc::OpaqueType::get(
+        context, "const std::map<std::string, char*>");
+
+    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";
+
+    // 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();
   }