mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of a bunch of dead shape code. Closes #2552.

Browse Source
This commit is contained in:
Michael Sullivan 2012-06-08 15:21:32 -07:00
parent 70b79d1e32
commit b22620624c
5 changed files with 69 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/rt/rust_box_annihilator.cpp
View File

@ -8,40 +8,36 @@ class annihilator : public shape::data<annihilator,shape::ptr> {
annihilator(const annihilator &other, const shape::ptr &in_dp)
: shape::data<annihilator,shape::ptr>(other.task, other.align,
other.sp, other.params,
other.sp,
other.tables, in_dp) {}
annihilator(const annihilator &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables = NULL)
: shape::data<annihilator,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables ? in_tables : other.tables,
other.dp) {}
annihilator(const annihilator &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
shape::ptr in_dp)
: shape::data<annihilator,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables,
in_dp) {}
annihilator(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
uint8_t *in_data)
: shape::data<annihilator,shape::ptr>(in_task, in_align, in_sp,
in_params, in_tables, in_data) {}
in_tables,
shape::ptr(in_data)) {}
void walk_vec2(bool is_pod) {
void *vec = shape::get_dp<void *>(dp);
@ -145,8 +141,7 @@ class annihilator : public shape::data<annihilator,shape::ptr> {
f(NULL, args->dtor->env, args->data);
}
void walk_res2(const shape::rust_fn *dtor, unsigned n_params,
const shape::type_param *params, const uint8_t *end_sp,
void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
bool live) {
void *data = (void*)(uintptr_t)dp;
// Switch back to the Rust stack to run the destructor
@ -173,7 +168,7 @@ class annihilator : public shape::data<annihilator,shape::ptr> {
void walk_variant2(shape::tag_info &tinfo, uint32_t variant_id,
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end) {
annihilator sub(*this, variant_ptr_and_end.first, tinfo.params);
annihilator sub(*this, variant_ptr_and_end.first);
const uint8_t *variant_end = variant_ptr_and_end.second;
while (sub.sp < variant_end) {
@ -194,11 +189,9 @@ annihilator::do_annihilate(rust_task *task, rust_opaque_box *box) {
const type_desc *tydesc = box->td;
uint8_t *p = (uint8_t*) box_body(box);
shape::arena arena;
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, p, arena);
annihilator annihilator(task, true, tydesc->shape,
params, tydesc->shape_tables, p);
tydesc->shape_tables, p);
annihilator.walk();
task->boxed.free(box);
}

55
src/rt/rust_cc.cpp
View File

@ -34,30 +34,26 @@ class irc : public shape::data<irc,shape::ptr> {
irc(const irc &other, const shape::ptr &in_dp)
: shape::data<irc,shape::ptr>(other.task, other.align, other.sp,
other.params, other.tables, in_dp),
other.tables, in_dp),
ircs(other.ircs) {}
irc(const irc &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables = NULL)
: shape::data<irc,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables ? in_tables : other.tables,
other.dp),
ircs(other.ircs) {}
irc(const irc &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
shape::ptr in_dp)
: shape::data<irc,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables,
in_dp),
ircs(other.ircs) {}
@ -65,13 +61,12 @@ class irc : public shape::data<irc,shape::ptr> {
irc(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
uint8_t *in_data,
irc_map &in_ircs)
: shape::data<irc,shape::ptr>(in_task, in_align, in_sp, in_params,
in_tables, in_data),
ircs(in_ircs) {}
: shape::data<irc,shape::ptr>(in_task, in_align, in_sp,
in_tables, shape::ptr(in_data)),
ircs(in_ircs) {}
void walk_vec2(bool is_pod, std::pair<uint8_t *,uint8_t *> data_range) {
@ -80,8 +75,8 @@ class irc : public shape::data<irc,shape::ptr> {
if (is_pod)
return;
irc sub(*this, data_range.first);
shape::ptr data_end = sub.end_dp = data_range.second;
irc sub(*this, shape::ptr(data_range.first));
shape::ptr data_end = sub.end_dp = shape::ptr(data_range.second);
while (sub.dp < data_end) {
sub.walk_reset();
// FIXME: shouldn't this be 'sub.align = true;'?
@ -148,8 +143,7 @@ class irc : public shape::data<irc,shape::ptr> {
void walk_tydesc2(char) {
}
void walk_res2(const shape::rust_fn *dtor, unsigned n_params,
const shape::type_param *params, const uint8_t *end_sp,
void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
bool live) {
while (this->sp != end_sp) {
this->walk();
@ -214,7 +208,7 @@ void
irc::walk_variant2(shape::tag_info &tinfo, uint32_t variant_id,
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end) {
irc sub(*this, variant_ptr_and_end.first, tinfo.params);
irc sub(*this, variant_ptr_and_end.first);
assert(variant_id < 256); // FIXME: Temporary sanity check.
@ -240,10 +234,8 @@ irc::compute_ircs(rust_task *task, irc_map &ircs) {
box, tydesc, body);
shape::arena arena;
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, body, arena);
irc irc(task, true, tydesc->shape, params, tydesc->shape_tables,
irc irc(task, true, tydesc->shape, tydesc->shape_tables,
body, ircs);
irc.walk();
}
@ -292,30 +284,26 @@ class mark : public shape::data<mark,shape::ptr> {
mark(const mark &other, const shape::ptr &in_dp)
: shape::data<mark,shape::ptr>(other.task, other.align, other.sp,
other.params, other.tables, in_dp),
other.tables, in_dp),
marked(other.marked) {}
mark(const mark &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables = NULL)
: shape::data<mark,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables ? in_tables : other.tables,
other.dp),
marked(other.marked) {}
mark(const mark &other,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
shape::ptr in_dp)
: shape::data<mark,shape::ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables,
in_dp),
marked(other.marked) {}
@ -323,12 +311,11 @@ class mark : public shape::data<mark,shape::ptr> {
mark(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const shape::type_param *in_params,
const rust_shape_tables *in_tables,
uint8_t *in_data,
std::set<rust_opaque_box*> &in_marked)
: shape::data<mark,shape::ptr>(in_task, in_align, in_sp, in_params,
in_tables, in_data),
: shape::data<mark,shape::ptr>(in_task, in_align, in_sp,
in_tables, shape::ptr(in_data)),
marked(in_marked) {}
void walk_vec2(bool is_pod, std::pair<uint8_t *,uint8_t *> data_range) {
@ -340,8 +327,8 @@ class mark : public shape::data<mark,shape::ptr> {
if (data_range.second - data_range.first > 100000)
abort(); // FIXME: Temporary sanity check.
mark sub(*this, data_range.first);
shape::ptr data_end = sub.end_dp = data_range.second;
mark sub(*this, shape::ptr(data_range.first));
shape::ptr data_end = sub.end_dp = shape::ptr(data_range.second);
while (sub.dp < data_end) {
sub.walk_reset();
align = true;
@ -399,9 +386,8 @@ class mark : public shape::data<mark,shape::ptr> {
}
}
void walk_res2(const shape::rust_fn *dtor, unsigned n_params,
const shape::type_param *params, const uint8_t *end_sp,
bool live) {
void walk_res2(const shape::rust_fn *dtor, const uint8_t *end_sp,
bool live) {
while (this->sp != end_sp) {
this->walk();
align = true;
@ -458,7 +444,7 @@ void
mark::walk_variant2(shape::tag_info &tinfo, uint32_t variant_id,
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end) {
mark sub(*this, variant_ptr_and_end.first, tinfo.params);
mark sub(*this, variant_ptr_and_end.first);
assert(variant_id < 256); // FIXME: Temporary sanity check.
@ -487,10 +473,8 @@ mark::do_mark(rust_task *task,
uint8_t *p = (uint8_t*) box_body(box);
shape::arena arena;
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, p, arena);
mark mark(task, true, tydesc->shape, params, tydesc->shape_tables,
mark mark(task, true, tydesc->shape, tydesc->shape_tables,
p, marked);
mark.walk();
}
@ -543,8 +527,7 @@ do_final_cc(rust_task *task) {
cerr << "Unreclaimed object found at " << (void*) box << ": ";
const type_desc *td = box->td;
shape::arena arena;
shape::type_param *params = shape::type_param::from_tydesc(td, arena);
shape::log log(task, true, td->shape, params, td->shape_tables,
shape::log log(task, true, td->shape, td->shape_tables,
(uint8_t*)box_body(box), cerr);
log.walk();
cerr << "\n";

123
src/rt/rust_shape.cpp
View File

@ -21,66 +21,11 @@ const uint8_t CMP_EQ = 0u;
const uint8_t CMP_LT = 1u;
const uint8_t CMP_LE = 2u;
// Type parameters
type_param *
type_param::make(const type_desc **tydescs, unsigned n_tydescs,
arena &arena) {
if (!n_tydescs)
return NULL;
type_param *ptrs = arena.alloc<type_param>(n_tydescs);
for (uint32_t i = 0; i < n_tydescs; i++) {
const type_desc *subtydesc = tydescs[i];
ptrs[i].shape = subtydesc->shape;
ptrs[i].tables = subtydesc->shape_tables;
// FIXME: Doesn't handle a type-parametric object closing over a
// type-parametric object type properly.
ptrs[i].params = from_tydesc(subtydesc, arena);
}
return ptrs;
}
// Constructs type parameters from an object shape. This is a bit messy,
// because it requires that the object shape have a specific format.
type_param *
type_param::from_obj_shape(const uint8_t *sp, ptr dp, arena &arena) {
uint8_t shape = *sp++; assert(shape == SHAPE_STRUCT);
get_u16_bump(sp); // Skip over the size.
shape = *sp++; assert(shape == SHAPE_PTR);
shape = *sp++; assert(shape == SHAPE_STRUCT);
unsigned n_tydescs = get_u16_bump(sp);
// Type descriptors start right after the reference count.
const type_desc **descs = (const type_desc **)(dp + sizeof(uintptr_t));
return make(descs, n_tydescs, arena);
}
// A shape printer, useful for debugging
void
print::walk_tag1(tag_info &tinfo) {
DPRINT("tag%u", tinfo.tag_id);
if (!tinfo.n_params)
return;
DPRINT("<");
bool first = true;
for (uint16_t i = 0; i < tinfo.n_params; i++) {
if (!first)
DPRINT(",");
first = false;
ctxt<print> sub(*this, tinfo.params[i].shape);
sub.walk();
}
DPRINT(">");
}
void
@ -100,27 +45,9 @@ print::walk_struct1(const uint8_t *end_sp) {
}
void
print::walk_res1(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp) {
print::walk_res1(const rust_fn *dtor, const uint8_t *end_sp) {
DPRINT("res@%p", dtor);
// Print type parameters.
if (n_params) {
DPRINT("<");
bool first = true;
for (uint16_t i = 0; i < n_params; i++) {
if (!first)
DPRINT(",");
first = false;
ctxt<print> sub(*this, params[i].shape);
sub.walk();
}
DPRINT(">");
}
// Print arguments.
if (sp == end_sp)
@ -140,15 +67,6 @@ print::walk_res1(const rust_fn *dtor, unsigned n_params,
DPRINT(")");
}
void
print::walk_var1(uint8_t param_index) {
DPRINT("%c=", 'T' + param_index);
const type_param *param = &params[param_index];
print sub(*this, param->shape, param->params, param->tables);
sub.walk();
}
template<>
void print::walk_number1<uint8_t>() { DPRINT("u8"); }
template<>
@ -186,7 +104,7 @@ size_of::compute_tag_size(tag_info &tinfo) {
const uint8_t *variant_ptr = variant_ptr_and_end.first;
const uint8_t *variant_end = variant_ptr_and_end.second;
size_of sub(*this, variant_ptr, tinfo.params, NULL);
size_of sub(*this, variant_ptr, NULL);
sub.align = false;
// Compute the size of this variant.
@ -308,31 +226,27 @@ public:
cmp(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables,
uint8_t *in_data_0,
uint8_t *in_data_1)
: data<cmp,ptr_pair>(in_task, in_align, in_sp, in_params, in_tables,
: data<cmp,ptr_pair>(in_task, in_align, in_sp, in_tables,
ptr_pair::make(in_data_0, in_data_1)),
result(0) {}
cmp(const cmp &other,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables,
ptr_pair &in_dp)
: data<cmp,ptr_pair>(other.task, other.align, in_sp, in_params, in_tables,
: data<cmp,ptr_pair>(other.task, other.align, in_sp, in_tables,
in_dp),
result(0) {}
cmp(const cmp &other,
const uint8_t *in_sp = NULL,
const type_param *in_params = NULL,
const rust_shape_tables *in_tables = NULL)
: data<cmp,ptr_pair>(other.task,
other.align,
in_sp ? in_sp : other.sp,
in_params ? in_params : other.params,
in_tables ? in_tables : other.tables,
other.dp),
result(0) {}
@ -341,7 +255,6 @@ public:
: data<cmp,ptr_pair>(other.task,
other.align,
other.sp,
other.params,
other.tables,
in_dp),
result(0) {}
@ -386,8 +299,7 @@ public:
void walk_tag2(tag_info &tinfo,
const data_pair<tag_variant_t> &tag_variants);
void walk_struct2(const uint8_t *end_sp);
void walk_res2(const rust_fn *dtor, uint16_t n_ty_params,
const type_param *ty_params_sp, const uint8_t *end_sp,
void walk_res2(const rust_fn *dtor, const uint8_t *end_sp,
const data_pair<uintptr_t> &live);
void walk_variant2(tag_info &tinfo,
tag_variant_t variant_id,
@ -439,8 +351,7 @@ cmp::walk_struct2(const uint8_t *end_sp) {
}
void
cmp::walk_res2(const rust_fn *dtor, uint16_t n_ty_params,
const type_param *ty_params_sp, const uint8_t *end_sp,
cmp::walk_res2(const rust_fn *dtor, const uint8_t *end_sp,
const data_pair<uintptr_t> &live) {
abort(); // TODO
}
@ -450,7 +361,7 @@ cmp::walk_variant2(tag_info &tinfo,
tag_variant_t variant_id,
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end) {
cmp sub(*this, variant_ptr_and_end.first, tinfo.params);
cmp sub(*this, variant_ptr_and_end.first);
const uint8_t *variant_end = variant_ptr_and_end.second;
while (!result && sub.sp < variant_end) {
@ -532,7 +443,7 @@ log::walk_variant2(tag_info &tinfo,
tag_variant_t variant_id,
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end) {
log sub(*this, variant_ptr_and_end.first, tinfo.params);
log sub(*this, variant_ptr_and_end.first);
const uint8_t *variant_end = variant_ptr_and_end.second;
bool first = true;
@ -547,8 +458,7 @@ log::walk_variant2(tag_info &tinfo,
}
void
log::walk_res2(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp, bool live) {
log::walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live) {
out << prefix << "res";
if (this->sp == end_sp)
@ -576,12 +486,7 @@ shape_cmp_type(int8_t *result, const type_desc *tydesc,
rust_task *task = rust_get_current_task();
shape::arena arena;
// FIXME: This may well be broken when comparing two closures or objects
// that close over different sets of type parameters.
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, data_0, arena);
shape::cmp cmp(task, true, tydesc->shape, params, tydesc->shape_tables,
shape::cmp cmp(task, true, tydesc->shape, tydesc->shape_tables,
data_0, data_1);
cmp.walk();
@ -597,11 +502,9 @@ shape_log_str(const type_desc *tydesc, uint8_t *data) {
rust_task *task = rust_get_current_task();
shape::arena arena;
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, data, arena);
std::stringstream ss;
shape::log log(task, true, tydesc->shape, params, tydesc->shape_tables,
shape::log log(task, true, tydesc->shape, tydesc->shape_tables,
data, ss);
log.walk();
@ -615,11 +518,9 @@ shape_log_type(const type_desc *tydesc, uint8_t *data, uint32_t level) {
rust_task *task = rust_get_current_task();
shape::arena arena;
shape::type_param *params =
shape::type_param::from_tydesc_and_data(tydesc, data, arena);
std::stringstream ss;
shape::log log(task, true, tydesc->shape, params, tydesc->shape_tables,
shape::log log(task, true, tydesc->shape, tydesc->shape_tables,
data, ss);
log.walk();

181
src/rt/rust_shape.h
View File

@ -49,7 +49,6 @@ const uint8_t SHAPE_STRUCT = 17u;
const uint8_t SHAPE_BOX_FN = 18u;
const uint8_t SHAPE_OBJ = 19u;
const uint8_t SHAPE_RES = 20u;
const uint8_t SHAPE_VAR = 21u;
const uint8_t SHAPE_UNIQ = 22u;
const uint8_t SHAPE_UNIQ_FN = 25u;
const uint8_t SHAPE_STACK_FN = 26u;
@ -72,7 +71,6 @@ const uint8_t SHAPE_PTR = SHAPE_U32;
struct rust_obj;
struct size_align;
class ptr;
class type_param;
// Arenas; these functions must execute very quickly, so we use an arena
@ -183,8 +181,6 @@ struct tag_info {
uint16_t variant_count; // Number of variants in the tag.
const uint8_t *largest_variants_ptr; // Ptr to largest variants table.
size_align tag_sa; // Size and align of this tag.
uint16_t n_params; // Number of type parameters.
const type_param *params; // Array of type parameters.
};
@ -229,7 +225,6 @@ template<typename T>
class ctxt {
public:
const uint8_t *sp; // shape pointer
const type_param *params; // shapes of type parameters
const rust_shape_tables *tables;
rust_task *task;
bool align;
@ -237,10 +232,8 @@ public:
ctxt(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables)
: sp(in_sp),
params(in_params),
tables(in_tables),
task(in_task),
align(in_align) {}
@ -248,10 +241,8 @@ public:
template<typename U>
ctxt(const ctxt<U> &other,
const uint8_t *in_sp = NULL,
const type_param *in_params = NULL,
const rust_shape_tables *in_tables = NULL)
: sp(in_sp ? in_sp : other.sp),
params(in_params ? in_params : other.params),
tables(in_tables ? in_tables : other.tables),
task(other.task),
align(other.align) {}
@ -278,7 +269,6 @@ private:
void walk_uniq0();
void walk_struct0();
void walk_res0();
void walk_var0();
void walk_rptr0();
void walk_fixedvec0();
void walk_slice0();
@ -292,60 +282,6 @@ struct rust_fn {
void *env;
};
// Type parameters
class type_param {
private:
static type_param *make(const type_desc **tydescs, unsigned n_tydescs,
arena &arena);
public:
const uint8_t *shape;
const rust_shape_tables *tables;
const type_param *params; // subparameters
// Creates type parameters from an object shape description.
static type_param *from_obj_shape(const uint8_t *sp, ptr dp,
arena &arena);
template<typename T>
inline void set(ctxt<T> *cx) {
shape = cx->sp;
tables = cx->tables;
params = cx->params;
}
// Creates type parameters from a type descriptor.
static inline type_param *from_tydesc(const type_desc *tydesc,
arena &arena) {
// In order to find the type parameters of objects and functions, we
// have to actually have the data pointer, since we don't statically
// know from the type of an object or function which type parameters
// it closes over.
assert(!tydesc->n_obj_params && "Type-parametric objects "
"must go through from_tydesc_and_data() instead!");
return make(tydesc->first_param, tydesc->n_params, arena);
}
static type_param *from_tydesc_and_data(const type_desc *tydesc,
uint8_t *dp, arena &arena) {
if (tydesc->n_obj_params) {
uintptr_t n_obj_params = tydesc->n_obj_params;
const type_desc **first_param;
// Object closure.
DPRINT("n_obj_params OBJ %lu, tydesc %p, starting at %p\n",
(unsigned long)n_obj_params, tydesc,
dp + sizeof(uintptr_t) * 2);
first_param = (const type_desc **)(dp + sizeof(uintptr_t) * 2);
return make(first_param, n_obj_params, arena);
}
return make(tydesc->first_param, tydesc->n_params, arena);
}
};
// Traversals
#define WALK_NUMBER(c_type) \
@ -372,7 +308,6 @@ ctxt<T>::walk() {
case SHAPE_BOX: walk_box0(); break;
case SHAPE_STRUCT: walk_struct0(); break;
case SHAPE_RES: walk_res0(); break;
case SHAPE_VAR: walk_var0(); break;
case SHAPE_UNIQ: walk_uniq0(); break;
case SHAPE_BOX_FN:
case SHAPE_UNIQ_FN:
@ -460,18 +395,9 @@ ctxt<T>::walk_tag0() {
// Determine the size and alignment.
tinfo.tag_sa = get_size_align(tinfo.info_ptr);
// Determine the number of parameters.
tinfo.n_params = get_u16_bump(sp);
// Read in the tag type parameters.
type_param params[tinfo.n_params];
for (uint16_t i = 0; i < tinfo.n_params; i++) {
uint16_t len = get_u16_bump(sp);
params[i].set(this);
sp += len;
}
tinfo.params = params;
// Read in a dummy value; this used to be the number of parameters
uint16_t number_of_params = get_u16_bump(sp);
assert(number_of_params == 0 && "tag has type parameters on it");
// Call to the implementation.
static_cast<T *>(this)->walk_tag1(tinfo);
@ -551,32 +477,22 @@ ctxt<T>::walk_res0() {
reinterpret_cast<const rust_fn **>(tables->resources);
const rust_fn *dtor = resources[dtor_offset];
// Read in the resource type parameters, but ignore them.
// TODO: remove after snapshot
uint16_t n_ty_params = get_u16_bump(sp);
// Read in the tag type parameters.
type_param params[n_ty_params];
for (uint16_t i = 0; i < n_ty_params; i++) {
uint16_t ty_param_len = get_u16_bump(sp);
const uint8_t *next_sp = sp + ty_param_len;
params[i].set(this);
sp = next_sp;
sp += ty_param_len;
}
uint16_t sp_size = get_u16_bump(sp);
const uint8_t *end_sp = sp + sp_size;
static_cast<T *>(this)->walk_res1(dtor, n_ty_params, params, end_sp);
static_cast<T *>(this)->walk_res1(dtor, end_sp);
sp = end_sp;
}
template<typename T>
void
ctxt<T>::walk_var0() {
uint8_t param = *sp++;
static_cast<T *>(this)->walk_var1(param);
}
// A shape printer, useful for debugging
class print : public ctxt<print> {
@ -584,22 +500,18 @@ public:
template<typename T>
print(const ctxt<T> &other,
const uint8_t *in_sp = NULL,
const type_param *in_params = NULL,
const rust_shape_tables *in_tables = NULL)
: ctxt<print>(other, in_sp, in_params, in_tables) {}
: ctxt<print>(other, in_sp, in_tables) {}
print(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables)
: ctxt<print>(in_task, in_align, in_sp, in_params, in_tables) {}
: ctxt<print>(in_task, in_align, in_sp, in_tables) {}
void walk_tag1(tag_info &tinfo);
void walk_struct1(const uint8_t *end_sp);
void walk_res1(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp);
void walk_var1(uint8_t param);
void walk_res1(const rust_fn *dtor, const uint8_t *end_sp);
void walk_vec1(bool is_pod) {
DPRINT("vec<"); walk(); DPRINT(">");
@ -665,16 +577,14 @@ private:
public:
size_of(const size_of &other,
const uint8_t *in_sp = NULL,
const type_param *in_params = NULL,
const rust_shape_tables *in_tables = NULL)
: ctxt<size_of>(other, in_sp, in_params, in_tables) {}
: ctxt<size_of>(other, in_sp, in_tables) {}
template<typename T>
size_of(const ctxt<T> &other,
const uint8_t *in_sp = NULL,
const type_param *in_params = NULL,
const rust_shape_tables *in_tables = NULL)
: ctxt<size_of>(other, in_sp, in_params, in_tables) {}
: ctxt<size_of>(other, in_sp, in_tables) {}
void walk_tag1(tag_info &tinfo);
void walk_struct1(const uint8_t *end_sp);
@ -693,15 +603,7 @@ public:
sa.set(sizeof(void *), sizeof(void *));
}
void walk_var1(uint8_t param_index) {
const type_param *param = &params[param_index];
size_of sub(*this, param->shape, param->params, param->tables);
sub.walk();
sa = sub.sa;
}
void walk_res1(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp) {
void walk_res1(const rust_fn *dtor, const uint8_t *end_sp) {
abort(); // TODO
}
@ -744,8 +646,8 @@ public:
struct data { typedef T t; };
ptr() : p(NULL) {}
ptr(uint8_t *in_p) : p(in_p) {}
ptr(uintptr_t in_p) : p((uint8_t *)in_p) {}
explicit ptr(uint8_t *in_p) : p(in_p) {}
explicit ptr(uintptr_t in_p) : p((uint8_t *)in_p) {}
inline ptr operator+(const size_t amount) const {
return make(p + amount);
@ -961,10 +863,9 @@ public:
data(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables,
U const &in_dp)
: ctxt< data<T,U> >(in_task, in_align, in_sp, in_params, in_tables),
: ctxt< data<T,U> >(in_task, in_align, in_sp, in_tables),
dp(in_dp),
end_dp() {}
@ -1016,20 +917,10 @@ public:
dp = next_dp;
}
void walk_res1(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp) {
void walk_res1(const rust_fn *dtor, const uint8_t *end_sp) {
typename U::template data<uintptr_t>::t live = bump_dp<uintptr_t>(dp);
// Delegate to the implementation.
static_cast<T *>(this)->walk_res2(dtor, n_params, params, end_sp,
live);
}
void walk_var1(uint8_t param_index) {
const type_param *param = &this->params[param_index];
T sub(*static_cast<T *>(this), param->shape, param->params,
param->tables);
static_cast<T *>(this)->walk_subcontext2(sub);
dp = sub.dp;
static_cast<T *>(this)->walk_res2(dtor, end_sp, live);
}
template<typename WN>
@ -1050,8 +941,7 @@ data<T,U>::walk_box_contents1() {
if (body_td) {
U body_dp(dp.box_body());
arena arena;
type_param *params = type_param::from_tydesc(body_td, arena);
T sub(*static_cast<T *>(this), body_td->shape, params,
T sub(*static_cast<T *>(this), body_td->shape,
body_td->shape_tables, body_dp);
sub.align = true;
static_cast<T *>(this)->walk_box_contents2(sub);
@ -1065,8 +955,7 @@ data<T,U>::walk_uniq_contents1() {
if (body_td) {
U body_dp(dp.box_body());
arena arena;
type_param *params = type_param::from_tydesc(body_td, arena);
T sub(*static_cast<T *>(this), body_td->shape, params,
T sub(*static_cast<T *>(this), body_td->shape,
body_td->shape_tables, body_dp);
sub.align = true;
static_cast<T *>(this)->walk_uniq_contents2(sub);
@ -1102,8 +991,10 @@ data<T,U>::get_vec_data_range(ptr dp) {
template<typename T,typename U>
std::pair<ptr_pair,ptr_pair>
data<T,U>::get_vec_data_range(ptr_pair &dp) {
std::pair<uint8_t *,uint8_t *> fst = get_vec_data_range(dp.fst);
std::pair<uint8_t *,uint8_t *> snd = get_vec_data_range(dp.snd);
std::pair<uint8_t *,uint8_t *> fst =
get_vec_data_range(shape::ptr(dp.fst));
std::pair<uint8_t *,uint8_t *> snd =
get_vec_data_range(shape::ptr(dp.snd));
ptr_pair start(fst.first, snd.first);
ptr_pair end(fst.second, snd.second);
return std::make_pair(start, end);
@ -1122,9 +1013,9 @@ template<typename T,typename U>
std::pair<ptr_pair,ptr_pair>
data<T,U>::get_slice_data_range(bool is_str, ptr_pair &dp) {
std::pair<uint8_t *,uint8_t *> fst =
get_slice_data_range(is_str, dp.fst);
get_slice_data_range(is_str, shape::ptr(dp.fst));
std::pair<uint8_t *,uint8_t *> snd =
get_slice_data_range(is_str, dp.snd);
get_slice_data_range(is_str, shape::ptr(dp.snd));
ptr_pair start(fst.first, snd.first);
ptr_pair end(fst.second, snd.second);
return std::make_pair(start, end);
@ -1142,9 +1033,9 @@ std::pair<ptr_pair,ptr_pair>
data<T,U>::get_fixedvec_data_range(uint16_t n_elts, size_t elt_sz,
ptr_pair &dp) {
std::pair<uint8_t *,uint8_t *> fst =
get_fixedvec_data_range(n_elts, elt_sz, dp.fst);
get_fixedvec_data_range(n_elts, elt_sz, shape::ptr(dp.fst));
std::pair<uint8_t *,uint8_t *> snd =
get_fixedvec_data_range(n_elts, elt_sz, dp.snd);
get_fixedvec_data_range(n_elts, elt_sz, shape::ptr(dp.snd));
ptr_pair start(fst.first, snd.first);
ptr_pair end(fst.second, snd.second);
return std::make_pair(start, end);
@ -1181,9 +1072,8 @@ void
arena arena;
const type_desc *closure_td = pair.env->td;
type_param *params = type_param::from_tydesc(closure_td, arena);
ptr closure_dp((uintptr_t)box_body(pair.env));
T sub(*static_cast<T *>(this), closure_td->shape, params,
T sub(*static_cast<T *>(this), closure_td->shape,
closure_td->shape_tables, closure_dp);
sub.align = true;
@ -1208,12 +1098,10 @@ private:
log(log &other,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables = NULL)
: data<log,ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables ? in_tables : other.tables,
other.dp),
out(other.out),
@ -1221,13 +1109,11 @@ private:
log(log &other,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables,
ptr in_dp)
: data<log,ptr>(other.task,
other.align,
in_sp,
in_params,
in_tables,
in_dp),
out(other.out),
@ -1237,7 +1123,6 @@ private:
: data<log,ptr>(other.task,
other.align,
other.sp,
other.params,
other.tables,
in_dp),
out(other.out),
@ -1334,9 +1219,7 @@ private:
const std::pair<const uint8_t *,const uint8_t *>
variant_ptr_and_end);
void walk_string2(const std::pair<ptr,ptr> &data);
void walk_res2(const rust_fn *dtor, unsigned n_params,
const type_param *params, const uint8_t *end_sp,
bool live);
void walk_res2(const rust_fn *dtor, const uint8_t *end_sp, bool live);
template<typename T>
inline void walk_number2() {
@ -1348,11 +1231,11 @@ public:
log(rust_task *in_task,
bool in_align,
const uint8_t *in_sp,
const type_param *in_params,
const rust_shape_tables *in_tables,
uint8_t *in_data,
std::ostream &in_out)
: data<log,ptr>(in_task, in_align, in_sp, in_params, in_tables, in_data),
: data<log,ptr>(in_task, in_align, in_sp, in_tables,
ptr(in_data)),
out(in_out),
prefix("") {}
};

1
src/rustc/middle/trans/shape.rs
View File

@ -83,7 +83,6 @@ const shape_enum: u8 = 12u8;
const shape_struct: u8 = 17u8;
const shape_box_fn: u8 = 18u8;
const shape_res: u8 = 20u8;
const shape_var: u8 = 21u8;
const shape_uniq: u8 = 22u8;
const shape_opaque_closure_ptr: u8 = 23u8; // the closure itself.
const shape_uniq_fn: u8 = 25u8;