Use wrapper functions for field info access

src/alloc.c

@@ -298,8 +298,9 @@ DLLEXPORT jl_value_t *jl_new_structv(jl_datatype_t *type, jl_value_t **args, uin
  jl_set_nth_field(jv, i, args[i]);
  }
  for(size_t i=na; i < nf; i++) {
- if (type->fields[i].isptr)
+ if (jl_field_isptr(type, i)) {
  *(jl_value_t**)((char*)jl_data_ptr(jv)+jl_field_offset(type,i)) = NULL;
+ }
  }
  return jv;
 }
@@ -557,7 +558,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
  if (__unlikely(fsz > JL_FIELD_MAX_SIZE))
  jl_throw(jl_overflow_exception);
  al = ((jl_datatype_t*)ty)->alignment;
- st->fields[i].isptr = 0;
+ jl_field_setisptr(st, i, 0);
  if (((jl_datatype_t*)ty)->haspadding)
  st->haspadding = 1;
  }
@@ -566,7 +567,7 @@ void jl_compute_field_offsets(jl_datatype_t *st)
  if (fsz > MAX_ALIGN)
  fsz = MAX_ALIGN;
  al = fsz;
- st->fields[i].isptr = 1;
+ jl_field_setisptr(st, i, 1);
  ptrfree = 0;
  }
  if (al != 0) {
@@ -577,8 +578,8 @@ void jl_compute_field_offsets(jl_datatype_t *st)
  if (al > alignm)
  alignm = al;
  }
- st->fields[i].offset = sz;
- st->fields[i].size = fsz;
+ jl_field_setoffset(st, i, sz);
+ jl_field_setsize(st, i, fsz);
  sz += fsz;
  if (__unlikely(sz >= JL_FIELD_MAX_SIZE)) {
  jl_throw(jl_overflow_exception);

src/builtins.c

@@ -254,11 +254,11 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
 {
  size_t nf = jl_datatype_nfields(dt);
  for (size_t f=0; f < nf; f++) {
- size_t offs = dt->fields[f].offset;
+ size_t offs = jl_field_offset(dt, f);
  char *ao = (char*)jl_data_ptr(a) + offs;
  char *bo = (char*)jl_data_ptr(b) + offs;
  int eq;
- if (dt->fields[f].isptr) {
+ if (jl_field_isptr(dt, f)) {
  jl_value_t *af = *(jl_value_t**)ao;
  jl_value_t *bf = *(jl_value_t**)bo;
  if (af == bf) eq = 1;
@@ -268,7 +268,7 @@ static int NOINLINE compare_fields(jl_value_t *a, jl_value_t *b, jl_datatype_t *
  else {
  jl_datatype_t *ft = (jl_datatype_t*)jl_field_type(dt, f);
  if (!ft->haspadding) {
- eq = bits_equal(ao, bo, dt->fields[f].size);
+ eq = bits_equal(ao, bo, jl_field_size(dt, f));
  }
  else {
  assert(jl_datatype_nfields(ft) > 0);
@@ -1178,20 +1178,20 @@ static uptrint_t jl_object_id_(jl_value_t *tv, jl_value_t *v)
  return bits_hash(jl_data_ptr(v), sz) ^ h;
  }
  for (size_t f=0; f < nf; f++) {
- size_t offs = dt->fields[f].offset;
+ size_t offs = jl_field_offset(dt, f);
  char *vo = (char*)jl_data_ptr(v) + offs;
  uptrint_t u;
- if (dt->fields[f].isptr) {
+ if (jl_field_isptr(dt, f)) {
  jl_value_t *f = *(jl_value_t**)vo;
  u = f==NULL ? 0 : jl_object_id(f);
  }
  else {
- jl_datatype_t *fieldtype = (jl_datatype_t*)jl_svecref(dt->types, f);
+ jl_datatype_t *fieldtype = (jl_datatype_t*)jl_field_type(dt, f);
  assert(jl_is_datatype(fieldtype) && !fieldtype->abstract && !fieldtype->mutabl);
  if (fieldtype->haspadding)
  u = jl_object_id_((jl_value_t*)fieldtype, (jl_value_t*)vo);
  else
- u = bits_hash(vo, dt->fields[f].size);
+ u = bits_hash(vo, jl_field_size(dt, f));
  }
  h = bitmix(h, u);
  }

src/cgutils.cpp

@@ -727,7 +727,7 @@ static Type *julia_struct_to_llvm(jl_value_t *jt)
  for(i = 0; i < ntypes; i++) {
  jl_value_t *ty = jl_svecref(jst->types, i);
  Type *lty;
- if (jst->fields[i].isptr)
+ if (jl_field_isptr(jst, i))
  lty = jl_pvalue_llvmt;
  else
  lty = ty==(jl_value_t*)jl_bool_type ? T_int8 : julia_type_to_llvm(ty);
@@ -764,8 +764,9 @@ static bool is_datatype_all_pointers(jl_datatype_t *dt)
 {
  size_t i, l = jl_datatype_nfields(dt);
  for(i=0; i < l; i++) {
- if (!dt->fields[i].isptr)
+ if (!jl_field_isptr(dt, i)) {
  return false;
+ }
  }
  return true;
 }
@@ -1848,7 +1849,7 @@ static void emit_setfield(jl_datatype_t *sty, const jl_cgval_t &strct, size_t id
  builder.CreateGEP(builder.CreateBitCast(strct.V, T_pint8),
  ConstantInt::get(T_size, jl_field_offset(sty,idx0)));
  jl_value_t *jfty = jl_svecref(sty->types, idx0);
- if (sty->fields[idx0].isptr) {
+ if (jl_field_isptr(sty, idx0)) {
  Value *r = boxed(rhs, ctx);
  builder.CreateStore(r,
  builder.CreateBitCast(addr, jl_ppvalue_llvmt));
@@ -1912,7 +1913,7 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
  }
  }
  size_t j = 0;
- if (nf > 0 && sty->fields[0].isptr && nargs>1) {
+ if (nf > 0 && jl_field_isptr(sty, 0) && nargs>1) {
  // emit first field before allocating struct to save
  // a couple store instructions. avoids initializing
  // the first field to NULL, and sometimes the GC root
@@ -1940,7 +1941,7 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
  make_gcroot(strct, ctx);
  }
  for(size_t i=j; i < nf; i++) {
- if (sty->fields[i].isptr) {
+ if (jl_field_isptr(sty, i)) {
  builder.CreateStore(
  V_null,
  builder.CreatePointerCast(
@@ -1952,7 +1953,7 @@ static jl_cgval_t emit_new_struct(jl_value_t *ty, size_t nargs, jl_value_t **arg
  bool need_wb = false;
  for(size_t i=j+1; i < nargs; i++) {
  jl_cgval_t rhs = emit_expr(args[i],ctx);
- if (sty->fields[i-1].isptr && !rhs.isboxed) {
+ if (jl_field_isptr(sty, i - 1) && !rhs.isboxed) {
  if (!needroots) {
  // if this struct element needs boxing and we haven't rooted
  // the struct, root it now.

src/codegen.cpp

@@ -1756,7 +1756,7 @@ static bool is_getfield_nonallocating(jl_datatype_t *ty, jl_value_t *fld)
  else if (jl_is_quotenode(fld) && jl_is_long(jl_fieldref(fld,0)))
  idx = jl_unbox_long(jl_fieldref(fld,0))-1;
  for(size_t i=0; i < jl_svec_len(ty->types); i++) {
- if (!(ty->fields[i].isptr || (idx >= 0 && (size_t)idx != i)))
+ if (!(jl_field_isptr(ty,i) || (idx >= 0 && (size_t)idx != i)))
  return false;
  }
  return true;
@@ -2570,7 +2570,7 @@ static bool emit_known_call(jl_cgval_t *ret, jl_value_t *ff,
  if (jl_is_leaf_type((jl_value_t*)sty) && jl_subtype(rhst, ft, 0)) {
  // TODO: attempt better codegen for approximate types
  jl_cgval_t strct = emit_expr(args[1], ctx); // emit lhs
- if (sty->fields[idx].isptr) // emit rhs
+ if (jl_field_isptr(sty, idx)) // emit rhs
  *ret = emit_expr(args[3], ctx);
  else
  *ret = emit_unboxed(args[3], ctx);

src/dump.c

@@ -896,7 +896,7 @@ static void jl_serialize_value_(ios_t *s, jl_value_t *v)
  }
  else {
  for(size_t i=0; i < nf; i++) {
- if (t->fields[i].size > 0) {
+ if (jl_field_size(t, i) > 0) {
  jl_serialize_value(s, jl_get_nth_field(v, i));
  }
  }
@@ -1511,8 +1511,8 @@ static jl_value_t *jl_deserialize_value_(ios_t *s, jl_value_t *vtag, jl_value_t
  else {
  char *data = (char*)jl_data_ptr(v);
  for(i=0; i < nf; i++) {
- if (dt->fields[i].size > 0) {
- if (dt->fields[i].isptr) {
+ if (jl_field_size(dt,i) > 0) {
+ if (jl_field_isptr(dt,i)) {
  jl_value_t **fld = (jl_value_t**)(data+jl_field_offset(dt, i));
  *fld = jl_deserialize_value(s, fld);
  }

src/gc.c

@@ -1744,11 +1744,11 @@ static int push_root(jl_value_t *v, int d, int bits)
  // int fdsz = sizeof(void*)*nf;
  // void** children = alloca(fdsz);
  // int ci = 0;
- jl_fielddesc_t* fields = dt->fields;
  for(int i=0; i < nf; i++) {
- if (fields[i].isptr) {
+ if (jl_field_isptr(dt, i)) {
  nptr++;
- jl_value_t **slot = (jl_value_t**)((char*)v + fields[i].offset);
+ jl_value_t **slot = (jl_value_t**)((char*)v +
+ jl_field_offset(dt, i));
  jl_value_t *fld = *slot;
  if (fld) {
  verify_parent2("object", v, slot, "field(%d)", i);

src/julia.h

@@ -695,14 +695,21 @@ STATIC_INLINE jl_value_t *jl_cellset(void *a, size_t i, void *x)
 #define jl_data_ptr(v) (((jl_value_t*)v)->fieldptr)
 
 // struct type info
-#define jl_field_offset(st,i) (((jl_datatype_t*)st)->fields[i].offset)
-#define jl_field_size(st,i) (((jl_datatype_t*)st)->fields[i].size)
-#define jl_field_isptr(st,i) (((jl_datatype_t*)st)->fields[i].isptr)
 #define jl_field_name(st,i) (jl_sym_t*)jl_svecref(((jl_datatype_t*)st)->name->names, (i))
 #define jl_field_type(st,i) jl_svecref(((jl_datatype_t*)st)->types, (i))
 #define jl_datatype_size(t) (((jl_datatype_t*)t)->size)
 #define jl_datatype_nfields(t) (((jl_datatype_t*)(t))->nfields)
 
+#define jl_field_offset(st,i) (((jl_datatype_t*)st)->fields[i].offset)
+#define jl_field_size(st,i) (((jl_datatype_t*)st)->fields[i].size)
+#define jl_field_isptr(st,i) (((jl_datatype_t*)st)->fields[i].isptr)
+#define jl_field_setoffset(st, i, v) \
+ (((jl_datatype_t*)st)->fields[i].offset = v)
+#define jl_field_setsize(st, i, v) \
+ (((jl_datatype_t*)st)->fields[i].size = v)
+#define jl_field_setisptr(st, i, v) \
+ (((jl_datatype_t*)st)->fields[i].isptr = v)
+
 // basic predicates -----------------------------------------------------------
 #define jl_is_nothing(v) (((jl_value_t*)(v)) == ((jl_value_t*)jl_nothing))
 #define jl_is_tuple(v) (((jl_datatype_t*)jl_typeof(v))->name == jl_tuple_typename)

src/sys.c

@@ -614,7 +614,7 @@ DLLEXPORT size_t jl_get_field_offset(jl_datatype_t *ty, int field)
 {
  if (field > jl_datatype_nfields(ty))
  jl_error("This type does not have that many fields");
- return ty->fields[field].offset;
+ return jl_field_offset(ty, field);
 }
 
 DLLEXPORT size_t jl_get_alignment(jl_datatype_t *ty)