Commit 29f41896ed9d99e82a88f4b63efa182ca0d2f93c | zig

lib/std/zig/Ast.zig+32

 @@ -396,6 +396,7 @@ pub fn firstToken(tree: Tree, node: Node.Index) TokenIndex {
         .assign_add,
         .assign_sub,
         .assign_bit_shift_left,
+        .assign_bit_shift_left_sat,
         .assign_bit_shift_right,
         .assign_bit_and,
         .assign_bit_xor,
 @@ -403,6 +404,9 @@ pub fn firstToken(tree: Tree, node: Node.Index) TokenIndex {
         .assign_mul_wrap,
         .assign_add_wrap,
         .assign_sub_wrap,
+        .assign_mul_sat,
+        .assign_add_sat,
+        .assign_sub_sat,
         .assign,
         .merge_error_sets,
         .mul,
 @@ -410,12 +414,16 @@ pub fn firstToken(tree: Tree, node: Node.Index) TokenIndex {
         .mod,
         .array_mult,
         .mul_wrap,
+        .mul_sat,
         .add,
         .sub,
         .array_cat,
         .add_wrap,
         .sub_wrap,
+        .add_sat,
+        .sub_sat,
         .bit_shift_left,
+        .bit_shift_left_sat,
         .bit_shift_right,
         .bit_and,
         .bit_xor,
 @@ -652,6 +660,7 @@ pub fn lastToken(tree: Tree, node: Node.Index) TokenIndex {
         .assign_add,
         .assign_sub,
         .assign_bit_shift_left,
+        .assign_bit_shift_left_sat,
         .assign_bit_shift_right,
         .assign_bit_and,
         .assign_bit_xor,
 @@ -659,6 +668,9 @@ pub fn lastToken(tree: Tree, node: Node.Index) TokenIndex {
         .assign_mul_wrap,
         .assign_add_wrap,
         .assign_sub_wrap,
+        .assign_mul_sat,
+        .assign_add_sat,
+        .assign_sub_sat,
         .assign,
         .merge_error_sets,
         .mul,
 @@ -666,12 +678,16 @@ pub fn lastToken(tree: Tree, node: Node.Index) TokenIndex {
         .mod,
         .array_mult,
         .mul_wrap,
+        .mul_sat,
         .add,
         .sub,
         .array_cat,
         .add_wrap,
         .sub_wrap,
+        .add_sat,
+        .sub_sat,
         .bit_shift_left,
+        .bit_shift_left_sat,
         .bit_shift_right,
         .bit_and,
         .bit_xor,
 @@ -2525,6 +2541,8 @@ pub const Node = struct {
         assign_sub,
         /// `lhs <<= rhs`. main_token is op.
         assign_bit_shift_left,
+        /// `lhs <<|= rhs`. main_token is op.
+        assign_bit_shift_left_sat,
         /// `lhs >>= rhs`. main_token is op.
         assign_bit_shift_right,
         /// `lhs &= rhs`. main_token is op.
 @@ -2539,6 +2557,12 @@ pub const Node = struct {
         assign_add_wrap,
         /// `lhs -%= rhs`. main_token is op.
         assign_sub_wrap,
+        /// `lhs *|= rhs`. main_token is op.
+        assign_mul_sat,
+        /// `lhs +|= rhs`. main_token is op.
+        assign_add_sat,
+        /// `lhs -|= rhs`. main_token is op.
+        assign_sub_sat,
         /// `lhs = rhs`. main_token is op.
         assign,
         /// `lhs || rhs`. main_token is the `||`.
 @@ -2553,6 +2577,8 @@ pub const Node = struct {
         array_mult,
         /// `lhs *% rhs`. main_token is the `*%`.
         mul_wrap,
+        /// `lhs *| rhs`. main_token is the `*%`.
+        mul_sat,
         /// `lhs + rhs`. main_token is the `+`.
         add,
         /// `lhs - rhs`. main_token is the `-`.
 @@ -2563,8 +2589,14 @@ pub const Node = struct {
         add_wrap,
         /// `lhs -% rhs`. main_token is the `-%`.
         sub_wrap,
+        /// `lhs +| rhs`. main_token is the `+|`.
+        add_sat,
+        /// `lhs -| rhs`. main_token is the `-|`.
+        sub_sat,
         /// `lhs << rhs`. main_token is the `<<`.
         bit_shift_left,
+        /// `lhs <<| rhs`. main_token is the `<<|`.
+        bit_shift_left_sat,
         /// `lhs >> rhs`. main_token is the `>>`.
         bit_shift_right,
         /// `lhs & rhs`. main_token is the `&`.

lib/std/zig/parse.zig+8

lib/std/zig/render.zig+8

 @@ -333,26 +333,32 @@ fn renderExpression(gpa: *Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
         .add,
         .add_wrap,
+        .add_sat,
         .array_cat,
         .array_mult,
         .assign,
         .assign_bit_and,
         .assign_bit_or,
         .assign_bit_shift_left,
+        .assign_bit_shift_left_sat,
         .assign_bit_shift_right,
         .assign_bit_xor,
         .assign_div,
         .assign_sub,
         .assign_sub_wrap,
+        .assign_sub_sat,
         .assign_mod,
         .assign_add,
         .assign_add_wrap,
+        .assign_add_sat,
         .assign_mul,
         .assign_mul_wrap,
+        .assign_mul_sat,
         .bang_equal,
         .bit_and,
         .bit_or,
         .bit_shift_left,
+        .bit_shift_left_sat,
         .bit_shift_right,
         .bit_xor,
         .bool_and,
 @@ -367,8 +373,10 @@ fn renderExpression(gpa: *Allocator, ais: *Ais, tree: Ast, node: Ast.Node.Index,
         .mod,
         .mul,
         .mul_wrap,
+        .mul_sat,
         .sub,
         .sub_wrap,
+        .sub_sat,
         .@"orelse",
         => {
             const infix = datas[node];

lib/std/zig/tokenizer.zig+79

 @@ -103,15 +103,21 @@ pub const Token = struct {
         plus_equal,
         plus_percent,
         plus_percent_equal,
+        plus_pipe,
+        plus_pipe_equal,
         minus,
         minus_equal,
         minus_percent,
         minus_percent_equal,
+        minus_pipe,
+        minus_pipe_equal,
         asterisk,
         asterisk_equal,
         asterisk_asterisk,
         asterisk_percent,
         asterisk_percent_equal,
+        asterisk_pipe,
+        asterisk_pipe_equal,
         arrow,
         colon,
         slash,
 @@ -124,6 +130,8 @@ pub const Token = struct {
         angle_bracket_left_equal,
         angle_bracket_angle_bracket_left,
         angle_bracket_angle_bracket_left_equal,
+        angle_bracket_angle_bracket_left_pipe,
+        angle_bracket_angle_bracket_left_pipe_equal,
         angle_bracket_right,
         angle_bracket_right_equal,
         angle_bracket_angle_bracket_right,
 @@ -227,15 +235,21 @@ pub const Token = struct {
                 .plus_equal => "+=",
                 .plus_percent => "+%",
                 .plus_percent_equal => "+%=",
+                .plus_pipe => "+|",
+                .plus_pipe_equal => "+|=",
                 .minus => "-",
                 .minus_equal => "-=",
                 .minus_percent => "-%",
                 .minus_percent_equal => "-%=",
+                .minus_pipe => "-|",
+                .minus_pipe_equal => "-|=",
                 .asterisk => "*",
                 .asterisk_equal => "*=",
                 .asterisk_asterisk => "**",
                 .asterisk_percent => "*%",
                 .asterisk_percent_equal => "*%=",
+                .asterisk_pipe => "*|",
+                .asterisk_pipe_equal => "*|=",
                 .arrow => "->",
                 .colon => ":",
                 .slash => "/",
 @@ -248,6 +262,8 @@ pub const Token = struct {
                 .angle_bracket_left_equal => "<=",
                 .angle_bracket_angle_bracket_left => "<<",
                 .angle_bracket_angle_bracket_left_equal => "<<=",
+                .angle_bracket_angle_bracket_left_pipe => "<<|",
+                .angle_bracket_angle_bracket_left_pipe_equal => "<<|=",
                 .angle_bracket_right => ">",
                 .angle_bracket_right_equal => ">=",
                 .angle_bracket_angle_bracket_right => ">>",
 @@ -352,8 +368,10 @@ pub const Tokenizer = struct {
         pipe,
         minus,
         minus_percent,
+        minus_pipe,
         asterisk,
         asterisk_percent,
+        asterisk_pipe,
         slash,
         line_comment_start,
         line_comment,
 @@ -382,8 +400,10 @@ pub const Tokenizer = struct {
         percent,
         plus,
         plus_percent,
+        plus_pipe,
         angle_bracket_left,
         angle_bracket_angle_bracket_left,
+        angle_bracket_angle_bracket_left_pipe,
         angle_bracket_right,
         angle_bracket_angle_bracket_right,
         period,
 @@ -584,6 +604,9 @@ pub const Tokenizer = struct {
                     '%' => {
                         state = .asterisk_percent;
                     },
+                    '|' => {
+                        state = .asterisk_pipe;
+                    },
                     else => {
                         result.tag = .asterisk;
                         break;
 @@ -602,6 +625,18 @@ pub const Tokenizer = struct {
                     },
                 },
+                .asterisk_pipe => switch (c) {
+                    '=' => {
+                        result.tag = .asterisk_pipe_equal;
+                        self.index += 1;
+                        break;
+                    },
+                    else => {
+                        result.tag = .asterisk_pipe;
+                        break;
+                    },
+                },
                 .percent => switch (c) {
                     '=' => {
                         result.tag = .percent_equal;
 @@ -628,6 +663,9 @@ pub const Tokenizer = struct {
                     '%' => {
                         state = .plus_percent;
                     },
+                    '|' => {
+                        state = .plus_pipe;
+                    },
                     else => {
                         result.tag = .plus;
                         break;
 @@ -646,6 +684,18 @@ pub const Tokenizer = struct {
                     },
                 },
+                .plus_pipe => switch (c) {
+                    '=' => {
+                        result.tag = .plus_pipe_equal;
+                        self.index += 1;
+                        break;
+                    },
+                    else => {
+                        result.tag = .plus_pipe;
+                        break;
+                    },
+                },
                 .caret => switch (c) {
                     '=' => {
                         result.tag = .caret_equal;
 @@ -903,6 +953,9 @@ pub const Tokenizer = struct {
                     '%' => {
                         state = .minus_percent;
                     },
+                    '|' => {
+                        state = .minus_pipe;
+                    },
                     else => {
                         result.tag = .minus;
                         break;
 @@ -920,6 +973,17 @@ pub const Tokenizer = struct {
                         break;
                     },
                 },
+                .minus_pipe => switch (c) {
+                    '=' => {
+                        result.tag = .minus_pipe_equal;
+                        self.index += 1;
+                        break;
+                    },
+                    else => {
+                        result.tag = .minus_pipe;
+                        break;
+                    },
+                },
                 .angle_bracket_left => switch (c) {
                     '<' => {
 @@ -942,12 +1006,27 @@ pub const Tokenizer = struct {
                         self.index += 1;
                         break;
                     },
+                    '|' => {
+                        result.tag = .angle_bracket_angle_bracket_left_pipe;
+                    },
                     else => {
                         result.tag = .angle_bracket_angle_bracket_left;
                         break;
                     },
                 },
+                .angle_bracket_angle_bracket_left_pipe => switch (c) {
+                    '=' => {
+                        result.tag = .angle_bracket_angle_bracket_left_pipe_equal;
+                        self.index += 1;
+                        break;
+                    },
+                    else => {
+                        result.tag = .angle_bracket_angle_bracket_left_pipe;
+                        break;
+                    },
+                },
                 .angle_bracket_right => switch (c) {
                     '>' => {
                         state = .angle_bracket_angle_bracket_right;

src/Air.zig+22

 @@ -44,6 +44,11 @@ pub const Inst = struct {
         /// is the same as both operands.
         /// Uses the `bin_op` field.
         addwrap,
+        /// Saturating integer addition.
+        /// Both operands are guaranteed to be the same type, and the result type
+        /// is the same as both operands.
+        /// Uses the `bin_op` field.
+        addsat,
         /// Float or integer subtraction. For integers, wrapping is undefined behavior.
         /// Both operands are guaranteed to be the same type, and the result type
         /// is the same as both operands.
 @@ -54,6 +59,11 @@ pub const Inst = struct {
         /// is the same as both operands.
         /// Uses the `bin_op` field.
         subwrap,
+        /// Saturating integer subtraction.
+        /// Both operands are guaranteed to be the same type, and the result type
+        /// is the same as both operands.
+        /// Uses the `bin_op` field.
+        subsat,
         /// Float or integer multiplication. For integers, wrapping is undefined behavior.
         /// Both operands are guaranteed to be the same type, and the result type
         /// is the same as both operands.
 @@ -64,6 +74,11 @@ pub const Inst = struct {
         /// is the same as both operands.
         /// Uses the `bin_op` field.
         mulwrap,
+        /// Saturating integer multiplication.
+        /// Both operands are guaranteed to be the same type, and the result type
+        /// is the same as both operands.
+        /// Uses the `bin_op` field.
+        mulsat,
         /// Integer or float division. For integers, wrapping is undefined behavior.
         /// Both operands are guaranteed to be the same type, and the result type
         /// is the same as both operands.
 @@ -110,6 +125,9 @@ pub const Inst = struct {
         /// Shift left. `<<`
         /// Uses the `bin_op` field.
         shl,
+        /// Shift left saturating. `<<|`
+        /// Uses the `bin_op` field.
+        shl_sat,
         /// Bitwise XOR. `^`
         /// Uses the `bin_op` field.
         xor,
 @@ -568,10 +586,13 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .add,
         .addwrap,
+        .addsat,
         .sub,
         .subwrap,
+        .subsat,
         .mul,
         .mulwrap,
+        .mulsat,
         .div,
         .rem,
         .mod,
 @@ -582,6 +603,7 @@ pub fn typeOfIndex(air: Air, inst: Air.Inst.Index) Type {
         .ptr_sub,
         .shr,
         .shl,
+        .shl_sat,
         => return air.typeOf(datas[inst].bin_op.lhs),
         .cmp_lt,

src/AstGen.zig+122-2

 @@ -318,27 +318,35 @@ fn lvalExpr(gz: *GenZir, scope: *Scope, node: Ast.Node.Index) InnerError!Zir.Ins
         .assign_bit_and,
         .assign_bit_or,
         .assign_bit_shift_left,
+        .assign_bit_shift_left_sat,
         .assign_bit_shift_right,
         .assign_bit_xor,
         .assign_div,
         .assign_sub,
         .assign_sub_wrap,
+        .assign_sub_sat,
         .assign_mod,
         .assign_add,
         .assign_add_wrap,
+        .assign_add_sat,
         .assign_mul,
         .assign_mul_wrap,
+        .assign_mul_sat,
         .add,
         .add_wrap,
+        .add_sat,
         .sub,
         .sub_wrap,
+        .sub_sat,
         .mul,
         .mul_wrap,
+        .mul_sat,
         .div,
         .mod,
         .bit_and,
         .bit_or,
         .bit_shift_left,
+        .bit_shift_left_sat,
         .bit_shift_right,
         .bit_xor,
         .bang_equal,
 @@ -526,6 +534,10 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
             try assignShift(gz, scope, node, .shl);
             return rvalue(gz, rl, .void_value, node);
         },
+        .assign_bit_shift_left_sat => {
+            try assignBinOpExt(gz, scope, node, .shl_with_saturation);
+            return rvalue(gz, rl, .void_value, node);
+        },
         .assign_bit_shift_right => {
             try assignShift(gz, scope, node, .shr);
             return rvalue(gz, rl, .void_value, node);
 @@ -555,6 +567,10 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
             try assignOp(gz, scope, node, .subwrap);
             return rvalue(gz, rl, .void_value, node);
         },
+        .assign_sub_sat => {
+            try assignBinOpExt(gz, scope, node, .sub_with_saturation);
+            return rvalue(gz, rl, .void_value, node);
+        },
         .assign_mod => {
             try assignOp(gz, scope, node, .mod_rem);
             return rvalue(gz, rl, .void_value, node);
 @@ -567,6 +583,10 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
             try assignOp(gz, scope, node, .addwrap);
             return rvalue(gz, rl, .void_value, node);
         },
+        .assign_add_sat => {
+            try assignBinOpExt(gz, scope, node, .add_with_saturation);
+            return rvalue(gz, rl, .void_value, node);
+        },
         .assign_mul => {
             try assignOp(gz, scope, node, .mul);
             return rvalue(gz, rl, .void_value, node);
 @@ -575,17 +595,25 @@ fn expr(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerEr
             try assignOp(gz, scope, node, .mulwrap);
             return rvalue(gz, rl, .void_value, node);
         },
+        .assign_mul_sat => {
+            try assignBinOpExt(gz, scope, node, .mul_with_saturation);
+            return rvalue(gz, rl, .void_value, node);
+        },
         // zig fmt: off
-        .bit_shift_left  => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shl),
+        .bit_shift_left     => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shl),
-        .bit_shift_right => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shr),
+        .bit_shift_left_sat => return binOpExt(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shl_with_saturation),
+        .bit_shift_right    => return shiftOp(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .shr),
         .add      => return simpleBinOp(gz, scope, rl, node, .add),
         .add_wrap => return simpleBinOp(gz, scope, rl, node, .addwrap),
+        .add_sat  => return binOpExt(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .add_with_saturation),
         .sub      => return simpleBinOp(gz, scope, rl, node, .sub),
         .sub_wrap => return simpleBinOp(gz, scope, rl, node, .subwrap),
+        .sub_sat  => return binOpExt(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .sub_with_saturation),
         .mul      => return simpleBinOp(gz, scope, rl, node, .mul),
         .mul_wrap => return simpleBinOp(gz, scope, rl, node, .mulwrap),
+        .mul_sat  => return binOpExt(gz, scope, rl, node, node_datas[node].lhs, node_datas[node].rhs, .mul_with_saturation),
         .div      => return simpleBinOp(gz, scope, rl, node, .div),
         .mod      => return simpleBinOp(gz, scope, rl, node, .mod_rem),
         .bit_and  => {
 @@ -2685,6 +2713,31 @@ fn assignOp(
     _ = try gz.addBin(.store, lhs_ptr, result);
 }
+// TODO: is there an existing method to accomplish this?
+// TODO: likely rename this to indicate rhs type coercion or add more params to make it more general
+fn assignBinOpExt(
+    gz: *GenZir,
+    scope: *Scope,
+    infix_node: Ast.Node.Index,
+    op_inst_tag: Zir.Inst.Extended,
+) InnerError!void {
+    try emitDbgNode(gz, infix_node);
+    const astgen = gz.astgen;
+    const tree = astgen.tree;
+    const node_datas = tree.nodes.items(.data);
+    const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
+    const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
+    const lhs_type = try gz.addUnNode(.typeof, lhs, infix_node);
+    const rhs = try expr(gz, scope, .{ .coerced_ty = lhs_type }, node_datas[infix_node].rhs);
+    const result = try gz.addExtendedPayload(op_inst_tag, Zir.Inst.BinNode{
+        .node = gz.nodeIndexToRelative(infix_node),
+        .lhs = lhs,
+        .rhs = rhs,
+    });
+    _ = try gz.addBin(.store, lhs_ptr, result);
+}
 fn assignShift(
     gz: *GenZir,
     scope: *Scope,
 @@ -2708,6 +2761,29 @@ fn assignShift(
     _ = try gz.addBin(.store, lhs_ptr, result);
 }
+fn assignShiftSat(
+    gz: *GenZir,
+    scope: *Scope,
+    infix_node: ast.Node.Index,
+    op_inst_tag: Zir.Inst.Tag,
+) InnerError!void {
+    try emitDbgNode(gz, infix_node);
+    const astgen = gz.astgen;
+    const tree = astgen.tree;
+    const node_datas = tree.nodes.items(.data);
+    const lhs_ptr = try lvalExpr(gz, scope, node_datas[infix_node].lhs);
+    const lhs = try gz.addUnNode(.load, lhs_ptr, infix_node);
+    const rhs_type = try gz.addUnNode(.typeof, lhs, infix_node);
+    const rhs = try expr(gz, scope, .{ .ty = rhs_type }, node_datas[infix_node].rhs);
+    const result = try gz.addPlNode(op_inst_tag, infix_node, Zir.Inst.Bin{
+        .lhs = lhs,
+        .rhs = rhs,
+    });
+    _ = try gz.addBin(.store, lhs_ptr, result);
+}
 fn boolNot(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
     const astgen = gz.astgen;
     const tree = astgen.tree;
 @@ -7827,6 +7903,26 @@ fn shiftOp(
     return rvalue(gz, rl, result, node);
 }
+// TODO: is there an existing way to do this?
+// TODO: likely rename this to reflect result_loc == .none or add more params to make it more general
+fn binOpExt(
+    gz: *GenZir,
+    scope: *Scope,
+    rl: ResultLoc,
+    node: Ast.Node.Index,
+    lhs_node: Ast.Node.Index,
+    rhs_node: Ast.Node.Index,
+    tag: Zir.Inst.Extended,
+) InnerError!Zir.Inst.Ref {
+    const lhs = try expr(gz, scope, .none, lhs_node);
+    const rhs = try expr(gz, scope, .none, rhs_node);
+    const result = try gz.addExtendedPayload(tag, Zir.Inst.Bin{
+        .lhs = lhs,
+        .rhs = rhs,
+    });
+    return rvalue(gz, rl, result, node);
+}
 fn cImport(
     gz: *GenZir,
     scope: *Scope,
 @@ -8119,26 +8215,32 @@ fn nodeMayNeedMemoryLocation(tree: *const Ast, start_node: Ast.Node.Index) bool
             .asm_simple,
             .add,
             .add_wrap,
+            .add_sat,
             .array_cat,
             .array_mult,
             .assign,
             .assign_bit_and,
             .assign_bit_or,
             .assign_bit_shift_left,
+            .assign_bit_shift_left_sat,
             .assign_bit_shift_right,
             .assign_bit_xor,
             .assign_div,
             .assign_sub,
             .assign_sub_wrap,
+            .assign_sub_sat,
             .assign_mod,
             .assign_add,
             .assign_add_wrap,
+            .assign_add_sat,
             .assign_mul,
             .assign_mul_wrap,
+            .assign_mul_sat,
             .bang_equal,
             .bit_and,
             .bit_or,
             .bit_shift_left,
+            .bit_shift_left_sat,
             .bit_shift_right,
             .bit_xor,
             .bool_and,
 @@ -8154,10 +8256,12 @@ fn nodeMayNeedMemoryLocation(tree: *const Ast, start_node: Ast.Node.Index) bool
             .mod,
             .mul,
             .mul_wrap,
+            .mul_sat,
             .switch_range,
             .field_access,
             .sub,
             .sub_wrap,
+            .sub_sat,
             .slice,
             .slice_open,
             .slice_sentinel,
 @@ -8352,26 +8456,32 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) enum { never
             .tagged_union_enum_tag_trailing,
             .add,
             .add_wrap,
+            .add_sat,
             .array_cat,
             .array_mult,
             .assign,
             .assign_bit_and,
             .assign_bit_or,
             .assign_bit_shift_left,
+            .assign_bit_shift_left_sat,
             .assign_bit_shift_right,
             .assign_bit_xor,
             .assign_div,
             .assign_sub,
             .assign_sub_wrap,
+            .assign_sub_sat,
             .assign_mod,
             .assign_add,
             .assign_add_wrap,
+            .assign_add_sat,
             .assign_mul,
             .assign_mul_wrap,
+            .assign_mul_sat,
             .bang_equal,
             .bit_and,
             .bit_or,
             .bit_shift_left,
+            .bit_shift_left_sat,
             .bit_shift_right,
             .bit_xor,
             .bool_and,
 @@ -8387,9 +8497,11 @@ fn nodeMayEvalToError(tree: *const Ast, start_node: Ast.Node.Index) enum { never
             .mod,
             .mul,
             .mul_wrap,
+            .mul_sat,
             .switch_range,
             .sub,
             .sub_wrap,
+            .sub_sat,
             .slice,
             .slice_open,
             .slice_sentinel,
 @@ -8524,26 +8636,32 @@ fn nodeImpliesRuntimeBits(tree: *const Ast, start_node: Ast.Node.Index) bool {
             .asm_simple,
             .add,
             .add_wrap,
+            .add_sat,
             .array_cat,
             .array_mult,
             .assign,
             .assign_bit_and,
             .assign_bit_or,
             .assign_bit_shift_left,
+            .assign_bit_shift_left_sat,
             .assign_bit_shift_right,
             .assign_bit_xor,
             .assign_div,
             .assign_sub,
             .assign_sub_wrap,
+            .assign_sub_sat,
             .assign_mod,
             .assign_add,
             .assign_add_wrap,
+            .assign_add_sat,
             .assign_mul,
             .assign_mul_wrap,
+            .assign_mul_sat,
             .bang_equal,
             .bit_and,
             .bit_or,
             .bit_shift_left,
+            .bit_shift_left_sat,
             .bit_shift_right,
             .bit_xor,
             .bool_and,
 @@ -8559,10 +8677,12 @@ fn nodeImpliesRuntimeBits(tree: *const Ast, start_node: Ast.Node.Index) bool {
             .mod,
             .mul,
             .mul_wrap,
+            .mul_sat,
             .switch_range,
             .field_access,
             .sub,
             .sub_wrap,
+            .sub_sat,
             .slice,
             .slice_open,
             .slice_sentinel,

src/Liveness.zig+4

 @@ -226,10 +226,13 @@ fn analyzeInst(
     switch (inst_tags[inst]) {
         .add,
         .addwrap,
+        .addsat,
         .sub,
         .subwrap,
+        .subsat,
         .mul,
         .mulwrap,
+        .mulsat,
         .div,
         .rem,
         .mod,
 @@ -252,6 +255,7 @@ fn analyzeInst(
         .ptr_elem_val,
         .ptr_ptr_elem_val,
         .shl,
+        .shl_sat,
         .shr,
         .atomic_store_unordered,
         .atomic_store_monotonic,

src/codegen.zig+12

 @@ -826,10 +826,13 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     // zig fmt: off
                     .add, .ptr_add => try self.airAdd(inst),
                     .addwrap       => try self.airAddWrap(inst),
+                    .addsat        => try self.airArithmeticOpSat(inst, "addsat"),
                     .sub, .ptr_sub => try self.airSub(inst),
                     .subwrap       => try self.airSubWrap(inst),
+                    .subsat        => try self.airArithmeticOpSat(inst, "subsat"),
                     .mul           => try self.airMul(inst),
                     .mulwrap       => try self.airMulWrap(inst),
+                    .mulsat        => try self.airArithmeticOpSat(inst, "mulsat"),
                     .div           => try self.airDiv(inst),
                     .rem           => try self.airRem(inst),
                     .mod           => try self.airMod(inst),
 @@ -848,6 +851,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
                     .xor      => try self.airXor(inst),
                     .shr      => try self.airShr(inst),
                     .shl      => try self.airShl(inst),
+                    .shl_sat  => try self.airArithmeticOpSat(inst, "shl_sat"),
                     .alloc           => try self.airAlloc(inst),
                     .arg             => try self.airArg(inst),
 @@ -1320,6 +1324,14 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
             return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
         }
+        fn airArithmeticOpSat(self: *Self, inst: Air.Inst.Index, comptime name: []const u8) !void {
+            const bin_op = self.air.instructions.items(.data)[inst].bin_op;
+            const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {
+                else => return self.fail("TODO implement " ++ name ++ " for {}", .{self.target.cpu.arch}),
+            };
+            return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
+        }
         fn airMul(self: *Self, inst: Air.Inst.Index) !void {
             const bin_op = self.air.instructions.items(.data)[inst].bin_op;
             const result: MCValue = if (self.liveness.isUnused(inst)) .dead else switch (arch) {

src/codegen/c.zig+3

 @@ -885,14 +885,17 @@ fn genBody(f: *Function, body: []const Air.Inst.Index) error{ AnalysisFail, OutO
             // that wrapping is UB.
             .add, .ptr_add => try airBinOp( f, inst, " + "),
             .addwrap       => try airWrapOp(f, inst, " + ", "addw_"),
+            .addsat        => return o.dg.fail("TODO: C backend: implement codegen for addsat", .{}),
             // TODO use a different strategy for sub that communicates to the optimizer
             // that wrapping is UB.
             .sub, .ptr_sub => try airBinOp( f, inst, " - "),
             .subwrap       => try airWrapOp(f, inst, " - ", "subw_"),
+            .subsat        => return o.dg.fail("TODO: C backend: implement codegen for subsat", .{}),
             // TODO use a different strategy for mul that communicates to the optimizer
             // that wrapping is UB.
             .mul           => try airBinOp( f, inst, " * "),
             .mulwrap       => try airWrapOp(f, inst, " * ", "mulw_"),
+            .mulsat        => return o.dg.fail("TODO: C backend: implement codegen for mulsat", .{}),
             // TODO use a different strategy for div that communicates to the optimizer
             // that wrapping is UB.
             .div           => try airBinOp( f, inst, " / "),

src/codegen/llvm.zig+49-17

 @@ -1236,12 +1236,15 @@ pub const FuncGen = struct {
         for (body) |inst| {
             const opt_value: ?*const llvm.Value = switch (air_tags[inst]) {
                 // zig fmt: off
-                .add     => try self.airAdd(inst, false),
+                .add     => try self.airAdd(inst, .standard),
-                .addwrap => try self.airAdd(inst, true),
+                .addwrap => try self.airAdd(inst, .wrapping),
-                .sub     => try self.airSub(inst, false),
+                .addsat  => try self.airAdd(inst, .saturated),
-                .subwrap => try self.airSub(inst, true),
+                .sub     => try self.airSub(inst, .standard),
-                .mul     => try self.airMul(inst, false),
+                .subwrap => try self.airSub(inst, .wrapping),
-                .mulwrap => try self.airMul(inst, true),
+                .subsat  => try self.airSub(inst, .saturated),
+                .mul     => try self.airMul(inst, .standard),
+                .mulwrap => try self.airMul(inst, .wrapping),
+                .mulsat  => try self.airMul(inst, .saturated),
                 .div     => try self.airDiv(inst),
                 .rem     => try self.airRem(inst),
                 .mod     => try self.airMod(inst),
 @@ -1252,7 +1255,8 @@ pub const FuncGen = struct {
                 .bit_or, .bool_or   => try self.airOr(inst),
                 .xor                => try self.airXor(inst),
-                .shl                => try self.airShl(inst),
+                .shl                => try self.airShl(inst, false),
+                .shl_sat             => try self.airShl(inst, true),
                 .shr                => try self.airShr(inst),
                 .cmp_eq  => try self.airCmp(inst, .eq),
 @@ -2024,7 +2028,8 @@ pub const FuncGen = struct {
         return self.todo("implement llvm codegen for 'airWrapErrUnionErr'", .{});
     }
-    fn airAdd(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
+    const ArithmeticType = enum { standard, wrapping, saturated };
+    fn airAdd(self: *FuncGen, inst: Air.Inst.Index, ty: ArithmeticType) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
 @@ -2033,13 +2038,20 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
-        if (inst_ty.isRuntimeFloat()) return self.builder.buildFAdd(lhs, rhs, "");
+        if (inst_ty.isFloat()) return self.builder.buildFAdd(lhs, rhs, "");
-        if (wrap) return self.builder.buildAdd(lhs, rhs, "");
+        if (ty == .wrapping)
+            return self.builder.buildAdd(lhs, rhs, "")
+        else if (ty == .saturated) {
+            if (inst_ty.isSignedInt())
+                return self.builder.buildSAddSat(lhs, rhs, "")
+            else
+                return self.builder.buildUAddSat(lhs, rhs, "");
+        }
         if (inst_ty.isSignedInt()) return self.builder.buildNSWAdd(lhs, rhs, "");
         return self.builder.buildNUWAdd(lhs, rhs, "");
     }
-    fn airSub(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
+    fn airSub(self: *FuncGen, inst: Air.Inst.Index, ty: ArithmeticType) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
 @@ -2048,13 +2060,20 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
-        if (inst_ty.isRuntimeFloat()) return self.builder.buildFSub(lhs, rhs, "");
+        if (inst_ty.isFloat()) return self.builder.buildFSub(lhs, rhs, "");
-        if (wrap) return self.builder.buildSub(lhs, rhs, "");
+        if (ty == .wrapping)
+            return self.builder.buildSub(lhs, rhs, "")
+        else if (ty == .saturated) {
+            if (inst_ty.isSignedInt())
+                return self.builder.buildSSubSat(lhs, rhs, "")
+            else
+                return self.builder.buildUSubSat(lhs, rhs, "");
+        }
         if (inst_ty.isSignedInt()) return self.builder.buildNSWSub(lhs, rhs, "");
         return self.builder.buildNUWSub(lhs, rhs, "");
     }
-    fn airMul(self: *FuncGen, inst: Air.Inst.Index, wrap: bool) !?*const llvm.Value {
+    fn airMul(self: *FuncGen, inst: Air.Inst.Index, ty: ArithmeticType) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
 @@ -2063,8 +2082,15 @@ pub const FuncGen = struct {
         const rhs = try self.resolveInst(bin_op.rhs);
         const inst_ty = self.air.typeOfIndex(inst);
-        if (inst_ty.isRuntimeFloat()) return self.builder.buildFMul(lhs, rhs, "");
+        if (inst_ty.isFloat()) return self.builder.buildFMul(lhs, rhs, "");
-        if (wrap) return self.builder.buildMul(lhs, rhs, "");
+        if (ty == .wrapping)
+            return self.builder.buildMul(lhs, rhs, "")
+        else if (ty == .saturated) {
+            if (inst_ty.isSignedInt())
+                return self.builder.buildSMulFixSat(lhs, rhs, "")
+            else
+                return self.builder.buildUMulFixSat(lhs, rhs, "");
+        }
         if (inst_ty.isSignedInt()) return self.builder.buildNSWMul(lhs, rhs, "");
         return self.builder.buildNUWMul(lhs, rhs, "");
     }
 @@ -2174,7 +2200,7 @@ pub const FuncGen = struct {
         return self.builder.buildXor(lhs, rhs, "");
     }
-    fn airShl(self: *FuncGen, inst: Air.Inst.Index) !?*const llvm.Value {
+    fn airShl(self: *FuncGen, inst: Air.Inst.Index, sat: bool) !?*const llvm.Value {
         if (self.liveness.isUnused(inst))
             return null;
         const bin_op = self.air.instructions.items(.data)[inst].bin_op;
 @@ -2186,6 +2212,12 @@ pub const FuncGen = struct {
             self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_type), "")
         else
             rhs;
+        if (sat) {
+            return if (lhs_type.isSignedInt())
+                self.builder.buildSShlSat(lhs, casted_rhs, "")
+            else
+                self.builder.buildUShlSat(lhs, casted_rhs, "");
+        }
         return self.builder.buildShl(lhs, casted_rhs, "");
     }

src/codegen/llvm/bindings.zig+24

...	@@ -397,6 +397,12 @@ pub const Builder = opaque {	...	@@ -397,6 +397,12 @@ pub const Builder = opaque {
397	pub const buildNUWAdd = LLVMBuildNUWAdd;	397	pub const buildNUWAdd = LLVMBuildNUWAdd;
398	extern fn LLVMBuildNUWAdd(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	398	extern fn LLVMBuildNUWAdd(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
399		399
		400	pub const buildSAddSat = ZigLLVMBuildSAddSat;
		401	extern fn ZigLLVMBuildSAddSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		402
		403	pub const buildUAddSat = ZigLLVMBuildUAddSat;
		404	extern fn ZigLLVMBuildUAddSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		405
400	pub const buildFSub = LLVMBuildFSub;	406	pub const buildFSub = LLVMBuildFSub;
401	extern fn LLVMBuildFSub(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	407	extern fn LLVMBuildFSub(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
402		408
...	@@ -409,6 +415,12 @@ pub const Builder = opaque {	...	@@ -409,6 +415,12 @@ pub const Builder = opaque {
409	pub const buildNUWSub = LLVMBuildNUWSub;	415	pub const buildNUWSub = LLVMBuildNUWSub;
410	extern fn LLVMBuildNUWSub(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	416	extern fn LLVMBuildNUWSub(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
411		417
		418	pub const buildSSubSat = ZigLLVMBuildSSubSat;
		419	extern fn ZigLLVMBuildSSubSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		420
		421	pub const buildUSubSat = ZigLLVMBuildUSubSat;
		422	extern fn ZigLLVMBuildUSubSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		423
412	pub const buildFMul = LLVMBuildFMul;	424	pub const buildFMul = LLVMBuildFMul;
413	extern fn LLVMBuildFMul(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	425	extern fn LLVMBuildFMul(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
414		426
...	@@ -421,6 +433,12 @@ pub const Builder = opaque {	...	@@ -421,6 +433,12 @@ pub const Builder = opaque {
421	pub const buildNUWMul = LLVMBuildNUWMul;	433	pub const buildNUWMul = LLVMBuildNUWMul;
422	extern fn LLVMBuildNUWMul(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	434	extern fn LLVMBuildNUWMul(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
423		435
		436	pub const buildSMulFixSat = ZigLLVMBuildSMulFixSat;
		437	extern fn ZigLLVMBuildSMulFixSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		438
		439	pub const buildUMulFixSat = ZigLLVMBuildUMulFixSat;
		440	extern fn ZigLLVMBuildUMulFixSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		441
424	pub const buildUDiv = LLVMBuildUDiv;	442	pub const buildUDiv = LLVMBuildUDiv;
425	extern fn LLVMBuildUDiv(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	443	extern fn LLVMBuildUDiv(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
426		444
...	@@ -451,6 +469,12 @@ pub const Builder = opaque {	...	@@ -451,6 +469,12 @@ pub const Builder = opaque {
451	pub const buildShl = LLVMBuildShl;	469	pub const buildShl = LLVMBuildShl;
452	extern fn LLVMBuildShl(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	470	extern fn LLVMBuildShl(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
453		471
		472	pub const buildSShlSat = ZigLLVMBuildSShlSat;
		473	extern fn ZigLLVMBuildSShlSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		474
		475	pub const buildUShlSat = ZigLLVMBuildUShlSat;
		476	extern fn ZigLLVMBuildUShlSat(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
		477
454	pub const buildOr = LLVMBuildOr;	478	pub const buildOr = LLVMBuildOr;
455	extern fn LLVMBuildOr(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;	479	extern fn LLVMBuildOr(const Builder, LHS: const Value, RHS: const Value, Name: [:0]const u8) *const Value;
456		480

src/print_air.zig+4

 @@ -104,10 +104,13 @@ const Writer = struct {
             .add,
             .addwrap,
+            .addsat,
             .sub,
             .subwrap,
+            .subsat,
             .mul,
             .mulwrap,
+            .mulsat,
             .div,
             .rem,
             .mod,
 @@ -130,6 +133,7 @@ const Writer = struct {
             .ptr_elem_val,
             .ptr_ptr_elem_val,
             .shl,
+            .shl_sat,
             .shr,
             .set_union_tag,
             => try w.writeBinOp(s, inst),

src/stage1/all_types.hpp+12-4

 @@ -812,14 +812,18 @@ enum BinOpType {
     BinOpTypeInvalid,
     BinOpTypeAssign,
     BinOpTypeAssignTimes,
+    BinOpTypeAssignTimesSat,
     BinOpTypeAssignTimesWrap,
     BinOpTypeAssignDiv,
     BinOpTypeAssignMod,
     BinOpTypeAssignPlus,
+    BinOpTypeAssignPlusSat,
     BinOpTypeAssignPlusWrap,
     BinOpTypeAssignMinus,
+    BinOpTypeAssignMinusSat,
     BinOpTypeAssignMinusWrap,
     BinOpTypeAssignBitShiftLeft,
+    BinOpTypeAssignBitShiftLeftSat,
     BinOpTypeAssignBitShiftRight,
     BinOpTypeAssignBitAnd,
     BinOpTypeAssignBitXor,
 @@ -836,12 +840,16 @@ enum BinOpType {
     BinOpTypeBinXor,
     BinOpTypeBinAnd,
     BinOpTypeBitShiftLeft,
+    BinOpTypeBitShiftLeftSat,
     BinOpTypeBitShiftRight,
     BinOpTypeAdd,
+    BinOpTypeAddSat,
     BinOpTypeAddWrap,
     BinOpTypeSub,
+    BinOpTypeSubSat,
     BinOpTypeSubWrap,
     BinOpTypeMult,
+    BinOpTypeMultSat,
     BinOpTypeMultWrap,
     BinOpTypeDiv,
     BinOpTypeMod,
 @@ -2958,10 +2966,10 @@ enum IrBinOp {
     IrBinOpArrayMult,
     IrBinOpMaximum,
     IrBinOpMinimum,
-    IrBinOpSatAdd,
+    IrBinOpAddSat,
-    IrBinOpSatSub,
+    IrBinOpSubSat,
-    IrBinOpSatMul,
+    IrBinOpMultSat,
-    IrBinOpSatShl,
+    IrBinOpShlSat,
 };
 struct Stage1ZirInstBinOp {

src/stage1/astgen.cpp+20-4

 @@ -3672,6 +3672,8 @@ static Stage1ZirInst *astgen_bin_op(Stage1AstGen *ag, Scope *scope, AstNode *nod
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpMult), lval, result_loc);
         case BinOpTypeAssignTimesWrap:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpMultWrap), lval, result_loc);
+        case BinOpTypeAssignTimesSat:
+            return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpMultSat), lval, result_loc);
         case BinOpTypeAssignDiv:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpDivUnspecified), lval, result_loc);
         case BinOpTypeAssignMod:
 @@ -3680,12 +3682,18 @@ static Stage1ZirInst *astgen_bin_op(Stage1AstGen *ag, Scope *scope, AstNode *nod
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpAdd), lval, result_loc);
         case BinOpTypeAssignPlusWrap:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpAddWrap), lval, result_loc);
+        case BinOpTypeAssignPlusSat:
+            return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpAddSat), lval, result_loc);
         case BinOpTypeAssignMinus:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpSub), lval, result_loc);
         case BinOpTypeAssignMinusWrap:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpSubWrap), lval, result_loc);
+        case BinOpTypeAssignMinusSat:
+            return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpSubSat), lval, result_loc);
         case BinOpTypeAssignBitShiftLeft:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpBitShiftLeftLossy), lval, result_loc);
+        case BinOpTypeAssignBitShiftLeftSat:
+            return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpShlSat), lval, result_loc);
         case BinOpTypeAssignBitShiftRight:
             return ir_lval_wrap(ag, scope, astgen_assign_op(ag, scope, node, IrBinOpBitShiftRightLossy), lval, result_loc);
         case BinOpTypeAssignBitAnd:
 @@ -3718,20 +3726,28 @@ static Stage1ZirInst *astgen_bin_op(Stage1AstGen *ag, Scope *scope, AstNode *nod
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpBinAnd), lval, result_loc);
         case BinOpTypeBitShiftLeft:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpBitShiftLeftLossy), lval, result_loc);
+        case BinOpTypeBitShiftLeftSat:
+            return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpShlSat), lval, result_loc);
         case BinOpTypeBitShiftRight:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpBitShiftRightLossy), lval, result_loc);
         case BinOpTypeAdd:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpAdd), lval, result_loc);
         case BinOpTypeAddWrap:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpAddWrap), lval, result_loc);
+        case BinOpTypeAddSat:
+            return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpAddSat), lval, result_loc);
         case BinOpTypeSub:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpSub), lval, result_loc);
         case BinOpTypeSubWrap:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpSubWrap), lval, result_loc);
+        case BinOpTypeSubSat:
+            return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpSubSat), lval, result_loc);
         case BinOpTypeMult:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpMult), lval, result_loc);
         case BinOpTypeMultWrap:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpMultWrap), lval, result_loc);
+        case BinOpTypeMultSat:
+            return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpMultSat), lval, result_loc);
         case BinOpTypeDiv:
             return ir_lval_wrap(ag, scope, astgen_bin_op_id(ag, scope, node, IrBinOpDivUnspecified), lval, result_loc);
         case BinOpTypeMod:
 @@ -4716,7 +4732,7 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 if (arg1_value == ag->codegen->invalid_inst_src)
                     return arg1_value;
-                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpSatAdd, arg0_value, arg1_value, true);
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpAddSat, arg0_value, arg1_value, true);
                 return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
             }
         case BuiltinFnIdSatSub:
 @@ -4731,7 +4747,7 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 if (arg1_value == ag->codegen->invalid_inst_src)
                     return arg1_value;
-                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpSatSub, arg0_value, arg1_value, true);
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpSubSat, arg0_value, arg1_value, true);
                 return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
             }
         case BuiltinFnIdSatMul:
 @@ -4746,7 +4762,7 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 if (arg1_value == ag->codegen->invalid_inst_src)
                     return arg1_value;
-                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpSatMul, arg0_value, arg1_value, true);
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpMultSat, arg0_value, arg1_value, true);
                 return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
             }
         case BuiltinFnIdSatShl:
 @@ -4761,7 +4777,7 @@ static Stage1ZirInst *astgen_builtin_fn_call(Stage1AstGen *ag, Scope *scope, Ast
                 if (arg1_value == ag->codegen->invalid_inst_src)
                     return arg1_value;
-                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpSatShl, arg0_value, arg1_value, true);
+                Stage1ZirInst *bin_op = ir_build_bin_op(ag, scope, node, IrBinOpShlSat, arg0_value, arg1_value, true);
                 return ir_lval_wrap(ag, scope, bin_op, lval, result_loc);
             }
         case BuiltinFnIdMemcpy:

src/stage1/codegen.cpp+4-4

...	@@ -3333,7 +3333,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,	...	@@ -3333,7 +3333,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,
3333	} else {	3333	} else {
3334	zig_unreachable();	3334	zig_unreachable();
3335	}	3335	}
3336	case IrBinOpSatAdd:	3336	case IrBinOpAddSat:
3337	if (scalar_type->id == ZigTypeIdInt) {	3337	if (scalar_type->id == ZigTypeIdInt) {
3338	if (scalar_type->data.integral.is_signed) {	3338	if (scalar_type->data.integral.is_signed) {
3339	return ZigLLVMBuildSAddSat(g->builder, op1_value, op2_value, "");	3339	return ZigLLVMBuildSAddSat(g->builder, op1_value, op2_value, "");
...	@@ -3343,7 +3343,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,	...	@@ -3343,7 +3343,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,
3343	} else {	3343	} else {
3344	zig_unreachable();	3344	zig_unreachable();
3345	}	3345	}
3346	case IrBinOpSatSub:	3346	case IrBinOpSubSat:
3347	if (scalar_type->id == ZigTypeIdInt) {	3347	if (scalar_type->id == ZigTypeIdInt) {
3348	if (scalar_type->data.integral.is_signed) {	3348	if (scalar_type->data.integral.is_signed) {
3349	return ZigLLVMBuildSSubSat(g->builder, op1_value, op2_value, "");	3349	return ZigLLVMBuildSSubSat(g->builder, op1_value, op2_value, "");
...	@@ -3353,7 +3353,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,	...	@@ -3353,7 +3353,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,
3353	} else {	3353	} else {
3354	zig_unreachable();	3354	zig_unreachable();
3355	}	3355	}
3356	case IrBinOpSatMul:	3356	case IrBinOpMultSat:
3357	if (scalar_type->id == ZigTypeIdInt) {	3357	if (scalar_type->id == ZigTypeIdInt) {
3358	if (scalar_type->data.integral.is_signed) {	3358	if (scalar_type->data.integral.is_signed) {
3359	return ZigLLVMBuildSMulFixSat(g->builder, op1_value, op2_value, "");	3359	return ZigLLVMBuildSMulFixSat(g->builder, op1_value, op2_value, "");
...	@@ -3363,7 +3363,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,	...	@@ -3363,7 +3363,7 @@ static LLVMValueRef ir_render_bin_op(CodeGen g, Stage1Air executable,
3363	} else {	3363	} else {
3364	zig_unreachable();	3364	zig_unreachable();
3365	}	3365	}
3366	case IrBinOpSatShl:	3366	case IrBinOpShlSat:
3367	if (scalar_type->id == ZigTypeIdInt) {	3367	if (scalar_type->id == ZigTypeIdInt) {
3368	if (scalar_type->data.integral.is_signed) {	3368	if (scalar_type->data.integral.is_signed) {
3369	return ZigLLVMBuildSShlSat(g->builder, op1_value, op2_value, "");	3369	return ZigLLVMBuildSShlSat(g->builder, op1_value, op2_value, "");

src/stage1/ir.cpp+12-12

...	@@ -9820,28 +9820,28 @@ static ErrorMsg ir_eval_math_op_scalar(IrAnalyze ira, Scope scope, AstNode s	...	@@ -9820,28 +9820,28 @@ static ErrorMsg ir_eval_math_op_scalar(IrAnalyze ira, Scope scope, AstNode s
9820	float_min(out_val, op1_val, op2_val);	9820	float_min(out_val, op1_val, op2_val);
9821	}	9821	}
9822	break;	9822	break;
9823	case IrBinOpSatAdd:	9823	case IrBinOpAddSat:
9824	if (is_int) {	9824	if (is_int) {
9825	bigint_add_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);	9825	bigint_add_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
9826	} else {	9826	} else {
9827	zig_unreachable();	9827	zig_unreachable();
9828	}	9828	}
9829	break;	9829	break;
9830	case IrBinOpSatSub:	9830	case IrBinOpSubSat:
9831	if (is_int) {	9831	if (is_int) {
9832	bigint_sub_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);	9832	bigint_sub_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
9833	} else {	9833	} else {
9834	zig_unreachable();	9834	zig_unreachable();
9835	}	9835	}
9836	break;	9836	break;
9837	case IrBinOpSatMul:	9837	case IrBinOpMultSat:
9838	if (is_int) {	9838	if (is_int) {
9839	bigint_mul_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);	9839	bigint_mul_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
9840	} else {	9840	} else {
9841	zig_unreachable();	9841	zig_unreachable();
9842	}	9842	}
9843	break;	9843	break;
9844	case IrBinOpSatShl:	9844	case IrBinOpShlSat:
9845	if (is_int) {	9845	if (is_int) {
9846	bigint_shl_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);	9846	bigint_shl_sat(&out_val->data.x_bigint, &op1_val->data.x_bigint, &op2_val->data.x_bigint, type_entry->data.integral.bit_count, type_entry->data.integral.is_signed);
9847	} else {	9847	} else {
...	@@ -10069,10 +10069,10 @@ static bool ok_float_op(IrBinOp op) {	...	@@ -10069,10 +10069,10 @@ static bool ok_float_op(IrBinOp op) {
10069	case IrBinOpBitShiftRightExact:	10069	case IrBinOpBitShiftRightExact:
10070	case IrBinOpAddWrap:	10070	case IrBinOpAddWrap:
10071	case IrBinOpSubWrap:	10071	case IrBinOpSubWrap:
10072	case IrBinOpSatAdd:	10072	case IrBinOpAddSat:
10073	case IrBinOpSatSub:	10073	case IrBinOpSubSat:
10074	case IrBinOpSatMul:	10074	case IrBinOpMultSat:
10075	case IrBinOpSatShl:	10075	case IrBinOpShlSat:
10076	case IrBinOpMultWrap:	10076	case IrBinOpMultWrap:
10077	case IrBinOpArrayCat:	10077	case IrBinOpArrayCat:
10078	case IrBinOpArrayMult:	10078	case IrBinOpArrayMult:
...	@@ -11046,10 +11046,10 @@ static Stage1AirInst ir_analyze_instruction_bin_op(IrAnalyze ira, Stage1ZirIns	...	@@ -11046,10 +11046,10 @@ static Stage1AirInst ir_analyze_instruction_bin_op(IrAnalyze ira, Stage1ZirIns
11046	case IrBinOpRemMod:	11046	case IrBinOpRemMod:
11047	case IrBinOpMaximum:	11047	case IrBinOpMaximum:
11048	case IrBinOpMinimum:	11048	case IrBinOpMinimum:
11049	case IrBinOpSatAdd:	11049	case IrBinOpAddSat:
11050	case IrBinOpSatSub:	11050	case IrBinOpSubSat:
11051	case IrBinOpSatMul:	11051	case IrBinOpMultSat:
11052	case IrBinOpSatShl:	11052	case IrBinOpShlSat:
11053	return ir_analyze_bin_op_math(ira, bin_op_instruction);	11053	return ir_analyze_bin_op_math(ira, bin_op_instruction);
11054	case IrBinOpArrayCat:	11054	case IrBinOpArrayCat:
11055	return ir_analyze_array_cat(ira, bin_op_instruction);	11055	return ir_analyze_array_cat(ira, bin_op_instruction);

src/stage1/ir_print.cpp+4-4

...	@@ -737,13 +737,13 @@ static const char *ir_bin_op_id_str(IrBinOp op_id) {	...	@@ -737,13 +737,13 @@ static const char *ir_bin_op_id_str(IrBinOp op_id) {
737	return "@maximum";	737	return "@maximum";
738	case IrBinOpMinimum:	738	case IrBinOpMinimum:
739	return "@minimum";	739	return "@minimum";
740	case IrBinOpSatAdd:	740	case IrBinOpAddSat:
741	return "@addWithSaturation";	741	return "@addWithSaturation";
742	case IrBinOpSatSub:	742	case IrBinOpSubSat:
743	return "@subWithSaturation";	743	return "@subWithSaturation";
744	case IrBinOpSatMul:	744	case IrBinOpMultSat:
745	return "@mulWithSaturation";	745	return "@mulWithSaturation";
746	case IrBinOpSatShl:	746	case IrBinOpShlSat:
747	return "@shlWithSaturation";	747	return "@shlWithSaturation";
748	}	748	}
749	zig_unreachable();	749	zig_unreachable();

src/stage1/parser.cpp+16

 @@ -2381,6 +2381,7 @@ static AstNode *ast_parse_switch_item(ParseContext *pc) {
 //      / PLUSEQUAL
 //      / MINUSEQUAL
 //      / LARROW2EQUAL
+//      / LARROW2PIPEEQUAL
 //      / RARROW2EQUAL
 //      / AMPERSANDEQUAL
 //      / CARETEQUAL
 @@ -2388,6 +2389,9 @@ static AstNode *ast_parse_switch_item(ParseContext *pc) {
 //      / ASTERISKPERCENTEQUAL
 //      / PLUSPERCENTEQUAL
 //      / MINUSPERCENTEQUAL
+//      / ASTERISKPIPEEQUAL
+//      / PLUSPIPEEQUAL
+//      / MINUSPIPEEQUAL
 //      / EQUAL
 static AstNode *ast_parse_assign_op(ParseContext *pc) {
     // In C, we have `T arr[N] = {[i] = T{}};` but it doesn't
 @@ -2396,17 +2400,21 @@ static AstNode *ast_parse_assign_op(ParseContext *pc) {
     table[TokenIdBitAndEq] = BinOpTypeAssignBitAnd;
     table[TokenIdBitOrEq] = BinOpTypeAssignBitOr;
     table[TokenIdBitShiftLeftEq] = BinOpTypeAssignBitShiftLeft;
+    table[TokenIdBitShiftLeftPipeEq] = BinOpTypeAssignBitShiftLeftSat;
     table[TokenIdBitShiftRightEq] = BinOpTypeAssignBitShiftRight;
     table[TokenIdBitXorEq] = BinOpTypeAssignBitXor;
     table[TokenIdDivEq] = BinOpTypeAssignDiv;
     table[TokenIdEq] = BinOpTypeAssign;
     table[TokenIdMinusEq] = BinOpTypeAssignMinus;
     table[TokenIdMinusPercentEq] = BinOpTypeAssignMinusWrap;
+    table[TokenIdMinusPipeEq] = BinOpTypeAssignMinusSat;
     table[TokenIdModEq] = BinOpTypeAssignMod;
     table[TokenIdPlusEq] = BinOpTypeAssignPlus;
     table[TokenIdPlusPercentEq] = BinOpTypeAssignPlusWrap;
+    table[TokenIdPlusPipeEq] = BinOpTypeAssignPlusSat;
     table[TokenIdTimesEq] = BinOpTypeAssignTimes;
     table[TokenIdTimesPercentEq] = BinOpTypeAssignTimesWrap;
+    table[TokenIdTimesPipeEq] = BinOpTypeAssignTimesSat;
     BinOpType op = table[pc->token_ids[pc->current_token]];
     if (op != BinOpTypeInvalid) {
 @@ -2483,10 +2491,12 @@ static AstNode *ast_parse_bitwise_op(ParseContext *pc) {
 // BitShiftOp
 //     <- LARROW2
+//      / LARROW2PIPE
 //      / RARROW2
 static AstNode *ast_parse_bit_shift_op(ParseContext *pc) {
     BinOpType table[TokenIdCount] = {};
     table[TokenIdBitShiftLeft] = BinOpTypeBitShiftLeft;
+    table[TokenIdBitShiftLeftPipe] = BinOpTypeBitShiftLeftSat;
     table[TokenIdBitShiftRight] = BinOpTypeBitShiftRight;
     BinOpType op = table[pc->token_ids[pc->current_token]];
 @@ -2506,6 +2516,8 @@ static AstNode *ast_parse_bit_shift_op(ParseContext *pc) {
 //      / PLUS2
 //      / PLUSPERCENT
 //      / MINUSPERCENT
+//      / PLUSPIPE
+//      / MINUSPIPE
 static AstNode *ast_parse_addition_op(ParseContext *pc) {
     BinOpType table[TokenIdCount] = {};
     table[TokenIdPlus] = BinOpTypeAdd;
 @@ -2513,6 +2525,8 @@ static AstNode *ast_parse_addition_op(ParseContext *pc) {
     table[TokenIdPlusPlus] = BinOpTypeArrayCat;
     table[TokenIdPlusPercent] = BinOpTypeAddWrap;
     table[TokenIdMinusPercent] = BinOpTypeSubWrap;
+    table[TokenIdPlusPipe] = BinOpTypeAddSat;
+    table[TokenIdMinusPipe] = BinOpTypeSubSat;
     BinOpType op = table[pc->token_ids[pc->current_token]];
     if (op != BinOpTypeInvalid) {
 @@ -2532,6 +2546,7 @@ static AstNode *ast_parse_addition_op(ParseContext *pc) {
 //      / PERCENT
 //      / ASTERISK2
 //      / ASTERISKPERCENT
+//      / ASTERISKPIPE
 static AstNode *ast_parse_multiply_op(ParseContext *pc) {
     BinOpType table[TokenIdCount] = {};
     table[TokenIdBarBar] = BinOpTypeMergeErrorSets;
 @@ -2540,6 +2555,7 @@ static AstNode *ast_parse_multiply_op(ParseContext *pc) {
     table[TokenIdPercent] = BinOpTypeMod;
     table[TokenIdStarStar] = BinOpTypeArrayMult;
     table[TokenIdTimesPercent] = BinOpTypeMultWrap;
+    table[TokenIdTimesPipe] = BinOpTypeMultSat;
     BinOpType op = table[pc->token_ids[pc->current_token]];
     if (op != BinOpTypeInvalid) {

src/stage1/tokenizer.cpp+85

...	@@ -226,8 +226,10 @@ enum TokenizeState {	...	@@ -226,8 +226,10 @@ enum TokenizeState {
226	TokenizeState_pipe,	226	TokenizeState_pipe,
227	TokenizeState_minus,	227	TokenizeState_minus,
228	TokenizeState_minus_percent,	228	TokenizeState_minus_percent,
		229	TokenizeState_minus_pipe,
229	TokenizeState_asterisk,	230	TokenizeState_asterisk,
230	TokenizeState_asterisk_percent,	231	TokenizeState_asterisk_percent,
		232	TokenizeState_asterisk_pipe,
231	TokenizeState_slash,	233	TokenizeState_slash,
232	TokenizeState_line_comment_start,	234	TokenizeState_line_comment_start,
233	TokenizeState_line_comment,	235	TokenizeState_line_comment,
...	@@ -257,8 +259,10 @@ enum TokenizeState {	...	@@ -257,8 +259,10 @@ enum TokenizeState {
257	TokenizeState_percent,	259	TokenizeState_percent,
258	TokenizeState_plus,	260	TokenizeState_plus,
259	TokenizeState_plus_percent,	261	TokenizeState_plus_percent,
		262	TokenizeState_plus_pipe,
260	TokenizeState_angle_bracket_left,	263	TokenizeState_angle_bracket_left,
261	TokenizeState_angle_bracket_angle_bracket_left,	264	TokenizeState_angle_bracket_angle_bracket_left,
		265	TokenizeState_angle_bracket_angle_bracket_left_pipe,
262	TokenizeState_angle_bracket_right,	266	TokenizeState_angle_bracket_right,
263	TokenizeState_angle_bracket_angle_bracket_right,	267	TokenizeState_angle_bracket_angle_bracket_right,
264	TokenizeState_period,	268	TokenizeState_period,
...	@@ -548,6 +552,9 @@ void tokenize(const char source, Tokenization out) {	...	@@ -548,6 +552,9 @@ void tokenize(const char source, Tokenization out) {
548	case '%':	552	case '%':
549	t.state = TokenizeState_asterisk_percent;	553	t.state = TokenizeState_asterisk_percent;
550	break;	554	break;
		555	case '\|':
		556	t.state = TokenizeState_asterisk_pipe;
		557	break;
551	default:	558	default:
552	t.state = TokenizeState_start;	559	t.state = TokenizeState_start;
553	continue;	560	continue;
...	@@ -568,6 +575,21 @@ void tokenize(const char source, Tokenization out) {	...	@@ -568,6 +575,21 @@ void tokenize(const char source, Tokenization out) {
568	continue;	575	continue;
569	}	576	}
570	break;	577	break;
		578	case TokenizeState_asterisk_pipe:
		579	switch (c) {
		580	case 0:
		581	t.out->ids.last() = TokenIdTimesPipe;
		582	goto eof;
		583	case '=':
		584	t.out->ids.last() = TokenIdTimesPipeEq;
		585	t.state = TokenizeState_start;
		586	break;
		587	default:
		588	t.out->ids.last() = TokenIdTimesPipe;
		589	t.state = TokenizeState_start;
		590	continue;
		591	}
		592	break;
571	case TokenizeState_percent:	593	case TokenizeState_percent:
572	switch (c) {	594	switch (c) {
573	case 0:	595	case 0:
...	@@ -596,6 +618,9 @@ void tokenize(const char source, Tokenization out) {	...	@@ -596,6 +618,9 @@ void tokenize(const char source, Tokenization out) {
596	case '%':	618	case '%':
597	t.state = TokenizeState_plus_percent;	619	t.state = TokenizeState_plus_percent;
598	break;	620	break;
		621	case '\|':
		622	t.state = TokenizeState_plus_pipe;
		623	break;
599	default:	624	default:
600	t.state = TokenizeState_start;	625	t.state = TokenizeState_start;
601	continue;	626	continue;
...	@@ -616,6 +641,21 @@ void tokenize(const char source, Tokenization out) {	...	@@ -616,6 +641,21 @@ void tokenize(const char source, Tokenization out) {
616	continue;	641	continue;
617	}	642	}
618	break;	643	break;
		644	case TokenizeState_plus_pipe:
		645	switch (c) {
		646	case 0:
		647	t.out->ids.last() = TokenIdPlusPipe;
		648	goto eof;
		649	case '=':
		650	t.out->ids.last() = TokenIdPlusPipeEq;
		651	t.state = TokenizeState_start;
		652	break;
		653	default:
		654	t.out->ids.last() = TokenIdPlusPipe;
		655	t.state = TokenizeState_start;
		656	continue;
		657	}
		658	break;
619	case TokenizeState_caret:	659	case TokenizeState_caret:
620	switch (c) {	660	switch (c) {
621	case 0:	661	case 0:
...	@@ -891,6 +931,9 @@ void tokenize(const char source, Tokenization out) {	...	@@ -891,6 +931,9 @@ void tokenize(const char source, Tokenization out) {
891	case '%':	931	case '%':
892	t.state = TokenizeState_minus_percent;	932	t.state = TokenizeState_minus_percent;
893	break;	933	break;
		934	case '\|':
		935	t.state = TokenizeState_minus_pipe;
		936	break;
894	default:	937	default:
895	t.state = TokenizeState_start;	938	t.state = TokenizeState_start;
896	continue;	939	continue;
...	@@ -911,6 +954,21 @@ void tokenize(const char source, Tokenization out) {	...	@@ -911,6 +954,21 @@ void tokenize(const char source, Tokenization out) {
911	continue;	954	continue;
912	}	955	}
913	break;	956	break;
		957	case TokenizeState_minus_pipe:
		958	switch (c) {
		959	case 0:
		960	t.out->ids.last() = TokenIdMinusPipe;
		961	goto eof;
		962	case '=':
		963	t.out->ids.last() = TokenIdMinusPipeEq;
		964	t.state = TokenizeState_start;
		965	break;
		966	default:
		967	t.out->ids.last() = TokenIdMinusPipe;
		968	t.state = TokenizeState_start;
		969	continue;
		970	}
		971	break;
914	case TokenizeState_angle_bracket_left:	972	case TokenizeState_angle_bracket_left:
915	switch (c) {	973	switch (c) {
916	case 0:	974	case 0:
...	@@ -936,12 +994,31 @@ void tokenize(const char source, Tokenization out) {	...	@@ -936,12 +994,31 @@ void tokenize(const char source, Tokenization out) {
936	t.out->ids.last() = TokenIdBitShiftLeftEq;	994	t.out->ids.last() = TokenIdBitShiftLeftEq;
937	t.state = TokenizeState_start;	995	t.state = TokenizeState_start;
938	break;	996	break;
		997	case '\|':
		998	// t.out->ids.last() = TokenIdBitShiftLeftPipe;
		999	t.state = TokenizeState_angle_bracket_angle_bracket_left_pipe;
		1000	break;
939	default:	1001	default:
940	t.out->ids.last() = TokenIdBitShiftLeft;	1002	t.out->ids.last() = TokenIdBitShiftLeft;
941	t.state = TokenizeState_start;	1003	t.state = TokenizeState_start;
942	continue;	1004	continue;
943	}	1005	}
944	break;	1006	break;
		1007	case TokenizeState_angle_bracket_angle_bracket_left_pipe:
		1008	switch (c) {
		1009	case 0:
		1010	t.out->ids.last() = TokenIdBitShiftLeftPipe;
		1011	goto eof;
		1012	case '=':
		1013	t.out->ids.last() = TokenIdBitShiftLeftPipeEq;
		1014	t.state = TokenizeState_start;
		1015	break;
		1016	default:
		1017	t.out->ids.last() = TokenIdBitShiftLeftPipe;
		1018	t.state = TokenizeState_start;
		1019	continue;
		1020	}
		1021	break;
945	case TokenizeState_angle_bracket_right:	1022	case TokenizeState_angle_bracket_right:
946	switch (c) {	1023	switch (c) {
947	case 0:	1024	case 0:
...	@@ -1437,6 +1514,8 @@ const char * token_name(TokenId id) {	...	@@ -1437,6 +1514,8 @@ const char * token_name(TokenId id) {
1437	case TokenIdBitOrEq: return "\|=";	1514	case TokenIdBitOrEq: return "\|=";
1438	case TokenIdBitShiftLeft: return "<<";	1515	case TokenIdBitShiftLeft: return "<<";
1439	case TokenIdBitShiftLeftEq: return "<<=";	1516	case TokenIdBitShiftLeftEq: return "<<=";
		1517	case TokenIdBitShiftLeftPipe: return "<<\|";
		1518	case TokenIdBitShiftLeftPipeEq: return "<<\|=";
1440	case TokenIdBitShiftRight: return ">>";	1519	case TokenIdBitShiftRight: return ">>";
1441	case TokenIdBitShiftRightEq: return ">>=";	1520	case TokenIdBitShiftRightEq: return ">>=";
1442	case TokenIdBitXorEq: return "^=";	1521	case TokenIdBitXorEq: return "^=";
...	@@ -1521,12 +1600,16 @@ const char * token_name(TokenId id) {	...	@@ -1521,12 +1600,16 @@ const char * token_name(TokenId id) {
1521	case TokenIdMinusEq: return "-=";	1600	case TokenIdMinusEq: return "-=";
1522	case TokenIdMinusPercent: return "-%";	1601	case TokenIdMinusPercent: return "-%";
1523	case TokenIdMinusPercentEq: return "-%=";	1602	case TokenIdMinusPercentEq: return "-%=";
		1603	case TokenIdMinusPipe: return "-\|";
		1604	case TokenIdMinusPipeEq: return "-\|=";
1524	case TokenIdModEq: return "%=";	1605	case TokenIdModEq: return "%=";
1525	case TokenIdPercent: return "%";	1606	case TokenIdPercent: return "%";
1526	case TokenIdPlus: return "+";	1607	case TokenIdPlus: return "+";
1527	case TokenIdPlusEq: return "+=";	1608	case TokenIdPlusEq: return "+=";
1528	case TokenIdPlusPercent: return "+%";	1609	case TokenIdPlusPercent: return "+%";
1529	case TokenIdPlusPercentEq: return "+%=";	1610	case TokenIdPlusPercentEq: return "+%=";
		1611	case TokenIdPlusPipe: return "+\|";
		1612	case TokenIdPlusPipeEq: return "+\|=";
1530	case TokenIdPlusPlus: return "++";	1613	case TokenIdPlusPlus: return "++";
1531	case TokenIdRBrace: return "}";	1614	case TokenIdRBrace: return "}";
1532	case TokenIdRBracket: return "]";	1615	case TokenIdRBracket: return "]";
...	@@ -1542,6 +1625,8 @@ const char * token_name(TokenId id) {	...	@@ -1542,6 +1625,8 @@ const char * token_name(TokenId id) {
1542	case TokenIdTimesEq: return "*=";	1625	case TokenIdTimesEq: return "*=";
1543	case TokenIdTimesPercent: return "*%";	1626	case TokenIdTimesPercent: return "*%";
1544	case TokenIdTimesPercentEq: return "*%=";	1627	case TokenIdTimesPercentEq: return "*%=";
		1628	case TokenIdTimesPipe: return "*\|";
		1629	case TokenIdTimesPipeEq: return "*\|=";
1545	case TokenIdBuiltin: return "Builtin";	1630	case TokenIdBuiltin: return "Builtin";
1546	case TokenIdCount:	1631	case TokenIdCount:
1547	zig_unreachable();	1632	zig_unreachable();

src/stage1/tokenizer.hpp+8

 @@ -23,6 +23,8 @@ enum TokenId : uint8_t {
     TokenIdBitOrEq,
     TokenIdBitShiftLeft,
     TokenIdBitShiftLeftEq,
+    TokenIdBitShiftLeftPipe,
+    TokenIdBitShiftLeftPipeEq,
     TokenIdBitShiftRight,
     TokenIdBitShiftRightEq,
     TokenIdBitXorEq,
 @@ -108,12 +110,16 @@ enum TokenId : uint8_t {
     TokenIdMinusEq,
     TokenIdMinusPercent,
     TokenIdMinusPercentEq,
+    TokenIdMinusPipe,
+    TokenIdMinusPipeEq,
     TokenIdModEq,
     TokenIdPercent,
     TokenIdPlus,
     TokenIdPlusEq,
     TokenIdPlusPercent,
     TokenIdPlusPercentEq,
+    TokenIdPlusPipe,
+    TokenIdPlusPipeEq,
     TokenIdPlusPlus,
     TokenIdRBrace,
     TokenIdRBracket,
 @@ -129,6 +135,8 @@ enum TokenId : uint8_t {
     TokenIdTimesEq,
     TokenIdTimesPercent,
     TokenIdTimesPercentEq,
+    TokenIdTimesPipe,
+    TokenIdTimesPipeEq,
     TokenIdCount,
 };

test/behavior/saturating_arithmetic.zig+28-7

...	@@ -11,13 +11,34 @@ fn testSaturatingOp(comptime op: Op, comptime T: type, test_data: [3]T) !void {	...	@@ -11,13 +11,34 @@ fn testSaturatingOp(comptime op: Op, comptime T: type, test_data: [3]T) !void {
11	const a = test_data[0];	11	const a = test_data[0];
12	const b = test_data[1];	12	const b = test_data[1];
13	const expected = test_data[2];	13	const expected = test_data[2];
14	const actual = switch (op) {	14	{
15	.add => @addWithSaturation(a, b),	15	const actual = switch (op) {
16	.sub => @subWithSaturation(a, b),	16	.add => @addWithSaturation(a, b),
17	.mul => @mulWithSaturation(a, b),	17	.sub => @subWithSaturation(a, b),
18	.shl => @shlWithSaturation(a, b),	18	.mul => @mulWithSaturation(a, b),
19	};	19	.shl => @shlWithSaturation(a, b),
20	try expectEqual(expected, actual);	20	};
		21	try expectEqual(expected, actual);
		22	}
		23	{
		24	const actual = switch (op) {
		25	.add => a +\| b,
		26	.sub => a -\| b,
		27	.mul => a *\| b,
		28	.shl => a <<\| b,
		29	};
		30	try expectEqual(expected, actual);
		31	}
		32	{
		33	var actual = a;
		34	switch (op) {
		35	.add => actual +\|= b,
		36	.sub => actual -\|= b,
		37	.mul => actual *\|= b,
		38	.shl => actual <<\|= b,
		39	}
		40	try expectEqual(expected, actual);
		41	}
21	}	42	}
22		43
23	test "@addWithSaturation" {	44	test "@addWithSaturation" {

author	Travis Staloch <twostepted@gmail.com> 2021-09-02 13:50:24-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-09-28 17:02:43-07:00
log	29f41896ed9d99e82a88f4b63efa182ca0d2f93c
tree	1e6eb1159df89f79b04f050da662653925c77b1c
parent	79bc5891c1c4cde0592fe1b10b6c9a85914155cf

...	@@ -1269,6 +1269,7 @@ const Parser = struct {	...	@@ -1269,6 +1269,7 @@ const Parser = struct {
1269	.plus_equal => .assign_add,	1269	.plus_equal => .assign_add,
1270	.minus_equal => .assign_sub,	1270	.minus_equal => .assign_sub,
1271	.angle_bracket_angle_bracket_left_equal => .assign_bit_shift_left,	1271	.angle_bracket_angle_bracket_left_equal => .assign_bit_shift_left,
		1272	.angle_bracket_angle_bracket_left_pipe_equal => .assign_bit_shift_left_sat,
1272	.angle_bracket_angle_bracket_right_equal => .assign_bit_shift_right,	1273	.angle_bracket_angle_bracket_right_equal => .assign_bit_shift_right,
1273	.ampersand_equal => .assign_bit_and,	1274	.ampersand_equal => .assign_bit_and,
1274	.caret_equal => .assign_bit_xor,	1275	.caret_equal => .assign_bit_xor,
...	@@ -1276,6 +1277,9 @@ const Parser = struct {	...	@@ -1276,6 +1277,9 @@ const Parser = struct {
1276	.asterisk_percent_equal => .assign_mul_wrap,	1277	.asterisk_percent_equal => .assign_mul_wrap,
1277	.plus_percent_equal => .assign_add_wrap,	1278	.plus_percent_equal => .assign_add_wrap,
1278	.minus_percent_equal => .assign_sub_wrap,	1279	.minus_percent_equal => .assign_sub_wrap,
		1280	.asterisk_pipe_equal => .assign_mul_sat,
		1281	.plus_pipe_equal => .assign_add_sat,
		1282	.minus_pipe_equal => .assign_sub_sat,
1279	.equal => .assign,	1283	.equal => .assign,
1280	else => return expr,	1284	else => return expr,
1281	};	1285	};
...	@@ -1343,6 +1347,7 @@ const Parser = struct {	...	@@ -1343,6 +1347,7 @@ const Parser = struct {
1343	.keyword_catch = .{ .prec = 40, .tag = .@"catch" },	1347	.keyword_catch = .{ .prec = 40, .tag = .@"catch" },
1344		1348
1345	.angle_bracket_angle_bracket_left = .{ .prec = 50, .tag = .bit_shift_left },	1349	.angle_bracket_angle_bracket_left = .{ .prec = 50, .tag = .bit_shift_left },
		1350	.angle_bracket_angle_bracket_left_pipe = .{ .prec = 50, .tag = .bit_shift_left_sat },
1346	.angle_bracket_angle_bracket_right = .{ .prec = 50, .tag = .bit_shift_right },	1351	.angle_bracket_angle_bracket_right = .{ .prec = 50, .tag = .bit_shift_right },
1347		1352
1348	.plus = .{ .prec = 60, .tag = .add },	1353	.plus = .{ .prec = 60, .tag = .add },
...	@@ -1350,6 +1355,8 @@ const Parser = struct {	...	@@ -1350,6 +1355,8 @@ const Parser = struct {
1350	.plus_plus = .{ .prec = 60, .tag = .array_cat },	1355	.plus_plus = .{ .prec = 60, .tag = .array_cat },
1351	.plus_percent = .{ .prec = 60, .tag = .add_wrap },	1356	.plus_percent = .{ .prec = 60, .tag = .add_wrap },
1352	.minus_percent = .{ .prec = 60, .tag = .sub_wrap },	1357	.minus_percent = .{ .prec = 60, .tag = .sub_wrap },
		1358	.plus_pipe = .{ .prec = 60, .tag = .add_sat },
		1359	.minus_pipe = .{ .prec = 60, .tag = .sub_sat },
1353		1360
1354	.pipe_pipe = .{ .prec = 70, .tag = .merge_error_sets },	1361	.pipe_pipe = .{ .prec = 70, .tag = .merge_error_sets },
1355	.asterisk = .{ .prec = 70, .tag = .mul },	1362	.asterisk = .{ .prec = 70, .tag = .mul },
...	@@ -1357,6 +1364,7 @@ const Parser = struct {	...	@@ -1357,6 +1364,7 @@ const Parser = struct {
1357	.percent = .{ .prec = 70, .tag = .mod },	1364	.percent = .{ .prec = 70, .tag = .mod },
1358	.asterisk_asterisk = .{ .prec = 70, .tag = .array_mult },	1365	.asterisk_asterisk = .{ .prec = 70, .tag = .array_mult },
1359	.asterisk_percent = .{ .prec = 70, .tag = .mul_wrap },	1366	.asterisk_percent = .{ .prec = 70, .tag = .mul_wrap },
		1367	.asterisk_pipe = .{ .prec = 70, .tag = .mul_sat },
1360	});	1368	});
1361		1369
1362	fn parseExprPrecedence(p: *Parser, min_prec: i32) Error!Node.Index {	1370	fn parseExprPrecedence(p: *Parser, min_prec: i32) Error!Node.Index {

sat-arithmetic: add operator support