Reduce code size for binary matching instructions

The new compiler required adding support for Y register for all
binary matching instructions. That was (intentionally) done in a
naive way that simplicated duplicated the entire body of each
instruction.

Now it's time to be less naive. Rewrite the binary matching
instructions using micro instructions. Because some of the binary
instructions are huge, that will significantly decrease the size of
process_main().

When compiling with clang, a huge process_main() would mess up
profile-guide optimization resulting in a significant performance
degradation. On my Mac, profile-guide optimzation would decrease
the estone benchmark by 100K estones (about 20 percent). This commit
gives me back the lost estones.

1 files changed, 186 insertions, 44 deletions

diff --git a/erts/emulator/beam/bs_instrs.tab b/erts/emulator/beam/bs_instrs.tab
index 2dde70c2e1..714f1d49ce 100644
--- a/erts/emulator/beam/bs_instrs.tab
+++ b/erts/emulator/beam/bs_instrs.tab
@@ -90,12 +90,22 @@ TEST_BIN_VHEAP(VNh, Nh, Live) {
     HEAP_SPACE_VERIFIED(need);
 }
 
-i_bs_get_binary_all2(Fail, Ms, Live, Unit, Dst) {
+i_bs_get_binary_all2 := i_bs_get_binary_all2.fetch.execute;
+
+i_bs_get_binary_all2.head() {
+    Eterm context;
+}
+
+i_bs_get_binary_all2.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_binary_all2.execute(Fail, Live, Unit, Dst) {
     ErlBinMatchBuffer *_mb;
     Eterm _result;
 
-    $GC_TEST(0, ERL_SUB_BIN_SIZE, $Live);
-    _mb = ms_matchbuffer($Ms);
+    $GC_TEST_PRESERVE(ERL_SUB_BIN_SIZE, $Live, context);
+    _mb = ms_matchbuffer(context);
     if (((_mb->size - _mb->offset) % $Unit) == 0) {
         LIGHT_SWAPOUT;
         _result = erts_bs_get_binary_all_2(c_p, _mb);
@@ -109,14 +119,23 @@ i_bs_get_binary_all2(Fail, Ms, Live, Unit, Dst) {
 	$FAIL($Fail);
     }
 }
+i_bs_get_binary2 := i_bs_get_binary2.fetch.execute;
+
+i_bs_get_binary2.head() {
+    Eterm context;
+}
 
-i_bs_get_binary2(Fail, Ms, Live, Sz, Flags, Dst) {
+i_bs_get_binary2.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_binary2.execute(Fail, Live, Sz, Flags, Dst) {
     ErlBinMatchBuffer *_mb;
     Eterm _result;
     Uint _size;
     $BS_GET_FIELD_SIZE($Sz, (($Flags) >> 3), $FAIL($Fail), _size);
-    $GC_TEST(0, ERL_SUB_BIN_SIZE, $Live);
-    _mb = ms_matchbuffer($Ms);
+    $GC_TEST_PRESERVE(ERL_SUB_BIN_SIZE, $Live, context);
+    _mb = ms_matchbuffer(context);
     LIGHT_SWAPOUT;
     _result = erts_bs_get_binary_2(c_p, _size, $Flags, _mb);
     LIGHT_SWAPIN;
@@ -129,11 +148,22 @@ i_bs_get_binary2(Fail, Ms, Live, Sz, Flags, Dst) {
     }
 }
 
-i_bs_get_binary_imm2(Fail, Ms, Live, Sz, Flags, Dst) {
+i_bs_get_binary_imm2 := i_bs_get_binary_imm2.fetch.execute;
+
+i_bs_get_binary_imm2.head() {
+    Eterm context;
+}
+
+i_bs_get_binary_imm2.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_binary_imm2.execute(Fail, Live, Sz, Flags, Dst) {
     ErlBinMatchBuffer *_mb;
     Eterm _result;
-    $GC_TEST(0, heap_bin_size(ERL_ONHEAP_BIN_LIMIT), $Live);
-    _mb = ms_matchbuffer($Ms);
+    $GC_TEST_PRESERVE(heap_bin_size(ERL_ONHEAP_BIN_LIMIT),
+                      $Live, context);
+    _mb = ms_matchbuffer(context);
     LIGHT_SWAPOUT;
     _result = erts_bs_get_binary_2(c_p, $Sz, $Flags, _mb);
     LIGHT_SWAPIN;
@@ -145,8 +175,17 @@ i_bs_get_binary_imm2(Fail, Ms, Live, Sz, Flags, Dst) {
         $Dst = _result;
     }
 }
+i_bs_get_float2 := i_bs_get_float2.fetch.execute;
+
+i_bs_get_float2.head() {
+    Eterm context;
+}
+
+i_bs_get_float2.fetch(Ctx) {
+    context = $Ctx;
+}
 
-i_bs_get_float2(Fail, Ms, Live, Sz, Flags, Dst) {
+i_bs_get_float2.execute(Fail, Live, Sz, Flags, Dst) {
     ErlBinMatchBuffer *_mb;
     Eterm _result;
     Sint _size;
@@ -155,8 +194,8 @@ i_bs_get_float2(Fail, Ms, Live, Sz, Flags, Dst) {
         $FAIL($Fail);
     }
     _size *= (($Flags) >> 3);
-    $GC_TEST(0, FLOAT_SIZE_OBJECT, $Live);
-    _mb = ms_matchbuffer($Ms);
+    $GC_TEST_PRESERVE(FLOAT_SIZE_OBJECT, $Live, context);
+    _mb = ms_matchbuffer(context);
     LIGHT_SWAPOUT;
     _result = erts_bs_get_float_2(c_p, _size, ($Flags), _mb);
     LIGHT_SWAPIN;
@@ -169,13 +208,24 @@ i_bs_get_float2(Fail, Ms, Live, Sz, Flags, Dst) {
     }
 }
 
-i_bs_skip_bits2(Fail, Ms, Bits, Unit) {
+i_bs_skip_bits2 := i_bs_skip_bits2.fetch.execute;
+
+i_bs_skip_bits2.head() {
+    Eterm context, bits;
+}
+
+i_bs_skip_bits2.fetch(Ctx, Bits) {
+    context = $Ctx;
+    bits = $Bits;
+}
+
+i_bs_skip_bits2.execute(Fail, Unit) {
     ErlBinMatchBuffer *_mb;
     size_t new_offset;
     Uint _size;
 
-    _mb = ms_matchbuffer($Ms);
-    $BS_GET_FIELD_SIZE($Bits, $Unit, $FAIL($Fail), _size);
+    _mb = ms_matchbuffer(context);
+    $BS_GET_FIELD_SIZE(bits, $Unit, $FAIL($Fail), _size);
     new_offset = _mb->offset + _size;
     if (new_offset <= _mb->size) {
         _mb->offset = new_offset;
@@ -809,9 +859,19 @@ bs_test_unit8(Fail, Ctx) {
     }
 }
 
-i_bs_get_integer_8(Ctx, Fail, Dst) {
+i_bs_get_integer_8 := i_bs_get_integer_8.fetch.execute;
+
+i_bs_get_integer_8.head() {
+    Eterm context;
+}
+
+i_bs_get_integer_8.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_integer_8.execute(Fail, Dst) {
     Eterm _result;
-    ErlBinMatchBuffer* _mb = ms_matchbuffer($Ctx);
+    ErlBinMatchBuffer* _mb = ms_matchbuffer(context);
 
     if (_mb->size - _mb->offset < 8) {
         $FAIL($Fail);
@@ -825,9 +885,19 @@ i_bs_get_integer_8(Ctx, Fail, Dst) {
     $Dst = _result;
 }
 
-i_bs_get_integer_16(Ctx, Fail, Dst) {
+i_bs_get_integer_16 := i_bs_get_integer_16.fetch.execute;
+
+i_bs_get_integer_16.head() {
+    Eterm context;
+}
+
+i_bs_get_integer_16.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_integer_16.execute(Fail, Dst) {
     Eterm _result;
-    ErlBinMatchBuffer* _mb = ms_matchbuffer($Ctx);
+    ErlBinMatchBuffer* _mb = ms_matchbuffer(context);
 
     if (_mb->size - _mb->offset < 16) {
         $FAIL($Fail);
@@ -842,9 +912,19 @@ i_bs_get_integer_16(Ctx, Fail, Dst) {
 }
 
 %if ARCH_64
-i_bs_get_integer_32(Ctx, Fail, Dst) {
+i_bs_get_integer_32 := i_bs_get_integer_32.fetch.execute;
+
+i_bs_get_integer_32.head() {
+    Eterm context;
+}
+
+i_bs_get_integer_32.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_integer_32.execute(Fail, Dst) {
     Uint32 _integer;
-    ErlBinMatchBuffer* _mb = ms_matchbuffer($Ctx);
+    ErlBinMatchBuffer* _mb = ms_matchbuffer(context);
 
     if (_mb->size - _mb->offset < 32) {
         $FAIL($Fail);
@@ -894,15 +974,23 @@ bs_get_integer.execute(Fail, Flags, Dst) {
     $Dst = result;
 }
 
-i_bs_get_integer(Fail, Live, FlagsAndUnit, Ms, Sz, Dst) {
+i_bs_get_integer := i_bs_get_integer.fetch.execute;
+
+i_bs_get_integer.head() {
+    Eterm context;
+}
+
+i_bs_get_integer.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_integer.execute(Fail, Live, FlagsAndUnit, Sz, Dst) {
     Uint flags;
     Uint size;
-    Eterm ms;
     ErlBinMatchBuffer* mb;
     Eterm result;
 
     flags = $FlagsAndUnit;
-    ms = $Ms;
     $BS_GET_FIELD_SIZE($Sz, (flags >> 3), $FAIL($Fail), size);
     if (size >= SMALL_BITS) {
         Uint wordsneeded;
@@ -913,15 +1001,15 @@ i_bs_get_integer(Fail, Live, FlagsAndUnit, Ms, Sz, Dst) {
          * Remember to re-acquire the matchbuffer after gc.
          */
 
-        mb = ms_matchbuffer(ms);
+        mb = ms_matchbuffer(context);
         if (mb->size - mb->offset < size) {
             $FAIL($Fail);
         }
         wordsneeded = 1+WSIZE(NBYTES((Uint) size));
-        $GC_TEST_PRESERVE(wordsneeded, $Live, ms);
+        $GC_TEST_PRESERVE(wordsneeded, $Live, context);
         $REFRESH_GEN_DEST();
     }
-    mb = ms_matchbuffer(ms);
+    mb = ms_matchbuffer(context);
     LIGHT_SWAPOUT;
     result = erts_bs_get_integer_2(c_p, size, flags, mb);
     LIGHT_SWAPIN;
@@ -932,9 +1020,19 @@ i_bs_get_integer(Fail, Live, FlagsAndUnit, Ms, Sz, Dst) {
     $Dst = result;
 }
 
-i_bs_get_utf8(Ctx, Fail, Dst) {
+i_bs_get_utf8 := i_bs_get_utf8.fetch.execute;
+
+i_bs_get_utf8.head() {
+    Eterm context;
+}
+
+i_bs_get_utf8.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_utf8.execute(Fail, Dst) {
     Eterm result;
-    ErlBinMatchBuffer* mb = ms_matchbuffer($Ctx);
+    ErlBinMatchBuffer* mb = ms_matchbuffer(context);
 
     if (mb->size - mb->offset < 8) {
         $FAIL($Fail);
@@ -957,8 +1055,18 @@ i_bs_get_utf8(Ctx, Fail, Dst) {
     $Dst = result;
 }
 
-i_bs_get_utf16(Ctx, Fail, Flags, Dst) {
-    ErlBinMatchBuffer* mb = ms_matchbuffer($Ctx);
+i_bs_get_utf16 := i_bs_get_utf16.fetch.execute;
+
+i_bs_get_utf16.head() {
+    Eterm context;
+}
+
+i_bs_get_utf16.fetch(Ctx) {
+    context = $Ctx;
+}
+
+i_bs_get_utf16.execute(Fail, Flags, Dst) {
+    ErlBinMatchBuffer* mb = ms_matchbuffer(context);
     Eterm result = erts_bs_get_utf16(mb, $Flags);
 
     if (is_non_value(result)) {
@@ -1055,13 +1163,20 @@ i_bs_restore2(Src, Slot) {
     _ms->mb.offset = _ms->save_offset[$Slot];
 }
 
-bs_get_tail(Src, Dst, Live) {
-    ErlBinMatchBuffer* mb;
-    Uint size, offs;
-    ErlSubBin* sb;
+bs_get_tail := bs_get_tail.fetch.execute;
+
+bs_get_tail.head() {
     Eterm context;
+}
 
+bs_get_tail.fetch(Src) {
     context = $Src;
+}
+
+bs_get_tail.execute(Dst, Live) {
+    ErlBinMatchBuffer* mb;
+    Uint size, offs;
+    ErlSubBin* sb;
 
     ASSERT(header_is_bin_matchstate(*boxed_val(context)));
 
@@ -1090,11 +1205,20 @@ bs_get_tail(Src, Dst, Live) {
 
 %if ARCH_64
 
-i_bs_start_match3_gp(Src, Live, Fail, Dst, Pos) {
-    Eterm context, header;
-    Uint position, live;
+i_bs_start_match3_gp := i_bs_start_match3_gp.fetch.execute;
 
+i_bs_start_match3_gp.head() {
+    Eterm context;
+}
+
+i_bs_start_match3_gp.fetch(Src) {
     context = $Src;
+}
+
+i_bs_start_match3_gp.execute(Live, Fail, Dst, Pos) {
+    Eterm header;
+    Uint position, live;
+
     live = $Live;
 
     if (!is_boxed(context)) {
@@ -1139,11 +1263,20 @@ i_bs_start_match3_gp(Src, Live, Fail, Dst, Pos) {
     $Pos = make_small(position);
 }
 
-i_bs_start_match3(Src, Live, Fail, Dst) {
-    Eterm context, header;
-    Uint live;
+i_bs_start_match3 := i_bs_start_match3.fetch.execute;
+
+i_bs_start_match3.head() {
+    Eterm context;
+}
 
+i_bs_start_match3.fetch(Src) {
     context = $Src;
+}
+
+i_bs_start_match3.execute(Live, Fail, Dst) {
+    Eterm header;
+    Uint live;
+
     live = $Live;
 
     if (!is_boxed(context)) {
@@ -1261,11 +1394,20 @@ bs_get_position(Ctx, Dst, Live) {
     }
 }
 
-i_bs_start_match3(Src, Live, Fail, Dst) {
-    Eterm context, header;
-    Uint live;
+i_bs_start_match3 := i_bs_start_match3.fetch.execute;
 
+i_bs_start_match3.head() {
+    Eterm context;
+}
+
+i_bs_start_match3.fetch(Src) {
     context = $Src;
+}
+
+i_bs_start_match3.execute(Live, Fail, Dst) {
+    Eterm header;
+    Uint live;
+
     live = $Live;
 
     if (!is_boxed(context)) {