static bool is_assigned_to(ast_t* ast, bool check_result_needed)
{
while(true)
{
ast_t* parent = ast_parent(ast);
switch(ast_id(parent))
{
case TK_ASSIGN:
{
// Has to be the left hand side of an assignment. Left and right sides
// are swapped, so we must be the second child.
if(ast_childidx(parent, 1) != ast)
return false;
if(!check_result_needed)
return true;
// The result of that assignment can't be used.
return !is_result_needed(parent);
}
case TK_SEQ:
{
// Might be in a tuple on the left hand side.
if(ast_childcount(parent) > 1)
return false;
break;
}
case TK_TUPLE:
break;
default:
return false;
}
ast = parent;
}
}
static bool case_body(compile_t* c, ast_t* body,
LLVMBasicBlockRef post_block, LLVMValueRef phi, LLVMTypeRef phi_type)
{
LLVMValueRef body_value = gen_expr(c, body);
// If it returns, we don't branch to the post block.
if(body_value == GEN_NOVALUE)
return true;
if(is_result_needed(body))
{
ast_t* body_type = ast_type(body);
body_value = gen_assign_cast(c, phi_type, body_value, body_type);
if(body_value == NULL)
return false;
LLVMBasicBlockRef block = LLVMGetInsertBlock(c->builder);
LLVMAddIncoming(phi, &body_value, &block, 1);
}
LLVMBuildBr(c->builder, post_block);
return true;
}
static void reachable_expr(reach_t* r, ast_t* ast, pass_opt_t* opt)
{
// If this is a method call, mark the method as reachable.
switch(ast_id(ast))
{
case TK_TRUE:
case TK_FALSE:
case TK_INT:
case TK_FLOAT:
case TK_STRING:
{
ast_t* type = ast_type(ast);
if(type != NULL)
reachable_method(r, type, stringtab("create"), NULL, opt);
break;
}
case TK_LET:
case TK_VAR:
case TK_TUPLE:
{
ast_t* type = ast_type(ast);
add_type(r, type, opt);
break;
}
case TK_CASE:
{
AST_GET_CHILDREN(ast, pattern, guard, body);
reachable_pattern(r, pattern, opt);
reachable_expr(r, guard, opt);
reachable_expr(r, body, opt);
break;
}
case TK_CALL:
reachable_call(r, ast, opt);
break;
case TK_FFICALL:
reachable_ffi(r, ast, opt);
break;
case TK_ADDRESS:
reachable_addressof(r, ast, opt);
break;
case TK_IF:
{
AST_GET_CHILDREN(ast, cond, then_clause, else_clause);
assert(ast_id(cond) == TK_SEQ);
cond = ast_child(cond);
ast_t* type = ast_type(ast);
if(is_result_needed(ast) && !is_control_type(type))
add_type(r, type, opt);
if(ast_sibling(cond) == NULL)
{
if(ast_id(cond) == TK_TRUE)
{
reachable_expr(r, then_clause, opt);
return;
} else if(ast_id(cond) == TK_FALSE) {
reachable_expr(r, else_clause, opt);
return;
}
}
break;
}
case TK_MATCH:
case TK_WHILE:
case TK_REPEAT:
case TK_TRY:
{
ast_t* type = ast_type(ast);
if(is_result_needed(ast) && !is_control_type(type))
add_type(r, type, opt);
break;
}
default: {}
}
// Traverse all child expressions looking for calls.
ast_t* child = ast_child(ast);
while(child != NULL)
{
reachable_expr(r, child, opt);
child = ast_sibling(child);
}
}
LLVMValueRef gen_match(compile_t* c, ast_t* ast)
{
bool needed = is_result_needed(ast);
ast_t* type = ast_type(ast);
AST_GET_CHILDREN(ast, match_expr, cases, else_expr);
// We will have no type if all case have control types.
LLVMTypeRef phi_type = NULL;
if(needed && !is_control_type(type))
{
reach_type_t* t_phi = reach_type(c->reach, type);
phi_type = t_phi->use_type;
}
ast_t* match_type = alias(ast_type(match_expr));
LLVMValueRef match_value = gen_expr(c, match_expr);
LLVMBasicBlockRef pattern_block = codegen_block(c, "case_pattern");
LLVMBasicBlockRef else_block = codegen_block(c, "match_else");
LLVMBasicBlockRef post_block = NULL;
LLVMBasicBlockRef next_block = NULL;
// Jump to the first case.
LLVMBuildBr(c->builder, pattern_block);
LLVMValueRef phi = GEN_NOVALUE;
if(!is_control_type(type))
{
// Start the post block so that a case can modify the phi node.
post_block = codegen_block(c, "match_post");
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
phi = LLVMBuildPhi(c->builder, phi_type, "");
else
phi = GEN_NOTNEEDED;
}
// Iterate over the cases.
ast_t* the_case = ast_child(cases);
while(the_case != NULL)
{
ast_t* next_case = ast_sibling(the_case);
if(next_case != NULL)
next_block = codegen_block(c, "case_pattern");
else
next_block = else_block;
AST_GET_CHILDREN(the_case, pattern, guard, body);
LLVMPositionBuilderAtEnd(c->builder, pattern_block);
codegen_pushscope(c, the_case);
ast_t* pattern_type = ast_type(pattern);
bool ok = true;
if(is_matchtype(match_type, pattern_type, c->opt) != MATCHTYPE_ACCEPT)
{
// If there's no possible match, jump directly to the next block.
LLVMBuildBr(c->builder, next_block);
} else {
// Check the pattern.
ok = static_match(c, match_value, match_type, pattern, next_block);
// Check the guard.
ok = ok && guard_match(c, guard, next_block);
// Case body.
ok = ok && case_body(c, body, post_block, phi, phi_type);
}
codegen_popscope(c);
if(!ok)
{
ast_free_unattached(match_type);
return NULL;
}
the_case = next_case;
pattern_block = next_block;
}
ast_free_unattached(match_type);
// Else body.
LLVMPositionBuilderAtEnd(c->builder, else_block);
codegen_pushscope(c, else_expr);
bool ok = case_body(c, else_expr, post_block, phi, phi_type);
codegen_popscope(c);
if(!ok)
return NULL;
if(post_block != NULL)
LLVMPositionBuilderAtEnd(c->builder, post_block);
return phi;
}
bool expr_assign(pass_opt_t* opt, ast_t* ast)
{
// Left and right are swapped in the AST to make sure we type check the
// right side before the left. Fetch them in the opposite order.
assert(ast != NULL);
AST_GET_CHILDREN(ast, right, left);
ast_t* l_type = ast_type(left);
if(!is_lvalue(&opt->check, left, is_result_needed(ast)))
{
ast_error(ast, "left side must be something that can be assigned to");
return false;
}
assert(l_type != NULL);
if(!coerce_literals(&right, l_type, opt))
return false;
ast_t* r_type = ast_type(right);
if(is_typecheck_error(r_type))
return false;
if(!infer_locals(left, r_type))
return false;
// Inferring locals may have changed the left type.
l_type = ast_type(left);
// Assignment is based on the alias of the right hand side.
ast_t* a_type = alias(r_type);
if(!is_subtype(a_type, l_type))
{
ast_error(ast, "right side must be a subtype of left side");
ast_error(a_type, "right side type: %s", ast_print_type(a_type));
ast_error(l_type, "left side type: %s", ast_print_type(l_type));
ast_free_unattached(a_type);
return false;
}
if((ast_id(left) == TK_TUPLE) && (ast_id(a_type) != TK_TUPLETYPE))
{
switch(ast_id(a_type))
{
case TK_UNIONTYPE:
ast_error(ast,
"can't destructure a union using assignment, use pattern matching "
"instead");
break;
case TK_ISECTTYPE:
ast_error(ast,
"can't destructure an intersection using assignment, use pattern "
"matching instead");
break;
default:
assert(0);
break;
}
ast_error(a_type, "right side type: %s", ast_print_type(a_type));
ast_free_unattached(a_type);
return false;
}
bool ok_safe = safe_to_write(left, a_type);
if(!ok_safe)
{
if(ast_id(left) == TK_FVARREF && ast_child(left) != NULL &&
ast_id(ast_child(left)) == TK_THIS)
{
// We are writing to a field in this
ast_t* fn = ast_nearest(left, TK_FUN);
if(fn != NULL)
{
ast_t* iso = ast_child(fn);
assert(iso != NULL);
token_id iso_id = ast_id(iso);
if(iso_id == TK_BOX || iso_id == TK_VAL || iso_id == TK_TAG)
{
ast_error(ast, "cannot write to a field in a %s function",
lexer_print(iso_id));
ast_free_unattached(a_type);
return false;
}
}
}
ast_error(ast, "not safe to write right side to left side");
ast_error(a_type, "right side type: %s", ast_print_type(a_type));
ast_free_unattached(a_type);
return false;
}
ast_free_unattached(a_type);
// If it's an embedded field, check for a constructor result.
if(ast_id(left) == TK_EMBEDREF)
{
if((ast_id(right) != TK_CALL) ||
(ast_id(ast_childidx(right, 2)) != TK_NEWREF))
{
ast_error(ast, "an embedded field must be assigned using a constructor");
return false;
}
}
ast_settype(ast, consume_type(l_type, TK_NONE));
ast_inheritflags(ast);
return true;
}
bool expr_assign(pass_opt_t* opt, ast_t* ast)
{
// Left and right are swapped in the AST to make sure we type check the
// right side before the left. Fetch them in the opposite order.
assert(ast != NULL);
AST_GET_CHILDREN(ast, right, left);
ast_t* l_type = ast_type(left);
if(l_type == NULL || !is_lvalue(opt, left, is_result_needed(ast)))
{
ast_error(opt->check.errors, ast,
"left side must be something that can be assigned to");
return false;
}
if(!coerce_literals(&right, l_type, opt))
return false;
ast_t* r_type = ast_type(right);
if(is_typecheck_error(r_type))
return false;
if(is_control_type(r_type))
{
ast_error(opt->check.errors, ast,
"the right hand side does not return a value");
return false;
}
if(!infer_locals(opt, left, r_type))
return false;
// Inferring locals may have changed the left type.
l_type = ast_type(left);
// Assignment is based on the alias of the right hand side.
ast_t* a_type = alias(r_type);
errorframe_t info = NULL;
if(!is_subtype(a_type, l_type, &info, opt))
{
errorframe_t frame = NULL;
ast_error_frame(&frame, ast, "right side must be a subtype of left side");
errorframe_append(&frame, &info);
errorframe_report(&frame, opt->check.errors);
ast_free_unattached(a_type);
return false;
}
if((ast_id(left) == TK_TUPLE) && (ast_id(a_type) != TK_TUPLETYPE))
{
switch(ast_id(a_type))
{
case TK_UNIONTYPE:
ast_error(opt->check.errors, ast,
"can't destructure a union using assignment, use pattern matching "
"instead");
break;
case TK_ISECTTYPE:
ast_error(opt->check.errors, ast,
"can't destructure an intersection using assignment, use pattern "
"matching instead");
break;
default:
assert(0);
break;
}
ast_free_unattached(a_type);
return false;
}
bool ok_safe = safe_to_write(left, a_type);
if(!ok_safe)
{
if(ast_id(left) == TK_FVARREF && ast_child(left) != NULL &&
ast_id(ast_child(left)) == TK_THIS)
{
// We are writing to a field in this
ast_t* fn = ast_nearest(left, TK_FUN);
if(fn != NULL)
{
ast_t* iso = ast_child(fn);
assert(iso != NULL);
token_id iso_id = ast_id(iso);
if(iso_id == TK_BOX || iso_id == TK_VAL || iso_id == TK_TAG)
{
ast_error(opt->check.errors, ast,
"cannot write to a field in a %s function. If you are trying to "
"change state in a function use fun ref",
lexer_print(iso_id));
ast_free_unattached(a_type);
return false;
}
}
}
ast_error(opt->check.errors, ast,
"not safe to write right side to left side");
ast_error_continue(opt->check.errors, a_type, "right side type: %s",
ast_print_type(a_type));
ast_free_unattached(a_type);
return false;
}
ast_free_unattached(a_type);
if(!check_embed_construction(opt, left, right))
return false;
ast_settype(ast, consume_type(l_type, TK_NONE));
return true;
}
LLVMValueRef gen_try(compile_t* c, ast_t* ast)
{
bool needed = is_result_needed(ast);
AST_GET_CHILDREN(ast, body, else_clause, then_clause);
ast_t* type = ast_type(ast);
ast_t* body_type = ast_type(body);
ast_t* else_type = ast_type(else_clause);
reach_type_t* phi_type = NULL;
// We will have no type if both branches have return statements.
if(!is_control_type(type))
phi_type = reach_type(c->reach, type);
LLVMBasicBlockRef block = LLVMGetInsertBlock(c->builder);
LLVMBasicBlockRef else_block = codegen_block(c, "try_else");
LLVMBasicBlockRef post_block = NULL;
if(!is_control_type(type))
post_block = codegen_block(c, "try_post");
// Keep a reference to the else block.
codegen_pushtry(c, else_block);
// Body block.
LLVMPositionBuilderAtEnd(c->builder, block);
LLVMValueRef body_value = gen_expr(c, body);
if(body_value != GEN_NOVALUE)
{
if(needed)
{
body_value = gen_assign_cast(c, phi_type->use_type, body_value,
body_type);
}
if(body_value == NULL)
return NULL;
gen_expr(c, then_clause);
block = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
// Pop the try before generating the else block.
codegen_poptry(c);
// Else block.
LLVMPositionBuilderAtEnd(c->builder, else_block);
// The landing pad is marked as a cleanup, since exceptions are typeless and
// valueless. The first landing pad is always the destination.
LLVMTypeRef lp_elements[2];
lp_elements[0] = c->void_ptr;
lp_elements[1] = c->i32;
LLVMTypeRef lp_type = LLVMStructTypeInContext(c->context, lp_elements, 2,
false);
#if PONY_LLVM == 307 && LLVM_VERSION_PATCH == 0
// This backwards-incompatible API change to LLVMBuildLandingPad is only in
// LLVM 3.7.0. In 3.7.1 and all later versions, backward-compatibility was
// restored.
assert((c->frame->fun != NULL) && "No function in current frame!");
LLVMSetPersonalityFn(c->frame->fun, c->personality);
LLVMValueRef landing = LLVMBuildLandingPad(c->builder, lp_type, 1, "");
#else
LLVMValueRef landing = LLVMBuildLandingPad(c->builder, lp_type,
c->personality, 1, "");
#endif
LLVMAddClause(landing, LLVMConstNull(c->void_ptr));
LLVMValueRef else_value = gen_expr(c, else_clause);
if(else_value != GEN_NOVALUE)
{
if(needed)
{
else_value = gen_assign_cast(c, phi_type->use_type, else_value,
else_type);
}
if(else_value == NULL)
return NULL;
gen_expr(c, then_clause);
else_block = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
// If both sides return, we return a sentinal value.
if(is_control_type(type))
return GEN_NOVALUE;
// Continue in the post block.
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
{
LLVMValueRef phi = LLVMBuildPhi(c->builder, phi_type->use_type, "");
if(body_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &body_value, &block, 1);
if(else_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &else_value, &else_block, 1);
return phi;
}
return GEN_NOTNEEDED;
}
LLVMValueRef gen_if(compile_t* c, ast_t* ast)
{
bool needed = is_result_needed(ast);
ast_t* type = ast_type(ast);
AST_GET_CHILDREN(ast, cond, left, right);
ast_t* left_type = ast_type(left);
ast_t* right_type = ast_type(right);
// We will have no type if both branches have return statements.
reach_type_t* phi_type = NULL;
if(!is_control_type(type))
phi_type = reach_type(c->reach, type);
LLVMValueRef c_value = gen_expr(c, cond);
if(c_value == NULL)
return NULL;
// If the conditional is constant, generate only one branch.
bool gen_left = true;
bool gen_right = true;
if(LLVMIsAConstantInt(c_value))
{
int value = (int)LLVMConstIntGetZExtValue(c_value);
if(value == 0)
gen_left = false;
else
gen_right = false;
}
LLVMBasicBlockRef then_block = codegen_block(c, "if_then");
LLVMBasicBlockRef else_block = codegen_block(c, "if_else");
LLVMBasicBlockRef post_block = NULL;
// If both branches return, we have no post block.
if(!is_control_type(type))
post_block = codegen_block(c, "if_post");
LLVMValueRef test = LLVMBuildTrunc(c->builder, c_value, c->i1, "");
LLVMBuildCondBr(c->builder, test, then_block, else_block);
// Left branch.
LLVMPositionBuilderAtEnd(c->builder, then_block);
LLVMValueRef l_value;
if(gen_left)
{
l_value = gen_expr(c, left);
} else if(phi_type != NULL) {
l_value = LLVMConstNull(phi_type->use_type);
} else {
LLVMBuildUnreachable(c->builder);
l_value = GEN_NOVALUE;
}
if(l_value != GEN_NOVALUE)
{
if(needed)
l_value = gen_assign_cast(c, phi_type->use_type, l_value, left_type);
if(l_value == NULL)
return NULL;
then_block = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
// Right branch.
LLVMPositionBuilderAtEnd(c->builder, else_block);
LLVMValueRef r_value;
if(gen_right)
{
r_value = gen_expr(c, right);
} else if(phi_type != NULL) {
r_value = LLVMConstNull(phi_type->use_type);
} else {
LLVMBuildUnreachable(c->builder);
r_value = GEN_NOVALUE;
}
// If the right side returns, we don't branch to the post block.
if(r_value != GEN_NOVALUE)
{
if(needed)
r_value = gen_assign_cast(c, phi_type->use_type, r_value, right_type);
if(r_value == NULL)
return NULL;
else_block = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
// If both sides return, we return a sentinal value.
if(is_control_type(type))
return GEN_NOVALUE;
// Continue in the post block.
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
{
LLVMValueRef phi = LLVMBuildPhi(c->builder, phi_type->use_type, "");
if(l_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &l_value, &then_block, 1);
if(r_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &r_value, &else_block, 1);
return phi;
}
return GEN_NOTNEEDED;
}
LLVMValueRef gen_repeat(compile_t* c, ast_t* ast)
{
bool needed = is_result_needed(ast);
AST_GET_CHILDREN(ast, body, cond, else_clause);
ast_t* type = ast_type(ast);
ast_t* body_type = ast_type(body);
ast_t* else_type = ast_type(else_clause);
reach_type_t* phi_type = NULL;
if(needed && !is_control_type(type))
phi_type = reach_type(c->reach, type);
LLVMBasicBlockRef body_block = codegen_block(c, "repeat_body");
LLVMBasicBlockRef cond_block = codegen_block(c, "repeat_cond");
LLVMBasicBlockRef else_block = codegen_block(c, "repeat_else");
LLVMBasicBlockRef post_block = NULL;
LLVMBuildBr(c->builder, body_block);
// start the post block so that a break can modify the phi node
LLVMValueRef phi = GEN_NOTNEEDED;
if(!is_control_type(type))
{
// Start the post block so that a break can modify the phi node.
post_block = codegen_block(c, "repeat_post");
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
phi = LLVMBuildPhi(c->builder, phi_type->use_type, "");
}
// Push the loop status.
codegen_pushloop(c, cond_block, post_block, else_block);
// Body.
LLVMPositionBuilderAtEnd(c->builder, body_block);
LLVMValueRef value = gen_expr(c, body);
if(needed)
value = gen_assign_cast(c, phi_type->use_type, value, body_type);
if(value == NULL)
return NULL;
LLVMBasicBlockRef body_from = NULL;
// If the body can't result in a value, don't generate the conditional
// evaluation. This basic block for the body already has a terminator.
if(value != GEN_NOVALUE)
{
// The body evaluates the condition itself, jumping either back to the body
// or directly to the post block.
LLVMValueRef c_value = gen_expr(c, cond);
if(c_value == NULL)
return NULL;
body_from = LLVMGetInsertBlock(c->builder);
LLVMValueRef test = LLVMBuildTrunc(c->builder, c_value, c->i1, "");
LLVMBuildCondBr(c->builder, test, post_block, body_block);
}
// cond block
// This is only evaluated from a continue, jumping either back to the body
// or to the else block.
LLVMPositionBuilderAtEnd(c->builder, cond_block);
LLVMValueRef i_value = gen_expr(c, cond);
LLVMValueRef test = LLVMBuildTrunc(c->builder, i_value, c->i1, "");
LLVMBuildCondBr(c->builder, test, else_block, body_block);
// Don't need loop status for the else block.
codegen_poploop(c);
// else
// Only happens for a continue in the last iteration.
LLVMPositionBuilderAtEnd(c->builder, else_block);
LLVMValueRef else_value = gen_expr(c, else_clause);
LLVMBasicBlockRef else_from = NULL;
if(else_value == NULL)
return NULL;
if(needed)
else_value = gen_assign_cast(c, phi_type->use_type, else_value, else_type);
if(else_value != GEN_NOVALUE)
{
else_from = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
if(is_control_type(type))
return GEN_NOVALUE;
// post
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
{
if(value != GEN_NOVALUE)
LLVMAddIncoming(phi, &value, &body_from, 1);
if(else_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &else_value, &else_from, 1);
return phi;
}
return GEN_NOTNEEDED;
}
LLVMValueRef gen_while(compile_t* c, ast_t* ast)
{
bool needed = is_result_needed(ast);
AST_GET_CHILDREN(ast, cond, body, else_clause);
ast_t* type = ast_type(ast);
ast_t* body_type = ast_type(body);
ast_t* else_type = ast_type(else_clause);
reach_type_t* phi_type = NULL;
if(needed && !is_control_type(type))
phi_type = reach_type(c->reach, type);
LLVMBasicBlockRef init_block = codegen_block(c, "while_init");
LLVMBasicBlockRef body_block = codegen_block(c, "while_body");
LLVMBasicBlockRef else_block = codegen_block(c, "while_else");
LLVMBasicBlockRef post_block = NULL;
LLVMBuildBr(c->builder, init_block);
// start the post block so that a break can modify the phi node
LLVMValueRef phi = GEN_NOTNEEDED;
if(!is_control_type(type))
{
// Start the post block so that a break can modify the phi node.
post_block = codegen_block(c, "while_post");
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
phi = LLVMBuildPhi(c->builder, phi_type->use_type, "");
}
// Push the loop status.
codegen_pushloop(c, init_block, post_block, else_block);
// init
// This jumps either to the body or the else clause. This is not evaluated
// on each loop iteration: only on the first entry or after a continue.
LLVMPositionBuilderAtEnd(c->builder, init_block);
LLVMValueRef i_value = gen_expr(c, cond);
if(i_value == NULL)
return NULL;
LLVMValueRef test = LLVMBuildTrunc(c->builder, i_value, c->i1, "");
LLVMBuildCondBr(c->builder, test, body_block, else_block);
// Body.
LLVMPositionBuilderAtEnd(c->builder, body_block);
LLVMValueRef l_value = gen_expr(c, body);
if(needed)
l_value = gen_assign_cast(c, phi_type->use_type, l_value, body_type);
if(l_value == NULL)
return NULL;
LLVMBasicBlockRef body_from = NULL;
// If the body can't result in a value, don't generate the conditional
// evaluation. This basic block for the body already has a terminator.
if(l_value != GEN_NOVALUE)
{
// The body evaluates the condition itself, jumping either back to the body
// or directly to the post block.
LLVMValueRef c_value = gen_expr(c, cond);
if(c_value == NULL)
return NULL;
body_from = LLVMGetInsertBlock(c->builder);
LLVMValueRef test = LLVMBuildTrunc(c->builder, c_value, c->i1, "");
LLVMBuildCondBr(c->builder, test, body_block, post_block);
}
// Don't need loop status for the else block.
codegen_poploop(c);
// else
// If the loop doesn't generate a value (doesn't execute, or continues on the
// last iteration), the else clause generates the value.
LLVMPositionBuilderAtEnd(c->builder, else_block);
LLVMValueRef r_value = gen_expr(c, else_clause);
LLVMBasicBlockRef else_from = NULL;
if(r_value != GEN_NOVALUE)
{
if(r_value == NULL)
return NULL;
if(needed)
r_value = gen_assign_cast(c, phi_type->use_type, r_value, else_type);
else_from = LLVMGetInsertBlock(c->builder);
LLVMBuildBr(c->builder, post_block);
}
if(is_control_type(type))
return GEN_NOVALUE;
// post
LLVMPositionBuilderAtEnd(c->builder, post_block);
if(needed)
{
if(l_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &l_value, &body_from, 1);
if(r_value != GEN_NOVALUE)
LLVMAddIncoming(phi, &r_value, &else_from, 1);
return phi;
}
return GEN_NOTNEEDED;
}
