Improve the performance of indirect jump for T1C

Considering the T1C ends with the indirect jump, our interpreter mode
now records the target of the indirect jump, identifying the most
frequent jump target for T1C. The T1 generated code for the indirect
jump compares the selected jump target and executes the jump if the
comparison results in equality. With this enhancement, T1C and T2C
which are integrated later can proceed with an indirect jump if the
target PC matches the selected jump target.

Based on the performance analysis, the benchmarks with significant
number of indirect jump effectively improve the performance.

| Metric   | N_in_jmp  | Original | Propused | Speedup |
|----------+-----------+----------+----------+---------|
|miniz	   |    2098313|   1.266 s|   1.225 s|   +3.35%|
|sha512    |   10500727|   1.905 s|   1.861 s|   +2.36%|
|dhrystone |   20000618|   0.325 s|   0.253 s|  +28.46%|
|nqueens   |   44658722|   1.051 s|    0.79 s|  +33.04%|
|qsort	   |  275000250|   1.978 s|   1.517 s|  +30.39%|

Author: qwe661234

src/jit.c

@@ -1339,18 +1339,19 @@ static void ra_load2_sext(struct jit_state *state,
 void parse_branch_history_table(struct jit_state *state, rv_insn_t *ir)
 {
     int max_idx = 0;
+    branch_history_table_t *bt = ir->branch_table;
     for (int i = 0; i < HISTORY_SIZE; i++) {
-        if (!ir->branch_table->times[i])
+        if (!bt->times[i])
             break;
-        if (ir->branch_table->times[max_idx] < ir->branch_table->times[i])
+        if (bt->times[max_idx] < bt->times[i])
             max_idx = i;
     }
-    if (ir->branch_table->PC[max_idx]) {
-        emit_load_imm(state, register_map[0], ir->branch_table->PC[max_idx]);
+    if (bt->PC[max_idx]) {
+        emit_load_imm(state, register_map[0], bt->PC[max_idx]);
         emit_cmp32(state, temp_reg, register_map[0]);
         uint32_t jump_loc = state->offset;
         emit_jcc_offset(state, 0x85);
-        emit_jmp(state, ir->branch_table->PC[max_idx]);
+        emit_jmp(state, bt->PC[max_idx]);
         emit_jump_target_offset(state, JUMP_LOC, state->offset);
     }
 }
@@ -1551,18 +1552,18 @@ static void translate_chained_block(struct jit_state *state,
         if (block1->translatable)
             translate_chained_block(state, rv, block1, set);
     }
-    if (ir->branch_table) {
+    branch_history_table_t *bt = ir->branch_table;
+    if (bt) {
         int max_idx = 0;
         for (int i = 0; i < HISTORY_SIZE; i++) {
-            if (!ir->branch_table->times[i])
+            if (!bt->times[i])
                 break;
-            if (ir->branch_table->times[max_idx] < ir->branch_table->times[i])
+            if (bt->times[max_idx] < bt->times[i])
                 max_idx = i;
         }
-        if (ir->branch_table->PC[max_idx] &&
-            !set_has(set, ir->branch_table->PC[max_idx])) {
-            block_t *block1 = cache_get(rv->block_cache,
-                                        ir->branch_table->PC[max_idx], false);
+        if (bt->PC[max_idx] && !set_has(set, bt->PC[max_idx])) {
+            block_t *block1 =
+                cache_get(rv->block_cache, bt->PC[max_idx], false);
             if (block1 && block1->translatable)
                 translate_chained_block(state, rv, block1, set);
         }

src/rv32_template.c

@@ -107,11 +107,16 @@
  * |                                | store the result into dst.             |
  * | cond, src;                     | set condition if (src)                 |
  * | end;                           | set the end of condition if (src)      |
+ * | parsebt;                       | parse the branch table of indirect     |
+ * |                                | jump and search the jump target with   |
+ * |                                | maxiumal frequency. Then, comparing    |
+ * |                                | and jumping to the target if the       |
+ * |                                | program counter matches.               |
  * | break;                         | In the end of a basic block, we need   |
  * |                                | to store all VM register value to rv   |
  * |                                | data, becasue the register allocation  |
  * |                                | is only applied on a basic block.      |
- */
+ * /
 
 /* Internal */
 RVOP(
@@ -276,7 +281,7 @@ RVOP(
         alu32imm, 32, 0x81, 0, TMP, imm;
         alu32imm, 32, 0x81, 4, TMP, ~1U;
         break;
-        bht;
+        parsebt;
         st, S32, TMP, PC;
         exit;
     }))