Backward Conversion

include/SDFG/Conversion/CMakeLists.txt

@@ -1,2 +1,4 @@
 add_subdirectory(GenericToSDFG)
 add_subdirectory(LinalgToSDFG)
+
+add_subdirectory(SDFGToGeneric)

include/SDFG/Conversion/GenericToSDFG/Passes.td

@@ -5,7 +5,7 @@ include "mlir/Pass/PassBase.td"
 include "SDFG/Dialect/Dialect.td"
 
 def GenericToSDFGPass : Pass<"convert-to-sdfg", "ModuleOp"> {
-  let summary = "Convert SCF, Arith and Memref dialect to SDFG dialect";
+  let summary = "Convert SCF, Arith, Math and Memref dialect to SDFG dialect";
   let constructor = "mlir::sdfg::conversion::createGenericToSDFGPass()";
   let dependentDialects = ["mlir::sdfg::SDFGDialect"];
   let options = [

include/SDFG/Conversion/SDFGToGeneric/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(LLVM_TARGET_DEFINITIONS Passes.td)
+mlir_tablegen(Passes.h.inc -gen-pass-decls -name SDFGToGeneric)
+add_public_tablegen_target(MLIRSDFGToGenericPassIncGen)
+
+target_sources(SOURCE_FILES_H PRIVATE PassDetail.h Passes.h SymbolicParser.h
+                                      OpCreators.h)

include/SDFG/Conversion/SDFGToGeneric/OpCreators.h

@@ -0,0 +1,104 @@
+#ifndef SDFG_Conversion_SDFGToGeneric_Op_Creators_H
+#define SDFG_Conversion_SDFGToGeneric_Op_Creators_H
+
+#include "mlir/Dialect/Arith/IR/Arith.h"
+#include "mlir/Dialect/ControlFlow/IR/ControlFlowOps.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Dialect/SCF/IR/SCF.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+using namespace mlir;
+
+namespace mlir::sdfg::conversion {
+
+func::FuncOp createFunc(PatternRewriter &rewriter, Location loc, StringRef name,
+                        TypeRange inputTypes, TypeRange resultTypes,
+                        StringRef visibility);
+
+func::CallOp createCall(PatternRewriter &rewriter, Location loc,
+                        TypeRange resultTypes, StringRef callee,
+                        ValueRange operands);
+
+func::ReturnOp createReturn(PatternRewriter &rewriter, Location loc,
+                            ValueRange operands);
+
+cf::BranchOp createBranch(PatternRewriter &rewriter, Location loc,
+                          ValueRange operands, Block *dest);
+
+cf::CondBranchOp createCondBranch(PatternRewriter &rewriter, Location loc,
+                                  Value condition, Block *trueDest,
+                                  Block *falseDest);
+
+memref::AllocOp createAlloc(PatternRewriter &rewriter, Location loc,
+                            MemRefType memrefType, ValueRange dynamicSizes);
+
+memref::LoadOp createLoad(PatternRewriter &rewriter, Location loc, Value memref,
+                          ValueRange indices);
+
+memref::StoreOp createStore(PatternRewriter &rewriter, Location loc,
+                            Value value, Value memref, ValueRange indices);
+
+memref::CopyOp createCopy(PatternRewriter &rewriter, Location loc, Value source,
+                          Value target);
+
+void allocSymbol(PatternRewriter &rewriter, Location loc, StringRef symName,
+                 llvm::StringMap<Value> &symbolMap);
+
+arith::ConstantIntOp createConstantInt(PatternRewriter &rewriter, Location loc,
+                                       int val, int width);
+
+arith::AddIOp createAddI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::SubIOp createSubI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::MulIOp createMulI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::DivSIOp createDivSI(PatternRewriter &rewriter, Location loc, Value a,
+                           Value b);
+
+arith::FloorDivSIOp createFloorDivSI(PatternRewriter &rewriter, Location loc,
+                                     Value a, Value b);
+
+arith::RemSIOp createRemSI(PatternRewriter &rewriter, Location loc, Value a,
+                           Value b);
+
+arith::OrIOp createOrI(PatternRewriter &rewriter, Location loc, Value a,
+                       Value b);
+
+arith::AndIOp createAndI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::XOrIOp createXOrI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::ShLIOp createShLI(PatternRewriter &rewriter, Location loc, Value a,
+                         Value b);
+
+arith::ShRSIOp createShRSI(PatternRewriter &rewriter, Location loc, Value a,
+                           Value b);
+
+arith::CmpIOp createCmpI(PatternRewriter &rewriter, Location loc,
+                         arith::CmpIPredicate predicate, Value lhs, Value rhs);
+
+arith::ExtSIOp createExtSI(PatternRewriter &rewriter, Location loc, Type out,
+                           Value in);
+
+arith::TruncIOp createTruncI(PatternRewriter &rewriter, Location loc, Type out,
+                             Value in);
+
+arith::IndexCastOp createIndexCast(PatternRewriter &rewriter, Location loc,
+                                   Type out, Value in);
+
+scf::ParallelOp createParallel(PatternRewriter &rewriter, Location loc,
+                               ValueRange lowerBounds, ValueRange upperBounds,
+                               ValueRange steps);
+
+scf::YieldOp createYield(PatternRewriter &rewriter, Location loc);
+
+} // namespace mlir::sdfg::conversion
+
+#endif // SDFG_Conversion_SDFGToGeneric_Op_Creators_H

include/SDFG/Conversion/SDFGToGeneric/PassDetail.h

@@ -0,0 +1,18 @@
+#ifndef SDFG_Conversion_SDFGToGeneric_PassDetail_H
+#define SDFG_Conversion_SDFGToGeneric_PassDetail_H
+
+#include "SDFG/Dialect/Dialect.h"
+#include "mlir/Pass/Pass.h"
+
+namespace mlir {
+namespace sdfg {
+namespace conversion {
+
+#define GEN_PASS_CLASSES
+#include "SDFG/Conversion/SDFGToGeneric/Passes.h.inc"
+
+} // namespace conversion
+} // namespace sdfg
+} // end namespace mlir
+
+#endif // SDFG_Conversion_SDFGToGeneric_PassDetail_H

include/SDFG/Conversion/SDFGToGeneric/Passes.h

@@ -0,0 +1,21 @@
+#ifndef SDFG_Conversion_SDFGToGeneric_H
+#define SDFG_Conversion_SDFGToGeneric_H
+
+#include "mlir/Pass/Pass.h"
+
+namespace mlir::sdfg::conversion {
+
+/// Creates a sdfg to generic converting pass
+std::unique_ptr<Pass> createSDFGToGenericPass();
+
+//===----------------------------------------------------------------------===//
+// Registration
+//===----------------------------------------------------------------------===//
+
+/// Generate the code for registering passes.
+#define GEN_PASS_REGISTRATION
+#include "SDFG/Conversion/SDFGToGeneric/Passes.h.inc"
+
+} // namespace mlir::sdfg::conversion
+
+#endif // SDFG_Conversion_SDFGToGeneric_H

include/SDFG/Conversion/SDFGToGeneric/Passes.td

@@ -0,0 +1,18 @@
+#ifndef SDFG_Conversion_SDFGToGeneric
+#define SDFG_Conversion_SDFGToGeneric
+
+include "mlir/Pass/PassBase.td"
+include "SDFG/Dialect/Dialect.td"
+
+def SDFGToGenericPass : Pass<"lower-sdfg", "ModuleOp"> {
+  let summary = "Convert SDFG dialect to Func, CF, Memref and SCF dialects";
+  let constructor = "mlir::sdfg::conversion::createSDFGToGenericPass()";
+  let dependentDialects = [
+    "mlir::func::FuncDialect",
+    "mlir::cf::ControlFlowDialect",
+    "mlir::memref::MemRefDialect",
+    "mlir::scf::SCFDialect"
+  ];
+}
+
+#endif // SDFG_Conversion_SDFGToGeneric

include/SDFG/Conversion/SDFGToGeneric/SymbolicParser.h

@@ -0,0 +1,189 @@
+#ifndef SDFG_Conversion_SDFGToGeneric_Symbolic_Parser_H
+#define SDFG_Conversion_SDFGToGeneric_Symbolic_Parser_H
+
+#include "mlir/Dialect/MemRef/IR/MemRef.h"
+#include "mlir/Transforms/DialectConversion.h"
+
+namespace mlir::sdfg::conversion {
+
+class ASTNode {
+public:
+  virtual ~ASTNode() = default;
+  virtual Value codegen(PatternRewriter &rewriter, Location loc,
+                        llvm::StringMap<Value> &symbolMap,
+                        llvm::StringMap<Value> &refMap) = 0;
+};
+
+class IntNode : public ASTNode {
+public:
+  int value;
+
+  IntNode(int value) : value(value){};
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+class BoolNode : public ASTNode {
+public:
+  bool value;
+
+  BoolNode(bool value) : value(value) {}
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+class VarNode : public ASTNode {
+public:
+  std::string name;
+
+  VarNode(std::string name) : name(name) {}
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+class AssignNode : public ASTNode {
+public:
+  std::unique_ptr<VarNode> variable;
+  std::unique_ptr<ASTNode> expr;
+
+  AssignNode(std::unique_ptr<VarNode> variable, std::unique_ptr<ASTNode> expr)
+      : variable(std::move(variable)), expr(std::move(expr)) {}
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+class UnOpNode : public ASTNode {
+public:
+  enum UnOp { ADD, SUB, LOG_NOT, BIT_NOT };
+  UnOp op;
+  std::unique_ptr<ASTNode> expr;
+
+  UnOpNode(UnOp op, std::unique_ptr<ASTNode> expr)
+      : op(op), expr(std::move(expr)) {}
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+class BinOpNode : public ASTNode {
+public:
+  enum BinOp {
+    ADD,
+    SUB,
+    MUL,
+    DIV,
+    FLOORDIV,
+    MOD,
+    EXP,
+    BIT_OR,
+    BIT_XOR,
+    BIT_AND,
+    LSHIFT,
+    RSHIFT,
+    LOG_OR,
+    LOG_AND,
+    EQ,
+    NE,
+    LT,
+    LE,
+    GT,
+    GE
+  };
+
+  std::unique_ptr<ASTNode> left;
+  BinOp op;
+  std::unique_ptr<ASTNode> right;
+
+  BinOpNode(std::unique_ptr<ASTNode> left, BinOp op,
+            std::unique_ptr<ASTNode> right)
+      : left(std::move(left)), op(op), right(std::move(right)) {}
+
+  Value codegen(PatternRewriter &rewriter, Location loc,
+                llvm::StringMap<Value> &symbolMap,
+                llvm::StringMap<Value> &refMap) override;
+};
+
+enum TokenType {
+  EQ,
+  NE,
+  LT,
+  LE,
+  GT,
+  GE,
+  ASSIGN,
+  LOG_OR,
+  LOG_AND,
+  LOG_NOT,
+  ADD,
+  SUB,
+  MUL,
+  DIV,
+  FLOORDIV,
+  MOD,
+  EXP,
+  TRUE,
+  FALSE,
+  BIT_OR,
+  BIT_XOR,
+  BIT_AND,
+  BIT_NOT,
+  LSHIFT,
+  RSHIFT,
+  LPAREN,
+  RPAREN,
+  INT_CONST,
+  IDENT,
+  WS
+};
+
+struct Token {
+  TokenType type;
+  std::string value;
+};
+
+class SymbolicParser {
+public:
+  std::unique_ptr<ASTNode> parse(StringRef input);
+
+private:
+  unsigned pos;
+  SmallVector<Token> tokens;
+
+  Optional<SmallVector<Token>> tokenize(StringRef input);
+
+  std::unique_ptr<ASTNode> stmt();
+  std::unique_ptr<ASTNode> assignment();
+
+  std::unique_ptr<ASTNode> log_or_expr();
+  std::unique_ptr<ASTNode> log_and_expr();
+
+  std::unique_ptr<ASTNode> eq_expr();
+  std::unique_ptr<ASTNode> rel_expr();
+  std::unique_ptr<ASTNode> shift_expr();
+
+  std::unique_ptr<ASTNode> bit_or_expr();
+  std::unique_ptr<ASTNode> bit_xor_expr();
+  std::unique_ptr<ASTNode> bit_and_expr();
+
+  std::unique_ptr<ASTNode> add_expr();
+  std::unique_ptr<ASTNode> mul_expr();
+  std::unique_ptr<ASTNode> exp_expr();
+  std::unique_ptr<ASTNode> unary_expr();
+  std::unique_ptr<ASTNode> factor();
+
+  std::unique_ptr<ASTNode> const_expr();
+  std::unique_ptr<ASTNode> bool_const();
+};
+
+} // namespace mlir::sdfg::conversion
+
+#endif // SDFG_Conversion_SDFGToGeneric_Symbolic_Parser_H

include/SDFG/Dialect/Dialect.td

@@ -44,7 +44,7 @@ def SDFG_SizedType : SDFG_Type<"Sized">{
 
         size_t getUndefRank(){ 
             size_t undefSize = 0;
-            for(int64_t dim : getIntegers()) if(dim == -1) undefSize++;
+            for(int64_t dim : getIntegers()) if(dim < 0) undefSize++;
             return undefSize;
         }
 
@@ -68,6 +68,13 @@ def SDFG_ArrayType : SDFG_Type<"Array">{
 
     let parameters = (ins SDFG_SizedType:$dimensions);
     let hasCustomAssemblyFormat = 1;
+
+    let extraClassDeclaration = [{
+        Type getElementType();
+        ArrayRef<StringAttr> getSymbols();
+        ArrayRef<int64_t> getIntegers();
+        ArrayRef<bool> getShape();
+    }];
 }
 
 //===----------------------------------------------------------------------===//