static void
readin_conf_stat(struct rk_conference *c)
{
struct rk_aux_item *rai;
int i, len;
c->rc_name = get_string();
c->rc_type = get_bitfield();
read_in_time(&c->rc_creation_time);
read_in_time(&c->rc_last_written);
c->rc_creator = get_int();
c->rc_presentation = get_int();
c->rc_supervisor = get_int();
c->rc_permitted_submitters = get_int();
c->rc_super_conf = get_int();
c->rc_msg_of_day = get_int();
c->rc_nice = get_int();
c->rc_keep_commented = get_int();
c->rc_no_of_members = get_int();
c->rc_first_local_no = get_int();
c->rc_no_of_texts = get_int();
c->rc_expire = get_int();
c->rc_aux_item.rc_aux_item_len = len = get_int();
if (len) {
rai = calloc(sizeof(struct rk_aux_item), len);
c->rc_aux_item.rc_aux_item_val = rai;
get_accept('{');
for (i = 0; i < len; i++)
read_in_aux_item(&rai[i]);
get_accept('}');
} else
get_accept('*');
get_accept('\n');
}
void cheney()
{
free_ptr = tospace_begin;
{
// Step 1: Copy roots.
int64_t** work_ptr = (int64_t**)rootstack_begin;
while ((void*)work_ptr != (void*)rootstack_ptr)
{
if (in_fromspace((void*)(*work_ptr)))
copy_vector(work_ptr);
work_ptr++;
}
}
{
// Step 2: Scan copied roots.
int64_t* work_ptr = (int64_t*)tospace_begin;
while ((void*)work_ptr != (void*)free_ptr)
{
int64_t info = *work_ptr;
int fields = get_length(info);
int64_t bitfield = get_bitfield(info);
for (int i = 0; i < fields; ++i)
{
if ((bitfield & (1 << i)) != 0)
{
// found a pointer
int64_t** ptr = (int64_t**)(work_ptr + 1 + i);
if (in_fromspace((void*)(*ptr)))
copy_vector(ptr);
}
}
work_ptr += 1 + fields;
}
}
// Step 3: Swap to/from spaces
void* tmp = tospace_begin;
tospace_begin = fromspace_begin;
fromspace_begin = tmp;
tmp = tospace_end;
tospace_end = fromspace_end;
fromspace_end = tmp;
#ifndef NDEBUG
memset((void*)tospace_begin, 0, (size_t)(tospace_end - tospace_begin));
#endif
}
uint64_t eq_dynamic(uint64_t* ptr1, uint64_t* ptr2)
{
uint64_t ptr1_tag = *ptr1;
uint64_t ptr2_tag = *ptr2;
if (ptr1_tag != ptr2_tag)
return 0;
int ptr1_len = get_length(ptr1_tag);
int ptr2_len = get_length(ptr2_tag);
if (ptr1_len != ptr2_len)
return 0;
int64_t ptr1_bitfield = get_bitfield(ptr1_tag);
int64_t ptr2_bitfield = get_bitfield(ptr2_tag);
if (ptr1_bitfield != ptr2_bitfield)
return 0;
for (int i = 0; i < ptr1_len; i++)
{
if ((ptr1_bitfield & (1 << i)) != 0)
{
uint64_t* ptr1_field = *(uint64_t**)(ptr1 + 1 + i);
uint64_t* ptr2_field = *(uint64_t**)(ptr2 + 1 + i);
if (eq_dynamic(ptr1_field, ptr2_field) != 1)
return 0;
}
else
{
if (*(ptr1 + 1 + i) != *(ptr2 + 1 + i))
return 0;
}
}
return 1;
}
void print_vector(int64_t* vector)
{
int64_t info = *vector;
if (is_forwarding(info))
{
printf("<vector: forwarding to: %p>\n", (void*)info);
if (in_tospace((void*)info))
printf("(%p is in tospace)\n", (void*)info);
else if (in_fromspace((void*)info))
printf("(%p is in fromspace)\n", (void*)info);
else
printf("(%p is not in fromspace or tospace)\n", (void*)info);
if (info)
{
printf("%p: ", (void*)info);
print_vector((int64_t*)info);
}
}
else
{
int fields = get_length(info);
int64_t bitfield = get_bitfield(info);
printf("<vector (%p, ", (void*) vector);
if (in_tospace((void*)vector))
printf("in tospace):");
else if (in_fromspace((void*)vector))
printf("in fromspace):");
else
printf("\?\?\?):");
for (int i = 0; i < fields; i++)
{
if ((bitfield & (1 << i)) != 0)
printf(" ptr(%p, %s)",
(void*)(*(vector + 1 + i)),
in_fromspace((void*)(*(vector + 1 + i))) ? "in fromspace" : "in tospace");
else
printf(" %" PRIi64, *(vector + 1 + i));
}
printf(">\n");
}
}
static u16 get_ddr3_mem_reg_col(u16 reg)
{
return get_bitfield(reg, 3, 0);
}
static u16 get_ddr3_mem_reg_c1m(u16 reg)
{
return get_bitfield(reg, 1, 13);
}
static u16 get_ddr3_mem_reg_size(u16 reg)
{
return get_bitfield(reg, 4, 8);
}
static u16 get_ddr3_mem_reg_row(u16 reg)
{
return get_bitfield(reg, 3, 5);
}
float bitfield_parse_float(const uint8_t source[], const uint16_t source_length,
const uint8_t bit_offset, const uint8_t bit_size, const float factor,
const float offset) {
return decode_float(get_bitfield(source, source_length, bit_offset, bit_size),
factor, offset);
}
