static LLVMValueRef gen_digestof_box(compile_t* c, reach_type_t* type,
LLVMValueRef value, int boxed_subtype)
{
pony_assert(LLVMGetTypeKind(LLVMTypeOf(value)) == LLVMPointerTypeKind);
LLVMBasicBlockRef box_block = NULL;
LLVMBasicBlockRef nonbox_block = NULL;
LLVMBasicBlockRef post_block = NULL;
LLVMValueRef desc = gendesc_fetch(c, value);
if((boxed_subtype & SUBTYPE_KIND_UNBOXED) != 0)
{
box_block = codegen_block(c, "digestof_box");
nonbox_block = codegen_block(c, "digestof_nonbox");
post_block = codegen_block(c, "digestof_post");
// Check if it's a boxed value.
LLVMValueRef type_id = gendesc_typeid(c, desc);
LLVMValueRef boxed_mask = LLVMConstInt(c->i32, 1, false);
LLVMValueRef is_boxed = LLVMBuildAnd(c->builder, type_id, boxed_mask, "");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
is_boxed = LLVMBuildICmp(c->builder, LLVMIntEQ, is_boxed, zero, "");
LLVMBuildCondBr(c->builder, is_boxed, box_block, nonbox_block);
LLVMPositionBuilderAtEnd(c->builder, box_block);
}
// Call the type-specific __digestof function, which will unbox the value.
reach_method_t* digest_fn = reach_method(type, TK_BOX,
stringtab("__digestof"), NULL);
pony_assert(digest_fn != NULL);
LLVMValueRef func = gendesc_vtable(c, desc, digest_fn->vtable_index);
LLVMTypeRef fn_type = LLVMFunctionType(c->intptr, &c->object_ptr, 1, false);
func = LLVMBuildBitCast(c->builder, func, LLVMPointerType(fn_type, 0), "");
LLVMValueRef box_digest = codegen_call(c, func, &value, 1, true);
if((boxed_subtype & SUBTYPE_KIND_UNBOXED) != 0)
{
LLVMBuildBr(c->builder, post_block);
// Just cast the address.
LLVMPositionBuilderAtEnd(c->builder, nonbox_block);
LLVMValueRef nonbox_digest = LLVMBuildPtrToInt(c->builder, value, c->intptr,
"");
LLVMBuildBr(c->builder, post_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->intptr, "");
LLVMAddIncoming(phi, &box_digest, &box_block, 1);
LLVMAddIncoming(phi, &nonbox_digest, &nonbox_block, 1);
return phi;
} else {
return box_digest;
}
}
LLVMValueRef gendesc_istrait(compile_t* c, LLVMValueRef desc, ast_t* type)
{
// Get the trait identifier.
LLVMValueRef trait_id = gendesc_typeid(c, type);
// Read the count and the trait list from the descriptor.
LLVMValueRef count = desc_field(c, desc, DESC_TRAIT_COUNT);
LLVMValueRef list = desc_field(c, desc, DESC_TRAITS);
LLVMBasicBlockRef entry_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef cond_block = codegen_block(c, "cond");
LLVMBasicBlockRef body_block = codegen_block(c, "body");
LLVMBasicBlockRef post_block = codegen_block(c, "post");
LLVMBuildBr(c->builder, cond_block);
// While the index is less than the count, check an ID.
LLVMPositionBuilderAtEnd(c->builder, cond_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->i32, "");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
LLVMAddIncoming(phi, &zero, &entry_block, 1);
LLVMValueRef test = LLVMBuildICmp(c->builder, LLVMIntULT, phi, count, "");
LLVMBuildCondBr(c->builder, test, body_block, post_block);
// The phi node is the index. Get ID and compare it.
LLVMPositionBuilderAtEnd(c->builder, body_block);
LLVMValueRef gep[2];
gep[0] = LLVMConstInt(c->i32, 0, false);
gep[1] = phi;
LLVMValueRef id_ptr = LLVMBuildGEP(c->builder, list, gep, 2, "");
LLVMValueRef id = LLVMBuildLoad(c->builder, id_ptr, "");
LLVMValueRef test_id = LLVMBuildICmp(c->builder, LLVMIntEQ, id, trait_id,
"");
// Add one to the phi node.
LLVMValueRef one = LLVMConstInt(c->i32, 1, false);
LLVMValueRef inc = LLVMBuildAdd(c->builder, phi, one, "");
LLVMAddIncoming(phi, &inc, &body_block, 1);
// Either to the post block or back to the condition.
LLVMBuildCondBr(c->builder, test_id, post_block, cond_block);
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMValueRef result = LLVMBuildPhi(c->builder, c->i1, "");
LLVMAddIncoming(result, &test, &cond_block, 1);
LLVMAddIncoming(result, &test_id, &body_block, 1);
return result;
}
static LLVMValueRef box_is_box(compile_t* c, ast_t* left_type,
LLVMValueRef l_value, LLVMValueRef r_value, int possible_boxes)
{
pony_assert(LLVMGetTypeKind(LLVMTypeOf(l_value)) == LLVMPointerTypeKind);
pony_assert(LLVMGetTypeKind(LLVMTypeOf(r_value)) == LLVMPointerTypeKind);
LLVMBasicBlockRef this_block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef checkbox_block = codegen_block(c, "is_checkbox");
LLVMBasicBlockRef box_block = codegen_block(c, "is_box");
LLVMBasicBlockRef num_block = NULL;
if((possible_boxes & BOXED_SUBTYPES_NUMERIC) != 0)
num_block = codegen_block(c, "is_num");
LLVMBasicBlockRef tuple_block = NULL;
if((possible_boxes & BOXED_SUBTYPES_TUPLE) != 0)
tuple_block = codegen_block(c, "is_tuple");
LLVMBasicBlockRef post_block = codegen_block(c, "is_post");
LLVMValueRef eq_addr = LLVMBuildICmp(c->builder, LLVMIntEQ, l_value, r_value,
"");
LLVMBuildCondBr(c->builder, eq_addr, post_block, checkbox_block);
// Check whether we have two boxed objects of the same type.
LLVMPositionBuilderAtEnd(c->builder, checkbox_block);
LLVMValueRef l_desc = gendesc_fetch(c, l_value);
LLVMValueRef r_desc = gendesc_fetch(c, r_value);
LLVMValueRef same_type = LLVMBuildICmp(c->builder, LLVMIntEQ, l_desc, r_desc,
"");
LLVMValueRef l_typeid = NULL;
if((possible_boxes & BOXED_SUBTYPES_UNBOXED) != 0)
{
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef boxed_mask = LLVMConstInt(c->i32, 1, false);
LLVMValueRef left_boxed = LLVMBuildAnd(c->builder, l_typeid, boxed_mask,
"");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
left_boxed = LLVMBuildICmp(c->builder, LLVMIntEQ, left_boxed, zero, "");
LLVMValueRef both_boxed = LLVMBuildAnd(c->builder, same_type, left_boxed,
"");
LLVMBuildCondBr(c->builder, both_boxed, box_block, post_block);
} else {
LLVMBuildCondBr(c->builder, same_type, box_block, post_block);
}
// Check whether it's a numeric primitive or a tuple.
LLVMPositionBuilderAtEnd(c->builder, box_block);
if((possible_boxes & BOXED_SUBTYPES_BOXED) == BOXED_SUBTYPES_BOXED)
{
if(l_typeid == NULL)
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef num_mask = LLVMConstInt(c->i32, 2, false);
LLVMValueRef boxed_num = LLVMBuildAnd(c->builder, l_typeid, num_mask, "");
LLVMValueRef zero = LLVMConstInt(c->i32, 0, false);
boxed_num = LLVMBuildICmp(c->builder, LLVMIntEQ, boxed_num, zero, "");
LLVMBuildCondBr(c->builder, boxed_num, num_block, tuple_block);
} else if((possible_boxes & BOXED_SUBTYPES_NUMERIC) != 0) {
LLVMBuildBr(c->builder, num_block);
} else {
pony_assert((possible_boxes & BOXED_SUBTYPES_TUPLE) != 0);
LLVMBuildBr(c->builder, tuple_block);
}
LLVMValueRef args[3];
LLVMValueRef is_num = NULL;
if(num_block != NULL)
{
// Get the machine word size and memcmp without unboxing.
LLVMPositionBuilderAtEnd(c->builder, num_block);
if(l_typeid == NULL)
l_typeid = gendesc_typeid(c, l_value);
LLVMValueRef num_sizes = LLVMBuildBitCast(c->builder, c->numeric_sizes,
c->void_ptr, "");
args[0] = LLVMBuildZExt(c->builder, l_typeid, c->intptr, "");
LLVMValueRef size = LLVMBuildInBoundsGEP(c->builder, num_sizes, args, 1,
"");
size = LLVMBuildBitCast(c->builder, size, LLVMPointerType(c->i32, 0), "");
size = LLVMBuildLoad(c->builder, size, "");
LLVMSetAlignment(size, 4);
LLVMValueRef one = LLVMConstInt(c->i32, 1, false);
args[0] = LLVMBuildInBoundsGEP(c->builder, l_value, &one, 1, "");
args[0] = LLVMBuildBitCast(c->builder, args[0], c->void_ptr, "");
args[1] = LLVMBuildInBoundsGEP(c->builder, r_value, &one, 1, "");
args[1] = LLVMBuildBitCast(c->builder, args[1], c->void_ptr, "");
args[2] = LLVMBuildZExt(c->builder, size, c->intptr, "");
is_num = gencall_runtime(c, "memcmp", args, 3, "");
is_num = LLVMBuildICmp(c->builder, LLVMIntEQ, is_num,
LLVMConstInt(c->i32, 0, false), "");
LLVMBuildBr(c->builder, post_block);
}
LLVMValueRef is_tuple = NULL;
if(tuple_block != NULL)
{
// Call the type-specific __is function, which will unbox the tuples.
LLVMPositionBuilderAtEnd(c->builder, tuple_block);
reach_type_t* r_left = reach_type(c->reach, left_type);
reach_method_t* is_fn = reach_method(r_left, TK_BOX, stringtab("__is"),
NULL);
pony_assert(is_fn != NULL);
LLVMValueRef func = gendesc_vtable(c, l_value, is_fn->vtable_index);
LLVMTypeRef params[2];
params[0] = c->object_ptr;
params[1] = c->object_ptr;
LLVMTypeRef type = LLVMFunctionType(c->i1, params, 2, false);
func = LLVMBuildBitCast(c->builder, func, LLVMPointerType(type, 0), "");
args[0] = l_value;
args[1] = r_value;
is_tuple = codegen_call(c, func, args, 2);
LLVMBuildBr(c->builder, post_block);
}
LLVMPositionBuilderAtEnd(c->builder, post_block);
LLVMValueRef phi = LLVMBuildPhi(c->builder, c->i1, "");
LLVMValueRef one = LLVMConstInt(c->i1, 1, false);
LLVMValueRef zero = LLVMConstInt(c->i1, 0, false);
LLVMAddIncoming(phi, &one, &this_block, 1);
if(is_num != NULL)
LLVMAddIncoming(phi, &is_num, &num_block, 1);
if(is_tuple != NULL)
LLVMAddIncoming(phi, &is_tuple, &tuple_block, 1);
LLVMAddIncoming(phi, &zero, &checkbox_block, 1);
return phi;
}
