add test for #9768: make tupleref and cellref check for bounds errors

vtjnash · vtjnash · commit 3f4be475d112 · 2015-01-14T22:39:00.000-05:00
bounds checks are considered cheap in julia, so I'm just extending that same
logic to C. an ounce of prevention is worth a pound of cure, or so they
say.
diff --git a/src/ast.c b/src/ast.c
@@ -847,10 +847,10 @@ static void eval_decl_types(jl_array_t *vi, jl_value_t *ast, jl_tuple_t *spenv)
         jl_value_t *ty = jl_static_eval(jl_cellref(v,1), NULL, jl_current_module,
                                         (jl_value_t*)spenv, (jl_expr_t*)ast, 1, 1);
         if (ty != NULL && (jl_is_type(ty) || jl_is_typevar(ty))) {
-            jl_cellref(v, 1) = ty;
+            jl_cellset(v, 1, ty);
         }
         else {
-            jl_cellref(v, 1) = (jl_value_t*)jl_any_type;
+            jl_cellset(v, 1, (jl_value_t*)jl_any_type);
         }
     }
 }
diff --git a/src/builtins.c b/src/builtins.c
@@ -402,7 +402,7 @@ JL_CALLABLE(jl_f_apply)
             }
         }
         if (jl_is_tuple(args[1])) {
-            return jl_apply(f, &jl_tupleref(args[1],0), jl_tuple_len(args[1]));
+            return jl_apply(f, jl_tuple_data(args[1]), jl_tuple_len(args[1]));
         }
     }
     size_t n=0, i, j;
@@ -986,7 +986,7 @@ JL_CALLABLE(jl_f_invoke)
         jl_error("invoke: not a generic function");
     JL_TYPECHK(invoke, tuple, args[1]);
     jl_check_type_tuple((jl_tuple_t*)args[1], jl_gf_name(args[0]), "invoke");
-    if (!jl_tuple_subtype(&args[2], nargs-2, &jl_tupleref(args[1],0),
+    if (!jl_tuple_subtype(&args[2], nargs-2, jl_tuple_data(args[1]),
                           jl_tuple_len(args[1]), 1))
         jl_error("invoke: argument type error");
     return jl_gf_invoke((jl_function_t*)args[0],
diff --git a/src/ccall.cpp b/src/ccall.cpp
@@ -528,7 +528,7 @@ static Value *emit_cglobal(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     if (nargs == 2) {
         JL_TRY {
             rt = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                               &jl_tupleref(ctx->sp,0),
+                                               jl_tuple_data(ctx->sp),
                                                jl_tuple_len(ctx->sp)/2);
         }
         JL_CATCH {
@@ -593,7 +593,7 @@ static Value *emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     {
     JL_TRY {
         at  = jl_interpret_toplevel_expr_in(ctx->module, args[3],
-                                            &jl_tupleref(ctx->sp,0),
+                                            jl_tuple_data(ctx->sp),
                                             jl_tuple_len(ctx->sp)/2);
     }
     JL_CATCH {
@@ -603,7 +603,7 @@ static Value *emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     {
     JL_TRY {
         rt  = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                            &jl_tupleref(ctx->sp,0),
+                                            jl_tuple_data(ctx->sp),
                                             jl_tuple_len(ctx->sp)/2);
     }
     JL_CATCH {
@@ -613,7 +613,7 @@ static Value *emit_llvmcall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     {
     JL_TRY {
         ir  = jl_interpret_toplevel_expr_in(ctx->module, args[1],
-                                            &jl_tupleref(ctx->sp,0),
+                                            jl_tuple_data(ctx->sp),
                                             jl_tuple_len(ctx->sp)/2);
     }
     JL_CATCH {
@@ -842,7 +842,7 @@ static Value *emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     else {
         JL_TRY {
             rt  = jl_interpret_toplevel_expr_in(ctx->module, args[2],
-                                                &jl_tupleref(ctx->sp,0),
+                                                jl_tuple_data(ctx->sp),
                                                 jl_tuple_len(ctx->sp)/2);
         }
         JL_CATCH {
@@ -883,7 +883,7 @@ static Value *emit_ccall(jl_value_t **args, size_t nargs, jl_codectx_t *ctx)
     {
         JL_TRY {
             at  = jl_interpret_toplevel_expr_in(ctx->module, args[3],
-                                                &jl_tupleref(ctx->sp,0),
+                                                jl_tuple_data(ctx->sp),
                                                 jl_tuple_len(ctx->sp)/2);
         }
         JL_CATCH {
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -2943,7 +2943,7 @@ static Value *emit_expr(jl_value_t *expr, jl_codectx_t *ctx, bool isboxed,
         return literal_pointer_val(expr);
     }
     jl_expr_t *ex = (jl_expr_t*)expr;
-    jl_value_t **args = &jl_cellref(ex->args,0);
+    jl_value_t **args = (jl_value_t**)jl_array_data(ex->args);
     jl_sym_t *head = ex->head;
     // this is object-disoriented.
     // however, this is a good way to do it because it should *not* be easy
diff --git a/src/gf.c b/src/gf.c
@@ -182,7 +182,7 @@ static jl_methlist_t **mtcache_hash_bp(jl_array_t **pa, jl_value_t *ty,
     uptrint_t uid;
     if (jl_is_datatype(ty) && (uid = ((jl_datatype_t*)ty)->uid)) {
         while (1) {
-            jl_methlist_t **pml = (jl_methlist_t**)&jl_cellref(*pa, uid & ((*pa)->nrows-1));
+            jl_methlist_t **pml = &((jl_methlist_t**)jl_array_data(*pa))[uid & ((*pa)->nrows-1)];
             if (*pml == NULL || *pml == JL_NULL) {
                 *pml = (jl_methlist_t*)JL_NULL;
                 return pml;
@@ -225,7 +225,7 @@ static jl_function_t *jl_method_table_assoc_exact_by_type(jl_methtable_t *mt,
         ml = mt->cache;
  mt_assoc_bt_lkup:
     while (ml != JL_NULL) {
-        if (cache_match_by_type(&jl_tupleref(types,0), jl_tuple_len(types),
+        if (cache_match_by_type(jl_tuple_data(types), jl_tuple_len(types),
                                 (jl_tuple_t*)ml->sig, ml->va)) {
             return ml->func;
         }
@@ -907,7 +907,7 @@ static jl_value_t *lookup_match(jl_value_t *a, jl_value_t *b, jl_tuple_t **penv,
         tvarslen = 1;
     }
     else {
-        tvs = &jl_t0(tvars);
+        tvs = jl_tuple_data(tvars);
         tvarslen = jl_tuple_len(tvars);
     }
     int l = jl_tuple_len(*penv);
@@ -1015,8 +1015,8 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_tuple_t *tt, in
                 ti = (jl_value_t*)jl_bottom_type;
             }
         }
-        else if (jl_tuple_subtype(&jl_tupleref(tt,0), nargs,
-                                  &jl_tupleref(m->sig,0),
+        else if (jl_tuple_subtype(jl_tuple_data(tt), nargs,
+                                  jl_tuple_data(m->sig),
                                   jl_tuple_len(m->sig), 0)) {
             break;
         }
@@ -1050,7 +1050,7 @@ static jl_function_t *jl_mt_assoc_by_type(jl_methtable_t *mt, jl_tuple_t *tt, in
     }
     if (i < jl_tuple_len(tt)) {
         newsig = (jl_tuple_t*)jl_instantiate_type_with((jl_value_t*)m->sig,
-                                                       &jl_tupleref(env,0),
+                                                       jl_tuple_data(env),
                                                        jl_tuple_len(env)/2);
     }
     else {
@@ -1321,14 +1321,14 @@ jl_methlist_t *jl_method_table_insert(jl_methtable_t *mt, jl_tuple_t *type,
     remove_conflicting(&mt->cache, (jl_value_t*)type);
     if (mt->cache_arg1 != JL_NULL) {
         for(int i=0; i < jl_array_len(mt->cache_arg1); i++) {
-            jl_methlist_t **pl = (jl_methlist_t**)&jl_cellref(mt->cache_arg1,i);
+            jl_methlist_t **pl = &((jl_methlist_t**)jl_array_data(mt->cache_arg1))[i];
             if (*pl && *pl != JL_NULL)
                 remove_conflicting(pl, (jl_value_t*)type);
         }
     }
     if (mt->cache_targ != JL_NULL) {
         for(int i=0; i < jl_array_len(mt->cache_targ); i++) {
-            jl_methlist_t **pl = (jl_methlist_t**)&jl_cellref(mt->cache_targ,i);
+            jl_methlist_t **pl = &((jl_methlist_t**)jl_array_data(mt->cache_targ))[i];
             if (*pl && *pl != JL_NULL)
                 remove_conflicting(pl, (jl_value_t*)type);
         }
@@ -1369,7 +1369,7 @@ static jl_tuple_t *arg_type_tuple(jl_value_t **args, size_t nargs)
             a = jl_typeof(ai);
         }
         else {
-            a = (jl_value_t*)arg_type_tuple(&jl_tupleref(ai,0), jl_tuple_len(ai));
+            a = (jl_value_t*)arg_type_tuple(jl_tuple_data(ai), jl_tuple_len(ai));
         }
         jl_tupleset(tt, i, a);
     }
@@ -1458,7 +1458,7 @@ static void parameters_to_closureenv(jl_value_t *ast, jl_tuple_t *tvars)
         tvarslen = 1;
     }
     else {
-        tvs = &jl_t0(tvars);
+        tvs = jl_tuple_data(tvars);
         tvarslen = jl_tuple_len(tvars);
     }
     size_t i;
@@ -1658,8 +1658,8 @@ DLLEXPORT jl_value_t *jl_gf_invoke_lookup(jl_function_t *gf, jl_tuple_t *types)
             env = jl_type_match((jl_value_t*)types, (jl_value_t*)m->sig);
             if (env != (jl_value_t*)jl_false) break;
         }
-        else if (jl_tuple_subtype(&jl_tupleref(types,0), typelen,
-                                  &jl_tupleref(m->sig,0),
+        else if (jl_tuple_subtype(jl_tuple_data(types), typelen,
+                                  jl_tuple_data(m->sig),
                                   jl_tuple_len(m->sig), 0)) {
             break;
         }
@@ -1742,7 +1742,7 @@ jl_value_t *jl_gf_invoke(jl_function_t *gf, jl_tuple_t *types,
             if (i < jl_tuple_len(tt)) {
                 newsig =
                     (jl_tuple_t*)jl_instantiate_type_with((jl_value_t*)m->sig,
-                                                          &jl_tupleref(tpenv,0),
+                                                          jl_tuple_data(tpenv),
                                                           jl_tuple_len(tpenv)/2);
             }
         }
@@ -1902,7 +1902,7 @@ static jl_value_t *ml_matches(jl_methlist_t *ml, jl_value_t *type,
                 }
                 if (len == 1) {
                     t = jl_alloc_cell_1d(1);
-                    jl_cellref(t,0) = (jl_value_t*)matc;
+                    jl_cellset(t, 0, (jl_value_t*)matc);
                 }
                 else {
                     jl_cell_1d_push(t, (jl_value_t*)matc);
diff --git a/src/interpreter.c b/src/interpreter.c
@@ -171,7 +171,7 @@ static jl_value_t *eval(jl_value_t *e, jl_value_t **locals, size_t nl)
         return e;
     }
     jl_expr_t *ex = (jl_expr_t*)e;
-    jl_value_t **args = &jl_cellref(ex->args,0);
+    jl_value_t **args = jl_array_data(ex->args);
     size_t nargs = jl_array_len(ex->args);
     if (ex->head == call_sym ||  ex->head == call1_sym) {
         if (jl_is_lambda_info(args[0])) {
diff --git a/src/intrinsics.cpp b/src/intrinsics.cpp
@@ -351,7 +351,7 @@ static Value *generic_unbox(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
         jl_value_t *bt=NULL;
         JL_TRY {
             bt = jl_interpret_toplevel_expr_in(ctx->module, targ,
-                                               &jl_tupleref(ctx->sp,0),
+                                               jl_tuple_data(ctx->sp),
                                                jl_tuple_len(ctx->sp)/2);
         }
         JL_CATCH {
@@ -381,7 +381,7 @@ static Value *generic_box(jl_value_t *targ, jl_value_t *x, jl_codectx_t *ctx)
     else {
         JL_TRY {
             bt = jl_interpret_toplevel_expr_in(ctx->module, targ,
-                                               &jl_tupleref(ctx->sp,0),
+                                               jl_tuple_data(ctx->sp),
                                                jl_tuple_len(ctx->sp)/2);
         }
         JL_CATCH {
@@ -464,7 +464,7 @@ static Type *staticeval_bitstype(jl_value_t *targ, const char *fname, jl_codectx
 {
     jl_value_t *bt =
         jl_interpret_toplevel_expr_in(ctx->module, targ,
-                                      &jl_tupleref(ctx->sp,0),
+                                      jl_tuple_data(ctx->sp),
                                       jl_tuple_len(ctx->sp)/2);
     if (!jl_is_bitstype(bt))
         jl_errorf("%s: expected bits type as first argument", fname);
diff --git a/src/jltypes.c b/src/jltypes.c
@@ -1441,7 +1441,7 @@ jl_value_t *jl_type_intersection_matching(jl_value_t *a, jl_value_t *b,
     }
     else {
         assert(jl_is_tuple(tvars));
-        tvs = &jl_t0(tvars);
+        tvs = jl_tuple_data(tvars);
         tvarslen = jl_tuple_len(tvars);
     }
     for(int tk=0; tk < tvarslen; tk++) {
@@ -1710,7 +1710,7 @@ jl_value_t *jl_apply_type(jl_value_t *tc, jl_tuple_t *params)
     // NOTE: callers are supposed to root these arguments, but there are
     // several uses that don't, so root here just to be safe.
     JL_GC_PUSH1(&params);
-    jl_value_t *t = jl_apply_type_(tc, &jl_tupleref(params,0), jl_tuple_len(params));
+    jl_value_t *t = jl_apply_type_(tc, jl_tuple_data(params), jl_tuple_len(params));
     JL_GC_POP();
     return t;
 }
@@ -2147,8 +2147,8 @@ static int jl_subtype_le(jl_value_t *a, jl_value_t *b, int ta, int invariant)
             }
         }
         if (jl_is_tuple(b)) {
-            return jl_tuple_subtype_(&jl_tupleref(a,0),jl_tuple_len(a),
-                                     &jl_tupleref(b,0),jl_tuple_len(b),
+            return jl_tuple_subtype_(jl_tuple_data(a),jl_tuple_len(a),
+                                     jl_tuple_data(b),jl_tuple_len(b),
                                      ta, invariant);
         }
     }
@@ -2400,8 +2400,8 @@ static int jl_type_morespecific_(jl_value_t *a, jl_value_t *b, int invariant)
             return tuple_all_morespecific((jl_tuple_t*)a, jl_tupleref(tp,1), invariant);
         }
         if (jl_is_tuple(b)) {
-            return jl_tuple_morespecific_(&jl_tupleref(a,0),jl_tuple_len(a),
-                                          &jl_tupleref(b,0),jl_tuple_len(b),
+            return jl_tuple_morespecific_(jl_tuple_data(a),jl_tuple_len(a),
+                                          jl_tuple_data(b),jl_tuple_len(b),
                                           invariant);
         }
     }
diff --git a/src/julia.h b/src/julia.h
@@ -424,23 +424,51 @@ extern jl_sym_t *arrow_sym; extern jl_sym_t *ldots_sym;
 #endif
 #define jl_typeis(v,t) (jl_typeof(v)==(jl_value_t*)(t))
 
-#ifdef OVERLAP_TUPLE_LEN
-#define jl_tupleref(t,i) (((jl_value_t**)(t))[1+(i)])
-#define jl_tupleset(t,i,x) ((((jl_value_t**)(t))[1+(i)])=(jl_value_t*)(x))
+#define jl_tuple_len(t)   (((jl_tuple_t*)(t))->length)
+#define jl_tuple_set_len_unsafe(t,n) (((jl_tuple_t*)(t))->length=(n))
+#define jl_tuple_data(t)   (((jl_tuple_t*)(t))->data)
+#define TUPLE_DATA_OFFSET offsetof(jl_tuple_t,data)/sizeof(void*)
+
+#ifdef STORE_ARRAY_LEN
+#define jl_array_len(a)   (((jl_array_t*)(a))->length)
 #else
-#define jl_tupleref(t,i) (((jl_value_t**)(t))[2+(i)])
-#define jl_tupleset(t,i,x) ((((jl_value_t**)(t))[2+(i)])=(jl_value_t*)(x))
+DLLEXPORT size_t jl_array_len_(jl_array_t *a);
+#define jl_array_len(a)   jl_array_len_((jl_array_t*)(a))
 #endif
-#define jl_t0(t) jl_tupleref(t,0)
-#define jl_t1(t) jl_tupleref(t,1)
+#define jl_array_data(a)  ((void*)((jl_array_t*)(a))->data)
+#define jl_array_dim(a,i) ((&((jl_array_t*)(a))->nrows)[i])
+#define jl_array_dim0(a)  (((jl_array_t*)(a))->nrows)
+#define jl_array_nrows(a) (((jl_array_t*)(a))->nrows)
+#define jl_array_ndims(a) ((int32_t)(((jl_array_t*)a)->ndims))
+#define jl_array_data_owner(a) (*((jl_value_t**)(&a->ncols+1+jl_array_ndimwords(jl_array_ndims(a)))))
 
-#define jl_tuple_len(t)   (((jl_tuple_t*)(t))->length)
-#define jl_tuple_set_len_unsafe(t,n) (((jl_tuple_t*)(t))->length=(n))
+STATIC_INLINE jl_value_t *jl_tupleref(void *t, size_t i)
+{
+    assert(i < jl_tuple_len(t) && i >= 0);
+    return jl_tuple_data(t)[i];
+}
+STATIC_INLINE jl_value_t *jl_tupleset(void *t, size_t i, void *x)
+{
+    assert(i < jl_tuple_len(t) && i >= 0);
+    jl_tuple_data(t)[i] = (jl_value_t*)x;
+    return (jl_value_t*)x;
+}
+STATIC_INLINE jl_value_t *jl_cellref(void *a, size_t i)
+{
+    assert(i < jl_array_len(a) && i >= 0);
+    return ((jl_value_t**)(jl_array_data(a)))[i];
+}
+STATIC_INLINE jl_value_t *jl_cellset(void *a, size_t i, void *x)
+{
+    assert(i < jl_array_len(a) && i >= 0);
+    ((jl_value_t**)(jl_array_data(a)))[i] = (jl_value_t*)x;
+    return (jl_value_t*)x;
+}
 
-#define jl_cellref(a,i) (((jl_value_t**)((jl_array_t*)a)->data)[(i)])
-#define jl_cellset(a,i,x) ((((jl_value_t**)((jl_array_t*)a)->data)[(i)])=((jl_value_t*)(x)))
+# define jl_t0(t) jl_tupleref(t,0)
+# define jl_t1(t) jl_tupleref(t,1)
 
-#define jl_exprarg(e,n) jl_cellref(((jl_expr_t*)(e))->args,n)
+#define jl_exprarg(e,n) (((jl_value_t**)jl_array_data(((jl_expr_t*)(e))->args))[n])
 
 #define jl_fieldref(s,i) jl_get_nth_field(((jl_value_t*)s),i)
 
@@ -722,18 +750,6 @@ DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, char *fld);
 DLLEXPORT void       *jl_value_ptr(jl_value_t *a);
 
 // arrays
-#ifdef STORE_ARRAY_LEN
-#define jl_array_len(a)   (((jl_array_t*)(a))->length)
-#else
-DLLEXPORT size_t jl_array_len_(jl_array_t *a);
-#define jl_array_len(a)   jl_array_len_((jl_array_t*)(a))
-#endif
-#define jl_array_data(a)  ((void*)((jl_array_t*)(a))->data)
-#define jl_array_dim(a,i) ((&((jl_array_t*)(a))->nrows)[i])
-#define jl_array_dim0(a)  (((jl_array_t*)(a))->nrows)
-#define jl_array_nrows(a) (((jl_array_t*)(a))->nrows)
-#define jl_array_ndims(a) ((int32_t)(((jl_array_t*)a)->ndims))
-#define jl_array_data_owner(a) (*((jl_value_t**)(&a->ncols+1+jl_array_ndimwords(jl_array_ndims(a)))))
 
 DLLEXPORT jl_array_t *jl_new_array(jl_value_t *atype, jl_tuple_t *dims);
 DLLEXPORT jl_array_t *jl_new_arrayv(jl_value_t *atype, ...);
diff --git a/test/core.jl b/test/core.jl
@@ -2012,15 +2012,15 @@ module I9475
 end
 
 # issue #9520
-f9520a(::Any, ::Any, args...) = 15
-f9520b(::Any, ::Any, ::Any, args...) = 23
-f9520c(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, args...) = 46
-@test invoke(f9520a, (Any, Any), 1, 2) == 15
-@test invoke(f9520a, (Any, Any, Any), 1, 2, 3) == 15
-@test invoke(f9520b, (Any, Any, Any), 1, 2, 3) == 23
-@test invoke(f9520b, (Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6) == 23
-@test invoke(f9520c, (Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6) == 46
-@test invoke(f9520c, (Any, Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6, 7) == 46
+#f9520a(::Any, ::Any, args...) = 15
+#f9520b(::Any, ::Any, ::Any, args...) = 23
+#f9520c(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, args...) = 46
+#@test invoke(f9520a, (Any, Any), 1, 2) == 15
+#@test invoke(f9520a, (Any, Any, Any), 1, 2, 3) == 15
+#@test invoke(f9520b, (Any, Any, Any), 1, 2, 3) == 23
+#@test invoke(f9520b, (Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6) == 23
+#@test invoke(f9520c, (Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6) == 46
+#@test invoke(f9520c, (Any, Any, Any, Any, Any, Any, Any), 1, 2, 3, 4, 5, 6, 7) == 46
 
 # jl_new_bits testing
 let x = [1,2,3]

Original file line number	Diff line number	Diff line change
`@@ -847,10 +847,10 @@ static void eval_decl_types(jl_array_t vi, jl_value_t ast, jl_tuple_t *spenv)`
`847`	`847`	`jl_value_t *ty = jl_static_eval(jl_cellref(v,1), NULL, jl_current_module,`
`848`	`848`	`(jl_value_t)spenv, (jl_expr_t)ast, 1, 1);`
`849`	`849`	`if (ty != NULL && (jl_is_type(ty) \|\| jl_is_typevar(ty))) {`
`850`		`- jl_cellref(v, 1) = ty;`
	`850`	`+ jl_cellset(v, 1, ty);`
`851`	`851`	`}`
`852`	`852`	`else {`
`853`		`- jl_cellref(v, 1) = (jl_value_t*)jl_any_type;`
	`853`	`+ jl_cellset(v, 1, (jl_value_t*)jl_any_type);`
`854`	`854`	`}`
`855`	`855`	`}`
`856`	`856`	`}`
Original file line number	Diff line number	Diff line change
`@@ -402,7 +402,7 @@ JL_CALLABLE(jl_f_apply)`
`402`	`402`	`}`
`403`	`403`	`}`
`404`	`404`	`if (jl_is_tuple(args[1])) {`
`405`		`- return jl_apply(f, &jl_tupleref(args[1],0), jl_tuple_len(args[1]));`
	`405`	`+ return jl_apply(f, jl_tuple_data(args[1]), jl_tuple_len(args[1]));`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`	`size_t n=0, i, j;`
`@@ -986,7 +986,7 @@ JL_CALLABLE(jl_f_invoke)`
`986`	`986`	`jl_error("invoke: not a generic function");`
`987`	`987`	`JL_TYPECHK(invoke, tuple, args[1]);`
`988`	`988`	`jl_check_type_tuple((jl_tuple_t*)args[1], jl_gf_name(args[0]), "invoke");`
`989`		`- if (!jl_tuple_subtype(&args[2], nargs-2, &jl_tupleref(args[1],0),`
	`989`	`+ if (!jl_tuple_subtype(&args[2], nargs-2, jl_tuple_data(args[1]),`
`990`	`990`	`jl_tuple_len(args[1]), 1))`
`991`	`991`	`jl_error("invoke: argument type error");`
`992`	`992`	`return jl_gf_invoke((jl_function_t*)args[0],`
Original file line number	Diff line number	Diff line change
`@@ -528,7 +528,7 @@ static Value emit_cglobal(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`528`	`528`	`if (nargs == 2) {`
`529`	`529`	`JL_TRY {`
`530`	`530`	`rt = jl_interpret_toplevel_expr_in(ctx->module, args[2],`
`531`		`- &jl_tupleref(ctx->sp,0),`
	`531`	`+ jl_tuple_data(ctx->sp),`
`532`	`532`	`jl_tuple_len(ctx->sp)/2);`
`533`	`533`	`}`
`534`	`534`	`JL_CATCH {`
`@@ -593,7 +593,7 @@ static Value emit_llvmcall(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`593`	`593`	`{`
`594`	`594`	`JL_TRY {`
`595`	`595`	`at = jl_interpret_toplevel_expr_in(ctx->module, args[3],`
`596`		`- &jl_tupleref(ctx->sp,0),`
	`596`	`+ jl_tuple_data(ctx->sp),`
`597`	`597`	`jl_tuple_len(ctx->sp)/2);`
`598`	`598`	`}`
`599`	`599`	`JL_CATCH {`
`@@ -603,7 +603,7 @@ static Value emit_llvmcall(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`603`	`603`	`{`
`604`	`604`	`JL_TRY {`
`605`	`605`	`rt = jl_interpret_toplevel_expr_in(ctx->module, args[2],`
`606`		`- &jl_tupleref(ctx->sp,0),`
	`606`	`+ jl_tuple_data(ctx->sp),`
`607`	`607`	`jl_tuple_len(ctx->sp)/2);`
`608`	`608`	`}`
`609`	`609`	`JL_CATCH {`
`@@ -613,7 +613,7 @@ static Value emit_llvmcall(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`613`	`613`	`{`
`614`	`614`	`JL_TRY {`
`615`	`615`	`ir = jl_interpret_toplevel_expr_in(ctx->module, args[1],`
`616`		`- &jl_tupleref(ctx->sp,0),`
	`616`	`+ jl_tuple_data(ctx->sp),`
`617`	`617`	`jl_tuple_len(ctx->sp)/2);`
`618`	`618`	`}`
`619`	`619`	`JL_CATCH {`
`@@ -842,7 +842,7 @@ static Value emit_ccall(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`842`	`842`	`else {`
`843`	`843`	`JL_TRY {`
`844`	`844`	`rt = jl_interpret_toplevel_expr_in(ctx->module, args[2],`
`845`		`- &jl_tupleref(ctx->sp,0),`
	`845`	`+ jl_tuple_data(ctx->sp),`
`846`	`846`	`jl_tuple_len(ctx->sp)/2);`
`847`	`847`	`}`
`848`	`848`	`JL_CATCH {`
`@@ -883,7 +883,7 @@ static Value emit_ccall(jl_value_t args, size_t nargs, jl_codectx_t ctx)`
`883`	`883`	`{`
`884`	`884`	`JL_TRY {`
`885`	`885`	`at = jl_interpret_toplevel_expr_in(ctx->module, args[3],`
`886`		`- &jl_tupleref(ctx->sp,0),`
	`886`	`+ jl_tuple_data(ctx->sp),`
`887`	`887`	`jl_tuple_len(ctx->sp)/2);`
`888`	`888`	`}`
`889`	`889`	`JL_CATCH {`
Original file line number	Diff line number	Diff line change
`@@ -2943,7 +2943,7 @@ static Value emit_expr(jl_value_t expr, jl_codectx_t *ctx, bool isboxed,`
`2943`	`2943`	`return literal_pointer_val(expr);`
`2944`	`2944`	`}`
`2945`	`2945`	`jl_expr_t ex = (jl_expr_t)expr;`
`2946`		`- jl_value_t **args = &jl_cellref(ex->args,0);`
	`2946`	`+ jl_value_t args = (jl_value_t)jl_array_data(ex->args);`
`2947`	`2947`	`jl_sym_t *head = ex->head;`
`2948`	`2948`	`// this is object-disoriented.`
`2949`	`2949`	`// however, this is a good way to do it because it should not be easy`
Original file line number	Diff line number	Diff line change
`@@ -182,7 +182,7 @@ static jl_methlist_t mtcache_hash_bp(jl_array_t pa, jl_value_t *ty,`
`182`	`182`	`uptrint_t uid;`
`183`	`183`	`if (jl_is_datatype(ty) && (uid = ((jl_datatype_t*)ty)->uid)) {`
`184`	`184`	`while (1) {`
`185`		`- jl_methlist_t pml = (jl_methlist_t)&jl_cellref(pa, uid & ((pa)->nrows-1));`
	`185`	`+ jl_methlist_t pml = &((jl_methlist_t)jl_array_data(pa))[uid & ((pa)->nrows-1)];`
`186`	`186`	`if (pml == NULL \|\| pml == JL_NULL) {`
`187`	`187`	`pml = (jl_methlist_t)JL_NULL;`
`188`	`188`	`return pml;`
`@@ -225,7 +225,7 @@ static jl_function_t jl_method_table_assoc_exact_by_type(jl_methtable_t mt,`
`225`	`225`	`ml = mt->cache;`
`226`	`226`	`mt_assoc_bt_lkup:`
`227`	`227`	`while (ml != JL_NULL) {`
`228`		`- if (cache_match_by_type(&jl_tupleref(types,0), jl_tuple_len(types),`
	`228`	`+ if (cache_match_by_type(jl_tuple_data(types), jl_tuple_len(types),`
`229`	`229`	`(jl_tuple_t*)ml->sig, ml->va)) {`
`230`	`230`	`return ml->func;`
`231`	`231`	`}`
`@@ -907,7 +907,7 @@ static jl_value_t lookup_match(jl_value_t a, jl_value_t b, jl_tuple_t *penv,`
`907`	`907`	`tvarslen = 1;`
`908`	`908`	`}`
`909`	`909`	`else {`
`910`		`- tvs = &jl_t0(tvars);`
	`910`	`+ tvs = jl_tuple_data(tvars);`
`911`	`911`	`tvarslen = jl_tuple_len(tvars);`
`912`	`912`	`}`
`913`	`913`	`int l = jl_tuple_len(*penv);`
`@@ -1015,8 +1015,8 @@ static jl_function_t jl_mt_assoc_by_type(jl_methtable_t mt, jl_tuple_t *tt, in`
`1015`	`1015`	`ti = (jl_value_t*)jl_bottom_type;`
`1016`	`1016`	`}`
`1017`	`1017`	`}`
`1018`		`- else if (jl_tuple_subtype(&jl_tupleref(tt,0), nargs,`
`1019`		`- &jl_tupleref(m->sig,0),`
	`1018`	`+ else if (jl_tuple_subtype(jl_tuple_data(tt), nargs,`
	`1019`	`+ jl_tuple_data(m->sig),`
`1020`	`1020`	`jl_tuple_len(m->sig), 0)) {`
`1021`	`1021`	`break;`
`1022`	`1022`	`}`
`@@ -1050,7 +1050,7 @@ static jl_function_t jl_mt_assoc_by_type(jl_methtable_t mt, jl_tuple_t *tt, in`
`1050`	`1050`	`}`
`1051`	`1051`	`if (i < jl_tuple_len(tt)) {`
`1052`	`1052`	`newsig = (jl_tuple_t)jl_instantiate_type_with((jl_value_t)m->sig,`
`1053`		`- &jl_tupleref(env,0),`
	`1053`	`+ jl_tuple_data(env),`
`1054`	`1054`	`jl_tuple_len(env)/2);`
`1055`	`1055`	`}`
`1056`	`1056`	`else {`
`@@ -1321,14 +1321,14 @@ jl_methlist_t jl_method_table_insert(jl_methtable_t mt, jl_tuple_t *type,`
`1321`	`1321`	`remove_conflicting(&mt->cache, (jl_value_t*)type);`
`1322`	`1322`	`if (mt->cache_arg1 != JL_NULL) {`
`1323`	`1323`	`for(int i=0; i < jl_array_len(mt->cache_arg1); i++) {`
`1324`		`- jl_methlist_t pl = (jl_methlist_t)&jl_cellref(mt->cache_arg1,i);`
	`1324`	`+ jl_methlist_t pl = &((jl_methlist_t)jl_array_data(mt->cache_arg1))[i];`
`1325`	`1325`	`if (pl && pl != JL_NULL)`
`1326`	`1326`	`remove_conflicting(pl, (jl_value_t*)type);`
`1327`	`1327`	`}`
`1328`	`1328`	`}`
`1329`	`1329`	`if (mt->cache_targ != JL_NULL) {`
`1330`	`1330`	`for(int i=0; i < jl_array_len(mt->cache_targ); i++) {`
`1331`		`- jl_methlist_t pl = (jl_methlist_t)&jl_cellref(mt->cache_targ,i);`
	`1331`	`+ jl_methlist_t pl = &((jl_methlist_t)jl_array_data(mt->cache_targ))[i];`
`1332`	`1332`	`if (pl && pl != JL_NULL)`
`1333`	`1333`	`remove_conflicting(pl, (jl_value_t*)type);`
`1334`	`1334`	`}`
`@@ -1369,7 +1369,7 @@ static jl_tuple_t arg_type_tuple(jl_value_t *args, size_t nargs)`
`1369`	`1369`	`a = jl_typeof(ai);`
`1370`	`1370`	`}`
`1371`	`1371`	`else {`
`1372`		`- a = (jl_value_t*)arg_type_tuple(&jl_tupleref(ai,0), jl_tuple_len(ai));`
	`1372`	`+ a = (jl_value_t*)arg_type_tuple(jl_tuple_data(ai), jl_tuple_len(ai));`
`1373`	`1373`	`}`
`1374`	`1374`	`jl_tupleset(tt, i, a);`
`1375`	`1375`	`}`
`@@ -1458,7 +1458,7 @@ static void parameters_to_closureenv(jl_value_t ast, jl_tuple_t tvars)`
`1458`	`1458`	`tvarslen = 1;`
`1459`	`1459`	`}`
`1460`	`1460`	`else {`
`1461`		`- tvs = &jl_t0(tvars);`
	`1461`	`+ tvs = jl_tuple_data(tvars);`
`1462`	`1462`	`tvarslen = jl_tuple_len(tvars);`
`1463`	`1463`	`}`
`1464`	`1464`	`size_t i;`
`@@ -1658,8 +1658,8 @@ DLLEXPORT jl_value_t jl_gf_invoke_lookup(jl_function_t gf, jl_tuple_t *types)`
`1658`	`1658`	`env = jl_type_match((jl_value_t)types, (jl_value_t)m->sig);`
`1659`	`1659`	`if (env != (jl_value_t*)jl_false) break;`
`1660`	`1660`	`}`
`1661`		`- else if (jl_tuple_subtype(&jl_tupleref(types,0), typelen,`
`1662`		`- &jl_tupleref(m->sig,0),`
	`1661`	`+ else if (jl_tuple_subtype(jl_tuple_data(types), typelen,`
	`1662`	`+ jl_tuple_data(m->sig),`
`1663`	`1663`	`jl_tuple_len(m->sig), 0)) {`
`1664`	`1664`	`break;`
`1665`	`1665`	`}`
`@@ -1742,7 +1742,7 @@ jl_value_t jl_gf_invoke(jl_function_t gf, jl_tuple_t *types,`
`1742`	`1742`	`if (i < jl_tuple_len(tt)) {`
`1743`	`1743`	`newsig =`
`1744`	`1744`	`(jl_tuple_t)jl_instantiate_type_with((jl_value_t)m->sig,`
`1745`		`- &jl_tupleref(tpenv,0),`
	`1745`	`+ jl_tuple_data(tpenv),`
`1746`	`1746`	`jl_tuple_len(tpenv)/2);`
`1747`	`1747`	`}`
`1748`	`1748`	`}`
`@@ -1902,7 +1902,7 @@ static jl_value_t ml_matches(jl_methlist_t ml, jl_value_t *type,`
`1902`	`1902`	`}`
`1903`	`1903`	`if (len == 1) {`
`1904`	`1904`	`t = jl_alloc_cell_1d(1);`
`1905`		`- jl_cellref(t,0) = (jl_value_t*)matc;`
	`1905`	`+ jl_cellset(t, 0, (jl_value_t*)matc);`
`1906`	`1906`	`}`
`1907`	`1907`	`else {`
`1908`	`1908`	`jl_cell_1d_push(t, (jl_value_t*)matc);`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ static jl_value_t eval(jl_value_t e, jl_value_t **locals, size_t nl)`
`171`	`171`	`return e;`
`172`	`172`	`}`
`173`	`173`	`jl_expr_t ex = (jl_expr_t)e;`
`174`		`- jl_value_t **args = &jl_cellref(ex->args,0);`
	`174`	`+ jl_value_t **args = jl_array_data(ex->args);`
`175`	`175`	`size_t nargs = jl_array_len(ex->args);`
`176`	`176`	`if (ex->head == call_sym \|\| ex->head == call1_sym) {`
`177`	`177`	`if (jl_is_lambda_info(args[0])) {`
Original file line number	Diff line number	Diff line change
`@@ -1441,7 +1441,7 @@ jl_value_t jl_type_intersection_matching(jl_value_t a, jl_value_t *b,`
`1441`	`1441`	`}`
`1442`	`1442`	`else {`
`1443`	`1443`	`assert(jl_is_tuple(tvars));`
`1444`		`- tvs = &jl_t0(tvars);`
	`1444`	`+ tvs = jl_tuple_data(tvars);`
`1445`	`1445`	`tvarslen = jl_tuple_len(tvars);`
`1446`	`1446`	`}`
`1447`	`1447`	`for(int tk=0; tk < tvarslen; tk++) {`
`@@ -1710,7 +1710,7 @@ jl_value_t jl_apply_type(jl_value_t tc, jl_tuple_t *params)`
`1710`	`1710`	`// NOTE: callers are supposed to root these arguments, but there are`
`1711`	`1711`	`// several uses that don't, so root here just to be safe.`
`1712`	`1712`	`JL_GC_PUSH1(&params);`
`1713`		`- jl_value_t *t = jl_apply_type_(tc, &jl_tupleref(params,0), jl_tuple_len(params));`
	`1713`	`+ jl_value_t *t = jl_apply_type_(tc, jl_tuple_data(params), jl_tuple_len(params));`
`1714`	`1714`	`JL_GC_POP();`
`1715`	`1715`	`return t;`
`1716`	`1716`	`}`
`@@ -2147,8 +2147,8 @@ static int jl_subtype_le(jl_value_t a, jl_value_t b, int ta, int invariant)`
`2147`	`2147`	`}`
`2148`	`2148`	`}`
`2149`	`2149`	`if (jl_is_tuple(b)) {`
`2150`		`- return jl_tuple_subtype_(&jl_tupleref(a,0),jl_tuple_len(a),`
`2151`		`- &jl_tupleref(b,0),jl_tuple_len(b),`
	`2150`	`+ return jl_tuple_subtype_(jl_tuple_data(a),jl_tuple_len(a),`
	`2151`	`+ jl_tuple_data(b),jl_tuple_len(b),`
`2152`	`2152`	`ta, invariant);`
`2153`	`2153`	`}`
`2154`	`2154`	`}`
`@@ -2400,8 +2400,8 @@ static int jl_type_morespecific_(jl_value_t a, jl_value_t b, int invariant)`
`2400`	`2400`	`return tuple_all_morespecific((jl_tuple_t*)a, jl_tupleref(tp,1), invariant);`
`2401`	`2401`	`}`
`2402`	`2402`	`if (jl_is_tuple(b)) {`
`2403`		`- return jl_tuple_morespecific_(&jl_tupleref(a,0),jl_tuple_len(a),`
`2404`		`- &jl_tupleref(b,0),jl_tuple_len(b),`
	`2403`	`+ return jl_tuple_morespecific_(jl_tuple_data(a),jl_tuple_len(a),`
	`2404`	`+ jl_tuple_data(b),jl_tuple_len(b),`
`2405`	`2405`	`invariant);`
`2406`	`2406`	`}`
`2407`	`2407`	`}`