fix: fix ec point add

Covers zero point cases. See [here](https://github.com/kroma-network/tachyon/blob/e7b13063c6f110b9851655cca740ee62ffb41137/tachyon/math/elliptic_curves/short_weierstrass/jacobian_point_impl.h#L15-L27) for more info

Author: ashjeong

tests/Dialect/EllipticCurve/elliptic_curve_to_field_runner.mlir

@@ -114,9 +114,9 @@ func.func @test_ops_in_order() {
 // CHECK_TEST_OPS_IN_ORDER: [1, 10, 1]
 // CHECK_TEST_OPS_IN_ORDER: [1, 10, 1, 1]
 // CHECK_TEST_OPS_IN_ORDER: [1, 10]
-// CHECK_TEST_OPS_IN_ORDER: [0, 0, 0]
-// CHECK_TEST_OPS_IN_ORDER: [1, 1]
-// CHECK_TEST_OPS_IN_ORDER: [4, 3, 0, 0]
+// CHECK_TEST_OPS_IN_ORDER: [10, 5, 4]
+// CHECK_TEST_OPS_IN_ORDER: [2, 3]
+// CHECK_TEST_OPS_IN_ORDER: [2, 8, 1, 1]
 
 
 // CHECK-LABEL: @test_msm
@@ -164,5 +164,5 @@ func.func @test_msm() {
   return
 }
 
-// CHECK_TEST_MSM: [0, 0, 0]
-// CHECK_TEST_MSM: [0, 0, 0]
+// CHECK_TEST_MSM: [0, 3, 7]
+// CHECK_TEST_MSM: [0, 3, 7]

zkir/Dialect/EllipticCurve/Conversions/EllipticCurveToField/EllipticCurveToField.cpp

@@ -344,20 +344,67 @@ struct ConvertAdd : public OpConversionPattern<AddOp> {
       ConversionPatternRewriter &rewriter) const override {
     ImplicitLocOpBuilder b(op.getLoc(), rewriter);
 
+    Value p1 = op.getLhs();
+    Value p2 = op.getRhs();
+    ValueRange p1Coords = adaptor.getLhs();
+    ValueRange p2Coords = adaptor.getRhs();
+    Type p1Type = p1.getType();
+    Type p2Type = p2.getType();
     Type outputType = op.getOutput().getType();
-    ValueRange p1 = adaptor.getLhs();
-    ValueRange p2 = adaptor.getRhs();
-    SmallVector<Value> sum;
-
-    if (auto xyzzType = dyn_cast<XYZZType>(outputType)) {
-      sum = xyzzAdd(p1, p2, xyzzType.getCurve(), b);
-    } else if (auto jacobianType = dyn_cast<JacobianType>(outputType)) {
-      sum = jacobianAdd(p1, p2, jacobianType.getCurve(), b);
-    } else {
-      assert(false && "Unsupported point types for addition");
-    }
 
-    rewriter.replaceOpWithMultiple(op, {sum});
+    // check p1 == zero point
+    Value p1isZeroCmp = b.create<elliptic_curve::IsZeroOp>(p1);
+    auto p1IsZeroOp = b.create<scf::IfOp>(
+        p1isZeroCmp,
+        /*thenBuilder=*/
+        [&](OpBuilder &builder, Location loc) {
+          ImplicitLocOpBuilder b(loc, builder);
+          ValueRange retP2 = p2Coords;
+          if (isa<AffineType>(p2Type)) {
+            retP2 = {
+                b.create<elliptic_curve::ConvertPointTypeOp>(outputType, p2)};
+          }
+
+          b.create<scf::YieldOp>(retP2);
+        },
+        /*elseBuilder=*/
+        [&](OpBuilder &builder, Location loc) {
+          ImplicitLocOpBuilder b(loc, builder);
+
+          // check p2 == zero point
+          Value p2isZeroCmp = b.create<elliptic_curve::IsZeroOp>(p2);
+          auto p2IsZeroOp = b.create<scf::IfOp>(
+              p2isZeroCmp,
+              /*thenBuilder=*/
+              [&](OpBuilder &builder, Location loc) {
+                ImplicitLocOpBuilder b(loc, builder);
+                ValueRange retP1 = p1Coords;
+                if (isa<AffineType>(p1Type)) {
+                  retP1 = {b.create<elliptic_curve::ConvertPointTypeOp>(
+                      outputType, p1)};
+                }
+
+                b.create<scf::YieldOp>(retP1);
+              },
+              /*elseBuilder=*/
+              [&](OpBuilder &builder, Location loc) {
+                ImplicitLocOpBuilder b(loc, builder);
+                // run default add
+                SmallVector<Value> sum;
+                if (auto xyzzType = dyn_cast<XYZZType>(outputType)) {
+                  sum = xyzzAdd(p1Coords, p2Coords, xyzzType.getCurve(), b);
+                } else if (auto jacobianType =
+                               dyn_cast<JacobianType>(outputType)) {
+                  sum = jacobianAdd(p1Coords, p2Coords, jacobianType.getCurve(),
+                                    b);
+                } else {
+                  assert(false && "Unsupported point types for addition");
+                }
+                b.create<scf::YieldOp>(loc, sum);
+              });
+          b.create<scf::YieldOp>(p2IsZeroOp.getResults());
+        });
+    rewriter.replaceOpWithMultiple(op, {p1IsZeroOp.getResults()});
     return success();
   }
 };