lvalue_locus, rvalue_locus);
tree return_stmt
- = ctx->get_backend ()->return_statement (fndecl, return_value,
- locus);
+ = Backend::return_statement (fndecl, return_value, locus);
ctx->add_statement (return_stmt);
}
else
// now just return unit expression
tree unit_expr = unit_expression (ctx, locus);
tree return_stmt
- = ctx->get_backend ()->return_statement (fndecl, unit_expr, locus);
+ = Backend::return_statement (fndecl, unit_expr, locus);
ctx->add_statement (return_stmt);
}
}
location_t locus = function_body.get_locus ();
tree return_value = unit_expression (ctx, locus);
tree return_stmt
- = ctx->get_backend ()->return_statement (fndecl, return_value, locus);
+ = Backend::return_statement (fndecl, return_value, locus);
ctx->add_statement (return_stmt);
}
}
std::string asm_name = fn_name;
unsigned int flags = 0;
- tree fndecl = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name,
- "" /* asm_name */, flags, locus);
+ tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name,
+ "" /* asm_name */, flags, locus);
setup_fndecl (fndecl, is_main_fn, fntype->has_subsititions_defined (),
visibility, qualifiers, outer_attrs);
compiled_param_var);
}
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
// lookup locals
location_t start_location = function_body->get_locus ();
location_t end_location = function_body->get_end_locus ();
- tree code_block = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree code_block = Backend::block (fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (code_block);
Bvariable *return_address = nullptr;
bool address_is_taken = false;
tree ret_var_stmt = NULL_TREE;
return_address
- = ctx->get_backend ()->temporary_variable (fndecl, code_block, return_type,
- NULL, address_is_taken, locus,
- &ret_var_stmt);
+ = Backend::temporary_variable (fndecl, code_block, return_type, NULL,
+ address_is_taken, locus, &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
// make a _fake_ function with a block so it can hold onto temps then
// use our constexpr code to fold it completely or error_mark_node
Backend::typed_identifier receiver;
- tree compiled_fn_type = ctx->get_backend ()->function_type (
+ tree compiled_fn_type = Backend::function_type (
receiver, {}, {Backend::typed_identifier ("_", const_type, locus)}, NULL,
locus);
- tree fndecl
- = ctx->get_backend ()->function (compiled_fn_type, ident, "", 0, locus);
+ tree fndecl = Backend::function (compiled_fn_type, ident, "", 0, locus);
TREE_READONLY (fndecl) = 1;
std::vector<Bvariable *> locals;
locals = compile_locals_for_block (ctx, *rib, fndecl);
}
- tree code_block = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree code_block = Backend::block (fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (code_block);
bool address_is_taken = false;
tree ret_var_stmt = NULL_TREE;
Bvariable *return_address
- = ctx->get_backend ()->temporary_variable (fndecl, code_block, const_type,
- NULL, address_is_taken, locus,
- &ret_var_stmt);
+ = Backend::temporary_variable (fndecl, code_block, const_type, NULL,
+ address_is_taken, locus, &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
ctx->push_fn (fndecl, return_address, resolved_type);
{
tree value = CompileExpr::Compile (const_value_expr, ctx);
- tree return_expr = ctx->get_backend ()->return_statement (
- fndecl, value, const_value_expr->get_locus ());
+ tree return_expr
+ = Backend::return_statement (fndecl, value,
+ const_value_expr->get_locus ());
ctx->add_statement (return_expr);
}
HIRCompileBase::unit_expression (Context *ctx, location_t locus)
{
tree unit_type = TyTyResolveCompile::get_unit_type (ctx);
- return ctx->get_backend ()->constructor_expression (unit_type, false, {}, -1,
- locus);
+ return Backend::constructor_expression (unit_type, false, {}, -1, locus);
}
} // namespace Compile
= compile_locals_for_block (ctx, *rib, fndecl);
tree enclosing_scope = ctx->peek_enclosing_scope ();
- tree new_block = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree new_block = Backend::block (fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (new_block);
for (auto &s : expr.get_statements ())
if (result != nullptr)
{
location_t locus = expr.get_final_expr ()->get_locus ();
- tree result_reference
- = ctx->get_backend ()->var_expression (result, locus);
+ tree result_reference = Backend::var_expression (result, locus);
tree assignment
- = ctx->get_backend ()->assignment_statement (result_reference,
- compiled_expr,
- expr.get_locus ());
+ = Backend::assignment_statement (result_reference, compiled_expr,
+ expr.get_locus ());
ctx->add_statement (assignment);
}
}
{
location_t locus = expr.get_locus ();
tree compiled_expr = unit_expression (ctx, expr.get_locus ());
- tree result_reference
- = ctx->get_backend ()->var_expression (result, locus);
+ tree result_reference = Backend::var_expression (result, locus);
tree assignment
- = ctx->get_backend ()->assignment_statement (result_reference,
- compiled_expr,
- expr.get_locus ());
+ = Backend::assignment_statement (result_reference, compiled_expr,
+ expr.get_locus ());
ctx->add_statement (assignment);
}
tree then_block
= CompileBlock::compile (expr.get_if_block ().get (), ctx, result);
- translated
- = ctx->get_backend ()->if_statement (fndecl, condition_expr, then_block,
- NULL, expr.get_locus ());
+ translated = Backend::if_statement (fndecl, condition_expr, then_block, NULL,
+ expr.get_locus ());
}
void
location_t start_location = expr.get_else_block ()->get_locus ();
location_t end_location = expr.get_else_block ()->get_locus (); // FIXME
tree enclosing_scope = ctx->peek_enclosing_scope ();
- tree else_block = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree else_block = Backend::block (fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (else_block);
tree else_stmt_decl
ctx->pop_block ();
- translated
- = ctx->get_backend ()->if_statement (fndecl, condition_expr, then_block,
- else_block, expr.get_locus ());
+ translated = Backend::if_statement (fndecl, condition_expr, then_block,
+ else_block, expr.get_locus ());
}
} // namespace Compile
namespace Rust {
namespace Compile {
-Context::Context (::Backend *backend)
- : backend (backend), resolver (Resolver::Resolver::get ()),
+Context::Context ()
+ : resolver (Resolver::Resolver::get ()),
tyctx (Resolver::TypeCheckContext::get ()),
mappings (Analysis::Mappings::get ()), mangler (Mangler ())
{
class Context
{
public:
- Context (::Backend *backend);
+ Context ();
void setup_builtins ();
return type;
}
- ::Backend *get_backend () { return backend; }
Resolver::Resolver *get_resolver () { return resolver; }
Resolver::TypeCheckContext *get_tyctx () { return tyctx; }
Analysis::Mappings *get_mappings () { return mappings; }
auto stmts = statements.back ();
statements.pop_back ();
- backend->block_add_statements (block, stmts);
+ Backend::block_add_statements (block, stmts);
return block;
}
void write_to_backend ()
{
- backend->write_global_definitions (type_decls, const_decls, func_decls,
+ Backend::write_global_definitions (type_decls, const_decls, func_decls,
var_decls);
}
static hashval_t type_hasher (tree type);
private:
- ::Backend *backend;
Resolver::Resolver *resolver;
Resolver::TypeCheckContext *tyctx;
Analysis::Mappings *mappings;
}
translated
- = ctx->get_backend ()->struct_field_expression (receiver_ref, index,
- expr.get_locus ());
+ = Backend::struct_field_expression (receiver_ref, index, expr.get_locus ());
}
void
vals.push_back (e);
}
- translated
- = ctx->get_backend ()->constructor_expression (tuple_type, false, vals, -1,
- expr.get_locus ());
+ translated = Backend::constructor_expression (tuple_type, false, vals, -1,
+ expr.get_locus ());
}
void
lvalue_locus, rvalue_locus);
}
- tree return_stmt
- = ctx->get_backend ()->return_statement (fncontext.fndecl, return_value,
- expr.get_locus ());
+ tree return_stmt = Backend::return_statement (fncontext.fndecl, return_value,
+ expr.get_locus ());
ctx->add_statement (return_stmt);
}
{
auto receiver_tmp = NULL_TREE;
auto receiver
- = ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl,
- NULL_TREE, TREE_TYPE (lhs),
- lhs, true, expr.get_locus (),
- &receiver_tmp);
+ = Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
+ TREE_TYPE (lhs), lhs, true,
+ expr.get_locus (), &receiver_tmp);
auto check
- = ctx->get_backend ()->arithmetic_or_logical_expression_checked (
- op, lhs, rhs, expr.get_locus (), receiver);
+ = Backend::arithmetic_or_logical_expression_checked (op, lhs, rhs,
+ expr.get_locus (),
+ receiver);
ctx->add_statement (check);
translated = receiver->get_tree (expr.get_locus ());
}
else
{
- translated = ctx->get_backend ()->arithmetic_or_logical_expression (
- op, lhs, rhs, expr.get_locus ());
+ translated
+ = Backend::arithmetic_or_logical_expression (op, lhs, rhs,
+ expr.get_locus ());
}
}
{
auto tmp = NULL_TREE;
auto receiver
- = ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl,
- NULL_TREE, TREE_TYPE (lhs),
- lhs, true, expr.get_locus (),
- &tmp);
+ = Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
+ TREE_TYPE (lhs), lhs, true,
+ expr.get_locus (), &tmp);
auto check
- = ctx->get_backend ()->arithmetic_or_logical_expression_checked (
- op, lhs, rhs, expr.get_locus (), receiver);
+ = Backend::arithmetic_or_logical_expression_checked (op, lhs, rhs,
+ expr.get_locus (),
+ receiver);
ctx->add_statement (check);
- translated = ctx->get_backend ()->assignment_statement (
- lhs, receiver->get_tree (expr.get_locus ()), expr.get_locus ());
+ translated
+ = Backend::assignment_statement (lhs,
+ receiver->get_tree (expr.get_locus ()),
+ expr.get_locus ());
}
else
{
- translated = ctx->get_backend ()->arithmetic_or_logical_expression (
- op, lhs, rhs, expr.get_locus ());
+ translated
+ = Backend::arithmetic_or_logical_expression (op, lhs, rhs,
+ expr.get_locus ());
}
}
return;
}
- translated
- = ctx->get_backend ()->negation_expression (op, negated_expr, location);
+ translated = Backend::negation_expression (op, negated_expr, location);
}
void
auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
auto location = expr.get_locus ();
- translated
- = ctx->get_backend ()->comparison_expression (op, lhs, rhs, location);
+ translated = Backend::comparison_expression (op, lhs, rhs, location);
}
void
auto rhs = CompileExpr::Compile (expr.get_rhs ().get (), ctx);
auto location = expr.get_locus ();
- translated
- = ctx->get_backend ()->lazy_boolean_expression (op, lhs, rhs, location);
+ translated = Backend::lazy_boolean_expression (op, lhs, rhs, location);
}
void
bool is_address_taken = false;
tree ret_var_stmt = nullptr;
- tmp = ctx->get_backend ()->temporary_variable (fnctx.fndecl, enclosing_scope,
- block_type, NULL,
- is_address_taken,
- expr.get_locus (),
- &ret_var_stmt);
+ tmp = Backend::temporary_variable (fnctx.fndecl, enclosing_scope, block_type,
+ NULL, is_address_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
auto stmt = CompileConditionalBlocks::compile (&expr, ctx, tmp);
ctx->add_statement (stmt);
- translated = ctx->get_backend ()->var_expression (tmp, expr.get_locus ());
+ translated = Backend::var_expression (tmp, expr.get_locus ());
}
void
bool is_address_taken = false;
tree ret_var_stmt = nullptr;
- tmp = ctx->get_backend ()->temporary_variable (fnctx.fndecl, enclosing_scope,
- block_type, NULL,
- is_address_taken,
- expr.get_locus (),
- &ret_var_stmt);
+ tmp = Backend::temporary_variable (fnctx.fndecl, enclosing_scope, block_type,
+ NULL, is_address_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
auto block_stmt = CompileBlock::compile (&expr, ctx, tmp);
rust_assert (TREE_CODE (block_stmt) == BIND_EXPR);
ctx->add_statement (block_stmt);
- translated = ctx->get_backend ()->var_expression (tmp, expr.get_locus ());
+ translated = Backend::var_expression (tmp, expr.get_locus ());
}
void
for (auto &arg : arguments)
ctor_arguments.push_back (arg);
- translated = ctx->get_backend ()->constructor_expression (
- compiled_adt_type, adt->is_enum (), ctor_arguments, union_disriminator,
- struct_expr.get_locus ());
+ translated
+ = Backend::constructor_expression (compiled_adt_type, adt->is_enum (),
+ ctor_arguments, union_disriminator,
+ struct_expr.get_locus ());
}
void
receiver_ref = indirect;
}
- translated
- = ctx->get_backend ()->struct_field_expression (receiver_ref, field_index,
- expr.get_locus ());
+ translated = Backend::struct_field_expression (receiver_ref, field_index,
+ expr.get_locus ());
}
void
bool is_address_taken = false;
tree ret_var_stmt = NULL_TREE;
- Bvariable *tmp = ctx->get_backend ()->temporary_variable (
- fnctx.fndecl, enclosing_scope, block_type, NULL, is_address_taken,
- expr.get_locus (), &ret_var_stmt);
+ Bvariable *tmp
+ = Backend::temporary_variable (fnctx.fndecl, enclosing_scope, block_type,
+ NULL, is_address_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
ctx->push_loop_context (tmp);
{
HIR::LoopLabel &loop_label = expr.get_loop_label ();
tree label
- = ctx->get_backend ()->label (fnctx.fndecl,
- loop_label.get_lifetime ().get_name (),
- loop_label.get_locus ());
- tree label_decl = ctx->get_backend ()->label_definition_statement (label);
+ = Backend::label (fnctx.fndecl, loop_label.get_lifetime ().get_name (),
+ loop_label.get_locus ());
+ tree label_decl = Backend::label_definition_statement (label);
ctx->add_statement (label_decl);
ctx->insert_label_decl (
loop_label.get_lifetime ().get_mappings ().get_hirid (), label);
}
- tree loop_begin_label
- = ctx->get_backend ()->label (fnctx.fndecl, "", expr.get_locus ());
+ tree loop_begin_label = Backend::label (fnctx.fndecl, "", expr.get_locus ());
tree loop_begin_label_decl
- = ctx->get_backend ()->label_definition_statement (loop_begin_label);
+ = Backend::label_definition_statement (loop_begin_label);
ctx->add_statement (loop_begin_label_decl);
ctx->push_loop_begin_label (loop_begin_label);
tree code_block
= CompileBlock::compile (expr.get_loop_block ().get (), ctx, nullptr);
- tree loop_expr
- = ctx->get_backend ()->loop_expression (code_block, expr.get_locus ());
+ tree loop_expr = Backend::loop_expression (code_block, expr.get_locus ());
ctx->add_statement (loop_expr);
ctx->pop_loop_context ();
- translated = ctx->get_backend ()->var_expression (tmp, expr.get_locus ());
+ translated = Backend::var_expression (tmp, expr.get_locus ());
ctx->pop_loop_begin_label ();
}
{
HIR::LoopLabel &loop_label = expr.get_loop_label ();
tree label
- = ctx->get_backend ()->label (fnctx.fndecl,
- loop_label.get_lifetime ().get_name (),
- loop_label.get_locus ());
- tree label_decl = ctx->get_backend ()->label_definition_statement (label);
+ = Backend::label (fnctx.fndecl, loop_label.get_lifetime ().get_name (),
+ loop_label.get_locus ());
+ tree label_decl = Backend::label_definition_statement (label);
ctx->add_statement (label_decl);
ctx->insert_label_decl (
loop_label.get_lifetime ().get_mappings ().get_hirid (), label);
location_t end_location = expr.get_loop_block ()->get_locus (); // FIXME
tree enclosing_scope = ctx->peek_enclosing_scope ();
- tree loop_block
- = ctx->get_backend ()->block (fnctx.fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree loop_block = Backend::block (fnctx.fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (loop_block);
- tree loop_begin_label
- = ctx->get_backend ()->label (fnctx.fndecl, "", expr.get_locus ());
+ tree loop_begin_label = Backend::label (fnctx.fndecl, "", expr.get_locus ());
tree loop_begin_label_decl
- = ctx->get_backend ()->label_definition_statement (loop_begin_label);
+ = Backend::label_definition_statement (loop_begin_label);
ctx->add_statement (loop_begin_label_decl);
ctx->push_loop_begin_label (loop_begin_label);
= CompileExpr::Compile (expr.get_predicate_expr ().get (), ctx);
tree exit_condition = fold_build1_loc (expr.get_locus (), TRUTH_NOT_EXPR,
boolean_type_node, condition);
- tree exit_expr
- = ctx->get_backend ()->exit_expression (exit_condition, expr.get_locus ());
+ tree exit_expr = Backend::exit_expression (exit_condition, expr.get_locus ());
ctx->add_statement (exit_expr);
tree code_block_stmt
ctx->pop_loop_begin_label ();
ctx->pop_block ();
- tree loop_expr
- = ctx->get_backend ()->loop_expression (loop_block, expr.get_locus ());
+ tree loop_expr = Backend::loop_expression (loop_block, expr.get_locus ());
ctx->add_statement (loop_expr);
}
Bvariable *loop_result_holder = ctx->peek_loop_context ();
tree result_reference
- = ctx->get_backend ()->var_expression (loop_result_holder,
- expr.get_expr ()->get_locus ());
+ = Backend::var_expression (loop_result_holder,
+ expr.get_expr ()->get_locus ());
tree assignment
- = ctx->get_backend ()->assignment_statement (result_reference,
- compiled_expr,
- expr.get_locus ());
+ = Backend::assignment_statement (result_reference, compiled_expr,
+ expr.get_locus ());
ctx->add_statement (assignment);
}
return;
}
- tree goto_label
- = ctx->get_backend ()->goto_statement (label, expr.get_locus ());
+ tree goto_label = Backend::goto_statement (label, expr.get_locus ());
ctx->add_statement (goto_label);
}
else
{
- tree exit_expr = ctx->get_backend ()->exit_expression (
- ctx->get_backend ()->boolean_constant_expression (true),
- expr.get_locus ());
+ tree exit_expr
+ = Backend::exit_expression (Backend::boolean_constant_expression (true),
+ expr.get_locus ());
ctx->add_statement (exit_expr);
}
}
}
}
- translated = ctx->get_backend ()->goto_statement (label, expr.get_locus ());
+ translated = Backend::goto_statement (label, expr.get_locus ());
}
void
// debug_tree (lvalue);
tree assignment
- = ctx->get_backend ()->assignment_statement (lvalue, rvalue,
- expr.get_locus ());
+ = Backend::assignment_statement (lvalue, rvalue, expr.get_locus ());
ctx->add_statement (assignment);
}
bool is_address_taken = false;
tree ret_var_stmt = nullptr;
- tmp = ctx->get_backend ()->temporary_variable (fnctx.fndecl, enclosing_scope,
- block_type, NULL,
- is_address_taken,
- expr.get_locus (),
- &ret_var_stmt);
+ tmp = Backend::temporary_variable (fnctx.fndecl, enclosing_scope, block_type,
+ NULL, is_address_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
// lets compile the scrutinee expression
tree match_scrutinee_rval
= CompileExpr::Compile (expr.get_scrutinee_expr ().get (), ctx);
- Bvariable *match_scrutinee_tmp_var = ctx->get_backend ()->temporary_variable (
- fnctx.fndecl, enclosing_scope, TREE_TYPE (match_scrutinee_rval), NULL,
- is_address_taken, expr.get_locus (), &ret_var_stmt);
+ Bvariable *match_scrutinee_tmp_var
+ = Backend::temporary_variable (fnctx.fndecl, enclosing_scope,
+ TREE_TYPE (match_scrutinee_rval), NULL,
+ is_address_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
tree match_scrutinee_expr = match_scrutinee_tmp_var->get_tree (
expr.get_scrutinee_expr ()->get_locus ());
tree assignment
- = ctx->get_backend ()->assignment_statement (match_scrutinee_expr,
- match_scrutinee_rval,
- expr.get_locus ());
+ = Backend::assignment_statement (match_scrutinee_expr, match_scrutinee_rval,
+ expr.get_locus ());
ctx->add_statement (assignment);
tree match_scrutinee_expr_qualifier_expr;
// would be DECL_QUALIFIER i think. For now this will just access the
// first record field and its respective qualifier because it will always
// be set because this is all a big special union
- tree scrutinee_first_record_expr
- = ctx->get_backend ()->struct_field_expression (
- match_scrutinee_expr, 0, expr.get_scrutinee_expr ()->get_locus ());
- match_scrutinee_expr_qualifier_expr
- = ctx->get_backend ()->struct_field_expression (
- scrutinee_first_record_expr, 0,
- expr.get_scrutinee_expr ()->get_locus ());
+ tree scrutinee_first_record_expr = Backend::struct_field_expression (
+ match_scrutinee_expr, 0, expr.get_scrutinee_expr ()->get_locus ());
+ match_scrutinee_expr_qualifier_expr = Backend::struct_field_expression (
+ scrutinee_first_record_expr, 0,
+ expr.get_scrutinee_expr ()->get_locus ());
}
else if (scrutinee_kind == TyTy::TypeKind::REF)
{
// because it will always be set because this is all a big
// special union
tree scrutinee_first_record_expr
- = ctx->get_backend ()->struct_field_expression (
+ = Backend::struct_field_expression (
match_scrutinee_expr, 0,
expr.get_scrutinee_expr ()->get_locus ());
match_scrutinee_expr_qualifier_expr
- = ctx->get_backend ()->struct_field_expression (
+ = Backend::struct_field_expression (
scrutinee_first_record_expr, 0,
expr.get_scrutinee_expr ()->get_locus ());
}
tree fndecl = fnctx.fndecl;
location_t end_label_locus = expr.get_locus (); // FIXME
tree end_label
- = ctx->get_backend ()->label (fndecl,
- "" /* empty creates an artificial label */,
- end_label_locus);
+ = Backend::label (fndecl, "" /* empty creates an artificial label */,
+ end_label_locus);
tree end_label_decl_statement
- = ctx->get_backend ()->label_definition_statement (end_label);
+ = Backend::label_definition_statement (end_label);
// setup the switch-body-block
location_t start_location = UNKNOWN_LOCATION; // FIXME
location_t end_location = UNKNOWN_LOCATION; // FIXME
- tree switch_body_block
- = ctx->get_backend ()->block (fndecl, enclosing_scope, {}, start_location,
- end_location);
+ tree switch_body_block = Backend::block (fndecl, enclosing_scope, {},
+ start_location, end_location);
ctx->push_block (switch_body_block);
for (auto &kase : expr.get_match_cases ())
// generate implicit label
location_t arm_locus = kase_arm.get_locus ();
- tree case_label = ctx->get_backend ()->label (
- fndecl, "" /* empty creates an artificial label */, arm_locus);
+ tree case_label
+ = Backend::label (fndecl, "" /* empty creates an artificial label */,
+ arm_locus);
// setup the bindings for the block
for (auto &kase_pattern : kase_arm.get_patterns ())
// compile the expr and setup the assignment if required when tmp != NULL
tree kase_expr_tree = CompileExpr::Compile (kase.get_expr ().get (), ctx);
- tree result_reference
- = ctx->get_backend ()->var_expression (tmp, arm_locus);
+ tree result_reference = Backend::var_expression (tmp, arm_locus);
tree assignment
- = ctx->get_backend ()->assignment_statement (result_reference,
- kase_expr_tree, arm_locus);
+ = Backend::assignment_statement (result_reference, kase_expr_tree,
+ arm_locus);
ctx->add_statement (assignment);
// go to end label
ctx->add_statement (match_expr_stmt);
ctx->add_statement (end_label_decl_statement);
- translated = ctx->get_backend ()->var_expression (tmp, expr.get_locus ());
+ translated = Backend::var_expression (tmp, expr.get_locus ());
}
void
for (auto &arg : arguments)
ctor_arguments.push_back (arg);
- translated = ctx->get_backend ()->constructor_expression (
- compiled_adt_type, adt->is_enum (), ctor_arguments, union_disriminator,
- expr.get_locus ());
+ translated
+ = Backend::constructor_expression (compiled_adt_type, adt->is_enum (),
+ ctor_arguments, union_disriminator,
+ expr.get_locus ());
return;
}
}
// must be a regular call to a function
- translated = ctx->get_backend ()->call_expression (fn_address, args, nullptr,
- expr.get_locus ());
+ translated
+ = Backend::call_expression (fn_address, args, nullptr, expr.get_locus ());
}
void
args.push_back (rvalue);
}
- translated = ctx->get_backend ()->call_expression (fn_expr, args, nullptr,
- expr.get_locus ());
+ translated
+ = Backend::call_expression (fn_expr, args, nullptr, expr.get_locus ());
}
tree
tree idx = build_int_cst (size_type_node, offs);
tree vtable_ptr
- = ctx->get_backend ()->struct_field_expression (receiver_ref, 1,
- expr_locus);
+ = Backend::struct_field_expression (receiver_ref, 1, expr_locus);
tree vtable_array_access
= build4_loc (expr_locus, ARRAY_REF, TREE_TYPE (TREE_TYPE (vtable_ptr)),
vtable_ptr, idx, NULL_TREE, NULL_TREE);
location_t expr_locus)
{
// access the offs + 1 for the fnptr and offs=0 for the reciever obj
- return ctx->get_backend ()->struct_field_expression (receiver_ref, 0,
- expr_locus);
+ return Backend::struct_field_expression (receiver_ref, 0, expr_locus);
}
tree
if (rhs != nullptr) // can be null for negation_expr (unary ones)
args.push_back (rhs);
- return ctx->get_backend ()->call_expression (fn_expr, args, nullptr,
- expr.get_locus ());
+ return Backend::call_expression (fn_expr, args, nullptr, expr.get_locus ());
}
tree
const auto literal_value = expr.get_literal ();
bool bval = literal_value.as_string ().compare ("true") == 0;
- return ctx->get_backend ()->boolean_constant_expression (bval);
+ return Backend::boolean_constant_expression (bval);
}
tree
// FIXME needs wchar_t
char c = literal_value.as_string ().c_str ()[0];
- return ctx->get_backend ()->wchar_constant_expression (c);
+ return Backend::wchar_constant_expression (c);
}
tree
rust_assert (expr.get_lit_type () == HIR::Literal::STRING);
const auto literal_value = expr.get_literal ();
- auto base = ctx->get_backend ()->string_constant_expression (
- literal_value.as_string ());
+ auto base = Backend::string_constant_expression (literal_value.as_string ());
tree data = address_expression (base, expr.get_locus ());
TyTy::BaseType *usize = nullptr;
tree size = build_int_cstu (type, literal_value.as_string ().size ());
- return ctx->get_backend ()->constructor_expression (fat_pointer, false,
- {data, size}, -1,
- expr.get_locus ());
+ return Backend::constructor_expression (fat_pointer, false, {data, size}, -1,
+ expr.get_locus ());
}
tree
for (size_t i = 0; i < value_str.size (); i++)
{
char b = value_str.at (i);
- tree bb = ctx->get_backend ()->char_constant_expression (b);
+ tree bb = Backend::char_constant_expression (b);
vals.push_back (bb);
indexes.push_back (i);
}
tree array_type = TyTyResolveCompile::compile (ctx, array_tyty);
tree constructed
- = ctx->get_backend ()->array_constructor_expression (array_type, indexes,
- vals,
- expr.get_locus ());
+ = Backend::array_constructor_expression (array_type, indexes, vals,
+ expr.get_locus ());
return address_expression (constructed, expr.get_locus ());
}
|| TREE_TYPE (expr_tree) == error_mark_node)
return error_mark_node;
- if (ctx->get_backend ()->type_size (type_to_cast_to) == 0
+ if (Backend::type_size (type_to_cast_to) == 0
|| TREE_TYPE (expr_tree) == void_type_node)
{
// Do not convert zero-sized types.
// this is returning the direct raw pointer of the slice an assumes a very
// specific layout
- return ctx->get_backend ()->struct_field_expression (expr_tree, 0,
- location);
+ return Backend::struct_field_expression (expr_tree, 0, location);
}
return fold_convert_loc (location, type_to_cast_to, expr_tree);
indexes.push_back (i++);
}
- return ctx->get_backend ()->array_constructor_expression (array_type, indexes,
- constructor,
- expr_locus);
+ return Backend::array_constructor_expression (array_type, indexes,
+ constructor, expr_locus);
}
tree
indexes.push_back (idx++);
}
- return ctx->get_backend ()->array_constructor_expression (array_type,
- indexes,
- constructor,
- expr_locus);
+ return Backend::array_constructor_expression (array_type, indexes,
+ constructor, expr_locus);
}
else
std::vector<Bvariable *> locals;
tree enclosing_scope = ctx->peek_enclosing_scope ();
- tree init_block
- = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- expr_locus, expr_locus);
+ tree init_block = Backend::block (fndecl, enclosing_scope, locals,
+ expr_locus, expr_locus);
ctx->push_block (init_block);
tree tmp;
- tree stmts
- = ctx->get_backend ()->array_initializer (fndecl, init_block,
- array_type, capacity_expr,
- translated_expr, &tmp,
- expr_locus);
+ tree stmts = Backend::array_initializer (fndecl, init_block, array_type,
+ capacity_expr, translated_expr,
+ &tmp, expr_locus);
ctx->add_statement (stmts);
tree block = ctx->pop_block ();
// The result is a compound expression which creates a temporary array,
// initializes all the elements in a loop, and then yeilds the array.
- return ctx->get_backend ()->compound_expression (block, tmp, expr_locus);
+ return Backend::compound_expression (block, tmp, expr_locus);
}
}
}
// make the call
- return ctx->get_backend ()->call_expression (fn_address, {adjusted_argument},
- nullptr, locus);
+ return Backend::call_expression (fn_address, {adjusted_argument}, nullptr,
+ locus);
}
tree
.to_uhwi ();
tree size = build_int_cstu (size_type_node, array_size);
- return ctx->get_backend ()->constructor_expression (fat_pointer, false,
- {data, size}, -1, locus);
+ return Backend::constructor_expression (fat_pointer, false, {data, size}, -1,
+ locus);
}
tree
tree adt = TyTyResolveCompile::compile (ctx, tyty);
// make the constructor
- translated
- = ctx->get_backend ()->constructor_expression (adt, false, {from, to}, -1,
- expr.get_locus ());
+ translated = Backend::constructor_expression (adt, false, {from, to}, -1,
+ expr.get_locus ());
}
void
tree adt = TyTyResolveCompile::compile (ctx, tyty);
// make the constructor
- translated
- = ctx->get_backend ()->constructor_expression (adt, false, {from}, -1,
- expr.get_locus ());
+ translated = Backend::constructor_expression (adt, false, {from}, -1,
+ expr.get_locus ());
}
void
// make the constructor
translated
- = ctx->get_backend ()->constructor_expression (adt, false, {to}, -1,
- expr.get_locus ());
+ = Backend::constructor_expression (adt, false, {to}, -1, expr.get_locus ());
}
void
rust_assert (ok);
tree adt = TyTyResolveCompile::compile (ctx, tyty);
- translated = ctx->get_backend ()->constructor_expression (adt, false, {}, -1,
- expr.get_locus ());
+ translated
+ = Backend::constructor_expression (adt, false, {}, -1, expr.get_locus ());
}
void
tree adt = TyTyResolveCompile::compile (ctx, tyty);
// make the constructor
- translated
- = ctx->get_backend ()->constructor_expression (adt, false, {from, to}, -1,
- expr.get_locus ());
+ translated = Backend::constructor_expression (adt, false, {from, to}, -1,
+ expr.get_locus ());
}
void
= indirect_expression (array_reference, expr.get_locus ());
}
- translated
- = ctx->get_backend ()->array_index_expression (array_reference, index,
- expr.get_locus ());
+ translated = Backend::array_index_expression (array_reference, index,
+ expr.get_locus ());
}
void
vals.push_back (val);
}
- translated
- = ctx->get_backend ()->constructor_expression (compiled_closure_tyty, false,
- vals, -1, expr.get_locus ());
+ translated = Backend::constructor_expression (compiled_closure_tyty, false,
+ vals, -1, expr.get_locus ());
}
tree
std::string asm_name = ctx->mangle_item (&closure_tyty, path);
unsigned int flags = 0;
- tree fndecl
- = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, asm_name,
- flags, expr.get_locus ());
+ tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name, asm_name,
+ flags, expr.get_locus ());
// insert into the context
ctx->insert_function_decl (fn_tyty, fndecl);
// closure self
Bvariable *self_param
- = ctx->get_backend ()->parameter_variable (fndecl, "$closure",
- compiled_closure_tyty,
- expr.get_locus ());
+ = Backend::parameter_variable (fndecl, "$closure", compiled_closure_tyty,
+ expr.get_locus ());
DECL_ARTIFICIAL (self_param->get_decl ()) = 1;
param_vars.push_back (self_param);
rust_assert (ok);
// get the assessor
- tree binding = ctx->get_backend ()->struct_field_expression (
- self_param->get_tree (expr.get_locus ()), idx, expr.get_locus ());
+ tree binding = Backend::struct_field_expression (self_param->get_tree (
+ expr.get_locus ()),
+ idx, expr.get_locus ());
tree indirection = indirect_expression (binding, expr.get_locus ());
// insert bindings
tree args_type
= TyTyResolveCompile::compile (ctx, &closure_tyty.get_parameters ());
Bvariable *args_param
- = ctx->get_backend ()->parameter_variable (fndecl, "args", args_type,
- expr.get_locus ());
+ = Backend::parameter_variable (fndecl, "args", args_type,
+ expr.get_locus ());
param_vars.push_back (args_param);
// setup the implicit mappings for the arguments. Since argument passing to
size_t i = 0;
for (auto &closure_param : expr.get_params ())
{
- tree compiled_param_var = ctx->get_backend ()->struct_field_expression (
- args_param_expr, i, closure_param.get_locus ());
+ tree compiled_param_var
+ = Backend::struct_field_expression (args_param_expr, i,
+ closure_param.get_locus ());
CompilePatternBindings::Compile (closure_param.get_pattern ().get (),
compiled_param_var, ctx);
i++;
}
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
{
ctx->pop_closure_context ();
return error_mark_node;
end_location = body->get_end_locus ();
}
- tree code_block = ctx->get_backend ()->block (fndecl, enclosing_scope, locals,
- start_location, end_location);
+ tree code_block = Backend::block (fndecl, enclosing_scope, locals,
+ start_location, end_location);
ctx->push_block (code_block);
TyTy::BaseType *tyret = &closure_tyty.get_result_type ();
tree ret_var_stmt = NULL_TREE;
return_address
- = ctx->get_backend ()->temporary_variable (fndecl, code_block, return_type,
- NULL, address_is_taken,
- expr.get_locus (),
- &ret_var_stmt);
+ = Backend::temporary_variable (fndecl, code_block, return_type, NULL,
+ address_is_taken, expr.get_locus (),
+ &ret_var_stmt);
ctx->add_statement (ret_var_stmt);
{
tree value = CompileExpr::Compile (function_body, ctx);
tree return_expr
- = ctx->get_backend ()->return_statement (fndecl, value,
- function_body->get_locus ());
+ = Backend::return_statement (fndecl, value,
+ function_body->get_locus ());
ctx->add_statement (return_expr);
}
tree tuple_args_tyty = TREE_VALUE (tuple_args_tyty_chain);
tree tuple_args
- = ctx->get_backend ()->constructor_expression (tuple_args_tyty, false,
- tuple_arg_vals, -1,
- expr.get_locus ());
+ = Backend::constructor_expression (tuple_args_tyty, false, tuple_arg_vals,
+ -1, expr.get_locus ());
// args are always self, and the tuple of the args we are passing where
// self is the path of the call-expr in this case the fn_address
args.push_back (tuple_args);
tree call_address = address_expression (function, expr.get_locus ());
- *result = ctx->get_backend ()->call_expression (call_address, args,
- nullptr /* static chain ?*/,
- expr.get_locus ());
+ *result
+ = Backend::call_expression (call_address, args, nullptr /* static chain ?*/,
+ expr.get_locus ());
return true;
}
Bvariable *lookup = Bvariable::error_variable ();
if (ctx->lookup_var_decl (item.get_mappings ().get_hirid (), &lookup))
{
- reference = ctx->get_backend ()->var_expression (lookup, ref_locus);
+ reference = Backend::var_expression (lookup, ref_locus);
return;
}
bool in_unique_section = false;
Bvariable *static_global
- = ctx->get_backend ()->global_variable (name, asm_name, type, is_external,
- is_hidden, in_unique_section,
- item.get_locus ());
+ = Backend::global_variable (name, asm_name, type, is_external, is_hidden,
+ in_unique_section, item.get_locus ());
ctx->insert_var_decl (item.get_mappings ().get_hirid (), static_global);
ctx->push_var (static_global);
- reference = ctx->get_backend ()->var_expression (static_global, ref_locus);
+ reference = Backend::var_expression (static_global, ref_locus);
}
void visit (HIR::ExternalFunctionItem &function) override
}
const unsigned int flags = Backend::function_is_declaration;
- tree fndecl
- = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name,
- asm_name, flags, function.get_locus ());
+ tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name, asm_name,
+ flags, function.get_locus ());
TREE_PUBLIC (fndecl) = 1;
setup_abi_options (fndecl, fntype->get_abi ());
CompileFnParam::visit (HIR::IdentifierPattern &pattern)
{
if (!pattern.is_mut ())
- decl_type = ctx->get_backend ()->immutable_type (decl_type);
+ decl_type = Backend::immutable_type (decl_type);
- compiled_param = ctx->get_backend ()->parameter_variable (
- fndecl, pattern.get_identifier ().as_string (), decl_type, locus);
+ compiled_param
+ = Backend::parameter_variable (fndecl,
+ pattern.get_identifier ().as_string (),
+ decl_type, locus);
}
void
CompileFnParam::visit (HIR::WildcardPattern &pattern)
{
- decl_type = ctx->get_backend ()->immutable_type (decl_type);
+ decl_type = Backend::immutable_type (decl_type);
- compiled_param
- = ctx->get_backend ()->parameter_variable (fndecl, "_", decl_type, locus);
+ compiled_param = Backend::parameter_variable (fndecl, "_", decl_type, locus);
}
void
= self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM
|| self.get_self_kind () == HIR::SelfParam::ImplicitSelfKind::IMM_REF;
if (is_immutable)
- decl_type = ctx->get_backend ()->immutable_type (decl_type);
+ decl_type = Backend::immutable_type (decl_type);
- return ctx->get_backend ()->parameter_variable (fndecl, "self", decl_type,
- locus);
+ return Backend::parameter_variable (fndecl, "self", decl_type, locus);
}
tree
tree tmp_ident = create_tmp_var_name ("RSTPRM");
std::string cpp_str_identifier = std::string (IDENTIFIER_POINTER (tmp_ident));
- decl_type = ctx->get_backend ()->immutable_type (decl_type);
- compiled_param
- = ctx->get_backend ()->parameter_variable (fndecl, cpp_str_identifier,
- decl_type, locus);
+ decl_type = Backend::immutable_type (decl_type);
+ compiled_param = Backend::parameter_variable (fndecl, cpp_str_identifier,
+ decl_type, locus);
- return ctx->get_backend ()->var_expression (compiled_param, locus);
+ return Backend::var_expression (compiled_param, locus);
}
} // namespace Compile
std::string asm_name = ctx->mangle_item (fntype, canonical_path);
unsigned int flags = 0;
- tree fndecl
- = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, asm_name,
- flags, fntype->get_ident ().locus);
+ tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name, asm_name,
+ flags, fntype->get_ident ().locus);
TREE_PUBLIC (fndecl) = 0;
TREE_READONLY (fndecl) = 1;
location_t start_location = UNDEF_LOCATION;
location_t end_location = UNDEF_LOCATION;
- auto block = ctx->get_backend ()->block (fndecl, enclosing_scope, vars,
- start_location, end_location);
+ auto block = Backend::block (fndecl, enclosing_scope, vars, start_location,
+ end_location);
ctx->push_block (block);
}
auto &dst_param = param_vars.at (0);
auto &size_param = param_vars.at (1);
rust_assert (param_vars.size () == 2);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN offset FN BODY BEGIN
- tree dst = ctx->get_backend ()->var_expression (dst_param, UNDEF_LOCATION);
- tree size = ctx->get_backend ()->var_expression (size_param, UNDEF_LOCATION);
+ tree dst = Backend::var_expression (dst_param, UNDEF_LOCATION);
+ tree size = Backend::var_expression (size_param, UNDEF_LOCATION);
tree pointer_offset_expr
= pointer_offset_expression (dst, size, BUILTINS_LOCATION);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, pointer_offset_expr,
- UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, pointer_offset_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN offset FN BODY END
// BUILTIN size_of FN BODY BEGIN
tree size_expr = TYPE_SIZE_UNIT (template_parameter_type);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, size_expr, UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, size_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN size_of FN BODY END
std::vector<tree_node *> compiled_types;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars, &compiled_types);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
// param to convert
Bvariable *convert_me_param = param_vars.at (0);
tree convert_me_expr
- = ctx->get_backend ()->var_expression (convert_me_param, UNDEF_LOCATION);
+ = Backend::var_expression (convert_me_param, UNDEF_LOCATION);
// check for transmute pre-conditions
tree target_type_expr = TREE_TYPE (DECL_RESULT (fndecl));
tree result_expr = build_fold_indirect_ref_loc (UNKNOWN_LOCATION, t);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, result_expr,
- UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, result_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN transmute FN BODY END
auto &x_param = param_vars.at (0);
auto &y_param = param_vars.at (1);
rust_assert (param_vars.size () == 2);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN rotate FN BODY BEGIN
- tree x = ctx->get_backend ()->var_expression (x_param, UNDEF_LOCATION);
- tree y = ctx->get_backend ()->var_expression (y_param, UNDEF_LOCATION);
+ tree x = Backend::var_expression (x_param, UNDEF_LOCATION);
+ tree y = Backend::var_expression (y_param, UNDEF_LOCATION);
tree rotate_expr
= fold_build2_loc (BUILTINS_LOCATION, op, TREE_TYPE (x), x, y);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, rotate_expr,
- UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, rotate_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN rotate FN BODY END
auto &lhs_param = param_vars.at (0);
auto &rhs_param = param_vars.at (1);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN wrapping_<op> FN BODY BEGIN
- auto lhs = ctx->get_backend ()->var_expression (lhs_param, UNDEF_LOCATION);
- auto rhs = ctx->get_backend ()->var_expression (rhs_param, UNDEF_LOCATION);
+ auto lhs = Backend::var_expression (lhs_param, UNDEF_LOCATION);
+ auto rhs = Backend::var_expression (rhs_param, UNDEF_LOCATION);
// Operations are always wrapping in Rust, as we have -fwrapv enabled by
// default. The difference between a wrapping_{add, sub, mul} and a regular
auto wrap_expr = build2 (op, TREE_TYPE (lhs), lhs, rhs);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, wrap_expr, UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, wrap_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN wrapping_<op> FN BODY END
auto &x_param = param_vars.at (0);
auto &y_param = param_vars.at (1);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
rust_assert (fntype->get_num_substitutions () == 1);
// this should match y as well or we can take it from the TyTy structure
tree tmp_stmt = error_mark_node;
- Bvariable *result_variable = ctx->get_backend ()->temporary_variable (
- fndecl, NULL_TREE, template_parameter_type, NULL_TREE,
- true /*address_is_taken*/, UNDEF_LOCATION, &tmp_stmt);
+ Bvariable *result_variable
+ = Backend::temporary_variable (fndecl, NULL_TREE, template_parameter_type,
+ NULL_TREE, true /*address_is_taken*/,
+ UNDEF_LOCATION, &tmp_stmt);
Bvariable *bool_variable
- = ctx->get_backend ()->temporary_variable (fndecl, NULL_TREE,
- boolean_type_node, NULL_TREE,
- true /*address_is_taken*/,
- UNDEF_LOCATION, &tmp_stmt);
+ = Backend::temporary_variable (fndecl, NULL_TREE, boolean_type_node,
+ NULL_TREE, true /*address_is_taken*/,
+ UNDEF_LOCATION, &tmp_stmt);
enter_intrinsic_block (ctx, fndecl, {result_variable, bool_variable});
// BUILTIN op_with_overflow FN BODY BEGIN
- auto x = ctx->get_backend ()->var_expression (x_param, UNDEF_LOCATION);
- auto y = ctx->get_backend ()->var_expression (y_param, UNDEF_LOCATION);
+ auto x = Backend::var_expression (x_param, UNDEF_LOCATION);
+ auto y = Backend::var_expression (y_param, UNDEF_LOCATION);
tree overflow_builtin = error_mark_node;
switch (op)
3, x, y, result_ref);
tree overflow_assignment
- = ctx->get_backend ()->assignment_statement (bool_decl, builtin_call,
- BUILTINS_LOCATION);
+ = Backend::assignment_statement (bool_decl, builtin_call,
+ BUILTINS_LOCATION);
ctx->add_statement (overflow_assignment);
std::vector<tree> vals = {result_decl, bool_decl};
tree tuple_type = TREE_TYPE (DECL_RESULT (fndecl));
- tree result_expr
- = ctx->get_backend ()->constructor_expression (tuple_type, false, vals, -1,
- UNDEF_LOCATION);
+ tree result_expr = Backend::constructor_expression (tuple_type, false, vals,
+ -1, UNDEF_LOCATION);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, result_expr,
- UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, result_expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN wrapping_<op> FN BODY END
std::vector<Bvariable *> param_vars;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN copy_nonoverlapping BODY BEGIN
- auto src
- = ctx->get_backend ()->var_expression (param_vars[0], UNDEF_LOCATION);
- auto dst
- = ctx->get_backend ()->var_expression (param_vars[1], UNDEF_LOCATION);
- auto count
- = ctx->get_backend ()->var_expression (param_vars[2], UNDEF_LOCATION);
+ auto src = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
+ auto dst = Backend::var_expression (param_vars[1], UNDEF_LOCATION);
+ auto count = Backend::var_expression (param_vars[2], UNDEF_LOCATION);
// We want to create the following statement
// memcpy(dst, src, size_of::<T>());
rust_assert (memcpy_raw);
auto memcpy = build_fold_addr_expr_loc (UNKNOWN_LOCATION, memcpy_raw);
- auto copy_call
- = ctx->get_backend ()->call_expression (memcpy, {dst, src, size_expr},
- nullptr, UNDEF_LOCATION);
+ auto copy_call = Backend::call_expression (memcpy, {dst, src, size_expr},
+ nullptr, UNDEF_LOCATION);
ctx->add_statement (copy_call);
mpz_t mpz_value;
mpz_init_set_ui (mpz_value, value);
- return ctx->get_backend ()->integer_constant_expression (integer_type_node,
- mpz_value);
+ return Backend::integer_constant_expression (integer_type_node, mpz_value);
}
static tree
std::vector<Bvariable *> args;
compile_fn_params (ctx, fntype, fndecl, &args);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, args))
+ if (!Backend::function_set_parameters (fndecl, args))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
- auto addr = ctx->get_backend ()->var_expression (args[0], UNDEF_LOCATION);
- auto locality = ctx->get_backend ()->var_expression (args[1], UNDEF_LOCATION);
+ auto addr = Backend::var_expression (args[0], UNDEF_LOCATION);
+ auto locality = Backend::var_expression (args[1], UNDEF_LOCATION);
auto rw_flag = make_unsigned_long_tree (ctx, kind == Prefetch::Write ? 1 : 0);
auto prefetch_raw = NULL_TREE;
auto prefetch = build_fold_addr_expr_loc (UNKNOWN_LOCATION, prefetch_raw);
auto prefetch_call
- = ctx->get_backend ()->call_expression (prefetch, {addr, rw_flag, locality},
- nullptr, UNDEF_LOCATION);
+ = Backend::call_expression (prefetch, {addr, rw_flag, locality}, nullptr,
+ UNDEF_LOCATION);
TREE_READONLY (prefetch_call) = 0;
TREE_SIDE_EFFECTS (prefetch_call) = 1;
std::vector<tree> types;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars, &types);
- auto ok = ctx->get_backend ()->function_set_parameters (fndecl, param_vars);
+ auto ok = Backend::function_set_parameters (fndecl, param_vars);
rust_assert (ok);
enter_intrinsic_block (ctx, fndecl);
- auto dst
- = ctx->get_backend ()->var_expression (param_vars[0], UNDEF_LOCATION);
+ auto dst = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
TREE_READONLY (dst) = 0;
- auto value
- = ctx->get_backend ()->var_expression (param_vars[1], UNDEF_LOCATION);
+ auto value = Backend::var_expression (param_vars[1], UNDEF_LOCATION);
auto memorder = make_unsigned_long_tree (ctx, ordering);
auto monomorphized_type
= build_fold_addr_expr_loc (UNKNOWN_LOCATION, atomic_store_raw);
auto store_call
- = ctx->get_backend ()->call_expression (atomic_store,
- {dst, value, memorder}, nullptr,
- UNDEF_LOCATION);
+ = Backend::call_expression (atomic_store, {dst, value, memorder}, nullptr,
+ UNDEF_LOCATION);
TREE_READONLY (store_call) = 0;
TREE_SIDE_EFFECTS (store_call) = 1;
std::vector<tree> types;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars, &types);
- auto ok = ctx->get_backend ()->function_set_parameters (fndecl, param_vars);
+ auto ok = Backend::function_set_parameters (fndecl, param_vars);
rust_assert (ok);
enter_intrinsic_block (ctx, fndecl);
- auto src
- = ctx->get_backend ()->var_expression (param_vars[0], UNDEF_LOCATION);
+ auto src = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
auto memorder = make_unsigned_long_tree (ctx, ordering);
auto monomorphized_type
auto atomic_load
= build_fold_addr_expr_loc (UNKNOWN_LOCATION, atomic_load_raw);
- auto load_call
- = ctx->get_backend ()->call_expression (atomic_load, {src, memorder},
- nullptr, UNDEF_LOCATION);
+ auto load_call = Backend::call_expression (atomic_load, {src, memorder},
+ nullptr, UNDEF_LOCATION);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, load_call, UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, load_call, UNDEF_LOCATION);
TREE_READONLY (load_call) = 0;
TREE_SIDE_EFFECTS (load_call) = 1;
std::vector<Bvariable *> param_vars;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN unchecked_<op> BODY BEGIN
- auto x = ctx->get_backend ()->var_expression (param_vars[0], UNDEF_LOCATION);
- auto y = ctx->get_backend ()->var_expression (param_vars[1], UNDEF_LOCATION);
+ auto x = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
+ auto y = Backend::var_expression (param_vars[1], UNDEF_LOCATION);
auto *monomorphized_type
= fntype->get_substs ().at (0).get_param_ty ()->resolve ();
auto expr = build2 (op, TREE_TYPE (x), x, y);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, expr, UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, expr, UNDEF_LOCATION);
ctx->add_statement (return_statement);
tree tmp_stmt = error_mark_node;
Bvariable *bvar
- = ctx->get_backend ()->temporary_variable (fndecl, NULL_TREE, dst_type,
- NULL_TREE,
- true /*address_is_taken*/,
- UNDEF_LOCATION, &tmp_stmt);
+ = Backend::temporary_variable (fndecl, NULL_TREE, dst_type, NULL_TREE,
+ true /*address_is_taken*/, UNDEF_LOCATION,
+ &tmp_stmt);
enter_intrinsic_block (ctx, fndecl, {bvar});
ctx->add_statement (memset_call);
auto return_statement
- = ctx->get_backend ()->return_statement (fndecl, dst, UNDEF_LOCATION);
+ = Backend::return_statement (fndecl, dst, UNDEF_LOCATION);
ctx->add_statement (return_statement);
// BUILTIN size_of FN BODY END
std::vector<Bvariable *> param_vars;
compile_fn_params (ctx, fntype, fndecl, ¶m_vars);
- if (!ctx->get_backend ()->function_set_parameters (fndecl, param_vars))
+ if (!Backend::function_set_parameters (fndecl, param_vars))
return error_mark_node;
enter_intrinsic_block (ctx, fndecl);
// BUILTIN size_of FN BODY BEGIN
- tree dst
- = ctx->get_backend ()->var_expression (param_vars[0], UNDEF_LOCATION);
- tree src
- = ctx->get_backend ()->var_expression (param_vars[1], UNDEF_LOCATION);
+ tree dst = Backend::var_expression (param_vars[0], UNDEF_LOCATION);
+ tree src = Backend::var_expression (param_vars[1], UNDEF_LOCATION);
tree size = TYPE_SIZE_UNIT (template_parameter_type);
tree memcpy_builtin = error_mark_node;
Bvariable *static_decl_ref = nullptr;
if (ctx->lookup_var_decl (var.get_mappings ().get_hirid (), &static_decl_ref))
{
- reference
- = ctx->get_backend ()->var_expression (static_decl_ref, ref_locus);
+ reference = Backend::var_expression (static_decl_ref, ref_locus);
return;
}
bool in_unique_section = true;
Bvariable *static_global
- = ctx->get_backend ()->global_variable (name, asm_name, type, is_external,
- is_hidden, in_unique_section,
- var.get_locus ());
+ = Backend::global_variable (name, asm_name, type, is_external, is_hidden,
+ in_unique_section, var.get_locus ());
tree init = value == error_mark_node ? error_mark_node : DECL_INITIAL (value);
- ctx->get_backend ()->global_variable_set_init (static_global, init);
+ Backend::global_variable_set_init (static_global, init);
ctx->insert_var_decl (var.get_mappings ().get_hirid (), static_global);
ctx->push_var (static_global);
- reference = ctx->get_backend ()->var_expression (static_global, ref_locus);
+ reference = Backend::var_expression (static_global, ref_locus);
}
void
for (auto &pattern : items_no_range.get_patterns ())
{
tree variant_accessor
- = ctx->get_backend ()->struct_field_expression (
- match_scrutinee_expr, variant_index, pattern->get_locus ());
+ = Backend::struct_field_expression (match_scrutinee_expr,
+ variant_index,
+ pattern->get_locus ());
- tree binding = ctx->get_backend ()->struct_field_expression (
- variant_accessor, tuple_field_index++, pattern->get_locus ());
+ tree binding
+ = Backend::struct_field_expression (variant_accessor,
+ tuple_field_index++,
+ pattern->get_locus ());
ctx->insert_pattern_binding (
pattern->get_pattern_mappings ().get_hirid (), binding);
{
tree variant_accessor = match_scrutinee_expr;
- tree binding = ctx->get_backend ()->struct_field_expression (
- variant_accessor, tuple_field_index++, pattern->get_locus ());
+ tree binding
+ = Backend::struct_field_expression (variant_accessor,
+ tuple_field_index++,
+ pattern->get_locus ());
ctx->insert_pattern_binding (
pattern->get_pattern_mappings ().get_hirid (), binding);
if (adt->is_enum ())
{
tree variant_accessor
- = ctx->get_backend ()->struct_field_expression (
- match_scrutinee_expr, variant_index, ident.get_locus ());
+ = Backend::struct_field_expression (match_scrutinee_expr,
+ variant_index,
+ ident.get_locus ());
// we are offsetting by + 1 here since the first field in the
// record is always the discriminator
- binding = ctx->get_backend ()->struct_field_expression (
- variant_accessor, offs + 1, ident.get_locus ());
+ binding = Backend::struct_field_expression (variant_accessor,
+ offs + 1,
+ ident.get_locus ());
}
else
{
tree variant_accessor = match_scrutinee_expr;
- binding = ctx->get_backend ()->struct_field_expression (
- variant_accessor, offs, ident.get_locus ());
+ binding
+ = Backend::struct_field_expression (variant_accessor, offs,
+ ident.get_locus ());
}
ctx->insert_pattern_binding (ident.get_mappings ().get_hirid (),
ctx->add_statement (init_expr);
auto unit_type_init_expr = unit_expression (ctx, rval_locus);
- auto s = ctx->get_backend ()->init_statement (fnctx.fndecl, var,
- unit_type_init_expr);
+ auto s = Backend::init_statement (fnctx.fndecl, var, unit_type_init_expr);
ctx->add_statement (s);
}
else
{
- auto s
- = ctx->get_backend ()->init_statement (fnctx.fndecl, var, init_expr);
+ auto s = Backend::init_statement (fnctx.fndecl, var, init_expr);
ctx->add_statement (s);
}
}
tree init_stmt = NULL;
tree stmt_type = TyTyResolveCompile::compile (ctx, ty);
- ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
- stmt_type, init_expr, false,
- pattern.get_locus (), &init_stmt);
+ Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE, stmt_type,
+ init_expr, false, pattern.get_locus (),
+ &init_stmt);
ctx->add_statement (init_stmt);
}
tree tuple_type = TyTyResolveCompile::compile (ctx, ty);
tree init_stmt;
Bvariable *tmp_var
- = ctx->get_backend ()->temporary_variable (ctx->peek_fn ().fndecl,
- NULL_TREE, tuple_type, init_expr,
- false, pattern.get_locus (),
- &init_stmt);
- tree access_expr
- = ctx->get_backend ()->var_expression (tmp_var, pattern.get_locus ());
+ = Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE,
+ tuple_type, init_expr, false,
+ pattern.get_locus (), &init_stmt);
+ tree access_expr = Backend::var_expression (tmp_var, pattern.get_locus ());
ctx->add_statement (init_stmt);
switch (pattern.get_items ()->get_pattern_type ())
bool ok = ctx->get_tyctx ()->lookup_type (pattern_id, &ty_sub);
rust_assert (ok);
- tree sub_init = ctx->get_backend ()->struct_field_expression (
- access_expr, tuple_idx, sub->get_locus ());
+ tree sub_init
+ = Backend::struct_field_expression (access_expr, tuple_idx,
+ sub->get_locus ());
CompilePatternLet::Compile (sub.get (), sub_init, ty_sub,
rval_locus, ctx);
tuple_idx++;
bool ok = ctx->get_tyctx ()->lookup_type (pattern_id, &ty_sub);
rust_assert (ok);
- tree sub_init = ctx->get_backend ()->struct_field_expression (
- access_expr, tuple_idx, sub->get_locus ());
+ tree sub_init
+ = Backend::struct_field_expression (access_expr, tuple_idx,
+ sub->get_locus ());
CompilePatternLet::Compile (sub.get (), sub_init, ty_sub,
rval_locus, ctx);
tuple_idx++;
bool ok = ctx->get_tyctx ()->lookup_type (pattern_id, &ty_sub);
rust_assert (ok);
- tree sub_init = ctx->get_backend ()->struct_field_expression (
- access_expr, tuple_idx, sub->get_locus ());
+ tree sub_init
+ = Backend::struct_field_expression (access_expr, tuple_idx,
+ sub->get_locus ());
CompilePatternLet::Compile (sub.get (), sub_init, ty_sub,
rval_locus, ctx);
tuple_idx++;
tree folded_discrim_expr = fold_expr (discrim_expr_node);
tree qualifier = folded_discrim_expr;
- return ctx->get_backend ()->constructor_expression (compiled_adt_type,
- true, {qualifier},
- union_disriminator,
- expr_locus);
+ return Backend::constructor_expression (compiled_adt_type, true,
+ {qualifier}, union_disriminator,
+ expr_locus);
}
HirId ref;
if (ctx->lookup_var_decl (ref, &var))
{
// TREE_USED is setup in the gcc abstraction here
- return ctx->get_backend ()->var_expression (var, expr_locus);
+ return Backend::var_expression (var, expr_locus);
}
// might be a match pattern binding
static tree enum_node = NULL_TREE;
if (enum_node == NULL_TREE)
{
- enum_node = ctx->get_backend ()->named_type (
- "enumeral", ctx->get_backend ()->integer_type (false, 64),
- BUILTINS_LOCATION);
+ enum_node
+ = Backend::named_type ("enumeral", Backend::integer_type (false, 64),
+ BUILTINS_LOCATION);
}
return enum_node;
}
static tree unit_type;
if (unit_type == nullptr)
{
- auto unit_type_node = ctx->get_backend ()->struct_type ({});
- unit_type = ctx->get_backend ()->named_type ("()", unit_type_node,
- BUILTINS_LOCATION);
+ auto unit_type_node = Backend::struct_type ({});
+ unit_type = Backend::named_type ("()", unit_type_node, BUILTINS_LOCATION);
}
return unit_type;
}
type.get_ident ().locus));
}
- tree type_record = ctx->get_backend ()->struct_type (fields);
+ tree type_record = Backend::struct_type (fields);
RS_CLOSURE_FLAG (type_record) = 1;
std::string named_struct_str
= type.get_ident ().path.get () + "::{{closure}}";
- translated = ctx->get_backend ()->named_type (named_struct_str, type_record,
- type.get_ident ().locus);
+ translated = Backend::named_type (named_struct_str, type_record,
+ type.get_ident ().locus);
}
void
}
if (!type.is_varadic ())
- translated
- = ctx->get_backend ()->function_type (receiver, parameters, results, NULL,
- type.get_ident ().locus);
+ translated = Backend::function_type (receiver, parameters, results, NULL,
+ type.get_ident ().locus);
else
- translated
- = ctx->get_backend ()->function_type_varadic (receiver, parameters,
- results, NULL,
- type.get_ident ().locus);
+ translated = Backend::function_type_varadic (receiver, parameters, results,
+ NULL, type.get_ident ().locus);
}
void
parameters.push_back (pty);
}
- translated = ctx->get_backend ()->function_ptr_type (result_type, parameters,
- type.get_ident ().locus);
+ translated = Backend::function_ptr_type (result_type, parameters,
+ type.get_ident ().locus);
}
void
fields.push_back (std::move (f));
}
- type_record = type.is_union ()
- ? ctx->get_backend ()->union_type (fields)
- : ctx->get_backend ()->struct_type (fields);
+ type_record = type.is_union () ? Backend::union_type (fields)
+ : Backend::struct_type (fields);
}
else
{
fields.push_back (std::move (f));
}
- tree variant_record = ctx->get_backend ()->struct_type (fields);
- tree named_variant_record = ctx->get_backend ()->named_type (
- variant->get_ident ().path.get (), variant_record,
- variant->get_ident ().locus);
+ tree variant_record = Backend::struct_type (fields);
+ tree named_variant_record
+ = Backend::named_type (variant->get_ident ().path.get (),
+ variant_record, variant->get_ident ().locus);
// set the qualifier to be a builtin
DECL_ARTIFICIAL (TYPE_FIELDS (variant_record)) = 1;
}
// finally make the union or the enum
- type_record = ctx->get_backend ()->union_type (enum_fields);
+ type_record = Backend::union_type (enum_fields);
}
// Handle repr options
std::string named_struct_str
= type.get_ident ().path.get () + type.subst_as_string ();
- translated = ctx->get_backend ()->named_type (named_struct_str, type_record,
- type.get_ident ().locus);
+ translated = Backend::named_type (named_struct_str, type_record,
+ type.get_ident ().locus);
}
void
fields.push_back (std::move (f));
}
- tree struct_type_record = ctx->get_backend ()->struct_type (fields);
- translated
- = ctx->get_backend ()->named_type (type.as_string (), struct_type_record,
- type.get_ident ().locus);
+ tree struct_type_record = Backend::struct_type (fields);
+ translated = Backend::named_type (type.as_string (), struct_type_record,
+ type.get_ident ().locus);
}
void
tree folded_capacity_expr = fold_expr (capacity_expr);
- translated
- = ctx->get_backend ()->array_type (element_type, folded_capacity_expr);
+ translated = Backend::array_type (element_type, folded_capacity_expr);
}
void
std::string named_struct_str
= std::string ("[") + type.get_element_type ()->get_name () + "]";
- translated = ctx->get_backend ()->named_type (named_struct_str, type_record,
- type.get_ident ().locus);
+ translated = Backend::named_type (named_struct_str, type_record,
+ type.get_ident ().locus);
}
void
TyTyResolveCompile::visit (const TyTy::BoolType &)
{
- translated = ctx->get_backend ()->named_type ("bool", boolean_type_node,
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("bool", boolean_type_node, BUILTINS_LOCATION);
}
void
switch (type.get_int_kind ())
{
case TyTy::IntType::I8:
- translated = ctx->get_backend ()->named_type (
- "i8", ctx->get_backend ()->integer_type (false, 8), BUILTINS_LOCATION);
+ translated = Backend::named_type ("i8", Backend::integer_type (false, 8),
+ BUILTINS_LOCATION);
return;
case TyTy::IntType::I16:
- translated = ctx->get_backend ()->named_type (
- "i16", ctx->get_backend ()->integer_type (false, 16),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("i16", Backend::integer_type (false, 16),
+ BUILTINS_LOCATION);
return;
case TyTy::IntType::I32:
- translated = ctx->get_backend ()->named_type (
- "i32", ctx->get_backend ()->integer_type (false, 32),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("i32", Backend::integer_type (false, 32),
+ BUILTINS_LOCATION);
return;
case TyTy::IntType::I64:
- translated = ctx->get_backend ()->named_type (
- "i64", ctx->get_backend ()->integer_type (false, 64),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("i64", Backend::integer_type (false, 64),
+ BUILTINS_LOCATION);
return;
case TyTy::IntType::I128:
- translated = ctx->get_backend ()->named_type (
- "i128", ctx->get_backend ()->integer_type (false, 128),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("i128", Backend::integer_type (false, 128),
+ BUILTINS_LOCATION);
return;
}
}
switch (type.get_uint_kind ())
{
case TyTy::UintType::U8:
- translated = ctx->get_backend ()->named_type (
- "u8", ctx->get_backend ()->integer_type (true, 8), BUILTINS_LOCATION);
+ translated = Backend::named_type ("u8", Backend::integer_type (true, 8),
+ BUILTINS_LOCATION);
return;
case TyTy::UintType::U16:
- translated = ctx->get_backend ()->named_type (
- "u16", ctx->get_backend ()->integer_type (true, 16), BUILTINS_LOCATION);
+ translated = Backend::named_type ("u16", Backend::integer_type (true, 16),
+ BUILTINS_LOCATION);
return;
case TyTy::UintType::U32:
- translated = ctx->get_backend ()->named_type (
- "u32", ctx->get_backend ()->integer_type (true, 32), BUILTINS_LOCATION);
+ translated = Backend::named_type ("u32", Backend::integer_type (true, 32),
+ BUILTINS_LOCATION);
return;
case TyTy::UintType::U64:
- translated = ctx->get_backend ()->named_type (
- "u64", ctx->get_backend ()->integer_type (true, 64), BUILTINS_LOCATION);
+ translated = Backend::named_type ("u64", Backend::integer_type (true, 64),
+ BUILTINS_LOCATION);
return;
case TyTy::UintType::U128:
- translated = ctx->get_backend ()->named_type (
- "u128", ctx->get_backend ()->integer_type (true, 128),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("u128", Backend::integer_type (true, 128),
+ BUILTINS_LOCATION);
return;
}
}
switch (type.get_float_kind ())
{
case TyTy::FloatType::F32:
- translated
- = ctx->get_backend ()->named_type ("f32",
- ctx->get_backend ()->float_type (32),
- BUILTINS_LOCATION);
+ translated = Backend::named_type ("f32", Backend::float_type (32),
+ BUILTINS_LOCATION);
return;
case TyTy::FloatType::F64:
- translated
- = ctx->get_backend ()->named_type ("f64",
- ctx->get_backend ()->float_type (64),
- BUILTINS_LOCATION);
+ translated = Backend::named_type ("f64", Backend::float_type (64),
+ BUILTINS_LOCATION);
return;
}
}
void
TyTyResolveCompile::visit (const TyTy::USizeType &)
{
- translated = ctx->get_backend ()->named_type (
- "usize",
- ctx->get_backend ()->integer_type (
- true, ctx->get_backend ()->get_pointer_size ()),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("usize",
+ Backend::integer_type (true,
+ Backend::get_pointer_size ()),
+ BUILTINS_LOCATION);
}
void
TyTyResolveCompile::visit (const TyTy::ISizeType &)
{
- translated = ctx->get_backend ()->named_type (
- "isize",
- ctx->get_backend ()->integer_type (
- false, ctx->get_backend ()->get_pointer_size ()),
- BUILTINS_LOCATION);
+ translated
+ = Backend::named_type ("isize",
+ Backend::integer_type (false,
+ Backend::get_pointer_size ()),
+ BUILTINS_LOCATION);
}
void
TyTyResolveCompile::visit (const TyTy::CharType &)
{
translated
- = ctx->get_backend ()->named_type ("char",
- ctx->get_backend ()->wchar_type (),
- BUILTINS_LOCATION);
+ = Backend::named_type ("char", Backend::wchar_type (), BUILTINS_LOCATION);
}
void
= std::string (type.is_mutable () ? "&mut " : "&") + "["
+ slice->get_element_type ()->get_name () + "]";
- translated
- = ctx->get_backend ()->named_type (dyn_slice_type_str, type_record,
- slice->get_locus ());
+ translated = Backend::named_type (dyn_slice_type_str, type_record,
+ slice->get_locus ());
return;
}
std::string dyn_str_type_str
= std::string (type.is_mutable () ? "&mut " : "&") + "str";
- translated
- = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
- str->get_locus ());
+ translated = Backend::named_type (dyn_str_type_str, type_record,
+ str->get_locus ());
return;
}
std::string dyn_str_type_str
= std::string (type.is_mutable () ? "&mut " : "& ") + dyn->get_name ();
- translated
- = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
- dyn->get_locus ());
+ translated = Backend::named_type (dyn_str_type_str, type_record,
+ dyn->get_locus ());
return;
}
= TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);
if (type.is_mutable ())
{
- translated = ctx->get_backend ()->reference_type (base_compiled_type);
+ translated = Backend::reference_type (base_compiled_type);
}
else
{
- auto base = ctx->get_backend ()->immutable_type (base_compiled_type);
- translated = ctx->get_backend ()->reference_type (base);
+ auto base = Backend::immutable_type (base_compiled_type);
+ translated = Backend::reference_type (base);
}
}
= std::string (type.is_mutable () ? "*mut " : "*const ") + "["
+ slice->get_element_type ()->get_name () + "]";
- translated
- = ctx->get_backend ()->named_type (dyn_slice_type_str, type_record,
- slice->get_locus ());
+ translated = Backend::named_type (dyn_slice_type_str, type_record,
+ slice->get_locus ());
return;
}
std::string dyn_str_type_str
= std::string (type.is_mutable () ? "*mut " : "*const ") + "str";
- translated
- = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
- str->get_locus ());
+ translated = Backend::named_type (dyn_str_type_str, type_record,
+ str->get_locus ());
return;
}
= std::string (type.is_mutable () ? "*mut " : "*const ")
+ dyn->get_name ();
- translated
- = ctx->get_backend ()->named_type (dyn_str_type_str, type_record,
- dyn->get_locus ());
+ translated = Backend::named_type (dyn_str_type_str, type_record,
+ dyn->get_locus ());
return;
}
= TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);
if (type.is_mutable ())
{
- translated = ctx->get_backend ()->pointer_type (base_compiled_type);
+ translated = Backend::pointer_type (base_compiled_type);
}
else
{
- auto base = ctx->get_backend ()->immutable_type (base_compiled_type);
- translated = ctx->get_backend ()->pointer_type (base);
+ auto base = Backend::immutable_type (base_compiled_type);
+ translated = Backend::pointer_type (base);
}
}
TyTyResolveCompile::visit (const TyTy::StrType &type)
{
tree raw_str = create_str_type_record (type);
- translated
- = ctx->get_backend ()->named_type ("str", raw_str, BUILTINS_LOCATION);
+ translated = Backend::named_type ("str", raw_str, BUILTINS_LOCATION);
}
void
{
if (trait_object_mode)
{
- translated = ctx->get_backend ()->integer_type (
- true, ctx->get_backend ()->get_pointer_size ());
+ translated = Backend::integer_type (true, Backend::get_pointer_size ());
return;
}
tree type_record = create_dyn_obj_record (type);
- translated = ctx->get_backend ()->named_type (type.get_name (), type_record,
- type.get_ident ().locus);
+ translated = Backend::named_type (type.get_name (), type_record,
+ type.get_ident ().locus);
}
tree
auto items = type.get_object_items ();
std::vector<Backend::typed_identifier> fields;
- tree uint = ctx->get_backend ()->integer_type (
- true, ctx->get_backend ()->get_pointer_size ());
+ tree uint = Backend::integer_type (true, Backend::get_pointer_size ());
tree uintptr_ty = build_pointer_type (uint);
Backend::typed_identifier f ("pointer", uintptr_ty,
fields.push_back (std::move (f));
tree vtable_size = build_int_cst (size_type_node, items.size ());
- tree vtable_type = ctx->get_backend ()->array_type (uintptr_ty, vtable_size);
+ tree vtable_type = Backend::array_type (uintptr_ty, vtable_size);
Backend::typed_identifier vtf ("vtable", vtable_type,
ctx->get_mappings ()->lookup_location (
type.get_ty_ref ()));
fields.push_back (std::move (vtf));
- tree record = ctx->get_backend ()->struct_type (fields);
+ tree record = Backend::struct_type (fields);
RS_DST_FLAG (record) = 1;
TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
tree len_field_ty = TyTyResolveCompile::compile (ctx, usize);
Backend::typed_identifier len_field ("len", len_field_ty, type.get_locus ());
- tree record = ctx->get_backend ()->struct_type ({data_field, len_field});
+ tree record = Backend::struct_type ({data_field, len_field});
RS_DST_FLAG (record) = 1;
TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
tree len_field_ty = TyTyResolveCompile::compile (ctx, usize);
Backend::typed_identifier len_field ("len", len_field_ty, type.get_locus ());
- tree record = ctx->get_backend ()->struct_type ({data_field, len_field});
+ tree record = Backend::struct_type ({data_field, len_field});
RS_DST_FLAG (record) = 1;
TYPE_MAIN_VARIANT (record) = ctx->insert_main_variant (record);
void visit (HIR::IdentifierPattern &pattern) override
{
if (!pattern.is_mut ())
- translated_type = ctx->get_backend ()->immutable_type (translated_type);
+ translated_type = Backend::immutable_type (translated_type);
- Bvariable *var = ctx->get_backend ()->local_variable (
- fndecl, pattern.get_identifier ().as_string (), translated_type,
- NULL /*decl_var*/, pattern.get_locus ());
+ Bvariable *var
+ = Backend::local_variable (fndecl, pattern.get_identifier ().as_string (),
+ translated_type, NULL /*decl_var*/,
+ pattern.get_locus ());
HirId stmt_id = pattern.get_pattern_mappings ().get_hirid ();
ctx->insert_var_decl (stmt_id, var);
vtable_ctor_idx.push_back (i++);
}
- tree vtable_ctor = ctx->get_backend ()->array_constructor_expression (
- TREE_TYPE (vtable_field), vtable_ctor_idx, vtable_ctor_elems, locus);
+ tree vtable_ctor
+ = Backend::array_constructor_expression (TREE_TYPE (vtable_field),
+ vtable_ctor_idx, vtable_ctor_elems,
+ locus);
std::vector<tree> dyn_ctor = {address_of_compiled_ref, vtable_ctor};
- return ctx->get_backend ()->constructor_expression (dynamic_object, false,
- dyn_ctor, -1, locus);
+ return Backend::constructor_expression (dynamic_object, false, dyn_ctor, -1,
+ locus);
}
tree
// The backend interface. This is a pure abstract class that a
// specific backend will implement.
-class Backend
-{
-public:
- Backend ();
-
- // Name/type/location. Used for function parameters, struct fields,
- // interface methods.
- struct typed_identifier
- {
- std::string name;
- tree type;
- location_t location;
-
- typed_identifier () : name (), type (NULL_TREE), location (UNKNOWN_LOCATION)
- {}
-
- typed_identifier (const std::string &a_name, tree a_type,
- location_t a_location)
- : name (a_name), type (a_type), location (a_location)
- {}
- };
-
- // debug
- void debug (tree);
- void debug (Bvariable *);
-
- tree get_identifier_node (const std::string &str);
-
- // Types.
-
- // Get the wchar type
- tree wchar_type ();
-
- // Get the Host pointer size in bits
- int get_pointer_size ();
-
- // Get the raw str type const char*
- tree raw_str_type ();
-
- // Get an unnamed integer type with the given signedness and number
- // of bits.
- tree integer_type (bool is_unsigned, int bits);
-
- // Get an unnamed floating point type with the given number of bits
- // (32 or 64).
- tree float_type (int bits);
-
- // Get an unnamed complex type with the given number of bits (64 or 128).
- tree complex_type (int bits);
-
- // Get a pointer type.
- tree pointer_type (tree to_type);
-
- // Get a reference type.
- tree reference_type (tree to_type);
-
- // make type immutable
- tree immutable_type (tree base);
-
- // Get a function type. The receiver, parameter, and results are
- // generated from the types in the Function_type. The Function_type
- // is provided so that the names are available. This should return
- // not the type of a Go function (which is a pointer to a struct)
- // but the type of a C function pointer (which will be used as the
- // type of the first field of the struct). If there is more than
- // one result, RESULT_STRUCT is a struct type to hold the results,
- // and RESULTS may be ignored; if there are zero or one results,
- // RESULT_STRUCT is NULL.
- tree function_type (const typed_identifier &receiver,
- const std::vector<typed_identifier> ¶meters,
- const std::vector<typed_identifier> &results,
- tree result_struct, location_t location);
-
- tree function_type_varadic (const typed_identifier &receiver,
- const std::vector<typed_identifier> ¶meters,
- const std::vector<typed_identifier> &results,
- tree result_struct, location_t location);
+namespace Backend {
- tree function_ptr_type (tree result, const std::vector<tree> &praameters,
- location_t location);
+void
+init ();
- // Get a struct type.
- tree struct_type (const std::vector<typed_identifier> &fields);
-
- // Get a union type.
- tree union_type (const std::vector<typed_identifier> &fields);
-
- // Get an array type.
- tree array_type (tree element_type, tree length);
-
- // Return a named version of a type. The location is the location
- // of the type definition. This will not be called for a type
- // created via placeholder_pointer_type, placeholder_struct_type, or
- // placeholder_array_type.. (It may be called for a pointer,
- // struct, or array type in a case like "type P *byte; type Q P".)
- tree named_type (const std::string &name, tree, location_t);
-
- // Return the size of a type.
- int64_t type_size (tree);
-
- // Return the alignment of a type.
- int64_t type_alignment (tree);
-
- // Return the alignment of a struct field of this type. This is
- // normally the same as type_alignment, but not always.
- int64_t type_field_alignment (tree);
-
- // Return the offset of field INDEX in a struct type. INDEX is the
- // entry in the FIELDS std::vector parameter of struct_type or
- // set_placeholder_struct_type.
- int64_t type_field_offset (tree, size_t index);
-
- // Expressions.
-
- // Return an expression for a zero value of the given type. This is
- // used for cases such as local variable initialization and
- // converting nil to other types.
- tree zero_expression (tree);
-
- // Create a reference to a variable.
- tree var_expression (Bvariable *var, location_t);
-
- // Return an expression for the multi-precision integer VAL in BTYPE.
- tree integer_constant_expression (tree btype, mpz_t val);
-
- // Return an expression for the floating point value VAL in BTYPE.
- tree float_constant_expression (tree btype, mpfr_t val);
-
- // Return an expression for the complex value VAL in BTYPE.
- tree complex_constant_expression (tree btype, mpc_t val);
-
- // Return an expression for the string value VAL.
- tree string_constant_expression (const std::string &val);
-
- // Get a char literal
- tree char_constant_expression (char c);
-
- // Get a char literal
- tree wchar_constant_expression (wchar_t c);
-
- // Return an expression for the boolean value VAL.
- tree boolean_constant_expression (bool val);
-
- // Return an expression for the real part of BCOMPLEX.
- tree real_part_expression (tree bcomplex, location_t);
-
- // Return an expression for the imaginary part of BCOMPLEX.
- tree imag_part_expression (tree bcomplex, location_t);
+// Name/type/location. Used for function parameters, struct fields,
+// interface methods.
+struct typed_identifier
+{
+ std::string name;
+ tree type;
+ location_t location;
- // Return an expression for the complex number (BREAL, BIMAG).
- tree complex_expression (tree breal, tree bimag, location_t);
+ typed_identifier () : name (), type (NULL_TREE), location (UNKNOWN_LOCATION)
+ {}
- // Return an expression that converts EXPR to TYPE.
- tree convert_expression (tree type, tree expr, location_t);
-
- // Return an expression for the field at INDEX in BSTRUCT.
- tree struct_field_expression (tree bstruct, size_t index, location_t);
-
- // Create an expression that executes BSTAT before BEXPR.
- tree compound_expression (tree bstat, tree bexpr, location_t);
-
- // Return an expression that executes THEN_EXPR if CONDITION is true, or
- // ELSE_EXPR otherwise and returns the result as type BTYPE, within the
- // specified function FUNCTION. ELSE_EXPR may be NULL. BTYPE may be NULL.
- tree conditional_expression (tree function, tree btype, tree condition,
- tree then_expr, tree else_expr, location_t);
-
- // Return an expression for the negation operation OP EXPR.
- // Supported values of OP are enumerated in NegationOperator.
- tree negation_expression (NegationOperator op, tree expr, location_t);
-
- // Return an expression for the operation LEFT OP RIGHT.
- // Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
- tree arithmetic_or_logical_expression (ArithmeticOrLogicalOperator op,
- tree left, tree right, location_t loc);
-
- // Return an expression for the operation LEFT OP RIGHT.
- // Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
- // This function adds overflow checking and returns a list of statements to
- // add to the current function context. The `receiver` variable refers to the
- // variable which will contain the result of that operation.
- tree arithmetic_or_logical_expression_checked (ArithmeticOrLogicalOperator op,
- tree left, tree right,
- location_t loc,
- Bvariable *receiver);
-
- // Return an expression for the operation LEFT OP RIGHT.
- // Supported values of OP are enumerated in ComparisonOperator.
- tree comparison_expression (ComparisonOperator op, tree left, tree right,
- location_t loc);
-
- // Return an expression for the operation LEFT OP RIGHT.
- // Supported values of OP are enumerated in LazyBooleanOperator.
- tree lazy_boolean_expression (LazyBooleanOperator op, tree left, tree right,
- location_t);
-
- // Return an expression that constructs BTYPE with VALS. BTYPE must be the
- // backend representation a of struct. VALS must be in the same order as the
- // corresponding fields in BTYPE.
- tree constructor_expression (tree btype, bool is_variant,
- const std::vector<tree> &vals, int, location_t);
-
- // Return an expression that constructs an array of BTYPE with INDEXES and
- // VALS. INDEXES and VALS must have the same amount of elements. Each index
- // in INDEXES must be in the same order as the corresponding value in VALS.
- tree array_constructor_expression (tree btype,
- const std::vector<unsigned long> &indexes,
- const std::vector<tree> &vals, location_t);
-
- tree array_initializer (tree, tree, tree, tree, tree, tree *, location_t);
-
- // Return an expression for ARRAY[INDEX] as an l-value. ARRAY is a valid
- // fixed-length array, not a slice.
- tree array_index_expression (tree array, tree index, location_t);
-
- // Create an expression for a call to FN with ARGS, taking place within
- // caller CALLER.
- tree call_expression (tree fn, const std::vector<tree> &args,
- tree static_chain, location_t);
-
- // Statements.
-
- // Create a variable initialization statement in the specified
- // function. This initializes a local variable at the point in the
- // program flow where it is declared.
- tree init_statement (tree, Bvariable *var, tree init);
-
- // Create an assignment statement within the specified function.
- tree assignment_statement (tree lhs, tree rhs, location_t);
-
- // Create return statement for an decl for a value (can be NULL_TREE) at a
- // location
- tree return_statement (tree fndecl, tree val, location_t);
-
- // Create an if statement within a function. ELSE_BLOCK may be NULL.
- tree if_statement (tree, tree condition, tree then_block, tree else_block,
- location_t);
-
- // infinite loop expressions
- tree loop_expression (tree body, location_t);
-
- // exit expressions
- tree exit_expression (tree condition, location_t);
-
- // Create a single statement from two statements.
- tree compound_statement (tree, tree);
-
- // Create a single statement from a list of statements.
- tree statement_list (const std::vector<tree> &);
-
- // Create a statement that attempts to execute BSTAT and calls EXCEPT_STMT if
- // an exception occurs. EXCEPT_STMT may be NULL. FINALLY_STMT may be NULL and
- // if not NULL, it will always be executed. This is used for handling defers
- // in Go functions. In C++, the resulting code is of this form:
- // try { BSTAT; } catch { EXCEPT_STMT; } finally { FINALLY_STMT; }
- tree exception_handler_statement (tree bstat, tree except_stmt,
- tree finally_stmt, location_t);
-
- // Blocks.
-
- // Create a block. The frontend will call this function when it
- // starts converting a block within a function. FUNCTION is the
- // current function. ENCLOSING is the enclosing block; it will be
- // NULL for the top-level block in a function. VARS is the list of
- // local variables defined within this block; each entry will be
- // created by the local_variable function. START_LOCATION is the
- // location of the start of the block, more or less the location of
- // the initial curly brace. END_LOCATION is the location of the end
- // of the block, more or less the location of the final curly brace.
- // The statements will be added after the block is created.
- tree block (tree function, tree enclosing,
- const std::vector<Bvariable *> &vars, location_t start_location,
- location_t end_location);
-
- // Add the statements to a block. The block is created first. Then
- // the statements are created. Then the statements are added to the
- // block. This will called exactly once per block. The vector may
- // be empty if there are no statements.
- void block_add_statements (tree, const std::vector<tree> &);
-
- // Variables.
-
- // Create a global variable. NAME is the package-qualified name of
- // the variable. ASM_NAME is the encoded identifier for the
- // variable, incorporating the package, and made safe for the
- // assembler. BTYPE is the type of the variable. IS_EXTERNAL is
- // true if the variable is defined in some other package. IS_HIDDEN
- // is true if the variable is not exported (name begins with a lower
- // case letter). IN_UNIQUE_SECTION is true if the variable should
- // be put into a unique section if possible; this is intended to
- // permit the linker to garbage collect the variable if it is not
- // referenced. LOCATION is where the variable was defined.
- Bvariable *global_variable (const std::string &name,
- const std::string &asm_name, tree btype,
- bool is_external, bool is_hidden,
- bool in_unique_section, location_t location);
-
- // A global variable will 1) be initialized to zero, or 2) be
- // initialized to a constant value, or 3) be initialized in the init
- // function. In case 2, the frontend will call
- // global_variable_set_init to set the initial value. If this is
- // not called, the backend should initialize a global variable to 0.
- // The init function may then assign a value to it.
- void global_variable_set_init (Bvariable *, tree);
-
- // Create a local variable. The frontend will create the local
- // variables first, and then create the block which contains them.
- // FUNCTION is the function in which the variable is defined. NAME
- // is the name of the variable. TYPE is the type. DECL_VAR, if not
- // null, gives the location at which the value of this variable may
- // be found, typically used to create an inner-scope reference to an
- // outer-scope variable, to extend the lifetime of the variable beyond
- // the inner scope. IS_ADDRESS_TAKEN is true if the address of this
- // variable is taken (this implies that the address does not escape
- // the function, as otherwise the variable would be on the heap).
- // LOCATION is where the variable is defined. For each local variable
- // the frontend will call init_statement to set the initial value.
- Bvariable *local_variable (tree function, const std::string &name, tree type,
- Bvariable *decl_var, location_t location);
-
- // Create a function parameter. This is an incoming parameter, not
- // a result parameter (result parameters are treated as local
- // variables). The arguments are as for local_variable.
- Bvariable *parameter_variable (tree function, const std::string &name,
- tree type, location_t location);
-
- // Create a static chain parameter. This is the closure parameter.
- Bvariable *static_chain_variable (tree function, const std::string &name,
- tree type, location_t location);
-
- // Create a temporary variable. A temporary variable has no name,
- // just a type. We pass in FUNCTION and BLOCK in case they are
- // needed. If INIT is not NULL, the variable should be initialized
- // to that value. Otherwise the initial value is irrelevant--the
- // backend does not have to explicitly initialize it to zero.
- // ADDRESS_IS_TAKEN is true if the programs needs to take the
- // address of this temporary variable. LOCATION is the location of
- // the statement or expression which requires creating the temporary
- // variable, and may not be very useful. This function should
- // return a variable which can be referenced later and should set
- // *PSTATEMENT to a statement which initializes the variable.
- Bvariable *temporary_variable (tree fndecl, tree bind_tree, tree type,
- tree init, bool address_is_taken,
- location_t location, tree *pstatement);
-
- // Labels.
-
- // Create a new label. NAME will be empty if this is a label
- // created by the frontend for a loop construct. The location is
- // where the label is defined.
- tree label (tree, const std::string &name, location_t);
-
- // Create a statement which defines a label. This statement will be
- // put into the codestream at the point where the label should be
- // defined.
- tree label_definition_statement (tree);
-
- // Create a goto statement to a label.
- tree goto_statement (tree, location_t);
-
- // Create an expression for the address of a label. This is used to
- // get the return address of a deferred function which may call
- // recover.
- tree label_address (tree, location_t);
-
- // Functions.
-
- // Bit flags to pass to the function method.
-
- // Set if this is a function declaration rather than a definition;
- // the definition will be in another compilation unit.
- static const unsigned int function_is_declaration = 1 << 0;
-
- // Set if the function should never be inlined because they call
- // recover and must be visible for correct panic recovery.
- static const unsigned int function_is_uninlinable = 1 << 1;
-
- // Set if the function does not return. This is set for the
- // implementation of panic.
- static const unsigned int function_does_not_return = 1 << 2;
-
- // Set if the function should be put in a unique section if
- // possible. This is used for field tracking.
- static const unsigned int function_in_unique_section = 1 << 3;
-
- // Declare or define a function of FNTYPE.
- // NAME is the Go name of the function. ASM_NAME, if not the empty
- // string, is the name that should be used in the symbol table; this
- // will be non-empty if a magic extern comment is used. FLAGS is
- // bit flags described above.
- tree function (tree fntype, const std::string &name,
- const std::string &asm_name, unsigned int flags, location_t);
-
- // Create a statement that runs all deferred calls for FUNCTION. This should
- // be a statement that looks like this in C++:
- // finish:
- // try { DEFER_RETURN; } catch { CHECK_DEFER; goto finish; }
- tree function_defer_statement (tree function, tree undefer, tree check_defer,
- location_t);
-
- // Record PARAM_VARS as the variables to use for the parameters of FUNCTION.
- // This will only be called for a function definition. Returns true on
- // success, false on failure.
- bool function_set_parameters (tree function,
- const std::vector<Bvariable *> ¶m_vars);
-
- // Utility.
-
- // Write the definitions for all TYPE_DECLS, CONSTANT_DECLS,
- // FUNCTION_DECLS, and VARIABLE_DECLS declared globally.
- void
- write_global_definitions (const std::vector<tree> &type_decls,
- const std::vector<tree> &constant_decls,
- const std::vector<tree> &function_decls,
- const std::vector<Bvariable *> &variable_decls);
-
-protected:
- tree fill_in_fields (tree, const std::vector<typed_identifier> &);
-
- tree fill_in_array (tree, tree, tree);
-
- tree non_zero_size_type (tree);
-
- tree convert_tree (tree, tree, location_t);
+ typed_identifier (const std::string &a_name, tree a_type,
+ location_t a_location)
+ : name (a_name), type (a_type), location (a_location)
+ {}
};
+// debug
+void debug (tree);
+void
+debug (Bvariable *);
+
+tree
+get_identifier_node (const std::string &str);
+
+// Types.
+
+// Get the wchar type
+tree
+wchar_type ();
+
+// Get the Host pointer size in bits
+int
+get_pointer_size ();
+
+// Get the raw str type const char*
+tree
+raw_str_type ();
+
+// Get an unnamed integer type with the given signedness and number
+// of bits.
+tree
+integer_type (bool is_unsigned, int bits);
+
+// Get an unnamed floating point type with the given number of bits
+// (32 or 64).
+tree
+float_type (int bits);
+
+// Get an unnamed complex type with the given number of bits (64 or 128).
+tree
+complex_type (int bits);
+
+// Get a pointer type.
+tree
+pointer_type (tree to_type);
+
+// Get a reference type.
+tree
+reference_type (tree to_type);
+
+// make type immutable
+tree
+immutable_type (tree base);
+
+// Get a function type. The receiver, parameter, and results are
+// generated from the types in the Function_type. The Function_type
+// is provided so that the names are available. This should return
+// not the type of a Go function (which is a pointer to a struct)
+// but the type of a C function pointer (which will be used as the
+// type of the first field of the struct). If there is more than
+// one result, RESULT_STRUCT is a struct type to hold the results,
+// and RESULTS may be ignored; if there are zero or one results,
+// RESULT_STRUCT is NULL.
+tree
+function_type (const typed_identifier &receiver,
+ const std::vector<typed_identifier> ¶meters,
+ const std::vector<typed_identifier> &results, tree result_struct,
+ location_t location);
+
+tree
+function_type_varadic (const typed_identifier &receiver,
+ const std::vector<typed_identifier> ¶meters,
+ const std::vector<typed_identifier> &results,
+ tree result_struct, location_t location);
+
+tree
+function_ptr_type (tree result, const std::vector<tree> &praameters,
+ location_t location);
+
+// Get a struct type.
+tree
+struct_type (const std::vector<typed_identifier> &fields);
+
+// Get a union type.
+tree
+union_type (const std::vector<typed_identifier> &fields);
+
+// Get an array type.
+tree
+array_type (tree element_type, tree length);
+
+// Return a named version of a type. The location is the location
+// of the type definition. This will not be called for a type
+// created via placeholder_pointer_type, placeholder_struct_type, or
+// placeholder_array_type.. (It may be called for a pointer,
+// struct, or array type in a case like "type P *byte; type Q P".)
+tree
+named_type (const std::string &name, tree, location_t);
+
+// Return the size of a type.
+int64_t type_size (tree);
+
+// Return the alignment of a type.
+int64_t type_alignment (tree);
+
+// Return the alignment of a struct field of this type. This is
+// normally the same as type_alignment, but not always.
+int64_t type_field_alignment (tree);
+
+// Return the offset of field INDEX in a struct type. INDEX is the
+// entry in the FIELDS std::vector parameter of struct_type or
+// set_placeholder_struct_type.
+int64_t
+type_field_offset (tree, size_t index);
+
+// Expressions.
+
+// Return an expression for a zero value of the given type. This is
+// used for cases such as local variable initialization and
+// converting nil to other types.
+tree zero_expression (tree);
+
+// Create a reference to a variable.
+tree
+var_expression (Bvariable *var, location_t);
+
+// Return an expression for the multi-precision integer VAL in BTYPE.
+tree
+integer_constant_expression (tree btype, mpz_t val);
+
+// Return an expression for the floating point value VAL in BTYPE.
+tree
+float_constant_expression (tree btype, mpfr_t val);
+
+// Return an expression for the complex value VAL in BTYPE.
+tree
+complex_constant_expression (tree btype, mpc_t val);
+
+// Return an expression for the string value VAL.
+tree
+string_constant_expression (const std::string &val);
+
+// Get a char literal
+tree
+char_constant_expression (char c);
+
+// Get a char literal
+tree
+wchar_constant_expression (wchar_t c);
+
+// Return an expression for the boolean value VAL.
+tree
+boolean_constant_expression (bool val);
+
+// Return an expression for the real part of BCOMPLEX.
+tree
+real_part_expression (tree bcomplex, location_t);
+
+// Return an expression for the imaginary part of BCOMPLEX.
+tree
+imag_part_expression (tree bcomplex, location_t);
+
+// Return an expression for the complex number (BREAL, BIMAG).
+tree
+complex_expression (tree breal, tree bimag, location_t);
+
+// Return an expression that converts EXPR to TYPE.
+tree
+convert_expression (tree type, tree expr, location_t);
+
+// Return an expression for the field at INDEX in BSTRUCT.
+tree
+struct_field_expression (tree bstruct, size_t index, location_t);
+
+// Create an expression that executes BSTAT before BEXPR.
+tree
+compound_expression (tree bstat, tree bexpr, location_t);
+
+// Return an expression that executes THEN_EXPR if CONDITION is true, or
+// ELSE_EXPR otherwise and returns the result as type BTYPE, within the
+// specified function FUNCTION. ELSE_EXPR may be NULL. BTYPE may be NULL.
+tree
+conditional_expression (tree function, tree btype, tree condition,
+ tree then_expr, tree else_expr, location_t);
+
+// Return an expression for the negation operation OP EXPR.
+// Supported values of OP are enumerated in NegationOperator.
+tree
+negation_expression (NegationOperator op, tree expr, location_t);
+
+// Return an expression for the operation LEFT OP RIGHT.
+// Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
+tree
+arithmetic_or_logical_expression (ArithmeticOrLogicalOperator op, tree left,
+ tree right, location_t loc);
+
+// Return an expression for the operation LEFT OP RIGHT.
+// Supported values of OP are enumerated in ArithmeticOrLogicalOperator.
+// This function adds overflow checking and returns a list of statements to
+// add to the current function context. The `receiver` variable refers to the
+// variable which will contain the result of that operation.
+tree
+arithmetic_or_logical_expression_checked (ArithmeticOrLogicalOperator op,
+ tree left, tree right, location_t loc,
+ Bvariable *receiver);
+
+// Return an expression for the operation LEFT OP RIGHT.
+// Supported values of OP are enumerated in ComparisonOperator.
+tree
+comparison_expression (ComparisonOperator op, tree left, tree right,
+ location_t loc);
+
+// Return an expression for the operation LEFT OP RIGHT.
+// Supported values of OP are enumerated in LazyBooleanOperator.
+tree
+lazy_boolean_expression (LazyBooleanOperator op, tree left, tree right,
+ location_t);
+
+// Return an expression that constructs BTYPE with VALS. BTYPE must be the
+// backend representation a of struct. VALS must be in the same order as the
+// corresponding fields in BTYPE.
+tree
+constructor_expression (tree btype, bool is_variant,
+ const std::vector<tree> &vals, int, location_t);
+
+// Return an expression that constructs an array of BTYPE with INDEXES and
+// VALS. INDEXES and VALS must have the same amount of elements. Each index
+// in INDEXES must be in the same order as the corresponding value in VALS.
+tree
+array_constructor_expression (tree btype,
+ const std::vector<unsigned long> &indexes,
+ const std::vector<tree> &vals, location_t);
+
+tree
+array_initializer (tree, tree, tree, tree, tree, tree *, location_t);
+
+// Return an expression for ARRAY[INDEX] as an l-value. ARRAY is a valid
+// fixed-length array, not a slice.
+tree
+array_index_expression (tree array, tree index, location_t);
+
+// Create an expression for a call to FN with ARGS, taking place within
+// caller CALLER.
+tree
+call_expression (tree fn, const std::vector<tree> &args, tree static_chain,
+ location_t);
+
+// Statements.
+
+// Create a variable initialization statement in the specified
+// function. This initializes a local variable at the point in the
+// program flow where it is declared.
+tree
+init_statement (tree, Bvariable *var, tree init);
+
+// Create an assignment statement within the specified function.
+tree
+assignment_statement (tree lhs, tree rhs, location_t);
+
+// Create return statement for an decl for a value (can be NULL_TREE) at a
+// location
+tree
+return_statement (tree fndecl, tree val, location_t);
+
+// Create an if statement within a function. ELSE_BLOCK may be NULL.
+tree
+if_statement (tree, tree condition, tree then_block, tree else_block,
+ location_t);
+
+// infinite loop expressions
+tree
+loop_expression (tree body, location_t);
+
+// exit expressions
+tree
+exit_expression (tree condition, location_t);
+
+// Create a single statement from two statements.
+tree compound_statement (tree, tree);
+
+// Create a single statement from a list of statements.
+tree
+statement_list (const std::vector<tree> &);
+
+// Create a statement that attempts to execute BSTAT and calls EXCEPT_STMT if
+// an exception occurs. EXCEPT_STMT may be NULL. FINALLY_STMT may be NULL and
+// if not NULL, it will always be executed. This is used for handling defers
+// in Go functions. In C++, the resulting code is of this form:
+// try { BSTAT; } catch { EXCEPT_STMT; } finally { FINALLY_STMT; }
+tree
+exception_handler_statement (tree bstat, tree except_stmt, tree finally_stmt,
+ location_t);
+
+// Blocks.
+
+// Create a block. The frontend will call this function when it
+// starts converting a block within a function. FUNCTION is the
+// current function. ENCLOSING is the enclosing block; it will be
+// NULL for the top-level block in a function. VARS is the list of
+// local variables defined within this block; each entry will be
+// created by the local_variable function. START_LOCATION is the
+// location of the start of the block, more or less the location of
+// the initial curly brace. END_LOCATION is the location of the end
+// of the block, more or less the location of the final curly brace.
+// The statements will be added after the block is created.
+tree
+block (tree function, tree enclosing, const std::vector<Bvariable *> &vars,
+ location_t start_location, location_t end_location);
+
+// Add the statements to a block. The block is created first. Then
+// the statements are created. Then the statements are added to the
+// block. This will called exactly once per block. The vector may
+// be empty if there are no statements.
+void
+block_add_statements (tree, const std::vector<tree> &);
+
+// Variables.
+
+// Create a global variable. NAME is the package-qualified name of
+// the variable. ASM_NAME is the encoded identifier for the
+// variable, incorporating the package, and made safe for the
+// assembler. BTYPE is the type of the variable. IS_EXTERNAL is
+// true if the variable is defined in some other package. IS_HIDDEN
+// is true if the variable is not exported (name begins with a lower
+// case letter). IN_UNIQUE_SECTION is true if the variable should
+// be put into a unique section if possible; this is intended to
+// permit the linker to garbage collect the variable if it is not
+// referenced. LOCATION is where the variable was defined.
+Bvariable *
+global_variable (const std::string &name, const std::string &asm_name,
+ tree btype, bool is_external, bool is_hidden,
+ bool in_unique_section, location_t location);
+
+// A global variable will 1) be initialized to zero, or 2) be
+// initialized to a constant value, or 3) be initialized in the init
+// function. In case 2, the frontend will call
+// global_variable_set_init to set the initial value. If this is
+// not called, the backend should initialize a global variable to 0.
+// The init function may then assign a value to it.
+void
+global_variable_set_init (Bvariable *, tree);
+
+// Create a local variable. The frontend will create the local
+// variables first, and then create the block which contains them.
+// FUNCTION is the function in which the variable is defined. NAME
+// is the name of the variable. TYPE is the type. DECL_VAR, if not
+// null, gives the location at which the value of this variable may
+// be found, typically used to create an inner-scope reference to an
+// outer-scope variable, to extend the lifetime of the variable beyond
+// the inner scope. IS_ADDRESS_TAKEN is true if the address of this
+// variable is taken (this implies that the address does not escape
+// the function, as otherwise the variable would be on the heap).
+// LOCATION is where the variable is defined. For each local variable
+// the frontend will call init_statement to set the initial value.
+Bvariable *
+local_variable (tree function, const std::string &name, tree type,
+ Bvariable *decl_var, location_t location);
+
+// Create a function parameter. This is an incoming parameter, not
+// a result parameter (result parameters are treated as local
+// variables). The arguments are as for local_variable.
+Bvariable *
+parameter_variable (tree function, const std::string &name, tree type,
+ location_t location);
+
+// Create a static chain parameter. This is the closure parameter.
+Bvariable *
+static_chain_variable (tree function, const std::string &name, tree type,
+ location_t location);
+
+// Create a temporary variable. A temporary variable has no name,
+// just a type. We pass in FUNCTION and BLOCK in case they are
+// needed. If INIT is not NULL, the variable should be initialized
+// to that value. Otherwise the initial value is irrelevant--the
+// backend does not have to explicitly initialize it to zero.
+// ADDRESS_IS_TAKEN is true if the programs needs to take the
+// address of this temporary variable. LOCATION is the location of
+// the statement or expression which requires creating the temporary
+// variable, and may not be very useful. This function should
+// return a variable which can be referenced later and should set
+// *PSTATEMENT to a statement which initializes the variable.
+Bvariable *
+temporary_variable (tree fndecl, tree bind_tree, tree type, tree init,
+ bool address_is_taken, location_t location,
+ tree *pstatement);
+
+// Labels.
+
+// Create a new label. NAME will be empty if this is a label
+// created by the frontend for a loop construct. The location is
+// where the label is defined.
+tree
+label (tree, const std::string &name, location_t);
+
+// Create a statement which defines a label. This statement will be
+// put into the codestream at the point where the label should be
+// defined.
+tree label_definition_statement (tree);
+
+// Create a goto statement to a label.
+tree goto_statement (tree, location_t);
+
+// Create an expression for the address of a label. This is used to
+// get the return address of a deferred function which may call
+// recover.
+tree label_address (tree, location_t);
+
+// Functions.
+
+// Bit flags to pass to the function method.
+
+// Set if this is a function declaration rather than a definition;
+// the definition will be in another compilation unit.
+static const unsigned int function_is_declaration = 1 << 0;
+
+// Set if the function should never be inlined because they call
+// recover and must be visible for correct panic recovery.
+static const unsigned int function_is_uninlinable = 1 << 1;
+
+// Set if the function does not return. This is set for the
+// implementation of panic.
+static const unsigned int function_does_not_return = 1 << 2;
+
+// Set if the function should be put in a unique section if
+// possible. This is used for field tracking.
+static const unsigned int function_in_unique_section = 1 << 3;
+
+// Declare or define a function of FNTYPE.
+// NAME is the Go name of the function. ASM_NAME, if not the empty
+// string, is the name that should be used in the symbol table; this
+// will be non-empty if a magic extern comment is used. FLAGS is
+// bit flags described above.
+tree
+function (tree fntype, const std::string &name, const std::string &asm_name,
+ unsigned int flags, location_t);
+
+// Create a statement that runs all deferred calls for FUNCTION. This should
+// be a statement that looks like this in C++:
+// finish:
+// try { DEFER_RETURN; } catch { CHECK_DEFER; goto finish; }
+tree
+function_defer_statement (tree function, tree undefer, tree check_defer,
+ location_t);
+
+// Record PARAM_VARS as the variables to use for the parameters of FUNCTION.
+// This will only be called for a function definition. Returns true on
+// success, false on failure.
+bool
+function_set_parameters (tree function,
+ const std::vector<Bvariable *> ¶m_vars);
+
+// Utility.
+
+// Write the definitions for all TYPE_DECLS, CONSTANT_DECLS,
+// FUNCTION_DECLS, and VARIABLE_DECLS declared globally.
+void
+write_global_definitions (const std::vector<tree> &type_decls,
+ const std::vector<tree> &constant_decls,
+ const std::vector<tree> &function_decls,
+ const std::vector<Bvariable *> &variable_decls);
+
+// TODO: make static
+
+tree
+fill_in_fields (tree, const std::vector<typed_identifier> &);
+
+tree fill_in_array (tree, tree, tree);
+
+tree non_zero_size_type (tree);
+
+tree convert_tree (tree, tree, location_t);
+
+} // namespace Backend
+
#endif // RUST_BACKEND_H
// Define the built-in functions that are exposed to GCCRust.
-Backend::Backend ()
+void
+Backend::init ()
{
/* We need to define the fetch_and_add functions, since we use them
for ++ and --. */
delete[] defs;
}
-
-// Return the backend generator.
-
-Backend *
-rust_get_backend ()
-{
- return new Backend ();
-}
extern Linemap *
rust_get_linemap ();
-extern Backend *
-rust_get_backend ();
-
namespace Rust {
const char *kLexDumpFile = "gccrs.lex.dump";
linemap = rust_get_linemap ();
// setup backend to GCC GIMPLE
- backend = rust_get_backend ();
+ Backend::init ();
// setup mappings class
mappings = Analysis::Mappings::get ();
return;
// do compile to gcc generic
- Compile::Context ctx (backend);
+ Compile::Context ctx;
Compile::CompileCrate::Compile (hir, &ctx);
// we can't do static analysis if there are errors to worry about
* expansion) */
std::vector<std::string> extra_files;
- // backend wrapper to GCC GENERIC
- Backend *backend;
-
// backend linemap
Linemap *linemap;
projects / thirdparty / gcc.git / commitdiff
