feat: Add SCF dialect and generate IR for a few basic expressions and statements

Also, add the option `-emit-ir` to the CLI to
generate the IR to the standard output.

Signed-off-by: Roberto Raggi <[email protected]>

Author: robertoraggi

src/frontend/cxx/frontend.cc

@@ -296,7 +296,7 @@ auto runOnFile(const CLI& cli, const std::string& fileName) -> bool {
     }
 
 #ifdef CXX_WITH_MLIR
-    if (cli.opt_ir_dump) {
+    if (cli.opt_emit_ir) {
       mlir::MLIRContext context;
       context.loadDialect<mlir::cxx::CxxDialect>();
 
@@ -305,7 +305,7 @@ auto runOnFile(const CLI& cli, const std::string& fileName) -> bool {
       auto ir = codegen(unit.ast());
 
       mlir::OpPrintingFlags flags;
-      flags.enableDebugInfo(true);
+      flags.enableDebugInfo(true, true);
       ir.module->print(llvm::outs(), flags);
     }
 #endif

src/mlir/cxx/mlir/CMakeLists.txt

@@ -18,6 +18,7 @@ target_link_libraries(cxx-mlir PUBLIC
     MLIRIR
     MLIRFuncDialect
     MLIRControlFlowDialect
+    MLIRSCFDialect
 )
 add_dependencies(cxx-mlir MLIRCxxOpsIncGen)
 

src/mlir/cxx/mlir/CxxOps.td

@@ -28,6 +28,7 @@ def Cxx_Dialect : Dialect {
   let dependentDialects = [
     "mlir::func::FuncDialect",
     "mlir::cf::ControlFlowDialect",
+    "mlir::scf::SCFDialect",
   ];
 }
 
@@ -40,7 +41,7 @@ class Cxx_Op<string mnemonic, list<Trait> traits = []> : Op<Cxx_Dialect, mnemoni
 
 def Cxx_ExprType : Cxx_Type<"Expr", "expr">;
 
-def Cxx_TodoExprOp : Cxx_Op<"todo.expr"> {
+def TodoExprOp : Cxx_Op<"todo.expr"> {
   let arguments = (ins StrAttr:$message);
   let results = (outs Cxx_ExprType:$result);
   let assemblyFormat = "$message attr-dict `:` type($result)";
@@ -50,8 +51,69 @@ def Cxx_TodoExprOp : Cxx_Op<"todo.expr"> {
   ];
 }
 
-def Cxx_TodoStmtOp : Cxx_Op<"todo.stmt"> {
+def TodoStmtOp : Cxx_Op<"todo.stmt"> {
   let arguments = (ins StrAttr:$message);
   let results = (outs);
   let assemblyFormat = "$message attr-dict";
 }
+
+def ToBoolOp : Cxx_Op<"to.bool"> {
+  let arguments = (ins Cxx_ExprType:$value);
+  let results = (outs I1:$result);
+  let assemblyFormat = "`(` $value `)` attr-dict `:` type($result)";
+}
+
+def ImplicitCastOp : Cxx_Op<"implicit.cast"> {
+  let arguments = (ins StrAttr:$cast, Cxx_ExprType:$value);
+  let results = (outs Cxx_ExprType:$result);
+  let assemblyFormat = "$cast `(` $value `)` attr-dict `:` type($result)";
+  let builders = [
+    OpBuilder<(ins "llvm::StringRef":$cast, "mlir::Value":$value),
+      [{ build($_builder, $_state, $_builder.getType<ExprType>(), cast, value); }]>,
+  ];
+}
+
+def IntLiteralOp : Cxx_Op<"int.literal"> {
+  let arguments = (ins I64Attr:$value);
+  let results = (outs Cxx_ExprType:$result);
+  let assemblyFormat = "$value attr-dict `:` type($result)";
+  let builders = [
+    OpBuilder<(ins "int64_t":$value),
+      [{ build($_builder, $_state, $_builder.getType<ExprType>(), value); }]>,
+  ];
+}
+
+def IdOp : Cxx_Op<"id"> {
+  let arguments = (ins StrAttr:$name);
+  let results = (outs Cxx_ExprType:$result);
+  let assemblyFormat = "$name attr-dict `:` type($result)";
+  let builders = [
+    OpBuilder<(ins "llvm::StringRef":$name),
+      [{ build($_builder, $_state, $_builder.getType<ExprType>(), name); }]>,
+  ];
+}
+
+def BinOp : Cxx_Op<"binary"> {
+  let arguments = (ins StrAttr:$op, Cxx_ExprType:$lhs, Cxx_ExprType:$rhs);
+  let results = (outs Cxx_ExprType:$result);
+  let assemblyFormat = "`op` $op `(` $lhs `,` $rhs `)` attr-dict `:` type($result)";
+  let builders = [
+    OpBuilder<(ins "llvm::StringRef":$op, "mlir::Value":$lhs, "mlir::Value":$rhs),
+      [{ build($_builder, $_state, $_builder.getType<ExprType>(), op, lhs, rhs); }]>,
+  ];
+}
+
+def CallOp : Cxx_Op<"call"> {
+  let arguments = (ins Cxx_ExprType:$callee, Variadic<AnyType>:$arguments);
+  let results = (outs Cxx_ExprType:$result);
+  let assemblyFormat = "$callee `(` $arguments `:` type($arguments) `)` attr-dict `:` type($result)";
+  let builders = [
+    OpBuilder<(ins "mlir::Value":$callee, "mlir::ValueRange":$arguments),
+      [{ build($_builder, $_state, $_builder.getType<ExprType>(), callee, arguments); }]>,
+  ];
+}
+
+def ReturnOp : Cxx_Op<"return"> {
+  let arguments = (ins Optional<Cxx_ExprType>:$value);
+  let results = (outs);
+}