jl_array_t *jl_reshape_array(jl_type_t *atype, jl_array_t *data,
jl_tuple_t *dims)
{
size_t i;
jl_array_t *a;
size_t ndims = dims->length;
int ndimwords = (ndims > 2 ? (ndims-2) : 0);
#ifndef __LP64__
// on 32-bit, ndimwords must be odd to preserve 8-byte alignment
ndimwords += (~ndimwords)&1;
#endif
a = allocobj(sizeof(jl_array_t) + ndimwords*sizeof(size_t));
a->type = atype;
*((jl_array_t**)(&a->_space[0] + ndimwords*sizeof(size_t))) = data;
a->data = data->data;
a->length = data->length;
a->elsize = data->elsize;
a->ndims = ndims;
a->reshaped = 1;
if (ndims == 1) {
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
}
}
return a;
}
static jl_value_t *new_scalar(jl_bits_type_t *bt)
{
size_t nb = jl_bitstype_nbits(bt)/8;
jl_value_t *v =
(jl_value_t*)allocobj((NWORDS(LLT_ALIGN(nb,sizeof(void*)))+1)*
sizeof(void*));
v->type = (jl_type_t*)bt;
return v;
}
jl_array_t *jl_reshape_array(jl_value_t *atype, jl_array_t *data, jl_tuple_t *dims)
{
size_t i;
jl_array_t *a;
size_t ndims = jl_tuple_len(dims);
int ndimwords = jl_array_ndimwords(ndims);
a = allocobj((sizeof(jl_array_t) + sizeof(void*) + ndimwords*sizeof(size_t) + 15)&-16);
a->type = atype;
a->ndims = ndims;
a->offset = 0;
a->data = NULL;
a->isaligned = data->isaligned;
jl_value_t *el_type = jl_tparam0(atype);
if (store_unboxed(el_type)) {
a->elsize = jl_datatype_size(el_type);
a->ptrarray = 0;
}
else {
a->elsize = sizeof(void*);
a->ptrarray = 1;
}
JL_GC_PUSH1(&a);
jl_array_data_owner(a) = (jl_value_t*)data;
a->how = 3;
a->data = data->data;
a->isshared = 1;
data->isshared = 1;
if (ndims == 1) {
size_t l = jl_unbox_long(jl_tupleref(dims,0));
#ifdef STORE_ARRAY_LEN
a->length = l;
#endif
a->nrows = l;
a->maxsize = l;
}
else {
size_t *adims = &a->nrows;
size_t l=1;
wideint_t prod;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
prod = (wideint_t)l * (wideint_t)adims[i];
if (prod > (wideint_t) MAXINTVAL)
jl_error("invalid Array dimensions");
l = prod;
}
#ifdef STORE_ARRAY_LEN
a->length = l;
#endif
}
JL_GC_POP();
return a;
}
jl_array_t *jl_ptr_to_array(jl_value_t *atype, void *data, jl_tuple_t *dims,
int own_buffer)
{
size_t i, elsz, nel=1;
jl_array_t *a;
size_t ndims = jl_tuple_len(dims);
wideint_t prod;
for(i=0; i < ndims; i++) {
prod = (wideint_t)nel * (wideint_t)jl_unbox_long(jl_tupleref(dims, i));
if (prod > (wideint_t) MAXINTVAL)
jl_error("invalid Array dimensions");
nel = prod;
}
jl_value_t *el_type = jl_tparam0(atype);
int isunboxed = store_unboxed(el_type);
if (isunboxed)
elsz = jl_datatype_size(el_type);
else
elsz = sizeof(void*);
int ndimwords = jl_array_ndimwords(ndims);
a = allocobj((sizeof(jl_array_t) + ndimwords*sizeof(size_t)+15)&-16);
a->type = atype;
a->data = data;
#ifdef STORE_ARRAY_LEN
a->length = nel;
#endif
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = ndims;
a->offset = 0;
a->isshared = 1;
a->isaligned = 0;
if (own_buffer) {
a->how = 2;
jl_gc_track_malloced_array(a);
}
else {
a->how = 0;
}
if (ndims == 1) {
a->nrows = nel;
a->maxsize = nel;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
}
}
return a;
}
jl_array_t *jl_ptr_to_array(jl_type_t *atype, void *data, jl_tuple_t *dims,
int julia_mallocated)
{
size_t i, elsz, nel=1;
jl_array_t *a;
size_t ndims = jl_tuple_len(dims);
for(i=0; i < ndims; i++) {
nel *= jl_unbox_long(jl_tupleref(dims, i));
}
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
int isunboxed = jl_is_bits_type(el_type);
if (isunboxed)
elsz = jl_bitstype_nbits(el_type)/8;
else
elsz = sizeof(void*);
int ndimwords = (ndims > 2 ? (ndims-2) : 0);
#ifndef __LP64__
// on 32-bit, ndimwords must be odd to preserve 8-byte alignment
ndimwords += (~ndimwords)&1;
#endif
a = allocobj(sizeof(jl_array_t) + ndimwords*sizeof(size_t));
a->type = atype;
a->data = data;
a->length = nel;
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = ndims;
if (julia_mallocated) {
a->reshaped = 0;
jl_gc_acquire_buffer(data);
}
else {
// this marks the array as not owning its buffer
a->reshaped = 1;
*((jl_array_t**)(&a->_space[0] + ndimwords*sizeof(size_t))) = a;
}
if (ndims == 1) {
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
}
}
return a;
}
obj*
symbol(char *symbol) {
obj *sym;
sym = allocobj();
sym->type = SYMBOL;
sym->refcount = 1;
sym->symbol = symbol;
return sym;
}
obj*
reference(unsigned int depth) {
obj *ref;
ref = allocobj();
ref->type = REFERENCE;
ref->refcount = 1;
ref->reference = depth;
return ref;
}
obj*
lambda(obj *expression) {
obj *function;
function = allocobj();
function->type = LAMBDA;
function->refcount = 1;
function->expression = expression;
return function;
}
obj*
apply(obj *function, obj *argument) {
obj *application;
application = allocobj();
application->type = APPLICATION;
application->refcount = 1;
application->function = function;
application->argument = argument;
return application;
}
jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_module_t *m = (jl_module_t*)allocobj(sizeof(jl_module_t));
m->type = (jl_type_t*)jl_module_type;
m->name = name;
htable_new(&m->bindings, 0);
htable_new(&m->macros, 0);
jl_set_const(m, name, (jl_value_t*)m);
if (jl_current_module)
jl_set_const(m, jl_current_module->name, (jl_value_t*)jl_current_module);
//arraylist_new(&m->imports, 0);
return m;
}
jl_array_t *jl_ptr_to_array(jl_type_t *atype, void *data, jl_tuple_t *dims,
int own_buffer)
{
size_t i, elsz, nel=1;
jl_array_t *a;
size_t ndims = jl_tuple_len(dims);
for(i=0; i < ndims; i++) {
nel *= jl_unbox_long(jl_tupleref(dims, i));
}
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
int isunboxed = jl_is_bits_type(el_type);
if (isunboxed)
elsz = jl_bitstype_nbits(el_type)/8;
else
elsz = sizeof(void*);
int ndimwords = jl_array_ndimwords(ndims);
a = allocobj((sizeof(jl_array_t) + ndimwords*sizeof(size_t)+15)&-16);
a->type = atype;
a->data = data;
a->length = nel;
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = ndims;
if (own_buffer) {
a->ismalloc = 1;
jl_array_data_owner(a) = (jl_value_t*)jl_gc_acquire_buffer(data,nel*elsz);
}
else {
a->ismalloc = 0;
jl_array_data_owner(a) = (jl_value_t*)a;
}
if (ndims == 1) {
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
}
}
return a;
}
static jl_methtable_t *new_method_table(void)
{
jl_methtable_t *mt = (jl_methtable_t*)allocobj(sizeof(jl_methtable_t));
mt->type = (jl_type_t*)jl_methtable_type;
mt->defs = NULL;
mt->cache = NULL;
mt->cache_arg1 = NULL;
mt->cache_targ = NULL;
mt->max_args = jl_box_long(0);
#ifdef JL_GF_PROFILE
mt->ncalls = 0;
#endif
return mt;
}
jl_module_t *jl_new_module(jl_sym_t *name)
{
jl_module_t *m = (jl_module_t*)allocobj(sizeof(jl_module_t));
m->type = (jl_value_t*)jl_module_type;
m->name = name;
htable_new(&m->bindings, 0);
jl_set_const(m, name, (jl_value_t*)m);
arraylist_new(&m->usings, 0);
if (jl_core_module) {
jl_module_using(m, jl_core_module);
}
// export own name, so "using Foo" makes "Foo" itself visible
jl_module_export(m, name);
return m;
}
static jl_value_t *jl_new_bits_internal(jl_value_t *dt, void *data, size_t *len)
{
if (jl_is_tuple(dt)) {
jl_tuple_t *tuple = (jl_tuple_t*)dt;
*len = LLT_ALIGN(*len, jl_new_bits_align(dt));
size_t i, l = jl_tuple_len(tuple);
jl_value_t *v = (jl_value_t*) jl_alloc_tuple(l);
JL_GC_PUSH1(v);
for (i = 0; i < l; i++) {
jl_tupleset(v,i,jl_new_bits_internal(jl_tupleref(tuple,i), (char*)data, len));
}
JL_GC_POP();
return v;
}
jl_datatype_t *bt = (jl_datatype_t*)dt;
size_t nb = jl_datatype_size(bt);
if (nb == 0)
return jl_new_struct_uninit(bt);
*len = LLT_ALIGN(*len, bt->alignment);
data = (char*)data + (*len);
*len += nb;
if (bt == jl_uint8_type) return jl_box_uint8(*(uint8_t*)data);
if (bt == jl_int64_type) return jl_box_int64(*(int64_t*)data);
if (bt == jl_bool_type) return (*(int8_t*)data) ? jl_true:jl_false;
if (bt == jl_int32_type) return jl_box_int32(*(int32_t*)data);
if (bt == jl_float64_type) return jl_box_float64(*(double*)data);
jl_value_t *v =
(jl_value_t*)allocobj((NWORDS(LLT_ALIGN(nb,sizeof(void*)))+1)*
sizeof(void*));
v->type = (jl_value_t*)bt;
switch (nb) {
case 1: *(int8_t*) jl_data_ptr(v) = *(int8_t*)data; break;
case 2: *(int16_t*) jl_data_ptr(v) = *(int16_t*)data; break;
case 4: *(int32_t*) jl_data_ptr(v) = *(int32_t*)data; break;
case 8: *(int64_t*) jl_data_ptr(v) = *(int64_t*)data; break;
case 16: *(bits128_t*)jl_data_ptr(v) = *(bits128_t*)data; break;
default: memcpy(jl_data_ptr(v), data, nb);
}
return v;
}
jl_value_t *jl_new_bits(jl_datatype_t *bt, void *data)
{
if (bt == jl_uint8_type) return jl_box_uint8(*(uint8_t*)data);
else if (bt == jl_int64_type) return jl_box_int64(*(int64_t*)data);
else if (bt == jl_bool_type) return (*(int8_t*)data) ? jl_true:jl_false;
else if (bt == jl_int32_type) return jl_box_int32(*(int32_t*)data);
else if (bt == jl_float64_type) return jl_box_float64(*(double*)data);
size_t nb = jl_datatype_size(bt);
jl_value_t *v =
(jl_value_t*)allocobj((NWORDS(LLT_ALIGN(nb,sizeof(void*)))+1)*
sizeof(void*));
v->type = (jl_value_t*)bt;
switch (nb) {
case 1: *(int8_t*) jl_data_ptr(v) = *(int8_t*)data; break;
case 2: *(int16_t*) jl_data_ptr(v) = *(int16_t*)data; break;
case 4: *(int32_t*) jl_data_ptr(v) = *(int32_t*)data; break;
case 8: *(int64_t*) jl_data_ptr(v) = *(int64_t*)data; break;
case 16: *(bits128_t*)jl_data_ptr(v) = *(bits128_t*)data; break;
default: memcpy(jl_data_ptr(v), data, nb);
}
return v;
}
// ** NOTE: julia_mallocated means buffer was allocated using julia_malloc.
// using the address of another array does not work!!
jl_array_t *jl_ptr_to_array_1d(jl_type_t *atype, void *data, size_t nel,
int julia_mallocated)
{
size_t elsz;
jl_array_t *a;
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
int isunboxed = jl_is_bits_type(el_type);
if (isunboxed)
elsz = jl_bitstype_nbits(el_type)/8;
else
elsz = sizeof(void*);
a = allocobj(sizeof(jl_array_t));
a->type = atype;
a->data = data;
a->length = nel;
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = 1;
if (julia_mallocated) {
a->reshaped = 0;
jl_gc_acquire_buffer(data);
}
else {
// this marks the array as not owning its buffer
a->reshaped = 1;
*((jl_array_t**)(&a->_space[0])) = a;
}
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
return a;
}
// own_buffer != 0 iff GC should call free() on this pointer eventually
jl_array_t *jl_ptr_to_array_1d(jl_value_t *atype, void *data, size_t nel,
int own_buffer)
{
size_t elsz;
jl_array_t *a;
jl_value_t *el_type = jl_tparam0(atype);
int isunboxed = store_unboxed(el_type);
if (isunboxed)
elsz = jl_datatype_size(el_type);
else
elsz = sizeof(void*);
a = allocobj((sizeof(jl_array_t)+jl_array_ndimwords(1)*sizeof(size_t)+15)&-16);
a->type = atype;
a->data = data;
#ifdef STORE_ARRAY_LEN
a->length = nel;
#endif
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = 1;
a->isshared = 1;
a->isaligned = 0; // TODO: allow passing memalign'd buffers
if (own_buffer) {
a->how = 2;
jl_gc_track_malloced_array(a);
}
else {
a->how = 0;
}
a->nrows = nel;
a->maxsize = nel;
a->offset = 0;
return a;
}
// own_buffer != 0 iff GC should call free() on this pointer eventually
jl_array_t *jl_ptr_to_array_1d(jl_type_t *atype, void *data, size_t nel,
int own_buffer)
{
size_t elsz;
jl_array_t *a;
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
int isunboxed = jl_is_bits_type(el_type);
if (isunboxed)
elsz = jl_bitstype_nbits(el_type)/8;
else
elsz = sizeof(void*);
a = allocobj((sizeof(jl_array_t)+jl_array_ndimwords(1)*sizeof(size_t)+15)&-16);
a->type = atype;
a->data = data;
a->length = nel;
a->elsize = elsz;
a->ptrarray = !isunboxed;
a->ndims = 1;
if (own_buffer) {
a->ismalloc = 1;
jl_array_data_owner(a) = (jl_value_t*)jl_gc_acquire_buffer(data,nel*elsz);
}
else {
a->ismalloc = 0;
jl_array_data_owner(a) = (jl_value_t*)a;
}
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
return a;
}
jl_array_t *jl_reshape_array(jl_type_t *atype, jl_array_t *data,
jl_tuple_t *dims)
{
size_t i;
jl_array_t *a;
size_t ndims = jl_tuple_len(dims);
int ndimwords = jl_array_ndimwords(ndims);
a = allocobj((sizeof(jl_array_t) + ndimwords*sizeof(size_t) + 15)&-16);
a->type = atype;
a->ndims = ndims;
a->data = NULL;
JL_GC_PUSH(&a);
char *d = data->data;
if (data->ndims == 1) d -= data->offset*data->elsize;
if (d == jl_array_inline_data_area(data)) {
if (data->ndims == 1) {
// data might resize, so switch it to shared representation.
// problem: we'd like to do that, but it might not be valid,
// since the buffer might be used from C in a way that it's
// assumed not to move. for now, just copy the data (note this
// case only happens for sizes <= ARRAY_INLINE_NBYTES)
jl_mallocptr_t *mp = array_new_buffer(data, data->length);
memcpy(mp->ptr, data->data, data->length * data->elsize);
a->data = mp->ptr;
jl_array_data_owner(a) = (jl_value_t*)mp;
a->ismalloc = 1;
//data->data = mp->ptr;
//data->offset = 0;
//data->maxsize = data->length;
//jl_array_data_owner(data) = (jl_value_t*)mp;
}
else {
a->ismalloc = 0;
jl_array_data_owner(a) = (jl_value_t*)data;
}
}
else {
a->ismalloc = data->ismalloc;
jl_array_data_owner(a) = jl_array_data_owner(data);
}
if (a->data == NULL) a->data = data->data;
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
if (jl_is_bits_type(el_type)) {
a->elsize = jl_bitstype_nbits(el_type)/8;
a->ptrarray = 0;
}
else {
a->elsize = sizeof(void*);
a->ptrarray = 1;
}
if (ndims == 1) {
a->length = jl_unbox_long(jl_tupleref(dims,0));
a->nrows = a->length;
a->maxsize = a->length;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
size_t l=1;
for(i=0; i < ndims; i++) {
adims[i] = jl_unbox_long(jl_tupleref(dims, i));
l *= adims[i];
}
a->length = l;
}
JL_GC_POP();
return a;
}
static jl_array_t *_new_array(jl_type_t *atype,
uint32_t ndims, size_t *dims)
{
size_t i, tot, nel=1;
int isunboxed=0, elsz;
void *data;
jl_array_t *a;
for(i=0; i < ndims; i++) {
nel *= dims[i];
}
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
isunboxed = jl_is_bits_type(el_type);
if (isunboxed) {
elsz = jl_bitstype_nbits(el_type)/8;
tot = elsz * nel;
if (elsz == 1) {
// hidden 0 terminator for all byte arrays
tot++;
}
}
else {
elsz = sizeof(void*);
tot = sizeof(void*) * nel;
}
int ndimwords = (ndims > 2 ? (ndims-2) : 0);
#ifndef __LP64__
// on 32-bit, ndimwords must be odd to preserve 8-byte alignment
ndimwords += (~ndimwords)&1;
#endif
if (tot <= ARRAY_INLINE_NBYTES) {
a = allocobj(sizeof(jl_array_t) + tot + (ndimwords-1)*sizeof(size_t));
a->type = atype;
data = (&a->_space[0] + ndimwords*sizeof(size_t));
if (tot > 0 && !isunboxed) {
memset(data, 0, tot);
}
}
else {
a = allocobj(sizeof(jl_array_t) + (ndimwords-1)*sizeof(size_t));
JL_GC_PUSH(&a);
a->type = atype;
// temporarily initialize to make gc-safe
a->data = NULL;
a->length = 0;
a->reshaped = 0;
data = allocb(tot);
if (!isunboxed)
memset(data, 0, tot);
JL_GC_POP();
}
a->data = data;
if (elsz == 1) ((char*)data)[tot-1] = '\0';
a->length = nel;
a->ndims = ndims;
a->reshaped = 0;
a->ptrarray = !isunboxed;
a->elsize = elsz;
if (ndims == 1) {
a->nrows = nel;
a->maxsize = nel;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++)
adims[i] = dims[i];
}
return a;
}
static jl_array_t *_new_array(jl_type_t *atype,
uint32_t ndims, size_t *dims)
{
size_t i, tot, nel=1;
int isunboxed=0, elsz;
void *data;
jl_array_t *a;
for(i=0; i < ndims; i++) {
nel *= dims[i];
}
jl_type_t *el_type = (jl_type_t*)jl_tparam0(atype);
isunboxed = jl_is_bits_type(el_type);
if (isunboxed) {
elsz = jl_bitstype_nbits(el_type)/8;
tot = elsz * nel;
if (elsz == 1) {
// hidden 0 terminator for all byte arrays
tot++;
}
}
else {
elsz = sizeof(void*);
tot = sizeof(void*) * nel;
}
int ndimwords = jl_array_ndimwords(ndims);
if (tot <= ARRAY_INLINE_NBYTES) {
size_t tsz = tot>sizeof(size_t) ? tot-sizeof(size_t) : tot;
a = allocobj((sizeof(jl_array_t)+tsz+ndimwords*sizeof(size_t)+15)&-16);
a->type = atype;
a->ismalloc = 0;
data = (&a->_space[0] + ndimwords*sizeof(size_t));
if (tot > 0 && !isunboxed) {
memset(data, 0, tot);
}
}
else {
a = allocobj((sizeof(jl_array_t)+ndimwords*sizeof(size_t)+15)&-16);
JL_GC_PUSH(&a);
a->type = atype;
a->ismalloc = 1;
// temporarily initialize to make gc-safe
a->data = NULL;
jl_value_t **powner = (jl_value_t**)(&a->_space[0] + ndimwords*sizeof(size_t));
*powner = (jl_value_t*)jl_gc_managed_malloc(tot);
data = ((jl_mallocptr_t*)*powner)->ptr;
if (!isunboxed)
memset(data, 0, tot);
JL_GC_POP();
}
a->data = data;
if (elsz == 1) ((char*)data)[tot-1] = '\0';
a->length = nel;
a->ndims = ndims;
a->ptrarray = !isunboxed;
a->elsize = elsz;
if (ndims == 1) {
a->nrows = nel;
a->maxsize = nel;
a->offset = 0;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++)
adims[i] = dims[i];
}
return a;
}
static jl_value_t *jl_deserialize_value(ios_t *s)
{
int pos = ios_pos(s);
int32_t tag = read_uint8(s);
if (tag == Null_tag)
return NULL;
if (tag == 0) {
tag = read_uint8(s);
return (jl_value_t*)ptrhash_get(&deser_tag, (void*)(ptrint_t)tag);
}
if (tag == BackRef_tag) {
assert(tree_literal_values == NULL);
ptrint_t offs = read_int32(s);
void **bp = ptrhash_bp(&backref_table, (void*)(ptrint_t)offs);
assert(*bp != HT_NOTFOUND);
return (jl_value_t*)*bp;
}
jl_value_t *vtag=(jl_value_t*)ptrhash_get(&deser_tag,(void*)(ptrint_t)tag);
if (tag >= VALUE_TAGS) {
return vtag;
}
int usetable = (tree_literal_values == NULL);
size_t i;
if (vtag == (jl_value_t*)jl_tuple_type ||
vtag == (jl_value_t*)LongTuple_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_tuple_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_tuple_t *tu = jl_alloc_tuple_uninit(len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)tu);
for(i=0; i < len; i++)
jl_tupleset(tu, i, jl_deserialize_value(s));
return (jl_value_t*)tu;
}
else if (vtag == (jl_value_t*)jl_symbol_type ||
vtag == (jl_value_t*)LongSymbol_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_symbol_type)
len = read_uint8(s);
else
len = read_int32(s);
char *name = alloca(len+1);
ios_read(s, name, len);
name[len] = '\0';
jl_value_t *s = (jl_value_t*)jl_symbol(name);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, s);
return s;
}
else if (vtag == (jl_value_t*)jl_array_type) {
jl_value_t *aty = jl_deserialize_value(s);
jl_value_t *elty = jl_tparam0(aty);
int16_t ndims = jl_unbox_long(jl_tparam1(aty));
size_t *dims = alloca(ndims*sizeof(size_t));
for(i=0; i < ndims; i++)
dims[i] = jl_unbox_long(jl_deserialize_value(s));
jl_array_t *a = jl_new_array_((jl_type_t*)aty, ndims, dims);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)a);
if (jl_is_bits_type(elty)) {
size_t tot = a->length * a->elsize;
ios_read(s, a->data, tot);
}
else {
for(i=0; i < a->length; i++) {
((jl_value_t**)a->data)[i] = jl_deserialize_value(s);
}
}
return (jl_value_t*)a;
}
else if (vtag == (jl_value_t*)jl_expr_type ||
vtag == (jl_value_t*)LongExpr_tag) {
size_t len;
if (vtag == (jl_value_t*)jl_expr_type)
len = read_uint8(s);
else
len = read_int32(s);
jl_expr_t *e = jl_exprn((jl_sym_t*)jl_deserialize_value(s), len);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, (jl_value_t*)e);
e->etype = jl_deserialize_value(s);
for(i=0; i < len; i++) {
jl_cellset(e->args, i, jl_deserialize_value(s));
}
return (jl_value_t*)e;
}
else if (vtag == (jl_value_t*)LiteralVal_tag) {
return jl_cellref(tree_literal_values, read_uint16(s));
}
else if (vtag == (jl_value_t*)jl_tvar_type) {
jl_tvar_t *tv = (jl_tvar_t*)newobj((jl_type_t*)jl_tvar_type, 4);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, tv);
tv->name = (jl_sym_t*)jl_deserialize_value(s);
tv->lb = jl_deserialize_value(s);
tv->ub = jl_deserialize_value(s);
tv->bound = read_int8(s);
return (jl_value_t*)tv;
}
else if (vtag == (jl_value_t*)jl_func_kind) {
jl_value_t *ftype = jl_deserialize_value(s);
jl_function_t *f = (jl_function_t*)newobj((jl_type_t*)ftype, 3);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, f);
f->linfo = (jl_lambda_info_t*)jl_deserialize_value(s);
f->env = jl_deserialize_value(s);
f->fptr = jl_deserialize_fptr(s);
if (f->fptr == NULL) {
f->fptr = &jl_trampoline;
}
return (jl_value_t*)f;
}
else if (vtag == (jl_value_t*)jl_lambda_info_type) {
jl_lambda_info_t *li =
(jl_lambda_info_t*)newobj((jl_type_t*)jl_lambda_info_type,
LAMBDA_INFO_NW);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, li);
li->ast = jl_deserialize_value(s);
li->sparams = (jl_tuple_t*)jl_deserialize_value(s);
li->tfunc = jl_deserialize_value(s);
li->name = (jl_sym_t*)jl_deserialize_value(s);
li->specTypes = jl_deserialize_value(s);
li->specializations = (jl_array_t*)jl_deserialize_value(s);
li->inferred = jl_deserialize_value(s);
li->file = jl_deserialize_value(s);
li->line = jl_deserialize_value(s);
li->module = (jl_module_t*)jl_deserialize_value(s);
li->fptr = NULL;
li->roots = NULL;
li->functionObject = NULL;
li->inInference = 0;
li->inCompile = 0;
li->unspecialized = NULL;
return (jl_value_t*)li;
}
else if (vtag == (jl_value_t*)jl_module_type) {
jl_module_t *m = jl_new_module(anonymous_sym);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, m);
m->name = (jl_sym_t*)jl_deserialize_value(s);
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_binding_t *b = jl_get_binding_wr(m, (jl_sym_t*)name);
b->value = jl_deserialize_value(s);
b->type = (jl_type_t*)jl_deserialize_value(s);
b->constp = read_int8(s);
b->exportp = read_int8(s);
}
while (1) {
jl_value_t *name = jl_deserialize_value(s);
if (name == NULL)
break;
jl_set_expander(m, (jl_sym_t*)name,
(jl_function_t*)jl_deserialize_value(s));
}
return (jl_value_t*)m;
}
else if (vtag == (jl_value_t*)jl_methtable_type) {
jl_methtable_t *mt = (jl_methtable_t*)allocobj(sizeof(jl_methtable_t));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, mt);
mt->type = (jl_type_t*)jl_methtable_type;
mt->defs = jl_deserialize_methlist(s);
mt->cache = jl_deserialize_methlist(s);
mt->cache_1arg = (jl_array_t*)jl_deserialize_value(s);
mt->max_args = read_int32(s);
return (jl_value_t*)mt;
}
else if (vtag == (jl_value_t*)SmallInt64_tag) {
jl_value_t *v = jl_box_int64(read_int32(s));
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_bits_kind) {
jl_bits_type_t *bt = (jl_bits_type_t*)jl_deserialize_value(s);
int nby = bt->nbits/8;
char *data = alloca(nby);
ios_read(s, data, nby);
jl_value_t *v=NULL;
if (bt == jl_int32_type)
v = jl_box_int32(*(int32_t*)data);
else if (bt == jl_int64_type)
v = jl_box_int64(*(int64_t*)data);
else if (bt == jl_bool_type)
v = jl_box_bool(*(int8_t*)data);
else {
switch (bt->nbits) {
case 8: v = jl_box8 (bt, *(int8_t*) data); break;
case 16: v = jl_box16(bt, *(int16_t*)data); break;
case 32: v = jl_box32(bt, *(int32_t*)data); break;
case 64: v = jl_box64(bt, *(int64_t*)data); break;
default:
v = (jl_value_t*)allocobj(sizeof(void*)+nby);
v->type = (jl_type_t*)bt;
memcpy(jl_bits_data(v), data, nby);
}
}
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
return v;
}
else if (vtag == (jl_value_t*)jl_struct_kind) {
jl_struct_type_t *typ = (jl_struct_type_t*)jl_deserialize_value(s);
if (typ == jl_struct_kind || typ == jl_bits_kind)
return jl_deserialize_tag_type(s, typ, pos);
size_t nf = typ->names->length;
jl_value_t *v = jl_new_struct_uninit(typ);
if (usetable)
ptrhash_put(&backref_table, (void*)(ptrint_t)pos, v);
for(i=0; i < nf; i++) {
((jl_value_t**)v)[i+1] = jl_deserialize_value(s);
}
// TODO: put WeakRefs on the weak_refs list
return v;
}
else if (vtag == (jl_value_t*)jl_tag_kind) {
return jl_deserialize_tag_type(s, jl_tag_kind, pos);
}
assert(0);
return NULL;
}
static jl_array_t *_new_array_(jl_value_t *atype, uint32_t ndims, size_t *dims,
int isunboxed, int elsz)
{
size_t i, tot, nel=1;
wideint_t prod;
void *data;
jl_array_t *a;
for(i=0; i < ndims; i++) {
prod = (wideint_t)nel * (wideint_t)dims[i];
if (prod > (wideint_t) MAXINTVAL)
jl_error("invalid Array dimensions");
nel = prod;
}
if (isunboxed) {
prod = (wideint_t)elsz * (wideint_t)nel;
if (prod > (wideint_t) MAXINTVAL)
jl_error("invalid Array size");
tot = prod;
if (elsz == 1) {
// hidden 0 terminator for all byte arrays
tot++;
}
}
else {
prod = (wideint_t)sizeof(void*) * (wideint_t)nel;
if (prod > (wideint_t) MAXINTVAL)
jl_error("invalid Array size");
tot = prod;
}
int ndimwords = jl_array_ndimwords(ndims);
size_t tsz = sizeof(jl_array_t);
tsz += ndimwords*sizeof(size_t);
if (tot <= ARRAY_INLINE_NBYTES) {
if (isunboxed && elsz >= 4)
tsz = (tsz+15)&-16; // align data area 16
size_t doffs = tsz;
tsz += tot;
tsz = (tsz+15)&-16; // align whole object 16
a = allocobj(tsz);
a->type = atype;
a->how = 0;
data = (char*)a + doffs;
if (tot > 0 && !isunboxed) {
memset(data, 0, tot);
}
}
else {
tsz = (tsz+15)&-16; // align whole object size 16
a = allocobj(tsz);
JL_GC_PUSH1(&a);
a->type = atype;
// temporarily initialize to make gc-safe
a->data = NULL;
a->how = 2;
data = jl_gc_managed_malloc(tot);
jl_gc_track_malloced_array(a);
if (!isunboxed)
memset(data, 0, tot);
JL_GC_POP();
}
a->data = data;
if (elsz == 1) ((char*)data)[tot-1] = '\0';
#ifdef STORE_ARRAY_LEN
a->length = nel;
#endif
a->ndims = ndims;
a->ptrarray = !isunboxed;
a->elsize = elsz;
a->isshared = 0;
a->isaligned = 1;
a->offset = 0;
if (ndims == 1) {
a->nrows = nel;
a->maxsize = nel;
}
else {
size_t *adims = &a->nrows;
for(i=0; i < ndims; i++)
adims[i] = dims[i];
}
return a;
}
