classfile* read_classfile(FILE* f){
classfile* c = malloc(sizeof(classfile));
memcheck(c);
c->magic = read32(f);
c->minor_version = read16(f);
c->major_version = read16(f);
c->constant_pool_count = read16(f);
c->constant_pool = malloc(sizeof(void*) * (c->constant_pool_count - 1));
for(int i = 0; i < (c->constant_pool_count - 1); i++){
c->constant_pool[i] = read_constant(i, f);
// print_constant(c->constant_pool[i], stderr);
}
c->access_flags = read16(f);
c->this_class = read16(f);
c->super_class = read16(f);
c->interfaces_count = read16(f);
if(c->interfaces_count > 0){
c->interfaces = malloc(sizeof(short) * c->interfaces_count);
memcheck(c->interfaces);
for(int i = 0; i < (c->interfaces_count); i++){
c->interfaces[i] = read16(f);
}
}
c->fields_count = read16(f);
if(c->fields_count > 0){
c->fields = malloc(sizeof(void*) * c->fields_count);
memcheck(c->fields);
//have to read in the fields
for(int i = 0; i < (c->fields_count); i++){
c->fields[i] = read_field(f);
}
} else
c->fields = NULL;
c->methods_count = read16(f);
if(c->methods_count > 0){
c->methods = malloc(sizeof(void*) * c->methods_count);
memcheck(c->methods);
for(int i = 0; i < (c->methods_count); i++){
c->methods[i] = read_method(c, f);
}
} else
c->methods = NULL;
c->attributes_count = read16(f);
if(c->attributes_count > 0){
c->attributes = malloc(sizeof(void*) * c->attributes_count);
memcheck(c->attributes);
for(int i = 0; i < c->attributes_count; i++){
c->attributes[i] = read_attribute(f);
}
} else
c->attributes = NULL;
int last = getc(f);
assert(last == EOF);
return c;
}
static nir_constant *
read_constant(read_ctx *ctx, nir_variable *nvar)
{
nir_constant *c = ralloc(nvar, nir_constant);
blob_copy_bytes(ctx->blob, (uint8_t *)c->values, sizeof(c->values));
c->num_elements = blob_read_uint32(ctx->blob);
c->elements = ralloc_array(nvar, nir_constant *, c->num_elements);
for (unsigned i = 0; i < c->num_elements; i++)
c->elements[i] = read_constant(ctx, nvar);
return c;
}
std::vector<Constant> read_constant_block(std::ifstream & stream) {
uint16_t count = parse<uint16_t>(extract<2>(stream));
bool skip = false;
std::vector<Constant> constants = {Constant()}; // Initialize with an empty constant, since Java starts counting at 1.
for (uint16_t id = 1; id < count; ++id) {
if (skip) {
constants.push_back(Constant());
skip = false;
continue;
}
std::pair<Constant, bool> result = read_constant(stream);
constants.push_back(result.first);
skip = result.second;
}
return constants;
}
static nir_variable *
read_variable(read_ctx *ctx)
{
nir_variable *var = rzalloc(ctx->nir, nir_variable);
read_add_object(ctx, var);
var->type = decode_type_from_blob(ctx->blob);
bool has_name = blob_read_uint32(ctx->blob);
if (has_name) {
const char *name = blob_read_string(ctx->blob);
var->name = ralloc_strdup(var, name);
} else {
var->name = NULL;
}
blob_copy_bytes(ctx->blob, (uint8_t *) &var->data, sizeof(var->data));
var->num_state_slots = blob_read_uint32(ctx->blob);
var->state_slots = ralloc_array(var, nir_state_slot, var->num_state_slots);
blob_copy_bytes(ctx->blob, (uint8_t *) var->state_slots,
var->num_state_slots * sizeof(nir_state_slot));
bool has_const_initializer = blob_read_uint32(ctx->blob);
if (has_const_initializer)
var->constant_initializer = read_constant(ctx, var);
else
var->constant_initializer = NULL;
bool has_interface_type = blob_read_uint32(ctx->blob);
if (has_interface_type)
var->interface_type = decode_type_from_blob(ctx->blob);
else
var->interface_type = NULL;
var->num_members = blob_read_uint32(ctx->blob);
if (var->num_members > 0) {
var->members = ralloc_array(var, struct nir_variable_data,
var->num_members);
blob_copy_bytes(ctx->blob, (uint8_t *) var->members,
var->num_members * sizeof(*var->members));
}
