Add MLX op handler for aten.bitwise_xor (#18931)

## Summary

- Add `BitwiseXorNode` to the MLX delegate schema, C++ runtime, Python
op handler, and tests
- Enables element-wise bitwise XOR for boolean and integer tensors via
`mlx::core::bitwise_xor`

Closes #18927

## Test plan

- [ ] `python -m executorch.backends.mlx.test.run_all_tests -k
bitwise_xor` passes both bool and int variants
- [ ] Existing MLX op tests remain passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

cc @metascroy

---------

Co-authored-by: Nanook <nanookclaw@users.noreply.github.com>
Co-authored-by: Scott Roy <161522778+metascroy@users.noreply.github.com>

Author: nanookclaw

backends/mlx/ops.py

@@ -53,6 +53,7 @@
     BitwiseAndNode,
     BitwiseInvertNode,
     BitwiseOrNode,
+    BitwiseXorNode,
     BroadcastToNode,
     CeilNode,
     ClipNode,
@@ -497,6 +498,12 @@ def _isnan_handler(P: MLXProgramBuilder, n: Node) -> Slot:
         "aten.bitwise_or",
         True,
     ),
+    (
+        [torch.ops.aten.bitwise_xor.Tensor, torch.ops.aten.bitwise_xor.Scalar],
+        BitwiseXorNode,
+        "aten.bitwise_xor",
+        True,
+    ),
     (
         [torch.ops.aten.lt.Tensor, torch.ops.aten.lt.Scalar],
         LessNode,

backends/mlx/runtime/MLXInterpreter.h

@@ -1422,6 +1422,15 @@ exec_bitwise_or(const BitwiseOrNode& n, ExecutionState& st, StreamOrDevice s) {
       n.out, bitwise_or(st.const_tensor_ref(n.a), st.const_tensor_ref(n.b), s));
 }
 
+inline void exec_bitwise_xor(
+    const BitwiseXorNode& n,
+    ExecutionState& st,
+    StreamOrDevice s) {
+  st.set_tensor(
+      n.out,
+      bitwise_xor(st.const_tensor_ref(n.a), st.const_tensor_ref(n.b), s));
+}
+
 inline void exec_tri(const TriNode& n, ExecutionState& st, StreamOrDevice s) {
   int rows = resolve_int(n.n, st);
   int cols = resolve_int(n.m, st);
@@ -2078,6 +2087,9 @@ class Interpreter {
       case OpCode::BITWISE_OR:
         ops::exec_bitwise_or(std::get<BitwiseOrNode>(instr.node), st, s);
         break;
+      case OpCode::BITWISE_XOR:
+        ops::exec_bitwise_xor(std::get<BitwiseXorNode>(instr.node), st, s);
+        break;
       case OpCode::TRI:
         ops::exec_tri(std::get<TriNode>(instr.node), st, s);
         break;

backends/mlx/serialization/schema.fbs

@@ -591,6 +591,12 @@ table BitwiseOrNode {
     out: Tid (required);
 }
 
+table BitwiseXorNode {
+    a: Tid (required);
+    b: Tid (required);
+    out: Tid (required);
+}
+
 // Triangular matrix ops
 table TriNode {
     out: Tid (required);
@@ -1144,7 +1150,8 @@ union OpNode {
     BitwiseInvertNode,
     RollNode,
     BitwiseAndNode,
-    BitwiseOrNode
+    BitwiseOrNode,
+    BitwiseXorNode
     // BC: Add new op nodes here (append only)
 }
 

backends/mlx/test/test_ops.py

@@ -4808,6 +4808,8 @@ def create_model(self) -> nn.Module:
     {"op_name": "bitwise_and_int",  "op_fn": torch.bitwise_and, "shapes": _SHAPES_3, "dtypes": [torch.int32, torch.int64], "input_fn_a": _int_input_fn(0, 256), "input_fn_b": _int_input_fn(0, 256)},
     {"op_name": "bitwise_or_bool",  "op_fn": torch.bitwise_or,  "shapes": _SHAPES_3, "dtypes": [torch.bool], "input_fn_a": _bool_input_fn(), "input_fn_b": _bool_input_fn()},
     {"op_name": "bitwise_or_int",   "op_fn": torch.bitwise_or,  "shapes": _SHAPES_3, "dtypes": [torch.int32, torch.int64], "input_fn_a": _int_input_fn(0, 256), "input_fn_b": _int_input_fn(0, 256)},
+    {"op_name": "bitwise_xor_bool", "op_fn": torch.bitwise_xor, "shapes": _SHAPES_3, "dtypes": [torch.bool], "input_fn_a": _bool_input_fn(), "input_fn_b": _bool_input_fn()},
+    {"op_name": "bitwise_xor_int",  "op_fn": torch.bitwise_xor, "shapes": _SHAPES_3, "dtypes": [torch.int32, torch.int64], "input_fn_a": _int_input_fn(0, 256), "input_fn_b": _int_input_fn(0, 256)},
     {"op_name": "logical_and",   "op_fn": torch.logical_and, "shapes": [(2, 3, 4), (10,), (4, 8)], "dtypes": [torch.bool], "input_fn_a": _bool_input_fn(), "input_fn_b": _bool_input_fn()},
     {"op_name": "logical_or",    "op_fn": torch.logical_or,  "shapes": [(2, 3, 4), (10,), (4, 8)], "dtypes": [torch.bool], "input_fn_a": _bool_input_fn(), "input_fn_b": _bool_input_fn()},
 ]
@@ -4910,6 +4912,51 @@ def create_model(self) -> nn.Module:
         return BitwiseOrScalarModel(self.scalar)
 
 
+class BitwiseXorScalarModel(nn.Module):
+    def __init__(self, scalar):
+        super().__init__()
+        self.scalar = scalar
+
+    def forward(self, a: torch.Tensor) -> torch.Tensor:
+        return torch.bitwise_xor(a, self.scalar)
+
+
+@register_test
+class BitwiseXorScalarTest(OpTestCase):
+    """Test case for aten.bitwise_xor op (Tensor_Scalar variant)."""
+
+    name = "bitwise_xor_scalar"
+
+    def __init__(
+        self,
+        shape: Tuple[int, ...],
+        dtype: torch.dtype,
+        scalar,
+    ):
+        self.shape = shape
+        self.dtype = dtype
+        self.scalar = scalar
+        shape_str = "x".join(str(s) for s in shape)
+        dtype_str = str(dtype).replace("torch.", "")
+        self.name = f"bitwise_xor_scalar_{shape_str}_{dtype_str}"
+
+    @classmethod
+    def get_test_configs(cls) -> List["BitwiseXorScalarTest"]:
+        return [
+            cls(shape=(16,), dtype=torch.bool, scalar=True),
+            cls(shape=(4, 4), dtype=torch.int32, scalar=7),
+            cls(shape=(2, 3, 4), dtype=torch.int64, scalar=13),
+        ]
+
+    def create_inputs(self) -> Tuple[torch.Tensor, ...]:
+        if self.dtype == torch.bool:
+            return _bool_input_fn()(self.shape, self.dtype)
+        return _int_input_fn(0, 256)(self.shape, self.dtype)
+
+    def create_model(self) -> nn.Module:
+        return BitwiseXorScalarModel(self.scalar)
+
+
 @register_test
 class PowerScalarTest(OpTestCase):
     """Test case for aten.pow op (Tensor_Scalar variant)."""