diff --git a/src/racket/src/bignum.c b/src/racket/src/bignum.c
index 1b871ed8e5..b17105ac93 100644
--- a/src/racket/src/bignum.c
+++ b/src/racket/src/bignum.c
@@ -1213,7 +1213,7 @@ char *scheme_bignum_to_allocated_string(const Scheme_Object *b, int radix, int a
 {
   Scheme_Object *c;
   unsigned char* str, *str2;
-  intptr_t i, slen, start, clen;
+  intptr_t i, slen, start;
   bigdig *c_digs;
   SAFE_SPACE(csd)
 
@@ -1244,8 +1244,7 @@ char *scheme_bignum_to_allocated_string(const Scheme_Object *b, int radix, int a
   str = (unsigned char *)MALLOC_PROTECT(slen);
 
   c_digs = SCHEME_BIGDIG_SAFE(c, csd);
-  clen = SCHEME_BIGLEN(c);
-  PROTECT(c_digs, clen);
+  PROTECT(c_digs, SCHEME_BIGLEN(c));
 
   slen = mpn_get_str(str, radix, c_digs, SCHEME_BIGLEN(c) - 1);
 
diff --git a/src/racket/src/codetab.inc b/src/racket/src/codetab.inc
index 9aaafa24d8..b4e7b9df35 100644
--- a/src/racket/src/codetab.inc
+++ b/src/racket/src/codetab.inc
@@ -237,7 +237,7 @@ static int do_clear_symbols(void **t, uintptr_t start, int offset, uintptr_t add
   /* If MZ_PRECISE_GC, then offset and addr are not used. */
 {
   int i, m, j;
-  void *p, *val, **subt;
+  void *val, **subt;
 
   /* Note: this function might be called  (via a GC callback)
      while add_symbol is running. */
@@ -250,7 +250,7 @@ static int do_clear_symbols(void **t, uintptr_t start, int offset, uintptr_t add
 	/* GCable pointer starts here */
 #ifndef MZ_PRECISE_GC
 	/* Conservative GC: GCable flag means use GC_is_marked */
-	p = (void *)(addr + ((uintptr_t)i << offset));
+	void *p = (void *)(addr + ((uintptr_t)i << offset));
 	if (!GC_is_marked(p))
 	  clearing = 1;
 #else
diff --git a/src/racket/src/compile.c b/src/racket/src/compile.c
index e900150baf..18b189b564 100644
--- a/src/racket/src/compile.c
+++ b/src/racket/src/compile.c
@@ -3356,7 +3356,7 @@ static Scheme_Object *
 begin_for_syntax_expand(Scheme_Object *orig_form, Scheme_Comp_Env *in_env, Scheme_Expand_Info *rec, int drec)
 {
   Scheme_Expand_Info recs[1];
-  Scheme_Object *form, *context_key, *l, *fn, *vec, *dummy;
+  Scheme_Object *form, *l, *fn, *vec, *dummy;
   Scheme_Comp_Env *env;
 
   SCHEME_EXPAND_OBSERVE_PRIM_BEGIN_FOR_SYNTAX(rec[drec].observer);
@@ -3383,8 +3383,6 @@ begin_for_syntax_expand(Scheme_Object *orig_form, Scheme_Comp_Env *in_env, Schem
   else
     dummy = NULL;
 
-  context_key = scheme_generate_lifts_key();
-  
   l = SCHEME_STX_CDR(form);
   form = scheme_null;
 
diff --git a/src/racket/src/hash.c b/src/racket/src/hash.c
index 1f43fbbbae..7ce5642367 100644
--- a/src/racket/src/hash.c
+++ b/src/racket/src/hash.c
@@ -1818,8 +1818,10 @@ typedef struct RBNode {
 
 #if 0
 # define RB_ASSERT(p) if (p) { } else { scheme_signal_error("hash-tree assert failure %d", __LINE__); }
+# define RB_ASSERT_ONLY(x) x
 #else
 # define RB_ASSERT(p) /* empty */
+# define RB_ASSERT_ONLY(x) /* empty */
 #endif
 
 static RBNode *make_rb(int red, 
@@ -2573,9 +2575,9 @@ int scheme_hash_tree_index(Scheme_Hash_Tree *tree, intptr_t pos, Scheme_Object *
   else
     elems = NULL;
   if (!elems) {
-    int total_pos;
+    RB_ASSERT_ONLY(int total_pos);
     elems = scheme_make_vector(tree->count * 2, NULL);
-    total_pos = fill_elems(tree->root, elems, 0, tree->count);
+    RB_ASSERT_ONLY(total_pos = ) fill_elems(tree->root, elems, 0, tree->count);
     RB_ASSERT(total_pos == tree->count);
     elems_box = scheme_make_weak_box(elems);
     tree->elems_box = elems_box;
diff --git a/src/racket/src/jit.c b/src/racket/src/jit.c
index 7811f3237b..ba751ed172 100644
--- a/src/racket/src/jit.c
+++ b/src/racket/src/jit.c
@@ -1118,8 +1118,7 @@ static int generate_closure(Scheme_Closure_Data *data,
                             int immediately_filled)
 {
   Scheme_Native_Closure_Data *code;
-  int retptr;
-  
+
   ensure_closure_native(data, NULL);
   code = data->u.native_code;
 
@@ -1156,8 +1155,7 @@ static int generate_closure(Scheme_Closure_Data *data,
         jit_movi_l(JIT_R1, init_word);
         jit_str_l(JIT_R0, JIT_R1); 
       }
-    retptr = mz_retain(code);
-    scheme_mz_load_retained(jitter, JIT_R1, retptr);
+    scheme_mz_load_retained(jitter, JIT_R1, code);
     jit_stxi_p((intptr_t)&((Scheme_Native_Closure *)0x0)->code, JIT_R0, JIT_R1);
 
     return 1;
@@ -1167,12 +1165,7 @@ static int generate_closure(Scheme_Closure_Data *data,
   JIT_UPDATE_THREAD_RSPTR_IF_NEEDED();
 
   mz_prepare(1);
-  retptr = mz_retain(code);
-#ifdef JIT_PRECISE_GC
-  scheme_mz_load_retained(jitter, JIT_R0, retptr);
-#else
-  (void)jit_patchable_movi_p(JIT_R0, code); /* !! */
-#endif
+  scheme_mz_load_retained(jitter, JIT_R0, code);
   jit_pusharg_p(JIT_R0);
   {
     GC_CAN_IGNORE jit_insn *refr;
@@ -1295,7 +1288,7 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t
   Scheme_Native_Closure_Data *ndata;
   Scheme_Closure_Data *data;
   Scheme_Object *o;
-  int i, offset, count, retptr;
+  int i, offset, count;
 
   ensure_case_closure_native(c);
   ndata = c->native_code;
@@ -1304,12 +1297,7 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t
 
   JIT_UPDATE_THREAD_RSPTR_IF_NEEDED();
   mz_prepare(1);
-  retptr = mz_retain(ndata);
-#ifdef JIT_PRECISE_GC
-  scheme_mz_load_retained(jitter, JIT_R0, retptr);
-#else
-  (void)jit_patchable_movi_p(JIT_R0, ndata); /* !! */
-#endif
+  scheme_mz_load_retained(jitter, JIT_R0, ndata);
   jit_pusharg_p(JIT_R0);
   {
     GC_CAN_IGNORE jit_insn *refr;
@@ -2947,7 +2935,6 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
 
       return 1;
     } else if (!result_ignored) {
-      int retptr;
       Scheme_Type type = SCHEME_TYPE(obj);
       START_JIT_DATA();
 
@@ -2966,21 +2953,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
 	}
       }
 
-      if (!SCHEME_INTP(obj)
-	  && !SAME_OBJ(obj, scheme_true)
-	  && !SAME_OBJ(obj, scheme_false)
-	  && !SAME_OBJ(obj, scheme_void)
-	  && !SAME_OBJ(obj, scheme_null)) {
-	retptr = mz_retain(obj);
-      } else
-	retptr = 0;
-
-#ifdef JIT_PRECISE_GC
-      if (retptr)
-	scheme_mz_load_retained(jitter, target, retptr);
-      else
-#endif
-	(void)jit_patchable_movi_p(target, obj); /* !! */
+      scheme_mz_load_retained(jitter, target, obj);
 
       END_JIT_DATA(19);
       return 1;
diff --git a/src/racket/src/jit.h b/src/racket/src/jit.h
index 00f7938b78..b36def5c0b 100644
--- a/src/racket/src/jit.h
+++ b/src/racket/src/jit.h
@@ -1110,9 +1110,7 @@ int scheme_stack_safety(mz_jit_state *jitter, int cnt, int offset);
 #ifdef USE_FLONUM_UNBOXING
 int scheme_mz_flonum_pos(mz_jit_state *jitter, int i);
 #endif
-#ifdef JIT_PRECISE_GC
-void scheme_mz_load_retained(mz_jit_state *jitter, int rs, int retptr);
-#endif
+void scheme_mz_load_retained(mz_jit_state *jitter, int rs, void *o);
 
 void scheme_mz_runstack_skipped(mz_jit_state *jitter, int n);
 void scheme_mz_runstack_unskipped(mz_jit_state *jitter, int n);
diff --git a/src/racket/src/jitarith.c b/src/racket/src/jitarith.c
index 753c3e05dc..97fabf6d07 100644
--- a/src/racket/src/jitarith.c
+++ b/src/racket/src/jitarith.c
@@ -1838,7 +1838,7 @@ static void patch_nary_branches(mz_jit_state *jitter, Branch_Info *for_nary_bran
 int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app,
                                int arith, int cmp, Branch_Info *for_branch, int branch_short)
 {
-  int c, i, non_simple_c = 0, stack_c, use_fl = 1, use_fx = 1, trigger_arg = 0;
+  int c, i, non_simple_c = 0, stack_c, use_fx = 1, trigger_arg = 0;
   Scheme_Object *non_simples[1+MAX_NON_SIMPLE_ARGS], **alt_args, *v;
   Branch_Info for_nary_branch;
   Branch_Info_Addr nary_addrs[3];
@@ -1847,6 +1847,10 @@ int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app,
 #ifdef INLINE_FP_OPS
   int args_unboxed;
   GC_CAN_IGNORE jit_insn *reffl, *refdone2;
+  int use_fl = 1;
+# define mzSET_USE_FL(x) x
+#else
+# define mzSET_USE_FL(x) /* empty */
 #endif
 
   if (arith == ARITH_DIV) {
@@ -1856,7 +1860,7 @@ int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app,
              || (arith == ARITH_IOR)
              || (arith == ARITH_XOR)) {
     /* bitwise operators are fixnum, only */
-    use_fl = 0;
+    mzSET_USE_FL(use_fl = 0);
   }
 
   c = app->num_args;
@@ -1868,7 +1872,7 @@ int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app,
       non_simple_c++;
     }
     if (SCHEME_INTP(v)) {
-      use_fl = 0;
+      mzSET_USE_FL(use_fl = 0);
       if (trigger_arg == i)
         trigger_arg++;
     } else if (SCHEME_FLOATP(v)) {
@@ -1877,7 +1881,7 @@ int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app,
         trigger_arg++;
     } else if (SCHEME_TYPE(v) >= _scheme_compiled_values_types_) {
       use_fx = 0;
-      use_fl = 0;
+      mzSET_USE_FL(use_fl = 0);
     }
   }
 
diff --git a/src/racket/src/jitcall.c b/src/racket/src/jitcall.c
index 6cc9ca86ea..b7f7197a33 100644
--- a/src/racket/src/jitcall.c
+++ b/src/racket/src/jitcall.c
@@ -379,16 +379,9 @@ int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_na
     JIT_UPDATE_THREAD_RSPTR();
   }
   if (direct_native && direct_to_code) {
-    int retptr;
     __END_SHORT_JUMPS__(num_rands < 100);
     /* load closure pointer into R0: */
-    retptr = mz_retain(direct_to_code);
-#ifdef JIT_PRECISE_GC
-    if (retptr)
-      scheme_mz_load_retained(jitter, JIT_R0, retptr);
-    else
-#endif
-      (void)jit_patchable_movi_p(JIT_R0, direct_to_code);
+    scheme_mz_load_retained(jitter, JIT_R0, direct_to_code);
     /* jump directly: */
     (void)jit_jmpi(direct_to_code->code->u.tail_code);
     /* no slow path in this mode */
@@ -927,8 +920,9 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i
   GC_CAN_IGNORE jit_insn *refslow, *refagain;
   int i, jmp_tiny, jmp_short;
   int closure_size = jitter->self_closure_size;
-  int space, offset, arg_offset, arg_tmp_offset;
+  int space, offset;
 #ifdef USE_FLONUM_UNBOXING
+  int arg_offset = 1, arg_tmp_offset;
   Scheme_Object *rand;
 #endif
 
@@ -953,10 +947,11 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i
 
   __END_TINY_OR_SHORT_JUMPS__(jmp_tiny, jmp_short);
 
-  arg_tmp_offset = offset = jitter->flostack_offset;
+  offset = jitter->flostack_offset;
   space = jitter->flostack_space;
-
-  arg_offset = 1;
+#ifdef USE_FLONUM_UNBOXING
+  arg_tmp_offset = offset;
+#endif
 
   /* Copy args to runstack after closure data: */
   mz_ld_runstack_base_alt(JIT_R2);
diff --git a/src/racket/src/jitinline.c b/src/racket/src/jitinline.c
index 4e1a8dba04..458930c7c6 100644
--- a/src/racket/src/jitinline.c
+++ b/src/racket/src/jitinline.c
@@ -1757,7 +1757,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
 
     if (SCHEME_TYPE(a1) > _scheme_values_types_) {
       /* Compare to constant: */
-      int retptr, reg_status;
+      int reg_status;
 
       mz_runstack_skipped(jitter, 2);
 
@@ -1767,14 +1767,6 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
       
       mz_runstack_unskipped(jitter, 2);
 
-      if (!SCHEME_INTP(a1)
-	  && !SCHEME_FALSEP(a1)
-	  && !SCHEME_VOIDP(a1)
-	  && !SAME_OBJ(a1, scheme_true))
-	retptr = mz_retain(a1);
-      else
-	retptr = 0;
-      
       __START_SHORT_JUMPS__(branch_short);
 
       if (for_branch) {
@@ -1784,23 +1776,23 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
 
       reg_status = mz_CURRENT_REG_STATUS_VALID();
       
-#ifdef JIT_PRECISE_GC
-      if (retptr) {
-	scheme_mz_load_retained(jitter, JIT_R1, retptr);
+      if (!SCHEME_INTP(a1)
+	  && !SCHEME_FALSEP(a1)
+	  && !SCHEME_VOIDP(a1)
+	  && !SAME_OBJ(a1, scheme_true)) {
+	scheme_mz_load_retained(jitter, JIT_R1, a1);
 	ref = jit_bner_p(jit_forward(), JIT_R0, JIT_R1);
-      } else
-#endif
+        /* In case true is a fall-through, note that the test 
+           didn't disturb R0: */
+        if (for_branch) mz_SET_R0_STATUS_VALID(reg_status);
+      } else {
 	ref = mz_bnei_p(jit_forward(), JIT_R0, a1);
+        /* In case true is a fall-through, note that the test 
+           didn't disturb R0 or R1: */
+        if (for_branch) mz_SET_REG_STATUS_VALID(reg_status);
+      }
 
       if (for_branch) {
-        /* In case true is a fall-through, note that the test 
-           didn't disturb R0 (and maybe not R1): */
-#ifdef JIT_PRECISE_GC
-        if (retptr)
-          mz_SET_R0_STATUS_VALID(reg_status);
-        else
-#endif
-          mz_SET_REG_STATUS_VALID(reg_status);
         scheme_add_branch_false(for_branch, ref);
         scheme_branch_for_true(jitter, for_branch);
         CHECK_LIMIT();
diff --git a/src/racket/src/jitstate.c b/src/racket/src/jitstate.c
index 3ec4c4ac2f..c8c57115f7 100644
--- a/src/racket/src/jitstate.c
+++ b/src/racket/src/jitstate.c
@@ -65,15 +65,29 @@ int scheme_mz_retain_it(mz_jit_state *jitter, void *v)
   return jitter->retained;
 }
 
-#ifdef JIT_PRECISE_GC
-void scheme_mz_load_retained(mz_jit_state *jitter, int rs, int retptr)
+void scheme_mz_load_retained(mz_jit_state *jitter, int rs, void *obj)
+/* obj is a pointer, but not necesarily tagged (in CGC) */
 {
-  void *p;
-  p = jitter->retain_start + retptr - 1;
-  (void)jit_patchable_movi_p(rs, p);
-  jit_ldr_p(rs, rs);
-}
+  if (!SCHEME_INTP((Scheme_Object *)obj)
+      && !SAME_OBJ((Scheme_Object *)obj, scheme_true)
+      && !SAME_OBJ((Scheme_Object *)obj, scheme_false)
+      && !SAME_OBJ((Scheme_Object *)obj, scheme_void)
+      && !SAME_OBJ((Scheme_Object *)obj, scheme_null)) {
+#ifdef JIT_PRECISE_GC
+    int retptr;
+    void *p;
+    retptr = mz_retain(obj);
+    p = jitter->retain_start + retptr - 1;
+    (void)jit_patchable_movi_p(rs, p);
+    jit_ldr_p(rs, rs);
+#else
+    mz_retain(obj);
+    (void)jit_patchable_movi_p(rs, obj);
 #endif
+  } else {
+    (void)jit_patchable_movi_p(rs, obj);
+  }
+}
 
 #if defined(MZ_USE_JIT_I386)
 double *scheme_mz_retain_double(mz_jit_state *jitter, double d)
diff --git a/src/racket/src/numstr.c b/src/racket/src/numstr.c
index 8071f0c3fd..32f5fc492f 100644
--- a/src/racket/src/numstr.c
+++ b/src/racket/src/numstr.c
@@ -413,7 +413,7 @@ Scheme_Object *scheme_read_number(const mzchar *str, intptr_t len,
   int report, delta;
   Scheme_Object *next_complain;
   int has_hash, has_expt, has_i, has_sign, has_at, has_hash_since_slash;
-  int saw_digit, saw_digit_since_slash, saw_nonzero_digit;
+  int saw_digit_since_slash, saw_nonzero_digit;
   Scheme_Object *o;
 #ifdef MZ_USE_SINGLE_FLOATS
   int sgl;
@@ -936,7 +936,7 @@ Scheme_Object *scheme_read_number(const mzchar *str, intptr_t len,
   }
 
   has_decimal = has_slash = has_hash = has_hash_since_slash = has_expt = 0;
-  saw_digit = saw_digit_since_slash = saw_nonzero_digit = 0;
+  saw_digit_since_slash = saw_nonzero_digit = 0;
   for (i = delta; i < len; i++) {
     mzchar ch = str[i];
     if (ch == '.') {
@@ -1028,7 +1028,6 @@ Scheme_Object *scheme_read_number(const mzchar *str, intptr_t len,
       }
       break;
     } else {
-      saw_digit = 1;
       saw_digit_since_slash = 1;
       if (ch != '0')
 	saw_nonzero_digit = 1;
diff --git a/src/racket/src/port.c b/src/racket/src/port.c
index 2672883e06..9ea6563481 100644
--- a/src/racket/src/port.c
+++ b/src/racket/src/port.c
@@ -9384,12 +9384,12 @@ static void close_fds_after_fork(int skip1, int skip2, int skip3)
 
 static Scheme_Object *sch_shell_execute(int c, Scheme_Object *argv[])
 {
-  int show;
 #ifdef WINDOWS_PROCESSES
   char *dir;
-# define mzseSHOW(x) x
+  int show = 0;
+# define mzseSHOW(s, x) s = x
 #else
-# define mzseSHOW(x) 1
+# define mzseSHOW(s, x) /* empty */
 #endif
 
   if (!SCHEME_FALSEP(argv[0]) && !SCHEME_CHAR_STRINGP(argv[0]))
@@ -9402,11 +9402,10 @@ static Scheme_Object *sch_shell_execute(int c, Scheme_Object *argv[])
     scheme_wrong_type("shell-execute", SCHEME_PATH_STRING_STR, 3, c, argv);
   {
     int show_set = 0;
-    show = 0;
 # define mzseCMP(id, str)			       \
     if (SAME_OBJ(scheme_intern_symbol(str), argv[4])   \
         || SAME_OBJ(scheme_intern_symbol(# id), argv[4])) { \
-      show = mzseSHOW(id); show_set = 1; }
+      mzseSHOW(show, id); show_set = 1; }
     mzseCMP(SW_HIDE, "sw_hide");
     mzseCMP(SW_MAXIMIZE, "sw_maximize");
     mzseCMP(SW_MINIMIZE, "sw_minimize");
diff --git a/src/racket/src/read.c b/src/racket/src/read.c
index 888ff6e1f2..899228b3e7 100644
--- a/src/racket/src/read.c
+++ b/src/racket/src/read.c
@@ -1618,9 +1618,8 @@ read_inner_inner(Scheme_Object *port, Scheme_Object *stxsrc, Scheme_Hash_Table *
           ch = scheme_getc_special_ok(port);
           if ((ch == ' ') || (ch == '/')) {
             /* line comment, with '\' as a continuation */
-            int was_backslash = 0, was_backslash_cr = 0, prev_backslash_cr;
+            int was_backslash = 0, was_backslash_cr = 0;
             while(1) {
-              prev_backslash_cr = was_backslash_cr;
               was_backslash_cr = 0;
               ch = scheme_getc_special_ok(port);
               if (ch == EOF) {
diff --git a/src/racket/src/regexp.c b/src/racket/src/regexp.c
index 191b7e28eb..e9472966d1 100644
--- a/src/racket/src/regexp.c
+++ b/src/racket/src/regexp.c
@@ -1771,7 +1771,12 @@ regranges(int parse_flags, int at_start)
 {
   int c;
   rxpos ret, save_regparse = 0;
-  int count, all_ci, num_ci, off_ranges, on_ranges, now_on, last_on, prev_last_on;
+  int count, off_ranges, on_ranges, now_on, last_on, prev_last_on;
+#ifdef COUNT_CI_CHARS
+  /* These could be used to pick an encoding as a _CI variant, but
+     _CI variants are not picked currently: */
+  int all_ci, num_ci;
+#endif
   char *new_map = NULL, *accum_map = NULL;
 
   count = 0;
@@ -1873,8 +1878,10 @@ regranges(int parse_flags, int at_start)
     /* Collect stats to pick the best run-time implementation for a range.
        We may do this twice if we decide to use a _CI variant. */
     count = 0;
+#ifdef COUNT_CI_CHARS
     num_ci = 0;
     all_ci = 1;
+#endif
     on_ranges = 0;
     off_ranges = 0;
     now_on = 0;
@@ -1889,6 +1896,7 @@ regranges(int parse_flags, int at_start)
 	prev_last_on = last_on;
 	last_on = c;
 
+#ifdef COUNT_CI_CHARS
 	if (c != rx_tolower(c)) {
 	  if (accum_map[rx_tolower(c)] != accum_map[c])
 	    all_ci = 0;
@@ -1898,6 +1906,7 @@ regranges(int parse_flags, int at_start)
 	    all_ci = 0;
 	  num_ci++;
 	}
+#endif
       } else {
 	if (now_on > 0)
 	  on_ranges++;
diff --git a/src/racket/src/salloc.c b/src/racket/src/salloc.c
index d71a929838..abb1ad862b 100644
--- a/src/racket/src/salloc.c
+++ b/src/racket/src/salloc.c
@@ -1668,6 +1668,13 @@ void scheme_free_key(Scheme_Object *k)
   free(k);
 }
 
+/************************************************************************/
+/*                              Misc                                   */
+/************************************************************************/
+
+void scheme_unused_object(Scheme_Object *o) { }
+void scheme_unused_intptr(intptr_t i) { }
+
 /************************************************************************/
 /*                             GC_dump                                  */
 /************************************************************************/
diff --git a/src/racket/src/schpriv.h b/src/racket/src/schpriv.h
index b208819527..42747cbebc 100644
--- a/src/racket/src/schpriv.h
+++ b/src/racket/src/schpriv.h
@@ -3659,6 +3659,10 @@ int scheme_can_inline_fp_comp();
 # define scheme_can_inline_fp_comp() 0
 #endif
 
+/* To suppress compiler warnings when it's difficult to avoid them otherwise: */
+void scheme_unused_object(Scheme_Object*);
+void scheme_unused_intptr(intptr_t);
+
 /*========================================================================*/
 /*                           places                                       */
 /*========================================================================*/
diff --git a/src/racket/src/string.c b/src/racket/src/string.c
index 5853220ad6..68966d3add 100644
--- a/src/racket/src/string.c
+++ b/src/racket/src/string.c
@@ -2938,7 +2938,7 @@ static char *locale_recase(int to_up,
      multibyte, then convert back. */
 # define MZ_WC_BUF_SIZE 32
   GC_CAN_IGNORE mbstate_t state;
-  size_t wl, wl2, ml, ml2;
+  size_t wl, ml;
   wchar_t *wc, *ws, wcbuf[MZ_WC_BUF_SIZE], cwc;
   const char *s;
   unsigned int j;
@@ -2964,7 +2964,7 @@ static char *locale_recase(int to_up,
   /* Convert */
   memset(&state, 0, sizeof(mbstate_t));
   s = in XFORM_OK_PLUS id;
-  wl2 = mz_mbsnrtowcs(wc, &s, iilen, wl + 1, &state);
+  (void)mz_mbsnrtowcs(wc, &s, iilen, wl + 1, &state);
   s = NULL;
 
   wc[wl] = 0; /* just in case */
@@ -3001,7 +3001,7 @@ static char *locale_recase(int to_up,
   /* Convert */
   memset(&state, 0, sizeof(mbstate_t));
   ws = wc;
-  ml2 = mz_wcsnrtombs(out + od, (const wchar_t **)&ws, wl, ml + 1, &state);
+  (void)mz_wcsnrtombs(out + od, (const wchar_t **)&ws, wl, ml + 1, &state);
   ws = NULL;
 
   out[od + ml] = 0;
diff --git a/src/racket/src/syntax.c b/src/racket/src/syntax.c
index 4bbdfc4aff..fd46506afc 100644
--- a/src/racket/src/syntax.c
+++ b/src/racket/src/syntax.c
@@ -4283,7 +4283,7 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
   WRAP_POS wraps;
   Scheme_Object *result;
   int is_in_module = 0, skip_other_mods = 0, sealed = STX_SEAL_ALL, floating_checked = 0;
-  int no_lexical = !free_id_recur, unsealed_reason = 0;
+  int no_lexical = !free_id_recur;
   Scheme_Object *phase = orig_phase;
   Scheme_Object *bdg = NULL, *floating = NULL;
 
@@ -4309,9 +4309,9 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
 	result = SCHEME_STX_VAL(a);
 
 #if 0
-      printf("%p %p %s (%d) %d %p %d\n", 
+      printf("%p %p %s (%d) %d %p\n", 
              a, orig_phase, SCHEME_SYMBOLP(result) ? SCHEME_SYM_VAL(result) : "!?", 
-             can_cache, sealed, free_id_recur, unsealed_reason);
+             can_cache, sealed, free_id_recur);
 #endif 
 
       if (can_cache && SAME_OBJ(orig_phase, scheme_make_integer(0)))
@@ -4333,10 +4333,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
         
         if ((!is_in_module || (mrns->kind != mzMOD_RENAME_TOPLEVEL))
             && !skip_other_mods) {
-          if (mrns->sealed < sealed) {
+          if (mrns->sealed < sealed)
             sealed = mrns->sealed;
-            unsealed_reason = 2;
-          }
         }
 
         mrn = extract_renames(mrns, phase);
@@ -4351,10 +4349,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
 	  /* Module rename: */
 	  Scheme_Object *rename, *glob_id;
 
-          if (mrn->sealed < sealed) {
+          if (mrn->sealed < sealed)
             sealed = mrn->sealed;
-            unsealed_reason = 3;
-          }
           
 	  if (mrn->needs_unmarshal) {
 	    /* Use resolve_env to trigger unmarshal, so that we
@@ -4394,10 +4390,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
                                                       rename,
                                                       &sd,
                                                       free_id_recur);
-              if (!sd) {
+              if (!sd)
                 sealed = 0;
-                unsealed_reason = 4;
-              }
             }
           } else
             rename = NULL;
@@ -4467,7 +4461,7 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
 
       do {
         if (rib) {
-          if (!*rib->sealed) { sealed = 0; unsealed_reason = 1; }
+          if (!*rib->sealed) sealed = 0;
           rename = rib->rename;
           rib = rib->next;
         }
@@ -4515,10 +4509,8 @@ static Scheme_Object *get_module_src_name(Scheme_Object *a, Scheme_Object *orig_
                 names[6] = NULL;
 
                 modname = resolve_env(a, orig_phase, 1, names, NULL, NULL, &rib_dep, 0, free_id_recur);
-                if (rib_dep) {
+                if (rib_dep)
                   sealed = 0;
-                  unsealed_reason = 5;
-                }
 
                 if (!SCHEME_FALSEP(modname)
                     && !SAME_OBJ(names[0], scheme_undefined)) {
diff --git a/src/racket/src/thread.c b/src/racket/src/thread.c
index ed3761ab6e..8951fbedf7 100644
--- a/src/racket/src/thread.c
+++ b/src/racket/src/thread.c
@@ -691,6 +691,7 @@ static Scheme_Object *current_memory_use(int argc, Scheme_Object *args[])
 #ifdef MZ_PRECISE_GC
   retval = GC_get_memory_use(arg);
 #else
+  scheme_unused_object(arg);
   retval = GC_get_memory_use();
 #endif
   
@@ -767,6 +768,8 @@ static Scheme_Object *custodian_require_mem(int argc, Scheme_Object *args[])
 #ifdef MZ_PRECISE_GC
   if (GC_set_account_hook(MZACCT_REQUIRE, c1, lim, c2))
     return scheme_void;
+#else
+  scheme_unused_intptr(lim);
 #endif
 
   scheme_raise_exn(MZEXN_FAIL_UNSUPPORTED,
@@ -809,6 +812,8 @@ static Scheme_Object *custodian_limit_mem(int argc, Scheme_Object *args[])
 #ifdef MZ_PRECISE_GC
   if (GC_set_account_hook(MZACCT_LIMIT, args[0], lim, (argc > 2) ? args[2] : args[0]))
     return scheme_void;
+#else
+  scheme_unused_intptr(lim);
 #endif
 
   scheme_raise_exn(MZEXN_FAIL_UNSUPPORTED,
@@ -3100,7 +3105,9 @@ Scheme_Object *scheme_thread_w_details(Scheme_Object *thunk,
 				       int suspend_to_kill)
 {
   Scheme_Object *result;
+#ifndef MZ_PRECISE_GC
   void *stack_marker;
+#endif
 
 #ifdef DO_STACK_CHECK
   /* Make sure the thread starts out with a reasonable stack size, so