[mlir][emitc] Add literal constant.

[jpienaar]

Summary

A literal constant is not emitted as a variable but rather printed inline. The
form used is same as the Attribute emission form.

Currently this reuses the emit attribute method wherever name is queried. This
works for the use cases under consideration but could fail in cases where the
emission should be deferred. Addressing that requires some refactoring.

[marbre]

Could you also add tests to test/Dialect/EmitC/ops.mlir and maybe also to test/Dialect/EmitC/invalid_ops.mlir?

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

206

constant op should be literal op here.

[simon-camp]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

778

I think this would need to emit a cast expression like the printFloat function below (at least when called from a LiteralOp). Otherwise the exact type of the literal gets lost. The compiler might for example chose an unexpected function overload if a literal is used as an operand of an emitc.call op.

[simon-camp]

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

84

We should disallow LiteralOps too here.

207

Wouldn't the AllTypesMatch constraint catch the type mismatch? The value can't be an OpaqueAttr anyhow here, because it is not a TypedAttr.

[jpienaar]

mlir/lib/Target/Cpp/TranslateToCpp.cpp

778

I started doing this and then wondered if I should go the opposite way: allow literal to take a string and return a different type. Make it just be a literal, have the lowering dictate the form and the type is to conform with the MLIR type system only. Then one could do things like

%20 = emitc.literal "M_PI" : f32

(no automatic casting or the like)

[jpienaar]

Switch to string literal varient

[jpienaar]

Update comment and test

[marbre]

Thanks for updating the PR @jpienaar.

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

207

Any comment on this?

[jpienaar]

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

207

Oh I removed this, but it would have yes. The attribute is now pure string and doesn't have a type associated beyond the op type to verify.

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

def EmitC_IncludeOp
   }];
   let arguments = (ins
     Arg<StrAttr, "source file to include">:$include,
     UnitAttr:$is_standard_include
   );
   let hasCustomAssemblyFormat = 1;
 }
 
+def EmitC_LiteralOp : EmitC_Op<"literal", [Pure]> {
+  let summary = "Literal operation";
+  let description = [{
+    The `literal` operation produces an SSA value equal to some constant
+    specified by an attribute.
+  }];
+
+  let arguments = (ins StrAttr:$value);
+  let results = (outs AnyType:$result);
+
+  let hasVerifier = 1;
+  let assemblyFormat = "$value attr-dict `:` type($result)";
+}
+
 def EmitC_MulOp : EmitC_BinaryArithOp<"mul", []> {
   let summary = "Multiplication operation";
   let description = [{
     With the `mul` operation the arithmetic operator * (multiplication) can
     be applied.
 
     Example:
 

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

LogicalResult ApplyOp::verify() {
   if (applicableOperatorStr.empty())
     return emitOpError("applicable operator must not be empty");
 
   // Only `*` and `&` are supported.
   if (applicableOperatorStr != "&" && applicableOperatorStr != "*")
     return emitOpError("applicable operator is illegal");
 
   Operation *op = getOperand().getDefiningOp();
   if (op && dyn_cast<ConstantOp>(op))
     return emitOpError("cannot apply to constant");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CastOp
 //===----------------------------------------------------------------------===//
ParseResult IncludeOp::parse(OpAsmParser &parser, OperationState &result) {
   if (standardInclude)
     result.addAttribute("is_standard_include",
                         UnitAttr::get(parser.getContext()));
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// LiteralOp
+//===----------------------------------------------------------------------===//
+
+/// The literal op requires a non-empty value.
+LogicalResult emitc::LiteralOp::verify() {
+  if (getValue().empty())
+    return emitOpError() << "value must not be empty";
+  return success();
+}
+//===----------------------------------------------------------------------===//
 // SubOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SubOp::verify() {
   Type lhsType = getLhs().getType();
   Type rhsType = getRhs().getType();
   Type resultType = getResult().getType();
 
   if (rhsType.isa<emitc::PointerType>() && !lhsType.isa<emitc::PointerType>())
     return emitOpError("rhs can only be a pointer if lhs is a pointer");
 
   if (lhsType.isa<emitc::PointerType>() &&
       !rhsType.isa<IntegerType, emitc::OpaqueType, emitc::PointerType>())
     return emitOpError("requires that rhs is an integer, pointer or of opaque "
                        "type if lhs is a pointer");
 
   if (lhsType.isa<emitc::PointerType>() && rhsType.isa<emitc::PointerType>() &&
       !resultType.isa<IntegerType, emitc::OpaqueType>())
     return emitOpError("requires that the result is an integer or of opaque "
                        "type if lhs and rhs are pointers");
-
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // VariableOp
 //===----------------------------------------------------------------------===//
 
 /// The variable op requires that the attribute's type matches the return type.

mlir/lib/Target/Cpp/TranslateToCpp.cpp

if (!block.hasNoPredecessors()) {
         return failure();
     }
     for (Operation &op : block.getOperations()) {
       // When generating code for an scf.if or cf.cond_br op no semicolon needs
       // to be printed after the closing brace.
       // When generating code for an scf.for op, printing a trailing semicolon
       // is handled within the printOperation function.
       bool trailingSemicolon =
-          !isa<scf::IfOp, scf::ForOp, cf::CondBranchOp>(op);
+          !isa<cf::CondBranchOp, emitc::LiteralOp, scf::IfOp, scf::ForOp>(op);
 
       if (failed(emitter.emitOperation(
               op, /*trailingSemicolon=*/trailingSemicolon)))
         return failure();
     }
   }
   os.unindent() << "}\n";
   return success();
 }
 
 CppEmitter::CppEmitter(raw_ostream &os, bool declareVariablesAtTop)
     : os(os), declareVariablesAtTop(declareVariablesAtTop) {
   valueInScopeCount.push(0);
   labelInScopeCount.push(0);
 }
 
 /// Return the existing or a new name for a Value.
 StringRef CppEmitter::getOrCreateName(Value val) {
+  if (auto literal = dyn_cast_if_present<emitc::LiteralOp>(val.getDefiningOp()))
+    return literal.getValue();
   if (!valueMapper.count(val))
     valueMapper.insert(val, formatv("v{0}", ++valueInScopeCount.top()));
   return *valueMapper.begin(val);
 }
 
 /// Return the existing or a new label for a Block.
 StringRef CppEmitter::getOrCreateName(Block &block) {
   if (!blockMapper.count(&block))
auto printInt = [&](const APInt &val, bool isUnsigned) {
     if (val.getBitWidth() == 1) {
       if (val.getBoolValue())
         os << "true";
       else
         os << "false";
     } else {
       SmallString<128> strValue;
       val.toString(strValue, 10, !isUnsigned, false);
       os << strValue;
     }
   };
 
   auto printFloat = [&](const APFloat &val) {
     if (val.isFinite()) {
       SmallString<128> strValue;
       // Use default values of toString except don't truncate zeros.
       val.toString(strValue, 0, 0, false);
LogicalResult status =
           .Case<func::CallOp, func::ConstantOp, func::FuncOp, func::ReturnOp>(
               [&](auto op) { return printOperation(*this, op); })
           // SCF ops.
           .Case<scf::ForOp, scf::IfOp, scf::YieldOp>(
               [&](auto op) { return printOperation(*this, op); })
           // Arithmetic ops.
           .Case<arith::ConstantOp>(
               [&](auto op) { return printOperation(*this, op); })
+          .Case<emitc::LiteralOp>([&](auto op) { return success(); })
           .Default([&](Operation *) {
             return op.emitOpError("unable to find printer for op");
           });
 
   if (failed(status))
     return failure();
+
+  if (isa<emitc::LiteralOp>(op))
+    return success();
+
   os << (trailingSemicolon ? ";\n" : "\n");
   return success();
 }
 
 LogicalResult CppEmitter::emitType(Location loc, Type type) {
   if (auto iType = dyn_cast<IntegerType>(type)) {
     switch (iType.getWidth()) {
     case 1:

mlir/test/Target/Cpp/for.mlir

 // CPP-DECLTOP-NEXT: [[SN]] = add([[SI]], [[ITER]]);
 // CPP-DECLTOP-NEXT: [[PN]] = mul([[PI]], [[ITER]]);
 // CPP-DECLTOP-NEXT: [[SI]] = [[SN]];
 // CPP-DECLTOP-NEXT: [[PI]] = [[PN]];
 // CPP-DECLTOP-NEXT: }
 // CPP-DECLTOP-NEXT: [[SE]] = [[SI]];
 // CPP-DECLTOP-NEXT: [[PE]] = [[PI]];
 // CPP-DECLTOP-NEXT: return;
+
+func.func @test_for_yield_2() {
+  %start = emitc.literal "0" : index
+  %stop = emitc.literal "10" : index
+  %step = emitc.literal "1" : index
+
+  %s0 = emitc.literal "0" : i32
+  %p0 = emitc.literal "M_PI" : f32
+
+  %result:2 = scf.for %iter = %start to %stop step %step iter_args(%si = %s0, %pi = %p0) -> (i32, f32) {
+    %sn = emitc.call "add"(%si, %iter) : (i32, index) -> i32
+    %pn = emitc.call "mul"(%pi, %iter) : (f32, index) -> f32
+    scf.yield %sn, %pn : i32, f32
+  }
+
+  return
+}
+// CPP-DEFAULT: void test_for_yield_2() {
+// CPP-DEFAULT: float{{.*}}= M_PI
+// CPP-DEFAULT: for (size_t [[IN:.*]] = 0; [[IN]] < 10; [[IN]] += 1) {