fixup! Implement the bs_create_bin instruction

6 files changed, 179 insertions, 116 deletions

diff --git a/erts/emulator/beam/beam_debug.c b/erts/emulator/beam/beam_debug.c
index 0f8ae9fdea..e4823f76bb 100644
--- a/erts/emulator/beam/beam_debug.c
+++ b/erts/emulator/beam/beam_debug.c
@@ -900,7 +900,7 @@ print_op(fmtfn_t to, void *to_arg, int op, int size, BeamInstr* addr)
 	break;
     case op_i_bs_create_bin_jItdW:
         {
-	    int n = unpacked[-1];
+            int n = unpacked[-1];
             int i = 0;
             Eterm type = 0;
 
@@ -943,7 +943,7 @@ print_op(fmtfn_t to, void *to_arg, int op, int size, BeamInstr* addr)
                         break;
                     }
                 }
-		i++, size++, n--;
+                i++, size++, n--;
             }
         }
         break;
diff --git a/erts/emulator/beam/emu/bs_instrs.tab b/erts/emulator/beam/emu/bs_instrs.tab
index e143331e51..bcd46052af 100644
--- a/erts/emulator/beam/emu/bs_instrs.tab
+++ b/erts/emulator/beam/emu/bs_instrs.tab
@@ -968,9 +968,9 @@ i_bs_create_bin(Fail, Alloc, Live, Dst, N) {
                     $BS_FAIL_INFO($Fail, BADARG, am_size);
                 }
 #else
-		Uint size;
+                Uint size;
 
-		if (!term_to_Uint(Size, &size)) {
+                if (!term_to_Uint(Size, &size)) {
                     if (size == BADARG) {
                         /* Not an integer or a negative integer. Determine which. */
                         if (is_big(Size)) {
@@ -982,13 +982,13 @@ i_bs_create_bin(Fail, Alloc, Live, Dst, N) {
                     }
                     /* Huge positive integer. */
                     $BS_FAIL_INFO_SYSTEM_LIMIT($Fail);
-		}
-		$BS_SAFE_MUL(size, unit, $BS_FAIL_INFO_SYSTEM_LIMIT($Fail), size);
-		if ((size >> 31) != 0) {
+                }
+                $BS_SAFE_MUL(size, unit, $BS_FAIL_INFO_SYSTEM_LIMIT($Fail), size);
+                if ((size >> 31) != 0) {
                     $BS_FAIL_INFO_SYSTEM_LIMIT($Fail);
-		} else {
+                } else {
                     num_bits += size;
-		}
+                }
 #endif
             }
             break;
diff --git a/erts/emulator/beam/jit/arm/instr_bs.cpp b/erts/emulator/beam/jit/arm/instr_bs.cpp
index 3a8d6652f5..2914dd0ebf 100644
--- a/erts/emulator/beam/jit/arm/instr_bs.cpp
+++ b/erts/emulator/beam/jit/arm/instr_bs.cpp
@@ -1453,7 +1453,7 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
      */
     for (std::size_t i = 0; i < n; i += 6) {
         BscSegment seg;
-        Uint bsc_op;
+        JitBSCOp bsc_op;
         Uint bsc_segment;
 
         ASSERT(args[i].isImmed());
@@ -1492,7 +1492,7 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
          * Save segment number and operation for use in extended
          * error information.
          */
-        seg.error_info = BSC_SET_SEGMENT_OP(bsc_segment, bsc_op);
+        seg.error_info = beam_jit_set_bsc_segment_op(bsc_segment, bsc_op);
 
         /*
          * Attempt to calculate the effective size of this segment.
@@ -1571,8 +1571,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             fragment_call(ga->get_bs_bit_size_shared());
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.cond_mi().b(resolve_label(error, disp1MB));
             a.add(sizeReg, sizeReg, ARG1);
@@ -1583,15 +1584,16 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             a.cmp(TMP2, imm(_TAG_IMMED1_SMALL));
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_DEPENDS,
-                                                             BSC_INFO_DEPENDS));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_DEPENDS,
+                                                        BSC_INFO_DEPENDS));
             }
             a.cond_ne().b(resolve_label(error, disp1MB));
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info |
-                                BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                    BSC_INFO_NEGATIVE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_NEGATIVE));
             }
             a.tbnz(ARG1, 63, resolve_label(error, disp32K));
             a.asr(TMP1, ARG1, imm(_TAG_IMMED1_SIZE));
@@ -1600,9 +1602,10 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             } else {
                 if (Fail.getValue() == 0) {
                     mov_imm(ARG4,
-                            seg.error_info |
-                                    BSC_SET_REASON_INFO(BSC_REASON_SYSTEM_LIMIT,
-                                                        BSC_INFO_SIZE));
+                            beam_jit_update_bsc_reason_info(
+                                    seg.error_info,
+                                    BSC_REASON_SYSTEM_LIMIT,
+                                    BSC_INFO_SIZE));
                 }
                 a.tst(TMP1, imm(0xffful << 52));
                 a.cond_ne().b(resolve_label(error, disp1MB));
@@ -1657,9 +1660,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
                 if (Fail.getValue() == 0) {
                     mov_imm(ARG4,
-                            seg.error_info |
-                                    BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                        BSC_INFO_TYPE));
+                            beam_jit_update_bsc_reason_info(seg.error_info,
+                                                            BSC_REASON_BADARG,
+                                                            BSC_INFO_TYPE));
                 }
 
                 a.add(sizeReg, sizeReg, imm(4 * 8));
@@ -1714,8 +1717,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
         if (Fail.getValue() == 0) {
             mov_imm(ARG4,
-                    seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                         BSC_INFO_FVALUE));
+                    beam_jit_update_bsc_reason_info(seg.error_info,
+                                                    BSC_REASON_BADARG,
+                                                    BSC_INFO_FVALUE));
         }
         emit_branch_if_not_value(ARG1, resolve_label(error, dispUnknown));
     } else if (segments[0].type == am_private_append) {
@@ -1737,8 +1741,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
         emit_leave_runtime(Live.getValue());
         if (Fail.getValue() == 0) {
             mov_imm(ARG4,
-                    seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_FREASON,
-                                                         BSC_INFO_FVALUE));
+                    beam_jit_update_bsc_reason_info(seg.error_info,
+                                                    BSC_REASON_FREASON,
+                                                    BSC_INFO_FVALUE));
         }
         emit_branch_if_not_value(ARG1, resolve_label(error, dispUnknown));
     } else {
@@ -1784,8 +1789,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_FVALUE);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_FVALUE);
             } else if (seg.size.isImmed() && seg.size.getValue() == am_all) {
                 /* Include the entire binary/bitstring in the
                  * resulting binary. */
@@ -1793,8 +1799,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary_all);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_UNIT);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_UNIT);
             } else {
                 /* The size is a variable. We have verified that
                  * the value is a non-negative small in the
@@ -1809,12 +1816,13 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_FVALUE);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_FVALUE);
             }
             emit_leave_runtime<Update::eReductions>(Live.getValue());
             if (Fail.getValue() == 0) {
-                mov_imm(ARG4, seg.error_info | error_info);
+                mov_imm(ARG4, error_info);
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
@@ -1841,8 +1849,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_FVALUE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_FVALUE));
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
@@ -1868,8 +1877,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
@@ -1897,8 +1907,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             emit_leave_runtime(Live.getValue());
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
@@ -1914,8 +1925,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
@@ -1931,8 +1943,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.cbz(ARG1, resolve_label(error, disp1MB));
             break;
diff --git a/erts/emulator/beam/jit/beam_jit_common.cpp b/erts/emulator/beam/jit/beam_jit_common.cpp
index d03ca7fcfd..6025b0130f 100644
--- a/erts/emulator/beam/jit/beam_jit_common.cpp
+++ b/erts/emulator/beam/jit/beam_jit_common.cpp
@@ -744,10 +744,10 @@ void beam_jit_bs_construct_fail_info(Process *c_p,
     Eterm *hp = HAlloc(c_p, Sint(MAP3_SZ + 3 + 1));
     Eterm cause_tuple;
     Eterm error_info;
-    Uint segment = BSC_GET_SEGMENT(packed_error_info);
-    Uint op = BSC_GET_OP(packed_error_info);
-    Uint info = BSC_GET_INFO(packed_error_info);
-    Uint reason = BSC_GET_REASON(packed_error_info);
+    Uint segment = beam_jit_get_bsc_segment(packed_error_info);
+    Uint op = beam_jit_get_bsc_op(packed_error_info);
+    Uint info = beam_jit_get_bsc_info(packed_error_info);
+    Uint reason = beam_jit_get_bsc_reason(packed_error_info);
     Eterm Op = am_none;
     Eterm Info = am_none;
 
diff --git a/erts/emulator/beam/jit/beam_jit_common.hpp b/erts/emulator/beam/jit/beam_jit_common.hpp
index 7d32f71dcd..8dbacb6026 100644
--- a/erts/emulator/beam/jit/beam_jit_common.hpp
+++ b/erts/emulator/beam/jit/beam_jit_common.hpp
@@ -235,32 +235,69 @@ public:
     }
 };
 
-static const int BSC_OP_BINARY = 0;
-static const int BSC_OP_FLOAT = 1;
-static const int BSC_OP_INTEGER = 2;
-static const int BSC_OP_UTF8 = 3;
-static const int BSC_OP_UTF16 = 4;
-static const int BSC_OP_UTF32 = 5;
-
-static const int BSC_INFO_FVALUE = 0;
-static const int BSC_INFO_TYPE = 1;
-static const int BSC_INFO_SIZE = 2;
-static const int BSC_INFO_NEGATIVE = 3;
-static const int BSC_INFO_UNIT = 4;
-static const int BSC_INFO_DEPENDS = 5;
-
-static const int BSC_REASON_FREASON = 0;
-static const int BSC_REASON_BADARG = 1;
-static const int BSC_REASON_SYSTEM_LIMIT = 2;
-static const int BSC_REASON_DEPENDS = 3;
-
-#define BSC_SET_SEGMENT_OP(Seg, Op) (((Seg) << 8) | ((Op) << 5))
-#define BSC_SET_REASON_INFO(Reason, Info) (((Info) << 2) | Reason)
-
-#define BSC_GET_SEGMENT(PackedInfo) ((PackedInfo) >> 8)
-#define BSC_GET_OP(PackedInfo) (((PackedInfo) >> 5) & 0x007)
-#define BSC_GET_INFO(PackedInfo) (((PackedInfo) >> 2) & 0x07);
-#define BSC_GET_REASON(PackedInfo) ((PackedInfo)&0x03);
+static const Uint BSC_SEGMENT_OFFSET = 8;
+
+typedef enum : Uint {
+    BSC_OP_BINARY = 0,
+    BSC_OP_FLOAT = 1,
+    BSC_OP_INTEGER = 2,
+    BSC_OP_UTF8 = 3,
+    BSC_OP_UTF16 = 4,
+    BSC_OP_UTF32 = 5,
+    BSC_OP_LAST = 5,
+    BSC_OP_MASK = 0x07,
+    BSC_OP_OFFSET = 5
+} JitBSCOp;
+
+typedef enum : Uint {
+    BSC_INFO_FVALUE = 0,
+    BSC_INFO_TYPE = 1,
+    BSC_INFO_SIZE = 2,
+    BSC_INFO_NEGATIVE = 3,
+    BSC_INFO_UNIT = 4,
+    BSC_INFO_DEPENDS = 5,
+    BSC_INFO_LAST = 5,
+    BSC_INFO_MASK = 0x07,
+    BSC_INFO_OFFSET = 2,
+} JitBSCInfo;
+
+typedef enum : Uint {
+    BSC_REASON_FREASON = 0,
+    BSC_REASON_BADARG = 1,
+    BSC_REASON_SYSTEM_LIMIT = 2,
+    BSC_REASON_DEPENDS = 3,
+    BSC_REASON_LAST = 3,
+    BSC_REASON_MASK = 0x03
+} JitBSCReason;
+
+static constexpr Uint beam_jit_set_bsc_segment_op(Uint segment, JitBSCOp op) {
+    return (segment << BSC_SEGMENT_OFFSET) | (op << BSC_OP_OFFSET);
+}
+
+static constexpr Uint beam_jit_update_bsc_reason_info(Uint packed_info,
+                                                      JitBSCReason reason,
+                                                      JitBSCInfo info) {
+    return packed_info | (info << BSC_INFO_OFFSET) | reason;
+}
+
+static constexpr Uint beam_jit_get_bsc_segment(Uint packed_info) {
+    return packed_info >> BSC_SEGMENT_OFFSET;
+}
+
+static constexpr JitBSCOp beam_jit_get_bsc_op(Uint packed_info) {
+    ERTS_CT_ASSERT((BSC_OP_LAST & ~BSC_OP_MASK) == 0);
+    return (JitBSCOp)((packed_info >> BSC_OP_OFFSET) & BSC_OP_MASK);
+}
+
+static constexpr JitBSCInfo beam_jit_get_bsc_info(Uint packed_info) {
+    ERTS_CT_ASSERT((BSC_INFO_LAST & ~BSC_INFO_MASK) == 0);
+    return (JitBSCInfo)((packed_info >> BSC_INFO_OFFSET) & BSC_INFO_MASK);
+}
+
+static constexpr JitBSCReason beam_jit_get_bsc_reason(Uint packed_info) {
+    ERTS_CT_ASSERT((BSC_REASON_LAST & ~BSC_REASON_MASK) == 0);
+    return (JitBSCReason)(packed_info & BSC_REASON_MASK);
+}
 
 /* ** */
 
diff --git a/erts/emulator/beam/jit/x86/instr_bs.cpp b/erts/emulator/beam/jit/x86/instr_bs.cpp
index 845e92fd2d..8bd4197d17 100644
--- a/erts/emulator/beam/jit/x86/instr_bs.cpp
+++ b/erts/emulator/beam/jit/x86/instr_bs.cpp
@@ -1626,7 +1626,7 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
      */
     for (std::size_t i = 0; i < n; i += 6) {
         BscSegment seg;
-        Uint bsc_op;
+        JitBSCOp bsc_op;
         Uint bsc_segment;
 
         ASSERT(args[i].isImmed());
@@ -1665,7 +1665,7 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
          * Save segment number and operation for use in extended
          * error information.
          */
-        seg.error_info = BSC_SET_SEGMENT_OP(bsc_segment, bsc_op);
+        seg.error_info = beam_jit_set_bsc_segment_op(bsc_segment, bsc_op);
 
         /*
          * As soon as we have entered runtime mode, Y registers can no
@@ -1756,8 +1756,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             runtime_call<1>(beam_jit_bs_bit_size);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.test(RET, RET);
             a.js(error);
@@ -1770,15 +1771,16 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             a.cmp(RETb, imm(_TAG_IMMED1_SMALL));
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_DEPENDS,
-                                                             BSC_INFO_DEPENDS));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_DEPENDS,
+                                                        BSC_INFO_DEPENDS));
             }
             a.jne(error);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info |
-                                BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                    BSC_INFO_NEGATIVE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_NEGATIVE));
             }
             a.sar(ARG1, imm(_TAG_IMMED1_SIZE));
             a.js(error);
@@ -1787,9 +1789,10 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             } else {
                 if (Fail.getValue() == 0) {
                     mov_imm(ARG4,
-                            seg.error_info |
-                                    BSC_SET_REASON_INFO(BSC_REASON_SYSTEM_LIMIT,
-                                                        BSC_INFO_SIZE));
+                            beam_jit_update_bsc_reason_info(
+                                    seg.error_info,
+                                    BSC_REASON_SYSTEM_LIMIT,
+                                    BSC_INFO_SIZE));
                 }
                 a.imul(RET, ARG1, imm(seg.unit));
                 a.jo(error);
@@ -1838,9 +1841,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
 
                 if (Fail.getValue() == 0) {
                     mov_imm(ARG4,
-                            seg.error_info |
-                                    BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                        BSC_INFO_TYPE));
+                            beam_jit_update_bsc_reason_info(seg.error_info,
+                                                            BSC_REASON_BADARG,
+                                                            BSC_INFO_TYPE));
                 }
 
                 a.add(sizeReg, imm(4 * 8));
@@ -1884,8 +1887,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
         runtime_call<6>(erts_bs_append_checked);
         if (Fail.getValue() == 0) {
             mov_imm(ARG4,
-                    seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                         BSC_INFO_FVALUE));
+                    beam_jit_update_bsc_reason_info(seg.error_info,
+                                                    BSC_REASON_BADARG,
+                                                    BSC_INFO_FVALUE));
         }
         emit_test_the_non_value(RET);
         a.je(error);
@@ -1906,8 +1910,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
         runtime_call<4>(erts_bs_private_append_checked);
         if (Fail.getValue() == 0) {
             mov_imm(ARG4,
-                    seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_FREASON,
-                                                         BSC_INFO_FVALUE));
+                    beam_jit_update_bsc_reason_info(seg.error_info,
+                                                    BSC_REASON_FREASON,
+                                                    BSC_INFO_FVALUE));
         }
         emit_test_the_non_value(RET);
         a.je(error);
@@ -1949,8 +1954,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_FVALUE);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_FVALUE);
             } else if (seg.size.isImmed() && seg.size.getValue() == am_all) {
                 /* Include the entire binary/bitstring in the
                  * resulting binary. */
@@ -1958,8 +1964,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary_all);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_UNIT);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_UNIT);
             } else {
                 /* The size is a variable. We have verified that
                  * the value is a non-negative small in the
@@ -1975,13 +1982,14 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
                 mov_arg(ARG2, seg.src);
                 a.mov(ARG1, c_p);
                 runtime_call<3>(erts_new_bs_put_binary);
-                error_info =
-                        BSC_SET_REASON_INFO(BSC_REASON_BADARG, BSC_INFO_FVALUE);
+                error_info = beam_jit_update_bsc_reason_info(seg.error_info,
+                                                             BSC_REASON_BADARG,
+                                                             BSC_INFO_FVALUE);
             }
-            a.test(RET, RET);
             if (Fail.getValue() == 0) {
-                mov_imm(ARG4, seg.error_info | error_info);
+                mov_imm(ARG4, error_info);
             }
+            a.test(RET, RET);
             a.je(error);
             break;
         }
@@ -2002,12 +2010,13 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             mov_imm(ARG4, seg.flags);
             a.mov(ARG1, c_p);
             runtime_call<4>(erts_new_bs_put_float);
-            a.test(RET, RET);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_FVALUE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_FVALUE));
             }
+            a.test(RET, RET);
             a.je(error);
             break;
         case am_integer:
@@ -2030,8 +2039,9 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             a.test(RET, RET);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
             a.je(error);
             break;
@@ -2047,12 +2057,13 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             mov_arg(ARG2, seg.src);
             load_erl_bits_state(ARG1);
             runtime_call<2>(erts_bs_put_utf8);
-            a.test(RET, RET);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
+            a.test(RET, RET);
             a.je(error);
             break;
         case am_utf16:
@@ -2060,12 +2071,13 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             a.mov(ARG3, seg.flags);
             load_erl_bits_state(ARG1);
             runtime_call<3>(erts_bs_put_utf16);
-            a.test(RET, RET);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
+            a.test(RET, RET);
             a.je(error);
             break;
         case am_utf32:
@@ -2074,12 +2086,13 @@ void BeamModuleAssembler::emit_i_bs_create_bin(const ArgVal &Fail,
             a.mov(ARG4, seg.flags);
             load_erl_bits_state(ARG1);
             runtime_call<4>(erts_new_bs_put_integer);
-            a.test(RET, RET);
             if (Fail.getValue() == 0) {
                 mov_imm(ARG4,
-                        seg.error_info | BSC_SET_REASON_INFO(BSC_REASON_BADARG,
-                                                             BSC_INFO_TYPE));
+                        beam_jit_update_bsc_reason_info(seg.error_info,
+                                                        BSC_REASON_BADARG,
+                                                        BSC_INFO_TYPE));
             }
+            a.test(RET, RET);
             a.je(error);
             break;
         default: