This patch by Chris Manghane change the Go frontend to move the handling
of indirecting through recursive pointer types to the backend.
Bootstrapped and ran Go testsuite on x86_64-unknown-linux-gnu.
Committed to mainline.
Ian
2014-05-05 Chris Manghane <cm...@google.com>
* go-gcc.cc (Gcc_backend::indirect_expression): Add btype
parameter.
(Gcc_backend::temporary_variable): Check for erroneous function.
Index: gcc/go/go-gcc.cc
===================================================================
--- gcc/go/go-gcc.cc (revision 209941)
+++ gcc/go/go-gcc.cc (working copy)
@@ -229,7 +229,7 @@ class Gcc_backend : public Backend
var_expression(Bvariable* var, Location);
Bexpression*
- indirect_expression(Bexpression* expr, bool known_valid, Location);
+ indirect_expression(Btype*, Bexpression* expr, bool known_valid, Location);
Bexpression*
named_constant_expression(Btype* btype, const std::string& name,
@@ -1147,14 +1147,26 @@ Gcc_backend::var_expression(Bvariable* v
// An expression that indirectly references an expression.
Bexpression*
-Gcc_backend::indirect_expression(Bexpression* expr, bool known_valid,
- Location location)
+Gcc_backend::indirect_expression(Btype* btype, Bexpression* expr,
+ bool known_valid, Location location)
{
+ tree expr_tree = expr->get_tree();
+ tree type_tree = btype->get_tree();
+ if (expr_tree == error_mark_node || type_tree == error_mark_node)
+ return this->error_expression();
+
+ // If the type of EXPR is a recursive pointer type, then we
+ // need to insert a cast before indirecting.
+ tree target_type_tree = TREE_TYPE(TREE_TYPE(expr_tree));
+ if (VOID_TYPE_P(target_type_tree))
+ expr_tree = fold_convert_loc(location.gcc_location(),
+ build_pointer_type(type_tree), expr_tree);
+
tree ret = build_fold_indirect_ref_loc(location.gcc_location(),
- expr->get_tree());
+ expr_tree);
if (known_valid)
TREE_THIS_NOTRAP(ret) = 1;
- return tree_to_expr(ret);
+ return this->make_expression(ret);
}
// Return an expression that declares a constant named NAME with the
@@ -2406,17 +2418,18 @@ Gcc_backend::temporary_variable(Bfunctio
Location location,
Bstatement** pstatement)
{
+ gcc_assert(function != NULL);
+ tree decl = function->get_tree();
tree type_tree = btype->get_tree();
tree init_tree = binit == NULL ? NULL_TREE : binit->get_tree();
- if (type_tree == error_mark_node || init_tree == error_mark_node)
+ if (type_tree == error_mark_node
+ || init_tree == error_mark_node
+ || decl == error_mark_node)
{
*pstatement = this->error_statement();
return this->error_variable();
}
- gcc_assert(function != NULL);
- tree decl = function->get_tree();
-
tree var;
// We can only use create_tmp_var if the type is not addressable.
if (!TREE_ADDRESSABLE(type_tree))
Index: gcc/go/gofrontend/gogo.cc
===================================================================
--- gcc/go/gofrontend/gogo.cc (revision 209983)
+++ gcc/go/gofrontend/gogo.cc (working copy)
@@ -5210,7 +5210,10 @@ Function::return_value(Gogo* gogo, Named
Bvariable* bvar = no->get_backend_variable(gogo, named_function);
Bexpression* val = gogo->backend()->var_expression(bvar, location);
if (no->result_var_value()->is_in_heap())
- val = gogo->backend()->indirect_expression(val, true, location);
+ {
+ Btype* bt = no->result_var_value()->type()->get_backend(gogo);
+ val = gogo->backend()->indirect_expression(bt, val, true, location);
+ }
vals[i] = val;
}
return gogo->backend()->return_statement(this->fndecl_, vals, location);
Index: gcc/go/gofrontend/expressions.cc
===================================================================
--- gcc/go/gofrontend/expressions.cc (revision 210084)
+++ gcc/go/gofrontend/expressions.cc (working copy)
@@ -760,16 +760,24 @@ Var_expression::do_get_tree(Translate_co
context->function());
bool is_in_heap;
Location loc = this->location();
+ Btype* btype;
+ Gogo* gogo = context->gogo();
if (this->variable_->is_variable())
- is_in_heap = this->variable_->var_value()->is_in_heap();
+ {
+ is_in_heap = this->variable_->var_value()->is_in_heap();
+ btype = this->variable_->var_value()->type()->get_backend(gogo);
+ }
else if (this->variable_->is_result_variable())
- is_in_heap = this->variable_->result_var_value()->is_in_heap();
+ {
+ is_in_heap = this->variable_->result_var_value()->is_in_heap();
+ btype = this->variable_->result_var_value()->type()->get_backend(gogo);
+ }
else
go_unreachable();
Bexpression* ret = context->backend()->var_expression(bvar, loc);
if (is_in_heap)
- ret = context->backend()->indirect_expression(ret, true, loc);
+ ret = context->backend()->indirect_expression(btype, ret, true, loc);
return expr_to_tree(ret);
}
@@ -4168,20 +4176,7 @@ Unary_expression::do_get_tree(Translate_
}
}
-
- // If the type of EXPR is a recursive pointer type, then we
- // need to insert a cast before indirecting.
- tree expr = expr_to_tree(bexpr);
- tree target_type_tree = TREE_TYPE(TREE_TYPE(expr));
- if (VOID_TYPE_P(target_type_tree))
- {
- tree ind = type_to_tree(pbtype);
- expr = fold_convert_loc(loc.gcc_location(),
- build_pointer_type(ind), expr);
- bexpr = tree_to_expr(expr);
- }
-
- ret = gogo->backend()->indirect_expression(bexpr, false, loc);
+ ret = gogo->backend()->indirect_expression(pbtype, bexpr, false, loc);
}
break;
@@ -10329,7 +10324,10 @@ Array_index_expression::do_get_tree(Tran
array_type->get_value_pointer(gogo, this->array_);
Bexpression* ptr = tree_to_expr(valptr->get_tree(context));
ptr = gogo->backend()->pointer_offset_expression(ptr, start, loc);
- ret = gogo->backend()->indirect_expression(ptr, true, loc);
+
+ Type* ele_type = this->array_->type()->array_type()->element_type();
+ Btype* ele_btype = ele_type->get_backend(gogo);
+ ret = gogo->backend()->indirect_expression(ele_btype, ptr, true, loc);
}
return expr_to_tree(ret);
}
@@ -10667,7 +10665,9 @@ String_index_expression::do_get_tree(Tra
Bexpression* bstart = tree_to_expr(start->get_tree(context));
Bexpression* ptr = tree_to_expr(bytes->get_tree(context));
ptr = gogo->backend()->pointer_offset_expression(ptr, bstart, loc);
- Bexpression* index = gogo->backend()->indirect_expression(ptr, true, loc);
+ Btype* ubtype = Type::lookup_integer_type("uint8")->get_backend(gogo);
+ Bexpression* index =
+ gogo->backend()->indirect_expression(ubtype, ptr, true, loc);
Btype* byte_btype = bytes->type()->points_to()->get_backend(gogo);
Bexpression* index_error = tree_to_expr(bad_index->get_tree(context));
@@ -13816,7 +13816,9 @@ Heap_expression::do_get_tree(Translate_c
gogo->backend()->temporary_variable(fndecl, context->bblock(), btype,
space, true, loc, &decl);
space = gogo->backend()->var_expression(space_temp, loc);
- Bexpression* ref = gogo->backend()->indirect_expression(space, true, loc);
+ Btype* expr_btype = this->expr_->type()->get_backend(gogo);
+ Bexpression* ref =
+ gogo->backend()->indirect_expression(expr_btype, space, true, loc);
Bexpression* bexpr = tree_to_expr(this->expr_->get_tree(context));
Bstatement* assn = gogo->backend()->assignment_statement(ref, bexpr, loc);
Index: gcc/go/gofrontend/backend.h
===================================================================
--- gcc/go/gofrontend/backend.h (revision 209941)
+++ gcc/go/gofrontend/backend.h (working copy)
@@ -253,9 +253,11 @@ class Backend
// Create an expression that indirects through the pointer expression EXPR
// (i.e., return the expression for *EXPR). KNOWN_VALID is true if the pointer
- // is known to point to a valid memory location.
+ // is known to point to a valid memory location. BTYPE is the expected type
+ // of the indirected EXPR.
virtual Bexpression*
- indirect_expression(Bexpression* expr, bool known_valid, Location) = 0;
+ indirect_expression(Btype* btype, Bexpression* expr, bool known_valid,
+ Location) = 0;
// Return an expression that declares a constant named NAME with the
// constant value VAL in BTYPE.
