[mlir] Lower logical not, bitwise not and ternary expressions

Author: abinavpp

libsolidity/codegen/mlir/SolidityToMLIR.cpp

@@ -335,6 +335,9 @@ class SolidityToMLIRPass {
   /// Returns the mlir expression for the binary operation.
   mlir::Value genExpr(BinaryOperation const &binOp);
 
+  /// Returns the mlir expressions for the conditional (ternary) operation.
+  mlir::SmallVector<mlir::Value> genExprs(Conditional const &cond);
+
   /// Returns the mlir expression for the call.
   mlir::SmallVector<mlir::Value> genExprs(FunctionCall const &call);
 
@@ -770,6 +773,31 @@ mlir::Value SolidityToMLIRPass::genExpr(UnaryOperation const &unaryOp) {
         b.create<mlir::sol::ConstantOp>(loc, b.getIntegerAttr(mlirTy, 0));
     return genBinExpr(Token::Sub, zero, expr, loc);
   }
+  // Logical not
+  case Token::Not: {
+    mlir::Value expr = genRValExpr(unaryOp.subExpression());
+    mlir::Value zero = b.create<mlir::sol::ConstantOp>(
+        loc, b.getIntegerAttr(expr.getType(), 0));
+    return b.create<mlir::sol::CmpOp>(loc, mlir::sol::CmpPredicate::eq, expr,
+                                      zero);
+  }
+  // Bitwise not (~x == x ^ -1)
+  case Token::BitNot: {
+    mlir::Value expr = genRValExpr(unaryOp.subExpression());
+
+    // Convert bytes to int if needed.
+    if (auto bytesTy = mlir::dyn_cast<mlir::sol::BytesType>(expr.getType())) {
+      mlir::Type intTy =
+          b.getIntegerType(bytesTy.getSize() * 8, /*isSigned=*/false);
+      expr = genCast(expr, intTy);
+    }
+
+    auto intTy = mlir::cast<mlir::IntegerType>(expr.getType());
+    mlir::Value allOnes = b.create<mlir::sol::ConstantOp>(
+        loc,
+        b.getIntegerAttr(intTy, llvm::APInt::getAllOnes(intTy.getWidth())));
+    return b.create<mlir::sol::XorOp>(loc, expr, allOnes);
+  }
   default:
     break;
   }
@@ -831,6 +859,39 @@ mlir::Value SolidityToMLIRPass::genExpr(BinaryOperation const &binOp) {
   return genBinExpr(binOp.getOperator(), lhs, rhs, loc);
 }
 
+mlir::SmallVector<mlir::Value>
+SolidityToMLIRPass::genExprs(Conditional const &cond) {
+  mlir::Location loc = getLoc(cond);
+  mlir::Value condVal = genRValExpr(cond.condition());
+
+  // Get result types - could be single type or tuple.
+  mlir::SmallVector<mlir::Type> resTys;
+  if (TupleType const *tupleTy =
+          dynamic_cast<TupleType const *>(cond.annotation().type)) {
+    for (const Type *astTy : tupleTy->components())
+      resTys.push_back(getType(astTy));
+  } else {
+    resTys.push_back(getType(cond.annotation().type));
+  }
+
+  auto ifOp =
+      b.create<mlir::scf::IfOp>(loc, resTys, condVal, /*withElse=*/true);
+  mlir::OpBuilder::InsertionGuard guard(b);
+
+  // True branch
+  b.setInsertionPointToStart(&ifOp.getThenRegion().front());
+  mlir::SmallVector<mlir::Value> trueVals = genRValExprs(cond.trueExpression());
+  b.create<mlir::scf::YieldOp>(loc, trueVals);
+
+  // False branch
+  b.setInsertionPointToStart(&ifOp.getElseRegion().front());
+  mlir::SmallVector<mlir::Value> falseVals =
+      genRValExprs(cond.falseExpression());
+  b.create<mlir::scf::YieldOp>(loc, falseVals);
+
+  return ifOp.getResults();
+}
+
 mlir::Value SolidityToMLIRPass::genExpr(IndexAccess const &idxAcc) {
   mlir::Location loc = getLoc(idxAcc);
 
@@ -1776,6 +1837,13 @@ mlir::Value SolidityToMLIRPass::genLValExpr(Expression const &expr) {
     return {};
   }
 
+  // Conditional (ternary operator)
+  if (const auto *cond = dynamic_cast<Conditional const *>(&expr)) {
+    mlir::SmallVector<mlir::Value> exprs = genExprs(*cond);
+    assert(exprs.size() == 1);
+    return exprs[0];
+  }
+
   llvm_unreachable("NYI");
 }
 
@@ -1789,6 +1857,10 @@ SolidityToMLIRPass::genLValExprs(Expression const &expr) {
   if (const auto *call = dynamic_cast<FunctionCall const *>(&expr))
     return genExprs(*call);
 
+  // Conditional (ternary)
+  if (const auto *cond = dynamic_cast<Conditional const *>(&expr))
+    return genExprs(*cond);
+
   mlir::SmallVector<mlir::Value, 1> vals;
   vals.push_back(genLValExpr(expr));
   return vals;

test/libsolidity/semanticTests/mlir/arith.sol

@@ -77,6 +77,14 @@ contract C {
     return (a & b, a | b, a ^ b);
   }
 
+  function bnot(uint a) public returns (uint) {
+    return ~a;
+  }
+
+  function bnotBytes(bytes4 a) public pure returns (bytes4) {
+    return ~a;
+  }
+
   function addmod8(uint8 a, uint8 b, uint8 m) public returns (uint256) {
     return addmod(a, b, m);
   }
@@ -122,6 +130,8 @@ contract C {
 // shr8(uint8,uint256): 1, 8 -> 0
 // bit(int256,int256): 6, 3 -> 2, 7, 5
 // bit8(int8,int8): 6, 3 -> 2, 7, 5
+// bnot(uint256): 0 -> 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+// bnotBytes(bytes4): left(0x12345678) -> left(0xedcba987)
 // addmod8(uint8,uint8,uint8): 42, 25, 0 -> FAILURE, hex"4e487b71", 0x12
 // addmod8(uint8,uint8,uint8): 42, 25, 24 -> 19
 // addmod8(uint8,uint8,uint8): 200, 100, 7 -> 6

test/libsolidity/semanticTests/mlir/cf.sol

@@ -26,10 +26,22 @@ contract C {
     }
     return r;
   }
+
+  function h(bool c, uint a, uint b) public pure returns (uint) {
+    return c ? a : b;
+  }
+
+  function i(bool c, bytes4 a, bytes4 b) public pure returns (bytes4) {
+    return c ? a : b;
+  }
 }
 
 // ====
 // compileViaMlir: true
 // ----
 // f(uint256,uint256): 20, 10 -> 1024
 // g(uint256): 10 -> 22
+// h(bool,uint256,uint256): true, 10, 20 -> 10
+// h(bool,uint256,uint256): false, 10, 20 -> 20
+// i(bool,bytes4,bytes4): true, left(0x12345678), left(0xaabbccdd) -> left(0x12345678)
+// i(bool,bytes4,bytes4): false, left(0x12345678), left(0xaabbccdd) -> left(0xaabbccdd)

test/libsolidity/semanticTests/mlir/logical.sol

@@ -23,6 +23,10 @@ contract C {
     x = 0;
     return (a || s(b), x);
   }
+
+  function j(bool a) public pure returns (bool) {
+    return !a;
+  }
 }
 
 // ====
@@ -42,3 +46,5 @@ contract C {
 // i(bool,bool): 1, 0 -> true, 0
 // i(bool,bool): 0, 1 -> true, 1
 // i(bool,bool): 0, 0 -> false, 1
+// j(bool): 0 -> true
+// j(bool): 1 -> false