void calc_type_size( struct type* type ) {
int offset = 0;
struct type_member* member = type->member;
while ( member ) {
if ( member->dim ) {
calc_dim_size( member->dim, member->type );
if ( member->dim->element_size ) {
int size = member->dim->size * member->dim->element_size;
type->size += size;
member->offset = offset;
offset += size;
}
}
else if ( ! member->type->primitive ) {
// Calculate the size of the type if it hasn't been already.
if ( ! member->type->size ) {
calc_type_size( member->type );
}
if ( member->type->size ) {
type->size += member->type->size;
member->offset = offset;
offset += member->type->size;
}
}
else {
member->size = member->type->size;
member->offset = offset;
offset += member->type->size;
type->size += member->size;
}
member = member->next;
}
}
void calc_dim_size( struct dim* dim, struct type* type ) {
if ( dim->next ) {
calc_dim_size( dim->next, type );
dim->element_size = dim->next->size * dim->next->element_size;
}
else {
// Calculate the size of the element type.
if ( ! type->size ) {
calc_type_size( type );
}
dim->element_size = type->size;
}
}
int main() {
int bits;
signed long long int slli = 1;
signed long int sli = 1;
signed short int ssi = 1;
signed char sc = 1;
unsigned long long int ulli = 1;
unsigned long int uli = 1;
unsigned short int usi = 1;
unsigned char uc = 1;
calc_type_size(sc);
calc_assert(bits, sc);
printf(" signed char: %3d bits\n", bits);
calc_type_size(ssi);
calc_assert(bits, ssi);
printf(" signed short int: %3d bits\n", bits);
calc_type_size(sli);
calc_assert(bits, sli);
printf(" signed long int: %3d bits\n", bits);
calc_type_size(slli);
calc_assert(bits, slli);
printf(" signed long long: %3d bits\n", bits);
calc_type_size(uc);
calc_assert(bits, uc);
printf(" unsigned char: %3d bits\n", bits);
calc_type_size(usi);
calc_assert(bits, usi);
printf("unsigned short int: %3d bits\n", bits);
calc_type_size(uli);
calc_assert(bits, uli);
printf(" unsigned long int: %3d bits\n", bits);
calc_type_size(ulli);
calc_assert(bits, ulli);
printf("unsigned long long: %3d bits\n", bits);
return 0;
}
// Allocate a new vector type to memory.
vaddr_t TypeStore::alloc_vector(VMemory::Accessor& memory, vaddr_t element, unsigned int num) {
picojson::object js_type;
std::pair<size_t, unsigned int> type_size = calc_type_size(memory, element);
js_type.insert(std::make_pair("program_type", Convert::int2json<uint8_t>(ProgramType::TYPE)));
js_type.insert(std::make_pair("kind", Convert::int2json<uint8_t>(TypeKind::VECTOR)));
js_type.insert(std::make_pair("size", Convert::int2json<unsigned int>(type_size.first * num)));
js_type.insert(std::make_pair("alignment", Convert::int2json<unsigned int>(type_size.second)));
js_type.insert(std::make_pair("element", Convert::vaddr2json(element)));
js_type.insert(std::make_pair("num", Convert::int2json<unsigned int>(num)));
vaddr_t addr = memory.reserve_program_area();
memory.set_program_area(addr, picojson::value(js_type).serialize());
return addr;
}
void s_calc_var_size( struct var* var ) {
// Calculate the size of the variable elements.
if ( var->dim ) {
calc_dim_size( var->dim, var->type );
}
else {
// Only calculate the size of the type if it hasn't been already.
if ( ! var->type->size ) {
calc_type_size( var->type );
}
}
// Calculate the size of the variable.
if ( var->dim ) {
var->size = var->dim->size * var->dim->element_size;
}
else {
var->size = var->type->size;
}
}
