compile.c: deduplicate inline constant caches

If a method reference the same constant twice or more, it can
use a single constant cache for all the instructions.

```ruby
puts RubyVM::InstructionSequence.compile(<<~RUBY).disasm
  Foo::Bar + Foo::Bar + Bar + Bar
RUBY
```

Before

```
== disasm: #<ISeq:<compiled>@<compiled>:1 (1,0)-(1,31)>
0000 opt_getconstant_path                   <ic:0 Foo::Bar>           (   1)[Li]
0002 opt_getconstant_path                   <ic:1 Foo::Bar>
0004 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0006 opt_getconstant_path                   <ic:2 Bar>
0008 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0010 opt_getconstant_path                   <ic:3 Bar>
0012 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0014 leave
```

After:

```
== disasm: #<ISeq:<compiled>@<compiled>:1 (1,0)-(1,31)>
0000 opt_getconstant_path                   <ic:0 Foo::Bar>           (   1)[Li]
0002 opt_getconstant_path                   <ic:0 Foo::Bar>
0004 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0006 opt_getconstant_path                   <ic:1 Bar>
0008 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0010 opt_getconstant_path                   <ic:1 Bar>
0012 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
0014 leave
```

Author: byroot

compile.c

@@ -2518,7 +2518,12 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *const anchor)
 
     if (stack_max < 0) return COMPILE_NG;
 
-    /* fix label position */
+    VALUE ic_table = 0;
+    if (ISEQ_BODY(iseq)->ic_size > 1) {
+        ic_table = rb_hash_new_capa(ISEQ_BODY(iseq)->ic_size);
+    }
+
+    /* fix label position and deduplicate ICs */
     insn_num = code_index = 0;
     for (list = FIRST_ELEMENT(anchor); list; list = list->next) {
         switch (list->type) {
@@ -2547,6 +2552,33 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *const anchor)
                 code_index += insn_data_length(iobj);
                 events = 0;
                 data = 0;
+
+                /* deduplicate ICs */
+                if (ic_table) {
+                    int insn = iobj->insn_id;
+                    VALUE *operands = iobj->operands;
+                    const char *types = insn_op_types(insn);
+
+                    for (int j = 0; types[j]; j++) {
+                        char type = types[j];
+
+                        switch (type) {
+                          case TS_IC: /* inline cache: constants */
+                            {
+                                VALUE segments = operands[j];
+                                VALUE ic_index = rb_hash_lookup2(ic_table, segments, Qfalse);
+                                if (ic_index) {
+                                    ISEQ_BODY(iseq)->ic_size--;
+                                }
+                                else {
+                                    rb_hash_aset(ic_table, segments, UINT2NUM(ISEQ_COMPILE_DATA(iseq)->ic_index++));
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+
                 break;
             }
           case ISEQ_ELEMENT_LABEL:
@@ -2692,16 +2724,26 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *const anchor)
                       /* [ TS_IVC | TS_ICVARC | TS_ISE | TS_IC ] */
                       case TS_IC: /* inline cache: constants */
                         {
-                            unsigned int ic_index = ISEQ_COMPILE_DATA(iseq)->ic_index++;
-                            IC ic = &ISEQ_IS_ENTRY_START(body, type)[ic_index].ic_cache;
+                            unsigned int ic_index;
+                            if (ic_table) {
+                                VALUE val = rb_hash_lookup2(ic_table, operands[j], Qnil);
+                                ic_index = NUM2UINT(val);
+                            }
+                            else {
+                                ic_index = ISEQ_COMPILE_DATA(iseq)->ic_index++;
+                            }
+
                             if (UNLIKELY(ic_index >= body->ic_size)) {
                                 BADINSN_DUMP(anchor, &iobj->link, 0);
                                 COMPILE_ERROR(iseq, iobj->insn_info.line_no,
                                               "iseq_set_sequence: ic_index overflow: index: %d, size: %d",
                                               ic_index, ISEQ_IS_SIZE(body));
                             }
 
-                            ic->segments = array_to_idlist(operands[j]);
+                            IC ic = &ISEQ_IS_ENTRY_START(body, type)[ic_index].ic_cache;
+                            if (!ic->segments) {
+                                ic->segments = array_to_idlist(operands[j]);
+                            }
 
                             generated_iseq[code_index + 1 + j] = (VALUE)ic;
                         }
@@ -2828,6 +2870,10 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *const anchor)
         list = list->next;
     }
 
+    if (ic_table) {
+        rb_hash_clear(ic_table);
+    }
+
     body->iseq_encoded = (void *)generated_iseq;
     body->iseq_size = code_index;
     body->stack_max = stack_max;