Update JIT, add tests

Author: mat-hek

libs/jit/src/jit.erl

@@ -1324,10 +1324,6 @@ first_pass(<<?OP_BS_GET_BINARY2, Rest0/binary>>, MMod, MSt0, State0) ->
     {MSt5, BSOffsetReg0} = MMod:get_array_element(MSt4, MatchStateRegPtr, 2),
     MSt6 =
         if
-            Unit =/= 8 ->
-                MMod:call_primitive_last(MSt5, ?PRIM_RAISE_ERROR, [
-                    ctx, jit_state, offset, ?UNSUPPORTED_ATOM
-                ]);
             FlagsValue =/= 0 ->
                 MMod:call_primitive_last(MSt5, ?PRIM_RAISE_ERROR, [
                     ctx, jit_state, offset, ?UNSUPPORTED_ATOM
@@ -1349,9 +1345,17 @@ first_pass(<<?OP_BS_GET_BINARY2, Rest0/binary>>, MMod, MSt0, State0) ->
             is_integer(Size) ->
                 % SizeReg is binary size
                 % SizeVal is a constant
-                MSt11 = MMod:sub(MSt10, SizeReg, Size bsl 4),
+                MSt11 =
+                    if
+                        (Size * Unit) rem 8 =/= 0 ->
+                            MMod:call_primitive_last(MSt10, ?PRIM_RAISE_ERROR, [
+                                ctx, jit_state, offset, ?UNSUPPORTED_ATOM
+                            ]);
+                        true ->
+                            MMod:sub(MSt10, SizeReg, (Size * Unit) div 8)
+                    end,
                 MSt12 = cond_jump_to_label({{free, SizeReg}, '<', BSOffsetReg1}, Fail, MMod, MSt11),
-                {MSt12, Size bsl 4};
+                {MSt12, (Size * Unit) div 8};
             true ->
                 {MSt11, SizeValReg} = MMod:move_to_native_register(MSt10, Size),
                 MSt12 = MMod:if_else_block(
@@ -1363,10 +1367,29 @@ first_pass(<<?OP_BS_GET_BINARY2, Rest0/binary>>, MMod, MSt0, State0) ->
                     end,
                     fun(BSt0) ->
                         {BSt1, SizeValReg} = term_to_int(SizeValReg, 0, MMod, BSt0),
-                        BSt2 = MMod:sub(BSt1, SizeReg, SizeValReg),
-                        BSt3 = cond_jump_to_label({SizeReg, '<', BSOffsetReg1}, Fail, MMod, BSt2),
-                        BSt4 = MMod:move_to_native_register(BSt3, SizeValReg, SizeReg),
-                        MMod:free_native_registers(BSt4, [SizeValReg])
+                        {BSt2, SizeValReg2} = if
+                            is_integer(SizeValReg) ->
+                                if
+                                    (SizeValReg * Unit) rem 8 =/= 0 ->
+                                        MMod:call_primitive_last(BSt1, ?PRIM_RAISE_ERROR, [
+                                            ctx, jit_state, offset, ?UNSUPPORTED_ATOM
+                                        ]);
+                                    true ->
+                                        {BSt1, (SizeValReg * Unit) div 8}
+                                end;
+                            true ->
+                                BBSt1 = MMod:mul(BSt1, SizeValReg, Unit),
+                                BBSt2 = MMod:if_block(BBSt1, {SizeValReg, '&', 16#7, '!=', 0}, fun(BlockSt) ->
+                                    MMod:call_primitive_last(BlockSt, ?PRIM_RAISE_ERROR, [
+                                        ctx, jit_state, offset, ?UNSUPPORTED_ATOM
+                                    ])
+                                end),
+                                MMod:shift_right(BBSt2, SizeValReg, 3)
+                            end,
+                        BSt3 = MMod:sub(BSt2, SizeReg, SizeValReg2),
+                        BSt4 = cond_jump_to_label({SizeReg, '<', BSOffsetReg1}, Fail, MMod, BSt3),
+                        BSt5 = MMod:move_to_native_register(BSt4, SizeValReg2, SizeReg),
+                        MMod:free_native_registers(BSt5, [SizeValReg])
                     end
                 ),
                 {MSt12, SizeReg}

tests/erlang_tests/test_bs.erl

@@ -99,6 +99,9 @@ start() ->
 
     ok = test_bs_skip_bits2_little(),
 
+    ok = test_bs_match_bitstring_modifier(),
+    ok = test_bs_create_bitstring_modifier(),
+
     0.
 
 test_pack_small_ints({A, B, C}, Expect) ->
@@ -532,6 +535,37 @@ test_bs_match_string_select() ->
 test_bs_skip_bits2_little() ->
     ok = check_x86_64_jt(id(<<16#e9, 0:32>>)).
 
+test_bs_match_bitstring_modifier() ->
+    ok =
+        try
+            bitstring_match(id(<<123, 234, 245>>), id(15)),
+            unexpected
+        catch
+            error:unsupported -> ok
+        end,
+
+    {<<123, 234>>, <<245>>} = bitstring_match(id(<<123, 234, 245>>), id(16)),
+    ok.
+
+bitstring_match(BS, Size) ->
+    <<Matched:Size/bitstring, Rest/bits>> = BS,
+    {Matched, Rest}.
+
+test_bs_create_bitstring_modifier() ->
+    ok =
+        try
+            bitstring_join(id(<<123, 234>>), id(15), id(<<245, 256>>), id(8)),
+            unexpected
+        catch
+            error:unsupported -> ok
+        end,
+
+    <<123, 234, 245>> = bitstring_join(id(<<123, 234>>), id(16), id(<<245, 256>>), id(8)),
+    ok.
+
+bitstring_join(BS1, Size1, BS2, Size2) ->
+    <<BS1:Size1/bitstring, BS2:Size2/bitstring>>.
+
 check_x86_64_jt(<<>>) -> ok;
 check_x86_64_jt(<<16#e9, _Offset:32/little, Tail/binary>>) -> check_x86_64_jt(Tail);
 check_x86_64_jt(Bin) -> {unexpected, Bin}.