Fix signedness mismatches with bytecode definition in spesh

src/6model/reprs/MVMSpeshLog.h

@@ -57,26 +57,26 @@ struct MVMSpeshLogEntry {
         struct {
             MVMObject *type;
             MVMint32 flags;
-            MVMint32 bytecode_offset;
+            MVMuint32 bytecode_offset;
         } type;
 
         /* Observed value (STATIC). */
         struct {
             MVMObject *value;
-            MVMint32 bytecode_offset;
+            MVMuint32 bytecode_offset;
         } value;
 
         /* Observed invocation (INVOKE). */
         struct {
             MVMStaticFrame *sf;
             MVMint16 caller_is_outer;
             MVMuint16 was_multi;
-            MVMint32 bytecode_offset;
+            MVMuint32 bytecode_offset;
         } invoke;
 
         /* Observed OSR point (OSR). */
         struct {
-            MVMint32 bytecode_offset;
+            MVMuint32 bytecode_offset;
         } osr;
 
         /* Spesh log resolution result (PLUGIN_RESOLUTION). */

src/jit/interface.c

@@ -62,8 +62,8 @@ void MVM_jit_code_trampoline(MVMThreadContext *tc) {
 }
 
 
-MVMint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame) {
-    MVMint32 i;
+MVMuint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame) {
+    MVMuint32 i;
     void *current_position = MVM_jit_code_get_current_position(tc, code, frame);
     for (i = 0; i < code->num_deopts; i++) {
         if (code->labels[code->deopts[i].label] == current_position) {

src/jit/interface.h

@@ -9,7 +9,7 @@ MVM_STATIC_INLINE MVMuint8 * MVM_frame_effective_bytecode(MVMFrame *f) {
 void MVM_jit_code_enter(MVMThreadContext *tc, MVMJitCode *code, MVMCompUnit *cu);
 void * MVM_jit_code_get_current_position(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame);
 void MVM_jit_code_set_current_position(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame, void *position);
-MVMint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame);
+MVMuint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame);
 /* split iterators because we don't want to allocate on this path */
 MVMint32 MVM_jit_code_get_active_handlers(MVMThreadContext *tc, MVMJitCode *code, void *current_position, MVMint32 i);
 MVMint32 MVM_jit_code_get_active_inlines(MVMThreadContext *tc, MVMJitCode *code, void *current_position, MVMint32 i);

src/jit/stub.c

@@ -37,7 +37,7 @@ MVMint32 MVM_jit_code_get_active_inlines(MVMThreadContext *tc, MVMJitCode *code,
     return 0;
 }
 
-MVMint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame) {
+MVMuint32 MVM_jit_code_get_active_deopt_idx(MVMThreadContext *tc, MVMJitCode *code, MVMFrame *frame) {
     return 0;
 }
 

src/spesh/candidate.c

@@ -5,7 +5,7 @@
 static void calculate_work_env_sizes(MVMThreadContext *tc, MVMStaticFrame *sf,
                                      MVMSpeshCandidate *c) {
     MVMuint32 max_callsite_size, jit_spill_size;
-    MVMint32 i;
+    MVMuint32 i;
 
     max_callsite_size = sf->body.cu->body.max_callsite_size;
     jit_spill_size = (c->jitcode ? c->jitcode->spill_size: 0);

src/spesh/codegen.c

@@ -21,8 +21,8 @@ typedef struct {
     /* Fixups we need to do by basic block. */
     MVMint32    *fixup_locations;
     MVMSpeshBB **fixup_bbs;
-    MVMint32     num_fixups;
-    MVMint32     alloc_fixups;
+    MVMuint32    num_fixups;
+    MVMuint32    alloc_fixups;
 
     /* Copied frame handlers (which we'll update offsets of). */
     MVMFrameHandler *handlers;
@@ -87,7 +87,7 @@ static void collect_deopt_users(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpesh
         MVMSpeshIns *ins = users->user;
         if (ins->info->opcode == MVM_SSA_PHI) {
             MVMint32 seen = 0;
-            MVMint32 i;
+            MVMuint32 i;
             for (i = 0; i < MVM_VECTOR_ELEMS(all_deopt_users->seen_phis); i++) {
                 if (all_deopt_users->seen_phis[i] == ins) {
                     seen = 1;
@@ -234,7 +234,7 @@ static void write_instructions(MVMThreadContext *tc, MVMSpeshGraph *g, SpeshWrit
                         write_int32(ws, ins->operands[i].lit_str_idx);
                         break;
                     case MVM_operand_ins: {
-                        MVMint32 bb_idx = ins->operands[i].ins_bb->idx;
+                        MVMuint32 bb_idx = ins->operands[i].ins_bb->idx;
                         MVMint32 offset;
                         if (bb_idx >= g->num_bbs)
                             MVM_panic(1, "Spesh codegen: out of range BB index %d", bb_idx);
@@ -322,7 +322,7 @@ static void write_instructions(MVMThreadContext *tc, MVMSpeshGraph *g, SpeshWrit
 MVMSpeshCode * MVM_spesh_codegen(MVMThreadContext *tc, MVMSpeshGraph *g) {
     MVMSpeshCode *res;
     MVMSpeshBB   *bb;
-    MVMint32      i, hanlen;
+    MVMuint32     i, hanlen;
 
     /* Initialize writer state. */
     SpeshWriterState *ws     = MVM_malloc(sizeof(SpeshWriterState));
@@ -386,9 +386,9 @@ MVMSpeshCode * MVM_spesh_codegen(MVMThreadContext *tc, MVMSpeshGraph *g) {
             ws->handlers[i].end_offset = -1;
             ws->handlers[i].goto_offset = -1;
         }
-        else if (ws->handlers[i].start_offset == -1 ||
-                 ws->handlers[i].end_offset   == -1 ||
-                 ws->handlers[i].goto_offset  == -1) {
+        else if (ws->handlers[i].start_offset == (MVMuint32)-1 ||
+                 ws->handlers[i].end_offset   == (MVMuint32)-1 ||
+                 ws->handlers[i].goto_offset  == (MVMuint32)-1) {
             MVM_oops(tc, "Spesh: failed to fix up handler %d in %s (%d, %d, %d)",
                 i,
                 MVM_string_utf8_maybe_encode_C_string(tc, g->sf->body.name),
@@ -405,7 +405,7 @@ MVMSpeshCode * MVM_spesh_codegen(MVMThreadContext *tc, MVMSpeshGraph *g) {
             g->inlines[i].end = -1;
         }
         else {
-            if (g->inlines[i].start == -1 || g->inlines[i].end == -1)
+            if (g->inlines[i].start == (MVMuint32)-1 || g->inlines[i].end == (MVMuint32)-1)
                 MVM_oops(tc, "Spesh: failed to fix up inline %d (%s) %d %d",
                     i,
                     MVM_string_utf8_maybe_encode_C_string(tc, g->inlines[i].sf->body.name),

src/spesh/dead_bb_elimination.c

@@ -121,7 +121,7 @@ void MVM_spesh_eliminate_dead_bbs(MVMThreadContext *tc, MVMSpeshGraph *g, MVMint
 
     /* First pass: mark every basic block that is reachable from the
      * entrypoint. */
-    MVMint32  orig_bbs = g->num_bbs;
+    MVMuint32 orig_bbs = g->num_bbs;
     MVMint8  *seen = MVM_calloc(1, g->num_bbs);
     mark_bb_seen(tc, g->entry, seen);
 

src/spesh/deopt.c

@@ -22,12 +22,12 @@ MVM_STATIC_INLINE void clear_dynlex_cache(MVMThreadContext *tc, MVMFrame *f) {
  * are running the de-optimized code. We may, of course, be in the original,
  * non-inline, bit of the code - in which case we've nothing to do. */
 static void uninline(MVMThreadContext *tc, MVMFrame *f, MVMSpeshCandidate *cand,
-                     MVMint32 offset, MVMint32 deopt_offset, MVMFrame *callee) {
+                     MVMuint32 offset, MVMuint32 deopt_offset, MVMFrame *callee) {
     MVMFrame      *last_uninlined = NULL;
     MVMuint16      last_res_reg = 0;
     MVMReturnType  last_res_type = 0;
     MVMuint32      last_return_deopt_idx = 0;
-    MVMint32 i;
+    MVMuint32 i;
     for (i = 0; i < cand->num_inlines; i++) {
         if (offset > cand->inlines[i].start && offset <= cand->inlines[i].end) {
             /* Create the frame. */
@@ -215,7 +215,7 @@ static void materialize_object(MVMThreadContext *tc, MVMFrame *f, MVMObject ***m
 
 /* Materialize all replaced objects that need to be at this deopt index. */
 static void materialize_replaced_objects(MVMThreadContext *tc, MVMFrame *f, MVMint32 deopt_index) {
-    MVMint32 i;
+    MVMuint32 i;
     MVMSpeshCandidate *cand = f->spesh_cand;
     MVMuint32 num_deopt_points = MVM_VECTOR_ELEMS(cand->deopt_pea.deopt_point);
     MVMObject **materialized = NULL;
@@ -312,7 +312,7 @@ MVMint32 MVM_spesh_deopt_find_inactive_frame_deopt_idx(MVMThreadContext *tc, MVM
     /* Is it JITted code? */
     if (f->spesh_cand->jitcode) {
         MVMJitCode *jitcode = f->spesh_cand->jitcode;
-        MVMint32 idx = MVM_jit_code_get_active_deopt_idx(tc, jitcode, f);
+        MVMuint32 idx = MVM_jit_code_get_active_deopt_idx(tc, jitcode, f);
         if (idx < jitcode->num_deopts) {
             MVMint32 deopt_idx = jitcode->deopts[idx].idx;
 #if MVM_LOG_DEOPTS

src/spesh/dump.c

@@ -567,7 +567,7 @@ static void dump_callsite(MVMThreadContext *tc, DumpStr *ds, MVMCallsite *cs) {
 static void dump_fileinfo(MVMThreadContext *tc, DumpStr *ds, MVMStaticFrame *sf) {
     MVMBytecodeAnnotation *ann = MVM_bytecode_resolve_annotation(tc, &sf->body, 0);
     MVMCompUnit            *cu = sf->body.cu;
-    MVMint32           str_idx = ann ? ann->filename_string_heap_index : 0;
+    MVMuint32          str_idx = ann ? ann->filename_string_heap_index : 0;
     MVMint32           line_nr = ann ? ann->line_number : 1;
     MVMString        *filename = cu->body.filename;
     char        *filename_utf8 = "<unknown>";
@@ -583,7 +583,7 @@ static void dump_fileinfo(MVMThreadContext *tc, DumpStr *ds, MVMStaticFrame *sf)
 }
 
 static void dump_deopt_pea(MVMThreadContext *tc, DumpStr *ds, MVMSpeshGraph *g) {
-    MVMint32 i, j;
+    MVMuint32 i, j;
     if (MVM_VECTOR_ELEMS(g->deopt_pea.materialize_info)) {
         append(ds, "\nMaterializations:\n");
         for (i = 0; i < MVM_VECTOR_ELEMS(g->deopt_pea.materialize_info); i++) {

src/spesh/facts.c

@@ -759,7 +759,7 @@ static void add_bb_facts(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB *bb,
  * instructions that install the block eliminated. This tweaks the usage of
  * them. */
 static void tweak_block_handler_usage(MVMThreadContext *tc, MVMSpeshGraph *g) {
-    MVMint32 i;
+    MVMuint32 i;
     for (i = 0; i < g->sf->body.num_handlers; i++) {
         if (g->sf->body.handlers[i].action == MVM_EX_ACTION_INVOKE) {
             MVMSpeshOperand operand;

src/spesh/frame_walker.c

@@ -46,14 +46,14 @@ static void go_to_next_inline(MVMThreadContext *tc, MVMSpeshFrameWalker *fw) {
     if (fw->inline_idx == NO_INLINE)
         return;
     if (jitcode) {
-        MVMint32 idx = MVM_jit_code_get_active_inlines(tc, jitcode, fw->jit_position, fw->inline_idx + 1);
+        MVMuint32 idx = MVM_jit_code_get_active_inlines(tc, jitcode, fw->jit_position, fw->inline_idx + 1);
         if (idx < jitcode->num_inlines) {
             fw->inline_idx = idx;
             return;
         }
     }
     else {
-        MVMint32 i;
+        MVMuint32 i;
         for (i = fw->inline_idx + 1; i < cand->num_inlines; i++) {
             if (fw->deopt_offset > cand->inlines[i].start && fw->deopt_offset <= cand->inlines[i].end) {
                 /* Found an applicable inline. */
@@ -77,7 +77,7 @@ static void go_to_first_inline(MVMThreadContext *tc, MVMSpeshFrameWalker *fw, MV
             void *current_position = prev && prev->extra && prev->extra->caller_jit_position
                 ? prev->extra->caller_jit_position
                 : MVM_jit_code_get_current_position(tc, jitcode, f);
-            MVMint32 idx = MVM_jit_code_get_active_inlines(tc, jitcode, current_position, 0);
+            MVMuint32 idx = MVM_jit_code_get_active_inlines(tc, jitcode, current_position, 0);
             if (idx < jitcode->num_inlines) {
                 fw->jit_position = current_position;
                 fw->inline_idx = idx;

src/spesh/frame_walker.h

@@ -7,7 +7,7 @@ struct MVMSpeshFrameWalker {
      * or deopt offset to look for them based on, together with the current inline
      * we are looking at. */
     void *jit_position;
-    MVMint32 deopt_offset;
+    MVMuint32 deopt_offset;
     MVMint32 inline_idx;
 
     /* If we're doing a walk of outer frames too, the current outer frame that

src/spesh/graph.c

@@ -180,7 +180,7 @@ static void build_cfg(MVMThreadContext *tc, MVMSpeshGraph *g, MVMStaticFrame *sf
     MVMBytecodeAnnotation *ann_ptr = MVM_bytecode_resolve_annotation(tc, &sf->body, sf->body.bytecode - pc);
 
     for (i = 0; i < g->num_handlers; i++) {
-        if (g->handlers[i].start_offset != -1 && g->handlers[i].goto_offset != -1) {
+        if (g->handlers[i].start_offset != (MVMuint32)-1 && g->handlers[i].goto_offset != (MVMuint32)-1) {
             byte_to_ins_flags[g->handlers[i].start_offset] |= MVM_CFG_BB_START;
             byte_to_ins_flags[g->handlers[i].end_offset] |= MVM_CFG_BB_START;
             byte_to_ins_flags[g->handlers[i].goto_offset] |= MVM_CFG_BB_START;
@@ -412,7 +412,7 @@ static void build_cfg(MVMThreadContext *tc, MVMSpeshGraph *g, MVMStaticFrame *sf
         /* Start or got may be -1 if the code the handler covered became
          * dead. If so, mark the handler as removed. Ditto if end is
          * before start (would never match). */
-        if (g->handlers[i].start_offset == -1 || g->handlers[i].goto_offset == -1 ||
+        if (g->handlers[i].start_offset == (MVMuint32)-1 || g->handlers[i].goto_offset == (MVMuint32)-1 ||
                 g->handlers[i].start_offset > g->handlers[i].end_offset) {
             if (!g->unreachable_handlers)
                 g->unreachable_handlers = MVM_spesh_alloc(tc, g, g->num_handlers);
@@ -556,7 +556,7 @@ static void build_cfg(MVMThreadContext *tc, MVMSpeshGraph *g, MVMStaticFrame *sf
             for (i = 0; i < g->num_handlers; i++) {
                 if (is_catch_handler(tc, g, i)) {
                     MVMuint32 offset = g->handlers[i].goto_offset;
-                    if (offset != -1)
+                    if (offset != (MVMuint32)-1)
                         cur_bb->succ[insert_pos++] = ins_to_bb[byte_to_ins_flags[offset] >> 3];
                 }
             }
@@ -830,7 +830,7 @@ MVMSpeshBB ** MVM_spesh_graph_reverse_postorder(MVMThreadContext *tc, MVMSpeshGr
 static void iter_check(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB **rpo, MVMint32 *doms, MVMint32 iters) {
     if (iters > 100000) {
 #ifdef NDEBUG
-        MVMint32 k;
+        MVMuint32 k;
         char *dump_msg = MVM_spesh_dump(tc, g);
         printf("%s", dump_msg);
         MVM_free(dump_msg);
@@ -864,7 +864,7 @@ static MVMint32 intersect(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB **r
 
 /* Computes dominator information about the basic blocks. */
 static MVMint32 * compute_dominators(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB **rpo) {
-    MVMint32 i, j, changed;
+    MVMuint32 i, j, changed;
 
     /* Create result list, with all initialized to undefined (use -1, as it's
      * not a valid basic block index). Start node dominates itself. */
@@ -898,7 +898,7 @@ static MVMint32 * compute_dominators(MVMThreadContext *tc, MVMSpeshGraph *g, MVM
                 MVM_oops(tc, "Spesh: could not find processed initial dominator");
             }
             for (j = 0; j < b->num_pred; j++) {
-                if (j != chosen_pred) {
+                if (j != (MVMuint32)chosen_pred) {
                     MVMint32 p_idx = b->pred[j]->rpo_idx;
                     if (doms[p_idx] != -1)
                         new_idom = intersect(tc, g, rpo, doms, p_idx, new_idom);
@@ -933,11 +933,11 @@ static void add_child(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB *target
     target->num_children++;
 }
 static void add_children(MVMThreadContext *tc, MVMSpeshGraph *g, MVMSpeshBB **rpo, MVMint32 *doms) {
-    MVMint32 i;
+    MVMuint32 i;
     for (i = 0; i < g->num_bbs; i++) {
         MVMSpeshBB *bb   = rpo[i];
-        MVMint32    idom = doms[i];
-        if (idom != i)
+        MVMuint32   idom = doms[i];
+        if ((MVMuint32)idom != i)
             add_child(tc, g, rpo[idom], bb);
     }
 }

src/spesh/graph.h

@@ -48,17 +48,17 @@ struct MVMSpeshGraph {
     MVMCollectable **spesh_slots;
 
     /* Number of spesh slots we have used and allocated. */
-    MVMint32 num_spesh_slots;
-    MVMint32 alloc_spesh_slots;
+    MVMuint16 num_spesh_slots;
+    MVMuint16 alloc_spesh_slots;
 
     /* De-opt indexes, as pairs of integers. The first integer, set when we
      * build the graph, is the return address in the original bytecode. The
      * code-gen phase for the specialized bytecode will fill in the second
      * integers afterwards, which are the return address in the specialized
      * bytecode. */
     MVMint32 *deopt_addrs;
-    MVMint32  num_deopt_addrs;
-    MVMint32  alloc_deopt_addrs;
+    MVMuint32 num_deopt_addrs;
+    MVMuint32 alloc_deopt_addrs;
 
     /* Bit field of named args used to put in place during deopt, since we
      * don't typically don't update the array in specialized code. */
@@ -80,7 +80,7 @@ struct MVMSpeshGraph {
     MVMuint32 num_inlines;
 
     /* Number of basic blocks we have. */
-    MVMint32 num_bbs;
+    MVMuint32 num_bbs;
 
     /* The list of local types (only set up if we do inlines). */
     MVMuint16 *local_types;
@@ -243,7 +243,7 @@ struct MVMSpeshAnn {
 
     /* Data (meaning depends on type). */
     union {
-        MVMint32 frame_handler_index;
+        MVMuint32 frame_handler_index;
         MVMint32 deopt_idx;
         MVMint32 inline_idx;
         MVMuint32 bytecode_offset;

src/spesh/inline.c

@@ -223,7 +223,7 @@ static void add_deopt_usages(MVMThreadContext *tc, MVMSpeshGraph *g, MVMint32 *d
 
 /* Get the maximum inline size applicable to the specified static frame (it can
  * be configured by language). */
-int MVM_spesh_inline_get_max_size(MVMThreadContext *tc, MVMStaticFrame *sf) {
+MVMuint32 MVM_spesh_inline_get_max_size(MVMThreadContext *tc, MVMStaticFrame *sf) {
     return sf->body.cu->body.hll_config->max_inline_size;
 }
 
@@ -320,7 +320,7 @@ MVMSpeshGraph * MVM_spesh_inline_try_get_graph_from_unspecialized(MVMThreadConte
 }
 
 /* Finds the deopt index of the return. */
-static MVMint32 return_deopt_idx(MVMThreadContext *tc, MVMSpeshIns *invoke_ins) {
+static MVMuint32 return_deopt_idx(MVMThreadContext *tc, MVMSpeshIns *invoke_ins) {
     MVMSpeshAnn *ann = invoke_ins->annotations;
     while (ann) {
         if (ann->type == MVM_SPESH_ANN_DEOPT_ALL_INS)
@@ -384,7 +384,7 @@ static void fix_wval(MVMThreadContext *tc, MVMSpeshGraph *inliner,
     MVMint64     idx      = to_fix->info->opcode == MVM_OP_wval
         ? to_fix->operands[2].lit_i16
         : to_fix->operands[2].lit_i64;
-    if (dep >= 0 && dep < sourcecu->body.num_scs) {
+    if (dep >= 0 && (MVMuint16)dep < sourcecu->body.num_scs) {
         MVMSerializationContext *sc = MVM_sc_get_sc(tc, sourcecu, dep);
         if (sc) {
             MVMuint16 otherdep;
@@ -520,7 +520,7 @@ static MVMSpeshBB * merge_graph(MVMThreadContext *tc, MVMSpeshGraph *inliner,
                  MVMCallsite *cs) {
     MVMSpeshFacts **merged_facts;
     MVMuint16      *merged_fact_counts;
-    MVMint32        i, j, orig_inlines, total_inlines, orig_deopt_addrs,
+    MVMuint32        i, j, orig_inlines, total_inlines, orig_deopt_addrs,
                     orig_deopt_pea_mat_infos, impl_deopt_idx;
     MVMuint32       total_handlers = inliner->num_handlers + inlinee->num_handlers + 1;
     MVMSpeshBB     *inlinee_first_bb = NULL, *inlinee_last_bb = NULL;
@@ -541,11 +541,11 @@ static MVMSpeshBB * merge_graph(MVMThreadContext *tc, MVMSpeshGraph *inliner,
     impl_deopt_idx = return_deopt_idx(tc, invoke_ins);
     MVM_VECTOR_INIT(regs_for_deopt, 0);
     for (i = 0; i < inliner->sf->body.num_locals; i++) {
-        MVMint32 vers = inliner->fact_counts[i];
+        MVMuint16 vers = inliner->fact_counts[i];
         for (j = 0; j < vers; j++) {
             MVMSpeshDeoptUseEntry *due = inliner->facts[i][j].usage.deopt_users;
             while (due) {
-                if (due->deopt_idx == impl_deopt_idx) {
+                if ((MVMuint32)due->deopt_idx == impl_deopt_idx) {
                     MVMSpeshOperand o;
                     o.reg.orig = i;
                     o.reg.i = j;

src/spesh/inline.h

@@ -65,4 +65,4 @@ void MVM_spesh_inline(MVMThreadContext *tc, MVMSpeshGraph *inliner,
     MVMSpeshCallInfo *call_info, MVMSpeshBB *invoke_bb,
     MVMSpeshIns *invoke, MVMSpeshGraph *inlinee, MVMStaticFrame *inlinee_sf,
     MVMSpeshOperand code_ref_reg, MVMuint32 proxy_deopt_idx, MVMuint16 bytecode_size);
-int MVM_spesh_inline_get_max_size(MVMThreadContext *tc, MVMStaticFrame *sf);
+MVMuint32 MVM_spesh_inline_get_max_size(MVMThreadContext *tc, MVMStaticFrame *sf);