Merge trunk into branch, part one.
[[Split portion of a mixed commit.]]
From-SVN: r174658.2
--- /dev/null
+// expressions.cc -- Go frontend expression handling.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "convert.h"
+#include "real.h"
+#include "realmpfr.h"
+#include "tm.h"
+#include "tm_p.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "types.h"
+#include "export.h"
+#include "import.h"
+#include "statements.h"
+#include "lex.h"
+#include "expressions.h"
+
+// Class Expression.
+
+Expression::Expression(Expression_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Expression::~Expression()
+{
+}
+
+// If this expression has a constant integer value, return it.
+
+bool
+Expression::integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ return this->do_integer_constant_value(iota_is_constant, val, ptype);
+}
+
+// If this expression has a constant floating point value, return it.
+
+bool
+Expression::float_constant_value(mpfr_t val, Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_float_constant_value(val, ptype))
+ return true;
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ bool ret;
+ if (!this->do_integer_constant_value(false, ival, &t))
+ ret = false;
+ else
+ {
+ mpfr_set_z(val, ival, GMP_RNDN);
+ ret = true;
+ }
+ mpz_clear(ival);
+ return ret;
+}
+
+// If this expression has a constant complex value, return it.
+
+bool
+Expression::complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_complex_constant_value(real, imag, ptype))
+ return true;
+ Type *t;
+ if (this->float_constant_value(real, &t))
+ {
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+ return false;
+}
+
+// Traverse the expressions.
+
+int
+Expression::traverse(Expression** pexpr, Traverse* traverse)
+{
+ Expression* expr = *pexpr;
+ if ((traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
+ {
+ int t = traverse->expression(pexpr);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ return expr->do_traverse(traverse);
+}
+
+// Traverse subexpressions of this expression.
+
+int
+Expression::traverse_subexpressions(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Default implementation for do_traverse for child classes.
+
+int
+Expression::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// This virtual function is called by the parser if the value of this
+// expression is being discarded. By default, we warn. Expressions
+// with side effects override.
+
+void
+Expression::do_discarding_value()
+{
+ this->warn_about_unused_value();
+}
+
+// This virtual function is called to export expressions. This will
+// only be used by expressions which may be constant.
+
+void
+Expression::do_export(Export*) const
+{
+ gcc_unreachable();
+}
+
+// Warn that the value of the expression is not used.
+
+void
+Expression::warn_about_unused_value()
+{
+ warning_at(this->location(), OPT_Wunused_value, "value computed is not used");
+}
+
+// Note that this expression is an error. This is called by children
+// when they discover an error.
+
+void
+Expression::set_is_error()
+{
+ this->classification_ = EXPRESSION_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Expression::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// Set types of variables and constants. This is implemented by the
+// child class.
+
+void
+Expression::determine_type(const Type_context* context)
+{
+ this->do_determine_type(context);
+}
+
+// Set types when there is no context.
+
+void
+Expression::determine_type_no_context()
+{
+ Type_context context;
+ this->do_determine_type(&context);
+}
+
+// Return a tree handling any conversions which must be done during
+// assignment.
+
+tree
+Expression::convert_for_assignment(Translate_context* context, Type* lhs_type,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ if (lhs_type == rhs_type)
+ return rhs_tree;
+
+ if (lhs_type->is_error_type() || rhs_type->is_error_type())
+ return error_mark_node;
+
+ if (lhs_type->is_undefined() || rhs_type->is_undefined())
+ {
+ // Make sure we report the error.
+ lhs_type->base();
+ rhs_type->base();
+ return error_mark_node;
+ }
+
+ if (rhs_tree == error_mark_node || TREE_TYPE(rhs_tree) == error_mark_node)
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ if (lhs_type->interface_type() != NULL)
+ {
+ if (rhs_type->interface_type() == NULL)
+ return Expression::convert_type_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ location);
+ else
+ return Expression::convert_interface_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ false, location);
+ }
+ else if (rhs_type->interface_type() != NULL)
+ return Expression::convert_interface_to_type(context, lhs_type, rhs_type,
+ rhs_tree, location);
+ else if (lhs_type->is_open_array_type()
+ && rhs_type->is_nil_type())
+ {
+ // Assigning nil to an open array.
+ gcc_assert(TREE_CODE(lhs_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ tree val = build_constructor(lhs_type_tree, init);
+ TREE_CONSTANT(val) = 1;
+
+ return val;
+ }
+ else if (rhs_type->is_nil_type())
+ {
+ // The left hand side should be a pointer type at the tree
+ // level.
+ gcc_assert(POINTER_TYPE_P(lhs_type_tree));
+ return fold_convert(lhs_type_tree, null_pointer_node);
+ }
+ else if (lhs_type_tree == TREE_TYPE(rhs_tree))
+ {
+ // No conversion is needed.
+ return rhs_tree;
+ }
+ else if (POINTER_TYPE_P(lhs_type_tree)
+ || INTEGRAL_TYPE_P(lhs_type_tree)
+ || SCALAR_FLOAT_TYPE_P(lhs_type_tree)
+ || COMPLEX_FLOAT_TYPE_P(lhs_type_tree))
+ return fold_convert_loc(location, lhs_type_tree, rhs_tree);
+ else if (TREE_CODE(lhs_type_tree) == RECORD_TYPE
+ && TREE_CODE(TREE_TYPE(rhs_tree)) == RECORD_TYPE)
+ {
+ // This conversion must be permitted by Go, or we wouldn't have
+ // gotten here.
+ gcc_assert(int_size_in_bytes(lhs_type_tree)
+ == int_size_in_bytes(TREE_TYPE(rhs_tree)));
+ return fold_build1_loc(location, VIEW_CONVERT_EXPR, lhs_type_tree,
+ rhs_tree);
+ }
+ else
+ {
+ gcc_assert(useless_type_conversion_p(lhs_type_tree, TREE_TYPE(rhs_tree)));
+ return rhs_tree;
+ }
+}
+
+// Return a tree for a conversion from a non-interface type to an
+// interface type.
+
+tree
+Expression::convert_type_to_interface(Translate_context* context,
+ Type* lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ // Since RHS_TYPE is a static type, we can create the interface
+ // method table at compile time.
+
+ // When setting an interface to nil, we just set both fields to
+ // NULL.
+ if (rhs_type->is_nil_type())
+ return lhs_type->get_init_tree(gogo, false);
+
+ // This should have been checked already.
+ gcc_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // An interface is a tuple. If LHS_TYPE is an empty interface type,
+ // then the first field is the type descriptor for RHS_TYPE.
+ // Otherwise it is the interface method table for RHS_TYPE.
+ tree first_field_value;
+ if (lhs_is_empty)
+ first_field_value = rhs_type->type_descriptor_pointer(gogo);
+ else
+ {
+ // Build the interface method table for this interface and this
+ // object type: a list of function pointers for each interface
+ // method.
+ Named_type* rhs_named_type = rhs_type->named_type();
+ bool is_pointer = false;
+ if (rhs_named_type == NULL)
+ {
+ rhs_named_type = rhs_type->deref()->named_type();
+ is_pointer = true;
+ }
+ tree method_table;
+ if (rhs_named_type == NULL)
+ method_table = null_pointer_node;
+ else
+ method_table =
+ rhs_named_type->interface_method_table(gogo, lhs_interface_type,
+ is_pointer);
+ first_field_value = fold_convert_loc(location, const_ptr_type_node,
+ method_table);
+ }
+
+ // Start building a constructor for the value we will return.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ (lhs_is_empty ? "__type_descriptor" : "__methods")) == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), first_field_value);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ if (rhs_type->points_to() != NULL)
+ {
+ // We are assigning a pointer to the interface; the interface
+ // holds the pointer itself.
+ elt->value = rhs_tree;
+ return build_constructor(lhs_type_tree, init);
+ }
+
+ // We are assigning a non-pointer value to the interface; the
+ // interface gets a copy of the value in the heap.
+
+ tree object_size = TYPE_SIZE_UNIT(TREE_TYPE(rhs_tree));
+
+ tree space = gogo->allocate_memory(rhs_type, object_size, location);
+ space = fold_convert_loc(location, build_pointer_type(TREE_TYPE(rhs_tree)),
+ space);
+ space = save_expr(space);
+
+ tree ref = build_fold_indirect_ref_loc(location, space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ ref, rhs_tree);
+
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), space);
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, set,
+ build_constructor(lhs_type_tree, init));
+}
+
+// Return a tree for the type descriptor of RHS_TREE, which has
+// interface type RHS_TYPE. If RHS_TREE is nil the result will be
+// NULL.
+
+tree
+Expression::get_interface_type_descriptor(Translate_context*,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = TYPE_FIELDS(rhs_type_tree);
+ tree v = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+ if (rhs_type->interface_type()->is_empty())
+ {
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)),
+ "__type_descriptor") == 0);
+ return v;
+ }
+
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__methods")
+ == 0);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(v)));
+ v = save_expr(v);
+ tree v1 = build_fold_indirect_ref_loc(location, v);
+ gcc_assert(TREE_CODE(TREE_TYPE(v1)) == RECORD_TYPE);
+ tree f = TYPE_FIELDS(TREE_TYPE(v1));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(f)), "__type_descriptor")
+ == 0);
+ v1 = build3(COMPONENT_REF, TREE_TYPE(f), v1, f, NULL_TREE);
+
+ tree eq = fold_build2_loc(location, EQ_EXPR, boolean_type_node, v,
+ fold_convert_loc(location, TREE_TYPE(v),
+ null_pointer_node));
+ tree n = fold_convert_loc(location, TREE_TYPE(v1), null_pointer_node);
+ return fold_build3_loc(location, COND_EXPR, TREE_TYPE(v1),
+ eq, n, v1);
+}
+
+// Return a tree for the conversion of an interface type to an
+// interface type.
+
+tree
+Expression::convert_interface_to_interface(Translate_context* context,
+ Type *lhs_type, Type *rhs_type,
+ tree rhs_tree, bool for_type_guard,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // In the general case this requires runtime examination of the type
+ // method table to match it up with the interface methods.
+
+ // FIXME: If all of the methods in the right hand side interface
+ // also appear in the left hand side interface, then we don't need
+ // to do a runtime check, although we still need to build a new
+ // method table.
+
+ // Get the type descriptor for the right hand side. This will be
+ // NULL for a nil interface.
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ // The result is going to be a two element constructor.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ elt->index = field;
+
+ if (for_type_guard)
+ {
+ // A type assertion fails when converting a nil interface.
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree assert_interface_decl;
+ tree call = Gogo::call_builtin(&assert_interface_decl,
+ location,
+ "__go_assert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(assert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+ else if (lhs_is_empty)
+ {
+ // A convertion to an empty interface always succeeds, and the
+ // first field is just the type descriptor of the object.
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__type_descriptor") == 0);
+ gcc_assert(TREE_TYPE(field) == TREE_TYPE(rhs_type_descriptor));
+ elt->value = rhs_type_descriptor;
+ }
+ else
+ {
+ // A conversion to a non-empty interface may fail, but unlike a
+ // type assertion converting nil will always succeed.
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods")
+ == 0);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree convert_interface_decl;
+ tree call = Gogo::call_builtin(&convert_interface_decl,
+ location,
+ "__go_convert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(convert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+
+ // The second field is simply the object pointer.
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ elt->value = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ return build_constructor(lhs_type_tree, init);
+}
+
+// Return a tree for the conversion of an interface type to a
+// non-interface type.
+
+tree
+Expression::convert_interface_to_type(Translate_context* context,
+ Type *lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // Call a function to check that the type is valid. The function
+ // will panic with an appropriate runtime type error if the type is
+ // not valid.
+
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo);
+
+ static tree check_interface_type_decl;
+ tree call = Gogo::call_builtin(&check_interface_type_decl,
+ location,
+ "__go_check_interface_type",
+ 3,
+ void_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor,
+ TREE_TYPE(rhs_inter_descriptor),
+ rhs_inter_descriptor);
+ // This call will panic if the conversion is invalid.
+ TREE_NOTHROW(check_interface_type_decl) = 0;
+
+ // If the call succeeds, pull out the value.
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ tree val = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ // If the value is a pointer, then it is the value we want.
+ // Otherwise it points to the value.
+ if (lhs_type->points_to() == NULL)
+ {
+ val = fold_convert_loc(location, build_pointer_type(lhs_type_tree), val);
+ val = build_fold_indirect_ref_loc(location, val);
+ }
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, call,
+ fold_convert_loc(location, lhs_type_tree, val));
+}
+
+// Convert an expression to a tree. This is implemented by the child
+// class. Not that it is not in general safe to call this multiple
+// times for a single expression, but that we don't catch such errors.
+
+tree
+Expression::get_tree(Translate_context* context)
+{
+ // The child may have marked this expression as having an error.
+ if (this->classification_ == EXPRESSION_ERROR)
+ return error_mark_node;
+
+ return this->do_get_tree(context);
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::integer_constant_tree(mpz_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ return double_int_to_tree(type,
+ mpz_get_double_int(type, val, true));
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree ret = Expression::float_constant_tree(fval, type);
+ mpfr_clear(fval);
+ return ret;
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree real = Expression::float_constant_tree(fval, TREE_TYPE(type));
+ mpfr_clear(fval);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, real, imag);
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::float_constant_tree(mpfr_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, val, GMP_RNDN);
+ tree ret = Expression::integer_constant_tree(ival, type);
+ mpz_clear(ival);
+ return ret;
+ }
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, type, GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(type), &r1);
+ return build_real(type, r2);
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, build_real(TREE_TYPE(type), r2), imag);
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree for REAL/IMAG in TYPE.
+
+tree
+Expression::complex_constant_tree(mpfr_t real, mpfr_t imag, tree type)
+{
+ if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, real, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+
+ REAL_VALUE_TYPE r3;
+ real_from_mpfr(&r3, imag, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r4;
+ real_convert(&r4, TYPE_MODE(TREE_TYPE(type)), &r3);
+
+ return build_complex(type, build_real(TREE_TYPE(type), r2),
+ build_real(TREE_TYPE(type), r4));
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree which evaluates to true if VAL, of arbitrary integer
+// type, is negative or is more than the maximum value of BOUND_TYPE.
+// If SOFAR is not NULL, it is or'red into the result. The return
+// value may be NULL if SOFAR is NULL.
+
+tree
+Expression::check_bounds(tree val, tree bound_type, tree sofar,
+ source_location loc)
+{
+ tree val_type = TREE_TYPE(val);
+ tree ret = NULL_TREE;
+
+ if (!TYPE_UNSIGNED(val_type))
+ {
+ ret = fold_build2_loc(loc, LT_EXPR, boolean_type_node, val,
+ build_int_cst(val_type, 0));
+ if (ret == boolean_false_node)
+ ret = NULL_TREE;
+ }
+
+ if ((TYPE_UNSIGNED(val_type) && !TYPE_UNSIGNED(bound_type))
+ || TYPE_SIZE(val_type) > TYPE_SIZE(bound_type))
+ {
+ tree max = TYPE_MAX_VALUE(bound_type);
+ tree big = fold_build2_loc(loc, GT_EXPR, boolean_type_node, val,
+ fold_convert_loc(loc, val_type, max));
+ if (big == boolean_false_node)
+ ;
+ else if (ret == NULL_TREE)
+ ret = big;
+ else
+ ret = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ ret, big);
+ }
+
+ if (ret == NULL_TREE)
+ return sofar;
+ else if (sofar == NULL_TREE)
+ return ret;
+ else
+ return fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ sofar, ret);
+}
+
+// Error expressions. This are used to avoid cascading errors.
+
+class Error_expression : public Expression
+{
+ public:
+ Error_expression(source_location location)
+ : Expression(EXPRESSION_ERROR, location)
+ { }
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const
+ {
+ mpz_set_ui(val, 0);
+ return true;
+ }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const
+ {
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ return true;
+ }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type()
+ { return Type::make_error_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return error_mark_node; }
+};
+
+Expression*
+Expression::make_error(source_location location)
+{
+ return new Error_expression(location);
+}
+
+// An expression which is really a type. This is used during parsing.
+// It is an error if these survive after lowering.
+
+class
+Type_expression : public Expression
+{
+ public:
+ Type_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*)
+ { this->report_error(_("invalid use of type")); }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The type which we are representing as an expression.
+ Type* type_;
+};
+
+Expression*
+Expression::make_type(Type* type, source_location location)
+{
+ return new Type_expression(type, location);
+}
+
+// Class Var_expression.
+
+// Lower a variable expression. Here we just make sure that the
+// initialization expression of the variable has been lowered. This
+// ensures that we will be able to determine the type of the variable
+// if necessary.
+
+Expression*
+Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->variable_->is_variable())
+ {
+ Variable* var = this->variable_->var_value();
+ // This is either a local variable or a global variable. A
+ // reference to a variable which is local to an enclosing
+ // function will be a reference to a field in a closure.
+ if (var->is_global())
+ function = NULL;
+ var->lower_init_expression(gogo, function);
+ }
+ return this;
+}
+
+// Return the name of the variable.
+
+const std::string&
+Var_expression::name() const
+{
+ return this->variable_->name();
+}
+
+// Return the type of a reference to a variable.
+
+Type*
+Var_expression::do_type()
+{
+ if (this->variable_->is_variable())
+ return this->variable_->var_value()->type();
+ else if (this->variable_->is_result_variable())
+ return this->variable_->result_var_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Something takes the address of this variable. This means that we
+// may want to move the variable onto the heap.
+
+void
+Var_expression::do_address_taken(bool escapes)
+{
+ if (!escapes)
+ ;
+ else if (this->variable_->is_variable())
+ this->variable_->var_value()->set_address_taken();
+ else if (this->variable_->is_result_variable())
+ this->variable_->result_var_value()->set_address_taken();
+ else
+ gcc_unreachable();
+}
+
+// Get the tree for a reference to a variable.
+
+tree
+Var_expression::do_get_tree(Translate_context* context)
+{
+ return this->variable_->get_tree(context->gogo(), context->function());
+}
+
+// Make a reference to a variable in an expression.
+
+Expression*
+Expression::make_var_reference(Named_object* var, source_location location)
+{
+ if (var->is_sink())
+ return Expression::make_sink(location);
+
+ // FIXME: Creating a new object for each reference to a variable is
+ // wasteful.
+ return new Var_expression(var, location);
+}
+
+// Class Temporary_reference_expression.
+
+// The type.
+
+Type*
+Temporary_reference_expression::do_type()
+{
+ return this->statement_->type();
+}
+
+// Called if something takes the address of this temporary variable.
+// We never have to move temporary variables to the heap, but we do
+// need to know that they must live in the stack rather than in a
+// register.
+
+void
+Temporary_reference_expression::do_address_taken(bool)
+{
+ this->statement_->set_is_address_taken();
+}
+
+// Get a tree referring to the variable.
+
+tree
+Temporary_reference_expression::do_get_tree(Translate_context*)
+{
+ return this->statement_->get_decl();
+}
+
+// Make a reference to a temporary variable.
+
+Expression*
+Expression::make_temporary_reference(Temporary_statement* statement,
+ source_location location)
+{
+ return new Temporary_reference_expression(statement, location);
+}
+
+// A sink expression--a use of the blank identifier _.
+
+class Sink_expression : public Expression
+{
+ public:
+ Sink_expression(source_location location)
+ : Expression(EXPRESSION_SINK, location),
+ type_(NULL), var_(NULL_TREE)
+ { }
+
+ protected:
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return new Sink_expression(this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type of this sink variable.
+ Type* type_;
+ // The temporary variable we generate.
+ tree var_;
+};
+
+// Return the type of a sink expression.
+
+Type*
+Sink_expression::do_type()
+{
+ if (this->type_ == NULL)
+ return Type::make_sink_type();
+ return this->type_;
+}
+
+// Determine the type of a sink expression.
+
+void
+Sink_expression::do_determine_type(const Type_context* context)
+{
+ if (context->type != NULL)
+ this->type_ = context->type;
+}
+
+// Return a temporary variable for a sink expression. This will
+// presumably be a write-only variable which the middle-end will drop.
+
+tree
+Sink_expression::do_get_tree(Translate_context* context)
+{
+ if (this->var_ == NULL_TREE)
+ {
+ gcc_assert(this->type_ != NULL && !this->type_->is_sink_type());
+ this->var_ = create_tmp_var(this->type_->get_tree(context->gogo()),
+ "blank");
+ }
+ return this->var_;
+}
+
+// Make a sink expression.
+
+Expression*
+Expression::make_sink(source_location location)
+{
+ return new Sink_expression(location);
+}
+
+// Class Func_expression.
+
+// FIXME: Can a function expression appear in a constant expression?
+// The value is unchanging. Initializing a constant to the address of
+// a function seems like it could work, though there might be little
+// point to it.
+
+// Return the name of the function.
+
+const std::string&
+Func_expression::name() const
+{
+ return this->function_->name();
+}
+
+// Traversal.
+
+int
+Func_expression::do_traverse(Traverse* traverse)
+{
+ return (this->closure_ == NULL
+ ? TRAVERSE_CONTINUE
+ : Expression::traverse(&this->closure_, traverse));
+}
+
+// Return the type of a function expression.
+
+Type*
+Func_expression::do_type()
+{
+ if (this->function_->is_function())
+ return this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ return this->function_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Get the tree for a function expression without evaluating the
+// closure.
+
+tree
+Func_expression::get_tree_without_closure(Gogo* gogo)
+{
+ Function_type* fntype;
+ if (this->function_->is_function())
+ fntype = this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ fntype = this->function_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+
+ // Builtin functions are handled specially by Call_expression. We
+ // can't take their address.
+ if (fntype->is_builtin())
+ {
+ error_at(this->location(), "invalid use of special builtin function %qs",
+ this->function_->name().c_str());
+ return error_mark_node;
+ }
+
+ Named_object* no = this->function_;
+ tree id = this->function_->get_id(gogo);
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(gogo, no, id);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
+ else
+ gcc_unreachable();
+
+ return build_fold_addr_expr_loc(this->location(), fndecl);
+}
+
+// Get the tree for a function expression. This is used when we take
+// the address of a function rather than simply calling it. If the
+// function has a closure, we must use a trampoline.
+
+tree
+Func_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ tree fnaddr = this->get_tree_without_closure(gogo);
+ if (fnaddr == error_mark_node)
+ return error_mark_node;
+
+ gcc_assert(TREE_CODE(fnaddr) == ADDR_EXPR
+ && TREE_CODE(TREE_OPERAND(fnaddr, 0)) == FUNCTION_DECL);
+ TREE_ADDRESSABLE(TREE_OPERAND(fnaddr, 0)) = 1;
+
+ // For a normal non-nested function call, that is all we have to do.
+ if (!this->function_->is_function()
+ || this->function_->func_value()->enclosing() == NULL)
+ {
+ gcc_assert(this->closure_ == NULL);
+ return fnaddr;
+ }
+
+ // For a nested function call, we have to always allocate a
+ // trampoline. If we don't always allocate, then closures will not
+ // be reliably distinct.
+ Expression* closure = this->closure_;
+ tree closure_tree;
+ if (closure == NULL)
+ closure_tree = null_pointer_node;
+ else
+ {
+ // Get the value of the closure. This will be a pointer to
+ // space allocated on the heap.
+ closure_tree = closure->get_tree(context);
+ if (closure_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(closure_tree)));
+ }
+
+ // Now we need to build some code on the heap. This code will load
+ // the static chain pointer with the closure and then jump to the
+ // body of the function. The normal gcc approach is to build the
+ // code on the stack. Unfortunately we can not do that, as Go
+ // permits us to return the function pointer.
+
+ return gogo->make_trampoline(fnaddr, closure_tree, this->location());
+}
+
+// Make a reference to a function in an expression.
+
+Expression*
+Expression::make_func_reference(Named_object* function, Expression* closure,
+ source_location location)
+{
+ return new Func_expression(function, closure, location);
+}
+
+// Class Unknown_expression.
+
+// Return the name of an unknown expression.
+
+const std::string&
+Unknown_expression::name() const
+{
+ return this->named_object_->name();
+}
+
+// Lower a reference to an unknown name.
+
+Expression*
+Unknown_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Named_object* no = this->named_object_;
+ Named_object* real = no->unknown_value()->real_named_object();
+ if (real == NULL)
+ {
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined name %qs",
+ this->named_object_->message_name().c_str());
+ return Expression::make_error(location);
+ }
+ switch (real->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(real, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(real->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined type %qs",
+ real->message_name().c_str());
+ return Expression::make_error(location);
+ case Named_object::NAMED_OBJECT_VAR:
+ return Expression::make_var_reference(real, location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(real, NULL, location);
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Make a reference to an unknown name.
+
+Expression*
+Expression::make_unknown_reference(Named_object* no, source_location location)
+{
+ gcc_assert(no->resolve()->is_unknown());
+ return new Unknown_expression(no, location);
+}
+
+// A boolean expression.
+
+class Boolean_expression : public Expression
+{
+ public:
+ Boolean_expression(bool val, source_location location)
+ : Expression(EXPRESSION_BOOLEAN, location),
+ val_(val), type_(NULL)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->val_ ? boolean_true_node : boolean_false_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string(this->val_ ? "true" : "false"); }
+
+ private:
+ // The constant.
+ bool val_;
+ // The type as determined by context.
+ Type* type_;
+};
+
+// Get the type.
+
+Type*
+Boolean_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_boolean_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+Boolean_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_bool_type();
+}
+
+// Import a boolean constant.
+
+Expression*
+Boolean_expression::do_import(Import* imp)
+{
+ if (imp->peek_char() == 't')
+ {
+ imp->require_c_string("true");
+ return Expression::make_boolean(true, imp->location());
+ }
+ else
+ {
+ imp->require_c_string("false");
+ return Expression::make_boolean(false, imp->location());
+ }
+}
+
+// Make a boolean expression.
+
+Expression*
+Expression::make_boolean(bool val, source_location location)
+{
+ return new Boolean_expression(val, location);
+}
+
+// Class String_expression.
+
+// Get the type.
+
+Type*
+String_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_string_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+String_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_string_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_string_type();
+}
+
+// Build a string constant.
+
+tree
+String_expression::do_get_tree(Translate_context* context)
+{
+ return context->gogo()->go_string_constant_tree(this->val_);
+}
+
+// Export a string expression.
+
+void
+String_expression::do_export(Export* exp) const
+{
+ std::string s;
+ s.reserve(this->val_.length() * 4 + 2);
+ s += '"';
+ for (std::string::const_iterator p = this->val_.begin();
+ p != this->val_.end();
+ ++p)
+ {
+ if (*p == '\\' || *p == '"')
+ {
+ s += '\\';
+ s += *p;
+ }
+ else if (*p >= 0x20 && *p < 0x7f)
+ s += *p;
+ else if (*p == '\n')
+ s += "\\n";
+ else if (*p == '\t')
+ s += "\\t";
+ else
+ {
+ s += "\\x";
+ unsigned char c = *p;
+ unsigned int dig = c >> 4;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ dig = c & 0xf;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ }
+ }
+ s += '"';
+ exp->write_string(s);
+}
+
+// Import a string expression.
+
+Expression*
+String_expression::do_import(Import* imp)
+{
+ imp->require_c_string("\"");
+ std::string val;
+ while (true)
+ {
+ int c = imp->get_char();
+ if (c == '"' || c == -1)
+ break;
+ if (c != '\\')
+ val += static_cast<char>(c);
+ else
+ {
+ c = imp->get_char();
+ if (c == '\\' || c == '"')
+ val += static_cast<char>(c);
+ else if (c == 'n')
+ val += '\n';
+ else if (c == 't')
+ val += '\t';
+ else if (c == 'x')
+ {
+ c = imp->get_char();
+ unsigned int vh = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ c = imp->get_char();
+ unsigned int vl = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ char v = (vh << 4) | vl;
+ val += v;
+ }
+ else
+ {
+ error_at(imp->location(), "bad string constant");
+ return Expression::make_error(imp->location());
+ }
+ }
+ }
+ return Expression::make_string(val, imp->location());
+}
+
+// Make a string expression.
+
+Expression*
+Expression::make_string(const std::string& val, source_location location)
+{
+ return new String_expression(val, location);
+}
+
+// Make an integer expression.
+
+class Integer_expression : public Expression
+{
+ public:
+ Integer_expression(const mpz_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_INTEGER, location),
+ type_(type)
+ { mpz_init_set(this->val_, *val); }
+
+ static Expression*
+ do_import(Import*);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpz_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_integer(Export* exp, const mpz_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type** ptype) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context* context);
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_integer(&this->val_, this->type_,
+ this->location()); }
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The integer value.
+ mpz_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Return an integer constant value.
+
+bool
+Integer_expression::do_integer_constant_value(bool, mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpz_set(val, this->val_);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract integer type.
+
+Type*
+Integer_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_integer_type();
+ return this->type_;
+}
+
+// Set the type of the integer value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Integer_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_integer_type("int");
+}
+
+// Return true if the integer VAL fits in the range of the type TYPE.
+// Otherwise give an error and return false. TYPE may be NULL.
+
+bool
+Integer_expression::check_constant(mpz_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Integer_type* itype = type->integer_type();
+ if (itype == NULL || itype->is_abstract())
+ return true;
+
+ int bits = mpz_sizeinbase(val, 2);
+
+ if (itype->is_unsigned())
+ {
+ // For an unsigned type we can only accept a nonnegative number,
+ // and we must be able to represent at least BITS.
+ if (mpz_sgn(val) >= 0
+ && bits <= itype->bits())
+ return true;
+ }
+ else
+ {
+ // For a signed type we need an extra bit to indicate the sign.
+ // We have to handle the most negative integer specially.
+ if (bits + 1 <= itype->bits()
+ || (bits <= itype->bits()
+ && mpz_sgn(val) < 0
+ && (mpz_scan1(val, 0)
+ == static_cast<unsigned long>(itype->bits() - 1))
+ && mpz_scan0(val, itype->bits()) == ULONG_MAX))
+ return true;
+ }
+
+ error_at(location, "integer constant overflow");
+ return false;
+}
+
+// Check the type of an integer constant.
+
+void
+Integer_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+ if (!Integer_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for an integer constant.
+
+tree
+Integer_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->float_type() != NULL)
+ {
+ // We are converting to an abstract floating point type.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ else if (this->type_ != NULL && this->type_->complex_type() != NULL)
+ {
+ // We are converting to an abstract complex type.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced for
+ // some reason. Use a type which will fit the value. We use <,
+ // not <=, because we need an extra bit for the sign bit.
+ int bits = mpz_sizeinbase(this->val_, 2);
+ if (bits < INT_TYPE_SIZE)
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ else if (bits < 64)
+ type = Type::lookup_integer_type("int64")->get_tree(gogo);
+ else
+ type = long_long_integer_type_node;
+ }
+ return Expression::integer_constant_tree(this->val_, type);
+}
+
+// Write VAL to export data.
+
+void
+Integer_expression::export_integer(Export* exp, const mpz_t val)
+{
+ char* s = mpz_get_str(NULL, 10, val);
+ exp->write_c_string(s);
+ free(s);
+}
+
+// Export an integer in a constant expression.
+
+void
+Integer_expression::do_export(Export* exp) const
+{
+ Integer_expression::export_integer(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Import an integer, floating point, or complex value. This handles
+// all these types because they all start with digits.
+
+Expression*
+Integer_expression::do_import(Import* imp)
+{
+ std::string num = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (!num.empty() && num[num.length() - 1] == 'i')
+ {
+ mpfr_t real;
+ size_t plus_pos = num.find('+', 1);
+ size_t minus_pos = num.find('-', 1);
+ size_t pos;
+ if (plus_pos == std::string::npos)
+ pos = minus_pos;
+ else if (minus_pos == std::string::npos)
+ pos = plus_pos;
+ else
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ if (pos == std::string::npos)
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ else
+ {
+ std::string real_str = num.substr(0, pos);
+ if (mpfr_init_set_str(real, real_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ real_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ }
+
+ std::string imag_str;
+ if (pos == std::string::npos)
+ imag_str = num;
+ else
+ imag_str = num.substr(pos);
+ imag_str = imag_str.substr(0, imag_str.size() - 1);
+ mpfr_t imag;
+ if (mpfr_init_set_str(imag, imag_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ imag_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_complex(&real, &imag, NULL,
+ imp->location());
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ else if (num.find('.') == std::string::npos
+ && num.find('E') == std::string::npos)
+ {
+ mpz_t val;
+ if (mpz_init_set_str(val, num.c_str(), 10) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_integer(&val, NULL, imp->location());
+ mpz_clear(val);
+ return ret;
+ }
+ else
+ {
+ mpfr_t val;
+ if (mpfr_init_set_str(val, num.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_float(&val, NULL, imp->location());
+ mpfr_clear(val);
+ return ret;
+ }
+}
+
+// Build a new integer value.
+
+Expression*
+Expression::make_integer(const mpz_t* val, Type* type,
+ source_location location)
+{
+ return new Integer_expression(val, type, location);
+}
+
+// Floats.
+
+class Float_expression : public Expression
+{
+ public:
+ Float_expression(const mpfr_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_FLOAT, location),
+ type_(type)
+ {
+ mpfr_init_set(this->val_, *val, GMP_RNDN);
+ }
+
+ // Constrain VAL to fit into TYPE.
+ static void
+ constrain_float(mpfr_t val, Type* type);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpfr_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_float(Export* exp, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_float(&this->val_, this->type_,
+ this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The floating point value.
+ mpfr_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Constrain VAL to fit into TYPE.
+
+void
+Float_expression::constrain_float(mpfr_t val, Type* type)
+{
+ Float_type* ftype = type->float_type();
+ if (ftype != NULL && !ftype->is_abstract())
+ {
+ tree type_tree = ftype->type_tree();
+ REAL_VALUE_TYPE rvt;
+ real_from_mpfr(&rvt, val, type_tree, GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(type_tree), &rvt);
+ mpfr_from_real(val, &rvt, GMP_RNDN);
+ }
+}
+
+// Return a floating point constant value.
+
+bool
+Float_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(val, this->val_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract float type.
+
+Type*
+Float_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_float_type();
+ return this->type_;
+}
+
+// Set the type of the float value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Float_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_float_type("float");
+}
+
+// Return true if the floating point value VAL fits in the range of
+// the type TYPE. Otherwise give an error and return false. TYPE may
+// be NULL.
+
+bool
+Float_expression::check_constant(mpfr_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Float_type* ftype = type->float_type();
+ if (ftype == NULL || ftype->is_abstract())
+ return true;
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (mpfr_nan_p(val) || mpfr_inf_p(val) || mpfr_zero_p(val))
+ return true;
+
+ mp_exp_t exp = mpfr_get_exp(val);
+ mp_exp_t max_exp;
+ switch (ftype->bits())
+ {
+ case 32:
+ max_exp = 128;
+ break;
+ case 64:
+ max_exp = 1024;
+ break;
+ default:
+ gcc_unreachable();
+ }
+ if (exp > max_exp)
+ {
+ error_at(location, "floating point constant overflow");
+ return false;
+ }
+ return true;
+}
+
+// Check the type of a float value.
+
+void
+Float_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Float_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+
+ Integer_type* integer_type = this->type_->integer_type();
+ if (integer_type != NULL)
+ {
+ if (!mpfr_integer_p(this->val_))
+ this->report_error(_("floating point constant truncated to integer"));
+ else
+ {
+ gcc_assert(!integer_type->is_abstract());
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, this->val_, GMP_RNDN);
+ Integer_expression::check_constant(ival, integer_type,
+ this->location());
+ mpz_clear(ival);
+ }
+ }
+}
+
+// Get a tree for a float constant.
+
+tree
+Float_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->integer_type() != NULL)
+ {
+ // We have an abstract integer type. We just hope for the best.
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use float64 and hope for the best.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ return Expression::float_constant_tree(this->val_, type);
+}
+
+// Write a floating point number to export data.
+
+void
+Float_expression::export_float(Export *exp, const mpfr_t val)
+{
+ mp_exp_t exponent;
+ char* s = mpfr_get_str(NULL, &exponent, 10, 0, val, GMP_RNDN);
+ if (*s == '-')
+ exp->write_c_string("-");
+ exp->write_c_string("0.");
+ exp->write_c_string(*s == '-' ? s + 1 : s);
+ mpfr_free_str(s);
+ char buf[30];
+ snprintf(buf, sizeof buf, "E%ld", exponent);
+ exp->write_c_string(buf);
+}
+
+// Export a floating point number in a constant expression.
+
+void
+Float_expression::do_export(Export* exp) const
+{
+ Float_expression::export_float(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a float expression.
+
+Expression*
+Expression::make_float(const mpfr_t* val, Type* type, source_location location)
+{
+ return new Float_expression(val, type, location);
+}
+
+// Complex numbers.
+
+class Complex_expression : public Expression
+{
+ public:
+ Complex_expression(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+ : Expression(EXPRESSION_COMPLEX, location),
+ type_(type)
+ {
+ mpfr_init_set(this->real_, *real, GMP_RNDN);
+ mpfr_init_set(this->imag_, *imag, GMP_RNDN);
+ }
+
+ // Constrain REAL/IMAG to fit into TYPE.
+ static void
+ constrain_complex(mpfr_t real, mpfr_t imag, Type* type);
+
+ // Return whether REAL/IMAG fits in the type.
+ static bool
+ check_constant(mpfr_t real, mpfr_t imag, Type*, source_location);
+
+ // Write REAL/IMAG to export data.
+ static void
+ export_complex(Export* exp, const mpfr_t real, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_complex(&this->real_, &this->imag_, this->type_,
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The real part.
+ mpfr_t real_;
+ // The imaginary part;
+ mpfr_t imag_;
+ // The type if known.
+ Type* type_;
+};
+
+// Constrain REAL/IMAG to fit into TYPE.
+
+void
+Complex_expression::constrain_complex(mpfr_t real, mpfr_t imag, Type* type)
+{
+ Complex_type* ctype = type->complex_type();
+ if (ctype != NULL && !ctype->is_abstract())
+ {
+ tree type_tree = ctype->type_tree();
+
+ REAL_VALUE_TYPE rvt;
+ real_from_mpfr(&rvt, real, TREE_TYPE(type_tree), GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(TREE_TYPE(type_tree)), &rvt);
+ mpfr_from_real(real, &rvt, GMP_RNDN);
+
+ real_from_mpfr(&rvt, imag, TREE_TYPE(type_tree), GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(TREE_TYPE(type_tree)), &rvt);
+ mpfr_from_real(imag, &rvt, GMP_RNDN);
+ }
+}
+
+// Return a complex constant value.
+
+bool
+Complex_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(real, this->real_, GMP_RNDN);
+ mpfr_set(imag, this->imag_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract complex type.
+
+Type*
+Complex_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_complex_type();
+ return this->type_;
+}
+
+// Set the type of the complex value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Complex_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && context->type->complex_type() != NULL)
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_complex_type("complex");
+}
+
+// Return true if the complex value REAL/IMAG fits in the range of the
+// type TYPE. Otherwise give an error and return false. TYPE may be
+// NULL.
+
+bool
+Complex_expression::check_constant(mpfr_t real, mpfr_t imag, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Complex_type* ctype = type->complex_type();
+ if (ctype == NULL || ctype->is_abstract())
+ return true;
+
+ mp_exp_t max_exp;
+ switch (ctype->bits())
+ {
+ case 64:
+ max_exp = 128;
+ break;
+ case 128:
+ max_exp = 1024;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (!mpfr_nan_p(real) && !mpfr_inf_p(real) && !mpfr_zero_p(real))
+ {
+ if (mpfr_get_exp(real) > max_exp)
+ {
+ error_at(location, "complex real part constant overflow");
+ return false;
+ }
+ }
+
+ if (!mpfr_nan_p(imag) && !mpfr_inf_p(imag) && !mpfr_zero_p(imag))
+ {
+ if (mpfr_get_exp(imag) > max_exp)
+ {
+ error_at(location, "complex imaginary part constant overflow");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check the type of a complex value.
+
+void
+Complex_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Complex_expression::check_constant(this->real_, this->imag_,
+ this->type_, this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for a complex constant.
+
+tree
+Complex_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else
+ {
+ // If we still have an abstract type here, this this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use complex128 and hope for the best.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ return Expression::complex_constant_tree(this->real_, this->imag_, type);
+}
+
+// Write REAL/IMAG to export data.
+
+void
+Complex_expression::export_complex(Export* exp, const mpfr_t real,
+ const mpfr_t imag)
+{
+ if (!mpfr_zero_p(real))
+ {
+ Float_expression::export_float(exp, real);
+ if (mpfr_sgn(imag) > 0)
+ exp->write_c_string("+");
+ }
+ Float_expression::export_float(exp, imag);
+ exp->write_c_string("i");
+}
+
+// Export a complex number in a constant expression.
+
+void
+Complex_expression::do_export(Export* exp) const
+{
+ Complex_expression::export_complex(exp, this->real_, this->imag_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a complex expression.
+
+Expression*
+Expression::make_complex(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+{
+ return new Complex_expression(real, imag, type, location);
+}
+
+// A reference to a const in an expression.
+
+class Const_expression : public Expression
+{
+ public:
+ Const_expression(Named_object* constant, source_location location)
+ : Expression(EXPRESSION_CONST_REFERENCE, location),
+ constant_(constant), type_(NULL)
+ { }
+
+ const std::string&
+ name() const
+ { return this->constant_->name(); }
+
+ protected:
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ bool
+ do_string_constant_value(std::string* val) const
+ { return this->constant_->const_value()->expr()->string_constant_value(val); }
+
+ Type*
+ do_type();
+
+ // The type of a const is set by the declaration, not the use.
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ // When exporting a reference to a const as part of a const
+ // expression, we export the value. We ignore the fact that it has
+ // a name.
+ void
+ do_export(Export* exp) const
+ { this->constant_->const_value()->expr()->export_expression(exp); }
+
+ private:
+ // The constant.
+ Named_object* constant_;
+ // The type of this reference. This is used if the constant has an
+ // abstract type.
+ Type* type_;
+};
+
+// Lower a constant expression. This is where we convert the
+// predeclared constant iota into an integer value.
+
+Expression*
+Const_expression::do_lower(Gogo* gogo, Named_object*, int iota_value)
+{
+ if (this->constant_->const_value()->expr()->classification()
+ == EXPRESSION_IOTA)
+ {
+ if (iota_value == -1)
+ {
+ error_at(this->location(),
+ "iota is only defined in const declarations");
+ iota_value = 0;
+ }
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned long>(iota_value));
+ Expression* ret = Expression::make_integer(&val, NULL,
+ this->location());
+ mpz_clear(val);
+ return ret;
+ }
+
+ // Make sure that the constant itself has been lowered.
+ gogo->lower_constant(this->constant_);
+
+ return this;
+}
+
+// Return an integer constant value.
+
+bool
+Const_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->integer_type() == NULL)
+ return false;
+
+ Expression* e = this->constant_->const_value()->expr();
+ Type* t;
+ bool r = e->integer_constant_value(iota_is_constant, val, &t);
+
+ if (r
+ && ctype != NULL
+ && !Integer_expression::check_constant(val, ctype, this->location()))
+ return false;
+
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a floating point constant value.
+
+bool
+Const_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->float_type() == NULL)
+ return false;
+
+ Type* t;
+ bool r = this->constant_->const_value()->expr()->float_constant_value(val,
+ &t);
+ if (r && ctype != NULL)
+ {
+ if (!Float_expression::check_constant(val, ctype, this->location()))
+ return false;
+ Float_expression::constrain_float(val, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a complex constant value.
+
+bool
+Const_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type **ptype) const
+{
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->complex_type() == NULL)
+ return false;
+
+ Type *t;
+ bool r = this->constant_->const_value()->expr()->complex_constant_value(real,
+ imag,
+ &t);
+ if (r && ctype != NULL)
+ {
+ if (!Complex_expression::check_constant(real, imag, ctype,
+ this->location()))
+ return false;
+ Complex_expression::constrain_complex(real, imag, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return the type of the const reference.
+
+Type*
+Const_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+ Named_constant* nc = this->constant_->const_value();
+ Type* ret = nc->type();
+ if (ret != NULL)
+ return ret;
+ // During parsing, a named constant may have a NULL type, but we
+ // must not return a NULL type here.
+ return nc->expr()->type();
+}
+
+// Set the type of the const reference.
+
+void
+Const_expression::do_determine_type(const Type_context* context)
+{
+ Type* ctype = this->constant_->const_value()->type();
+ Type* cetype = (ctype != NULL
+ ? ctype
+ : this->constant_->const_value()->expr()->type());
+ if (ctype != NULL && !ctype->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL)
+ && (cetype->integer_type() != NULL
+ || cetype->float_type() != NULL
+ || cetype->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_string_type()
+ && cetype->is_string_type())
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_boolean_type()
+ && cetype->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ {
+ if (cetype->is_abstract())
+ cetype = cetype->make_non_abstract_type();
+ this->type_ = cetype;
+ }
+}
+
+// Check types of a const reference.
+
+void
+Const_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL || this->type_->is_abstract())
+ return;
+
+ // Check for integer overflow.
+ if (this->type_->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (!this->integer_constant_value(true, ival, &dummy))
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Expression* cexpr = this->constant_->const_value()->expr();
+ if (cexpr->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ this->report_error(_("floating point constant "
+ "truncated to integer"));
+ else
+ {
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ Integer_expression::check_constant(ival, this->type_,
+ this->location());
+ }
+ }
+ mpfr_clear(fval);
+ }
+ mpz_clear(ival);
+ }
+}
+
+// Return a tree for the const reference.
+
+tree
+Const_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree;
+ if (this->type_ == NULL)
+ type_tree = NULL_TREE;
+ else
+ {
+ type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ }
+
+ // If the type has been set for this expression, but the underlying
+ // object is an abstract int or float, we try to get the abstract
+ // value. Otherwise we may lose something in the conversion.
+ if (this->type_ != NULL
+ && this->constant_->const_value()->type()->is_abstract())
+ {
+ Expression* expr = this->constant_->const_value()->expr();
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ if (expr->integer_constant_value(true, ival, &t))
+ {
+ tree ret = Expression::integer_constant_tree(ival, type_tree);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (expr->float_constant_value(fval, &t))
+ {
+ tree ret = Expression::float_constant_tree(fval, type_tree);
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (expr->complex_constant_value(fval, imag, &t))
+ {
+ tree ret = Expression::complex_constant_tree(fval, imag, type_tree);
+ mpfr_clear(fval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(imag);
+ mpfr_clear(fval);
+ }
+
+ tree const_tree = this->constant_->get_tree(gogo, context->function());
+ if (this->type_ == NULL
+ || const_tree == error_mark_node
+ || TREE_TYPE(const_tree) == error_mark_node)
+ return const_tree;
+
+ tree ret;
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(const_tree)))
+ ret = fold_convert(type_tree, const_tree);
+ else if (TREE_CODE(type_tree) == INTEGER_TYPE)
+ ret = fold(convert_to_integer(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == REAL_TYPE)
+ ret = fold(convert_to_real(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
+ ret = fold(convert_to_complex(type_tree, const_tree));
+ else
+ gcc_unreachable();
+ return ret;
+}
+
+// Make a reference to a constant in an expression.
+
+Expression*
+Expression::make_const_reference(Named_object* constant,
+ source_location location)
+{
+ return new Const_expression(constant, location);
+}
+
+// The nil value.
+
+class Nil_expression : public Expression
+{
+ public:
+ Nil_expression(source_location location)
+ : Expression(EXPRESSION_NIL, location)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type()
+ { return Type::make_nil_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return null_pointer_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string("nil"); }
+};
+
+// Import a nil expression.
+
+Expression*
+Nil_expression::do_import(Import* imp)
+{
+ imp->require_c_string("nil");
+ return Expression::make_nil(imp->location());
+}
+
+// Make a nil expression.
+
+Expression*
+Expression::make_nil(source_location location)
+{
+ return new Nil_expression(location);
+}
+
+// The value of the predeclared constant iota. This is little more
+// than a marker. This will be lowered to an integer in
+// Const_expression::do_lower, which is where we know the value that
+// it should have.
+
+class Iota_expression : public Parser_expression
+{
+ public:
+ Iota_expression(source_location location)
+ : Parser_expression(EXPRESSION_IOTA, location)
+ { }
+
+ protected:
+ Expression*
+ do_lower(Gogo*, Named_object*, int)
+ { gcc_unreachable(); }
+
+ // There should only ever be one of these.
+ Expression*
+ do_copy()
+ { gcc_unreachable(); }
+};
+
+// Make an iota expression. This is only called for one case: the
+// value of the predeclared constant iota.
+
+Expression*
+Expression::make_iota()
+{
+ static Iota_expression iota_expression(UNKNOWN_LOCATION);
+ return &iota_expression;
+}
+
+// A type conversion expression.
+
+class Type_conversion_expression : public Expression
+{
+ public:
+ Type_conversion_expression(Type* type, Expression* expr,
+ source_location location)
+ : Expression(EXPRESSION_CONVERSION, location),
+ type_(type), expr_(expr), may_convert_function_types_(false)
+ { }
+
+ // Return the type to which we are converting.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Return the expression which we are converting.
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ // Permit converting from one function type to another. This is
+ // used internally for method expressions.
+ void
+ set_may_convert_function_types()
+ {
+ this->may_convert_function_types_ = true;
+ }
+
+ // Import a type conversion expression.
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return this->expr_->is_constant(); }
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ bool
+ do_string_constant_value(std::string*) const;
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ {
+ Type_context subcontext(this->type_, false);
+ this->expr_->determine_type(&subcontext);
+ }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Type_conversion_expression(this->type_, this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type to convert to.
+ Type* type_;
+ // The expression to convert.
+ Expression* expr_;
+ // True if this is permitted to convert function types. This is
+ // used internally for method expressions.
+ bool may_convert_function_types_;
+};
+
+// Traversal.
+
+int
+Type_conversion_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert to a constant at lowering time.
+
+Expression*
+Type_conversion_expression::do_lower(Gogo*, Named_object*, int)
+{
+ Type* type = this->type_;
+ Expression* val = this->expr_;
+ source_location location = this->location();
+
+ if (type->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (val->integer_constant_value(false, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpz_clear(ival);
+ return ret;
+ }
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(location,
+ "floating point constant truncated to integer");
+ return Expression::make_error(location);
+ }
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ }
+
+ if (type->float_type() != NULL)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, type, location))
+ mpfr_set_ui(fval, 0, GMP_RNDN);
+ Float_expression::constrain_float(fval, type);
+ Expression *ret = Expression::make_float(&fval, type, location);
+ mpfr_clear(fval);
+ return ret;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (type->complex_type() != NULL)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ Type* dummy;
+ if (val->complex_constant_value(real, imag, &dummy))
+ {
+ if (!Complex_expression::check_constant(real, imag, type, location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ Complex_expression::constrain_complex(real, imag, type);
+ Expression* ret = Expression::make_complex(&real, &imag, type,
+ location);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (type->is_open_array_type() && type->named_type() == NULL)
+ {
+ Type* element_type = type->array_type()->element_type()->forwarded();
+ bool is_byte = element_type == Type::lookup_integer_type("uint8");
+ bool is_int = element_type == Type::lookup_integer_type("int");
+ if (is_byte || is_int)
+ {
+ std::string s;
+ if (val->string_constant_value(&s))
+ {
+ Expression_list* vals = new Expression_list();
+ if (is_byte)
+ {
+ for (std::string::const_iterator p = s.begin();
+ p != s.end();
+ p++)
+ {
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned char>(*p));
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+ else
+ {
+ const char *p = s.data();
+ const char *pend = s.data() + s.length();
+ while (p < pend)
+ {
+ unsigned int c;
+ int adv = Lex::fetch_char(p, &c);
+ if (adv == 0)
+ {
+ warning_at(this->location(), 0,
+ "invalid UTF-8 encoding");
+ adv = 1;
+ }
+ p += adv;
+ mpz_t val;
+ mpz_init_set_ui(val, c);
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+
+ return Expression::make_slice_composite_literal(type, vals,
+ location);
+ }
+ }
+ }
+
+ return this;
+}
+
+// Return the constant integer value if there is one.
+
+bool
+Type_conversion_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_->integer_type() == NULL)
+ return false;
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(iota_is_constant, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, this->type_,
+ this->location()))
+ {
+ mpz_clear(ival);
+ return false;
+ }
+ mpz_set(val, ival);
+ mpz_clear(ival);
+ *ptype = this->type_;
+ return true;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ if (!Integer_expression::check_constant(val, this->type_,
+ this->location()))
+ return false;
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant floating point value if there is one.
+
+bool
+Type_conversion_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->type_->float_type() == NULL)
+ return false;
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, this->type_,
+ this->location()))
+ {
+ mpfr_clear(fval);
+ return false;
+ }
+ mpfr_set(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ Float_expression::constrain_float(val, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant complex value if there is one.
+
+bool
+Type_conversion_expression::do_complex_constant_value(mpfr_t real,
+ mpfr_t imag,
+ Type **ptype) const
+{
+ if (this->type_->complex_type() == NULL)
+ return false;
+
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ Type* dummy;
+ if (this->expr_->complex_constant_value(rval, ival, &dummy))
+ {
+ if (!Complex_expression::check_constant(rval, ival, this->type_,
+ this->location()))
+ {
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return false;
+ }
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ Complex_expression::constrain_complex(real, imag, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+
+ return false;
+}
+
+// Return the constant string value if there is one.
+
+bool
+Type_conversion_expression::do_string_constant_value(std::string* val) const
+{
+ if (this->type_->is_string_type()
+ && this->expr_->type()->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(false, ival, &dummy))
+ {
+ unsigned long ulval = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, ulval) == 0)
+ {
+ Lex::append_char(ulval, true, val, this->location());
+ mpz_clear(ival);
+ return true;
+ }
+ }
+ mpz_clear(ival);
+ }
+
+ // FIXME: Could handle conversion from const []int here.
+
+ return false;
+}
+
+// Check that types are convertible.
+
+void
+Type_conversion_expression::do_check_types(Gogo*)
+{
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ std::string reason;
+
+ if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ return;
+
+ if (Type::are_convertible(type, expr_type, &reason))
+ return;
+
+ error_at(this->location(), "%s", reason.c_str());
+ this->set_is_error();
+}
+
+// Get a tree for a type conversion.
+
+tree
+Type_conversion_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->type_->get_tree(gogo);
+ tree expr_tree = this->expr_->get_tree(context);
+
+ if (type_tree == error_mark_node
+ || expr_tree == error_mark_node
+ || TREE_TYPE(expr_tree) == error_mark_node)
+ return error_mark_node;
+
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(expr_tree)))
+ return fold_convert(type_tree, expr_tree);
+
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ tree ret;
+ if (type->interface_type() != NULL || expr_type->interface_type() != NULL)
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+ else if (type->integer_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL
+ || expr_type->is_unsafe_pointer_type())
+ ret = fold(convert_to_integer(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->float_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL)
+ ret = fold(convert_to_real(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->complex_type() != NULL)
+ {
+ if (expr_type->complex_type() != NULL)
+ ret = fold(convert_to_complex(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->is_string_type()
+ && expr_type->integer_type() != NULL)
+ {
+ expr_tree = fold_convert(integer_type_node, expr_tree);
+ if (host_integerp(expr_tree, 0))
+ {
+ HOST_WIDE_INT intval = tree_low_cst(expr_tree, 0);
+ std::string s;
+ Lex::append_char(intval, true, &s, this->location());
+ Expression* se = Expression::make_string(s, this->location());
+ return se->get_tree(context);
+ }
+
+ static tree int_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_to_string_fndecl,
+ this->location(),
+ "__go_int_to_string",
+ 1,
+ type_tree,
+ integer_type_node,
+ fold_convert(integer_type_node, expr_tree));
+ }
+ else if (type->is_string_type()
+ && (expr_type->array_type() != NULL
+ || (expr_type->points_to() != NULL
+ && expr_type->points_to()->array_type() != NULL)))
+ {
+ Type* t = expr_type;
+ if (t->points_to() != NULL)
+ {
+ t = t->points_to();
+ expr_tree = build_fold_indirect_ref(expr_tree);
+ }
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ Array_type* a = t->array_type();
+ Type* e = a->element_type()->forwarded();
+ gcc_assert(e->integer_type() != NULL);
+ tree valptr = fold_convert(const_ptr_type_node,
+ a->value_pointer_tree(gogo, expr_tree));
+ tree len = a->length_tree(gogo, expr_tree);
+ len = fold_convert_loc(this->location(), size_type_node, len);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree byte_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&byte_array_to_string_fndecl,
+ this->location(),
+ "__go_byte_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ size_type_node,
+ len);
+ }
+ else
+ {
+ gcc_assert(e == Type::lookup_integer_type("int"));
+ static tree int_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_array_to_string_fndecl,
+ this->location(),
+ "__go_int_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ size_type_node,
+ len);
+ }
+ }
+ else if (type->is_open_array_type() && expr_type->is_string_type())
+ {
+ Type* e = type->array_type()->element_type()->forwarded();
+ gcc_assert(e->integer_type() != NULL);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree string_to_byte_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_byte_array_fndecl,
+ this->location(),
+ "__go_string_to_byte_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ else
+ {
+ gcc_assert(e == Type::lookup_integer_type("int"));
+ static tree string_to_int_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_int_array_fndecl,
+ this->location(),
+ "__go_string_to_int_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ }
+ else if ((type->is_unsafe_pointer_type()
+ && expr_type->points_to() != NULL)
+ || (expr_type->is_unsafe_pointer_type()
+ && type->points_to() != NULL))
+ ret = fold_convert(type_tree, expr_tree);
+ else if (type->is_unsafe_pointer_type()
+ && expr_type->integer_type() != NULL)
+ ret = convert_to_pointer(type_tree, expr_tree);
+ else if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ ret = fold_convert_loc(this->location(), type_tree, expr_tree);
+ else
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+
+ return ret;
+}
+
+// Output a type conversion in a constant expression.
+
+void
+Type_conversion_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ exp->write_c_string(", ");
+ this->expr_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a type conversion or a struct construction.
+
+Expression*
+Type_conversion_expression::do_import(Import* imp)
+{
+ imp->require_c_string("convert(");
+ Type* type = imp->read_type();
+ imp->require_c_string(", ");
+ Expression* val = Expression::import_expression(imp);
+ imp->require_c_string(")");
+ return Expression::make_cast(type, val, imp->location());
+}
+
+// Make a type cast expression.
+
+Expression*
+Expression::make_cast(Type* type, Expression* val, source_location location)
+{
+ if (type->is_error_type() || val->is_error_expression())
+ return Expression::make_error(location);
+ return new Type_conversion_expression(type, val, location);
+}
+
+// Unary expressions.
+
+class Unary_expression : public Expression
+{
+ public:
+ Unary_expression(Operator op, Expression* expr, source_location location)
+ : Expression(EXPRESSION_UNARY, location),
+ op_(op), escapes_(true), expr_(expr)
+ { }
+
+ // Return the operator.
+ Operator
+ op() const
+ { return this->op_; }
+
+ // Return the operand.
+ Expression*
+ operand() const
+ { return this->expr_; }
+
+ // Record that an address expression does not escape.
+ void
+ set_does_not_escape()
+ {
+ gcc_assert(this->op_ == OPERATOR_AND);
+ this->escapes_ = false;
+ }
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location);
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_float(Operator op, mpfr_t uval, mpfr_t val);
+
+ // Apply unary opcode OP to UREAL/UIMAG, setting REAL/IMAG. Return
+ // true if this could be done, false if not.
+ static bool
+ eval_complex(Operator op, mpfr_t ureal, mpfr_t uimag, mpfr_t real,
+ mpfr_t imag);
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_unary(this->op_, this->expr_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return this->op_ == OPERATOR_MULT; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The unary operator to apply.
+ Operator op_;
+ // Normally true. False if this is an address expression which does
+ // not escape the current function.
+ bool escapes_;
+ // The operand.
+ Expression* expr_;
+};
+
+// If we are taking the address of a composite literal, and the
+// contents are not constant, then we want to make a heap composite
+// instead.
+
+Expression*
+Unary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location loc = this->location();
+ Operator op = this->op_;
+ Expression* expr = this->expr_;
+
+ if (op == OPERATOR_MULT && expr->is_type_expression())
+ return Expression::make_type(Type::make_pointer_type(expr->type()), loc);
+
+ // *&x simplifies to x. *(*T)(unsafe.Pointer)(&x) does not require
+ // moving x to the heap. FIXME: Is it worth doing a real escape
+ // analysis here? This case is found in math/unsafe.go and is
+ // therefore worth special casing.
+ if (op == OPERATOR_MULT)
+ {
+ Expression* e = expr;
+ while (e->classification() == EXPRESSION_CONVERSION)
+ {
+ Type_conversion_expression* te
+ = static_cast<Type_conversion_expression*>(e);
+ e = te->expr();
+ }
+
+ if (e->classification() == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(e);
+ if (ue->op_ == OPERATOR_AND)
+ {
+ if (e == expr)
+ {
+ // *&x == x.
+ return ue->expr_;
+ }
+ ue->set_does_not_escape();
+ }
+ }
+ }
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS
+ || op == OPERATOR_NOT || op == OPERATOR_XOR)
+ {
+ Expression* ret = NULL;
+
+ mpz_t eval;
+ mpz_init(eval);
+ Type* etype;
+ if (expr->integer_constant_value(false, eval, &etype))
+ {
+ mpz_t val;
+ mpz_init(val);
+ if (Unary_expression::eval_integer(op, etype, eval, val, loc))
+ ret = Expression::make_integer(&val, etype, loc);
+ mpz_clear(val);
+ }
+ mpz_clear(eval);
+ if (ret != NULL)
+ return ret;
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* ftype;
+ if (expr->float_constant_value(fval, &ftype))
+ {
+ mpfr_t val;
+ mpfr_init(val);
+ if (Unary_expression::eval_float(op, fval, val))
+ ret = Expression::make_float(&val, ftype, loc);
+ mpfr_clear(val);
+ }
+ if (ret != NULL)
+ {
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t ival;
+ mpfr_init(ival);
+ if (expr->complex_constant_value(fval, ival, &ftype))
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (Unary_expression::eval_complex(op, fval, ival, real, imag))
+ ret = Expression::make_complex(&real, &imag, ftype, loc);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+ mpfr_clear(ival);
+ mpfr_clear(fval);
+ if (ret != NULL)
+ return ret;
+ }
+ }
+
+ return this;
+}
+
+// Return whether a unary expression is a constant.
+
+bool
+Unary_expression::do_is_constant() const
+{
+ if (this->op_ == OPERATOR_MULT)
+ {
+ // Indirecting through a pointer is only constant if the object
+ // to which the expression points is constant, but we currently
+ // have no way to determine that.
+ return false;
+ }
+ else if (this->op_ == OPERATOR_AND)
+ {
+ // Taking the address of a variable is constant if it is a
+ // global variable, not constant otherwise. In other cases
+ // taking the address is probably not a constant.
+ Var_expression* ve = this->expr_->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* no = ve->named_object();
+ return no->is_variable() && no->var_value()->is_global();
+ }
+ return false;
+ }
+ else
+ return this->expr_->is_constant();
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. UTYPE is the type of
+// UVAL, if known; it may be NULL. Return true if this could be done,
+// false if not.
+
+bool
+Unary_expression::eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpz_set(val, uval);
+ return true;
+ case OPERATOR_MINUS:
+ mpz_neg(val, uval);
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_NOT:
+ mpz_set_ui(val, mpz_cmp_si(uval, 0) == 0 ? 1 : 0);
+ return true;
+ case OPERATOR_XOR:
+ if (utype == NULL
+ || utype->integer_type() == NULL
+ || utype->integer_type()->is_abstract())
+ mpz_com(val, uval);
+ else
+ {
+ // The number of HOST_WIDE_INTs that it takes to represent
+ // UVAL.
+ size_t count = ((mpz_sizeinbase(uval, 2)
+ + HOST_BITS_PER_WIDE_INT
+ - 1)
+ / HOST_BITS_PER_WIDE_INT);
+
+ unsigned HOST_WIDE_INT* phwi = new unsigned HOST_WIDE_INT[count];
+ memset(phwi, 0, count * sizeof(HOST_WIDE_INT));
+
+ size_t ecount;
+ mpz_export(phwi, &ecount, -1, sizeof(HOST_WIDE_INT), 0, 0, uval);
+ gcc_assert(ecount <= count);
+
+ // Trim down to the number of words required by the type.
+ size_t obits = utype->integer_type()->bits();
+ if (!utype->integer_type()->is_unsigned())
+ ++obits;
+ size_t ocount = ((obits + HOST_BITS_PER_WIDE_INT - 1)
+ / HOST_BITS_PER_WIDE_INT);
+ gcc_assert(ocount <= ocount);
+
+ for (size_t i = 0; i < ocount; ++i)
+ phwi[i] = ~phwi[i];
+
+ size_t clearbits = ocount * HOST_BITS_PER_WIDE_INT - obits;
+ if (clearbits != 0)
+ phwi[ocount - 1] &= (((unsigned HOST_WIDE_INT) (HOST_WIDE_INT) -1)
+ >> clearbits);
+
+ mpz_import(val, ocount, -1, sizeof(HOST_WIDE_INT), 0, 0, phwi);
+
+ delete[] phwi;
+ }
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. Return true if this
+// could be done, false if not.
+
+bool
+Unary_expression::eval_float(Operator op, mpfr_t uval, mpfr_t val)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply unary opcode OP to RVAL/IVAL, setting REAL/IMAG. Return true
+// if this could be done, false if not.
+
+bool
+Unary_expression::eval_complex(Operator op, mpfr_t rval, mpfr_t ival,
+ mpfr_t real, mpfr_t imag)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(real, rval, GMP_RNDN);
+ mpfr_neg(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return the integral constant value of a unary expression, if it has one.
+
+bool
+Unary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t uval;
+ mpz_init(uval);
+ bool ret;
+ if (!this->expr_->integer_constant_value(iota_is_constant, uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_integer(this->op_, *ptype, uval, val,
+ this->location());
+ mpz_clear(uval);
+ return ret;
+}
+
+// Return the floating point constant value of a unary expression, if
+// it has one.
+
+bool
+Unary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t uval;
+ mpfr_init(uval);
+ bool ret;
+ if (!this->expr_->float_constant_value(uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_float(this->op_, uval, val);
+ mpfr_clear(uval);
+ return ret;
+}
+
+// Return the complex constant value of a unary expression, if it has
+// one.
+
+bool
+Unary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ bool ret;
+ if (!this->expr_->complex_constant_value(rval, ival, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_complex(this->op_, rval, ival, real, imag);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return ret;
+}
+
+// Return the type of a unary expression.
+
+Type*
+Unary_expression::do_type()
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ return this->expr_->type();
+
+ case OPERATOR_AND:
+ return Type::make_pointer_type(this->expr_->type());
+
+ case OPERATOR_MULT:
+ {
+ Type* subtype = this->expr_->type();
+ Type* points_to = subtype->points_to();
+ if (points_to == NULL)
+ return Type::make_error_type();
+ return points_to;
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Determine abstract types for a unary expression.
+
+void
+Unary_expression::do_determine_type(const Type_context* context)
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ this->expr_->determine_type(context);
+ break;
+
+ case OPERATOR_AND:
+ // Taking the address of something.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : context->type->points_to());
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : Type::make_pointer_type(context->type));
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Check types for a unary expression.
+
+void
+Unary_expression::do_check_types(Gogo*)
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ {
+ Type* type = this->expr_->type();
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_error_type())
+ this->report_error(_("expected numeric type"));
+ }
+ break;
+
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ {
+ Type* type = this->expr_->type();
+ if (type->integer_type() == NULL
+ && !type->is_boolean_type()
+ && !type->is_error_type())
+ this->report_error(_("expected integer or boolean type"));
+ }
+ break;
+
+ case OPERATOR_AND:
+ if (!this->expr_->is_addressable())
+ this->report_error(_("invalid operand for unary %<&%>"));
+ else
+ this->expr_->address_taken(this->escapes_);
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ {
+ Type* type = this->expr_->type();
+ if (type->points_to() == NULL
+ && !type->is_error_type())
+ this->report_error(_("expected pointer"));
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Get a tree for a unary expression.
+
+tree
+Unary_expression::do_get_tree(Translate_context* context)
+{
+ tree expr = this->expr_->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+
+ source_location loc = this->location();
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ return expr;
+
+ case OPERATOR_MINUS:
+ {
+ tree type = TREE_TYPE(expr);
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ expr = ::convert(compute_type, expr);
+ tree ret = fold_build1_loc(loc, NEGATE_EXPR,
+ (compute_type != NULL_TREE
+ ? compute_type
+ : type),
+ expr);
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+ return ret;
+ }
+
+ case OPERATOR_NOT:
+ if (TREE_CODE(TREE_TYPE(expr)) == BOOLEAN_TYPE)
+ return fold_build1_loc(loc, TRUTH_NOT_EXPR, TREE_TYPE(expr), expr);
+ else
+ return fold_build2_loc(loc, NE_EXPR, boolean_type_node, expr,
+ build_int_cst(TREE_TYPE(expr), 0));
+
+ case OPERATOR_XOR:
+ return fold_build1_loc(loc, BIT_NOT_EXPR, TREE_TYPE(expr), expr);
+
+ case OPERATOR_AND:
+ // We should not see a non-constant constructor here; cases
+ // where we would see one should have been moved onto the heap
+ // at parse time. Taking the address of a nonconstant
+ // constructor will not do what the programmer expects.
+ gcc_assert(TREE_CODE(expr) != CONSTRUCTOR || TREE_CONSTANT(expr));
+ gcc_assert(TREE_CODE(expr) != ADDR_EXPR);
+
+ // Build a decl for a constant constructor.
+ if (TREE_CODE(expr) == CONSTRUCTOR && TREE_CONSTANT(expr))
+ {
+ tree decl = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(expr));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ TREE_ADDRESSABLE(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = expr;
+ rest_of_decl_compilation(decl, 1, 0);
+ expr = decl;
+ }
+
+ return build_fold_addr_expr_loc(loc, expr);
+
+ case OPERATOR_MULT:
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(expr)));
+
+ // If we are dereferencing the pointer to a large struct, we
+ // need to check for nil. We don't bother to check for small
+ // structs because we expect the system to crash on a nil
+ // pointer dereference.
+ HOST_WIDE_INT s = int_size_in_bytes(TREE_TYPE(TREE_TYPE(expr)));
+ if (s == -1 || s >= 4096)
+ {
+ if (!DECL_P(expr))
+ expr = save_expr(expr);
+ tree compare = fold_build2_loc(loc, EQ_EXPR, boolean_type_node,
+ expr,
+ fold_convert(TREE_TYPE(expr),
+ null_pointer_node));
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE,
+ loc);
+ expr = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(expr),
+ build3(COND_EXPR, void_type_node,
+ compare, crash, NULL_TREE),
+ expr);
+ }
+
+ // If the type of EXPR is a recursive pointer type, then we
+ // need to insert a cast before indirecting.
+ if (TREE_TYPE(TREE_TYPE(expr)) == ptr_type_node)
+ {
+ Type* pt = this->expr_->type()->points_to();
+ tree ind = pt->get_tree(context->gogo());
+ expr = fold_convert_loc(loc, build_pointer_type(ind), expr);
+ }
+
+ return build_fold_indirect_ref_loc(loc, expr);
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Export a unary expression.
+
+void
+Unary_expression::do_export(Export* exp) const
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ exp->write_c_string("+ ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string("- ");
+ break;
+ case OPERATOR_NOT:
+ exp->write_c_string("! ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string("^ ");
+ break;
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ default:
+ gcc_unreachable();
+ }
+ this->expr_->export_expression(exp);
+}
+
+// Import a unary expression.
+
+Expression*
+Unary_expression::do_import(Import* imp)
+{
+ Operator op;
+ switch (imp->get_char())
+ {
+ case '+':
+ op = OPERATOR_PLUS;
+ break;
+ case '-':
+ op = OPERATOR_MINUS;
+ break;
+ case '!':
+ op = OPERATOR_NOT;
+ break;
+ case '^':
+ op = OPERATOR_XOR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+ imp->require_c_string(" ");
+ Expression* expr = Expression::import_expression(imp);
+ return Expression::make_unary(op, expr, imp->location());
+}
+
+// Make a unary expression.
+
+Expression*
+Expression::make_unary(Operator op, Expression* expr, source_location location)
+{
+ return new Unary_expression(op, expr, location);
+}
+
+// If this is an indirection through a pointer, return the expression
+// being pointed through. Otherwise return this.
+
+Expression*
+Expression::deref()
+{
+ if (this->classification_ == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(this);
+ if (ue->op() == OPERATOR_MULT)
+ return ue->operand();
+ }
+ return this;
+}
+
+// Class Binary_expression.
+
+// Traversal.
+
+int
+Binary_expression::do_traverse(Traverse* traverse)
+{
+ int t = Expression::traverse(&this->left_, traverse);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->right_, traverse);
+}
+
+// Compare integer constants according to OP.
+
+bool
+Binary_expression::compare_integer(Operator op, mpz_t left_val,
+ mpz_t right_val)
+{
+ int i = mpz_cmp(left_val, right_val);
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Compare floating point constants according to OP.
+
+bool
+Binary_expression::compare_float(Operator op, Type* type, mpfr_t left_val,
+ mpfr_t right_val)
+{
+ int i;
+ if (type == NULL)
+ i = mpfr_cmp(left_val, right_val);
+ else
+ {
+ mpfr_t lv;
+ mpfr_init_set(lv, left_val, GMP_RNDN);
+ mpfr_t rv;
+ mpfr_init_set(rv, right_val, GMP_RNDN);
+ Float_expression::constrain_float(lv, type);
+ Float_expression::constrain_float(rv, type);
+ i = mpfr_cmp(lv, rv);
+ mpfr_clear(lv);
+ mpfr_clear(rv);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Compare complex constants according to OP. Complex numbers may
+// only be compared for equality.
+
+bool
+Binary_expression::compare_complex(Operator op, Type* type,
+ mpfr_t left_real, mpfr_t left_imag,
+ mpfr_t right_real, mpfr_t right_imag)
+{
+ bool is_equal;
+ if (type == NULL)
+ is_equal = (mpfr_cmp(left_real, right_real) == 0
+ && mpfr_cmp(left_imag, right_imag) == 0);
+ else
+ {
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ Complex_expression::constrain_complex(lr, li, type);
+ Complex_expression::constrain_complex(rr, ri, type);
+ is_equal = mpfr_cmp(lr, rr) == 0 && mpfr_cmp(li, ri) == 0;
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return is_equal;
+ case OPERATOR_NOTEQ:
+ return !is_equal;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// LEFT_TYPE is the type of LEFT_VAL, RIGHT_TYPE is the type of
+// RIGHT_VAL; LEFT_TYPE and/or RIGHT_TYPE may be NULL. Return true if
+// this could be done, false if not.
+
+bool
+Binary_expression::eval_integer(Operator op, Type* left_type, mpz_t left_val,
+ Type* right_type, mpz_t right_val,
+ source_location location, mpz_t val)
+{
+ bool is_shift_op = false;
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpz_add(val, left_val, right_val);
+ break;
+ case OPERATOR_MINUS:
+ mpz_sub(val, left_val, right_val);
+ break;
+ case OPERATOR_OR:
+ mpz_ior(val, left_val, right_val);
+ break;
+ case OPERATOR_XOR:
+ mpz_xor(val, left_val, right_val);
+ break;
+ case OPERATOR_MULT:
+ mpz_mul(val, left_val, right_val);
+ break;
+ case OPERATOR_DIV:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_q(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_MOD:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_r(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_LSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ mpz_mul_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_RSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ if (mpz_cmp_ui(left_val, 0) >= 0)
+ mpz_tdiv_q_2exp(val, left_val, shift);
+ else
+ mpz_fdiv_q_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_AND:
+ mpz_and(val, left_val, right_val);
+ break;
+ case OPERATOR_BITCLEAR:
+ {
+ mpz_t tval;
+ mpz_init(tval);
+ mpz_com(tval, right_val);
+ mpz_and(val, left_val, tval);
+ mpz_clear(tval);
+ }
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (!is_shift_op)
+ {
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This look like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an
+ // unhelpful chain of error messages.
+ return true;
+ }
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ // We have to check the operands too, as we have implicitly
+ // coerced them to TYPE.
+ if ((type != left_type
+ && !Integer_expression::check_constant(left_val, type, location))
+ || (!is_shift_op
+ && type != right_type
+ && !Integer_expression::check_constant(right_val, type,
+ location))
+ || !Integer_expression::check_constant(val, type, location))
+ mpz_set_ui(val, 0);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// Return true if this could be done, false if not.
+
+bool
+Binary_expression::eval_float(Operator op, Type* left_type, mpfr_t left_val,
+ Type* right_type, mpfr_t right_val,
+ mpfr_t val, source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ mpfr_mul(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_DIV:
+ if (mpfr_zero_p(right_val))
+ error_at(location, "division by zero");
+ mpfr_div(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Float_expression::check_constant(left_val, type, location))
+ || (type != right_type
+ && !Float_expression::check_constant(right_val, type,
+ location))
+ || !Float_expression::check_constant(val, type, location))
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_REAL/LEFT_IMAG and
+// RIGHT_REAL/RIGHT_IMAG, setting REAL/IMAG. Return true if this
+// could be done, false if not.
+
+bool
+Binary_expression::eval_complex(Operator op, Type* left_type,
+ mpfr_t left_real, mpfr_t left_imag,
+ Type *right_type,
+ mpfr_t right_real, mpfr_t right_imag,
+ mpfr_t real, mpfr_t imag,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values and must be handled differently.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(real, left_real, right_real, GMP_RNDN);
+ mpfr_add(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(real, left_real, right_real, GMP_RNDN);
+ mpfr_sub(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ {
+ // You might think that multiplying two complex numbers would
+ // be simple, and you would be right, until you start to think
+ // about getting the right answer for infinity. If one
+ // operand here is infinity and the other is anything other
+ // than zero or NaN, then we are going to wind up subtracting
+ // two infinity values. That will give us a NaN, but the
+ // correct answer is infinity.
+
+ mpfr_t lrrr;
+ mpfr_init(lrrr);
+ mpfr_mul(lrrr, left_real, right_real, GMP_RNDN);
+
+ mpfr_t lrri;
+ mpfr_init(lrri);
+ mpfr_mul(lrri, left_real, right_imag, GMP_RNDN);
+
+ mpfr_t lirr;
+ mpfr_init(lirr);
+ mpfr_mul(lirr, left_imag, right_real, GMP_RNDN);
+
+ mpfr_t liri;
+ mpfr_init(liri);
+ mpfr_mul(liri, left_imag, right_imag, GMP_RNDN);
+
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+
+ // If we get NaN on both sides, check whether it should really
+ // be infinity. The rule is that if either side of the
+ // complex number is infinity, then the whole value is
+ // infinity, even if the other side is NaN. So the only case
+ // we have to fix is the one in which both sides are NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ bool is_infinity = false;
+
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+
+ // If the left side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(lr) || mpfr_inf_p(li))
+ {
+ mpfr_set_ui(lr, mpfr_inf_p(lr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ mpfr_set_ui(li, mpfr_inf_p(li) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If the right side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(rr) || mpfr_inf_p(ri))
+ {
+ mpfr_set_ui(rr, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ mpfr_set_ui(ri, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If we got an overflow in the intermediate computations,
+ // then the result is infinity.
+ if (!is_infinity
+ && (mpfr_inf_p(lrrr) || mpfr_inf_p(lrri)
+ || mpfr_inf_p(lirr) || mpfr_inf_p(liri)))
+ {
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ if (is_infinity)
+ {
+ mpfr_mul(lrrr, lr, rr, GMP_RNDN);
+ mpfr_mul(lrri, lr, ri, GMP_RNDN);
+ mpfr_mul(lirr, li, rr, GMP_RNDN);
+ mpfr_mul(liri, li, ri, GMP_RNDN);
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(real));
+ mpfr_set_inf(imag, mpfr_sgn(imag));
+ }
+
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+
+ mpfr_clear(lrrr);
+ mpfr_clear(lrri);
+ mpfr_clear(lirr);
+ mpfr_clear(liri);
+ }
+ break;
+ case OPERATOR_DIV:
+ {
+ // For complex division we want to avoid having an
+ // intermediate overflow turn the whole result in a NaN. We
+ // scale the values to try to avoid this.
+
+ if (mpfr_zero_p(right_real) && mpfr_zero_p(right_imag))
+ error_at(location, "division by zero");
+
+ mpfr_t rra;
+ mpfr_t ria;
+ mpfr_init(rra);
+ mpfr_init(ria);
+ mpfr_abs(rra, right_real, GMP_RNDN);
+ mpfr_abs(ria, right_imag, GMP_RNDN);
+ mpfr_t t;
+ mpfr_init(t);
+ mpfr_max(t, rra, ria, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ long ilogbw = 0;
+ if (!mpfr_inf_p(t) && !mpfr_nan_p(t) && !mpfr_zero_p(t))
+ {
+ ilogbw = mpfr_get_exp(t);
+ mpfr_mul_2si(rr, rr, - ilogbw, GMP_RNDN);
+ mpfr_mul_2si(ri, ri, - ilogbw, GMP_RNDN);
+ }
+
+ mpfr_t denom;
+ mpfr_init(denom);
+ mpfr_mul(denom, rr, rr, GMP_RNDN);
+ mpfr_mul(t, ri, ri, GMP_RNDN);
+ mpfr_add(denom, denom, t, GMP_RNDN);
+
+ mpfr_mul(real, left_real, rr, GMP_RNDN);
+ mpfr_mul(t, left_imag, ri, GMP_RNDN);
+ mpfr_add(real, real, t, GMP_RNDN);
+ mpfr_div(real, real, denom, GMP_RNDN);
+ mpfr_mul_2si(real, real, - ilogbw, GMP_RNDN);
+
+ mpfr_mul(imag, left_imag, rr, GMP_RNDN);
+ mpfr_mul(t, left_real, ri, GMP_RNDN);
+ mpfr_sub(imag, imag, t, GMP_RNDN);
+ mpfr_div(imag, imag, denom, GMP_RNDN);
+ mpfr_mul_2si(imag, imag, - ilogbw, GMP_RNDN);
+
+ // If we wind up with NaN on both sides, check whether we
+ // should really have infinity. The rule is that if either
+ // side of the complex number is infinity, then the whole
+ // value is infinity, even if the other side is NaN. So the
+ // only case we have to fix is the one in which both sides are
+ // NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ if (mpfr_zero_p(denom))
+ {
+ mpfr_set_inf(real, mpfr_sgn(rr));
+ mpfr_mul(real, real, left_real, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(rr));
+ mpfr_mul(imag, imag, left_imag, GMP_RNDN);
+ }
+ else if ((mpfr_inf_p(left_real) || mpfr_inf_p(left_imag))
+ && mpfr_number_p(rr) && mpfr_number_p(ri))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(left_real) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, left_real, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(left_imag) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, left_imag, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, t, rr, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, t2, ri, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(t3));
+
+ mpfr_mul(t3, t2, rr, GMP_RNDN);
+ mpfr_mul(t4, t, ri, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(t3));
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ else if ((mpfr_inf_p(right_real) || mpfr_inf_p(right_imag))
+ && mpfr_number_p(left_real) && mpfr_number_p(left_imag))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, rr, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, ri, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, left_real, t, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, left_imag, t2, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_mul(real, real, t3, GMP_RNDN);
+
+ mpfr_mul(t3, left_imag, t, GMP_RNDN);
+ mpfr_mul(t4, left_real, t2, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ mpfr_mul(imag, imag, t3, GMP_RNDN);
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ }
+
+ mpfr_clear(denom);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ mpfr_clear(t);
+ mpfr_clear(rra);
+ mpfr_clear(ria);
+ }
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Complex_expression::check_constant(left_real, left_imag,
+ type, location))
+ || (type != right_type
+ && !Complex_expression::check_constant(right_real, right_imag,
+ type, location))
+ || !Complex_expression::check_constant(real, imag, type,
+ location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ }
+
+ return true;
+}
+
+// Lower a binary expression. We have to evaluate constant
+// expressions now, in order to implement Go's unlimited precision
+// constants.
+
+Expression*
+Binary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Operator op = this->op_;
+ Expression* left = this->left_;
+ Expression* right = this->right_;
+
+ const bool is_comparison = (op == OPERATOR_EQEQ
+ || op == OPERATOR_NOTEQ
+ || op == OPERATOR_LT
+ || op == OPERATOR_LE
+ || op == OPERATOR_GT
+ || op == OPERATOR_GE);
+
+ // Integer constant expressions.
+ {
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (left->integer_constant_value(false, left_val, &left_type)
+ && right->integer_constant_value(false, right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_integer(op, left_val,
+ right_val);
+ ret = Expression::make_cast(Type::lookup_bool_type(),
+ Expression::make_boolean(b, location),
+ location);
+ }
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+
+ if (Binary_expression::eval_integer(op, left_type, left_val,
+ right_type, right_val,
+ location, val))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND);
+ Type* type;
+ if (op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT)
+ type = left_type;
+ else if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_integer(&val, type, location);
+ }
+
+ mpz_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return ret;
+ }
+ }
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ }
+
+ // Floating point constant expressions.
+ {
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (left->float_constant_value(left_val, &left_type)
+ && right->float_constant_value(right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_float(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_val, right_val);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t val;
+ mpfr_init(val);
+
+ if (Binary_expression::eval_float(op, left_type, left_val,
+ right_type, right_val, val,
+ location))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_float(&val, type, location);
+ }
+
+ mpfr_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return ret;
+ }
+ }
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ }
+
+ // Complex constant expressions.
+ {
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+
+ if (left->complex_constant_value(left_real, left_imag, &left_type)
+ && right->complex_constant_value(right_real, right_imag, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_complex(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_real,
+ left_imag,
+ right_real,
+ right_imag);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ if (Binary_expression::eval_complex(op, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ location))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_complex(&real, &imag, type,
+ location);
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return ret;
+ }
+ }
+
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ }
+
+ // String constant expressions.
+ if (op == OPERATOR_PLUS
+ && left->type()->is_string_type()
+ && right->type()->is_string_type())
+ {
+ std::string left_string;
+ std::string right_string;
+ if (left->string_constant_value(&left_string)
+ && right->string_constant_value(&right_string))
+ return Expression::make_string(left_string + right_string, location);
+ }
+
+ return this;
+}
+
+// Return the integer constant value, if it has one.
+
+bool
+Binary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ if (!this->left_->integer_constant_value(iota_is_constant, left_val,
+ &left_type))
+ {
+ mpz_clear(left_val);
+ return false;
+ }
+
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (!this->right_->integer_constant_value(iota_is_constant, right_val,
+ &right_type))
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && this->op_ != OPERATOR_RSHIFT
+ && this->op_ != OPERATOR_LSHIFT)
+ ret = false;
+ else
+ ret = Binary_expression::eval_integer(this->op_, left_type, left_val,
+ right_type, right_val,
+ this->location(), val);
+
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the floating point constant value, if it has one.
+
+bool
+Binary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ if (!this->left_->float_constant_value(left_val, &left_type))
+ {
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (!this->right_->float_constant_value(right_val, &right_type))
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_float(this->op_, left_type, left_val,
+ right_type, right_val,
+ val, this->location());
+
+ mpfr_clear(left_val);
+ mpfr_clear(right_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the complex constant value, if it has one.
+
+bool
+Binary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+ if (!this->left_->complex_constant_value(left_real, left_imag, &left_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ return false;
+ }
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+ if (!this->right_->complex_constant_value(right_real, right_imag,
+ &right_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_complex(this->op_, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ this->location());
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Note that the value is being discarded.
+
+void
+Binary_expression::do_discarding_value()
+{
+ if (this->op_ == OPERATOR_OROR || this->op_ == OPERATOR_ANDAND)
+ this->right_->discarding_value();
+ else
+ this->warn_about_unused_value();
+}
+
+// Get type.
+
+Type*
+Binary_expression::do_type()
+{
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Type::lookup_bool_type();
+
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ {
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (!left_type->is_abstract() && left_type->named_type() != NULL)
+ return left_type;
+ else if (!right_type->is_abstract() && right_type->named_type() != NULL)
+ return right_type;
+ else if (!left_type->is_abstract())
+ return left_type;
+ else if (!right_type->is_abstract())
+ return right_type;
+ else if (left_type->complex_type() != NULL)
+ return left_type;
+ else if (right_type->complex_type() != NULL)
+ return right_type;
+ else if (left_type->float_type() != NULL)
+ return left_type;
+ else if (right_type->float_type() != NULL)
+ return right_type;
+ else
+ return left_type;
+ }
+
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return this->left_->type();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Set type for a binary expression.
+
+void
+Binary_expression::do_determine_type(const Type_context* context)
+{
+ Type* tleft = this->left_->type();
+ Type* tright = this->right_->type();
+
+ // Both sides should have the same type, except for the shift
+ // operations. For a comparison, we should ignore the incoming
+ // type.
+
+ bool is_shift_op = (this->op_ == OPERATOR_LSHIFT
+ || this->op_ == OPERATOR_RSHIFT);
+
+ bool is_comparison = (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE);
+
+ Type_context subcontext(*context);
+
+ if (is_comparison)
+ {
+ // In a comparison, the context does not determine the types of
+ // the operands.
+ subcontext.type = NULL;
+ }
+
+ // Set the context for the left hand operand.
+ if (is_shift_op)
+ {
+ // The right hand operand plays no role in determining the type
+ // of the left hand operand. A shift of an abstract integer in
+ // a string context gets special treatment, which may be a
+ // language bug.
+ if (subcontext.type != NULL
+ && subcontext.type->is_string_type()
+ && tleft->is_abstract())
+ error_at(this->location(), "shift of non-integer operand");
+ }
+ else if (!tleft->is_abstract())
+ subcontext.type = tleft;
+ else if (!tright->is_abstract())
+ subcontext.type = tright;
+ else if (subcontext.type == NULL)
+ {
+ if ((tleft->integer_type() != NULL && tright->integer_type() != NULL)
+ || (tleft->float_type() != NULL && tright->float_type() != NULL)
+ || (tleft->complex_type() != NULL && tright->complex_type() != NULL))
+ {
+ // Both sides have an abstract integer, abstract float, or
+ // abstract complex type. Just let CONTEXT determine
+ // whether they may remain abstract or not.
+ }
+ else if (tleft->complex_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->complex_type() != NULL)
+ subcontext.type = tright;
+ else if (tleft->float_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->float_type() != NULL)
+ subcontext.type = tright;
+ else
+ subcontext.type = tleft;
+ }
+
+ this->left_->determine_type(&subcontext);
+
+ // The context for the right hand operand is the same as for the
+ // left hand operand, except for a shift operator.
+ if (is_shift_op)
+ {
+ subcontext.type = Type::lookup_integer_type("uint");
+ subcontext.may_be_abstract = false;
+ }
+
+ this->right_->determine_type(&subcontext);
+}
+
+// Report an error if the binary operator OP does not support TYPE.
+// Return whether the operation is OK. This should not be used for
+// shift.
+
+bool
+Binary_expression::check_operator_type(Operator op, Type* type,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ if (!type->is_boolean_type())
+ {
+ error_at(location, "expected boolean type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type()
+ && type->points_to() == NULL
+ && !type->is_nil_type()
+ && !type->is_boolean_type()
+ && type->interface_type() == NULL
+ && (type->array_type() == NULL
+ || type->array_type()->length() != NULL)
+ && type->map_type() == NULL
+ && type->channel_type() == NULL
+ && type->function_type() == NULL)
+ {
+ error_at(location,
+ ("expected integer, floating, complex, string, pointer, "
+ "boolean, interface, slice, map, channel, "
+ "or function type"));
+ return false;
+ }
+ break;
+
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location, "expected integer, floating, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_PLUS:
+ case OPERATOR_PLUSEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location,
+ "expected integer, floating, complex, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MINUS:
+ case OPERATOR_MINUSEQ:
+ case OPERATOR_MULT:
+ case OPERATOR_MULTEQ:
+ case OPERATOR_DIV:
+ case OPERATOR_DIVEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL)
+ {
+ error_at(location, "expected integer, floating, or complex type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MOD:
+ case OPERATOR_MODEQ:
+ case OPERATOR_OR:
+ case OPERATOR_OREQ:
+ case OPERATOR_AND:
+ case OPERATOR_ANDEQ:
+ case OPERATOR_XOR:
+ case OPERATOR_XOREQ:
+ case OPERATOR_BITCLEAR:
+ case OPERATOR_BITCLEAREQ:
+ if (type->integer_type() == NULL)
+ {
+ error_at(location, "expected integer type");
+ return false;
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+
+ return true;
+}
+
+// Check types.
+
+void
+Binary_expression::do_check_types(Gogo*)
+{
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (left_type->is_error_type() || right_type->is_error_type())
+ return;
+
+ if (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE)
+ {
+ if (!Type::are_assignable(left_type, right_type, NULL)
+ && !Type::are_assignable(right_type, left_type, NULL))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location())
+ || !Binary_expression::check_operator_type(this->op_, right_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else if (this->op_ != OPERATOR_LSHIFT && this->op_ != OPERATOR_RSHIFT)
+ {
+ if (!Type::are_compatible_for_binop(left_type, right_type))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else
+ {
+ if (left_type->integer_type() == NULL)
+ this->report_error(_("shift of non-integer operand"));
+
+ if (!right_type->is_abstract()
+ && (right_type->integer_type() == NULL
+ || !right_type->integer_type()->is_unsigned()))
+ this->report_error(_("shift count not unsigned integer"));
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (this->right_->integer_constant_value(true, val, &type))
+ {
+ if (mpz_sgn(val) < 0)
+ this->report_error(_("negative shift count"));
+ }
+ mpz_clear(val);
+ }
+ }
+}
+
+// Get a tree for a binary expression.
+
+tree
+Binary_expression::do_get_tree(Translate_context* context)
+{
+ tree left = this->left_->get_tree(context);
+ tree right = this->right_->get_tree(context);
+
+ if (left == error_mark_node || right == error_mark_node)
+ return error_mark_node;
+
+ enum tree_code code;
+ bool use_left_type = true;
+ bool is_shift_op = false;
+ switch (this->op_)
+ {
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Expression::comparison_tree(context, this->op_,
+ this->left_->type(), left,
+ this->right_->type(), right,
+ this->location());
+
+ case OPERATOR_OROR:
+ code = TRUTH_ORIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_ANDAND:
+ code = TRUTH_ANDIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_PLUS:
+ code = PLUS_EXPR;
+ break;
+ case OPERATOR_MINUS:
+ code = MINUS_EXPR;
+ break;
+ case OPERATOR_OR:
+ code = BIT_IOR_EXPR;
+ break;
+ case OPERATOR_XOR:
+ code = BIT_XOR_EXPR;
+ break;
+ case OPERATOR_MULT:
+ code = MULT_EXPR;
+ break;
+ case OPERATOR_DIV:
+ {
+ Type *t = this->left_->type();
+ if (t->float_type() != NULL || t->complex_type() != NULL)
+ code = RDIV_EXPR;
+ else
+ code = TRUNC_DIV_EXPR;
+ }
+ break;
+ case OPERATOR_MOD:
+ code = TRUNC_MOD_EXPR;
+ break;
+ case OPERATOR_LSHIFT:
+ code = LSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_RSHIFT:
+ code = RSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_AND:
+ code = BIT_AND_EXPR;
+ break;
+ case OPERATOR_BITCLEAR:
+ right = fold_build1(BIT_NOT_EXPR, TREE_TYPE(right), right);
+ code = BIT_AND_EXPR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ tree type = use_left_type ? TREE_TYPE(left) : TREE_TYPE(right);
+
+ if (this->left_->type()->is_string_type())
+ {
+ gcc_assert(this->op_ == OPERATOR_PLUS);
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_plus_decl;
+ return Gogo::call_builtin(&string_plus_decl,
+ this->location(),
+ "__go_string_plus",
+ 2,
+ string_type,
+ string_type,
+ left,
+ string_type,
+ right);
+ }
+
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ {
+ left = ::convert(compute_type, left);
+ right = ::convert(compute_type, right);
+ }
+
+ tree eval_saved = NULL_TREE;
+ if (is_shift_op)
+ {
+ if (!DECL_P(left))
+ left = save_expr(left);
+ if (!DECL_P(right))
+ right = save_expr(right);
+ // Make sure the values are evaluated.
+ eval_saved = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ void_type_node, left, right);
+ }
+
+ tree ret = fold_build2_loc(this->location(),
+ code,
+ compute_type != NULL_TREE ? compute_type : type,
+ left, right);
+
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+
+ // In Go, a shift larger than the size of the type is well-defined.
+ // This is not true in GENERIC, so we need to insert a conditional.
+ if (is_shift_op)
+ {
+ gcc_assert(INTEGRAL_TYPE_P(TREE_TYPE(left)));
+ gcc_assert(this->left_->type()->integer_type() != NULL);
+ int bits = TYPE_PRECISION(TREE_TYPE(left));
+
+ tree compare = fold_build2(LT_EXPR, boolean_type_node, right,
+ build_int_cst_type(TREE_TYPE(right), bits));
+
+ tree overflow_result = fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node);
+ if (this->op_ == OPERATOR_RSHIFT
+ && !this->left_->type()->integer_type()->is_unsigned())
+ {
+ tree neg = fold_build2_loc(this->location(), LT_EXPR,
+ boolean_type_node, left,
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node));
+ tree neg_one = fold_build2_loc(this->location(),
+ MINUS_EXPR, TREE_TYPE(left),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_one_node));
+ overflow_result = fold_build3_loc(this->location(), COND_EXPR,
+ TREE_TYPE(left), neg, neg_one,
+ overflow_result);
+ }
+
+ ret = fold_build3_loc(this->location(), COND_EXPR, TREE_TYPE(left),
+ compare, ret, overflow_result);
+
+ ret = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ TREE_TYPE(ret), eval_saved, ret);
+ }
+
+ return ret;
+}
+
+// Export a binary expression.
+
+void
+Binary_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("(");
+ this->left_->export_expression(exp);
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ exp->write_c_string(" || ");
+ break;
+ case OPERATOR_ANDAND:
+ exp->write_c_string(" && ");
+ break;
+ case OPERATOR_EQEQ:
+ exp->write_c_string(" == ");
+ break;
+ case OPERATOR_NOTEQ:
+ exp->write_c_string(" != ");
+ break;
+ case OPERATOR_LT:
+ exp->write_c_string(" < ");
+ break;
+ case OPERATOR_LE:
+ exp->write_c_string(" <= ");
+ break;
+ case OPERATOR_GT:
+ exp->write_c_string(" > ");
+ break;
+ case OPERATOR_GE:
+ exp->write_c_string(" >= ");
+ break;
+ case OPERATOR_PLUS:
+ exp->write_c_string(" + ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string(" - ");
+ break;
+ case OPERATOR_OR:
+ exp->write_c_string(" | ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string(" ^ ");
+ break;
+ case OPERATOR_MULT:
+ exp->write_c_string(" * ");
+ break;
+ case OPERATOR_DIV:
+ exp->write_c_string(" / ");
+ break;
+ case OPERATOR_MOD:
+ exp->write_c_string(" % ");
+ break;
+ case OPERATOR_LSHIFT:
+ exp->write_c_string(" << ");
+ break;
+ case OPERATOR_RSHIFT:
+ exp->write_c_string(" >> ");
+ break;
+ case OPERATOR_AND:
+ exp->write_c_string(" & ");
+ break;
+ case OPERATOR_BITCLEAR:
+ exp->write_c_string(" &^ ");
+ break;
+ default:
+ gcc_unreachable();
+ }
+ this->right_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a binary expression.
+
+Expression*
+Binary_expression::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+
+ Expression* left = Expression::import_expression(imp);
+
+ Operator op;
+ if (imp->match_c_string(" || "))
+ {
+ op = OPERATOR_OROR;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" && "))
+ {
+ op = OPERATOR_ANDAND;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" == "))
+ {
+ op = OPERATOR_EQEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" != "))
+ {
+ op = OPERATOR_NOTEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" < "))
+ {
+ op = OPERATOR_LT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" <= "))
+ {
+ op = OPERATOR_LE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" > "))
+ {
+ op = OPERATOR_GT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" >= "))
+ {
+ op = OPERATOR_GE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" + "))
+ {
+ op = OPERATOR_PLUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" - "))
+ {
+ op = OPERATOR_MINUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" | "))
+ {
+ op = OPERATOR_OR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" ^ "))
+ {
+ op = OPERATOR_XOR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" * "))
+ {
+ op = OPERATOR_MULT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" / "))
+ {
+ op = OPERATOR_DIV;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" % "))
+ {
+ op = OPERATOR_MOD;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" << "))
+ {
+ op = OPERATOR_LSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" >> "))
+ {
+ op = OPERATOR_RSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" & "))
+ {
+ op = OPERATOR_AND;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" &^ "))
+ {
+ op = OPERATOR_BITCLEAR;
+ imp->advance(4);
+ }
+ else
+ {
+ error_at(imp->location(), "unrecognized binary operator");
+ return Expression::make_error(imp->location());
+ }
+
+ Expression* right = Expression::import_expression(imp);
+
+ imp->require_c_string(")");
+
+ return Expression::make_binary(op, left, right, imp->location());
+}
+
+// Make a binary expression.
+
+Expression*
+Expression::make_binary(Operator op, Expression* left, Expression* right,
+ source_location location)
+{
+ return new Binary_expression(op, left, right, location);
+}
+
+// Implement a comparison.
+
+tree
+Expression::comparison_tree(Translate_context* context, Operator op,
+ Type* left_type, tree left_tree,
+ Type* right_type, tree right_tree,
+ source_location location)
+{
+ enum tree_code code;
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ code = EQ_EXPR;
+ break;
+ case OPERATOR_NOTEQ:
+ code = NE_EXPR;
+ break;
+ case OPERATOR_LT:
+ code = LT_EXPR;
+ break;
+ case OPERATOR_LE:
+ code = LE_EXPR;
+ break;
+ case OPERATOR_GT:
+ code = GT_EXPR;
+ break;
+ case OPERATOR_GE:
+ code = GE_EXPR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ if (left_type->is_string_type())
+ {
+ gcc_assert(right_type->is_string_type());
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_compare_decl;
+ left_tree = Gogo::call_builtin(&string_compare_decl,
+ location,
+ "__go_strcmp",
+ 2,
+ integer_type_node,
+ string_type,
+ left_tree,
+ string_type,
+ right_tree);
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+
+ if ((left_type->interface_type() != NULL
+ && right_type->interface_type() == NULL
+ && !right_type->is_nil_type())
+ || (left_type->interface_type() == NULL
+ && !left_type->is_nil_type()
+ && right_type->interface_type() != NULL))
+ {
+ // Comparing an interface value to a non-interface value.
+ if (left_type->interface_type() == NULL)
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ // The right operand is not an interface. We need to take its
+ // address if it is not a pointer.
+ tree make_tmp;
+ tree arg;
+ if (right_type->points_to() != NULL)
+ {
+ make_tmp = NULL_TREE;
+ arg = right_tree;
+ }
+ else if (TREE_ADDRESSABLE(TREE_TYPE(right_tree)) || DECL_P(right_tree))
+ {
+ make_tmp = NULL_TREE;
+ arg = build_fold_addr_expr_loc(location, right_tree);
+ if (DECL_P(right_tree))
+ TREE_ADDRESSABLE(right_tree) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(right_tree),
+ get_name(right_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = right_tree;
+ TREE_ADDRESSABLE(tmp) = 1;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ arg = build_fold_addr_expr_loc(location, tmp);
+ }
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+
+ tree descriptor = right_type->type_descriptor_pointer(context->gogo());
+
+ if (left_type->interface_type()->is_empty())
+ {
+ static tree empty_interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_value_compare_decl,
+ location,
+ "__go_empty_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(empty_interface_value_compare_decl) = 0;
+ }
+ else
+ {
+ static tree interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_value_compare_decl,
+ location,
+ "__go_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(interface_value_compare_decl) = 0;
+ }
+ right_tree = build_int_cst_type(integer_type_node, 0);
+
+ if (make_tmp != NULL_TREE)
+ left_tree = build2(COMPOUND_EXPR, TREE_TYPE(left_tree), make_tmp,
+ left_tree);
+ }
+ else if (left_type->interface_type() != NULL
+ && right_type->interface_type() != NULL)
+ {
+ if (left_type->interface_type()->is_empty())
+ {
+ gcc_assert(right_type->interface_type()->is_empty());
+ static tree empty_interface_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_compare_decl,
+ location,
+ "__go_empty_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(empty_interface_compare_decl) = 0;
+ }
+ else
+ {
+ gcc_assert(!right_type->interface_type()->is_empty());
+ static tree interface_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_compare_decl,
+ location,
+ "__go_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(interface_compare_decl) = 0;
+ }
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+
+ if (left_type->is_nil_type()
+ && (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ))
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ if (right_type->is_nil_type())
+ {
+ if (left_type->array_type() != NULL
+ && left_type->array_type()->length() == NULL)
+ {
+ Array_type* at = left_type->array_type();
+ left_tree = at->value_pointer_tree(context->gogo(), left_tree);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else if (left_type->interface_type() != NULL)
+ {
+ // An interface is nil if the first field is nil.
+ tree left_type_tree = TREE_TYPE(left_tree);
+ gcc_assert(TREE_CODE(left_type_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(left_type_tree);
+ left_tree = build3(COMPONENT_REF, TREE_TYPE(field), left_tree,
+ field, NULL_TREE);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(left_tree)));
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ }
+
+ tree ret = fold_build2(code, boolean_type_node, left_tree, right_tree);
+ if (CAN_HAVE_LOCATION_P(ret))
+ SET_EXPR_LOCATION(ret, location);
+ return ret;
+}
+
+// Class Bound_method_expression.
+
+// Traversal.
+
+int
+Bound_method_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->method_, traverse);
+}
+
+// Return the type of a bound method expression. The type of this
+// object is really the type of the method with no receiver. We
+// should be able to get away with just returning the type of the
+// method.
+
+Type*
+Bound_method_expression::do_type()
+{
+ return this->method_->type();
+}
+
+// Determine the types of a method expression.
+
+void
+Bound_method_expression::do_determine_type(const Type_context*)
+{
+ this->method_->determine_type_no_context();
+ Type* mtype = this->method_->type();
+ Function_type* fntype = mtype == NULL ? NULL : mtype->function_type();
+ if (fntype == NULL || !fntype->is_method())
+ this->expr_->determine_type_no_context();
+ else
+ {
+ Type_context subcontext(fntype->receiver()->type(), false);
+ this->expr_->determine_type(&subcontext);
+ }
+}
+
+// Check the types of a method expression.
+
+void
+Bound_method_expression::do_check_types(Gogo*)
+{
+ Type* type = this->method_->type()->deref();
+ if (type == NULL
+ || type->function_type() == NULL
+ || !type->function_type()->is_method())
+ this->report_error(_("object is not a method"));
+ else
+ {
+ Type* rtype = type->function_type()->receiver()->type()->deref();
+ Type* etype = (this->expr_type_ != NULL
+ ? this->expr_type_
+ : this->expr_->type());
+ etype = etype->deref();
+ if (!Type::are_identical(rtype, etype, NULL))
+ this->report_error(_("method type does not match object type"));
+ }
+}
+
+// Get the tree for a method expression. There is no standard tree
+// representation for this. The only places it may currently be used
+// are in a Call_expression or a Go_statement, which will take it
+// apart directly. So this has nothing to do at present.
+
+tree
+Bound_method_expression::do_get_tree(Translate_context*)
+{
+ gcc_unreachable();
+}
+
+// Make a method expression.
+
+Bound_method_expression*
+Expression::make_bound_method(Expression* expr, Expression* method,
+ source_location location)
+{
+ return new Bound_method_expression(expr, method, location);
+}
+
+// Class Builtin_call_expression. This is used for a call to a
+// builtin function.
+
+class Builtin_call_expression : public Call_expression
+{
+ public:
+ Builtin_call_expression(Gogo* gogo, Expression* fn, Expression_list* args,
+ bool is_varargs, source_location location);
+
+ protected:
+ // This overrides Call_expression::do_lower.
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Builtin_call_expression(this->gogo_, this->fn()->copy(),
+ this->args()->copy(),
+ this->is_varargs(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ virtual bool
+ do_is_recover_call() const;
+
+ virtual void
+ do_set_recover_arg(Expression*);
+
+ private:
+ // The builtin functions.
+ enum Builtin_function_code
+ {
+ BUILTIN_INVALID,
+
+ // Predeclared builtin functions.
+ BUILTIN_APPEND,
+ BUILTIN_CAP,
+ BUILTIN_CLOSE,
+ BUILTIN_CLOSED,
+ BUILTIN_CMPLX,
+ BUILTIN_COPY,
+ BUILTIN_IMAG,
+ BUILTIN_LEN,
+ BUILTIN_MAKE,
+ BUILTIN_NEW,
+ BUILTIN_PANIC,
+ BUILTIN_PRINT,
+ BUILTIN_PRINTLN,
+ BUILTIN_REAL,
+ BUILTIN_RECOVER,
+
+ // Builtin functions from the unsafe package.
+ BUILTIN_ALIGNOF,
+ BUILTIN_OFFSETOF,
+ BUILTIN_SIZEOF
+ };
+
+ Expression*
+ one_arg() const;
+
+ bool
+ check_one_arg();
+
+ static Type*
+ real_imag_type(Type*);
+
+ static Type*
+ cmplx_type(Type*);
+
+ // A pointer back to the general IR structure. This avoids a global
+ // variable, or passing it around everywhere.
+ Gogo* gogo_;
+ // The builtin function being called.
+ Builtin_function_code code_;
+};
+
+Builtin_call_expression::Builtin_call_expression(Gogo* gogo,
+ Expression* fn,
+ Expression_list* args,
+ bool is_varargs,
+ source_location location)
+ : Call_expression(fn, args, is_varargs, location),
+ gogo_(gogo), code_(BUILTIN_INVALID)
+{
+ Func_expression* fnexp = this->fn()->func_expression();
+ gcc_assert(fnexp != NULL);
+ const std::string& name(fnexp->named_object()->name());
+ if (name == "append")
+ this->code_ = BUILTIN_APPEND;
+ else if (name == "cap")
+ this->code_ = BUILTIN_CAP;
+ else if (name == "close")
+ this->code_ = BUILTIN_CLOSE;
+ else if (name == "closed")
+ this->code_ = BUILTIN_CLOSED;
+ else if (name == "cmplx")
+ this->code_ = BUILTIN_CMPLX;
+ else if (name == "copy")
+ this->code_ = BUILTIN_COPY;
+ else if (name == "imag")
+ this->code_ = BUILTIN_IMAG;
+ else if (name == "len")
+ this->code_ = BUILTIN_LEN;
+ else if (name == "make")
+ this->code_ = BUILTIN_MAKE;
+ else if (name == "new")
+ this->code_ = BUILTIN_NEW;
+ else if (name == "panic")
+ this->code_ = BUILTIN_PANIC;
+ else if (name == "print")
+ this->code_ = BUILTIN_PRINT;
+ else if (name == "println")
+ this->code_ = BUILTIN_PRINTLN;
+ else if (name == "real")
+ this->code_ = BUILTIN_REAL;
+ else if (name == "recover")
+ this->code_ = BUILTIN_RECOVER;
+ else if (name == "Alignof")
+ this->code_ = BUILTIN_ALIGNOF;
+ else if (name == "Offsetof")
+ this->code_ = BUILTIN_OFFSETOF;
+ else if (name == "Sizeof")
+ this->code_ = BUILTIN_SIZEOF;
+ else
+ gcc_unreachable();
+}
+
+// Return whether this is a call to recover. This is a virtual
+// function called from the parent class.
+
+bool
+Builtin_call_expression::do_is_recover_call() const
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return false;
+ return this->code_ == BUILTIN_RECOVER;
+}
+
+// Set the argument for a call to recover.
+
+void
+Builtin_call_expression::do_set_recover_arg(Expression* arg)
+{
+ const Expression_list* args = this->args();
+ gcc_assert(args == NULL || args->empty());
+ Expression_list* new_args = new Expression_list();
+ new_args->push_back(arg);
+ this->set_args(new_args);
+}
+
+// A traversal class which looks for a call expression.
+
+class Find_call_expression : public Traverse
+{
+ public:
+ Find_call_expression()
+ : Traverse(traverse_expressions),
+ found_(false)
+ { }
+
+ int
+ expression(Expression**);
+
+ bool
+ found()
+ { return this->found_; }
+
+ private:
+ bool found_;
+};
+
+int
+Find_call_expression::expression(Expression** pexpr)
+{
+ if ((*pexpr)->call_expression() != NULL)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a builtin call expression. This turns new and make into
+// specific expressions. We also convert to a constant if we can.
+
+Expression*
+Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->code_ == BUILTIN_NEW)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 1)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ return Expression::make_allocation(arg->type(), this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_MAKE)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ {
+ Expression_list* newargs;
+ if (args->size() == 1)
+ newargs = NULL;
+ else
+ {
+ newargs = new Expression_list();
+ Expression_list::const_iterator p = args->begin();
+ ++p;
+ for (; p != args->end(); ++p)
+ newargs->push_back(*p);
+ }
+ return Expression::make_make(arg->type(), newargs,
+ this->location());
+ }
+ }
+ }
+ else if (this->is_constant())
+ {
+ // We can only lower len and cap if there are no function calls
+ // in the arguments. Otherwise we have to make the call.
+ if (this->code_ == BUILTIN_LEN || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (!arg->is_constant())
+ {
+ Find_call_expression find_call;
+ Expression::traverse(&arg, &find_call);
+ if (find_call.found())
+ return this;
+ }
+ }
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* type;
+ if (this->integer_constant_value(true, ival, &type))
+ {
+ Expression* ret = Expression::make_integer(&ival, type,
+ this->location());
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t rval;
+ mpfr_init(rval);
+ if (this->float_constant_value(rval, &type))
+ {
+ Expression* ret = Expression::make_float(&rval, type,
+ this->location());
+ mpfr_clear(rval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (this->complex_constant_value(rval, imag, &type))
+ {
+ Expression* ret = Expression::make_complex(&rval, &imag, type,
+ this->location());
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ }
+ else if (this->code_ == BUILTIN_RECOVER)
+ {
+ if (function != NULL)
+ function->func_value()->set_calls_recover();
+ else
+ {
+ // Calling recover outside of a function always returns the
+ // nil empty interface.
+ Type* eface = Type::make_interface_type(NULL, this->location());
+ return Expression::make_cast(eface,
+ Expression::make_nil(this->location()),
+ this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_APPEND)
+ {
+ // Lower the varargs.
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return this;
+ Type* slice_type = args->front()->type();
+ if (!slice_type->is_open_array_type())
+ {
+ error_at(args->front()->location(), "argument 1 must be a slice");
+ this->set_is_error();
+ return this;
+ }
+ return this->lower_varargs(gogo, function, slice_type, 2);
+ }
+
+ return this;
+}
+
+// Return the type of the real or imag functions, given the type of
+// the argument. We need to map complex to float, complex64 to
+// float32, and complex128 to float64, so it has to be done by name.
+// This returns NULL if it can't figure out the type.
+
+Type*
+Builtin_call_expression::real_imag_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "complex")
+ return Type::lookup_float_type("float");
+ else if (nt->name() == "complex64")
+ return Type::lookup_float_type("float32");
+ else if (nt->name() == "complex128")
+ return Type::lookup_float_type("float64");
+ else
+ return NULL;
+}
+
+// Return the type of the cmplx function, given the type of one of the
+// argments. Like real_imag_type, we have to map by name.
+
+Type*
+Builtin_call_expression::cmplx_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "float")
+ return Type::lookup_complex_type("complex");
+ else if (nt->name() == "float32")
+ return Type::lookup_complex_type("complex64");
+ else if (nt->name() == "float64")
+ return Type::lookup_complex_type("complex128");
+ else
+ return NULL;
+}
+
+// Return a single argument, or NULL if there isn't one.
+
+Expression*
+Builtin_call_expression::one_arg() const
+{
+ const Expression_list* args = this->args();
+ if (args->size() != 1)
+ return NULL;
+ return args->front();
+}
+
+// Return whether this is constant: len of a string, or len or cap of
+// a fixed array, or unsafe.Sizeof, unsafe.Offsetof, unsafe.Alignof.
+
+bool
+Builtin_call_expression::do_is_constant() const
+{
+ switch (this->code_)
+ {
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ return arg_type->array_type()->length()->is_constant();
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ return arg->is_constant();
+ }
+ break;
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ return this->one_arg() != NULL;
+
+ case BUILTIN_OFFSETOF:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ return arg->field_reference_expression() != NULL;
+ }
+
+ case BUILTIN_CMPLX:
+ {
+ const Expression_list* args = this->args();
+ if (args != NULL && args->size() == 2)
+ return args->front()->is_constant() && args->back()->is_constant();
+ }
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ return arg != NULL && arg->is_constant();
+ }
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
+// Return an integer constant value if possible.
+
+bool
+Builtin_call_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_LEN
+ || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ {
+ std::string sval;
+ if (arg->string_constant_value(&sval))
+ {
+ mpz_set_ui(val, sval.length());
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ {
+ Expression* e = arg_type->array_type()->length();
+ if (e->integer_constant_value(iota_is_constant, val, ptype))
+ {
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+ }
+ else if (this->code_ == BUILTIN_SIZEOF
+ || this->code_ == BUILTIN_ALIGNOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+ if (arg_type->is_error_type())
+ return false;
+ if (arg_type->is_abstract())
+ return false;
+ tree arg_type_tree = arg_type->get_tree(this->gogo_);
+ unsigned long val_long;
+ if (this->code_ == BUILTIN_SIZEOF)
+ {
+ tree type_size = TYPE_SIZE_UNIT(arg_type_tree);
+ gcc_assert(TREE_CODE(type_size) == INTEGER_CST);
+ if (TREE_INT_CST_HIGH(type_size) != 0)
+ return false;
+ unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW(type_size);
+ val_long = static_cast<unsigned long>(val_wide);
+ if (val_long != val_wide)
+ return false;
+ }
+ else if (this->code_ == BUILTIN_ALIGNOF)
+ {
+ val_long = TYPE_ALIGN(arg_type_tree);
+ if (arg->field_reference_expression() != NULL)
+ {
+ // Calling unsafe.Alignof(s.f) returns the alignment of
+ // the type of f when it is used as a field in a struct.
+#ifdef BIGGEST_FIELD_ALIGNMENT
+ if (val_long > BIGGEST_FIELD_ALIGNMENT)
+ val_long = BIGGEST_FIELD_ALIGNMENT;
+#endif
+#ifdef ADJUST_FIELD_ALIGN
+ // A separate declaration avoids a warning promoted to
+ // an error if ADJUST_FIELD_ALIGN ignores FIELD.
+ tree field;
+ field = build_decl(UNKNOWN_LOCATION, FIELD_DECL, NULL,
+ arg_type_tree);
+ val_long = ADJUST_FIELD_ALIGN(field, val_long);
+#endif
+ }
+ val_long /= BITS_PER_UNIT;
+ }
+ else
+ gcc_unreachable();
+ mpz_set_ui(val, val_long);
+ *ptype = NULL;
+ return true;
+ }
+ else if (this->code_ == BUILTIN_OFFSETOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Field_reference_expression* farg = arg->field_reference_expression();
+ if (farg == NULL)
+ return false;
+ Expression* struct_expr = farg->expr();
+ Type* st = struct_expr->type();
+ if (st->struct_type() == NULL)
+ return false;
+ tree struct_tree = st->get_tree(this->gogo_);
+ gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(struct_tree);
+ for (unsigned int index = farg->field_index(); index > 0; --index)
+ {
+ field = DECL_CHAIN(field);
+ gcc_assert(field != NULL_TREE);
+ }
+ HOST_WIDE_INT offset_wide = int_byte_position (field);
+ if (offset_wide < 0)
+ return false;
+ unsigned long offset_long = static_cast<unsigned long>(offset_wide);
+ if (offset_long != static_cast<unsigned HOST_WIDE_INT>(offset_wide))
+ return false;
+ mpz_set_ui(val, offset_long);
+ return true;
+ }
+ return false;
+}
+
+// Return a floating point constant value if possible.
+
+bool
+Builtin_call_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_REAL || this->code_ == BUILTIN_IMAG)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ bool ret = false;
+ Type* type;
+ if (arg->complex_constant_value(real, imag, &type))
+ {
+ if (this->code_ == BUILTIN_REAL)
+ mpfr_set(val, real, GMP_RNDN);
+ else
+ mpfr_set(val, imag, GMP_RNDN);
+ *ptype = Builtin_call_expression::real_imag_type(type);
+ ret = true;
+ }
+
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+
+ return false;
+}
+
+// Return a complex constant value if possible.
+
+bool
+Builtin_call_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_CMPLX)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return false;
+
+ mpfr_t r;
+ mpfr_init(r);
+ Type* rtype;
+ if (!args->front()->float_constant_value(r, &rtype))
+ {
+ mpfr_clear(r);
+ return false;
+ }
+
+ mpfr_t i;
+ mpfr_init(i);
+
+ bool ret = false;
+ Type* itype;
+ if (args->back()->float_constant_value(i, &itype)
+ && Type::are_identical(rtype, itype, NULL))
+ {
+ mpfr_set(real, r, GMP_RNDN);
+ mpfr_set(imag, i, GMP_RNDN);
+ *ptype = Builtin_call_expression::cmplx_type(rtype);
+ ret = true;
+ }
+
+ mpfr_clear(r);
+ mpfr_clear(i);
+
+ return ret;
+ }
+
+ return false;
+}
+
+// Return the type.
+
+Type*
+Builtin_call_expression::do_type()
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ default:
+ gcc_unreachable();
+
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return Type::make_pointer_type(args->front()->type());
+ }
+
+ case BUILTIN_CAP:
+ case BUILTIN_COPY:
+ case BUILTIN_LEN:
+ case BUILTIN_ALIGNOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_SIZEOF:
+ return Type::lookup_integer_type("int");
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_PANIC:
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ return Type::make_void_type();
+
+ case BUILTIN_CLOSED:
+ return Type::lookup_bool_type();
+
+ case BUILTIN_RECOVER:
+ return Type::make_interface_type(NULL, BUILTINS_LOCATION);
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return args->front()->type();
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return Type::make_error_type();
+ Type* t = arg->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ t = Builtin_call_expression::real_imag_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+
+ case BUILTIN_CMPLX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return Type::make_error_type();
+ Type* t = args->front()->type();
+ if (t->is_abstract())
+ {
+ t = args->back()->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ }
+ t = Builtin_call_expression::cmplx_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+ }
+}
+
+// Determine the type.
+
+void
+Builtin_call_expression::do_determine_type(const Type_context* context)
+{
+ this->fn()->determine_type_no_context();
+
+ const Expression_list* args = this->args();
+
+ bool is_print;
+ Type* arg_type = NULL;
+ switch (this->code_)
+ {
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ // Do not force a large integer constant to "int".
+ is_print = true;
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ arg_type = Builtin_call_expression::cmplx_type(context->type);
+ is_print = false;
+ break;
+
+ case BUILTIN_CMPLX:
+ {
+ // For the cmplx function the type of one operand can
+ // determine the type of the other, as in a binary expression.
+ arg_type = Builtin_call_expression::real_imag_type(context->type);
+ if (args != NULL && args->size() == 2)
+ {
+ Type* t1 = args->front()->type();
+ Type* t2 = args->front()->type();
+ if (!t1->is_abstract())
+ arg_type = t1;
+ else if (!t2->is_abstract())
+ arg_type = t2;
+ }
+ is_print = false;
+ }
+ break;
+
+ default:
+ is_print = false;
+ break;
+ }
+
+ if (args != NULL)
+ {
+ for (Expression_list::const_iterator pa = args->begin();
+ pa != args->end();
+ ++pa)
+ {
+ Type_context subcontext;
+ subcontext.type = arg_type;
+
+ if (is_print)
+ {
+ // We want to print large constants, we so can't just
+ // use the appropriate nonabstract type. Use uint64 for
+ // an integer if we know it is nonnegative, otherwise
+ // use int64 for a integer, otherwise use float64 for a
+ // float or complex128 for a complex.
+ Type* want_type = NULL;
+ Type* atype = (*pa)->type();
+ if (atype->is_abstract())
+ {
+ if (atype->integer_type() != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy)
+ && mpz_sgn(val) >= 0)
+ want_type = Type::lookup_integer_type("uint64");
+ else
+ want_type = Type::lookup_integer_type("int64");
+ mpz_clear(val);
+ }
+ else if (atype->float_type() != NULL)
+ want_type = Type::lookup_float_type("float64");
+ else if (atype->complex_type() != NULL)
+ want_type = Type::lookup_complex_type("complex128");
+ else if (atype->is_abstract_string_type())
+ want_type = Type::lookup_string_type();
+ else if (atype->is_abstract_boolean_type())
+ want_type = Type::lookup_bool_type();
+ else
+ gcc_unreachable();
+ subcontext.type = want_type;
+ }
+ }
+
+ (*pa)->determine_type(&subcontext);
+ }
+ }
+}
+
+// If there is exactly one argument, return true. Otherwise give an
+// error message and return false.
+
+bool
+Builtin_call_expression::check_one_arg()
+{
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ {
+ this->report_error(_("not enough arguments"));
+ return false;
+ }
+ else if (args->size() > 1)
+ {
+ this->report_error(_("too many arguments"));
+ return false;
+ }
+ if (args->front()->is_error_expression()
+ || args->front()->type()->is_error_type())
+ {
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check argument types for a builtin function.
+
+void
+Builtin_call_expression::do_check_types(Gogo*)
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ return;
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ // The single argument may be either a string or an array or a
+ // map or a channel, or a pointer to a closed array.
+ if (this->check_one_arg())
+ {
+ Type* arg_type = this->one_arg()->type();
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+ if (this->code_ == BUILTIN_CAP)
+ {
+ if (!arg_type->is_error_type()
+ && arg_type->array_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be array or slice "
+ "or channel"));
+ }
+ else
+ {
+ if (!arg_type->is_error_type()
+ && !arg_type->is_string_type()
+ && arg_type->array_type() == NULL
+ && arg_type->map_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be string or "
+ "array or slice or map or channel"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL)
+ {
+ if (this->code_ == BUILTIN_PRINT)
+ warning_at(this->location(), 0,
+ "no arguments for builtin function %<%s%>",
+ (this->code_ == BUILTIN_PRINT
+ ? "print"
+ : "println"));
+ }
+ else
+ {
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p)
+ {
+ Type* type = (*p)->type();
+ if (type->is_error_type()
+ || type->is_string_type()
+ || type->integer_type() != NULL
+ || type->float_type() != NULL
+ || type->complex_type() != NULL
+ || type->is_boolean_type()
+ || type->points_to() != NULL
+ || type->interface_type() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL
+ || type->is_open_array_type())
+ ;
+ else
+ this->report_error(_("unsupported argument type to "
+ "builtin function"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_CLOSED:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->channel_type() == NULL)
+ this->report_error(_("argument must be channel"));
+ }
+ break;
+
+ case BUILTIN_PANIC:
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ this->check_one_arg();
+ break;
+
+ case BUILTIN_RECOVER:
+ if (this->args() != NULL && !this->args()->empty())
+ this->report_error(_("too many arguments"));
+ break;
+
+ case BUILTIN_OFFSETOF:
+ if (this->check_one_arg())
+ {
+ Expression* arg = this->one_arg();
+ if (arg->field_reference_expression() == NULL)
+ this->report_error(_("argument must be a field reference"));
+ }
+ break;
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ else if (args->size() > 2)
+ {
+ this->report_error(_("too many arguments"));
+ break;
+ }
+ Type* arg1_type = args->front()->type();
+ Type* arg2_type = args->back()->type();
+ if (arg1_type->is_error_type() || arg2_type->is_error_type())
+ break;
+
+ Type* e1;
+ if (arg1_type->is_open_array_type())
+ e1 = arg1_type->array_type()->element_type();
+ else
+ {
+ this->report_error(_("left argument must be a slice"));
+ break;
+ }
+
+ Type* e2;
+ if (arg2_type->is_open_array_type())
+ e2 = arg2_type->array_type()->element_type();
+ else if (arg2_type->is_string_type())
+ e2 = Type::lookup_integer_type("uint8");
+ else
+ {
+ this->report_error(_("right argument must be a slice or a string"));
+ break;
+ }
+
+ if (!Type::are_identical(e1, e2, NULL))
+ this->report_error(_("element types must be the same"));
+ }
+ break;
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ /* Lowering varargs should have left us with 2 arguments. */
+ gcc_assert(args->size() == 2);
+ std::string reason;
+ if (!Type::are_assignable(args->front()->type(), args->back()->type(),
+ &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("arguments 1 and 2 have different types"));
+ else
+ {
+ error_at(this->location(),
+ "arguments 1 and 2 have different types (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ break;
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->complex_type() == NULL)
+ this->report_error(_("argument must have complex type"));
+ }
+ break;
+
+ case BUILTIN_CMPLX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 2)
+ this->report_error(_("too many arguments"));
+ else if (args->front()->is_error_expression()
+ || args->front()->type()->is_error_type()
+ || args->back()->is_error_expression()
+ || args->back()->type()->is_error_type())
+ this->set_is_error();
+ else if (!Type::are_identical(args->front()->type(),
+ args->back()->type(), NULL))
+ this->report_error(_("cmplx arguments must have identical types"));
+ else if (args->front()->type()->float_type() == NULL)
+ this->report_error(_("cmplx arguments must have "
+ "floating-point type"));
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return the tree for a builtin function.
+
+tree
+Builtin_call_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ gcc_unreachable();
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = *args->begin();
+ Type* arg_type = arg->type();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ if (arg_type->points_to() != NULL)
+ {
+ arg_type = arg_type->points_to();
+ gcc_assert(arg_type->array_type() != NULL
+ && !arg_type->is_open_array_type());
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(arg_tree)));
+ arg_tree = build_fold_indirect_ref(arg_tree);
+ }
+
+ tree val_tree;
+ if (this->code_ == BUILTIN_LEN)
+ {
+ if (arg_type->is_string_type())
+ val_tree = String_type::length_tree(gogo, arg_tree);
+ else if (arg_type->array_type() != NULL)
+ val_tree = arg_type->array_type()->length_tree(gogo, arg_tree);
+ else if (arg_type->map_type() != NULL)
+ {
+ static tree map_len_fndecl;
+ val_tree = Gogo::call_builtin(&map_len_fndecl,
+ location,
+ "__go_map_len",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_len_fndecl;
+ val_tree = Gogo::call_builtin(&chan_len_fndecl,
+ location,
+ "__go_chan_len",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ gcc_unreachable();
+ }
+ else
+ {
+ if (arg_type->array_type() != NULL)
+ val_tree = arg_type->array_type()->capacity_tree(gogo, arg_tree);
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_cap_fndecl;
+ val_tree = Gogo::call_builtin(&chan_cap_fndecl,
+ location,
+ "__go_chan_cap",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ gcc_unreachable();
+ }
+
+ tree type_tree = Type::lookup_integer_type("int")->get_tree(gogo);
+ if (type_tree == TREE_TYPE(val_tree))
+ return val_tree;
+ else
+ return fold(convert_to_integer(type_tree, val_tree));
+ }
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const bool is_ln = this->code_ == BUILTIN_PRINTLN;
+ tree stmt_list = NULL_TREE;
+
+ const Expression_list* call_args = this->args();
+ if (call_args != NULL)
+ {
+ for (Expression_list::const_iterator p = call_args->begin();
+ p != call_args->end();
+ ++p)
+ {
+ if (is_ln && p != call_args->begin())
+ {
+ static tree print_space_fndecl;
+ tree call = Gogo::call_builtin(&print_space_fndecl,
+ location,
+ "__go_print_space",
+ 0,
+ void_type_node);
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ Type* type = (*p)->type();
+
+ tree arg = (*p)->get_tree(context);
+ if (arg == error_mark_node)
+ return error_mark_node;
+
+ tree* pfndecl;
+ const char* fnname;
+ if (type->is_string_type())
+ {
+ static tree print_string_fndecl;
+ pfndecl = &print_string_fndecl;
+ fnname = "__go_print_string";
+ }
+ else if (type->integer_type() != NULL
+ && type->integer_type()->is_unsigned())
+ {
+ static tree print_uint64_fndecl;
+ pfndecl = &print_uint64_fndecl;
+ fnname = "__go_print_uint64";
+ Type* itype = Type::lookup_integer_type("uint64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->integer_type() != NULL)
+ {
+ static tree print_int64_fndecl;
+ pfndecl = &print_int64_fndecl;
+ fnname = "__go_print_int64";
+ Type* itype = Type::lookup_integer_type("int64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->float_type() != NULL)
+ {
+ static tree print_double_fndecl;
+ pfndecl = &print_double_fndecl;
+ fnname = "__go_print_double";
+ arg = fold_convert_loc(location, double_type_node, arg);
+ }
+ else if (type->complex_type() != NULL)
+ {
+ static tree print_complex_fndecl;
+ pfndecl = &print_complex_fndecl;
+ fnname = "__go_print_complex";
+ arg = fold_convert_loc(location, complex_double_type_node,
+ arg);
+ }
+ else if (type->is_boolean_type())
+ {
+ static tree print_bool_fndecl;
+ pfndecl = &print_bool_fndecl;
+ fnname = "__go_print_bool";
+ }
+ else if (type->points_to() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL)
+ {
+ static tree print_pointer_fndecl;
+ pfndecl = &print_pointer_fndecl;
+ fnname = "__go_print_pointer";
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+ }
+ else if (type->interface_type() != NULL)
+ {
+ if (type->interface_type()->is_empty())
+ {
+ static tree print_empty_interface_fndecl;
+ pfndecl = &print_empty_interface_fndecl;
+ fnname = "__go_print_empty_interface";
+ }
+ else
+ {
+ static tree print_interface_fndecl;
+ pfndecl = &print_interface_fndecl;
+ fnname = "__go_print_interface";
+ }
+ }
+ else if (type->is_open_array_type())
+ {
+ static tree print_slice_fndecl;
+ pfndecl = &print_slice_fndecl;
+ fnname = "__go_print_slice";
+ }
+ else
+ gcc_unreachable();
+
+ tree call = Gogo::call_builtin(pfndecl,
+ location,
+ fnname,
+ 1,
+ void_type_node,
+ TREE_TYPE(arg),
+ arg);
+ append_to_statement_list(call, &stmt_list);
+ }
+ }
+
+ if (is_ln)
+ {
+ static tree print_nl_fndecl;
+ tree call = Gogo::call_builtin(&print_nl_fndecl,
+ location,
+ "__go_print_nl",
+ 0,
+ void_type_node);
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ return stmt_list;
+ }
+
+ case BUILTIN_PANIC:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ arg_tree = Expression::convert_for_assignment(context, empty,
+ arg->type(),
+ arg_tree, location);
+ static tree panic_fndecl;
+ tree call = Gogo::call_builtin(&panic_fndecl,
+ location,
+ "__go_panic",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ // This function will throw an exception.
+ TREE_NOTHROW(panic_fndecl) = 0;
+ // This function will not return.
+ TREE_THIS_VOLATILE(panic_fndecl) = 1;
+ return call;
+ }
+
+ case BUILTIN_RECOVER:
+ {
+ // The argument is set when building recover thunks. It's a
+ // boolean value which is true if we can recover a value now.
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ tree empty_tree = empty->get_tree(context->gogo());
+
+ Type* nil_type = Type::make_nil_type();
+ Expression* nil = Expression::make_nil(location);
+ tree nil_tree = nil->get_tree(context);
+ tree empty_nil_tree = Expression::convert_for_assignment(context,
+ empty,
+ nil_type,
+ nil_tree,
+ location);
+
+ // We need to handle a deferred call to recover specially,
+ // because it changes whether it can recover a panic or not.
+ // See test7 in test/recover1.go.
+ tree call;
+ if (this->is_deferred())
+ {
+ static tree deferred_recover_fndecl;
+ call = Gogo::call_builtin(&deferred_recover_fndecl,
+ location,
+ "__go_deferred_recover",
+ 0,
+ empty_tree);
+ }
+ else
+ {
+ static tree recover_fndecl;
+ call = Gogo::call_builtin(&recover_fndecl,
+ location,
+ "__go_recover",
+ 0,
+ empty_tree);
+ }
+ return fold_build3_loc(location, COND_EXPR, empty_tree, arg_tree,
+ call, empty_nil_tree);
+ }
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_CLOSED:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ if (this->code_ == BUILTIN_CLOSE)
+ {
+ static tree close_fndecl;
+ return Gogo::call_builtin(&close_fndecl,
+ location,
+ "__go_builtin_close",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ }
+ else
+ {
+ static tree closed_fndecl;
+ return Gogo::call_builtin(&closed_fndecl,
+ location,
+ "__go_builtin_closed",
+ 1,
+ boolean_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ }
+ }
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_ALIGNOF:
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ bool b = this->integer_constant_value(true, val, &dummy);
+ gcc_assert(b);
+ tree type = Type::lookup_integer_type("int")->get_tree(gogo);
+ tree ret = Expression::integer_constant_tree(val, type);
+ mpz_clear(val);
+ return ret;
+ }
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ Type* arg1_type = arg1->type();
+ Array_type* at = arg1_type->array_type();
+ arg1_tree = save_expr(arg1_tree);
+ tree arg1_val = at->value_pointer_tree(gogo, arg1_tree);
+ tree arg1_len = at->length_tree(gogo, arg1_tree);
+
+ Type* arg2_type = arg2->type();
+ tree arg2_val;
+ tree arg2_len;
+ if (arg2_type->is_open_array_type())
+ {
+ at = arg2_type->array_type();
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ arg2_len = at->length_tree(gogo, arg2_tree);
+ }
+ else
+ {
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = String_type::bytes_tree(gogo, arg2_tree);
+ arg2_len = String_type::length_tree(gogo, arg2_tree);
+ }
+
+ arg1_len = save_expr(arg1_len);
+ arg2_len = save_expr(arg2_len);
+ tree len = fold_build3_loc(location, COND_EXPR, TREE_TYPE(arg1_len),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ arg1_len, arg2_len),
+ arg1_len, arg2_len);
+ len = save_expr(len);
+
+ Type* element_type = at->element_type();
+ tree element_type_tree = element_type->get_tree(gogo);
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree bytecount = fold_convert_loc(location, TREE_TYPE(element_size),
+ len);
+ bytecount = fold_build2_loc(location, MULT_EXPR,
+ TREE_TYPE(element_size),
+ bytecount, element_size);
+ bytecount = fold_convert_loc(location, size_type_node, bytecount);
+
+ tree call = build_call_expr_loc(location,
+ built_in_decls[BUILT_IN_MEMMOVE],
+ 3, arg1_val, arg2_val, bytecount);
+
+ return fold_build2_loc(location, COMPOUND_EXPR, TREE_TYPE(len),
+ call, len);
+ }
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ tree descriptor_tree = arg1->type()->type_descriptor_pointer(gogo);
+
+ // We rebuild the decl each time since the slice types may
+ // change.
+ tree append_fndecl = NULL_TREE;
+ return Gogo::call_builtin(&append_fndecl,
+ location,
+ "__go_append",
+ 3,
+ TREE_TYPE(arg1_tree),
+ TREE_TYPE(descriptor_tree),
+ descriptor_tree,
+ TREE_TYPE(arg1_tree),
+ arg1_tree,
+ TREE_TYPE(arg2_tree),
+ arg2_tree);
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(COMPLEX_FLOAT_TYPE_P(TREE_TYPE(arg_tree)));
+ if (this->code_ == BUILTIN_REAL)
+ return fold_build1_loc(location, REALPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ else
+ return fold_build1_loc(location, IMAGPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ }
+
+ case BUILTIN_CMPLX:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ tree r = args->front()->get_tree(context);
+ tree i = args->back()->get_tree(context);
+ if (r == error_mark_node || i == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(r))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(i)));
+ gcc_assert(SCALAR_FLOAT_TYPE_P(TREE_TYPE(r)));
+ return fold_build2_loc(location, COMPLEX_EXPR,
+ build_complex_type(TREE_TYPE(r)),
+ r, i);
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// We have to support exporting a builtin call expression, because
+// code can set a constant to the result of a builtin expression.
+
+void
+Builtin_call_expression::do_export(Export* exp) const
+{
+ bool ok = false;
+
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy))
+ {
+ Integer_expression::export_integer(exp, val);
+ ok = true;
+ }
+ mpz_clear(val);
+
+ if (!ok)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->float_constant_value(fval, &dummy))
+ {
+ Float_expression::export_float(exp, fval);
+ ok = true;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (!ok)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (this->complex_constant_value(real, imag, &dummy))
+ {
+ Complex_expression::export_complex(exp, real, imag);
+ ok = true;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (!ok)
+ {
+ error_at(this->location(), "value is not constant");
+ return;
+ }
+
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Class Call_expression.
+
+// Traversal.
+
+int
+Call_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->fn_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->args_ != NULL)
+ {
+ if (this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a call statement.
+
+Expression*
+Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ // A type case can look like a function call.
+ if (this->fn_->is_type_expression()
+ && this->args_ != NULL
+ && this->args_->size() == 1)
+ return Expression::make_cast(this->fn_->type(), this->args_->front(),
+ this->location());
+
+ // Recognize a call to a builtin function.
+ Func_expression* fne = this->fn_->func_expression();
+ if (fne != NULL
+ && fne->named_object()->is_function_declaration()
+ && fne->named_object()->func_declaration_value()->type()->is_builtin())
+ return new Builtin_call_expression(gogo, this->fn_, this->args_,
+ this->is_varargs_, this->location());
+
+ // Handle an argument which is a call to a function which returns
+ // multiple results.
+ if (this->args_ != NULL
+ && this->args_->size() == 1
+ && this->args_->front()->call_expression() != NULL
+ && this->fn_->type()->function_type() != NULL)
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ size_t rc = this->args_->front()->call_expression()->result_count();
+ if (rc > 1
+ && fntype->parameters() != NULL
+ && (fntype->parameters()->size() == rc
+ || (fntype->is_varargs()
+ && fntype->parameters()->size() - 1 <= rc)))
+ {
+ Call_expression* call = this->args_->front()->call_expression();
+ Expression_list* args = new Expression_list;
+ for (size_t i = 0; i < rc; ++i)
+ args->push_back(Expression::make_call_result(call, i));
+ // We can't return a new call expression here, because this
+ // one may be referenced by Call_result expressions. FIXME.
+ delete this->args_;
+ this->args_ = args;
+ }
+ }
+
+ // Handle a call to a varargs function by packaging up the extra
+ // parameters.
+ if (this->fn_->type()->function_type() != NULL
+ && this->fn_->type()->function_type()->is_varargs())
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ const Typed_identifier_list* parameters = fntype->parameters();
+ gcc_assert(parameters != NULL && !parameters->empty());
+ Type* varargs_type = parameters->back().type();
+ return this->lower_varargs(gogo, function, varargs_type,
+ parameters->size());
+ }
+
+ return this;
+}
+
+// Lower a call to a varargs function. FUNCTION is the function in
+// which the call occurs--it's not the function we are calling.
+// VARARGS_TYPE is the type of the varargs parameter, a slice type.
+// PARAM_COUNT is the number of parameters of the function we are
+// calling; the last of these parameters will be the varargs
+// parameter.
+
+Expression*
+Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
+ Type* varargs_type, size_t param_count)
+{
+ if (this->varargs_are_lowered_)
+ return this;
+
+ source_location loc = this->location();
+
+ gcc_assert(param_count > 0);
+ gcc_assert(varargs_type->is_open_array_type());
+
+ size_t arg_count = this->args_ == NULL ? 0 : this->args_->size();
+ if (arg_count < param_count - 1)
+ {
+ // Not enough arguments; will be caught in check_types.
+ return this;
+ }
+
+ Expression_list* old_args = this->args_;
+ Expression_list* new_args = new Expression_list();
+ bool push_empty_arg = false;
+ if (old_args == NULL || old_args->empty())
+ {
+ gcc_assert(param_count == 1);
+ push_empty_arg = true;
+ }
+ else
+ {
+ Expression_list::const_iterator pa;
+ int i = 1;
+ for (pa = old_args->begin(); pa != old_args->end(); ++pa, ++i)
+ {
+ if (static_cast<size_t>(i) == param_count)
+ break;
+ new_args->push_back(*pa);
+ }
+
+ // We have reached the varargs parameter.
+
+ bool issued_error = false;
+ if (pa == old_args->end())
+ push_empty_arg = true;
+ else if (pa + 1 == old_args->end() && this->is_varargs_)
+ new_args->push_back(*pa);
+ else if (this->is_varargs_)
+ {
+ this->report_error(_("too many arguments"));
+ return this;
+ }
+ else if (pa + 1 == old_args->end()
+ && this->is_compatible_varargs_argument(function, *pa,
+ varargs_type,
+ &issued_error))
+ new_args->push_back(*pa);
+ else
+ {
+ Type* element_type = varargs_type->array_type()->element_type();
+ Expression_list* vals = new Expression_list;
+ for (; pa != old_args->end(); ++pa, ++i)
+ {
+ // Check types here so that we get a better message.
+ Type* patype = (*pa)->type();
+ source_location paloc = (*pa)->location();
+ if (!this->check_argument_type(i, element_type, patype,
+ paloc, issued_error))
+ continue;
+ vals->push_back(*pa);
+ }
+ Expression* val =
+ Expression::make_slice_composite_literal(varargs_type, vals, loc);
+ new_args->push_back(val);
+ }
+ }
+
+ if (push_empty_arg)
+ new_args->push_back(Expression::make_nil(loc));
+
+ // We can't return a new call expression here, because this one may
+ // be referenced by Call_result expressions. FIXME.
+ if (old_args != NULL)
+ delete old_args;
+ this->args_ = new_args;
+ this->varargs_are_lowered_ = true;
+
+ // Lower all the new subexpressions.
+ Expression* ret = this;
+ gogo->lower_expression(function, &ret);
+ gcc_assert(ret == this);
+ return ret;
+}
+
+// Return true if ARG is a varargs argment which should be passed to
+// the varargs parameter of type PARAM_TYPE without wrapping. ARG
+// will be the last argument passed in the call, and PARAM_TYPE will
+// be the type of the last parameter of the varargs function being
+// called.
+
+bool
+Call_expression::is_compatible_varargs_argument(Named_object* function,
+ Expression* arg,
+ Type* param_type,
+ bool* issued_error)
+{
+ *issued_error = false;
+
+ Type* var_type = NULL;
+
+ // The simple case is passing the varargs parameter of the caller.
+ Var_expression* ve = arg->var_expression();
+ if (ve != NULL && ve->named_object()->is_variable())
+ {
+ Variable* var = ve->named_object()->var_value();
+ if (var->is_varargs_parameter())
+ var_type = var->type();
+ }
+
+ // The complex case is passing the varargs parameter of some
+ // enclosing function. This will look like passing down *c.f where
+ // c is the closure variable and f is a field in the closure.
+ if (function != NULL
+ && function->func_value()->needs_closure()
+ && arg->classification() == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(arg);
+ if (ue->op() == OPERATOR_MULT)
+ {
+ Field_reference_expression* fre =
+ ue->operand()->deref()->field_reference_expression();
+ if (fre != NULL)
+ {
+ Var_expression* ve = fre->expr()->deref()->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* no = ve->named_object();
+ Function* f = function->func_value();
+ if (no == f->closure_var())
+ {
+ // At this point we know that this indeed a
+ // reference to some enclosing variable. Now we
+ // need to figure out whether that variable is a
+ // varargs parameter.
+ Named_object* enclosing =
+ f->enclosing_var(fre->field_index());
+ Variable* var = enclosing->var_value();
+ if (var->is_varargs_parameter())
+ var_type = var->type();
+ }
+ }
+ }
+ }
+ }
+
+ if (var_type == NULL)
+ return false;
+
+ // We only match if the parameter is the same, with an identical
+ // type.
+ Array_type* var_at = var_type->array_type();
+ gcc_assert(var_at != NULL);
+ Array_type* param_at = param_type->array_type();
+ if (param_at != NULL
+ && Type::are_identical(var_at->element_type(),
+ param_at->element_type(), NULL))
+ return true;
+ error_at(arg->location(), "... mismatch: passing ...T as ...");
+ *issued_error = true;
+ return false;
+}
+
+// Get the function type. Returns NULL if we don't know the type. If
+// this returns NULL, and if_ERROR is true, issues an error.
+
+Function_type*
+Call_expression::get_function_type() const
+{
+ return this->fn_->type()->function_type();
+}
+
+// Return the number of values which this call will return.
+
+size_t
+Call_expression::result_count() const
+{
+ const Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return 0;
+ if (fntype->results() == NULL)
+ return 0;
+ return fntype->results()->size();
+}
+
+// Return whether this is a call to the predeclared function recover.
+
+bool
+Call_expression::is_recover_call() const
+{
+ return this->do_is_recover_call();
+}
+
+// Set the argument to the recover function.
+
+void
+Call_expression::set_recover_arg(Expression* arg)
+{
+ this->do_set_recover_arg(arg);
+}
+
+// Virtual functions also implemented by Builtin_call_expression.
+
+bool
+Call_expression::do_is_recover_call() const
+{
+ return false;
+}
+
+void
+Call_expression::do_set_recover_arg(Expression*)
+{
+ gcc_unreachable();
+}
+
+// Get the type.
+
+Type*
+Call_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+
+ Type* ret;
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results == NULL)
+ ret = Type::make_void_type();
+ else if (results->size() == 1)
+ ret = results->begin()->type();
+ else
+ ret = Type::make_call_multiple_result_type(this);
+
+ this->type_ = ret;
+
+ return this->type_;
+}
+
+// Determine types for a call expression. We can use the function
+// parameter types to set the types of the arguments.
+
+void
+Call_expression::do_determine_type(const Type_context*)
+{
+ this->fn_->determine_type_no_context();
+ Function_type* fntype = this->get_function_type();
+ const Typed_identifier_list* parameters = NULL;
+ if (fntype != NULL)
+ parameters = fntype->parameters();
+ if (this->args_ != NULL)
+ {
+ Typed_identifier_list::const_iterator pt;
+ if (parameters != NULL)
+ pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa)
+ {
+ if (parameters != NULL && pt != parameters->end())
+ {
+ Type_context subcontext(pt->type(), false);
+ (*pa)->determine_type(&subcontext);
+ ++pt;
+ }
+ else
+ (*pa)->determine_type_no_context();
+ }
+ }
+}
+
+// Check types for parameter I.
+
+bool
+Call_expression::check_argument_type(int i, const Type* parameter_type,
+ const Type* argument_type,
+ source_location argument_location,
+ bool issued_error)
+{
+ std::string reason;
+ if (!Type::are_assignable(parameter_type, argument_type, &reason))
+ {
+ if (!issued_error)
+ {
+ if (reason.empty())
+ error_at(argument_location, "argument %d has incompatible type", i);
+ else
+ error_at(argument_location,
+ "argument %d has incompatible type (%s)",
+ i, reason.c_str());
+ }
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check types.
+
+void
+Call_expression::do_check_types(Gogo*)
+{
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ {
+ if (!this->fn_->type()->is_error_type())
+ this->report_error(_("expected function"));
+ return;
+ }
+
+ if (fntype->is_method())
+ {
+ // We don't support pointers to methods, so the function has to
+ // be a bound method expression.
+ Bound_method_expression* bme = this->fn_->bound_method_expression();
+ if (bme == NULL)
+ {
+ this->report_error(_("method call without object"));
+ return;
+ }
+ Type* first_arg_type = bme->first_argument()->type();
+ if (first_arg_type->points_to() == NULL)
+ {
+ // When passing a value, we need to check that we are
+ // permitted to copy it.
+ std::string reason;
+ if (!Type::are_assignable(fntype->receiver()->type(),
+ first_arg_type, &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for receiver"));
+ else
+ {
+ error_at(this->location(),
+ "incompatible type for receiver (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ }
+ }
+
+ // Note that varargs was handled by the lower_varargs() method, so
+ // we don't have to worry about it here.
+
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (this->args_ == NULL)
+ {
+ if (parameters != NULL && !parameters->empty())
+ this->report_error(_("not enough arguments"));
+ }
+ else if (parameters == NULL)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ int i = 0;
+ Typed_identifier_list::const_iterator pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa, ++pt, ++i)
+ {
+ if (pt == parameters->end())
+ {
+ this->report_error(_("too many arguments"));
+ return;
+ }
+ this->check_argument_type(i + 1, pt->type(), (*pa)->type(),
+ (*pa)->location(), false);
+ }
+ if (pt != parameters->end())
+ this->report_error(_("not enough arguments"));
+ }
+}
+
+// Return whether we have to use a temporary variable to ensure that
+// we evaluate this call expression in order. If the call returns no
+// results then it will inevitably be executed last. If the call
+// returns more than one result then it will be used with Call_result
+// expressions. So we only have to use a temporary variable if the
+// call returns exactly one result.
+
+bool
+Call_expression::do_must_eval_in_order() const
+{
+ return this->result_count() == 1;
+}
+
+// Get the function and the first argument to use when calling a bound
+// method.
+
+tree
+Call_expression::bound_method_function(Translate_context* context,
+ Bound_method_expression* bound_method,
+ tree* first_arg_ptr)
+{
+ Expression* first_argument = bound_method->first_argument();
+ tree first_arg = first_argument->get_tree(context);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+
+ // We always pass a pointer to the first argument when calling a
+ // method.
+ if (first_argument->type()->points_to() == NULL)
+ {
+ tree pointer_to_arg_type = build_pointer_type(TREE_TYPE(first_arg));
+ if (TREE_ADDRESSABLE(TREE_TYPE(first_arg))
+ || DECL_P(first_arg)
+ || TREE_CODE(first_arg) == INDIRECT_REF
+ || TREE_CODE(first_arg) == COMPONENT_REF)
+ {
+ first_arg = build_fold_addr_expr(first_arg);
+ if (DECL_P(first_arg))
+ TREE_ADDRESSABLE(first_arg) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(first_arg),
+ get_name(first_arg));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = first_arg;
+ first_arg = build2(COMPOUND_EXPR, pointer_to_arg_type,
+ build1(DECL_EXPR, void_type_node, tmp),
+ build_fold_addr_expr(tmp));
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ }
+
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ first_arg = fold_convert(fatype->get_tree(context->gogo()), first_arg);
+ if (first_arg == error_mark_node
+ || TREE_TYPE(first_arg) == error_mark_node)
+ return error_mark_node;
+ }
+
+ *first_arg_ptr = first_arg;
+
+ return bound_method->method()->get_tree(context);
+}
+
+// Get the function and the first argument to use when calling an
+// interface method.
+
+tree
+Call_expression::interface_method_function(
+ Translate_context* context,
+ Interface_field_reference_expression* interface_method,
+ tree* first_arg_ptr)
+{
+ tree expr = interface_method->expr()->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+ expr = save_expr(expr);
+ tree first_arg = interface_method->get_underlying_object_tree(context, expr);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ *first_arg_ptr = first_arg;
+ return interface_method->get_function_tree(context, expr);
+}
+
+// Build the call expression.
+
+tree
+Call_expression::do_get_tree(Translate_context* context)
+{
+ if (this->tree_ != NULL_TREE)
+ return this->tree_;
+
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return error_mark_node;
+
+ if (this->fn_->is_error_expression())
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+
+ Func_expression* func = this->fn_->func_expression();
+ Bound_method_expression* bound_method = this->fn_->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ this->fn_->interface_field_reference_expression();
+ const bool has_closure = func != NULL && func->closure() != NULL;
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+ gcc_assert(!fntype->is_method() || is_method);
+
+ int nargs;
+ tree* args;
+ if (this->args_ == NULL || this->args_->empty())
+ {
+ nargs = is_method ? 1 : 0;
+ args = nargs == 0 ? NULL : new tree[nargs];
+ }
+ else
+ {
+ const Typed_identifier_list* params = fntype->parameters();
+ gcc_assert(params != NULL);
+
+ nargs = this->args_->size();
+ int i = is_method ? 1 : 0;
+ nargs += i;
+ args = new tree[nargs];
+
+ Typed_identifier_list::const_iterator pp = params->begin();
+ Expression_list::const_iterator pe;
+ for (pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe, ++pp, ++i)
+ {
+ tree arg_val = (*pe)->get_tree(context);
+ args[i] = Expression::convert_for_assignment(context,
+ pp->type(),
+ (*pe)->type(),
+ arg_val,
+ location);
+ if (args[i] == error_mark_node)
+ return error_mark_node;
+ }
+ gcc_assert(pp == params->end());
+ gcc_assert(i == nargs);
+ }
+
+ tree rettype = TREE_TYPE(TREE_TYPE(fntype->get_tree(gogo)));
+ if (rettype == error_mark_node)
+ return error_mark_node;
+
+ tree fn;
+ if (has_closure)
+ fn = func->get_tree_without_closure(gogo);
+ else if (!is_method)
+ fn = this->fn_->get_tree(context);
+ else if (bound_method != NULL)
+ fn = this->bound_method_function(context, bound_method, &args[0]);
+ else if (interface_method != NULL)
+ fn = this->interface_method_function(context, interface_method, &args[0]);
+ else
+ gcc_unreachable();
+
+ if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
+ return error_mark_node;
+
+ // This is to support builtin math functions when using 80387 math.
+ tree fndecl = fn;
+ if (TREE_CODE(fndecl) == ADDR_EXPR)
+ fndecl = TREE_OPERAND(fndecl, 0);
+ tree excess_type = NULL_TREE;
+ if (DECL_P(fndecl)
+ && DECL_IS_BUILTIN(fndecl)
+ && DECL_BUILT_IN_CLASS(fndecl) == BUILT_IN_NORMAL
+ && nargs > 0
+ && ((SCALAR_FLOAT_TYPE_P(rettype)
+ && SCALAR_FLOAT_TYPE_P(TREE_TYPE(args[0])))
+ || (COMPLEX_FLOAT_TYPE_P(rettype)
+ && COMPLEX_FLOAT_TYPE_P(TREE_TYPE(args[0])))))
+ {
+ excess_type = excess_precision_type(TREE_TYPE(args[0]));
+ if (excess_type != NULL_TREE)
+ {
+ tree excess_fndecl = mathfn_built_in(excess_type,
+ DECL_FUNCTION_CODE(fndecl));
+ if (excess_fndecl == NULL_TREE)
+ excess_type = NULL_TREE;
+ else
+ {
+ fn = build_fold_addr_expr_loc(location, excess_fndecl);
+ for (int i = 0; i < nargs; ++i)
+ args[i] = ::convert(excess_type, args[i]);
+ }
+ }
+ }
+
+ tree ret = build_call_array(excess_type != NULL_TREE ? excess_type : rettype,
+ fn, nargs, args);
+ delete[] args;
+
+ SET_EXPR_LOCATION(ret, location);
+
+ if (has_closure)
+ {
+ tree closure_tree = func->closure()->get_tree(context);
+ if (closure_tree != error_mark_node)
+ CALL_EXPR_STATIC_CHAIN(ret) = closure_tree;
+ }
+
+ // If this is a recursive function type which returns itself, as in
+ // type F func() F
+ // we have used ptr_type_node for the return type. Add a cast here
+ // to the correct type.
+ if (TREE_TYPE(ret) == ptr_type_node)
+ {
+ tree t = this->type()->get_tree(gogo);
+ ret = fold_convert_loc(location, t, ret);
+ }
+
+ if (excess_type != NULL_TREE)
+ {
+ // Calling convert here can undo our excess precision change.
+ // That may or may not be a bug in convert_to_real.
+ ret = build1(NOP_EXPR, rettype, ret);
+ }
+
+ // If there is more than one result, we will refer to the call
+ // multiple times.
+ if (fntype->results() != NULL && fntype->results()->size() > 1)
+ ret = save_expr(ret);
+
+ this->tree_ = ret;
+
+ return ret;
+}
+
+// Make a call expression.
+
+Call_expression*
+Expression::make_call(Expression* fn, Expression_list* args, bool is_varargs,
+ source_location location)
+{
+ return new Call_expression(fn, args, is_varargs, location);
+}
+
+// A single result from a call which returns multiple results.
+
+class Call_result_expression : public Expression
+{
+ public:
+ Call_result_expression(Call_expression* call, unsigned int index)
+ : Expression(EXPRESSION_CALL_RESULT, call->location()),
+ call_(call), index_(index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Call_result_expression(this->call_->call_expression(),
+ this->index_);
+ }
+
+ bool
+ do_must_eval_in_order() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The underlying call expression.
+ Expression* call_;
+ // Which result we want.
+ unsigned int index_;
+};
+
+// Traverse a call result.
+
+int
+Call_result_expression::do_traverse(Traverse* traverse)
+{
+ if (traverse->remember_expression(this->call_))
+ {
+ // We have already traversed the call expression.
+ return TRAVERSE_CONTINUE;
+ }
+ return Expression::traverse(&this->call_, traverse);
+}
+
+// Get the type.
+
+Type*
+Call_result_expression::do_type()
+{
+ // THIS->CALL_ can be replaced with a temporary reference due to
+ // Call_expression::do_must_eval_in_order when there is an error.
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ return Type::make_error_type();
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL)
+ return Type::make_error_type();
+ const Typed_identifier_list* results = fntype->results();
+ Typed_identifier_list::const_iterator pr = results->begin();
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ if (pr == results->end())
+ return Type::make_error_type();
+ ++pr;
+ }
+ if (pr == results->end())
+ return Type::make_error_type();
+ return pr->type();
+}
+
+// Check the type. This is where we give an error if we're trying to
+// extract too many values from a call.
+
+void
+Call_result_expression::do_check_types(Gogo*)
+{
+ bool ok = true;
+ Call_expression* ce = this->call_->call_expression();
+ if (ce != NULL)
+ ok = this->index_ < ce->result_count();
+ else
+ {
+ // This can happen when the call returns a single value but we
+ // are asking for the second result.
+ if (this->call_->is_error_expression())
+ return;
+ ok = false;
+ }
+ if (!ok)
+ error_at(this->location(),
+ "number of results does not match number of values");
+}
+
+// Determine the type. We have nothing to do here, but the 0 result
+// needs to pass down to the caller.
+
+void
+Call_result_expression::do_determine_type(const Type_context*)
+{
+ if (this->index_ == 0)
+ this->call_->determine_type_no_context();
+}
+
+// Return the tree.
+
+tree
+Call_result_expression::do_get_tree(Translate_context* context)
+{
+ tree call_tree = this->call_->get_tree(context);
+ if (call_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(TREE_TYPE(call_tree)) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ gcc_assert(field != NULL_TREE);
+ field = DECL_CHAIN(field);
+ }
+ gcc_assert(field != NULL_TREE);
+ return build3(COMPONENT_REF, TREE_TYPE(field), call_tree, field, NULL_TREE);
+}
+
+// Make a reference to a single result of a call which returns
+// multiple results.
+
+Expression*
+Expression::make_call_result(Call_expression* call, unsigned int index)
+{
+ return new Call_result_expression(call, index);
+}
+
+// Class Index_expression.
+
+// Traversal.
+
+int
+Index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->left_, traverse) == TRAVERSE_EXIT
+ || Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT
+ || (this->end_ != NULL
+ && Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT))
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower an index expression. This converts the generic index
+// expression into an array index, a string index, or a map index.
+
+Expression*
+Index_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Expression* left = this->left_;
+ Expression* start = this->start_;
+ Expression* end = this->end_;
+
+ Type* type = left->type();
+ if (type->is_error_type())
+ return Expression::make_error(location);
+ else if (type->array_type() != NULL)
+ return Expression::make_array_index(left, start, end, location);
+ else if (type->points_to() != NULL
+ && type->points_to()->array_type() != NULL
+ && !type->points_to()->is_open_array_type())
+ {
+ Expression* deref = Expression::make_unary(OPERATOR_MULT, left,
+ location);
+ return Expression::make_array_index(deref, start, end, location);
+ }
+ else if (type->is_string_type())
+ return Expression::make_string_index(left, start, end, location);
+ else if (type->map_type() != NULL)
+ {
+ if (end != NULL)
+ {
+ error_at(location, "invalid slice of map");
+ return Expression::make_error(location);
+ }
+ Map_index_expression* ret= Expression::make_map_index(left, start,
+ location);
+ if (this->is_lvalue_)
+ ret->set_is_lvalue();
+ return ret;
+ }
+ else
+ {
+ error_at(location,
+ "attempt to index object which is not array, string, or map");
+ return Expression::make_error(location);
+ }
+}
+
+// Make an index expression.
+
+Expression*
+Expression::make_index(Expression* left, Expression* start, Expression* end,
+ source_location location)
+{
+ return new Index_expression(left, start, end, location);
+}
+
+// An array index. This is used for both indexing and slicing.
+
+class Array_index_expression : public Expression
+{
+ public:
+ Array_index_expression(Expression* array, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_ARRAY_INDEX, location),
+ array_(array), start_(start), end_(end), type_(NULL)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_array_index(this->array_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const;
+
+ void
+ do_address_taken(bool escapes)
+ { this->array_->address_taken(escapes); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The array we are getting a value from.
+ Expression* array_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a simple array
+ // index, or it may be a nil expression for the length of the array.
+ Expression* end_;
+ // The type of the expression.
+ Type* type_;
+};
+
+// Array index traversal.
+
+int
+Array_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->array_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of an array index.
+
+Type*
+Array_index_expression::do_type()
+{
+ if (this->type_ == NULL)
+ {
+ Array_type* type = this->array_->type()->array_type();
+ if (type == NULL)
+ this->type_ = Type::make_error_type();
+ else if (this->end_ == NULL)
+ this->type_ = type->element_type();
+ else if (type->is_open_array_type())
+ {
+ // A slice of a slice has the same type as the original
+ // slice.
+ this->type_ = this->array_->type()->deref();
+ }
+ else
+ {
+ // A slice of an array is a slice.
+ this->type_ = Type::make_array_type(type->element_type(), NULL);
+ }
+ }
+ return this->type_;
+}
+
+// Set the type of an array index.
+
+void
+Array_index_expression::do_determine_type(const Type_context*)
+{
+ this->array_->determine_type_no_context();
+ Type_context subcontext(NULL, true);
+ this->start_->determine_type(&subcontext);
+ if (this->end_ != NULL)
+ this->end_->determine_type(&subcontext);
+}
+
+// Check types of an array index.
+
+void
+Array_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ Array_type* array_type = this->array_->type()->array_type();
+ gcc_assert(array_type != NULL);
+
+ unsigned int int_bits =
+ Type::lookup_integer_type("int")->integer_type()->bits();
+
+ Type* dummy;
+ mpz_t lval;
+ mpz_init(lval);
+ bool lval_valid = (array_type->length() != NULL
+ && array_type->length()->integer_constant_value(true,
+ lval,
+ &dummy));
+ mpz_t ival;
+ mpz_init(ival);
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid
+ && (this->end_ == NULL
+ ? mpz_cmp(ival, lval) >= 0
+ : mpz_cmp(ival, lval) > 0)))
+ {
+ error_at(this->start_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid && mpz_cmp(ival, lval) > 0))
+ {
+ error_at(this->end_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+ mpz_clear(lval);
+
+ // A slice of an array requires an addressable array. A slice of a
+ // slice is always possible.
+ if (this->end_ != NULL
+ && !array_type->is_open_array_type()
+ && !this->array_->is_addressable())
+ this->report_error(_("array is not addressable"));
+}
+
+// Return whether this expression is addressable.
+
+bool
+Array_index_expression::do_is_addressable() const
+{
+ // A slice expression is not addressable.
+ if (this->end_ != NULL)
+ return false;
+
+ // An index into a slice is addressable.
+ if (this->array_->type()->is_open_array_type())
+ return true;
+
+ // An index into an array is addressable if the array is
+ // addressable.
+ return this->array_->is_addressable();
+}
+
+// Get a tree for an array index.
+
+tree
+Array_index_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Array_type* array_type = this->array_->type()->array_type();
+ gcc_assert(array_type != NULL);
+
+ tree type_tree = array_type->get_tree(gogo);
+
+ tree array_tree = this->array_->get_tree(context);
+ if (array_tree == error_mark_node)
+ return error_mark_node;
+
+ if (array_type->length() == NULL && !DECL_P(array_tree))
+ array_tree = save_expr(array_tree);
+ tree length_tree = array_type->length_tree(gogo, array_tree);
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node, bad_index,
+ fold_build2_loc(loc,
+ (this->end_ == NULL
+ ? GE_EXPR
+ : GT_EXPR),
+ boolean_type_node, start_tree,
+ length_tree));
+
+ int code = (array_type->length() != NULL
+ ? (this->end_ == NULL
+ ? RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS)
+ : (this->end_ == NULL
+ ? RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS));
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ // Simple array indexing. This has to return an l-value, so
+ // wrap the index check into START_TREE.
+ start_tree = build2(COMPOUND_EXPR, TREE_TYPE(start_tree),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ start_tree);
+ start_tree = fold_convert_loc(loc, sizetype, start_tree);
+
+ if (array_type->length() != NULL)
+ {
+ // Fixed array.
+ return build4(ARRAY_REF, TREE_TYPE(type_tree), array_tree,
+ start_tree, NULL_TREE, NULL_TREE);
+ }
+ else
+ {
+ // Open array.
+ tree values = array_type->value_pointer_tree(gogo, array_tree);
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ start_tree, element_size);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(values), values, offset);
+ return build_fold_indirect_ref(ptr);
+ }
+ }
+
+ // Array slice.
+
+ tree capacity_tree = array_type->capacity_tree(gogo, array_tree);
+ capacity_tree = fold_convert_loc(loc, length_type, capacity_tree);
+
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = length_tree;
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type, bad_index,
+ loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+
+ capacity_tree = save_expr(capacity_tree);
+ tree bad_end = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ fold_build2_loc(loc, LT_EXPR,
+ boolean_type_node,
+ end_tree, start_tree),
+ fold_build2_loc(loc, GT_EXPR,
+ boolean_type_node,
+ end_tree, capacity_tree));
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, bad_end);
+ }
+
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ fold_convert_loc(loc, sizetype, start_tree),
+ element_size);
+
+ tree value_pointer = array_type->value_pointer_tree(gogo, array_tree);
+
+ value_pointer = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(value_pointer),
+ value_pointer, offset);
+
+ tree result_length_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ end_tree, start_tree);
+
+ tree result_capacity_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ capacity_tree, start_tree);
+
+ tree struct_tree = this->type()->get_tree(gogo);
+ gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(struct_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = value_pointer;
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_capacity_tree);
+
+ tree constructor = build_constructor(struct_tree, init);
+
+ if (TREE_CONSTANT(value_pointer)
+ && TREE_CONSTANT(result_length_tree)
+ && TREE_CONSTANT(result_capacity_tree))
+ TREE_CONSTANT(constructor) = 1;
+
+ return fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(constructor),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ constructor);
+}
+
+// Make an array index expression. END may be NULL.
+
+Expression*
+Expression::make_array_index(Expression* array, Expression* start,
+ Expression* end, source_location location)
+{
+ // Taking a slice of a composite literal requires moving the literal
+ // onto the heap.
+ if (end != NULL && array->is_composite_literal())
+ {
+ array = Expression::make_heap_composite(array, location);
+ array = Expression::make_unary(OPERATOR_MULT, array, location);
+ }
+ return new Array_index_expression(array, start, end, location);
+}
+
+// A string index. This is used for both indexing and slicing.
+
+class String_index_expression : public Expression
+{
+ public:
+ String_index_expression(Expression* string, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_STRING_INDEX, location),
+ string_(string), start_(start), end_(end)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_string_index(this->string_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The string we are getting a value from.
+ Expression* string_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a single index,
+ // or it may be a nil expression for the length of the string.
+ Expression* end_;
+};
+
+// String index traversal.
+
+int
+String_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->string_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of a string index.
+
+Type*
+String_index_expression::do_type()
+{
+ if (this->end_ == NULL)
+ return Type::lookup_integer_type("uint8");
+ else
+ return Type::make_string_type();
+}
+
+// Determine the type of a string index.
+
+void
+String_index_expression::do_determine_type(const Type_context*)
+{
+ this->string_->determine_type_no_context();
+ Type_context subcontext(NULL, true);
+ this->start_->determine_type(&subcontext);
+ if (this->end_ != NULL)
+ this->end_->determine_type(&subcontext);
+}
+
+// Check types of a string index.
+
+void
+String_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ std::string sval;
+ bool sval_valid = this->string_->string_constant_value(&sval);
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) >= 0))
+ {
+ error_at(this->start_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) > 0))
+ {
+ error_at(this->end_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+}
+
+// Get a tree for a string index.
+
+tree
+String_index_expression::do_get_tree(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ tree string_tree = this->string_->get_tree(context);
+ if (string_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->string_->type()->points_to() != NULL)
+ string_tree = build_fold_indirect_ref(string_tree);
+ if (!DECL_P(string_tree))
+ string_tree = save_expr(string_tree);
+ tree string_type = TREE_TYPE(string_tree);
+
+ tree length_tree = String_type::length_tree(context->gogo(), string_tree);
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+
+ int code = (this->end_ == NULL
+ ? RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS);
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index,
+ fold_build2_loc(loc, GE_EXPR,
+ boolean_type_node,
+ start_tree, length_tree));
+
+ tree bytes_tree = String_type::bytes_tree(context->gogo(), string_tree);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR, TREE_TYPE(bytes_tree),
+ bytes_tree,
+ fold_convert_loc(loc, sizetype, start_tree));
+ tree index = build_fold_indirect_ref_loc(loc, ptr);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(index),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ index);
+ }
+ else
+ {
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = build_int_cst(length_type, -1);
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type,
+ bad_index, loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+ }
+
+ static tree strslice_fndecl;
+ tree ret = Gogo::call_builtin(&strslice_fndecl,
+ loc,
+ "__go_string_slice",
+ 3,
+ string_type,
+ string_type,
+ string_tree,
+ length_type,
+ start_tree,
+ length_type,
+ end_tree);
+ // This will panic if the bounds are out of range for the
+ // string.
+ TREE_NOTHROW(strslice_fndecl) = 0;
+
+ if (bad_index == boolean_false_node)
+ return ret;
+ else
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Make a string index expression. END may be NULL.
+
+Expression*
+Expression::make_string_index(Expression* string, Expression* start,
+ Expression* end, source_location location)
+{
+ return new String_index_expression(string, start, end, location);
+}
+
+// Class Map_index.
+
+// Get the type of the map.
+
+Map_type*
+Map_index_expression::get_map_type() const
+{
+ Map_type* mt = this->map_->type()->deref()->map_type();
+ gcc_assert(mt != NULL);
+ return mt;
+}
+
+// Map index traversal.
+
+int
+Map_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->map_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->index_, traverse);
+}
+
+// Return the type of a map index.
+
+Type*
+Map_index_expression::do_type()
+{
+ Type* type = this->get_map_type()->val_type();
+ // If this map index is in a tuple assignment, we actually return a
+ // pointer to the value type. Tuple_map_assignment_statement is
+ // responsible for handling this correctly. We need to get the type
+ // right in case this gets assigned to a temporary variable.
+ if (this->is_in_tuple_assignment_)
+ type = Type::make_pointer_type(type);
+ return type;
+}
+
+// Fix the type of a map index.
+
+void
+Map_index_expression::do_determine_type(const Type_context*)
+{
+ this->map_->determine_type_no_context();
+ Type_context subcontext(this->get_map_type()->key_type(), false);
+ this->index_->determine_type(&subcontext);
+}
+
+// Check types of a map index.
+
+void
+Map_index_expression::do_check_types(Gogo*)
+{
+ std::string reason;
+ if (!Type::are_assignable(this->get_map_type()->key_type(),
+ this->index_->type(), &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for map index"));
+ else
+ {
+ error_at(this->location(), "incompatible type for map index (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a map index.
+
+tree
+Map_index_expression::do_get_tree(Translate_context* context)
+{
+ Map_type* type = this->get_map_type();
+
+ tree valptr = this->get_value_pointer(context, this->is_lvalue_);
+ if (valptr == error_mark_node)
+ return error_mark_node;
+ valptr = save_expr(valptr);
+
+ tree val_type_tree = TREE_TYPE(TREE_TYPE(valptr));
+
+ if (this->is_lvalue_)
+ return build_fold_indirect_ref(valptr);
+ else if (this->is_in_tuple_assignment_)
+ {
+ // Tuple_map_assignment_statement is responsible for using this
+ // appropriately.
+ return valptr;
+ }
+ else
+ {
+ return fold_build3(COND_EXPR, val_type_tree,
+ fold_build2(EQ_EXPR, boolean_type_node, valptr,
+ fold_convert(TREE_TYPE(valptr),
+ null_pointer_node)),
+ type->val_type()->get_init_tree(context->gogo(),
+ false),
+ build_fold_indirect_ref(valptr));
+ }
+}
+
+// Get a tree for the map index. This returns a tree which evaluates
+// to a pointer to a value. The pointer will be NULL if the key is
+// not in the map.
+
+tree
+Map_index_expression::get_value_pointer(Translate_context* context,
+ bool insert)
+{
+ Map_type* type = this->get_map_type();
+
+ tree map_tree = this->map_->get_tree(context);
+ tree index_tree = this->index_->get_tree(context);
+ index_tree = Expression::convert_for_assignment(context, type->key_type(),
+ this->index_->type(),
+ index_tree,
+ this->location());
+ if (map_tree == error_mark_node || index_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->map_->type()->points_to() != NULL)
+ map_tree = build_fold_indirect_ref(map_tree);
+
+ // We need to pass in a pointer to the key, so stuff it into a
+ // variable.
+ tree tmp = create_tmp_var(TREE_TYPE(index_tree), get_name(index_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = index_tree;
+ tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ tree tmpref = fold_convert(const_ptr_type_node, build_fold_addr_expr(tmp));
+ TREE_ADDRESSABLE(tmp) = 1;
+
+ static tree map_index_fndecl;
+ tree call = Gogo::call_builtin(&map_index_fndecl,
+ this->location(),
+ "__go_map_index",
+ 3,
+ const_ptr_type_node,
+ TREE_TYPE(map_tree),
+ map_tree,
+ const_ptr_type_node,
+ tmpref,
+ boolean_type_node,
+ (insert
+ ? boolean_true_node
+ : boolean_false_node));
+ // This can panic on a map of interface type if the interface holds
+ // an uncomparable or unhashable type.
+ TREE_NOTHROW(map_index_fndecl) = 0;
+
+ tree val_type_tree = type->val_type()->get_tree(context->gogo());
+ if (val_type_tree == error_mark_node)
+ return error_mark_node;
+ tree ptr_val_type_tree = build_pointer_type(val_type_tree);
+
+ return build2(COMPOUND_EXPR, ptr_val_type_tree,
+ make_tmp,
+ fold_convert(ptr_val_type_tree, call));
+}
+
+// Make a map index expression.
+
+Map_index_expression*
+Expression::make_map_index(Expression* map, Expression* index,
+ source_location location)
+{
+ return new Map_index_expression(map, index, location);
+}
+
+// Class Field_reference_expression.
+
+// Return the type of a field reference.
+
+Type*
+Field_reference_expression::do_type()
+{
+ Struct_type* struct_type = this->expr_->type()->struct_type();
+ gcc_assert(struct_type != NULL);
+ return struct_type->field(this->field_index_)->type();
+}
+
+// Check the types for a field reference.
+
+void
+Field_reference_expression::do_check_types(Gogo*)
+{
+ Struct_type* struct_type = this->expr_->type()->struct_type();
+ gcc_assert(struct_type != NULL);
+ gcc_assert(struct_type->field(this->field_index_) != NULL);
+}
+
+// Get a tree for a field reference.
+
+tree
+Field_reference_expression::do_get_tree(Translate_context* context)
+{
+ tree struct_tree = this->expr_->get_tree(context);
+ if (struct_tree == error_mark_node
+ || TREE_TYPE(struct_tree) == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(TREE_TYPE(struct_tree)) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(TREE_TYPE(struct_tree));
+ gcc_assert(field != NULL_TREE);
+ for (unsigned int i = this->field_index_; i > 0; --i)
+ {
+ field = DECL_CHAIN(field);
+ gcc_assert(field != NULL_TREE);
+ }
+ return build3(COMPONENT_REF, TREE_TYPE(field), struct_tree, field,
+ NULL_TREE);
+}
+
+// Make a reference to a qualified identifier in an expression.
+
+Field_reference_expression*
+Expression::make_field_reference(Expression* expr, unsigned int field_index,
+ source_location location)
+{
+ return new Field_reference_expression(expr, field_index, location);
+}
+
+// Class Interface_field_reference_expression.
+
+// Return a tree for the pointer to the function to call.
+
+tree
+Interface_field_reference_expression::get_function_tree(Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ gcc_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = TYPE_FIELDS(expr_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods") == 0);
+
+ tree table = build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(table)));
+
+ table = build_fold_indirect_ref(table);
+ gcc_assert(TREE_CODE(TREE_TYPE(table)) == RECORD_TYPE);
+
+ std::string name = Gogo::unpack_hidden_name(this->name_);
+ for (field = DECL_CHAIN(TYPE_FIELDS(TREE_TYPE(table)));
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ if (name == IDENTIFIER_POINTER(DECL_NAME(field)))
+ break;
+ }
+ gcc_assert(field != NULL_TREE);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), table, field, NULL_TREE);
+}
+
+// Return a tree for the first argument to pass to the interface
+// function.
+
+tree
+Interface_field_reference_expression::get_underlying_object_tree(
+ Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ gcc_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(expr_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+}
+
+// Traversal.
+
+int
+Interface_field_reference_expression::do_traverse(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Return the type of an interface field reference.
+
+Type*
+Interface_field_reference_expression::do_type()
+{
+ Type* expr_type = this->expr_->type();
+
+ Type* points_to = expr_type->points_to();
+ if (points_to != NULL)
+ expr_type = points_to;
+
+ Interface_type* interface_type = expr_type->interface_type();
+ if (interface_type == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier* method = interface_type->find_method(this->name_);
+ if (method == NULL)
+ return Type::make_error_type();
+
+ return method->type();
+}
+
+// Determine types.
+
+void
+Interface_field_reference_expression::do_determine_type(const Type_context*)
+{
+ this->expr_->determine_type_no_context();
+}
+
+// Check the types for an interface field reference.
+
+void
+Interface_field_reference_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+
+ Type* points_to = type->points_to();
+ if (points_to != NULL)
+ type = points_to;
+
+ Interface_type* interface_type = type->interface_type();
+ if (interface_type == NULL)
+ this->report_error(_("expected interface or pointer to interface"));
+ else
+ {
+ const Typed_identifier* method =
+ interface_type->find_method(this->name_);
+ if (method == NULL)
+ {
+ error_at(this->location(), "method %qs not in interface",
+ Gogo::message_name(this->name_).c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a reference to a field in an interface. There is no
+// standard tree type representation for this: it's a function
+// attached to its first argument, like a Bound_method_expression.
+// The only places it may currently be used are in a Call_expression
+// or a Go_statement, which will take it apart directly. So this has
+// nothing to do at present.
+
+tree
+Interface_field_reference_expression::do_get_tree(Translate_context*)
+{
+ gcc_unreachable();
+}
+
+// Make a reference to a field in an interface.
+
+Expression*
+Expression::make_interface_field_reference(Expression* expr,
+ const std::string& field,
+ source_location location)
+{
+ return new Interface_field_reference_expression(expr, field, location);
+}
+
+// A general selector. This is a Parser_expression for LEFT.NAME. It
+// is lowered after we know the type of the left hand side.
+
+class Selector_expression : public Parser_expression
+{
+ public:
+ Selector_expression(Expression* left, const std::string& name,
+ source_location location)
+ : Parser_expression(EXPRESSION_SELECTOR, location),
+ left_(left), name_(name)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->left_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Selector_expression(this->left_->copy(), this->name_,
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_method_expression(Gogo*);
+
+ // The expression on the left hand side.
+ Expression* left_;
+ // The name on the right hand side.
+ std::string name_;
+};
+
+// Lower a selector expression once we know the real type of the left
+// hand side.
+
+Expression*
+Selector_expression::do_lower(Gogo* gogo, Named_object*, int)
+{
+ Expression* left = this->left_;
+ if (left->is_type_expression())
+ return this->lower_method_expression(gogo);
+ return Type::bind_field_or_method(gogo, left->type(), left, this->name_,
+ this->location());
+}
+
+// Lower a method expression T.M or (*T).M. We turn this into a
+// function literal.
+
+Expression*
+Selector_expression::lower_method_expression(Gogo* gogo)
+{
+ source_location location = this->location();
+ Type* type = this->left_->type();
+ const std::string& name(this->name_);
+
+ bool is_pointer;
+ if (type->points_to() == NULL)
+ is_pointer = false;
+ else
+ {
+ is_pointer = true;
+ type = type->points_to();
+ }
+ Named_type* nt = type->named_type();
+ if (nt == NULL)
+ {
+ error_at(location,
+ ("method expression requires named type or "
+ "pointer to named type"));
+ return Expression::make_error(location);
+ }
+
+ bool is_ambiguous;
+ Method* method = nt->method_function(name, &is_ambiguous);
+ if (method == NULL)
+ {
+ if (!is_ambiguous)
+ error_at(location, "type %<%s%> has no method %<%s%>",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "method %<%s%> is ambiguous in type %<%s%>",
+ Gogo::message_name(name).c_str(),
+ nt->message_name().c_str());
+ return Expression::make_error(location);
+ }
+
+ if (!is_pointer && !method->is_value_method())
+ {
+ error_at(location, "method requires pointer (use %<(*%s).%s)%>",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ return Expression::make_error(location);
+ }
+
+ // Build a new function type in which the receiver becomes the first
+ // argument.
+ Function_type* method_type = method->type();
+ gcc_assert(method_type->is_method());
+
+ const char* const receiver_name = "$this";
+ Typed_identifier_list* parameters = new Typed_identifier_list();
+ parameters->push_back(Typed_identifier(receiver_name, this->left_->type(),
+ location));
+
+ const Typed_identifier_list* method_parameters = method_type->parameters();
+ if (method_parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ parameters->push_back(*p);
+ }
+
+ const Typed_identifier_list* method_results = method_type->results();
+ Typed_identifier_list* results;
+ if (method_results == NULL)
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = method_results->begin();
+ p != method_results->end();
+ ++p)
+ results->push_back(*p);
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters, results,
+ location);
+ if (method_type->is_varargs())
+ fntype->set_is_varargs();
+
+ // We generate methods which always takes a pointer to the receiver
+ // as their first argument. If this is for a pointer type, we can
+ // simply reuse the existing function. We use an internal hack to
+ // get the right type.
+
+ if (is_pointer)
+ {
+ Named_object* mno = (method->needs_stub_method()
+ ? method->stub_object()
+ : method->named_object());
+ Expression* f = Expression::make_func_reference(mno, NULL, location);
+ f = Expression::make_cast(fntype, f, location);
+ Type_conversion_expression* tce =
+ static_cast<Type_conversion_expression*>(f);
+ tce->set_may_convert_function_types();
+ return f;
+ }
+
+ Named_object* no = gogo->start_function(Gogo::thunk_name(), fntype, false,
+ location);
+
+ Named_object* vno = gogo->lookup(receiver_name, NULL);
+ gcc_assert(vno != NULL);
+ Expression* ve = Expression::make_var_reference(vno, location);
+ Expression* bm = Type::bind_field_or_method(gogo, nt, ve, name, location);
+ gcc_assert(bm != NULL && !bm->is_error_expression());
+
+ Expression_list* args;
+ if (method_parameters == NULL)
+ args = NULL;
+ else
+ {
+ args = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ {
+ vno = gogo->lookup(p->name(), NULL);
+ gcc_assert(vno != NULL);
+ args->push_back(Expression::make_var_reference(vno, location));
+ }
+ }
+
+ Call_expression* call = Expression::make_call(bm, args,
+ method_type->is_varargs(),
+ location);
+
+ size_t count = call->result_count();
+ Statement* s;
+ if (count == 0)
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ s = Statement::make_return_statement(no->func_value()->type()->results(),
+ retvals, location);
+ }
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ return Expression::make_func_reference(no, NULL, location);
+}
+
+// Make a selector expression.
+
+Expression*
+Expression::make_selector(Expression* left, const std::string& name,
+ source_location location)
+{
+ return new Selector_expression(left, name, location);
+}
+
+// Implement the builtin function new.
+
+class Allocation_expression : public Expression
+{
+ public:
+ Allocation_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_ALLOCATION, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->type_); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return new Allocation_expression(this->type_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are allocating.
+ Type* type_;
+};
+
+// Check the type of an allocation expression.
+
+void
+Allocation_expression::do_check_types(Gogo*)
+{
+ if (this->type_->function_type() != NULL)
+ this->report_error(_("invalid new of function type"));
+}
+
+// Return a tree for an allocation expression.
+
+tree
+Allocation_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ tree size_tree = TYPE_SIZE_UNIT(type_tree);
+ tree space = context->gogo()->allocate_memory(this->type_, size_tree,
+ this->location());
+ return fold_convert(build_pointer_type(type_tree), space);
+}
+
+// Make an allocation expression.
+
+Expression*
+Expression::make_allocation(Type* type, source_location location)
+{
+ return new Allocation_expression(type, location);
+}
+
+// Implement the builtin function make.
+
+class Make_expression : public Expression
+{
+ public:
+ Make_expression(Type* type, Expression_list* args, source_location location)
+ : Expression(EXPRESSION_MAKE, location),
+ type_(type), args_(args)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Make_expression(this->type_, this->args_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are making.
+ Type* type_;
+ // The arguments to pass to the make routine.
+ Expression_list* args_;
+};
+
+// Traversal.
+
+int
+Make_expression::do_traverse(Traverse* traverse)
+{
+ if (this->args_ != NULL
+ && this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Set types of arguments.
+
+void
+Make_expression::do_determine_type(const Type_context*)
+{
+ if (this->args_ != NULL)
+ {
+ Type_context context(Type::lookup_integer_type("int"), false);
+ for (Expression_list::const_iterator pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe)
+ (*pe)->determine_type(&context);
+ }
+}
+
+// Check types for a make expression.
+
+void
+Make_expression::do_check_types(Gogo*)
+{
+ if (this->type_->channel_type() == NULL
+ && this->type_->map_type() == NULL
+ && (this->type_->array_type() == NULL
+ || this->type_->array_type()->length() != NULL))
+ this->report_error(_("invalid type for make function"));
+ else if (!this->type_->check_make_expression(this->args_, this->location()))
+ this->set_is_error();
+}
+
+// Return a tree for a make expression.
+
+tree
+Make_expression::do_get_tree(Translate_context* context)
+{
+ return this->type_->make_expression_tree(context, this->args_,
+ this->location());
+}
+
+// Make a make expression.
+
+Expression*
+Expression::make_make(Type* type, Expression_list* args,
+ source_location location)
+{
+ return new Make_expression(type, args, location);
+}
+
+// Construct a struct.
+
+class Struct_construction_expression : public Expression
+{
+ public:
+ Struct_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_STRUCT_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { }
+
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_struct() const;
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Struct_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the struct to construct.
+ Type* type_;
+ // The list of values, in order of the fields in the struct. A NULL
+ // entry means that the field should be zero-initialized.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Struct_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Struct_construction_expression::is_constant_struct() const
+{
+ if (this->vals_ == NULL)
+ return true;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ // There are no constant constructors for interfaces.
+ if (pf->type()->interface_type() != NULL)
+ return false;
+ }
+
+ return true;
+}
+
+// Final type determination.
+
+void
+Struct_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv)
+ {
+ if (pv == this->vals_->end())
+ return;
+ if (*pv != NULL)
+ {
+ Type_context subcontext(pf->type(), false);
+ (*pv)->determine_type(&subcontext);
+ }
+ }
+}
+
+// Check types.
+
+void
+Struct_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Struct_type* st = this->type_->struct_type();
+ if (this->vals_->size() > st->field_count())
+ {
+ this->report_error(_("too many expressions for struct"));
+ return;
+ }
+
+ const Struct_field_list* fields = st->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv, ++i)
+ {
+ if (pv == this->vals_->end())
+ {
+ this->report_error(_("too few expressions for struct"));
+ break;
+ }
+
+ if (*pv == NULL)
+ continue;
+
+ std::string reason;
+ if (!Type::are_assignable(pf->type(), (*pv)->type(), &reason))
+ {
+ if (reason.empty())
+ error_at((*pv)->location(),
+ "incompatible type for field %d in struct construction",
+ i + 1);
+ else
+ error_at((*pv)->location(),
+ ("incompatible type for field %d in "
+ "struct construction (%s)"),
+ i + 1, reason.c_str());
+ this->set_is_error();
+ }
+ }
+ gcc_assert(pv == this->vals_->end());
+}
+
+// Return a tree for constructing a struct.
+
+tree
+Struct_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ if (this->vals_ == NULL)
+ return this->type_->get_init_tree(gogo, false);
+
+ tree type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ bool is_constant = true;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ VEC(constructor_elt,gc)* elts = VEC_alloc(constructor_elt, gc,
+ fields->size());
+ Struct_field_list::const_iterator pf = fields->begin();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field), ++pf)
+ {
+ gcc_assert(pf != fields->end());
+
+ tree val;
+ if (pv == this->vals_->end())
+ val = pf->type()->get_init_tree(gogo, false);
+ else if (*pv == NULL)
+ {
+ val = pf->type()->get_init_tree(gogo, false);
+ ++pv;
+ }
+ else
+ {
+ val = Expression::convert_for_assignment(context, pf->type(),
+ (*pv)->type(),
+ (*pv)->get_tree(context),
+ this->location());
+ ++pv;
+ }
+
+ if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
+ return error_mark_node;
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, elts, NULL);
+ elt->index = field;
+ elt->value = val;
+ if (!TREE_CONSTANT(val))
+ is_constant = false;
+ }
+ gcc_assert(pf == fields->end());
+
+ tree ret = build_constructor(type_tree, elts);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export a struct construction.
+
+void
+Struct_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// Make a struct composite literal. This used by the thunk code.
+
+Expression*
+Expression::make_struct_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ gcc_assert(type->struct_type() != NULL);
+ return new Struct_construction_expression(type, vals, location);
+}
+
+// Construct an array. This class is not used directly; instead we
+// use the child classes, Fixed_array_construction_expression and
+// Open_array_construction_expression.
+
+class Array_construction_expression : public Expression
+{
+ protected:
+ Array_construction_expression(Expression_classification classification,
+ Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(classification, location),
+ type_(type), vals_(vals)
+ { }
+
+ public:
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_array() const;
+
+ // Return the number of elements.
+ size_t
+ element_count() const
+ { return this->vals_ == NULL ? 0 : this->vals_->size(); }
+
+protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ void
+ do_export(Export*) const;
+
+ // The list of values.
+ Expression_list*
+ vals()
+ { return this->vals_; }
+
+ // Get a constructor tree for the array values.
+ tree
+ get_constructor_tree(Translate_context* context, tree type_tree);
+
+ private:
+ // The type of the array to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Array_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Array_construction_expression::is_constant_array() const
+{
+ if (this->vals_ == NULL)
+ return true;
+
+ // There are no constant constructors for interfaces.
+ if (this->type_->array_type()->element_type()->interface_type() != NULL)
+ return false;
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+ return true;
+}
+
+// Final type determination.
+
+void
+Array_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ Type_context subcontext(this->type_->array_type()->element_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL)
+ (*pv)->determine_type(&subcontext);
+ }
+}
+
+// Check types.
+
+void
+Array_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Array_type* at = this->type_->array_type();
+ int i = 0;
+ Type* element_type = at->element_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (*pv != NULL
+ && !Type::are_assignable(element_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d in composite literal",
+ i + 1);
+ this->set_is_error();
+ }
+ }
+
+ Expression* length = at->length();
+ if (length != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (at->length()->integer_constant_value(true, val, &type))
+ {
+ if (this->vals_->size() > mpz_get_ui(val))
+ this->report_error(_("too many elements in composite literal"));
+ }
+ mpz_clear(val);
+ }
+}
+
+// Get a constructor tree for the array values.
+
+tree
+Array_construction_expression::get_constructor_tree(Translate_context* context,
+ tree type_tree)
+{
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ (this->vals_ == NULL
+ ? 0
+ : this->vals_->size()));
+ Type* element_type = this->type_->array_type()->element_type();
+ bool is_constant = true;
+ if (this->vals_ != NULL)
+ {
+ size_t i = 0;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ if (*pv == NULL)
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ else
+ {
+ tree value_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context,
+ element_type,
+ (*pv)->type(),
+ value_tree,
+ this->location());
+ }
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ is_constant = false;
+ }
+ }
+
+ tree ret = build_constructor(type_tree, values);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Array_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ if (this->vals_ != NULL)
+ {
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ }
+ exp->write_c_string(")");
+}
+
+// Construct a fixed array.
+
+class Fixed_array_construction_expression :
+ public Array_construction_expression
+{
+ public:
+ Fixed_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ gcc_assert(type->array_type() != NULL
+ && type->array_type()->length() != NULL);
+ }
+
+ protected:
+ Expression*
+ do_copy()
+ {
+ return new Fixed_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing a fixed array.
+
+tree
+Fixed_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ return this->get_constructor_tree(context,
+ this->type()->get_tree(context->gogo()));
+}
+
+// Construct an open array.
+
+class Open_array_construction_expression : public Array_construction_expression
+{
+ public:
+ Open_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_OPEN_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ gcc_assert(type->array_type() != NULL
+ && type->array_type()->length() == NULL);
+ }
+
+ protected:
+ // Note that taking the address of an open array literal is invalid.
+
+ Expression*
+ do_copy()
+ {
+ return new Open_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing an open array.
+
+tree
+Open_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ Type* element_type = this->type()->array_type()->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+ tree values;
+ tree length_tree;
+ if (this->vals() == NULL || this->vals()->empty())
+ {
+ // We need to create a unique value.
+ tree max = size_int(0);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ VEC(constructor_elt,gc)* vec = VEC_alloc(constructor_elt, gc, 1);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, vec, NULL);
+ elt->index = size_int(0);
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ values = build_constructor(constructor_type, vec);
+ if (TREE_CONSTANT(elt->value))
+ TREE_CONSTANT(values) = 1;
+ length_tree = size_int(0);
+ }
+ else
+ {
+ tree max = size_int(this->vals()->size() - 1);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ values = this->get_constructor_tree(context, constructor_type);
+ length_tree = size_int(this->vals()->size());
+ }
+
+ if (values == error_mark_node)
+ return error_mark_node;
+
+ bool is_constant_initializer = TREE_CONSTANT(values);
+ bool is_in_function = context->function() != NULL;
+
+ if (is_constant_initializer)
+ {
+ tree tmp = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(values));
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (is_in_function)
+ {
+ // If this is not a function, we will only initialize the
+ // value once, so we can use this directly rather than
+ // copying it. In that case we can't make it read-only,
+ // because the program is permitted to change it.
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ }
+ DECL_INITIAL(tmp) = values;
+ rest_of_decl_compilation(tmp, 1, 0);
+ values = tmp;
+ }
+
+ tree space;
+ tree set;
+ if (!is_in_function && is_constant_initializer)
+ {
+ // Outside of a function, we know the initializer will only run
+ // once.
+ space = build_fold_addr_expr(values);
+ set = NULL_TREE;
+ }
+ else
+ {
+ tree memsize = TYPE_SIZE_UNIT(TREE_TYPE(values));
+ space = context->gogo()->allocate_memory(element_type, memsize,
+ this->location());
+ space = save_expr(space);
+
+ tree s = fold_convert(build_pointer_type(TREE_TYPE(values)), space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), s);
+ TREE_THIS_NOTRAP(ref) = 1;
+ set = build2(MODIFY_EXPR, void_type_node, ref, values);
+ }
+
+ // Build a constructor for the open array.
+
+ tree type_tree = this->type()->get_tree(context->gogo());
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), space);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),"__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ tree constructor = build_constructor(type_tree, init);
+ if (!is_in_function && is_constant_initializer)
+ TREE_CONSTANT(constructor) = 1;
+
+ if (set == NULL_TREE)
+ return constructor;
+ else
+ return build2(COMPOUND_EXPR, type_tree, set, constructor);
+}
+
+// Make a slice composite literal. This is used by the type
+// descriptor code.
+
+Expression*
+Expression::make_slice_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ gcc_assert(type->is_open_array_type());
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Construct a map.
+
+class Map_construction_expression : public Expression
+{
+ public:
+ Map_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_MAP_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { gcc_assert(vals == NULL || vals->size() % 2 == 0); }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Map_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the map to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Map_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Final type determination.
+
+void
+Map_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ Type_context key_context(mt->key_type(), false);
+ Type_context val_context(mt->val_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ (*pv)->determine_type(&key_context);
+ ++pv;
+ (*pv)->determine_type(&val_context);
+ }
+}
+
+// Check types.
+
+void
+Map_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ int i = 0;
+ Type* key_type = mt->key_type();
+ Type* val_type = mt->val_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (!Type::are_assignable(key_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d key in map construction",
+ i + 1);
+ this->set_is_error();
+ }
+ ++pv;
+ if (!Type::are_assignable(val_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ ("incompatible type for element %d value "
+ "in map construction"),
+ i + 1);
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree for constructing a map.
+
+tree
+Map_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Map_type* mt = this->type_->map_type();
+
+ // Build a struct to hold the key and value.
+ tree struct_type = make_node(RECORD_TYPE);
+
+ Type* key_type = mt->key_type();
+ tree id = get_identifier("__key");
+ tree key_field = build_decl(loc, FIELD_DECL, id, key_type->get_tree(gogo));
+ DECL_CONTEXT(key_field) = struct_type;
+ TYPE_FIELDS(struct_type) = key_field;
+
+ Type* val_type = mt->val_type();
+ id = get_identifier("__val");
+ tree val_field = build_decl(loc, FIELD_DECL, id, val_type->get_tree(gogo));
+ DECL_CONTEXT(val_field) = struct_type;
+ DECL_CHAIN(key_field) = val_field;
+
+ layout_type(struct_type);
+
+ bool is_constant = true;
+ size_t i = 0;
+ tree valaddr;
+ tree make_tmp;
+
+ if (this->vals_ == NULL || this->vals_->empty())
+ {
+ valaddr = null_pointer_node;
+ make_tmp = NULL_TREE;
+ }
+ else
+ {
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ this->vals_->size() / 2);
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ bool one_is_constant = true;
+
+ VEC(constructor_elt,gc)* one = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = key_field;
+ tree val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, key_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ ++pv;
+
+ elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = val_field;
+ val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, val_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(struct_type, one);
+ if (one_is_constant)
+ TREE_CONSTANT(elt->value) = 1;
+ else
+ is_constant = false;
+ }
+
+ tree index_type = build_index_type(size_int(i - 1));
+ tree array_type = build_array_type(struct_type, index_type);
+ tree init = build_constructor(array_type, values);
+ if (is_constant)
+ TREE_CONSTANT(init) = 1;
+ tree tmp;
+ if (current_function_decl != NULL)
+ {
+ tmp = create_tmp_var(array_type, get_name(array_type));
+ DECL_INITIAL(tmp) = init;
+ make_tmp = fold_build1_loc(loc, DECL_EXPR, void_type_node, tmp);
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ else
+ {
+ tmp = build_decl(loc, VAR_DECL, create_tmp_var_name("M"), array_type);
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (!TREE_CONSTANT(init))
+ make_tmp = fold_build2_loc(loc, INIT_EXPR, void_type_node, tmp,
+ init);
+ else
+ {
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ DECL_INITIAL(tmp) = init;
+ make_tmp = NULL_TREE;
+ }
+ rest_of_decl_compilation(tmp, 1, 0);
+ }
+
+ valaddr = build_fold_addr_expr(tmp);
+ }
+
+ tree descriptor = gogo->map_descriptor(mt);
+
+ tree type_tree = this->type_->get_tree(gogo);
+
+ static tree construct_map_fndecl;
+ tree call = Gogo::call_builtin(&construct_map_fndecl,
+ loc,
+ "__go_construct_map",
+ 6,
+ type_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ sizetype,
+ size_int(i),
+ sizetype,
+ TYPE_SIZE_UNIT(struct_type),
+ sizetype,
+ byte_position(val_field),
+ sizetype,
+ TYPE_SIZE_UNIT(TREE_TYPE(val_field)),
+ const_ptr_type_node,
+ fold_convert(const_ptr_type_node, valaddr));
+
+ tree ret;
+ if (make_tmp == NULL)
+ ret = call;
+ else
+ ret = fold_build2_loc(loc, COMPOUND_EXPR, type_tree, make_tmp, call);
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Map_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// A general composite literal. This is lowered to a type specific
+// version.
+
+class Composite_literal_expression : public Parser_expression
+{
+ public:
+ Composite_literal_expression(Type* type, int depth, bool has_keys,
+ Expression_list* vals, source_location location)
+ : Parser_expression(EXPRESSION_COMPOSITE_LITERAL, location),
+ type_(type), depth_(depth), vals_(vals), has_keys_(has_keys)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Composite_literal_expression(this->type_, this->depth_,
+ this->has_keys_,
+ (this->vals_ == NULL
+ ? NULL
+ : this->vals_->copy()),
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_struct(Type*);
+
+ Expression*
+ lower_array(Type*);
+
+ Expression*
+ make_array(Type*, Expression_list*);
+
+ Expression*
+ lower_map(Type*);
+
+ // The type of the composite literal.
+ Type* type_;
+ // The depth within a list of composite literals within a composite
+ // literal, when the type is omitted.
+ int depth_;
+ // The values to put in the composite literal.
+ Expression_list* vals_;
+ // If this is true, then VALS_ is a list of pairs: a key and a
+ // value. In an array initializer, a missing key will be NULL.
+ bool has_keys_;
+};
+
+// Traversal.
+
+int
+Composite_literal_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Type::traverse(this->type_, traverse);
+}
+
+// Lower a generic composite literal into a specific version based on
+// the type.
+
+Expression*
+Composite_literal_expression::do_lower(Gogo*, Named_object*, int)
+{
+ Type* type = this->type_;
+
+ for (int depth = this->depth_; depth > 0; --depth)
+ {
+ if (type->array_type() != NULL)
+ type = type->array_type()->element_type();
+ else if (type->map_type() != NULL)
+ type = type->map_type()->val_type();
+ else
+ {
+ if (!type->is_error_type())
+ error_at(this->location(),
+ ("may only omit types within composite literals "
+ "of slice, array, or map type"));
+ return Expression::make_error(this->location());
+ }
+ }
+
+ if (type->is_error_type())
+ return Expression::make_error(this->location());
+ else if (type->struct_type() != NULL)
+ return this->lower_struct(type);
+ else if (type->array_type() != NULL)
+ return this->lower_array(type);
+ else if (type->map_type() != NULL)
+ return this->lower_map(type);
+ else
+ {
+ error_at(this->location(),
+ ("expected struct, slice, array, or map type "
+ "for composite literal"));
+ return Expression::make_error(this->location());
+ }
+}
+
+// Lower a struct composite literal.
+
+Expression*
+Composite_literal_expression::lower_struct(Type* type)
+{
+ source_location location = this->location();
+ Struct_type* st = type->struct_type();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return new Struct_construction_expression(type, this->vals_, location);
+
+ size_t field_count = st->field_count();
+ std::vector<Expression*> vals(field_count);
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* name_expr = *p;
+
+ ++p;
+ gcc_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (name_expr == NULL)
+ {
+ error_at(val->location(), "mixture of field and value initializers");
+ return Expression::make_error(location);
+ }
+
+ bool bad_key = false;
+ std::string name;
+ switch (name_expr->classification())
+ {
+ case EXPRESSION_UNKNOWN_REFERENCE:
+ name = name_expr->unknown_expression()->name();
+ break;
+
+ case EXPRESSION_CONST_REFERENCE:
+ name = static_cast<Const_expression*>(name_expr)->name();
+ break;
+
+ case EXPRESSION_TYPE:
+ {
+ Type* t = name_expr->type();
+ Named_type* nt = t->named_type();
+ if (nt == NULL)
+ bad_key = true;
+ else
+ name = nt->name();
+ }
+ break;
+
+ case EXPRESSION_VAR_REFERENCE:
+ name = name_expr->var_expression()->name();
+ break;
+
+ case EXPRESSION_FUNC_REFERENCE:
+ name = name_expr->func_expression()->name();
+ break;
+
+ case EXPRESSION_UNARY:
+ // If there is a local variable around with the same name as
+ // the field, and this occurs in the closure, then the
+ // parser may turn the field reference into an indirection
+ // through the closure. FIXME: This is a mess.
+ {
+ bad_key = true;
+ Unary_expression* ue = static_cast<Unary_expression*>(name_expr);
+ if (ue->op() == OPERATOR_MULT)
+ {
+ Field_reference_expression* fre =
+ ue->operand()->field_reference_expression();
+ if (fre != NULL)
+ {
+ Struct_type* st =
+ fre->expr()->type()->deref()->struct_type();
+ if (st != NULL)
+ {
+ const Struct_field* sf = st->field(fre->field_index());
+ name = sf->field_name();
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", fre->field_index());
+ size_t buflen = strlen(buf);
+ if (name.compare(name.length() - buflen, buflen, buf)
+ == 0)
+ {
+ name = name.substr(0, name.length() - buflen);
+ bad_key = false;
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ bad_key = true;
+ break;
+ }
+ if (bad_key)
+ {
+ error_at(name_expr->location(), "expected struct field name");
+ return Expression::make_error(location);
+ }
+
+ unsigned int index;
+ const Struct_field* sf = st->find_local_field(name, &index);
+ if (sf == NULL)
+ {
+ error_at(name_expr->location(), "unknown field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+ if (vals[index] != NULL)
+ {
+ error_at(name_expr->location(),
+ "duplicate value for field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+
+ vals[index] = val;
+ }
+
+ Expression_list* list = new Expression_list;
+ list->reserve(field_count);
+ for (size_t i = 0; i < field_count; ++i)
+ list->push_back(vals[i]);
+
+ return new Struct_construction_expression(type, list, location);
+}
+
+// Lower an array composite literal.
+
+Expression*
+Composite_literal_expression::lower_array(Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return this->make_array(type, this->vals_);
+
+ std::vector<Expression*> vals;
+ vals.reserve(this->vals_->size());
+ unsigned long index = 0;
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* index_expr = *p;
+
+ ++p;
+ gcc_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (index_expr != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (!index_expr->integer_constant_value(true, ival, &dummy))
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(),
+ "index expression is not integer constant");
+ return Expression::make_error(location);
+ }
+ if (mpz_sgn(ival) < 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index expression is negative");
+ return Expression::make_error(location);
+ }
+ index = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, index) != 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index value overflow");
+ return Expression::make_error(location);
+ }
+ mpz_clear(ival);
+ }
+
+ if (index == vals.size())
+ vals.push_back(val);
+ else
+ {
+ if (index > vals.size())
+ {
+ vals.reserve(index + 32);
+ vals.resize(index + 1, static_cast<Expression*>(NULL));
+ }
+ if (vals[index] != NULL)
+ {
+ error_at((index_expr != NULL
+ ? index_expr->location()
+ : val->location()),
+ "duplicate value for index %lu",
+ index);
+ return Expression::make_error(location);
+ }
+ vals[index] = val;
+ }
+
+ ++index;
+ }
+
+ size_t size = vals.size();
+ Expression_list* list = new Expression_list;
+ list->reserve(size);
+ for (size_t i = 0; i < size; ++i)
+ list->push_back(vals[i]);
+
+ return this->make_array(type, list);
+}
+
+// Actually build the array composite literal. This handles
+// [...]{...}.
+
+Expression*
+Composite_literal_expression::make_array(Type* type, Expression_list* vals)
+{
+ source_location location = this->location();
+ Array_type* at = type->array_type();
+ if (at->length() != NULL && at->length()->is_nil_expression())
+ {
+ size_t size = vals == NULL ? 0 : vals->size();
+ mpz_t vlen;
+ mpz_init_set_ui(vlen, size);
+ Expression* elen = Expression::make_integer(&vlen, NULL, location);
+ mpz_clear(vlen);
+ at = Type::make_array_type(at->element_type(), elen);
+ type = at;
+ }
+ if (at->length() != NULL)
+ return new Fixed_array_construction_expression(type, vals, location);
+ else
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Lower a map composite literal.
+
+Expression*
+Composite_literal_expression::lower_map(Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ != NULL)
+ {
+ if (!this->has_keys_)
+ {
+ error_at(location, "map composite literal must have keys");
+ return Expression::make_error(location);
+ }
+
+ for (Expression_list::const_iterator p = this->vals_->begin();
+ p != this->vals_->end();
+ p += 2)
+ {
+ if (*p == NULL)
+ {
+ ++p;
+ error_at((*p)->location(),
+ "map composite literal must have keys for every value");
+ return Expression::make_error(location);
+ }
+ }
+ }
+
+ return new Map_construction_expression(type, this->vals_, location);
+}
+
+// Make a composite literal expression.
+
+Expression*
+Expression::make_composite_literal(Type* type, int depth, bool has_keys,
+ Expression_list* vals,
+ source_location location)
+{
+ return new Composite_literal_expression(type, depth, has_keys, vals,
+ location);
+}
+
+// Return whether this expression is a composite literal.
+
+bool
+Expression::is_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_COMPOSITE_LITERAL:
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return whether this expression is a composite literal which is not
+// constant.
+
+bool
+Expression::is_nonconstant_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ {
+ const Struct_construction_expression *psce =
+ static_cast<const Struct_construction_expression*>(this);
+ return !psce->is_constant_struct();
+ }
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ {
+ const Fixed_array_construction_expression *pace =
+ static_cast<const Fixed_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ {
+ const Open_array_construction_expression *pace =
+ static_cast<const Open_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return true if this is a reference to a local variable.
+
+bool
+Expression::is_local_variable() const
+{
+ const Var_expression* ve = this->var_expression();
+ if (ve == NULL)
+ return false;
+ const Named_object* no = ve->named_object();
+ return (no->is_result_variable()
+ || (no->is_variable() && !no->var_value()->is_global()));
+}
+
+// Class Type_guard_expression.
+
+// Traversal.
+
+int
+Type_guard_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check types of a type guard expression. The expression must have
+// an interface type, but the actual type conversion is checked at run
+// time.
+
+void
+Type_guard_expression::do_check_types(Gogo*)
+{
+ // 6g permits using a type guard with unsafe.pointer; we are
+ // compatible.
+ Type* expr_type = this->expr_->type();
+ if (expr_type->is_unsafe_pointer_type())
+ {
+ if (this->type_->points_to() == NULL
+ && (this->type_->integer_type() == NULL
+ || (this->type_->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (this->type_->is_unsafe_pointer_type())
+ {
+ if (expr_type->points_to() == NULL
+ && (expr_type->integer_type() == NULL
+ || (expr_type->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (expr_type->interface_type() == NULL)
+ this->report_error(_("type assertion only valid for interface types"));
+ else if (this->type_->interface_type() == NULL)
+ {
+ std::string reason;
+ if (!expr_type->interface_type()->implements_interface(this->type_,
+ &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("impossible type assertion: "
+ "type does not implement interface"));
+ else
+ {
+ error_at(this->location(),
+ ("impossible type assertion: "
+ "type does not implement interface (%s)"),
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ }
+}
+
+// Return a tree for a type guard expression.
+
+tree
+Type_guard_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ Type* expr_type = this->expr_->type();
+ if ((this->type_->is_unsafe_pointer_type()
+ && (expr_type->points_to() != NULL
+ || expr_type->integer_type() != NULL))
+ || (expr_type->is_unsafe_pointer_type()
+ && this->type_->points_to() != NULL))
+ return convert_to_pointer(this->type_->get_tree(gogo), expr_tree);
+ else if (expr_type->is_unsafe_pointer_type()
+ && this->type_->integer_type() != NULL)
+ return convert_to_integer(this->type_->get_tree(gogo), expr_tree);
+ else if (this->type_->interface_type() != NULL)
+ return Expression::convert_interface_to_interface(context, this->type_,
+ this->expr_->type(),
+ expr_tree, true,
+ this->location());
+ else
+ return Expression::convert_for_assignment(context, this->type_,
+ this->expr_->type(), expr_tree,
+ this->location());
+}
+
+// Make a type guard expression.
+
+Expression*
+Expression::make_type_guard(Expression* expr, Type* type,
+ source_location location)
+{
+ return new Type_guard_expression(expr, type, location);
+}
+
+// Class Heap_composite_expression.
+
+// When you take the address of a composite literal, it is allocated
+// on the heap. This class implements that.
+
+class Heap_composite_expression : public Expression
+{
+ public:
+ Heap_composite_expression(Expression* expr, source_location location)
+ : Expression(EXPRESSION_HEAP_COMPOSITE, location),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->expr_->type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { this->expr_->determine_type_no_context(); }
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_heap_composite(this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ // We only export global objects, and the parser does not generate
+ // this in global scope.
+ void
+ do_export(Export*) const
+ { gcc_unreachable(); }
+
+ private:
+ // The composite literal which is being put on the heap.
+ Expression* expr_;
+};
+
+// Return a tree which allocates a composite literal on the heap.
+
+tree
+Heap_composite_expression::do_get_tree(Translate_context* context)
+{
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ tree expr_size = TYPE_SIZE_UNIT(TREE_TYPE(expr_tree));
+ gcc_assert(TREE_CODE(expr_size) == INTEGER_CST);
+ tree space = context->gogo()->allocate_memory(this->expr_->type(),
+ expr_size, this->location());
+ space = fold_convert(build_pointer_type(TREE_TYPE(expr_tree)), space);
+ space = save_expr(space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree ret = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, ref, expr_tree),
+ space);
+ SET_EXPR_LOCATION(ret, this->location());
+ return ret;
+}
+
+// Allocate a composite literal on the heap.
+
+Expression*
+Expression::make_heap_composite(Expression* expr, source_location location)
+{
+ return new Heap_composite_expression(expr, location);
+}
+
+// Class Receive_expression.
+
+// Return the type of a receive expression.
+
+Type*
+Receive_expression::do_type()
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ return Type::make_error_type();
+ return channel_type->element_type();
+}
+
+// Check types for a receive expression.
+
+void
+Receive_expression::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+ if (type->channel_type() == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return;
+ }
+ if (!type->channel_type()->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return;
+ }
+}
+
+// Get a tree for a receive expression.
+
+tree
+Receive_expression::do_get_tree(Translate_context* context)
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ gcc_assert(channel_type != NULL);
+ Type* element_type = channel_type->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+
+ tree channel = this->channel_->get_tree(context);
+ if (element_type_tree == error_mark_node || channel == error_mark_node)
+ return error_mark_node;
+
+ return Gogo::receive_from_channel(element_type_tree, channel,
+ this->for_select_, this->location());
+}
+
+// Make a receive expression.
+
+Receive_expression*
+Expression::make_receive(Expression* channel, source_location location)
+{
+ return new Receive_expression(channel, location);
+}
+
+// Class Send_expression.
+
+// Traversal.
+
+int
+Send_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->val_, traverse);
+}
+
+// Get the type.
+
+Type*
+Send_expression::do_type()
+{
+ return Type::lookup_bool_type();
+}
+
+// Set types.
+
+void
+Send_expression::do_determine_type(const Type_context*)
+{
+ this->channel_->determine_type_no_context();
+
+ Type* type = this->channel_->type();
+ Type_context subcontext;
+ if (type->channel_type() != NULL)
+ subcontext.type = type->channel_type()->element_type();
+ this->val_->determine_type(&subcontext);
+}
+
+// Check types.
+
+void
+Send_expression::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+ Channel_type* channel_type = type->channel_type();
+ if (channel_type == NULL)
+ {
+ error_at(this->location(), "left operand of %<<-%> must be channel");
+ this->set_is_error();
+ return;
+ }
+ Type* element_type = channel_type->element_type();
+ if (element_type != NULL
+ && !Type::are_assignable(element_type, this->val_->type(), NULL))
+ {
+ this->report_error(_("incompatible types in send"));
+ return;
+ }
+ if (!channel_type->may_send())
+ {
+ this->report_error(_("invalid send on receive-only channel"));
+ return;
+ }
+}
+
+// Get a tree for a send expression.
+
+tree
+Send_expression::do_get_tree(Translate_context* context)
+{
+ tree channel = this->channel_->get_tree(context);
+ tree val = this->val_->get_tree(context);
+ if (channel == error_mark_node || val == error_mark_node)
+ return error_mark_node;
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ val = Expression::convert_for_assignment(context,
+ channel_type->element_type(),
+ this->val_->type(),
+ val,
+ this->location());
+ return Gogo::send_on_channel(channel, val, this->is_value_discarded_,
+ this->for_select_, this->location());
+}
+
+// Make a send expression
+
+Send_expression*
+Expression::make_send(Expression* channel, Expression* val,
+ source_location location)
+{
+ return new Send_expression(channel, val, location);
+}
+
+// An expression which evaluates to a pointer to the type descriptor
+// of a type.
+
+class Type_descriptor_expression : public Expression
+{
+ public:
+ Type_descriptor_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE_DESCRIPTOR, location),
+ type_(type)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_type_descriptor_ptr_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->type_->type_descriptor_pointer(context->gogo()); }
+
+ private:
+ // The type for which this is the descriptor.
+ Type* type_;
+};
+
+// Make a type descriptor expression.
+
+Expression*
+Expression::make_type_descriptor(Type* type, source_location location)
+{
+ return new Type_descriptor_expression(type, location);
+}
+
+// An expression which evaluates to some characteristic of a type.
+// This is only used to initialize fields of a type descriptor. Using
+// a new expression class is slightly inefficient but gives us a good
+// separation between the frontend and the middle-end with regard to
+// how types are laid out.
+
+class Type_info_expression : public Expression
+{
+ public:
+ Type_info_expression(Type* type, Type_info type_info)
+ : Expression(EXPRESSION_TYPE_INFO, BUILTINS_LOCATION),
+ type_(type), type_info_(type_info)
+ { }
+
+ protected:
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type for which we are getting information.
+ Type* type_;
+ // What information we want.
+ Type_info type_info_;
+};
+
+// The type is chosen to match what the type descriptor struct
+// expects.
+
+Type*
+Type_info_expression::do_type()
+{
+ switch (this->type_info_)
+ {
+ case TYPE_INFO_SIZE:
+ return Type::lookup_integer_type("uintptr");
+ case TYPE_INFO_ALIGNMENT:
+ case TYPE_INFO_FIELD_ALIGNMENT:
+ return Type::lookup_integer_type("uint8");
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return type information in GENERIC.
+
+tree
+Type_info_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ gcc_assert(val_type_tree != error_mark_node);
+
+ if (this->type_info_ == TYPE_INFO_SIZE)
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ TYPE_SIZE_UNIT(type_tree));
+ else
+ {
+ unsigned HOST_WIDE_INT val;
+ if (this->type_info_ == TYPE_INFO_ALIGNMENT)
+ val = TYPE_ALIGN_UNIT(type_tree);
+ else
+ {
+ gcc_assert(this->type_info_ == TYPE_INFO_FIELD_ALIGNMENT);
+ val = TYPE_ALIGN(type_tree);
+#ifdef BIGGEST_FIELD_ALIGMENT
+ if (val > BIGGEST_FIELD_ALIGNMENT)
+ val = BIGGEST_FIELD_ALIGNMENT;
+#endif
+#ifdef ADJUST_FIELD_ALIGN
+ {
+ tree f = build_decl(UNKNOWN_LOCATION, FIELD_DECL, NULL, type_tree);
+ val = ADJUST_FIELD_ALIGN(f, val);
+ }
+#endif
+ val /= BITS_PER_UNIT;
+ }
+
+ return build_int_cstu(val_type_tree, val);
+ }
+}
+
+// Make a type info expression.
+
+Expression*
+Expression::make_type_info(Type* type, Type_info type_info)
+{
+ return new Type_info_expression(type, type_info);
+}
+
+// An expression which evaluates to the offset of a field within a
+// struct. This, like Type_info_expression, q.v., is only used to
+// initialize fields of a type descriptor.
+
+class Struct_field_offset_expression : public Expression
+{
+ public:
+ Struct_field_offset_expression(Struct_type* type, const Struct_field* field)
+ : Expression(EXPRESSION_STRUCT_FIELD_OFFSET, BUILTINS_LOCATION),
+ type_(type), field_(field)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::lookup_integer_type("uintptr"); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type of the struct.
+ Struct_type* type_;
+ // The field.
+ const Struct_field* field_;
+};
+
+// Return a struct field offset in GENERIC.
+
+tree
+Struct_field_offset_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ gcc_assert(val_type_tree != error_mark_node);
+
+ const Struct_field_list* fields = this->type_->fields();
+ tree struct_field_tree = TYPE_FIELDS(type_tree);
+ Struct_field_list::const_iterator p;
+ for (p = fields->begin();
+ p != fields->end();
+ ++p, struct_field_tree = DECL_CHAIN(struct_field_tree))
+ {
+ gcc_assert(struct_field_tree != NULL_TREE);
+ if (&*p == this->field_)
+ break;
+ }
+ gcc_assert(&*p == this->field_);
+
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ byte_position(struct_field_tree));
+}
+
+// Make an expression for a struct field offset.
+
+Expression*
+Expression::make_struct_field_offset(Struct_type* type,
+ const Struct_field* field)
+{
+ return new Struct_field_offset_expression(type, field);
+}
+
+// An expression which evaluates to the address of an unnamed label.
+
+class Label_addr_expression : public Expression
+{
+ public:
+ Label_addr_expression(Label* label, source_location location)
+ : Expression(EXPRESSION_LABEL_ADDR, location),
+ label_(label)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_pointer_type(Type::make_void_type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return new Label_addr_expression(this->label_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_addr(this->location()); }
+
+ private:
+ // The label whose address we are taking.
+ Label* label_;
+};
+
+// Make an expression for the address of an unnamed label.
+
+Expression*
+Expression::make_label_addr(Label* label, source_location location)
+{
+ return new Label_addr_expression(label, location);
+}
+
+// Import an expression. This comes at the end in order to see the
+// various class definitions.
+
+Expression*
+Expression::import_expression(Import* imp)
+{
+ int c = imp->peek_char();
+ if (imp->match_c_string("- ")
+ || imp->match_c_string("! ")
+ || imp->match_c_string("^ "))
+ return Unary_expression::do_import(imp);
+ else if (c == '(')
+ return Binary_expression::do_import(imp);
+ else if (imp->match_c_string("true")
+ || imp->match_c_string("false"))
+ return Boolean_expression::do_import(imp);
+ else if (c == '"')
+ return String_expression::do_import(imp);
+ else if (c == '-' || (c >= '0' && c <= '9'))
+ {
+ // This handles integers, floats and complex constants.
+ return Integer_expression::do_import(imp);
+ }
+ else if (imp->match_c_string("nil"))
+ return Nil_expression::do_import(imp);
+ else if (imp->match_c_string("convert"))
+ return Type_conversion_expression::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected expression");
+ return Expression::make_error(imp->location());
+ }
+}
+
+// Class Expression_list.
+
+// Traverse the list.
+
+int
+Expression_list::traverse(Traverse* traverse)
+{
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p != NULL)
+ {
+ if (Expression::traverse(&*p, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Expression_list*
+Expression_list::copy()
+{
+ Expression_list* ret = new Expression_list();
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p == NULL)
+ ret->push_back(NULL);
+ else
+ ret->push_back((*p)->copy());
+ }
+ return ret;
+}
+
+// Return whether an expression list has an error expression.
+
+bool
+Expression_list::contains_error() const
+{
+ for (Expression_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ if (*p != NULL && (*p)->is_error_expression())
+ return true;
+ return false;
+}
--- /dev/null
+// expressions.cc -- Go frontend expression handling.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "convert.h"
+#include "real.h"
+#include "realmpfr.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "types.h"
+#include "export.h"
+#include "import.h"
+#include "statements.h"
+#include "lex.h"
+#include "backend.h"
+#include "expressions.h"
+
+// Class Expression.
+
+Expression::Expression(Expression_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Expression::~Expression()
+{
+}
+
+// If this expression has a constant integer value, return it.
+
+bool
+Expression::integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ return this->do_integer_constant_value(iota_is_constant, val, ptype);
+}
+
+// If this expression has a constant floating point value, return it.
+
+bool
+Expression::float_constant_value(mpfr_t val, Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_float_constant_value(val, ptype))
+ return true;
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ bool ret;
+ if (!this->do_integer_constant_value(false, ival, &t))
+ ret = false;
+ else
+ {
+ mpfr_set_z(val, ival, GMP_RNDN);
+ ret = true;
+ }
+ mpz_clear(ival);
+ return ret;
+}
+
+// If this expression has a constant complex value, return it.
+
+bool
+Expression::complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_complex_constant_value(real, imag, ptype))
+ return true;
+ Type *t;
+ if (this->float_constant_value(real, &t))
+ {
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+ return false;
+}
+
+// Traverse the expressions.
+
+int
+Expression::traverse(Expression** pexpr, Traverse* traverse)
+{
+ Expression* expr = *pexpr;
+ if ((traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
+ {
+ int t = traverse->expression(pexpr);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ return expr->do_traverse(traverse);
+}
+
+// Traverse subexpressions of this expression.
+
+int
+Expression::traverse_subexpressions(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Default implementation for do_traverse for child classes.
+
+int
+Expression::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// This virtual function is called by the parser if the value of this
+// expression is being discarded. By default, we warn. Expressions
+// with side effects override.
+
+void
+Expression::do_discarding_value()
+{
+ this->warn_about_unused_value();
+}
+
+// This virtual function is called to export expressions. This will
+// only be used by expressions which may be constant.
+
+void
+Expression::do_export(Export*) const
+{
+ go_unreachable();
+}
+
+// Warn that the value of the expression is not used.
+
+void
+Expression::warn_about_unused_value()
+{
+ warning_at(this->location(), OPT_Wunused_value, "value computed is not used");
+}
+
+// Note that this expression is an error. This is called by children
+// when they discover an error.
+
+void
+Expression::set_is_error()
+{
+ this->classification_ = EXPRESSION_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Expression::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// Set types of variables and constants. This is implemented by the
+// child class.
+
+void
+Expression::determine_type(const Type_context* context)
+{
+ this->do_determine_type(context);
+}
+
+// Set types when there is no context.
+
+void
+Expression::determine_type_no_context()
+{
+ Type_context context;
+ this->do_determine_type(&context);
+}
+
+// Return a tree handling any conversions which must be done during
+// assignment.
+
+tree
+Expression::convert_for_assignment(Translate_context* context, Type* lhs_type,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ if (lhs_type == rhs_type)
+ return rhs_tree;
+
+ if (lhs_type->is_error() || rhs_type->is_error())
+ return error_mark_node;
+
+ if (rhs_tree == error_mark_node || TREE_TYPE(rhs_tree) == error_mark_node)
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ if (lhs_type->interface_type() != NULL)
+ {
+ if (rhs_type->interface_type() == NULL)
+ return Expression::convert_type_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ location);
+ else
+ return Expression::convert_interface_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ false, location);
+ }
+ else if (rhs_type->interface_type() != NULL)
+ return Expression::convert_interface_to_type(context, lhs_type, rhs_type,
+ rhs_tree, location);
+ else if (lhs_type->is_open_array_type()
+ && rhs_type->is_nil_type())
+ {
+ // Assigning nil to an open array.
+ go_assert(TREE_CODE(lhs_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ tree val = build_constructor(lhs_type_tree, init);
+ TREE_CONSTANT(val) = 1;
+
+ return val;
+ }
+ else if (rhs_type->is_nil_type())
+ {
+ // The left hand side should be a pointer type at the tree
+ // level.
+ go_assert(POINTER_TYPE_P(lhs_type_tree));
+ return fold_convert(lhs_type_tree, null_pointer_node);
+ }
+ else if (lhs_type_tree == TREE_TYPE(rhs_tree))
+ {
+ // No conversion is needed.
+ return rhs_tree;
+ }
+ else if (POINTER_TYPE_P(lhs_type_tree)
+ || INTEGRAL_TYPE_P(lhs_type_tree)
+ || SCALAR_FLOAT_TYPE_P(lhs_type_tree)
+ || COMPLEX_FLOAT_TYPE_P(lhs_type_tree))
+ return fold_convert_loc(location, lhs_type_tree, rhs_tree);
+ else if (TREE_CODE(lhs_type_tree) == RECORD_TYPE
+ && TREE_CODE(TREE_TYPE(rhs_tree)) == RECORD_TYPE)
+ {
+ // This conversion must be permitted by Go, or we wouldn't have
+ // gotten here.
+ go_assert(int_size_in_bytes(lhs_type_tree)
+ == int_size_in_bytes(TREE_TYPE(rhs_tree)));
+ return fold_build1_loc(location, VIEW_CONVERT_EXPR, lhs_type_tree,
+ rhs_tree);
+ }
+ else
+ {
+ go_assert(useless_type_conversion_p(lhs_type_tree, TREE_TYPE(rhs_tree)));
+ return rhs_tree;
+ }
+}
+
+// Return a tree for a conversion from a non-interface type to an
+// interface type.
+
+tree
+Expression::convert_type_to_interface(Translate_context* context,
+ Type* lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ // Since RHS_TYPE is a static type, we can create the interface
+ // method table at compile time.
+
+ // When setting an interface to nil, we just set both fields to
+ // NULL.
+ if (rhs_type->is_nil_type())
+ return lhs_type->get_init_tree(gogo, false);
+
+ // This should have been checked already.
+ go_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // An interface is a tuple. If LHS_TYPE is an empty interface type,
+ // then the first field is the type descriptor for RHS_TYPE.
+ // Otherwise it is the interface method table for RHS_TYPE.
+ tree first_field_value;
+ if (lhs_is_empty)
+ first_field_value = rhs_type->type_descriptor_pointer(gogo);
+ else
+ {
+ // Build the interface method table for this interface and this
+ // object type: a list of function pointers for each interface
+ // method.
+ Named_type* rhs_named_type = rhs_type->named_type();
+ bool is_pointer = false;
+ if (rhs_named_type == NULL)
+ {
+ rhs_named_type = rhs_type->deref()->named_type();
+ is_pointer = true;
+ }
+ tree method_table;
+ if (rhs_named_type == NULL)
+ method_table = null_pointer_node;
+ else
+ method_table =
+ rhs_named_type->interface_method_table(gogo, lhs_interface_type,
+ is_pointer);
+ first_field_value = fold_convert_loc(location, const_ptr_type_node,
+ method_table);
+ }
+ if (first_field_value == error_mark_node)
+ return error_mark_node;
+
+ // Start building a constructor for the value we will return.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ (lhs_is_empty ? "__type_descriptor" : "__methods")) == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), first_field_value);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ if (rhs_type->points_to() != NULL)
+ {
+ // We are assigning a pointer to the interface; the interface
+ // holds the pointer itself.
+ elt->value = rhs_tree;
+ return build_constructor(lhs_type_tree, init);
+ }
+
+ // We are assigning a non-pointer value to the interface; the
+ // interface gets a copy of the value in the heap.
+
+ tree object_size = TYPE_SIZE_UNIT(TREE_TYPE(rhs_tree));
+
+ tree space = gogo->allocate_memory(rhs_type, object_size, location);
+ space = fold_convert_loc(location, build_pointer_type(TREE_TYPE(rhs_tree)),
+ space);
+ space = save_expr(space);
+
+ tree ref = build_fold_indirect_ref_loc(location, space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ ref, rhs_tree);
+
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), space);
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, set,
+ build_constructor(lhs_type_tree, init));
+}
+
+// Return a tree for the type descriptor of RHS_TREE, which has
+// interface type RHS_TYPE. If RHS_TREE is nil the result will be
+// NULL.
+
+tree
+Expression::get_interface_type_descriptor(Translate_context*,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = TYPE_FIELDS(rhs_type_tree);
+ tree v = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+ if (rhs_type->interface_type()->is_empty())
+ {
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)),
+ "__type_descriptor") == 0);
+ return v;
+ }
+
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__methods")
+ == 0);
+ go_assert(POINTER_TYPE_P(TREE_TYPE(v)));
+ v = save_expr(v);
+ tree v1 = build_fold_indirect_ref_loc(location, v);
+ go_assert(TREE_CODE(TREE_TYPE(v1)) == RECORD_TYPE);
+ tree f = TYPE_FIELDS(TREE_TYPE(v1));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(f)), "__type_descriptor")
+ == 0);
+ v1 = build3(COMPONENT_REF, TREE_TYPE(f), v1, f, NULL_TREE);
+
+ tree eq = fold_build2_loc(location, EQ_EXPR, boolean_type_node, v,
+ fold_convert_loc(location, TREE_TYPE(v),
+ null_pointer_node));
+ tree n = fold_convert_loc(location, TREE_TYPE(v1), null_pointer_node);
+ return fold_build3_loc(location, COND_EXPR, TREE_TYPE(v1),
+ eq, n, v1);
+}
+
+// Return a tree for the conversion of an interface type to an
+// interface type.
+
+tree
+Expression::convert_interface_to_interface(Translate_context* context,
+ Type *lhs_type, Type *rhs_type,
+ tree rhs_tree, bool for_type_guard,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // In the general case this requires runtime examination of the type
+ // method table to match it up with the interface methods.
+
+ // FIXME: If all of the methods in the right hand side interface
+ // also appear in the left hand side interface, then we don't need
+ // to do a runtime check, although we still need to build a new
+ // method table.
+
+ // Get the type descriptor for the right hand side. This will be
+ // NULL for a nil interface.
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ // The result is going to be a two element constructor.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ elt->index = field;
+
+ if (for_type_guard)
+ {
+ // A type assertion fails when converting a nil interface.
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree assert_interface_decl;
+ tree call = Gogo::call_builtin(&assert_interface_decl,
+ location,
+ "__go_assert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(assert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+ else if (lhs_is_empty)
+ {
+ // A convertion to an empty interface always succeeds, and the
+ // first field is just the type descriptor of the object.
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__type_descriptor") == 0);
+ go_assert(TREE_TYPE(field) == TREE_TYPE(rhs_type_descriptor));
+ elt->value = rhs_type_descriptor;
+ }
+ else
+ {
+ // A conversion to a non-empty interface may fail, but unlike a
+ // type assertion converting nil will always succeed.
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods")
+ == 0);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree convert_interface_decl;
+ tree call = Gogo::call_builtin(&convert_interface_decl,
+ location,
+ "__go_convert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(convert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+
+ // The second field is simply the object pointer.
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ elt->value = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ return build_constructor(lhs_type_tree, init);
+}
+
+// Return a tree for the conversion of an interface type to a
+// non-interface type.
+
+tree
+Expression::convert_interface_to_type(Translate_context* context,
+ Type *lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // Call a function to check that the type is valid. The function
+ // will panic with an appropriate runtime type error if the type is
+ // not valid.
+
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo);
+
+ static tree check_interface_type_decl;
+ tree call = Gogo::call_builtin(&check_interface_type_decl,
+ location,
+ "__go_check_interface_type",
+ 3,
+ void_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor,
+ TREE_TYPE(rhs_inter_descriptor),
+ rhs_inter_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This call will panic if the conversion is invalid.
+ TREE_NOTHROW(check_interface_type_decl) = 0;
+
+ // If the call succeeds, pull out the value.
+ go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ tree val = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ // If the value is a pointer, then it is the value we want.
+ // Otherwise it points to the value.
+ if (lhs_type->points_to() == NULL)
+ {
+ val = fold_convert_loc(location, build_pointer_type(lhs_type_tree), val);
+ val = build_fold_indirect_ref_loc(location, val);
+ }
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, call,
+ fold_convert_loc(location, lhs_type_tree, val));
+}
+
+// Convert an expression to a tree. This is implemented by the child
+// class. Not that it is not in general safe to call this multiple
+// times for a single expression, but that we don't catch such errors.
+
+tree
+Expression::get_tree(Translate_context* context)
+{
+ // The child may have marked this expression as having an error.
+ if (this->classification_ == EXPRESSION_ERROR)
+ return error_mark_node;
+
+ return this->do_get_tree(context);
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::integer_constant_tree(mpz_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ return double_int_to_tree(type,
+ mpz_get_double_int(type, val, true));
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree ret = Expression::float_constant_tree(fval, type);
+ mpfr_clear(fval);
+ return ret;
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree real = Expression::float_constant_tree(fval, TREE_TYPE(type));
+ mpfr_clear(fval);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, real, imag);
+ }
+ else
+ go_unreachable();
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::float_constant_tree(mpfr_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, val, GMP_RNDN);
+ tree ret = Expression::integer_constant_tree(ival, type);
+ mpz_clear(ival);
+ return ret;
+ }
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, type, GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(type), &r1);
+ return build_real(type, r2);
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, build_real(TREE_TYPE(type), r2), imag);
+ }
+ else
+ go_unreachable();
+}
+
+// Return a tree for REAL/IMAG in TYPE.
+
+tree
+Expression::complex_constant_tree(mpfr_t real, mpfr_t imag, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE || TREE_CODE(type) == REAL_TYPE)
+ return Expression::float_constant_tree(real, type);
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, real, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+
+ REAL_VALUE_TYPE r3;
+ real_from_mpfr(&r3, imag, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r4;
+ real_convert(&r4, TYPE_MODE(TREE_TYPE(type)), &r3);
+
+ return build_complex(type, build_real(TREE_TYPE(type), r2),
+ build_real(TREE_TYPE(type), r4));
+ }
+ else
+ go_unreachable();
+}
+
+// Return a tree which evaluates to true if VAL, of arbitrary integer
+// type, is negative or is more than the maximum value of BOUND_TYPE.
+// If SOFAR is not NULL, it is or'red into the result. The return
+// value may be NULL if SOFAR is NULL.
+
+tree
+Expression::check_bounds(tree val, tree bound_type, tree sofar,
+ source_location loc)
+{
+ tree val_type = TREE_TYPE(val);
+ tree ret = NULL_TREE;
+
+ if (!TYPE_UNSIGNED(val_type))
+ {
+ ret = fold_build2_loc(loc, LT_EXPR, boolean_type_node, val,
+ build_int_cst(val_type, 0));
+ if (ret == boolean_false_node)
+ ret = NULL_TREE;
+ }
+
+ if ((TYPE_UNSIGNED(val_type) && !TYPE_UNSIGNED(bound_type))
+ || TYPE_SIZE(val_type) > TYPE_SIZE(bound_type))
+ {
+ tree max = TYPE_MAX_VALUE(bound_type);
+ tree big = fold_build2_loc(loc, GT_EXPR, boolean_type_node, val,
+ fold_convert_loc(loc, val_type, max));
+ if (big == boolean_false_node)
+ ;
+ else if (ret == NULL_TREE)
+ ret = big;
+ else
+ ret = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ ret, big);
+ }
+
+ if (ret == NULL_TREE)
+ return sofar;
+ else if (sofar == NULL_TREE)
+ return ret;
+ else
+ return fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ sofar, ret);
+}
+
+// Error expressions. This are used to avoid cascading errors.
+
+class Error_expression : public Expression
+{
+ public:
+ Error_expression(source_location location)
+ : Expression(EXPRESSION_ERROR, location)
+ { }
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const
+ {
+ mpz_set_ui(val, 0);
+ return true;
+ }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const
+ {
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ return true;
+ }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type()
+ { return Type::make_error_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return error_mark_node; }
+};
+
+Expression*
+Expression::make_error(source_location location)
+{
+ return new Error_expression(location);
+}
+
+// An expression which is really a type. This is used during parsing.
+// It is an error if these survive after lowering.
+
+class
+Type_expression : public Expression
+{
+ public:
+ Type_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*)
+ { this->report_error(_("invalid use of type")); }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The type which we are representing as an expression.
+ Type* type_;
+};
+
+Expression*
+Expression::make_type(Type* type, source_location location)
+{
+ return new Type_expression(type, location);
+}
+
+// Class Parser_expression.
+
+Type*
+Parser_expression::do_type()
+{
+ // We should never really ask for the type of a Parser_expression.
+ // However, it can happen, at least when we have an invalid const
+ // whose initializer refers to the const itself. In that case we
+ // may ask for the type when lowering the const itself.
+ go_assert(saw_errors());
+ return Type::make_error_type();
+}
+
+// Class Var_expression.
+
+// Lower a variable expression. Here we just make sure that the
+// initialization expression of the variable has been lowered. This
+// ensures that we will be able to determine the type of the variable
+// if necessary.
+
+Expression*
+Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->variable_->is_variable())
+ {
+ Variable* var = this->variable_->var_value();
+ // This is either a local variable or a global variable. A
+ // reference to a variable which is local to an enclosing
+ // function will be a reference to a field in a closure.
+ if (var->is_global())
+ function = NULL;
+ var->lower_init_expression(gogo, function);
+ }
+ return this;
+}
+
+// Return the type of a reference to a variable.
+
+Type*
+Var_expression::do_type()
+{
+ if (this->variable_->is_variable())
+ return this->variable_->var_value()->type();
+ else if (this->variable_->is_result_variable())
+ return this->variable_->result_var_value()->type();
+ else
+ go_unreachable();
+}
+
+// Determine the type of a reference to a variable.
+
+void
+Var_expression::do_determine_type(const Type_context*)
+{
+ if (this->variable_->is_variable())
+ this->variable_->var_value()->determine_type();
+}
+
+// Something takes the address of this variable. This means that we
+// may want to move the variable onto the heap.
+
+void
+Var_expression::do_address_taken(bool escapes)
+{
+ if (!escapes)
+ ;
+ else if (this->variable_->is_variable())
+ this->variable_->var_value()->set_address_taken();
+ else if (this->variable_->is_result_variable())
+ this->variable_->result_var_value()->set_address_taken();
+ else
+ go_unreachable();
+}
+
+// Get the tree for a reference to a variable.
+
+tree
+Var_expression::do_get_tree(Translate_context* context)
+{
+ Bvariable* bvar = this->variable_->get_backend_variable(context->gogo(),
+ context->function());
+ tree ret = var_to_tree(bvar);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ bool is_in_heap;
+ if (this->variable_->is_variable())
+ is_in_heap = this->variable_->var_value()->is_in_heap();
+ else if (this->variable_->is_result_variable())
+ is_in_heap = this->variable_->result_var_value()->is_in_heap();
+ else
+ go_unreachable();
+ if (is_in_heap)
+ {
+ ret = build_fold_indirect_ref_loc(this->location(), ret);
+ TREE_THIS_NOTRAP(ret) = 1;
+ }
+ return ret;
+}
+
+// Make a reference to a variable in an expression.
+
+Expression*
+Expression::make_var_reference(Named_object* var, source_location location)
+{
+ if (var->is_sink())
+ return Expression::make_sink(location);
+
+ // FIXME: Creating a new object for each reference to a variable is
+ // wasteful.
+ return new Var_expression(var, location);
+}
+
+// Class Temporary_reference_expression.
+
+// The type.
+
+Type*
+Temporary_reference_expression::do_type()
+{
+ return this->statement_->type();
+}
+
+// Called if something takes the address of this temporary variable.
+// We never have to move temporary variables to the heap, but we do
+// need to know that they must live in the stack rather than in a
+// register.
+
+void
+Temporary_reference_expression::do_address_taken(bool)
+{
+ this->statement_->set_is_address_taken();
+}
+
+// Get a tree referring to the variable.
+
+tree
+Temporary_reference_expression::do_get_tree(Translate_context* context)
+{
+ Bvariable* bvar = this->statement_->get_backend_variable(context);
+
+ // The gcc backend can't represent the same set of recursive types
+ // that the Go frontend can. In some cases this means that a
+ // temporary variable won't have the right backend type. Correct
+ // that here by adding a type cast. We need to use base() to push
+ // the circularity down one level.
+ tree ret = var_to_tree(bvar);
+ if (POINTER_TYPE_P(TREE_TYPE(ret)) && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
+ {
+ tree type_tree = this->type()->base()->get_tree(context->gogo());
+ ret = fold_convert_loc(this->location(), type_tree, ret);
+ }
+ return ret;
+}
+
+// Make a reference to a temporary variable.
+
+Expression*
+Expression::make_temporary_reference(Temporary_statement* statement,
+ source_location location)
+{
+ return new Temporary_reference_expression(statement, location);
+}
+
+// A sink expression--a use of the blank identifier _.
+
+class Sink_expression : public Expression
+{
+ public:
+ Sink_expression(source_location location)
+ : Expression(EXPRESSION_SINK, location),
+ type_(NULL), var_(NULL_TREE)
+ { }
+
+ protected:
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return new Sink_expression(this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type of this sink variable.
+ Type* type_;
+ // The temporary variable we generate.
+ tree var_;
+};
+
+// Return the type of a sink expression.
+
+Type*
+Sink_expression::do_type()
+{
+ if (this->type_ == NULL)
+ return Type::make_sink_type();
+ return this->type_;
+}
+
+// Determine the type of a sink expression.
+
+void
+Sink_expression::do_determine_type(const Type_context* context)
+{
+ if (context->type != NULL)
+ this->type_ = context->type;
+}
+
+// Return a temporary variable for a sink expression. This will
+// presumably be a write-only variable which the middle-end will drop.
+
+tree
+Sink_expression::do_get_tree(Translate_context* context)
+{
+ if (this->var_ == NULL_TREE)
+ {
+ go_assert(this->type_ != NULL && !this->type_->is_sink_type());
+ this->var_ = create_tmp_var(this->type_->get_tree(context->gogo()),
+ "blank");
+ }
+ return this->var_;
+}
+
+// Make a sink expression.
+
+Expression*
+Expression::make_sink(source_location location)
+{
+ return new Sink_expression(location);
+}
+
+// Class Func_expression.
+
+// FIXME: Can a function expression appear in a constant expression?
+// The value is unchanging. Initializing a constant to the address of
+// a function seems like it could work, though there might be little
+// point to it.
+
+// Traversal.
+
+int
+Func_expression::do_traverse(Traverse* traverse)
+{
+ return (this->closure_ == NULL
+ ? TRAVERSE_CONTINUE
+ : Expression::traverse(&this->closure_, traverse));
+}
+
+// Return the type of a function expression.
+
+Type*
+Func_expression::do_type()
+{
+ if (this->function_->is_function())
+ return this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ return this->function_->func_declaration_value()->type();
+ else
+ go_unreachable();
+}
+
+// Get the tree for a function expression without evaluating the
+// closure.
+
+tree
+Func_expression::get_tree_without_closure(Gogo* gogo)
+{
+ Function_type* fntype;
+ if (this->function_->is_function())
+ fntype = this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ fntype = this->function_->func_declaration_value()->type();
+ else
+ go_unreachable();
+
+ // Builtin functions are handled specially by Call_expression. We
+ // can't take their address.
+ if (fntype->is_builtin())
+ {
+ error_at(this->location(), "invalid use of special builtin function %qs",
+ this->function_->name().c_str());
+ return error_mark_node;
+ }
+
+ Named_object* no = this->function_;
+
+ tree id = no->get_id(gogo);
+ if (id == error_mark_node)
+ return error_mark_node;
+
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(gogo, no, id);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
+ else
+ go_unreachable();
+
+ if (fndecl == error_mark_node)
+ return error_mark_node;
+
+ return build_fold_addr_expr_loc(this->location(), fndecl);
+}
+
+// Get the tree for a function expression. This is used when we take
+// the address of a function rather than simply calling it. If the
+// function has a closure, we must use a trampoline.
+
+tree
+Func_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ tree fnaddr = this->get_tree_without_closure(gogo);
+ if (fnaddr == error_mark_node)
+ return error_mark_node;
+
+ go_assert(TREE_CODE(fnaddr) == ADDR_EXPR
+ && TREE_CODE(TREE_OPERAND(fnaddr, 0)) == FUNCTION_DECL);
+ TREE_ADDRESSABLE(TREE_OPERAND(fnaddr, 0)) = 1;
+
+ // For a normal non-nested function call, that is all we have to do.
+ if (!this->function_->is_function()
+ || this->function_->func_value()->enclosing() == NULL)
+ {
+ go_assert(this->closure_ == NULL);
+ return fnaddr;
+ }
+
+ // For a nested function call, we have to always allocate a
+ // trampoline. If we don't always allocate, then closures will not
+ // be reliably distinct.
+ Expression* closure = this->closure_;
+ tree closure_tree;
+ if (closure == NULL)
+ closure_tree = null_pointer_node;
+ else
+ {
+ // Get the value of the closure. This will be a pointer to
+ // space allocated on the heap.
+ closure_tree = closure->get_tree(context);
+ if (closure_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(POINTER_TYPE_P(TREE_TYPE(closure_tree)));
+ }
+
+ // Now we need to build some code on the heap. This code will load
+ // the static chain pointer with the closure and then jump to the
+ // body of the function. The normal gcc approach is to build the
+ // code on the stack. Unfortunately we can not do that, as Go
+ // permits us to return the function pointer.
+
+ return gogo->make_trampoline(fnaddr, closure_tree, this->location());
+}
+
+// Make a reference to a function in an expression.
+
+Expression*
+Expression::make_func_reference(Named_object* function, Expression* closure,
+ source_location location)
+{
+ return new Func_expression(function, closure, location);
+}
+
+// Class Unknown_expression.
+
+// Return the name of an unknown expression.
+
+const std::string&
+Unknown_expression::name() const
+{
+ return this->named_object_->name();
+}
+
+// Lower a reference to an unknown name.
+
+Expression*
+Unknown_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Named_object* no = this->named_object_;
+ Named_object* real;
+ if (!no->is_unknown())
+ real = no;
+ else
+ {
+ real = no->unknown_value()->real_named_object();
+ if (real == NULL)
+ {
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined name %qs",
+ this->named_object_->message_name().c_str());
+ return Expression::make_error(location);
+ }
+ }
+ switch (real->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(real, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(real->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined type %qs",
+ real->message_name().c_str());
+ return Expression::make_error(location);
+ case Named_object::NAMED_OBJECT_VAR:
+ return Expression::make_var_reference(real, location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(real, NULL, location);
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ default:
+ go_unreachable();
+ }
+}
+
+// Make a reference to an unknown name.
+
+Expression*
+Expression::make_unknown_reference(Named_object* no, source_location location)
+{
+ go_assert(no->resolve()->is_unknown());
+ return new Unknown_expression(no, location);
+}
+
+// A boolean expression.
+
+class Boolean_expression : public Expression
+{
+ public:
+ Boolean_expression(bool val, source_location location)
+ : Expression(EXPRESSION_BOOLEAN, location),
+ val_(val), type_(NULL)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->val_ ? boolean_true_node : boolean_false_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string(this->val_ ? "true" : "false"); }
+
+ private:
+ // The constant.
+ bool val_;
+ // The type as determined by context.
+ Type* type_;
+};
+
+// Get the type.
+
+Type*
+Boolean_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_boolean_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+Boolean_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_bool_type();
+}
+
+// Import a boolean constant.
+
+Expression*
+Boolean_expression::do_import(Import* imp)
+{
+ if (imp->peek_char() == 't')
+ {
+ imp->require_c_string("true");
+ return Expression::make_boolean(true, imp->location());
+ }
+ else
+ {
+ imp->require_c_string("false");
+ return Expression::make_boolean(false, imp->location());
+ }
+}
+
+// Make a boolean expression.
+
+Expression*
+Expression::make_boolean(bool val, source_location location)
+{
+ return new Boolean_expression(val, location);
+}
+
+// Class String_expression.
+
+// Get the type.
+
+Type*
+String_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_string_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+String_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_string_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_string_type();
+}
+
+// Build a string constant.
+
+tree
+String_expression::do_get_tree(Translate_context* context)
+{
+ return context->gogo()->go_string_constant_tree(this->val_);
+}
+
+// Export a string expression.
+
+void
+String_expression::do_export(Export* exp) const
+{
+ std::string s;
+ s.reserve(this->val_.length() * 4 + 2);
+ s += '"';
+ for (std::string::const_iterator p = this->val_.begin();
+ p != this->val_.end();
+ ++p)
+ {
+ if (*p == '\\' || *p == '"')
+ {
+ s += '\\';
+ s += *p;
+ }
+ else if (*p >= 0x20 && *p < 0x7f)
+ s += *p;
+ else if (*p == '\n')
+ s += "\\n";
+ else if (*p == '\t')
+ s += "\\t";
+ else
+ {
+ s += "\\x";
+ unsigned char c = *p;
+ unsigned int dig = c >> 4;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ dig = c & 0xf;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ }
+ }
+ s += '"';
+ exp->write_string(s);
+}
+
+// Import a string expression.
+
+Expression*
+String_expression::do_import(Import* imp)
+{
+ imp->require_c_string("\"");
+ std::string val;
+ while (true)
+ {
+ int c = imp->get_char();
+ if (c == '"' || c == -1)
+ break;
+ if (c != '\\')
+ val += static_cast<char>(c);
+ else
+ {
+ c = imp->get_char();
+ if (c == '\\' || c == '"')
+ val += static_cast<char>(c);
+ else if (c == 'n')
+ val += '\n';
+ else if (c == 't')
+ val += '\t';
+ else if (c == 'x')
+ {
+ c = imp->get_char();
+ unsigned int vh = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ c = imp->get_char();
+ unsigned int vl = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ char v = (vh << 4) | vl;
+ val += v;
+ }
+ else
+ {
+ error_at(imp->location(), "bad string constant");
+ return Expression::make_error(imp->location());
+ }
+ }
+ }
+ return Expression::make_string(val, imp->location());
+}
+
+// Make a string expression.
+
+Expression*
+Expression::make_string(const std::string& val, source_location location)
+{
+ return new String_expression(val, location);
+}
+
+// Make an integer expression.
+
+class Integer_expression : public Expression
+{
+ public:
+ Integer_expression(const mpz_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_INTEGER, location),
+ type_(type)
+ { mpz_init_set(this->val_, *val); }
+
+ static Expression*
+ do_import(Import*);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpz_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_integer(Export* exp, const mpz_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type** ptype) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context* context);
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_integer(&this->val_, this->type_,
+ this->location()); }
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The integer value.
+ mpz_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Return an integer constant value.
+
+bool
+Integer_expression::do_integer_constant_value(bool, mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpz_set(val, this->val_);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract integer type.
+
+Type*
+Integer_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_integer_type();
+ return this->type_;
+}
+
+// Set the type of the integer value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Integer_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_integer_type("int");
+}
+
+// Return true if the integer VAL fits in the range of the type TYPE.
+// Otherwise give an error and return false. TYPE may be NULL.
+
+bool
+Integer_expression::check_constant(mpz_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Integer_type* itype = type->integer_type();
+ if (itype == NULL || itype->is_abstract())
+ return true;
+
+ int bits = mpz_sizeinbase(val, 2);
+
+ if (itype->is_unsigned())
+ {
+ // For an unsigned type we can only accept a nonnegative number,
+ // and we must be able to represent at least BITS.
+ if (mpz_sgn(val) >= 0
+ && bits <= itype->bits())
+ return true;
+ }
+ else
+ {
+ // For a signed type we need an extra bit to indicate the sign.
+ // We have to handle the most negative integer specially.
+ if (bits + 1 <= itype->bits()
+ || (bits <= itype->bits()
+ && mpz_sgn(val) < 0
+ && (mpz_scan1(val, 0)
+ == static_cast<unsigned long>(itype->bits() - 1))
+ && mpz_scan0(val, itype->bits()) == ULONG_MAX))
+ return true;
+ }
+
+ error_at(location, "integer constant overflow");
+ return false;
+}
+
+// Check the type of an integer constant.
+
+void
+Integer_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+ if (!Integer_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for an integer constant.
+
+tree
+Integer_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->float_type() != NULL)
+ {
+ // We are converting to an abstract floating point type.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ else if (this->type_ != NULL && this->type_->complex_type() != NULL)
+ {
+ // We are converting to an abstract complex type.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced for
+ // some reason. Use a type which will fit the value. We use <,
+ // not <=, because we need an extra bit for the sign bit.
+ int bits = mpz_sizeinbase(this->val_, 2);
+ if (bits < INT_TYPE_SIZE)
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ else if (bits < 64)
+ type = Type::lookup_integer_type("int64")->get_tree(gogo);
+ else
+ type = long_long_integer_type_node;
+ }
+ return Expression::integer_constant_tree(this->val_, type);
+}
+
+// Write VAL to export data.
+
+void
+Integer_expression::export_integer(Export* exp, const mpz_t val)
+{
+ char* s = mpz_get_str(NULL, 10, val);
+ exp->write_c_string(s);
+ free(s);
+}
+
+// Export an integer in a constant expression.
+
+void
+Integer_expression::do_export(Export* exp) const
+{
+ Integer_expression::export_integer(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Import an integer, floating point, or complex value. This handles
+// all these types because they all start with digits.
+
+Expression*
+Integer_expression::do_import(Import* imp)
+{
+ std::string num = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (!num.empty() && num[num.length() - 1] == 'i')
+ {
+ mpfr_t real;
+ size_t plus_pos = num.find('+', 1);
+ size_t minus_pos = num.find('-', 1);
+ size_t pos;
+ if (plus_pos == std::string::npos)
+ pos = minus_pos;
+ else if (minus_pos == std::string::npos)
+ pos = plus_pos;
+ else
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ if (pos == std::string::npos)
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ else
+ {
+ std::string real_str = num.substr(0, pos);
+ if (mpfr_init_set_str(real, real_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ real_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ }
+
+ std::string imag_str;
+ if (pos == std::string::npos)
+ imag_str = num;
+ else
+ imag_str = num.substr(pos);
+ imag_str = imag_str.substr(0, imag_str.size() - 1);
+ mpfr_t imag;
+ if (mpfr_init_set_str(imag, imag_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ imag_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_complex(&real, &imag, NULL,
+ imp->location());
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ else if (num.find('.') == std::string::npos
+ && num.find('E') == std::string::npos)
+ {
+ mpz_t val;
+ if (mpz_init_set_str(val, num.c_str(), 10) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_integer(&val, NULL, imp->location());
+ mpz_clear(val);
+ return ret;
+ }
+ else
+ {
+ mpfr_t val;
+ if (mpfr_init_set_str(val, num.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_float(&val, NULL, imp->location());
+ mpfr_clear(val);
+ return ret;
+ }
+}
+
+// Build a new integer value.
+
+Expression*
+Expression::make_integer(const mpz_t* val, Type* type,
+ source_location location)
+{
+ return new Integer_expression(val, type, location);
+}
+
+// Floats.
+
+class Float_expression : public Expression
+{
+ public:
+ Float_expression(const mpfr_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_FLOAT, location),
+ type_(type)
+ {
+ mpfr_init_set(this->val_, *val, GMP_RNDN);
+ }
+
+ // Constrain VAL to fit into TYPE.
+ static void
+ constrain_float(mpfr_t val, Type* type);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpfr_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_float(Export* exp, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_float(&this->val_, this->type_,
+ this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The floating point value.
+ mpfr_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Constrain VAL to fit into TYPE.
+
+void
+Float_expression::constrain_float(mpfr_t val, Type* type)
+{
+ Float_type* ftype = type->float_type();
+ if (ftype != NULL && !ftype->is_abstract())
+ mpfr_prec_round(val, ftype->bits(), GMP_RNDN);
+}
+
+// Return a floating point constant value.
+
+bool
+Float_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(val, this->val_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract float type.
+
+Type*
+Float_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_float_type();
+ return this->type_;
+}
+
+// Set the type of the float value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Float_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_float_type("float64");
+}
+
+// Return true if the floating point value VAL fits in the range of
+// the type TYPE. Otherwise give an error and return false. TYPE may
+// be NULL.
+
+bool
+Float_expression::check_constant(mpfr_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Float_type* ftype = type->float_type();
+ if (ftype == NULL || ftype->is_abstract())
+ return true;
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (mpfr_nan_p(val) || mpfr_inf_p(val) || mpfr_zero_p(val))
+ return true;
+
+ mp_exp_t exp = mpfr_get_exp(val);
+ mp_exp_t max_exp;
+ switch (ftype->bits())
+ {
+ case 32:
+ max_exp = 128;
+ break;
+ case 64:
+ max_exp = 1024;
+ break;
+ default:
+ go_unreachable();
+ }
+ if (exp > max_exp)
+ {
+ error_at(location, "floating point constant overflow");
+ return false;
+ }
+ return true;
+}
+
+// Check the type of a float value.
+
+void
+Float_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Float_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+
+ Integer_type* integer_type = this->type_->integer_type();
+ if (integer_type != NULL)
+ {
+ if (!mpfr_integer_p(this->val_))
+ this->report_error(_("floating point constant truncated to integer"));
+ else
+ {
+ go_assert(!integer_type->is_abstract());
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, this->val_, GMP_RNDN);
+ Integer_expression::check_constant(ival, integer_type,
+ this->location());
+ mpz_clear(ival);
+ }
+ }
+}
+
+// Get a tree for a float constant.
+
+tree
+Float_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->integer_type() != NULL)
+ {
+ // We have an abstract integer type. We just hope for the best.
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use float64 and hope for the best.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ return Expression::float_constant_tree(this->val_, type);
+}
+
+// Write a floating point number to export data.
+
+void
+Float_expression::export_float(Export *exp, const mpfr_t val)
+{
+ mp_exp_t exponent;
+ char* s = mpfr_get_str(NULL, &exponent, 10, 0, val, GMP_RNDN);
+ if (*s == '-')
+ exp->write_c_string("-");
+ exp->write_c_string("0.");
+ exp->write_c_string(*s == '-' ? s + 1 : s);
+ mpfr_free_str(s);
+ char buf[30];
+ snprintf(buf, sizeof buf, "E%ld", exponent);
+ exp->write_c_string(buf);
+}
+
+// Export a floating point number in a constant expression.
+
+void
+Float_expression::do_export(Export* exp) const
+{
+ Float_expression::export_float(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a float expression.
+
+Expression*
+Expression::make_float(const mpfr_t* val, Type* type, source_location location)
+{
+ return new Float_expression(val, type, location);
+}
+
+// Complex numbers.
+
+class Complex_expression : public Expression
+{
+ public:
+ Complex_expression(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+ : Expression(EXPRESSION_COMPLEX, location),
+ type_(type)
+ {
+ mpfr_init_set(this->real_, *real, GMP_RNDN);
+ mpfr_init_set(this->imag_, *imag, GMP_RNDN);
+ }
+
+ // Constrain REAL/IMAG to fit into TYPE.
+ static void
+ constrain_complex(mpfr_t real, mpfr_t imag, Type* type);
+
+ // Return whether REAL/IMAG fits in the type.
+ static bool
+ check_constant(mpfr_t real, mpfr_t imag, Type*, source_location);
+
+ // Write REAL/IMAG to export data.
+ static void
+ export_complex(Export* exp, const mpfr_t real, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_complex(&this->real_, &this->imag_, this->type_,
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The real part.
+ mpfr_t real_;
+ // The imaginary part;
+ mpfr_t imag_;
+ // The type if known.
+ Type* type_;
+};
+
+// Constrain REAL/IMAG to fit into TYPE.
+
+void
+Complex_expression::constrain_complex(mpfr_t real, mpfr_t imag, Type* type)
+{
+ Complex_type* ctype = type->complex_type();
+ if (ctype != NULL && !ctype->is_abstract())
+ {
+ mpfr_prec_round(real, ctype->bits() / 2, GMP_RNDN);
+ mpfr_prec_round(imag, ctype->bits() / 2, GMP_RNDN);
+ }
+}
+
+// Return a complex constant value.
+
+bool
+Complex_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(real, this->real_, GMP_RNDN);
+ mpfr_set(imag, this->imag_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract complex type.
+
+Type*
+Complex_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_complex_type();
+ return this->type_;
+}
+
+// Set the type of the complex value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Complex_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && context->type->complex_type() != NULL)
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_complex_type("complex128");
+}
+
+// Return true if the complex value REAL/IMAG fits in the range of the
+// type TYPE. Otherwise give an error and return false. TYPE may be
+// NULL.
+
+bool
+Complex_expression::check_constant(mpfr_t real, mpfr_t imag, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Complex_type* ctype = type->complex_type();
+ if (ctype == NULL || ctype->is_abstract())
+ return true;
+
+ mp_exp_t max_exp;
+ switch (ctype->bits())
+ {
+ case 64:
+ max_exp = 128;
+ break;
+ case 128:
+ max_exp = 1024;
+ break;
+ default:
+ go_unreachable();
+ }
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (!mpfr_nan_p(real) && !mpfr_inf_p(real) && !mpfr_zero_p(real))
+ {
+ if (mpfr_get_exp(real) > max_exp)
+ {
+ error_at(location, "complex real part constant overflow");
+ return false;
+ }
+ }
+
+ if (!mpfr_nan_p(imag) && !mpfr_inf_p(imag) && !mpfr_zero_p(imag))
+ {
+ if (mpfr_get_exp(imag) > max_exp)
+ {
+ error_at(location, "complex imaginary part constant overflow");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check the type of a complex value.
+
+void
+Complex_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Complex_expression::check_constant(this->real_, this->imag_,
+ this->type_, this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for a complex constant.
+
+tree
+Complex_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else
+ {
+ // If we still have an abstract type here, this this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use complex128 and hope for the best.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ return Expression::complex_constant_tree(this->real_, this->imag_, type);
+}
+
+// Write REAL/IMAG to export data.
+
+void
+Complex_expression::export_complex(Export* exp, const mpfr_t real,
+ const mpfr_t imag)
+{
+ if (!mpfr_zero_p(real))
+ {
+ Float_expression::export_float(exp, real);
+ if (mpfr_sgn(imag) > 0)
+ exp->write_c_string("+");
+ }
+ Float_expression::export_float(exp, imag);
+ exp->write_c_string("i");
+}
+
+// Export a complex number in a constant expression.
+
+void
+Complex_expression::do_export(Export* exp) const
+{
+ Complex_expression::export_complex(exp, this->real_, this->imag_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a complex expression.
+
+Expression*
+Expression::make_complex(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+{
+ return new Complex_expression(real, imag, type, location);
+}
+
+// Find a named object in an expression.
+
+class Find_named_object : public Traverse
+{
+ public:
+ Find_named_object(Named_object* no)
+ : Traverse(traverse_expressions),
+ no_(no), found_(false)
+ { }
+
+ // Whether we found the object.
+ bool
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The object we are looking for.
+ Named_object* no_;
+ // Whether we found it.
+ bool found_;
+};
+
+// A reference to a const in an expression.
+
+class Const_expression : public Expression
+{
+ public:
+ Const_expression(Named_object* constant, source_location location)
+ : Expression(EXPRESSION_CONST_REFERENCE, location),
+ constant_(constant), type_(NULL), seen_(false)
+ { }
+
+ Named_object*
+ named_object()
+ { return this->constant_; }
+
+ // Check that the initializer does not refer to the constant itself.
+ void
+ check_for_init_loop();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ bool
+ do_string_constant_value(std::string* val) const
+ { return this->constant_->const_value()->expr()->string_constant_value(val); }
+
+ Type*
+ do_type();
+
+ // The type of a const is set by the declaration, not the use.
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ // When exporting a reference to a const as part of a const
+ // expression, we export the value. We ignore the fact that it has
+ // a name.
+ void
+ do_export(Export* exp) const
+ { this->constant_->const_value()->expr()->export_expression(exp); }
+
+ private:
+ // The constant.
+ Named_object* constant_;
+ // The type of this reference. This is used if the constant has an
+ // abstract type.
+ Type* type_;
+ // Used to prevent infinite recursion when a constant incorrectly
+ // refers to itself.
+ mutable bool seen_;
+};
+
+// Traversal.
+
+int
+Const_expression::do_traverse(Traverse* traverse)
+{
+ if (this->type_ != NULL)
+ return Type::traverse(this->type_, traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a constant expression. This is where we convert the
+// predeclared constant iota into an integer value.
+
+Expression*
+Const_expression::do_lower(Gogo* gogo, Named_object*, int iota_value)
+{
+ if (this->constant_->const_value()->expr()->classification()
+ == EXPRESSION_IOTA)
+ {
+ if (iota_value == -1)
+ {
+ error_at(this->location(),
+ "iota is only defined in const declarations");
+ iota_value = 0;
+ }
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned long>(iota_value));
+ Expression* ret = Expression::make_integer(&val, NULL,
+ this->location());
+ mpz_clear(val);
+ return ret;
+ }
+
+ // Make sure that the constant itself has been lowered.
+ gogo->lower_constant(this->constant_);
+
+ return this;
+}
+
+// Return an integer constant value.
+
+bool
+Const_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->integer_type() == NULL)
+ return false;
+
+ Expression* e = this->constant_->const_value()->expr();
+
+ this->seen_ = true;
+
+ Type* t;
+ bool r = e->integer_constant_value(iota_is_constant, val, &t);
+
+ this->seen_ = false;
+
+ if (r
+ && ctype != NULL
+ && !Integer_expression::check_constant(val, ctype, this->location()))
+ return false;
+
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a floating point constant value.
+
+bool
+Const_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->float_type() == NULL)
+ return false;
+
+ this->seen_ = true;
+
+ Type* t;
+ bool r = this->constant_->const_value()->expr()->float_constant_value(val,
+ &t);
+
+ this->seen_ = false;
+
+ if (r && ctype != NULL)
+ {
+ if (!Float_expression::check_constant(val, ctype, this->location()))
+ return false;
+ Float_expression::constrain_float(val, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a complex constant value.
+
+bool
+Const_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type **ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->complex_type() == NULL)
+ return false;
+
+ this->seen_ = true;
+
+ Type *t;
+ bool r = this->constant_->const_value()->expr()->complex_constant_value(real,
+ imag,
+ &t);
+
+ this->seen_ = false;
+
+ if (r && ctype != NULL)
+ {
+ if (!Complex_expression::check_constant(real, imag, ctype,
+ this->location()))
+ return false;
+ Complex_expression::constrain_complex(real, imag, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return the type of the const reference.
+
+Type*
+Const_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+
+ Named_constant* nc = this->constant_->const_value();
+
+ if (this->seen_ || nc->lowering())
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ return this->type_;
+ }
+
+ this->seen_ = true;
+
+ Type* ret = nc->type();
+
+ if (ret != NULL)
+ {
+ this->seen_ = false;
+ return ret;
+ }
+
+ // During parsing, a named constant may have a NULL type, but we
+ // must not return a NULL type here.
+ ret = nc->expr()->type();
+
+ this->seen_ = false;
+
+ return ret;
+}
+
+// Set the type of the const reference.
+
+void
+Const_expression::do_determine_type(const Type_context* context)
+{
+ Type* ctype = this->constant_->const_value()->type();
+ Type* cetype = (ctype != NULL
+ ? ctype
+ : this->constant_->const_value()->expr()->type());
+ if (ctype != NULL && !ctype->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL)
+ && (cetype->integer_type() != NULL
+ || cetype->float_type() != NULL
+ || cetype->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_string_type()
+ && cetype->is_string_type())
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_boolean_type()
+ && cetype->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ {
+ if (cetype->is_abstract())
+ cetype = cetype->make_non_abstract_type();
+ this->type_ = cetype;
+ }
+}
+
+// Check for a loop in which the initializer of a constant refers to
+// the constant itself.
+
+void
+Const_expression::check_for_init_loop()
+{
+ if (this->type_ != NULL && this->type_->is_error())
+ return;
+
+ if (this->seen_)
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ return;
+ }
+
+ Expression* init = this->constant_->const_value()->expr();
+ Find_named_object find_named_object(this->constant_);
+
+ this->seen_ = true;
+ Expression::traverse(&init, &find_named_object);
+ this->seen_ = false;
+
+ if (find_named_object.found())
+ {
+ if (this->type_ == NULL || !this->type_->is_error())
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ }
+ return;
+ }
+}
+
+// Check types of a const reference.
+
+void
+Const_expression::do_check_types(Gogo*)
+{
+ if (this->type_ != NULL && this->type_->is_error())
+ return;
+
+ this->check_for_init_loop();
+
+ if (this->type_ == NULL || this->type_->is_abstract())
+ return;
+
+ // Check for integer overflow.
+ if (this->type_->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (!this->integer_constant_value(true, ival, &dummy))
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Expression* cexpr = this->constant_->const_value()->expr();
+ if (cexpr->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ this->report_error(_("floating point constant "
+ "truncated to integer"));
+ else
+ {
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ Integer_expression::check_constant(ival, this->type_,
+ this->location());
+ }
+ }
+ mpfr_clear(fval);
+ }
+ mpz_clear(ival);
+ }
+}
+
+// Return a tree for the const reference.
+
+tree
+Const_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree;
+ if (this->type_ == NULL)
+ type_tree = NULL_TREE;
+ else
+ {
+ type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ }
+
+ // If the type has been set for this expression, but the underlying
+ // object is an abstract int or float, we try to get the abstract
+ // value. Otherwise we may lose something in the conversion.
+ if (this->type_ != NULL
+ && (this->constant_->const_value()->type() == NULL
+ || this->constant_->const_value()->type()->is_abstract()))
+ {
+ Expression* expr = this->constant_->const_value()->expr();
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ if (expr->integer_constant_value(true, ival, &t))
+ {
+ tree ret = Expression::integer_constant_tree(ival, type_tree);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (expr->float_constant_value(fval, &t))
+ {
+ tree ret = Expression::float_constant_tree(fval, type_tree);
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (expr->complex_constant_value(fval, imag, &t))
+ {
+ tree ret = Expression::complex_constant_tree(fval, imag, type_tree);
+ mpfr_clear(fval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(imag);
+ mpfr_clear(fval);
+ }
+
+ tree const_tree = this->constant_->get_tree(gogo, context->function());
+ if (this->type_ == NULL
+ || const_tree == error_mark_node
+ || TREE_TYPE(const_tree) == error_mark_node)
+ return const_tree;
+
+ tree ret;
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(const_tree)))
+ ret = fold_convert(type_tree, const_tree);
+ else if (TREE_CODE(type_tree) == INTEGER_TYPE)
+ ret = fold(convert_to_integer(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == REAL_TYPE)
+ ret = fold(convert_to_real(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
+ ret = fold(convert_to_complex(type_tree, const_tree));
+ else
+ go_unreachable();
+ return ret;
+}
+
+// Make a reference to a constant in an expression.
+
+Expression*
+Expression::make_const_reference(Named_object* constant,
+ source_location location)
+{
+ return new Const_expression(constant, location);
+}
+
+// Find a named object in an expression.
+
+int
+Find_named_object::expression(Expression** pexpr)
+{
+ switch ((*pexpr)->classification())
+ {
+ case Expression::EXPRESSION_CONST_REFERENCE:
+ {
+ Const_expression* ce = static_cast<Const_expression*>(*pexpr);
+ if (ce->named_object() == this->no_)
+ break;
+
+ // We need to check a constant initializer explicitly, as
+ // loops here will not be caught by the loop checking for
+ // variable initializers.
+ ce->check_for_init_loop();
+
+ return TRAVERSE_CONTINUE;
+ }
+
+ case Expression::EXPRESSION_VAR_REFERENCE:
+ if ((*pexpr)->var_expression()->named_object() == this->no_)
+ break;
+ return TRAVERSE_CONTINUE;
+ case Expression::EXPRESSION_FUNC_REFERENCE:
+ if ((*pexpr)->func_expression()->named_object() == this->no_)
+ break;
+ return TRAVERSE_CONTINUE;
+ default:
+ return TRAVERSE_CONTINUE;
+ }
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+}
+
+// The nil value.
+
+class Nil_expression : public Expression
+{
+ public:
+ Nil_expression(source_location location)
+ : Expression(EXPRESSION_NIL, location)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type()
+ { return Type::make_nil_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return null_pointer_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string("nil"); }
+};
+
+// Import a nil expression.
+
+Expression*
+Nil_expression::do_import(Import* imp)
+{
+ imp->require_c_string("nil");
+ return Expression::make_nil(imp->location());
+}
+
+// Make a nil expression.
+
+Expression*
+Expression::make_nil(source_location location)
+{
+ return new Nil_expression(location);
+}
+
+// The value of the predeclared constant iota. This is little more
+// than a marker. This will be lowered to an integer in
+// Const_expression::do_lower, which is where we know the value that
+// it should have.
+
+class Iota_expression : public Parser_expression
+{
+ public:
+ Iota_expression(source_location location)
+ : Parser_expression(EXPRESSION_IOTA, location)
+ { }
+
+ protected:
+ Expression*
+ do_lower(Gogo*, Named_object*, int)
+ { go_unreachable(); }
+
+ // There should only ever be one of these.
+ Expression*
+ do_copy()
+ { go_unreachable(); }
+};
+
+// Make an iota expression. This is only called for one case: the
+// value of the predeclared constant iota.
+
+Expression*
+Expression::make_iota()
+{
+ static Iota_expression iota_expression(UNKNOWN_LOCATION);
+ return &iota_expression;
+}
+
+// A type conversion expression.
+
+class Type_conversion_expression : public Expression
+{
+ public:
+ Type_conversion_expression(Type* type, Expression* expr,
+ source_location location)
+ : Expression(EXPRESSION_CONVERSION, location),
+ type_(type), expr_(expr), may_convert_function_types_(false)
+ { }
+
+ // Return the type to which we are converting.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Return the expression which we are converting.
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ // Permit converting from one function type to another. This is
+ // used internally for method expressions.
+ void
+ set_may_convert_function_types()
+ {
+ this->may_convert_function_types_ = true;
+ }
+
+ // Import a type conversion expression.
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return this->expr_->is_constant(); }
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ bool
+ do_string_constant_value(std::string*) const;
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ {
+ Type_context subcontext(this->type_, false);
+ this->expr_->determine_type(&subcontext);
+ }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Type_conversion_expression(this->type_, this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type to convert to.
+ Type* type_;
+ // The expression to convert.
+ Expression* expr_;
+ // True if this is permitted to convert function types. This is
+ // used internally for method expressions.
+ bool may_convert_function_types_;
+};
+
+// Traversal.
+
+int
+Type_conversion_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert to a constant at lowering time.
+
+Expression*
+Type_conversion_expression::do_lower(Gogo*, Named_object*, int)
+{
+ Type* type = this->type_;
+ Expression* val = this->expr_;
+ source_location location = this->location();
+
+ if (type->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (val->integer_constant_value(false, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpz_clear(ival);
+ return ret;
+ }
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(location,
+ "floating point constant truncated to integer");
+ return Expression::make_error(location);
+ }
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ }
+
+ if (type->float_type() != NULL)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, type, location))
+ mpfr_set_ui(fval, 0, GMP_RNDN);
+ Float_expression::constrain_float(fval, type);
+ Expression *ret = Expression::make_float(&fval, type, location);
+ mpfr_clear(fval);
+ return ret;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (type->complex_type() != NULL)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ Type* dummy;
+ if (val->complex_constant_value(real, imag, &dummy))
+ {
+ if (!Complex_expression::check_constant(real, imag, type, location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ Complex_expression::constrain_complex(real, imag, type);
+ Expression* ret = Expression::make_complex(&real, &imag, type,
+ location);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (type->is_open_array_type() && type->named_type() == NULL)
+ {
+ Type* element_type = type->array_type()->element_type()->forwarded();
+ bool is_byte = element_type == Type::lookup_integer_type("uint8");
+ bool is_int = element_type == Type::lookup_integer_type("int");
+ if (is_byte || is_int)
+ {
+ std::string s;
+ if (val->string_constant_value(&s))
+ {
+ Expression_list* vals = new Expression_list();
+ if (is_byte)
+ {
+ for (std::string::const_iterator p = s.begin();
+ p != s.end();
+ p++)
+ {
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned char>(*p));
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+ else
+ {
+ const char *p = s.data();
+ const char *pend = s.data() + s.length();
+ while (p < pend)
+ {
+ unsigned int c;
+ int adv = Lex::fetch_char(p, &c);
+ if (adv == 0)
+ {
+ warning_at(this->location(), 0,
+ "invalid UTF-8 encoding");
+ adv = 1;
+ }
+ p += adv;
+ mpz_t val;
+ mpz_init_set_ui(val, c);
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+
+ return Expression::make_slice_composite_literal(type, vals,
+ location);
+ }
+ }
+ }
+
+ return this;
+}
+
+// Return the constant integer value if there is one.
+
+bool
+Type_conversion_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_->integer_type() == NULL)
+ return false;
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(iota_is_constant, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, this->type_,
+ this->location()))
+ {
+ mpz_clear(ival);
+ return false;
+ }
+ mpz_set(val, ival);
+ mpz_clear(ival);
+ *ptype = this->type_;
+ return true;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ if (!Integer_expression::check_constant(val, this->type_,
+ this->location()))
+ return false;
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant floating point value if there is one.
+
+bool
+Type_conversion_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->type_->float_type() == NULL)
+ return false;
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, this->type_,
+ this->location()))
+ {
+ mpfr_clear(fval);
+ return false;
+ }
+ mpfr_set(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ Float_expression::constrain_float(val, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant complex value if there is one.
+
+bool
+Type_conversion_expression::do_complex_constant_value(mpfr_t real,
+ mpfr_t imag,
+ Type **ptype) const
+{
+ if (this->type_->complex_type() == NULL)
+ return false;
+
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ Type* dummy;
+ if (this->expr_->complex_constant_value(rval, ival, &dummy))
+ {
+ if (!Complex_expression::check_constant(rval, ival, this->type_,
+ this->location()))
+ {
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return false;
+ }
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ Complex_expression::constrain_complex(real, imag, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+
+ return false;
+}
+
+// Return the constant string value if there is one.
+
+bool
+Type_conversion_expression::do_string_constant_value(std::string* val) const
+{
+ if (this->type_->is_string_type()
+ && this->expr_->type()->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(false, ival, &dummy))
+ {
+ unsigned long ulval = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, ulval) == 0)
+ {
+ Lex::append_char(ulval, true, val, this->location());
+ mpz_clear(ival);
+ return true;
+ }
+ }
+ mpz_clear(ival);
+ }
+
+ // FIXME: Could handle conversion from const []int here.
+
+ return false;
+}
+
+// Check that types are convertible.
+
+void
+Type_conversion_expression::do_check_types(Gogo*)
+{
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ std::string reason;
+
+ if (type->is_error() || expr_type->is_error())
+ {
+ this->set_is_error();
+ return;
+ }
+
+ if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ return;
+
+ if (Type::are_convertible(type, expr_type, &reason))
+ return;
+
+ error_at(this->location(), "%s", reason.c_str());
+ this->set_is_error();
+}
+
+// Get a tree for a type conversion.
+
+tree
+Type_conversion_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->type_->get_tree(gogo);
+ tree expr_tree = this->expr_->get_tree(context);
+
+ if (type_tree == error_mark_node
+ || expr_tree == error_mark_node
+ || TREE_TYPE(expr_tree) == error_mark_node)
+ return error_mark_node;
+
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(expr_tree)))
+ return fold_convert(type_tree, expr_tree);
+
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ tree ret;
+ if (type->interface_type() != NULL || expr_type->interface_type() != NULL)
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+ else if (type->integer_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL
+ || expr_type->is_unsafe_pointer_type())
+ ret = fold(convert_to_integer(type_tree, expr_tree));
+ else
+ go_unreachable();
+ }
+ else if (type->float_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL)
+ ret = fold(convert_to_real(type_tree, expr_tree));
+ else
+ go_unreachable();
+ }
+ else if (type->complex_type() != NULL)
+ {
+ if (expr_type->complex_type() != NULL)
+ ret = fold(convert_to_complex(type_tree, expr_tree));
+ else
+ go_unreachable();
+ }
+ else if (type->is_string_type()
+ && expr_type->integer_type() != NULL)
+ {
+ expr_tree = fold_convert(integer_type_node, expr_tree);
+ if (host_integerp(expr_tree, 0))
+ {
+ HOST_WIDE_INT intval = tree_low_cst(expr_tree, 0);
+ std::string s;
+ Lex::append_char(intval, true, &s, this->location());
+ Expression* se = Expression::make_string(s, this->location());
+ return se->get_tree(context);
+ }
+
+ static tree int_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_to_string_fndecl,
+ this->location(),
+ "__go_int_to_string",
+ 1,
+ type_tree,
+ integer_type_node,
+ fold_convert(integer_type_node, expr_tree));
+ }
+ else if (type->is_string_type()
+ && (expr_type->array_type() != NULL
+ || (expr_type->points_to() != NULL
+ && expr_type->points_to()->array_type() != NULL)))
+ {
+ Type* t = expr_type;
+ if (t->points_to() != NULL)
+ {
+ t = t->points_to();
+ expr_tree = build_fold_indirect_ref(expr_tree);
+ }
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ Array_type* a = t->array_type();
+ Type* e = a->element_type()->forwarded();
+ go_assert(e->integer_type() != NULL);
+ tree valptr = fold_convert(const_ptr_type_node,
+ a->value_pointer_tree(gogo, expr_tree));
+ tree len = a->length_tree(gogo, expr_tree);
+ len = fold_convert_loc(this->location(), integer_type_node, len);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree byte_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&byte_array_to_string_fndecl,
+ this->location(),
+ "__go_byte_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ integer_type_node,
+ len);
+ }
+ else
+ {
+ go_assert(e == Type::lookup_integer_type("int"));
+ static tree int_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_array_to_string_fndecl,
+ this->location(),
+ "__go_int_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ integer_type_node,
+ len);
+ }
+ }
+ else if (type->is_open_array_type() && expr_type->is_string_type())
+ {
+ Type* e = type->array_type()->element_type()->forwarded();
+ go_assert(e->integer_type() != NULL);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree string_to_byte_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_byte_array_fndecl,
+ this->location(),
+ "__go_string_to_byte_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ else
+ {
+ go_assert(e == Type::lookup_integer_type("int"));
+ static tree string_to_int_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_int_array_fndecl,
+ this->location(),
+ "__go_string_to_int_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ }
+ else if ((type->is_unsafe_pointer_type()
+ && expr_type->points_to() != NULL)
+ || (expr_type->is_unsafe_pointer_type()
+ && type->points_to() != NULL))
+ ret = fold_convert(type_tree, expr_tree);
+ else if (type->is_unsafe_pointer_type()
+ && expr_type->integer_type() != NULL)
+ ret = convert_to_pointer(type_tree, expr_tree);
+ else if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ ret = fold_convert_loc(this->location(), type_tree, expr_tree);
+ else
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+
+ return ret;
+}
+
+// Output a type conversion in a constant expression.
+
+void
+Type_conversion_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ exp->write_c_string(", ");
+ this->expr_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a type conversion or a struct construction.
+
+Expression*
+Type_conversion_expression::do_import(Import* imp)
+{
+ imp->require_c_string("convert(");
+ Type* type = imp->read_type();
+ imp->require_c_string(", ");
+ Expression* val = Expression::import_expression(imp);
+ imp->require_c_string(")");
+ return Expression::make_cast(type, val, imp->location());
+}
+
+// Make a type cast expression.
+
+Expression*
+Expression::make_cast(Type* type, Expression* val, source_location location)
+{
+ if (type->is_error_type() || val->is_error_expression())
+ return Expression::make_error(location);
+ return new Type_conversion_expression(type, val, location);
+}
+
+// An unsafe type conversion, used to pass values to builtin functions.
+
+class Unsafe_type_conversion_expression : public Expression
+{
+ public:
+ Unsafe_type_conversion_expression(Type* type, Expression* expr,
+ source_location location)
+ : Expression(EXPRESSION_UNSAFE_CONVERSION, location),
+ type_(type), expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ {
+ return new Unsafe_type_conversion_expression(this->type_,
+ this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type to convert to.
+ Type* type_;
+ // The expression to convert.
+ Expression* expr_;
+};
+
+// Traversal.
+
+int
+Unsafe_type_conversion_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert to backend representation.
+
+tree
+Unsafe_type_conversion_expression::do_get_tree(Translate_context* context)
+{
+ // We are only called for a limited number of cases.
+
+ Type* t = this->type_;
+ Type* et = this->expr_->type();
+
+ tree type_tree = this->type_->get_tree(context->gogo());
+ tree expr_tree = this->expr_->get_tree(context);
+ if (type_tree == error_mark_node || expr_tree == error_mark_node)
+ return error_mark_node;
+
+ source_location loc = this->location();
+
+ bool use_view_convert = false;
+ if (t->is_open_array_type())
+ {
+ go_assert(et->is_open_array_type());
+ use_view_convert = true;
+ }
+ else if (t->map_type() != NULL)
+ go_assert(et->map_type() != NULL);
+ else if (t->channel_type() != NULL)
+ go_assert(et->channel_type() != NULL);
+ else if (t->points_to() != NULL && t->points_to()->channel_type() != NULL)
+ go_assert((et->points_to() != NULL
+ && et->points_to()->channel_type() != NULL)
+ || et->is_nil_type());
+ else if (t->is_unsafe_pointer_type())
+ go_assert(et->points_to() != NULL || et->is_nil_type());
+ else if (et->is_unsafe_pointer_type())
+ go_assert(t->points_to() != NULL);
+ else if (t->interface_type() != NULL && !t->interface_type()->is_empty())
+ {
+ go_assert(et->interface_type() != NULL
+ && !et->interface_type()->is_empty());
+ use_view_convert = true;
+ }
+ else if (t->interface_type() != NULL && t->interface_type()->is_empty())
+ {
+ go_assert(et->interface_type() != NULL
+ && et->interface_type()->is_empty());
+ use_view_convert = true;
+ }
+ else if (t->integer_type() != NULL)
+ {
+ go_assert(et->is_boolean_type()
+ || et->integer_type() != NULL
+ || et->function_type() != NULL
+ || et->points_to() != NULL
+ || et->map_type() != NULL
+ || et->channel_type() != NULL);
+ return convert_to_integer(type_tree, expr_tree);
+ }
+ else
+ go_unreachable();
+
+ if (use_view_convert)
+ return fold_build1_loc(loc, VIEW_CONVERT_EXPR, type_tree, expr_tree);
+ else
+ return fold_convert_loc(loc, type_tree, expr_tree);
+}
+
+// Make an unsafe type conversion expression.
+
+Expression*
+Expression::make_unsafe_cast(Type* type, Expression* expr,
+ source_location location)
+{
+ return new Unsafe_type_conversion_expression(type, expr, location);
+}
+
+// Unary expressions.
+
+class Unary_expression : public Expression
+{
+ public:
+ Unary_expression(Operator op, Expression* expr, source_location location)
+ : Expression(EXPRESSION_UNARY, location),
+ op_(op), escapes_(true), expr_(expr)
+ { }
+
+ // Return the operator.
+ Operator
+ op() const
+ { return this->op_; }
+
+ // Return the operand.
+ Expression*
+ operand() const
+ { return this->expr_; }
+
+ // Record that an address expression does not escape.
+ void
+ set_does_not_escape()
+ {
+ go_assert(this->op_ == OPERATOR_AND);
+ this->escapes_ = false;
+ }
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location);
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_float(Operator op, mpfr_t uval, mpfr_t val);
+
+ // Apply unary opcode OP to UREAL/UIMAG, setting REAL/IMAG. Return
+ // true if this could be done, false if not.
+ static bool
+ eval_complex(Operator op, mpfr_t ureal, mpfr_t uimag, mpfr_t real,
+ mpfr_t imag);
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_unary(this->op_, this->expr_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return this->op_ == OPERATOR_MULT; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The unary operator to apply.
+ Operator op_;
+ // Normally true. False if this is an address expression which does
+ // not escape the current function.
+ bool escapes_;
+ // The operand.
+ Expression* expr_;
+};
+
+// If we are taking the address of a composite literal, and the
+// contents are not constant, then we want to make a heap composite
+// instead.
+
+Expression*
+Unary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location loc = this->location();
+ Operator op = this->op_;
+ Expression* expr = this->expr_;
+
+ if (op == OPERATOR_MULT && expr->is_type_expression())
+ return Expression::make_type(Type::make_pointer_type(expr->type()), loc);
+
+ // *&x simplifies to x. *(*T)(unsafe.Pointer)(&x) does not require
+ // moving x to the heap. FIXME: Is it worth doing a real escape
+ // analysis here? This case is found in math/unsafe.go and is
+ // therefore worth special casing.
+ if (op == OPERATOR_MULT)
+ {
+ Expression* e = expr;
+ while (e->classification() == EXPRESSION_CONVERSION)
+ {
+ Type_conversion_expression* te
+ = static_cast<Type_conversion_expression*>(e);
+ e = te->expr();
+ }
+
+ if (e->classification() == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(e);
+ if (ue->op_ == OPERATOR_AND)
+ {
+ if (e == expr)
+ {
+ // *&x == x.
+ return ue->expr_;
+ }
+ ue->set_does_not_escape();
+ }
+ }
+ }
+
+ // Catching an invalid indirection of unsafe.Pointer here avoid
+ // having to deal with TYPE_VOID in other places.
+ if (op == OPERATOR_MULT && expr->type()->is_unsafe_pointer_type())
+ {
+ error_at(this->location(), "invalid indirect of %<unsafe.Pointer%>");
+ return Expression::make_error(this->location());
+ }
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS
+ || op == OPERATOR_NOT || op == OPERATOR_XOR)
+ {
+ Expression* ret = NULL;
+
+ mpz_t eval;
+ mpz_init(eval);
+ Type* etype;
+ if (expr->integer_constant_value(false, eval, &etype))
+ {
+ mpz_t val;
+ mpz_init(val);
+ if (Unary_expression::eval_integer(op, etype, eval, val, loc))
+ ret = Expression::make_integer(&val, etype, loc);
+ mpz_clear(val);
+ }
+ mpz_clear(eval);
+ if (ret != NULL)
+ return ret;
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* ftype;
+ if (expr->float_constant_value(fval, &ftype))
+ {
+ mpfr_t val;
+ mpfr_init(val);
+ if (Unary_expression::eval_float(op, fval, val))
+ ret = Expression::make_float(&val, ftype, loc);
+ mpfr_clear(val);
+ }
+ if (ret != NULL)
+ {
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t ival;
+ mpfr_init(ival);
+ if (expr->complex_constant_value(fval, ival, &ftype))
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (Unary_expression::eval_complex(op, fval, ival, real, imag))
+ ret = Expression::make_complex(&real, &imag, ftype, loc);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+ mpfr_clear(ival);
+ mpfr_clear(fval);
+ if (ret != NULL)
+ return ret;
+ }
+ }
+
+ return this;
+}
+
+// Return whether a unary expression is a constant.
+
+bool
+Unary_expression::do_is_constant() const
+{
+ if (this->op_ == OPERATOR_MULT)
+ {
+ // Indirecting through a pointer is only constant if the object
+ // to which the expression points is constant, but we currently
+ // have no way to determine that.
+ return false;
+ }
+ else if (this->op_ == OPERATOR_AND)
+ {
+ // Taking the address of a variable is constant if it is a
+ // global variable, not constant otherwise. In other cases
+ // taking the address is probably not a constant.
+ Var_expression* ve = this->expr_->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* no = ve->named_object();
+ return no->is_variable() && no->var_value()->is_global();
+ }
+ return false;
+ }
+ else
+ return this->expr_->is_constant();
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. UTYPE is the type of
+// UVAL, if known; it may be NULL. Return true if this could be done,
+// false if not.
+
+bool
+Unary_expression::eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpz_set(val, uval);
+ return true;
+ case OPERATOR_MINUS:
+ mpz_neg(val, uval);
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_NOT:
+ mpz_set_ui(val, mpz_cmp_si(uval, 0) == 0 ? 1 : 0);
+ return true;
+ case OPERATOR_XOR:
+ if (utype == NULL
+ || utype->integer_type() == NULL
+ || utype->integer_type()->is_abstract())
+ mpz_com(val, uval);
+ else
+ {
+ // The number of HOST_WIDE_INTs that it takes to represent
+ // UVAL.
+ size_t count = ((mpz_sizeinbase(uval, 2)
+ + HOST_BITS_PER_WIDE_INT
+ - 1)
+ / HOST_BITS_PER_WIDE_INT);
+
+ unsigned HOST_WIDE_INT* phwi = new unsigned HOST_WIDE_INT[count];
+ memset(phwi, 0, count * sizeof(HOST_WIDE_INT));
+
+ size_t ecount;
+ mpz_export(phwi, &ecount, -1, sizeof(HOST_WIDE_INT), 0, 0, uval);
+ go_assert(ecount <= count);
+
+ // Trim down to the number of words required by the type.
+ size_t obits = utype->integer_type()->bits();
+ if (!utype->integer_type()->is_unsigned())
+ ++obits;
+ size_t ocount = ((obits + HOST_BITS_PER_WIDE_INT - 1)
+ / HOST_BITS_PER_WIDE_INT);
+ go_assert(ocount <= count);
+
+ for (size_t i = 0; i < ocount; ++i)
+ phwi[i] = ~phwi[i];
+
+ size_t clearbits = ocount * HOST_BITS_PER_WIDE_INT - obits;
+ if (clearbits != 0)
+ phwi[ocount - 1] &= (((unsigned HOST_WIDE_INT) (HOST_WIDE_INT) -1)
+ >> clearbits);
+
+ mpz_import(val, ocount, -1, sizeof(HOST_WIDE_INT), 0, 0, phwi);
+
+ delete[] phwi;
+ }
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ go_unreachable();
+ }
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. Return true if this
+// could be done, false if not.
+
+bool
+Unary_expression::eval_float(Operator op, mpfr_t uval, mpfr_t val)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ go_unreachable();
+ }
+}
+
+// Apply unary opcode OP to RVAL/IVAL, setting REAL/IMAG. Return true
+// if this could be done, false if not.
+
+bool
+Unary_expression::eval_complex(Operator op, mpfr_t rval, mpfr_t ival,
+ mpfr_t real, mpfr_t imag)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(real, rval, GMP_RNDN);
+ mpfr_neg(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ go_unreachable();
+ }
+}
+
+// Return the integral constant value of a unary expression, if it has one.
+
+bool
+Unary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t uval;
+ mpz_init(uval);
+ bool ret;
+ if (!this->expr_->integer_constant_value(iota_is_constant, uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_integer(this->op_, *ptype, uval, val,
+ this->location());
+ mpz_clear(uval);
+ return ret;
+}
+
+// Return the floating point constant value of a unary expression, if
+// it has one.
+
+bool
+Unary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t uval;
+ mpfr_init(uval);
+ bool ret;
+ if (!this->expr_->float_constant_value(uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_float(this->op_, uval, val);
+ mpfr_clear(uval);
+ return ret;
+}
+
+// Return the complex constant value of a unary expression, if it has
+// one.
+
+bool
+Unary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ bool ret;
+ if (!this->expr_->complex_constant_value(rval, ival, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_complex(this->op_, rval, ival, real, imag);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return ret;
+}
+
+// Return the type of a unary expression.
+
+Type*
+Unary_expression::do_type()
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ return this->expr_->type();
+
+ case OPERATOR_AND:
+ return Type::make_pointer_type(this->expr_->type());
+
+ case OPERATOR_MULT:
+ {
+ Type* subtype = this->expr_->type();
+ Type* points_to = subtype->points_to();
+ if (points_to == NULL)
+ return Type::make_error_type();
+ return points_to;
+ }
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Determine abstract types for a unary expression.
+
+void
+Unary_expression::do_determine_type(const Type_context* context)
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ this->expr_->determine_type(context);
+ break;
+
+ case OPERATOR_AND:
+ // Taking the address of something.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : context->type->points_to());
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : Type::make_pointer_type(context->type));
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Check types for a unary expression.
+
+void
+Unary_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+ if (type->is_error())
+ {
+ this->set_is_error();
+ return;
+ }
+
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL)
+ this->report_error(_("expected numeric type"));
+ break;
+
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ if (type->integer_type() == NULL
+ && !type->is_boolean_type())
+ this->report_error(_("expected integer or boolean type"));
+ break;
+
+ case OPERATOR_AND:
+ if (!this->expr_->is_addressable())
+ this->report_error(_("invalid operand for unary %<&%>"));
+ else
+ this->expr_->address_taken(this->escapes_);
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ if (type->points_to() == NULL)
+ this->report_error(_("expected pointer"));
+ break;
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Get a tree for a unary expression.
+
+tree
+Unary_expression::do_get_tree(Translate_context* context)
+{
+ tree expr = this->expr_->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+
+ source_location loc = this->location();
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ return expr;
+
+ case OPERATOR_MINUS:
+ {
+ tree type = TREE_TYPE(expr);
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ expr = ::convert(compute_type, expr);
+ tree ret = fold_build1_loc(loc, NEGATE_EXPR,
+ (compute_type != NULL_TREE
+ ? compute_type
+ : type),
+ expr);
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+ return ret;
+ }
+
+ case OPERATOR_NOT:
+ if (TREE_CODE(TREE_TYPE(expr)) == BOOLEAN_TYPE)
+ return fold_build1_loc(loc, TRUTH_NOT_EXPR, TREE_TYPE(expr), expr);
+ else
+ return fold_build2_loc(loc, NE_EXPR, boolean_type_node, expr,
+ build_int_cst(TREE_TYPE(expr), 0));
+
+ case OPERATOR_XOR:
+ return fold_build1_loc(loc, BIT_NOT_EXPR, TREE_TYPE(expr), expr);
+
+ case OPERATOR_AND:
+ // We should not see a non-constant constructor here; cases
+ // where we would see one should have been moved onto the heap
+ // at parse time. Taking the address of a nonconstant
+ // constructor will not do what the programmer expects.
+ go_assert(TREE_CODE(expr) != CONSTRUCTOR || TREE_CONSTANT(expr));
+ go_assert(TREE_CODE(expr) != ADDR_EXPR);
+
+ // Build a decl for a constant constructor.
+ if (TREE_CODE(expr) == CONSTRUCTOR && TREE_CONSTANT(expr))
+ {
+ tree decl = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(expr));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ TREE_ADDRESSABLE(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = expr;
+ rest_of_decl_compilation(decl, 1, 0);
+ expr = decl;
+ }
+
+ return build_fold_addr_expr_loc(loc, expr);
+
+ case OPERATOR_MULT:
+ {
+ go_assert(POINTER_TYPE_P(TREE_TYPE(expr)));
+
+ // If we are dereferencing the pointer to a large struct, we
+ // need to check for nil. We don't bother to check for small
+ // structs because we expect the system to crash on a nil
+ // pointer dereference.
+ HOST_WIDE_INT s = int_size_in_bytes(TREE_TYPE(TREE_TYPE(expr)));
+ if (s == -1 || s >= 4096)
+ {
+ if (!DECL_P(expr))
+ expr = save_expr(expr);
+ tree compare = fold_build2_loc(loc, EQ_EXPR, boolean_type_node,
+ expr,
+ fold_convert(TREE_TYPE(expr),
+ null_pointer_node));
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE,
+ loc);
+ expr = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(expr),
+ build3(COND_EXPR, void_type_node,
+ compare, crash, NULL_TREE),
+ expr);
+ }
+
+ // If the type of EXPR is a recursive pointer type, then we
+ // need to insert a cast before indirecting.
+ if (TREE_TYPE(TREE_TYPE(expr)) == ptr_type_node)
+ {
+ Type* pt = this->expr_->type()->points_to();
+ tree ind = pt->get_tree(context->gogo());
+ expr = fold_convert_loc(loc, build_pointer_type(ind), expr);
+ }
+
+ return build_fold_indirect_ref_loc(loc, expr);
+ }
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Export a unary expression.
+
+void
+Unary_expression::do_export(Export* exp) const
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ exp->write_c_string("+ ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string("- ");
+ break;
+ case OPERATOR_NOT:
+ exp->write_c_string("! ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string("^ ");
+ break;
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ default:
+ go_unreachable();
+ }
+ this->expr_->export_expression(exp);
+}
+
+// Import a unary expression.
+
+Expression*
+Unary_expression::do_import(Import* imp)
+{
+ Operator op;
+ switch (imp->get_char())
+ {
+ case '+':
+ op = OPERATOR_PLUS;
+ break;
+ case '-':
+ op = OPERATOR_MINUS;
+ break;
+ case '!':
+ op = OPERATOR_NOT;
+ break;
+ case '^':
+ op = OPERATOR_XOR;
+ break;
+ default:
+ go_unreachable();
+ }
+ imp->require_c_string(" ");
+ Expression* expr = Expression::import_expression(imp);
+ return Expression::make_unary(op, expr, imp->location());
+}
+
+// Make a unary expression.
+
+Expression*
+Expression::make_unary(Operator op, Expression* expr, source_location location)
+{
+ return new Unary_expression(op, expr, location);
+}
+
+// If this is an indirection through a pointer, return the expression
+// being pointed through. Otherwise return this.
+
+Expression*
+Expression::deref()
+{
+ if (this->classification_ == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(this);
+ if (ue->op() == OPERATOR_MULT)
+ return ue->operand();
+ }
+ return this;
+}
+
+// Class Binary_expression.
+
+// Traversal.
+
+int
+Binary_expression::do_traverse(Traverse* traverse)
+{
+ int t = Expression::traverse(&this->left_, traverse);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->right_, traverse);
+}
+
+// Compare integer constants according to OP.
+
+bool
+Binary_expression::compare_integer(Operator op, mpz_t left_val,
+ mpz_t right_val)
+{
+ int i = mpz_cmp(left_val, right_val);
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ go_unreachable();
+ }
+}
+
+// Compare floating point constants according to OP.
+
+bool
+Binary_expression::compare_float(Operator op, Type* type, mpfr_t left_val,
+ mpfr_t right_val)
+{
+ int i;
+ if (type == NULL)
+ i = mpfr_cmp(left_val, right_val);
+ else
+ {
+ mpfr_t lv;
+ mpfr_init_set(lv, left_val, GMP_RNDN);
+ mpfr_t rv;
+ mpfr_init_set(rv, right_val, GMP_RNDN);
+ Float_expression::constrain_float(lv, type);
+ Float_expression::constrain_float(rv, type);
+ i = mpfr_cmp(lv, rv);
+ mpfr_clear(lv);
+ mpfr_clear(rv);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ go_unreachable();
+ }
+}
+
+// Compare complex constants according to OP. Complex numbers may
+// only be compared for equality.
+
+bool
+Binary_expression::compare_complex(Operator op, Type* type,
+ mpfr_t left_real, mpfr_t left_imag,
+ mpfr_t right_real, mpfr_t right_imag)
+{
+ bool is_equal;
+ if (type == NULL)
+ is_equal = (mpfr_cmp(left_real, right_real) == 0
+ && mpfr_cmp(left_imag, right_imag) == 0);
+ else
+ {
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ Complex_expression::constrain_complex(lr, li, type);
+ Complex_expression::constrain_complex(rr, ri, type);
+ is_equal = mpfr_cmp(lr, rr) == 0 && mpfr_cmp(li, ri) == 0;
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return is_equal;
+ case OPERATOR_NOTEQ:
+ return !is_equal;
+ default:
+ go_unreachable();
+ }
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// LEFT_TYPE is the type of LEFT_VAL, RIGHT_TYPE is the type of
+// RIGHT_VAL; LEFT_TYPE and/or RIGHT_TYPE may be NULL. Return true if
+// this could be done, false if not.
+
+bool
+Binary_expression::eval_integer(Operator op, Type* left_type, mpz_t left_val,
+ Type* right_type, mpz_t right_val,
+ source_location location, mpz_t val)
+{
+ bool is_shift_op = false;
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpz_add(val, left_val, right_val);
+ break;
+ case OPERATOR_MINUS:
+ mpz_sub(val, left_val, right_val);
+ break;
+ case OPERATOR_OR:
+ mpz_ior(val, left_val, right_val);
+ break;
+ case OPERATOR_XOR:
+ mpz_xor(val, left_val, right_val);
+ break;
+ case OPERATOR_MULT:
+ mpz_mul(val, left_val, right_val);
+ break;
+ case OPERATOR_DIV:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_q(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_MOD:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_r(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_LSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0 || shift > 0x100000)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ mpz_mul_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_RSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ if (mpz_cmp_ui(left_val, 0) >= 0)
+ mpz_tdiv_q_2exp(val, left_val, shift);
+ else
+ mpz_fdiv_q_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_AND:
+ mpz_and(val, left_val, right_val);
+ break;
+ case OPERATOR_BITCLEAR:
+ {
+ mpz_t tval;
+ mpz_init(tval);
+ mpz_com(tval, right_val);
+ mpz_and(val, left_val, tval);
+ mpz_clear(tval);
+ }
+ break;
+ default:
+ go_unreachable();
+ }
+
+ Type* type = left_type;
+ if (!is_shift_op)
+ {
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This look like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an
+ // unhelpful chain of error messages.
+ return true;
+ }
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ // We have to check the operands too, as we have implicitly
+ // coerced them to TYPE.
+ if ((type != left_type
+ && !Integer_expression::check_constant(left_val, type, location))
+ || (!is_shift_op
+ && type != right_type
+ && !Integer_expression::check_constant(right_val, type,
+ location))
+ || !Integer_expression::check_constant(val, type, location))
+ mpz_set_ui(val, 0);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// Return true if this could be done, false if not.
+
+bool
+Binary_expression::eval_float(Operator op, Type* left_type, mpfr_t left_val,
+ Type* right_type, mpfr_t right_val,
+ mpfr_t val, source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ mpfr_mul(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_DIV:
+ if (mpfr_zero_p(right_val))
+ error_at(location, "division by zero");
+ mpfr_div(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ go_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Float_expression::check_constant(left_val, type, location))
+ || (type != right_type
+ && !Float_expression::check_constant(right_val, type,
+ location))
+ || !Float_expression::check_constant(val, type, location))
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_REAL/LEFT_IMAG and
+// RIGHT_REAL/RIGHT_IMAG, setting REAL/IMAG. Return true if this
+// could be done, false if not.
+
+bool
+Binary_expression::eval_complex(Operator op, Type* left_type,
+ mpfr_t left_real, mpfr_t left_imag,
+ Type *right_type,
+ mpfr_t right_real, mpfr_t right_imag,
+ mpfr_t real, mpfr_t imag,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values and must be handled differently.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(real, left_real, right_real, GMP_RNDN);
+ mpfr_add(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(real, left_real, right_real, GMP_RNDN);
+ mpfr_sub(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ {
+ // You might think that multiplying two complex numbers would
+ // be simple, and you would be right, until you start to think
+ // about getting the right answer for infinity. If one
+ // operand here is infinity and the other is anything other
+ // than zero or NaN, then we are going to wind up subtracting
+ // two infinity values. That will give us a NaN, but the
+ // correct answer is infinity.
+
+ mpfr_t lrrr;
+ mpfr_init(lrrr);
+ mpfr_mul(lrrr, left_real, right_real, GMP_RNDN);
+
+ mpfr_t lrri;
+ mpfr_init(lrri);
+ mpfr_mul(lrri, left_real, right_imag, GMP_RNDN);
+
+ mpfr_t lirr;
+ mpfr_init(lirr);
+ mpfr_mul(lirr, left_imag, right_real, GMP_RNDN);
+
+ mpfr_t liri;
+ mpfr_init(liri);
+ mpfr_mul(liri, left_imag, right_imag, GMP_RNDN);
+
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+
+ // If we get NaN on both sides, check whether it should really
+ // be infinity. The rule is that if either side of the
+ // complex number is infinity, then the whole value is
+ // infinity, even if the other side is NaN. So the only case
+ // we have to fix is the one in which both sides are NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ bool is_infinity = false;
+
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+
+ // If the left side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(lr) || mpfr_inf_p(li))
+ {
+ mpfr_set_ui(lr, mpfr_inf_p(lr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ mpfr_set_ui(li, mpfr_inf_p(li) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If the right side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(rr) || mpfr_inf_p(ri))
+ {
+ mpfr_set_ui(rr, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ mpfr_set_ui(ri, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If we got an overflow in the intermediate computations,
+ // then the result is infinity.
+ if (!is_infinity
+ && (mpfr_inf_p(lrrr) || mpfr_inf_p(lrri)
+ || mpfr_inf_p(lirr) || mpfr_inf_p(liri)))
+ {
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ if (is_infinity)
+ {
+ mpfr_mul(lrrr, lr, rr, GMP_RNDN);
+ mpfr_mul(lrri, lr, ri, GMP_RNDN);
+ mpfr_mul(lirr, li, rr, GMP_RNDN);
+ mpfr_mul(liri, li, ri, GMP_RNDN);
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(real));
+ mpfr_set_inf(imag, mpfr_sgn(imag));
+ }
+
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+
+ mpfr_clear(lrrr);
+ mpfr_clear(lrri);
+ mpfr_clear(lirr);
+ mpfr_clear(liri);
+ }
+ break;
+ case OPERATOR_DIV:
+ {
+ // For complex division we want to avoid having an
+ // intermediate overflow turn the whole result in a NaN. We
+ // scale the values to try to avoid this.
+
+ if (mpfr_zero_p(right_real) && mpfr_zero_p(right_imag))
+ error_at(location, "division by zero");
+
+ mpfr_t rra;
+ mpfr_t ria;
+ mpfr_init(rra);
+ mpfr_init(ria);
+ mpfr_abs(rra, right_real, GMP_RNDN);
+ mpfr_abs(ria, right_imag, GMP_RNDN);
+ mpfr_t t;
+ mpfr_init(t);
+ mpfr_max(t, rra, ria, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ long ilogbw = 0;
+ if (!mpfr_inf_p(t) && !mpfr_nan_p(t) && !mpfr_zero_p(t))
+ {
+ ilogbw = mpfr_get_exp(t);
+ mpfr_mul_2si(rr, rr, - ilogbw, GMP_RNDN);
+ mpfr_mul_2si(ri, ri, - ilogbw, GMP_RNDN);
+ }
+
+ mpfr_t denom;
+ mpfr_init(denom);
+ mpfr_mul(denom, rr, rr, GMP_RNDN);
+ mpfr_mul(t, ri, ri, GMP_RNDN);
+ mpfr_add(denom, denom, t, GMP_RNDN);
+
+ mpfr_mul(real, left_real, rr, GMP_RNDN);
+ mpfr_mul(t, left_imag, ri, GMP_RNDN);
+ mpfr_add(real, real, t, GMP_RNDN);
+ mpfr_div(real, real, denom, GMP_RNDN);
+ mpfr_mul_2si(real, real, - ilogbw, GMP_RNDN);
+
+ mpfr_mul(imag, left_imag, rr, GMP_RNDN);
+ mpfr_mul(t, left_real, ri, GMP_RNDN);
+ mpfr_sub(imag, imag, t, GMP_RNDN);
+ mpfr_div(imag, imag, denom, GMP_RNDN);
+ mpfr_mul_2si(imag, imag, - ilogbw, GMP_RNDN);
+
+ // If we wind up with NaN on both sides, check whether we
+ // should really have infinity. The rule is that if either
+ // side of the complex number is infinity, then the whole
+ // value is infinity, even if the other side is NaN. So the
+ // only case we have to fix is the one in which both sides are
+ // NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ if (mpfr_zero_p(denom))
+ {
+ mpfr_set_inf(real, mpfr_sgn(rr));
+ mpfr_mul(real, real, left_real, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(rr));
+ mpfr_mul(imag, imag, left_imag, GMP_RNDN);
+ }
+ else if ((mpfr_inf_p(left_real) || mpfr_inf_p(left_imag))
+ && mpfr_number_p(rr) && mpfr_number_p(ri))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(left_real) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, left_real, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(left_imag) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, left_imag, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, t, rr, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, t2, ri, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(t3));
+
+ mpfr_mul(t3, t2, rr, GMP_RNDN);
+ mpfr_mul(t4, t, ri, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(t3));
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ else if ((mpfr_inf_p(right_real) || mpfr_inf_p(right_imag))
+ && mpfr_number_p(left_real) && mpfr_number_p(left_imag))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, rr, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, ri, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, left_real, t, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, left_imag, t2, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_mul(real, real, t3, GMP_RNDN);
+
+ mpfr_mul(t3, left_imag, t, GMP_RNDN);
+ mpfr_mul(t4, left_real, t2, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ mpfr_mul(imag, imag, t3, GMP_RNDN);
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ }
+
+ mpfr_clear(denom);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ mpfr_clear(t);
+ mpfr_clear(rra);
+ mpfr_clear(ria);
+ }
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ go_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Complex_expression::check_constant(left_real, left_imag,
+ type, location))
+ || (type != right_type
+ && !Complex_expression::check_constant(right_real, right_imag,
+ type, location))
+ || !Complex_expression::check_constant(real, imag, type,
+ location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ }
+
+ return true;
+}
+
+// Lower a binary expression. We have to evaluate constant
+// expressions now, in order to implement Go's unlimited precision
+// constants.
+
+Expression*
+Binary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Operator op = this->op_;
+ Expression* left = this->left_;
+ Expression* right = this->right_;
+
+ const bool is_comparison = (op == OPERATOR_EQEQ
+ || op == OPERATOR_NOTEQ
+ || op == OPERATOR_LT
+ || op == OPERATOR_LE
+ || op == OPERATOR_GT
+ || op == OPERATOR_GE);
+
+ // Integer constant expressions.
+ {
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (left->integer_constant_value(false, left_val, &left_type)
+ && right->integer_constant_value(false, right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_integer(op, left_val,
+ right_val);
+ ret = Expression::make_cast(Type::lookup_bool_type(),
+ Expression::make_boolean(b, location),
+ location);
+ }
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+
+ if (Binary_expression::eval_integer(op, left_type, left_val,
+ right_type, right_val,
+ location, val))
+ {
+ go_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND);
+ Type* type;
+ if (op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT)
+ type = left_type;
+ else if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_integer(&val, type, location);
+ }
+
+ mpz_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return ret;
+ }
+ }
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ }
+
+ // Floating point constant expressions.
+ {
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (left->float_constant_value(left_val, &left_type)
+ && right->float_constant_value(right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_float(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_val, right_val);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t val;
+ mpfr_init(val);
+
+ if (Binary_expression::eval_float(op, left_type, left_val,
+ right_type, right_val, val,
+ location))
+ {
+ go_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_float(&val, type, location);
+ }
+
+ mpfr_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return ret;
+ }
+ }
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ }
+
+ // Complex constant expressions.
+ {
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+
+ if (left->complex_constant_value(left_real, left_imag, &left_type)
+ && right->complex_constant_value(right_real, right_imag, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ)
+ {
+ bool b = Binary_expression::compare_complex(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_real,
+ left_imag,
+ right_real,
+ right_imag);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ if (Binary_expression::eval_complex(op, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ location))
+ {
+ go_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_complex(&real, &imag, type,
+ location);
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return ret;
+ }
+ }
+
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ }
+
+ // String constant expressions.
+ if (op == OPERATOR_PLUS
+ && left->type()->is_string_type()
+ && right->type()->is_string_type())
+ {
+ std::string left_string;
+ std::string right_string;
+ if (left->string_constant_value(&left_string)
+ && right->string_constant_value(&right_string))
+ return Expression::make_string(left_string + right_string, location);
+ }
+
+ return this;
+}
+
+// Return the integer constant value, if it has one.
+
+bool
+Binary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ if (!this->left_->integer_constant_value(iota_is_constant, left_val,
+ &left_type))
+ {
+ mpz_clear(left_val);
+ return false;
+ }
+
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (!this->right_->integer_constant_value(iota_is_constant, right_val,
+ &right_type))
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && this->op_ != OPERATOR_RSHIFT
+ && this->op_ != OPERATOR_LSHIFT)
+ ret = false;
+ else
+ ret = Binary_expression::eval_integer(this->op_, left_type, left_val,
+ right_type, right_val,
+ this->location(), val);
+
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the floating point constant value, if it has one.
+
+bool
+Binary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ if (!this->left_->float_constant_value(left_val, &left_type))
+ {
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (!this->right_->float_constant_value(right_val, &right_type))
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_float(this->op_, left_type, left_val,
+ right_type, right_val,
+ val, this->location());
+
+ mpfr_clear(left_val);
+ mpfr_clear(right_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the complex constant value, if it has one.
+
+bool
+Binary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+ if (!this->left_->complex_constant_value(left_real, left_imag, &left_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ return false;
+ }
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+ if (!this->right_->complex_constant_value(right_real, right_imag,
+ &right_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_complex(this->op_, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ this->location());
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Note that the value is being discarded.
+
+void
+Binary_expression::do_discarding_value()
+{
+ if (this->op_ == OPERATOR_OROR || this->op_ == OPERATOR_ANDAND)
+ this->right_->discarding_value();
+ else
+ this->warn_about_unused_value();
+}
+
+// Get type.
+
+Type*
+Binary_expression::do_type()
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return Type::make_error_type();
+
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Type::lookup_bool_type();
+
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ {
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (left_type->is_error())
+ return left_type;
+ else if (right_type->is_error())
+ return right_type;
+ else if (!Type::are_compatible_for_binop(left_type, right_type))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return Type::make_error_type();
+ }
+ else if (!left_type->is_abstract() && left_type->named_type() != NULL)
+ return left_type;
+ else if (!right_type->is_abstract() && right_type->named_type() != NULL)
+ return right_type;
+ else if (!left_type->is_abstract())
+ return left_type;
+ else if (!right_type->is_abstract())
+ return right_type;
+ else if (left_type->complex_type() != NULL)
+ return left_type;
+ else if (right_type->complex_type() != NULL)
+ return right_type;
+ else if (left_type->float_type() != NULL)
+ return left_type;
+ else if (right_type->float_type() != NULL)
+ return right_type;
+ else
+ return left_type;
+ }
+
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return this->left_->type();
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Set type for a binary expression.
+
+void
+Binary_expression::do_determine_type(const Type_context* context)
+{
+ Type* tleft = this->left_->type();
+ Type* tright = this->right_->type();
+
+ // Both sides should have the same type, except for the shift
+ // operations. For a comparison, we should ignore the incoming
+ // type.
+
+ bool is_shift_op = (this->op_ == OPERATOR_LSHIFT
+ || this->op_ == OPERATOR_RSHIFT);
+
+ bool is_comparison = (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE);
+
+ Type_context subcontext(*context);
+
+ if (is_comparison)
+ {
+ // In a comparison, the context does not determine the types of
+ // the operands.
+ subcontext.type = NULL;
+ }
+
+ // Set the context for the left hand operand.
+ if (is_shift_op)
+ {
+ // The right hand operand plays no role in determining the type
+ // of the left hand operand. A shift of an abstract integer in
+ // a string context gets special treatment, which may be a
+ // language bug.
+ if (subcontext.type != NULL
+ && subcontext.type->is_string_type()
+ && tleft->is_abstract())
+ error_at(this->location(), "shift of non-integer operand");
+ }
+ else if (!tleft->is_abstract())
+ subcontext.type = tleft;
+ else if (!tright->is_abstract())
+ subcontext.type = tright;
+ else if (subcontext.type == NULL)
+ {
+ if ((tleft->integer_type() != NULL && tright->integer_type() != NULL)
+ || (tleft->float_type() != NULL && tright->float_type() != NULL)
+ || (tleft->complex_type() != NULL && tright->complex_type() != NULL))
+ {
+ // Both sides have an abstract integer, abstract float, or
+ // abstract complex type. Just let CONTEXT determine
+ // whether they may remain abstract or not.
+ }
+ else if (tleft->complex_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->complex_type() != NULL)
+ subcontext.type = tright;
+ else if (tleft->float_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->float_type() != NULL)
+ subcontext.type = tright;
+ else
+ subcontext.type = tleft;
+
+ if (subcontext.type != NULL && !context->may_be_abstract)
+ subcontext.type = subcontext.type->make_non_abstract_type();
+ }
+
+ this->left_->determine_type(&subcontext);
+
+ // The context for the right hand operand is the same as for the
+ // left hand operand, except for a shift operator.
+ if (is_shift_op)
+ {
+ subcontext.type = Type::lookup_integer_type("uint");
+ subcontext.may_be_abstract = false;
+ }
+
+ this->right_->determine_type(&subcontext);
+}
+
+// Report an error if the binary operator OP does not support TYPE.
+// Return whether the operation is OK. This should not be used for
+// shift.
+
+bool
+Binary_expression::check_operator_type(Operator op, Type* type,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ if (!type->is_boolean_type())
+ {
+ error_at(location, "expected boolean type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type()
+ && type->points_to() == NULL
+ && !type->is_nil_type()
+ && !type->is_boolean_type()
+ && type->interface_type() == NULL
+ && (type->array_type() == NULL
+ || type->array_type()->length() != NULL)
+ && type->map_type() == NULL
+ && type->channel_type() == NULL
+ && type->function_type() == NULL)
+ {
+ error_at(location,
+ ("expected integer, floating, complex, string, pointer, "
+ "boolean, interface, slice, map, channel, "
+ "or function type"));
+ return false;
+ }
+ break;
+
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location, "expected integer, floating, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_PLUS:
+ case OPERATOR_PLUSEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location,
+ "expected integer, floating, complex, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MINUS:
+ case OPERATOR_MINUSEQ:
+ case OPERATOR_MULT:
+ case OPERATOR_MULTEQ:
+ case OPERATOR_DIV:
+ case OPERATOR_DIVEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL)
+ {
+ error_at(location, "expected integer, floating, or complex type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MOD:
+ case OPERATOR_MODEQ:
+ case OPERATOR_OR:
+ case OPERATOR_OREQ:
+ case OPERATOR_AND:
+ case OPERATOR_ANDEQ:
+ case OPERATOR_XOR:
+ case OPERATOR_XOREQ:
+ case OPERATOR_BITCLEAR:
+ case OPERATOR_BITCLEAREQ:
+ if (type->integer_type() == NULL)
+ {
+ error_at(location, "expected integer type");
+ return false;
+ }
+ break;
+
+ default:
+ go_unreachable();
+ }
+
+ return true;
+}
+
+// Check types.
+
+void
+Binary_expression::do_check_types(Gogo*)
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return;
+
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (left_type->is_error() || right_type->is_error())
+ {
+ this->set_is_error();
+ return;
+ }
+
+ if (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE)
+ {
+ if (!Type::are_assignable(left_type, right_type, NULL)
+ && !Type::are_assignable(right_type, left_type, NULL))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location())
+ || !Binary_expression::check_operator_type(this->op_, right_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else if (this->op_ != OPERATOR_LSHIFT && this->op_ != OPERATOR_RSHIFT)
+ {
+ if (!Type::are_compatible_for_binop(left_type, right_type))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else
+ {
+ if (left_type->integer_type() == NULL)
+ this->report_error(_("shift of non-integer operand"));
+
+ if (!right_type->is_abstract()
+ && (right_type->integer_type() == NULL
+ || !right_type->integer_type()->is_unsigned()))
+ this->report_error(_("shift count not unsigned integer"));
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (this->right_->integer_constant_value(true, val, &type))
+ {
+ if (mpz_sgn(val) < 0)
+ {
+ this->report_error(_("negative shift count"));
+ mpz_set_ui(val, 0);
+ source_location rloc = this->right_->location();
+ this->right_ = Expression::make_integer(&val, right_type,
+ rloc);
+ }
+ }
+ mpz_clear(val);
+ }
+ }
+}
+
+// Get a tree for a binary expression.
+
+tree
+Binary_expression::do_get_tree(Translate_context* context)
+{
+ tree left = this->left_->get_tree(context);
+ tree right = this->right_->get_tree(context);
+
+ if (left == error_mark_node || right == error_mark_node)
+ return error_mark_node;
+
+ enum tree_code code;
+ bool use_left_type = true;
+ bool is_shift_op = false;
+ switch (this->op_)
+ {
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Expression::comparison_tree(context, this->op_,
+ this->left_->type(), left,
+ this->right_->type(), right,
+ this->location());
+
+ case OPERATOR_OROR:
+ code = TRUTH_ORIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_ANDAND:
+ code = TRUTH_ANDIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_PLUS:
+ code = PLUS_EXPR;
+ break;
+ case OPERATOR_MINUS:
+ code = MINUS_EXPR;
+ break;
+ case OPERATOR_OR:
+ code = BIT_IOR_EXPR;
+ break;
+ case OPERATOR_XOR:
+ code = BIT_XOR_EXPR;
+ break;
+ case OPERATOR_MULT:
+ code = MULT_EXPR;
+ break;
+ case OPERATOR_DIV:
+ {
+ Type *t = this->left_->type();
+ if (t->float_type() != NULL || t->complex_type() != NULL)
+ code = RDIV_EXPR;
+ else
+ code = TRUNC_DIV_EXPR;
+ }
+ break;
+ case OPERATOR_MOD:
+ code = TRUNC_MOD_EXPR;
+ break;
+ case OPERATOR_LSHIFT:
+ code = LSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_RSHIFT:
+ code = RSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_AND:
+ code = BIT_AND_EXPR;
+ break;
+ case OPERATOR_BITCLEAR:
+ right = fold_build1(BIT_NOT_EXPR, TREE_TYPE(right), right);
+ code = BIT_AND_EXPR;
+ break;
+ default:
+ go_unreachable();
+ }
+
+ tree type = use_left_type ? TREE_TYPE(left) : TREE_TYPE(right);
+
+ if (this->left_->type()->is_string_type())
+ {
+ go_assert(this->op_ == OPERATOR_PLUS);
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_plus_decl;
+ return Gogo::call_builtin(&string_plus_decl,
+ this->location(),
+ "__go_string_plus",
+ 2,
+ string_type,
+ string_type,
+ left,
+ string_type,
+ right);
+ }
+
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ {
+ left = ::convert(compute_type, left);
+ right = ::convert(compute_type, right);
+ }
+
+ tree eval_saved = NULL_TREE;
+ if (is_shift_op)
+ {
+ // Make sure the values are evaluated.
+ if (!DECL_P(left) && TREE_SIDE_EFFECTS(left))
+ {
+ left = save_expr(left);
+ eval_saved = left;
+ }
+ if (!DECL_P(right) && TREE_SIDE_EFFECTS(right))
+ {
+ right = save_expr(right);
+ if (eval_saved == NULL_TREE)
+ eval_saved = right;
+ else
+ eval_saved = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ void_type_node, eval_saved, right);
+ }
+ }
+
+ tree ret = fold_build2_loc(this->location(),
+ code,
+ compute_type != NULL_TREE ? compute_type : type,
+ left, right);
+
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+
+ // In Go, a shift larger than the size of the type is well-defined.
+ // This is not true in GENERIC, so we need to insert a conditional.
+ if (is_shift_op)
+ {
+ go_assert(INTEGRAL_TYPE_P(TREE_TYPE(left)));
+ go_assert(this->left_->type()->integer_type() != NULL);
+ int bits = TYPE_PRECISION(TREE_TYPE(left));
+
+ tree compare = fold_build2(LT_EXPR, boolean_type_node, right,
+ build_int_cst_type(TREE_TYPE(right), bits));
+
+ tree overflow_result = fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node);
+ if (this->op_ == OPERATOR_RSHIFT
+ && !this->left_->type()->integer_type()->is_unsigned())
+ {
+ tree neg = fold_build2_loc(this->location(), LT_EXPR,
+ boolean_type_node, left,
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node));
+ tree neg_one = fold_build2_loc(this->location(),
+ MINUS_EXPR, TREE_TYPE(left),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_one_node));
+ overflow_result = fold_build3_loc(this->location(), COND_EXPR,
+ TREE_TYPE(left), neg, neg_one,
+ overflow_result);
+ }
+
+ ret = fold_build3_loc(this->location(), COND_EXPR, TREE_TYPE(left),
+ compare, ret, overflow_result);
+
+ if (eval_saved != NULL_TREE)
+ ret = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ TREE_TYPE(ret), eval_saved, ret);
+ }
+
+ return ret;
+}
+
+// Export a binary expression.
+
+void
+Binary_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("(");
+ this->left_->export_expression(exp);
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ exp->write_c_string(" || ");
+ break;
+ case OPERATOR_ANDAND:
+ exp->write_c_string(" && ");
+ break;
+ case OPERATOR_EQEQ:
+ exp->write_c_string(" == ");
+ break;
+ case OPERATOR_NOTEQ:
+ exp->write_c_string(" != ");
+ break;
+ case OPERATOR_LT:
+ exp->write_c_string(" < ");
+ break;
+ case OPERATOR_LE:
+ exp->write_c_string(" <= ");
+ break;
+ case OPERATOR_GT:
+ exp->write_c_string(" > ");
+ break;
+ case OPERATOR_GE:
+ exp->write_c_string(" >= ");
+ break;
+ case OPERATOR_PLUS:
+ exp->write_c_string(" + ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string(" - ");
+ break;
+ case OPERATOR_OR:
+ exp->write_c_string(" | ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string(" ^ ");
+ break;
+ case OPERATOR_MULT:
+ exp->write_c_string(" * ");
+ break;
+ case OPERATOR_DIV:
+ exp->write_c_string(" / ");
+ break;
+ case OPERATOR_MOD:
+ exp->write_c_string(" % ");
+ break;
+ case OPERATOR_LSHIFT:
+ exp->write_c_string(" << ");
+ break;
+ case OPERATOR_RSHIFT:
+ exp->write_c_string(" >> ");
+ break;
+ case OPERATOR_AND:
+ exp->write_c_string(" & ");
+ break;
+ case OPERATOR_BITCLEAR:
+ exp->write_c_string(" &^ ");
+ break;
+ default:
+ go_unreachable();
+ }
+ this->right_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a binary expression.
+
+Expression*
+Binary_expression::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+
+ Expression* left = Expression::import_expression(imp);
+
+ Operator op;
+ if (imp->match_c_string(" || "))
+ {
+ op = OPERATOR_OROR;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" && "))
+ {
+ op = OPERATOR_ANDAND;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" == "))
+ {
+ op = OPERATOR_EQEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" != "))
+ {
+ op = OPERATOR_NOTEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" < "))
+ {
+ op = OPERATOR_LT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" <= "))
+ {
+ op = OPERATOR_LE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" > "))
+ {
+ op = OPERATOR_GT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" >= "))
+ {
+ op = OPERATOR_GE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" + "))
+ {
+ op = OPERATOR_PLUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" - "))
+ {
+ op = OPERATOR_MINUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" | "))
+ {
+ op = OPERATOR_OR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" ^ "))
+ {
+ op = OPERATOR_XOR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" * "))
+ {
+ op = OPERATOR_MULT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" / "))
+ {
+ op = OPERATOR_DIV;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" % "))
+ {
+ op = OPERATOR_MOD;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" << "))
+ {
+ op = OPERATOR_LSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" >> "))
+ {
+ op = OPERATOR_RSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" & "))
+ {
+ op = OPERATOR_AND;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" &^ "))
+ {
+ op = OPERATOR_BITCLEAR;
+ imp->advance(4);
+ }
+ else
+ {
+ error_at(imp->location(), "unrecognized binary operator");
+ return Expression::make_error(imp->location());
+ }
+
+ Expression* right = Expression::import_expression(imp);
+
+ imp->require_c_string(")");
+
+ return Expression::make_binary(op, left, right, imp->location());
+}
+
+// Make a binary expression.
+
+Expression*
+Expression::make_binary(Operator op, Expression* left, Expression* right,
+ source_location location)
+{
+ return new Binary_expression(op, left, right, location);
+}
+
+// Implement a comparison.
+
+tree
+Expression::comparison_tree(Translate_context* context, Operator op,
+ Type* left_type, tree left_tree,
+ Type* right_type, tree right_tree,
+ source_location location)
+{
+ enum tree_code code;
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ code = EQ_EXPR;
+ break;
+ case OPERATOR_NOTEQ:
+ code = NE_EXPR;
+ break;
+ case OPERATOR_LT:
+ code = LT_EXPR;
+ break;
+ case OPERATOR_LE:
+ code = LE_EXPR;
+ break;
+ case OPERATOR_GT:
+ code = GT_EXPR;
+ break;
+ case OPERATOR_GE:
+ code = GE_EXPR;
+ break;
+ default:
+ go_unreachable();
+ }
+
+ if (left_type->is_string_type() && right_type->is_string_type())
+ {
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_compare_decl;
+ left_tree = Gogo::call_builtin(&string_compare_decl,
+ location,
+ "__go_strcmp",
+ 2,
+ integer_type_node,
+ string_type,
+ left_tree,
+ string_type,
+ right_tree);
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+ else if ((left_type->interface_type() != NULL
+ && right_type->interface_type() == NULL
+ && !right_type->is_nil_type())
+ || (left_type->interface_type() == NULL
+ && !left_type->is_nil_type()
+ && right_type->interface_type() != NULL))
+ {
+ // Comparing an interface value to a non-interface value.
+ if (left_type->interface_type() == NULL)
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ // The right operand is not an interface. We need to take its
+ // address if it is not a pointer.
+ tree make_tmp;
+ tree arg;
+ if (right_type->points_to() != NULL)
+ {
+ make_tmp = NULL_TREE;
+ arg = right_tree;
+ }
+ else if (TREE_ADDRESSABLE(TREE_TYPE(right_tree)) || DECL_P(right_tree))
+ {
+ make_tmp = NULL_TREE;
+ arg = build_fold_addr_expr_loc(location, right_tree);
+ if (DECL_P(right_tree))
+ TREE_ADDRESSABLE(right_tree) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(right_tree),
+ get_name(right_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = right_tree;
+ TREE_ADDRESSABLE(tmp) = 1;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ arg = build_fold_addr_expr_loc(location, tmp);
+ }
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+
+ tree descriptor = right_type->type_descriptor_pointer(context->gogo());
+
+ if (left_type->interface_type()->is_empty())
+ {
+ static tree empty_interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_value_compare_decl,
+ location,
+ "__go_empty_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(empty_interface_value_compare_decl) = 0;
+ }
+ else
+ {
+ static tree interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_value_compare_decl,
+ location,
+ "__go_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(interface_value_compare_decl) = 0;
+ }
+ right_tree = build_int_cst_type(integer_type_node, 0);
+
+ if (make_tmp != NULL_TREE)
+ left_tree = build2(COMPOUND_EXPR, TREE_TYPE(left_tree), make_tmp,
+ left_tree);
+ }
+ else if (left_type->interface_type() != NULL
+ && right_type->interface_type() != NULL)
+ {
+ if (left_type->interface_type()->is_empty()
+ && right_type->interface_type()->is_empty())
+ {
+ static tree empty_interface_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_compare_decl,
+ location,
+ "__go_empty_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(empty_interface_compare_decl) = 0;
+ }
+ else if (!left_type->interface_type()->is_empty()
+ && !right_type->interface_type()->is_empty())
+ {
+ static tree interface_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_compare_decl,
+ location,
+ "__go_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(interface_compare_decl) = 0;
+ }
+ else
+ {
+ if (left_type->interface_type()->is_empty())
+ {
+ go_assert(op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ);
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+ go_assert(!left_type->interface_type()->is_empty());
+ go_assert(right_type->interface_type()->is_empty());
+ static tree interface_empty_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_empty_compare_decl,
+ location,
+ "__go_interface_empty_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(interface_empty_compare_decl) = 0;
+ }
+
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+
+ if (left_type->is_nil_type()
+ && (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ))
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ if (right_type->is_nil_type())
+ {
+ if (left_type->array_type() != NULL
+ && left_type->array_type()->length() == NULL)
+ {
+ Array_type* at = left_type->array_type();
+ left_tree = at->value_pointer_tree(context->gogo(), left_tree);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else if (left_type->interface_type() != NULL)
+ {
+ // An interface is nil if the first field is nil.
+ tree left_type_tree = TREE_TYPE(left_tree);
+ go_assert(TREE_CODE(left_type_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(left_type_tree);
+ left_tree = build3(COMPONENT_REF, TREE_TYPE(field), left_tree,
+ field, NULL_TREE);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else
+ {
+ go_assert(POINTER_TYPE_P(TREE_TYPE(left_tree)));
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ }
+
+ if (left_tree == error_mark_node || right_tree == error_mark_node)
+ return error_mark_node;
+
+ tree ret = fold_build2(code, boolean_type_node, left_tree, right_tree);
+ if (CAN_HAVE_LOCATION_P(ret))
+ SET_EXPR_LOCATION(ret, location);
+ return ret;
+}
+
+// Class Bound_method_expression.
+
+// Traversal.
+
+int
+Bound_method_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->method_, traverse);
+}
+
+// Return the type of a bound method expression. The type of this
+// object is really the type of the method with no receiver. We
+// should be able to get away with just returning the type of the
+// method.
+
+Type*
+Bound_method_expression::do_type()
+{
+ return this->method_->type();
+}
+
+// Determine the types of a method expression.
+
+void
+Bound_method_expression::do_determine_type(const Type_context*)
+{
+ this->method_->determine_type_no_context();
+ Type* mtype = this->method_->type();
+ Function_type* fntype = mtype == NULL ? NULL : mtype->function_type();
+ if (fntype == NULL || !fntype->is_method())
+ this->expr_->determine_type_no_context();
+ else
+ {
+ Type_context subcontext(fntype->receiver()->type(), false);
+ this->expr_->determine_type(&subcontext);
+ }
+}
+
+// Check the types of a method expression.
+
+void
+Bound_method_expression::do_check_types(Gogo*)
+{
+ Type* type = this->method_->type()->deref();
+ if (type == NULL
+ || type->function_type() == NULL
+ || !type->function_type()->is_method())
+ this->report_error(_("object is not a method"));
+ else
+ {
+ Type* rtype = type->function_type()->receiver()->type()->deref();
+ Type* etype = (this->expr_type_ != NULL
+ ? this->expr_type_
+ : this->expr_->type());
+ etype = etype->deref();
+ if (!Type::are_identical(rtype, etype, true, NULL))
+ this->report_error(_("method type does not match object type"));
+ }
+}
+
+// Get the tree for a method expression. There is no standard tree
+// representation for this. The only places it may currently be used
+// are in a Call_expression or a Go_statement, which will take it
+// apart directly. So this has nothing to do at present.
+
+tree
+Bound_method_expression::do_get_tree(Translate_context*)
+{
+ error_at(this->location(), "reference to method other than calling it");
+ return error_mark_node;
+}
+
+// Make a method expression.
+
+Bound_method_expression*
+Expression::make_bound_method(Expression* expr, Expression* method,
+ source_location location)
+{
+ return new Bound_method_expression(expr, method, location);
+}
+
+// Class Builtin_call_expression. This is used for a call to a
+// builtin function.
+
+class Builtin_call_expression : public Call_expression
+{
+ public:
+ Builtin_call_expression(Gogo* gogo, Expression* fn, Expression_list* args,
+ bool is_varargs, source_location location);
+
+ protected:
+ // This overrides Call_expression::do_lower.
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Builtin_call_expression(this->gogo_, this->fn()->copy(),
+ this->args()->copy(),
+ this->is_varargs(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ virtual bool
+ do_is_recover_call() const;
+
+ virtual void
+ do_set_recover_arg(Expression*);
+
+ private:
+ // The builtin functions.
+ enum Builtin_function_code
+ {
+ BUILTIN_INVALID,
+
+ // Predeclared builtin functions.
+ BUILTIN_APPEND,
+ BUILTIN_CAP,
+ BUILTIN_CLOSE,
+ BUILTIN_COMPLEX,
+ BUILTIN_COPY,
+ BUILTIN_IMAG,
+ BUILTIN_LEN,
+ BUILTIN_MAKE,
+ BUILTIN_NEW,
+ BUILTIN_PANIC,
+ BUILTIN_PRINT,
+ BUILTIN_PRINTLN,
+ BUILTIN_REAL,
+ BUILTIN_RECOVER,
+
+ // Builtin functions from the unsafe package.
+ BUILTIN_ALIGNOF,
+ BUILTIN_OFFSETOF,
+ BUILTIN_SIZEOF
+ };
+
+ Expression*
+ one_arg() const;
+
+ bool
+ check_one_arg();
+
+ static Type*
+ real_imag_type(Type*);
+
+ static Type*
+ complex_type(Type*);
+
+ // A pointer back to the general IR structure. This avoids a global
+ // variable, or passing it around everywhere.
+ Gogo* gogo_;
+ // The builtin function being called.
+ Builtin_function_code code_;
+ // Used to stop endless loops when the length of an array uses len
+ // or cap of the array itself.
+ mutable bool seen_;
+};
+
+Builtin_call_expression::Builtin_call_expression(Gogo* gogo,
+ Expression* fn,
+ Expression_list* args,
+ bool is_varargs,
+ source_location location)
+ : Call_expression(fn, args, is_varargs, location),
+ gogo_(gogo), code_(BUILTIN_INVALID), seen_(false)
+{
+ Func_expression* fnexp = this->fn()->func_expression();
+ go_assert(fnexp != NULL);
+ const std::string& name(fnexp->named_object()->name());
+ if (name == "append")
+ this->code_ = BUILTIN_APPEND;
+ else if (name == "cap")
+ this->code_ = BUILTIN_CAP;
+ else if (name == "close")
+ this->code_ = BUILTIN_CLOSE;
+ else if (name == "complex")
+ this->code_ = BUILTIN_COMPLEX;
+ else if (name == "copy")
+ this->code_ = BUILTIN_COPY;
+ else if (name == "imag")
+ this->code_ = BUILTIN_IMAG;
+ else if (name == "len")
+ this->code_ = BUILTIN_LEN;
+ else if (name == "make")
+ this->code_ = BUILTIN_MAKE;
+ else if (name == "new")
+ this->code_ = BUILTIN_NEW;
+ else if (name == "panic")
+ this->code_ = BUILTIN_PANIC;
+ else if (name == "print")
+ this->code_ = BUILTIN_PRINT;
+ else if (name == "println")
+ this->code_ = BUILTIN_PRINTLN;
+ else if (name == "real")
+ this->code_ = BUILTIN_REAL;
+ else if (name == "recover")
+ this->code_ = BUILTIN_RECOVER;
+ else if (name == "Alignof")
+ this->code_ = BUILTIN_ALIGNOF;
+ else if (name == "Offsetof")
+ this->code_ = BUILTIN_OFFSETOF;
+ else if (name == "Sizeof")
+ this->code_ = BUILTIN_SIZEOF;
+ else
+ go_unreachable();
+}
+
+// Return whether this is a call to recover. This is a virtual
+// function called from the parent class.
+
+bool
+Builtin_call_expression::do_is_recover_call() const
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return false;
+ return this->code_ == BUILTIN_RECOVER;
+}
+
+// Set the argument for a call to recover.
+
+void
+Builtin_call_expression::do_set_recover_arg(Expression* arg)
+{
+ const Expression_list* args = this->args();
+ go_assert(args == NULL || args->empty());
+ Expression_list* new_args = new Expression_list();
+ new_args->push_back(arg);
+ this->set_args(new_args);
+}
+
+// A traversal class which looks for a call expression.
+
+class Find_call_expression : public Traverse
+{
+ public:
+ Find_call_expression()
+ : Traverse(traverse_expressions),
+ found_(false)
+ { }
+
+ int
+ expression(Expression**);
+
+ bool
+ found()
+ { return this->found_; }
+
+ private:
+ bool found_;
+};
+
+int
+Find_call_expression::expression(Expression** pexpr)
+{
+ if ((*pexpr)->call_expression() != NULL)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a builtin call expression. This turns new and make into
+// specific expressions. We also convert to a constant if we can.
+
+Expression*
+Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->is_varargs() && this->code_ != BUILTIN_APPEND)
+ {
+ this->report_error(_("invalid use of %<...%> with builtin function"));
+ return Expression::make_error(this->location());
+ }
+
+ if (this->code_ == BUILTIN_NEW)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 1)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ return Expression::make_allocation(arg->type(), this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_MAKE)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ {
+ Expression_list* newargs;
+ if (args->size() == 1)
+ newargs = NULL;
+ else
+ {
+ newargs = new Expression_list();
+ Expression_list::const_iterator p = args->begin();
+ ++p;
+ for (; p != args->end(); ++p)
+ newargs->push_back(*p);
+ }
+ return Expression::make_make(arg->type(), newargs,
+ this->location());
+ }
+ }
+ }
+ else if (this->is_constant())
+ {
+ // We can only lower len and cap if there are no function calls
+ // in the arguments. Otherwise we have to make the call.
+ if (this->code_ == BUILTIN_LEN || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (!arg->is_constant())
+ {
+ Find_call_expression find_call;
+ Expression::traverse(&arg, &find_call);
+ if (find_call.found())
+ return this;
+ }
+ }
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* type;
+ if (this->integer_constant_value(true, ival, &type))
+ {
+ Expression* ret = Expression::make_integer(&ival, type,
+ this->location());
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t rval;
+ mpfr_init(rval);
+ if (this->float_constant_value(rval, &type))
+ {
+ Expression* ret = Expression::make_float(&rval, type,
+ this->location());
+ mpfr_clear(rval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (this->complex_constant_value(rval, imag, &type))
+ {
+ Expression* ret = Expression::make_complex(&rval, &imag, type,
+ this->location());
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ }
+ else if (this->code_ == BUILTIN_RECOVER)
+ {
+ if (function != NULL)
+ function->func_value()->set_calls_recover();
+ else
+ {
+ // Calling recover outside of a function always returns the
+ // nil empty interface.
+ Type* eface = Type::make_interface_type(NULL, this->location());
+ return Expression::make_cast(eface,
+ Expression::make_nil(this->location()),
+ this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_APPEND)
+ {
+ // Lower the varargs.
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return this;
+ Type* slice_type = args->front()->type();
+ if (!slice_type->is_open_array_type())
+ {
+ error_at(args->front()->location(), "argument 1 must be a slice");
+ this->set_is_error();
+ return this;
+ }
+ return this->lower_varargs(gogo, function, slice_type, 2);
+ }
+
+ return this;
+}
+
+// Return the type of the real or imag functions, given the type of
+// the argument. We need to map complex to float, complex64 to
+// float32, and complex128 to float64, so it has to be done by name.
+// This returns NULL if it can't figure out the type.
+
+Type*
+Builtin_call_expression::real_imag_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "complex64")
+ return Type::lookup_float_type("float32");
+ else if (nt->name() == "complex128")
+ return Type::lookup_float_type("float64");
+ else
+ return NULL;
+}
+
+// Return the type of the complex function, given the type of one of the
+// argments. Like real_imag_type, we have to map by name.
+
+Type*
+Builtin_call_expression::complex_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "float32")
+ return Type::lookup_complex_type("complex64");
+ else if (nt->name() == "float64")
+ return Type::lookup_complex_type("complex128");
+ else
+ return NULL;
+}
+
+// Return a single argument, or NULL if there isn't one.
+
+Expression*
+Builtin_call_expression::one_arg() const
+{
+ const Expression_list* args = this->args();
+ if (args->size() != 1)
+ return NULL;
+ return args->front();
+}
+
+// Return whether this is constant: len of a string, or len or cap of
+// a fixed array, or unsafe.Sizeof, unsafe.Offsetof, unsafe.Alignof.
+
+bool
+Builtin_call_expression::do_is_constant() const
+{
+ switch (this->code_)
+ {
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ if (this->seen_)
+ return false;
+
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ return true;
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ {
+ this->seen_ = true;
+ bool ret = arg->is_constant();
+ this->seen_ = false;
+ return ret;
+ }
+ }
+ break;
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ return this->one_arg() != NULL;
+
+ case BUILTIN_OFFSETOF:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ return arg->field_reference_expression() != NULL;
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args != NULL && args->size() == 2)
+ return args->front()->is_constant() && args->back()->is_constant();
+ }
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ return arg != NULL && arg->is_constant();
+ }
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
+// Return an integer constant value if possible.
+
+bool
+Builtin_call_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_LEN
+ || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ {
+ std::string sval;
+ if (arg->string_constant_value(&sval))
+ {
+ mpz_set_ui(val, sval.length());
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ {
+ if (this->seen_)
+ return false;
+ Expression* e = arg_type->array_type()->length();
+ this->seen_ = true;
+ bool r = e->integer_constant_value(iota_is_constant, val, ptype);
+ this->seen_ = false;
+ if (r)
+ {
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+ }
+ else if (this->code_ == BUILTIN_SIZEOF
+ || this->code_ == BUILTIN_ALIGNOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+ if (arg_type->is_error())
+ return false;
+ if (arg_type->is_abstract())
+ return false;
+ if (arg_type->named_type() != NULL)
+ arg_type->named_type()->convert(this->gogo_);
+ tree arg_type_tree = arg_type->get_tree(this->gogo_);
+ if (arg_type_tree == error_mark_node)
+ return false;
+ unsigned long val_long;
+ if (this->code_ == BUILTIN_SIZEOF)
+ {
+ tree type_size = TYPE_SIZE_UNIT(arg_type_tree);
+ go_assert(TREE_CODE(type_size) == INTEGER_CST);
+ if (TREE_INT_CST_HIGH(type_size) != 0)
+ return false;
+ unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW(type_size);
+ val_long = static_cast<unsigned long>(val_wide);
+ if (val_long != val_wide)
+ return false;
+ }
+ else if (this->code_ == BUILTIN_ALIGNOF)
+ {
+ if (arg->field_reference_expression() == NULL)
+ val_long = go_type_alignment(arg_type_tree);
+ else
+ {
+ // Calling unsafe.Alignof(s.f) returns the alignment of
+ // the type of f when it is used as a field in a struct.
+ val_long = go_field_alignment(arg_type_tree);
+ }
+ }
+ else
+ go_unreachable();
+ mpz_set_ui(val, val_long);
+ *ptype = NULL;
+ return true;
+ }
+ else if (this->code_ == BUILTIN_OFFSETOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Field_reference_expression* farg = arg->field_reference_expression();
+ if (farg == NULL)
+ return false;
+ Expression* struct_expr = farg->expr();
+ Type* st = struct_expr->type();
+ if (st->struct_type() == NULL)
+ return false;
+ if (st->named_type() != NULL)
+ st->named_type()->convert(this->gogo_);
+ tree struct_tree = st->get_tree(this->gogo_);
+ go_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(struct_tree);
+ for (unsigned int index = farg->field_index(); index > 0; --index)
+ {
+ field = DECL_CHAIN(field);
+ go_assert(field != NULL_TREE);
+ }
+ HOST_WIDE_INT offset_wide = int_byte_position (field);
+ if (offset_wide < 0)
+ return false;
+ unsigned long offset_long = static_cast<unsigned long>(offset_wide);
+ if (offset_long != static_cast<unsigned HOST_WIDE_INT>(offset_wide))
+ return false;
+ mpz_set_ui(val, offset_long);
+ return true;
+ }
+ return false;
+}
+
+// Return a floating point constant value if possible.
+
+bool
+Builtin_call_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_REAL || this->code_ == BUILTIN_IMAG)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ bool ret = false;
+ Type* type;
+ if (arg->complex_constant_value(real, imag, &type))
+ {
+ if (this->code_ == BUILTIN_REAL)
+ mpfr_set(val, real, GMP_RNDN);
+ else
+ mpfr_set(val, imag, GMP_RNDN);
+ *ptype = Builtin_call_expression::real_imag_type(type);
+ ret = true;
+ }
+
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+
+ return false;
+}
+
+// Return a complex constant value if possible.
+
+bool
+Builtin_call_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_COMPLEX)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return false;
+
+ mpfr_t r;
+ mpfr_init(r);
+ Type* rtype;
+ if (!args->front()->float_constant_value(r, &rtype))
+ {
+ mpfr_clear(r);
+ return false;
+ }
+
+ mpfr_t i;
+ mpfr_init(i);
+
+ bool ret = false;
+ Type* itype;
+ if (args->back()->float_constant_value(i, &itype)
+ && Type::are_identical(rtype, itype, false, NULL))
+ {
+ mpfr_set(real, r, GMP_RNDN);
+ mpfr_set(imag, i, GMP_RNDN);
+ *ptype = Builtin_call_expression::complex_type(rtype);
+ ret = true;
+ }
+
+ mpfr_clear(r);
+ mpfr_clear(i);
+
+ return ret;
+ }
+
+ return false;
+}
+
+// Return the type.
+
+Type*
+Builtin_call_expression::do_type()
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ default:
+ go_unreachable();
+
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return Type::make_pointer_type(args->front()->type());
+ }
+
+ case BUILTIN_CAP:
+ case BUILTIN_COPY:
+ case BUILTIN_LEN:
+ case BUILTIN_ALIGNOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_SIZEOF:
+ return Type::lookup_integer_type("int");
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_PANIC:
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ return Type::make_void_type();
+
+ case BUILTIN_RECOVER:
+ return Type::make_interface_type(NULL, BUILTINS_LOCATION);
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return args->front()->type();
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return Type::make_error_type();
+ Type* t = arg->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ t = Builtin_call_expression::real_imag_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return Type::make_error_type();
+ Type* t = args->front()->type();
+ if (t->is_abstract())
+ {
+ t = args->back()->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ }
+ t = Builtin_call_expression::complex_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+ }
+}
+
+// Determine the type.
+
+void
+Builtin_call_expression::do_determine_type(const Type_context* context)
+{
+ if (!this->determining_types())
+ return;
+
+ this->fn()->determine_type_no_context();
+
+ const Expression_list* args = this->args();
+
+ bool is_print;
+ Type* arg_type = NULL;
+ switch (this->code_)
+ {
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ // Do not force a large integer constant to "int".
+ is_print = true;
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ arg_type = Builtin_call_expression::complex_type(context->type);
+ is_print = false;
+ break;
+
+ case BUILTIN_COMPLEX:
+ {
+ // For the complex function the type of one operand can
+ // determine the type of the other, as in a binary expression.
+ arg_type = Builtin_call_expression::real_imag_type(context->type);
+ if (args != NULL && args->size() == 2)
+ {
+ Type* t1 = args->front()->type();
+ Type* t2 = args->front()->type();
+ if (!t1->is_abstract())
+ arg_type = t1;
+ else if (!t2->is_abstract())
+ arg_type = t2;
+ }
+ is_print = false;
+ }
+ break;
+
+ default:
+ is_print = false;
+ break;
+ }
+
+ if (args != NULL)
+ {
+ for (Expression_list::const_iterator pa = args->begin();
+ pa != args->end();
+ ++pa)
+ {
+ Type_context subcontext;
+ subcontext.type = arg_type;
+
+ if (is_print)
+ {
+ // We want to print large constants, we so can't just
+ // use the appropriate nonabstract type. Use uint64 for
+ // an integer if we know it is nonnegative, otherwise
+ // use int64 for a integer, otherwise use float64 for a
+ // float or complex128 for a complex.
+ Type* want_type = NULL;
+ Type* atype = (*pa)->type();
+ if (atype->is_abstract())
+ {
+ if (atype->integer_type() != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy)
+ && mpz_sgn(val) >= 0)
+ want_type = Type::lookup_integer_type("uint64");
+ else
+ want_type = Type::lookup_integer_type("int64");
+ mpz_clear(val);
+ }
+ else if (atype->float_type() != NULL)
+ want_type = Type::lookup_float_type("float64");
+ else if (atype->complex_type() != NULL)
+ want_type = Type::lookup_complex_type("complex128");
+ else if (atype->is_abstract_string_type())
+ want_type = Type::lookup_string_type();
+ else if (atype->is_abstract_boolean_type())
+ want_type = Type::lookup_bool_type();
+ else
+ go_unreachable();
+ subcontext.type = want_type;
+ }
+ }
+
+ (*pa)->determine_type(&subcontext);
+ }
+ }
+}
+
+// If there is exactly one argument, return true. Otherwise give an
+// error message and return false.
+
+bool
+Builtin_call_expression::check_one_arg()
+{
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ {
+ this->report_error(_("not enough arguments"));
+ return false;
+ }
+ else if (args->size() > 1)
+ {
+ this->report_error(_("too many arguments"));
+ return false;
+ }
+ if (args->front()->is_error_expression()
+ || args->front()->type()->is_error())
+ {
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check argument types for a builtin function.
+
+void
+Builtin_call_expression::do_check_types(Gogo*)
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ return;
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ // The single argument may be either a string or an array or a
+ // map or a channel, or a pointer to a closed array.
+ if (this->check_one_arg())
+ {
+ Type* arg_type = this->one_arg()->type();
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+ if (this->code_ == BUILTIN_CAP)
+ {
+ if (!arg_type->is_error()
+ && arg_type->array_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be array or slice "
+ "or channel"));
+ }
+ else
+ {
+ if (!arg_type->is_error()
+ && !arg_type->is_string_type()
+ && arg_type->array_type() == NULL
+ && arg_type->map_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be string or "
+ "array or slice or map or channel"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL)
+ {
+ if (this->code_ == BUILTIN_PRINT)
+ warning_at(this->location(), 0,
+ "no arguments for builtin function %<%s%>",
+ (this->code_ == BUILTIN_PRINT
+ ? "print"
+ : "println"));
+ }
+ else
+ {
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p)
+ {
+ Type* type = (*p)->type();
+ if (type->is_error()
+ || type->is_string_type()
+ || type->integer_type() != NULL
+ || type->float_type() != NULL
+ || type->complex_type() != NULL
+ || type->is_boolean_type()
+ || type->points_to() != NULL
+ || type->interface_type() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL
+ || type->is_open_array_type())
+ ;
+ else
+ this->report_error(_("unsupported argument type to "
+ "builtin function"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_CLOSE:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->channel_type() == NULL)
+ this->report_error(_("argument must be channel"));
+ }
+ break;
+
+ case BUILTIN_PANIC:
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ this->check_one_arg();
+ break;
+
+ case BUILTIN_RECOVER:
+ if (this->args() != NULL && !this->args()->empty())
+ this->report_error(_("too many arguments"));
+ break;
+
+ case BUILTIN_OFFSETOF:
+ if (this->check_one_arg())
+ {
+ Expression* arg = this->one_arg();
+ if (arg->field_reference_expression() == NULL)
+ this->report_error(_("argument must be a field reference"));
+ }
+ break;
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ else if (args->size() > 2)
+ {
+ this->report_error(_("too many arguments"));
+ break;
+ }
+ Type* arg1_type = args->front()->type();
+ Type* arg2_type = args->back()->type();
+ if (arg1_type->is_error() || arg2_type->is_error())
+ break;
+
+ Type* e1;
+ if (arg1_type->is_open_array_type())
+ e1 = arg1_type->array_type()->element_type();
+ else
+ {
+ this->report_error(_("left argument must be a slice"));
+ break;
+ }
+
+ Type* e2;
+ if (arg2_type->is_open_array_type())
+ e2 = arg2_type->array_type()->element_type();
+ else if (arg2_type->is_string_type())
+ e2 = Type::lookup_integer_type("uint8");
+ else
+ {
+ this->report_error(_("right argument must be a slice or a string"));
+ break;
+ }
+
+ if (!Type::are_identical(e1, e2, true, NULL))
+ this->report_error(_("element types must be the same"));
+ }
+ break;
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ if (args->size() > 2)
+ {
+ this->report_error(_("too many arguments"));
+ break;
+ }
+ std::string reason;
+ if (!Type::are_assignable(args->front()->type(), args->back()->type(),
+ &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("arguments 1 and 2 have different types"));
+ else
+ {
+ error_at(this->location(),
+ "arguments 1 and 2 have different types (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ break;
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->complex_type() == NULL)
+ this->report_error(_("argument must have complex type"));
+ }
+ break;
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 2)
+ this->report_error(_("too many arguments"));
+ else if (args->front()->is_error_expression()
+ || args->front()->type()->is_error()
+ || args->back()->is_error_expression()
+ || args->back()->type()->is_error())
+ this->set_is_error();
+ else if (!Type::are_identical(args->front()->type(),
+ args->back()->type(), true, NULL))
+ this->report_error(_("complex arguments must have identical types"));
+ else if (args->front()->type()->float_type() == NULL)
+ this->report_error(_("complex arguments must have "
+ "floating-point type"));
+ }
+ break;
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Return the tree for a builtin function.
+
+tree
+Builtin_call_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ go_unreachable();
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 1);
+ Expression* arg = *args->begin();
+ Type* arg_type = arg->type();
+
+ if (this->seen_)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+
+ tree arg_tree = arg->get_tree(context);
+
+ this->seen_ = false;
+
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ if (arg_type->points_to() != NULL)
+ {
+ arg_type = arg_type->points_to();
+ go_assert(arg_type->array_type() != NULL
+ && !arg_type->is_open_array_type());
+ go_assert(POINTER_TYPE_P(TREE_TYPE(arg_tree)));
+ arg_tree = build_fold_indirect_ref(arg_tree);
+ }
+
+ tree val_tree;
+ if (this->code_ == BUILTIN_LEN)
+ {
+ if (arg_type->is_string_type())
+ val_tree = String_type::length_tree(gogo, arg_tree);
+ else if (arg_type->array_type() != NULL)
+ {
+ if (this->seen_)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+ val_tree = arg_type->array_type()->length_tree(gogo, arg_tree);
+ this->seen_ = false;
+ }
+ else if (arg_type->map_type() != NULL)
+ {
+ static tree map_len_fndecl;
+ val_tree = Gogo::call_builtin(&map_len_fndecl,
+ location,
+ "__go_map_len",
+ 1,
+ integer_type_node,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_len_fndecl;
+ val_tree = Gogo::call_builtin(&chan_len_fndecl,
+ location,
+ "__go_chan_len",
+ 1,
+ integer_type_node,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ go_unreachable();
+ }
+ else
+ {
+ if (arg_type->array_type() != NULL)
+ {
+ if (this->seen_)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+ val_tree = arg_type->array_type()->capacity_tree(gogo,
+ arg_tree);
+ this->seen_ = false;
+ }
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_cap_fndecl;
+ val_tree = Gogo::call_builtin(&chan_cap_fndecl,
+ location,
+ "__go_chan_cap",
+ 1,
+ integer_type_node,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ go_unreachable();
+ }
+
+ if (val_tree == error_mark_node)
+ return error_mark_node;
+
+ tree type_tree = Type::lookup_integer_type("int")->get_tree(gogo);
+ if (type_tree == TREE_TYPE(val_tree))
+ return val_tree;
+ else
+ return fold(convert_to_integer(type_tree, val_tree));
+ }
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const bool is_ln = this->code_ == BUILTIN_PRINTLN;
+ tree stmt_list = NULL_TREE;
+
+ const Expression_list* call_args = this->args();
+ if (call_args != NULL)
+ {
+ for (Expression_list::const_iterator p = call_args->begin();
+ p != call_args->end();
+ ++p)
+ {
+ if (is_ln && p != call_args->begin())
+ {
+ static tree print_space_fndecl;
+ tree call = Gogo::call_builtin(&print_space_fndecl,
+ location,
+ "__go_print_space",
+ 0,
+ void_type_node);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ Type* type = (*p)->type();
+
+ tree arg = (*p)->get_tree(context);
+ if (arg == error_mark_node)
+ return error_mark_node;
+
+ tree* pfndecl;
+ const char* fnname;
+ if (type->is_string_type())
+ {
+ static tree print_string_fndecl;
+ pfndecl = &print_string_fndecl;
+ fnname = "__go_print_string";
+ }
+ else if (type->integer_type() != NULL
+ && type->integer_type()->is_unsigned())
+ {
+ static tree print_uint64_fndecl;
+ pfndecl = &print_uint64_fndecl;
+ fnname = "__go_print_uint64";
+ Type* itype = Type::lookup_integer_type("uint64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->integer_type() != NULL)
+ {
+ static tree print_int64_fndecl;
+ pfndecl = &print_int64_fndecl;
+ fnname = "__go_print_int64";
+ Type* itype = Type::lookup_integer_type("int64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->float_type() != NULL)
+ {
+ static tree print_double_fndecl;
+ pfndecl = &print_double_fndecl;
+ fnname = "__go_print_double";
+ arg = fold_convert_loc(location, double_type_node, arg);
+ }
+ else if (type->complex_type() != NULL)
+ {
+ static tree print_complex_fndecl;
+ pfndecl = &print_complex_fndecl;
+ fnname = "__go_print_complex";
+ arg = fold_convert_loc(location, complex_double_type_node,
+ arg);
+ }
+ else if (type->is_boolean_type())
+ {
+ static tree print_bool_fndecl;
+ pfndecl = &print_bool_fndecl;
+ fnname = "__go_print_bool";
+ }
+ else if (type->points_to() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL)
+ {
+ static tree print_pointer_fndecl;
+ pfndecl = &print_pointer_fndecl;
+ fnname = "__go_print_pointer";
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+ }
+ else if (type->interface_type() != NULL)
+ {
+ if (type->interface_type()->is_empty())
+ {
+ static tree print_empty_interface_fndecl;
+ pfndecl = &print_empty_interface_fndecl;
+ fnname = "__go_print_empty_interface";
+ }
+ else
+ {
+ static tree print_interface_fndecl;
+ pfndecl = &print_interface_fndecl;
+ fnname = "__go_print_interface";
+ }
+ }
+ else if (type->is_open_array_type())
+ {
+ static tree print_slice_fndecl;
+ pfndecl = &print_slice_fndecl;
+ fnname = "__go_print_slice";
+ }
+ else
+ go_unreachable();
+
+ tree call = Gogo::call_builtin(pfndecl,
+ location,
+ fnname,
+ 1,
+ void_type_node,
+ TREE_TYPE(arg),
+ arg);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+ }
+
+ if (is_ln)
+ {
+ static tree print_nl_fndecl;
+ tree call = Gogo::call_builtin(&print_nl_fndecl,
+ location,
+ "__go_print_nl",
+ 0,
+ void_type_node);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ return stmt_list;
+ }
+
+ case BUILTIN_PANIC:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ arg_tree = Expression::convert_for_assignment(context, empty,
+ arg->type(),
+ arg_tree, location);
+ static tree panic_fndecl;
+ tree call = Gogo::call_builtin(&panic_fndecl,
+ location,
+ "__go_panic",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This function will throw an exception.
+ TREE_NOTHROW(panic_fndecl) = 0;
+ // This function will not return.
+ TREE_THIS_VOLATILE(panic_fndecl) = 1;
+ return call;
+ }
+
+ case BUILTIN_RECOVER:
+ {
+ // The argument is set when building recover thunks. It's a
+ // boolean value which is true if we can recover a value now.
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ tree empty_tree = empty->get_tree(context->gogo());
+
+ Type* nil_type = Type::make_nil_type();
+ Expression* nil = Expression::make_nil(location);
+ tree nil_tree = nil->get_tree(context);
+ tree empty_nil_tree = Expression::convert_for_assignment(context,
+ empty,
+ nil_type,
+ nil_tree,
+ location);
+
+ // We need to handle a deferred call to recover specially,
+ // because it changes whether it can recover a panic or not.
+ // See test7 in test/recover1.go.
+ tree call;
+ if (this->is_deferred())
+ {
+ static tree deferred_recover_fndecl;
+ call = Gogo::call_builtin(&deferred_recover_fndecl,
+ location,
+ "__go_deferred_recover",
+ 0,
+ empty_tree);
+ }
+ else
+ {
+ static tree recover_fndecl;
+ call = Gogo::call_builtin(&recover_fndecl,
+ location,
+ "__go_recover",
+ 0,
+ empty_tree);
+ }
+ if (call == error_mark_node)
+ return error_mark_node;
+ return fold_build3_loc(location, COND_EXPR, empty_tree, arg_tree,
+ call, empty_nil_tree);
+ }
+
+ case BUILTIN_CLOSE:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ static tree close_fndecl;
+ return Gogo::call_builtin(&close_fndecl,
+ location,
+ "__go_builtin_close",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ }
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_ALIGNOF:
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ bool b = this->integer_constant_value(true, val, &dummy);
+ if (!b)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ tree type = Type::lookup_integer_type("int")->get_tree(gogo);
+ tree ret = Expression::integer_constant_tree(val, type);
+ mpz_clear(val);
+ return ret;
+ }
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ Type* arg1_type = arg1->type();
+ Array_type* at = arg1_type->array_type();
+ arg1_tree = save_expr(arg1_tree);
+ tree arg1_val = at->value_pointer_tree(gogo, arg1_tree);
+ tree arg1_len = at->length_tree(gogo, arg1_tree);
+ if (arg1_val == error_mark_node || arg1_len == error_mark_node)
+ return error_mark_node;
+
+ Type* arg2_type = arg2->type();
+ tree arg2_val;
+ tree arg2_len;
+ if (arg2_type->is_open_array_type())
+ {
+ at = arg2_type->array_type();
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ arg2_len = at->length_tree(gogo, arg2_tree);
+ }
+ else
+ {
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = String_type::bytes_tree(gogo, arg2_tree);
+ arg2_len = String_type::length_tree(gogo, arg2_tree);
+ }
+ if (arg2_val == error_mark_node || arg2_len == error_mark_node)
+ return error_mark_node;
+
+ arg1_len = save_expr(arg1_len);
+ arg2_len = save_expr(arg2_len);
+ tree len = fold_build3_loc(location, COND_EXPR, TREE_TYPE(arg1_len),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ arg1_len, arg2_len),
+ arg1_len, arg2_len);
+ len = save_expr(len);
+
+ Type* element_type = at->element_type();
+ tree element_type_tree = element_type->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree bytecount = fold_convert_loc(location, TREE_TYPE(element_size),
+ len);
+ bytecount = fold_build2_loc(location, MULT_EXPR,
+ TREE_TYPE(element_size),
+ bytecount, element_size);
+ bytecount = fold_convert_loc(location, size_type_node, bytecount);
+
+ arg1_val = fold_convert_loc(location, ptr_type_node, arg1_val);
+ arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
+
+ static tree copy_fndecl;
+ tree call = Gogo::call_builtin(©_fndecl,
+ location,
+ "__go_copy",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ arg1_val,
+ ptr_type_node,
+ arg2_val,
+ size_type_node,
+ bytecount);
+ if (call == error_mark_node)
+ return error_mark_node;
+
+ return fold_build2_loc(location, COMPOUND_EXPR, TREE_TYPE(len),
+ call, len);
+ }
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ Array_type* at = arg1->type()->array_type();
+ Type* element_type = at->element_type();
+
+ arg2_tree = Expression::convert_for_assignment(context, at,
+ arg2->type(),
+ arg2_tree,
+ location);
+ if (arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ arg2_tree = save_expr(arg2_tree);
+ tree arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ tree arg2_len = at->length_tree(gogo, arg2_tree);
+ if (arg2_val == error_mark_node || arg2_len == error_mark_node)
+ return error_mark_node;
+ arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
+ arg2_len = fold_convert_loc(location, size_type_node, arg2_len);
+
+ tree element_type_tree = element_type->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ element_size = fold_convert_loc(location, size_type_node,
+ element_size);
+
+ // We rebuild the decl each time since the slice types may
+ // change.
+ tree append_fndecl = NULL_TREE;
+ return Gogo::call_builtin(&append_fndecl,
+ location,
+ "__go_append",
+ 4,
+ TREE_TYPE(arg1_tree),
+ TREE_TYPE(arg1_tree),
+ arg1_tree,
+ ptr_type_node,
+ arg2_val,
+ size_type_node,
+ arg2_len,
+ size_type_node,
+ element_size);
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(COMPLEX_FLOAT_TYPE_P(TREE_TYPE(arg_tree)));
+ if (this->code_ == BUILTIN_REAL)
+ return fold_build1_loc(location, REALPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ else
+ return fold_build1_loc(location, IMAGPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ go_assert(args != NULL && args->size() == 2);
+ tree r = args->front()->get_tree(context);
+ tree i = args->back()->get_tree(context);
+ if (r == error_mark_node || i == error_mark_node)
+ return error_mark_node;
+ go_assert(TYPE_MAIN_VARIANT(TREE_TYPE(r))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(i)));
+ go_assert(SCALAR_FLOAT_TYPE_P(TREE_TYPE(r)));
+ return fold_build2_loc(location, COMPLEX_EXPR,
+ build_complex_type(TREE_TYPE(r)),
+ r, i);
+ }
+
+ default:
+ go_unreachable();
+ }
+}
+
+// We have to support exporting a builtin call expression, because
+// code can set a constant to the result of a builtin expression.
+
+void
+Builtin_call_expression::do_export(Export* exp) const
+{
+ bool ok = false;
+
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy))
+ {
+ Integer_expression::export_integer(exp, val);
+ ok = true;
+ }
+ mpz_clear(val);
+
+ if (!ok)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->float_constant_value(fval, &dummy))
+ {
+ Float_expression::export_float(exp, fval);
+ ok = true;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (!ok)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (this->complex_constant_value(real, imag, &dummy))
+ {
+ Complex_expression::export_complex(exp, real, imag);
+ ok = true;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (!ok)
+ {
+ error_at(this->location(), "value is not constant");
+ return;
+ }
+
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Class Call_expression.
+
+// Traversal.
+
+int
+Call_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->fn_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->args_ != NULL)
+ {
+ if (this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a call statement.
+
+Expression*
+Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ // A type case can look like a function call.
+ if (this->fn_->is_type_expression()
+ && this->args_ != NULL
+ && this->args_->size() == 1)
+ return Expression::make_cast(this->fn_->type(), this->args_->front(),
+ this->location());
+
+ // Recognize a call to a builtin function.
+ Func_expression* fne = this->fn_->func_expression();
+ if (fne != NULL
+ && fne->named_object()->is_function_declaration()
+ && fne->named_object()->func_declaration_value()->type()->is_builtin())
+ return new Builtin_call_expression(gogo, this->fn_, this->args_,
+ this->is_varargs_, this->location());
+
+ // Handle an argument which is a call to a function which returns
+ // multiple results.
+ if (this->args_ != NULL
+ && this->args_->size() == 1
+ && this->args_->front()->call_expression() != NULL
+ && this->fn_->type()->function_type() != NULL)
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ size_t rc = this->args_->front()->call_expression()->result_count();
+ if (rc > 1
+ && fntype->parameters() != NULL
+ && (fntype->parameters()->size() == rc
+ || (fntype->is_varargs()
+ && fntype->parameters()->size() - 1 <= rc)))
+ {
+ Call_expression* call = this->args_->front()->call_expression();
+ Expression_list* args = new Expression_list;
+ for (size_t i = 0; i < rc; ++i)
+ args->push_back(Expression::make_call_result(call, i));
+ // We can't return a new call expression here, because this
+ // one may be referenced by Call_result expressions. We
+ // also can't delete the old arguments, because we may still
+ // traverse them somewhere up the call stack. FIXME.
+ this->args_ = args;
+ }
+ }
+
+ // Handle a call to a varargs function by packaging up the extra
+ // parameters.
+ if (this->fn_->type()->function_type() != NULL
+ && this->fn_->type()->function_type()->is_varargs())
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ const Typed_identifier_list* parameters = fntype->parameters();
+ go_assert(parameters != NULL && !parameters->empty());
+ Type* varargs_type = parameters->back().type();
+ return this->lower_varargs(gogo, function, varargs_type,
+ parameters->size());
+ }
+
+ return this;
+}
+
+// Lower a call to a varargs function. FUNCTION is the function in
+// which the call occurs--it's not the function we are calling.
+// VARARGS_TYPE is the type of the varargs parameter, a slice type.
+// PARAM_COUNT is the number of parameters of the function we are
+// calling; the last of these parameters will be the varargs
+// parameter.
+
+Expression*
+Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
+ Type* varargs_type, size_t param_count)
+{
+ if (this->varargs_are_lowered_)
+ return this;
+
+ source_location loc = this->location();
+
+ go_assert(param_count > 0);
+ go_assert(varargs_type->is_open_array_type());
+
+ size_t arg_count = this->args_ == NULL ? 0 : this->args_->size();
+ if (arg_count < param_count - 1)
+ {
+ // Not enough arguments; will be caught in check_types.
+ return this;
+ }
+
+ Expression_list* old_args = this->args_;
+ Expression_list* new_args = new Expression_list();
+ bool push_empty_arg = false;
+ if (old_args == NULL || old_args->empty())
+ {
+ go_assert(param_count == 1);
+ push_empty_arg = true;
+ }
+ else
+ {
+ Expression_list::const_iterator pa;
+ int i = 1;
+ for (pa = old_args->begin(); pa != old_args->end(); ++pa, ++i)
+ {
+ if (static_cast<size_t>(i) == param_count)
+ break;
+ new_args->push_back(*pa);
+ }
+
+ // We have reached the varargs parameter.
+
+ bool issued_error = false;
+ if (pa == old_args->end())
+ push_empty_arg = true;
+ else if (pa + 1 == old_args->end() && this->is_varargs_)
+ new_args->push_back(*pa);
+ else if (this->is_varargs_)
+ {
+ this->report_error(_("too many arguments"));
+ return this;
+ }
+ else
+ {
+ Type* element_type = varargs_type->array_type()->element_type();
+ Expression_list* vals = new Expression_list;
+ for (; pa != old_args->end(); ++pa, ++i)
+ {
+ // Check types here so that we get a better message.
+ Type* patype = (*pa)->type();
+ source_location paloc = (*pa)->location();
+ if (!this->check_argument_type(i, element_type, patype,
+ paloc, issued_error))
+ continue;
+ vals->push_back(*pa);
+ }
+ Expression* val =
+ Expression::make_slice_composite_literal(varargs_type, vals, loc);
+ new_args->push_back(val);
+ }
+ }
+
+ if (push_empty_arg)
+ new_args->push_back(Expression::make_nil(loc));
+
+ // We can't return a new call expression here, because this one may
+ // be referenced by Call_result expressions. FIXME.
+ if (old_args != NULL)
+ delete old_args;
+ this->args_ = new_args;
+ this->varargs_are_lowered_ = true;
+
+ // Lower all the new subexpressions.
+ Expression* ret = this;
+ gogo->lower_expression(function, &ret);
+ go_assert(ret == this);
+ return ret;
+}
+
+// Get the function type. Returns NULL if we don't know the type. If
+// this returns NULL, and if_ERROR is true, issues an error.
+
+Function_type*
+Call_expression::get_function_type() const
+{
+ return this->fn_->type()->function_type();
+}
+
+// Return the number of values which this call will return.
+
+size_t
+Call_expression::result_count() const
+{
+ const Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return 0;
+ if (fntype->results() == NULL)
+ return 0;
+ return fntype->results()->size();
+}
+
+// Return whether this is a call to the predeclared function recover.
+
+bool
+Call_expression::is_recover_call() const
+{
+ return this->do_is_recover_call();
+}
+
+// Set the argument to the recover function.
+
+void
+Call_expression::set_recover_arg(Expression* arg)
+{
+ this->do_set_recover_arg(arg);
+}
+
+// Virtual functions also implemented by Builtin_call_expression.
+
+bool
+Call_expression::do_is_recover_call() const
+{
+ return false;
+}
+
+void
+Call_expression::do_set_recover_arg(Expression*)
+{
+ go_unreachable();
+}
+
+// Get the type.
+
+Type*
+Call_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+
+ Type* ret;
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results == NULL)
+ ret = Type::make_void_type();
+ else if (results->size() == 1)
+ ret = results->begin()->type();
+ else
+ ret = Type::make_call_multiple_result_type(this);
+
+ this->type_ = ret;
+
+ return this->type_;
+}
+
+// Determine types for a call expression. We can use the function
+// parameter types to set the types of the arguments.
+
+void
+Call_expression::do_determine_type(const Type_context*)
+{
+ if (!this->determining_types())
+ return;
+
+ this->fn_->determine_type_no_context();
+ Function_type* fntype = this->get_function_type();
+ const Typed_identifier_list* parameters = NULL;
+ if (fntype != NULL)
+ parameters = fntype->parameters();
+ if (this->args_ != NULL)
+ {
+ Typed_identifier_list::const_iterator pt;
+ if (parameters != NULL)
+ pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa)
+ {
+ if (parameters != NULL && pt != parameters->end())
+ {
+ Type_context subcontext(pt->type(), false);
+ (*pa)->determine_type(&subcontext);
+ ++pt;
+ }
+ else
+ (*pa)->determine_type_no_context();
+ }
+ }
+}
+
+// Called when determining types for a Call_expression. Return true
+// if we should go ahead, false if they have already been determined.
+
+bool
+Call_expression::determining_types()
+{
+ if (this->types_are_determined_)
+ return false;
+ else
+ {
+ this->types_are_determined_ = true;
+ return true;
+ }
+}
+
+// Check types for parameter I.
+
+bool
+Call_expression::check_argument_type(int i, const Type* parameter_type,
+ const Type* argument_type,
+ source_location argument_location,
+ bool issued_error)
+{
+ std::string reason;
+ if (!Type::are_assignable(parameter_type, argument_type, &reason))
+ {
+ if (!issued_error)
+ {
+ if (reason.empty())
+ error_at(argument_location, "argument %d has incompatible type", i);
+ else
+ error_at(argument_location,
+ "argument %d has incompatible type (%s)",
+ i, reason.c_str());
+ }
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check types.
+
+void
+Call_expression::do_check_types(Gogo*)
+{
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ {
+ if (!this->fn_->type()->is_error())
+ this->report_error(_("expected function"));
+ return;
+ }
+
+ if (fntype->is_method())
+ {
+ // We don't support pointers to methods, so the function has to
+ // be a bound method expression.
+ Bound_method_expression* bme = this->fn_->bound_method_expression();
+ if (bme == NULL)
+ {
+ this->report_error(_("method call without object"));
+ return;
+ }
+ Type* first_arg_type = bme->first_argument()->type();
+ if (first_arg_type->points_to() == NULL)
+ {
+ // When passing a value, we need to check that we are
+ // permitted to copy it. The language permits copying
+ // hidden fields for a method receiver.
+ std::string reason;
+ if (!Type::are_assignable_hidden_ok(fntype->receiver()->type(),
+ first_arg_type, &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for receiver"));
+ else
+ {
+ error_at(this->location(),
+ "incompatible type for receiver (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ }
+ }
+
+ // Note that varargs was handled by the lower_varargs() method, so
+ // we don't have to worry about it here.
+
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (this->args_ == NULL)
+ {
+ if (parameters != NULL && !parameters->empty())
+ this->report_error(_("not enough arguments"));
+ }
+ else if (parameters == NULL)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ int i = 0;
+ Typed_identifier_list::const_iterator pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa, ++pt, ++i)
+ {
+ if (pt == parameters->end())
+ {
+ this->report_error(_("too many arguments"));
+ return;
+ }
+ this->check_argument_type(i + 1, pt->type(), (*pa)->type(),
+ (*pa)->location(), false);
+ }
+ if (pt != parameters->end())
+ this->report_error(_("not enough arguments"));
+ }
+}
+
+// Return whether we have to use a temporary variable to ensure that
+// we evaluate this call expression in order. If the call returns no
+// results then it will inevitably be executed last. If the call
+// returns more than one result then it will be used with Call_result
+// expressions. So we only have to use a temporary variable if the
+// call returns exactly one result.
+
+bool
+Call_expression::do_must_eval_in_order() const
+{
+ return this->result_count() == 1;
+}
+
+// Get the function and the first argument to use when calling a bound
+// method.
+
+tree
+Call_expression::bound_method_function(Translate_context* context,
+ Bound_method_expression* bound_method,
+ tree* first_arg_ptr)
+{
+ Expression* first_argument = bound_method->first_argument();
+ tree first_arg = first_argument->get_tree(context);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+
+ // We always pass a pointer to the first argument when calling a
+ // method.
+ if (first_argument->type()->points_to() == NULL)
+ {
+ tree pointer_to_arg_type = build_pointer_type(TREE_TYPE(first_arg));
+ if (TREE_ADDRESSABLE(TREE_TYPE(first_arg))
+ || DECL_P(first_arg)
+ || TREE_CODE(first_arg) == INDIRECT_REF
+ || TREE_CODE(first_arg) == COMPONENT_REF)
+ {
+ first_arg = build_fold_addr_expr(first_arg);
+ if (DECL_P(first_arg))
+ TREE_ADDRESSABLE(first_arg) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(first_arg),
+ get_name(first_arg));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = first_arg;
+ first_arg = build2(COMPOUND_EXPR, pointer_to_arg_type,
+ build1(DECL_EXPR, void_type_node, tmp),
+ build_fold_addr_expr(tmp));
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ }
+
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ first_arg = fold_convert(fatype->get_tree(context->gogo()), first_arg);
+ if (first_arg == error_mark_node
+ || TREE_TYPE(first_arg) == error_mark_node)
+ return error_mark_node;
+ }
+
+ *first_arg_ptr = first_arg;
+
+ return bound_method->method()->get_tree(context);
+}
+
+// Get the function and the first argument to use when calling an
+// interface method.
+
+tree
+Call_expression::interface_method_function(
+ Translate_context* context,
+ Interface_field_reference_expression* interface_method,
+ tree* first_arg_ptr)
+{
+ tree expr = interface_method->expr()->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+ expr = save_expr(expr);
+ tree first_arg = interface_method->get_underlying_object_tree(context, expr);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ *first_arg_ptr = first_arg;
+ return interface_method->get_function_tree(context, expr);
+}
+
+// Build the call expression.
+
+tree
+Call_expression::do_get_tree(Translate_context* context)
+{
+ if (this->tree_ != NULL_TREE)
+ return this->tree_;
+
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return error_mark_node;
+
+ if (this->fn_->is_error_expression())
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+
+ Func_expression* func = this->fn_->func_expression();
+ Bound_method_expression* bound_method = this->fn_->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ this->fn_->interface_field_reference_expression();
+ const bool has_closure = func != NULL && func->closure() != NULL;
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+ go_assert(!fntype->is_method() || is_method);
+
+ int nargs;
+ tree* args;
+ if (this->args_ == NULL || this->args_->empty())
+ {
+ nargs = is_method ? 1 : 0;
+ args = nargs == 0 ? NULL : new tree[nargs];
+ }
+ else
+ {
+ const Typed_identifier_list* params = fntype->parameters();
+ go_assert(params != NULL);
+
+ nargs = this->args_->size();
+ int i = is_method ? 1 : 0;
+ nargs += i;
+ args = new tree[nargs];
+
+ Typed_identifier_list::const_iterator pp = params->begin();
+ Expression_list::const_iterator pe;
+ for (pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe, ++pp, ++i)
+ {
+ go_assert(pp != params->end());
+ tree arg_val = (*pe)->get_tree(context);
+ args[i] = Expression::convert_for_assignment(context,
+ pp->type(),
+ (*pe)->type(),
+ arg_val,
+ location);
+ if (args[i] == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+ }
+ go_assert(pp == params->end());
+ go_assert(i == nargs);
+ }
+
+ tree rettype = TREE_TYPE(TREE_TYPE(fntype->get_tree(gogo)));
+ if (rettype == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+
+ tree fn;
+ if (has_closure)
+ fn = func->get_tree_without_closure(gogo);
+ else if (!is_method)
+ fn = this->fn_->get_tree(context);
+ else if (bound_method != NULL)
+ fn = this->bound_method_function(context, bound_method, &args[0]);
+ else if (interface_method != NULL)
+ fn = this->interface_method_function(context, interface_method, &args[0]);
+ else
+ go_unreachable();
+
+ if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+
+ tree fndecl = fn;
+ if (TREE_CODE(fndecl) == ADDR_EXPR)
+ fndecl = TREE_OPERAND(fndecl, 0);
+
+ // Add a type cast in case the type of the function is a recursive
+ // type which refers to itself.
+ if (!DECL_P(fndecl) || !DECL_IS_BUILTIN(fndecl))
+ {
+ tree fnt = fntype->get_tree(gogo);
+ if (fnt == error_mark_node)
+ return error_mark_node;
+ fn = fold_convert_loc(location, fnt, fn);
+ }
+
+ // This is to support builtin math functions when using 80387 math.
+ tree excess_type = NULL_TREE;
+ if (TREE_CODE(fndecl) == FUNCTION_DECL
+ && DECL_IS_BUILTIN(fndecl)
+ && DECL_BUILT_IN_CLASS(fndecl) == BUILT_IN_NORMAL
+ && nargs > 0
+ && ((SCALAR_FLOAT_TYPE_P(rettype)
+ && SCALAR_FLOAT_TYPE_P(TREE_TYPE(args[0])))
+ || (COMPLEX_FLOAT_TYPE_P(rettype)
+ && COMPLEX_FLOAT_TYPE_P(TREE_TYPE(args[0])))))
+ {
+ excess_type = excess_precision_type(TREE_TYPE(args[0]));
+ if (excess_type != NULL_TREE)
+ {
+ tree excess_fndecl = mathfn_built_in(excess_type,
+ DECL_FUNCTION_CODE(fndecl));
+ if (excess_fndecl == NULL_TREE)
+ excess_type = NULL_TREE;
+ else
+ {
+ fn = build_fold_addr_expr_loc(location, excess_fndecl);
+ for (int i = 0; i < nargs; ++i)
+ args[i] = ::convert(excess_type, args[i]);
+ }
+ }
+ }
+
+ tree ret = build_call_array(excess_type != NULL_TREE ? excess_type : rettype,
+ fn, nargs, args);
+ delete[] args;
+
+ SET_EXPR_LOCATION(ret, location);
+
+ if (has_closure)
+ {
+ tree closure_tree = func->closure()->get_tree(context);
+ if (closure_tree != error_mark_node)
+ CALL_EXPR_STATIC_CHAIN(ret) = closure_tree;
+ }
+
+ // If this is a recursive function type which returns itself, as in
+ // type F func() F
+ // we have used ptr_type_node for the return type. Add a cast here
+ // to the correct type.
+ if (TREE_TYPE(ret) == ptr_type_node)
+ {
+ tree t = this->type()->base()->get_tree(gogo);
+ ret = fold_convert_loc(location, t, ret);
+ }
+
+ if (excess_type != NULL_TREE)
+ {
+ // Calling convert here can undo our excess precision change.
+ // That may or may not be a bug in convert_to_real.
+ ret = build1(NOP_EXPR, rettype, ret);
+ }
+
+ // If there is more than one result, we will refer to the call
+ // multiple times.
+ if (fntype->results() != NULL && fntype->results()->size() > 1)
+ ret = save_expr(ret);
+
+ this->tree_ = ret;
+
+ return ret;
+}
+
+// Make a call expression.
+
+Call_expression*
+Expression::make_call(Expression* fn, Expression_list* args, bool is_varargs,
+ source_location location)
+{
+ return new Call_expression(fn, args, is_varargs, location);
+}
+
+// A single result from a call which returns multiple results.
+
+class Call_result_expression : public Expression
+{
+ public:
+ Call_result_expression(Call_expression* call, unsigned int index)
+ : Expression(EXPRESSION_CALL_RESULT, call->location()),
+ call_(call), index_(index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Call_result_expression(this->call_->call_expression(),
+ this->index_);
+ }
+
+ bool
+ do_must_eval_in_order() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The underlying call expression.
+ Expression* call_;
+ // Which result we want.
+ unsigned int index_;
+};
+
+// Traverse a call result.
+
+int
+Call_result_expression::do_traverse(Traverse* traverse)
+{
+ if (traverse->remember_expression(this->call_))
+ {
+ // We have already traversed the call expression.
+ return TRAVERSE_CONTINUE;
+ }
+ return Expression::traverse(&this->call_, traverse);
+}
+
+// Get the type.
+
+Type*
+Call_result_expression::do_type()
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return Type::make_error_type();
+
+ // THIS->CALL_ can be replaced with a temporary reference due to
+ // Call_expression::do_must_eval_in_order when there is an error.
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ {
+ this->set_is_error();
+ return Type::make_error_type();
+ }
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL)
+ {
+ this->set_is_error();
+ return Type::make_error_type();
+ }
+ const Typed_identifier_list* results = fntype->results();
+ if (results == NULL)
+ {
+ this->report_error(_("number of results does not match "
+ "number of values"));
+ return Type::make_error_type();
+ }
+ Typed_identifier_list::const_iterator pr = results->begin();
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ if (pr == results->end())
+ break;
+ ++pr;
+ }
+ if (pr == results->end())
+ {
+ this->report_error(_("number of results does not match "
+ "number of values"));
+ return Type::make_error_type();
+ }
+ return pr->type();
+}
+
+// Check the type. Just make sure that we trigger the warning in
+// do_type.
+
+void
+Call_result_expression::do_check_types(Gogo*)
+{
+ this->type();
+}
+
+// Determine the type. We have nothing to do here, but the 0 result
+// needs to pass down to the caller.
+
+void
+Call_result_expression::do_determine_type(const Type_context*)
+{
+ this->call_->determine_type_no_context();
+}
+
+// Return the tree.
+
+tree
+Call_result_expression::do_get_tree(Translate_context* context)
+{
+ tree call_tree = this->call_->get_tree(context);
+ if (call_tree == error_mark_node)
+ return error_mark_node;
+ if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ go_assert(field != NULL_TREE);
+ field = DECL_CHAIN(field);
+ }
+ go_assert(field != NULL_TREE);
+ return build3(COMPONENT_REF, TREE_TYPE(field), call_tree, field, NULL_TREE);
+}
+
+// Make a reference to a single result of a call which returns
+// multiple results.
+
+Expression*
+Expression::make_call_result(Call_expression* call, unsigned int index)
+{
+ return new Call_result_expression(call, index);
+}
+
+// Class Index_expression.
+
+// Traversal.
+
+int
+Index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->left_, traverse) == TRAVERSE_EXIT
+ || Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT
+ || (this->end_ != NULL
+ && Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT))
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower an index expression. This converts the generic index
+// expression into an array index, a string index, or a map index.
+
+Expression*
+Index_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Expression* left = this->left_;
+ Expression* start = this->start_;
+ Expression* end = this->end_;
+
+ Type* type = left->type();
+ if (type->is_error())
+ return Expression::make_error(location);
+ else if (left->is_type_expression())
+ {
+ error_at(location, "attempt to index type expression");
+ return Expression::make_error(location);
+ }
+ else if (type->array_type() != NULL)
+ return Expression::make_array_index(left, start, end, location);
+ else if (type->points_to() != NULL
+ && type->points_to()->array_type() != NULL
+ && !type->points_to()->is_open_array_type())
+ {
+ Expression* deref = Expression::make_unary(OPERATOR_MULT, left,
+ location);
+ return Expression::make_array_index(deref, start, end, location);
+ }
+ else if (type->is_string_type())
+ return Expression::make_string_index(left, start, end, location);
+ else if (type->map_type() != NULL)
+ {
+ if (end != NULL)
+ {
+ error_at(location, "invalid slice of map");
+ return Expression::make_error(location);
+ }
+ Map_index_expression* ret= Expression::make_map_index(left, start,
+ location);
+ if (this->is_lvalue_)
+ ret->set_is_lvalue();
+ return ret;
+ }
+ else
+ {
+ error_at(location,
+ "attempt to index object which is not array, string, or map");
+ return Expression::make_error(location);
+ }
+}
+
+// Make an index expression.
+
+Expression*
+Expression::make_index(Expression* left, Expression* start, Expression* end,
+ source_location location)
+{
+ return new Index_expression(left, start, end, location);
+}
+
+// An array index. This is used for both indexing and slicing.
+
+class Array_index_expression : public Expression
+{
+ public:
+ Array_index_expression(Expression* array, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_ARRAY_INDEX, location),
+ array_(array), start_(start), end_(end), type_(NULL)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_array_index(this->array_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const;
+
+ void
+ do_address_taken(bool escapes)
+ { this->array_->address_taken(escapes); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The array we are getting a value from.
+ Expression* array_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a simple array
+ // index, or it may be a nil expression for the length of the array.
+ Expression* end_;
+ // The type of the expression.
+ Type* type_;
+};
+
+// Array index traversal.
+
+int
+Array_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->array_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of an array index.
+
+Type*
+Array_index_expression::do_type()
+{
+ if (this->type_ == NULL)
+ {
+ Array_type* type = this->array_->type()->array_type();
+ if (type == NULL)
+ this->type_ = Type::make_error_type();
+ else if (this->end_ == NULL)
+ this->type_ = type->element_type();
+ else if (type->is_open_array_type())
+ {
+ // A slice of a slice has the same type as the original
+ // slice.
+ this->type_ = this->array_->type()->deref();
+ }
+ else
+ {
+ // A slice of an array is a slice.
+ this->type_ = Type::make_array_type(type->element_type(), NULL);
+ }
+ }
+ return this->type_;
+}
+
+// Set the type of an array index.
+
+void
+Array_index_expression::do_determine_type(const Type_context*)
+{
+ this->array_->determine_type_no_context();
+ this->start_->determine_type_no_context();
+ if (this->end_ != NULL)
+ this->end_->determine_type_no_context();
+}
+
+// Check types of an array index.
+
+void
+Array_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ Array_type* array_type = this->array_->type()->array_type();
+ if (array_type == NULL)
+ {
+ go_assert(this->array_->type()->is_error());
+ return;
+ }
+
+ unsigned int int_bits =
+ Type::lookup_integer_type("int")->integer_type()->bits();
+
+ Type* dummy;
+ mpz_t lval;
+ mpz_init(lval);
+ bool lval_valid = (array_type->length() != NULL
+ && array_type->length()->integer_constant_value(true,
+ lval,
+ &dummy));
+ mpz_t ival;
+ mpz_init(ival);
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid
+ && (this->end_ == NULL
+ ? mpz_cmp(ival, lval) >= 0
+ : mpz_cmp(ival, lval) > 0)))
+ {
+ error_at(this->start_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid && mpz_cmp(ival, lval) > 0))
+ {
+ error_at(this->end_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+ mpz_clear(lval);
+
+ // A slice of an array requires an addressable array. A slice of a
+ // slice is always possible.
+ if (this->end_ != NULL && !array_type->is_open_array_type())
+ {
+ if (!this->array_->is_addressable())
+ this->report_error(_("array is not addressable"));
+ else
+ this->array_->address_taken(true);
+ }
+}
+
+// Return whether this expression is addressable.
+
+bool
+Array_index_expression::do_is_addressable() const
+{
+ // A slice expression is not addressable.
+ if (this->end_ != NULL)
+ return false;
+
+ // An index into a slice is addressable.
+ if (this->array_->type()->is_open_array_type())
+ return true;
+
+ // An index into an array is addressable if the array is
+ // addressable.
+ return this->array_->is_addressable();
+}
+
+// Get a tree for an array index.
+
+tree
+Array_index_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Array_type* array_type = this->array_->type()->array_type();
+ if (array_type == NULL)
+ {
+ go_assert(this->array_->type()->is_error());
+ return error_mark_node;
+ }
+
+ tree type_tree = array_type->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree array_tree = this->array_->get_tree(context);
+ if (array_tree == error_mark_node)
+ return error_mark_node;
+
+ if (array_type->length() == NULL && !DECL_P(array_tree))
+ array_tree = save_expr(array_tree);
+ tree length_tree = array_type->length_tree(gogo, array_tree);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node, bad_index,
+ fold_build2_loc(loc,
+ (this->end_ == NULL
+ ? GE_EXPR
+ : GT_EXPR),
+ boolean_type_node, start_tree,
+ length_tree));
+
+ int code = (array_type->length() != NULL
+ ? (this->end_ == NULL
+ ? RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS)
+ : (this->end_ == NULL
+ ? RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS));
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ // Simple array indexing. This has to return an l-value, so
+ // wrap the index check into START_TREE.
+ start_tree = build2(COMPOUND_EXPR, TREE_TYPE(start_tree),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ start_tree);
+ start_tree = fold_convert_loc(loc, sizetype, start_tree);
+
+ if (array_type->length() != NULL)
+ {
+ // Fixed array.
+ return build4(ARRAY_REF, TREE_TYPE(type_tree), array_tree,
+ start_tree, NULL_TREE, NULL_TREE);
+ }
+ else
+ {
+ // Open array.
+ tree values = array_type->value_pointer_tree(gogo, array_tree);
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ start_tree, element_size);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(values), values, offset);
+ return build_fold_indirect_ref(ptr);
+ }
+ }
+
+ // Array slice.
+
+ tree capacity_tree = array_type->capacity_tree(gogo, array_tree);
+ if (capacity_tree == error_mark_node)
+ return error_mark_node;
+ capacity_tree = fold_convert_loc(loc, length_type, capacity_tree);
+
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = length_tree;
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type, bad_index,
+ loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+
+ capacity_tree = save_expr(capacity_tree);
+ tree bad_end = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ fold_build2_loc(loc, LT_EXPR,
+ boolean_type_node,
+ end_tree, start_tree),
+ fold_build2_loc(loc, GT_EXPR,
+ boolean_type_node,
+ end_tree, capacity_tree));
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, bad_end);
+ }
+
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ fold_convert_loc(loc, sizetype, start_tree),
+ element_size);
+
+ tree value_pointer = array_type->value_pointer_tree(gogo, array_tree);
+ if (value_pointer == error_mark_node)
+ return error_mark_node;
+
+ value_pointer = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(value_pointer),
+ value_pointer, offset);
+
+ tree result_length_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ end_tree, start_tree);
+
+ tree result_capacity_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ capacity_tree, start_tree);
+
+ tree struct_tree = this->type()->get_tree(gogo);
+ go_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(struct_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = value_pointer;
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_capacity_tree);
+
+ tree constructor = build_constructor(struct_tree, init);
+
+ if (TREE_CONSTANT(value_pointer)
+ && TREE_CONSTANT(result_length_tree)
+ && TREE_CONSTANT(result_capacity_tree))
+ TREE_CONSTANT(constructor) = 1;
+
+ return fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(constructor),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ constructor);
+}
+
+// Make an array index expression. END may be NULL.
+
+Expression*
+Expression::make_array_index(Expression* array, Expression* start,
+ Expression* end, source_location location)
+{
+ // Taking a slice of a composite literal requires moving the literal
+ // onto the heap.
+ if (end != NULL && array->is_composite_literal())
+ {
+ array = Expression::make_heap_composite(array, location);
+ array = Expression::make_unary(OPERATOR_MULT, array, location);
+ }
+ return new Array_index_expression(array, start, end, location);
+}
+
+// A string index. This is used for both indexing and slicing.
+
+class String_index_expression : public Expression
+{
+ public:
+ String_index_expression(Expression* string, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_STRING_INDEX, location),
+ string_(string), start_(start), end_(end)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_string_index(this->string_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The string we are getting a value from.
+ Expression* string_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a single index,
+ // or it may be a nil expression for the length of the string.
+ Expression* end_;
+};
+
+// String index traversal.
+
+int
+String_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->string_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of a string index.
+
+Type*
+String_index_expression::do_type()
+{
+ if (this->end_ == NULL)
+ return Type::lookup_integer_type("uint8");
+ else
+ return this->string_->type();
+}
+
+// Determine the type of a string index.
+
+void
+String_index_expression::do_determine_type(const Type_context*)
+{
+ this->string_->determine_type_no_context();
+ this->start_->determine_type_no_context();
+ if (this->end_ != NULL)
+ this->end_->determine_type_no_context();
+}
+
+// Check types of a string index.
+
+void
+String_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ std::string sval;
+ bool sval_valid = this->string_->string_constant_value(&sval);
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) >= 0))
+ {
+ error_at(this->start_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) > 0))
+ {
+ error_at(this->end_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+}
+
+// Get a tree for a string index.
+
+tree
+String_index_expression::do_get_tree(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ tree string_tree = this->string_->get_tree(context);
+ if (string_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->string_->type()->points_to() != NULL)
+ string_tree = build_fold_indirect_ref(string_tree);
+ if (!DECL_P(string_tree))
+ string_tree = save_expr(string_tree);
+ tree string_type = TREE_TYPE(string_tree);
+
+ tree length_tree = String_type::length_tree(context->gogo(), string_tree);
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+
+ int code = (this->end_ == NULL
+ ? RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS);
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index,
+ fold_build2_loc(loc, GE_EXPR,
+ boolean_type_node,
+ start_tree, length_tree));
+
+ tree bytes_tree = String_type::bytes_tree(context->gogo(), string_tree);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR, TREE_TYPE(bytes_tree),
+ bytes_tree,
+ fold_convert_loc(loc, sizetype, start_tree));
+ tree index = build_fold_indirect_ref_loc(loc, ptr);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(index),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ index);
+ }
+ else
+ {
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = build_int_cst(length_type, -1);
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type,
+ bad_index, loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+ }
+
+ static tree strslice_fndecl;
+ tree ret = Gogo::call_builtin(&strslice_fndecl,
+ loc,
+ "__go_string_slice",
+ 3,
+ string_type,
+ string_type,
+ string_tree,
+ length_type,
+ start_tree,
+ length_type,
+ end_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This will panic if the bounds are out of range for the
+ // string.
+ TREE_NOTHROW(strslice_fndecl) = 0;
+
+ if (bad_index == boolean_false_node)
+ return ret;
+ else
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Make a string index expression. END may be NULL.
+
+Expression*
+Expression::make_string_index(Expression* string, Expression* start,
+ Expression* end, source_location location)
+{
+ return new String_index_expression(string, start, end, location);
+}
+
+// Class Map_index.
+
+// Get the type of the map.
+
+Map_type*
+Map_index_expression::get_map_type() const
+{
+ Map_type* mt = this->map_->type()->deref()->map_type();
+ if (mt == NULL)
+ go_assert(saw_errors());
+ return mt;
+}
+
+// Map index traversal.
+
+int
+Map_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->map_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->index_, traverse);
+}
+
+// Return the type of a map index.
+
+Type*
+Map_index_expression::do_type()
+{
+ Map_type* mt = this->get_map_type();
+ if (mt == NULL)
+ return Type::make_error_type();
+ Type* type = mt->val_type();
+ // If this map index is in a tuple assignment, we actually return a
+ // pointer to the value type. Tuple_map_assignment_statement is
+ // responsible for handling this correctly. We need to get the type
+ // right in case this gets assigned to a temporary variable.
+ if (this->is_in_tuple_assignment_)
+ type = Type::make_pointer_type(type);
+ return type;
+}
+
+// Fix the type of a map index.
+
+void
+Map_index_expression::do_determine_type(const Type_context*)
+{
+ this->map_->determine_type_no_context();
+ Map_type* mt = this->get_map_type();
+ Type* key_type = mt == NULL ? NULL : mt->key_type();
+ Type_context subcontext(key_type, false);
+ this->index_->determine_type(&subcontext);
+}
+
+// Check types of a map index.
+
+void
+Map_index_expression::do_check_types(Gogo*)
+{
+ std::string reason;
+ Map_type* mt = this->get_map_type();
+ if (mt == NULL)
+ return;
+ if (!Type::are_assignable(mt->key_type(), this->index_->type(), &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for map index"));
+ else
+ {
+ error_at(this->location(), "incompatible type for map index (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a map index.
+
+tree
+Map_index_expression::do_get_tree(Translate_context* context)
+{
+ Map_type* type = this->get_map_type();
+ if (type == NULL)
+ return error_mark_node;
+
+ tree valptr = this->get_value_pointer(context, this->is_lvalue_);
+ if (valptr == error_mark_node)
+ return error_mark_node;
+ valptr = save_expr(valptr);
+
+ tree val_type_tree = TREE_TYPE(TREE_TYPE(valptr));
+
+ if (this->is_lvalue_)
+ return build_fold_indirect_ref(valptr);
+ else if (this->is_in_tuple_assignment_)
+ {
+ // Tuple_map_assignment_statement is responsible for using this
+ // appropriately.
+ return valptr;
+ }
+ else
+ {
+ return fold_build3(COND_EXPR, val_type_tree,
+ fold_build2(EQ_EXPR, boolean_type_node, valptr,
+ fold_convert(TREE_TYPE(valptr),
+ null_pointer_node)),
+ type->val_type()->get_init_tree(context->gogo(),
+ false),
+ build_fold_indirect_ref(valptr));
+ }
+}
+
+// Get a tree for the map index. This returns a tree which evaluates
+// to a pointer to a value. The pointer will be NULL if the key is
+// not in the map.
+
+tree
+Map_index_expression::get_value_pointer(Translate_context* context,
+ bool insert)
+{
+ Map_type* type = this->get_map_type();
+ if (type == NULL)
+ return error_mark_node;
+
+ tree map_tree = this->map_->get_tree(context);
+ tree index_tree = this->index_->get_tree(context);
+ index_tree = Expression::convert_for_assignment(context, type->key_type(),
+ this->index_->type(),
+ index_tree,
+ this->location());
+ if (map_tree == error_mark_node || index_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->map_->type()->points_to() != NULL)
+ map_tree = build_fold_indirect_ref(map_tree);
+
+ // We need to pass in a pointer to the key, so stuff it into a
+ // variable.
+ tree tmp;
+ tree make_tmp;
+ if (current_function_decl != NULL)
+ {
+ tmp = create_tmp_var(TREE_TYPE(index_tree), get_name(index_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = index_tree;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ else
+ {
+ tmp = build_decl(this->location(), VAR_DECL, create_tmp_var_name("M"),
+ TREE_TYPE(index_tree));
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (!TREE_CONSTANT(index_tree))
+ make_tmp = fold_build2_loc(this->location(), INIT_EXPR, void_type_node,
+ tmp, index_tree);
+ else
+ {
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ DECL_INITIAL(tmp) = index_tree;
+ make_tmp = NULL_TREE;
+ }
+ rest_of_decl_compilation(tmp, 1, 0);
+ }
+ tree tmpref = fold_convert_loc(this->location(), const_ptr_type_node,
+ build_fold_addr_expr_loc(this->location(),
+ tmp));
+
+ static tree map_index_fndecl;
+ tree call = Gogo::call_builtin(&map_index_fndecl,
+ this->location(),
+ "__go_map_index",
+ 3,
+ const_ptr_type_node,
+ TREE_TYPE(map_tree),
+ map_tree,
+ const_ptr_type_node,
+ tmpref,
+ boolean_type_node,
+ (insert
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic on a map of interface type if the interface holds
+ // an uncomparable or unhashable type.
+ TREE_NOTHROW(map_index_fndecl) = 0;
+
+ tree val_type_tree = type->val_type()->get_tree(context->gogo());
+ if (val_type_tree == error_mark_node)
+ return error_mark_node;
+ tree ptr_val_type_tree = build_pointer_type(val_type_tree);
+
+ tree ret = fold_convert_loc(this->location(), ptr_val_type_tree, call);
+ if (make_tmp != NULL_TREE)
+ ret = build2(COMPOUND_EXPR, ptr_val_type_tree, make_tmp, ret);
+ return ret;
+}
+
+// Make a map index expression.
+
+Map_index_expression*
+Expression::make_map_index(Expression* map, Expression* index,
+ source_location location)
+{
+ return new Map_index_expression(map, index, location);
+}
+
+// Class Field_reference_expression.
+
+// Return the type of a field reference.
+
+Type*
+Field_reference_expression::do_type()
+{
+ Type* type = this->expr_->type();
+ if (type->is_error())
+ return type;
+ Struct_type* struct_type = type->struct_type();
+ go_assert(struct_type != NULL);
+ return struct_type->field(this->field_index_)->type();
+}
+
+// Check the types for a field reference.
+
+void
+Field_reference_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+ if (type->is_error())
+ return;
+ Struct_type* struct_type = type->struct_type();
+ go_assert(struct_type != NULL);
+ go_assert(struct_type->field(this->field_index_) != NULL);
+}
+
+// Get a tree for a field reference.
+
+tree
+Field_reference_expression::do_get_tree(Translate_context* context)
+{
+ tree struct_tree = this->expr_->get_tree(context);
+ if (struct_tree == error_mark_node
+ || TREE_TYPE(struct_tree) == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(TREE_TYPE(struct_tree)) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(TREE_TYPE(struct_tree));
+ if (field == NULL_TREE)
+ {
+ // This can happen for a type which refers to itself indirectly
+ // and then turns out to be erroneous.
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+ for (unsigned int i = this->field_index_; i > 0; --i)
+ {
+ field = DECL_CHAIN(field);
+ go_assert(field != NULL_TREE);
+ }
+ if (TREE_TYPE(field) == error_mark_node)
+ return error_mark_node;
+ return build3(COMPONENT_REF, TREE_TYPE(field), struct_tree, field,
+ NULL_TREE);
+}
+
+// Make a reference to a qualified identifier in an expression.
+
+Field_reference_expression*
+Expression::make_field_reference(Expression* expr, unsigned int field_index,
+ source_location location)
+{
+ return new Field_reference_expression(expr, field_index, location);
+}
+
+// Class Interface_field_reference_expression.
+
+// Return a tree for the pointer to the function to call.
+
+tree
+Interface_field_reference_expression::get_function_tree(Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ go_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = TYPE_FIELDS(expr_type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods") == 0);
+
+ tree table = build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+ go_assert(POINTER_TYPE_P(TREE_TYPE(table)));
+
+ table = build_fold_indirect_ref(table);
+ go_assert(TREE_CODE(TREE_TYPE(table)) == RECORD_TYPE);
+
+ std::string name = Gogo::unpack_hidden_name(this->name_);
+ for (field = DECL_CHAIN(TYPE_FIELDS(TREE_TYPE(table)));
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ if (name == IDENTIFIER_POINTER(DECL_NAME(field)))
+ break;
+ }
+ go_assert(field != NULL_TREE);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), table, field, NULL_TREE);
+}
+
+// Return a tree for the first argument to pass to the interface
+// function.
+
+tree
+Interface_field_reference_expression::get_underlying_object_tree(
+ Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ go_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(expr_type));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+}
+
+// Traversal.
+
+int
+Interface_field_reference_expression::do_traverse(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Return the type of an interface field reference.
+
+Type*
+Interface_field_reference_expression::do_type()
+{
+ Type* expr_type = this->expr_->type();
+
+ Type* points_to = expr_type->points_to();
+ if (points_to != NULL)
+ expr_type = points_to;
+
+ Interface_type* interface_type = expr_type->interface_type();
+ if (interface_type == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier* method = interface_type->find_method(this->name_);
+ if (method == NULL)
+ return Type::make_error_type();
+
+ return method->type();
+}
+
+// Determine types.
+
+void
+Interface_field_reference_expression::do_determine_type(const Type_context*)
+{
+ this->expr_->determine_type_no_context();
+}
+
+// Check the types for an interface field reference.
+
+void
+Interface_field_reference_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+
+ Type* points_to = type->points_to();
+ if (points_to != NULL)
+ type = points_to;
+
+ Interface_type* interface_type = type->interface_type();
+ if (interface_type == NULL)
+ {
+ if (!type->is_error_type())
+ this->report_error(_("expected interface or pointer to interface"));
+ }
+ else
+ {
+ const Typed_identifier* method =
+ interface_type->find_method(this->name_);
+ if (method == NULL)
+ {
+ error_at(this->location(), "method %qs not in interface",
+ Gogo::message_name(this->name_).c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a reference to a field in an interface. There is no
+// standard tree type representation for this: it's a function
+// attached to its first argument, like a Bound_method_expression.
+// The only places it may currently be used are in a Call_expression
+// or a Go_statement, which will take it apart directly. So this has
+// nothing to do at present.
+
+tree
+Interface_field_reference_expression::do_get_tree(Translate_context*)
+{
+ go_unreachable();
+}
+
+// Make a reference to a field in an interface.
+
+Expression*
+Expression::make_interface_field_reference(Expression* expr,
+ const std::string& field,
+ source_location location)
+{
+ return new Interface_field_reference_expression(expr, field, location);
+}
+
+// A general selector. This is a Parser_expression for LEFT.NAME. It
+// is lowered after we know the type of the left hand side.
+
+class Selector_expression : public Parser_expression
+{
+ public:
+ Selector_expression(Expression* left, const std::string& name,
+ source_location location)
+ : Parser_expression(EXPRESSION_SELECTOR, location),
+ left_(left), name_(name)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->left_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Selector_expression(this->left_->copy(), this->name_,
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_method_expression(Gogo*);
+
+ // The expression on the left hand side.
+ Expression* left_;
+ // The name on the right hand side.
+ std::string name_;
+};
+
+// Lower a selector expression once we know the real type of the left
+// hand side.
+
+Expression*
+Selector_expression::do_lower(Gogo* gogo, Named_object*, int)
+{
+ Expression* left = this->left_;
+ if (left->is_type_expression())
+ return this->lower_method_expression(gogo);
+ return Type::bind_field_or_method(gogo, left->type(), left, this->name_,
+ this->location());
+}
+
+// Lower a method expression T.M or (*T).M. We turn this into a
+// function literal.
+
+Expression*
+Selector_expression::lower_method_expression(Gogo* gogo)
+{
+ source_location location = this->location();
+ Type* type = this->left_->type();
+ const std::string& name(this->name_);
+
+ bool is_pointer;
+ if (type->points_to() == NULL)
+ is_pointer = false;
+ else
+ {
+ is_pointer = true;
+ type = type->points_to();
+ }
+ Named_type* nt = type->named_type();
+ if (nt == NULL)
+ {
+ error_at(location,
+ ("method expression requires named type or "
+ "pointer to named type"));
+ return Expression::make_error(location);
+ }
+
+ bool is_ambiguous;
+ Method* method = nt->method_function(name, &is_ambiguous);
+ const Typed_identifier* imethod = NULL;
+ if (method == NULL && !is_pointer)
+ {
+ Interface_type* it = nt->interface_type();
+ if (it != NULL)
+ imethod = it->find_method(name);
+ }
+
+ if (method == NULL && imethod == NULL)
+ {
+ if (!is_ambiguous)
+ error_at(location, "type %<%s%s%> has no method %<%s%>",
+ is_pointer ? "*" : "",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "method %<%s%s%> is ambiguous in type %<%s%>",
+ Gogo::message_name(name).c_str(),
+ is_pointer ? "*" : "",
+ nt->message_name().c_str());
+ return Expression::make_error(location);
+ }
+
+ if (method != NULL && !is_pointer && !method->is_value_method())
+ {
+ error_at(location, "method requires pointer (use %<(*%s).%s)%>",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ return Expression::make_error(location);
+ }
+
+ // Build a new function type in which the receiver becomes the first
+ // argument.
+ Function_type* method_type;
+ if (method != NULL)
+ {
+ method_type = method->type();
+ go_assert(method_type->is_method());
+ }
+ else
+ {
+ method_type = imethod->type()->function_type();
+ go_assert(method_type != NULL && !method_type->is_method());
+ }
+
+ const char* const receiver_name = "$this";
+ Typed_identifier_list* parameters = new Typed_identifier_list();
+ parameters->push_back(Typed_identifier(receiver_name, this->left_->type(),
+ location));
+
+ const Typed_identifier_list* method_parameters = method_type->parameters();
+ if (method_parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ parameters->push_back(*p);
+ }
+
+ const Typed_identifier_list* method_results = method_type->results();
+ Typed_identifier_list* results;
+ if (method_results == NULL)
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = method_results->begin();
+ p != method_results->end();
+ ++p)
+ results->push_back(*p);
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters, results,
+ location);
+ if (method_type->is_varargs())
+ fntype->set_is_varargs();
+
+ // We generate methods which always takes a pointer to the receiver
+ // as their first argument. If this is for a pointer type, we can
+ // simply reuse the existing function. We use an internal hack to
+ // get the right type.
+
+ if (method != NULL && is_pointer)
+ {
+ Named_object* mno = (method->needs_stub_method()
+ ? method->stub_object()
+ : method->named_object());
+ Expression* f = Expression::make_func_reference(mno, NULL, location);
+ f = Expression::make_cast(fntype, f, location);
+ Type_conversion_expression* tce =
+ static_cast<Type_conversion_expression*>(f);
+ tce->set_may_convert_function_types();
+ return f;
+ }
+
+ Named_object* no = gogo->start_function(Gogo::thunk_name(), fntype, false,
+ location);
+
+ Named_object* vno = gogo->lookup(receiver_name, NULL);
+ go_assert(vno != NULL);
+ Expression* ve = Expression::make_var_reference(vno, location);
+ Expression* bm;
+ if (method != NULL)
+ bm = Type::bind_field_or_method(gogo, nt, ve, name, location);
+ else
+ bm = Expression::make_interface_field_reference(ve, name, location);
+
+ // Even though we found the method above, if it has an error type we
+ // may see an error here.
+ if (bm->is_error_expression())
+ {
+ gogo->finish_function(location);
+ return bm;
+ }
+
+ Expression_list* args;
+ if (method_parameters == NULL)
+ args = NULL;
+ else
+ {
+ args = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ {
+ vno = gogo->lookup(p->name(), NULL);
+ go_assert(vno != NULL);
+ args->push_back(Expression::make_var_reference(vno, location));
+ }
+ }
+
+ Call_expression* call = Expression::make_call(bm, args,
+ method_type->is_varargs(),
+ location);
+
+ size_t count = call->result_count();
+ Statement* s;
+ if (count == 0)
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ s = Statement::make_return_statement(retvals, location);
+ }
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ return Expression::make_func_reference(no, NULL, location);
+}
+
+// Make a selector expression.
+
+Expression*
+Expression::make_selector(Expression* left, const std::string& name,
+ source_location location)
+{
+ return new Selector_expression(left, name, location);
+}
+
+// Implement the builtin function new.
+
+class Allocation_expression : public Expression
+{
+ public:
+ Allocation_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_ALLOCATION, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->type_); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return new Allocation_expression(this->type_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are allocating.
+ Type* type_;
+};
+
+// Check the type of an allocation expression.
+
+void
+Allocation_expression::do_check_types(Gogo*)
+{
+ if (this->type_->function_type() != NULL)
+ this->report_error(_("invalid new of function type"));
+}
+
+// Return a tree for an allocation expression.
+
+tree
+Allocation_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ tree size_tree = TYPE_SIZE_UNIT(type_tree);
+ tree space = context->gogo()->allocate_memory(this->type_, size_tree,
+ this->location());
+ if (space == error_mark_node)
+ return error_mark_node;
+ return fold_convert(build_pointer_type(type_tree), space);
+}
+
+// Make an allocation expression.
+
+Expression*
+Expression::make_allocation(Type* type, source_location location)
+{
+ return new Allocation_expression(type, location);
+}
+
+// Implement the builtin function make.
+
+class Make_expression : public Expression
+{
+ public:
+ Make_expression(Type* type, Expression_list* args, source_location location)
+ : Expression(EXPRESSION_MAKE, location),
+ type_(type), args_(args)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Make_expression(this->type_, this->args_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are making.
+ Type* type_;
+ // The arguments to pass to the make routine.
+ Expression_list* args_;
+};
+
+// Traversal.
+
+int
+Make_expression::do_traverse(Traverse* traverse)
+{
+ if (this->args_ != NULL
+ && this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Set types of arguments.
+
+void
+Make_expression::do_determine_type(const Type_context*)
+{
+ if (this->args_ != NULL)
+ {
+ Type_context context(Type::lookup_integer_type("int"), false);
+ for (Expression_list::const_iterator pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe)
+ (*pe)->determine_type(&context);
+ }
+}
+
+// Check types for a make expression.
+
+void
+Make_expression::do_check_types(Gogo*)
+{
+ if (this->type_->channel_type() == NULL
+ && this->type_->map_type() == NULL
+ && (this->type_->array_type() == NULL
+ || this->type_->array_type()->length() != NULL))
+ this->report_error(_("invalid type for make function"));
+ else if (!this->type_->check_make_expression(this->args_, this->location()))
+ this->set_is_error();
+}
+
+// Return a tree for a make expression.
+
+tree
+Make_expression::do_get_tree(Translate_context* context)
+{
+ return this->type_->make_expression_tree(context, this->args_,
+ this->location());
+}
+
+// Make a make expression.
+
+Expression*
+Expression::make_make(Type* type, Expression_list* args,
+ source_location location)
+{
+ return new Make_expression(type, args, location);
+}
+
+// Construct a struct.
+
+class Struct_construction_expression : public Expression
+{
+ public:
+ Struct_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_STRUCT_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { }
+
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_struct() const;
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Struct_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the struct to construct.
+ Type* type_;
+ // The list of values, in order of the fields in the struct. A NULL
+ // entry means that the field should be zero-initialized.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Struct_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Struct_construction_expression::is_constant_struct() const
+{
+ if (this->vals_ == NULL)
+ return true;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ // There are no constant constructors for interfaces.
+ if (pf->type()->interface_type() != NULL)
+ return false;
+ }
+
+ return true;
+}
+
+// Final type determination.
+
+void
+Struct_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv)
+ {
+ if (pv == this->vals_->end())
+ return;
+ if (*pv != NULL)
+ {
+ Type_context subcontext(pf->type(), false);
+ (*pv)->determine_type(&subcontext);
+ }
+ }
+ // Extra values are an error we will report elsewhere; we still want
+ // to determine the type to avoid knockon errors.
+ for (; pv != this->vals_->end(); ++pv)
+ (*pv)->determine_type_no_context();
+}
+
+// Check types.
+
+void
+Struct_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Struct_type* st = this->type_->struct_type();
+ if (this->vals_->size() > st->field_count())
+ {
+ this->report_error(_("too many expressions for struct"));
+ return;
+ }
+
+ const Struct_field_list* fields = st->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv, ++i)
+ {
+ if (pv == this->vals_->end())
+ {
+ this->report_error(_("too few expressions for struct"));
+ break;
+ }
+
+ if (*pv == NULL)
+ continue;
+
+ std::string reason;
+ if (!Type::are_assignable(pf->type(), (*pv)->type(), &reason))
+ {
+ if (reason.empty())
+ error_at((*pv)->location(),
+ "incompatible type for field %d in struct construction",
+ i + 1);
+ else
+ error_at((*pv)->location(),
+ ("incompatible type for field %d in "
+ "struct construction (%s)"),
+ i + 1, reason.c_str());
+ this->set_is_error();
+ }
+ }
+ go_assert(pv == this->vals_->end());
+}
+
+// Return a tree for constructing a struct.
+
+tree
+Struct_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ if (this->vals_ == NULL)
+ return this->type_->get_init_tree(gogo, false);
+
+ tree type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ bool is_constant = true;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ VEC(constructor_elt,gc)* elts = VEC_alloc(constructor_elt, gc,
+ fields->size());
+ Struct_field_list::const_iterator pf = fields->begin();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field), ++pf)
+ {
+ go_assert(pf != fields->end());
+
+ tree val;
+ if (pv == this->vals_->end())
+ val = pf->type()->get_init_tree(gogo, false);
+ else if (*pv == NULL)
+ {
+ val = pf->type()->get_init_tree(gogo, false);
+ ++pv;
+ }
+ else
+ {
+ val = Expression::convert_for_assignment(context, pf->type(),
+ (*pv)->type(),
+ (*pv)->get_tree(context),
+ this->location());
+ ++pv;
+ }
+
+ if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
+ return error_mark_node;
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, elts, NULL);
+ elt->index = field;
+ elt->value = val;
+ if (!TREE_CONSTANT(val))
+ is_constant = false;
+ }
+ go_assert(pf == fields->end());
+
+ tree ret = build_constructor(type_tree, elts);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export a struct construction.
+
+void
+Struct_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// Make a struct composite literal. This used by the thunk code.
+
+Expression*
+Expression::make_struct_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ go_assert(type->struct_type() != NULL);
+ return new Struct_construction_expression(type, vals, location);
+}
+
+// Construct an array. This class is not used directly; instead we
+// use the child classes, Fixed_array_construction_expression and
+// Open_array_construction_expression.
+
+class Array_construction_expression : public Expression
+{
+ protected:
+ Array_construction_expression(Expression_classification classification,
+ Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(classification, location),
+ type_(type), vals_(vals)
+ { }
+
+ public:
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_array() const;
+
+ // Return the number of elements.
+ size_t
+ element_count() const
+ { return this->vals_ == NULL ? 0 : this->vals_->size(); }
+
+protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ void
+ do_export(Export*) const;
+
+ // The list of values.
+ Expression_list*
+ vals()
+ { return this->vals_; }
+
+ // Get a constructor tree for the array values.
+ tree
+ get_constructor_tree(Translate_context* context, tree type_tree);
+
+ private:
+ // The type of the array to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Array_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Array_construction_expression::is_constant_array() const
+{
+ if (this->vals_ == NULL)
+ return true;
+
+ // There are no constant constructors for interfaces.
+ if (this->type_->array_type()->element_type()->interface_type() != NULL)
+ return false;
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+ return true;
+}
+
+// Final type determination.
+
+void
+Array_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ Type_context subcontext(this->type_->array_type()->element_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL)
+ (*pv)->determine_type(&subcontext);
+ }
+}
+
+// Check types.
+
+void
+Array_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Array_type* at = this->type_->array_type();
+ int i = 0;
+ Type* element_type = at->element_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (*pv != NULL
+ && !Type::are_assignable(element_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d in composite literal",
+ i + 1);
+ this->set_is_error();
+ }
+ }
+
+ Expression* length = at->length();
+ if (length != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (at->length()->integer_constant_value(true, val, &type))
+ {
+ if (this->vals_->size() > mpz_get_ui(val))
+ this->report_error(_("too many elements in composite literal"));
+ }
+ mpz_clear(val);
+ }
+}
+
+// Get a constructor tree for the array values.
+
+tree
+Array_construction_expression::get_constructor_tree(Translate_context* context,
+ tree type_tree)
+{
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ (this->vals_ == NULL
+ ? 0
+ : this->vals_->size()));
+ Type* element_type = this->type_->array_type()->element_type();
+ bool is_constant = true;
+ if (this->vals_ != NULL)
+ {
+ size_t i = 0;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ if (*pv == NULL)
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ else
+ {
+ tree value_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context,
+ element_type,
+ (*pv)->type(),
+ value_tree,
+ this->location());
+ }
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ is_constant = false;
+ }
+ }
+
+ tree ret = build_constructor(type_tree, values);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Array_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ if (this->vals_ != NULL)
+ {
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ }
+ exp->write_c_string(")");
+}
+
+// Construct a fixed array.
+
+class Fixed_array_construction_expression :
+ public Array_construction_expression
+{
+ public:
+ Fixed_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ go_assert(type->array_type() != NULL
+ && type->array_type()->length() != NULL);
+ }
+
+ protected:
+ Expression*
+ do_copy()
+ {
+ return new Fixed_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing a fixed array.
+
+tree
+Fixed_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ return this->get_constructor_tree(context,
+ this->type()->get_tree(context->gogo()));
+}
+
+// Construct an open array.
+
+class Open_array_construction_expression : public Array_construction_expression
+{
+ public:
+ Open_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_OPEN_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ go_assert(type->array_type() != NULL
+ && type->array_type()->length() == NULL);
+ }
+
+ protected:
+ // Note that taking the address of an open array literal is invalid.
+
+ Expression*
+ do_copy()
+ {
+ return new Open_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing an open array.
+
+tree
+Open_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ Array_type* array_type = this->type()->array_type();
+ if (array_type == NULL)
+ {
+ go_assert(this->type()->is_error());
+ return error_mark_node;
+ }
+
+ Type* element_type = array_type->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree values;
+ tree length_tree;
+ if (this->vals() == NULL || this->vals()->empty())
+ {
+ // We need to create a unique value.
+ tree max = size_int(0);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ VEC(constructor_elt,gc)* vec = VEC_alloc(constructor_elt, gc, 1);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, vec, NULL);
+ elt->index = size_int(0);
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ values = build_constructor(constructor_type, vec);
+ if (TREE_CONSTANT(elt->value))
+ TREE_CONSTANT(values) = 1;
+ length_tree = size_int(0);
+ }
+ else
+ {
+ tree max = size_int(this->vals()->size() - 1);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ values = this->get_constructor_tree(context, constructor_type);
+ length_tree = size_int(this->vals()->size());
+ }
+
+ if (values == error_mark_node)
+ return error_mark_node;
+
+ bool is_constant_initializer = TREE_CONSTANT(values);
+
+ // We have to copy the initial values into heap memory if we are in
+ // a function or if the values are not constants. We also have to
+ // copy them if they may contain pointers in a non-constant context,
+ // as otherwise the garbage collector won't see them.
+ bool copy_to_heap = (context->function() != NULL
+ || !is_constant_initializer
+ || (element_type->has_pointer()
+ && !context->is_const()));
+
+ if (is_constant_initializer)
+ {
+ tree tmp = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(values));
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (copy_to_heap)
+ {
+ // If we are not copying the value to the heap, we will only
+ // initialize the value once, so we can use this directly
+ // rather than copying it. In that case we can't make it
+ // read-only, because the program is permitted to change it.
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ }
+ DECL_INITIAL(tmp) = values;
+ rest_of_decl_compilation(tmp, 1, 0);
+ values = tmp;
+ }
+
+ tree space;
+ tree set;
+ if (!copy_to_heap)
+ {
+ // the initializer will only run once.
+ space = build_fold_addr_expr(values);
+ set = NULL_TREE;
+ }
+ else
+ {
+ tree memsize = TYPE_SIZE_UNIT(TREE_TYPE(values));
+ space = context->gogo()->allocate_memory(element_type, memsize,
+ this->location());
+ space = save_expr(space);
+
+ tree s = fold_convert(build_pointer_type(TREE_TYPE(values)), space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), s);
+ TREE_THIS_NOTRAP(ref) = 1;
+ set = build2(MODIFY_EXPR, void_type_node, ref, values);
+ }
+
+ // Build a constructor for the open array.
+
+ tree type_tree = this->type()->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(type_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), space);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),"__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ tree constructor = build_constructor(type_tree, init);
+ if (constructor == error_mark_node)
+ return error_mark_node;
+ if (!copy_to_heap)
+ TREE_CONSTANT(constructor) = 1;
+
+ if (set == NULL_TREE)
+ return constructor;
+ else
+ return build2(COMPOUND_EXPR, type_tree, set, constructor);
+}
+
+// Make a slice composite literal. This is used by the type
+// descriptor code.
+
+Expression*
+Expression::make_slice_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ go_assert(type->is_open_array_type());
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Construct a map.
+
+class Map_construction_expression : public Expression
+{
+ public:
+ Map_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_MAP_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { go_assert(vals == NULL || vals->size() % 2 == 0); }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Map_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the map to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Map_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Final type determination.
+
+void
+Map_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ Type_context key_context(mt->key_type(), false);
+ Type_context val_context(mt->val_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ (*pv)->determine_type(&key_context);
+ ++pv;
+ (*pv)->determine_type(&val_context);
+ }
+}
+
+// Check types.
+
+void
+Map_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ int i = 0;
+ Type* key_type = mt->key_type();
+ Type* val_type = mt->val_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (!Type::are_assignable(key_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d key in map construction",
+ i + 1);
+ this->set_is_error();
+ }
+ ++pv;
+ if (!Type::are_assignable(val_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ ("incompatible type for element %d value "
+ "in map construction"),
+ i + 1);
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree for constructing a map.
+
+tree
+Map_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Map_type* mt = this->type_->map_type();
+
+ // Build a struct to hold the key and value.
+ tree struct_type = make_node(RECORD_TYPE);
+
+ Type* key_type = mt->key_type();
+ tree id = get_identifier("__key");
+ tree key_type_tree = key_type->get_tree(gogo);
+ if (key_type_tree == error_mark_node)
+ return error_mark_node;
+ tree key_field = build_decl(loc, FIELD_DECL, id, key_type_tree);
+ DECL_CONTEXT(key_field) = struct_type;
+ TYPE_FIELDS(struct_type) = key_field;
+
+ Type* val_type = mt->val_type();
+ id = get_identifier("__val");
+ tree val_type_tree = val_type->get_tree(gogo);
+ if (val_type_tree == error_mark_node)
+ return error_mark_node;
+ tree val_field = build_decl(loc, FIELD_DECL, id, val_type_tree);
+ DECL_CONTEXT(val_field) = struct_type;
+ DECL_CHAIN(key_field) = val_field;
+
+ layout_type(struct_type);
+
+ bool is_constant = true;
+ size_t i = 0;
+ tree valaddr;
+ tree make_tmp;
+
+ if (this->vals_ == NULL || this->vals_->empty())
+ {
+ valaddr = null_pointer_node;
+ make_tmp = NULL_TREE;
+ }
+ else
+ {
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ this->vals_->size() / 2);
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ bool one_is_constant = true;
+
+ VEC(constructor_elt,gc)* one = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = key_field;
+ tree val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, key_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ ++pv;
+
+ elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = val_field;
+ val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, val_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(struct_type, one);
+ if (one_is_constant)
+ TREE_CONSTANT(elt->value) = 1;
+ else
+ is_constant = false;
+ }
+
+ tree index_type = build_index_type(size_int(i - 1));
+ tree array_type = build_array_type(struct_type, index_type);
+ tree init = build_constructor(array_type, values);
+ if (is_constant)
+ TREE_CONSTANT(init) = 1;
+ tree tmp;
+ if (current_function_decl != NULL)
+ {
+ tmp = create_tmp_var(array_type, get_name(array_type));
+ DECL_INITIAL(tmp) = init;
+ make_tmp = fold_build1_loc(loc, DECL_EXPR, void_type_node, tmp);
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ else
+ {
+ tmp = build_decl(loc, VAR_DECL, create_tmp_var_name("M"), array_type);
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (!TREE_CONSTANT(init))
+ make_tmp = fold_build2_loc(loc, INIT_EXPR, void_type_node, tmp,
+ init);
+ else
+ {
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ DECL_INITIAL(tmp) = init;
+ make_tmp = NULL_TREE;
+ }
+ rest_of_decl_compilation(tmp, 1, 0);
+ }
+
+ valaddr = build_fold_addr_expr(tmp);
+ }
+
+ tree descriptor = gogo->map_descriptor(mt);
+
+ tree type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ static tree construct_map_fndecl;
+ tree call = Gogo::call_builtin(&construct_map_fndecl,
+ loc,
+ "__go_construct_map",
+ 6,
+ type_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ sizetype,
+ size_int(i),
+ sizetype,
+ TYPE_SIZE_UNIT(struct_type),
+ sizetype,
+ byte_position(val_field),
+ sizetype,
+ TYPE_SIZE_UNIT(TREE_TYPE(val_field)),
+ const_ptr_type_node,
+ fold_convert(const_ptr_type_node, valaddr));
+ if (call == error_mark_node)
+ return error_mark_node;
+
+ tree ret;
+ if (make_tmp == NULL)
+ ret = call;
+ else
+ ret = fold_build2_loc(loc, COMPOUND_EXPR, type_tree, make_tmp, call);
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Map_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// A general composite literal. This is lowered to a type specific
+// version.
+
+class Composite_literal_expression : public Parser_expression
+{
+ public:
+ Composite_literal_expression(Type* type, int depth, bool has_keys,
+ Expression_list* vals, source_location location)
+ : Parser_expression(EXPRESSION_COMPOSITE_LITERAL, location),
+ type_(type), depth_(depth), vals_(vals), has_keys_(has_keys)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Composite_literal_expression(this->type_, this->depth_,
+ this->has_keys_,
+ (this->vals_ == NULL
+ ? NULL
+ : this->vals_->copy()),
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_struct(Gogo*, Type*);
+
+ Expression*
+ lower_array(Type*);
+
+ Expression*
+ make_array(Type*, Expression_list*);
+
+ Expression*
+ lower_map(Gogo*, Named_object*, Type*);
+
+ // The type of the composite literal.
+ Type* type_;
+ // The depth within a list of composite literals within a composite
+ // literal, when the type is omitted.
+ int depth_;
+ // The values to put in the composite literal.
+ Expression_list* vals_;
+ // If this is true, then VALS_ is a list of pairs: a key and a
+ // value. In an array initializer, a missing key will be NULL.
+ bool has_keys_;
+};
+
+// Traversal.
+
+int
+Composite_literal_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Type::traverse(this->type_, traverse);
+}
+
+// Lower a generic composite literal into a specific version based on
+// the type.
+
+Expression*
+Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ Type* type = this->type_;
+
+ for (int depth = this->depth_; depth > 0; --depth)
+ {
+ if (type->array_type() != NULL)
+ type = type->array_type()->element_type();
+ else if (type->map_type() != NULL)
+ type = type->map_type()->val_type();
+ else
+ {
+ if (!type->is_error())
+ error_at(this->location(),
+ ("may only omit types within composite literals "
+ "of slice, array, or map type"));
+ return Expression::make_error(this->location());
+ }
+ }
+
+ if (type->is_error())
+ return Expression::make_error(this->location());
+ else if (type->struct_type() != NULL)
+ return this->lower_struct(gogo, type);
+ else if (type->array_type() != NULL)
+ return this->lower_array(type);
+ else if (type->map_type() != NULL)
+ return this->lower_map(gogo, function, type);
+ else
+ {
+ error_at(this->location(),
+ ("expected struct, slice, array, or map type "
+ "for composite literal"));
+ return Expression::make_error(this->location());
+ }
+}
+
+// Lower a struct composite literal.
+
+Expression*
+Composite_literal_expression::lower_struct(Gogo* gogo, Type* type)
+{
+ source_location location = this->location();
+ Struct_type* st = type->struct_type();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return new Struct_construction_expression(type, this->vals_, location);
+
+ size_t field_count = st->field_count();
+ std::vector<Expression*> vals(field_count);
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* name_expr = *p;
+
+ ++p;
+ go_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (name_expr == NULL)
+ {
+ error_at(val->location(), "mixture of field and value initializers");
+ return Expression::make_error(location);
+ }
+
+ bool bad_key = false;
+ std::string name;
+ const Named_object* no = NULL;
+ switch (name_expr->classification())
+ {
+ case EXPRESSION_UNKNOWN_REFERENCE:
+ name = name_expr->unknown_expression()->name();
+ break;
+
+ case EXPRESSION_CONST_REFERENCE:
+ no = static_cast<Const_expression*>(name_expr)->named_object();
+ break;
+
+ case EXPRESSION_TYPE:
+ {
+ Type* t = name_expr->type();
+ Named_type* nt = t->named_type();
+ if (nt == NULL)
+ bad_key = true;
+ else
+ no = nt->named_object();
+ }
+ break;
+
+ case EXPRESSION_VAR_REFERENCE:
+ no = name_expr->var_expression()->named_object();
+ break;
+
+ case EXPRESSION_FUNC_REFERENCE:
+ no = name_expr->func_expression()->named_object();
+ break;
+
+ case EXPRESSION_UNARY:
+ // If there is a local variable around with the same name as
+ // the field, and this occurs in the closure, then the
+ // parser may turn the field reference into an indirection
+ // through the closure. FIXME: This is a mess.
+ {
+ bad_key = true;
+ Unary_expression* ue = static_cast<Unary_expression*>(name_expr);
+ if (ue->op() == OPERATOR_MULT)
+ {
+ Field_reference_expression* fre =
+ ue->operand()->field_reference_expression();
+ if (fre != NULL)
+ {
+ Struct_type* st =
+ fre->expr()->type()->deref()->struct_type();
+ if (st != NULL)
+ {
+ const Struct_field* sf = st->field(fre->field_index());
+ name = sf->field_name();
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", fre->field_index());
+ size_t buflen = strlen(buf);
+ if (name.compare(name.length() - buflen, buflen, buf)
+ == 0)
+ {
+ name = name.substr(0, name.length() - buflen);
+ bad_key = false;
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ bad_key = true;
+ break;
+ }
+ if (bad_key)
+ {
+ error_at(name_expr->location(), "expected struct field name");
+ return Expression::make_error(location);
+ }
+
+ if (no != NULL)
+ {
+ name = no->name();
+
+ // A predefined name won't be packed. If it starts with a
+ // lower case letter we need to check for that case, because
+ // the field name will be packed.
+ if (!Gogo::is_hidden_name(name)
+ && name[0] >= 'a'
+ && name[0] <= 'z')
+ {
+ Named_object* gno = gogo->lookup_global(name.c_str());
+ if (gno == no)
+ name = gogo->pack_hidden_name(name, false);
+ }
+ }
+
+ unsigned int index;
+ const Struct_field* sf = st->find_local_field(name, &index);
+ if (sf == NULL)
+ {
+ error_at(name_expr->location(), "unknown field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+ if (vals[index] != NULL)
+ {
+ error_at(name_expr->location(),
+ "duplicate value for field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+
+ vals[index] = val;
+ }
+
+ Expression_list* list = new Expression_list;
+ list->reserve(field_count);
+ for (size_t i = 0; i < field_count; ++i)
+ list->push_back(vals[i]);
+
+ return new Struct_construction_expression(type, list, location);
+}
+
+// Lower an array composite literal.
+
+Expression*
+Composite_literal_expression::lower_array(Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return this->make_array(type, this->vals_);
+
+ std::vector<Expression*> vals;
+ vals.reserve(this->vals_->size());
+ unsigned long index = 0;
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* index_expr = *p;
+
+ ++p;
+ go_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (index_expr != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ Type* dummy;
+ if (!index_expr->integer_constant_value(true, ival, &dummy))
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(),
+ "index expression is not integer constant");
+ return Expression::make_error(location);
+ }
+
+ if (mpz_sgn(ival) < 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index expression is negative");
+ return Expression::make_error(location);
+ }
+
+ index = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, index) != 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index value overflow");
+ return Expression::make_error(location);
+ }
+
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ bool ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ if (!ok)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index value overflow");
+ return Expression::make_error(location);
+ }
+
+ mpz_clear(ival);
+
+ // FIXME: Our representation isn't very good; this avoids
+ // thrashing.
+ if (index > 0x1000000)
+ {
+ error_at(index_expr->location(), "index too large for compiler");
+ return Expression::make_error(location);
+ }
+ }
+
+ if (index == vals.size())
+ vals.push_back(val);
+ else
+ {
+ if (index > vals.size())
+ {
+ vals.reserve(index + 32);
+ vals.resize(index + 1, static_cast<Expression*>(NULL));
+ }
+ if (vals[index] != NULL)
+ {
+ error_at((index_expr != NULL
+ ? index_expr->location()
+ : val->location()),
+ "duplicate value for index %lu",
+ index);
+ return Expression::make_error(location);
+ }
+ vals[index] = val;
+ }
+
+ ++index;
+ }
+
+ size_t size = vals.size();
+ Expression_list* list = new Expression_list;
+ list->reserve(size);
+ for (size_t i = 0; i < size; ++i)
+ list->push_back(vals[i]);
+
+ return this->make_array(type, list);
+}
+
+// Actually build the array composite literal. This handles
+// [...]{...}.
+
+Expression*
+Composite_literal_expression::make_array(Type* type, Expression_list* vals)
+{
+ source_location location = this->location();
+ Array_type* at = type->array_type();
+ if (at->length() != NULL && at->length()->is_nil_expression())
+ {
+ size_t size = vals == NULL ? 0 : vals->size();
+ mpz_t vlen;
+ mpz_init_set_ui(vlen, size);
+ Expression* elen = Expression::make_integer(&vlen, NULL, location);
+ mpz_clear(vlen);
+ at = Type::make_array_type(at->element_type(), elen);
+ type = at;
+ }
+ if (at->length() != NULL)
+ return new Fixed_array_construction_expression(type, vals, location);
+ else
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Lower a map composite literal.
+
+Expression*
+Composite_literal_expression::lower_map(Gogo* gogo, Named_object* function,
+ Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ != NULL)
+ {
+ if (!this->has_keys_)
+ {
+ error_at(location, "map composite literal must have keys");
+ return Expression::make_error(location);
+ }
+
+ for (Expression_list::iterator p = this->vals_->begin();
+ p != this->vals_->end();
+ p += 2)
+ {
+ if (*p == NULL)
+ {
+ ++p;
+ error_at((*p)->location(),
+ "map composite literal must have keys for every value");
+ return Expression::make_error(location);
+ }
+ // Make sure we have lowered the key; it may not have been
+ // lowered in order to handle keys for struct composite
+ // literals. Lower it now to get the right error message.
+ if ((*p)->unknown_expression() != NULL)
+ {
+ (*p)->unknown_expression()->clear_is_composite_literal_key();
+ gogo->lower_expression(function, &*p);
+ go_assert((*p)->is_error_expression());
+ return Expression::make_error(location);
+ }
+ }
+ }
+
+ return new Map_construction_expression(type, this->vals_, location);
+}
+
+// Make a composite literal expression.
+
+Expression*
+Expression::make_composite_literal(Type* type, int depth, bool has_keys,
+ Expression_list* vals,
+ source_location location)
+{
+ return new Composite_literal_expression(type, depth, has_keys, vals,
+ location);
+}
+
+// Return whether this expression is a composite literal.
+
+bool
+Expression::is_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_COMPOSITE_LITERAL:
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return whether this expression is a composite literal which is not
+// constant.
+
+bool
+Expression::is_nonconstant_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ {
+ const Struct_construction_expression *psce =
+ static_cast<const Struct_construction_expression*>(this);
+ return !psce->is_constant_struct();
+ }
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ {
+ const Fixed_array_construction_expression *pace =
+ static_cast<const Fixed_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ {
+ const Open_array_construction_expression *pace =
+ static_cast<const Open_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return true if this is a reference to a local variable.
+
+bool
+Expression::is_local_variable() const
+{
+ const Var_expression* ve = this->var_expression();
+ if (ve == NULL)
+ return false;
+ const Named_object* no = ve->named_object();
+ return (no->is_result_variable()
+ || (no->is_variable() && !no->var_value()->is_global()));
+}
+
+// Class Type_guard_expression.
+
+// Traversal.
+
+int
+Type_guard_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check types of a type guard expression. The expression must have
+// an interface type, but the actual type conversion is checked at run
+// time.
+
+void
+Type_guard_expression::do_check_types(Gogo*)
+{
+ // 6g permits using a type guard with unsafe.pointer; we are
+ // compatible.
+ Type* expr_type = this->expr_->type();
+ if (expr_type->is_unsafe_pointer_type())
+ {
+ if (this->type_->points_to() == NULL
+ && (this->type_->integer_type() == NULL
+ || (this->type_->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (this->type_->is_unsafe_pointer_type())
+ {
+ if (expr_type->points_to() == NULL
+ && (expr_type->integer_type() == NULL
+ || (expr_type->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (expr_type->interface_type() == NULL)
+ {
+ if (!expr_type->is_error() && !this->type_->is_error())
+ this->report_error(_("type assertion only valid for interface types"));
+ this->set_is_error();
+ }
+ else if (this->type_->interface_type() == NULL)
+ {
+ std::string reason;
+ if (!expr_type->interface_type()->implements_interface(this->type_,
+ &reason))
+ {
+ if (!this->type_->is_error())
+ {
+ if (reason.empty())
+ this->report_error(_("impossible type assertion: "
+ "type does not implement interface"));
+ else
+ error_at(this->location(),
+ ("impossible type assertion: "
+ "type does not implement interface (%s)"),
+ reason.c_str());
+ }
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree for a type guard expression.
+
+tree
+Type_guard_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ Type* expr_type = this->expr_->type();
+ if ((this->type_->is_unsafe_pointer_type()
+ && (expr_type->points_to() != NULL
+ || expr_type->integer_type() != NULL))
+ || (expr_type->is_unsafe_pointer_type()
+ && this->type_->points_to() != NULL))
+ return convert_to_pointer(this->type_->get_tree(gogo), expr_tree);
+ else if (expr_type->is_unsafe_pointer_type()
+ && this->type_->integer_type() != NULL)
+ return convert_to_integer(this->type_->get_tree(gogo), expr_tree);
+ else if (this->type_->interface_type() != NULL)
+ return Expression::convert_interface_to_interface(context, this->type_,
+ this->expr_->type(),
+ expr_tree, true,
+ this->location());
+ else
+ return Expression::convert_for_assignment(context, this->type_,
+ this->expr_->type(), expr_tree,
+ this->location());
+}
+
+// Make a type guard expression.
+
+Expression*
+Expression::make_type_guard(Expression* expr, Type* type,
+ source_location location)
+{
+ return new Type_guard_expression(expr, type, location);
+}
+
+// Class Heap_composite_expression.
+
+// When you take the address of a composite literal, it is allocated
+// on the heap. This class implements that.
+
+class Heap_composite_expression : public Expression
+{
+ public:
+ Heap_composite_expression(Expression* expr, source_location location)
+ : Expression(EXPRESSION_HEAP_COMPOSITE, location),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->expr_->type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { this->expr_->determine_type_no_context(); }
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_heap_composite(this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ // We only export global objects, and the parser does not generate
+ // this in global scope.
+ void
+ do_export(Export*) const
+ { go_unreachable(); }
+
+ private:
+ // The composite literal which is being put on the heap.
+ Expression* expr_;
+};
+
+// Return a tree which allocates a composite literal on the heap.
+
+tree
+Heap_composite_expression::do_get_tree(Translate_context* context)
+{
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ tree expr_size = TYPE_SIZE_UNIT(TREE_TYPE(expr_tree));
+ go_assert(TREE_CODE(expr_size) == INTEGER_CST);
+ tree space = context->gogo()->allocate_memory(this->expr_->type(),
+ expr_size, this->location());
+ space = fold_convert(build_pointer_type(TREE_TYPE(expr_tree)), space);
+ space = save_expr(space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree ret = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, ref, expr_tree),
+ space);
+ SET_EXPR_LOCATION(ret, this->location());
+ return ret;
+}
+
+// Allocate a composite literal on the heap.
+
+Expression*
+Expression::make_heap_composite(Expression* expr, source_location location)
+{
+ return new Heap_composite_expression(expr, location);
+}
+
+// Class Receive_expression.
+
+// Return the type of a receive expression.
+
+Type*
+Receive_expression::do_type()
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ return Type::make_error_type();
+ return channel_type->element_type();
+}
+
+// Check types for a receive expression.
+
+void
+Receive_expression::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error())
+ {
+ this->set_is_error();
+ return;
+ }
+ if (type->channel_type() == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return;
+ }
+ if (!type->channel_type()->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return;
+ }
+}
+
+// Get a tree for a receive expression.
+
+tree
+Receive_expression::do_get_tree(Translate_context* context)
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ {
+ go_assert(this->channel_->type()->is_error());
+ return error_mark_node;
+ }
+ Type* element_type = channel_type->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+
+ tree channel = this->channel_->get_tree(context);
+ if (element_type_tree == error_mark_node || channel == error_mark_node)
+ return error_mark_node;
+
+ return Gogo::receive_from_channel(element_type_tree, channel,
+ this->for_select_, this->location());
+}
+
+// Make a receive expression.
+
+Receive_expression*
+Expression::make_receive(Expression* channel, source_location location)
+{
+ return new Receive_expression(channel, location);
+}
+
+// An expression which evaluates to a pointer to the type descriptor
+// of a type.
+
+class Type_descriptor_expression : public Expression
+{
+ public:
+ Type_descriptor_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE_DESCRIPTOR, location),
+ type_(type)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_type_descriptor_ptr_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->type_->type_descriptor_pointer(context->gogo()); }
+
+ private:
+ // The type for which this is the descriptor.
+ Type* type_;
+};
+
+// Make a type descriptor expression.
+
+Expression*
+Expression::make_type_descriptor(Type* type, source_location location)
+{
+ return new Type_descriptor_expression(type, location);
+}
+
+// An expression which evaluates to some characteristic of a type.
+// This is only used to initialize fields of a type descriptor. Using
+// a new expression class is slightly inefficient but gives us a good
+// separation between the frontend and the middle-end with regard to
+// how types are laid out.
+
+class Type_info_expression : public Expression
+{
+ public:
+ Type_info_expression(Type* type, Type_info type_info)
+ : Expression(EXPRESSION_TYPE_INFO, BUILTINS_LOCATION),
+ type_(type), type_info_(type_info)
+ { }
+
+ protected:
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type for which we are getting information.
+ Type* type_;
+ // What information we want.
+ Type_info type_info_;
+};
+
+// The type is chosen to match what the type descriptor struct
+// expects.
+
+Type*
+Type_info_expression::do_type()
+{
+ switch (this->type_info_)
+ {
+ case TYPE_INFO_SIZE:
+ return Type::lookup_integer_type("uintptr");
+ case TYPE_INFO_ALIGNMENT:
+ case TYPE_INFO_FIELD_ALIGNMENT:
+ return Type::lookup_integer_type("uint8");
+ default:
+ go_unreachable();
+ }
+}
+
+// Return type information in GENERIC.
+
+tree
+Type_info_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ go_assert(val_type_tree != error_mark_node);
+
+ if (this->type_info_ == TYPE_INFO_SIZE)
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ TYPE_SIZE_UNIT(type_tree));
+ else
+ {
+ unsigned int val;
+ if (this->type_info_ == TYPE_INFO_ALIGNMENT)
+ val = go_type_alignment(type_tree);
+ else
+ val = go_field_alignment(type_tree);
+ return build_int_cstu(val_type_tree, val);
+ }
+}
+
+// Make a type info expression.
+
+Expression*
+Expression::make_type_info(Type* type, Type_info type_info)
+{
+ return new Type_info_expression(type, type_info);
+}
+
+// An expression which evaluates to the offset of a field within a
+// struct. This, like Type_info_expression, q.v., is only used to
+// initialize fields of a type descriptor.
+
+class Struct_field_offset_expression : public Expression
+{
+ public:
+ Struct_field_offset_expression(Struct_type* type, const Struct_field* field)
+ : Expression(EXPRESSION_STRUCT_FIELD_OFFSET, BUILTINS_LOCATION),
+ type_(type), field_(field)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::lookup_integer_type("uintptr"); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type of the struct.
+ Struct_type* type_;
+ // The field.
+ const Struct_field* field_;
+};
+
+// Return a struct field offset in GENERIC.
+
+tree
+Struct_field_offset_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ go_assert(val_type_tree != error_mark_node);
+
+ const Struct_field_list* fields = this->type_->fields();
+ tree struct_field_tree = TYPE_FIELDS(type_tree);
+ Struct_field_list::const_iterator p;
+ for (p = fields->begin();
+ p != fields->end();
+ ++p, struct_field_tree = DECL_CHAIN(struct_field_tree))
+ {
+ go_assert(struct_field_tree != NULL_TREE);
+ if (&*p == this->field_)
+ break;
+ }
+ go_assert(&*p == this->field_);
+
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ byte_position(struct_field_tree));
+}
+
+// Make an expression for a struct field offset.
+
+Expression*
+Expression::make_struct_field_offset(Struct_type* type,
+ const Struct_field* field)
+{
+ return new Struct_field_offset_expression(type, field);
+}
+
+// An expression which evaluates to the address of an unnamed label.
+
+class Label_addr_expression : public Expression
+{
+ public:
+ Label_addr_expression(Label* label, source_location location)
+ : Expression(EXPRESSION_LABEL_ADDR, location),
+ label_(label)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_pointer_type(Type::make_void_type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return new Label_addr_expression(this->label_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context* context)
+ {
+ return expr_to_tree(this->label_->get_addr(context, this->location()));
+ }
+
+ private:
+ // The label whose address we are taking.
+ Label* label_;
+};
+
+// Make an expression for the address of an unnamed label.
+
+Expression*
+Expression::make_label_addr(Label* label, source_location location)
+{
+ return new Label_addr_expression(label, location);
+}
+
+// Import an expression. This comes at the end in order to see the
+// various class definitions.
+
+Expression*
+Expression::import_expression(Import* imp)
+{
+ int c = imp->peek_char();
+ if (imp->match_c_string("- ")
+ || imp->match_c_string("! ")
+ || imp->match_c_string("^ "))
+ return Unary_expression::do_import(imp);
+ else if (c == '(')
+ return Binary_expression::do_import(imp);
+ else if (imp->match_c_string("true")
+ || imp->match_c_string("false"))
+ return Boolean_expression::do_import(imp);
+ else if (c == '"')
+ return String_expression::do_import(imp);
+ else if (c == '-' || (c >= '0' && c <= '9'))
+ {
+ // This handles integers, floats and complex constants.
+ return Integer_expression::do_import(imp);
+ }
+ else if (imp->match_c_string("nil"))
+ return Nil_expression::do_import(imp);
+ else if (imp->match_c_string("convert"))
+ return Type_conversion_expression::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected expression");
+ return Expression::make_error(imp->location());
+ }
+}
+
+// Class Expression_list.
+
+// Traverse the list.
+
+int
+Expression_list::traverse(Traverse* traverse)
+{
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p != NULL)
+ {
+ if (Expression::traverse(&*p, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Expression_list*
+Expression_list::copy()
+{
+ Expression_list* ret = new Expression_list();
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p == NULL)
+ ret->push_back(NULL);
+ else
+ ret->push_back((*p)->copy());
+ }
+ return ret;
+}
+
+// Return whether an expression list has an error expression.
+
+bool
+Expression_list::contains_error() const
+{
+ for (Expression_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ if (*p != NULL && (*p)->is_error_expression())
+ return true;
+ return false;
+}
--- /dev/null
+// expressions.cc -- Go frontend expression handling.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "convert.h"
+#include "real.h"
+#include "realmpfr.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "types.h"
+#include "export.h"
+#include "import.h"
+#include "statements.h"
+#include "lex.h"
+#include "expressions.h"
+
+// Class Expression.
+
+Expression::Expression(Expression_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Expression::~Expression()
+{
+}
+
+// If this expression has a constant integer value, return it.
+
+bool
+Expression::integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ return this->do_integer_constant_value(iota_is_constant, val, ptype);
+}
+
+// If this expression has a constant floating point value, return it.
+
+bool
+Expression::float_constant_value(mpfr_t val, Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_float_constant_value(val, ptype))
+ return true;
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ bool ret;
+ if (!this->do_integer_constant_value(false, ival, &t))
+ ret = false;
+ else
+ {
+ mpfr_set_z(val, ival, GMP_RNDN);
+ ret = true;
+ }
+ mpz_clear(ival);
+ return ret;
+}
+
+// If this expression has a constant complex value, return it.
+
+bool
+Expression::complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ *ptype = NULL;
+ if (this->do_complex_constant_value(real, imag, ptype))
+ return true;
+ Type *t;
+ if (this->float_constant_value(real, &t))
+ {
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+ return false;
+}
+
+// Traverse the expressions.
+
+int
+Expression::traverse(Expression** pexpr, Traverse* traverse)
+{
+ Expression* expr = *pexpr;
+ if ((traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
+ {
+ int t = traverse->expression(pexpr);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ return expr->do_traverse(traverse);
+}
+
+// Traverse subexpressions of this expression.
+
+int
+Expression::traverse_subexpressions(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Default implementation for do_traverse for child classes.
+
+int
+Expression::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// This virtual function is called by the parser if the value of this
+// expression is being discarded. By default, we warn. Expressions
+// with side effects override.
+
+void
+Expression::do_discarding_value()
+{
+ this->warn_about_unused_value();
+}
+
+// This virtual function is called to export expressions. This will
+// only be used by expressions which may be constant.
+
+void
+Expression::do_export(Export*) const
+{
+ gcc_unreachable();
+}
+
+// Warn that the value of the expression is not used.
+
+void
+Expression::warn_about_unused_value()
+{
+ warning_at(this->location(), OPT_Wunused_value, "value computed is not used");
+}
+
+// Note that this expression is an error. This is called by children
+// when they discover an error.
+
+void
+Expression::set_is_error()
+{
+ this->classification_ = EXPRESSION_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Expression::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// Set types of variables and constants. This is implemented by the
+// child class.
+
+void
+Expression::determine_type(const Type_context* context)
+{
+ this->do_determine_type(context);
+}
+
+// Set types when there is no context.
+
+void
+Expression::determine_type_no_context()
+{
+ Type_context context;
+ this->do_determine_type(&context);
+}
+
+// Return a tree handling any conversions which must be done during
+// assignment.
+
+tree
+Expression::convert_for_assignment(Translate_context* context, Type* lhs_type,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ if (lhs_type == rhs_type)
+ return rhs_tree;
+
+ if (lhs_type->is_error_type() || rhs_type->is_error_type())
+ return error_mark_node;
+
+ if (lhs_type->is_undefined() || rhs_type->is_undefined())
+ {
+ // Make sure we report the error.
+ lhs_type->base();
+ rhs_type->base();
+ return error_mark_node;
+ }
+
+ if (rhs_tree == error_mark_node || TREE_TYPE(rhs_tree) == error_mark_node)
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ if (lhs_type->interface_type() != NULL)
+ {
+ if (rhs_type->interface_type() == NULL)
+ return Expression::convert_type_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ location);
+ else
+ return Expression::convert_interface_to_interface(context, lhs_type,
+ rhs_type, rhs_tree,
+ false, location);
+ }
+ else if (rhs_type->interface_type() != NULL)
+ return Expression::convert_interface_to_type(context, lhs_type, rhs_type,
+ rhs_tree, location);
+ else if (lhs_type->is_open_array_type()
+ && rhs_type->is_nil_type())
+ {
+ // Assigning nil to an open array.
+ gcc_assert(TREE_CODE(lhs_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
+
+ tree val = build_constructor(lhs_type_tree, init);
+ TREE_CONSTANT(val) = 1;
+
+ return val;
+ }
+ else if (rhs_type->is_nil_type())
+ {
+ // The left hand side should be a pointer type at the tree
+ // level.
+ gcc_assert(POINTER_TYPE_P(lhs_type_tree));
+ return fold_convert(lhs_type_tree, null_pointer_node);
+ }
+ else if (lhs_type_tree == TREE_TYPE(rhs_tree))
+ {
+ // No conversion is needed.
+ return rhs_tree;
+ }
+ else if (POINTER_TYPE_P(lhs_type_tree)
+ || INTEGRAL_TYPE_P(lhs_type_tree)
+ || SCALAR_FLOAT_TYPE_P(lhs_type_tree)
+ || COMPLEX_FLOAT_TYPE_P(lhs_type_tree))
+ return fold_convert_loc(location, lhs_type_tree, rhs_tree);
+ else if (TREE_CODE(lhs_type_tree) == RECORD_TYPE
+ && TREE_CODE(TREE_TYPE(rhs_tree)) == RECORD_TYPE)
+ {
+ // This conversion must be permitted by Go, or we wouldn't have
+ // gotten here.
+ gcc_assert(int_size_in_bytes(lhs_type_tree)
+ == int_size_in_bytes(TREE_TYPE(rhs_tree)));
+ return fold_build1_loc(location, VIEW_CONVERT_EXPR, lhs_type_tree,
+ rhs_tree);
+ }
+ else
+ {
+ gcc_assert(useless_type_conversion_p(lhs_type_tree, TREE_TYPE(rhs_tree)));
+ return rhs_tree;
+ }
+}
+
+// Return a tree for a conversion from a non-interface type to an
+// interface type.
+
+tree
+Expression::convert_type_to_interface(Translate_context* context,
+ Type* lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ // Since RHS_TYPE is a static type, we can create the interface
+ // method table at compile time.
+
+ // When setting an interface to nil, we just set both fields to
+ // NULL.
+ if (rhs_type->is_nil_type())
+ return lhs_type->get_init_tree(gogo, false);
+
+ // This should have been checked already.
+ gcc_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // An interface is a tuple. If LHS_TYPE is an empty interface type,
+ // then the first field is the type descriptor for RHS_TYPE.
+ // Otherwise it is the interface method table for RHS_TYPE.
+ tree first_field_value;
+ if (lhs_is_empty)
+ first_field_value = rhs_type->type_descriptor_pointer(gogo);
+ else
+ {
+ // Build the interface method table for this interface and this
+ // object type: a list of function pointers for each interface
+ // method.
+ Named_type* rhs_named_type = rhs_type->named_type();
+ bool is_pointer = false;
+ if (rhs_named_type == NULL)
+ {
+ rhs_named_type = rhs_type->deref()->named_type();
+ is_pointer = true;
+ }
+ tree method_table;
+ if (rhs_named_type == NULL)
+ method_table = null_pointer_node;
+ else
+ method_table =
+ rhs_named_type->interface_method_table(gogo, lhs_interface_type,
+ is_pointer);
+ first_field_value = fold_convert_loc(location, const_ptr_type_node,
+ method_table);
+ }
+ if (first_field_value == error_mark_node)
+ return error_mark_node;
+
+ // Start building a constructor for the value we will return.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ (lhs_is_empty ? "__type_descriptor" : "__methods")) == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), first_field_value);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ if (rhs_type->points_to() != NULL)
+ {
+ // We are assigning a pointer to the interface; the interface
+ // holds the pointer itself.
+ elt->value = rhs_tree;
+ return build_constructor(lhs_type_tree, init);
+ }
+
+ // We are assigning a non-pointer value to the interface; the
+ // interface gets a copy of the value in the heap.
+
+ tree object_size = TYPE_SIZE_UNIT(TREE_TYPE(rhs_tree));
+
+ tree space = gogo->allocate_memory(rhs_type, object_size, location);
+ space = fold_convert_loc(location, build_pointer_type(TREE_TYPE(rhs_tree)),
+ space);
+ space = save_expr(space);
+
+ tree ref = build_fold_indirect_ref_loc(location, space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ ref, rhs_tree);
+
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), space);
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, set,
+ build_constructor(lhs_type_tree, init));
+}
+
+// Return a tree for the type descriptor of RHS_TREE, which has
+// interface type RHS_TYPE. If RHS_TREE is nil the result will be
+// NULL.
+
+tree
+Expression::get_interface_type_descriptor(Translate_context*,
+ Type* rhs_type, tree rhs_tree,
+ source_location location)
+{
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = TYPE_FIELDS(rhs_type_tree);
+ tree v = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+ if (rhs_type->interface_type()->is_empty())
+ {
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)),
+ "__type_descriptor") == 0);
+ return v;
+ }
+
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__methods")
+ == 0);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(v)));
+ v = save_expr(v);
+ tree v1 = build_fold_indirect_ref_loc(location, v);
+ gcc_assert(TREE_CODE(TREE_TYPE(v1)) == RECORD_TYPE);
+ tree f = TYPE_FIELDS(TREE_TYPE(v1));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(f)), "__type_descriptor")
+ == 0);
+ v1 = build3(COMPONENT_REF, TREE_TYPE(f), v1, f, NULL_TREE);
+
+ tree eq = fold_build2_loc(location, EQ_EXPR, boolean_type_node, v,
+ fold_convert_loc(location, TREE_TYPE(v),
+ null_pointer_node));
+ tree n = fold_convert_loc(location, TREE_TYPE(v1), null_pointer_node);
+ return fold_build3_loc(location, COND_EXPR, TREE_TYPE(v1),
+ eq, n, v1);
+}
+
+// Return a tree for the conversion of an interface type to an
+// interface type.
+
+tree
+Expression::convert_interface_to_interface(Translate_context* context,
+ Type *lhs_type, Type *rhs_type,
+ tree rhs_tree, bool for_type_guard,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ Interface_type* lhs_interface_type = lhs_type->interface_type();
+ bool lhs_is_empty = lhs_interface_type->is_empty();
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // In the general case this requires runtime examination of the type
+ // method table to match it up with the interface methods.
+
+ // FIXME: If all of the methods in the right hand side interface
+ // also appear in the left hand side interface, then we don't need
+ // to do a runtime check, although we still need to build a new
+ // method table.
+
+ // Get the type descriptor for the right hand side. This will be
+ // NULL for a nil interface.
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ // The result is going to be a two element constructor.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(lhs_type_tree);
+ elt->index = field;
+
+ if (for_type_guard)
+ {
+ // A type assertion fails when converting a nil interface.
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree assert_interface_decl;
+ tree call = Gogo::call_builtin(&assert_interface_decl,
+ location,
+ "__go_assert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(assert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+ else if (lhs_is_empty)
+ {
+ // A convertion to an empty interface always succeeds, and the
+ // first field is just the type descriptor of the object.
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__type_descriptor") == 0);
+ gcc_assert(TREE_TYPE(field) == TREE_TYPE(rhs_type_descriptor));
+ elt->value = rhs_type_descriptor;
+ }
+ else
+ {
+ // A conversion to a non-empty interface may fail, but unlike a
+ // type assertion converting nil will always succeed.
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods")
+ == 0);
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+ static tree convert_interface_decl;
+ tree call = Gogo::call_builtin(&convert_interface_decl,
+ location,
+ "__go_convert_interface",
+ 2,
+ ptr_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This will panic if the interface conversion fails.
+ TREE_NOTHROW(convert_interface_decl) = 0;
+ elt->value = fold_convert_loc(location, TREE_TYPE(field), call);
+ }
+
+ // The second field is simply the object pointer.
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+ elt->index = field;
+
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ elt->value = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ return build_constructor(lhs_type_tree, init);
+}
+
+// Return a tree for the conversion of an interface type to a
+// non-interface type.
+
+tree
+Expression::convert_interface_to_type(Translate_context* context,
+ Type *lhs_type, Type* rhs_type,
+ tree rhs_tree, source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree rhs_type_tree = TREE_TYPE(rhs_tree);
+
+ tree lhs_type_tree = lhs_type->get_tree(gogo);
+ if (lhs_type_tree == error_mark_node)
+ return error_mark_node;
+
+ // Call a function to check that the type is valid. The function
+ // will panic with an appropriate runtime type error if the type is
+ // not valid.
+
+ tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo);
+
+ if (!DECL_P(rhs_tree))
+ rhs_tree = save_expr(rhs_tree);
+
+ tree rhs_type_descriptor =
+ Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
+ location);
+
+ tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo);
+
+ static tree check_interface_type_decl;
+ tree call = Gogo::call_builtin(&check_interface_type_decl,
+ location,
+ "__go_check_interface_type",
+ 3,
+ void_type_node,
+ TREE_TYPE(lhs_type_descriptor),
+ lhs_type_descriptor,
+ TREE_TYPE(rhs_type_descriptor),
+ rhs_type_descriptor,
+ TREE_TYPE(rhs_inter_descriptor),
+ rhs_inter_descriptor);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This call will panic if the conversion is invalid.
+ TREE_NOTHROW(check_interface_type_decl) = 0;
+
+ // If the call succeeds, pull out the value.
+ gcc_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
+ tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
+ tree val = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
+ NULL_TREE);
+
+ // If the value is a pointer, then it is the value we want.
+ // Otherwise it points to the value.
+ if (lhs_type->points_to() == NULL)
+ {
+ val = fold_convert_loc(location, build_pointer_type(lhs_type_tree), val);
+ val = build_fold_indirect_ref_loc(location, val);
+ }
+
+ return build2(COMPOUND_EXPR, lhs_type_tree, call,
+ fold_convert_loc(location, lhs_type_tree, val));
+}
+
+// Convert an expression to a tree. This is implemented by the child
+// class. Not that it is not in general safe to call this multiple
+// times for a single expression, but that we don't catch such errors.
+
+tree
+Expression::get_tree(Translate_context* context)
+{
+ // The child may have marked this expression as having an error.
+ if (this->classification_ == EXPRESSION_ERROR)
+ return error_mark_node;
+
+ return this->do_get_tree(context);
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::integer_constant_tree(mpz_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ return double_int_to_tree(type,
+ mpz_get_double_int(type, val, true));
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree ret = Expression::float_constant_tree(fval, type);
+ mpfr_clear(fval);
+ return ret;
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ mpfr_t fval;
+ mpfr_init_set_z(fval, val, GMP_RNDN);
+ tree real = Expression::float_constant_tree(fval, TREE_TYPE(type));
+ mpfr_clear(fval);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, real, imag);
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree for VAL in TYPE.
+
+tree
+Expression::float_constant_tree(mpfr_t val, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, val, GMP_RNDN);
+ tree ret = Expression::integer_constant_tree(ival, type);
+ mpz_clear(ival);
+ return ret;
+ }
+ else if (TREE_CODE(type) == REAL_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, type, GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(type), &r1);
+ return build_real(type, r2);
+ }
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, val, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+ tree imag = build_real_from_int_cst(TREE_TYPE(type),
+ integer_zero_node);
+ return build_complex(type, build_real(TREE_TYPE(type), r2), imag);
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree for REAL/IMAG in TYPE.
+
+tree
+Expression::complex_constant_tree(mpfr_t real, mpfr_t imag, tree type)
+{
+ if (type == error_mark_node)
+ return error_mark_node;
+ else if (TREE_CODE(type) == INTEGER_TYPE || TREE_CODE(type) == REAL_TYPE)
+ return Expression::float_constant_tree(real, type);
+ else if (TREE_CODE(type) == COMPLEX_TYPE)
+ {
+ REAL_VALUE_TYPE r1;
+ real_from_mpfr(&r1, real, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r2;
+ real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
+
+ REAL_VALUE_TYPE r3;
+ real_from_mpfr(&r3, imag, TREE_TYPE(type), GMP_RNDN);
+ REAL_VALUE_TYPE r4;
+ real_convert(&r4, TYPE_MODE(TREE_TYPE(type)), &r3);
+
+ return build_complex(type, build_real(TREE_TYPE(type), r2),
+ build_real(TREE_TYPE(type), r4));
+ }
+ else
+ gcc_unreachable();
+}
+
+// Return a tree which evaluates to true if VAL, of arbitrary integer
+// type, is negative or is more than the maximum value of BOUND_TYPE.
+// If SOFAR is not NULL, it is or'red into the result. The return
+// value may be NULL if SOFAR is NULL.
+
+tree
+Expression::check_bounds(tree val, tree bound_type, tree sofar,
+ source_location loc)
+{
+ tree val_type = TREE_TYPE(val);
+ tree ret = NULL_TREE;
+
+ if (!TYPE_UNSIGNED(val_type))
+ {
+ ret = fold_build2_loc(loc, LT_EXPR, boolean_type_node, val,
+ build_int_cst(val_type, 0));
+ if (ret == boolean_false_node)
+ ret = NULL_TREE;
+ }
+
+ if ((TYPE_UNSIGNED(val_type) && !TYPE_UNSIGNED(bound_type))
+ || TYPE_SIZE(val_type) > TYPE_SIZE(bound_type))
+ {
+ tree max = TYPE_MAX_VALUE(bound_type);
+ tree big = fold_build2_loc(loc, GT_EXPR, boolean_type_node, val,
+ fold_convert_loc(loc, val_type, max));
+ if (big == boolean_false_node)
+ ;
+ else if (ret == NULL_TREE)
+ ret = big;
+ else
+ ret = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ ret, big);
+ }
+
+ if (ret == NULL_TREE)
+ return sofar;
+ else if (sofar == NULL_TREE)
+ return ret;
+ else
+ return fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ sofar, ret);
+}
+
+// Error expressions. This are used to avoid cascading errors.
+
+class Error_expression : public Expression
+{
+ public:
+ Error_expression(source_location location)
+ : Expression(EXPRESSION_ERROR, location)
+ { }
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const
+ {
+ mpz_set_ui(val, 0);
+ return true;
+ }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const
+ {
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ return true;
+ }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ return true;
+ }
+
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type()
+ { return Type::make_error_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return error_mark_node; }
+};
+
+Expression*
+Expression::make_error(source_location location)
+{
+ return new Error_expression(location);
+}
+
+// An expression which is really a type. This is used during parsing.
+// It is an error if these survive after lowering.
+
+class
+Type_expression : public Expression
+{
+ public:
+ Type_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*)
+ { this->report_error(_("invalid use of type")); }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The type which we are representing as an expression.
+ Type* type_;
+};
+
+Expression*
+Expression::make_type(Type* type, source_location location)
+{
+ return new Type_expression(type, location);
+}
+
+// Class Parser_expression.
+
+Type*
+Parser_expression::do_type()
+{
+ // We should never really ask for the type of a Parser_expression.
+ // However, it can happen, at least when we have an invalid const
+ // whose initializer refers to the const itself. In that case we
+ // may ask for the type when lowering the const itself.
+ gcc_assert(saw_errors());
+ return Type::make_error_type();
+}
+
+// Class Var_expression.
+
+// Lower a variable expression. Here we just make sure that the
+// initialization expression of the variable has been lowered. This
+// ensures that we will be able to determine the type of the variable
+// if necessary.
+
+Expression*
+Var_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->variable_->is_variable())
+ {
+ Variable* var = this->variable_->var_value();
+ // This is either a local variable or a global variable. A
+ // reference to a variable which is local to an enclosing
+ // function will be a reference to a field in a closure.
+ if (var->is_global())
+ function = NULL;
+ var->lower_init_expression(gogo, function);
+ }
+ return this;
+}
+
+// Return the type of a reference to a variable.
+
+Type*
+Var_expression::do_type()
+{
+ if (this->variable_->is_variable())
+ return this->variable_->var_value()->type();
+ else if (this->variable_->is_result_variable())
+ return this->variable_->result_var_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Determine the type of a reference to a variable.
+
+void
+Var_expression::do_determine_type(const Type_context*)
+{
+ if (this->variable_->is_variable())
+ this->variable_->var_value()->determine_type();
+}
+
+// Something takes the address of this variable. This means that we
+// may want to move the variable onto the heap.
+
+void
+Var_expression::do_address_taken(bool escapes)
+{
+ if (!escapes)
+ ;
+ else if (this->variable_->is_variable())
+ this->variable_->var_value()->set_address_taken();
+ else if (this->variable_->is_result_variable())
+ this->variable_->result_var_value()->set_address_taken();
+ else
+ gcc_unreachable();
+}
+
+// Get the tree for a reference to a variable.
+
+tree
+Var_expression::do_get_tree(Translate_context* context)
+{
+ return this->variable_->get_tree(context->gogo(), context->function());
+}
+
+// Make a reference to a variable in an expression.
+
+Expression*
+Expression::make_var_reference(Named_object* var, source_location location)
+{
+ if (var->is_sink())
+ return Expression::make_sink(location);
+
+ // FIXME: Creating a new object for each reference to a variable is
+ // wasteful.
+ return new Var_expression(var, location);
+}
+
+// Class Temporary_reference_expression.
+
+// The type.
+
+Type*
+Temporary_reference_expression::do_type()
+{
+ return this->statement_->type();
+}
+
+// Called if something takes the address of this temporary variable.
+// We never have to move temporary variables to the heap, but we do
+// need to know that they must live in the stack rather than in a
+// register.
+
+void
+Temporary_reference_expression::do_address_taken(bool)
+{
+ this->statement_->set_is_address_taken();
+}
+
+// Get a tree referring to the variable.
+
+tree
+Temporary_reference_expression::do_get_tree(Translate_context*)
+{
+ return this->statement_->get_decl();
+}
+
+// Make a reference to a temporary variable.
+
+Expression*
+Expression::make_temporary_reference(Temporary_statement* statement,
+ source_location location)
+{
+ return new Temporary_reference_expression(statement, location);
+}
+
+// A sink expression--a use of the blank identifier _.
+
+class Sink_expression : public Expression
+{
+ public:
+ Sink_expression(source_location location)
+ : Expression(EXPRESSION_SINK, location),
+ type_(NULL), var_(NULL_TREE)
+ { }
+
+ protected:
+ void
+ do_discarding_value()
+ { }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return new Sink_expression(this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type of this sink variable.
+ Type* type_;
+ // The temporary variable we generate.
+ tree var_;
+};
+
+// Return the type of a sink expression.
+
+Type*
+Sink_expression::do_type()
+{
+ if (this->type_ == NULL)
+ return Type::make_sink_type();
+ return this->type_;
+}
+
+// Determine the type of a sink expression.
+
+void
+Sink_expression::do_determine_type(const Type_context* context)
+{
+ if (context->type != NULL)
+ this->type_ = context->type;
+}
+
+// Return a temporary variable for a sink expression. This will
+// presumably be a write-only variable which the middle-end will drop.
+
+tree
+Sink_expression::do_get_tree(Translate_context* context)
+{
+ if (this->var_ == NULL_TREE)
+ {
+ gcc_assert(this->type_ != NULL && !this->type_->is_sink_type());
+ this->var_ = create_tmp_var(this->type_->get_tree(context->gogo()),
+ "blank");
+ }
+ return this->var_;
+}
+
+// Make a sink expression.
+
+Expression*
+Expression::make_sink(source_location location)
+{
+ return new Sink_expression(location);
+}
+
+// Class Func_expression.
+
+// FIXME: Can a function expression appear in a constant expression?
+// The value is unchanging. Initializing a constant to the address of
+// a function seems like it could work, though there might be little
+// point to it.
+
+// Traversal.
+
+int
+Func_expression::do_traverse(Traverse* traverse)
+{
+ return (this->closure_ == NULL
+ ? TRAVERSE_CONTINUE
+ : Expression::traverse(&this->closure_, traverse));
+}
+
+// Return the type of a function expression.
+
+Type*
+Func_expression::do_type()
+{
+ if (this->function_->is_function())
+ return this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ return this->function_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Get the tree for a function expression without evaluating the
+// closure.
+
+tree
+Func_expression::get_tree_without_closure(Gogo* gogo)
+{
+ Function_type* fntype;
+ if (this->function_->is_function())
+ fntype = this->function_->func_value()->type();
+ else if (this->function_->is_function_declaration())
+ fntype = this->function_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+
+ // Builtin functions are handled specially by Call_expression. We
+ // can't take their address.
+ if (fntype->is_builtin())
+ {
+ error_at(this->location(), "invalid use of special builtin function %qs",
+ this->function_->name().c_str());
+ return error_mark_node;
+ }
+
+ Named_object* no = this->function_;
+
+ tree id = no->get_id(gogo);
+ if (id == error_mark_node)
+ return error_mark_node;
+
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(gogo, no, id);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
+ else
+ gcc_unreachable();
+
+ if (fndecl == error_mark_node)
+ return error_mark_node;
+
+ return build_fold_addr_expr_loc(this->location(), fndecl);
+}
+
+// Get the tree for a function expression. This is used when we take
+// the address of a function rather than simply calling it. If the
+// function has a closure, we must use a trampoline.
+
+tree
+Func_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ tree fnaddr = this->get_tree_without_closure(gogo);
+ if (fnaddr == error_mark_node)
+ return error_mark_node;
+
+ gcc_assert(TREE_CODE(fnaddr) == ADDR_EXPR
+ && TREE_CODE(TREE_OPERAND(fnaddr, 0)) == FUNCTION_DECL);
+ TREE_ADDRESSABLE(TREE_OPERAND(fnaddr, 0)) = 1;
+
+ // For a normal non-nested function call, that is all we have to do.
+ if (!this->function_->is_function()
+ || this->function_->func_value()->enclosing() == NULL)
+ {
+ gcc_assert(this->closure_ == NULL);
+ return fnaddr;
+ }
+
+ // For a nested function call, we have to always allocate a
+ // trampoline. If we don't always allocate, then closures will not
+ // be reliably distinct.
+ Expression* closure = this->closure_;
+ tree closure_tree;
+ if (closure == NULL)
+ closure_tree = null_pointer_node;
+ else
+ {
+ // Get the value of the closure. This will be a pointer to
+ // space allocated on the heap.
+ closure_tree = closure->get_tree(context);
+ if (closure_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(closure_tree)));
+ }
+
+ // Now we need to build some code on the heap. This code will load
+ // the static chain pointer with the closure and then jump to the
+ // body of the function. The normal gcc approach is to build the
+ // code on the stack. Unfortunately we can not do that, as Go
+ // permits us to return the function pointer.
+
+ return gogo->make_trampoline(fnaddr, closure_tree, this->location());
+}
+
+// Make a reference to a function in an expression.
+
+Expression*
+Expression::make_func_reference(Named_object* function, Expression* closure,
+ source_location location)
+{
+ return new Func_expression(function, closure, location);
+}
+
+// Class Unknown_expression.
+
+// Return the name of an unknown expression.
+
+const std::string&
+Unknown_expression::name() const
+{
+ return this->named_object_->name();
+}
+
+// Lower a reference to an unknown name.
+
+Expression*
+Unknown_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Named_object* no = this->named_object_;
+ Named_object* real;
+ if (!no->is_unknown())
+ real = no;
+ else
+ {
+ real = no->unknown_value()->real_named_object();
+ if (real == NULL)
+ {
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined name %qs",
+ this->named_object_->message_name().c_str());
+ return Expression::make_error(location);
+ }
+ }
+ switch (real->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(real, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(real->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "reference to undefined type %qs",
+ real->message_name().c_str());
+ return Expression::make_error(location);
+ case Named_object::NAMED_OBJECT_VAR:
+ return Expression::make_var_reference(real, location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(real, NULL, location);
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (this->is_composite_literal_key_)
+ return this;
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Make a reference to an unknown name.
+
+Expression*
+Expression::make_unknown_reference(Named_object* no, source_location location)
+{
+ gcc_assert(no->resolve()->is_unknown());
+ return new Unknown_expression(no, location);
+}
+
+// A boolean expression.
+
+class Boolean_expression : public Expression
+{
+ public:
+ Boolean_expression(bool val, source_location location)
+ : Expression(EXPRESSION_BOOLEAN, location),
+ val_(val), type_(NULL)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->val_ ? boolean_true_node : boolean_false_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string(this->val_ ? "true" : "false"); }
+
+ private:
+ // The constant.
+ bool val_;
+ // The type as determined by context.
+ Type* type_;
+};
+
+// Get the type.
+
+Type*
+Boolean_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_boolean_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+Boolean_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_bool_type();
+}
+
+// Import a boolean constant.
+
+Expression*
+Boolean_expression::do_import(Import* imp)
+{
+ if (imp->peek_char() == 't')
+ {
+ imp->require_c_string("true");
+ return Expression::make_boolean(true, imp->location());
+ }
+ else
+ {
+ imp->require_c_string("false");
+ return Expression::make_boolean(false, imp->location());
+ }
+}
+
+// Make a boolean expression.
+
+Expression*
+Expression::make_boolean(bool val, source_location location)
+{
+ return new Boolean_expression(val, location);
+}
+
+// Class String_expression.
+
+// Get the type.
+
+Type*
+String_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_string_type();
+ return this->type_;
+}
+
+// Set the type from the context.
+
+void
+String_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL && context->type->is_string_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_string_type();
+}
+
+// Build a string constant.
+
+tree
+String_expression::do_get_tree(Translate_context* context)
+{
+ return context->gogo()->go_string_constant_tree(this->val_);
+}
+
+// Export a string expression.
+
+void
+String_expression::do_export(Export* exp) const
+{
+ std::string s;
+ s.reserve(this->val_.length() * 4 + 2);
+ s += '"';
+ for (std::string::const_iterator p = this->val_.begin();
+ p != this->val_.end();
+ ++p)
+ {
+ if (*p == '\\' || *p == '"')
+ {
+ s += '\\';
+ s += *p;
+ }
+ else if (*p >= 0x20 && *p < 0x7f)
+ s += *p;
+ else if (*p == '\n')
+ s += "\\n";
+ else if (*p == '\t')
+ s += "\\t";
+ else
+ {
+ s += "\\x";
+ unsigned char c = *p;
+ unsigned int dig = c >> 4;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ dig = c & 0xf;
+ s += dig < 10 ? '0' + dig : 'A' + dig - 10;
+ }
+ }
+ s += '"';
+ exp->write_string(s);
+}
+
+// Import a string expression.
+
+Expression*
+String_expression::do_import(Import* imp)
+{
+ imp->require_c_string("\"");
+ std::string val;
+ while (true)
+ {
+ int c = imp->get_char();
+ if (c == '"' || c == -1)
+ break;
+ if (c != '\\')
+ val += static_cast<char>(c);
+ else
+ {
+ c = imp->get_char();
+ if (c == '\\' || c == '"')
+ val += static_cast<char>(c);
+ else if (c == 'n')
+ val += '\n';
+ else if (c == 't')
+ val += '\t';
+ else if (c == 'x')
+ {
+ c = imp->get_char();
+ unsigned int vh = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ c = imp->get_char();
+ unsigned int vl = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
+ char v = (vh << 4) | vl;
+ val += v;
+ }
+ else
+ {
+ error_at(imp->location(), "bad string constant");
+ return Expression::make_error(imp->location());
+ }
+ }
+ }
+ return Expression::make_string(val, imp->location());
+}
+
+// Make a string expression.
+
+Expression*
+Expression::make_string(const std::string& val, source_location location)
+{
+ return new String_expression(val, location);
+}
+
+// Make an integer expression.
+
+class Integer_expression : public Expression
+{
+ public:
+ Integer_expression(const mpz_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_INTEGER, location),
+ type_(type)
+ { mpz_init_set(this->val_, *val); }
+
+ static Expression*
+ do_import(Import*);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpz_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_integer(Export* exp, const mpz_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type** ptype) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context* context);
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_integer(&this->val_, this->type_,
+ this->location()); }
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The integer value.
+ mpz_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Return an integer constant value.
+
+bool
+Integer_expression::do_integer_constant_value(bool, mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpz_set(val, this->val_);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract integer type.
+
+Type*
+Integer_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_integer_type();
+ return this->type_;
+}
+
+// Set the type of the integer value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Integer_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_integer_type("int");
+}
+
+// Return true if the integer VAL fits in the range of the type TYPE.
+// Otherwise give an error and return false. TYPE may be NULL.
+
+bool
+Integer_expression::check_constant(mpz_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Integer_type* itype = type->integer_type();
+ if (itype == NULL || itype->is_abstract())
+ return true;
+
+ int bits = mpz_sizeinbase(val, 2);
+
+ if (itype->is_unsigned())
+ {
+ // For an unsigned type we can only accept a nonnegative number,
+ // and we must be able to represent at least BITS.
+ if (mpz_sgn(val) >= 0
+ && bits <= itype->bits())
+ return true;
+ }
+ else
+ {
+ // For a signed type we need an extra bit to indicate the sign.
+ // We have to handle the most negative integer specially.
+ if (bits + 1 <= itype->bits()
+ || (bits <= itype->bits()
+ && mpz_sgn(val) < 0
+ && (mpz_scan1(val, 0)
+ == static_cast<unsigned long>(itype->bits() - 1))
+ && mpz_scan0(val, itype->bits()) == ULONG_MAX))
+ return true;
+ }
+
+ error_at(location, "integer constant overflow");
+ return false;
+}
+
+// Check the type of an integer constant.
+
+void
+Integer_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+ if (!Integer_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for an integer constant.
+
+tree
+Integer_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->float_type() != NULL)
+ {
+ // We are converting to an abstract floating point type.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ else if (this->type_ != NULL && this->type_->complex_type() != NULL)
+ {
+ // We are converting to an abstract complex type.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced for
+ // some reason. Use a type which will fit the value. We use <,
+ // not <=, because we need an extra bit for the sign bit.
+ int bits = mpz_sizeinbase(this->val_, 2);
+ if (bits < INT_TYPE_SIZE)
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ else if (bits < 64)
+ type = Type::lookup_integer_type("int64")->get_tree(gogo);
+ else
+ type = long_long_integer_type_node;
+ }
+ return Expression::integer_constant_tree(this->val_, type);
+}
+
+// Write VAL to export data.
+
+void
+Integer_expression::export_integer(Export* exp, const mpz_t val)
+{
+ char* s = mpz_get_str(NULL, 10, val);
+ exp->write_c_string(s);
+ free(s);
+}
+
+// Export an integer in a constant expression.
+
+void
+Integer_expression::do_export(Export* exp) const
+{
+ Integer_expression::export_integer(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Import an integer, floating point, or complex value. This handles
+// all these types because they all start with digits.
+
+Expression*
+Integer_expression::do_import(Import* imp)
+{
+ std::string num = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (!num.empty() && num[num.length() - 1] == 'i')
+ {
+ mpfr_t real;
+ size_t plus_pos = num.find('+', 1);
+ size_t minus_pos = num.find('-', 1);
+ size_t pos;
+ if (plus_pos == std::string::npos)
+ pos = minus_pos;
+ else if (minus_pos == std::string::npos)
+ pos = plus_pos;
+ else
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ if (pos == std::string::npos)
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ else
+ {
+ std::string real_str = num.substr(0, pos);
+ if (mpfr_init_set_str(real, real_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ real_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ }
+
+ std::string imag_str;
+ if (pos == std::string::npos)
+ imag_str = num;
+ else
+ imag_str = num.substr(pos);
+ imag_str = imag_str.substr(0, imag_str.size() - 1);
+ mpfr_t imag;
+ if (mpfr_init_set_str(imag, imag_str.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ imag_str.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_complex(&real, &imag, NULL,
+ imp->location());
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ else if (num.find('.') == std::string::npos
+ && num.find('E') == std::string::npos)
+ {
+ mpz_t val;
+ if (mpz_init_set_str(val, num.c_str(), 10) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_integer(&val, NULL, imp->location());
+ mpz_clear(val);
+ return ret;
+ }
+ else
+ {
+ mpfr_t val;
+ if (mpfr_init_set_str(val, num.c_str(), 10, GMP_RNDN) != 0)
+ {
+ error_at(imp->location(), "bad number in import data: %qs",
+ num.c_str());
+ return Expression::make_error(imp->location());
+ }
+ Expression* ret = Expression::make_float(&val, NULL, imp->location());
+ mpfr_clear(val);
+ return ret;
+ }
+}
+
+// Build a new integer value.
+
+Expression*
+Expression::make_integer(const mpz_t* val, Type* type,
+ source_location location)
+{
+ return new Integer_expression(val, type, location);
+}
+
+// Floats.
+
+class Float_expression : public Expression
+{
+ public:
+ Float_expression(const mpfr_t* val, Type* type, source_location location)
+ : Expression(EXPRESSION_FLOAT, location),
+ type_(type)
+ {
+ mpfr_init_set(this->val_, *val, GMP_RNDN);
+ }
+
+ // Constrain VAL to fit into TYPE.
+ static void
+ constrain_float(mpfr_t val, Type* type);
+
+ // Return whether VAL fits in the type.
+ static bool
+ check_constant(mpfr_t val, Type*, source_location);
+
+ // Write VAL to export data.
+ static void
+ export_float(Export* exp, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return Expression::make_float(&this->val_, this->type_,
+ this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The floating point value.
+ mpfr_t val_;
+ // The type so far.
+ Type* type_;
+};
+
+// Constrain VAL to fit into TYPE.
+
+void
+Float_expression::constrain_float(mpfr_t val, Type* type)
+{
+ Float_type* ftype = type->float_type();
+ if (ftype != NULL && !ftype->is_abstract())
+ {
+ tree type_tree = ftype->type_tree();
+ REAL_VALUE_TYPE rvt;
+ real_from_mpfr(&rvt, val, type_tree, GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(type_tree), &rvt);
+ mpfr_from_real(val, &rvt, GMP_RNDN);
+ }
+}
+
+// Return a floating point constant value.
+
+bool
+Float_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(val, this->val_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract float type.
+
+Type*
+Float_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_float_type();
+ return this->type_;
+}
+
+// Set the type of the float value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Float_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_float_type("float64");
+}
+
+// Return true if the floating point value VAL fits in the range of
+// the type TYPE. Otherwise give an error and return false. TYPE may
+// be NULL.
+
+bool
+Float_expression::check_constant(mpfr_t val, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Float_type* ftype = type->float_type();
+ if (ftype == NULL || ftype->is_abstract())
+ return true;
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (mpfr_nan_p(val) || mpfr_inf_p(val) || mpfr_zero_p(val))
+ return true;
+
+ mp_exp_t exp = mpfr_get_exp(val);
+ mp_exp_t max_exp;
+ switch (ftype->bits())
+ {
+ case 32:
+ max_exp = 128;
+ break;
+ case 64:
+ max_exp = 1024;
+ break;
+ default:
+ gcc_unreachable();
+ }
+ if (exp > max_exp)
+ {
+ error_at(location, "floating point constant overflow");
+ return false;
+ }
+ return true;
+}
+
+// Check the type of a float value.
+
+void
+Float_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Float_expression::check_constant(this->val_, this->type_,
+ this->location()))
+ this->set_is_error();
+
+ Integer_type* integer_type = this->type_->integer_type();
+ if (integer_type != NULL)
+ {
+ if (!mpfr_integer_p(this->val_))
+ this->report_error(_("floating point constant truncated to integer"));
+ else
+ {
+ gcc_assert(!integer_type->is_abstract());
+ mpz_t ival;
+ mpz_init(ival);
+ mpfr_get_z(ival, this->val_, GMP_RNDN);
+ Integer_expression::check_constant(ival, integer_type,
+ this->location());
+ mpz_clear(ival);
+ }
+ }
+}
+
+// Get a tree for a float constant.
+
+tree
+Float_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else if (this->type_ != NULL && this->type_->integer_type() != NULL)
+ {
+ // We have an abstract integer type. We just hope for the best.
+ type = Type::lookup_integer_type("int")->get_tree(gogo);
+ }
+ else
+ {
+ // If we still have an abstract type here, then this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use float64 and hope for the best.
+ type = Type::lookup_float_type("float64")->get_tree(gogo);
+ }
+ return Expression::float_constant_tree(this->val_, type);
+}
+
+// Write a floating point number to export data.
+
+void
+Float_expression::export_float(Export *exp, const mpfr_t val)
+{
+ mp_exp_t exponent;
+ char* s = mpfr_get_str(NULL, &exponent, 10, 0, val, GMP_RNDN);
+ if (*s == '-')
+ exp->write_c_string("-");
+ exp->write_c_string("0.");
+ exp->write_c_string(*s == '-' ? s + 1 : s);
+ mpfr_free_str(s);
+ char buf[30];
+ snprintf(buf, sizeof buf, "E%ld", exponent);
+ exp->write_c_string(buf);
+}
+
+// Export a floating point number in a constant expression.
+
+void
+Float_expression::do_export(Export* exp) const
+{
+ Float_expression::export_float(exp, this->val_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a float expression.
+
+Expression*
+Expression::make_float(const mpfr_t* val, Type* type, source_location location)
+{
+ return new Float_expression(val, type, location);
+}
+
+// Complex numbers.
+
+class Complex_expression : public Expression
+{
+ public:
+ Complex_expression(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+ : Expression(EXPRESSION_COMPLEX, location),
+ type_(type)
+ {
+ mpfr_init_set(this->real_, *real, GMP_RNDN);
+ mpfr_init_set(this->imag_, *imag, GMP_RNDN);
+ }
+
+ // Constrain REAL/IMAG to fit into TYPE.
+ static void
+ constrain_complex(mpfr_t real, mpfr_t imag, Type* type);
+
+ // Return whether REAL/IMAG fits in the type.
+ static bool
+ check_constant(mpfr_t real, mpfr_t imag, Type*, source_location);
+
+ // Write REAL/IMAG to export data.
+ static void
+ export_complex(Export* exp, const mpfr_t real, const mpfr_t val);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_complex(&this->real_, &this->imag_, this->type_,
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The real part.
+ mpfr_t real_;
+ // The imaginary part;
+ mpfr_t imag_;
+ // The type if known.
+ Type* type_;
+};
+
+// Constrain REAL/IMAG to fit into TYPE.
+
+void
+Complex_expression::constrain_complex(mpfr_t real, mpfr_t imag, Type* type)
+{
+ Complex_type* ctype = type->complex_type();
+ if (ctype != NULL && !ctype->is_abstract())
+ {
+ tree type_tree = ctype->type_tree();
+
+ REAL_VALUE_TYPE rvt;
+ real_from_mpfr(&rvt, real, TREE_TYPE(type_tree), GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(TREE_TYPE(type_tree)), &rvt);
+ mpfr_from_real(real, &rvt, GMP_RNDN);
+
+ real_from_mpfr(&rvt, imag, TREE_TYPE(type_tree), GMP_RNDN);
+ real_convert(&rvt, TYPE_MODE(TREE_TYPE(type_tree)), &rvt);
+ mpfr_from_real(imag, &rvt, GMP_RNDN);
+ }
+}
+
+// Return a complex constant value.
+
+bool
+Complex_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->type_ != NULL)
+ *ptype = this->type_;
+ mpfr_set(real, this->real_, GMP_RNDN);
+ mpfr_set(imag, this->imag_, GMP_RNDN);
+ return true;
+}
+
+// Return the current type. If we haven't set the type yet, we return
+// an abstract complex type.
+
+Type*
+Complex_expression::do_type()
+{
+ if (this->type_ == NULL)
+ this->type_ = Type::make_abstract_complex_type();
+ return this->type_;
+}
+
+// Set the type of the complex value. Here we may switch from an
+// abstract type to a real type.
+
+void
+Complex_expression::do_determine_type(const Type_context* context)
+{
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ ;
+ else if (context->type != NULL
+ && context->type->complex_type() != NULL)
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ this->type_ = Type::lookup_complex_type("complex128");
+}
+
+// Return true if the complex value REAL/IMAG fits in the range of the
+// type TYPE. Otherwise give an error and return false. TYPE may be
+// NULL.
+
+bool
+Complex_expression::check_constant(mpfr_t real, mpfr_t imag, Type* type,
+ source_location location)
+{
+ if (type == NULL)
+ return true;
+ Complex_type* ctype = type->complex_type();
+ if (ctype == NULL || ctype->is_abstract())
+ return true;
+
+ mp_exp_t max_exp;
+ switch (ctype->bits())
+ {
+ case 64:
+ max_exp = 128;
+ break;
+ case 128:
+ max_exp = 1024;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ // A NaN or Infinity always fits in the range of the type.
+ if (!mpfr_nan_p(real) && !mpfr_inf_p(real) && !mpfr_zero_p(real))
+ {
+ if (mpfr_get_exp(real) > max_exp)
+ {
+ error_at(location, "complex real part constant overflow");
+ return false;
+ }
+ }
+
+ if (!mpfr_nan_p(imag) && !mpfr_inf_p(imag) && !mpfr_zero_p(imag))
+ {
+ if (mpfr_get_exp(imag) > max_exp)
+ {
+ error_at(location, "complex imaginary part constant overflow");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check the type of a complex value.
+
+void
+Complex_expression::do_check_types(Gogo*)
+{
+ if (this->type_ == NULL)
+ return;
+
+ if (!Complex_expression::check_constant(this->real_, this->imag_,
+ this->type_, this->location()))
+ this->set_is_error();
+}
+
+// Get a tree for a complex constant.
+
+tree
+Complex_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type;
+ if (this->type_ != NULL && !this->type_->is_abstract())
+ type = this->type_->get_tree(gogo);
+ else
+ {
+ // If we still have an abstract type here, this this is being
+ // used in a constant expression which didn't get reduced. We
+ // just use complex128 and hope for the best.
+ type = Type::lookup_complex_type("complex128")->get_tree(gogo);
+ }
+ return Expression::complex_constant_tree(this->real_, this->imag_, type);
+}
+
+// Write REAL/IMAG to export data.
+
+void
+Complex_expression::export_complex(Export* exp, const mpfr_t real,
+ const mpfr_t imag)
+{
+ if (!mpfr_zero_p(real))
+ {
+ Float_expression::export_float(exp, real);
+ if (mpfr_sgn(imag) > 0)
+ exp->write_c_string("+");
+ }
+ Float_expression::export_float(exp, imag);
+ exp->write_c_string("i");
+}
+
+// Export a complex number in a constant expression.
+
+void
+Complex_expression::do_export(Export* exp) const
+{
+ Complex_expression::export_complex(exp, this->real_, this->imag_);
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Make a complex expression.
+
+Expression*
+Expression::make_complex(const mpfr_t* real, const mpfr_t* imag, Type* type,
+ source_location location)
+{
+ return new Complex_expression(real, imag, type, location);
+}
+
+// Find a named object in an expression.
+
+class Find_named_object : public Traverse
+{
+ public:
+ Find_named_object(Named_object* no)
+ : Traverse(traverse_expressions),
+ no_(no), found_(false)
+ { }
+
+ // Whether we found the object.
+ bool
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The object we are looking for.
+ Named_object* no_;
+ // Whether we found it.
+ bool found_;
+};
+
+// A reference to a const in an expression.
+
+class Const_expression : public Expression
+{
+ public:
+ Const_expression(Named_object* constant, source_location location)
+ : Expression(EXPRESSION_CONST_REFERENCE, location),
+ constant_(constant), type_(NULL), seen_(false)
+ { }
+
+ Named_object*
+ named_object()
+ { return this->constant_; }
+
+ // Check that the initializer does not refer to the constant itself.
+ void
+ check_for_init_loop();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return true; }
+
+ bool
+ do_integer_constant_value(bool, mpz_t val, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t val, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t real, mpfr_t imag, Type**) const;
+
+ bool
+ do_string_constant_value(std::string* val) const
+ { return this->constant_->const_value()->expr()->string_constant_value(val); }
+
+ Type*
+ do_type();
+
+ // The type of a const is set by the declaration, not the use.
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ // When exporting a reference to a const as part of a const
+ // expression, we export the value. We ignore the fact that it has
+ // a name.
+ void
+ do_export(Export* exp) const
+ { this->constant_->const_value()->expr()->export_expression(exp); }
+
+ private:
+ // The constant.
+ Named_object* constant_;
+ // The type of this reference. This is used if the constant has an
+ // abstract type.
+ Type* type_;
+ // Used to prevent infinite recursion when a constant incorrectly
+ // refers to itself.
+ mutable bool seen_;
+};
+
+// Traversal.
+
+int
+Const_expression::do_traverse(Traverse* traverse)
+{
+ if (this->type_ != NULL)
+ return Type::traverse(this->type_, traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a constant expression. This is where we convert the
+// predeclared constant iota into an integer value.
+
+Expression*
+Const_expression::do_lower(Gogo* gogo, Named_object*, int iota_value)
+{
+ if (this->constant_->const_value()->expr()->classification()
+ == EXPRESSION_IOTA)
+ {
+ if (iota_value == -1)
+ {
+ error_at(this->location(),
+ "iota is only defined in const declarations");
+ iota_value = 0;
+ }
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned long>(iota_value));
+ Expression* ret = Expression::make_integer(&val, NULL,
+ this->location());
+ mpz_clear(val);
+ return ret;
+ }
+
+ // Make sure that the constant itself has been lowered.
+ gogo->lower_constant(this->constant_);
+
+ return this;
+}
+
+// Return an integer constant value.
+
+bool
+Const_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->integer_type() == NULL)
+ return false;
+
+ Expression* e = this->constant_->const_value()->expr();
+
+ this->seen_ = true;
+
+ Type* t;
+ bool r = e->integer_constant_value(iota_is_constant, val, &t);
+
+ this->seen_ = false;
+
+ if (r
+ && ctype != NULL
+ && !Integer_expression::check_constant(val, ctype, this->location()))
+ return false;
+
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a floating point constant value.
+
+bool
+Const_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->float_type() == NULL)
+ return false;
+
+ this->seen_ = true;
+
+ Type* t;
+ bool r = this->constant_->const_value()->expr()->float_constant_value(val,
+ &t);
+
+ this->seen_ = false;
+
+ if (r && ctype != NULL)
+ {
+ if (!Float_expression::check_constant(val, ctype, this->location()))
+ return false;
+ Float_expression::constrain_float(val, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return a complex constant value.
+
+bool
+Const_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type **ptype) const
+{
+ if (this->seen_)
+ return false;
+
+ Type* ctype;
+ if (this->type_ != NULL)
+ ctype = this->type_;
+ else
+ ctype = this->constant_->const_value()->type();
+ if (ctype != NULL && ctype->complex_type() == NULL)
+ return false;
+
+ this->seen_ = true;
+
+ Type *t;
+ bool r = this->constant_->const_value()->expr()->complex_constant_value(real,
+ imag,
+ &t);
+
+ this->seen_ = false;
+
+ if (r && ctype != NULL)
+ {
+ if (!Complex_expression::check_constant(real, imag, ctype,
+ this->location()))
+ return false;
+ Complex_expression::constrain_complex(real, imag, ctype);
+ }
+ *ptype = ctype != NULL ? ctype : t;
+ return r;
+}
+
+// Return the type of the const reference.
+
+Type*
+Const_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+
+ Named_constant* nc = this->constant_->const_value();
+
+ if (this->seen_ || nc->lowering())
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ return this->type_;
+ }
+
+ this->seen_ = true;
+
+ Type* ret = nc->type();
+
+ if (ret != NULL)
+ {
+ this->seen_ = false;
+ return ret;
+ }
+
+ // During parsing, a named constant may have a NULL type, but we
+ // must not return a NULL type here.
+ ret = nc->expr()->type();
+
+ this->seen_ = false;
+
+ return ret;
+}
+
+// Set the type of the const reference.
+
+void
+Const_expression::do_determine_type(const Type_context* context)
+{
+ Type* ctype = this->constant_->const_value()->type();
+ Type* cetype = (ctype != NULL
+ ? ctype
+ : this->constant_->const_value()->expr()->type());
+ if (ctype != NULL && !ctype->is_abstract())
+ ;
+ else if (context->type != NULL
+ && (context->type->integer_type() != NULL
+ || context->type->float_type() != NULL
+ || context->type->complex_type() != NULL)
+ && (cetype->integer_type() != NULL
+ || cetype->float_type() != NULL
+ || cetype->complex_type() != NULL))
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_string_type()
+ && cetype->is_string_type())
+ this->type_ = context->type;
+ else if (context->type != NULL
+ && context->type->is_boolean_type()
+ && cetype->is_boolean_type())
+ this->type_ = context->type;
+ else if (!context->may_be_abstract)
+ {
+ if (cetype->is_abstract())
+ cetype = cetype->make_non_abstract_type();
+ this->type_ = cetype;
+ }
+}
+
+// Check for a loop in which the initializer of a constant refers to
+// the constant itself.
+
+void
+Const_expression::check_for_init_loop()
+{
+ if (this->type_ != NULL && this->type_->is_error_type())
+ return;
+
+ if (this->seen_)
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ return;
+ }
+
+ Expression* init = this->constant_->const_value()->expr();
+ Find_named_object find_named_object(this->constant_);
+
+ this->seen_ = true;
+ Expression::traverse(&init, &find_named_object);
+ this->seen_ = false;
+
+ if (find_named_object.found())
+ {
+ if (this->type_ == NULL || !this->type_->is_error_type())
+ {
+ this->report_error(_("constant refers to itself"));
+ this->type_ = Type::make_error_type();
+ }
+ return;
+ }
+}
+
+// Check types of a const reference.
+
+void
+Const_expression::do_check_types(Gogo*)
+{
+ if (this->type_ != NULL && this->type_->is_error_type())
+ return;
+
+ this->check_for_init_loop();
+
+ if (this->type_ == NULL || this->type_->is_abstract())
+ return;
+
+ // Check for integer overflow.
+ if (this->type_->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (!this->integer_constant_value(true, ival, &dummy))
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Expression* cexpr = this->constant_->const_value()->expr();
+ if (cexpr->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ this->report_error(_("floating point constant "
+ "truncated to integer"));
+ else
+ {
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ Integer_expression::check_constant(ival, this->type_,
+ this->location());
+ }
+ }
+ mpfr_clear(fval);
+ }
+ mpz_clear(ival);
+ }
+}
+
+// Return a tree for the const reference.
+
+tree
+Const_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree;
+ if (this->type_ == NULL)
+ type_tree = NULL_TREE;
+ else
+ {
+ type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ }
+
+ // If the type has been set for this expression, but the underlying
+ // object is an abstract int or float, we try to get the abstract
+ // value. Otherwise we may lose something in the conversion.
+ if (this->type_ != NULL
+ && (this->constant_->const_value()->type() == NULL
+ || this->constant_->const_value()->type()->is_abstract()))
+ {
+ Expression* expr = this->constant_->const_value()->expr();
+ mpz_t ival;
+ mpz_init(ival);
+ Type* t;
+ if (expr->integer_constant_value(true, ival, &t))
+ {
+ tree ret = Expression::integer_constant_tree(ival, type_tree);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (expr->float_constant_value(fval, &t))
+ {
+ tree ret = Expression::float_constant_tree(fval, type_tree);
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (expr->complex_constant_value(fval, imag, &t))
+ {
+ tree ret = Expression::complex_constant_tree(fval, imag, type_tree);
+ mpfr_clear(fval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(imag);
+ mpfr_clear(fval);
+ }
+
+ tree const_tree = this->constant_->get_tree(gogo, context->function());
+ if (this->type_ == NULL
+ || const_tree == error_mark_node
+ || TREE_TYPE(const_tree) == error_mark_node)
+ return const_tree;
+
+ tree ret;
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(const_tree)))
+ ret = fold_convert(type_tree, const_tree);
+ else if (TREE_CODE(type_tree) == INTEGER_TYPE)
+ ret = fold(convert_to_integer(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == REAL_TYPE)
+ ret = fold(convert_to_real(type_tree, const_tree));
+ else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
+ ret = fold(convert_to_complex(type_tree, const_tree));
+ else
+ gcc_unreachable();
+ return ret;
+}
+
+// Make a reference to a constant in an expression.
+
+Expression*
+Expression::make_const_reference(Named_object* constant,
+ source_location location)
+{
+ return new Const_expression(constant, location);
+}
+
+// Find a named object in an expression.
+
+int
+Find_named_object::expression(Expression** pexpr)
+{
+ switch ((*pexpr)->classification())
+ {
+ case Expression::EXPRESSION_CONST_REFERENCE:
+ {
+ Const_expression* ce = static_cast<Const_expression*>(*pexpr);
+ if (ce->named_object() == this->no_)
+ break;
+
+ // We need to check a constant initializer explicitly, as
+ // loops here will not be caught by the loop checking for
+ // variable initializers.
+ ce->check_for_init_loop();
+
+ return TRAVERSE_CONTINUE;
+ }
+
+ case Expression::EXPRESSION_VAR_REFERENCE:
+ if ((*pexpr)->var_expression()->named_object() == this->no_)
+ break;
+ return TRAVERSE_CONTINUE;
+ case Expression::EXPRESSION_FUNC_REFERENCE:
+ if ((*pexpr)->func_expression()->named_object() == this->no_)
+ break;
+ return TRAVERSE_CONTINUE;
+ default:
+ return TRAVERSE_CONTINUE;
+ }
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+}
+
+// The nil value.
+
+class Nil_expression : public Expression
+{
+ public:
+ Nil_expression(source_location location)
+ : Expression(EXPRESSION_NIL, location)
+ { }
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ bool
+ do_is_constant() const
+ { return true; }
+
+ Type*
+ do_type()
+ { return Type::make_nil_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return null_pointer_node; }
+
+ void
+ do_export(Export* exp) const
+ { exp->write_c_string("nil"); }
+};
+
+// Import a nil expression.
+
+Expression*
+Nil_expression::do_import(Import* imp)
+{
+ imp->require_c_string("nil");
+ return Expression::make_nil(imp->location());
+}
+
+// Make a nil expression.
+
+Expression*
+Expression::make_nil(source_location location)
+{
+ return new Nil_expression(location);
+}
+
+// The value of the predeclared constant iota. This is little more
+// than a marker. This will be lowered to an integer in
+// Const_expression::do_lower, which is where we know the value that
+// it should have.
+
+class Iota_expression : public Parser_expression
+{
+ public:
+ Iota_expression(source_location location)
+ : Parser_expression(EXPRESSION_IOTA, location)
+ { }
+
+ protected:
+ Expression*
+ do_lower(Gogo*, Named_object*, int)
+ { gcc_unreachable(); }
+
+ // There should only ever be one of these.
+ Expression*
+ do_copy()
+ { gcc_unreachable(); }
+};
+
+// Make an iota expression. This is only called for one case: the
+// value of the predeclared constant iota.
+
+Expression*
+Expression::make_iota()
+{
+ static Iota_expression iota_expression(UNKNOWN_LOCATION);
+ return &iota_expression;
+}
+
+// A type conversion expression.
+
+class Type_conversion_expression : public Expression
+{
+ public:
+ Type_conversion_expression(Type* type, Expression* expr,
+ source_location location)
+ : Expression(EXPRESSION_CONVERSION, location),
+ type_(type), expr_(expr), may_convert_function_types_(false)
+ { }
+
+ // Return the type to which we are converting.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Return the expression which we are converting.
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ // Permit converting from one function type to another. This is
+ // used internally for method expressions.
+ void
+ set_may_convert_function_types()
+ {
+ this->may_convert_function_types_ = true;
+ }
+
+ // Import a type conversion expression.
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const
+ { return this->expr_->is_constant(); }
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ bool
+ do_string_constant_value(std::string*) const;
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*)
+ {
+ Type_context subcontext(this->type_, false);
+ this->expr_->determine_type(&subcontext);
+ }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Type_conversion_expression(this->type_, this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type to convert to.
+ Type* type_;
+ // The expression to convert.
+ Expression* expr_;
+ // True if this is permitted to convert function types. This is
+ // used internally for method expressions.
+ bool may_convert_function_types_;
+};
+
+// Traversal.
+
+int
+Type_conversion_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert to a constant at lowering time.
+
+Expression*
+Type_conversion_expression::do_lower(Gogo*, Named_object*, int)
+{
+ Type* type = this->type_;
+ Expression* val = this->expr_;
+ source_location location = this->location();
+
+ if (type->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (val->integer_constant_value(false, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpz_clear(ival);
+ return ret;
+ }
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(location,
+ "floating point constant truncated to integer");
+ return Expression::make_error(location);
+ }
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!Integer_expression::check_constant(ival, type, location))
+ mpz_set_ui(ival, 0);
+ Expression* ret = Expression::make_integer(&ival, type, location);
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ return ret;
+ }
+ mpfr_clear(fval);
+ mpz_clear(ival);
+ }
+
+ if (type->float_type() != NULL)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (val->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, type, location))
+ mpfr_set_ui(fval, 0, GMP_RNDN);
+ Float_expression::constrain_float(fval, type);
+ Expression *ret = Expression::make_float(&fval, type, location);
+ mpfr_clear(fval);
+ return ret;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (type->complex_type() != NULL)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ Type* dummy;
+ if (val->complex_constant_value(real, imag, &dummy))
+ {
+ if (!Complex_expression::check_constant(real, imag, type, location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ Complex_expression::constrain_complex(real, imag, type);
+ Expression* ret = Expression::make_complex(&real, &imag, type,
+ location);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (type->is_open_array_type() && type->named_type() == NULL)
+ {
+ Type* element_type = type->array_type()->element_type()->forwarded();
+ bool is_byte = element_type == Type::lookup_integer_type("uint8");
+ bool is_int = element_type == Type::lookup_integer_type("int");
+ if (is_byte || is_int)
+ {
+ std::string s;
+ if (val->string_constant_value(&s))
+ {
+ Expression_list* vals = new Expression_list();
+ if (is_byte)
+ {
+ for (std::string::const_iterator p = s.begin();
+ p != s.end();
+ p++)
+ {
+ mpz_t val;
+ mpz_init_set_ui(val, static_cast<unsigned char>(*p));
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+ else
+ {
+ const char *p = s.data();
+ const char *pend = s.data() + s.length();
+ while (p < pend)
+ {
+ unsigned int c;
+ int adv = Lex::fetch_char(p, &c);
+ if (adv == 0)
+ {
+ warning_at(this->location(), 0,
+ "invalid UTF-8 encoding");
+ adv = 1;
+ }
+ p += adv;
+ mpz_t val;
+ mpz_init_set_ui(val, c);
+ Expression* v = Expression::make_integer(&val,
+ element_type,
+ location);
+ vals->push_back(v);
+ mpz_clear(val);
+ }
+ }
+
+ return Expression::make_slice_composite_literal(type, vals,
+ location);
+ }
+ }
+ }
+
+ return this;
+}
+
+// Return the constant integer value if there is one.
+
+bool
+Type_conversion_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->type_->integer_type() == NULL)
+ return false;
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(iota_is_constant, ival, &dummy))
+ {
+ if (!Integer_expression::check_constant(ival, this->type_,
+ this->location()))
+ {
+ mpz_clear(ival);
+ return false;
+ }
+ mpz_set(val, ival);
+ mpz_clear(ival);
+ *ptype = this->type_;
+ return true;
+ }
+ mpz_clear(ival);
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ if (!Integer_expression::check_constant(val, this->type_,
+ this->location()))
+ return false;
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant floating point value if there is one.
+
+bool
+Type_conversion_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->type_->float_type() == NULL)
+ return false;
+
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* dummy;
+ if (this->expr_->float_constant_value(fval, &dummy))
+ {
+ if (!Float_expression::check_constant(fval, this->type_,
+ this->location()))
+ {
+ mpfr_clear(fval);
+ return false;
+ }
+ mpfr_set(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ Float_expression::constrain_float(val, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(fval);
+
+ return false;
+}
+
+// Return the constant complex value if there is one.
+
+bool
+Type_conversion_expression::do_complex_constant_value(mpfr_t real,
+ mpfr_t imag,
+ Type **ptype) const
+{
+ if (this->type_->complex_type() == NULL)
+ return false;
+
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ Type* dummy;
+ if (this->expr_->complex_constant_value(rval, ival, &dummy))
+ {
+ if (!Complex_expression::check_constant(rval, ival, this->type_,
+ this->location()))
+ {
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return false;
+ }
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ Complex_expression::constrain_complex(real, imag, this->type_);
+ *ptype = this->type_;
+ return true;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+
+ return false;
+}
+
+// Return the constant string value if there is one.
+
+bool
+Type_conversion_expression::do_string_constant_value(std::string* val) const
+{
+ if (this->type_->is_string_type()
+ && this->expr_->type()->integer_type() != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->expr_->integer_constant_value(false, ival, &dummy))
+ {
+ unsigned long ulval = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, ulval) == 0)
+ {
+ Lex::append_char(ulval, true, val, this->location());
+ mpz_clear(ival);
+ return true;
+ }
+ }
+ mpz_clear(ival);
+ }
+
+ // FIXME: Could handle conversion from const []int here.
+
+ return false;
+}
+
+// Check that types are convertible.
+
+void
+Type_conversion_expression::do_check_types(Gogo*)
+{
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ std::string reason;
+
+ if (type->is_error_type()
+ || type->is_undefined()
+ || expr_type->is_error_type()
+ || expr_type->is_undefined())
+ {
+ // Make sure we emit an error for an undefined type.
+ type->base();
+ expr_type->base();
+ this->set_is_error();
+ return;
+ }
+
+ if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ return;
+
+ if (Type::are_convertible(type, expr_type, &reason))
+ return;
+
+ error_at(this->location(), "%s", reason.c_str());
+ this->set_is_error();
+}
+
+// Get a tree for a type conversion.
+
+tree
+Type_conversion_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->type_->get_tree(gogo);
+ tree expr_tree = this->expr_->get_tree(context);
+
+ if (type_tree == error_mark_node
+ || expr_tree == error_mark_node
+ || TREE_TYPE(expr_tree) == error_mark_node)
+ return error_mark_node;
+
+ if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(expr_tree)))
+ return fold_convert(type_tree, expr_tree);
+
+ Type* type = this->type_;
+ Type* expr_type = this->expr_->type();
+ tree ret;
+ if (type->interface_type() != NULL || expr_type->interface_type() != NULL)
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+ else if (type->integer_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL
+ || expr_type->is_unsafe_pointer_type())
+ ret = fold(convert_to_integer(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->float_type() != NULL)
+ {
+ if (expr_type->integer_type() != NULL
+ || expr_type->float_type() != NULL)
+ ret = fold(convert_to_real(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->complex_type() != NULL)
+ {
+ if (expr_type->complex_type() != NULL)
+ ret = fold(convert_to_complex(type_tree, expr_tree));
+ else
+ gcc_unreachable();
+ }
+ else if (type->is_string_type()
+ && expr_type->integer_type() != NULL)
+ {
+ expr_tree = fold_convert(integer_type_node, expr_tree);
+ if (host_integerp(expr_tree, 0))
+ {
+ HOST_WIDE_INT intval = tree_low_cst(expr_tree, 0);
+ std::string s;
+ Lex::append_char(intval, true, &s, this->location());
+ Expression* se = Expression::make_string(s, this->location());
+ return se->get_tree(context);
+ }
+
+ static tree int_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_to_string_fndecl,
+ this->location(),
+ "__go_int_to_string",
+ 1,
+ type_tree,
+ integer_type_node,
+ fold_convert(integer_type_node, expr_tree));
+ }
+ else if (type->is_string_type()
+ && (expr_type->array_type() != NULL
+ || (expr_type->points_to() != NULL
+ && expr_type->points_to()->array_type() != NULL)))
+ {
+ Type* t = expr_type;
+ if (t->points_to() != NULL)
+ {
+ t = t->points_to();
+ expr_tree = build_fold_indirect_ref(expr_tree);
+ }
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ Array_type* a = t->array_type();
+ Type* e = a->element_type()->forwarded();
+ gcc_assert(e->integer_type() != NULL);
+ tree valptr = fold_convert(const_ptr_type_node,
+ a->value_pointer_tree(gogo, expr_tree));
+ tree len = a->length_tree(gogo, expr_tree);
+ len = fold_convert_loc(this->location(), size_type_node, len);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree byte_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&byte_array_to_string_fndecl,
+ this->location(),
+ "__go_byte_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ size_type_node,
+ len);
+ }
+ else
+ {
+ gcc_assert(e == Type::lookup_integer_type("int"));
+ static tree int_array_to_string_fndecl;
+ ret = Gogo::call_builtin(&int_array_to_string_fndecl,
+ this->location(),
+ "__go_int_array_to_string",
+ 2,
+ type_tree,
+ const_ptr_type_node,
+ valptr,
+ size_type_node,
+ len);
+ }
+ }
+ else if (type->is_open_array_type() && expr_type->is_string_type())
+ {
+ Type* e = type->array_type()->element_type()->forwarded();
+ gcc_assert(e->integer_type() != NULL);
+ if (e->integer_type()->is_unsigned()
+ && e->integer_type()->bits() == 8)
+ {
+ static tree string_to_byte_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_byte_array_fndecl,
+ this->location(),
+ "__go_string_to_byte_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ else
+ {
+ gcc_assert(e == Type::lookup_integer_type("int"));
+ static tree string_to_int_array_fndecl;
+ ret = Gogo::call_builtin(&string_to_int_array_fndecl,
+ this->location(),
+ "__go_string_to_int_array",
+ 1,
+ type_tree,
+ TREE_TYPE(expr_tree),
+ expr_tree);
+ }
+ }
+ else if ((type->is_unsafe_pointer_type()
+ && expr_type->points_to() != NULL)
+ || (expr_type->is_unsafe_pointer_type()
+ && type->points_to() != NULL))
+ ret = fold_convert(type_tree, expr_tree);
+ else if (type->is_unsafe_pointer_type()
+ && expr_type->integer_type() != NULL)
+ ret = convert_to_pointer(type_tree, expr_tree);
+ else if (this->may_convert_function_types_
+ && type->function_type() != NULL
+ && expr_type->function_type() != NULL)
+ ret = fold_convert_loc(this->location(), type_tree, expr_tree);
+ else
+ ret = Expression::convert_for_assignment(context, type, expr_type,
+ expr_tree, this->location());
+
+ return ret;
+}
+
+// Output a type conversion in a constant expression.
+
+void
+Type_conversion_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ exp->write_c_string(", ");
+ this->expr_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a type conversion or a struct construction.
+
+Expression*
+Type_conversion_expression::do_import(Import* imp)
+{
+ imp->require_c_string("convert(");
+ Type* type = imp->read_type();
+ imp->require_c_string(", ");
+ Expression* val = Expression::import_expression(imp);
+ imp->require_c_string(")");
+ return Expression::make_cast(type, val, imp->location());
+}
+
+// Make a type cast expression.
+
+Expression*
+Expression::make_cast(Type* type, Expression* val, source_location location)
+{
+ if (type->is_error_type() || val->is_error_expression())
+ return Expression::make_error(location);
+ return new Type_conversion_expression(type, val, location);
+}
+
+// Unary expressions.
+
+class Unary_expression : public Expression
+{
+ public:
+ Unary_expression(Operator op, Expression* expr, source_location location)
+ : Expression(EXPRESSION_UNARY, location),
+ op_(op), escapes_(true), expr_(expr)
+ { }
+
+ // Return the operator.
+ Operator
+ op() const
+ { return this->op_; }
+
+ // Return the operand.
+ Expression*
+ operand() const
+ { return this->expr_; }
+
+ // Record that an address expression does not escape.
+ void
+ set_does_not_escape()
+ {
+ gcc_assert(this->op_ == OPERATOR_AND);
+ this->escapes_ = false;
+ }
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location);
+
+ // Apply unary opcode OP to UVAL, setting VAL. Return true if this
+ // could be done, false if not.
+ static bool
+ eval_float(Operator op, mpfr_t uval, mpfr_t val);
+
+ // Apply unary opcode OP to UREAL/UIMAG, setting REAL/IMAG. Return
+ // true if this could be done, false if not.
+ static bool
+ eval_complex(Operator op, mpfr_t ureal, mpfr_t uimag, mpfr_t real,
+ mpfr_t imag);
+
+ static Expression*
+ do_import(Import*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_unary(this->op_, this->expr_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return this->op_ == OPERATOR_MULT; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The unary operator to apply.
+ Operator op_;
+ // Normally true. False if this is an address expression which does
+ // not escape the current function.
+ bool escapes_;
+ // The operand.
+ Expression* expr_;
+};
+
+// If we are taking the address of a composite literal, and the
+// contents are not constant, then we want to make a heap composite
+// instead.
+
+Expression*
+Unary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location loc = this->location();
+ Operator op = this->op_;
+ Expression* expr = this->expr_;
+
+ if (op == OPERATOR_MULT && expr->is_type_expression())
+ return Expression::make_type(Type::make_pointer_type(expr->type()), loc);
+
+ // *&x simplifies to x. *(*T)(unsafe.Pointer)(&x) does not require
+ // moving x to the heap. FIXME: Is it worth doing a real escape
+ // analysis here? This case is found in math/unsafe.go and is
+ // therefore worth special casing.
+ if (op == OPERATOR_MULT)
+ {
+ Expression* e = expr;
+ while (e->classification() == EXPRESSION_CONVERSION)
+ {
+ Type_conversion_expression* te
+ = static_cast<Type_conversion_expression*>(e);
+ e = te->expr();
+ }
+
+ if (e->classification() == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(e);
+ if (ue->op_ == OPERATOR_AND)
+ {
+ if (e == expr)
+ {
+ // *&x == x.
+ return ue->expr_;
+ }
+ ue->set_does_not_escape();
+ }
+ }
+ }
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS
+ || op == OPERATOR_NOT || op == OPERATOR_XOR)
+ {
+ Expression* ret = NULL;
+
+ mpz_t eval;
+ mpz_init(eval);
+ Type* etype;
+ if (expr->integer_constant_value(false, eval, &etype))
+ {
+ mpz_t val;
+ mpz_init(val);
+ if (Unary_expression::eval_integer(op, etype, eval, val, loc))
+ ret = Expression::make_integer(&val, etype, loc);
+ mpz_clear(val);
+ }
+ mpz_clear(eval);
+ if (ret != NULL)
+ return ret;
+
+ if (op == OPERATOR_PLUS || op == OPERATOR_MINUS)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ Type* ftype;
+ if (expr->float_constant_value(fval, &ftype))
+ {
+ mpfr_t val;
+ mpfr_init(val);
+ if (Unary_expression::eval_float(op, fval, val))
+ ret = Expression::make_float(&val, ftype, loc);
+ mpfr_clear(val);
+ }
+ if (ret != NULL)
+ {
+ mpfr_clear(fval);
+ return ret;
+ }
+
+ mpfr_t ival;
+ mpfr_init(ival);
+ if (expr->complex_constant_value(fval, ival, &ftype))
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (Unary_expression::eval_complex(op, fval, ival, real, imag))
+ ret = Expression::make_complex(&real, &imag, ftype, loc);
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+ mpfr_clear(ival);
+ mpfr_clear(fval);
+ if (ret != NULL)
+ return ret;
+ }
+ }
+
+ return this;
+}
+
+// Return whether a unary expression is a constant.
+
+bool
+Unary_expression::do_is_constant() const
+{
+ if (this->op_ == OPERATOR_MULT)
+ {
+ // Indirecting through a pointer is only constant if the object
+ // to which the expression points is constant, but we currently
+ // have no way to determine that.
+ return false;
+ }
+ else if (this->op_ == OPERATOR_AND)
+ {
+ // Taking the address of a variable is constant if it is a
+ // global variable, not constant otherwise. In other cases
+ // taking the address is probably not a constant.
+ Var_expression* ve = this->expr_->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* no = ve->named_object();
+ return no->is_variable() && no->var_value()->is_global();
+ }
+ return false;
+ }
+ else
+ return this->expr_->is_constant();
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. UTYPE is the type of
+// UVAL, if known; it may be NULL. Return true if this could be done,
+// false if not.
+
+bool
+Unary_expression::eval_integer(Operator op, Type* utype, mpz_t uval, mpz_t val,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpz_set(val, uval);
+ return true;
+ case OPERATOR_MINUS:
+ mpz_neg(val, uval);
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_NOT:
+ mpz_set_ui(val, mpz_cmp_si(uval, 0) == 0 ? 1 : 0);
+ return true;
+ case OPERATOR_XOR:
+ if (utype == NULL
+ || utype->integer_type() == NULL
+ || utype->integer_type()->is_abstract())
+ mpz_com(val, uval);
+ else
+ {
+ // The number of HOST_WIDE_INTs that it takes to represent
+ // UVAL.
+ size_t count = ((mpz_sizeinbase(uval, 2)
+ + HOST_BITS_PER_WIDE_INT
+ - 1)
+ / HOST_BITS_PER_WIDE_INT);
+
+ unsigned HOST_WIDE_INT* phwi = new unsigned HOST_WIDE_INT[count];
+ memset(phwi, 0, count * sizeof(HOST_WIDE_INT));
+
+ size_t ecount;
+ mpz_export(phwi, &ecount, -1, sizeof(HOST_WIDE_INT), 0, 0, uval);
+ gcc_assert(ecount <= count);
+
+ // Trim down to the number of words required by the type.
+ size_t obits = utype->integer_type()->bits();
+ if (!utype->integer_type()->is_unsigned())
+ ++obits;
+ size_t ocount = ((obits + HOST_BITS_PER_WIDE_INT - 1)
+ / HOST_BITS_PER_WIDE_INT);
+ gcc_assert(ocount <= ocount);
+
+ for (size_t i = 0; i < ocount; ++i)
+ phwi[i] = ~phwi[i];
+
+ size_t clearbits = ocount * HOST_BITS_PER_WIDE_INT - obits;
+ if (clearbits != 0)
+ phwi[ocount - 1] &= (((unsigned HOST_WIDE_INT) (HOST_WIDE_INT) -1)
+ >> clearbits);
+
+ mpz_import(val, ocount, -1, sizeof(HOST_WIDE_INT), 0, 0, phwi);
+
+ delete[] phwi;
+ }
+ return Integer_expression::check_constant(val, utype, location);
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply unary opcode OP to UVAL, setting VAL. Return true if this
+// could be done, false if not.
+
+bool
+Unary_expression::eval_float(Operator op, mpfr_t uval, mpfr_t val)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(val, uval, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply unary opcode OP to RVAL/IVAL, setting REAL/IMAG. Return true
+// if this could be done, false if not.
+
+bool
+Unary_expression::eval_complex(Operator op, mpfr_t rval, mpfr_t ival,
+ mpfr_t real, mpfr_t imag)
+{
+ switch (op)
+ {
+ case OPERATOR_PLUS:
+ mpfr_set(real, rval, GMP_RNDN);
+ mpfr_set(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_MINUS:
+ mpfr_neg(real, rval, GMP_RNDN);
+ mpfr_neg(imag, ival, GMP_RNDN);
+ return true;
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return the integral constant value of a unary expression, if it has one.
+
+bool
+Unary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t uval;
+ mpz_init(uval);
+ bool ret;
+ if (!this->expr_->integer_constant_value(iota_is_constant, uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_integer(this->op_, *ptype, uval, val,
+ this->location());
+ mpz_clear(uval);
+ return ret;
+}
+
+// Return the floating point constant value of a unary expression, if
+// it has one.
+
+bool
+Unary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t uval;
+ mpfr_init(uval);
+ bool ret;
+ if (!this->expr_->float_constant_value(uval, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_float(this->op_, uval, val);
+ mpfr_clear(uval);
+ return ret;
+}
+
+// Return the complex constant value of a unary expression, if it has
+// one.
+
+bool
+Unary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t rval;
+ mpfr_t ival;
+ mpfr_init(rval);
+ mpfr_init(ival);
+ bool ret;
+ if (!this->expr_->complex_constant_value(rval, ival, ptype))
+ ret = false;
+ else
+ ret = Unary_expression::eval_complex(this->op_, rval, ival, real, imag);
+ mpfr_clear(rval);
+ mpfr_clear(ival);
+ return ret;
+}
+
+// Return the type of a unary expression.
+
+Type*
+Unary_expression::do_type()
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ return this->expr_->type();
+
+ case OPERATOR_AND:
+ return Type::make_pointer_type(this->expr_->type());
+
+ case OPERATOR_MULT:
+ {
+ Type* subtype = this->expr_->type();
+ Type* points_to = subtype->points_to();
+ if (points_to == NULL)
+ return Type::make_error_type();
+ return points_to;
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Determine abstract types for a unary expression.
+
+void
+Unary_expression::do_determine_type(const Type_context* context)
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ this->expr_->determine_type(context);
+ break;
+
+ case OPERATOR_AND:
+ // Taking the address of something.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : context->type->points_to());
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ {
+ Type* subtype = (context->type == NULL
+ ? NULL
+ : Type::make_pointer_type(context->type));
+ Type_context subcontext(subtype, false);
+ this->expr_->determine_type(&subcontext);
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Check types for a unary expression.
+
+void
+Unary_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+ if (type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL)
+ this->report_error(_("expected numeric type"));
+ break;
+
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ if (type->integer_type() == NULL
+ && !type->is_boolean_type())
+ this->report_error(_("expected integer or boolean type"));
+ break;
+
+ case OPERATOR_AND:
+ if (!this->expr_->is_addressable())
+ this->report_error(_("invalid operand for unary %<&%>"));
+ else
+ this->expr_->address_taken(this->escapes_);
+ break;
+
+ case OPERATOR_MULT:
+ // Indirecting through a pointer.
+ if (type->points_to() == NULL)
+ this->report_error(_("expected pointer"));
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Get a tree for a unary expression.
+
+tree
+Unary_expression::do_get_tree(Translate_context* context)
+{
+ tree expr = this->expr_->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+
+ source_location loc = this->location();
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ return expr;
+
+ case OPERATOR_MINUS:
+ {
+ tree type = TREE_TYPE(expr);
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ expr = ::convert(compute_type, expr);
+ tree ret = fold_build1_loc(loc, NEGATE_EXPR,
+ (compute_type != NULL_TREE
+ ? compute_type
+ : type),
+ expr);
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+ return ret;
+ }
+
+ case OPERATOR_NOT:
+ if (TREE_CODE(TREE_TYPE(expr)) == BOOLEAN_TYPE)
+ return fold_build1_loc(loc, TRUTH_NOT_EXPR, TREE_TYPE(expr), expr);
+ else
+ return fold_build2_loc(loc, NE_EXPR, boolean_type_node, expr,
+ build_int_cst(TREE_TYPE(expr), 0));
+
+ case OPERATOR_XOR:
+ return fold_build1_loc(loc, BIT_NOT_EXPR, TREE_TYPE(expr), expr);
+
+ case OPERATOR_AND:
+ // We should not see a non-constant constructor here; cases
+ // where we would see one should have been moved onto the heap
+ // at parse time. Taking the address of a nonconstant
+ // constructor will not do what the programmer expects.
+ gcc_assert(TREE_CODE(expr) != CONSTRUCTOR || TREE_CONSTANT(expr));
+ gcc_assert(TREE_CODE(expr) != ADDR_EXPR);
+
+ // Build a decl for a constant constructor.
+ if (TREE_CODE(expr) == CONSTRUCTOR && TREE_CONSTANT(expr))
+ {
+ tree decl = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(expr));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ TREE_ADDRESSABLE(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = expr;
+ rest_of_decl_compilation(decl, 1, 0);
+ expr = decl;
+ }
+
+ return build_fold_addr_expr_loc(loc, expr);
+
+ case OPERATOR_MULT:
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(expr)));
+
+ // If we are dereferencing the pointer to a large struct, we
+ // need to check for nil. We don't bother to check for small
+ // structs because we expect the system to crash on a nil
+ // pointer dereference.
+ HOST_WIDE_INT s = int_size_in_bytes(TREE_TYPE(TREE_TYPE(expr)));
+ if (s == -1 || s >= 4096)
+ {
+ if (!DECL_P(expr))
+ expr = save_expr(expr);
+ tree compare = fold_build2_loc(loc, EQ_EXPR, boolean_type_node,
+ expr,
+ fold_convert(TREE_TYPE(expr),
+ null_pointer_node));
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE,
+ loc);
+ expr = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(expr),
+ build3(COND_EXPR, void_type_node,
+ compare, crash, NULL_TREE),
+ expr);
+ }
+
+ // If the type of EXPR is a recursive pointer type, then we
+ // need to insert a cast before indirecting.
+ if (TREE_TYPE(TREE_TYPE(expr)) == ptr_type_node)
+ {
+ Type* pt = this->expr_->type()->points_to();
+ tree ind = pt->get_tree(context->gogo());
+ expr = fold_convert_loc(loc, build_pointer_type(ind), expr);
+ }
+
+ return build_fold_indirect_ref_loc(loc, expr);
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Export a unary expression.
+
+void
+Unary_expression::do_export(Export* exp) const
+{
+ switch (this->op_)
+ {
+ case OPERATOR_PLUS:
+ exp->write_c_string("+ ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string("- ");
+ break;
+ case OPERATOR_NOT:
+ exp->write_c_string("! ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string("^ ");
+ break;
+ case OPERATOR_AND:
+ case OPERATOR_MULT:
+ default:
+ gcc_unreachable();
+ }
+ this->expr_->export_expression(exp);
+}
+
+// Import a unary expression.
+
+Expression*
+Unary_expression::do_import(Import* imp)
+{
+ Operator op;
+ switch (imp->get_char())
+ {
+ case '+':
+ op = OPERATOR_PLUS;
+ break;
+ case '-':
+ op = OPERATOR_MINUS;
+ break;
+ case '!':
+ op = OPERATOR_NOT;
+ break;
+ case '^':
+ op = OPERATOR_XOR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+ imp->require_c_string(" ");
+ Expression* expr = Expression::import_expression(imp);
+ return Expression::make_unary(op, expr, imp->location());
+}
+
+// Make a unary expression.
+
+Expression*
+Expression::make_unary(Operator op, Expression* expr, source_location location)
+{
+ return new Unary_expression(op, expr, location);
+}
+
+// If this is an indirection through a pointer, return the expression
+// being pointed through. Otherwise return this.
+
+Expression*
+Expression::deref()
+{
+ if (this->classification_ == EXPRESSION_UNARY)
+ {
+ Unary_expression* ue = static_cast<Unary_expression*>(this);
+ if (ue->op() == OPERATOR_MULT)
+ return ue->operand();
+ }
+ return this;
+}
+
+// Class Binary_expression.
+
+// Traversal.
+
+int
+Binary_expression::do_traverse(Traverse* traverse)
+{
+ int t = Expression::traverse(&this->left_, traverse);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->right_, traverse);
+}
+
+// Compare integer constants according to OP.
+
+bool
+Binary_expression::compare_integer(Operator op, mpz_t left_val,
+ mpz_t right_val)
+{
+ int i = mpz_cmp(left_val, right_val);
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Compare floating point constants according to OP.
+
+bool
+Binary_expression::compare_float(Operator op, Type* type, mpfr_t left_val,
+ mpfr_t right_val)
+{
+ int i;
+ if (type == NULL)
+ i = mpfr_cmp(left_val, right_val);
+ else
+ {
+ mpfr_t lv;
+ mpfr_init_set(lv, left_val, GMP_RNDN);
+ mpfr_t rv;
+ mpfr_init_set(rv, right_val, GMP_RNDN);
+ Float_expression::constrain_float(lv, type);
+ Float_expression::constrain_float(rv, type);
+ i = mpfr_cmp(lv, rv);
+ mpfr_clear(lv);
+ mpfr_clear(rv);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return i == 0;
+ case OPERATOR_NOTEQ:
+ return i != 0;
+ case OPERATOR_LT:
+ return i < 0;
+ case OPERATOR_LE:
+ return i <= 0;
+ case OPERATOR_GT:
+ return i > 0;
+ case OPERATOR_GE:
+ return i >= 0;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Compare complex constants according to OP. Complex numbers may
+// only be compared for equality.
+
+bool
+Binary_expression::compare_complex(Operator op, Type* type,
+ mpfr_t left_real, mpfr_t left_imag,
+ mpfr_t right_real, mpfr_t right_imag)
+{
+ bool is_equal;
+ if (type == NULL)
+ is_equal = (mpfr_cmp(left_real, right_real) == 0
+ && mpfr_cmp(left_imag, right_imag) == 0);
+ else
+ {
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ Complex_expression::constrain_complex(lr, li, type);
+ Complex_expression::constrain_complex(rr, ri, type);
+ is_equal = mpfr_cmp(lr, rr) == 0 && mpfr_cmp(li, ri) == 0;
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ return is_equal;
+ case OPERATOR_NOTEQ:
+ return !is_equal;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// LEFT_TYPE is the type of LEFT_VAL, RIGHT_TYPE is the type of
+// RIGHT_VAL; LEFT_TYPE and/or RIGHT_TYPE may be NULL. Return true if
+// this could be done, false if not.
+
+bool
+Binary_expression::eval_integer(Operator op, Type* left_type, mpz_t left_val,
+ Type* right_type, mpz_t right_val,
+ source_location location, mpz_t val)
+{
+ bool is_shift_op = false;
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpz_add(val, left_val, right_val);
+ break;
+ case OPERATOR_MINUS:
+ mpz_sub(val, left_val, right_val);
+ break;
+ case OPERATOR_OR:
+ mpz_ior(val, left_val, right_val);
+ break;
+ case OPERATOR_XOR:
+ mpz_xor(val, left_val, right_val);
+ break;
+ case OPERATOR_MULT:
+ mpz_mul(val, left_val, right_val);
+ break;
+ case OPERATOR_DIV:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_q(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_MOD:
+ if (mpz_sgn(right_val) != 0)
+ mpz_tdiv_r(val, left_val, right_val);
+ else
+ {
+ error_at(location, "division by zero");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ break;
+ case OPERATOR_LSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0 || shift > 0x100000)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ mpz_mul_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_RSHIFT:
+ {
+ unsigned long shift = mpz_get_ui(right_val);
+ if (mpz_cmp_ui(right_val, shift) != 0)
+ {
+ error_at(location, "shift count overflow");
+ mpz_set_ui(val, 0);
+ return true;
+ }
+ if (mpz_cmp_ui(left_val, 0) >= 0)
+ mpz_tdiv_q_2exp(val, left_val, shift);
+ else
+ mpz_fdiv_q_2exp(val, left_val, shift);
+ is_shift_op = true;
+ break;
+ }
+ break;
+ case OPERATOR_AND:
+ mpz_and(val, left_val, right_val);
+ break;
+ case OPERATOR_BITCLEAR:
+ {
+ mpz_t tval;
+ mpz_init(tval);
+ mpz_com(tval, right_val);
+ mpz_and(val, left_val, tval);
+ mpz_clear(tval);
+ }
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (!is_shift_op)
+ {
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This look like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an
+ // unhelpful chain of error messages.
+ return true;
+ }
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ // We have to check the operands too, as we have implicitly
+ // coerced them to TYPE.
+ if ((type != left_type
+ && !Integer_expression::check_constant(left_val, type, location))
+ || (!is_shift_op
+ && type != right_type
+ && !Integer_expression::check_constant(right_val, type,
+ location))
+ || !Integer_expression::check_constant(val, type, location))
+ mpz_set_ui(val, 0);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_VAL and RIGHT_VAL, setting VAL.
+// Return true if this could be done, false if not.
+
+bool
+Binary_expression::eval_float(Operator op, Type* left_type, mpfr_t left_val,
+ Type* right_type, mpfr_t right_val,
+ mpfr_t val, source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values. We should probably handle them
+ // anyhow in case a type conversion is used on the result.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ mpfr_mul(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_DIV:
+ if (mpfr_zero_p(right_val))
+ error_at(location, "division by zero");
+ mpfr_div(val, left_val, right_val, GMP_RNDN);
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Float_expression::check_constant(left_val, type, location))
+ || (type != right_type
+ && !Float_expression::check_constant(right_val, type,
+ location))
+ || !Float_expression::check_constant(val, type, location))
+ mpfr_set_ui(val, 0, GMP_RNDN);
+ }
+
+ return true;
+}
+
+// Apply binary opcode OP to LEFT_REAL/LEFT_IMAG and
+// RIGHT_REAL/RIGHT_IMAG, setting REAL/IMAG. Return true if this
+// could be done, false if not.
+
+bool
+Binary_expression::eval_complex(Operator op, Type* left_type,
+ mpfr_t left_real, mpfr_t left_imag,
+ Type *right_type,
+ mpfr_t right_real, mpfr_t right_imag,
+ mpfr_t real, mpfr_t imag,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ // These return boolean values and must be handled differently.
+ return false;
+ case OPERATOR_PLUS:
+ mpfr_add(real, left_real, right_real, GMP_RNDN);
+ mpfr_add(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_MINUS:
+ mpfr_sub(real, left_real, right_real, GMP_RNDN);
+ mpfr_sub(imag, left_imag, right_imag, GMP_RNDN);
+ break;
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ return false;
+ case OPERATOR_MULT:
+ {
+ // You might think that multiplying two complex numbers would
+ // be simple, and you would be right, until you start to think
+ // about getting the right answer for infinity. If one
+ // operand here is infinity and the other is anything other
+ // than zero or NaN, then we are going to wind up subtracting
+ // two infinity values. That will give us a NaN, but the
+ // correct answer is infinity.
+
+ mpfr_t lrrr;
+ mpfr_init(lrrr);
+ mpfr_mul(lrrr, left_real, right_real, GMP_RNDN);
+
+ mpfr_t lrri;
+ mpfr_init(lrri);
+ mpfr_mul(lrri, left_real, right_imag, GMP_RNDN);
+
+ mpfr_t lirr;
+ mpfr_init(lirr);
+ mpfr_mul(lirr, left_imag, right_real, GMP_RNDN);
+
+ mpfr_t liri;
+ mpfr_init(liri);
+ mpfr_mul(liri, left_imag, right_imag, GMP_RNDN);
+
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+
+ // If we get NaN on both sides, check whether it should really
+ // be infinity. The rule is that if either side of the
+ // complex number is infinity, then the whole value is
+ // infinity, even if the other side is NaN. So the only case
+ // we have to fix is the one in which both sides are NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ bool is_infinity = false;
+
+ mpfr_t lr;
+ mpfr_t li;
+ mpfr_init_set(lr, left_real, GMP_RNDN);
+ mpfr_init_set(li, left_imag, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+
+ // If the left side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(lr) || mpfr_inf_p(li))
+ {
+ mpfr_set_ui(lr, mpfr_inf_p(lr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ mpfr_set_ui(li, mpfr_inf_p(li) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If the right side is infinity, then the result is
+ // infinity.
+ if (mpfr_inf_p(rr) || mpfr_inf_p(ri))
+ {
+ mpfr_set_ui(rr, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ mpfr_set_ui(ri, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ // If we got an overflow in the intermediate computations,
+ // then the result is infinity.
+ if (!is_infinity
+ && (mpfr_inf_p(lrrr) || mpfr_inf_p(lrri)
+ || mpfr_inf_p(lirr) || mpfr_inf_p(liri)))
+ {
+ if (mpfr_nan_p(lr))
+ {
+ mpfr_set_ui(lr, 0, GMP_RNDN);
+ mpfr_copysign(lr, lr, left_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(li))
+ {
+ mpfr_set_ui(li, 0, GMP_RNDN);
+ mpfr_copysign(li, li, left_imag, GMP_RNDN);
+ }
+ if (mpfr_nan_p(rr))
+ {
+ mpfr_set_ui(rr, 0, GMP_RNDN);
+ mpfr_copysign(rr, rr, right_real, GMP_RNDN);
+ }
+ if (mpfr_nan_p(ri))
+ {
+ mpfr_set_ui(ri, 0, GMP_RNDN);
+ mpfr_copysign(ri, ri, right_imag, GMP_RNDN);
+ }
+ is_infinity = true;
+ }
+
+ if (is_infinity)
+ {
+ mpfr_mul(lrrr, lr, rr, GMP_RNDN);
+ mpfr_mul(lrri, lr, ri, GMP_RNDN);
+ mpfr_mul(lirr, li, rr, GMP_RNDN);
+ mpfr_mul(liri, li, ri, GMP_RNDN);
+ mpfr_sub(real, lrrr, liri, GMP_RNDN);
+ mpfr_add(imag, lrri, lirr, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(real));
+ mpfr_set_inf(imag, mpfr_sgn(imag));
+ }
+
+ mpfr_clear(lr);
+ mpfr_clear(li);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ }
+
+ mpfr_clear(lrrr);
+ mpfr_clear(lrri);
+ mpfr_clear(lirr);
+ mpfr_clear(liri);
+ }
+ break;
+ case OPERATOR_DIV:
+ {
+ // For complex division we want to avoid having an
+ // intermediate overflow turn the whole result in a NaN. We
+ // scale the values to try to avoid this.
+
+ if (mpfr_zero_p(right_real) && mpfr_zero_p(right_imag))
+ error_at(location, "division by zero");
+
+ mpfr_t rra;
+ mpfr_t ria;
+ mpfr_init(rra);
+ mpfr_init(ria);
+ mpfr_abs(rra, right_real, GMP_RNDN);
+ mpfr_abs(ria, right_imag, GMP_RNDN);
+ mpfr_t t;
+ mpfr_init(t);
+ mpfr_max(t, rra, ria, GMP_RNDN);
+
+ mpfr_t rr;
+ mpfr_t ri;
+ mpfr_init_set(rr, right_real, GMP_RNDN);
+ mpfr_init_set(ri, right_imag, GMP_RNDN);
+ long ilogbw = 0;
+ if (!mpfr_inf_p(t) && !mpfr_nan_p(t) && !mpfr_zero_p(t))
+ {
+ ilogbw = mpfr_get_exp(t);
+ mpfr_mul_2si(rr, rr, - ilogbw, GMP_RNDN);
+ mpfr_mul_2si(ri, ri, - ilogbw, GMP_RNDN);
+ }
+
+ mpfr_t denom;
+ mpfr_init(denom);
+ mpfr_mul(denom, rr, rr, GMP_RNDN);
+ mpfr_mul(t, ri, ri, GMP_RNDN);
+ mpfr_add(denom, denom, t, GMP_RNDN);
+
+ mpfr_mul(real, left_real, rr, GMP_RNDN);
+ mpfr_mul(t, left_imag, ri, GMP_RNDN);
+ mpfr_add(real, real, t, GMP_RNDN);
+ mpfr_div(real, real, denom, GMP_RNDN);
+ mpfr_mul_2si(real, real, - ilogbw, GMP_RNDN);
+
+ mpfr_mul(imag, left_imag, rr, GMP_RNDN);
+ mpfr_mul(t, left_real, ri, GMP_RNDN);
+ mpfr_sub(imag, imag, t, GMP_RNDN);
+ mpfr_div(imag, imag, denom, GMP_RNDN);
+ mpfr_mul_2si(imag, imag, - ilogbw, GMP_RNDN);
+
+ // If we wind up with NaN on both sides, check whether we
+ // should really have infinity. The rule is that if either
+ // side of the complex number is infinity, then the whole
+ // value is infinity, even if the other side is NaN. So the
+ // only case we have to fix is the one in which both sides are
+ // NaN.
+ if (mpfr_nan_p(real) && mpfr_nan_p(imag)
+ && (!mpfr_nan_p(left_real) || !mpfr_nan_p(left_imag))
+ && (!mpfr_nan_p(right_real) || !mpfr_nan_p(right_imag)))
+ {
+ if (mpfr_zero_p(denom))
+ {
+ mpfr_set_inf(real, mpfr_sgn(rr));
+ mpfr_mul(real, real, left_real, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(rr));
+ mpfr_mul(imag, imag, left_imag, GMP_RNDN);
+ }
+ else if ((mpfr_inf_p(left_real) || mpfr_inf_p(left_imag))
+ && mpfr_number_p(rr) && mpfr_number_p(ri))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(left_real) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, left_real, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(left_imag) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, left_imag, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, t, rr, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, t2, ri, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(real, mpfr_sgn(t3));
+
+ mpfr_mul(t3, t2, rr, GMP_RNDN);
+ mpfr_mul(t4, t, ri, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_inf(imag, mpfr_sgn(t3));
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ else if ((mpfr_inf_p(right_real) || mpfr_inf_p(right_imag))
+ && mpfr_number_p(left_real) && mpfr_number_p(left_imag))
+ {
+ mpfr_set_ui(t, mpfr_inf_p(rr) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t, t, rr, GMP_RNDN);
+
+ mpfr_t t2;
+ mpfr_init_set_ui(t2, mpfr_inf_p(ri) ? 1 : 0, GMP_RNDN);
+ mpfr_copysign(t2, t2, ri, GMP_RNDN);
+
+ mpfr_t t3;
+ mpfr_init(t3);
+ mpfr_mul(t3, left_real, t, GMP_RNDN);
+
+ mpfr_t t4;
+ mpfr_init(t4);
+ mpfr_mul(t4, left_imag, t2, GMP_RNDN);
+
+ mpfr_add(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_mul(real, real, t3, GMP_RNDN);
+
+ mpfr_mul(t3, left_imag, t, GMP_RNDN);
+ mpfr_mul(t4, left_real, t2, GMP_RNDN);
+ mpfr_sub(t3, t3, t4, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ mpfr_mul(imag, imag, t3, GMP_RNDN);
+
+ mpfr_clear(t2);
+ mpfr_clear(t3);
+ mpfr_clear(t4);
+ }
+ }
+
+ mpfr_clear(denom);
+ mpfr_clear(rr);
+ mpfr_clear(ri);
+ mpfr_clear(t);
+ mpfr_clear(rra);
+ mpfr_clear(ria);
+ }
+ break;
+ case OPERATOR_MOD:
+ return false;
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return false;
+ default:
+ gcc_unreachable();
+ }
+
+ Type* type = left_type;
+ if (type == NULL)
+ type = right_type;
+ else if (type != right_type && right_type != NULL)
+ {
+ if (type->is_abstract())
+ type = right_type;
+ else if (!right_type->is_abstract())
+ {
+ // This looks like a type error which should be diagnosed
+ // elsewhere. Don't do anything here, to avoid an unhelpful
+ // chain of error messages.
+ return true;
+ }
+ }
+
+ if (type != NULL && !type->is_abstract())
+ {
+ if ((type != left_type
+ && !Complex_expression::check_constant(left_real, left_imag,
+ type, location))
+ || (type != right_type
+ && !Complex_expression::check_constant(right_real, right_imag,
+ type, location))
+ || !Complex_expression::check_constant(real, imag, type,
+ location))
+ {
+ mpfr_set_ui(real, 0, GMP_RNDN);
+ mpfr_set_ui(imag, 0, GMP_RNDN);
+ }
+ }
+
+ return true;
+}
+
+// Lower a binary expression. We have to evaluate constant
+// expressions now, in order to implement Go's unlimited precision
+// constants.
+
+Expression*
+Binary_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Operator op = this->op_;
+ Expression* left = this->left_;
+ Expression* right = this->right_;
+
+ const bool is_comparison = (op == OPERATOR_EQEQ
+ || op == OPERATOR_NOTEQ
+ || op == OPERATOR_LT
+ || op == OPERATOR_LE
+ || op == OPERATOR_GT
+ || op == OPERATOR_GE);
+
+ // Integer constant expressions.
+ {
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (left->integer_constant_value(false, left_val, &left_type)
+ && right->integer_constant_value(false, right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_integer(op, left_val,
+ right_val);
+ ret = Expression::make_cast(Type::lookup_bool_type(),
+ Expression::make_boolean(b, location),
+ location);
+ }
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+
+ if (Binary_expression::eval_integer(op, left_type, left_val,
+ right_type, right_val,
+ location, val))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND);
+ Type* type;
+ if (op == OPERATOR_LSHIFT || op == OPERATOR_RSHIFT)
+ type = left_type;
+ else if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_integer(&val, type, location);
+ }
+
+ mpz_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return ret;
+ }
+ }
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ }
+
+ // Floating point constant expressions.
+ {
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (left->float_constant_value(left_val, &left_type)
+ && right->float_constant_value(right_val, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && op != OPERATOR_LSHIFT
+ && op != OPERATOR_RSHIFT)
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (is_comparison)
+ {
+ bool b = Binary_expression::compare_float(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_val, right_val);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t val;
+ mpfr_init(val);
+
+ if (Binary_expression::eval_float(op, left_type, left_val,
+ right_type, right_val, val,
+ location))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->float_type() != NULL)
+ type = left_type;
+ else if (right_type->float_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_float(&val, type, location);
+ }
+
+ mpfr_clear(val);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return ret;
+ }
+ }
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ }
+
+ // Complex constant expressions.
+ {
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+
+ if (left->complex_constant_value(left_real, left_imag, &left_type)
+ && right->complex_constant_value(right_real, right_imag, &right_type))
+ {
+ Expression* ret = NULL;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ {
+ // May be a type error--let it be diagnosed later.
+ }
+ else if (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ)
+ {
+ bool b = Binary_expression::compare_complex(op,
+ (left_type != NULL
+ ? left_type
+ : right_type),
+ left_real,
+ left_imag,
+ right_real,
+ right_imag);
+ ret = Expression::make_boolean(b, location);
+ }
+ else
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ if (Binary_expression::eval_complex(op, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ location))
+ {
+ gcc_assert(op != OPERATOR_OROR && op != OPERATOR_ANDAND
+ && op != OPERATOR_LSHIFT && op != OPERATOR_RSHIFT);
+ Type* type;
+ if (left_type == NULL)
+ type = right_type;
+ else if (right_type == NULL)
+ type = left_type;
+ else if (!left_type->is_abstract()
+ && left_type->named_type() != NULL)
+ type = left_type;
+ else if (!right_type->is_abstract()
+ && right_type->named_type() != NULL)
+ type = right_type;
+ else if (!left_type->is_abstract())
+ type = left_type;
+ else if (!right_type->is_abstract())
+ type = right_type;
+ else if (left_type->complex_type() != NULL)
+ type = left_type;
+ else if (right_type->complex_type() != NULL)
+ type = right_type;
+ else
+ type = left_type;
+ ret = Expression::make_complex(&real, &imag, type,
+ location);
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (ret != NULL)
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return ret;
+ }
+ }
+
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ }
+
+ // String constant expressions.
+ if (op == OPERATOR_PLUS
+ && left->type()->is_string_type()
+ && right->type()->is_string_type())
+ {
+ std::string left_string;
+ std::string right_string;
+ if (left->string_constant_value(&left_string)
+ && right->string_constant_value(&right_string))
+ return Expression::make_string(left_string + right_string, location);
+ }
+
+ return this;
+}
+
+// Return the integer constant value, if it has one.
+
+bool
+Binary_expression::do_integer_constant_value(bool iota_is_constant, mpz_t val,
+ Type** ptype) const
+{
+ mpz_t left_val;
+ mpz_init(left_val);
+ Type* left_type;
+ if (!this->left_->integer_constant_value(iota_is_constant, left_val,
+ &left_type))
+ {
+ mpz_clear(left_val);
+ return false;
+ }
+
+ mpz_t right_val;
+ mpz_init(right_val);
+ Type* right_type;
+ if (!this->right_->integer_constant_value(iota_is_constant, right_val,
+ &right_type))
+ {
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base()
+ && this->op_ != OPERATOR_RSHIFT
+ && this->op_ != OPERATOR_LSHIFT)
+ ret = false;
+ else
+ ret = Binary_expression::eval_integer(this->op_, left_type, left_val,
+ right_type, right_val,
+ this->location(), val);
+
+ mpz_clear(right_val);
+ mpz_clear(left_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the floating point constant value, if it has one.
+
+bool
+Binary_expression::do_float_constant_value(mpfr_t val, Type** ptype) const
+{
+ mpfr_t left_val;
+ mpfr_init(left_val);
+ Type* left_type;
+ if (!this->left_->float_constant_value(left_val, &left_type))
+ {
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ mpfr_t right_val;
+ mpfr_init(right_val);
+ Type* right_type;
+ if (!this->right_->float_constant_value(right_val, &right_type))
+ {
+ mpfr_clear(right_val);
+ mpfr_clear(left_val);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_float(this->op_, left_type, left_val,
+ right_type, right_val,
+ val, this->location());
+
+ mpfr_clear(left_val);
+ mpfr_clear(right_val);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Return the complex constant value, if it has one.
+
+bool
+Binary_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ mpfr_t left_real;
+ mpfr_t left_imag;
+ mpfr_init(left_real);
+ mpfr_init(left_imag);
+ Type* left_type;
+ if (!this->left_->complex_constant_value(left_real, left_imag, &left_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ return false;
+ }
+
+ mpfr_t right_real;
+ mpfr_t right_imag;
+ mpfr_init(right_real);
+ mpfr_init(right_imag);
+ Type* right_type;
+ if (!this->right_->complex_constant_value(right_real, right_imag,
+ &right_type))
+ {
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+ return false;
+ }
+
+ bool ret;
+ if (left_type != right_type
+ && left_type != NULL
+ && right_type != NULL
+ && left_type->base() != right_type->base())
+ ret = false;
+ else
+ ret = Binary_expression::eval_complex(this->op_, left_type,
+ left_real, left_imag,
+ right_type,
+ right_real, right_imag,
+ real, imag,
+ this->location());
+ mpfr_clear(left_real);
+ mpfr_clear(left_imag);
+ mpfr_clear(right_real);
+ mpfr_clear(right_imag);
+
+ if (ret)
+ *ptype = left_type;
+
+ return ret;
+}
+
+// Note that the value is being discarded.
+
+void
+Binary_expression::do_discarding_value()
+{
+ if (this->op_ == OPERATOR_OROR || this->op_ == OPERATOR_ANDAND)
+ this->right_->discarding_value();
+ else
+ this->warn_about_unused_value();
+}
+
+// Get type.
+
+Type*
+Binary_expression::do_type()
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return Type::make_error_type();
+
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Type::lookup_bool_type();
+
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ {
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (left_type->is_error_type())
+ return left_type;
+ else if (right_type->is_error_type())
+ return right_type;
+ else if (!Type::are_compatible_for_binop(left_type, right_type))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return Type::make_error_type();
+ }
+ else if (!left_type->is_abstract() && left_type->named_type() != NULL)
+ return left_type;
+ else if (!right_type->is_abstract() && right_type->named_type() != NULL)
+ return right_type;
+ else if (!left_type->is_abstract())
+ return left_type;
+ else if (!right_type->is_abstract())
+ return right_type;
+ else if (left_type->complex_type() != NULL)
+ return left_type;
+ else if (right_type->complex_type() != NULL)
+ return right_type;
+ else if (left_type->float_type() != NULL)
+ return left_type;
+ else if (right_type->float_type() != NULL)
+ return right_type;
+ else
+ return left_type;
+ }
+
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ return this->left_->type();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Set type for a binary expression.
+
+void
+Binary_expression::do_determine_type(const Type_context* context)
+{
+ Type* tleft = this->left_->type();
+ Type* tright = this->right_->type();
+
+ // Both sides should have the same type, except for the shift
+ // operations. For a comparison, we should ignore the incoming
+ // type.
+
+ bool is_shift_op = (this->op_ == OPERATOR_LSHIFT
+ || this->op_ == OPERATOR_RSHIFT);
+
+ bool is_comparison = (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE);
+
+ Type_context subcontext(*context);
+
+ if (is_comparison)
+ {
+ // In a comparison, the context does not determine the types of
+ // the operands.
+ subcontext.type = NULL;
+ }
+
+ // Set the context for the left hand operand.
+ if (is_shift_op)
+ {
+ // The right hand operand plays no role in determining the type
+ // of the left hand operand. A shift of an abstract integer in
+ // a string context gets special treatment, which may be a
+ // language bug.
+ if (subcontext.type != NULL
+ && subcontext.type->is_string_type()
+ && tleft->is_abstract())
+ error_at(this->location(), "shift of non-integer operand");
+ }
+ else if (!tleft->is_abstract())
+ subcontext.type = tleft;
+ else if (!tright->is_abstract())
+ subcontext.type = tright;
+ else if (subcontext.type == NULL)
+ {
+ if ((tleft->integer_type() != NULL && tright->integer_type() != NULL)
+ || (tleft->float_type() != NULL && tright->float_type() != NULL)
+ || (tleft->complex_type() != NULL && tright->complex_type() != NULL))
+ {
+ // Both sides have an abstract integer, abstract float, or
+ // abstract complex type. Just let CONTEXT determine
+ // whether they may remain abstract or not.
+ }
+ else if (tleft->complex_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->complex_type() != NULL)
+ subcontext.type = tright;
+ else if (tleft->float_type() != NULL)
+ subcontext.type = tleft;
+ else if (tright->float_type() != NULL)
+ subcontext.type = tright;
+ else
+ subcontext.type = tleft;
+
+ if (subcontext.type != NULL && !context->may_be_abstract)
+ subcontext.type = subcontext.type->make_non_abstract_type();
+ }
+
+ this->left_->determine_type(&subcontext);
+
+ // The context for the right hand operand is the same as for the
+ // left hand operand, except for a shift operator.
+ if (is_shift_op)
+ {
+ subcontext.type = Type::lookup_integer_type("uint");
+ subcontext.may_be_abstract = false;
+ }
+
+ this->right_->determine_type(&subcontext);
+}
+
+// Report an error if the binary operator OP does not support TYPE.
+// Return whether the operation is OK. This should not be used for
+// shift.
+
+bool
+Binary_expression::check_operator_type(Operator op, Type* type,
+ source_location location)
+{
+ switch (op)
+ {
+ case OPERATOR_OROR:
+ case OPERATOR_ANDAND:
+ if (!type->is_boolean_type())
+ {
+ error_at(location, "expected boolean type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type()
+ && type->points_to() == NULL
+ && !type->is_nil_type()
+ && !type->is_boolean_type()
+ && type->interface_type() == NULL
+ && (type->array_type() == NULL
+ || type->array_type()->length() != NULL)
+ && type->map_type() == NULL
+ && type->channel_type() == NULL
+ && type->function_type() == NULL)
+ {
+ error_at(location,
+ ("expected integer, floating, complex, string, pointer, "
+ "boolean, interface, slice, map, channel, "
+ "or function type"));
+ return false;
+ }
+ break;
+
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location, "expected integer, floating, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_PLUS:
+ case OPERATOR_PLUSEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL
+ && !type->is_string_type())
+ {
+ error_at(location,
+ "expected integer, floating, complex, or string type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MINUS:
+ case OPERATOR_MINUSEQ:
+ case OPERATOR_MULT:
+ case OPERATOR_MULTEQ:
+ case OPERATOR_DIV:
+ case OPERATOR_DIVEQ:
+ if (type->integer_type() == NULL
+ && type->float_type() == NULL
+ && type->complex_type() == NULL)
+ {
+ error_at(location, "expected integer, floating, or complex type");
+ return false;
+ }
+ break;
+
+ case OPERATOR_MOD:
+ case OPERATOR_MODEQ:
+ case OPERATOR_OR:
+ case OPERATOR_OREQ:
+ case OPERATOR_AND:
+ case OPERATOR_ANDEQ:
+ case OPERATOR_XOR:
+ case OPERATOR_XOREQ:
+ case OPERATOR_BITCLEAR:
+ case OPERATOR_BITCLEAREQ:
+ if (type->integer_type() == NULL)
+ {
+ error_at(location, "expected integer type");
+ return false;
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+
+ return true;
+}
+
+// Check types.
+
+void
+Binary_expression::do_check_types(Gogo*)
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return;
+
+ Type* left_type = this->left_->type();
+ Type* right_type = this->right_->type();
+ if (left_type->is_error_type() || right_type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+
+ if (this->op_ == OPERATOR_EQEQ
+ || this->op_ == OPERATOR_NOTEQ
+ || this->op_ == OPERATOR_LT
+ || this->op_ == OPERATOR_LE
+ || this->op_ == OPERATOR_GT
+ || this->op_ == OPERATOR_GE)
+ {
+ if (!Type::are_assignable(left_type, right_type, NULL)
+ && !Type::are_assignable(right_type, left_type, NULL))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location())
+ || !Binary_expression::check_operator_type(this->op_, right_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else if (this->op_ != OPERATOR_LSHIFT && this->op_ != OPERATOR_RSHIFT)
+ {
+ if (!Type::are_compatible_for_binop(left_type, right_type))
+ {
+ this->report_error(_("incompatible types in binary expression"));
+ return;
+ }
+ if (!Binary_expression::check_operator_type(this->op_, left_type,
+ this->location()))
+ {
+ this->set_is_error();
+ return;
+ }
+ }
+ else
+ {
+ if (left_type->integer_type() == NULL)
+ this->report_error(_("shift of non-integer operand"));
+
+ if (!right_type->is_abstract()
+ && (right_type->integer_type() == NULL
+ || !right_type->integer_type()->is_unsigned()))
+ this->report_error(_("shift count not unsigned integer"));
+ else
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (this->right_->integer_constant_value(true, val, &type))
+ {
+ if (mpz_sgn(val) < 0)
+ this->report_error(_("negative shift count"));
+ }
+ mpz_clear(val);
+ }
+ }
+}
+
+// Get a tree for a binary expression.
+
+tree
+Binary_expression::do_get_tree(Translate_context* context)
+{
+ tree left = this->left_->get_tree(context);
+ tree right = this->right_->get_tree(context);
+
+ if (left == error_mark_node || right == error_mark_node)
+ return error_mark_node;
+
+ enum tree_code code;
+ bool use_left_type = true;
+ bool is_shift_op = false;
+ switch (this->op_)
+ {
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ return Expression::comparison_tree(context, this->op_,
+ this->left_->type(), left,
+ this->right_->type(), right,
+ this->location());
+
+ case OPERATOR_OROR:
+ code = TRUTH_ORIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_ANDAND:
+ code = TRUTH_ANDIF_EXPR;
+ use_left_type = false;
+ break;
+ case OPERATOR_PLUS:
+ code = PLUS_EXPR;
+ break;
+ case OPERATOR_MINUS:
+ code = MINUS_EXPR;
+ break;
+ case OPERATOR_OR:
+ code = BIT_IOR_EXPR;
+ break;
+ case OPERATOR_XOR:
+ code = BIT_XOR_EXPR;
+ break;
+ case OPERATOR_MULT:
+ code = MULT_EXPR;
+ break;
+ case OPERATOR_DIV:
+ {
+ Type *t = this->left_->type();
+ if (t->float_type() != NULL || t->complex_type() != NULL)
+ code = RDIV_EXPR;
+ else
+ code = TRUNC_DIV_EXPR;
+ }
+ break;
+ case OPERATOR_MOD:
+ code = TRUNC_MOD_EXPR;
+ break;
+ case OPERATOR_LSHIFT:
+ code = LSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_RSHIFT:
+ code = RSHIFT_EXPR;
+ is_shift_op = true;
+ break;
+ case OPERATOR_AND:
+ code = BIT_AND_EXPR;
+ break;
+ case OPERATOR_BITCLEAR:
+ right = fold_build1(BIT_NOT_EXPR, TREE_TYPE(right), right);
+ code = BIT_AND_EXPR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ tree type = use_left_type ? TREE_TYPE(left) : TREE_TYPE(right);
+
+ if (this->left_->type()->is_string_type())
+ {
+ gcc_assert(this->op_ == OPERATOR_PLUS);
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_plus_decl;
+ return Gogo::call_builtin(&string_plus_decl,
+ this->location(),
+ "__go_string_plus",
+ 2,
+ string_type,
+ string_type,
+ left,
+ string_type,
+ right);
+ }
+
+ tree compute_type = excess_precision_type(type);
+ if (compute_type != NULL_TREE)
+ {
+ left = ::convert(compute_type, left);
+ right = ::convert(compute_type, right);
+ }
+
+ tree eval_saved = NULL_TREE;
+ if (is_shift_op)
+ {
+ // Make sure the values are evaluated.
+ if (!DECL_P(left) && TREE_SIDE_EFFECTS(left))
+ {
+ left = save_expr(left);
+ eval_saved = left;
+ }
+ if (!DECL_P(right) && TREE_SIDE_EFFECTS(right))
+ {
+ right = save_expr(right);
+ if (eval_saved == NULL_TREE)
+ eval_saved = right;
+ else
+ eval_saved = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ void_type_node, eval_saved, right);
+ }
+ }
+
+ tree ret = fold_build2_loc(this->location(),
+ code,
+ compute_type != NULL_TREE ? compute_type : type,
+ left, right);
+
+ if (compute_type != NULL_TREE)
+ ret = ::convert(type, ret);
+
+ // In Go, a shift larger than the size of the type is well-defined.
+ // This is not true in GENERIC, so we need to insert a conditional.
+ if (is_shift_op)
+ {
+ gcc_assert(INTEGRAL_TYPE_P(TREE_TYPE(left)));
+ gcc_assert(this->left_->type()->integer_type() != NULL);
+ int bits = TYPE_PRECISION(TREE_TYPE(left));
+
+ tree compare = fold_build2(LT_EXPR, boolean_type_node, right,
+ build_int_cst_type(TREE_TYPE(right), bits));
+
+ tree overflow_result = fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node);
+ if (this->op_ == OPERATOR_RSHIFT
+ && !this->left_->type()->integer_type()->is_unsigned())
+ {
+ tree neg = fold_build2_loc(this->location(), LT_EXPR,
+ boolean_type_node, left,
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node));
+ tree neg_one = fold_build2_loc(this->location(),
+ MINUS_EXPR, TREE_TYPE(left),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_zero_node),
+ fold_convert_loc(this->location(),
+ TREE_TYPE(left),
+ integer_one_node));
+ overflow_result = fold_build3_loc(this->location(), COND_EXPR,
+ TREE_TYPE(left), neg, neg_one,
+ overflow_result);
+ }
+
+ ret = fold_build3_loc(this->location(), COND_EXPR, TREE_TYPE(left),
+ compare, ret, overflow_result);
+
+ if (eval_saved != NULL_TREE)
+ ret = fold_build2_loc(this->location(), COMPOUND_EXPR,
+ TREE_TYPE(ret), eval_saved, ret);
+ }
+
+ return ret;
+}
+
+// Export a binary expression.
+
+void
+Binary_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("(");
+ this->left_->export_expression(exp);
+ switch (this->op_)
+ {
+ case OPERATOR_OROR:
+ exp->write_c_string(" || ");
+ break;
+ case OPERATOR_ANDAND:
+ exp->write_c_string(" && ");
+ break;
+ case OPERATOR_EQEQ:
+ exp->write_c_string(" == ");
+ break;
+ case OPERATOR_NOTEQ:
+ exp->write_c_string(" != ");
+ break;
+ case OPERATOR_LT:
+ exp->write_c_string(" < ");
+ break;
+ case OPERATOR_LE:
+ exp->write_c_string(" <= ");
+ break;
+ case OPERATOR_GT:
+ exp->write_c_string(" > ");
+ break;
+ case OPERATOR_GE:
+ exp->write_c_string(" >= ");
+ break;
+ case OPERATOR_PLUS:
+ exp->write_c_string(" + ");
+ break;
+ case OPERATOR_MINUS:
+ exp->write_c_string(" - ");
+ break;
+ case OPERATOR_OR:
+ exp->write_c_string(" | ");
+ break;
+ case OPERATOR_XOR:
+ exp->write_c_string(" ^ ");
+ break;
+ case OPERATOR_MULT:
+ exp->write_c_string(" * ");
+ break;
+ case OPERATOR_DIV:
+ exp->write_c_string(" / ");
+ break;
+ case OPERATOR_MOD:
+ exp->write_c_string(" % ");
+ break;
+ case OPERATOR_LSHIFT:
+ exp->write_c_string(" << ");
+ break;
+ case OPERATOR_RSHIFT:
+ exp->write_c_string(" >> ");
+ break;
+ case OPERATOR_AND:
+ exp->write_c_string(" & ");
+ break;
+ case OPERATOR_BITCLEAR:
+ exp->write_c_string(" &^ ");
+ break;
+ default:
+ gcc_unreachable();
+ }
+ this->right_->export_expression(exp);
+ exp->write_c_string(")");
+}
+
+// Import a binary expression.
+
+Expression*
+Binary_expression::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+
+ Expression* left = Expression::import_expression(imp);
+
+ Operator op;
+ if (imp->match_c_string(" || "))
+ {
+ op = OPERATOR_OROR;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" && "))
+ {
+ op = OPERATOR_ANDAND;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" == "))
+ {
+ op = OPERATOR_EQEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" != "))
+ {
+ op = OPERATOR_NOTEQ;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" < "))
+ {
+ op = OPERATOR_LT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" <= "))
+ {
+ op = OPERATOR_LE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" > "))
+ {
+ op = OPERATOR_GT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" >= "))
+ {
+ op = OPERATOR_GE;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" + "))
+ {
+ op = OPERATOR_PLUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" - "))
+ {
+ op = OPERATOR_MINUS;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" | "))
+ {
+ op = OPERATOR_OR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" ^ "))
+ {
+ op = OPERATOR_XOR;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" * "))
+ {
+ op = OPERATOR_MULT;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" / "))
+ {
+ op = OPERATOR_DIV;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" % "))
+ {
+ op = OPERATOR_MOD;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" << "))
+ {
+ op = OPERATOR_LSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" >> "))
+ {
+ op = OPERATOR_RSHIFT;
+ imp->advance(4);
+ }
+ else if (imp->match_c_string(" & "))
+ {
+ op = OPERATOR_AND;
+ imp->advance(3);
+ }
+ else if (imp->match_c_string(" &^ "))
+ {
+ op = OPERATOR_BITCLEAR;
+ imp->advance(4);
+ }
+ else
+ {
+ error_at(imp->location(), "unrecognized binary operator");
+ return Expression::make_error(imp->location());
+ }
+
+ Expression* right = Expression::import_expression(imp);
+
+ imp->require_c_string(")");
+
+ return Expression::make_binary(op, left, right, imp->location());
+}
+
+// Make a binary expression.
+
+Expression*
+Expression::make_binary(Operator op, Expression* left, Expression* right,
+ source_location location)
+{
+ return new Binary_expression(op, left, right, location);
+}
+
+// Implement a comparison.
+
+tree
+Expression::comparison_tree(Translate_context* context, Operator op,
+ Type* left_type, tree left_tree,
+ Type* right_type, tree right_tree,
+ source_location location)
+{
+ enum tree_code code;
+ switch (op)
+ {
+ case OPERATOR_EQEQ:
+ code = EQ_EXPR;
+ break;
+ case OPERATOR_NOTEQ:
+ code = NE_EXPR;
+ break;
+ case OPERATOR_LT:
+ code = LT_EXPR;
+ break;
+ case OPERATOR_LE:
+ code = LE_EXPR;
+ break;
+ case OPERATOR_GT:
+ code = GT_EXPR;
+ break;
+ case OPERATOR_GE:
+ code = GE_EXPR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ if (left_type->is_string_type() && right_type->is_string_type())
+ {
+ tree string_type = Type::make_string_type()->get_tree(context->gogo());
+ static tree string_compare_decl;
+ left_tree = Gogo::call_builtin(&string_compare_decl,
+ location,
+ "__go_strcmp",
+ 2,
+ integer_type_node,
+ string_type,
+ left_tree,
+ string_type,
+ right_tree);
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+ else if ((left_type->interface_type() != NULL
+ && right_type->interface_type() == NULL
+ && !right_type->is_nil_type())
+ || (left_type->interface_type() == NULL
+ && !left_type->is_nil_type()
+ && right_type->interface_type() != NULL))
+ {
+ // Comparing an interface value to a non-interface value.
+ if (left_type->interface_type() == NULL)
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ // The right operand is not an interface. We need to take its
+ // address if it is not a pointer.
+ tree make_tmp;
+ tree arg;
+ if (right_type->points_to() != NULL)
+ {
+ make_tmp = NULL_TREE;
+ arg = right_tree;
+ }
+ else if (TREE_ADDRESSABLE(TREE_TYPE(right_tree)) || DECL_P(right_tree))
+ {
+ make_tmp = NULL_TREE;
+ arg = build_fold_addr_expr_loc(location, right_tree);
+ if (DECL_P(right_tree))
+ TREE_ADDRESSABLE(right_tree) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(right_tree),
+ get_name(right_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = right_tree;
+ TREE_ADDRESSABLE(tmp) = 1;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ arg = build_fold_addr_expr_loc(location, tmp);
+ }
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+
+ tree descriptor = right_type->type_descriptor_pointer(context->gogo());
+
+ if (left_type->interface_type()->is_empty())
+ {
+ static tree empty_interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_value_compare_decl,
+ location,
+ "__go_empty_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(empty_interface_value_compare_decl) = 0;
+ }
+ else
+ {
+ static tree interface_value_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_value_compare_decl,
+ location,
+ "__go_interface_value_compare",
+ 3,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ ptr_type_node,
+ arg);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is not comparable.
+ TREE_NOTHROW(interface_value_compare_decl) = 0;
+ }
+ right_tree = build_int_cst_type(integer_type_node, 0);
+
+ if (make_tmp != NULL_TREE)
+ left_tree = build2(COMPOUND_EXPR, TREE_TYPE(left_tree), make_tmp,
+ left_tree);
+ }
+ else if (left_type->interface_type() != NULL
+ && right_type->interface_type() != NULL)
+ {
+ if (left_type->interface_type()->is_empty()
+ && right_type->interface_type()->is_empty())
+ {
+ static tree empty_interface_compare_decl;
+ left_tree = Gogo::call_builtin(&empty_interface_compare_decl,
+ location,
+ "__go_empty_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(empty_interface_compare_decl) = 0;
+ }
+ else if (!left_type->interface_type()->is_empty()
+ && !right_type->interface_type()->is_empty())
+ {
+ static tree interface_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_compare_decl,
+ location,
+ "__go_interface_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(interface_compare_decl) = 0;
+ }
+ else
+ {
+ if (left_type->interface_type()->is_empty())
+ {
+ gcc_assert(op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ);
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+ gcc_assert(!left_type->interface_type()->is_empty());
+ gcc_assert(right_type->interface_type()->is_empty());
+ static tree interface_empty_compare_decl;
+ left_tree = Gogo::call_builtin(&interface_empty_compare_decl,
+ location,
+ "__go_interface_empty_compare",
+ 2,
+ integer_type_node,
+ TREE_TYPE(left_tree),
+ left_tree,
+ TREE_TYPE(right_tree),
+ right_tree);
+ if (left_tree == error_mark_node)
+ return error_mark_node;
+ // This can panic if the type is uncomparable.
+ TREE_NOTHROW(interface_empty_compare_decl) = 0;
+ }
+
+ right_tree = build_int_cst_type(integer_type_node, 0);
+ }
+
+ if (left_type->is_nil_type()
+ && (op == OPERATOR_EQEQ || op == OPERATOR_NOTEQ))
+ {
+ std::swap(left_type, right_type);
+ std::swap(left_tree, right_tree);
+ }
+
+ if (right_type->is_nil_type())
+ {
+ if (left_type->array_type() != NULL
+ && left_type->array_type()->length() == NULL)
+ {
+ Array_type* at = left_type->array_type();
+ left_tree = at->value_pointer_tree(context->gogo(), left_tree);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else if (left_type->interface_type() != NULL)
+ {
+ // An interface is nil if the first field is nil.
+ tree left_type_tree = TREE_TYPE(left_tree);
+ gcc_assert(TREE_CODE(left_type_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(left_type_tree);
+ left_tree = build3(COMPONENT_REF, TREE_TYPE(field), left_tree,
+ field, NULL_TREE);
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ else
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(left_tree)));
+ right_tree = fold_convert(TREE_TYPE(left_tree), null_pointer_node);
+ }
+ }
+
+ if (left_tree == error_mark_node || right_tree == error_mark_node)
+ return error_mark_node;
+
+ tree ret = fold_build2(code, boolean_type_node, left_tree, right_tree);
+ if (CAN_HAVE_LOCATION_P(ret))
+ SET_EXPR_LOCATION(ret, location);
+ return ret;
+}
+
+// Class Bound_method_expression.
+
+// Traversal.
+
+int
+Bound_method_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->method_, traverse);
+}
+
+// Return the type of a bound method expression. The type of this
+// object is really the type of the method with no receiver. We
+// should be able to get away with just returning the type of the
+// method.
+
+Type*
+Bound_method_expression::do_type()
+{
+ return this->method_->type();
+}
+
+// Determine the types of a method expression.
+
+void
+Bound_method_expression::do_determine_type(const Type_context*)
+{
+ this->method_->determine_type_no_context();
+ Type* mtype = this->method_->type();
+ Function_type* fntype = mtype == NULL ? NULL : mtype->function_type();
+ if (fntype == NULL || !fntype->is_method())
+ this->expr_->determine_type_no_context();
+ else
+ {
+ Type_context subcontext(fntype->receiver()->type(), false);
+ this->expr_->determine_type(&subcontext);
+ }
+}
+
+// Check the types of a method expression.
+
+void
+Bound_method_expression::do_check_types(Gogo*)
+{
+ Type* type = this->method_->type()->deref();
+ if (type == NULL
+ || type->function_type() == NULL
+ || !type->function_type()->is_method())
+ this->report_error(_("object is not a method"));
+ else
+ {
+ Type* rtype = type->function_type()->receiver()->type()->deref();
+ Type* etype = (this->expr_type_ != NULL
+ ? this->expr_type_
+ : this->expr_->type());
+ etype = etype->deref();
+ if (!Type::are_identical(rtype, etype, true, NULL))
+ this->report_error(_("method type does not match object type"));
+ }
+}
+
+// Get the tree for a method expression. There is no standard tree
+// representation for this. The only places it may currently be used
+// are in a Call_expression or a Go_statement, which will take it
+// apart directly. So this has nothing to do at present.
+
+tree
+Bound_method_expression::do_get_tree(Translate_context*)
+{
+ error_at(this->location(), "reference to method other than calling it");
+ return error_mark_node;
+}
+
+// Make a method expression.
+
+Bound_method_expression*
+Expression::make_bound_method(Expression* expr, Expression* method,
+ source_location location)
+{
+ return new Bound_method_expression(expr, method, location);
+}
+
+// Class Builtin_call_expression. This is used for a call to a
+// builtin function.
+
+class Builtin_call_expression : public Call_expression
+{
+ public:
+ Builtin_call_expression(Gogo* gogo, Expression* fn, Expression_list* args,
+ bool is_varargs, source_location location);
+
+ protected:
+ // This overrides Call_expression::do_lower.
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ bool
+ do_is_constant() const;
+
+ bool
+ do_integer_constant_value(bool, mpz_t, Type**) const;
+
+ bool
+ do_float_constant_value(mpfr_t, Type**) const;
+
+ bool
+ do_complex_constant_value(mpfr_t, mpfr_t, Type**) const;
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Builtin_call_expression(this->gogo_, this->fn()->copy(),
+ this->args()->copy(),
+ this->is_varargs(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ virtual bool
+ do_is_recover_call() const;
+
+ virtual void
+ do_set_recover_arg(Expression*);
+
+ private:
+ // The builtin functions.
+ enum Builtin_function_code
+ {
+ BUILTIN_INVALID,
+
+ // Predeclared builtin functions.
+ BUILTIN_APPEND,
+ BUILTIN_CAP,
+ BUILTIN_CLOSE,
+ BUILTIN_COMPLEX,
+ BUILTIN_COPY,
+ BUILTIN_IMAG,
+ BUILTIN_LEN,
+ BUILTIN_MAKE,
+ BUILTIN_NEW,
+ BUILTIN_PANIC,
+ BUILTIN_PRINT,
+ BUILTIN_PRINTLN,
+ BUILTIN_REAL,
+ BUILTIN_RECOVER,
+
+ // Builtin functions from the unsafe package.
+ BUILTIN_ALIGNOF,
+ BUILTIN_OFFSETOF,
+ BUILTIN_SIZEOF
+ };
+
+ Expression*
+ one_arg() const;
+
+ bool
+ check_one_arg();
+
+ static Type*
+ real_imag_type(Type*);
+
+ static Type*
+ complex_type(Type*);
+
+ // A pointer back to the general IR structure. This avoids a global
+ // variable, or passing it around everywhere.
+ Gogo* gogo_;
+ // The builtin function being called.
+ Builtin_function_code code_;
+ // Used to stop endless loops when the length of an array uses len
+ // or cap of the array itself.
+ mutable bool seen_;
+};
+
+Builtin_call_expression::Builtin_call_expression(Gogo* gogo,
+ Expression* fn,
+ Expression_list* args,
+ bool is_varargs,
+ source_location location)
+ : Call_expression(fn, args, is_varargs, location),
+ gogo_(gogo), code_(BUILTIN_INVALID), seen_(false)
+{
+ Func_expression* fnexp = this->fn()->func_expression();
+ gcc_assert(fnexp != NULL);
+ const std::string& name(fnexp->named_object()->name());
+ if (name == "append")
+ this->code_ = BUILTIN_APPEND;
+ else if (name == "cap")
+ this->code_ = BUILTIN_CAP;
+ else if (name == "close")
+ this->code_ = BUILTIN_CLOSE;
+ else if (name == "complex")
+ this->code_ = BUILTIN_COMPLEX;
+ else if (name == "copy")
+ this->code_ = BUILTIN_COPY;
+ else if (name == "imag")
+ this->code_ = BUILTIN_IMAG;
+ else if (name == "len")
+ this->code_ = BUILTIN_LEN;
+ else if (name == "make")
+ this->code_ = BUILTIN_MAKE;
+ else if (name == "new")
+ this->code_ = BUILTIN_NEW;
+ else if (name == "panic")
+ this->code_ = BUILTIN_PANIC;
+ else if (name == "print")
+ this->code_ = BUILTIN_PRINT;
+ else if (name == "println")
+ this->code_ = BUILTIN_PRINTLN;
+ else if (name == "real")
+ this->code_ = BUILTIN_REAL;
+ else if (name == "recover")
+ this->code_ = BUILTIN_RECOVER;
+ else if (name == "Alignof")
+ this->code_ = BUILTIN_ALIGNOF;
+ else if (name == "Offsetof")
+ this->code_ = BUILTIN_OFFSETOF;
+ else if (name == "Sizeof")
+ this->code_ = BUILTIN_SIZEOF;
+ else
+ gcc_unreachable();
+}
+
+// Return whether this is a call to recover. This is a virtual
+// function called from the parent class.
+
+bool
+Builtin_call_expression::do_is_recover_call() const
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return false;
+ return this->code_ == BUILTIN_RECOVER;
+}
+
+// Set the argument for a call to recover.
+
+void
+Builtin_call_expression::do_set_recover_arg(Expression* arg)
+{
+ const Expression_list* args = this->args();
+ gcc_assert(args == NULL || args->empty());
+ Expression_list* new_args = new Expression_list();
+ new_args->push_back(arg);
+ this->set_args(new_args);
+}
+
+// A traversal class which looks for a call expression.
+
+class Find_call_expression : public Traverse
+{
+ public:
+ Find_call_expression()
+ : Traverse(traverse_expressions),
+ found_(false)
+ { }
+
+ int
+ expression(Expression**);
+
+ bool
+ found()
+ { return this->found_; }
+
+ private:
+ bool found_;
+};
+
+int
+Find_call_expression::expression(Expression** pexpr)
+{
+ if ((*pexpr)->call_expression() != NULL)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a builtin call expression. This turns new and make into
+// specific expressions. We also convert to a constant if we can.
+
+Expression*
+Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ if (this->code_ == BUILTIN_NEW)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 1)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ return Expression::make_allocation(arg->type(), this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_MAKE)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ this->report_error(_("not enough arguments"));
+ else
+ {
+ Expression* arg = args->front();
+ if (!arg->is_type_expression())
+ {
+ error_at(arg->location(), "expected type");
+ this->set_is_error();
+ }
+ else
+ {
+ Expression_list* newargs;
+ if (args->size() == 1)
+ newargs = NULL;
+ else
+ {
+ newargs = new Expression_list();
+ Expression_list::const_iterator p = args->begin();
+ ++p;
+ for (; p != args->end(); ++p)
+ newargs->push_back(*p);
+ }
+ return Expression::make_make(arg->type(), newargs,
+ this->location());
+ }
+ }
+ }
+ else if (this->is_constant())
+ {
+ // We can only lower len and cap if there are no function calls
+ // in the arguments. Otherwise we have to make the call.
+ if (this->code_ == BUILTIN_LEN || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (!arg->is_constant())
+ {
+ Find_call_expression find_call;
+ Expression::traverse(&arg, &find_call);
+ if (find_call.found())
+ return this;
+ }
+ }
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* type;
+ if (this->integer_constant_value(true, ival, &type))
+ {
+ Expression* ret = Expression::make_integer(&ival, type,
+ this->location());
+ mpz_clear(ival);
+ return ret;
+ }
+ mpz_clear(ival);
+
+ mpfr_t rval;
+ mpfr_init(rval);
+ if (this->float_constant_value(rval, &type))
+ {
+ Expression* ret = Expression::make_float(&rval, type,
+ this->location());
+ mpfr_clear(rval);
+ return ret;
+ }
+
+ mpfr_t imag;
+ mpfr_init(imag);
+ if (this->complex_constant_value(rval, imag, &type))
+ {
+ Expression* ret = Expression::make_complex(&rval, &imag, type,
+ this->location());
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ return ret;
+ }
+ mpfr_clear(rval);
+ mpfr_clear(imag);
+ }
+ else if (this->code_ == BUILTIN_RECOVER)
+ {
+ if (function != NULL)
+ function->func_value()->set_calls_recover();
+ else
+ {
+ // Calling recover outside of a function always returns the
+ // nil empty interface.
+ Type* eface = Type::make_interface_type(NULL, this->location());
+ return Expression::make_cast(eface,
+ Expression::make_nil(this->location()),
+ this->location());
+ }
+ }
+ else if (this->code_ == BUILTIN_APPEND)
+ {
+ // Lower the varargs.
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return this;
+ Type* slice_type = args->front()->type();
+ if (!slice_type->is_open_array_type())
+ {
+ error_at(args->front()->location(), "argument 1 must be a slice");
+ this->set_is_error();
+ return this;
+ }
+ return this->lower_varargs(gogo, function, slice_type, 2);
+ }
+
+ return this;
+}
+
+// Return the type of the real or imag functions, given the type of
+// the argument. We need to map complex to float, complex64 to
+// float32, and complex128 to float64, so it has to be done by name.
+// This returns NULL if it can't figure out the type.
+
+Type*
+Builtin_call_expression::real_imag_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "complex64")
+ return Type::lookup_float_type("float32");
+ else if (nt->name() == "complex128")
+ return Type::lookup_float_type("float64");
+ else
+ return NULL;
+}
+
+// Return the type of the complex function, given the type of one of the
+// argments. Like real_imag_type, we have to map by name.
+
+Type*
+Builtin_call_expression::complex_type(Type* arg_type)
+{
+ if (arg_type == NULL || arg_type->is_abstract())
+ return NULL;
+ Named_type* nt = arg_type->named_type();
+ if (nt == NULL)
+ return NULL;
+ while (nt->real_type()->named_type() != NULL)
+ nt = nt->real_type()->named_type();
+ if (nt->name() == "float32")
+ return Type::lookup_complex_type("complex64");
+ else if (nt->name() == "float64")
+ return Type::lookup_complex_type("complex128");
+ else
+ return NULL;
+}
+
+// Return a single argument, or NULL if there isn't one.
+
+Expression*
+Builtin_call_expression::one_arg() const
+{
+ const Expression_list* args = this->args();
+ if (args->size() != 1)
+ return NULL;
+ return args->front();
+}
+
+// Return whether this is constant: len of a string, or len or cap of
+// a fixed array, or unsafe.Sizeof, unsafe.Offsetof, unsafe.Alignof.
+
+bool
+Builtin_call_expression::do_is_constant() const
+{
+ switch (this->code_)
+ {
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ if (this->seen_)
+ return false;
+
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ return true;
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ {
+ this->seen_ = true;
+ bool ret = arg->is_constant();
+ this->seen_ = false;
+ return ret;
+ }
+ }
+ break;
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ return this->one_arg() != NULL;
+
+ case BUILTIN_OFFSETOF:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ return arg->field_reference_expression() != NULL;
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args != NULL && args->size() == 2)
+ return args->front()->is_constant() && args->back()->is_constant();
+ }
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ return arg != NULL && arg->is_constant();
+ }
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
+// Return an integer constant value if possible.
+
+bool
+Builtin_call_expression::do_integer_constant_value(bool iota_is_constant,
+ mpz_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_LEN
+ || this->code_ == BUILTIN_CAP)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+
+ if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
+ {
+ std::string sval;
+ if (arg->string_constant_value(&sval))
+ {
+ mpz_set_ui(val, sval.length());
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+
+ if (arg_type->array_type() != NULL
+ && arg_type->array_type()->length() != NULL)
+ {
+ if (this->seen_)
+ return false;
+ Expression* e = arg_type->array_type()->length();
+ this->seen_ = true;
+ bool r = e->integer_constant_value(iota_is_constant, val, ptype);
+ this->seen_ = false;
+ if (r)
+ {
+ *ptype = Type::lookup_integer_type("int");
+ return true;
+ }
+ }
+ }
+ else if (this->code_ == BUILTIN_SIZEOF
+ || this->code_ == BUILTIN_ALIGNOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Type* arg_type = arg->type();
+ if (arg_type->is_error_type() || arg_type->is_undefined())
+ return false;
+ if (arg_type->is_abstract())
+ return false;
+ if (arg_type->named_type() != NULL)
+ arg_type->named_type()->convert(this->gogo_);
+ tree arg_type_tree = arg_type->get_tree(this->gogo_);
+ if (arg_type_tree == error_mark_node)
+ return false;
+ unsigned long val_long;
+ if (this->code_ == BUILTIN_SIZEOF)
+ {
+ tree type_size = TYPE_SIZE_UNIT(arg_type_tree);
+ gcc_assert(TREE_CODE(type_size) == INTEGER_CST);
+ if (TREE_INT_CST_HIGH(type_size) != 0)
+ return false;
+ unsigned HOST_WIDE_INT val_wide = TREE_INT_CST_LOW(type_size);
+ val_long = static_cast<unsigned long>(val_wide);
+ if (val_long != val_wide)
+ return false;
+ }
+ else if (this->code_ == BUILTIN_ALIGNOF)
+ {
+ if (arg->field_reference_expression() == NULL)
+ val_long = go_type_alignment(arg_type_tree);
+ else
+ {
+ // Calling unsafe.Alignof(s.f) returns the alignment of
+ // the type of f when it is used as a field in a struct.
+ val_long = go_field_alignment(arg_type_tree);
+ }
+ }
+ else
+ gcc_unreachable();
+ mpz_set_ui(val, val_long);
+ *ptype = NULL;
+ return true;
+ }
+ else if (this->code_ == BUILTIN_OFFSETOF)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+ Field_reference_expression* farg = arg->field_reference_expression();
+ if (farg == NULL)
+ return false;
+ Expression* struct_expr = farg->expr();
+ Type* st = struct_expr->type();
+ if (st->struct_type() == NULL)
+ return false;
+ if (st->named_type() != NULL)
+ st->named_type()->convert(this->gogo_);
+ tree struct_tree = st->get_tree(this->gogo_);
+ gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(struct_tree);
+ for (unsigned int index = farg->field_index(); index > 0; --index)
+ {
+ field = DECL_CHAIN(field);
+ gcc_assert(field != NULL_TREE);
+ }
+ HOST_WIDE_INT offset_wide = int_byte_position (field);
+ if (offset_wide < 0)
+ return false;
+ unsigned long offset_long = static_cast<unsigned long>(offset_wide);
+ if (offset_long != static_cast<unsigned HOST_WIDE_INT>(offset_wide))
+ return false;
+ mpz_set_ui(val, offset_long);
+ return true;
+ }
+ return false;
+}
+
+// Return a floating point constant value if possible.
+
+bool
+Builtin_call_expression::do_float_constant_value(mpfr_t val,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_REAL || this->code_ == BUILTIN_IMAG)
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return false;
+
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+
+ bool ret = false;
+ Type* type;
+ if (arg->complex_constant_value(real, imag, &type))
+ {
+ if (this->code_ == BUILTIN_REAL)
+ mpfr_set(val, real, GMP_RNDN);
+ else
+ mpfr_set(val, imag, GMP_RNDN);
+ *ptype = Builtin_call_expression::real_imag_type(type);
+ ret = true;
+ }
+
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ return ret;
+ }
+
+ return false;
+}
+
+// Return a complex constant value if possible.
+
+bool
+Builtin_call_expression::do_complex_constant_value(mpfr_t real, mpfr_t imag,
+ Type** ptype) const
+{
+ if (this->code_ == BUILTIN_COMPLEX)
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return false;
+
+ mpfr_t r;
+ mpfr_init(r);
+ Type* rtype;
+ if (!args->front()->float_constant_value(r, &rtype))
+ {
+ mpfr_clear(r);
+ return false;
+ }
+
+ mpfr_t i;
+ mpfr_init(i);
+
+ bool ret = false;
+ Type* itype;
+ if (args->back()->float_constant_value(i, &itype)
+ && Type::are_identical(rtype, itype, false, NULL))
+ {
+ mpfr_set(real, r, GMP_RNDN);
+ mpfr_set(imag, i, GMP_RNDN);
+ *ptype = Builtin_call_expression::complex_type(rtype);
+ ret = true;
+ }
+
+ mpfr_clear(r);
+ mpfr_clear(i);
+
+ return ret;
+ }
+
+ return false;
+}
+
+// Return the type.
+
+Type*
+Builtin_call_expression::do_type()
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ default:
+ gcc_unreachable();
+
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return Type::make_pointer_type(args->front()->type());
+ }
+
+ case BUILTIN_CAP:
+ case BUILTIN_COPY:
+ case BUILTIN_LEN:
+ case BUILTIN_ALIGNOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_SIZEOF:
+ return Type::lookup_integer_type("int");
+
+ case BUILTIN_CLOSE:
+ case BUILTIN_PANIC:
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ return Type::make_void_type();
+
+ case BUILTIN_RECOVER:
+ return Type::make_interface_type(NULL, BUILTINS_LOCATION);
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->empty())
+ return Type::make_error_type();
+ return args->front()->type();
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ Expression* arg = this->one_arg();
+ if (arg == NULL)
+ return Type::make_error_type();
+ Type* t = arg->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ t = Builtin_call_expression::real_imag_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() != 2)
+ return Type::make_error_type();
+ Type* t = args->front()->type();
+ if (t->is_abstract())
+ {
+ t = args->back()->type();
+ if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ }
+ t = Builtin_call_expression::complex_type(t);
+ if (t == NULL)
+ t = Type::make_error_type();
+ return t;
+ }
+ }
+}
+
+// Determine the type.
+
+void
+Builtin_call_expression::do_determine_type(const Type_context* context)
+{
+ if (!this->determining_types())
+ return;
+
+ this->fn()->determine_type_no_context();
+
+ const Expression_list* args = this->args();
+
+ bool is_print;
+ Type* arg_type = NULL;
+ switch (this->code_)
+ {
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ // Do not force a large integer constant to "int".
+ is_print = true;
+ break;
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ arg_type = Builtin_call_expression::complex_type(context->type);
+ is_print = false;
+ break;
+
+ case BUILTIN_COMPLEX:
+ {
+ // For the complex function the type of one operand can
+ // determine the type of the other, as in a binary expression.
+ arg_type = Builtin_call_expression::real_imag_type(context->type);
+ if (args != NULL && args->size() == 2)
+ {
+ Type* t1 = args->front()->type();
+ Type* t2 = args->front()->type();
+ if (!t1->is_abstract())
+ arg_type = t1;
+ else if (!t2->is_abstract())
+ arg_type = t2;
+ }
+ is_print = false;
+ }
+ break;
+
+ default:
+ is_print = false;
+ break;
+ }
+
+ if (args != NULL)
+ {
+ for (Expression_list::const_iterator pa = args->begin();
+ pa != args->end();
+ ++pa)
+ {
+ Type_context subcontext;
+ subcontext.type = arg_type;
+
+ if (is_print)
+ {
+ // We want to print large constants, we so can't just
+ // use the appropriate nonabstract type. Use uint64 for
+ // an integer if we know it is nonnegative, otherwise
+ // use int64 for a integer, otherwise use float64 for a
+ // float or complex128 for a complex.
+ Type* want_type = NULL;
+ Type* atype = (*pa)->type();
+ if (atype->is_abstract())
+ {
+ if (atype->integer_type() != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy)
+ && mpz_sgn(val) >= 0)
+ want_type = Type::lookup_integer_type("uint64");
+ else
+ want_type = Type::lookup_integer_type("int64");
+ mpz_clear(val);
+ }
+ else if (atype->float_type() != NULL)
+ want_type = Type::lookup_float_type("float64");
+ else if (atype->complex_type() != NULL)
+ want_type = Type::lookup_complex_type("complex128");
+ else if (atype->is_abstract_string_type())
+ want_type = Type::lookup_string_type();
+ else if (atype->is_abstract_boolean_type())
+ want_type = Type::lookup_bool_type();
+ else
+ gcc_unreachable();
+ subcontext.type = want_type;
+ }
+ }
+
+ (*pa)->determine_type(&subcontext);
+ }
+ }
+}
+
+// If there is exactly one argument, return true. Otherwise give an
+// error message and return false.
+
+bool
+Builtin_call_expression::check_one_arg()
+{
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 1)
+ {
+ this->report_error(_("not enough arguments"));
+ return false;
+ }
+ else if (args->size() > 1)
+ {
+ this->report_error(_("too many arguments"));
+ return false;
+ }
+ if (args->front()->is_error_expression()
+ || args->front()->type()->is_error_type()
+ || args->front()->type()->is_undefined())
+ {
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check argument types for a builtin function.
+
+void
+Builtin_call_expression::do_check_types(Gogo*)
+{
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ return;
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ // The single argument may be either a string or an array or a
+ // map or a channel, or a pointer to a closed array.
+ if (this->check_one_arg())
+ {
+ Type* arg_type = this->one_arg()->type();
+ if (arg_type->points_to() != NULL
+ && arg_type->points_to()->array_type() != NULL
+ && !arg_type->points_to()->is_open_array_type())
+ arg_type = arg_type->points_to();
+ if (this->code_ == BUILTIN_CAP)
+ {
+ if (!arg_type->is_error_type()
+ && arg_type->array_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be array or slice "
+ "or channel"));
+ }
+ else
+ {
+ if (!arg_type->is_error_type()
+ && !arg_type->is_string_type()
+ && arg_type->array_type() == NULL
+ && arg_type->map_type() == NULL
+ && arg_type->channel_type() == NULL)
+ this->report_error(_("argument must be string or "
+ "array or slice or map or channel"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL)
+ {
+ if (this->code_ == BUILTIN_PRINT)
+ warning_at(this->location(), 0,
+ "no arguments for builtin function %<%s%>",
+ (this->code_ == BUILTIN_PRINT
+ ? "print"
+ : "println"));
+ }
+ else
+ {
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p)
+ {
+ Type* type = (*p)->type();
+ if (type->is_error_type()
+ || type->is_string_type()
+ || type->integer_type() != NULL
+ || type->float_type() != NULL
+ || type->complex_type() != NULL
+ || type->is_boolean_type()
+ || type->points_to() != NULL
+ || type->interface_type() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL
+ || type->is_open_array_type())
+ ;
+ else
+ this->report_error(_("unsupported argument type to "
+ "builtin function"));
+ }
+ }
+ }
+ break;
+
+ case BUILTIN_CLOSE:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->channel_type() == NULL)
+ this->report_error(_("argument must be channel"));
+ }
+ break;
+
+ case BUILTIN_PANIC:
+ case BUILTIN_SIZEOF:
+ case BUILTIN_ALIGNOF:
+ this->check_one_arg();
+ break;
+
+ case BUILTIN_RECOVER:
+ if (this->args() != NULL && !this->args()->empty())
+ this->report_error(_("too many arguments"));
+ break;
+
+ case BUILTIN_OFFSETOF:
+ if (this->check_one_arg())
+ {
+ Expression* arg = this->one_arg();
+ if (arg->field_reference_expression() == NULL)
+ this->report_error(_("argument must be a field reference"));
+ }
+ break;
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ else if (args->size() > 2)
+ {
+ this->report_error(_("too many arguments"));
+ break;
+ }
+ Type* arg1_type = args->front()->type();
+ Type* arg2_type = args->back()->type();
+ if (arg1_type->is_error_type() || arg2_type->is_error_type())
+ break;
+
+ Type* e1;
+ if (arg1_type->is_open_array_type())
+ e1 = arg1_type->array_type()->element_type();
+ else
+ {
+ this->report_error(_("left argument must be a slice"));
+ break;
+ }
+
+ Type* e2;
+ if (arg2_type->is_open_array_type())
+ e2 = arg2_type->array_type()->element_type();
+ else if (arg2_type->is_string_type())
+ e2 = Type::lookup_integer_type("uint8");
+ else
+ {
+ this->report_error(_("right argument must be a slice or a string"));
+ break;
+ }
+
+ if (!Type::are_identical(e1, e2, true, NULL))
+ this->report_error(_("element types must be the same"));
+ }
+ break;
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ {
+ this->report_error(_("not enough arguments"));
+ break;
+ }
+ if (args->size() > 2)
+ {
+ this->report_error(_("too many arguments"));
+ break;
+ }
+ std::string reason;
+ if (!Type::are_assignable(args->front()->type(), args->back()->type(),
+ &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("arguments 1 and 2 have different types"));
+ else
+ {
+ error_at(this->location(),
+ "arguments 1 and 2 have different types (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ break;
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ if (this->check_one_arg())
+ {
+ if (this->one_arg()->type()->complex_type() == NULL)
+ this->report_error(_("argument must have complex type"));
+ }
+ break;
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ if (args == NULL || args->size() < 2)
+ this->report_error(_("not enough arguments"));
+ else if (args->size() > 2)
+ this->report_error(_("too many arguments"));
+ else if (args->front()->is_error_expression()
+ || args->front()->type()->is_error_type()
+ || args->back()->is_error_expression()
+ || args->back()->type()->is_error_type())
+ this->set_is_error();
+ else if (!Type::are_identical(args->front()->type(),
+ args->back()->type(), true, NULL))
+ this->report_error(_("complex arguments must have identical types"));
+ else if (args->front()->type()->float_type() == NULL)
+ this->report_error(_("complex arguments must have "
+ "floating-point type"));
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return the tree for a builtin function.
+
+tree
+Builtin_call_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+ switch (this->code_)
+ {
+ case BUILTIN_INVALID:
+ case BUILTIN_NEW:
+ case BUILTIN_MAKE:
+ gcc_unreachable();
+
+ case BUILTIN_LEN:
+ case BUILTIN_CAP:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = *args->begin();
+ Type* arg_type = arg->type();
+
+ if (this->seen_)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+
+ tree arg_tree = arg->get_tree(context);
+
+ this->seen_ = false;
+
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ if (arg_type->points_to() != NULL)
+ {
+ arg_type = arg_type->points_to();
+ gcc_assert(arg_type->array_type() != NULL
+ && !arg_type->is_open_array_type());
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(arg_tree)));
+ arg_tree = build_fold_indirect_ref(arg_tree);
+ }
+
+ tree val_tree;
+ if (this->code_ == BUILTIN_LEN)
+ {
+ if (arg_type->is_string_type())
+ val_tree = String_type::length_tree(gogo, arg_tree);
+ else if (arg_type->array_type() != NULL)
+ {
+ if (this->seen_)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+ val_tree = arg_type->array_type()->length_tree(gogo, arg_tree);
+ this->seen_ = false;
+ }
+ else if (arg_type->map_type() != NULL)
+ {
+ static tree map_len_fndecl;
+ val_tree = Gogo::call_builtin(&map_len_fndecl,
+ location,
+ "__go_map_len",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_len_fndecl;
+ val_tree = Gogo::call_builtin(&chan_len_fndecl,
+ location,
+ "__go_chan_len",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ gcc_unreachable();
+ }
+ else
+ {
+ if (arg_type->array_type() != NULL)
+ {
+ if (this->seen_)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ this->seen_ = true;
+ val_tree = arg_type->array_type()->capacity_tree(gogo,
+ arg_tree);
+ this->seen_ = false;
+ }
+ else if (arg_type->channel_type() != NULL)
+ {
+ static tree chan_cap_fndecl;
+ val_tree = Gogo::call_builtin(&chan_cap_fndecl,
+ location,
+ "__go_chan_cap",
+ 1,
+ sizetype,
+ arg_type->get_tree(gogo),
+ arg_tree);
+ }
+ else
+ gcc_unreachable();
+ }
+
+ if (val_tree == error_mark_node)
+ return error_mark_node;
+
+ tree type_tree = Type::lookup_integer_type("int")->get_tree(gogo);
+ if (type_tree == TREE_TYPE(val_tree))
+ return val_tree;
+ else
+ return fold(convert_to_integer(type_tree, val_tree));
+ }
+
+ case BUILTIN_PRINT:
+ case BUILTIN_PRINTLN:
+ {
+ const bool is_ln = this->code_ == BUILTIN_PRINTLN;
+ tree stmt_list = NULL_TREE;
+
+ const Expression_list* call_args = this->args();
+ if (call_args != NULL)
+ {
+ for (Expression_list::const_iterator p = call_args->begin();
+ p != call_args->end();
+ ++p)
+ {
+ if (is_ln && p != call_args->begin())
+ {
+ static tree print_space_fndecl;
+ tree call = Gogo::call_builtin(&print_space_fndecl,
+ location,
+ "__go_print_space",
+ 0,
+ void_type_node);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ Type* type = (*p)->type();
+
+ tree arg = (*p)->get_tree(context);
+ if (arg == error_mark_node)
+ return error_mark_node;
+
+ tree* pfndecl;
+ const char* fnname;
+ if (type->is_string_type())
+ {
+ static tree print_string_fndecl;
+ pfndecl = &print_string_fndecl;
+ fnname = "__go_print_string";
+ }
+ else if (type->integer_type() != NULL
+ && type->integer_type()->is_unsigned())
+ {
+ static tree print_uint64_fndecl;
+ pfndecl = &print_uint64_fndecl;
+ fnname = "__go_print_uint64";
+ Type* itype = Type::lookup_integer_type("uint64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->integer_type() != NULL)
+ {
+ static tree print_int64_fndecl;
+ pfndecl = &print_int64_fndecl;
+ fnname = "__go_print_int64";
+ Type* itype = Type::lookup_integer_type("int64");
+ arg = fold_convert_loc(location, itype->get_tree(gogo),
+ arg);
+ }
+ else if (type->float_type() != NULL)
+ {
+ static tree print_double_fndecl;
+ pfndecl = &print_double_fndecl;
+ fnname = "__go_print_double";
+ arg = fold_convert_loc(location, double_type_node, arg);
+ }
+ else if (type->complex_type() != NULL)
+ {
+ static tree print_complex_fndecl;
+ pfndecl = &print_complex_fndecl;
+ fnname = "__go_print_complex";
+ arg = fold_convert_loc(location, complex_double_type_node,
+ arg);
+ }
+ else if (type->is_boolean_type())
+ {
+ static tree print_bool_fndecl;
+ pfndecl = &print_bool_fndecl;
+ fnname = "__go_print_bool";
+ }
+ else if (type->points_to() != NULL
+ || type->channel_type() != NULL
+ || type->map_type() != NULL
+ || type->function_type() != NULL)
+ {
+ static tree print_pointer_fndecl;
+ pfndecl = &print_pointer_fndecl;
+ fnname = "__go_print_pointer";
+ arg = fold_convert_loc(location, ptr_type_node, arg);
+ }
+ else if (type->interface_type() != NULL)
+ {
+ if (type->interface_type()->is_empty())
+ {
+ static tree print_empty_interface_fndecl;
+ pfndecl = &print_empty_interface_fndecl;
+ fnname = "__go_print_empty_interface";
+ }
+ else
+ {
+ static tree print_interface_fndecl;
+ pfndecl = &print_interface_fndecl;
+ fnname = "__go_print_interface";
+ }
+ }
+ else if (type->is_open_array_type())
+ {
+ static tree print_slice_fndecl;
+ pfndecl = &print_slice_fndecl;
+ fnname = "__go_print_slice";
+ }
+ else
+ gcc_unreachable();
+
+ tree call = Gogo::call_builtin(pfndecl,
+ location,
+ fnname,
+ 1,
+ void_type_node,
+ TREE_TYPE(arg),
+ arg);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+ }
+
+ if (is_ln)
+ {
+ static tree print_nl_fndecl;
+ tree call = Gogo::call_builtin(&print_nl_fndecl,
+ location,
+ "__go_print_nl",
+ 0,
+ void_type_node);
+ if (call == error_mark_node)
+ return error_mark_node;
+ append_to_statement_list(call, &stmt_list);
+ }
+
+ return stmt_list;
+ }
+
+ case BUILTIN_PANIC:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ arg_tree = Expression::convert_for_assignment(context, empty,
+ arg->type(),
+ arg_tree, location);
+ static tree panic_fndecl;
+ tree call = Gogo::call_builtin(&panic_fndecl,
+ location,
+ "__go_panic",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This function will throw an exception.
+ TREE_NOTHROW(panic_fndecl) = 0;
+ // This function will not return.
+ TREE_THIS_VOLATILE(panic_fndecl) = 1;
+ return call;
+ }
+
+ case BUILTIN_RECOVER:
+ {
+ // The argument is set when building recover thunks. It's a
+ // boolean value which is true if we can recover a value now.
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+
+ Type *empty = Type::make_interface_type(NULL, BUILTINS_LOCATION);
+ tree empty_tree = empty->get_tree(context->gogo());
+
+ Type* nil_type = Type::make_nil_type();
+ Expression* nil = Expression::make_nil(location);
+ tree nil_tree = nil->get_tree(context);
+ tree empty_nil_tree = Expression::convert_for_assignment(context,
+ empty,
+ nil_type,
+ nil_tree,
+ location);
+
+ // We need to handle a deferred call to recover specially,
+ // because it changes whether it can recover a panic or not.
+ // See test7 in test/recover1.go.
+ tree call;
+ if (this->is_deferred())
+ {
+ static tree deferred_recover_fndecl;
+ call = Gogo::call_builtin(&deferred_recover_fndecl,
+ location,
+ "__go_deferred_recover",
+ 0,
+ empty_tree);
+ }
+ else
+ {
+ static tree recover_fndecl;
+ call = Gogo::call_builtin(&recover_fndecl,
+ location,
+ "__go_recover",
+ 0,
+ empty_tree);
+ }
+ if (call == error_mark_node)
+ return error_mark_node;
+ return fold_build3_loc(location, COND_EXPR, empty_tree, arg_tree,
+ call, empty_nil_tree);
+ }
+
+ case BUILTIN_CLOSE:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ static tree close_fndecl;
+ return Gogo::call_builtin(&close_fndecl,
+ location,
+ "__go_builtin_close",
+ 1,
+ void_type_node,
+ TREE_TYPE(arg_tree),
+ arg_tree);
+ }
+
+ case BUILTIN_SIZEOF:
+ case BUILTIN_OFFSETOF:
+ case BUILTIN_ALIGNOF:
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ bool b = this->integer_constant_value(true, val, &dummy);
+ if (!b)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ tree type = Type::lookup_integer_type("int")->get_tree(gogo);
+ tree ret = Expression::integer_constant_tree(val, type);
+ mpz_clear(val);
+ return ret;
+ }
+
+ case BUILTIN_COPY:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ Type* arg1_type = arg1->type();
+ Array_type* at = arg1_type->array_type();
+ arg1_tree = save_expr(arg1_tree);
+ tree arg1_val = at->value_pointer_tree(gogo, arg1_tree);
+ tree arg1_len = at->length_tree(gogo, arg1_tree);
+ if (arg1_val == error_mark_node || arg1_len == error_mark_node)
+ return error_mark_node;
+
+ Type* arg2_type = arg2->type();
+ tree arg2_val;
+ tree arg2_len;
+ if (arg2_type->is_open_array_type())
+ {
+ at = arg2_type->array_type();
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ arg2_len = at->length_tree(gogo, arg2_tree);
+ }
+ else
+ {
+ arg2_tree = save_expr(arg2_tree);
+ arg2_val = String_type::bytes_tree(gogo, arg2_tree);
+ arg2_len = String_type::length_tree(gogo, arg2_tree);
+ }
+ if (arg2_val == error_mark_node || arg2_len == error_mark_node)
+ return error_mark_node;
+
+ arg1_len = save_expr(arg1_len);
+ arg2_len = save_expr(arg2_len);
+ tree len = fold_build3_loc(location, COND_EXPR, TREE_TYPE(arg1_len),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ arg1_len, arg2_len),
+ arg1_len, arg2_len);
+ len = save_expr(len);
+
+ Type* element_type = at->element_type();
+ tree element_type_tree = element_type->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree bytecount = fold_convert_loc(location, TREE_TYPE(element_size),
+ len);
+ bytecount = fold_build2_loc(location, MULT_EXPR,
+ TREE_TYPE(element_size),
+ bytecount, element_size);
+ bytecount = fold_convert_loc(location, size_type_node, bytecount);
+
+ arg1_val = fold_convert_loc(location, ptr_type_node, arg1_val);
+ arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
+
+ static tree copy_fndecl;
+ tree call = Gogo::call_builtin(©_fndecl,
+ location,
+ "__go_copy",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ arg1_val,
+ ptr_type_node,
+ arg2_val,
+ size_type_node,
+ bytecount);
+ if (call == error_mark_node)
+ return error_mark_node;
+
+ return fold_build2_loc(location, COMPOUND_EXPR, TREE_TYPE(len),
+ call, len);
+ }
+
+ case BUILTIN_APPEND:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ Expression* arg1 = args->front();
+ Expression* arg2 = args->back();
+
+ tree arg1_tree = arg1->get_tree(context);
+ tree arg2_tree = arg2->get_tree(context);
+ if (arg1_tree == error_mark_node || arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ Array_type* at = arg1->type()->array_type();
+ Type* element_type = at->element_type();
+
+ arg2_tree = Expression::convert_for_assignment(context, at,
+ arg2->type(),
+ arg2_tree,
+ location);
+ if (arg2_tree == error_mark_node)
+ return error_mark_node;
+
+ arg2_tree = save_expr(arg2_tree);
+ tree arg2_val = at->value_pointer_tree(gogo, arg2_tree);
+ tree arg2_len = at->length_tree(gogo, arg2_tree);
+ if (arg2_val == error_mark_node || arg2_len == error_mark_node)
+ return error_mark_node;
+ arg2_val = fold_convert_loc(location, ptr_type_node, arg2_val);
+ arg2_len = fold_convert_loc(location, size_type_node, arg2_len);
+
+ tree element_type_tree = element_type->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ element_size = fold_convert_loc(location, size_type_node,
+ element_size);
+
+ // We rebuild the decl each time since the slice types may
+ // change.
+ tree append_fndecl = NULL_TREE;
+ return Gogo::call_builtin(&append_fndecl,
+ location,
+ "__go_append",
+ 4,
+ TREE_TYPE(arg1_tree),
+ TREE_TYPE(arg1_tree),
+ arg1_tree,
+ ptr_type_node,
+ arg2_val,
+ size_type_node,
+ arg2_len,
+ size_type_node,
+ element_size);
+ }
+
+ case BUILTIN_REAL:
+ case BUILTIN_IMAG:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 1);
+ Expression* arg = args->front();
+ tree arg_tree = arg->get_tree(context);
+ if (arg_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(COMPLEX_FLOAT_TYPE_P(TREE_TYPE(arg_tree)));
+ if (this->code_ == BUILTIN_REAL)
+ return fold_build1_loc(location, REALPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ else
+ return fold_build1_loc(location, IMAGPART_EXPR,
+ TREE_TYPE(TREE_TYPE(arg_tree)),
+ arg_tree);
+ }
+
+ case BUILTIN_COMPLEX:
+ {
+ const Expression_list* args = this->args();
+ gcc_assert(args != NULL && args->size() == 2);
+ tree r = args->front()->get_tree(context);
+ tree i = args->back()->get_tree(context);
+ if (r == error_mark_node || i == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(r))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(i)));
+ gcc_assert(SCALAR_FLOAT_TYPE_P(TREE_TYPE(r)));
+ return fold_build2_loc(location, COMPLEX_EXPR,
+ build_complex_type(TREE_TYPE(r)),
+ r, i);
+ }
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// We have to support exporting a builtin call expression, because
+// code can set a constant to the result of a builtin expression.
+
+void
+Builtin_call_expression::do_export(Export* exp) const
+{
+ bool ok = false;
+
+ mpz_t val;
+ mpz_init(val);
+ Type* dummy;
+ if (this->integer_constant_value(true, val, &dummy))
+ {
+ Integer_expression::export_integer(exp, val);
+ ok = true;
+ }
+ mpz_clear(val);
+
+ if (!ok)
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (this->float_constant_value(fval, &dummy))
+ {
+ Float_expression::export_float(exp, fval);
+ ok = true;
+ }
+ mpfr_clear(fval);
+ }
+
+ if (!ok)
+ {
+ mpfr_t real;
+ mpfr_t imag;
+ mpfr_init(real);
+ mpfr_init(imag);
+ if (this->complex_constant_value(real, imag, &dummy))
+ {
+ Complex_expression::export_complex(exp, real, imag);
+ ok = true;
+ }
+ mpfr_clear(real);
+ mpfr_clear(imag);
+ }
+
+ if (!ok)
+ {
+ error_at(this->location(), "value is not constant");
+ return;
+ }
+
+ // A trailing space lets us reliably identify the end of the number.
+ exp->write_c_string(" ");
+}
+
+// Class Call_expression.
+
+// Traversal.
+
+int
+Call_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->fn_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->args_ != NULL)
+ {
+ if (this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a call statement.
+
+Expression*
+Call_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ // A type case can look like a function call.
+ if (this->fn_->is_type_expression()
+ && this->args_ != NULL
+ && this->args_->size() == 1)
+ return Expression::make_cast(this->fn_->type(), this->args_->front(),
+ this->location());
+
+ // Recognize a call to a builtin function.
+ Func_expression* fne = this->fn_->func_expression();
+ if (fne != NULL
+ && fne->named_object()->is_function_declaration()
+ && fne->named_object()->func_declaration_value()->type()->is_builtin())
+ return new Builtin_call_expression(gogo, this->fn_, this->args_,
+ this->is_varargs_, this->location());
+
+ // Handle an argument which is a call to a function which returns
+ // multiple results.
+ if (this->args_ != NULL
+ && this->args_->size() == 1
+ && this->args_->front()->call_expression() != NULL
+ && this->fn_->type()->function_type() != NULL)
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ size_t rc = this->args_->front()->call_expression()->result_count();
+ if (rc > 1
+ && fntype->parameters() != NULL
+ && (fntype->parameters()->size() == rc
+ || (fntype->is_varargs()
+ && fntype->parameters()->size() - 1 <= rc)))
+ {
+ Call_expression* call = this->args_->front()->call_expression();
+ Expression_list* args = new Expression_list;
+ for (size_t i = 0; i < rc; ++i)
+ args->push_back(Expression::make_call_result(call, i));
+ // We can't return a new call expression here, because this
+ // one may be referenced by Call_result expressions. We
+ // also can't delete the old arguments, because we may still
+ // traverse them somewhere up the call stack. FIXME.
+ this->args_ = args;
+ }
+ }
+
+ // Handle a call to a varargs function by packaging up the extra
+ // parameters.
+ if (this->fn_->type()->function_type() != NULL
+ && this->fn_->type()->function_type()->is_varargs())
+ {
+ Function_type* fntype = this->fn_->type()->function_type();
+ const Typed_identifier_list* parameters = fntype->parameters();
+ gcc_assert(parameters != NULL && !parameters->empty());
+ Type* varargs_type = parameters->back().type();
+ return this->lower_varargs(gogo, function, varargs_type,
+ parameters->size());
+ }
+
+ return this;
+}
+
+// Lower a call to a varargs function. FUNCTION is the function in
+// which the call occurs--it's not the function we are calling.
+// VARARGS_TYPE is the type of the varargs parameter, a slice type.
+// PARAM_COUNT is the number of parameters of the function we are
+// calling; the last of these parameters will be the varargs
+// parameter.
+
+Expression*
+Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
+ Type* varargs_type, size_t param_count)
+{
+ if (this->varargs_are_lowered_)
+ return this;
+
+ source_location loc = this->location();
+
+ gcc_assert(param_count > 0);
+ gcc_assert(varargs_type->is_open_array_type());
+
+ size_t arg_count = this->args_ == NULL ? 0 : this->args_->size();
+ if (arg_count < param_count - 1)
+ {
+ // Not enough arguments; will be caught in check_types.
+ return this;
+ }
+
+ Expression_list* old_args = this->args_;
+ Expression_list* new_args = new Expression_list();
+ bool push_empty_arg = false;
+ if (old_args == NULL || old_args->empty())
+ {
+ gcc_assert(param_count == 1);
+ push_empty_arg = true;
+ }
+ else
+ {
+ Expression_list::const_iterator pa;
+ int i = 1;
+ for (pa = old_args->begin(); pa != old_args->end(); ++pa, ++i)
+ {
+ if (static_cast<size_t>(i) == param_count)
+ break;
+ new_args->push_back(*pa);
+ }
+
+ // We have reached the varargs parameter.
+
+ bool issued_error = false;
+ if (pa == old_args->end())
+ push_empty_arg = true;
+ else if (pa + 1 == old_args->end() && this->is_varargs_)
+ new_args->push_back(*pa);
+ else if (this->is_varargs_)
+ {
+ this->report_error(_("too many arguments"));
+ return this;
+ }
+ else
+ {
+ Type* element_type = varargs_type->array_type()->element_type();
+ Expression_list* vals = new Expression_list;
+ for (; pa != old_args->end(); ++pa, ++i)
+ {
+ // Check types here so that we get a better message.
+ Type* patype = (*pa)->type();
+ source_location paloc = (*pa)->location();
+ if (!this->check_argument_type(i, element_type, patype,
+ paloc, issued_error))
+ continue;
+ vals->push_back(*pa);
+ }
+ Expression* val =
+ Expression::make_slice_composite_literal(varargs_type, vals, loc);
+ new_args->push_back(val);
+ }
+ }
+
+ if (push_empty_arg)
+ new_args->push_back(Expression::make_nil(loc));
+
+ // We can't return a new call expression here, because this one may
+ // be referenced by Call_result expressions. FIXME.
+ if (old_args != NULL)
+ delete old_args;
+ this->args_ = new_args;
+ this->varargs_are_lowered_ = true;
+
+ // Lower all the new subexpressions.
+ Expression* ret = this;
+ gogo->lower_expression(function, &ret);
+ gcc_assert(ret == this);
+ return ret;
+}
+
+// Get the function type. Returns NULL if we don't know the type. If
+// this returns NULL, and if_ERROR is true, issues an error.
+
+Function_type*
+Call_expression::get_function_type() const
+{
+ return this->fn_->type()->function_type();
+}
+
+// Return the number of values which this call will return.
+
+size_t
+Call_expression::result_count() const
+{
+ const Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return 0;
+ if (fntype->results() == NULL)
+ return 0;
+ return fntype->results()->size();
+}
+
+// Return whether this is a call to the predeclared function recover.
+
+bool
+Call_expression::is_recover_call() const
+{
+ return this->do_is_recover_call();
+}
+
+// Set the argument to the recover function.
+
+void
+Call_expression::set_recover_arg(Expression* arg)
+{
+ this->do_set_recover_arg(arg);
+}
+
+// Virtual functions also implemented by Builtin_call_expression.
+
+bool
+Call_expression::do_is_recover_call() const
+{
+ return false;
+}
+
+void
+Call_expression::do_set_recover_arg(Expression*)
+{
+ gcc_unreachable();
+}
+
+// Get the type.
+
+Type*
+Call_expression::do_type()
+{
+ if (this->type_ != NULL)
+ return this->type_;
+
+ Type* ret;
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results == NULL)
+ ret = Type::make_void_type();
+ else if (results->size() == 1)
+ ret = results->begin()->type();
+ else
+ ret = Type::make_call_multiple_result_type(this);
+
+ this->type_ = ret;
+
+ return this->type_;
+}
+
+// Determine types for a call expression. We can use the function
+// parameter types to set the types of the arguments.
+
+void
+Call_expression::do_determine_type(const Type_context*)
+{
+ if (!this->determining_types())
+ return;
+
+ this->fn_->determine_type_no_context();
+ Function_type* fntype = this->get_function_type();
+ const Typed_identifier_list* parameters = NULL;
+ if (fntype != NULL)
+ parameters = fntype->parameters();
+ if (this->args_ != NULL)
+ {
+ Typed_identifier_list::const_iterator pt;
+ if (parameters != NULL)
+ pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa)
+ {
+ if (parameters != NULL && pt != parameters->end())
+ {
+ Type_context subcontext(pt->type(), false);
+ (*pa)->determine_type(&subcontext);
+ ++pt;
+ }
+ else
+ (*pa)->determine_type_no_context();
+ }
+ }
+}
+
+// Called when determining types for a Call_expression. Return true
+// if we should go ahead, false if they have already been determined.
+
+bool
+Call_expression::determining_types()
+{
+ if (this->types_are_determined_)
+ return false;
+ else
+ {
+ this->types_are_determined_ = true;
+ return true;
+ }
+}
+
+// Check types for parameter I.
+
+bool
+Call_expression::check_argument_type(int i, const Type* parameter_type,
+ const Type* argument_type,
+ source_location argument_location,
+ bool issued_error)
+{
+ std::string reason;
+ if (!Type::are_assignable(parameter_type, argument_type, &reason))
+ {
+ if (!issued_error)
+ {
+ if (reason.empty())
+ error_at(argument_location, "argument %d has incompatible type", i);
+ else
+ error_at(argument_location,
+ "argument %d has incompatible type (%s)",
+ i, reason.c_str());
+ }
+ this->set_is_error();
+ return false;
+ }
+ return true;
+}
+
+// Check types.
+
+void
+Call_expression::do_check_types(Gogo*)
+{
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ {
+ if (!this->fn_->type()->is_error_type())
+ this->report_error(_("expected function"));
+ return;
+ }
+
+ if (fntype->is_method())
+ {
+ // We don't support pointers to methods, so the function has to
+ // be a bound method expression.
+ Bound_method_expression* bme = this->fn_->bound_method_expression();
+ if (bme == NULL)
+ {
+ this->report_error(_("method call without object"));
+ return;
+ }
+ Type* first_arg_type = bme->first_argument()->type();
+ if (first_arg_type->points_to() == NULL)
+ {
+ // When passing a value, we need to check that we are
+ // permitted to copy it.
+ std::string reason;
+ if (!Type::are_assignable(fntype->receiver()->type(),
+ first_arg_type, &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for receiver"));
+ else
+ {
+ error_at(this->location(),
+ "incompatible type for receiver (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+ }
+ }
+
+ // Note that varargs was handled by the lower_varargs() method, so
+ // we don't have to worry about it here.
+
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (this->args_ == NULL)
+ {
+ if (parameters != NULL && !parameters->empty())
+ this->report_error(_("not enough arguments"));
+ }
+ else if (parameters == NULL)
+ this->report_error(_("too many arguments"));
+ else
+ {
+ int i = 0;
+ Typed_identifier_list::const_iterator pt = parameters->begin();
+ for (Expression_list::const_iterator pa = this->args_->begin();
+ pa != this->args_->end();
+ ++pa, ++pt, ++i)
+ {
+ if (pt == parameters->end())
+ {
+ this->report_error(_("too many arguments"));
+ return;
+ }
+ this->check_argument_type(i + 1, pt->type(), (*pa)->type(),
+ (*pa)->location(), false);
+ }
+ if (pt != parameters->end())
+ this->report_error(_("not enough arguments"));
+ }
+}
+
+// Return whether we have to use a temporary variable to ensure that
+// we evaluate this call expression in order. If the call returns no
+// results then it will inevitably be executed last. If the call
+// returns more than one result then it will be used with Call_result
+// expressions. So we only have to use a temporary variable if the
+// call returns exactly one result.
+
+bool
+Call_expression::do_must_eval_in_order() const
+{
+ return this->result_count() == 1;
+}
+
+// Get the function and the first argument to use when calling a bound
+// method.
+
+tree
+Call_expression::bound_method_function(Translate_context* context,
+ Bound_method_expression* bound_method,
+ tree* first_arg_ptr)
+{
+ Expression* first_argument = bound_method->first_argument();
+ tree first_arg = first_argument->get_tree(context);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+
+ // We always pass a pointer to the first argument when calling a
+ // method.
+ if (first_argument->type()->points_to() == NULL)
+ {
+ tree pointer_to_arg_type = build_pointer_type(TREE_TYPE(first_arg));
+ if (TREE_ADDRESSABLE(TREE_TYPE(first_arg))
+ || DECL_P(first_arg)
+ || TREE_CODE(first_arg) == INDIRECT_REF
+ || TREE_CODE(first_arg) == COMPONENT_REF)
+ {
+ first_arg = build_fold_addr_expr(first_arg);
+ if (DECL_P(first_arg))
+ TREE_ADDRESSABLE(first_arg) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(first_arg),
+ get_name(first_arg));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = first_arg;
+ first_arg = build2(COMPOUND_EXPR, pointer_to_arg_type,
+ build1(DECL_EXPR, void_type_node, tmp),
+ build_fold_addr_expr(tmp));
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ }
+
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ first_arg = fold_convert(fatype->get_tree(context->gogo()), first_arg);
+ if (first_arg == error_mark_node
+ || TREE_TYPE(first_arg) == error_mark_node)
+ return error_mark_node;
+ }
+
+ *first_arg_ptr = first_arg;
+
+ return bound_method->method()->get_tree(context);
+}
+
+// Get the function and the first argument to use when calling an
+// interface method.
+
+tree
+Call_expression::interface_method_function(
+ Translate_context* context,
+ Interface_field_reference_expression* interface_method,
+ tree* first_arg_ptr)
+{
+ tree expr = interface_method->expr()->get_tree(context);
+ if (expr == error_mark_node)
+ return error_mark_node;
+ expr = save_expr(expr);
+ tree first_arg = interface_method->get_underlying_object_tree(context, expr);
+ if (first_arg == error_mark_node)
+ return error_mark_node;
+ *first_arg_ptr = first_arg;
+ return interface_method->get_function_tree(context, expr);
+}
+
+// Build the call expression.
+
+tree
+Call_expression::do_get_tree(Translate_context* context)
+{
+ if (this->tree_ != NULL_TREE)
+ return this->tree_;
+
+ Function_type* fntype = this->get_function_type();
+ if (fntype == NULL)
+ return error_mark_node;
+
+ if (this->fn_->is_error_expression())
+ return error_mark_node;
+
+ Gogo* gogo = context->gogo();
+ source_location location = this->location();
+
+ Func_expression* func = this->fn_->func_expression();
+ Bound_method_expression* bound_method = this->fn_->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ this->fn_->interface_field_reference_expression();
+ const bool has_closure = func != NULL && func->closure() != NULL;
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+ gcc_assert(!fntype->is_method() || is_method);
+
+ int nargs;
+ tree* args;
+ if (this->args_ == NULL || this->args_->empty())
+ {
+ nargs = is_method ? 1 : 0;
+ args = nargs == 0 ? NULL : new tree[nargs];
+ }
+ else
+ {
+ const Typed_identifier_list* params = fntype->parameters();
+ gcc_assert(params != NULL);
+
+ nargs = this->args_->size();
+ int i = is_method ? 1 : 0;
+ nargs += i;
+ args = new tree[nargs];
+
+ Typed_identifier_list::const_iterator pp = params->begin();
+ Expression_list::const_iterator pe;
+ for (pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe, ++pp, ++i)
+ {
+ gcc_assert(pp != params->end());
+ tree arg_val = (*pe)->get_tree(context);
+ args[i] = Expression::convert_for_assignment(context,
+ pp->type(),
+ (*pe)->type(),
+ arg_val,
+ location);
+ if (args[i] == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+ }
+ gcc_assert(pp == params->end());
+ gcc_assert(i == nargs);
+ }
+
+ tree rettype = TREE_TYPE(TREE_TYPE(fntype->get_tree(gogo)));
+ if (rettype == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+
+ tree fn;
+ if (has_closure)
+ fn = func->get_tree_without_closure(gogo);
+ else if (!is_method)
+ fn = this->fn_->get_tree(context);
+ else if (bound_method != NULL)
+ fn = this->bound_method_function(context, bound_method, &args[0]);
+ else if (interface_method != NULL)
+ fn = this->interface_method_function(context, interface_method, &args[0]);
+ else
+ gcc_unreachable();
+
+ if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
+ {
+ delete[] args;
+ return error_mark_node;
+ }
+
+ tree fndecl = fn;
+ if (TREE_CODE(fndecl) == ADDR_EXPR)
+ fndecl = TREE_OPERAND(fndecl, 0);
+
+ // Add a type cast in case the type of the function is a recursive
+ // type which refers to itself.
+ if (!DECL_P(fndecl) || !DECL_IS_BUILTIN(fndecl))
+ {
+ tree fnt = fntype->get_tree(gogo);
+ if (fnt == error_mark_node)
+ return error_mark_node;
+ fn = fold_convert_loc(location, fnt, fn);
+ }
+
+ // This is to support builtin math functions when using 80387 math.
+ tree excess_type = NULL_TREE;
+ if (DECL_P(fndecl)
+ && DECL_IS_BUILTIN(fndecl)
+ && DECL_BUILT_IN_CLASS(fndecl) == BUILT_IN_NORMAL
+ && nargs > 0
+ && ((SCALAR_FLOAT_TYPE_P(rettype)
+ && SCALAR_FLOAT_TYPE_P(TREE_TYPE(args[0])))
+ || (COMPLEX_FLOAT_TYPE_P(rettype)
+ && COMPLEX_FLOAT_TYPE_P(TREE_TYPE(args[0])))))
+ {
+ excess_type = excess_precision_type(TREE_TYPE(args[0]));
+ if (excess_type != NULL_TREE)
+ {
+ tree excess_fndecl = mathfn_built_in(excess_type,
+ DECL_FUNCTION_CODE(fndecl));
+ if (excess_fndecl == NULL_TREE)
+ excess_type = NULL_TREE;
+ else
+ {
+ fn = build_fold_addr_expr_loc(location, excess_fndecl);
+ for (int i = 0; i < nargs; ++i)
+ args[i] = ::convert(excess_type, args[i]);
+ }
+ }
+ }
+
+ tree ret = build_call_array(excess_type != NULL_TREE ? excess_type : rettype,
+ fn, nargs, args);
+ delete[] args;
+
+ SET_EXPR_LOCATION(ret, location);
+
+ if (has_closure)
+ {
+ tree closure_tree = func->closure()->get_tree(context);
+ if (closure_tree != error_mark_node)
+ CALL_EXPR_STATIC_CHAIN(ret) = closure_tree;
+ }
+
+ // If this is a recursive function type which returns itself, as in
+ // type F func() F
+ // we have used ptr_type_node for the return type. Add a cast here
+ // to the correct type.
+ if (TREE_TYPE(ret) == ptr_type_node)
+ {
+ tree t = this->type()->base()->get_tree(gogo);
+ ret = fold_convert_loc(location, t, ret);
+ }
+
+ if (excess_type != NULL_TREE)
+ {
+ // Calling convert here can undo our excess precision change.
+ // That may or may not be a bug in convert_to_real.
+ ret = build1(NOP_EXPR, rettype, ret);
+ }
+
+ // If there is more than one result, we will refer to the call
+ // multiple times.
+ if (fntype->results() != NULL && fntype->results()->size() > 1)
+ ret = save_expr(ret);
+
+ this->tree_ = ret;
+
+ return ret;
+}
+
+// Make a call expression.
+
+Call_expression*
+Expression::make_call(Expression* fn, Expression_list* args, bool is_varargs,
+ source_location location)
+{
+ return new Call_expression(fn, args, is_varargs, location);
+}
+
+// A single result from a call which returns multiple results.
+
+class Call_result_expression : public Expression
+{
+ public:
+ Call_result_expression(Call_expression* call, unsigned int index)
+ : Expression(EXPRESSION_CALL_RESULT, call->location()),
+ call_(call), index_(index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Call_result_expression(this->call_->call_expression(),
+ this->index_);
+ }
+
+ bool
+ do_must_eval_in_order() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The underlying call expression.
+ Expression* call_;
+ // Which result we want.
+ unsigned int index_;
+};
+
+// Traverse a call result.
+
+int
+Call_result_expression::do_traverse(Traverse* traverse)
+{
+ if (traverse->remember_expression(this->call_))
+ {
+ // We have already traversed the call expression.
+ return TRAVERSE_CONTINUE;
+ }
+ return Expression::traverse(&this->call_, traverse);
+}
+
+// Get the type.
+
+Type*
+Call_result_expression::do_type()
+{
+ if (this->classification() == EXPRESSION_ERROR)
+ return Type::make_error_type();
+
+ // THIS->CALL_ can be replaced with a temporary reference due to
+ // Call_expression::do_must_eval_in_order when there is an error.
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ {
+ this->set_is_error();
+ return Type::make_error_type();
+ }
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL)
+ {
+ this->set_is_error();
+ return Type::make_error_type();
+ }
+ const Typed_identifier_list* results = fntype->results();
+ if (results == NULL)
+ {
+ this->report_error(_("number of results does not match "
+ "number of values"));
+ return Type::make_error_type();
+ }
+ Typed_identifier_list::const_iterator pr = results->begin();
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ if (pr == results->end())
+ break;
+ ++pr;
+ }
+ if (pr == results->end())
+ {
+ this->report_error(_("number of results does not match "
+ "number of values"));
+ return Type::make_error_type();
+ }
+ return pr->type();
+}
+
+// Check the type. Just make sure that we trigger the warning in
+// do_type.
+
+void
+Call_result_expression::do_check_types(Gogo*)
+{
+ this->type();
+}
+
+// Determine the type. We have nothing to do here, but the 0 result
+// needs to pass down to the caller.
+
+void
+Call_result_expression::do_determine_type(const Type_context*)
+{
+ this->call_->determine_type_no_context();
+}
+
+// Return the tree.
+
+tree
+Call_result_expression::do_get_tree(Translate_context* context)
+{
+ tree call_tree = this->call_->get_tree(context);
+ if (call_tree == error_mark_node)
+ return error_mark_node;
+ if (TREE_CODE(TREE_TYPE(call_tree)) != RECORD_TYPE)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ tree field = TYPE_FIELDS(TREE_TYPE(call_tree));
+ for (unsigned int i = 0; i < this->index_; ++i)
+ {
+ gcc_assert(field != NULL_TREE);
+ field = DECL_CHAIN(field);
+ }
+ gcc_assert(field != NULL_TREE);
+ return build3(COMPONENT_REF, TREE_TYPE(field), call_tree, field, NULL_TREE);
+}
+
+// Make a reference to a single result of a call which returns
+// multiple results.
+
+Expression*
+Expression::make_call_result(Call_expression* call, unsigned int index)
+{
+ return new Call_result_expression(call, index);
+}
+
+// Class Index_expression.
+
+// Traversal.
+
+int
+Index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->left_, traverse) == TRAVERSE_EXIT
+ || Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT
+ || (this->end_ != NULL
+ && Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT))
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower an index expression. This converts the generic index
+// expression into an array index, a string index, or a map index.
+
+Expression*
+Index_expression::do_lower(Gogo*, Named_object*, int)
+{
+ source_location location = this->location();
+ Expression* left = this->left_;
+ Expression* start = this->start_;
+ Expression* end = this->end_;
+
+ Type* type = left->type();
+ if (type->is_error_type())
+ return Expression::make_error(location);
+ else if (left->is_type_expression())
+ {
+ error_at(location, "attempt to index type expression");
+ return Expression::make_error(location);
+ }
+ else if (type->array_type() != NULL)
+ return Expression::make_array_index(left, start, end, location);
+ else if (type->points_to() != NULL
+ && type->points_to()->array_type() != NULL
+ && !type->points_to()->is_open_array_type())
+ {
+ Expression* deref = Expression::make_unary(OPERATOR_MULT, left,
+ location);
+ return Expression::make_array_index(deref, start, end, location);
+ }
+ else if (type->is_string_type())
+ return Expression::make_string_index(left, start, end, location);
+ else if (type->map_type() != NULL)
+ {
+ if (end != NULL)
+ {
+ error_at(location, "invalid slice of map");
+ return Expression::make_error(location);
+ }
+ Map_index_expression* ret= Expression::make_map_index(left, start,
+ location);
+ if (this->is_lvalue_)
+ ret->set_is_lvalue();
+ return ret;
+ }
+ else
+ {
+ error_at(location,
+ "attempt to index object which is not array, string, or map");
+ return Expression::make_error(location);
+ }
+}
+
+// Make an index expression.
+
+Expression*
+Expression::make_index(Expression* left, Expression* start, Expression* end,
+ source_location location)
+{
+ return new Index_expression(left, start, end, location);
+}
+
+// An array index. This is used for both indexing and slicing.
+
+class Array_index_expression : public Expression
+{
+ public:
+ Array_index_expression(Expression* array, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_ARRAY_INDEX, location),
+ array_(array), start_(start), end_(end), type_(NULL)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_array_index(this->array_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const;
+
+ void
+ do_address_taken(bool escapes)
+ { this->array_->address_taken(escapes); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The array we are getting a value from.
+ Expression* array_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a simple array
+ // index, or it may be a nil expression for the length of the array.
+ Expression* end_;
+ // The type of the expression.
+ Type* type_;
+};
+
+// Array index traversal.
+
+int
+Array_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->array_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of an array index.
+
+Type*
+Array_index_expression::do_type()
+{
+ if (this->type_ == NULL)
+ {
+ Array_type* type = this->array_->type()->array_type();
+ if (type == NULL)
+ this->type_ = Type::make_error_type();
+ else if (this->end_ == NULL)
+ this->type_ = type->element_type();
+ else if (type->is_open_array_type())
+ {
+ // A slice of a slice has the same type as the original
+ // slice.
+ this->type_ = this->array_->type()->deref();
+ }
+ else
+ {
+ // A slice of an array is a slice.
+ this->type_ = Type::make_array_type(type->element_type(), NULL);
+ }
+ }
+ return this->type_;
+}
+
+// Set the type of an array index.
+
+void
+Array_index_expression::do_determine_type(const Type_context*)
+{
+ this->array_->determine_type_no_context();
+ this->start_->determine_type_no_context();
+ if (this->end_ != NULL)
+ this->end_->determine_type_no_context();
+}
+
+// Check types of an array index.
+
+void
+Array_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ Array_type* array_type = this->array_->type()->array_type();
+ if (array_type == NULL)
+ {
+ gcc_assert(this->array_->type()->is_error_type());
+ return;
+ }
+
+ unsigned int int_bits =
+ Type::lookup_integer_type("int")->integer_type()->bits();
+
+ Type* dummy;
+ mpz_t lval;
+ mpz_init(lval);
+ bool lval_valid = (array_type->length() != NULL
+ && array_type->length()->integer_constant_value(true,
+ lval,
+ &dummy));
+ mpz_t ival;
+ mpz_init(ival);
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid
+ && (this->end_ == NULL
+ ? mpz_cmp(ival, lval) >= 0
+ : mpz_cmp(ival, lval) > 0)))
+ {
+ error_at(this->start_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || mpz_sizeinbase(ival, 2) >= int_bits
+ || (lval_valid && mpz_cmp(ival, lval) > 0))
+ {
+ error_at(this->end_->location(), "array index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+ mpz_clear(lval);
+
+ // A slice of an array requires an addressable array. A slice of a
+ // slice is always possible.
+ if (this->end_ != NULL
+ && !array_type->is_open_array_type()
+ && !this->array_->is_addressable())
+ this->report_error(_("array is not addressable"));
+}
+
+// Return whether this expression is addressable.
+
+bool
+Array_index_expression::do_is_addressable() const
+{
+ // A slice expression is not addressable.
+ if (this->end_ != NULL)
+ return false;
+
+ // An index into a slice is addressable.
+ if (this->array_->type()->is_open_array_type())
+ return true;
+
+ // An index into an array is addressable if the array is
+ // addressable.
+ return this->array_->is_addressable();
+}
+
+// Get a tree for an array index.
+
+tree
+Array_index_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Array_type* array_type = this->array_->type()->array_type();
+ if (array_type == NULL)
+ {
+ gcc_assert(this->array_->type()->is_error_type());
+ return error_mark_node;
+ }
+
+ tree type_tree = array_type->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree array_tree = this->array_->get_tree(context);
+ if (array_tree == error_mark_node)
+ return error_mark_node;
+
+ if (array_type->length() == NULL && !DECL_P(array_tree))
+ array_tree = save_expr(array_tree);
+ tree length_tree = array_type->length_tree(gogo, array_tree);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node, bad_index,
+ fold_build2_loc(loc,
+ (this->end_ == NULL
+ ? GE_EXPR
+ : GT_EXPR),
+ boolean_type_node, start_tree,
+ length_tree));
+
+ int code = (array_type->length() != NULL
+ ? (this->end_ == NULL
+ ? RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS)
+ : (this->end_ == NULL
+ ? RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS));
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ // Simple array indexing. This has to return an l-value, so
+ // wrap the index check into START_TREE.
+ start_tree = build2(COMPOUND_EXPR, TREE_TYPE(start_tree),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ start_tree);
+ start_tree = fold_convert_loc(loc, sizetype, start_tree);
+
+ if (array_type->length() != NULL)
+ {
+ // Fixed array.
+ return build4(ARRAY_REF, TREE_TYPE(type_tree), array_tree,
+ start_tree, NULL_TREE, NULL_TREE);
+ }
+ else
+ {
+ // Open array.
+ tree values = array_type->value_pointer_tree(gogo, array_tree);
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ start_tree, element_size);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(values), values, offset);
+ return build_fold_indirect_ref(ptr);
+ }
+ }
+
+ // Array slice.
+
+ tree capacity_tree = array_type->capacity_tree(gogo, array_tree);
+ if (capacity_tree == error_mark_node)
+ return error_mark_node;
+ capacity_tree = fold_convert_loc(loc, length_type, capacity_tree);
+
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = length_tree;
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type, bad_index,
+ loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+
+ capacity_tree = save_expr(capacity_tree);
+ tree bad_end = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ fold_build2_loc(loc, LT_EXPR,
+ boolean_type_node,
+ end_tree, start_tree),
+ fold_build2_loc(loc, GT_EXPR,
+ boolean_type_node,
+ end_tree, capacity_tree));
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, bad_end);
+ }
+
+ tree element_type_tree = array_type->element_type()->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree offset = fold_build2_loc(loc, MULT_EXPR, sizetype,
+ fold_convert_loc(loc, sizetype, start_tree),
+ element_size);
+
+ tree value_pointer = array_type->value_pointer_tree(gogo, array_tree);
+ if (value_pointer == error_mark_node)
+ return error_mark_node;
+
+ value_pointer = fold_build2_loc(loc, POINTER_PLUS_EXPR,
+ TREE_TYPE(value_pointer),
+ value_pointer, offset);
+
+ tree result_length_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ end_tree, start_tree);
+
+ tree result_capacity_tree = fold_build2_loc(loc, MINUS_EXPR, length_type,
+ capacity_tree, start_tree);
+
+ tree struct_tree = this->type()->get_tree(gogo);
+ gcc_assert(TREE_CODE(struct_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(struct_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = value_pointer;
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert_loc(loc, TREE_TYPE(field), result_capacity_tree);
+
+ tree constructor = build_constructor(struct_tree, init);
+
+ if (TREE_CONSTANT(value_pointer)
+ && TREE_CONSTANT(result_length_tree)
+ && TREE_CONSTANT(result_capacity_tree))
+ TREE_CONSTANT(constructor) = 1;
+
+ return fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(constructor),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ constructor);
+}
+
+// Make an array index expression. END may be NULL.
+
+Expression*
+Expression::make_array_index(Expression* array, Expression* start,
+ Expression* end, source_location location)
+{
+ // Taking a slice of a composite literal requires moving the literal
+ // onto the heap.
+ if (end != NULL && array->is_composite_literal())
+ {
+ array = Expression::make_heap_composite(array, location);
+ array = Expression::make_unary(OPERATOR_MULT, array, location);
+ }
+ return new Array_index_expression(array, start, end, location);
+}
+
+// A string index. This is used for both indexing and slicing.
+
+class String_index_expression : public Expression
+{
+ public:
+ String_index_expression(Expression* string, Expression* start,
+ Expression* end, source_location location)
+ : Expression(EXPRESSION_STRING_INDEX, location),
+ string_(string), start_(start), end_(end)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_string_index(this->string_->copy(),
+ this->start_->copy(),
+ (this->end_ == NULL
+ ? NULL
+ : this->end_->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The string we are getting a value from.
+ Expression* string_;
+ // The start or only index.
+ Expression* start_;
+ // The end index of a slice. This may be NULL for a single index,
+ // or it may be a nil expression for the length of the string.
+ Expression* end_;
+};
+
+// String index traversal.
+
+int
+String_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->string_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Expression::traverse(&this->start_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->end_ != NULL)
+ {
+ if (Expression::traverse(&this->end_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the type of a string index.
+
+Type*
+String_index_expression::do_type()
+{
+ if (this->end_ == NULL)
+ return Type::lookup_integer_type("uint8");
+ else
+ return this->string_->type();
+}
+
+// Determine the type of a string index.
+
+void
+String_index_expression::do_determine_type(const Type_context*)
+{
+ this->string_->determine_type_no_context();
+ this->start_->determine_type_no_context();
+ if (this->end_ != NULL)
+ this->end_->determine_type_no_context();
+}
+
+// Check types of a string index.
+
+void
+String_index_expression::do_check_types(Gogo*)
+{
+ if (this->start_->type()->integer_type() == NULL)
+ this->report_error(_("index must be integer"));
+ if (this->end_ != NULL
+ && this->end_->type()->integer_type() == NULL
+ && !this->end_->is_nil_expression())
+ this->report_error(_("slice end must be integer"));
+
+ std::string sval;
+ bool sval_valid = this->string_->string_constant_value(&sval);
+
+ mpz_t ival;
+ mpz_init(ival);
+ Type* dummy;
+ if (this->start_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) >= 0))
+ {
+ error_at(this->start_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ if (this->end_ != NULL && !this->end_->is_nil_expression())
+ {
+ if (this->end_->integer_constant_value(true, ival, &dummy))
+ {
+ if (mpz_sgn(ival) < 0
+ || (sval_valid && mpz_cmp_ui(ival, sval.length()) > 0))
+ {
+ error_at(this->end_->location(), "string index out of bounds");
+ this->set_is_error();
+ }
+ }
+ }
+ mpz_clear(ival);
+}
+
+// Get a tree for a string index.
+
+tree
+String_index_expression::do_get_tree(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ tree string_tree = this->string_->get_tree(context);
+ if (string_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->string_->type()->points_to() != NULL)
+ string_tree = build_fold_indirect_ref(string_tree);
+ if (!DECL_P(string_tree))
+ string_tree = save_expr(string_tree);
+ tree string_type = TREE_TYPE(string_tree);
+
+ tree length_tree = String_type::length_tree(context->gogo(), string_tree);
+ length_tree = save_expr(length_tree);
+ tree length_type = TREE_TYPE(length_tree);
+
+ tree bad_index = boolean_false_node;
+
+ tree start_tree = this->start_->get_tree(context);
+ if (start_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(start_tree))
+ start_tree = save_expr(start_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(start_tree)))
+ start_tree = convert_to_integer(length_type, start_tree);
+
+ bad_index = Expression::check_bounds(start_tree, length_type, bad_index,
+ loc);
+
+ start_tree = fold_convert_loc(loc, length_type, start_tree);
+
+ int code = (this->end_ == NULL
+ ? RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
+ : RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS);
+ tree crash = Gogo::runtime_error(code, loc);
+
+ if (this->end_ == NULL)
+ {
+ bad_index = fold_build2_loc(loc, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index,
+ fold_build2_loc(loc, GE_EXPR,
+ boolean_type_node,
+ start_tree, length_tree));
+
+ tree bytes_tree = String_type::bytes_tree(context->gogo(), string_tree);
+ tree ptr = fold_build2_loc(loc, POINTER_PLUS_EXPR, TREE_TYPE(bytes_tree),
+ bytes_tree,
+ fold_convert_loc(loc, sizetype, start_tree));
+ tree index = build_fold_indirect_ref_loc(loc, ptr);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(index),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ index);
+ }
+ else
+ {
+ tree end_tree;
+ if (this->end_->is_nil_expression())
+ end_tree = build_int_cst(length_type, -1);
+ else
+ {
+ end_tree = this->end_->get_tree(context);
+ if (end_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(end_tree))
+ end_tree = save_expr(end_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(end_tree)))
+ end_tree = convert_to_integer(length_type, end_tree);
+
+ bad_index = Expression::check_bounds(end_tree, length_type,
+ bad_index, loc);
+
+ end_tree = fold_convert_loc(loc, length_type, end_tree);
+ }
+
+ static tree strslice_fndecl;
+ tree ret = Gogo::call_builtin(&strslice_fndecl,
+ loc,
+ "__go_string_slice",
+ 3,
+ string_type,
+ string_type,
+ string_tree,
+ length_type,
+ start_tree,
+ length_type,
+ end_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This will panic if the bounds are out of range for the
+ // string.
+ TREE_NOTHROW(strslice_fndecl) = 0;
+
+ if (bad_index == boolean_false_node)
+ return ret;
+ else
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Make a string index expression. END may be NULL.
+
+Expression*
+Expression::make_string_index(Expression* string, Expression* start,
+ Expression* end, source_location location)
+{
+ return new String_index_expression(string, start, end, location);
+}
+
+// Class Map_index.
+
+// Get the type of the map.
+
+Map_type*
+Map_index_expression::get_map_type() const
+{
+ Map_type* mt = this->map_->type()->deref()->map_type();
+ if (mt == NULL)
+ gcc_assert(saw_errors());
+ return mt;
+}
+
+// Map index traversal.
+
+int
+Map_index_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->map_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Expression::traverse(&this->index_, traverse);
+}
+
+// Return the type of a map index.
+
+Type*
+Map_index_expression::do_type()
+{
+ Map_type* mt = this->get_map_type();
+ if (mt == NULL)
+ return Type::make_error_type();
+ Type* type = mt->val_type();
+ // If this map index is in a tuple assignment, we actually return a
+ // pointer to the value type. Tuple_map_assignment_statement is
+ // responsible for handling this correctly. We need to get the type
+ // right in case this gets assigned to a temporary variable.
+ if (this->is_in_tuple_assignment_)
+ type = Type::make_pointer_type(type);
+ return type;
+}
+
+// Fix the type of a map index.
+
+void
+Map_index_expression::do_determine_type(const Type_context*)
+{
+ this->map_->determine_type_no_context();
+ Map_type* mt = this->get_map_type();
+ Type* key_type = mt == NULL ? NULL : mt->key_type();
+ Type_context subcontext(key_type, false);
+ this->index_->determine_type(&subcontext);
+}
+
+// Check types of a map index.
+
+void
+Map_index_expression::do_check_types(Gogo*)
+{
+ std::string reason;
+ Map_type* mt = this->get_map_type();
+ if (mt == NULL)
+ return;
+ if (!Type::are_assignable(mt->key_type(), this->index_->type(), &reason))
+ {
+ if (reason.empty())
+ this->report_error(_("incompatible type for map index"));
+ else
+ {
+ error_at(this->location(), "incompatible type for map index (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a map index.
+
+tree
+Map_index_expression::do_get_tree(Translate_context* context)
+{
+ Map_type* type = this->get_map_type();
+ if (type == NULL)
+ return error_mark_node;
+
+ tree valptr = this->get_value_pointer(context, this->is_lvalue_);
+ if (valptr == error_mark_node)
+ return error_mark_node;
+ valptr = save_expr(valptr);
+
+ tree val_type_tree = TREE_TYPE(TREE_TYPE(valptr));
+
+ if (this->is_lvalue_)
+ return build_fold_indirect_ref(valptr);
+ else if (this->is_in_tuple_assignment_)
+ {
+ // Tuple_map_assignment_statement is responsible for using this
+ // appropriately.
+ return valptr;
+ }
+ else
+ {
+ return fold_build3(COND_EXPR, val_type_tree,
+ fold_build2(EQ_EXPR, boolean_type_node, valptr,
+ fold_convert(TREE_TYPE(valptr),
+ null_pointer_node)),
+ type->val_type()->get_init_tree(context->gogo(),
+ false),
+ build_fold_indirect_ref(valptr));
+ }
+}
+
+// Get a tree for the map index. This returns a tree which evaluates
+// to a pointer to a value. The pointer will be NULL if the key is
+// not in the map.
+
+tree
+Map_index_expression::get_value_pointer(Translate_context* context,
+ bool insert)
+{
+ Map_type* type = this->get_map_type();
+ if (type == NULL)
+ return error_mark_node;
+
+ tree map_tree = this->map_->get_tree(context);
+ tree index_tree = this->index_->get_tree(context);
+ index_tree = Expression::convert_for_assignment(context, type->key_type(),
+ this->index_->type(),
+ index_tree,
+ this->location());
+ if (map_tree == error_mark_node || index_tree == error_mark_node)
+ return error_mark_node;
+
+ if (this->map_->type()->points_to() != NULL)
+ map_tree = build_fold_indirect_ref(map_tree);
+
+ // We need to pass in a pointer to the key, so stuff it into a
+ // variable.
+ tree tmp;
+ tree make_tmp;
+ if (current_function_decl != NULL)
+ {
+ tmp = create_tmp_var(TREE_TYPE(index_tree), get_name(index_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = index_tree;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ else
+ {
+ tmp = build_decl(this->location(), VAR_DECL, create_tmp_var_name("M"),
+ TREE_TYPE(index_tree));
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (!TREE_CONSTANT(index_tree))
+ make_tmp = fold_build2_loc(this->location(), INIT_EXPR, void_type_node,
+ tmp, index_tree);
+ else
+ {
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ DECL_INITIAL(tmp) = index_tree;
+ make_tmp = NULL_TREE;
+ }
+ rest_of_decl_compilation(tmp, 1, 0);
+ }
+ tree tmpref = fold_convert_loc(this->location(), const_ptr_type_node,
+ build_fold_addr_expr_loc(this->location(),
+ tmp));
+
+ static tree map_index_fndecl;
+ tree call = Gogo::call_builtin(&map_index_fndecl,
+ this->location(),
+ "__go_map_index",
+ 3,
+ const_ptr_type_node,
+ TREE_TYPE(map_tree),
+ map_tree,
+ const_ptr_type_node,
+ tmpref,
+ boolean_type_node,
+ (insert
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic on a map of interface type if the interface holds
+ // an uncomparable or unhashable type.
+ TREE_NOTHROW(map_index_fndecl) = 0;
+
+ tree val_type_tree = type->val_type()->get_tree(context->gogo());
+ if (val_type_tree == error_mark_node)
+ return error_mark_node;
+ tree ptr_val_type_tree = build_pointer_type(val_type_tree);
+
+ tree ret = fold_convert_loc(this->location(), ptr_val_type_tree, call);
+ if (make_tmp != NULL_TREE)
+ ret = build2(COMPOUND_EXPR, ptr_val_type_tree, make_tmp, ret);
+ return ret;
+}
+
+// Make a map index expression.
+
+Map_index_expression*
+Expression::make_map_index(Expression* map, Expression* index,
+ source_location location)
+{
+ return new Map_index_expression(map, index, location);
+}
+
+// Class Field_reference_expression.
+
+// Return the type of a field reference.
+
+Type*
+Field_reference_expression::do_type()
+{
+ Type* type = this->expr_->type();
+ if (type->is_error_type())
+ return type;
+ Struct_type* struct_type = type->struct_type();
+ gcc_assert(struct_type != NULL);
+ return struct_type->field(this->field_index_)->type();
+}
+
+// Check the types for a field reference.
+
+void
+Field_reference_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+ if (type->is_error_type())
+ return;
+ Struct_type* struct_type = type->struct_type();
+ gcc_assert(struct_type != NULL);
+ gcc_assert(struct_type->field(this->field_index_) != NULL);
+}
+
+// Get a tree for a field reference.
+
+tree
+Field_reference_expression::do_get_tree(Translate_context* context)
+{
+ tree struct_tree = this->expr_->get_tree(context);
+ if (struct_tree == error_mark_node
+ || TREE_TYPE(struct_tree) == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(TREE_TYPE(struct_tree)) == RECORD_TYPE);
+ tree field = TYPE_FIELDS(TREE_TYPE(struct_tree));
+ if (field == NULL_TREE)
+ {
+ // This can happen for a type which refers to itself indirectly
+ // and then turns out to be erroneous.
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ for (unsigned int i = this->field_index_; i > 0; --i)
+ {
+ field = DECL_CHAIN(field);
+ gcc_assert(field != NULL_TREE);
+ }
+ if (TREE_TYPE(field) == error_mark_node)
+ return error_mark_node;
+ return build3(COMPONENT_REF, TREE_TYPE(field), struct_tree, field,
+ NULL_TREE);
+}
+
+// Make a reference to a qualified identifier in an expression.
+
+Field_reference_expression*
+Expression::make_field_reference(Expression* expr, unsigned int field_index,
+ source_location location)
+{
+ return new Field_reference_expression(expr, field_index, location);
+}
+
+// Class Interface_field_reference_expression.
+
+// Return a tree for the pointer to the function to call.
+
+tree
+Interface_field_reference_expression::get_function_tree(Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ gcc_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = TYPE_FIELDS(expr_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods") == 0);
+
+ tree table = build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(table)));
+
+ table = build_fold_indirect_ref(table);
+ gcc_assert(TREE_CODE(TREE_TYPE(table)) == RECORD_TYPE);
+
+ std::string name = Gogo::unpack_hidden_name(this->name_);
+ for (field = DECL_CHAIN(TYPE_FIELDS(TREE_TYPE(table)));
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ if (name == IDENTIFIER_POINTER(DECL_NAME(field)))
+ break;
+ }
+ gcc_assert(field != NULL_TREE);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), table, field, NULL_TREE);
+}
+
+// Return a tree for the first argument to pass to the interface
+// function.
+
+tree
+Interface_field_reference_expression::get_underlying_object_tree(
+ Translate_context*,
+ tree expr)
+{
+ if (this->expr_->type()->points_to() != NULL)
+ expr = build_fold_indirect_ref(expr);
+
+ tree expr_type = TREE_TYPE(expr);
+ gcc_assert(TREE_CODE(expr_type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(expr_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), expr, field, NULL_TREE);
+}
+
+// Traversal.
+
+int
+Interface_field_reference_expression::do_traverse(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Return the type of an interface field reference.
+
+Type*
+Interface_field_reference_expression::do_type()
+{
+ Type* expr_type = this->expr_->type();
+
+ Type* points_to = expr_type->points_to();
+ if (points_to != NULL)
+ expr_type = points_to;
+
+ Interface_type* interface_type = expr_type->interface_type();
+ if (interface_type == NULL)
+ return Type::make_error_type();
+
+ const Typed_identifier* method = interface_type->find_method(this->name_);
+ if (method == NULL)
+ return Type::make_error_type();
+
+ return method->type();
+}
+
+// Determine types.
+
+void
+Interface_field_reference_expression::do_determine_type(const Type_context*)
+{
+ this->expr_->determine_type_no_context();
+}
+
+// Check the types for an interface field reference.
+
+void
+Interface_field_reference_expression::do_check_types(Gogo*)
+{
+ Type* type = this->expr_->type();
+
+ Type* points_to = type->points_to();
+ if (points_to != NULL)
+ type = points_to;
+
+ Interface_type* interface_type = type->interface_type();
+ if (interface_type == NULL)
+ this->report_error(_("expected interface or pointer to interface"));
+ else
+ {
+ const Typed_identifier* method =
+ interface_type->find_method(this->name_);
+ if (method == NULL)
+ {
+ error_at(this->location(), "method %qs not in interface",
+ Gogo::message_name(this->name_).c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Get a tree for a reference to a field in an interface. There is no
+// standard tree type representation for this: it's a function
+// attached to its first argument, like a Bound_method_expression.
+// The only places it may currently be used are in a Call_expression
+// or a Go_statement, which will take it apart directly. So this has
+// nothing to do at present.
+
+tree
+Interface_field_reference_expression::do_get_tree(Translate_context*)
+{
+ gcc_unreachable();
+}
+
+// Make a reference to a field in an interface.
+
+Expression*
+Expression::make_interface_field_reference(Expression* expr,
+ const std::string& field,
+ source_location location)
+{
+ return new Interface_field_reference_expression(expr, field, location);
+}
+
+// A general selector. This is a Parser_expression for LEFT.NAME. It
+// is lowered after we know the type of the left hand side.
+
+class Selector_expression : public Parser_expression
+{
+ public:
+ Selector_expression(Expression* left, const std::string& name,
+ source_location location)
+ : Parser_expression(EXPRESSION_SELECTOR, location),
+ left_(left), name_(name)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->left_, traverse); }
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Selector_expression(this->left_->copy(), this->name_,
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_method_expression(Gogo*);
+
+ // The expression on the left hand side.
+ Expression* left_;
+ // The name on the right hand side.
+ std::string name_;
+};
+
+// Lower a selector expression once we know the real type of the left
+// hand side.
+
+Expression*
+Selector_expression::do_lower(Gogo* gogo, Named_object*, int)
+{
+ Expression* left = this->left_;
+ if (left->is_type_expression())
+ return this->lower_method_expression(gogo);
+ return Type::bind_field_or_method(gogo, left->type(), left, this->name_,
+ this->location());
+}
+
+// Lower a method expression T.M or (*T).M. We turn this into a
+// function literal.
+
+Expression*
+Selector_expression::lower_method_expression(Gogo* gogo)
+{
+ source_location location = this->location();
+ Type* type = this->left_->type();
+ const std::string& name(this->name_);
+
+ bool is_pointer;
+ if (type->points_to() == NULL)
+ is_pointer = false;
+ else
+ {
+ is_pointer = true;
+ type = type->points_to();
+ }
+ Named_type* nt = type->named_type();
+ if (nt == NULL)
+ {
+ error_at(location,
+ ("method expression requires named type or "
+ "pointer to named type"));
+ return Expression::make_error(location);
+ }
+
+ bool is_ambiguous;
+ Method* method = nt->method_function(name, &is_ambiguous);
+ if (method == NULL)
+ {
+ if (!is_ambiguous)
+ error_at(location, "type %<%s%> has no method %<%s%>",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "method %<%s%> is ambiguous in type %<%s%>",
+ Gogo::message_name(name).c_str(),
+ nt->message_name().c_str());
+ return Expression::make_error(location);
+ }
+
+ if (!is_pointer && !method->is_value_method())
+ {
+ error_at(location, "method requires pointer (use %<(*%s).%s)%>",
+ nt->message_name().c_str(),
+ Gogo::message_name(name).c_str());
+ return Expression::make_error(location);
+ }
+
+ // Build a new function type in which the receiver becomes the first
+ // argument.
+ Function_type* method_type = method->type();
+ gcc_assert(method_type->is_method());
+
+ const char* const receiver_name = "$this";
+ Typed_identifier_list* parameters = new Typed_identifier_list();
+ parameters->push_back(Typed_identifier(receiver_name, this->left_->type(),
+ location));
+
+ const Typed_identifier_list* method_parameters = method_type->parameters();
+ if (method_parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ parameters->push_back(*p);
+ }
+
+ const Typed_identifier_list* method_results = method_type->results();
+ Typed_identifier_list* results;
+ if (method_results == NULL)
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = method_results->begin();
+ p != method_results->end();
+ ++p)
+ results->push_back(*p);
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters, results,
+ location);
+ if (method_type->is_varargs())
+ fntype->set_is_varargs();
+
+ // We generate methods which always takes a pointer to the receiver
+ // as their first argument. If this is for a pointer type, we can
+ // simply reuse the existing function. We use an internal hack to
+ // get the right type.
+
+ if (is_pointer)
+ {
+ Named_object* mno = (method->needs_stub_method()
+ ? method->stub_object()
+ : method->named_object());
+ Expression* f = Expression::make_func_reference(mno, NULL, location);
+ f = Expression::make_cast(fntype, f, location);
+ Type_conversion_expression* tce =
+ static_cast<Type_conversion_expression*>(f);
+ tce->set_may_convert_function_types();
+ return f;
+ }
+
+ Named_object* no = gogo->start_function(Gogo::thunk_name(), fntype, false,
+ location);
+
+ Named_object* vno = gogo->lookup(receiver_name, NULL);
+ gcc_assert(vno != NULL);
+ Expression* ve = Expression::make_var_reference(vno, location);
+ Expression* bm = Type::bind_field_or_method(gogo, nt, ve, name, location);
+
+ // Even though we found the method above, if it has an error type we
+ // may see an error here.
+ if (bm->is_error_expression())
+ {
+ gogo->finish_function(location);
+ return bm;
+ }
+
+ Expression_list* args;
+ if (method_parameters == NULL)
+ args = NULL;
+ else
+ {
+ args = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = method_parameters->begin();
+ p != method_parameters->end();
+ ++p)
+ {
+ vno = gogo->lookup(p->name(), NULL);
+ gcc_assert(vno != NULL);
+ args->push_back(Expression::make_var_reference(vno, location));
+ }
+ }
+
+ Call_expression* call = Expression::make_call(bm, args,
+ method_type->is_varargs(),
+ location);
+
+ size_t count = call->result_count();
+ Statement* s;
+ if (count == 0)
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ s = Statement::make_return_statement(no->func_value()->type()->results(),
+ retvals, location);
+ }
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ return Expression::make_func_reference(no, NULL, location);
+}
+
+// Make a selector expression.
+
+Expression*
+Expression::make_selector(Expression* left, const std::string& name,
+ source_location location)
+{
+ return new Selector_expression(left, name, location);
+}
+
+// Implement the builtin function new.
+
+class Allocation_expression : public Expression
+{
+ public:
+ Allocation_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_ALLOCATION, location),
+ type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Type::traverse(this->type_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->type_); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ { return new Allocation_expression(this->type_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are allocating.
+ Type* type_;
+};
+
+// Check the type of an allocation expression.
+
+void
+Allocation_expression::do_check_types(Gogo*)
+{
+ if (this->type_->function_type() != NULL)
+ this->report_error(_("invalid new of function type"));
+}
+
+// Return a tree for an allocation expression.
+
+tree
+Allocation_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ tree size_tree = TYPE_SIZE_UNIT(type_tree);
+ tree space = context->gogo()->allocate_memory(this->type_, size_tree,
+ this->location());
+ if (space == error_mark_node)
+ return error_mark_node;
+ return fold_convert(build_pointer_type(type_tree), space);
+}
+
+// Make an allocation expression.
+
+Expression*
+Expression::make_allocation(Type* type, source_location location)
+{
+ return new Allocation_expression(type, location);
+}
+
+// Implement the builtin function make.
+
+class Make_expression : public Expression
+{
+ public:
+ Make_expression(Type* type, Expression_list* args, source_location location)
+ : Expression(EXPRESSION_MAKE, location),
+ type_(type), args_(args)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Make_expression(this->type_, this->args_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type we are making.
+ Type* type_;
+ // The arguments to pass to the make routine.
+ Expression_list* args_;
+};
+
+// Traversal.
+
+int
+Make_expression::do_traverse(Traverse* traverse)
+{
+ if (this->args_ != NULL
+ && this->args_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Set types of arguments.
+
+void
+Make_expression::do_determine_type(const Type_context*)
+{
+ if (this->args_ != NULL)
+ {
+ Type_context context(Type::lookup_integer_type("int"), false);
+ for (Expression_list::const_iterator pe = this->args_->begin();
+ pe != this->args_->end();
+ ++pe)
+ (*pe)->determine_type(&context);
+ }
+}
+
+// Check types for a make expression.
+
+void
+Make_expression::do_check_types(Gogo*)
+{
+ if (this->type_->channel_type() == NULL
+ && this->type_->map_type() == NULL
+ && (this->type_->array_type() == NULL
+ || this->type_->array_type()->length() != NULL))
+ this->report_error(_("invalid type for make function"));
+ else if (!this->type_->check_make_expression(this->args_, this->location()))
+ this->set_is_error();
+}
+
+// Return a tree for a make expression.
+
+tree
+Make_expression::do_get_tree(Translate_context* context)
+{
+ return this->type_->make_expression_tree(context, this->args_,
+ this->location());
+}
+
+// Make a make expression.
+
+Expression*
+Expression::make_make(Type* type, Expression_list* args,
+ source_location location)
+{
+ return new Make_expression(type, args, location);
+}
+
+// Construct a struct.
+
+class Struct_construction_expression : public Expression
+{
+ public:
+ Struct_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_STRUCT_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { }
+
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_struct() const;
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Struct_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the struct to construct.
+ Type* type_;
+ // The list of values, in order of the fields in the struct. A NULL
+ // entry means that the field should be zero-initialized.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Struct_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Struct_construction_expression::is_constant_struct() const
+{
+ if (this->vals_ == NULL)
+ return true;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ // There are no constant constructors for interfaces.
+ if (pf->type()->interface_type() != NULL)
+ return false;
+ }
+
+ return true;
+}
+
+// Final type determination.
+
+void
+Struct_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv)
+ {
+ if (pv == this->vals_->end())
+ return;
+ if (*pv != NULL)
+ {
+ Type_context subcontext(pf->type(), false);
+ (*pv)->determine_type(&subcontext);
+ }
+ }
+ // Extra values are an error we will report elsewhere; we still want
+ // to determine the type to avoid knockon errors.
+ for (; pv != this->vals_->end(); ++pv)
+ (*pv)->determine_type_no_context();
+}
+
+// Check types.
+
+void
+Struct_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Struct_type* st = this->type_->struct_type();
+ if (this->vals_->size() > st->field_count())
+ {
+ this->report_error(_("too many expressions for struct"));
+ return;
+ }
+
+ const Struct_field_list* fields = st->fields();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++pv, ++i)
+ {
+ if (pv == this->vals_->end())
+ {
+ this->report_error(_("too few expressions for struct"));
+ break;
+ }
+
+ if (*pv == NULL)
+ continue;
+
+ std::string reason;
+ if (!Type::are_assignable(pf->type(), (*pv)->type(), &reason))
+ {
+ if (reason.empty())
+ error_at((*pv)->location(),
+ "incompatible type for field %d in struct construction",
+ i + 1);
+ else
+ error_at((*pv)->location(),
+ ("incompatible type for field %d in "
+ "struct construction (%s)"),
+ i + 1, reason.c_str());
+ this->set_is_error();
+ }
+ }
+ gcc_assert(pv == this->vals_->end());
+}
+
+// Return a tree for constructing a struct.
+
+tree
+Struct_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ if (this->vals_ == NULL)
+ return this->type_->get_init_tree(gogo, false);
+
+ tree type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ bool is_constant = true;
+ const Struct_field_list* fields = this->type_->struct_type()->fields();
+ VEC(constructor_elt,gc)* elts = VEC_alloc(constructor_elt, gc,
+ fields->size());
+ Struct_field_list::const_iterator pf = fields->begin();
+ Expression_list::const_iterator pv = this->vals_->begin();
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field), ++pf)
+ {
+ gcc_assert(pf != fields->end());
+
+ tree val;
+ if (pv == this->vals_->end())
+ val = pf->type()->get_init_tree(gogo, false);
+ else if (*pv == NULL)
+ {
+ val = pf->type()->get_init_tree(gogo, false);
+ ++pv;
+ }
+ else
+ {
+ val = Expression::convert_for_assignment(context, pf->type(),
+ (*pv)->type(),
+ (*pv)->get_tree(context),
+ this->location());
+ ++pv;
+ }
+
+ if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
+ return error_mark_node;
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, elts, NULL);
+ elt->index = field;
+ elt->value = val;
+ if (!TREE_CONSTANT(val))
+ is_constant = false;
+ }
+ gcc_assert(pf == fields->end());
+
+ tree ret = build_constructor(type_tree, elts);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export a struct construction.
+
+void
+Struct_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// Make a struct composite literal. This used by the thunk code.
+
+Expression*
+Expression::make_struct_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ gcc_assert(type->struct_type() != NULL);
+ return new Struct_construction_expression(type, vals, location);
+}
+
+// Construct an array. This class is not used directly; instead we
+// use the child classes, Fixed_array_construction_expression and
+// Open_array_construction_expression.
+
+class Array_construction_expression : public Expression
+{
+ protected:
+ Array_construction_expression(Expression_classification classification,
+ Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(classification, location),
+ type_(type), vals_(vals)
+ { }
+
+ public:
+ // Return whether this is a constant initializer.
+ bool
+ is_constant_array() const;
+
+ // Return the number of elements.
+ size_t
+ element_count() const
+ { return this->vals_ == NULL ? 0 : this->vals_->size(); }
+
+protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_is_addressable() const
+ { return true; }
+
+ void
+ do_export(Export*) const;
+
+ // The list of values.
+ Expression_list*
+ vals()
+ { return this->vals_; }
+
+ // Get a constructor tree for the array values.
+ tree
+ get_constructor_tree(Translate_context* context, tree type_tree);
+
+ private:
+ // The type of the array to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Array_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether this is a constant initializer.
+
+bool
+Array_construction_expression::is_constant_array() const
+{
+ if (this->vals_ == NULL)
+ return true;
+
+ // There are no constant constructors for interfaces.
+ if (this->type_->array_type()->element_type()->interface_type() != NULL)
+ return false;
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL
+ && !(*pv)->is_constant()
+ && (!(*pv)->is_composite_literal()
+ || (*pv)->is_nonconstant_composite_literal()))
+ return false;
+ }
+ return true;
+}
+
+// Final type determination.
+
+void
+Array_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+ Type_context subcontext(this->type_->array_type()->element_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ if (*pv != NULL)
+ (*pv)->determine_type(&subcontext);
+ }
+}
+
+// Check types.
+
+void
+Array_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Array_type* at = this->type_->array_type();
+ int i = 0;
+ Type* element_type = at->element_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (*pv != NULL
+ && !Type::are_assignable(element_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d in composite literal",
+ i + 1);
+ this->set_is_error();
+ }
+ }
+
+ Expression* length = at->length();
+ if (length != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (at->length()->integer_constant_value(true, val, &type))
+ {
+ if (this->vals_->size() > mpz_get_ui(val))
+ this->report_error(_("too many elements in composite literal"));
+ }
+ mpz_clear(val);
+ }
+}
+
+// Get a constructor tree for the array values.
+
+tree
+Array_construction_expression::get_constructor_tree(Translate_context* context,
+ tree type_tree)
+{
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ (this->vals_ == NULL
+ ? 0
+ : this->vals_->size()));
+ Type* element_type = this->type_->array_type()->element_type();
+ bool is_constant = true;
+ if (this->vals_ != NULL)
+ {
+ size_t i = 0;
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ if (*pv == NULL)
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ else
+ {
+ tree value_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context,
+ element_type,
+ (*pv)->type(),
+ value_tree,
+ this->location());
+ }
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ is_constant = false;
+ }
+ }
+
+ tree ret = build_constructor(type_tree, values);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Array_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ if (this->vals_ != NULL)
+ {
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ if (*pv != NULL)
+ (*pv)->export_expression(exp);
+ }
+ }
+ exp->write_c_string(")");
+}
+
+// Construct a fixed array.
+
+class Fixed_array_construction_expression :
+ public Array_construction_expression
+{
+ public:
+ Fixed_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ gcc_assert(type->array_type() != NULL
+ && type->array_type()->length() != NULL);
+ }
+
+ protected:
+ Expression*
+ do_copy()
+ {
+ return new Fixed_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing a fixed array.
+
+tree
+Fixed_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ return this->get_constructor_tree(context,
+ this->type()->get_tree(context->gogo()));
+}
+
+// Construct an open array.
+
+class Open_array_construction_expression : public Array_construction_expression
+{
+ public:
+ Open_array_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Array_construction_expression(EXPRESSION_OPEN_ARRAY_CONSTRUCTION,
+ type, vals, location)
+ {
+ gcc_assert(type->array_type() != NULL
+ && type->array_type()->length() == NULL);
+ }
+
+ protected:
+ // Note that taking the address of an open array literal is invalid.
+
+ Expression*
+ do_copy()
+ {
+ return new Open_array_construction_expression(this->type(),
+ (this->vals() == NULL
+ ? NULL
+ : this->vals()->copy()),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// Return a tree for constructing an open array.
+
+tree
+Open_array_construction_expression::do_get_tree(Translate_context* context)
+{
+ Array_type* array_type = this->type()->array_type();
+ if (array_type == NULL)
+ {
+ gcc_assert(this->type()->is_error_type());
+ return error_mark_node;
+ }
+
+ Type* element_type = array_type->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree values;
+ tree length_tree;
+ if (this->vals() == NULL || this->vals()->empty())
+ {
+ // We need to create a unique value.
+ tree max = size_int(0);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ VEC(constructor_elt,gc)* vec = VEC_alloc(constructor_elt, gc, 1);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, vec, NULL);
+ elt->index = size_int(0);
+ elt->value = element_type->get_init_tree(context->gogo(), false);
+ values = build_constructor(constructor_type, vec);
+ if (TREE_CONSTANT(elt->value))
+ TREE_CONSTANT(values) = 1;
+ length_tree = size_int(0);
+ }
+ else
+ {
+ tree max = size_int(this->vals()->size() - 1);
+ tree constructor_type = build_array_type(element_type_tree,
+ build_index_type(max));
+ if (constructor_type == error_mark_node)
+ return error_mark_node;
+ values = this->get_constructor_tree(context, constructor_type);
+ length_tree = size_int(this->vals()->size());
+ }
+
+ if (values == error_mark_node)
+ return error_mark_node;
+
+ bool is_constant_initializer = TREE_CONSTANT(values);
+
+ // We have to copy the initial values into heap memory if we are in
+ // a function or if the values are not constants. We also have to
+ // copy them if they may contain pointers in a non-constant context,
+ // as otherwise the garbage collector won't see them.
+ bool copy_to_heap = (context->function() != NULL
+ || !is_constant_initializer
+ || (element_type->has_pointer()
+ && !context->is_const()));
+
+ if (is_constant_initializer)
+ {
+ tree tmp = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("C"), TREE_TYPE(values));
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (copy_to_heap)
+ {
+ // If we are not copying the value to the heap, we will only
+ // initialize the value once, so we can use this directly
+ // rather than copying it. In that case we can't make it
+ // read-only, because the program is permitted to change it.
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ }
+ DECL_INITIAL(tmp) = values;
+ rest_of_decl_compilation(tmp, 1, 0);
+ values = tmp;
+ }
+
+ tree space;
+ tree set;
+ if (!copy_to_heap)
+ {
+ // the initializer will only run once.
+ space = build_fold_addr_expr(values);
+ set = NULL_TREE;
+ }
+ else
+ {
+ tree memsize = TYPE_SIZE_UNIT(TREE_TYPE(values));
+ space = context->gogo()->allocate_memory(element_type, memsize,
+ this->location());
+ space = save_expr(space);
+
+ tree s = fold_convert(build_pointer_type(TREE_TYPE(values)), space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), s);
+ TREE_THIS_NOTRAP(ref) = 1;
+ set = build2(MODIFY_EXPR, void_type_node, ref, values);
+ }
+
+ // Build a constructor for the open array.
+
+ tree type_tree = this->type()->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), space);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),"__capacity") == 0);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), length_tree);
+
+ tree constructor = build_constructor(type_tree, init);
+ if (constructor == error_mark_node)
+ return error_mark_node;
+ if (!copy_to_heap)
+ TREE_CONSTANT(constructor) = 1;
+
+ if (set == NULL_TREE)
+ return constructor;
+ else
+ return build2(COMPOUND_EXPR, type_tree, set, constructor);
+}
+
+// Make a slice composite literal. This is used by the type
+// descriptor code.
+
+Expression*
+Expression::make_slice_composite_literal(Type* type, Expression_list* vals,
+ source_location location)
+{
+ gcc_assert(type->is_open_array_type());
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Construct a map.
+
+class Map_construction_expression : public Expression
+{
+ public:
+ Map_construction_expression(Type* type, Expression_list* vals,
+ source_location location)
+ : Expression(EXPRESSION_MAP_CONSTRUCTION, location),
+ type_(type), vals_(vals)
+ { gcc_assert(vals == NULL || vals->size() % 2 == 0); }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Type*
+ do_type()
+ { return this->type_; }
+
+ void
+ do_determine_type(const Type_context*);
+
+ void
+ do_check_types(Gogo*);
+
+ Expression*
+ do_copy()
+ {
+ return new Map_construction_expression(this->type_, this->vals_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ void
+ do_export(Export*) const;
+
+ private:
+ // The type of the map to construct.
+ Type* type_;
+ // The list of values.
+ Expression_list* vals_;
+};
+
+// Traversal.
+
+int
+Map_construction_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Final type determination.
+
+void
+Map_construction_expression::do_determine_type(const Type_context*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ Type_context key_context(mt->key_type(), false);
+ Type_context val_context(mt->val_type(), false);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ (*pv)->determine_type(&key_context);
+ ++pv;
+ (*pv)->determine_type(&val_context);
+ }
+}
+
+// Check types.
+
+void
+Map_construction_expression::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ Map_type* mt = this->type_->map_type();
+ int i = 0;
+ Type* key_type = mt->key_type();
+ Type* val_type = mt->val_type();
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ if (!Type::are_assignable(key_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ "incompatible type for element %d key in map construction",
+ i + 1);
+ this->set_is_error();
+ }
+ ++pv;
+ if (!Type::are_assignable(val_type, (*pv)->type(), NULL))
+ {
+ error_at((*pv)->location(),
+ ("incompatible type for element %d value "
+ "in map construction"),
+ i + 1);
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree for constructing a map.
+
+tree
+Map_construction_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ source_location loc = this->location();
+
+ Map_type* mt = this->type_->map_type();
+
+ // Build a struct to hold the key and value.
+ tree struct_type = make_node(RECORD_TYPE);
+
+ Type* key_type = mt->key_type();
+ tree id = get_identifier("__key");
+ tree key_type_tree = key_type->get_tree(gogo);
+ if (key_type_tree == error_mark_node)
+ return error_mark_node;
+ tree key_field = build_decl(loc, FIELD_DECL, id, key_type_tree);
+ DECL_CONTEXT(key_field) = struct_type;
+ TYPE_FIELDS(struct_type) = key_field;
+
+ Type* val_type = mt->val_type();
+ id = get_identifier("__val");
+ tree val_type_tree = val_type->get_tree(gogo);
+ if (val_type_tree == error_mark_node)
+ return error_mark_node;
+ tree val_field = build_decl(loc, FIELD_DECL, id, val_type_tree);
+ DECL_CONTEXT(val_field) = struct_type;
+ DECL_CHAIN(key_field) = val_field;
+
+ layout_type(struct_type);
+
+ bool is_constant = true;
+ size_t i = 0;
+ tree valaddr;
+ tree make_tmp;
+
+ if (this->vals_ == NULL || this->vals_->empty())
+ {
+ valaddr = null_pointer_node;
+ make_tmp = NULL_TREE;
+ }
+ else
+ {
+ VEC(constructor_elt,gc)* values = VEC_alloc(constructor_elt, gc,
+ this->vals_->size() / 2);
+
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv, ++i)
+ {
+ bool one_is_constant = true;
+
+ VEC(constructor_elt,gc)* one = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = key_field;
+ tree val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, key_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ ++pv;
+
+ elt = VEC_quick_push(constructor_elt, one, NULL);
+ elt->index = val_field;
+ val_tree = (*pv)->get_tree(context);
+ elt->value = Expression::convert_for_assignment(context, val_type,
+ (*pv)->type(),
+ val_tree, loc);
+ if (elt->value == error_mark_node)
+ return error_mark_node;
+ if (!TREE_CONSTANT(elt->value))
+ one_is_constant = false;
+
+ elt = VEC_quick_push(constructor_elt, values, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(struct_type, one);
+ if (one_is_constant)
+ TREE_CONSTANT(elt->value) = 1;
+ else
+ is_constant = false;
+ }
+
+ tree index_type = build_index_type(size_int(i - 1));
+ tree array_type = build_array_type(struct_type, index_type);
+ tree init = build_constructor(array_type, values);
+ if (is_constant)
+ TREE_CONSTANT(init) = 1;
+ tree tmp;
+ if (current_function_decl != NULL)
+ {
+ tmp = create_tmp_var(array_type, get_name(array_type));
+ DECL_INITIAL(tmp) = init;
+ make_tmp = fold_build1_loc(loc, DECL_EXPR, void_type_node, tmp);
+ TREE_ADDRESSABLE(tmp) = 1;
+ }
+ else
+ {
+ tmp = build_decl(loc, VAR_DECL, create_tmp_var_name("M"), array_type);
+ DECL_EXTERNAL(tmp) = 0;
+ TREE_PUBLIC(tmp) = 0;
+ TREE_STATIC(tmp) = 1;
+ DECL_ARTIFICIAL(tmp) = 1;
+ if (!TREE_CONSTANT(init))
+ make_tmp = fold_build2_loc(loc, INIT_EXPR, void_type_node, tmp,
+ init);
+ else
+ {
+ TREE_READONLY(tmp) = 1;
+ TREE_CONSTANT(tmp) = 1;
+ DECL_INITIAL(tmp) = init;
+ make_tmp = NULL_TREE;
+ }
+ rest_of_decl_compilation(tmp, 1, 0);
+ }
+
+ valaddr = build_fold_addr_expr(tmp);
+ }
+
+ tree descriptor = gogo->map_descriptor(mt);
+
+ tree type_tree = this->type_->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ static tree construct_map_fndecl;
+ tree call = Gogo::call_builtin(&construct_map_fndecl,
+ loc,
+ "__go_construct_map",
+ 6,
+ type_tree,
+ TREE_TYPE(descriptor),
+ descriptor,
+ sizetype,
+ size_int(i),
+ sizetype,
+ TYPE_SIZE_UNIT(struct_type),
+ sizetype,
+ byte_position(val_field),
+ sizetype,
+ TYPE_SIZE_UNIT(TREE_TYPE(val_field)),
+ const_ptr_type_node,
+ fold_convert(const_ptr_type_node, valaddr));
+ if (call == error_mark_node)
+ return error_mark_node;
+
+ tree ret;
+ if (make_tmp == NULL)
+ ret = call;
+ else
+ ret = fold_build2_loc(loc, COMPOUND_EXPR, type_tree, make_tmp, call);
+ return ret;
+}
+
+// Export an array construction.
+
+void
+Map_construction_expression::do_export(Export* exp) const
+{
+ exp->write_c_string("convert(");
+ exp->write_type(this->type_);
+ for (Expression_list::const_iterator pv = this->vals_->begin();
+ pv != this->vals_->end();
+ ++pv)
+ {
+ exp->write_c_string(", ");
+ (*pv)->export_expression(exp);
+ }
+ exp->write_c_string(")");
+}
+
+// A general composite literal. This is lowered to a type specific
+// version.
+
+class Composite_literal_expression : public Parser_expression
+{
+ public:
+ Composite_literal_expression(Type* type, int depth, bool has_keys,
+ Expression_list* vals, source_location location)
+ : Parser_expression(EXPRESSION_COMPOSITE_LITERAL, location),
+ type_(type), depth_(depth), vals_(vals), has_keys_(has_keys)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ Expression*
+ do_lower(Gogo*, Named_object*, int);
+
+ Expression*
+ do_copy()
+ {
+ return new Composite_literal_expression(this->type_, this->depth_,
+ this->has_keys_,
+ (this->vals_ == NULL
+ ? NULL
+ : this->vals_->copy()),
+ this->location());
+ }
+
+ private:
+ Expression*
+ lower_struct(Gogo*, Type*);
+
+ Expression*
+ lower_array(Type*);
+
+ Expression*
+ make_array(Type*, Expression_list*);
+
+ Expression*
+ lower_map(Gogo*, Named_object*, Type*);
+
+ // The type of the composite literal.
+ Type* type_;
+ // The depth within a list of composite literals within a composite
+ // literal, when the type is omitted.
+ int depth_;
+ // The values to put in the composite literal.
+ Expression_list* vals_;
+ // If this is true, then VALS_ is a list of pairs: a key and a
+ // value. In an array initializer, a missing key will be NULL.
+ bool has_keys_;
+};
+
+// Traversal.
+
+int
+Composite_literal_expression::do_traverse(Traverse* traverse)
+{
+ if (this->vals_ != NULL
+ && this->vals_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return Type::traverse(this->type_, traverse);
+}
+
+// Lower a generic composite literal into a specific version based on
+// the type.
+
+Expression*
+Composite_literal_expression::do_lower(Gogo* gogo, Named_object* function, int)
+{
+ Type* type = this->type_;
+
+ for (int depth = this->depth_; depth > 0; --depth)
+ {
+ if (type->array_type() != NULL)
+ type = type->array_type()->element_type();
+ else if (type->map_type() != NULL)
+ type = type->map_type()->val_type();
+ else
+ {
+ if (!type->is_error_type())
+ error_at(this->location(),
+ ("may only omit types within composite literals "
+ "of slice, array, or map type"));
+ return Expression::make_error(this->location());
+ }
+ }
+
+ if (type->is_error_type())
+ return Expression::make_error(this->location());
+ else if (type->struct_type() != NULL)
+ return this->lower_struct(gogo, type);
+ else if (type->array_type() != NULL)
+ return this->lower_array(type);
+ else if (type->map_type() != NULL)
+ return this->lower_map(gogo, function, type);
+ else
+ {
+ error_at(this->location(),
+ ("expected struct, slice, array, or map type "
+ "for composite literal"));
+ return Expression::make_error(this->location());
+ }
+}
+
+// Lower a struct composite literal.
+
+Expression*
+Composite_literal_expression::lower_struct(Gogo* gogo, Type* type)
+{
+ source_location location = this->location();
+ Struct_type* st = type->struct_type();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return new Struct_construction_expression(type, this->vals_, location);
+
+ size_t field_count = st->field_count();
+ std::vector<Expression*> vals(field_count);
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* name_expr = *p;
+
+ ++p;
+ gcc_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (name_expr == NULL)
+ {
+ error_at(val->location(), "mixture of field and value initializers");
+ return Expression::make_error(location);
+ }
+
+ bool bad_key = false;
+ std::string name;
+ const Named_object* no = NULL;
+ switch (name_expr->classification())
+ {
+ case EXPRESSION_UNKNOWN_REFERENCE:
+ name = name_expr->unknown_expression()->name();
+ break;
+
+ case EXPRESSION_CONST_REFERENCE:
+ no = static_cast<Const_expression*>(name_expr)->named_object();
+ break;
+
+ case EXPRESSION_TYPE:
+ {
+ Type* t = name_expr->type();
+ Named_type* nt = t->named_type();
+ if (nt == NULL)
+ bad_key = true;
+ else
+ no = nt->named_object();
+ }
+ break;
+
+ case EXPRESSION_VAR_REFERENCE:
+ no = name_expr->var_expression()->named_object();
+ break;
+
+ case EXPRESSION_FUNC_REFERENCE:
+ no = name_expr->func_expression()->named_object();
+ break;
+
+ case EXPRESSION_UNARY:
+ // If there is a local variable around with the same name as
+ // the field, and this occurs in the closure, then the
+ // parser may turn the field reference into an indirection
+ // through the closure. FIXME: This is a mess.
+ {
+ bad_key = true;
+ Unary_expression* ue = static_cast<Unary_expression*>(name_expr);
+ if (ue->op() == OPERATOR_MULT)
+ {
+ Field_reference_expression* fre =
+ ue->operand()->field_reference_expression();
+ if (fre != NULL)
+ {
+ Struct_type* st =
+ fre->expr()->type()->deref()->struct_type();
+ if (st != NULL)
+ {
+ const Struct_field* sf = st->field(fre->field_index());
+ name = sf->field_name();
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", fre->field_index());
+ size_t buflen = strlen(buf);
+ if (name.compare(name.length() - buflen, buflen, buf)
+ == 0)
+ {
+ name = name.substr(0, name.length() - buflen);
+ bad_key = false;
+ }
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ bad_key = true;
+ break;
+ }
+ if (bad_key)
+ {
+ error_at(name_expr->location(), "expected struct field name");
+ return Expression::make_error(location);
+ }
+
+ if (no != NULL)
+ {
+ name = no->name();
+
+ // A predefined name won't be packed. If it starts with a
+ // lower case letter we need to check for that case, because
+ // the field name will be packed.
+ if (!Gogo::is_hidden_name(name)
+ && name[0] >= 'a'
+ && name[0] <= 'z')
+ {
+ Named_object* gno = gogo->lookup_global(name.c_str());
+ if (gno == no)
+ name = gogo->pack_hidden_name(name, false);
+ }
+ }
+
+ unsigned int index;
+ const Struct_field* sf = st->find_local_field(name, &index);
+ if (sf == NULL)
+ {
+ error_at(name_expr->location(), "unknown field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+ if (vals[index] != NULL)
+ {
+ error_at(name_expr->location(),
+ "duplicate value for field %qs in %qs",
+ Gogo::message_name(name).c_str(),
+ (type->named_type() != NULL
+ ? type->named_type()->message_name().c_str()
+ : "unnamed struct"));
+ return Expression::make_error(location);
+ }
+
+ vals[index] = val;
+ }
+
+ Expression_list* list = new Expression_list;
+ list->reserve(field_count);
+ for (size_t i = 0; i < field_count; ++i)
+ list->push_back(vals[i]);
+
+ return new Struct_construction_expression(type, list, location);
+}
+
+// Lower an array composite literal.
+
+Expression*
+Composite_literal_expression::lower_array(Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ == NULL || !this->has_keys_)
+ return this->make_array(type, this->vals_);
+
+ std::vector<Expression*> vals;
+ vals.reserve(this->vals_->size());
+ unsigned long index = 0;
+ Expression_list::const_iterator p = this->vals_->begin();
+ while (p != this->vals_->end())
+ {
+ Expression* index_expr = *p;
+
+ ++p;
+ gcc_assert(p != this->vals_->end());
+ Expression* val = *p;
+
+ ++p;
+
+ if (index_expr != NULL)
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ Type* dummy;
+ if (!index_expr->integer_constant_value(true, ival, &dummy))
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(),
+ "index expression is not integer constant");
+ return Expression::make_error(location);
+ }
+
+ if (mpz_sgn(ival) < 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index expression is negative");
+ return Expression::make_error(location);
+ }
+
+ index = mpz_get_ui(ival);
+ if (mpz_cmp_ui(ival, index) != 0)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index value overflow");
+ return Expression::make_error(location);
+ }
+
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ bool ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ if (!ok)
+ {
+ mpz_clear(ival);
+ error_at(index_expr->location(), "index value overflow");
+ return Expression::make_error(location);
+ }
+
+ mpz_clear(ival);
+
+ // FIXME: Our representation isn't very good; this avoids
+ // thrashing.
+ if (index > 0x1000000)
+ {
+ error_at(index_expr->location(), "index too large for compiler");
+ return Expression::make_error(location);
+ }
+ }
+
+ if (index == vals.size())
+ vals.push_back(val);
+ else
+ {
+ if (index > vals.size())
+ {
+ vals.reserve(index + 32);
+ vals.resize(index + 1, static_cast<Expression*>(NULL));
+ }
+ if (vals[index] != NULL)
+ {
+ error_at((index_expr != NULL
+ ? index_expr->location()
+ : val->location()),
+ "duplicate value for index %lu",
+ index);
+ return Expression::make_error(location);
+ }
+ vals[index] = val;
+ }
+
+ ++index;
+ }
+
+ size_t size = vals.size();
+ Expression_list* list = new Expression_list;
+ list->reserve(size);
+ for (size_t i = 0; i < size; ++i)
+ list->push_back(vals[i]);
+
+ return this->make_array(type, list);
+}
+
+// Actually build the array composite literal. This handles
+// [...]{...}.
+
+Expression*
+Composite_literal_expression::make_array(Type* type, Expression_list* vals)
+{
+ source_location location = this->location();
+ Array_type* at = type->array_type();
+ if (at->length() != NULL && at->length()->is_nil_expression())
+ {
+ size_t size = vals == NULL ? 0 : vals->size();
+ mpz_t vlen;
+ mpz_init_set_ui(vlen, size);
+ Expression* elen = Expression::make_integer(&vlen, NULL, location);
+ mpz_clear(vlen);
+ at = Type::make_array_type(at->element_type(), elen);
+ type = at;
+ }
+ if (at->length() != NULL)
+ return new Fixed_array_construction_expression(type, vals, location);
+ else
+ return new Open_array_construction_expression(type, vals, location);
+}
+
+// Lower a map composite literal.
+
+Expression*
+Composite_literal_expression::lower_map(Gogo* gogo, Named_object* function,
+ Type* type)
+{
+ source_location location = this->location();
+ if (this->vals_ != NULL)
+ {
+ if (!this->has_keys_)
+ {
+ error_at(location, "map composite literal must have keys");
+ return Expression::make_error(location);
+ }
+
+ for (Expression_list::iterator p = this->vals_->begin();
+ p != this->vals_->end();
+ p += 2)
+ {
+ if (*p == NULL)
+ {
+ ++p;
+ error_at((*p)->location(),
+ "map composite literal must have keys for every value");
+ return Expression::make_error(location);
+ }
+ // Make sure we have lowered the key; it may not have been
+ // lowered in order to handle keys for struct composite
+ // literals. Lower it now to get the right error message.
+ if ((*p)->unknown_expression() != NULL)
+ {
+ (*p)->unknown_expression()->clear_is_composite_literal_key();
+ gogo->lower_expression(function, &*p);
+ gcc_assert((*p)->is_error_expression());
+ return Expression::make_error(location);
+ }
+ }
+ }
+
+ return new Map_construction_expression(type, this->vals_, location);
+}
+
+// Make a composite literal expression.
+
+Expression*
+Expression::make_composite_literal(Type* type, int depth, bool has_keys,
+ Expression_list* vals,
+ source_location location)
+{
+ return new Composite_literal_expression(type, depth, has_keys, vals,
+ location);
+}
+
+// Return whether this expression is a composite literal.
+
+bool
+Expression::is_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_COMPOSITE_LITERAL:
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return whether this expression is a composite literal which is not
+// constant.
+
+bool
+Expression::is_nonconstant_composite_literal() const
+{
+ switch (this->classification_)
+ {
+ case EXPRESSION_STRUCT_CONSTRUCTION:
+ {
+ const Struct_construction_expression *psce =
+ static_cast<const Struct_construction_expression*>(this);
+ return !psce->is_constant_struct();
+ }
+ case EXPRESSION_FIXED_ARRAY_CONSTRUCTION:
+ {
+ const Fixed_array_construction_expression *pace =
+ static_cast<const Fixed_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_OPEN_ARRAY_CONSTRUCTION:
+ {
+ const Open_array_construction_expression *pace =
+ static_cast<const Open_array_construction_expression*>(this);
+ return !pace->is_constant_array();
+ }
+ case EXPRESSION_MAP_CONSTRUCTION:
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Return true if this is a reference to a local variable.
+
+bool
+Expression::is_local_variable() const
+{
+ const Var_expression* ve = this->var_expression();
+ if (ve == NULL)
+ return false;
+ const Named_object* no = ve->named_object();
+ return (no->is_result_variable()
+ || (no->is_variable() && !no->var_value()->is_global()));
+}
+
+// Class Type_guard_expression.
+
+// Traversal.
+
+int
+Type_guard_expression::do_traverse(Traverse* traverse)
+{
+ if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check types of a type guard expression. The expression must have
+// an interface type, but the actual type conversion is checked at run
+// time.
+
+void
+Type_guard_expression::do_check_types(Gogo*)
+{
+ // 6g permits using a type guard with unsafe.pointer; we are
+ // compatible.
+ Type* expr_type = this->expr_->type();
+ if (expr_type->is_unsafe_pointer_type())
+ {
+ if (this->type_->points_to() == NULL
+ && (this->type_->integer_type() == NULL
+ || (this->type_->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (this->type_->is_unsafe_pointer_type())
+ {
+ if (expr_type->points_to() == NULL
+ && (expr_type->integer_type() == NULL
+ || (expr_type->forwarded()
+ != Type::lookup_integer_type("uintptr"))))
+ this->report_error(_("invalid unsafe.Pointer conversion"));
+ }
+ else if (expr_type->interface_type() == NULL)
+ {
+ if (!expr_type->is_error_type() && !this->type_->is_error_type())
+ this->report_error(_("type assertion only valid for interface types"));
+ this->set_is_error();
+ }
+ else if (this->type_->interface_type() == NULL)
+ {
+ std::string reason;
+ if (!expr_type->interface_type()->implements_interface(this->type_,
+ &reason))
+ {
+ if (!this->type_->is_error_type())
+ {
+ if (reason.empty())
+ this->report_error(_("impossible type assertion: "
+ "type does not implement interface"));
+ else
+ error_at(this->location(),
+ ("impossible type assertion: "
+ "type does not implement interface (%s)"),
+ reason.c_str());
+ }
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree for a type guard expression.
+
+tree
+Type_guard_expression::do_get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ Type* expr_type = this->expr_->type();
+ if ((this->type_->is_unsafe_pointer_type()
+ && (expr_type->points_to() != NULL
+ || expr_type->integer_type() != NULL))
+ || (expr_type->is_unsafe_pointer_type()
+ && this->type_->points_to() != NULL))
+ return convert_to_pointer(this->type_->get_tree(gogo), expr_tree);
+ else if (expr_type->is_unsafe_pointer_type()
+ && this->type_->integer_type() != NULL)
+ return convert_to_integer(this->type_->get_tree(gogo), expr_tree);
+ else if (this->type_->interface_type() != NULL)
+ return Expression::convert_interface_to_interface(context, this->type_,
+ this->expr_->type(),
+ expr_tree, true,
+ this->location());
+ else
+ return Expression::convert_for_assignment(context, this->type_,
+ this->expr_->type(), expr_tree,
+ this->location());
+}
+
+// Make a type guard expression.
+
+Expression*
+Expression::make_type_guard(Expression* expr, Type* type,
+ source_location location)
+{
+ return new Type_guard_expression(expr, type, location);
+}
+
+// Class Heap_composite_expression.
+
+// When you take the address of a composite literal, it is allocated
+// on the heap. This class implements that.
+
+class Heap_composite_expression : public Expression
+{
+ public:
+ Heap_composite_expression(Expression* expr, source_location location)
+ : Expression(EXPRESSION_HEAP_COMPOSITE, location),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return Expression::traverse(&this->expr_, traverse); }
+
+ Type*
+ do_type()
+ { return Type::make_pointer_type(this->expr_->type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { this->expr_->determine_type_no_context(); }
+
+ Expression*
+ do_copy()
+ {
+ return Expression::make_heap_composite(this->expr_->copy(),
+ this->location());
+ }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ // We only export global objects, and the parser does not generate
+ // this in global scope.
+ void
+ do_export(Export*) const
+ { gcc_unreachable(); }
+
+ private:
+ // The composite literal which is being put on the heap.
+ Expression* expr_;
+};
+
+// Return a tree which allocates a composite literal on the heap.
+
+tree
+Heap_composite_expression::do_get_tree(Translate_context* context)
+{
+ tree expr_tree = this->expr_->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ tree expr_size = TYPE_SIZE_UNIT(TREE_TYPE(expr_tree));
+ gcc_assert(TREE_CODE(expr_size) == INTEGER_CST);
+ tree space = context->gogo()->allocate_memory(this->expr_->type(),
+ expr_size, this->location());
+ space = fold_convert(build_pointer_type(TREE_TYPE(expr_tree)), space);
+ space = save_expr(space);
+ tree ref = build_fold_indirect_ref_loc(this->location(), space);
+ TREE_THIS_NOTRAP(ref) = 1;
+ tree ret = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, ref, expr_tree),
+ space);
+ SET_EXPR_LOCATION(ret, this->location());
+ return ret;
+}
+
+// Allocate a composite literal on the heap.
+
+Expression*
+Expression::make_heap_composite(Expression* expr, source_location location)
+{
+ return new Heap_composite_expression(expr, location);
+}
+
+// Class Receive_expression.
+
+// Return the type of a receive expression.
+
+Type*
+Receive_expression::do_type()
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ return Type::make_error_type();
+ return channel_type->element_type();
+}
+
+// Check types for a receive expression.
+
+void
+Receive_expression::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+ if (type->channel_type() == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return;
+ }
+ if (!type->channel_type()->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return;
+ }
+}
+
+// Get a tree for a receive expression.
+
+tree
+Receive_expression::do_get_tree(Translate_context* context)
+{
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ {
+ gcc_assert(this->channel_->type()->is_error_type());
+ return error_mark_node;
+ }
+ Type* element_type = channel_type->element_type();
+ tree element_type_tree = element_type->get_tree(context->gogo());
+
+ tree channel = this->channel_->get_tree(context);
+ if (element_type_tree == error_mark_node || channel == error_mark_node)
+ return error_mark_node;
+
+ return Gogo::receive_from_channel(element_type_tree, channel,
+ this->for_select_, this->location());
+}
+
+// Make a receive expression.
+
+Receive_expression*
+Expression::make_receive(Expression* channel, source_location location)
+{
+ return new Receive_expression(channel, location);
+}
+
+// An expression which evaluates to a pointer to the type descriptor
+// of a type.
+
+class Type_descriptor_expression : public Expression
+{
+ public:
+ Type_descriptor_expression(Type* type, source_location location)
+ : Expression(EXPRESSION_TYPE_DESCRIPTOR, location),
+ type_(type)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_type_descriptor_ptr_type(); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->type_->type_descriptor_pointer(context->gogo()); }
+
+ private:
+ // The type for which this is the descriptor.
+ Type* type_;
+};
+
+// Make a type descriptor expression.
+
+Expression*
+Expression::make_type_descriptor(Type* type, source_location location)
+{
+ return new Type_descriptor_expression(type, location);
+}
+
+// An expression which evaluates to some characteristic of a type.
+// This is only used to initialize fields of a type descriptor. Using
+// a new expression class is slightly inefficient but gives us a good
+// separation between the frontend and the middle-end with regard to
+// how types are laid out.
+
+class Type_info_expression : public Expression
+{
+ public:
+ Type_info_expression(Type* type, Type_info type_info)
+ : Expression(EXPRESSION_TYPE_INFO, BUILTINS_LOCATION),
+ type_(type), type_info_(type_info)
+ { }
+
+ protected:
+ Type*
+ do_type();
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type for which we are getting information.
+ Type* type_;
+ // What information we want.
+ Type_info type_info_;
+};
+
+// The type is chosen to match what the type descriptor struct
+// expects.
+
+Type*
+Type_info_expression::do_type()
+{
+ switch (this->type_info_)
+ {
+ case TYPE_INFO_SIZE:
+ return Type::lookup_integer_type("uintptr");
+ case TYPE_INFO_ALIGNMENT:
+ case TYPE_INFO_FIELD_ALIGNMENT:
+ return Type::lookup_integer_type("uint8");
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return type information in GENERIC.
+
+tree
+Type_info_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ gcc_assert(val_type_tree != error_mark_node);
+
+ if (this->type_info_ == TYPE_INFO_SIZE)
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ TYPE_SIZE_UNIT(type_tree));
+ else
+ {
+ unsigned int val;
+ if (this->type_info_ == TYPE_INFO_ALIGNMENT)
+ val = go_type_alignment(type_tree);
+ else
+ val = go_field_alignment(type_tree);
+ return build_int_cstu(val_type_tree, val);
+ }
+}
+
+// Make a type info expression.
+
+Expression*
+Expression::make_type_info(Type* type, Type_info type_info)
+{
+ return new Type_info_expression(type, type_info);
+}
+
+// An expression which evaluates to the offset of a field within a
+// struct. This, like Type_info_expression, q.v., is only used to
+// initialize fields of a type descriptor.
+
+class Struct_field_offset_expression : public Expression
+{
+ public:
+ Struct_field_offset_expression(Struct_type* type, const Struct_field* field)
+ : Expression(EXPRESSION_STRUCT_FIELD_OFFSET, BUILTINS_LOCATION),
+ type_(type), field_(field)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::lookup_integer_type("uintptr"); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return this; }
+
+ tree
+ do_get_tree(Translate_context* context);
+
+ private:
+ // The type of the struct.
+ Struct_type* type_;
+ // The field.
+ const Struct_field* field_;
+};
+
+// Return a struct field offset in GENERIC.
+
+tree
+Struct_field_offset_expression::do_get_tree(Translate_context* context)
+{
+ tree type_tree = this->type_->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree val_type_tree = this->type()->get_tree(context->gogo());
+ gcc_assert(val_type_tree != error_mark_node);
+
+ const Struct_field_list* fields = this->type_->fields();
+ tree struct_field_tree = TYPE_FIELDS(type_tree);
+ Struct_field_list::const_iterator p;
+ for (p = fields->begin();
+ p != fields->end();
+ ++p, struct_field_tree = DECL_CHAIN(struct_field_tree))
+ {
+ gcc_assert(struct_field_tree != NULL_TREE);
+ if (&*p == this->field_)
+ break;
+ }
+ gcc_assert(&*p == this->field_);
+
+ return fold_convert_loc(BUILTINS_LOCATION, val_type_tree,
+ byte_position(struct_field_tree));
+}
+
+// Make an expression for a struct field offset.
+
+Expression*
+Expression::make_struct_field_offset(Struct_type* type,
+ const Struct_field* field)
+{
+ return new Struct_field_offset_expression(type, field);
+}
+
+// An expression which evaluates to the address of an unnamed label.
+
+class Label_addr_expression : public Expression
+{
+ public:
+ Label_addr_expression(Label* label, source_location location)
+ : Expression(EXPRESSION_LABEL_ADDR, location),
+ label_(label)
+ { }
+
+ protected:
+ Type*
+ do_type()
+ { return Type::make_pointer_type(Type::make_void_type()); }
+
+ void
+ do_determine_type(const Type_context*)
+ { }
+
+ Expression*
+ do_copy()
+ { return new Label_addr_expression(this->label_, this->location()); }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_addr(this->location()); }
+
+ private:
+ // The label whose address we are taking.
+ Label* label_;
+};
+
+// Make an expression for the address of an unnamed label.
+
+Expression*
+Expression::make_label_addr(Label* label, source_location location)
+{
+ return new Label_addr_expression(label, location);
+}
+
+// Import an expression. This comes at the end in order to see the
+// various class definitions.
+
+Expression*
+Expression::import_expression(Import* imp)
+{
+ int c = imp->peek_char();
+ if (imp->match_c_string("- ")
+ || imp->match_c_string("! ")
+ || imp->match_c_string("^ "))
+ return Unary_expression::do_import(imp);
+ else if (c == '(')
+ return Binary_expression::do_import(imp);
+ else if (imp->match_c_string("true")
+ || imp->match_c_string("false"))
+ return Boolean_expression::do_import(imp);
+ else if (c == '"')
+ return String_expression::do_import(imp);
+ else if (c == '-' || (c >= '0' && c <= '9'))
+ {
+ // This handles integers, floats and complex constants.
+ return Integer_expression::do_import(imp);
+ }
+ else if (imp->match_c_string("nil"))
+ return Nil_expression::do_import(imp);
+ else if (imp->match_c_string("convert"))
+ return Type_conversion_expression::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected expression");
+ return Expression::make_error(imp->location());
+ }
+}
+
+// Class Expression_list.
+
+// Traverse the list.
+
+int
+Expression_list::traverse(Traverse* traverse)
+{
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p != NULL)
+ {
+ if (Expression::traverse(&*p, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Expression_list*
+Expression_list::copy()
+{
+ Expression_list* ret = new Expression_list();
+ for (Expression_list::iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (*p == NULL)
+ ret->push_back(NULL);
+ else
+ ret->push_back((*p)->copy());
+ }
+ return ret;
+}
+
+// Return whether an expression list has an error expression.
+
+bool
+Expression_list::contains_error() const
+{
+ for (Expression_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ if (*p != NULL && (*p)->is_error_expression())
+ return true;
+ return false;
+}
--- /dev/null
+// go.cc -- Go frontend main file for gcc.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+
+#include "lex.h"
+#include "parse.h"
+#include "gogo.h"
+
+// The unique prefix to use for exported symbols. This is set during
+// option processing.
+
+static std::string unique_prefix;
+
+// The data structures we build to represent the file.
+static Gogo* gogo;
+
+// Create the main IR data structure.
+
+GO_EXTERN_C
+void
+go_create_gogo(int int_type_size, int float_type_size, int pointer_size)
+{
+ gcc_assert(::gogo == NULL);
+ ::gogo = new Gogo(int_type_size, float_type_size, pointer_size);
+ if (!unique_prefix.empty())
+ ::gogo->set_unique_prefix(unique_prefix);
+}
+
+// Set the unique prefix we use for exported symbols.
+
+GO_EXTERN_C
+void
+go_set_prefix(const char* arg)
+{
+ unique_prefix = arg;
+ for (size_t i = 0; i < unique_prefix.length(); ++i)
+ {
+ char c = unique_prefix[i];
+ if ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '_')
+ ;
+ else
+ unique_prefix[i] = '_';
+ }
+}
+
+// Parse the input files.
+
+GO_EXTERN_C
+void
+go_parse_input_files(const char** filenames, unsigned int filename_count,
+ bool only_check_syntax, bool require_return_statement)
+{
+ gcc_assert(filename_count > 0);
+ for (unsigned int i = 0; i < filename_count; ++i)
+ {
+ if (i > 0)
+ ::gogo->clear_file_scope();
+
+ const char* filename = filenames[i];
+ FILE* file;
+ if (strcmp(filename, "-") == 0)
+ file = stdin;
+ else
+ {
+ file = fopen(filename, "r");
+ if (file == NULL)
+ fatal_error("cannot open %s: %m", filename);
+ }
+
+ Lex lexer(filename, file);
+
+ Parse parse(&lexer, ::gogo);
+ parse.program();
+
+ if (strcmp(filename, "-") != 0)
+ fclose(file);
+ }
+
+ ::gogo->clear_file_scope();
+
+ // If the global predeclared names are referenced but not defined,
+ // define them now.
+ ::gogo->define_global_names();
+
+ // Finalize method lists and build stub methods for named types.
+ ::gogo->finalize_methods();
+
+ // Now that we have seen all the names, lower the parse tree into a
+ // form which is easier to use.
+ ::gogo->lower_parse_tree();
+
+ // Now that we have seen all the names, verify that types are
+ // correct.
+ ::gogo->verify_types();
+
+ // Work out types of unspecified constants and variables.
+ ::gogo->determine_types();
+
+ // Check types and issue errors as appropriate.
+ ::gogo->check_types();
+
+ if (only_check_syntax)
+ return;
+
+ // Check that functions have return statements.
+ if (require_return_statement)
+ ::gogo->check_return_statements();
+
+ // Export global identifiers as appropriate.
+ ::gogo->do_exports();
+
+ // Build required interface method tables.
+ ::gogo->build_interface_method_tables();
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ ::gogo->remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ ::gogo->order_evaluations();
+
+ // Build thunks for functions which call recover.
+ ::gogo->build_recover_thunks();
+
+ // Convert complicated go and defer statements into simpler ones.
+ ::gogo->simplify_thunk_statements();
+}
+
+// Write out globals.
+
+GO_EXTERN_C
+void
+go_write_globals()
+{
+ return ::gogo->write_globals();
+}
+
+// Return the global IR structure. This is used by some of the
+// langhooks to pass to other code.
+
+Gogo*
+go_get_gogo()
+{
+ return ::gogo;
+}
--- /dev/null
+// go.cc -- Go frontend main file for gcc.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+
+#include "lex.h"
+#include "parse.h"
+#include "backend.h"
+#include "gogo.h"
+
+// The unique prefix to use for exported symbols. This is set during
+// option processing.
+
+static std::string unique_prefix;
+
+// The data structures we build to represent the file.
+static Gogo* gogo;
+
+// Create the main IR data structure.
+
+GO_EXTERN_C
+void
+go_create_gogo(int int_type_size, int pointer_size)
+{
+ go_assert(::gogo == NULL);
+ ::gogo = new Gogo(go_get_backend(), int_type_size, pointer_size);
+ if (!unique_prefix.empty())
+ ::gogo->set_unique_prefix(unique_prefix);
+}
+
+// Set the unique prefix we use for exported symbols.
+
+GO_EXTERN_C
+void
+go_set_prefix(const char* arg)
+{
+ unique_prefix = arg;
+ for (size_t i = 0; i < unique_prefix.length(); ++i)
+ {
+ char c = unique_prefix[i];
+ if ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '_')
+ ;
+ else
+ unique_prefix[i] = '_';
+ }
+}
+
+// Parse the input files.
+
+GO_EXTERN_C
+void
+go_parse_input_files(const char** filenames, unsigned int filename_count,
+ bool only_check_syntax, bool require_return_statement)
+{
+ go_assert(filename_count > 0);
+ for (unsigned int i = 0; i < filename_count; ++i)
+ {
+ if (i > 0)
+ ::gogo->clear_file_scope();
+
+ const char* filename = filenames[i];
+ FILE* file;
+ if (strcmp(filename, "-") == 0)
+ file = stdin;
+ else
+ {
+ file = fopen(filename, "r");
+ if (file == NULL)
+ fatal_error("cannot open %s: %m", filename);
+ }
+
+ Lex lexer(filename, file);
+
+ Parse parse(&lexer, ::gogo);
+ parse.program();
+
+ if (strcmp(filename, "-") != 0)
+ fclose(file);
+ }
+
+ ::gogo->clear_file_scope();
+
+ // If the global predeclared names are referenced but not defined,
+ // define them now.
+ ::gogo->define_global_names();
+
+ // Finalize method lists and build stub methods for named types.
+ ::gogo->finalize_methods();
+
+ // Now that we have seen all the names, lower the parse tree into a
+ // form which is easier to use.
+ ::gogo->lower_parse_tree();
+
+ // Now that we have seen all the names, verify that types are
+ // correct.
+ ::gogo->verify_types();
+
+ // Work out types of unspecified constants and variables.
+ ::gogo->determine_types();
+
+ // Check types and issue errors as appropriate.
+ ::gogo->check_types();
+
+ if (only_check_syntax)
+ return;
+
+ // Check that functions have return statements.
+ if (require_return_statement)
+ ::gogo->check_return_statements();
+
+ // Export global identifiers as appropriate.
+ ::gogo->do_exports();
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ ::gogo->remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ ::gogo->order_evaluations();
+
+ // Build thunks for functions which call recover.
+ ::gogo->build_recover_thunks();
+
+ // Convert complicated go and defer statements into simpler ones.
+ ::gogo->simplify_thunk_statements();
+}
+
+// Write out globals.
+
+GO_EXTERN_C
+void
+go_write_globals()
+{
+ return ::gogo->write_globals();
+}
+
+// Return the global IR structure. This is used by some of the
+// langhooks to pass to other code.
+
+Gogo*
+go_get_gogo()
+{
+ return ::gogo;
+}
--- /dev/null
+// go.cc -- Go frontend main file for gcc.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+
+#include "lex.h"
+#include "parse.h"
+#include "gogo.h"
+
+// The unique prefix to use for exported symbols. This is set during
+// option processing.
+
+static std::string unique_prefix;
+
+// The data structures we build to represent the file.
+static Gogo* gogo;
+
+// Create the main IR data structure.
+
+GO_EXTERN_C
+void
+go_create_gogo(int int_type_size, int pointer_size)
+{
+ gcc_assert(::gogo == NULL);
+ ::gogo = new Gogo(int_type_size, pointer_size);
+ if (!unique_prefix.empty())
+ ::gogo->set_unique_prefix(unique_prefix);
+}
+
+// Set the unique prefix we use for exported symbols.
+
+GO_EXTERN_C
+void
+go_set_prefix(const char* arg)
+{
+ unique_prefix = arg;
+ for (size_t i = 0; i < unique_prefix.length(); ++i)
+ {
+ char c = unique_prefix[i];
+ if ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '_')
+ ;
+ else
+ unique_prefix[i] = '_';
+ }
+}
+
+// Parse the input files.
+
+GO_EXTERN_C
+void
+go_parse_input_files(const char** filenames, unsigned int filename_count,
+ bool only_check_syntax, bool require_return_statement)
+{
+ gcc_assert(filename_count > 0);
+ for (unsigned int i = 0; i < filename_count; ++i)
+ {
+ if (i > 0)
+ ::gogo->clear_file_scope();
+
+ const char* filename = filenames[i];
+ FILE* file;
+ if (strcmp(filename, "-") == 0)
+ file = stdin;
+ else
+ {
+ file = fopen(filename, "r");
+ if (file == NULL)
+ fatal_error("cannot open %s: %m", filename);
+ }
+
+ Lex lexer(filename, file);
+
+ Parse parse(&lexer, ::gogo);
+ parse.program();
+
+ if (strcmp(filename, "-") != 0)
+ fclose(file);
+ }
+
+ ::gogo->clear_file_scope();
+
+ // If the global predeclared names are referenced but not defined,
+ // define them now.
+ ::gogo->define_global_names();
+
+ // Finalize method lists and build stub methods for named types.
+ ::gogo->finalize_methods();
+
+ // Now that we have seen all the names, lower the parse tree into a
+ // form which is easier to use.
+ ::gogo->lower_parse_tree();
+
+ // Now that we have seen all the names, verify that types are
+ // correct.
+ ::gogo->verify_types();
+
+ // Work out types of unspecified constants and variables.
+ ::gogo->determine_types();
+
+ // Check types and issue errors as appropriate.
+ ::gogo->check_types();
+
+ if (only_check_syntax)
+ return;
+
+ // Check that functions have return statements.
+ if (require_return_statement)
+ ::gogo->check_return_statements();
+
+ // Export global identifiers as appropriate.
+ ::gogo->do_exports();
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ ::gogo->remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ ::gogo->order_evaluations();
+
+ // Build thunks for functions which call recover.
+ ::gogo->build_recover_thunks();
+
+ // Convert complicated go and defer statements into simpler ones.
+ ::gogo->simplify_thunk_statements();
+}
+
+// Write out globals.
+
+GO_EXTERN_C
+void
+go_write_globals()
+{
+ return ::gogo->write_globals();
+}
+
+// Return the global IR structure. This is used by some of the
+// langhooks to pass to other code.
+
+Gogo*
+go_get_gogo()
+{
+ return ::gogo;
+}
--- /dev/null
+// gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "tm.h"
+#include "toplev.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "cgraph.h"
+#include "langhooks.h"
+#include "convert.h"
+#include "output.h"
+#include "diagnostic.h"
+#include "rtl.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "statements.h"
+#include "gogo.h"
+
+// Whether we have seen any errors.
+
+bool
+saw_errors()
+{
+ return errorcount != 0 || sorrycount != 0;
+}
+
+// A helper function.
+
+static inline tree
+get_identifier_from_string(const std::string& str)
+{
+ return get_identifier_with_length(str.data(), str.length());
+}
+
+// Builtin functions.
+
+static std::map<std::string, tree> builtin_functions;
+
+// Define a builtin function. BCODE is the builtin function code
+// defined by builtins.def. NAME is the name of the builtin function.
+// LIBNAME is the name of the corresponding library function, and is
+// NULL if there isn't one. FNTYPE is the type of the function.
+// CONST_P is true if the function has the const attribute.
+
+static void
+define_builtin(built_in_function bcode, const char* name, const char* libname,
+ tree fntype, bool const_p)
+{
+ tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
+ libname, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ built_in_decls[bcode] = decl;
+ implicit_built_in_decls[bcode] = decl;
+ builtin_functions[name] = decl;
+ if (libname != NULL)
+ {
+ decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
+ NULL, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ builtin_functions[libname] = decl;
+ }
+}
+
+// Create trees for implicit builtin functions.
+
+void
+Gogo::define_builtin_function_trees()
+{
+ /* We need to define the fetch_and_add functions, since we use them
+ for ++ and --. */
+ tree t = go_type_for_size(BITS_PER_UNIT, 1);
+ tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 2, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin (BUILT_IN_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 4, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 8, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ // We use __builtin_expect for magic import functions.
+ define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
+ build_function_type_list(long_integer_type_node,
+ long_integer_type_node,
+ long_integer_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_memmove for the predeclared copy function.
+ define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
+ build_function_type_list(ptr_type_node,
+ ptr_type_node,
+ const_ptr_type_node,
+ size_type_node,
+ NULL_TREE),
+ false);
+
+ // We provide sqrt for the math library.
+ define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
+ build_function_type_list(double_type_node,
+ double_type_node,
+ NULL_TREE),
+ true);
+ define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
+ build_function_type_list(long_double_type_node,
+ long_double_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_return_address in the thunk we build for
+ // functions which call recover.
+ define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
+ build_function_type_list(ptr_type_node,
+ unsigned_type_node,
+ NULL_TREE),
+ false);
+
+ // The compiler uses __builtin_trap for some exception handling
+ // cases.
+ define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
+ build_function_type(void_type_node, void_list_node),
+ false);
+}
+
+// Get the name to use for the import control function. If there is a
+// global function or variable, then we know that that name must be
+// unique in the link, and we use it as the basis for our name.
+
+const std::string&
+Gogo::get_init_fn_name()
+{
+ if (this->init_fn_name_.empty())
+ {
+ gcc_assert(this->package_ != NULL);
+ if (this->package_name() == "main")
+ {
+ // Use a name which the runtime knows.
+ this->init_fn_name_ = "__go_init_main";
+ }
+ else
+ {
+ std::string s = this->unique_prefix();
+ s.append(1, '.');
+ s.append(this->package_name());
+ s.append("..import");
+ this->init_fn_name_ = s;
+ }
+ }
+
+ return this->init_fn_name_;
+}
+
+// Add statements to INIT_STMT_LIST which run the initialization
+// functions for imported packages. This is only used for the "main"
+// package.
+
+void
+Gogo::init_imports(tree* init_stmt_list)
+{
+ gcc_assert(this->package_name() == "main");
+
+ if (this->imported_init_fns_.empty())
+ return;
+
+ tree fntype = build_function_type(void_type_node, void_list_node);
+
+ // We must call them in increasing priority order.
+ std::vector<Import_init> v;
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ v.push_back(*p);
+ std::sort(v.begin(), v.end());
+
+ for (std::vector<Import_init>::const_iterator p = v.begin();
+ p != v.end();
+ ++p)
+ {
+ std::string user_name = p->package_name() + ".init";
+ tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(user_name),
+ fntype);
+ const std::string& init_name(p->init_name());
+ SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
+ }
+}
+
+// Register global variables with the garbage collector. We need to
+// register all variables which can hold a pointer value. They become
+// roots during the mark phase. We build a struct that is easy to
+// hook into a list of roots.
+
+// struct __go_gc_root_list
+// {
+// struct __go_gc_root_list* __next;
+// struct __go_gc_root
+// {
+// void* __decl;
+// size_t __size;
+// } __roots[];
+// };
+
+// The last entry in the roots array has a NULL decl field.
+
+void
+Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
+ tree* init_stmt_list)
+{
+ if (var_gc.empty())
+ return;
+
+ size_t count = var_gc.size();
+
+ tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
+ "__next",
+ ptr_type_node,
+ "__size",
+ sizetype);
+
+ tree index_type = build_index_type(size_int(count));
+ tree array_type = build_array_type(root_type, index_type);
+
+ tree root_list_type = make_node(RECORD_TYPE);
+ root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
+ root_list_type, 2,
+ "__next",
+ build_pointer_type(root_list_type),
+ "__roots",
+ array_type);
+
+ // Build an initialier for the __roots array.
+
+ VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ size_t i = 0;
+ for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
+ p != var_gc.end();
+ ++p, ++i)
+ {
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ tree decl = (*p)->get_tree(this, NULL);
+ gcc_assert(TREE_CODE(decl) == VAR_DECL);
+ elt->value = build_fold_addr_expr(decl);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = DECL_SIZE_UNIT(decl);
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+ }
+
+ // The list ends with a NULL entry.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = size_zero_node;
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+
+ // Build a constructor for the struct.
+
+ VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = TYPE_FIELDS(root_list_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = build_constructor(array_type, roots_init);
+
+ // Build a decl to register.
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
+ create_tmp_var_name("gc"), root_list_type);
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
+ rest_of_decl_compilation(decl, 1, 0);
+
+ static tree register_gc_fndecl;
+ tree call = Gogo::call_builtin(®ister_gc_fndecl, BUILTINS_LOCATION,
+ "__go_register_gc_roots",
+ 1,
+ void_type_node,
+ build_pointer_type(root_list_type),
+ build_fold_addr_expr(decl));
+ append_to_statement_list(call, init_stmt_list);
+}
+
+// Build the decl for the initialization function.
+
+tree
+Gogo::initialization_function_decl()
+{
+ // The tedious details of building your own function. There doesn't
+ // seem to be a helper function for this.
+ std::string name = this->package_name() + ".init";
+ tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(name),
+ build_function_type(void_type_node,
+ void_list_node));
+ const std::string& asm_name(this->get_init_fn_name());
+ SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
+
+ tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
+ void_type_node);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = fndecl;
+ DECL_RESULT(fndecl) = resdecl;
+
+ TREE_STATIC(fndecl) = 1;
+ TREE_USED(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+
+ DECL_INITIAL(fndecl) = make_node(BLOCK);
+ TREE_USED(DECL_INITIAL(fndecl)) = 1;
+
+ return fndecl;
+}
+
+// Create the magic initialization function. INIT_STMT_LIST is the
+// code that it needs to run.
+
+void
+Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
+{
+ // Make sure that we thought we needed an initialization function,
+ // as otherwise we will not have reported it in the export data.
+ gcc_assert(this->package_name() == "main" || this->need_init_fn_);
+
+ if (fndecl == NULL_TREE)
+ fndecl = this->initialization_function_decl();
+
+ DECL_SAVED_TREE(fndecl) = init_stmt_list;
+
+ current_function_decl = fndecl;
+ if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
+ push_struct_function(fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(fndecl));
+ cfun->function_end_locus = BUILTINS_LOCATION;
+
+ gimplify_function_tree(fndecl);
+
+ cgraph_add_new_function(fndecl, false);
+ cgraph_mark_needed_node(cgraph_node(fndecl));
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+}
+
+// Search for references to VAR in any statements or called functions.
+
+class Find_var : public Traverse
+{
+ public:
+ // A hash table we use to avoid looping. The index is the name of a
+ // named object. We only look through objects defined in this
+ // package.
+ typedef Unordered_set(std::string) Seen_objects;
+
+ Find_var(Named_object* var, Seen_objects* seen_objects)
+ : Traverse(traverse_expressions),
+ var_(var), seen_objects_(seen_objects), found_(false)
+ { }
+
+ // Whether the variable was found.
+ bool
+ found() const
+ { return this->found_; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // The variable we are looking for.
+ Named_object* var_;
+ // Names of objects we have already seen.
+ Seen_objects* seen_objects_;
+ // True if the variable was found.
+ bool found_;
+};
+
+// See if EXPR refers to VAR, looking through function calls and
+// variable initializations.
+
+int
+Find_var::expression(Expression** pexpr)
+{
+ Expression* e = *pexpr;
+
+ Var_expression* ve = e->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* v = ve->named_object();
+ if (v == this->var_)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+
+ if (v->is_variable() && v->package() == NULL)
+ {
+ Expression* init = v->var_value()->init();
+ if (init != NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(v->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ }
+
+ // We traverse the code of any function we see. Note that this
+ // means that we will traverse the code of a function whose address
+ // is taken even if it is not called.
+ Func_expression* fe = e->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* f = fe->named_object();
+ if (f->is_function() && f->package() == NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(f->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return true if EXPR refers to VAR.
+
+static bool
+expression_requires(Expression* expr, Block* preinit, Named_object* var)
+{
+ Find_var::Seen_objects seen_objects;
+ Find_var find_var(var, &seen_objects);
+ if (expr != NULL)
+ Expression::traverse(&expr, &find_var);
+ if (preinit != NULL)
+ preinit->traverse(&find_var);
+
+ return find_var.found();
+}
+
+// Sort variable initializations. If the initialization expression
+// for variable A refers directly or indirectly to the initialization
+// expression for variable B, then we must initialize B before A.
+
+class Var_init
+{
+ public:
+ Var_init()
+ : var_(NULL), init_(NULL_TREE), waiting_(0)
+ { }
+
+ Var_init(Named_object* var, tree init)
+ : var_(var), init_(init), waiting_(0)
+ { }
+
+ // Return the variable.
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ // Return the initialization expression.
+ tree
+ init() const
+ { return this->init_; }
+
+ // Return the number of variables waiting for this one to be
+ // initialized.
+ size_t
+ waiting() const
+ { return this->waiting_; }
+
+ // Increment the number waiting.
+ void
+ increment_waiting()
+ { ++this->waiting_; }
+
+ private:
+ // The variable being initialized.
+ Named_object* var_;
+ // The initialization expression to run.
+ tree init_;
+ // The number of variables which are waiting for this one.
+ size_t waiting_;
+};
+
+typedef std::list<Var_init> Var_inits;
+
+// Sort the variable initializations. The rule we follow is that we
+// emit them in the order they appear in the array, except that if the
+// initialization expression for a variable V1 depends upon another
+// variable V2 then we initialize V1 after V2.
+
+static void
+sort_var_inits(Var_inits* var_inits)
+{
+ Var_inits ready;
+ while (!var_inits->empty())
+ {
+ Var_inits::iterator p1 = var_inits->begin();
+ Named_object* var = p1->var();
+ Expression* init = var->var_value()->init();
+ Block* preinit = var->var_value()->preinit();
+
+ // Start walking through the list to see which variables VAR
+ // needs to wait for. We can skip P1->WAITING variables--that
+ // is the number we've already checked.
+ Var_inits::iterator p2 = p1;
+ ++p2;
+ for (size_t i = p1->waiting(); i > 0; --i)
+ ++p2;
+
+ for (; p2 != var_inits->end(); ++p2)
+ {
+ if (expression_requires(init, preinit, p2->var()))
+ {
+ // Check for cycles.
+ if (expression_requires(p2->var()->var_value()->init(),
+ p2->var()->var_value()->preinit(),
+ var))
+ {
+ error_at(var->location(),
+ ("initialization expressions for %qs and "
+ "%qs depend upon each other"),
+ var->message_name().c_str(),
+ p2->var()->message_name().c_str());
+ inform(p2->var()->location(), "%qs defined here",
+ p2->var()->message_name().c_str());
+ p2 = var_inits->end();
+ }
+ else
+ {
+ // We can't emit P1 until P2 is emitted. Move P1.
+ // Note that the WAITING loop always executes at
+ // least once, which is what we want.
+ p2->increment_waiting();
+ Var_inits::iterator p3 = p2;
+ for (size_t i = p2->waiting(); i > 0; --i)
+ ++p3;
+ var_inits->splice(p3, *var_inits, p1);
+ }
+ break;
+ }
+ }
+
+ if (p2 == var_inits->end())
+ {
+ // VAR does not depends upon any other initialization expressions.
+
+ // Check for a loop of VAR on itself. We only do this if
+ // INIT is not NULL; when INIT is NULL, it means that
+ // PREINIT sets VAR, which we will interpret as a loop.
+ if (init != NULL && expression_requires(init, preinit, var))
+ error_at(var->location(),
+ "initialization expression for %qs depends upon itself",
+ var->message_name().c_str());
+ ready.splice(ready.end(), *var_inits, p1);
+ }
+ }
+
+ // Now READY is the list in the desired initialization order.
+ var_inits->swap(ready);
+}
+
+// Write out the global definitions.
+
+void
+Gogo::write_globals()
+{
+ Bindings* bindings = this->current_bindings();
+ size_t count = bindings->size_definitions();
+
+ tree* vec = new tree[count];
+
+ tree init_fndecl = NULL_TREE;
+ tree init_stmt_list = NULL_TREE;
+
+ if (this->package_name() == "main")
+ this->init_imports(&init_stmt_list);
+
+ // A list of variable initializations.
+ Var_inits var_inits;
+
+ // A list of variables which need to be registered with the garbage
+ // collector.
+ std::vector<Named_object*> var_gc;
+ var_gc.reserve(count);
+
+ tree var_init_stmt_list = NULL_TREE;
+ size_t i = 0;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p, ++i)
+ {
+ Named_object* no = *p;
+
+ gcc_assert(!no->is_type_declaration() && !no->is_function_declaration());
+ // There is nothing to do for a package.
+ if (no->is_package())
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing to do for an object which was imported from
+ // a different package into the global scope.
+ if (no->package() != NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing useful we can output for constants which
+ // have ideal or non-integeral type.
+ if (no->is_const())
+ {
+ Type* type = no->const_value()->type();
+ if (type == NULL)
+ type = no->const_value()->expr()->type();
+ if (type->is_abstract() || type->integer_type() == NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+ }
+
+ vec[i] = no->get_tree(this, NULL);
+
+ if (vec[i] == error_mark_node)
+ {
+ gcc_assert(saw_errors());
+ --i;
+ --count;
+ continue;
+ }
+
+ // If a variable is initialized to a non-constant value, do the
+ // initialization in an initialization function.
+ if (TREE_CODE(vec[i]) == VAR_DECL)
+ {
+ gcc_assert(no->is_variable());
+
+ // Check for a sink variable, which may be used to run
+ // an initializer purely for its side effects.
+ bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
+
+ tree var_init_tree = NULL_TREE;
+ if (!no->var_value()->has_pre_init())
+ {
+ tree init = no->var_value()->get_init_tree(this, NULL);
+ if (init == error_mark_node)
+ gcc_assert(saw_errors());
+ else if (init == NULL_TREE)
+ ;
+ else if (TREE_CONSTANT(init))
+ DECL_INITIAL(vec[i]) = init;
+ else if (is_sink)
+ var_init_tree = init;
+ else
+ var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
+ void_type_node, vec[i], init);
+ }
+ else
+ {
+ // We are going to create temporary variables which
+ // means that we need an fndecl.
+ if (init_fndecl == NULL_TREE)
+ init_fndecl = this->initialization_function_decl();
+ current_function_decl = init_fndecl;
+ if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
+ push_struct_function(init_fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
+
+ tree var_decl = is_sink ? NULL_TREE : vec[i];
+ var_init_tree = no->var_value()->get_init_block(this, NULL,
+ var_decl);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+
+ if (var_init_tree != NULL_TREE)
+ {
+ if (no->var_value()->init() == NULL
+ && !no->var_value()->has_pre_init())
+ append_to_statement_list(var_init_tree, &var_init_stmt_list);
+ else
+ var_inits.push_back(Var_init(no, var_init_tree));
+ }
+
+ if (!is_sink && no->var_value()->type()->has_pointer())
+ var_gc.push_back(no);
+ }
+ }
+
+ // Register global variables with the garbage collector.
+ this->register_gc_vars(var_gc, &init_stmt_list);
+
+ // Simple variable initializations, after all variables are
+ // registered.
+ append_to_statement_list(var_init_stmt_list, &init_stmt_list);
+
+ // Complex variable initializations, first sorting them into a
+ // workable order.
+ if (!var_inits.empty())
+ {
+ sort_var_inits(&var_inits);
+ for (Var_inits::const_iterator p = var_inits.begin();
+ p != var_inits.end();
+ ++p)
+ append_to_statement_list(p->init(), &init_stmt_list);
+ }
+
+ // After all the variables are initialized, call the "init"
+ // functions if there are any.
+ for (std::vector<Named_object*>::const_iterator p =
+ this->init_functions_.begin();
+ p != this->init_functions_.end();
+ ++p)
+ {
+ tree decl = (*p)->get_tree(this, NULL);
+ tree call = build_call_expr(decl, 0);
+ append_to_statement_list(call, &init_stmt_list);
+ }
+
+ // Set up a magic function to do all the initialization actions.
+ // This will be called if this package is imported.
+ if (init_stmt_list != NULL_TREE
+ || this->need_init_fn_
+ || this->package_name() == "main")
+ this->write_initialization_function(init_fndecl, init_stmt_list);
+
+ // Pass everything back to the middle-end.
+
+ if (this->imported_unsafe_)
+ {
+ // Importing the "unsafe" package automatically disables TBAA.
+ flag_strict_aliasing = false;
+
+ // This is a real hack. init_varasm_once has already grabbed an
+ // alias set, which we don't want when we aren't going strict
+ // aliasing. We reinitialize to make it do it again. FIXME.
+ init_varasm_once();
+ }
+
+ wrapup_global_declarations(vec, count);
+
+ cgraph_finalize_compilation_unit();
+
+ check_global_declarations(vec, count);
+ emit_debug_global_declarations(vec, count);
+
+ delete[] vec;
+}
+
+// Get a tree for the identifier for a named object.
+
+tree
+Named_object::get_id(Gogo* gogo)
+{
+ std::string decl_name;
+ if (this->is_function_declaration()
+ && !this->func_declaration_value()->asm_name().empty())
+ decl_name = this->func_declaration_value()->asm_name();
+ else if ((this->is_variable() && !this->var_value()->is_global())
+ || (this->is_type()
+ && this->type_value()->location() == BUILTINS_LOCATION))
+ {
+ // We don't need the package name for local variables or builtin
+ // types.
+ decl_name = Gogo::unpack_hidden_name(this->name_);
+ }
+ else if (this->is_function()
+ && !this->func_value()->is_method()
+ && this->package_ == NULL
+ && Gogo::unpack_hidden_name(this->name_) == "init")
+ {
+ // A single package can have multiple "init" functions, which
+ // means that we need to give them different names.
+ static int init_index;
+ char buf[20];
+ snprintf(buf, sizeof buf, "%d", init_index);
+ ++init_index;
+ decl_name = gogo->package_name() + ".init." + buf;
+ }
+ else
+ {
+ std::string package_name;
+ if (this->package_ == NULL)
+ package_name = gogo->package_name();
+ else
+ package_name = this->package_->name();
+
+ decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
+
+ Function_type* fntype;
+ if (this->is_function())
+ fntype = this->func_value()->type();
+ else if (this->is_function_declaration())
+ fntype = this->func_declaration_value()->type();
+ else
+ fntype = NULL;
+ if (fntype != NULL && fntype->is_method())
+ {
+ decl_name.push_back('.');
+ decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
+ }
+ }
+ if (this->is_type())
+ {
+ const Named_object* in_function = this->type_value()->in_function();
+ if (in_function != NULL)
+ decl_name += '$' + in_function->name();
+ }
+ return get_identifier_from_string(decl_name);
+}
+
+// Get a tree for a named object.
+
+tree
+Named_object::get_tree(Gogo* gogo, Named_object* function)
+{
+ if (this->tree_ != NULL_TREE)
+ {
+ // If this is a variable whose address is taken, we must rebuild
+ // the INDIRECT_REF each time to avoid invalid sharing.
+ tree ret = this->tree_;
+ if (((this->classification_ == NAMED_OBJECT_VAR
+ && this->var_value()->is_in_heap())
+ || (this->classification_ == NAMED_OBJECT_RESULT_VAR
+ && this->result_var_value()->is_in_heap()))
+ && ret != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(ret) == INDIRECT_REF);
+ ret = build_fold_indirect_ref(TREE_OPERAND(ret, 0));
+ TREE_THIS_NOTRAP(ret) = 1;
+ }
+ return ret;
+ }
+
+ tree name;
+ if (this->classification_ == NAMED_OBJECT_TYPE)
+ name = NULL_TREE;
+ else
+ name = this->get_id(gogo);
+ tree decl;
+ switch (this->classification_)
+ {
+ case NAMED_OBJECT_CONST:
+ {
+ Named_constant* named_constant = this->u_.const_value;
+ Translate_context subcontext(gogo, function, NULL, NULL_TREE);
+ tree expr_tree = named_constant->expr()->get_tree(&subcontext);
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ Type* type = named_constant->type();
+ if (type != NULL && !type->is_abstract())
+ expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ {
+ decl = build_decl(named_constant->location(), CONST_DECL,
+ name, TREE_TYPE(expr_tree));
+ DECL_INITIAL(decl) = expr_tree;
+ TREE_CONSTANT(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ }
+ else
+ {
+ // A CONST_DECL is only for an enum constant, so we
+ // shouldn't use for non-integral types. Instead we
+ // just return the constant itself, rather than a
+ // decl.
+ decl = expr_tree;
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ {
+ Named_type* named_type = this->u_.type_value;
+ tree type_tree = named_type->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ decl = TYPE_NAME(type_tree);
+ gcc_assert(decl != NULL_TREE);
+
+ // We need to produce a type descriptor for every named
+ // type, and for a pointer to every named type, since
+ // other files or packages might refer to them. We need
+ // to do this even for hidden types, because they might
+ // still be returned by some function. Simply calling the
+ // type_descriptor method is enough to create the type
+ // descriptor, even though we don't do anything with it.
+ if (this->package_ == NULL)
+ {
+ named_type->type_descriptor_pointer(gogo);
+ Type* pn = Type::make_pointer_type(named_type);
+ pn->type_descriptor_pointer(gogo);
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error("reference to undefined type %qs",
+ this->message_name().c_str());
+ return error_mark_node;
+
+ case NAMED_OBJECT_VAR:
+ {
+ Variable* var = this->u_.var_value;
+ Type* type = var->type();
+ if (type->is_error_type()
+ || (type->is_undefined()
+ && (!var->is_global() || this->package() == NULL)))
+ {
+ // Force the error for an undefined type, just in case.
+ type->base();
+ decl = error_mark_node;
+ }
+ else
+ {
+ tree var_type = type->get_tree(gogo);
+ bool is_parameter = var->is_parameter();
+ if (var->is_receiver() && type->points_to() == NULL)
+ is_parameter = false;
+ if (var->is_in_heap())
+ {
+ is_parameter = false;
+ var_type = build_pointer_type(var_type);
+ }
+ decl = build_decl(var->location(),
+ is_parameter ? PARM_DECL : VAR_DECL,
+ name, var_type);
+ if (!var->is_global())
+ {
+ tree fnid = function->get_id(gogo);
+ tree fndecl = function->func_value()->get_or_make_decl(gogo,
+ function,
+ fnid);
+ DECL_CONTEXT(decl) = fndecl;
+ }
+ if (is_parameter)
+ DECL_ARG_TYPE(decl) = TREE_TYPE(decl);
+
+ if (var->is_global())
+ {
+ const Package* package = this->package();
+ if (package == NULL)
+ TREE_STATIC(decl) = 1;
+ else
+ DECL_EXTERNAL(decl) = 1;
+ if (!Gogo::is_hidden_name(this->name_))
+ {
+ TREE_PUBLIC(decl) = 1;
+ std::string asm_name = (package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix());
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(name),
+ IDENTIFIER_LENGTH(name));
+ tree asm_id = get_identifier_from_string(asm_name);
+ SET_DECL_ASSEMBLER_NAME(decl, asm_id);
+ }
+ }
+
+ // FIXME: We should only set this for variables which are
+ // actually used somewhere.
+ TREE_USED(decl) = 1;
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_RESULT_VAR:
+ {
+ Result_variable* result = this->u_.result_var_value;
+ Type* type = result->type();
+ if (type->is_error_type() || type->is_undefined())
+ {
+ // Force the error.
+ type->base();
+ decl = error_mark_node;
+ }
+ else
+ {
+ gcc_assert(result->function() == function->func_value());
+ source_location loc = function->location();
+ tree result_type = type->get_tree(gogo);
+ tree init;
+ if (!result->is_in_heap())
+ init = type->get_init_tree(gogo, false);
+ else
+ {
+ tree space = gogo->allocate_memory(type,
+ TYPE_SIZE_UNIT(result_type),
+ loc);
+ result_type = build_pointer_type(result_type);
+ tree subinit = type->get_init_tree(gogo, true);
+ if (subinit == NULL_TREE)
+ init = fold_convert_loc(loc, result_type, space);
+ else
+ {
+ space = save_expr(space);
+ space = fold_convert_loc(loc, result_type, space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, subinit);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ set, space);
+ }
+ }
+ decl = build_decl(loc, VAR_DECL, name, result_type);
+ tree fnid = function->get_id(gogo);
+ tree fndecl = function->func_value()->get_or_make_decl(gogo,
+ function,
+ fnid);
+ DECL_CONTEXT(decl) = fndecl;
+ DECL_INITIAL(decl) = init;
+ TREE_USED(decl) = 1;
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ {
+ Function* func = this->u_.func_value;
+ decl = func->get_or_make_decl(gogo, this, name);
+ if (decl != error_mark_node)
+ {
+ if (func->block() != NULL)
+ {
+ if (DECL_STRUCT_FUNCTION(decl) == NULL)
+ push_struct_function(decl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(decl));
+
+ cfun->function_end_locus = func->block()->end_location();
+
+ current_function_decl = decl;
+
+ func->build_tree(gogo, this);
+
+ gimplify_function_tree(decl);
+
+ cgraph_finalize_function(decl, true);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+ }
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+
+ if (TREE_TYPE(decl) == error_mark_node)
+ decl = error_mark_node;
+
+ tree ret = decl;
+
+ // If this is a local variable whose address is taken, then we
+ // actually store it in the heap. For uses of the variable we need
+ // to return a reference to that heap location.
+ if (((this->classification_ == NAMED_OBJECT_VAR
+ && this->var_value()->is_in_heap())
+ || (this->classification_ == NAMED_OBJECT_RESULT_VAR
+ && this->result_var_value()->is_in_heap()))
+ && ret != error_mark_node)
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(ret)));
+ ret = build_fold_indirect_ref(ret);
+ TREE_THIS_NOTRAP(ret) = 1;
+ }
+
+ this->tree_ = ret;
+
+ if (ret != error_mark_node)
+ go_preserve_from_gc(ret);
+
+ return ret;
+}
+
+// Get the initial value of a variable as a tree. This does not
+// consider whether the variable is in the heap--it returns the
+// initial value as though it were always stored in the stack.
+
+tree
+Variable::get_init_tree(Gogo* gogo, Named_object* function)
+{
+ gcc_assert(this->preinit_ == NULL);
+ if (this->init_ == NULL)
+ {
+ gcc_assert(!this->is_parameter_);
+ return this->type_->get_init_tree(gogo, this->is_global_);
+ }
+ else
+ {
+ Translate_context context(gogo, function, NULL, NULL_TREE);
+ tree rhs_tree = this->init_->get_tree(&context);
+ return Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree, this->location());
+ }
+}
+
+// Get the initial value of a variable when a block is required.
+// VAR_DECL is the decl to set; it may be NULL for a sink variable.
+
+tree
+Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
+{
+ gcc_assert(this->preinit_ != NULL);
+
+ // We want to add the variable assignment to the end of the preinit
+ // block. The preinit block may have a TRY_FINALLY_EXPR and a
+ // TRY_CATCH_EXPR; if it does, we want to add to the end of the
+ // regular statements.
+
+ Translate_context context(gogo, function, NULL, NULL_TREE);
+ tree block_tree = this->preinit_->get_tree(&context);
+ gcc_assert(TREE_CODE(block_tree) == BIND_EXPR);
+ tree statements = BIND_EXPR_BODY(block_tree);
+ while (TREE_CODE(statements) == TRY_FINALLY_EXPR
+ || TREE_CODE(statements) == TRY_CATCH_EXPR)
+ statements = TREE_OPERAND(statements, 0);
+
+ // It's possible to have pre-init statements without an initializer
+ // if the pre-init statements set the variable.
+ if (this->init_ != NULL)
+ {
+ tree rhs_tree = this->init_->get_tree(&context);
+ if (var_decl == NULL_TREE)
+ append_to_statement_list(rhs_tree, &statements);
+ else
+ {
+ tree val = Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree,
+ this->location());
+ tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
+ void_type_node, var_decl, val);
+ append_to_statement_list(set, &statements);
+ }
+ }
+
+ return block_tree;
+}
+
+// Get a tree for a function decl.
+
+tree
+Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ tree functype = this->type_->get_tree(gogo);
+ if (functype == error_mark_node)
+ this->fndecl_ = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ gcc_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+
+ this->fndecl_ = decl;
+
+ gcc_assert(no->package() == NULL);
+ if (this->enclosing_ != NULL || Gogo::is_thunk(no))
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "init"
+ && !this->type_->is_method())
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "main"
+ && gogo->package_name() == "main")
+ TREE_PUBLIC(decl) = 1;
+ // Methods have to be public even if they are hidden because
+ // they can be pulled into type descriptors when using
+ // anonymous fields.
+ else if (!Gogo::is_hidden_name(no->name())
+ || this->type_->is_method())
+ {
+ TREE_PUBLIC(decl) = 1;
+ std::string asm_name = gogo->unique_prefix();
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+
+ // Why do we have to do this in the frontend?
+ tree restype = TREE_TYPE(functype);
+ tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
+ restype);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_IGNORED_P(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = decl;
+ DECL_RESULT(decl) = resdecl;
+
+ if (this->enclosing_ != NULL)
+ DECL_STATIC_CHAIN(decl) = 1;
+
+ // If a function calls the predeclared recover function, we
+ // can't inline it, because recover behaves differently in a
+ // function passed directly to defer.
+ if (this->calls_recover_ && !this->is_recover_thunk_)
+ DECL_UNINLINABLE(decl) = 1;
+
+ // If this is a thunk created to call a function which calls
+ // the predeclared recover function, we need to disable
+ // stack splitting for the thunk.
+ if (this->is_recover_thunk_)
+ {
+ tree attr = get_identifier("__no_split_stack__");
+ DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
+ }
+
+ go_preserve_from_gc(decl);
+
+ if (this->closure_var_ != NULL)
+ {
+ push_struct_function(decl);
+
+ tree closure_decl = this->closure_var_->get_tree(gogo, no);
+
+ DECL_ARTIFICIAL(closure_decl) = 1;
+ DECL_IGNORED_P(closure_decl) = 1;
+ TREE_USED(closure_decl) = 1;
+ DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
+ TREE_READONLY(closure_decl) = 1;
+
+ DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
+ pop_cfun();
+ }
+ }
+ }
+ return this->fndecl_;
+}
+
+// Get a tree for a function declaration.
+
+tree
+Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ // Let Go code use an asm declaration to pick up a builtin
+ // function.
+ if (!this->asm_name_.empty())
+ {
+ std::map<std::string, tree>::const_iterator p =
+ builtin_functions.find(this->asm_name_);
+ if (p != builtin_functions.end())
+ {
+ this->fndecl_ = p->second;
+ return this->fndecl_;
+ }
+ }
+
+ tree functype = this->fntype_->get_tree(gogo);
+ tree decl;
+ if (functype == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ gcc_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+
+ if (this->asm_name_.empty())
+ {
+ std::string asm_name = (no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+ }
+ this->fndecl_ = decl;
+ go_preserve_from_gc(decl);
+ }
+ return this->fndecl_;
+}
+
+// We always pass the receiver to a method as a pointer. If the
+// receiver is actually declared as a non-pointer type, then we copy
+// the value into a local variable, so that it has the right type. In
+// this function we create the real PARM_DECL to use, and set
+// DEC_INITIAL of the var_decl to be the value passed in.
+
+tree
+Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
+{
+ // If the function takes the address of a receiver which is passed
+ // by value, then we will have an INDIRECT_REF here. We need to get
+ // the real variable.
+ bool is_in_heap = no->var_value()->is_in_heap();
+ tree val_type;
+ if (TREE_CODE(var_decl) != INDIRECT_REF)
+ {
+ gcc_assert(!is_in_heap);
+ val_type = TREE_TYPE(var_decl);
+ }
+ else
+ {
+ gcc_assert(is_in_heap);
+ var_decl = TREE_OPERAND(var_decl, 0);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(var_decl)));
+ val_type = TREE_TYPE(TREE_TYPE(var_decl));
+ }
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".pointer";
+ tree id = get_identifier_from_string(name);
+ tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
+
+ gcc_assert(DECL_INITIAL(var_decl) == NULL_TREE);
+ // The receiver might be passed as a null pointer.
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node, parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
+ TREE_THIS_NOTRAP(ind) = 1;
+ tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
+ tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
+ check, ind, zero_init);
+
+ if (is_in_heap)
+ {
+ tree size = TYPE_SIZE_UNIT(val_type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size,
+ no->location());
+ space = save_expr(space);
+ space = fold_convert(build_pointer_type(val_type), space);
+ tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node,
+ parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree parmref = build_fold_indirect_ref_loc(no->location(), parm_decl);
+ TREE_THIS_NOTRAP(parmref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, parmref);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ check, set, NULL_TREE),
+ space);
+ }
+
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// If we take the address of a parameter, then we need to copy it into
+// the heap. We will access it as a local variable via an
+// indirection.
+
+tree
+Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree ref)
+{
+ gcc_assert(TREE_CODE(ref) == INDIRECT_REF);
+
+ tree var_decl = TREE_OPERAND(ref, 0);
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".param";
+ tree id = get_identifier_from_string(name);
+
+ tree type = TREE_TYPE(var_decl);
+ gcc_assert(POINTER_TYPE_P(type));
+ type = TREE_TYPE(type);
+
+ tree parm_decl = build_decl(loc, PARM_DECL, id, type);
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = type;
+
+ tree size = TYPE_SIZE_UNIT(type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
+ space = save_expr(space);
+ space = fold_convert(TREE_TYPE(var_decl), space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
+ space);
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// Get a tree for function code.
+
+void
+Function::build_tree(Gogo* gogo, Named_object* named_function)
+{
+ tree fndecl = this->fndecl_;
+ gcc_assert(fndecl != NULL_TREE);
+
+ tree params = NULL_TREE;
+ tree* pp = ¶ms;
+
+ tree declare_vars = NULL_TREE;
+ for (Bindings::const_definitions_iterator p =
+ this->block_->bindings()->begin_definitions();
+ p != this->block_->bindings()->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
+ {
+ *pp = (*p)->get_tree(gogo, named_function);
+
+ // We always pass the receiver to a method as a pointer. If
+ // the receiver is declared as a non-pointer type, then we
+ // copy the value into a local variable.
+ if ((*p)->var_value()->is_receiver()
+ && (*p)->var_value()->type()->points_to() == NULL)
+ {
+ tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
+ tree var = *pp;
+ if (TREE_CODE(var) == INDIRECT_REF)
+ var = TREE_OPERAND(var, 0);
+ gcc_assert(TREE_CODE(var) == VAR_DECL);
+ DECL_CHAIN(var) = declare_vars;
+ declare_vars = var;
+ *pp = parm_decl;
+ }
+ else if ((*p)->var_value()->is_in_heap())
+ {
+ // If we take the address of a parameter, then we need
+ // to copy it into the heap.
+ tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
+ gcc_assert(TREE_CODE(*pp) == INDIRECT_REF);
+ tree var_decl = TREE_OPERAND(*pp, 0);
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ DECL_CHAIN(var_decl) = declare_vars;
+ declare_vars = var_decl;
+ *pp = parm_decl;
+ }
+
+ if (*pp != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(*pp) == PARM_DECL);
+ pp = &DECL_CHAIN(*pp);
+ }
+ }
+ else if ((*p)->is_result_variable())
+ {
+ tree var_decl = (*p)->get_tree(gogo, named_function);
+ if ((*p)->result_var_value()->is_in_heap())
+ {
+ gcc_assert(TREE_CODE(var_decl) == INDIRECT_REF);
+ var_decl = TREE_OPERAND(var_decl, 0);
+ }
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ DECL_CHAIN(var_decl) = declare_vars;
+ declare_vars = var_decl;
+ }
+ }
+ *pp = NULL_TREE;
+
+ DECL_ARGUMENTS(fndecl) = params;
+
+ if (this->block_ != NULL)
+ {
+ gcc_assert(DECL_INITIAL(fndecl) == NULL_TREE);
+
+ // Declare variables if necessary.
+ tree bind = NULL_TREE;
+ if (declare_vars != NULL_TREE)
+ {
+ tree block = make_node(BLOCK);
+ BLOCK_SUPERCONTEXT(block) = fndecl;
+ DECL_INITIAL(fndecl) = block;
+ BLOCK_VARS(block) = declare_vars;
+ TREE_USED(block) = 1;
+ bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
+ NULL_TREE, block);
+ TREE_SIDE_EFFECTS(bind) = 1;
+ }
+
+ // Build the trees for all the statements in the function.
+ Translate_context context(gogo, named_function, NULL, NULL_TREE);
+ tree code = this->block_->get_tree(&context);
+
+ tree init = NULL_TREE;
+ tree except = NULL_TREE;
+ tree fini = NULL_TREE;
+
+ // Initialize variables if necessary.
+ for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
+ {
+ tree dv = build1(DECL_EXPR, void_type_node, v);
+ SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
+ append_to_statement_list(dv, &init);
+ }
+
+ // If we have a defer stack, initialize it at the start of a
+ // function.
+ if (this->defer_stack_ != NULL_TREE)
+ {
+ tree defer_init = build1(DECL_EXPR, void_type_node,
+ this->defer_stack_);
+ SET_EXPR_LOCATION(defer_init, this->block_->start_location());
+ append_to_statement_list(defer_init, &init);
+
+ // Clean up the defer stack when we leave the function.
+ this->build_defer_wrapper(gogo, named_function, &except, &fini);
+ }
+
+ if (code != NULL_TREE && code != error_mark_node)
+ {
+ if (init != NULL_TREE)
+ code = build2(COMPOUND_EXPR, void_type_node, init, code);
+ if (except != NULL_TREE)
+ code = build2(TRY_CATCH_EXPR, void_type_node, code,
+ build2(CATCH_EXPR, void_type_node, NULL, except));
+ if (fini != NULL_TREE)
+ code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
+ }
+
+ // Stick the code into the block we built for the receiver, if
+ // we built on.
+ if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
+ {
+ BIND_EXPR_BODY(bind) = code;
+ code = bind;
+ }
+
+ DECL_SAVED_TREE(fndecl) = code;
+ }
+}
+
+// Build the wrappers around function code needed if the function has
+// any defer statements. This sets *EXCEPT to an exception handler
+// and *FINI to a finally handler.
+
+void
+Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
+ tree *except, tree *fini)
+{
+ source_location end_loc = this->block_->end_location();
+
+ // Add an exception handler. This is used if a panic occurs. Its
+ // purpose is to stop the stack unwinding if a deferred function
+ // calls recover. There are more details in
+ // libgo/runtime/go-unwind.c.
+ tree stmt_list = NULL_TREE;
+ static tree check_fndecl;
+ tree call = Gogo::call_builtin(&check_fndecl,
+ end_loc,
+ "__go_check_defer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ append_to_statement_list(call, &stmt_list);
+
+ tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
+ tree set;
+ if (retval == NULL_TREE)
+ set = NULL_TREE;
+ else
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+
+ gcc_assert(*except == NULL_TREE);
+ *except = stmt_list;
+
+ // Add some finally code to run the defer functions. This is used
+ // both in the normal case, when no panic occurs, and also if a
+ // panic occurs to run any further defer functions. Of course, it
+ // is possible for a defer function to call panic which should be
+ // caught by another defer function. To handle that we use a loop.
+ // finish:
+ // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
+ // if (return values are named) return named_vals;
+
+ stmt_list = NULL;
+
+ tree label = create_artificial_label(end_loc);
+ tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
+ label);
+ append_to_statement_list(define_label, &stmt_list);
+
+ static tree undefer_fndecl;
+ tree undefer = Gogo::call_builtin(&undefer_fndecl,
+ end_loc,
+ "__go_undefer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ TREE_NOTHROW(undefer_fndecl) = 0;
+
+ tree defer = Gogo::call_builtin(&check_fndecl,
+ end_loc,
+ "__go_check_defer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
+ tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
+ catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
+ tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
+
+ append_to_statement_list(try_catch, &stmt_list);
+
+ if (this->type_->results() != NULL
+ && !this->type_->results()->empty()
+ && !this->type_->results()->front().name().empty())
+ {
+ // If the result variables are named, we need to return them
+ // again, because they might have been changed by a defer
+ // function.
+ retval = this->return_value(gogo, named_function, end_loc,
+ &stmt_list);
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+ }
+
+ gcc_assert(*fini == NULL_TREE);
+ *fini = stmt_list;
+}
+
+// Return the value to assign to DECL_RESULT(this->fndecl_). This may
+// also add statements to STMT_LIST, which need to be executed before
+// the assignment. This is used for a return statement with no
+// explicit values.
+
+tree
+Function::return_value(Gogo* gogo, Named_object* named_function,
+ source_location location, tree* stmt_list) const
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL || results->empty())
+ return NULL_TREE;
+
+ // In the case of an exception handler created for functions with
+ // defer statements, the result variables may be unnamed.
+ bool is_named = !results->front().name().empty();
+ if (is_named)
+ gcc_assert(this->named_results_ != NULL
+ && this->named_results_->size() == results->size());
+
+ tree retval;
+ if (results->size() == 1)
+ {
+ if (is_named)
+ return this->named_results_->front()->get_tree(gogo, named_function);
+ else
+ return results->front().type()->get_init_tree(gogo, false);
+ }
+ else
+ {
+ tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
+ retval = create_tmp_var(rettype, "RESULT");
+ tree field = TYPE_FIELDS(rettype);
+ int index = 0;
+ for (Typed_identifier_list::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++index, field = DECL_CHAIN(field))
+ {
+ gcc_assert(field != NULL);
+ tree val;
+ if (is_named)
+ val = (*this->named_results_)[index]->get_tree(gogo,
+ named_function);
+ else
+ val = pr->type()->get_init_tree(gogo, false);
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ build3(COMPONENT_REF, TREE_TYPE(field),
+ retval, field, NULL_TREE),
+ val);
+ append_to_statement_list(set, stmt_list);
+ }
+ return retval;
+ }
+}
+
+// Get the tree for the variable holding the defer stack for this
+// function. At least at present, the value of this variable is not
+// used. However, a pointer to this variable is used as a marker for
+// the functions on the defer stack associated with this function.
+// Doing things this way permits inlining a function which uses defer.
+
+tree
+Function::defer_stack(source_location location)
+{
+ if (this->defer_stack_ == NULL_TREE)
+ {
+ tree var = create_tmp_var(ptr_type_node, "DEFER");
+ DECL_INITIAL(var) = null_pointer_node;
+ DECL_SOURCE_LOCATION(var) = location;
+ TREE_ADDRESSABLE(var) = 1;
+ this->defer_stack_ = var;
+ }
+ return fold_convert_loc(location, ptr_type_node,
+ build_fold_addr_expr_loc(location,
+ this->defer_stack_));
+}
+
+// Get a tree for the statements in a block.
+
+tree
+Block::get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ tree block = make_node(BLOCK);
+
+ // Put the new block into the block tree.
+
+ if (context->block() == NULL)
+ {
+ tree fndecl;
+ if (context->function() != NULL)
+ fndecl = context->function()->func_value()->get_decl();
+ else
+ fndecl = current_function_decl;
+ gcc_assert(fndecl != NULL_TREE);
+
+ // We may have already created a block for the receiver.
+ if (DECL_INITIAL(fndecl) == NULL_TREE)
+ {
+ BLOCK_SUPERCONTEXT(block) = fndecl;
+ DECL_INITIAL(fndecl) = block;
+ }
+ else
+ {
+ tree superblock_tree = DECL_INITIAL(fndecl);
+ BLOCK_SUPERCONTEXT(block) = superblock_tree;
+ gcc_assert(BLOCK_CHAIN(block) == NULL_TREE);
+ BLOCK_CHAIN(block) = block;
+ }
+ }
+ else
+ {
+ tree superblock_tree = context->block_tree();
+ BLOCK_SUPERCONTEXT(block) = superblock_tree;
+ tree* pp;
+ for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
+ *pp != NULL_TREE;
+ pp = &BLOCK_CHAIN(*pp))
+ ;
+ *pp = block;
+ }
+
+ // Expand local variables in the block.
+
+ tree* pp = &BLOCK_VARS(block);
+ for (Bindings::const_definitions_iterator pv =
+ this->bindings_->begin_definitions();
+ pv != this->bindings_->end_definitions();
+ ++pv)
+ {
+ if ((!(*pv)->is_variable() || !(*pv)->var_value()->is_parameter())
+ && !(*pv)->is_result_variable()
+ && !(*pv)->is_const())
+ {
+ tree var = (*pv)->get_tree(gogo, context->function());
+ if (var != error_mark_node && TREE_TYPE(var) != error_mark_node)
+ {
+ if ((*pv)->is_variable() && (*pv)->var_value()->is_in_heap())
+ {
+ gcc_assert(TREE_CODE(var) == INDIRECT_REF);
+ var = TREE_OPERAND(var, 0);
+ gcc_assert(TREE_CODE(var) == VAR_DECL);
+ }
+ *pp = var;
+ pp = &DECL_CHAIN(*pp);
+ }
+ }
+ }
+ *pp = NULL_TREE;
+
+ Translate_context subcontext(context->gogo(), context->function(),
+ this, block);
+
+ tree statements = NULL_TREE;
+
+ // Expand the statements.
+
+ for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
+ p != this->statements_.end();
+ ++p)
+ {
+ tree statement = (*p)->get_tree(&subcontext);
+ if (statement != error_mark_node)
+ append_to_statement_list(statement, &statements);
+ }
+
+ TREE_USED(block) = 1;
+
+ tree bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block), statements,
+ block);
+ TREE_SIDE_EFFECTS(bind) = 1;
+
+ return bind;
+}
+
+// Get the LABEL_DECL for a label.
+
+tree
+Label::get_decl()
+{
+ if (this->decl_ == NULL)
+ {
+ tree id = get_identifier_from_string(this->name_);
+ this->decl_ = build_decl(this->location_, LABEL_DECL, id, void_type_node);
+ DECL_CONTEXT(this->decl_) = current_function_decl;
+ }
+ return this->decl_;
+}
+
+// Return an expression for the address of this label.
+
+tree
+Label::get_addr(source_location location)
+{
+ tree decl = this->get_decl();
+ TREE_USED(decl) = 1;
+ TREE_ADDRESSABLE(decl) = 1;
+ return fold_convert_loc(location, ptr_type_node,
+ build_fold_addr_expr_loc(location, decl));
+}
+
+// Get the LABEL_DECL for an unnamed label.
+
+tree
+Unnamed_label::get_decl()
+{
+ if (this->decl_ == NULL)
+ this->decl_ = create_artificial_label(this->location_);
+ return this->decl_;
+}
+
+// Get the LABEL_EXPR for an unnamed label.
+
+tree
+Unnamed_label::get_definition()
+{
+ tree t = build1(LABEL_EXPR, void_type_node, this->get_decl());
+ SET_EXPR_LOCATION(t, this->location_);
+ return t;
+}
+
+// Return a goto to this label.
+
+tree
+Unnamed_label::get_goto(source_location location)
+{
+ tree t = build1(GOTO_EXPR, void_type_node, this->get_decl());
+ SET_EXPR_LOCATION(t, location);
+ return t;
+}
+
+// Return the integer type to use for a size.
+
+GO_EXTERN_C
+tree
+go_type_for_size(unsigned int bits, int unsignedp)
+{
+ const char* name;
+ switch (bits)
+ {
+ case 8:
+ name = unsignedp ? "uint8" : "int8";
+ break;
+ case 16:
+ name = unsignedp ? "uint16" : "int16";
+ break;
+ case 32:
+ name = unsignedp ? "uint32" : "int32";
+ break;
+ case 64:
+ name = unsignedp ? "uint64" : "int64";
+ break;
+ default:
+ if (bits == POINTER_SIZE && unsignedp)
+ name = "uintptr";
+ else
+ return NULL_TREE;
+ }
+ Type* type = Type::lookup_integer_type(name);
+ return type->get_tree(go_get_gogo());
+}
+
+// Return the type to use for a mode.
+
+GO_EXTERN_C
+tree
+go_type_for_mode(enum machine_mode mode, int unsignedp)
+{
+ // FIXME: This static_cast should be in machmode.h.
+ enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
+ if (mc == MODE_INT)
+ return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
+ else if (mc == MODE_FLOAT)
+ {
+ Type* type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 32:
+ type = Type::lookup_float_type("float32");
+ break;
+ case 64:
+ type = Type::lookup_float_type("float64");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(long_double_type_node))
+ return long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->float_type()->type_tree();
+ }
+ else if (mc == MODE_COMPLEX_FLOAT)
+ {
+ Type *type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 64:
+ type = Type::lookup_complex_type("complex64");
+ break;
+ case 128:
+ type = Type::lookup_complex_type("complex128");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(complex_long_double_type_node))
+ return complex_long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->complex_type()->type_tree();
+ }
+ else
+ return NULL_TREE;
+}
+
+// Return a tree which allocates SIZE bytes which will holds value of
+// type TYPE.
+
+tree
+Gogo::allocate_memory(Type* type, tree size, source_location location)
+{
+ // If the package imports unsafe, then it may play games with
+ // pointers that look like integers.
+ if (this->imported_unsafe_ || type->has_pointer())
+ {
+ static tree new_fndecl;
+ return Gogo::call_builtin(&new_fndecl,
+ location,
+ "__go_new",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+ else
+ {
+ static tree new_nopointers_fndecl;
+ return Gogo::call_builtin(&new_nopointers_fndecl,
+ location,
+ "__go_new_nopointers",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+}
+
+// Build a builtin struct with a list of fields. The name is
+// STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
+// node; this exists so that the struct can have fields which point to
+// itself. If PTYPE is not NULL, store the result in *PTYPE. There
+// are NFIELDS fields. Each field is a name (a const char*) followed
+// by a type (a tree).
+
+tree
+Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...)
+{
+ if (ptype != NULL && *ptype != NULL_TREE)
+ return *ptype;
+
+ va_list ap;
+ va_start(ap, nfields);
+
+ tree fields = NULL_TREE;
+ for (int i = 0; i < nfields; ++i)
+ {
+ const char* field_name = va_arg(ap, const char*);
+ tree type = va_arg(ap, tree);
+ if (type == error_mark_node)
+ {
+ if (ptype != NULL)
+ *ptype = error_mark_node;
+ return error_mark_node;
+ }
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
+ get_identifier(field_name), type);
+ DECL_CHAIN(field) = fields;
+ fields = field;
+ }
+
+ va_end(ap);
+
+ if (struct_type == NULL_TREE)
+ struct_type = make_node(RECORD_TYPE);
+ finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
+
+ if (ptype != NULL)
+ {
+ go_preserve_from_gc(struct_type);
+ *ptype = struct_type;
+ }
+
+ return struct_type;
+}
+
+// Return a type to use for pointer to const char for a string.
+
+tree
+Gogo::const_char_pointer_type_tree()
+{
+ static tree type;
+ if (type == NULL_TREE)
+ {
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ type = build_pointer_type(const_char_type);
+ go_preserve_from_gc(type);
+ }
+ return type;
+}
+
+// Return a tree for a string constant.
+
+tree
+Gogo::string_constant_tree(const std::string& val)
+{
+ tree index_type = build_index_type(size_int(val.length()));
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ tree string_type = build_array_type(const_char_type, index_type);
+ string_type = build_variant_type_copy(string_type);
+ TYPE_STRING_FLAG(string_type) = 1;
+ tree string_val = build_string(val.length(), val.data());
+ TREE_TYPE(string_val) = string_type;
+ return string_val;
+}
+
+// Return a tree for a Go string constant.
+
+tree
+Gogo::go_string_constant_tree(const std::string& val)
+{
+ tree string_type = Type::make_string_type()->get_tree(this);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(string_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
+ elt->index = field;
+ tree str = Gogo::string_constant_tree(val);
+ elt->value = fold_convert(TREE_TYPE(field),
+ build_fold_addr_expr(str));
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
+ elt->index = field;
+ elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
+
+ tree constructor = build_constructor(string_type, init);
+ TREE_READONLY(constructor) = 1;
+ TREE_CONSTANT(constructor) = 1;
+
+ return constructor;
+}
+
+// Return a tree for a pointer to a Go string constant. This is only
+// used for type descriptors, so we return a pointer to a constant
+// decl.
+
+tree
+Gogo::ptr_go_string_constant_tree(const std::string& val)
+{
+ tree pval = this->go_string_constant_tree(val);
+
+ tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
+ create_tmp_var_name("SP"), TREE_TYPE(pval));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = pval;
+ rest_of_decl_compilation(decl, 1, 0);
+
+ return build_fold_addr_expr(decl);
+}
+
+// Build the type of the struct that holds a slice for the given
+// element type.
+
+tree
+Gogo::slice_type_tree(tree element_type_tree)
+{
+ // We use int for the count and capacity fields in a slice header.
+ // This matches 6g. The language definition guarantees that we
+ // can't allocate space of a size which does not fit in int
+ // anyhow. FIXME: integer_type_node is the the C type "int" but is
+ // not necessarily the Go type "int". They will differ when the C
+ // type "int" has fewer than 32 bits.
+ return Gogo::builtin_struct(NULL, "__go_slice", NULL_TREE, 3,
+ "__values",
+ build_pointer_type(element_type_tree),
+ "__count",
+ integer_type_node,
+ "__capacity",
+ integer_type_node);
+}
+
+// Given the tree for a slice type, return the tree for the type of
+// the elements of the slice.
+
+tree
+Gogo::slice_element_type_tree(tree slice_type_tree)
+{
+ gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE
+ && POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree))));
+ return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree)));
+}
+
+// Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+// the slice. VALUES is the value pointer and COUNT is the number of
+// entries. If CAPACITY is not NULL, it is the capacity; otherwise
+// the capacity and the count are the same.
+
+tree
+Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity)
+{
+ gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ tree field = TYPE_FIELDS(slice_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(values)));
+ elt->value = values;
+
+ count = fold_convert(sizetype, count);
+ if (capacity == NULL_TREE)
+ {
+ count = save_expr(count);
+ capacity = count;
+ }
+
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), count);
+
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), capacity);
+
+ return build_constructor(slice_type_tree, init);
+}
+
+// Build a constructor for an empty slice.
+
+tree
+Gogo::empty_slice_constructor(tree slice_type_tree)
+{
+ tree element_field = TYPE_FIELDS(slice_type_tree);
+ tree ret = Gogo::slice_constructor(slice_type_tree,
+ fold_convert(TREE_TYPE(element_field),
+ null_pointer_node),
+ size_zero_node,
+ size_zero_node);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Build a map descriptor for a map of type MAPTYPE.
+
+tree
+Gogo::map_descriptor(Map_type* maptype)
+{
+ if (this->map_descriptors_ == NULL)
+ this->map_descriptors_ = new Map_descriptors(10);
+
+ std::pair<const Map_type*, tree> val(maptype, NULL);
+ std::pair<Map_descriptors::iterator, bool> ins =
+ this->map_descriptors_->insert(val);
+ Map_descriptors::iterator p = ins.first;
+ if (!ins.second)
+ {
+ gcc_assert(p->second != NULL_TREE && DECL_P(p->second));
+ return build_fold_addr_expr(p->second);
+ }
+
+ Type* keytype = maptype->key_type();
+ Type* valtype = maptype->val_type();
+
+ std::string mangled_name = ("__go_map_" + maptype->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // Get the type of the map descriptor. This is __go_map_descriptor
+ // in libgo/map.h.
+
+ tree struct_type = this->map_descriptor_type();
+
+ // The map entry type is a struct with three fields. This struct is
+ // specific to MAPTYPE. Build it.
+
+ tree map_entry_type = make_node(RECORD_TYPE);
+
+ map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
+ "__next",
+ build_pointer_type(map_entry_type),
+ "__key",
+ keytype->get_tree(this),
+ "__val",
+ valtype->get_tree(this));
+ if (map_entry_type == error_mark_node)
+ return error_mark_node;
+
+ tree map_entry_key_field = DECL_CHAIN(TYPE_FIELDS(map_entry_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field)),
+ "__key") == 0);
+
+ tree map_entry_val_field = DECL_CHAIN(map_entry_key_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field)),
+ "__val") == 0);
+
+ // Initialize the entries.
+
+ tree map_descriptor_field = TYPE_FIELDS(struct_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field)),
+ "__map_descriptor") == 0);
+ tree entry_size_field = DECL_CHAIN(map_descriptor_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field)),
+ "__entry_size") == 0);
+ tree key_offset_field = DECL_CHAIN(entry_size_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field)),
+ "__key_offset") == 0);
+ tree val_offset_field = DECL_CHAIN(key_offset_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field)),
+ "__val_offset") == 0);
+
+ VEC(constructor_elt, gc)* descriptor = VEC_alloc(constructor_elt, gc, 6);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = map_descriptor_field;
+ elt->value = maptype->type_descriptor_pointer(this);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = entry_size_field;
+ elt->value = TYPE_SIZE_UNIT(map_entry_type);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = key_offset_field;
+ elt->value = byte_position(map_entry_key_field);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = val_offset_field;
+ elt->value = byte_position(map_entry_val_field);
+
+ tree constructor = build_constructor(struct_type, descriptor);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, struct_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+ p->second = decl;
+
+ return build_fold_addr_expr(decl);
+}
+
+// Return a tree for the type of a map descriptor. This is struct
+// __go_map_descriptor in libgo/runtime/map.h. This is the same for
+// all map types.
+
+tree
+Gogo::map_descriptor_type()
+{
+ static tree struct_type;
+ tree dtype = Type::make_type_descriptor_type()->get_tree(this);
+ dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
+ return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
+ 4,
+ "__map_descriptor",
+ build_pointer_type(dtype),
+ "__entry_size",
+ sizetype,
+ "__key_offset",
+ sizetype,
+ "__val_offset",
+ sizetype);
+}
+
+// Return the name to use for a type descriptor decl for TYPE. This
+// is used when TYPE does not have a name.
+
+std::string
+Gogo::unnamed_type_descriptor_decl_name(const Type* type)
+{
+ return "__go_td_" + type->mangled_name(this);
+}
+
+// Return the name to use for a type descriptor decl for a type named
+// NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
+// normally be NULL.
+
+std::string
+Gogo::type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function)
+{
+ std::string ret = "__go_tdn_";
+ if (no->type_value()->is_builtin())
+ gcc_assert(in_function == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? this->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? this->package_name()
+ : no->package()->name());
+ ret.append(unique_prefix);
+ ret.append(1, '.');
+ ret.append(package_name);
+ ret.append(1, '.');
+ if (in_function != NULL)
+ {
+ ret.append(Gogo::unpack_hidden_name(in_function->name()));
+ ret.append(1, '.');
+ }
+ }
+ ret.append(no->name());
+ return ret;
+}
+
+// Where a type descriptor decl should be defined.
+
+Gogo::Type_descriptor_location
+Gogo::type_descriptor_location(const Type* type)
+{
+ const Named_type* name = type->named_type();
+ if (name != NULL)
+ {
+ if (name->named_object()->package() != NULL)
+ {
+ // This is a named type defined in a different package. The
+ // descriptor should be defined in that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else if (name->is_builtin())
+ {
+ // We create the descriptor for a builtin type whenever we
+ // need it.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ else
+ {
+ // This is a named type defined in this package. The
+ // descriptor should be defined here.
+ return TYPE_DESCRIPTOR_DEFINED;
+ }
+ }
+ else
+ {
+ if (type->points_to() != NULL
+ && type->points_to()->named_type() != NULL
+ && type->points_to()->named_type()->named_object()->package() != NULL)
+ {
+ // This is an unnamed pointer to a named type defined in a
+ // different package. The descriptor should be defined in
+ // that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else
+ {
+ // This is an unnamed type. The descriptor could be defined
+ // in any package where it is needed, and the linker will
+ // pick one descriptor to keep.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ }
+}
+
+// Build a type descriptor decl for TYPE. INITIALIZER is a struct
+// composite literal which initializers the type descriptor.
+
+void
+Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
+ tree* pdecl)
+{
+ const Named_type* name = type->named_type();
+
+ // We can have multiple instances of unnamed types, but we only want
+ // to emit the type descriptor once. We use a hash table to handle
+ // this. This is not necessary for named types, as they are unique,
+ // and we store the type descriptor decl in the type itself.
+ tree* phash = NULL;
+ if (name == NULL)
+ {
+ if (this->type_descriptor_decls_ == NULL)
+ this->type_descriptor_decls_ = new Type_descriptor_decls(10);
+
+ std::pair<Type_descriptor_decls::iterator, bool> ins =
+ this->type_descriptor_decls_->insert(std::make_pair(type, NULL_TREE));
+ if (!ins.second)
+ {
+ // We've already built a type descriptor for this type.
+ *pdecl = ins.first->second;
+ return;
+ }
+ phash = &ins.first->second;
+ }
+
+ std::string decl_name;
+ if (name == NULL)
+ decl_name = this->unnamed_type_descriptor_decl_name(type);
+ else
+ decl_name = this->type_descriptor_decl_name(name->named_object(),
+ name->in_function());
+ tree id = get_identifier_from_string(decl_name);
+ tree descriptor_type_tree = initializer->type()->get_tree(this);
+ if (descriptor_type_tree == error_mark_node)
+ {
+ *pdecl = error_mark_node;
+ return;
+ }
+ tree decl = build_decl(name == NULL ? BUILTINS_LOCATION : name->location(),
+ VAR_DECL, id,
+ build_qualified_type(descriptor_type_tree,
+ TYPE_QUAL_CONST));
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+
+ go_preserve_from_gc(decl);
+ if (phash != NULL)
+ *phash = decl;
+
+ // We store the new DECL now because we may need to refer to it when
+ // expanding INITIALIZER.
+ *pdecl = decl;
+
+ // If appropriate, just refer to the exported type identifier.
+ Gogo::Type_descriptor_location type_descriptor_location =
+ this->type_descriptor_location(type);
+ if (type_descriptor_location == TYPE_DESCRIPTOR_UNDEFINED)
+ {
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ return;
+ }
+
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+
+ Translate_context context(this, NULL, NULL, NULL);
+ context.set_is_const();
+ tree constructor = initializer->get_tree(&context);
+
+ if (constructor == error_mark_node)
+ gcc_assert(saw_errors());
+
+ DECL_INITIAL(decl) = constructor;
+
+ if (type_descriptor_location == TYPE_DESCRIPTOR_COMMON)
+ {
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+ else
+ {
+#ifdef OBJECT_FORMAT_ELF
+ // Give the decl protected visibility. This avoids out-of-range
+ // references with shared libraries with the x86_64 small model
+ // when the type descriptor gets a COPY reloc into the main
+ // executable. There is no need to have unique pointers to type
+ // descriptors, as the runtime code compares reflection strings
+ // if necessary.
+ DECL_VISIBILITY(decl) = VISIBILITY_PROTECTED;
+ DECL_VISIBILITY_SPECIFIED(decl) = 1;
+#endif
+
+ TREE_PUBLIC(decl) = 1;
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+}
+
+// Build an interface method table for a type: a list of function
+// pointers, one for each interface method. This is used for
+// interfaces.
+
+tree
+Gogo::interface_method_table_for_type(const Interface_type* interface,
+ Named_type* type,
+ bool is_pointer)
+{
+ const Typed_identifier_list* interface_methods = interface->methods();
+ gcc_assert(!interface_methods->empty());
+
+ std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
+ + interface->mangled_name(this)
+ + "__"
+ + type->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // See whether this interface has any hidden methods.
+ bool has_hidden_methods = false;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->name()))
+ {
+ has_hidden_methods = true;
+ break;
+ }
+ }
+
+ // We already know that the named type is convertible to the
+ // interface. If the interface has hidden methods, and the named
+ // type is defined in a different package, then the interface
+ // conversion table will be defined by that other package.
+ if (has_hidden_methods && type->named_object()->package() != NULL)
+ {
+ tree array_type = build_array_type(const_ptr_type_node, NULL);
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ go_preserve_from_gc(decl);
+ return decl;
+ }
+
+ size_t count = interface_methods->size();
+ VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ // The first element is the type descriptor.
+ constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_zero_node;
+ Type* td_type;
+ if (!is_pointer)
+ td_type = type;
+ else
+ td_type = Type::make_pointer_type(type);
+ elt->value = fold_convert(const_ptr_type_node,
+ td_type->type_descriptor_pointer(this));
+
+ size_t i = 1;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p, ++i)
+ {
+ bool is_ambiguous;
+ Method* m = type->method_function(p->name(), &is_ambiguous);
+ gcc_assert(m != NULL);
+
+ Named_object* no = m->named_object();
+
+ tree fnid = no->get_id(this);
+
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
+ fnid);
+ else
+ gcc_unreachable();
+ fndecl = build_fold_addr_expr(fndecl);
+
+ elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_int(i);
+ elt->value = fold_convert(const_ptr_type_node, fndecl);
+ }
+ gcc_assert(i == count + 1);
+
+ tree array_type = build_array_type(const_ptr_type_node,
+ build_index_type(size_int(count)));
+ tree constructor = build_constructor(array_type, pointers);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+
+ // If the interface type has hidden methods, then this is the only
+ // definition of the table. Otherwise it is a comdat table which
+ // may be defined in multiple packages.
+ if (has_hidden_methods)
+ {
+#ifdef OBJECT_FORMAT_ELF
+ // Give the decl protected visibility. This avoids out-of-range
+ // references with shared libraries with the x86_64 small model
+ // when the table gets a COPY reloc into the main executable.
+ DECL_VISIBILITY(decl) = VISIBILITY_PROTECTED;
+ DECL_VISIBILITY_SPECIFIED(decl) = 1;
+#endif
+
+ TREE_PUBLIC(decl) = 1;
+ }
+ else
+ {
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+
+ return decl;
+}
+
+// Mark a function as a builtin library function.
+
+void
+Gogo::mark_fndecl_as_builtin_library(tree fndecl)
+{
+ DECL_EXTERNAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_NOTHROW(fndecl) = 1;
+ DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
+}
+
+// Build a call to a builtin function.
+
+tree
+Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
+ int nargs, tree rettype, ...)
+{
+ if (rettype == error_mark_node)
+ return error_mark_node;
+
+ tree* types = new tree[nargs];
+ tree* args = new tree[nargs];
+
+ va_list ap;
+ va_start(ap, rettype);
+ for (int i = 0; i < nargs; ++i)
+ {
+ types[i] = va_arg(ap, tree);
+ args[i] = va_arg(ap, tree);
+ if (types[i] == error_mark_node || args[i] == error_mark_node)
+ return error_mark_node;
+ }
+ va_end(ap);
+
+ if (*pdecl == NULL_TREE)
+ {
+ tree fnid = get_identifier(name);
+
+ tree argtypes = NULL_TREE;
+ tree* pp = &argtypes;
+ for (int i = 0; i < nargs; ++i)
+ {
+ *pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
+ pp = &TREE_CHAIN(*pp);
+ }
+ *pp = void_list_node;
+
+ tree fntype = build_function_type(rettype, argtypes);
+
+ *pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
+ Gogo::mark_fndecl_as_builtin_library(*pdecl);
+ go_preserve_from_gc(*pdecl);
+ }
+
+ tree fnptr = build_fold_addr_expr(*pdecl);
+ if (CAN_HAVE_LOCATION_P(fnptr))
+ SET_EXPR_LOCATION(fnptr, location);
+
+ tree ret = build_call_array(rettype, fnptr, nargs, args);
+ SET_EXPR_LOCATION(ret, location);
+
+ delete[] types;
+ delete[] args;
+
+ return ret;
+}
+
+// Build a call to the runtime error function.
+
+tree
+Gogo::runtime_error(int code, source_location location)
+{
+ static tree runtime_error_fndecl;
+ tree ret = Gogo::call_builtin(&runtime_error_fndecl,
+ location,
+ "__go_runtime_error",
+ 1,
+ void_type_node,
+ integer_type_node,
+ build_int_cst(integer_type_node, code));
+ // The runtime error function panics and does not return.
+ TREE_NOTHROW(runtime_error_fndecl) = 0;
+ TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
+ return ret;
+}
+
+// Send VAL on CHANNEL. If BLOCKING is true, the resulting tree has a
+// void type. If BLOCKING is false, the resulting tree has a boolean
+// type, and it will evaluate as true if the value was sent. If
+// FOR_SELECT is true, this is being done because it was chosen in a
+// select statement.
+
+tree
+Gogo::send_on_channel(tree channel, tree val, bool blocking, bool for_select,
+ source_location location)
+{
+ if (int_size_in_bytes(TREE_TYPE(val)) <= 8
+ && !AGGREGATE_TYPE_P(TREE_TYPE(val))
+ && !FLOAT_TYPE_P(TREE_TYPE(val)))
+ {
+ val = convert_to_integer(uint64_type_node, val);
+ if (blocking)
+ {
+ static tree send_small_fndecl;
+ tree ret = Gogo::call_builtin(&send_small_fndecl,
+ location,
+ "__go_send_small",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ channel,
+ uint64_type_node,
+ val,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_small_fndecl) = 0;
+ return ret;
+ }
+ else
+ {
+ gcc_assert(!for_select);
+ static tree send_nonblocking_small_fndecl;
+ tree ret = Gogo::call_builtin(&send_nonblocking_small_fndecl,
+ location,
+ "__go_send_nonblocking_small",
+ 2,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ uint64_type_node,
+ val);
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_nonblocking_small_fndecl) = 0;
+ return ret;
+ }
+ }
+ else
+ {
+ tree make_tmp;
+ if (TREE_ADDRESSABLE(TREE_TYPE(val)) || TREE_CODE(val) == VAR_DECL)
+ {
+ make_tmp = NULL_TREE;
+ val = build_fold_addr_expr(val);
+ if (DECL_P(val))
+ TREE_ADDRESSABLE(val) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(val), get_name(val));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = val;
+ TREE_ADDRESSABLE(tmp) = 1;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ val = build_fold_addr_expr(tmp);
+ }
+ val = fold_convert(ptr_type_node, val);
+
+ tree call;
+ if (blocking)
+ {
+ static tree send_big_fndecl;
+ call = Gogo::call_builtin(&send_big_fndecl,
+ location,
+ "__go_send_big",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ val,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_big_fndecl) = 0;
+ }
+ else
+ {
+ gcc_assert(!for_select);
+ static tree send_nonblocking_big_fndecl;
+ call = Gogo::call_builtin(&send_nonblocking_big_fndecl,
+ location,
+ "__go_send_nonblocking_big",
+ 2,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ val);
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_nonblocking_big_fndecl) = 0;
+ }
+
+ if (make_tmp == NULL_TREE)
+ return call;
+ else
+ {
+ tree ret = build2(COMPOUND_EXPR, TREE_TYPE(call), make_tmp, call);
+ SET_EXPR_LOCATION(ret, location);
+ return ret;
+ }
+ }
+}
+
+// Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
+// This does a blocking receive and returns the value read from the
+// channel. If FOR_SELECT is true, this is being done because it was
+// chosen in a select statement.
+
+tree
+Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location location)
+{
+ if (int_size_in_bytes(type_tree) <= 8
+ && !AGGREGATE_TYPE_P(type_tree)
+ && !FLOAT_TYPE_P(type_tree))
+ {
+ static tree receive_small_fndecl;
+ tree call = Gogo::call_builtin(&receive_small_fndecl,
+ location,
+ "__go_receive_small",
+ 2,
+ uint64_type_node,
+ ptr_type_node,
+ channel,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_small_fndecl) = 0;
+ int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
+ tree int_type_tree = go_type_for_size(bitsize, 1);
+ return fold_convert_loc(location, type_tree,
+ fold_convert_loc(location, int_type_tree,
+ call));
+ }
+ else
+ {
+ tree tmp = create_tmp_var(type_tree, get_name(type_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ TREE_ADDRESSABLE(tmp) = 1;
+ tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ tree tmpaddr = build_fold_addr_expr(tmp);
+ tmpaddr = fold_convert(ptr_type_node, tmpaddr);
+ static tree receive_big_fndecl;
+ tree call = Gogo::call_builtin(&receive_big_fndecl,
+ location,
+ "__go_receive_big",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ tmpaddr,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_big_fndecl) = 0;
+ return build2(COMPOUND_EXPR, type_tree, make_tmp,
+ build2(COMPOUND_EXPR, type_tree, call, tmp));
+ }
+}
+
+// Return the type of a function trampoline. This is like
+// get_trampoline_type in tree-nested.c.
+
+tree
+Gogo::trampoline_type_tree()
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ unsigned int align = TRAMPOLINE_ALIGNMENT;
+ unsigned int size = TRAMPOLINE_SIZE;
+ tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
+ t = build_array_type(char_type_node, t);
+
+ type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
+ "__data", t);
+ t = TYPE_FIELDS(type_tree);
+ DECL_ALIGN(t) = align;
+ DECL_USER_ALIGN(t) = 1;
+
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Make a trampoline which calls FNADDR passing CLOSURE.
+
+tree
+Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
+{
+ tree trampoline_type = Gogo::trampoline_type_tree();
+ tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
+
+ closure = save_expr(closure);
+
+ // We allocate the trampoline using a special function which will
+ // mark it as executable.
+ static tree trampoline_fndecl;
+ tree x = Gogo::call_builtin(&trampoline_fndecl,
+ location,
+ "__go_allocate_trampoline",
+ 2,
+ ptr_type_node,
+ size_type_node,
+ trampoline_size,
+ ptr_type_node,
+ fold_convert_loc(location, ptr_type_node,
+ closure));
+
+ x = save_expr(x);
+
+ // Initialize the trampoline.
+ tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
+ 3, x, fnaddr, closure);
+
+ // On some targets the trampoline address needs to be adjusted. For
+ // example, when compiling in Thumb mode on the ARM, the address
+ // needs to have the low bit set.
+ x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
+ 1, x);
+ x = fold_convert(TREE_TYPE(fnaddr), x);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);
+}
--- /dev/null
+// gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "cgraph.h"
+#include "langhooks.h"
+#include "convert.h"
+#include "output.h"
+#include "diagnostic.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "statements.h"
+#include "runtime.h"
+#include "backend.h"
+#include "gogo.h"
+
+// Whether we have seen any errors.
+
+bool
+saw_errors()
+{
+ return errorcount != 0 || sorrycount != 0;
+}
+
+// A helper function.
+
+static inline tree
+get_identifier_from_string(const std::string& str)
+{
+ return get_identifier_with_length(str.data(), str.length());
+}
+
+// Builtin functions.
+
+static std::map<std::string, tree> builtin_functions;
+
+// Define a builtin function. BCODE is the builtin function code
+// defined by builtins.def. NAME is the name of the builtin function.
+// LIBNAME is the name of the corresponding library function, and is
+// NULL if there isn't one. FNTYPE is the type of the function.
+// CONST_P is true if the function has the const attribute.
+
+static void
+define_builtin(built_in_function bcode, const char* name, const char* libname,
+ tree fntype, bool const_p)
+{
+ tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
+ libname, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ built_in_decls[bcode] = decl;
+ implicit_built_in_decls[bcode] = decl;
+ builtin_functions[name] = decl;
+ if (libname != NULL)
+ {
+ decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
+ NULL, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ builtin_functions[libname] = decl;
+ }
+}
+
+// Create trees for implicit builtin functions.
+
+void
+Gogo::define_builtin_function_trees()
+{
+ /* We need to define the fetch_and_add functions, since we use them
+ for ++ and --. */
+ tree t = go_type_for_size(BITS_PER_UNIT, 1);
+ tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 2, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin (BUILT_IN_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 4, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 8, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ // We use __builtin_expect for magic import functions.
+ define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
+ build_function_type_list(long_integer_type_node,
+ long_integer_type_node,
+ long_integer_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_memmove for the predeclared copy function.
+ define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
+ build_function_type_list(ptr_type_node,
+ ptr_type_node,
+ const_ptr_type_node,
+ size_type_node,
+ NULL_TREE),
+ false);
+
+ // We provide sqrt for the math library.
+ define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
+ build_function_type_list(double_type_node,
+ double_type_node,
+ NULL_TREE),
+ true);
+ define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
+ build_function_type_list(long_double_type_node,
+ long_double_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_return_address in the thunk we build for
+ // functions which call recover.
+ define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
+ build_function_type_list(ptr_type_node,
+ unsigned_type_node,
+ NULL_TREE),
+ false);
+
+ // The compiler uses __builtin_trap for some exception handling
+ // cases.
+ define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
+ build_function_type(void_type_node, void_list_node),
+ false);
+}
+
+// Get the name to use for the import control function. If there is a
+// global function or variable, then we know that that name must be
+// unique in the link, and we use it as the basis for our name.
+
+const std::string&
+Gogo::get_init_fn_name()
+{
+ if (this->init_fn_name_.empty())
+ {
+ go_assert(this->package_ != NULL);
+ if (this->is_main_package())
+ {
+ // Use a name which the runtime knows.
+ this->init_fn_name_ = "__go_init_main";
+ }
+ else
+ {
+ std::string s = this->unique_prefix();
+ s.append(1, '.');
+ s.append(this->package_name());
+ s.append("..import");
+ this->init_fn_name_ = s;
+ }
+ }
+
+ return this->init_fn_name_;
+}
+
+// Add statements to INIT_STMT_LIST which run the initialization
+// functions for imported packages. This is only used for the "main"
+// package.
+
+void
+Gogo::init_imports(tree* init_stmt_list)
+{
+ go_assert(this->is_main_package());
+
+ if (this->imported_init_fns_.empty())
+ return;
+
+ tree fntype = build_function_type(void_type_node, void_list_node);
+
+ // We must call them in increasing priority order.
+ std::vector<Import_init> v;
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ v.push_back(*p);
+ std::sort(v.begin(), v.end());
+
+ for (std::vector<Import_init>::const_iterator p = v.begin();
+ p != v.end();
+ ++p)
+ {
+ std::string user_name = p->package_name() + ".init";
+ tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(user_name),
+ fntype);
+ const std::string& init_name(p->init_name());
+ SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
+ }
+}
+
+// Register global variables with the garbage collector. We need to
+// register all variables which can hold a pointer value. They become
+// roots during the mark phase. We build a struct that is easy to
+// hook into a list of roots.
+
+// struct __go_gc_root_list
+// {
+// struct __go_gc_root_list* __next;
+// struct __go_gc_root
+// {
+// void* __decl;
+// size_t __size;
+// } __roots[];
+// };
+
+// The last entry in the roots array has a NULL decl field.
+
+void
+Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
+ tree* init_stmt_list)
+{
+ if (var_gc.empty())
+ return;
+
+ size_t count = var_gc.size();
+
+ tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
+ "__next",
+ ptr_type_node,
+ "__size",
+ sizetype);
+
+ tree index_type = build_index_type(size_int(count));
+ tree array_type = build_array_type(root_type, index_type);
+
+ tree root_list_type = make_node(RECORD_TYPE);
+ root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
+ root_list_type, 2,
+ "__next",
+ build_pointer_type(root_list_type),
+ "__roots",
+ array_type);
+
+ // Build an initialier for the __roots array.
+
+ VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ size_t i = 0;
+ for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
+ p != var_gc.end();
+ ++p, ++i)
+ {
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ Bvariable* bvar = (*p)->get_backend_variable(this, NULL);
+ tree decl = var_to_tree(bvar);
+ go_assert(TREE_CODE(decl) == VAR_DECL);
+ elt->value = build_fold_addr_expr(decl);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = DECL_SIZE_UNIT(decl);
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+ }
+
+ // The list ends with a NULL entry.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = size_zero_node;
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+
+ // Build a constructor for the struct.
+
+ VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = TYPE_FIELDS(root_list_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = build_constructor(array_type, roots_init);
+
+ // Build a decl to register.
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
+ create_tmp_var_name("gc"), root_list_type);
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
+ rest_of_decl_compilation(decl, 1, 0);
+
+ static tree register_gc_fndecl;
+ tree call = Gogo::call_builtin(®ister_gc_fndecl, BUILTINS_LOCATION,
+ "__go_register_gc_roots",
+ 1,
+ void_type_node,
+ build_pointer_type(root_list_type),
+ build_fold_addr_expr(decl));
+ if (call != error_mark_node)
+ append_to_statement_list(call, init_stmt_list);
+}
+
+// Build the decl for the initialization function.
+
+tree
+Gogo::initialization_function_decl()
+{
+ // The tedious details of building your own function. There doesn't
+ // seem to be a helper function for this.
+ std::string name = this->package_name() + ".init";
+ tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(name),
+ build_function_type(void_type_node,
+ void_list_node));
+ const std::string& asm_name(this->get_init_fn_name());
+ SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
+
+ tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
+ void_type_node);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = fndecl;
+ DECL_RESULT(fndecl) = resdecl;
+
+ TREE_STATIC(fndecl) = 1;
+ TREE_USED(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+
+ DECL_INITIAL(fndecl) = make_node(BLOCK);
+ TREE_USED(DECL_INITIAL(fndecl)) = 1;
+
+ return fndecl;
+}
+
+// Create the magic initialization function. INIT_STMT_LIST is the
+// code that it needs to run.
+
+void
+Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
+{
+ // Make sure that we thought we needed an initialization function,
+ // as otherwise we will not have reported it in the export data.
+ go_assert(this->is_main_package() || this->need_init_fn_);
+
+ if (fndecl == NULL_TREE)
+ fndecl = this->initialization_function_decl();
+
+ DECL_SAVED_TREE(fndecl) = init_stmt_list;
+
+ current_function_decl = fndecl;
+ if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
+ push_struct_function(fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(fndecl));
+ cfun->function_end_locus = BUILTINS_LOCATION;
+
+ gimplify_function_tree(fndecl);
+
+ cgraph_add_new_function(fndecl, false);
+ cgraph_mark_needed_node(cgraph_get_node(fndecl));
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+}
+
+// Search for references to VAR in any statements or called functions.
+
+class Find_var : public Traverse
+{
+ public:
+ // A hash table we use to avoid looping. The index is the name of a
+ // named object. We only look through objects defined in this
+ // package.
+ typedef Unordered_set(std::string) Seen_objects;
+
+ Find_var(Named_object* var, Seen_objects* seen_objects)
+ : Traverse(traverse_expressions),
+ var_(var), seen_objects_(seen_objects), found_(false)
+ { }
+
+ // Whether the variable was found.
+ bool
+ found() const
+ { return this->found_; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // The variable we are looking for.
+ Named_object* var_;
+ // Names of objects we have already seen.
+ Seen_objects* seen_objects_;
+ // True if the variable was found.
+ bool found_;
+};
+
+// See if EXPR refers to VAR, looking through function calls and
+// variable initializations.
+
+int
+Find_var::expression(Expression** pexpr)
+{
+ Expression* e = *pexpr;
+
+ Var_expression* ve = e->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* v = ve->named_object();
+ if (v == this->var_)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+
+ if (v->is_variable() && v->package() == NULL)
+ {
+ Expression* init = v->var_value()->init();
+ if (init != NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(v->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ }
+
+ // We traverse the code of any function we see. Note that this
+ // means that we will traverse the code of a function whose address
+ // is taken even if it is not called.
+ Func_expression* fe = e->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* f = fe->named_object();
+ if (f->is_function() && f->package() == NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(f->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return true if EXPR refers to VAR.
+
+static bool
+expression_requires(Expression* expr, Block* preinit, Named_object* var)
+{
+ Find_var::Seen_objects seen_objects;
+ Find_var find_var(var, &seen_objects);
+ if (expr != NULL)
+ Expression::traverse(&expr, &find_var);
+ if (preinit != NULL)
+ preinit->traverse(&find_var);
+
+ return find_var.found();
+}
+
+// Sort variable initializations. If the initialization expression
+// for variable A refers directly or indirectly to the initialization
+// expression for variable B, then we must initialize B before A.
+
+class Var_init
+{
+ public:
+ Var_init()
+ : var_(NULL), init_(NULL_TREE), waiting_(0)
+ { }
+
+ Var_init(Named_object* var, tree init)
+ : var_(var), init_(init), waiting_(0)
+ { }
+
+ // Return the variable.
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ // Return the initialization expression.
+ tree
+ init() const
+ { return this->init_; }
+
+ // Return the number of variables waiting for this one to be
+ // initialized.
+ size_t
+ waiting() const
+ { return this->waiting_; }
+
+ // Increment the number waiting.
+ void
+ increment_waiting()
+ { ++this->waiting_; }
+
+ private:
+ // The variable being initialized.
+ Named_object* var_;
+ // The initialization expression to run.
+ tree init_;
+ // The number of variables which are waiting for this one.
+ size_t waiting_;
+};
+
+typedef std::list<Var_init> Var_inits;
+
+// Sort the variable initializations. The rule we follow is that we
+// emit them in the order they appear in the array, except that if the
+// initialization expression for a variable V1 depends upon another
+// variable V2 then we initialize V1 after V2.
+
+static void
+sort_var_inits(Var_inits* var_inits)
+{
+ Var_inits ready;
+ while (!var_inits->empty())
+ {
+ Var_inits::iterator p1 = var_inits->begin();
+ Named_object* var = p1->var();
+ Expression* init = var->var_value()->init();
+ Block* preinit = var->var_value()->preinit();
+
+ // Start walking through the list to see which variables VAR
+ // needs to wait for. We can skip P1->WAITING variables--that
+ // is the number we've already checked.
+ Var_inits::iterator p2 = p1;
+ ++p2;
+ for (size_t i = p1->waiting(); i > 0; --i)
+ ++p2;
+
+ for (; p2 != var_inits->end(); ++p2)
+ {
+ if (expression_requires(init, preinit, p2->var()))
+ {
+ // Check for cycles.
+ if (expression_requires(p2->var()->var_value()->init(),
+ p2->var()->var_value()->preinit(),
+ var))
+ {
+ error_at(var->location(),
+ ("initialization expressions for %qs and "
+ "%qs depend upon each other"),
+ var->message_name().c_str(),
+ p2->var()->message_name().c_str());
+ inform(p2->var()->location(), "%qs defined here",
+ p2->var()->message_name().c_str());
+ p2 = var_inits->end();
+ }
+ else
+ {
+ // We can't emit P1 until P2 is emitted. Move P1.
+ // Note that the WAITING loop always executes at
+ // least once, which is what we want.
+ p2->increment_waiting();
+ Var_inits::iterator p3 = p2;
+ for (size_t i = p2->waiting(); i > 0; --i)
+ ++p3;
+ var_inits->splice(p3, *var_inits, p1);
+ }
+ break;
+ }
+ }
+
+ if (p2 == var_inits->end())
+ {
+ // VAR does not depends upon any other initialization expressions.
+
+ // Check for a loop of VAR on itself. We only do this if
+ // INIT is not NULL; when INIT is NULL, it means that
+ // PREINIT sets VAR, which we will interpret as a loop.
+ if (init != NULL && expression_requires(init, preinit, var))
+ error_at(var->location(),
+ "initialization expression for %qs depends upon itself",
+ var->message_name().c_str());
+ ready.splice(ready.end(), *var_inits, p1);
+ }
+ }
+
+ // Now READY is the list in the desired initialization order.
+ var_inits->swap(ready);
+}
+
+// Write out the global definitions.
+
+void
+Gogo::write_globals()
+{
+ this->convert_named_types();
+ this->build_interface_method_tables();
+
+ Bindings* bindings = this->current_bindings();
+ size_t count = bindings->size_definitions();
+
+ tree* vec = new tree[count];
+
+ tree init_fndecl = NULL_TREE;
+ tree init_stmt_list = NULL_TREE;
+
+ if (this->is_main_package())
+ this->init_imports(&init_stmt_list);
+
+ // A list of variable initializations.
+ Var_inits var_inits;
+
+ // A list of variables which need to be registered with the garbage
+ // collector.
+ std::vector<Named_object*> var_gc;
+ var_gc.reserve(count);
+
+ tree var_init_stmt_list = NULL_TREE;
+ size_t i = 0;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p, ++i)
+ {
+ Named_object* no = *p;
+
+ go_assert(!no->is_type_declaration() && !no->is_function_declaration());
+ // There is nothing to do for a package.
+ if (no->is_package())
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing to do for an object which was imported from
+ // a different package into the global scope.
+ if (no->package() != NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing useful we can output for constants which
+ // have ideal or non-integeral type.
+ if (no->is_const())
+ {
+ Type* type = no->const_value()->type();
+ if (type == NULL)
+ type = no->const_value()->expr()->type();
+ if (type->is_abstract() || type->integer_type() == NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+ }
+
+ if (!no->is_variable())
+ {
+ vec[i] = no->get_tree(this, NULL);
+ if (vec[i] == error_mark_node)
+ {
+ go_assert(saw_errors());
+ --i;
+ --count;
+ continue;
+ }
+ }
+ else
+ {
+ Bvariable* var = no->get_backend_variable(this, NULL);
+ vec[i] = var_to_tree(var);
+ if (vec[i] == error_mark_node)
+ {
+ go_assert(saw_errors());
+ --i;
+ --count;
+ continue;
+ }
+
+ // Check for a sink variable, which may be used to run an
+ // initializer purely for its side effects.
+ bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
+
+ tree var_init_tree = NULL_TREE;
+ if (!no->var_value()->has_pre_init())
+ {
+ tree init = no->var_value()->get_init_tree(this, NULL);
+ if (init == error_mark_node)
+ go_assert(saw_errors());
+ else if (init == NULL_TREE)
+ ;
+ else if (TREE_CONSTANT(init))
+ this->backend()->global_variable_set_init(var,
+ tree_to_expr(init));
+ else if (is_sink)
+ var_init_tree = init;
+ else
+ var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
+ void_type_node, vec[i], init);
+ }
+ else
+ {
+ // We are going to create temporary variables which
+ // means that we need an fndecl.
+ if (init_fndecl == NULL_TREE)
+ init_fndecl = this->initialization_function_decl();
+ current_function_decl = init_fndecl;
+ if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
+ push_struct_function(init_fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
+
+ tree var_decl = is_sink ? NULL_TREE : vec[i];
+ var_init_tree = no->var_value()->get_init_block(this, NULL,
+ var_decl);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+
+ if (var_init_tree != NULL_TREE && var_init_tree != error_mark_node)
+ {
+ if (no->var_value()->init() == NULL
+ && !no->var_value()->has_pre_init())
+ append_to_statement_list(var_init_tree, &var_init_stmt_list);
+ else
+ var_inits.push_back(Var_init(no, var_init_tree));
+ }
+
+ if (!is_sink && no->var_value()->type()->has_pointer())
+ var_gc.push_back(no);
+ }
+ }
+
+ // Register global variables with the garbage collector.
+ this->register_gc_vars(var_gc, &init_stmt_list);
+
+ // Simple variable initializations, after all variables are
+ // registered.
+ append_to_statement_list(var_init_stmt_list, &init_stmt_list);
+
+ // Complex variable initializations, first sorting them into a
+ // workable order.
+ if (!var_inits.empty())
+ {
+ sort_var_inits(&var_inits);
+ for (Var_inits::const_iterator p = var_inits.begin();
+ p != var_inits.end();
+ ++p)
+ append_to_statement_list(p->init(), &init_stmt_list);
+ }
+
+ // After all the variables are initialized, call the "init"
+ // functions if there are any.
+ for (std::vector<Named_object*>::const_iterator p =
+ this->init_functions_.begin();
+ p != this->init_functions_.end();
+ ++p)
+ {
+ tree decl = (*p)->get_tree(this, NULL);
+ tree call = build_call_expr(decl, 0);
+ append_to_statement_list(call, &init_stmt_list);
+ }
+
+ // Set up a magic function to do all the initialization actions.
+ // This will be called if this package is imported.
+ if (init_stmt_list != NULL_TREE
+ || this->need_init_fn_
+ || this->is_main_package())
+ this->write_initialization_function(init_fndecl, init_stmt_list);
+
+ // Pass everything back to the middle-end.
+
+ wrapup_global_declarations(vec, count);
+
+ cgraph_finalize_compilation_unit();
+
+ check_global_declarations(vec, count);
+ emit_debug_global_declarations(vec, count);
+
+ delete[] vec;
+}
+
+// Get a tree for the identifier for a named object.
+
+tree
+Named_object::get_id(Gogo* gogo)
+{
+ go_assert(!this->is_variable() && !this->is_result_variable());
+ std::string decl_name;
+ if (this->is_function_declaration()
+ && !this->func_declaration_value()->asm_name().empty())
+ decl_name = this->func_declaration_value()->asm_name();
+ else if (this->is_type()
+ && this->type_value()->location() == BUILTINS_LOCATION)
+ {
+ // We don't need the package name for builtin types.
+ decl_name = Gogo::unpack_hidden_name(this->name_);
+ }
+ else
+ {
+ std::string package_name;
+ if (this->package_ == NULL)
+ package_name = gogo->package_name();
+ else
+ package_name = this->package_->name();
+
+ decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
+
+ Function_type* fntype;
+ if (this->is_function())
+ fntype = this->func_value()->type();
+ else if (this->is_function_declaration())
+ fntype = this->func_declaration_value()->type();
+ else
+ fntype = NULL;
+ if (fntype != NULL && fntype->is_method())
+ {
+ decl_name.push_back('.');
+ decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
+ }
+ }
+ if (this->is_type())
+ {
+ const Named_object* in_function = this->type_value()->in_function();
+ if (in_function != NULL)
+ decl_name += '$' + in_function->name();
+ }
+ return get_identifier_from_string(decl_name);
+}
+
+// Get a tree for a named object.
+
+tree
+Named_object::get_tree(Gogo* gogo, Named_object* function)
+{
+ if (this->tree_ != NULL_TREE)
+ return this->tree_;
+
+ tree name;
+ if (this->classification_ == NAMED_OBJECT_TYPE)
+ name = NULL_TREE;
+ else
+ name = this->get_id(gogo);
+ tree decl;
+ switch (this->classification_)
+ {
+ case NAMED_OBJECT_CONST:
+ {
+ Named_constant* named_constant = this->u_.const_value;
+ Translate_context subcontext(gogo, function, NULL, NULL);
+ tree expr_tree = named_constant->expr()->get_tree(&subcontext);
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ Type* type = named_constant->type();
+ if (type != NULL && !type->is_abstract())
+ {
+ if (!type->is_error())
+ expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
+ else
+ expr_tree = error_mark_node;
+ }
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ {
+ decl = build_decl(named_constant->location(), CONST_DECL,
+ name, TREE_TYPE(expr_tree));
+ DECL_INITIAL(decl) = expr_tree;
+ TREE_CONSTANT(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ }
+ else
+ {
+ // A CONST_DECL is only for an enum constant, so we
+ // shouldn't use for non-integral types. Instead we
+ // just return the constant itself, rather than a
+ // decl.
+ decl = expr_tree;
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ {
+ Named_type* named_type = this->u_.type_value;
+ tree type_tree = named_type->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ decl = TYPE_NAME(type_tree);
+ go_assert(decl != NULL_TREE);
+
+ // We need to produce a type descriptor for every named
+ // type, and for a pointer to every named type, since
+ // other files or packages might refer to them. We need
+ // to do this even for hidden types, because they might
+ // still be returned by some function. Simply calling the
+ // type_descriptor method is enough to create the type
+ // descriptor, even though we don't do anything with it.
+ if (this->package_ == NULL)
+ {
+ named_type->type_descriptor_pointer(gogo);
+ Type* pn = Type::make_pointer_type(named_type);
+ pn->type_descriptor_pointer(gogo);
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error("reference to undefined type %qs",
+ this->message_name().c_str());
+ return error_mark_node;
+
+ case NAMED_OBJECT_VAR:
+ case NAMED_OBJECT_RESULT_VAR:
+ case NAMED_OBJECT_SINK:
+ go_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ {
+ Function* func = this->u_.func_value;
+ decl = func->get_or_make_decl(gogo, this, name);
+ if (decl != error_mark_node)
+ {
+ if (func->block() != NULL)
+ {
+ if (DECL_STRUCT_FUNCTION(decl) == NULL)
+ push_struct_function(decl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(decl));
+
+ cfun->function_end_locus = func->block()->end_location();
+
+ current_function_decl = decl;
+
+ func->build_tree(gogo, this);
+
+ gimplify_function_tree(decl);
+
+ cgraph_finalize_function(decl, true);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+ }
+ }
+ break;
+
+ default:
+ go_unreachable();
+ }
+
+ if (TREE_TYPE(decl) == error_mark_node)
+ decl = error_mark_node;
+
+ tree ret = decl;
+
+ this->tree_ = ret;
+
+ if (ret != error_mark_node)
+ go_preserve_from_gc(ret);
+
+ return ret;
+}
+
+// Get the initial value of a variable as a tree. This does not
+// consider whether the variable is in the heap--it returns the
+// initial value as though it were always stored in the stack.
+
+tree
+Variable::get_init_tree(Gogo* gogo, Named_object* function)
+{
+ go_assert(this->preinit_ == NULL);
+ if (this->init_ == NULL)
+ {
+ go_assert(!this->is_parameter_);
+ return this->type_->get_init_tree(gogo,
+ (this->is_global_
+ || this->is_in_heap()));
+ }
+ else
+ {
+ Translate_context context(gogo, function, NULL, NULL);
+ tree rhs_tree = this->init_->get_tree(&context);
+ return Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree, this->location());
+ }
+}
+
+// Get the initial value of a variable when a block is required.
+// VAR_DECL is the decl to set; it may be NULL for a sink variable.
+
+tree
+Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
+{
+ go_assert(this->preinit_ != NULL);
+
+ // We want to add the variable assignment to the end of the preinit
+ // block. The preinit block may have a TRY_FINALLY_EXPR and a
+ // TRY_CATCH_EXPR; if it does, we want to add to the end of the
+ // regular statements.
+
+ Translate_context context(gogo, function, NULL, NULL);
+ Bblock* bblock = this->preinit_->get_backend(&context);
+ tree block_tree = block_to_tree(bblock);
+ if (block_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(block_tree) == BIND_EXPR);
+ tree statements = BIND_EXPR_BODY(block_tree);
+ while (statements != NULL_TREE
+ && (TREE_CODE(statements) == TRY_FINALLY_EXPR
+ || TREE_CODE(statements) == TRY_CATCH_EXPR))
+ statements = TREE_OPERAND(statements, 0);
+
+ // It's possible to have pre-init statements without an initializer
+ // if the pre-init statements set the variable.
+ if (this->init_ != NULL)
+ {
+ tree rhs_tree = this->init_->get_tree(&context);
+ if (rhs_tree == error_mark_node)
+ return error_mark_node;
+ if (var_decl == NULL_TREE)
+ append_to_statement_list(rhs_tree, &statements);
+ else
+ {
+ tree val = Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree,
+ this->location());
+ if (val == error_mark_node)
+ return error_mark_node;
+ tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
+ void_type_node, var_decl, val);
+ append_to_statement_list(set, &statements);
+ }
+ }
+
+ return block_tree;
+}
+
+// Get a tree for a function decl.
+
+tree
+Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ tree functype = this->type_->get_tree(gogo);
+ if (functype == error_mark_node)
+ this->fndecl_ = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ go_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+
+ this->fndecl_ = decl;
+
+ if (no->package() != NULL)
+ ;
+ else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "init"
+ && !this->type_->is_method())
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "main"
+ && gogo->is_main_package())
+ TREE_PUBLIC(decl) = 1;
+ // Methods have to be public even if they are hidden because
+ // they can be pulled into type descriptors when using
+ // anonymous fields.
+ else if (!Gogo::is_hidden_name(no->name())
+ || this->type_->is_method())
+ {
+ TREE_PUBLIC(decl) = 1;
+ std::string asm_name = gogo->unique_prefix();
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+
+ // Why do we have to do this in the frontend?
+ tree restype = TREE_TYPE(functype);
+ tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
+ restype);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_IGNORED_P(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = decl;
+ DECL_RESULT(decl) = resdecl;
+
+ if (this->enclosing_ != NULL)
+ DECL_STATIC_CHAIN(decl) = 1;
+
+ // If a function calls the predeclared recover function, we
+ // can't inline it, because recover behaves differently in a
+ // function passed directly to defer.
+ if (this->calls_recover_ && !this->is_recover_thunk_)
+ DECL_UNINLINABLE(decl) = 1;
+
+ // If this is a thunk created to call a function which calls
+ // the predeclared recover function, we need to disable
+ // stack splitting for the thunk.
+ if (this->is_recover_thunk_)
+ {
+ tree attr = get_identifier("__no_split_stack__");
+ DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
+ }
+
+ go_preserve_from_gc(decl);
+
+ if (this->closure_var_ != NULL)
+ {
+ push_struct_function(decl);
+
+ Bvariable* bvar = this->closure_var_->get_backend_variable(gogo,
+ no);
+ tree closure_decl = var_to_tree(bvar);
+ if (closure_decl == error_mark_node)
+ this->fndecl_ = error_mark_node;
+ else
+ {
+ DECL_ARTIFICIAL(closure_decl) = 1;
+ DECL_IGNORED_P(closure_decl) = 1;
+ TREE_USED(closure_decl) = 1;
+ DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
+ TREE_READONLY(closure_decl) = 1;
+
+ DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
+ }
+
+ pop_cfun();
+ }
+ }
+ }
+ return this->fndecl_;
+}
+
+// Get a tree for a function declaration.
+
+tree
+Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ // Let Go code use an asm declaration to pick up a builtin
+ // function.
+ if (!this->asm_name_.empty())
+ {
+ std::map<std::string, tree>::const_iterator p =
+ builtin_functions.find(this->asm_name_);
+ if (p != builtin_functions.end())
+ {
+ this->fndecl_ = p->second;
+ return this->fndecl_;
+ }
+ }
+
+ tree functype = this->fntype_->get_tree(gogo);
+ tree decl;
+ if (functype == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ go_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+
+ if (this->asm_name_.empty())
+ {
+ std::string asm_name = (no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+ }
+ this->fndecl_ = decl;
+ go_preserve_from_gc(decl);
+ }
+ return this->fndecl_;
+}
+
+// We always pass the receiver to a method as a pointer. If the
+// receiver is actually declared as a non-pointer type, then we copy
+// the value into a local variable, so that it has the right type. In
+// this function we create the real PARM_DECL to use, and set
+// DEC_INITIAL of the var_decl to be the value passed in.
+
+tree
+Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
+{
+ if (var_decl == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(var_decl) == VAR_DECL);
+ tree val_type = TREE_TYPE(var_decl);
+ bool is_in_heap = no->var_value()->is_in_heap();
+ if (is_in_heap)
+ {
+ go_assert(POINTER_TYPE_P(val_type));
+ val_type = TREE_TYPE(val_type);
+ }
+
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".pointer";
+ tree id = get_identifier_from_string(name);
+ tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
+
+ go_assert(DECL_INITIAL(var_decl) == NULL_TREE);
+ // The receiver might be passed as a null pointer.
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node, parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
+ TREE_THIS_NOTRAP(ind) = 1;
+ tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
+ tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
+ check, ind, zero_init);
+
+ if (is_in_heap)
+ {
+ tree size = TYPE_SIZE_UNIT(val_type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size,
+ no->location());
+ space = save_expr(space);
+ space = fold_convert(build_pointer_type(val_type), space);
+ tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node,
+ parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree parmref = build_fold_indirect_ref_loc(no->location(), parm_decl);
+ TREE_THIS_NOTRAP(parmref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, parmref);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ check, set, NULL_TREE),
+ space);
+ }
+
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// If we take the address of a parameter, then we need to copy it into
+// the heap. We will access it as a local variable via an
+// indirection.
+
+tree
+Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree var_decl)
+{
+ if (var_decl == error_mark_node)
+ return error_mark_node;
+ go_assert(TREE_CODE(var_decl) == VAR_DECL);
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".param";
+ tree id = get_identifier_from_string(name);
+
+ tree type = TREE_TYPE(var_decl);
+ go_assert(POINTER_TYPE_P(type));
+ type = TREE_TYPE(type);
+
+ tree parm_decl = build_decl(loc, PARM_DECL, id, type);
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = type;
+
+ tree size = TYPE_SIZE_UNIT(type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
+ space = save_expr(space);
+ space = fold_convert(TREE_TYPE(var_decl), space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
+ space);
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// Get a tree for function code.
+
+void
+Function::build_tree(Gogo* gogo, Named_object* named_function)
+{
+ tree fndecl = this->fndecl_;
+ go_assert(fndecl != NULL_TREE);
+
+ tree params = NULL_TREE;
+ tree* pp = ¶ms;
+
+ tree declare_vars = NULL_TREE;
+ for (Bindings::const_definitions_iterator p =
+ this->block_->bindings()->begin_definitions();
+ p != this->block_->bindings()->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
+ {
+ Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
+ *pp = var_to_tree(bvar);
+
+ // We always pass the receiver to a method as a pointer. If
+ // the receiver is declared as a non-pointer type, then we
+ // copy the value into a local variable.
+ if ((*p)->var_value()->is_receiver()
+ && (*p)->var_value()->type()->points_to() == NULL)
+ {
+ tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
+ tree var = *pp;
+ if (var != error_mark_node)
+ {
+ go_assert(TREE_CODE(var) == VAR_DECL);
+ DECL_CHAIN(var) = declare_vars;
+ declare_vars = var;
+ }
+ *pp = parm_decl;
+ }
+ else if ((*p)->var_value()->is_in_heap())
+ {
+ // If we take the address of a parameter, then we need
+ // to copy it into the heap.
+ tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
+ tree var = *pp;
+ if (var != error_mark_node)
+ {
+ go_assert(TREE_CODE(var) == VAR_DECL);
+ DECL_CHAIN(var) = declare_vars;
+ declare_vars = var;
+ }
+ *pp = parm_decl;
+ }
+
+ if (*pp != error_mark_node)
+ {
+ go_assert(TREE_CODE(*pp) == PARM_DECL);
+ pp = &DECL_CHAIN(*pp);
+ }
+ }
+ else if ((*p)->is_result_variable())
+ {
+ Bvariable* bvar = (*p)->get_backend_variable(gogo, named_function);
+ tree var_decl = var_to_tree(bvar);
+
+ Type* type = (*p)->result_var_value()->type();
+ tree init;
+ if (!(*p)->result_var_value()->is_in_heap())
+ init = type->get_init_tree(gogo, false);
+ else
+ {
+ source_location loc = (*p)->location();
+ tree type_tree = type->get_tree(gogo);
+ tree space = gogo->allocate_memory(type,
+ TYPE_SIZE_UNIT(type_tree),
+ loc);
+ tree ptr_type_tree = build_pointer_type(type_tree);
+ tree subinit = type->get_init_tree(gogo, true);
+ if (subinit == NULL_TREE)
+ init = fold_convert_loc(loc, ptr_type_tree, space);
+ else
+ {
+ space = save_expr(space);
+ space = fold_convert_loc(loc, ptr_type_tree, space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, subinit);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ set, space);
+ }
+ }
+
+ if (var_decl != error_mark_node)
+ {
+ go_assert(TREE_CODE(var_decl) == VAR_DECL);
+ DECL_INITIAL(var_decl) = init;
+ DECL_CHAIN(var_decl) = declare_vars;
+ declare_vars = var_decl;
+ }
+ }
+ }
+ *pp = NULL_TREE;
+
+ DECL_ARGUMENTS(fndecl) = params;
+
+ if (this->block_ != NULL)
+ {
+ go_assert(DECL_INITIAL(fndecl) == NULL_TREE);
+
+ // Declare variables if necessary.
+ tree bind = NULL_TREE;
+ tree defer_init = NULL_TREE;
+ if (declare_vars != NULL_TREE || this->defer_stack_ != NULL)
+ {
+ tree block = make_node(BLOCK);
+ BLOCK_SUPERCONTEXT(block) = fndecl;
+ DECL_INITIAL(fndecl) = block;
+ BLOCK_VARS(block) = declare_vars;
+ TREE_USED(block) = 1;
+
+ bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
+ NULL_TREE, block);
+ TREE_SIDE_EFFECTS(bind) = 1;
+
+ if (this->defer_stack_ != NULL)
+ {
+ Translate_context dcontext(gogo, named_function, this->block_,
+ tree_to_block(bind));
+ Bstatement* bdi = this->defer_stack_->get_backend(&dcontext);
+ defer_init = stat_to_tree(bdi);
+ }
+ }
+
+ // Build the trees for all the statements in the function.
+ Translate_context context(gogo, named_function, NULL, NULL);
+ Bblock* bblock = this->block_->get_backend(&context);
+ tree code = block_to_tree(bblock);
+
+ tree init = NULL_TREE;
+ tree except = NULL_TREE;
+ tree fini = NULL_TREE;
+
+ // Initialize variables if necessary.
+ for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
+ {
+ tree dv = build1(DECL_EXPR, void_type_node, v);
+ SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
+ append_to_statement_list(dv, &init);
+ }
+
+ // If we have a defer stack, initialize it at the start of a
+ // function.
+ if (defer_init != NULL_TREE && defer_init != error_mark_node)
+ {
+ SET_EXPR_LOCATION(defer_init, this->block_->start_location());
+ append_to_statement_list(defer_init, &init);
+
+ // Clean up the defer stack when we leave the function.
+ this->build_defer_wrapper(gogo, named_function, &except, &fini);
+ }
+
+ if (code != NULL_TREE && code != error_mark_node)
+ {
+ if (init != NULL_TREE)
+ code = build2(COMPOUND_EXPR, void_type_node, init, code);
+ if (except != NULL_TREE)
+ code = build2(TRY_CATCH_EXPR, void_type_node, code,
+ build2(CATCH_EXPR, void_type_node, NULL, except));
+ if (fini != NULL_TREE)
+ code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
+ }
+
+ // Stick the code into the block we built for the receiver, if
+ // we built on.
+ if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
+ {
+ BIND_EXPR_BODY(bind) = code;
+ code = bind;
+ }
+
+ DECL_SAVED_TREE(fndecl) = code;
+ }
+}
+
+// Build the wrappers around function code needed if the function has
+// any defer statements. This sets *EXCEPT to an exception handler
+// and *FINI to a finally handler.
+
+void
+Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
+ tree *except, tree *fini)
+{
+ source_location end_loc = this->block_->end_location();
+
+ // Add an exception handler. This is used if a panic occurs. Its
+ // purpose is to stop the stack unwinding if a deferred function
+ // calls recover. There are more details in
+ // libgo/runtime/go-unwind.c.
+
+ tree stmt_list = NULL_TREE;
+
+ Expression* call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
+ this->defer_stack(end_loc));
+ Translate_context context(gogo, named_function, NULL, NULL);
+ tree call_tree = call->get_tree(&context);
+ if (call_tree != error_mark_node)
+ append_to_statement_list(call_tree, &stmt_list);
+
+ tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
+ tree set;
+ if (retval == NULL_TREE)
+ set = NULL_TREE;
+ else
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+
+ go_assert(*except == NULL_TREE);
+ *except = stmt_list;
+
+ // Add some finally code to run the defer functions. This is used
+ // both in the normal case, when no panic occurs, and also if a
+ // panic occurs to run any further defer functions. Of course, it
+ // is possible for a defer function to call panic which should be
+ // caught by another defer function. To handle that we use a loop.
+ // finish:
+ // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
+ // if (return values are named) return named_vals;
+
+ stmt_list = NULL;
+
+ tree label = create_artificial_label(end_loc);
+ tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
+ label);
+ append_to_statement_list(define_label, &stmt_list);
+
+ call = Runtime::make_call(Runtime::UNDEFER, end_loc, 1,
+ this->defer_stack(end_loc));
+ tree undefer = call->get_tree(&context);
+
+ call = Runtime::make_call(Runtime::CHECK_DEFER, end_loc, 1,
+ this->defer_stack(end_loc));
+ tree defer = call->get_tree(&context);
+
+ if (undefer == error_mark_node || defer == error_mark_node)
+ return;
+
+ tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
+ tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
+ catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
+ tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
+
+ append_to_statement_list(try_catch, &stmt_list);
+
+ if (this->type_->results() != NULL
+ && !this->type_->results()->empty()
+ && !this->type_->results()->front().name().empty())
+ {
+ // If the result variables are named, we need to return them
+ // again, because they might have been changed by a defer
+ // function.
+ retval = this->return_value(gogo, named_function, end_loc,
+ &stmt_list);
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+ }
+
+ go_assert(*fini == NULL_TREE);
+ *fini = stmt_list;
+}
+
+// Return the value to assign to DECL_RESULT(this->fndecl_). This may
+// also add statements to STMT_LIST, which need to be executed before
+// the assignment. This is used for a return statement with no
+// explicit values.
+
+tree
+Function::return_value(Gogo* gogo, Named_object* named_function,
+ source_location location, tree* stmt_list) const
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL || results->empty())
+ return NULL_TREE;
+
+ go_assert(this->results_ != NULL);
+ if (this->results_->size() != results->size())
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ tree retval;
+ if (results->size() == 1)
+ {
+ Bvariable* bvar =
+ this->results_->front()->get_backend_variable(gogo,
+ named_function);
+ tree ret = var_to_tree(bvar);
+ if (this->results_->front()->result_var_value()->is_in_heap())
+ ret = build_fold_indirect_ref_loc(location, ret);
+ return ret;
+ }
+ else
+ {
+ tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
+ retval = create_tmp_var(rettype, "RESULT");
+ tree field = TYPE_FIELDS(rettype);
+ int index = 0;
+ for (Typed_identifier_list::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++index, field = DECL_CHAIN(field))
+ {
+ go_assert(field != NULL);
+ Named_object* no = (*this->results_)[index];
+ Bvariable* bvar = no->get_backend_variable(gogo, named_function);
+ tree val = var_to_tree(bvar);
+ if (no->result_var_value()->is_in_heap())
+ val = build_fold_indirect_ref_loc(location, val);
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ build3(COMPONENT_REF, TREE_TYPE(field),
+ retval, field, NULL_TREE),
+ val);
+ append_to_statement_list(set, stmt_list);
+ }
+ return retval;
+ }
+}
+
+// Return the integer type to use for a size.
+
+GO_EXTERN_C
+tree
+go_type_for_size(unsigned int bits, int unsignedp)
+{
+ const char* name;
+ switch (bits)
+ {
+ case 8:
+ name = unsignedp ? "uint8" : "int8";
+ break;
+ case 16:
+ name = unsignedp ? "uint16" : "int16";
+ break;
+ case 32:
+ name = unsignedp ? "uint32" : "int32";
+ break;
+ case 64:
+ name = unsignedp ? "uint64" : "int64";
+ break;
+ default:
+ if (bits == POINTER_SIZE && unsignedp)
+ name = "uintptr";
+ else
+ return NULL_TREE;
+ }
+ Type* type = Type::lookup_integer_type(name);
+ return type->get_tree(go_get_gogo());
+}
+
+// Return the type to use for a mode.
+
+GO_EXTERN_C
+tree
+go_type_for_mode(enum machine_mode mode, int unsignedp)
+{
+ // FIXME: This static_cast should be in machmode.h.
+ enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
+ if (mc == MODE_INT)
+ return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
+ else if (mc == MODE_FLOAT)
+ {
+ Type* type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 32:
+ type = Type::lookup_float_type("float32");
+ break;
+ case 64:
+ type = Type::lookup_float_type("float64");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(long_double_type_node))
+ return long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->float_type()->type_tree();
+ }
+ else if (mc == MODE_COMPLEX_FLOAT)
+ {
+ Type *type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 64:
+ type = Type::lookup_complex_type("complex64");
+ break;
+ case 128:
+ type = Type::lookup_complex_type("complex128");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(complex_long_double_type_node))
+ return complex_long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->complex_type()->type_tree();
+ }
+ else
+ return NULL_TREE;
+}
+
+// Return a tree which allocates SIZE bytes which will holds value of
+// type TYPE.
+
+tree
+Gogo::allocate_memory(Type* type, tree size, source_location location)
+{
+ // If the package imports unsafe, then it may play games with
+ // pointers that look like integers.
+ if (this->imported_unsafe_ || type->has_pointer())
+ {
+ static tree new_fndecl;
+ return Gogo::call_builtin(&new_fndecl,
+ location,
+ "__go_new",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+ else
+ {
+ static tree new_nopointers_fndecl;
+ return Gogo::call_builtin(&new_nopointers_fndecl,
+ location,
+ "__go_new_nopointers",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+}
+
+// Build a builtin struct with a list of fields. The name is
+// STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
+// node; this exists so that the struct can have fields which point to
+// itself. If PTYPE is not NULL, store the result in *PTYPE. There
+// are NFIELDS fields. Each field is a name (a const char*) followed
+// by a type (a tree).
+
+tree
+Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...)
+{
+ if (ptype != NULL && *ptype != NULL_TREE)
+ return *ptype;
+
+ va_list ap;
+ va_start(ap, nfields);
+
+ tree fields = NULL_TREE;
+ for (int i = 0; i < nfields; ++i)
+ {
+ const char* field_name = va_arg(ap, const char*);
+ tree type = va_arg(ap, tree);
+ if (type == error_mark_node)
+ {
+ if (ptype != NULL)
+ *ptype = error_mark_node;
+ return error_mark_node;
+ }
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
+ get_identifier(field_name), type);
+ DECL_CHAIN(field) = fields;
+ fields = field;
+ }
+
+ va_end(ap);
+
+ if (struct_type == NULL_TREE)
+ struct_type = make_node(RECORD_TYPE);
+ finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
+
+ if (ptype != NULL)
+ {
+ go_preserve_from_gc(struct_type);
+ *ptype = struct_type;
+ }
+
+ return struct_type;
+}
+
+// Return a type to use for pointer to const char for a string.
+
+tree
+Gogo::const_char_pointer_type_tree()
+{
+ static tree type;
+ if (type == NULL_TREE)
+ {
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ type = build_pointer_type(const_char_type);
+ go_preserve_from_gc(type);
+ }
+ return type;
+}
+
+// Return a tree for a string constant.
+
+tree
+Gogo::string_constant_tree(const std::string& val)
+{
+ tree index_type = build_index_type(size_int(val.length()));
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ tree string_type = build_array_type(const_char_type, index_type);
+ string_type = build_variant_type_copy(string_type);
+ TYPE_STRING_FLAG(string_type) = 1;
+ tree string_val = build_string(val.length(), val.data());
+ TREE_TYPE(string_val) = string_type;
+ return string_val;
+}
+
+// Return a tree for a Go string constant.
+
+tree
+Gogo::go_string_constant_tree(const std::string& val)
+{
+ tree string_type = Type::make_string_type()->get_tree(this);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(string_type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
+ elt->index = field;
+ tree str = Gogo::string_constant_tree(val);
+ elt->value = fold_convert(TREE_TYPE(field),
+ build_fold_addr_expr(str));
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
+ elt->index = field;
+ elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
+
+ tree constructor = build_constructor(string_type, init);
+ TREE_READONLY(constructor) = 1;
+ TREE_CONSTANT(constructor) = 1;
+
+ return constructor;
+}
+
+// Return a tree for a pointer to a Go string constant. This is only
+// used for type descriptors, so we return a pointer to a constant
+// decl.
+
+tree
+Gogo::ptr_go_string_constant_tree(const std::string& val)
+{
+ tree pval = this->go_string_constant_tree(val);
+
+ tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
+ create_tmp_var_name("SP"), TREE_TYPE(pval));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = pval;
+ rest_of_decl_compilation(decl, 1, 0);
+
+ return build_fold_addr_expr(decl);
+}
+
+// Build the type of the struct that holds a slice for the given
+// element type.
+
+tree
+Gogo::slice_type_tree(tree element_type_tree)
+{
+ // We use int for the count and capacity fields in a slice header.
+ // This matches 6g. The language definition guarantees that we
+ // can't allocate space of a size which does not fit in int
+ // anyhow. FIXME: integer_type_node is the the C type "int" but is
+ // not necessarily the Go type "int". They will differ when the C
+ // type "int" has fewer than 32 bits.
+ return Gogo::builtin_struct(NULL, "__go_slice", NULL_TREE, 3,
+ "__values",
+ build_pointer_type(element_type_tree),
+ "__count",
+ integer_type_node,
+ "__capacity",
+ integer_type_node);
+}
+
+// Given the tree for a slice type, return the tree for the type of
+// the elements of the slice.
+
+tree
+Gogo::slice_element_type_tree(tree slice_type_tree)
+{
+ go_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE
+ && POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree))));
+ return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree)));
+}
+
+// Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+// the slice. VALUES is the value pointer and COUNT is the number of
+// entries. If CAPACITY is not NULL, it is the capacity; otherwise
+// the capacity and the count are the same.
+
+tree
+Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity)
+{
+ go_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ tree field = TYPE_FIELDS(slice_type_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ go_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(values)));
+ elt->value = values;
+
+ count = fold_convert(sizetype, count);
+ if (capacity == NULL_TREE)
+ {
+ count = save_expr(count);
+ capacity = count;
+ }
+
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), count);
+
+ field = DECL_CHAIN(field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), capacity);
+
+ return build_constructor(slice_type_tree, init);
+}
+
+// Build a constructor for an empty slice.
+
+tree
+Gogo::empty_slice_constructor(tree slice_type_tree)
+{
+ tree element_field = TYPE_FIELDS(slice_type_tree);
+ tree ret = Gogo::slice_constructor(slice_type_tree,
+ fold_convert(TREE_TYPE(element_field),
+ null_pointer_node),
+ size_zero_node,
+ size_zero_node);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Build a map descriptor for a map of type MAPTYPE.
+
+tree
+Gogo::map_descriptor(Map_type* maptype)
+{
+ if (this->map_descriptors_ == NULL)
+ this->map_descriptors_ = new Map_descriptors(10);
+
+ std::pair<const Map_type*, tree> val(maptype, NULL);
+ std::pair<Map_descriptors::iterator, bool> ins =
+ this->map_descriptors_->insert(val);
+ Map_descriptors::iterator p = ins.first;
+ if (!ins.second)
+ {
+ if (p->second == error_mark_node)
+ return error_mark_node;
+ go_assert(p->second != NULL_TREE && DECL_P(p->second));
+ return build_fold_addr_expr(p->second);
+ }
+
+ Type* keytype = maptype->key_type();
+ Type* valtype = maptype->val_type();
+
+ std::string mangled_name = ("__go_map_" + maptype->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // Get the type of the map descriptor. This is __go_map_descriptor
+ // in libgo/map.h.
+
+ tree struct_type = this->map_descriptor_type();
+
+ // The map entry type is a struct with three fields. This struct is
+ // specific to MAPTYPE. Build it.
+
+ tree map_entry_type = make_node(RECORD_TYPE);
+
+ map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
+ "__next",
+ build_pointer_type(map_entry_type),
+ "__key",
+ keytype->get_tree(this),
+ "__val",
+ valtype->get_tree(this));
+ if (map_entry_type == error_mark_node)
+ {
+ p->second = error_mark_node;
+ return error_mark_node;
+ }
+
+ tree map_entry_key_field = DECL_CHAIN(TYPE_FIELDS(map_entry_type));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field)),
+ "__key") == 0);
+
+ tree map_entry_val_field = DECL_CHAIN(map_entry_key_field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field)),
+ "__val") == 0);
+
+ // Initialize the entries.
+
+ tree map_descriptor_field = TYPE_FIELDS(struct_type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field)),
+ "__map_descriptor") == 0);
+ tree entry_size_field = DECL_CHAIN(map_descriptor_field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field)),
+ "__entry_size") == 0);
+ tree key_offset_field = DECL_CHAIN(entry_size_field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field)),
+ "__key_offset") == 0);
+ tree val_offset_field = DECL_CHAIN(key_offset_field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field)),
+ "__val_offset") == 0);
+
+ VEC(constructor_elt, gc)* descriptor = VEC_alloc(constructor_elt, gc, 6);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = map_descriptor_field;
+ elt->value = maptype->type_descriptor_pointer(this);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = entry_size_field;
+ elt->value = TYPE_SIZE_UNIT(map_entry_type);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = key_offset_field;
+ elt->value = byte_position(map_entry_key_field);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = val_offset_field;
+ elt->value = byte_position(map_entry_val_field);
+
+ tree constructor = build_constructor(struct_type, descriptor);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, struct_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+ p->second = decl;
+
+ return build_fold_addr_expr(decl);
+}
+
+// Return a tree for the type of a map descriptor. This is struct
+// __go_map_descriptor in libgo/runtime/map.h. This is the same for
+// all map types.
+
+tree
+Gogo::map_descriptor_type()
+{
+ static tree struct_type;
+ tree dtype = Type::make_type_descriptor_type()->get_tree(this);
+ dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
+ return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
+ 4,
+ "__map_descriptor",
+ build_pointer_type(dtype),
+ "__entry_size",
+ sizetype,
+ "__key_offset",
+ sizetype,
+ "__val_offset",
+ sizetype);
+}
+
+// Return the name to use for a type descriptor decl for TYPE. This
+// is used when TYPE does not have a name.
+
+std::string
+Gogo::unnamed_type_descriptor_decl_name(const Type* type)
+{
+ return "__go_td_" + type->mangled_name(this);
+}
+
+// Return the name to use for a type descriptor decl for a type named
+// NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
+// normally be NULL.
+
+std::string
+Gogo::type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function)
+{
+ std::string ret = "__go_tdn_";
+ if (no->type_value()->is_builtin())
+ go_assert(in_function == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? this->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? this->package_name()
+ : no->package()->name());
+ ret.append(unique_prefix);
+ ret.append(1, '.');
+ ret.append(package_name);
+ ret.append(1, '.');
+ if (in_function != NULL)
+ {
+ ret.append(Gogo::unpack_hidden_name(in_function->name()));
+ ret.append(1, '.');
+ }
+ }
+ ret.append(no->name());
+ return ret;
+}
+
+// Where a type descriptor decl should be defined.
+
+Gogo::Type_descriptor_location
+Gogo::type_descriptor_location(const Type* type)
+{
+ const Named_type* name = type->named_type();
+ if (name != NULL)
+ {
+ if (name->named_object()->package() != NULL)
+ {
+ // This is a named type defined in a different package. The
+ // descriptor should be defined in that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else if (name->is_builtin())
+ {
+ // We create the descriptor for a builtin type whenever we
+ // need it.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ else
+ {
+ // This is a named type defined in this package. The
+ // descriptor should be defined here.
+ return TYPE_DESCRIPTOR_DEFINED;
+ }
+ }
+ else
+ {
+ if (type->points_to() != NULL
+ && type->points_to()->named_type() != NULL
+ && type->points_to()->named_type()->named_object()->package() != NULL)
+ {
+ // This is an unnamed pointer to a named type defined in a
+ // different package. The descriptor should be defined in
+ // that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else
+ {
+ // This is an unnamed type. The descriptor could be defined
+ // in any package where it is needed, and the linker will
+ // pick one descriptor to keep.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ }
+}
+
+// Build a type descriptor decl for TYPE. INITIALIZER is a struct
+// composite literal which initializers the type descriptor.
+
+void
+Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
+ tree* pdecl)
+{
+ const Named_type* name = type->named_type();
+
+ // We can have multiple instances of unnamed types, but we only want
+ // to emit the type descriptor once. We use a hash table to handle
+ // this. This is not necessary for named types, as they are unique,
+ // and we store the type descriptor decl in the type itself.
+ tree* phash = NULL;
+ if (name == NULL)
+ {
+ if (this->type_descriptor_decls_ == NULL)
+ this->type_descriptor_decls_ = new Type_descriptor_decls(10);
+
+ std::pair<Type_descriptor_decls::iterator, bool> ins =
+ this->type_descriptor_decls_->insert(std::make_pair(type, NULL_TREE));
+ if (!ins.second)
+ {
+ // We've already built a type descriptor for this type.
+ *pdecl = ins.first->second;
+ return;
+ }
+ phash = &ins.first->second;
+ }
+
+ std::string decl_name;
+ if (name == NULL)
+ decl_name = this->unnamed_type_descriptor_decl_name(type);
+ else
+ decl_name = this->type_descriptor_decl_name(name->named_object(),
+ name->in_function());
+ tree id = get_identifier_from_string(decl_name);
+ tree descriptor_type_tree = initializer->type()->get_tree(this);
+ if (descriptor_type_tree == error_mark_node)
+ {
+ *pdecl = error_mark_node;
+ return;
+ }
+ tree decl = build_decl(name == NULL ? BUILTINS_LOCATION : name->location(),
+ VAR_DECL, id,
+ build_qualified_type(descriptor_type_tree,
+ TYPE_QUAL_CONST));
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+
+ go_preserve_from_gc(decl);
+ if (phash != NULL)
+ *phash = decl;
+
+ // We store the new DECL now because we may need to refer to it when
+ // expanding INITIALIZER.
+ *pdecl = decl;
+
+ // If appropriate, just refer to the exported type identifier.
+ Gogo::Type_descriptor_location type_descriptor_location =
+ this->type_descriptor_location(type);
+ if (type_descriptor_location == TYPE_DESCRIPTOR_UNDEFINED)
+ {
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ return;
+ }
+
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+
+ Translate_context context(this, NULL, NULL, NULL);
+ context.set_is_const();
+ tree constructor = initializer->get_tree(&context);
+
+ if (constructor == error_mark_node)
+ go_assert(saw_errors());
+
+ DECL_INITIAL(decl) = constructor;
+
+ if (type_descriptor_location == TYPE_DESCRIPTOR_DEFINED)
+ TREE_PUBLIC(decl) = 1;
+ else
+ {
+ go_assert(type_descriptor_location == TYPE_DESCRIPTOR_COMMON);
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+}
+
+// Build an interface method table for a type: a list of function
+// pointers, one for each interface method. This is used for
+// interfaces.
+
+tree
+Gogo::interface_method_table_for_type(const Interface_type* interface,
+ Named_type* type,
+ bool is_pointer)
+{
+ const Typed_identifier_list* interface_methods = interface->methods();
+ go_assert(!interface_methods->empty());
+
+ std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
+ + interface->mangled_name(this)
+ + "__"
+ + type->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // See whether this interface has any hidden methods.
+ bool has_hidden_methods = false;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->name()))
+ {
+ has_hidden_methods = true;
+ break;
+ }
+ }
+
+ // We already know that the named type is convertible to the
+ // interface. If the interface has hidden methods, and the named
+ // type is defined in a different package, then the interface
+ // conversion table will be defined by that other package.
+ if (has_hidden_methods && type->named_object()->package() != NULL)
+ {
+ tree array_type = build_array_type(const_ptr_type_node, NULL);
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ go_preserve_from_gc(decl);
+ return decl;
+ }
+
+ size_t count = interface_methods->size();
+ VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ // The first element is the type descriptor.
+ constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_zero_node;
+ Type* td_type;
+ if (!is_pointer)
+ td_type = type;
+ else
+ td_type = Type::make_pointer_type(type);
+ elt->value = fold_convert(const_ptr_type_node,
+ td_type->type_descriptor_pointer(this));
+
+ size_t i = 1;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p, ++i)
+ {
+ bool is_ambiguous;
+ Method* m = type->method_function(p->name(), &is_ambiguous);
+ go_assert(m != NULL);
+
+ Named_object* no = m->named_object();
+
+ tree fnid = no->get_id(this);
+
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
+ fnid);
+ else
+ go_unreachable();
+ fndecl = build_fold_addr_expr(fndecl);
+
+ elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_int(i);
+ elt->value = fold_convert(const_ptr_type_node, fndecl);
+ }
+ go_assert(i == count + 1);
+
+ tree array_type = build_array_type(const_ptr_type_node,
+ build_index_type(size_int(count)));
+ tree constructor = build_constructor(array_type, pointers);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+
+ // If the interface type has hidden methods, then this is the only
+ // definition of the table. Otherwise it is a comdat table which
+ // may be defined in multiple packages.
+ if (has_hidden_methods)
+ TREE_PUBLIC(decl) = 1;
+ else
+ {
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+
+ return decl;
+}
+
+// Mark a function as a builtin library function.
+
+void
+Gogo::mark_fndecl_as_builtin_library(tree fndecl)
+{
+ DECL_EXTERNAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_NOTHROW(fndecl) = 1;
+ DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
+}
+
+// Build a call to a builtin function.
+
+tree
+Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
+ int nargs, tree rettype, ...)
+{
+ if (rettype == error_mark_node)
+ return error_mark_node;
+
+ tree* types = new tree[nargs];
+ tree* args = new tree[nargs];
+
+ va_list ap;
+ va_start(ap, rettype);
+ for (int i = 0; i < nargs; ++i)
+ {
+ types[i] = va_arg(ap, tree);
+ args[i] = va_arg(ap, tree);
+ if (types[i] == error_mark_node || args[i] == error_mark_node)
+ {
+ delete[] types;
+ delete[] args;
+ return error_mark_node;
+ }
+ }
+ va_end(ap);
+
+ if (*pdecl == NULL_TREE)
+ {
+ tree fnid = get_identifier(name);
+
+ tree argtypes = NULL_TREE;
+ tree* pp = &argtypes;
+ for (int i = 0; i < nargs; ++i)
+ {
+ *pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
+ pp = &TREE_CHAIN(*pp);
+ }
+ *pp = void_list_node;
+
+ tree fntype = build_function_type(rettype, argtypes);
+
+ *pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
+ Gogo::mark_fndecl_as_builtin_library(*pdecl);
+ go_preserve_from_gc(*pdecl);
+ }
+
+ tree fnptr = build_fold_addr_expr(*pdecl);
+ if (CAN_HAVE_LOCATION_P(fnptr))
+ SET_EXPR_LOCATION(fnptr, location);
+
+ tree ret = build_call_array(rettype, fnptr, nargs, args);
+ SET_EXPR_LOCATION(ret, location);
+
+ delete[] types;
+ delete[] args;
+
+ return ret;
+}
+
+// Build a call to the runtime error function.
+
+tree
+Gogo::runtime_error(int code, source_location location)
+{
+ static tree runtime_error_fndecl;
+ tree ret = Gogo::call_builtin(&runtime_error_fndecl,
+ location,
+ "__go_runtime_error",
+ 1,
+ void_type_node,
+ integer_type_node,
+ build_int_cst(integer_type_node, code));
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // The runtime error function panics and does not return.
+ TREE_NOTHROW(runtime_error_fndecl) = 0;
+ TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
+ return ret;
+}
+
+// Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
+// This does a blocking receive and returns the value read from the
+// channel. If FOR_SELECT is true, this is being done because it was
+// chosen in a select statement.
+
+tree
+Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location location)
+{
+ if (type_tree == error_mark_node || channel == error_mark_node)
+ return error_mark_node;
+
+ if (int_size_in_bytes(type_tree) <= 8
+ && !AGGREGATE_TYPE_P(type_tree)
+ && !FLOAT_TYPE_P(type_tree))
+ {
+ static tree receive_small_fndecl;
+ tree call = Gogo::call_builtin(&receive_small_fndecl,
+ location,
+ "__go_receive_small",
+ 2,
+ uint64_type_node,
+ ptr_type_node,
+ channel,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_small_fndecl) = 0;
+ int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
+ tree int_type_tree = go_type_for_size(bitsize, 1);
+ return fold_convert_loc(location, type_tree,
+ fold_convert_loc(location, int_type_tree,
+ call));
+ }
+ else
+ {
+ tree tmp = create_tmp_var(type_tree, get_name(type_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ TREE_ADDRESSABLE(tmp) = 1;
+ tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ tree tmpaddr = build_fold_addr_expr(tmp);
+ tmpaddr = fold_convert(ptr_type_node, tmpaddr);
+ static tree receive_big_fndecl;
+ tree call = Gogo::call_builtin(&receive_big_fndecl,
+ location,
+ "__go_receive_big",
+ 3,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ tmpaddr,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_big_fndecl) = 0;
+ return build2(COMPOUND_EXPR, type_tree, make_tmp,
+ build2(COMPOUND_EXPR, type_tree, call, tmp));
+ }
+}
+
+// Return the type of a function trampoline. This is like
+// get_trampoline_type in tree-nested.c.
+
+tree
+Gogo::trampoline_type_tree()
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ unsigned int size;
+ unsigned int align;
+ go_trampoline_info(&size, &align);
+ tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
+ t = build_array_type(char_type_node, t);
+
+ type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
+ "__data", t);
+ t = TYPE_FIELDS(type_tree);
+ DECL_ALIGN(t) = align;
+ DECL_USER_ALIGN(t) = 1;
+
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Make a trampoline which calls FNADDR passing CLOSURE.
+
+tree
+Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
+{
+ tree trampoline_type = Gogo::trampoline_type_tree();
+ tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
+
+ closure = save_expr(closure);
+
+ // We allocate the trampoline using a special function which will
+ // mark it as executable.
+ static tree trampoline_fndecl;
+ tree x = Gogo::call_builtin(&trampoline_fndecl,
+ location,
+ "__go_allocate_trampoline",
+ 2,
+ ptr_type_node,
+ size_type_node,
+ trampoline_size,
+ ptr_type_node,
+ fold_convert_loc(location, ptr_type_node,
+ closure));
+ if (x == error_mark_node)
+ return error_mark_node;
+
+ x = save_expr(x);
+
+ // Initialize the trampoline.
+ tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
+ 3, x, fnaddr, closure);
+
+ // On some targets the trampoline address needs to be adjusted. For
+ // example, when compiling in Thumb mode on the ARM, the address
+ // needs to have the low bit set.
+ x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
+ 1, x);
+ x = fold_convert(TREE_TYPE(fnaddr), x);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);
+}
--- /dev/null
+// gogo-tree.cc -- convert Go frontend Gogo IR to gcc trees.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "tree.h"
+#include "gimple.h"
+#include "tree-iterator.h"
+#include "cgraph.h"
+#include "langhooks.h"
+#include "convert.h"
+#include "output.h"
+#include "diagnostic.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "statements.h"
+#include "gogo.h"
+
+// Whether we have seen any errors.
+
+bool
+saw_errors()
+{
+ return errorcount != 0 || sorrycount != 0;
+}
+
+// A helper function.
+
+static inline tree
+get_identifier_from_string(const std::string& str)
+{
+ return get_identifier_with_length(str.data(), str.length());
+}
+
+// Builtin functions.
+
+static std::map<std::string, tree> builtin_functions;
+
+// Define a builtin function. BCODE is the builtin function code
+// defined by builtins.def. NAME is the name of the builtin function.
+// LIBNAME is the name of the corresponding library function, and is
+// NULL if there isn't one. FNTYPE is the type of the function.
+// CONST_P is true if the function has the const attribute.
+
+static void
+define_builtin(built_in_function bcode, const char* name, const char* libname,
+ tree fntype, bool const_p)
+{
+ tree decl = add_builtin_function(name, fntype, bcode, BUILT_IN_NORMAL,
+ libname, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ built_in_decls[bcode] = decl;
+ implicit_built_in_decls[bcode] = decl;
+ builtin_functions[name] = decl;
+ if (libname != NULL)
+ {
+ decl = add_builtin_function(libname, fntype, bcode, BUILT_IN_NORMAL,
+ NULL, NULL_TREE);
+ if (const_p)
+ TREE_READONLY(decl) = 1;
+ builtin_functions[libname] = decl;
+ }
+}
+
+// Create trees for implicit builtin functions.
+
+void
+Gogo::define_builtin_function_trees()
+{
+ /* We need to define the fetch_and_add functions, since we use them
+ for ++ and --. */
+ tree t = go_type_for_size(BITS_PER_UNIT, 1);
+ tree p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_1, "__sync_fetch_and_add_1", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 2, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin (BUILT_IN_ADD_AND_FETCH_2, "__sync_fetch_and_add_2", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 4, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_4, "__sync_fetch_and_add_4", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ t = go_type_for_size(BITS_PER_UNIT * 8, 1);
+ p = build_pointer_type(build_qualified_type(t, TYPE_QUAL_VOLATILE));
+ define_builtin(BUILT_IN_ADD_AND_FETCH_8, "__sync_fetch_and_add_8", NULL,
+ build_function_type_list(t, p, t, NULL_TREE), false);
+
+ // We use __builtin_expect for magic import functions.
+ define_builtin(BUILT_IN_EXPECT, "__builtin_expect", NULL,
+ build_function_type_list(long_integer_type_node,
+ long_integer_type_node,
+ long_integer_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_memmove for the predeclared copy function.
+ define_builtin(BUILT_IN_MEMMOVE, "__builtin_memmove", "memmove",
+ build_function_type_list(ptr_type_node,
+ ptr_type_node,
+ const_ptr_type_node,
+ size_type_node,
+ NULL_TREE),
+ false);
+
+ // We provide sqrt for the math library.
+ define_builtin(BUILT_IN_SQRT, "__builtin_sqrt", "sqrt",
+ build_function_type_list(double_type_node,
+ double_type_node,
+ NULL_TREE),
+ true);
+ define_builtin(BUILT_IN_SQRTL, "__builtin_sqrtl", "sqrtl",
+ build_function_type_list(long_double_type_node,
+ long_double_type_node,
+ NULL_TREE),
+ true);
+
+ // We use __builtin_return_address in the thunk we build for
+ // functions which call recover.
+ define_builtin(BUILT_IN_RETURN_ADDRESS, "__builtin_return_address", NULL,
+ build_function_type_list(ptr_type_node,
+ unsigned_type_node,
+ NULL_TREE),
+ false);
+
+ // The compiler uses __builtin_trap for some exception handling
+ // cases.
+ define_builtin(BUILT_IN_TRAP, "__builtin_trap", NULL,
+ build_function_type(void_type_node, void_list_node),
+ false);
+}
+
+// Get the name to use for the import control function. If there is a
+// global function or variable, then we know that that name must be
+// unique in the link, and we use it as the basis for our name.
+
+const std::string&
+Gogo::get_init_fn_name()
+{
+ if (this->init_fn_name_.empty())
+ {
+ gcc_assert(this->package_ != NULL);
+ if (this->is_main_package())
+ {
+ // Use a name which the runtime knows.
+ this->init_fn_name_ = "__go_init_main";
+ }
+ else
+ {
+ std::string s = this->unique_prefix();
+ s.append(1, '.');
+ s.append(this->package_name());
+ s.append("..import");
+ this->init_fn_name_ = s;
+ }
+ }
+
+ return this->init_fn_name_;
+}
+
+// Add statements to INIT_STMT_LIST which run the initialization
+// functions for imported packages. This is only used for the "main"
+// package.
+
+void
+Gogo::init_imports(tree* init_stmt_list)
+{
+ gcc_assert(this->is_main_package());
+
+ if (this->imported_init_fns_.empty())
+ return;
+
+ tree fntype = build_function_type(void_type_node, void_list_node);
+
+ // We must call them in increasing priority order.
+ std::vector<Import_init> v;
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ v.push_back(*p);
+ std::sort(v.begin(), v.end());
+
+ for (std::vector<Import_init>::const_iterator p = v.begin();
+ p != v.end();
+ ++p)
+ {
+ std::string user_name = p->package_name() + ".init";
+ tree decl = build_decl(UNKNOWN_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(user_name),
+ fntype);
+ const std::string& init_name(p->init_name());
+ SET_DECL_ASSEMBLER_NAME(decl, get_identifier_from_string(init_name));
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ append_to_statement_list(build_call_expr(decl, 0), init_stmt_list);
+ }
+}
+
+// Register global variables with the garbage collector. We need to
+// register all variables which can hold a pointer value. They become
+// roots during the mark phase. We build a struct that is easy to
+// hook into a list of roots.
+
+// struct __go_gc_root_list
+// {
+// struct __go_gc_root_list* __next;
+// struct __go_gc_root
+// {
+// void* __decl;
+// size_t __size;
+// } __roots[];
+// };
+
+// The last entry in the roots array has a NULL decl field.
+
+void
+Gogo::register_gc_vars(const std::vector<Named_object*>& var_gc,
+ tree* init_stmt_list)
+{
+ if (var_gc.empty())
+ return;
+
+ size_t count = var_gc.size();
+
+ tree root_type = Gogo::builtin_struct(NULL, "__go_gc_root", NULL_TREE, 2,
+ "__next",
+ ptr_type_node,
+ "__size",
+ sizetype);
+
+ tree index_type = build_index_type(size_int(count));
+ tree array_type = build_array_type(root_type, index_type);
+
+ tree root_list_type = make_node(RECORD_TYPE);
+ root_list_type = Gogo::builtin_struct(NULL, "__go_gc_root_list",
+ root_list_type, 2,
+ "__next",
+ build_pointer_type(root_list_type),
+ "__roots",
+ array_type);
+
+ // Build an initialier for the __roots array.
+
+ VEC(constructor_elt,gc)* roots_init = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ size_t i = 0;
+ for (std::vector<Named_object*>::const_iterator p = var_gc.begin();
+ p != var_gc.end();
+ ++p, ++i)
+ {
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ tree decl = (*p)->get_tree(this, NULL);
+ gcc_assert(TREE_CODE(decl) == VAR_DECL);
+ elt->value = build_fold_addr_expr(decl);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = DECL_SIZE_UNIT(decl);
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+ }
+
+ // The list ends with a NULL entry.
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(root_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = size_zero_node;
+
+ elt = VEC_quick_push(constructor_elt, roots_init, NULL);
+ elt->index = size_int(i);
+ elt->value = build_constructor(root_type, init);
+
+ // Build a constructor for the struct.
+
+ VEC(constructor_elt,gc*) root_list_init = VEC_alloc(constructor_elt, gc, 2);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = TYPE_FIELDS(root_list_type);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+
+ elt = VEC_quick_push(constructor_elt, root_list_init, NULL);
+ field = DECL_CHAIN(field);
+ elt->index = field;
+ elt->value = build_constructor(array_type, roots_init);
+
+ // Build a decl to register.
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL,
+ create_tmp_var_name("gc"), root_list_type);
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = build_constructor(root_list_type, root_list_init);
+ rest_of_decl_compilation(decl, 1, 0);
+
+ static tree register_gc_fndecl;
+ tree call = Gogo::call_builtin(®ister_gc_fndecl, BUILTINS_LOCATION,
+ "__go_register_gc_roots",
+ 1,
+ void_type_node,
+ build_pointer_type(root_list_type),
+ build_fold_addr_expr(decl));
+ if (call != error_mark_node)
+ append_to_statement_list(call, init_stmt_list);
+}
+
+// Build the decl for the initialization function.
+
+tree
+Gogo::initialization_function_decl()
+{
+ // The tedious details of building your own function. There doesn't
+ // seem to be a helper function for this.
+ std::string name = this->package_name() + ".init";
+ tree fndecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL,
+ get_identifier_from_string(name),
+ build_function_type(void_type_node,
+ void_list_node));
+ const std::string& asm_name(this->get_init_fn_name());
+ SET_DECL_ASSEMBLER_NAME(fndecl, get_identifier_from_string(asm_name));
+
+ tree resdecl = build_decl(BUILTINS_LOCATION, RESULT_DECL, NULL_TREE,
+ void_type_node);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = fndecl;
+ DECL_RESULT(fndecl) = resdecl;
+
+ TREE_STATIC(fndecl) = 1;
+ TREE_USED(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+
+ DECL_INITIAL(fndecl) = make_node(BLOCK);
+ TREE_USED(DECL_INITIAL(fndecl)) = 1;
+
+ return fndecl;
+}
+
+// Create the magic initialization function. INIT_STMT_LIST is the
+// code that it needs to run.
+
+void
+Gogo::write_initialization_function(tree fndecl, tree init_stmt_list)
+{
+ // Make sure that we thought we needed an initialization function,
+ // as otherwise we will not have reported it in the export data.
+ gcc_assert(this->is_main_package() || this->need_init_fn_);
+
+ if (fndecl == NULL_TREE)
+ fndecl = this->initialization_function_decl();
+
+ DECL_SAVED_TREE(fndecl) = init_stmt_list;
+
+ current_function_decl = fndecl;
+ if (DECL_STRUCT_FUNCTION(fndecl) == NULL)
+ push_struct_function(fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(fndecl));
+ cfun->function_end_locus = BUILTINS_LOCATION;
+
+ gimplify_function_tree(fndecl);
+
+ cgraph_add_new_function(fndecl, false);
+ cgraph_mark_needed_node(cgraph_node(fndecl));
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+}
+
+// Search for references to VAR in any statements or called functions.
+
+class Find_var : public Traverse
+{
+ public:
+ // A hash table we use to avoid looping. The index is the name of a
+ // named object. We only look through objects defined in this
+ // package.
+ typedef Unordered_set(std::string) Seen_objects;
+
+ Find_var(Named_object* var, Seen_objects* seen_objects)
+ : Traverse(traverse_expressions),
+ var_(var), seen_objects_(seen_objects), found_(false)
+ { }
+
+ // Whether the variable was found.
+ bool
+ found() const
+ { return this->found_; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // The variable we are looking for.
+ Named_object* var_;
+ // Names of objects we have already seen.
+ Seen_objects* seen_objects_;
+ // True if the variable was found.
+ bool found_;
+};
+
+// See if EXPR refers to VAR, looking through function calls and
+// variable initializations.
+
+int
+Find_var::expression(Expression** pexpr)
+{
+ Expression* e = *pexpr;
+
+ Var_expression* ve = e->var_expression();
+ if (ve != NULL)
+ {
+ Named_object* v = ve->named_object();
+ if (v == this->var_)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+
+ if (v->is_variable() && v->package() == NULL)
+ {
+ Expression* init = v->var_value()->init();
+ if (init != NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(v->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ }
+
+ // We traverse the code of any function we see. Note that this
+ // means that we will traverse the code of a function whose address
+ // is taken even if it is not called.
+ Func_expression* fe = e->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* f = fe->named_object();
+ if (f->is_function() && f->package() == NULL)
+ {
+ std::pair<Seen_objects::iterator, bool> ins =
+ this->seen_objects_->insert(f->name());
+ if (ins.second)
+ {
+ // This is the first time we have seen this name.
+ if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return true if EXPR refers to VAR.
+
+static bool
+expression_requires(Expression* expr, Block* preinit, Named_object* var)
+{
+ Find_var::Seen_objects seen_objects;
+ Find_var find_var(var, &seen_objects);
+ if (expr != NULL)
+ Expression::traverse(&expr, &find_var);
+ if (preinit != NULL)
+ preinit->traverse(&find_var);
+
+ return find_var.found();
+}
+
+// Sort variable initializations. If the initialization expression
+// for variable A refers directly or indirectly to the initialization
+// expression for variable B, then we must initialize B before A.
+
+class Var_init
+{
+ public:
+ Var_init()
+ : var_(NULL), init_(NULL_TREE), waiting_(0)
+ { }
+
+ Var_init(Named_object* var, tree init)
+ : var_(var), init_(init), waiting_(0)
+ { }
+
+ // Return the variable.
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ // Return the initialization expression.
+ tree
+ init() const
+ { return this->init_; }
+
+ // Return the number of variables waiting for this one to be
+ // initialized.
+ size_t
+ waiting() const
+ { return this->waiting_; }
+
+ // Increment the number waiting.
+ void
+ increment_waiting()
+ { ++this->waiting_; }
+
+ private:
+ // The variable being initialized.
+ Named_object* var_;
+ // The initialization expression to run.
+ tree init_;
+ // The number of variables which are waiting for this one.
+ size_t waiting_;
+};
+
+typedef std::list<Var_init> Var_inits;
+
+// Sort the variable initializations. The rule we follow is that we
+// emit them in the order they appear in the array, except that if the
+// initialization expression for a variable V1 depends upon another
+// variable V2 then we initialize V1 after V2.
+
+static void
+sort_var_inits(Var_inits* var_inits)
+{
+ Var_inits ready;
+ while (!var_inits->empty())
+ {
+ Var_inits::iterator p1 = var_inits->begin();
+ Named_object* var = p1->var();
+ Expression* init = var->var_value()->init();
+ Block* preinit = var->var_value()->preinit();
+
+ // Start walking through the list to see which variables VAR
+ // needs to wait for. We can skip P1->WAITING variables--that
+ // is the number we've already checked.
+ Var_inits::iterator p2 = p1;
+ ++p2;
+ for (size_t i = p1->waiting(); i > 0; --i)
+ ++p2;
+
+ for (; p2 != var_inits->end(); ++p2)
+ {
+ if (expression_requires(init, preinit, p2->var()))
+ {
+ // Check for cycles.
+ if (expression_requires(p2->var()->var_value()->init(),
+ p2->var()->var_value()->preinit(),
+ var))
+ {
+ error_at(var->location(),
+ ("initialization expressions for %qs and "
+ "%qs depend upon each other"),
+ var->message_name().c_str(),
+ p2->var()->message_name().c_str());
+ inform(p2->var()->location(), "%qs defined here",
+ p2->var()->message_name().c_str());
+ p2 = var_inits->end();
+ }
+ else
+ {
+ // We can't emit P1 until P2 is emitted. Move P1.
+ // Note that the WAITING loop always executes at
+ // least once, which is what we want.
+ p2->increment_waiting();
+ Var_inits::iterator p3 = p2;
+ for (size_t i = p2->waiting(); i > 0; --i)
+ ++p3;
+ var_inits->splice(p3, *var_inits, p1);
+ }
+ break;
+ }
+ }
+
+ if (p2 == var_inits->end())
+ {
+ // VAR does not depends upon any other initialization expressions.
+
+ // Check for a loop of VAR on itself. We only do this if
+ // INIT is not NULL; when INIT is NULL, it means that
+ // PREINIT sets VAR, which we will interpret as a loop.
+ if (init != NULL && expression_requires(init, preinit, var))
+ error_at(var->location(),
+ "initialization expression for %qs depends upon itself",
+ var->message_name().c_str());
+ ready.splice(ready.end(), *var_inits, p1);
+ }
+ }
+
+ // Now READY is the list in the desired initialization order.
+ var_inits->swap(ready);
+}
+
+// Write out the global definitions.
+
+void
+Gogo::write_globals()
+{
+ this->convert_named_types();
+ this->build_interface_method_tables();
+
+ Bindings* bindings = this->current_bindings();
+ size_t count = bindings->size_definitions();
+
+ tree* vec = new tree[count];
+
+ tree init_fndecl = NULL_TREE;
+ tree init_stmt_list = NULL_TREE;
+
+ if (this->is_main_package())
+ this->init_imports(&init_stmt_list);
+
+ // A list of variable initializations.
+ Var_inits var_inits;
+
+ // A list of variables which need to be registered with the garbage
+ // collector.
+ std::vector<Named_object*> var_gc;
+ var_gc.reserve(count);
+
+ tree var_init_stmt_list = NULL_TREE;
+ size_t i = 0;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p, ++i)
+ {
+ Named_object* no = *p;
+
+ gcc_assert(!no->is_type_declaration() && !no->is_function_declaration());
+ // There is nothing to do for a package.
+ if (no->is_package())
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing to do for an object which was imported from
+ // a different package into the global scope.
+ if (no->package() != NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+
+ // There is nothing useful we can output for constants which
+ // have ideal or non-integeral type.
+ if (no->is_const())
+ {
+ Type* type = no->const_value()->type();
+ if (type == NULL)
+ type = no->const_value()->expr()->type();
+ if (type->is_abstract() || type->integer_type() == NULL)
+ {
+ --i;
+ --count;
+ continue;
+ }
+ }
+
+ vec[i] = no->get_tree(this, NULL);
+
+ if (vec[i] == error_mark_node)
+ {
+ gcc_assert(saw_errors());
+ --i;
+ --count;
+ continue;
+ }
+
+ // If a variable is initialized to a non-constant value, do the
+ // initialization in an initialization function.
+ if (TREE_CODE(vec[i]) == VAR_DECL)
+ {
+ gcc_assert(no->is_variable());
+
+ // Check for a sink variable, which may be used to run
+ // an initializer purely for its side effects.
+ bool is_sink = no->name()[0] == '_' && no->name()[1] == '.';
+
+ tree var_init_tree = NULL_TREE;
+ if (!no->var_value()->has_pre_init())
+ {
+ tree init = no->var_value()->get_init_tree(this, NULL);
+ if (init == error_mark_node)
+ gcc_assert(saw_errors());
+ else if (init == NULL_TREE)
+ ;
+ else if (TREE_CONSTANT(init))
+ DECL_INITIAL(vec[i]) = init;
+ else if (is_sink)
+ var_init_tree = init;
+ else
+ var_init_tree = fold_build2_loc(no->location(), MODIFY_EXPR,
+ void_type_node, vec[i], init);
+ }
+ else
+ {
+ // We are going to create temporary variables which
+ // means that we need an fndecl.
+ if (init_fndecl == NULL_TREE)
+ init_fndecl = this->initialization_function_decl();
+ current_function_decl = init_fndecl;
+ if (DECL_STRUCT_FUNCTION(init_fndecl) == NULL)
+ push_struct_function(init_fndecl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(init_fndecl));
+
+ tree var_decl = is_sink ? NULL_TREE : vec[i];
+ var_init_tree = no->var_value()->get_init_block(this, NULL,
+ var_decl);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+
+ if (var_init_tree != NULL_TREE && var_init_tree != error_mark_node)
+ {
+ if (no->var_value()->init() == NULL
+ && !no->var_value()->has_pre_init())
+ append_to_statement_list(var_init_tree, &var_init_stmt_list);
+ else
+ var_inits.push_back(Var_init(no, var_init_tree));
+ }
+
+ if (!is_sink && no->var_value()->type()->has_pointer())
+ var_gc.push_back(no);
+ }
+ }
+
+ // Register global variables with the garbage collector.
+ this->register_gc_vars(var_gc, &init_stmt_list);
+
+ // Simple variable initializations, after all variables are
+ // registered.
+ append_to_statement_list(var_init_stmt_list, &init_stmt_list);
+
+ // Complex variable initializations, first sorting them into a
+ // workable order.
+ if (!var_inits.empty())
+ {
+ sort_var_inits(&var_inits);
+ for (Var_inits::const_iterator p = var_inits.begin();
+ p != var_inits.end();
+ ++p)
+ append_to_statement_list(p->init(), &init_stmt_list);
+ }
+
+ // After all the variables are initialized, call the "init"
+ // functions if there are any.
+ for (std::vector<Named_object*>::const_iterator p =
+ this->init_functions_.begin();
+ p != this->init_functions_.end();
+ ++p)
+ {
+ tree decl = (*p)->get_tree(this, NULL);
+ tree call = build_call_expr(decl, 0);
+ append_to_statement_list(call, &init_stmt_list);
+ }
+
+ // Set up a magic function to do all the initialization actions.
+ // This will be called if this package is imported.
+ if (init_stmt_list != NULL_TREE
+ || this->need_init_fn_
+ || this->is_main_package())
+ this->write_initialization_function(init_fndecl, init_stmt_list);
+
+ // Pass everything back to the middle-end.
+
+ wrapup_global_declarations(vec, count);
+
+ cgraph_finalize_compilation_unit();
+
+ check_global_declarations(vec, count);
+ emit_debug_global_declarations(vec, count);
+
+ delete[] vec;
+}
+
+// Get a tree for the identifier for a named object.
+
+tree
+Named_object::get_id(Gogo* gogo)
+{
+ std::string decl_name;
+ if (this->is_function_declaration()
+ && !this->func_declaration_value()->asm_name().empty())
+ decl_name = this->func_declaration_value()->asm_name();
+ else if ((this->is_variable() && !this->var_value()->is_global())
+ || (this->is_type()
+ && this->type_value()->location() == BUILTINS_LOCATION))
+ {
+ // We don't need the package name for local variables or builtin
+ // types.
+ decl_name = Gogo::unpack_hidden_name(this->name_);
+ }
+ else
+ {
+ std::string package_name;
+ if (this->package_ == NULL)
+ package_name = gogo->package_name();
+ else
+ package_name = this->package_->name();
+
+ decl_name = package_name + '.' + Gogo::unpack_hidden_name(this->name_);
+
+ Function_type* fntype;
+ if (this->is_function())
+ fntype = this->func_value()->type();
+ else if (this->is_function_declaration())
+ fntype = this->func_declaration_value()->type();
+ else
+ fntype = NULL;
+ if (fntype != NULL && fntype->is_method())
+ {
+ decl_name.push_back('.');
+ decl_name.append(fntype->receiver()->type()->mangled_name(gogo));
+ }
+ }
+ if (this->is_type())
+ {
+ const Named_object* in_function = this->type_value()->in_function();
+ if (in_function != NULL)
+ decl_name += '$' + in_function->name();
+ }
+ return get_identifier_from_string(decl_name);
+}
+
+// Get a tree for a named object.
+
+tree
+Named_object::get_tree(Gogo* gogo, Named_object* function)
+{
+ if (this->tree_ != NULL_TREE)
+ {
+ // If this is a variable whose address is taken, we must rebuild
+ // the INDIRECT_REF each time to avoid invalid sharing.
+ tree ret = this->tree_;
+ if (((this->classification_ == NAMED_OBJECT_VAR
+ && this->var_value()->is_in_heap())
+ || (this->classification_ == NAMED_OBJECT_RESULT_VAR
+ && this->result_var_value()->is_in_heap()))
+ && ret != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(ret) == INDIRECT_REF);
+ ret = build_fold_indirect_ref(TREE_OPERAND(ret, 0));
+ TREE_THIS_NOTRAP(ret) = 1;
+ }
+ return ret;
+ }
+
+ tree name;
+ if (this->classification_ == NAMED_OBJECT_TYPE)
+ name = NULL_TREE;
+ else
+ name = this->get_id(gogo);
+ tree decl;
+ switch (this->classification_)
+ {
+ case NAMED_OBJECT_CONST:
+ {
+ Named_constant* named_constant = this->u_.const_value;
+ Translate_context subcontext(gogo, function, NULL, NULL_TREE);
+ tree expr_tree = named_constant->expr()->get_tree(&subcontext);
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ Type* type = named_constant->type();
+ if (type != NULL && !type->is_abstract())
+ {
+ if (!type->is_undefined())
+ expr_tree = fold_convert(type->get_tree(gogo), expr_tree);
+ else
+ {
+ // Make sure we report the error.
+ type->base();
+ expr_tree = error_mark_node;
+ }
+ }
+ if (expr_tree == error_mark_node)
+ decl = error_mark_node;
+ else if (INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ {
+ decl = build_decl(named_constant->location(), CONST_DECL,
+ name, TREE_TYPE(expr_tree));
+ DECL_INITIAL(decl) = expr_tree;
+ TREE_CONSTANT(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ }
+ else
+ {
+ // A CONST_DECL is only for an enum constant, so we
+ // shouldn't use for non-integral types. Instead we
+ // just return the constant itself, rather than a
+ // decl.
+ decl = expr_tree;
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ {
+ Named_type* named_type = this->u_.type_value;
+ tree type_tree = named_type->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ decl = TYPE_NAME(type_tree);
+ gcc_assert(decl != NULL_TREE);
+
+ // We need to produce a type descriptor for every named
+ // type, and for a pointer to every named type, since
+ // other files or packages might refer to them. We need
+ // to do this even for hidden types, because they might
+ // still be returned by some function. Simply calling the
+ // type_descriptor method is enough to create the type
+ // descriptor, even though we don't do anything with it.
+ if (this->package_ == NULL)
+ {
+ named_type->type_descriptor_pointer(gogo);
+ Type* pn = Type::make_pointer_type(named_type);
+ pn->type_descriptor_pointer(gogo);
+ }
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error("reference to undefined type %qs",
+ this->message_name().c_str());
+ return error_mark_node;
+
+ case NAMED_OBJECT_VAR:
+ {
+ Variable* var = this->u_.var_value;
+ Type* type = var->type();
+ if (type->is_error_type()
+ || (type->is_undefined()
+ && (!var->is_global() || this->package() == NULL)))
+ {
+ // Force the error for an undefined type, just in case.
+ type->base();
+ decl = error_mark_node;
+ }
+ else
+ {
+ tree var_type = type->get_tree(gogo);
+ bool is_parameter = var->is_parameter();
+ if (var->is_receiver() && type->points_to() == NULL)
+ is_parameter = false;
+ if (var->is_in_heap())
+ {
+ is_parameter = false;
+ var_type = build_pointer_type(var_type);
+ }
+ decl = build_decl(var->location(),
+ is_parameter ? PARM_DECL : VAR_DECL,
+ name, var_type);
+ if (!var->is_global())
+ {
+ tree fnid = function->get_id(gogo);
+ tree fndecl = function->func_value()->get_or_make_decl(gogo,
+ function,
+ fnid);
+ DECL_CONTEXT(decl) = fndecl;
+ }
+ if (is_parameter)
+ DECL_ARG_TYPE(decl) = TREE_TYPE(decl);
+
+ if (var->is_global())
+ {
+ const Package* package = this->package();
+ if (package == NULL)
+ TREE_STATIC(decl) = 1;
+ else
+ DECL_EXTERNAL(decl) = 1;
+ if (!Gogo::is_hidden_name(this->name_))
+ {
+ TREE_PUBLIC(decl) = 1;
+ std::string asm_name = (package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix());
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(name),
+ IDENTIFIER_LENGTH(name));
+ tree asm_id = get_identifier_from_string(asm_name);
+ SET_DECL_ASSEMBLER_NAME(decl, asm_id);
+ }
+ }
+
+ // FIXME: We should only set this for variables which are
+ // actually used somewhere.
+ TREE_USED(decl) = 1;
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_RESULT_VAR:
+ {
+ Result_variable* result = this->u_.result_var_value;
+ Type* type = result->type();
+ if (type->is_error_type() || type->is_undefined())
+ {
+ // Force the error.
+ type->base();
+ decl = error_mark_node;
+ }
+ else
+ {
+ gcc_assert(result->function() == function->func_value());
+ source_location loc = function->location();
+ tree result_type = type->get_tree(gogo);
+ tree init;
+ if (!result->is_in_heap())
+ init = type->get_init_tree(gogo, false);
+ else
+ {
+ tree space = gogo->allocate_memory(type,
+ TYPE_SIZE_UNIT(result_type),
+ loc);
+ result_type = build_pointer_type(result_type);
+ tree subinit = type->get_init_tree(gogo, true);
+ if (subinit == NULL_TREE)
+ init = fold_convert_loc(loc, result_type, space);
+ else
+ {
+ space = save_expr(space);
+ space = fold_convert_loc(loc, result_type, space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, subinit);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ set, space);
+ }
+ }
+ decl = build_decl(loc, VAR_DECL, name, result_type);
+ tree fnid = function->get_id(gogo);
+ tree fndecl = function->func_value()->get_or_make_decl(gogo,
+ function,
+ fnid);
+ DECL_CONTEXT(decl) = fndecl;
+ DECL_INITIAL(decl) = init;
+ TREE_USED(decl) = 1;
+ }
+ }
+ break;
+
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ {
+ Function* func = this->u_.func_value;
+ decl = func->get_or_make_decl(gogo, this, name);
+ if (decl != error_mark_node)
+ {
+ if (func->block() != NULL)
+ {
+ if (DECL_STRUCT_FUNCTION(decl) == NULL)
+ push_struct_function(decl);
+ else
+ push_cfun(DECL_STRUCT_FUNCTION(decl));
+
+ cfun->function_end_locus = func->block()->end_location();
+
+ current_function_decl = decl;
+
+ func->build_tree(gogo, this);
+
+ gimplify_function_tree(decl);
+
+ cgraph_finalize_function(decl, true);
+
+ current_function_decl = NULL_TREE;
+ pop_cfun();
+ }
+ }
+ }
+ break;
+
+ default:
+ gcc_unreachable();
+ }
+
+ if (TREE_TYPE(decl) == error_mark_node)
+ decl = error_mark_node;
+
+ tree ret = decl;
+
+ // If this is a local variable whose address is taken, then we
+ // actually store it in the heap. For uses of the variable we need
+ // to return a reference to that heap location.
+ if (((this->classification_ == NAMED_OBJECT_VAR
+ && this->var_value()->is_in_heap())
+ || (this->classification_ == NAMED_OBJECT_RESULT_VAR
+ && this->result_var_value()->is_in_heap()))
+ && ret != error_mark_node)
+ {
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(ret)));
+ ret = build_fold_indirect_ref(ret);
+ TREE_THIS_NOTRAP(ret) = 1;
+ }
+
+ this->tree_ = ret;
+
+ if (ret != error_mark_node)
+ go_preserve_from_gc(ret);
+
+ return ret;
+}
+
+// Get the initial value of a variable as a tree. This does not
+// consider whether the variable is in the heap--it returns the
+// initial value as though it were always stored in the stack.
+
+tree
+Variable::get_init_tree(Gogo* gogo, Named_object* function)
+{
+ gcc_assert(this->preinit_ == NULL);
+ if (this->init_ == NULL)
+ {
+ gcc_assert(!this->is_parameter_);
+ return this->type_->get_init_tree(gogo, this->is_global_);
+ }
+ else
+ {
+ Translate_context context(gogo, function, NULL, NULL_TREE);
+ tree rhs_tree = this->init_->get_tree(&context);
+ return Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree, this->location());
+ }
+}
+
+// Get the initial value of a variable when a block is required.
+// VAR_DECL is the decl to set; it may be NULL for a sink variable.
+
+tree
+Variable::get_init_block(Gogo* gogo, Named_object* function, tree var_decl)
+{
+ gcc_assert(this->preinit_ != NULL);
+
+ // We want to add the variable assignment to the end of the preinit
+ // block. The preinit block may have a TRY_FINALLY_EXPR and a
+ // TRY_CATCH_EXPR; if it does, we want to add to the end of the
+ // regular statements.
+
+ Translate_context context(gogo, function, NULL, NULL_TREE);
+ tree block_tree = this->preinit_->get_tree(&context);
+ if (block_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(block_tree) == BIND_EXPR);
+ tree statements = BIND_EXPR_BODY(block_tree);
+ while (statements != NULL_TREE
+ && (TREE_CODE(statements) == TRY_FINALLY_EXPR
+ || TREE_CODE(statements) == TRY_CATCH_EXPR))
+ statements = TREE_OPERAND(statements, 0);
+
+ // It's possible to have pre-init statements without an initializer
+ // if the pre-init statements set the variable.
+ if (this->init_ != NULL)
+ {
+ tree rhs_tree = this->init_->get_tree(&context);
+ if (rhs_tree == error_mark_node)
+ return error_mark_node;
+ if (var_decl == NULL_TREE)
+ append_to_statement_list(rhs_tree, &statements);
+ else
+ {
+ tree val = Expression::convert_for_assignment(&context, this->type(),
+ this->init_->type(),
+ rhs_tree,
+ this->location());
+ if (val == error_mark_node)
+ return error_mark_node;
+ tree set = fold_build2_loc(this->location(), MODIFY_EXPR,
+ void_type_node, var_decl, val);
+ append_to_statement_list(set, &statements);
+ }
+ }
+
+ return block_tree;
+}
+
+// Get a tree for a function decl.
+
+tree
+Function::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ tree functype = this->type_->get_tree(gogo);
+ if (functype == error_mark_node)
+ this->fndecl_ = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ gcc_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ tree decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+
+ this->fndecl_ = decl;
+
+ if (no->package() != NULL)
+ ;
+ else if (this->enclosing_ != NULL || Gogo::is_thunk(no))
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "init"
+ && !this->type_->is_method())
+ ;
+ else if (Gogo::unpack_hidden_name(no->name()) == "main"
+ && gogo->is_main_package())
+ TREE_PUBLIC(decl) = 1;
+ // Methods have to be public even if they are hidden because
+ // they can be pulled into type descriptors when using
+ // anonymous fields.
+ else if (!Gogo::is_hidden_name(no->name())
+ || this->type_->is_method())
+ {
+ TREE_PUBLIC(decl) = 1;
+ std::string asm_name = gogo->unique_prefix();
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+
+ // Why do we have to do this in the frontend?
+ tree restype = TREE_TYPE(functype);
+ tree resdecl = build_decl(this->location(), RESULT_DECL, NULL_TREE,
+ restype);
+ DECL_ARTIFICIAL(resdecl) = 1;
+ DECL_IGNORED_P(resdecl) = 1;
+ DECL_CONTEXT(resdecl) = decl;
+ DECL_RESULT(decl) = resdecl;
+
+ if (this->enclosing_ != NULL)
+ DECL_STATIC_CHAIN(decl) = 1;
+
+ // If a function calls the predeclared recover function, we
+ // can't inline it, because recover behaves differently in a
+ // function passed directly to defer.
+ if (this->calls_recover_ && !this->is_recover_thunk_)
+ DECL_UNINLINABLE(decl) = 1;
+
+ // If this is a thunk created to call a function which calls
+ // the predeclared recover function, we need to disable
+ // stack splitting for the thunk.
+ if (this->is_recover_thunk_)
+ {
+ tree attr = get_identifier("__no_split_stack__");
+ DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE);
+ }
+
+ go_preserve_from_gc(decl);
+
+ if (this->closure_var_ != NULL)
+ {
+ push_struct_function(decl);
+
+ tree closure_decl = this->closure_var_->get_tree(gogo, no);
+ if (closure_decl == error_mark_node)
+ this->fndecl_ = error_mark_node;
+ else
+ {
+ DECL_ARTIFICIAL(closure_decl) = 1;
+ DECL_IGNORED_P(closure_decl) = 1;
+ TREE_USED(closure_decl) = 1;
+ DECL_ARG_TYPE(closure_decl) = TREE_TYPE(closure_decl);
+ TREE_READONLY(closure_decl) = 1;
+
+ DECL_STRUCT_FUNCTION(decl)->static_chain_decl = closure_decl;
+ }
+
+ pop_cfun();
+ }
+ }
+ }
+ return this->fndecl_;
+}
+
+// Get a tree for a function declaration.
+
+tree
+Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no, tree id)
+{
+ if (this->fndecl_ == NULL_TREE)
+ {
+ // Let Go code use an asm declaration to pick up a builtin
+ // function.
+ if (!this->asm_name_.empty())
+ {
+ std::map<std::string, tree>::const_iterator p =
+ builtin_functions.find(this->asm_name_);
+ if (p != builtin_functions.end())
+ {
+ this->fndecl_ = p->second;
+ return this->fndecl_;
+ }
+ }
+
+ tree functype = this->fntype_->get_tree(gogo);
+ tree decl;
+ if (functype == error_mark_node)
+ decl = error_mark_node;
+ else
+ {
+ // The type of a function comes back as a pointer, but we
+ // want the real function type for a function declaration.
+ gcc_assert(POINTER_TYPE_P(functype));
+ functype = TREE_TYPE(functype);
+ decl = build_decl(this->location(), FUNCTION_DECL, id, functype);
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+
+ if (this->asm_name_.empty())
+ {
+ std::string asm_name = (no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ asm_name.append(1, '.');
+ asm_name.append(IDENTIFIER_POINTER(id), IDENTIFIER_LENGTH(id));
+ SET_DECL_ASSEMBLER_NAME(decl,
+ get_identifier_from_string(asm_name));
+ }
+ }
+ this->fndecl_ = decl;
+ go_preserve_from_gc(decl);
+ }
+ return this->fndecl_;
+}
+
+// We always pass the receiver to a method as a pointer. If the
+// receiver is actually declared as a non-pointer type, then we copy
+// the value into a local variable, so that it has the right type. In
+// this function we create the real PARM_DECL to use, and set
+// DEC_INITIAL of the var_decl to be the value passed in.
+
+tree
+Function::make_receiver_parm_decl(Gogo* gogo, Named_object* no, tree var_decl)
+{
+ if (var_decl == error_mark_node)
+ return error_mark_node;
+ // If the function takes the address of a receiver which is passed
+ // by value, then we will have an INDIRECT_REF here. We need to get
+ // the real variable.
+ bool is_in_heap = no->var_value()->is_in_heap();
+ tree val_type;
+ if (TREE_CODE(var_decl) != INDIRECT_REF)
+ {
+ gcc_assert(!is_in_heap);
+ val_type = TREE_TYPE(var_decl);
+ }
+ else
+ {
+ gcc_assert(is_in_heap);
+ var_decl = TREE_OPERAND(var_decl, 0);
+ if (var_decl == error_mark_node)
+ return error_mark_node;
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(var_decl)));
+ val_type = TREE_TYPE(TREE_TYPE(var_decl));
+ }
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".pointer";
+ tree id = get_identifier_from_string(name);
+ tree parm_decl = build_decl(loc, PARM_DECL, id, build_pointer_type(val_type));
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = TREE_TYPE(parm_decl);
+
+ gcc_assert(DECL_INITIAL(var_decl) == NULL_TREE);
+ // The receiver might be passed as a null pointer.
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node, parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree ind = build_fold_indirect_ref_loc(loc, parm_decl);
+ TREE_THIS_NOTRAP(ind) = 1;
+ tree zero_init = no->var_value()->type()->get_init_tree(gogo, false);
+ tree init = fold_build3_loc(loc, COND_EXPR, TREE_TYPE(ind),
+ check, ind, zero_init);
+
+ if (is_in_heap)
+ {
+ tree size = TYPE_SIZE_UNIT(val_type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size,
+ no->location());
+ space = save_expr(space);
+ space = fold_convert(build_pointer_type(val_type), space);
+ tree spaceref = build_fold_indirect_ref_loc(no->location(), space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree check = fold_build2_loc(loc, NE_EXPR, boolean_type_node,
+ parm_decl,
+ fold_convert_loc(loc, TREE_TYPE(parm_decl),
+ null_pointer_node));
+ tree parmref = build_fold_indirect_ref_loc(no->location(), parm_decl);
+ TREE_THIS_NOTRAP(parmref) = 1;
+ tree set = fold_build2_loc(loc, MODIFY_EXPR, void_type_node,
+ spaceref, parmref);
+ init = fold_build2_loc(loc, COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ check, set, NULL_TREE),
+ space);
+ }
+
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// If we take the address of a parameter, then we need to copy it into
+// the heap. We will access it as a local variable via an
+// indirection.
+
+tree
+Function::copy_parm_to_heap(Gogo* gogo, Named_object* no, tree ref)
+{
+ if (ref == error_mark_node)
+ return error_mark_node;
+
+ gcc_assert(TREE_CODE(ref) == INDIRECT_REF);
+
+ tree var_decl = TREE_OPERAND(ref, 0);
+ if (var_decl == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ source_location loc = DECL_SOURCE_LOCATION(var_decl);
+
+ std::string name = IDENTIFIER_POINTER(DECL_NAME(var_decl));
+ name += ".param";
+ tree id = get_identifier_from_string(name);
+
+ tree type = TREE_TYPE(var_decl);
+ gcc_assert(POINTER_TYPE_P(type));
+ type = TREE_TYPE(type);
+
+ tree parm_decl = build_decl(loc, PARM_DECL, id, type);
+ DECL_CONTEXT(parm_decl) = current_function_decl;
+ DECL_ARG_TYPE(parm_decl) = type;
+
+ tree size = TYPE_SIZE_UNIT(type);
+ tree space = gogo->allocate_memory(no->var_value()->type(), size, loc);
+ space = save_expr(space);
+ space = fold_convert(TREE_TYPE(var_decl), space);
+ tree spaceref = build_fold_indirect_ref_loc(loc, space);
+ TREE_THIS_NOTRAP(spaceref) = 1;
+ tree init = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node, spaceref, parm_decl),
+ space);
+ DECL_INITIAL(var_decl) = init;
+
+ return parm_decl;
+}
+
+// Get a tree for function code.
+
+void
+Function::build_tree(Gogo* gogo, Named_object* named_function)
+{
+ tree fndecl = this->fndecl_;
+ gcc_assert(fndecl != NULL_TREE);
+
+ tree params = NULL_TREE;
+ tree* pp = ¶ms;
+
+ tree declare_vars = NULL_TREE;
+ for (Bindings::const_definitions_iterator p =
+ this->block_->bindings()->begin_definitions();
+ p != this->block_->bindings()->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_variable() && (*p)->var_value()->is_parameter())
+ {
+ *pp = (*p)->get_tree(gogo, named_function);
+
+ // We always pass the receiver to a method as a pointer. If
+ // the receiver is declared as a non-pointer type, then we
+ // copy the value into a local variable.
+ if ((*p)->var_value()->is_receiver()
+ && (*p)->var_value()->type()->points_to() == NULL)
+ {
+ tree parm_decl = this->make_receiver_parm_decl(gogo, *p, *pp);
+ tree var = *pp;
+ if (TREE_CODE(var) == INDIRECT_REF)
+ var = TREE_OPERAND(var, 0);
+ if (var != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(var) == VAR_DECL);
+ DECL_CHAIN(var) = declare_vars;
+ declare_vars = var;
+ }
+ *pp = parm_decl;
+ }
+ else if ((*p)->var_value()->is_in_heap())
+ {
+ // If we take the address of a parameter, then we need
+ // to copy it into the heap.
+ tree parm_decl = this->copy_parm_to_heap(gogo, *p, *pp);
+ if (*pp != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(*pp) == INDIRECT_REF);
+ tree var_decl = TREE_OPERAND(*pp, 0);
+ if (var_decl != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ DECL_CHAIN(var_decl) = declare_vars;
+ declare_vars = var_decl;
+ }
+ }
+ *pp = parm_decl;
+ }
+
+ if (*pp != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(*pp) == PARM_DECL);
+ pp = &DECL_CHAIN(*pp);
+ }
+ }
+ else if ((*p)->is_result_variable())
+ {
+ tree var_decl = (*p)->get_tree(gogo, named_function);
+ if (var_decl != error_mark_node
+ && (*p)->result_var_value()->is_in_heap())
+ {
+ gcc_assert(TREE_CODE(var_decl) == INDIRECT_REF);
+ var_decl = TREE_OPERAND(var_decl, 0);
+ }
+ if (var_decl != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(var_decl) == VAR_DECL);
+ DECL_CHAIN(var_decl) = declare_vars;
+ declare_vars = var_decl;
+ }
+ }
+ }
+ *pp = NULL_TREE;
+
+ DECL_ARGUMENTS(fndecl) = params;
+
+ if (this->block_ != NULL)
+ {
+ gcc_assert(DECL_INITIAL(fndecl) == NULL_TREE);
+
+ // Declare variables if necessary.
+ tree bind = NULL_TREE;
+ if (declare_vars != NULL_TREE)
+ {
+ tree block = make_node(BLOCK);
+ BLOCK_SUPERCONTEXT(block) = fndecl;
+ DECL_INITIAL(fndecl) = block;
+ BLOCK_VARS(block) = declare_vars;
+ TREE_USED(block) = 1;
+ bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block),
+ NULL_TREE, block);
+ TREE_SIDE_EFFECTS(bind) = 1;
+ }
+
+ // Build the trees for all the statements in the function.
+ Translate_context context(gogo, named_function, NULL, NULL_TREE);
+ tree code = this->block_->get_tree(&context);
+
+ tree init = NULL_TREE;
+ tree except = NULL_TREE;
+ tree fini = NULL_TREE;
+
+ // Initialize variables if necessary.
+ for (tree v = declare_vars; v != NULL_TREE; v = DECL_CHAIN(v))
+ {
+ tree dv = build1(DECL_EXPR, void_type_node, v);
+ SET_EXPR_LOCATION(dv, DECL_SOURCE_LOCATION(v));
+ append_to_statement_list(dv, &init);
+ }
+
+ // If we have a defer stack, initialize it at the start of a
+ // function.
+ if (this->defer_stack_ != NULL_TREE)
+ {
+ tree defer_init = build1(DECL_EXPR, void_type_node,
+ this->defer_stack_);
+ SET_EXPR_LOCATION(defer_init, this->block_->start_location());
+ append_to_statement_list(defer_init, &init);
+
+ // Clean up the defer stack when we leave the function.
+ this->build_defer_wrapper(gogo, named_function, &except, &fini);
+ }
+
+ if (code != NULL_TREE && code != error_mark_node)
+ {
+ if (init != NULL_TREE)
+ code = build2(COMPOUND_EXPR, void_type_node, init, code);
+ if (except != NULL_TREE)
+ code = build2(TRY_CATCH_EXPR, void_type_node, code,
+ build2(CATCH_EXPR, void_type_node, NULL, except));
+ if (fini != NULL_TREE)
+ code = build2(TRY_FINALLY_EXPR, void_type_node, code, fini);
+ }
+
+ // Stick the code into the block we built for the receiver, if
+ // we built on.
+ if (bind != NULL_TREE && code != NULL_TREE && code != error_mark_node)
+ {
+ BIND_EXPR_BODY(bind) = code;
+ code = bind;
+ }
+
+ DECL_SAVED_TREE(fndecl) = code;
+ }
+}
+
+// Build the wrappers around function code needed if the function has
+// any defer statements. This sets *EXCEPT to an exception handler
+// and *FINI to a finally handler.
+
+void
+Function::build_defer_wrapper(Gogo* gogo, Named_object* named_function,
+ tree *except, tree *fini)
+{
+ source_location end_loc = this->block_->end_location();
+
+ // Add an exception handler. This is used if a panic occurs. Its
+ // purpose is to stop the stack unwinding if a deferred function
+ // calls recover. There are more details in
+ // libgo/runtime/go-unwind.c.
+ tree stmt_list = NULL_TREE;
+ static tree check_fndecl;
+ tree call = Gogo::call_builtin(&check_fndecl,
+ end_loc,
+ "__go_check_defer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ if (call != error_mark_node)
+ append_to_statement_list(call, &stmt_list);
+
+ tree retval = this->return_value(gogo, named_function, end_loc, &stmt_list);
+ tree set;
+ if (retval == NULL_TREE)
+ set = NULL_TREE;
+ else
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ tree ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+
+ gcc_assert(*except == NULL_TREE);
+ *except = stmt_list;
+
+ // Add some finally code to run the defer functions. This is used
+ // both in the normal case, when no panic occurs, and also if a
+ // panic occurs to run any further defer functions. Of course, it
+ // is possible for a defer function to call panic which should be
+ // caught by another defer function. To handle that we use a loop.
+ // finish:
+ // try { __go_undefer(); } catch { __go_check_defer(); goto finish; }
+ // if (return values are named) return named_vals;
+
+ stmt_list = NULL;
+
+ tree label = create_artificial_label(end_loc);
+ tree define_label = fold_build1_loc(end_loc, LABEL_EXPR, void_type_node,
+ label);
+ append_to_statement_list(define_label, &stmt_list);
+
+ static tree undefer_fndecl;
+ tree undefer = Gogo::call_builtin(&undefer_fndecl,
+ end_loc,
+ "__go_undefer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ if (undefer_fndecl != NULL_TREE)
+ TREE_NOTHROW(undefer_fndecl) = 0;
+
+ tree defer = Gogo::call_builtin(&check_fndecl,
+ end_loc,
+ "__go_check_defer",
+ 1,
+ void_type_node,
+ ptr_type_node,
+ this->defer_stack(end_loc));
+ tree jump = fold_build1_loc(end_loc, GOTO_EXPR, void_type_node, label);
+ tree catch_body = build2(COMPOUND_EXPR, void_type_node, defer, jump);
+ catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
+ tree try_catch = build2(TRY_CATCH_EXPR, void_type_node, undefer, catch_body);
+
+ append_to_statement_list(try_catch, &stmt_list);
+
+ if (this->type_->results() != NULL
+ && !this->type_->results()->empty()
+ && !this->type_->results()->front().name().empty())
+ {
+ // If the result variables are named, we need to return them
+ // again, because they might have been changed by a defer
+ // function.
+ retval = this->return_value(gogo, named_function, end_loc,
+ &stmt_list);
+ set = fold_build2_loc(end_loc, MODIFY_EXPR, void_type_node,
+ DECL_RESULT(this->fndecl_), retval);
+ ret_stmt = fold_build1_loc(end_loc, RETURN_EXPR, void_type_node, set);
+ append_to_statement_list(ret_stmt, &stmt_list);
+ }
+
+ gcc_assert(*fini == NULL_TREE);
+ *fini = stmt_list;
+}
+
+// Return the value to assign to DECL_RESULT(this->fndecl_). This may
+// also add statements to STMT_LIST, which need to be executed before
+// the assignment. This is used for a return statement with no
+// explicit values.
+
+tree
+Function::return_value(Gogo* gogo, Named_object* named_function,
+ source_location location, tree* stmt_list) const
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL || results->empty())
+ return NULL_TREE;
+
+ // In the case of an exception handler created for functions with
+ // defer statements, the result variables may be unnamed.
+ bool is_named = !results->front().name().empty();
+ if (is_named)
+ {
+ gcc_assert(this->named_results_ != NULL);
+ if (this->named_results_->size() != results->size())
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ }
+
+ tree retval;
+ if (results->size() == 1)
+ {
+ if (is_named)
+ return this->named_results_->front()->get_tree(gogo, named_function);
+ else
+ return results->front().type()->get_init_tree(gogo, false);
+ }
+ else
+ {
+ tree rettype = TREE_TYPE(DECL_RESULT(this->fndecl_));
+ retval = create_tmp_var(rettype, "RESULT");
+ tree field = TYPE_FIELDS(rettype);
+ int index = 0;
+ for (Typed_identifier_list::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++index, field = DECL_CHAIN(field))
+ {
+ gcc_assert(field != NULL);
+ tree val;
+ if (is_named)
+ val = (*this->named_results_)[index]->get_tree(gogo,
+ named_function);
+ else
+ val = pr->type()->get_init_tree(gogo, false);
+ tree set = fold_build2_loc(location, MODIFY_EXPR, void_type_node,
+ build3(COMPONENT_REF, TREE_TYPE(field),
+ retval, field, NULL_TREE),
+ val);
+ append_to_statement_list(set, stmt_list);
+ }
+ return retval;
+ }
+}
+
+// Get the tree for the variable holding the defer stack for this
+// function. At least at present, the value of this variable is not
+// used. However, a pointer to this variable is used as a marker for
+// the functions on the defer stack associated with this function.
+// Doing things this way permits inlining a function which uses defer.
+
+tree
+Function::defer_stack(source_location location)
+{
+ if (this->defer_stack_ == NULL_TREE)
+ {
+ tree var = create_tmp_var(ptr_type_node, "DEFER");
+ DECL_INITIAL(var) = null_pointer_node;
+ DECL_SOURCE_LOCATION(var) = location;
+ TREE_ADDRESSABLE(var) = 1;
+ this->defer_stack_ = var;
+ }
+ return fold_convert_loc(location, ptr_type_node,
+ build_fold_addr_expr_loc(location,
+ this->defer_stack_));
+}
+
+// Get a tree for the statements in a block.
+
+tree
+Block::get_tree(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+
+ tree block = make_node(BLOCK);
+
+ // Put the new block into the block tree.
+
+ if (context->block() == NULL)
+ {
+ tree fndecl;
+ if (context->function() != NULL)
+ fndecl = context->function()->func_value()->get_decl();
+ else
+ fndecl = current_function_decl;
+ gcc_assert(fndecl != NULL_TREE);
+
+ // We may have already created a block for the receiver.
+ if (DECL_INITIAL(fndecl) == NULL_TREE)
+ {
+ BLOCK_SUPERCONTEXT(block) = fndecl;
+ DECL_INITIAL(fndecl) = block;
+ }
+ else
+ {
+ tree superblock_tree = DECL_INITIAL(fndecl);
+ BLOCK_SUPERCONTEXT(block) = superblock_tree;
+ gcc_assert(BLOCK_CHAIN(block) == NULL_TREE);
+ BLOCK_CHAIN(block) = block;
+ }
+ }
+ else
+ {
+ tree superblock_tree = context->block_tree();
+ BLOCK_SUPERCONTEXT(block) = superblock_tree;
+ tree* pp;
+ for (pp = &BLOCK_SUBBLOCKS(superblock_tree);
+ *pp != NULL_TREE;
+ pp = &BLOCK_CHAIN(*pp))
+ ;
+ *pp = block;
+ }
+
+ // Expand local variables in the block.
+
+ tree* pp = &BLOCK_VARS(block);
+ for (Bindings::const_definitions_iterator pv =
+ this->bindings_->begin_definitions();
+ pv != this->bindings_->end_definitions();
+ ++pv)
+ {
+ if ((!(*pv)->is_variable() || !(*pv)->var_value()->is_parameter())
+ && !(*pv)->is_result_variable()
+ && !(*pv)->is_const())
+ {
+ tree var = (*pv)->get_tree(gogo, context->function());
+ if (var != error_mark_node && TREE_TYPE(var) != error_mark_node)
+ {
+ if ((*pv)->is_variable() && (*pv)->var_value()->is_in_heap())
+ {
+ gcc_assert(TREE_CODE(var) == INDIRECT_REF);
+ var = TREE_OPERAND(var, 0);
+ gcc_assert(TREE_CODE(var) == VAR_DECL);
+ }
+ *pp = var;
+ pp = &DECL_CHAIN(*pp);
+ }
+ }
+ }
+ *pp = NULL_TREE;
+
+ Translate_context subcontext(context->gogo(), context->function(),
+ this, block);
+
+ tree statements = NULL_TREE;
+
+ // Expand the statements.
+
+ for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
+ p != this->statements_.end();
+ ++p)
+ {
+ tree statement = (*p)->get_tree(&subcontext);
+ if (statement != error_mark_node)
+ append_to_statement_list(statement, &statements);
+ }
+
+ TREE_USED(block) = 1;
+
+ tree bind = build3(BIND_EXPR, void_type_node, BLOCK_VARS(block), statements,
+ block);
+ TREE_SIDE_EFFECTS(bind) = 1;
+
+ return bind;
+}
+
+// Get the LABEL_DECL for a label.
+
+tree
+Label::get_decl()
+{
+ if (this->decl_ == NULL)
+ {
+ tree id = get_identifier_from_string(this->name_);
+ this->decl_ = build_decl(this->location_, LABEL_DECL, id, void_type_node);
+ DECL_CONTEXT(this->decl_) = current_function_decl;
+ }
+ return this->decl_;
+}
+
+// Return an expression for the address of this label.
+
+tree
+Label::get_addr(source_location location)
+{
+ tree decl = this->get_decl();
+ TREE_USED(decl) = 1;
+ TREE_ADDRESSABLE(decl) = 1;
+ return fold_convert_loc(location, ptr_type_node,
+ build_fold_addr_expr_loc(location, decl));
+}
+
+// Get the LABEL_DECL for an unnamed label.
+
+tree
+Unnamed_label::get_decl()
+{
+ if (this->decl_ == NULL)
+ this->decl_ = create_artificial_label(this->location_);
+ return this->decl_;
+}
+
+// Get the LABEL_EXPR for an unnamed label.
+
+tree
+Unnamed_label::get_definition()
+{
+ tree t = build1(LABEL_EXPR, void_type_node, this->get_decl());
+ SET_EXPR_LOCATION(t, this->location_);
+ return t;
+}
+
+// Return a goto to this label.
+
+tree
+Unnamed_label::get_goto(source_location location)
+{
+ tree t = build1(GOTO_EXPR, void_type_node, this->get_decl());
+ SET_EXPR_LOCATION(t, location);
+ return t;
+}
+
+// Return the integer type to use for a size.
+
+GO_EXTERN_C
+tree
+go_type_for_size(unsigned int bits, int unsignedp)
+{
+ const char* name;
+ switch (bits)
+ {
+ case 8:
+ name = unsignedp ? "uint8" : "int8";
+ break;
+ case 16:
+ name = unsignedp ? "uint16" : "int16";
+ break;
+ case 32:
+ name = unsignedp ? "uint32" : "int32";
+ break;
+ case 64:
+ name = unsignedp ? "uint64" : "int64";
+ break;
+ default:
+ if (bits == POINTER_SIZE && unsignedp)
+ name = "uintptr";
+ else
+ return NULL_TREE;
+ }
+ Type* type = Type::lookup_integer_type(name);
+ return type->get_tree(go_get_gogo());
+}
+
+// Return the type to use for a mode.
+
+GO_EXTERN_C
+tree
+go_type_for_mode(enum machine_mode mode, int unsignedp)
+{
+ // FIXME: This static_cast should be in machmode.h.
+ enum mode_class mc = static_cast<enum mode_class>(GET_MODE_CLASS(mode));
+ if (mc == MODE_INT)
+ return go_type_for_size(GET_MODE_BITSIZE(mode), unsignedp);
+ else if (mc == MODE_FLOAT)
+ {
+ Type* type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 32:
+ type = Type::lookup_float_type("float32");
+ break;
+ case 64:
+ type = Type::lookup_float_type("float64");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(long_double_type_node))
+ return long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->float_type()->type_tree();
+ }
+ else if (mc == MODE_COMPLEX_FLOAT)
+ {
+ Type *type;
+ switch (GET_MODE_BITSIZE (mode))
+ {
+ case 64:
+ type = Type::lookup_complex_type("complex64");
+ break;
+ case 128:
+ type = Type::lookup_complex_type("complex128");
+ break;
+ default:
+ // We have to check for long double in order to support
+ // i386 excess precision.
+ if (mode == TYPE_MODE(complex_long_double_type_node))
+ return complex_long_double_type_node;
+ return NULL_TREE;
+ }
+ return type->complex_type()->type_tree();
+ }
+ else
+ return NULL_TREE;
+}
+
+// Return a tree which allocates SIZE bytes which will holds value of
+// type TYPE.
+
+tree
+Gogo::allocate_memory(Type* type, tree size, source_location location)
+{
+ // If the package imports unsafe, then it may play games with
+ // pointers that look like integers.
+ if (this->imported_unsafe_ || type->has_pointer())
+ {
+ static tree new_fndecl;
+ return Gogo::call_builtin(&new_fndecl,
+ location,
+ "__go_new",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+ else
+ {
+ static tree new_nopointers_fndecl;
+ return Gogo::call_builtin(&new_nopointers_fndecl,
+ location,
+ "__go_new_nopointers",
+ 1,
+ ptr_type_node,
+ sizetype,
+ size);
+ }
+}
+
+// Build a builtin struct with a list of fields. The name is
+// STRUCT_NAME. STRUCT_TYPE is NULL_TREE or an empty RECORD_TYPE
+// node; this exists so that the struct can have fields which point to
+// itself. If PTYPE is not NULL, store the result in *PTYPE. There
+// are NFIELDS fields. Each field is a name (a const char*) followed
+// by a type (a tree).
+
+tree
+Gogo::builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...)
+{
+ if (ptype != NULL && *ptype != NULL_TREE)
+ return *ptype;
+
+ va_list ap;
+ va_start(ap, nfields);
+
+ tree fields = NULL_TREE;
+ for (int i = 0; i < nfields; ++i)
+ {
+ const char* field_name = va_arg(ap, const char*);
+ tree type = va_arg(ap, tree);
+ if (type == error_mark_node)
+ {
+ if (ptype != NULL)
+ *ptype = error_mark_node;
+ return error_mark_node;
+ }
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL,
+ get_identifier(field_name), type);
+ DECL_CHAIN(field) = fields;
+ fields = field;
+ }
+
+ va_end(ap);
+
+ if (struct_type == NULL_TREE)
+ struct_type = make_node(RECORD_TYPE);
+ finish_builtin_struct(struct_type, struct_name, fields, NULL_TREE);
+
+ if (ptype != NULL)
+ {
+ go_preserve_from_gc(struct_type);
+ *ptype = struct_type;
+ }
+
+ return struct_type;
+}
+
+// Return a type to use for pointer to const char for a string.
+
+tree
+Gogo::const_char_pointer_type_tree()
+{
+ static tree type;
+ if (type == NULL_TREE)
+ {
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ type = build_pointer_type(const_char_type);
+ go_preserve_from_gc(type);
+ }
+ return type;
+}
+
+// Return a tree for a string constant.
+
+tree
+Gogo::string_constant_tree(const std::string& val)
+{
+ tree index_type = build_index_type(size_int(val.length()));
+ tree const_char_type = build_qualified_type(unsigned_char_type_node,
+ TYPE_QUAL_CONST);
+ tree string_type = build_array_type(const_char_type, index_type);
+ string_type = build_variant_type_copy(string_type);
+ TYPE_STRING_FLAG(string_type) = 1;
+ tree string_val = build_string(val.length(), val.data());
+ TREE_TYPE(string_val) = string_type;
+ return string_val;
+}
+
+// Return a tree for a Go string constant.
+
+tree
+Gogo::go_string_constant_tree(const std::string& val)
+{
+ tree string_type = Type::make_string_type()->get_tree(this);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ tree field = TYPE_FIELDS(string_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__data") == 0);
+ elt->index = field;
+ tree str = Gogo::string_constant_tree(val);
+ elt->value = fold_convert(TREE_TYPE(field),
+ build_fold_addr_expr(str));
+
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__length") == 0);
+ elt->index = field;
+ elt->value = build_int_cst_type(TREE_TYPE(field), val.length());
+
+ tree constructor = build_constructor(string_type, init);
+ TREE_READONLY(constructor) = 1;
+ TREE_CONSTANT(constructor) = 1;
+
+ return constructor;
+}
+
+// Return a tree for a pointer to a Go string constant. This is only
+// used for type descriptors, so we return a pointer to a constant
+// decl.
+
+tree
+Gogo::ptr_go_string_constant_tree(const std::string& val)
+{
+ tree pval = this->go_string_constant_tree(val);
+
+ tree decl = build_decl(UNKNOWN_LOCATION, VAR_DECL,
+ create_tmp_var_name("SP"), TREE_TYPE(pval));
+ DECL_EXTERNAL(decl) = 0;
+ TREE_PUBLIC(decl) = 0;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_STATIC(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_INITIAL(decl) = pval;
+ rest_of_decl_compilation(decl, 1, 0);
+
+ return build_fold_addr_expr(decl);
+}
+
+// Build the type of the struct that holds a slice for the given
+// element type.
+
+tree
+Gogo::slice_type_tree(tree element_type_tree)
+{
+ // We use int for the count and capacity fields in a slice header.
+ // This matches 6g. The language definition guarantees that we
+ // can't allocate space of a size which does not fit in int
+ // anyhow. FIXME: integer_type_node is the the C type "int" but is
+ // not necessarily the Go type "int". They will differ when the C
+ // type "int" has fewer than 32 bits.
+ return Gogo::builtin_struct(NULL, "__go_slice", NULL_TREE, 3,
+ "__values",
+ build_pointer_type(element_type_tree),
+ "__count",
+ integer_type_node,
+ "__capacity",
+ integer_type_node);
+}
+
+// Given the tree for a slice type, return the tree for the type of
+// the elements of the slice.
+
+tree
+Gogo::slice_element_type_tree(tree slice_type_tree)
+{
+ gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE
+ && POINTER_TYPE_P(TREE_TYPE(TYPE_FIELDS(slice_type_tree))));
+ return TREE_TYPE(TREE_TYPE(TYPE_FIELDS(slice_type_tree)));
+}
+
+// Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+// the slice. VALUES is the value pointer and COUNT is the number of
+// entries. If CAPACITY is not NULL, it is the capacity; otherwise
+// the capacity and the count are the same.
+
+tree
+Gogo::slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity)
+{
+ gcc_assert(TREE_CODE(slice_type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ tree field = TYPE_FIELDS(slice_type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ gcc_assert(TYPE_MAIN_VARIANT(TREE_TYPE(field))
+ == TYPE_MAIN_VARIANT(TREE_TYPE(values)));
+ elt->value = values;
+
+ count = fold_convert(sizetype, count);
+ if (capacity == NULL_TREE)
+ {
+ count = save_expr(count);
+ capacity = count;
+ }
+
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), count);
+
+ field = DECL_CHAIN(field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+ elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), capacity);
+
+ return build_constructor(slice_type_tree, init);
+}
+
+// Build a constructor for an empty slice.
+
+tree
+Gogo::empty_slice_constructor(tree slice_type_tree)
+{
+ tree element_field = TYPE_FIELDS(slice_type_tree);
+ tree ret = Gogo::slice_constructor(slice_type_tree,
+ fold_convert(TREE_TYPE(element_field),
+ null_pointer_node),
+ size_zero_node,
+ size_zero_node);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Build a map descriptor for a map of type MAPTYPE.
+
+tree
+Gogo::map_descriptor(Map_type* maptype)
+{
+ if (this->map_descriptors_ == NULL)
+ this->map_descriptors_ = new Map_descriptors(10);
+
+ std::pair<const Map_type*, tree> val(maptype, NULL);
+ std::pair<Map_descriptors::iterator, bool> ins =
+ this->map_descriptors_->insert(val);
+ Map_descriptors::iterator p = ins.first;
+ if (!ins.second)
+ {
+ if (p->second == error_mark_node)
+ return error_mark_node;
+ gcc_assert(p->second != NULL_TREE && DECL_P(p->second));
+ return build_fold_addr_expr(p->second);
+ }
+
+ Type* keytype = maptype->key_type();
+ Type* valtype = maptype->val_type();
+
+ std::string mangled_name = ("__go_map_" + maptype->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // Get the type of the map descriptor. This is __go_map_descriptor
+ // in libgo/map.h.
+
+ tree struct_type = this->map_descriptor_type();
+
+ // The map entry type is a struct with three fields. This struct is
+ // specific to MAPTYPE. Build it.
+
+ tree map_entry_type = make_node(RECORD_TYPE);
+
+ map_entry_type = Gogo::builtin_struct(NULL, "__map", map_entry_type, 3,
+ "__next",
+ build_pointer_type(map_entry_type),
+ "__key",
+ keytype->get_tree(this),
+ "__val",
+ valtype->get_tree(this));
+ if (map_entry_type == error_mark_node)
+ {
+ p->second = error_mark_node;
+ return error_mark_node;
+ }
+
+ tree map_entry_key_field = DECL_CHAIN(TYPE_FIELDS(map_entry_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_key_field)),
+ "__key") == 0);
+
+ tree map_entry_val_field = DECL_CHAIN(map_entry_key_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_entry_val_field)),
+ "__val") == 0);
+
+ // Initialize the entries.
+
+ tree map_descriptor_field = TYPE_FIELDS(struct_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(map_descriptor_field)),
+ "__map_descriptor") == 0);
+ tree entry_size_field = DECL_CHAIN(map_descriptor_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(entry_size_field)),
+ "__entry_size") == 0);
+ tree key_offset_field = DECL_CHAIN(entry_size_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(key_offset_field)),
+ "__key_offset") == 0);
+ tree val_offset_field = DECL_CHAIN(key_offset_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(val_offset_field)),
+ "__val_offset") == 0);
+
+ VEC(constructor_elt, gc)* descriptor = VEC_alloc(constructor_elt, gc, 6);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = map_descriptor_field;
+ elt->value = maptype->type_descriptor_pointer(this);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = entry_size_field;
+ elt->value = TYPE_SIZE_UNIT(map_entry_type);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = key_offset_field;
+ elt->value = byte_position(map_entry_key_field);
+
+ elt = VEC_quick_push(constructor_elt, descriptor, NULL);
+ elt->index = val_offset_field;
+ elt->value = byte_position(map_entry_val_field);
+
+ tree constructor = build_constructor(struct_type, descriptor);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, struct_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+ p->second = decl;
+
+ return build_fold_addr_expr(decl);
+}
+
+// Return a tree for the type of a map descriptor. This is struct
+// __go_map_descriptor in libgo/runtime/map.h. This is the same for
+// all map types.
+
+tree
+Gogo::map_descriptor_type()
+{
+ static tree struct_type;
+ tree dtype = Type::make_type_descriptor_type()->get_tree(this);
+ dtype = build_qualified_type(dtype, TYPE_QUAL_CONST);
+ return Gogo::builtin_struct(&struct_type, "__go_map_descriptor", NULL_TREE,
+ 4,
+ "__map_descriptor",
+ build_pointer_type(dtype),
+ "__entry_size",
+ sizetype,
+ "__key_offset",
+ sizetype,
+ "__val_offset",
+ sizetype);
+}
+
+// Return the name to use for a type descriptor decl for TYPE. This
+// is used when TYPE does not have a name.
+
+std::string
+Gogo::unnamed_type_descriptor_decl_name(const Type* type)
+{
+ return "__go_td_" + type->mangled_name(this);
+}
+
+// Return the name to use for a type descriptor decl for a type named
+// NAME, defined in the function IN_FUNCTION. IN_FUNCTION will
+// normally be NULL.
+
+std::string
+Gogo::type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function)
+{
+ std::string ret = "__go_tdn_";
+ if (no->type_value()->is_builtin())
+ gcc_assert(in_function == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? this->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? this->package_name()
+ : no->package()->name());
+ ret.append(unique_prefix);
+ ret.append(1, '.');
+ ret.append(package_name);
+ ret.append(1, '.');
+ if (in_function != NULL)
+ {
+ ret.append(Gogo::unpack_hidden_name(in_function->name()));
+ ret.append(1, '.');
+ }
+ }
+ ret.append(no->name());
+ return ret;
+}
+
+// Where a type descriptor decl should be defined.
+
+Gogo::Type_descriptor_location
+Gogo::type_descriptor_location(const Type* type)
+{
+ const Named_type* name = type->named_type();
+ if (name != NULL)
+ {
+ if (name->named_object()->package() != NULL)
+ {
+ // This is a named type defined in a different package. The
+ // descriptor should be defined in that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else if (name->is_builtin())
+ {
+ // We create the descriptor for a builtin type whenever we
+ // need it.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ else
+ {
+ // This is a named type defined in this package. The
+ // descriptor should be defined here.
+ return TYPE_DESCRIPTOR_DEFINED;
+ }
+ }
+ else
+ {
+ if (type->points_to() != NULL
+ && type->points_to()->named_type() != NULL
+ && type->points_to()->named_type()->named_object()->package() != NULL)
+ {
+ // This is an unnamed pointer to a named type defined in a
+ // different package. The descriptor should be defined in
+ // that package.
+ return TYPE_DESCRIPTOR_UNDEFINED;
+ }
+ else
+ {
+ // This is an unnamed type. The descriptor could be defined
+ // in any package where it is needed, and the linker will
+ // pick one descriptor to keep.
+ return TYPE_DESCRIPTOR_COMMON;
+ }
+ }
+}
+
+// Build a type descriptor decl for TYPE. INITIALIZER is a struct
+// composite literal which initializers the type descriptor.
+
+void
+Gogo::build_type_descriptor_decl(const Type* type, Expression* initializer,
+ tree* pdecl)
+{
+ const Named_type* name = type->named_type();
+
+ // We can have multiple instances of unnamed types, but we only want
+ // to emit the type descriptor once. We use a hash table to handle
+ // this. This is not necessary for named types, as they are unique,
+ // and we store the type descriptor decl in the type itself.
+ tree* phash = NULL;
+ if (name == NULL)
+ {
+ if (this->type_descriptor_decls_ == NULL)
+ this->type_descriptor_decls_ = new Type_descriptor_decls(10);
+
+ std::pair<Type_descriptor_decls::iterator, bool> ins =
+ this->type_descriptor_decls_->insert(std::make_pair(type, NULL_TREE));
+ if (!ins.second)
+ {
+ // We've already built a type descriptor for this type.
+ *pdecl = ins.first->second;
+ return;
+ }
+ phash = &ins.first->second;
+ }
+
+ std::string decl_name;
+ if (name == NULL)
+ decl_name = this->unnamed_type_descriptor_decl_name(type);
+ else
+ decl_name = this->type_descriptor_decl_name(name->named_object(),
+ name->in_function());
+ tree id = get_identifier_from_string(decl_name);
+ tree descriptor_type_tree = initializer->type()->get_tree(this);
+ if (descriptor_type_tree == error_mark_node)
+ {
+ *pdecl = error_mark_node;
+ return;
+ }
+ tree decl = build_decl(name == NULL ? BUILTINS_LOCATION : name->location(),
+ VAR_DECL, id,
+ build_qualified_type(descriptor_type_tree,
+ TYPE_QUAL_CONST));
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_ARTIFICIAL(decl) = 1;
+
+ go_preserve_from_gc(decl);
+ if (phash != NULL)
+ *phash = decl;
+
+ // We store the new DECL now because we may need to refer to it when
+ // expanding INITIALIZER.
+ *pdecl = decl;
+
+ // If appropriate, just refer to the exported type identifier.
+ Gogo::Type_descriptor_location type_descriptor_location =
+ this->type_descriptor_location(type);
+ if (type_descriptor_location == TYPE_DESCRIPTOR_UNDEFINED)
+ {
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ return;
+ }
+
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+
+ Translate_context context(this, NULL, NULL, NULL);
+ context.set_is_const();
+ tree constructor = initializer->get_tree(&context);
+
+ if (constructor == error_mark_node)
+ gcc_assert(saw_errors());
+
+ DECL_INITIAL(decl) = constructor;
+
+ if (type_descriptor_location == TYPE_DESCRIPTOR_DEFINED)
+ TREE_PUBLIC(decl) = 1;
+ else
+ {
+ gcc_assert(type_descriptor_location == TYPE_DESCRIPTOR_COMMON);
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+}
+
+// Build an interface method table for a type: a list of function
+// pointers, one for each interface method. This is used for
+// interfaces.
+
+tree
+Gogo::interface_method_table_for_type(const Interface_type* interface,
+ Named_type* type,
+ bool is_pointer)
+{
+ const Typed_identifier_list* interface_methods = interface->methods();
+ gcc_assert(!interface_methods->empty());
+
+ std::string mangled_name = ((is_pointer ? "__go_pimt__" : "__go_imt_")
+ + interface->mangled_name(this)
+ + "__"
+ + type->mangled_name(this));
+
+ tree id = get_identifier_from_string(mangled_name);
+
+ // See whether this interface has any hidden methods.
+ bool has_hidden_methods = false;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->name()))
+ {
+ has_hidden_methods = true;
+ break;
+ }
+ }
+
+ // We already know that the named type is convertible to the
+ // interface. If the interface has hidden methods, and the named
+ // type is defined in a different package, then the interface
+ // conversion table will be defined by that other package.
+ if (has_hidden_methods && type->named_object()->package() != NULL)
+ {
+ tree array_type = build_array_type(const_ptr_type_node, NULL);
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ TREE_PUBLIC(decl) = 1;
+ DECL_EXTERNAL(decl) = 1;
+ go_preserve_from_gc(decl);
+ return decl;
+ }
+
+ size_t count = interface_methods->size();
+ VEC(constructor_elt, gc)* pointers = VEC_alloc(constructor_elt, gc,
+ count + 1);
+
+ // The first element is the type descriptor.
+ constructor_elt* elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_zero_node;
+ Type* td_type;
+ if (!is_pointer)
+ td_type = type;
+ else
+ td_type = Type::make_pointer_type(type);
+ elt->value = fold_convert(const_ptr_type_node,
+ td_type->type_descriptor_pointer(this));
+
+ size_t i = 1;
+ for (Typed_identifier_list::const_iterator p = interface_methods->begin();
+ p != interface_methods->end();
+ ++p, ++i)
+ {
+ bool is_ambiguous;
+ Method* m = type->method_function(p->name(), &is_ambiguous);
+ gcc_assert(m != NULL);
+
+ Named_object* no = m->named_object();
+
+ tree fnid = no->get_id(this);
+
+ tree fndecl;
+ if (no->is_function())
+ fndecl = no->func_value()->get_or_make_decl(this, no, fnid);
+ else if (no->is_function_declaration())
+ fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
+ fnid);
+ else
+ gcc_unreachable();
+ fndecl = build_fold_addr_expr(fndecl);
+
+ elt = VEC_quick_push(constructor_elt, pointers, NULL);
+ elt->index = size_int(i);
+ elt->value = fold_convert(const_ptr_type_node, fndecl);
+ }
+ gcc_assert(i == count + 1);
+
+ tree array_type = build_array_type(const_ptr_type_node,
+ build_index_type(size_int(count)));
+ tree constructor = build_constructor(array_type, pointers);
+
+ tree decl = build_decl(BUILTINS_LOCATION, VAR_DECL, id, array_type);
+ TREE_STATIC(decl) = 1;
+ TREE_USED(decl) = 1;
+ TREE_READONLY(decl) = 1;
+ TREE_CONSTANT(decl) = 1;
+ DECL_INITIAL(decl) = constructor;
+
+ // If the interface type has hidden methods, then this is the only
+ // definition of the table. Otherwise it is a comdat table which
+ // may be defined in multiple packages.
+ if (has_hidden_methods)
+ TREE_PUBLIC(decl) = 1;
+ else
+ {
+ make_decl_one_only(decl, DECL_ASSEMBLER_NAME(decl));
+ resolve_unique_section(decl, 1, 0);
+ }
+
+ rest_of_decl_compilation(decl, 1, 0);
+
+ go_preserve_from_gc(decl);
+
+ return decl;
+}
+
+// Mark a function as a builtin library function.
+
+void
+Gogo::mark_fndecl_as_builtin_library(tree fndecl)
+{
+ DECL_EXTERNAL(fndecl) = 1;
+ TREE_PUBLIC(fndecl) = 1;
+ DECL_ARTIFICIAL(fndecl) = 1;
+ TREE_NOTHROW(fndecl) = 1;
+ DECL_VISIBILITY(fndecl) = VISIBILITY_DEFAULT;
+ DECL_VISIBILITY_SPECIFIED(fndecl) = 1;
+}
+
+// Build a call to a builtin function.
+
+tree
+Gogo::call_builtin(tree* pdecl, source_location location, const char* name,
+ int nargs, tree rettype, ...)
+{
+ if (rettype == error_mark_node)
+ return error_mark_node;
+
+ tree* types = new tree[nargs];
+ tree* args = new tree[nargs];
+
+ va_list ap;
+ va_start(ap, rettype);
+ for (int i = 0; i < nargs; ++i)
+ {
+ types[i] = va_arg(ap, tree);
+ args[i] = va_arg(ap, tree);
+ if (types[i] == error_mark_node || args[i] == error_mark_node)
+ {
+ delete[] types;
+ delete[] args;
+ return error_mark_node;
+ }
+ }
+ va_end(ap);
+
+ if (*pdecl == NULL_TREE)
+ {
+ tree fnid = get_identifier(name);
+
+ tree argtypes = NULL_TREE;
+ tree* pp = &argtypes;
+ for (int i = 0; i < nargs; ++i)
+ {
+ *pp = tree_cons(NULL_TREE, types[i], NULL_TREE);
+ pp = &TREE_CHAIN(*pp);
+ }
+ *pp = void_list_node;
+
+ tree fntype = build_function_type(rettype, argtypes);
+
+ *pdecl = build_decl(BUILTINS_LOCATION, FUNCTION_DECL, fnid, fntype);
+ Gogo::mark_fndecl_as_builtin_library(*pdecl);
+ go_preserve_from_gc(*pdecl);
+ }
+
+ tree fnptr = build_fold_addr_expr(*pdecl);
+ if (CAN_HAVE_LOCATION_P(fnptr))
+ SET_EXPR_LOCATION(fnptr, location);
+
+ tree ret = build_call_array(rettype, fnptr, nargs, args);
+ SET_EXPR_LOCATION(ret, location);
+
+ delete[] types;
+ delete[] args;
+
+ return ret;
+}
+
+// Build a call to the runtime error function.
+
+tree
+Gogo::runtime_error(int code, source_location location)
+{
+ static tree runtime_error_fndecl;
+ tree ret = Gogo::call_builtin(&runtime_error_fndecl,
+ location,
+ "__go_runtime_error",
+ 1,
+ void_type_node,
+ integer_type_node,
+ build_int_cst(integer_type_node, code));
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // The runtime error function panics and does not return.
+ TREE_NOTHROW(runtime_error_fndecl) = 0;
+ TREE_THIS_VOLATILE(runtime_error_fndecl) = 1;
+ return ret;
+}
+
+// Send VAL on CHANNEL. If BLOCKING is true, the resulting tree has a
+// void type. If BLOCKING is false, the resulting tree has a boolean
+// type, and it will evaluate as true if the value was sent. If
+// FOR_SELECT is true, this is being done because it was chosen in a
+// select statement.
+
+tree
+Gogo::send_on_channel(tree channel, tree val, bool blocking, bool for_select,
+ source_location location)
+{
+ if (channel == error_mark_node || val == error_mark_node)
+ return error_mark_node;
+
+ if (int_size_in_bytes(TREE_TYPE(val)) <= 8
+ && !AGGREGATE_TYPE_P(TREE_TYPE(val))
+ && !FLOAT_TYPE_P(TREE_TYPE(val)))
+ {
+ val = convert_to_integer(uint64_type_node, val);
+ if (blocking)
+ {
+ static tree send_small_fndecl;
+ tree ret = Gogo::call_builtin(&send_small_fndecl,
+ location,
+ "__go_send_small",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ channel,
+ uint64_type_node,
+ val,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_small_fndecl) = 0;
+ return ret;
+ }
+ else
+ {
+ gcc_assert(!for_select);
+ static tree send_nonblocking_small_fndecl;
+ tree ret = Gogo::call_builtin(&send_nonblocking_small_fndecl,
+ location,
+ "__go_send_nonblocking_small",
+ 2,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ uint64_type_node,
+ val);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_nonblocking_small_fndecl) = 0;
+ return ret;
+ }
+ }
+ else
+ {
+ tree make_tmp;
+ if (TREE_ADDRESSABLE(TREE_TYPE(val)) || TREE_CODE(val) == VAR_DECL)
+ {
+ make_tmp = NULL_TREE;
+ val = build_fold_addr_expr(val);
+ if (DECL_P(val))
+ TREE_ADDRESSABLE(val) = 1;
+ }
+ else
+ {
+ tree tmp = create_tmp_var(TREE_TYPE(val), get_name(val));
+ DECL_IGNORED_P(tmp) = 0;
+ DECL_INITIAL(tmp) = val;
+ TREE_ADDRESSABLE(tmp) = 1;
+ make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ val = build_fold_addr_expr(tmp);
+ }
+ val = fold_convert(ptr_type_node, val);
+
+ tree call;
+ if (blocking)
+ {
+ static tree send_big_fndecl;
+ call = Gogo::call_builtin(&send_big_fndecl,
+ location,
+ "__go_send_big",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ val,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_big_fndecl) = 0;
+ }
+ else
+ {
+ gcc_assert(!for_select);
+ static tree send_nonblocking_big_fndecl;
+ call = Gogo::call_builtin(&send_nonblocking_big_fndecl,
+ location,
+ "__go_send_nonblocking_big",
+ 2,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ val);
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a
+ // closed channel.
+ TREE_NOTHROW(send_nonblocking_big_fndecl) = 0;
+ }
+
+ if (make_tmp == NULL_TREE)
+ return call;
+ else
+ {
+ tree ret = build2(COMPOUND_EXPR, TREE_TYPE(call), make_tmp, call);
+ SET_EXPR_LOCATION(ret, location);
+ return ret;
+ }
+ }
+}
+
+// Return a tree for receiving a value of type TYPE_TREE on CHANNEL.
+// This does a blocking receive and returns the value read from the
+// channel. If FOR_SELECT is true, this is being done because it was
+// chosen in a select statement.
+
+tree
+Gogo::receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location location)
+{
+ if (type_tree == error_mark_node || channel == error_mark_node)
+ return error_mark_node;
+
+ if (int_size_in_bytes(type_tree) <= 8
+ && !AGGREGATE_TYPE_P(type_tree)
+ && !FLOAT_TYPE_P(type_tree))
+ {
+ static tree receive_small_fndecl;
+ tree call = Gogo::call_builtin(&receive_small_fndecl,
+ location,
+ "__go_receive_small",
+ 2,
+ uint64_type_node,
+ ptr_type_node,
+ channel,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_small_fndecl) = 0;
+ int bitsize = GET_MODE_BITSIZE(TYPE_MODE(type_tree));
+ tree int_type_tree = go_type_for_size(bitsize, 1);
+ return fold_convert_loc(location, type_tree,
+ fold_convert_loc(location, int_type_tree,
+ call));
+ }
+ else
+ {
+ tree tmp = create_tmp_var(type_tree, get_name(type_tree));
+ DECL_IGNORED_P(tmp) = 0;
+ TREE_ADDRESSABLE(tmp) = 1;
+ tree make_tmp = build1(DECL_EXPR, void_type_node, tmp);
+ SET_EXPR_LOCATION(make_tmp, location);
+ tree tmpaddr = build_fold_addr_expr(tmp);
+ tmpaddr = fold_convert(ptr_type_node, tmpaddr);
+ static tree receive_big_fndecl;
+ tree call = Gogo::call_builtin(&receive_big_fndecl,
+ location,
+ "__go_receive_big",
+ 3,
+ boolean_type_node,
+ ptr_type_node,
+ channel,
+ ptr_type_node,
+ tmpaddr,
+ boolean_type_node,
+ (for_select
+ ? boolean_true_node
+ : boolean_false_node));
+ if (call == error_mark_node)
+ return error_mark_node;
+ // This can panic if there are too many operations on a closed
+ // channel.
+ TREE_NOTHROW(receive_big_fndecl) = 0;
+ return build2(COMPOUND_EXPR, type_tree, make_tmp,
+ build2(COMPOUND_EXPR, type_tree, call, tmp));
+ }
+}
+
+// Return the type of a function trampoline. This is like
+// get_trampoline_type in tree-nested.c.
+
+tree
+Gogo::trampoline_type_tree()
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ unsigned int size;
+ unsigned int align;
+ go_trampoline_info(&size, &align);
+ tree t = build_index_type(build_int_cst(integer_type_node, size - 1));
+ t = build_array_type(char_type_node, t);
+
+ type_tree = Gogo::builtin_struct(NULL, "__go_trampoline", NULL_TREE, 1,
+ "__data", t);
+ t = TYPE_FIELDS(type_tree);
+ DECL_ALIGN(t) = align;
+ DECL_USER_ALIGN(t) = 1;
+
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Make a trampoline which calls FNADDR passing CLOSURE.
+
+tree
+Gogo::make_trampoline(tree fnaddr, tree closure, source_location location)
+{
+ tree trampoline_type = Gogo::trampoline_type_tree();
+ tree trampoline_size = TYPE_SIZE_UNIT(trampoline_type);
+
+ closure = save_expr(closure);
+
+ // We allocate the trampoline using a special function which will
+ // mark it as executable.
+ static tree trampoline_fndecl;
+ tree x = Gogo::call_builtin(&trampoline_fndecl,
+ location,
+ "__go_allocate_trampoline",
+ 2,
+ ptr_type_node,
+ size_type_node,
+ trampoline_size,
+ ptr_type_node,
+ fold_convert_loc(location, ptr_type_node,
+ closure));
+ if (x == error_mark_node)
+ return error_mark_node;
+
+ x = save_expr(x);
+
+ // Initialize the trampoline.
+ tree ini = build_call_expr(implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE],
+ 3, x, fnaddr, closure);
+
+ // On some targets the trampoline address needs to be adjusted. For
+ // example, when compiling in Thumb mode on the ARM, the address
+ // needs to have the low bit set.
+ x = build_call_expr(implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
+ 1, x);
+ x = fold_convert(TREE_TYPE(fnaddr), x);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(x), ini, x);
+}
--- /dev/null
+// gogo.cc -- Go frontend parsed representation.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+#include "go-dump.h"
+#include "lex.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "dataflow.h"
+#include "import.h"
+#include "export.h"
+#include "gogo.h"
+
+// Class Gogo.
+
+Gogo::Gogo(int int_type_size, int float_type_size, int pointer_size)
+ : package_(NULL),
+ functions_(),
+ globals_(new Bindings(NULL)),
+ imports_(),
+ imported_unsafe_(false),
+ packages_(),
+ map_descriptors_(NULL),
+ type_descriptor_decls_(NULL),
+ init_functions_(),
+ need_init_fn_(false),
+ init_fn_name_(),
+ imported_init_fns_(),
+ unique_prefix_(),
+ interface_types_()
+{
+ const source_location loc = BUILTINS_LOCATION;
+
+ Named_type* uint8_type = Type::make_integer_type("uint8", true, 8,
+ RUNTIME_TYPE_KIND_UINT8);
+ this->add_named_type(uint8_type);
+ this->add_named_type(Type::make_integer_type("uint16", true, 16,
+ RUNTIME_TYPE_KIND_UINT16));
+ this->add_named_type(Type::make_integer_type("uint32", true, 32,
+ RUNTIME_TYPE_KIND_UINT32));
+ this->add_named_type(Type::make_integer_type("uint64", true, 64,
+ RUNTIME_TYPE_KIND_UINT64));
+
+ this->add_named_type(Type::make_integer_type("int8", false, 8,
+ RUNTIME_TYPE_KIND_INT8));
+ this->add_named_type(Type::make_integer_type("int16", false, 16,
+ RUNTIME_TYPE_KIND_INT16));
+ this->add_named_type(Type::make_integer_type("int32", false, 32,
+ RUNTIME_TYPE_KIND_INT32));
+ this->add_named_type(Type::make_integer_type("int64", false, 64,
+ RUNTIME_TYPE_KIND_INT64));
+
+ this->add_named_type(Type::make_float_type("float32", 32,
+ RUNTIME_TYPE_KIND_FLOAT32));
+ this->add_named_type(Type::make_float_type("float64", 64,
+ RUNTIME_TYPE_KIND_FLOAT64));
+
+ this->add_named_type(Type::make_complex_type("complex64", 64,
+ RUNTIME_TYPE_KIND_COMPLEX64));
+ this->add_named_type(Type::make_complex_type("complex128", 128,
+ RUNTIME_TYPE_KIND_COMPLEX128));
+
+ if (int_type_size < 32)
+ int_type_size = 32;
+ this->add_named_type(Type::make_integer_type("uint", true,
+ int_type_size,
+ RUNTIME_TYPE_KIND_UINT));
+ Named_type* int_type = Type::make_integer_type("int", false, int_type_size,
+ RUNTIME_TYPE_KIND_INT);
+ this->add_named_type(int_type);
+
+ // "byte" is an alias for "uint8". Construct a Named_object which
+ // points to UINT8_TYPE. Note that this breaks the normal pairing
+ // in which a Named_object points to a Named_type which points back
+ // to the same Named_object.
+ Named_object* byte_type = this->declare_type("byte", loc);
+ byte_type->set_type_value(uint8_type);
+
+ this->add_named_type(Type::make_integer_type("uintptr", true,
+ pointer_size,
+ RUNTIME_TYPE_KIND_UINTPTR));
+
+ this->add_named_type(Type::make_float_type("float", float_type_size,
+ RUNTIME_TYPE_KIND_FLOAT));
+
+ this->add_named_type(Type::make_complex_type("complex", float_type_size * 2,
+ RUNTIME_TYPE_KIND_COMPLEX));
+
+ this->add_named_type(Type::make_named_bool_type());
+
+ this->add_named_type(Type::make_named_string_type());
+
+ this->globals_->add_constant(Typed_identifier("true",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(true, loc),
+ 0);
+ this->globals_->add_constant(Typed_identifier("false",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(false, loc),
+ 0);
+
+ this->globals_->add_constant(Typed_identifier("nil", Type::make_nil_type(),
+ loc),
+ NULL,
+ Expression::make_nil(loc),
+ 0);
+
+ Type* abstract_int_type = Type::make_abstract_integer_type();
+ this->globals_->add_constant(Typed_identifier("iota", abstract_int_type,
+ loc),
+ NULL,
+ Expression::make_iota(),
+ 0);
+
+ Function_type* new_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ new_type->set_is_varargs();
+ new_type->set_is_builtin();
+ this->globals_->add_function_declaration("new", NULL, new_type, loc);
+
+ Function_type* make_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ make_type->set_is_varargs();
+ make_type->set_is_builtin();
+ this->globals_->add_function_declaration("make", NULL, make_type, loc);
+
+ Typed_identifier_list* len_result = new Typed_identifier_list();
+ len_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* len_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ len_type->set_is_builtin();
+ this->globals_->add_function_declaration("len", NULL, len_type, loc);
+
+ Typed_identifier_list* cap_result = new Typed_identifier_list();
+ cap_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* cap_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ cap_type->set_is_builtin();
+ this->globals_->add_function_declaration("cap", NULL, cap_type, loc);
+
+ Function_type* print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("print", NULL, print_type, loc);
+
+ print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("println", NULL, print_type, loc);
+
+ Type *empty = Type::make_interface_type(NULL, loc);
+ Typed_identifier_list* panic_parms = new Typed_identifier_list();
+ panic_parms->push_back(Typed_identifier("e", empty, loc));
+ Function_type *panic_type = Type::make_function_type(NULL, panic_parms,
+ NULL, loc);
+ panic_type->set_is_builtin();
+ this->globals_->add_function_declaration("panic", NULL, panic_type, loc);
+
+ Typed_identifier_list* recover_result = new Typed_identifier_list();
+ recover_result->push_back(Typed_identifier("", empty, loc));
+ Function_type* recover_type = Type::make_function_type(NULL, NULL,
+ recover_result,
+ loc);
+ recover_type->set_is_builtin();
+ this->globals_->add_function_declaration("recover", NULL, recover_type, loc);
+
+ Function_type* close_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ close_type->set_is_varargs();
+ close_type->set_is_builtin();
+ this->globals_->add_function_declaration("close", NULL, close_type, loc);
+
+ Typed_identifier_list* closed_result = new Typed_identifier_list();
+ closed_result->push_back(Typed_identifier("", Type::lookup_bool_type(),
+ loc));
+ Function_type* closed_type = Type::make_function_type(NULL, NULL,
+ closed_result, loc);
+ closed_type->set_is_varargs();
+ closed_type->set_is_builtin();
+ this->globals_->add_function_declaration("closed", NULL, closed_type, loc);
+
+ Typed_identifier_list* copy_result = new Typed_identifier_list();
+ copy_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* copy_type = Type::make_function_type(NULL, NULL,
+ copy_result, loc);
+ copy_type->set_is_varargs();
+ copy_type->set_is_builtin();
+ this->globals_->add_function_declaration("copy", NULL, copy_type, loc);
+
+ Function_type* append_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ append_type->set_is_varargs();
+ append_type->set_is_builtin();
+ this->globals_->add_function_declaration("append", NULL, append_type, loc);
+
+ Function_type* cmplx_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ cmplx_type->set_is_varargs();
+ cmplx_type->set_is_builtin();
+ this->globals_->add_function_declaration("cmplx", NULL, cmplx_type, loc);
+
+ Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ real_type->set_is_varargs();
+ real_type->set_is_builtin();
+ this->globals_->add_function_declaration("real", NULL, real_type, loc);
+
+ Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ imag_type->set_is_varargs();
+ imag_type->set_is_builtin();
+ this->globals_->add_function_declaration("imag", NULL, cmplx_type, loc);
+
+ this->define_builtin_function_trees();
+
+ // Declare "init", to ensure that it is not defined with parameters
+ // or return values.
+ this->declare_function("init",
+ Type::make_function_type(NULL, NULL, NULL, loc),
+ loc);
+}
+
+// Munge name for use in an error message.
+
+std::string
+Gogo::message_name(const std::string& name)
+{
+ return go_localize_identifier(Gogo::unpack_hidden_name(name).c_str());
+}
+
+// Get the package name.
+
+const std::string&
+Gogo::package_name() const
+{
+ gcc_assert(this->package_ != NULL);
+ return this->package_->name();
+}
+
+// Set the package name.
+
+void
+Gogo::set_package_name(const std::string& package_name,
+ source_location location)
+{
+ if (this->package_ != NULL && this->package_->name() != package_name)
+ {
+ error_at(location, "expected package %<%s%>",
+ Gogo::message_name(this->package_->name()).c_str());
+ return;
+ }
+
+ // If the user did not specify a unique prefix, we always use "go".
+ // This in effect requires that the package name be unique.
+ if (this->unique_prefix_.empty())
+ this->unique_prefix_ = "go";
+
+ this->package_ = this->register_package(package_name, this->unique_prefix_,
+ location);
+
+ // We used to permit people to qualify symbols with the current
+ // package name (e.g., P.x), but we no longer do.
+ // this->globals_->add_package(package_name, this->package_);
+
+ if (package_name == "main")
+ {
+ // Declare "main" as a function which takes no parameters and
+ // returns no value.
+ this->declare_function("main",
+ Type::make_function_type(NULL, NULL, NULL,
+ BUILTINS_LOCATION),
+ BUILTINS_LOCATION);
+ }
+}
+
+// Import a package.
+
+void
+Gogo::import_package(const std::string& filename,
+ const std::string& local_name,
+ bool is_local_name_exported,
+ source_location location)
+{
+ if (filename == "unsafe")
+ {
+ this->import_unsafe(local_name, is_local_name_exported, location);
+ return;
+ }
+
+ Imports::const_iterator p = this->imports_.find(filename);
+ if (p != this->imports_.end())
+ {
+ Package* package = p->second;
+ package->set_location(location);
+ package->set_is_imported();
+ std::string ln = local_name;
+ bool is_ln_exported = is_local_name_exported;
+ if (ln.empty())
+ {
+ ln = package->name();
+ is_ln_exported = Lex::is_exported_name(ln);
+ }
+ if (ln != ".")
+ {
+ ln = this->pack_hidden_name(ln, is_ln_exported);
+ this->package_->bindings()->add_package(ln, package);
+ }
+ else
+ {
+ Bindings* bindings = package->bindings();
+ for (Bindings::const_declarations_iterator p =
+ bindings->begin_declarations();
+ p != bindings->end_declarations();
+ ++p)
+ this->add_named_object(p->second);
+ }
+ return;
+ }
+
+ Import::Stream* stream = Import::open_package(filename, location);
+ if (stream == NULL)
+ {
+ error_at(location, "import file %qs not found", filename.c_str());
+ return;
+ }
+
+ Import imp(stream, location);
+ imp.register_builtin_types(this);
+ Package* package = imp.import(this, local_name, is_local_name_exported);
+ this->imports_.insert(std::make_pair(filename, package));
+ package->set_is_imported();
+
+ delete stream;
+}
+
+// Add an import control function for an imported package to the list.
+
+void
+Gogo::add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio)
+{
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ {
+ if (p->init_name() == init_name
+ && (p->package_name() != package_name || p->priority() != prio))
+ {
+ error("duplicate package initialization name %qs",
+ Gogo::message_name(init_name).c_str());
+ inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
+ Gogo::message_name(p->package_name()).c_str(),
+ p->priority());
+ inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
+ Gogo::message_name(package_name).c_str(), prio);
+ return;
+ }
+ }
+
+ this->imported_init_fns_.insert(Import_init(package_name, init_name,
+ prio));
+}
+
+// Return whether we are at the global binding level.
+
+bool
+Gogo::in_global_scope() const
+{
+ return this->functions_.empty();
+}
+
+// Return the current binding contour.
+
+Bindings*
+Gogo::current_bindings()
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+const Bindings*
+Gogo::current_bindings() const
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+// Return the current block.
+
+Block*
+Gogo::current_block()
+{
+ if (this->functions_.empty())
+ return NULL;
+ else
+ return this->functions_.back().blocks.back();
+}
+
+// Look up a name in the current binding contour. If PFUNCTION is not
+// NULL, set it to the function in which the name is defined, or NULL
+// if the name is defined in global scope.
+
+Named_object*
+Gogo::lookup(const std::string& name, Named_object** pfunction) const
+{
+ if (Gogo::is_sink_name(name))
+ return Named_object::make_sink();
+
+ for (Open_functions::const_reverse_iterator p = this->functions_.rbegin();
+ p != this->functions_.rend();
+ ++p)
+ {
+ Named_object* ret = p->blocks.back()->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (pfunction != NULL)
+ *pfunction = p->function;
+ return ret;
+ }
+ }
+
+ if (pfunction != NULL)
+ *pfunction = NULL;
+
+ if (this->package_ != NULL)
+ {
+ Named_object* ret = this->package_->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (ret->package() != NULL)
+ ret->package()->set_used();
+ return ret;
+ }
+ }
+
+ // We do not look in the global namespace. If we did, the global
+ // namespace would effectively hide names which were defined in
+ // package scope which we have not yet seen. Instead,
+ // define_global_names is called after parsing is over to connect
+ // undefined names at package scope with names defined at global
+ // scope.
+
+ return NULL;
+}
+
+// Look up a name in the current block, without searching enclosing
+// blocks.
+
+Named_object*
+Gogo::lookup_in_block(const std::string& name) const
+{
+ gcc_assert(!this->functions_.empty());
+ gcc_assert(!this->functions_.back().blocks.empty());
+ return this->functions_.back().blocks.back()->bindings()->lookup_local(name);
+}
+
+// Look up a name in the global namespace.
+
+Named_object*
+Gogo::lookup_global(const char* name) const
+{
+ return this->globals_->lookup(name);
+}
+
+// Add an imported package.
+
+Package*
+Gogo::add_imported_package(const std::string& real_name,
+ const std::string& alias_arg,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals)
+{
+ // FIXME: Now that we compile packages as a whole, should we permit
+ // importing the current package?
+ if (this->package_name() == real_name
+ && this->unique_prefix() == unique_prefix)
+ {
+ *padd_to_globals = false;
+ if (!alias_arg.empty() && alias_arg != ".")
+ {
+ std::string alias = this->pack_hidden_name(alias_arg,
+ is_alias_exported);
+ this->package_->bindings()->add_package(alias, this->package_);
+ }
+ return this->package_;
+ }
+ else if (alias_arg == ".")
+ {
+ *padd_to_globals = true;
+ return this->register_package(real_name, unique_prefix, location);
+ }
+ else if (alias_arg == "_")
+ {
+ Package* ret = this->register_package(real_name, unique_prefix, location);
+ ret->set_uses_sink_alias();
+ return ret;
+ }
+ else
+ {
+ *padd_to_globals = false;
+ std::string alias = alias_arg;
+ if (alias.empty())
+ {
+ alias = real_name;
+ is_alias_exported = Lex::is_exported_name(alias);
+ }
+ alias = this->pack_hidden_name(alias, is_alias_exported);
+ Named_object* no = this->add_package(real_name, alias, unique_prefix,
+ location);
+ if (!no->is_package())
+ return NULL;
+ return no->package_value();
+ }
+}
+
+// Add a package.
+
+Named_object*
+Gogo::add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location)
+{
+ gcc_assert(this->in_global_scope());
+
+ // Register the package. Note that we might have already seen it in
+ // an earlier import.
+ Package* package = this->register_package(real_name, unique_prefix, location);
+
+ return this->package_->bindings()->add_package(alias, package);
+}
+
+// Register a package. This package may or may not be imported. This
+// returns the Package structure for the package, creating if it
+// necessary.
+
+Package*
+Gogo::register_package(const std::string& package_name,
+ const std::string& unique_prefix,
+ source_location location)
+{
+ gcc_assert(!unique_prefix.empty() && !package_name.empty());
+ std::string name = unique_prefix + '.' + package_name;
+ Package* package = NULL;
+ std::pair<Packages::iterator, bool> ins =
+ this->packages_.insert(std::make_pair(name, package));
+ if (!ins.second)
+ {
+ // We have seen this package name before.
+ package = ins.first->second;
+ gcc_assert(package != NULL);
+ gcc_assert(package->name() == package_name
+ && package->unique_prefix() == unique_prefix);
+ if (package->location() == UNKNOWN_LOCATION)
+ package->set_location(location);
+ }
+ else
+ {
+ // First time we have seen this package name.
+ package = new Package(package_name, unique_prefix, location);
+ gcc_assert(ins.first->second == NULL);
+ ins.first->second = package;
+ }
+
+ return package;
+}
+
+// Start compiling a function.
+
+Named_object*
+Gogo::start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location location)
+{
+ bool at_top_level = this->functions_.empty();
+
+ Block* block = new Block(NULL, location);
+
+ Function* enclosing = (at_top_level
+ ? NULL
+ : this->functions_.back().function->func_value());
+
+ Function* function = new Function(type, enclosing, block, location);
+
+ if (type->is_method())
+ {
+ const Typed_identifier* receiver = type->receiver();
+ Variable* this_param = new Variable(receiver->type(), NULL, false,
+ true, true, location);
+ std::string name = receiver->name();
+ if (name.empty())
+ {
+ // We need to give receivers a name since they wind up in
+ // DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "r.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, this_param);
+ }
+
+ const Typed_identifier_list* parameters = type->parameters();
+ bool is_varargs = type->is_varargs();
+ if (parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ Variable* param = new Variable(p->type(), NULL, false, true, false,
+ location);
+ if (is_varargs && p + 1 == parameters->end())
+ param->set_is_varargs_parameter();
+
+ std::string name = p->name();
+ if (name.empty() || Gogo::is_sink_name(name))
+ {
+ // We need to give parameters a name since they wind up
+ // in DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "p.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, param);
+ }
+ }
+
+ function->create_named_result_variables();
+
+ const std::string* pname;
+ std::string nested_name;
+ if (!name.empty())
+ pname = &name;
+ else
+ {
+ // Invent a name for a nested function.
+ static int nested_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$nested%d", nested_count);
+ ++nested_count;
+ nested_name = buf;
+ pname = &nested_name;
+ }
+
+ Named_object* ret;
+ if (Gogo::is_sink_name(*pname))
+ ret = Named_object::make_sink();
+ else if (!type->is_method())
+ {
+ ret = this->package_->bindings()->add_function(*pname, NULL, function);
+ if (!ret->is_function())
+ {
+ // Redefinition error.
+ ret = Named_object::make_function(name, NULL, function);
+ }
+ }
+ else
+ {
+ if (!add_method_to_type)
+ ret = Named_object::make_function(name, NULL, function);
+ else
+ {
+ gcc_assert(at_top_level);
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ ret = Named_object::make_function(name, NULL, function);
+ else if (rtype->named_type() != NULL)
+ {
+ ret = rtype->named_type()->add_method(name, function);
+ if (!ret->is_function())
+ {
+ // Redefinition error.
+ ret = Named_object::make_function(name, NULL, function);
+ }
+ }
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Named_object* type_no =
+ rtype->forward_declaration_type()->named_object();
+ if (type_no->is_unknown())
+ {
+ // If we are seeing methods it really must be a
+ // type. Declare it as such. An alternative would
+ // be to support lists of methods for unknown
+ // expressions. Either way the error messages if
+ // this is not a type are going to get confusing.
+ Named_object* declared =
+ this->declare_package_type(type_no->name(),
+ type_no->location());
+ gcc_assert(declared
+ == type_no->unknown_value()->real_named_object());
+ }
+ ret = rtype->forward_declaration_type()->add_method(name,
+ function);
+ }
+ else
+ gcc_unreachable();
+ }
+ this->package_->bindings()->add_method(ret);
+ }
+
+ this->functions_.resize(this->functions_.size() + 1);
+ Open_function& of(this->functions_.back());
+ of.function = ret;
+ of.blocks.push_back(block);
+
+ if (!type->is_method() && Gogo::unpack_hidden_name(name) == "init")
+ {
+ this->init_functions_.push_back(ret);
+ this->need_init_fn_ = true;
+ }
+
+ return ret;
+}
+
+// Finish compiling a function.
+
+void
+Gogo::finish_function(source_location location)
+{
+ this->finish_block(location);
+ gcc_assert(this->functions_.back().blocks.empty());
+ this->functions_.pop_back();
+}
+
+// Return the current function.
+
+Named_object*
+Gogo::current_function() const
+{
+ gcc_assert(!this->functions_.empty());
+ return this->functions_.back().function;
+}
+
+// Start a new block.
+
+void
+Gogo::start_block(source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ Block* block = new Block(this->current_block(), location);
+ this->functions_.back().blocks.push_back(block);
+}
+
+// Finish a block.
+
+Block*
+Gogo::finish_block(source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ gcc_assert(!this->functions_.back().blocks.empty());
+ Block* block = this->functions_.back().blocks.back();
+ this->functions_.back().blocks.pop_back();
+ block->set_end_location(location);
+ return block;
+}
+
+// Add an unknown name.
+
+Named_object*
+Gogo::add_unknown_name(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_unknown_name(name, location);
+}
+
+// Declare a function.
+
+Named_object*
+Gogo::declare_function(const std::string& name, Function_type* type,
+ source_location location)
+{
+ if (!type->is_method())
+ return this->current_bindings()->add_function_declaration(name, NULL, type,
+ location);
+ else
+ {
+ // We don't bother to add this to the list of global
+ // declarations.
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ return NULL;
+ else if (rtype->named_type() != NULL)
+ return rtype->named_type()->add_method_declaration(name, NULL, type,
+ location);
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Forward_declaration_type* ftype = rtype->forward_declaration_type();
+ return ftype->add_method_declaration(name, type, location);
+ }
+ else
+ gcc_unreachable();
+ }
+}
+
+// Add a label definition.
+
+Label*
+Gogo::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ Label* label = func->add_label_definition(label_name, location);
+ this->add_statement(Statement::make_label_statement(label, location));
+ return label;
+}
+
+// Add a label reference.
+
+Label*
+Gogo::add_label_reference(const std::string& label_name)
+{
+ gcc_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ return func->add_label_reference(label_name);
+}
+
+// Add a statement.
+
+void
+Gogo::add_statement(Statement* statement)
+{
+ gcc_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a block.
+
+void
+Gogo::add_block(Block* block, source_location location)
+{
+ gcc_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ Statement* statement = Statement::make_block_statement(block, location);
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a constant.
+
+Named_object*
+Gogo::add_constant(const Typed_identifier& tid, Expression* expr,
+ int iota_value)
+{
+ return this->current_bindings()->add_constant(tid, NULL, expr, iota_value);
+}
+
+// Add a type.
+
+void
+Gogo::add_type(const std::string& name, Type* type, source_location location)
+{
+ Named_object* no = this->current_bindings()->add_type(name, NULL, type,
+ location);
+ if (!this->in_global_scope())
+ no->type_value()->set_in_function(this->functions_.back().function);
+}
+
+// Add a named type.
+
+void
+Gogo::add_named_type(Named_type* type)
+{
+ gcc_assert(this->in_global_scope());
+ this->current_bindings()->add_named_type(type);
+}
+
+// Declare a type.
+
+Named_object*
+Gogo::declare_type(const std::string& name, source_location location)
+{
+ Bindings* bindings = this->current_bindings();
+ Named_object* no = bindings->add_type_declaration(name, NULL, location);
+ if (!this->in_global_scope())
+ {
+ Named_object* f = this->functions_.back().function;
+ no->type_declaration_value()->set_in_function(f);
+ }
+ return no;
+}
+
+// Declare a type at the package level.
+
+Named_object*
+Gogo::declare_package_type(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_type_declaration(name, NULL, location);
+}
+
+// Define a type which was already declared.
+
+void
+Gogo::define_type(Named_object* no, Named_type* type)
+{
+ this->current_bindings()->define_type(no, type);
+}
+
+// Add a variable.
+
+Named_object*
+Gogo::add_variable(const std::string& name, Variable* variable)
+{
+ Named_object* no = this->current_bindings()->add_variable(name, NULL,
+ variable);
+
+ // In a function the middle-end wants to see a DECL_EXPR node.
+ if (no != NULL
+ && no->is_variable()
+ && !no->var_value()->is_parameter()
+ && !this->functions_.empty())
+ this->add_statement(Statement::make_variable_declaration(no));
+
+ return no;
+}
+
+// Add a sink--a reference to the blank identifier _.
+
+Named_object*
+Gogo::add_sink()
+{
+ return Named_object::make_sink();
+}
+
+// Add a named object.
+
+void
+Gogo::add_named_object(Named_object* no)
+{
+ this->current_bindings()->add_named_object(no);
+}
+
+// Record that we've seen an interface type.
+
+void
+Gogo::record_interface_type(Interface_type* itype)
+{
+ this->interface_types_.push_back(itype);
+}
+
+// Return a name for a thunk object.
+
+std::string
+Gogo::thunk_name()
+{
+ static int thunk_count;
+ char thunk_name[50];
+ snprintf(thunk_name, sizeof thunk_name, "$thunk%d", thunk_count);
+ ++thunk_count;
+ return thunk_name;
+}
+
+// Return whether a function is a thunk.
+
+bool
+Gogo::is_thunk(const Named_object* no)
+{
+ return no->name().compare(0, 6, "$thunk") == 0;
+}
+
+// Define the global names. We do this only after parsing all the
+// input files, because the program might define the global names
+// itself.
+
+void
+Gogo::define_global_names()
+{
+ for (Bindings::const_declarations_iterator p =
+ this->globals_->begin_declarations();
+ p != this->globals_->end_declarations();
+ ++p)
+ {
+ Named_object* global_no = p->second;
+ std::string name(Gogo::pack_hidden_name(global_no->name(), false));
+ Named_object* no = this->package_->bindings()->lookup(name);
+ if (no == NULL)
+ continue;
+ no = no->resolve();
+ if (no->is_type_declaration())
+ {
+ if (global_no->is_type())
+ {
+ if (no->type_declaration_value()->has_methods())
+ error_at(no->location(),
+ "may not define methods for global type");
+ no->set_type_value(global_no->type_value());
+ }
+ else
+ {
+ error_at(no->location(), "expected type");
+ Type* errtype = Type::make_error_type();
+ Named_object* err = Named_object::make_type("error", NULL,
+ errtype,
+ BUILTINS_LOCATION);
+ no->set_type_value(err->type_value());
+ }
+ }
+ else if (no->is_unknown())
+ no->unknown_value()->set_real_named_object(global_no);
+ }
+}
+
+// Clear out names in file scope.
+
+void
+Gogo::clear_file_scope()
+{
+ this->package_->bindings()->clear_file_scope();
+
+ // Warn about packages which were imported but not used.
+ for (Packages::iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ Package* package = p->second;
+ if (package != this->package_
+ && package->is_imported()
+ && !package->used()
+ && !package->uses_sink_alias()
+ && !saw_errors())
+ error_at(package->location(), "imported and not used: %s",
+ Gogo::message_name(package->name()).c_str());
+ package->clear_is_imported();
+ package->clear_uses_sink_alias();
+ package->clear_used();
+ }
+}
+
+// Traverse the tree.
+
+void
+Gogo::traverse(Traverse* traverse)
+{
+ // Traverse the current package first for consistency. The other
+ // packages will only contain imported types, constants, and
+ // declarations.
+ if (this->package_->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ return;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ if (p->second != this->package_)
+ {
+ if (p->second->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ break;
+ }
+ }
+}
+
+// Traversal class used to verify types.
+
+class Verify_types : public Traverse
+{
+ public:
+ Verify_types()
+ : Traverse(traverse_types)
+ { }
+
+ int
+ type(Type*);
+};
+
+// Verify that a type is correct.
+
+int
+Verify_types::type(Type* t)
+{
+ // Don't verify types defined in other packages.
+ Named_type* nt = t->named_type();
+ if (nt != NULL && nt->named_object()->package() != NULL)
+ return TRAVERSE_SKIP_COMPONENTS;
+
+ if (!t->verify())
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that all types are correct.
+
+void
+Gogo::verify_types()
+{
+ Verify_types traverse;
+ this->traverse(&traverse);
+}
+
+// Traversal class used to lower parse tree.
+
+class Lower_parse_tree : public Traverse
+{
+ public:
+ Lower_parse_tree(Gogo* gogo, Named_object* function)
+ : Traverse(traverse_constants
+ | traverse_functions
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo), function_(function), iota_value_(-1)
+ { }
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ function(Named_object*);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+ // The function we are traversing.
+ Named_object* function_;
+ // Value to use for the predeclared constant iota.
+ int iota_value_;
+};
+
+// Lower constants. We handle constants specially so that we can set
+// the right value for the predeclared constant iota. This works in
+// conjunction with the way we lower Const_expression objects.
+
+int
+Lower_parse_tree::constant(Named_object* no, bool)
+{
+ Named_constant* nc = no->const_value();
+
+ // We can recursively a constant if the initializer expression
+ // manages to refer to itself.
+ if (nc->lowering())
+ return TRAVERSE_CONTINUE;
+ nc->set_lowering();
+
+ gcc_assert(this->iota_value_ == -1);
+ this->iota_value_ = nc->iota_value();
+ nc->traverse_expression(this);
+ this->iota_value_ = -1;
+
+ nc->clear_lowering();
+
+ // We will traverse the expression a second time, but that will be
+ // fast.
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower function closure types. Record the function while lowering
+// it, so that we can pass it down when lowering an expression.
+
+int
+Lower_parse_tree::function(Named_object* no)
+{
+ no->func_value()->set_closure_type();
+
+ gcc_assert(this->function_ == NULL);
+ this->function_ = no;
+ int t = no->func_value()->traverse(this);
+ this->function_ = NULL;
+
+ if (t == TRAVERSE_EXIT)
+ return t;
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower statement parse trees.
+
+int
+Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
+{
+ // Lower the expressions first.
+ int t = sorig->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+
+ // Keep lowering until nothing changes.
+ Statement* s = sorig;
+ while (true)
+ {
+ Statement* snew = s->lower(this->gogo_, block);
+ if (snew == s)
+ break;
+ s = snew;
+ t = s->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+ }
+
+ if (s != sorig)
+ block->replace_statement(*pindex, s);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower expression parse trees.
+
+int
+Lower_parse_tree::expression(Expression** pexpr)
+{
+ // We have to lower all subexpressions first, so that we can get
+ // their type if necessary. This is awkward, because we don't have
+ // a postorder traversal pass.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ // Keep lowering until nothing changes.
+ while (true)
+ {
+ Expression* e = *pexpr;
+ Expression* enew = e->lower(this->gogo_, this->function_,
+ this->iota_value_);
+ if (enew == e)
+ break;
+ *pexpr = enew;
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower the parse tree. This is called after the parse is complete,
+// when all names should be resolved.
+
+void
+Gogo::lower_parse_tree()
+{
+ Lower_parse_tree lower_parse_tree(this, NULL);
+ this->traverse(&lower_parse_tree);
+}
+
+// Lower an expression.
+
+void
+Gogo::lower_expression(Named_object* function, Expression** pexpr)
+{
+ Lower_parse_tree lower_parse_tree(this, function);
+ lower_parse_tree.expression(pexpr);
+}
+
+// Lower a constant. This is called when lowering a reference to a
+// constant. We have to make sure that the constant has already been
+// lowered.
+
+void
+Gogo::lower_constant(Named_object* no)
+{
+ gcc_assert(no->is_const());
+ Lower_parse_tree lower(this, NULL);
+ lower.constant(no, false);
+}
+
+// Look for interface types to finalize methods of inherited
+// interfaces.
+
+class Finalize_methods : public Traverse
+{
+ public:
+ Finalize_methods(Gogo* gogo)
+ : Traverse(traverse_types),
+ gogo_(gogo)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ Gogo* gogo_;
+};
+
+// Finalize the methods of an interface type.
+
+int
+Finalize_methods::type(Type* t)
+{
+ // Check the classification so that we don't finalize the methods
+ // twice for a named interface type.
+ switch (t->classification())
+ {
+ case Type::TYPE_INTERFACE:
+ t->interface_type()->finalize_methods();
+ break;
+
+ case Type::TYPE_NAMED:
+ {
+ // We have to finalize the methods of the real type first.
+ // But if the real type is a struct type, then we only want to
+ // finalize the methods of the field types, not of the struct
+ // type itself. We don't want to add methods to the struct,
+ // since it has a name.
+ Type* rt = t->named_type()->real_type();
+ if (rt->classification() != Type::TYPE_STRUCT)
+ {
+ if (Type::traverse(rt, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ else
+ {
+ if (rt->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ t->named_type()->finalize_methods(this->gogo_);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ case Type::TYPE_STRUCT:
+ t->struct_type()->finalize_methods(this->gogo_);
+ break;
+
+ default:
+ break;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Finalize method lists and build stub methods for types.
+
+void
+Gogo::finalize_methods()
+{
+ Finalize_methods finalize(this);
+ this->traverse(&finalize);
+}
+
+// Set types for unspecified variables and constants.
+
+void
+Gogo::determine_types()
+{
+ Bindings* bindings = this->current_bindings();
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_function())
+ (*p)->func_value()->determine_types();
+ else if ((*p)->is_variable())
+ (*p)->var_value()->determine_type();
+ else if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+
+ // See if a variable requires us to build an initialization
+ // function. We know that we will see all global variables
+ // here.
+ if (!this->need_init_fn_ && (*p)->is_variable())
+ {
+ Variable* variable = (*p)->var_value();
+
+ // If this is a global variable which requires runtime
+ // initialization, we need an initialization function.
+ if (!variable->is_global() || variable->init() == NULL)
+ ;
+ else if (variable->type()->interface_type() != NULL)
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_constant())
+ ;
+ else if (!variable->init()->is_composite_literal())
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_nonconstant_composite_literal())
+ this->need_init_fn_ = true;
+
+ // If this is a global variable which holds a pointer value,
+ // then we need an initialization function to register it as a
+ // GC root.
+ if (variable->is_global() && variable->type()->has_pointer())
+ this->need_init_fn_ = true;
+ }
+ }
+
+ // Determine the types of constants in packages.
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ p->second->determine_types();
+}
+
+// Traversal class used for type checking.
+
+class Check_types_traverse : public Traverse
+{
+ public:
+ Check_types_traverse(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_constants
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+};
+
+// Check that a variable initializer has the right type.
+
+int
+Check_types_traverse::variable(Named_object* named_object)
+{
+ if (named_object->is_variable())
+ {
+ Variable* var = named_object->var_value();
+ Expression* init = var->init();
+ std::string reason;
+ if (init != NULL
+ && !Type::are_assignable(var->type(), init->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(var->location(), "incompatible type in initialization");
+ else
+ error_at(var->location(),
+ "incompatible type in initialization (%s)",
+ reason.c_str());
+ var->clear_init();
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that a constant initializer has the right type.
+
+int
+Check_types_traverse::constant(Named_object* named_object, bool)
+{
+ Named_constant* constant = named_object->const_value();
+ Type* ctype = constant->type();
+ if (ctype->integer_type() == NULL
+ && ctype->float_type() == NULL
+ && ctype->complex_type() == NULL
+ && !ctype->is_boolean_type()
+ && !ctype->is_string_type())
+ {
+ error_at(constant->location(), "invalid constant type");
+ constant->set_error();
+ }
+ else if (!constant->expr()->is_constant())
+ {
+ error_at(constant->expr()->location(), "expression is not constant");
+ constant->set_error();
+ }
+ else if (!Type::are_assignable(constant->type(), constant->expr()->type(),
+ NULL))
+ {
+ error_at(constant->location(),
+ "initialization expression has wrong type");
+ constant->set_error();
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in a statement.
+
+int
+Check_types_traverse::statement(Block*, size_t*, Statement* s)
+{
+ s->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in an expression.
+
+int
+Check_types_traverse::expression(Expression** expr)
+{
+ (*expr)->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid.
+
+void
+Gogo::check_types()
+{
+ Check_types_traverse traverse(this);
+ this->traverse(&traverse);
+}
+
+// Check the types in a single block.
+
+void
+Gogo::check_types_in_block(Block* block)
+{
+ Check_types_traverse traverse(this);
+ block->traverse(&traverse);
+}
+
+// A traversal class used to find a single shortcut operator within an
+// expression.
+
+class Find_shortcut : public Traverse
+{
+ public:
+ Find_shortcut()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ found_(NULL)
+ { }
+
+ // A pointer to the expression which was found, or NULL if none was
+ // found.
+ Expression**
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ Expression** found_;
+};
+
+// Find a shortcut expression.
+
+int
+Find_shortcut::expression(Expression** pexpr)
+{
+ Expression* expr = *pexpr;
+ Binary_expression* be = expr->binary_expression();
+ if (be == NULL)
+ return TRAVERSE_CONTINUE;
+ Operator op = be->op();
+ if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
+ return TRAVERSE_CONTINUE;
+ gcc_assert(this->found_ == NULL);
+ this->found_ = pexpr;
+ return TRAVERSE_EXIT;
+}
+
+// A traversal class used to turn shortcut operators into explicit if
+// statements.
+
+class Shortcuts : public Traverse
+{
+ public:
+ Shortcuts()
+ : Traverse(traverse_variables
+ | traverse_statements)
+ { }
+
+ protected:
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+
+ private:
+ // Convert a shortcut operator.
+ Statement*
+ convert_shortcut(Block* enclosing, Expression** pshortcut);
+};
+
+// Remove shortcut operators in a single statement.
+
+int
+Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+
+ // If S is a variable declaration, then ordinary traversal won't
+ // do anything. We want to explicitly traverse the
+ // initialization expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_shortcut);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ init->traverse(&init, &find_shortcut);
+ }
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(block, pshortcut);
+ block->insert_statement_before(*pindex, snew);
+ ++*pindex;
+
+ if (pshortcut == &init)
+ vds->var()->var_value()->set_init(init);
+ }
+}
+
+// Remove shortcut operators in the initializer of a global variable.
+
+int
+Shortcuts::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+ init->traverse(&init, &find_shortcut);
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(NULL, pshortcut);
+ var->add_preinit_statement(snew);
+ if (pshortcut == &init)
+ var->set_init(init);
+ }
+}
+
+// Given an expression which uses a shortcut operator, return a
+// statement which implements it, and update *PSHORTCUT accordingly.
+
+Statement*
+Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
+{
+ Binary_expression* shortcut = (*pshortcut)->binary_expression();
+ Expression* left = shortcut->left();
+ Expression* right = shortcut->right();
+ source_location loc = shortcut->location();
+
+ Block* retblock = new Block(enclosing, loc);
+ retblock->set_end_location(loc);
+
+ Temporary_statement* ts = Statement::make_temporary(Type::make_boolean_type(),
+ left, loc);
+ retblock->add_statement(ts);
+
+ Block* block = new Block(retblock, loc);
+ block->set_end_location(loc);
+ Expression* tmpref = Expression::make_temporary_reference(ts, loc);
+ Statement* assign = Statement::make_assignment(tmpref, right, loc);
+ block->add_statement(assign);
+
+ Expression* cond = Expression::make_temporary_reference(ts, loc);
+ if (shortcut->binary_expression()->op() == OPERATOR_OROR)
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+
+ Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
+ loc);
+ retblock->add_statement(if_statement);
+
+ *pshortcut = Expression::make_temporary_reference(ts, loc);
+
+ delete shortcut;
+
+ // Now convert any shortcut operators in LEFT and RIGHT.
+ Shortcuts shortcuts;
+ retblock->traverse(&shortcuts);
+
+ return Statement::make_block_statement(retblock, loc);
+}
+
+// Turn shortcut operators into explicit if statements. Doing this
+// considerably simplifies the order of evaluation rules.
+
+void
+Gogo::remove_shortcuts()
+{
+ Shortcuts shortcuts;
+ this->traverse(&shortcuts);
+}
+
+// A traversal class which finds all the expressions which must be
+// evaluated in order within a statement or larger expression. This
+// is used to implement the rules about order of evaluation.
+
+class Find_eval_ordering : public Traverse
+{
+ private:
+ typedef std::vector<Expression**> Expression_pointers;
+
+ public:
+ Find_eval_ordering()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ exprs_()
+ { }
+
+ size_t
+ size() const
+ { return this->exprs_.size(); }
+
+ typedef Expression_pointers::const_iterator const_iterator;
+
+ const_iterator
+ begin() const
+ { return this->exprs_.begin(); }
+
+ const_iterator
+ end() const
+ { return this->exprs_.end(); }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // A list of pointers to expressions with side-effects.
+ Expression_pointers exprs_;
+};
+
+// If an expression must be evaluated in order, put it on the list.
+
+int
+Find_eval_ordering::expression(Expression** expression_pointer)
+{
+ // We have to look at subexpressions before this one.
+ if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*expression_pointer)->must_eval_in_order())
+ this->exprs_.push_back(expression_pointer);
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// A traversal class for ordering evaluations.
+
+class Order_eval : public Traverse
+{
+ public:
+ Order_eval()
+ : Traverse(traverse_variables
+ | traverse_statements)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+};
+
+// Implement the order of evaluation rules for a statement.
+
+int
+Order_eval::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+
+ // If S is a variable declaration, then ordinary traversal won't do
+ // anything. We want to explicitly traverse the initialization
+ // expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ Expression* orig_init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_eval_ordering);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ orig_init = init;
+
+ // It might seem that this could be
+ // init->traverse_subexpressions. Unfortunately that can fail
+ // in a case like
+ // var err os.Error
+ // newvar, err := call(arg())
+ // Here newvar will have an init of call result 0 of
+ // call(arg()). If we only traverse subexpressions, we will
+ // only find arg(), and we won't bother to move anything out.
+ // Then we get to the assignment to err, we will traverse the
+ // whole statement, and this time we will find both call() and
+ // arg(), and so we will move them out. This will cause them to
+ // be put into temporary variables before the assignment to err
+ // but after the declaration of newvar. To avoid that problem,
+ // we traverse the entire expression here.
+ Expression::traverse(&init, &find_eval_ordering);
+ }
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_CONTINUE;
+ }
+
+ bool is_thunk = s->thunk_statement() != NULL;
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+
+ // If the last expression is a send or receive expression, we
+ // may be ignoring the value; we don't want to evaluate it
+ // early.
+ if (p + 1 == find_eval_ordering.end()
+ && ((*pexpr)->classification() == Expression::EXPRESSION_SEND
+ || (*pexpr)->classification() == Expression::EXPRESSION_RECEIVE))
+ break;
+
+ // The last expression in a thunk will be the call passed to go
+ // or defer, which we must not evaluate early.
+ if (is_thunk && p + 1 == find_eval_ordering.end())
+ break;
+
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ block->insert_statement_before(*pindex, ts);
+ ++*pindex;
+
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ if (init != orig_init)
+ vds->var()->var_value()->set_init(init);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Implement the order of evaluation rules for the initializer of a
+// global variable.
+
+int
+Order_eval::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+ init->traverse_subexpressions(&find_eval_ordering);
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ var->add_preinit_statement(ts);
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Use temporary variables to implement the order of evaluation rules.
+
+void
+Gogo::order_evaluations()
+{
+ Order_eval order_eval;
+ this->traverse(&order_eval);
+}
+
+// Traversal to convert calls to the predeclared recover function to
+// pass in an argument indicating whether it can recover from a panic
+// or not.
+
+class Convert_recover : public Traverse
+{
+ public:
+ Convert_recover(Named_object* arg)
+ : Traverse(traverse_expressions),
+ arg_(arg)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The argument to pass to the function.
+ Named_object* arg_;
+};
+
+// Convert calls to recover.
+
+int
+Convert_recover::expression(Expression** pp)
+{
+ Call_expression* ce = (*pp)->call_expression();
+ if (ce != NULL && ce->is_recover_call())
+ ce->set_recover_arg(Expression::make_var_reference(this->arg_,
+ ce->location()));
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal for build_recover_thunks.
+
+class Build_recover_thunks : public Traverse
+{
+ public:
+ Build_recover_thunks(Gogo* gogo)
+ : Traverse(traverse_functions),
+ gogo_(gogo)
+ { }
+
+ int
+ function(Named_object*);
+
+ private:
+ Expression*
+ can_recover_arg(source_location);
+
+ // General IR.
+ Gogo* gogo_;
+};
+
+// If this function calls recover, turn it into a thunk.
+
+int
+Build_recover_thunks::function(Named_object* orig_no)
+{
+ Function* orig_func = orig_no->func_value();
+ if (!orig_func->calls_recover()
+ || orig_func->is_recover_thunk()
+ || orig_func->has_recover_thunk())
+ return TRAVERSE_CONTINUE;
+
+ Gogo* gogo = this->gogo_;
+ source_location location = orig_func->location();
+
+ static int count;
+ char buf[50];
+
+ Function_type* orig_fntype = orig_func->type();
+ Typed_identifier_list* new_params = new Typed_identifier_list();
+ std::string receiver_name;
+ if (orig_fntype->is_method())
+ {
+ const Typed_identifier* receiver = orig_fntype->receiver();
+ snprintf(buf, sizeof buf, "rt.%u", count);
+ ++count;
+ receiver_name = buf;
+ new_params->push_back(Typed_identifier(receiver_name, receiver->type(),
+ receiver->location()));
+ }
+ const Typed_identifier_list* orig_params = orig_fntype->parameters();
+ if (orig_params != NULL && !orig_params->empty())
+ {
+ for (Typed_identifier_list::const_iterator p = orig_params->begin();
+ p != orig_params->end();
+ ++p)
+ {
+ snprintf(buf, sizeof buf, "pt.%u", count);
+ ++count;
+ new_params->push_back(Typed_identifier(buf, p->type(),
+ p->location()));
+ }
+ }
+ snprintf(buf, sizeof buf, "pr.%u", count);
+ ++count;
+ std::string can_recover_name = buf;
+ new_params->push_back(Typed_identifier(can_recover_name,
+ Type::make_boolean_type(),
+ orig_fntype->location()));
+
+ const Typed_identifier_list* orig_results = orig_fntype->results();
+ Typed_identifier_list* new_results;
+ if (orig_results == NULL || orig_results->empty())
+ new_results = NULL;
+ else
+ {
+ new_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = orig_results->begin();
+ p != orig_results->end();
+ ++p)
+ new_results->push_back(*p);
+ }
+
+ Function_type *new_fntype = Type::make_function_type(NULL, new_params,
+ new_results,
+ orig_fntype->location());
+ if (orig_fntype->is_varargs())
+ new_fntype->set_is_varargs();
+
+ std::string name = orig_no->name() + "$recover";
+ Named_object *new_no = gogo->start_function(name, new_fntype, false,
+ location);
+ Function *new_func = new_no->func_value();
+ if (orig_func->enclosing() != NULL)
+ new_func->set_enclosing(orig_func->enclosing());
+
+ // We build the code for the original function attached to the new
+ // function, and then swap the original and new function bodies.
+ // This means that existing references to the original function will
+ // then refer to the new function. That makes this code a little
+ // confusing, in that the reference to NEW_NO really refers to the
+ // other function, not the one we are building.
+
+ Expression* closure = NULL;
+ if (orig_func->needs_closure())
+ {
+ Named_object* orig_closure_no = orig_func->closure_var();
+ Variable* orig_closure_var = orig_closure_no->var_value();
+ Variable* new_var = new Variable(orig_closure_var->type(), NULL, false,
+ true, false, location);
+ snprintf(buf, sizeof buf, "closure.%u", count);
+ ++count;
+ Named_object* new_closure_no = Named_object::make_variable(buf, NULL,
+ new_var);
+ new_func->set_closure_var(new_closure_no);
+ closure = Expression::make_var_reference(new_closure_no, location);
+ }
+
+ Expression* fn = Expression::make_func_reference(new_no, closure, location);
+
+ Expression_list* args = new Expression_list();
+ if (orig_fntype->is_method())
+ {
+ Named_object* rec_no = gogo->lookup(receiver_name, NULL);
+ gcc_assert(rec_no != NULL
+ && rec_no->is_variable()
+ && rec_no->var_value()->is_parameter());
+ args->push_back(Expression::make_var_reference(rec_no, location));
+ }
+ if (new_params != NULL)
+ {
+ // Note that we skip the last parameter, which is the boolean
+ // indicating whether recover can succed.
+ for (Typed_identifier_list::const_iterator p = new_params->begin();
+ p + 1 != new_params->end();
+ ++p)
+ {
+ Named_object* p_no = gogo->lookup(p->name(), NULL);
+ gcc_assert(p_no != NULL
+ && p_no->is_variable()
+ && p_no->var_value()->is_parameter());
+ args->push_back(Expression::make_var_reference(p_no, location));
+ }
+ }
+ args->push_back(this->can_recover_arg(location));
+
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ Statement* s;
+ if (orig_fntype->results() == NULL || orig_fntype->results()->empty())
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* vals = new Expression_list();
+ vals->push_back(call);
+ s = Statement::make_return_statement(new_func->type()->results(),
+ vals, location);
+ }
+ s->determine_types();
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ // Swap the function bodies and types.
+ new_func->swap_for_recover(orig_func);
+ orig_func->set_is_recover_thunk();
+ new_func->set_calls_recover();
+ new_func->set_has_recover_thunk();
+
+ Bindings* orig_bindings = orig_func->block()->bindings();
+ Bindings* new_bindings = new_func->block()->bindings();
+ if (orig_fntype->is_method())
+ {
+ // We changed the receiver to be a regular parameter. We have
+ // to update the binding accordingly in both functions.
+ Named_object* orig_rec_no = orig_bindings->lookup_local(receiver_name);
+ gcc_assert(orig_rec_no != NULL
+ && orig_rec_no->is_variable()
+ && !orig_rec_no->var_value()->is_receiver());
+ orig_rec_no->var_value()->set_is_receiver();
+
+ Named_object* new_rec_no = new_bindings->lookup_local(receiver_name);
+ gcc_assert(new_rec_no != NULL
+ && new_rec_no->is_variable()
+ && !new_rec_no->var_value()->is_receiver());
+ new_rec_no->var_value()->set_is_not_receiver();
+ }
+
+ // Because we flipped blocks but not types, the can_recover
+ // parameter appears in the (now) old bindings as a parameter.
+ // Change it to a local variable, whereupon it will be discarded.
+ Named_object* can_recover_no = orig_bindings->lookup_local(can_recover_name);
+ gcc_assert(can_recover_no != NULL
+ && can_recover_no->is_variable()
+ && can_recover_no->var_value()->is_parameter());
+ orig_bindings->remove_binding(can_recover_no);
+
+ // Add the can_recover argument to the (now) new bindings, and
+ // attach it to any recover statements.
+ Variable* can_recover_var = new Variable(Type::make_boolean_type(), NULL,
+ false, true, false, location);
+ can_recover_no = new_bindings->add_variable(can_recover_name, NULL,
+ can_recover_var);
+ Convert_recover convert_recover(can_recover_no);
+ new_func->traverse(&convert_recover);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the expression to pass for the .can_recover parameter to the
+// new function. This indicates whether a call to recover may return
+// non-nil. The expression is
+// __go_can_recover(__builtin_return_address()).
+
+Expression*
+Build_recover_thunks::can_recover_arg(source_location location)
+{
+ static Named_object* builtin_return_address;
+ if (builtin_return_address == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* uint_type = Type::lookup_integer_type("uint");
+ param_types->push_back(Typed_identifier("l", uint_type, bloc));
+
+ Typed_identifier_list* return_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ return_types->push_back(Typed_identifier("", voidptr_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ return_types, bloc);
+ builtin_return_address =
+ Named_object::make_function_declaration("__builtin_return_address",
+ NULL, fntype, bloc);
+ const char* n = "__builtin_return_address";
+ builtin_return_address->func_declaration_value()->set_asm_name(n);
+ }
+
+ static Named_object* can_recover;
+ if (can_recover == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ param_types->push_back(Typed_identifier("a", voidptr_type, bloc));
+ Type* boolean_type = Type::make_boolean_type();
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", boolean_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ results, bloc);
+ can_recover = Named_object::make_function_declaration("__go_can_recover",
+ NULL, fntype,
+ bloc);
+ can_recover->func_declaration_value()->set_asm_name("__go_can_recover");
+ }
+
+ Expression* fn = Expression::make_func_reference(builtin_return_address,
+ NULL, location);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, location);
+ mpz_clear(zval);
+ Expression_list *args = new Expression_list();
+ args->push_back(zexpr);
+
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ args = new Expression_list();
+ args->push_back(call);
+
+ fn = Expression::make_func_reference(can_recover, NULL, location);
+ return Expression::make_call(fn, args, false, location);
+}
+
+// Build thunks for functions which call recover. We build a new
+// function with an extra parameter, which is whether a call to
+// recover can succeed. We then move the body of this function to
+// that one. We then turn this function into a thunk which calls the
+// new one, passing the value of
+// __go_can_recover(__builtin_return_address()). The function will be
+// marked as not splitting the stack. This will cooperate with the
+// implementation of defer to make recover do the right thing.
+
+void
+Gogo::build_recover_thunks()
+{
+ Build_recover_thunks build_recover_thunks(this);
+ this->traverse(&build_recover_thunks);
+}
+
+// Look for named types to see whether we need to create an interface
+// method table.
+
+class Build_method_tables : public Traverse
+{
+ public:
+ Build_method_tables(Gogo* gogo,
+ const std::vector<Interface_type*>& interfaces)
+ : Traverse(traverse_types),
+ gogo_(gogo), interfaces_(interfaces)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ // The IR.
+ Gogo* gogo_;
+ // A list of locally defined interfaces which have hidden methods.
+ const std::vector<Interface_type*>& interfaces_;
+};
+
+// Build all required interface method tables for types. We need to
+// ensure that we have an interface method table for every interface
+// which has a hidden method, for every named type which implements
+// that interface. Normally we can just build interface method tables
+// as we need them. However, in some cases we can require an
+// interface method table for an interface defined in a different
+// package for a type defined in that package. If that interface and
+// type both use a hidden method, that is OK. However, we will not be
+// able to build that interface method table when we need it, because
+// the type's hidden method will be static. So we have to build it
+// here, and just refer it from other packages as needed.
+
+void
+Gogo::build_interface_method_tables()
+{
+ std::vector<Interface_type*> hidden_interfaces;
+ hidden_interfaces.reserve(this->interface_types_.size());
+ for (std::vector<Interface_type*>::const_iterator pi =
+ this->interface_types_.begin();
+ pi != this->interface_types_.end();
+ ++pi)
+ {
+ const Typed_identifier_list* methods = (*pi)->methods();
+ if (methods == NULL)
+ continue;
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ if (Gogo::is_hidden_name(pm->name()))
+ {
+ hidden_interfaces.push_back(*pi);
+ break;
+ }
+ }
+ }
+
+ if (!hidden_interfaces.empty())
+ {
+ // Now traverse the tree looking for all named types.
+ Build_method_tables bmt(this, hidden_interfaces);
+ this->traverse(&bmt);
+ }
+
+ // We no longer need the list of interfaces.
+
+ this->interface_types_.clear();
+}
+
+// This is called for each type. For a named type, for each of the
+// interfaces with hidden methods that it implements, create the
+// method table.
+
+int
+Build_method_tables::type(Type* type)
+{
+ Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ for (std::vector<Interface_type*>::const_iterator p =
+ this->interfaces_.begin();
+ p != this->interfaces_.end();
+ ++p)
+ {
+ // We ask whether a pointer to the named type implements the
+ // interface, because a pointer can implement more methods
+ // than a value.
+ if ((*p)->implements_interface(Type::make_pointer_type(nt), NULL))
+ {
+ nt->interface_method_table(this->gogo_, *p, false);
+ nt->interface_method_table(this->gogo_, *p, true);
+ }
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal class used to check for return statements.
+
+class Check_return_statements_traverse : public Traverse
+{
+ public:
+ Check_return_statements_traverse()
+ : Traverse(traverse_functions)
+ { }
+
+ int
+ function(Named_object*);
+};
+
+// Check that a function has a return statement if it needs one.
+
+int
+Check_return_statements_traverse::function(Named_object* no)
+{
+ Function* func = no->func_value();
+ const Function_type* fntype = func->type();
+ const Typed_identifier_list* results = fntype->results();
+
+ // We only need a return statement if there is a return value.
+ if (results == NULL || results->empty())
+ return TRAVERSE_CONTINUE;
+
+ if (func->block()->may_fall_through())
+ error_at(func->location(), "control reaches end of non-void function");
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Check return statements.
+
+void
+Gogo::check_return_statements()
+{
+ Check_return_statements_traverse traverse;
+ this->traverse(&traverse);
+}
+
+// Get the unique prefix to use before all exported symbols. This
+// must be unique across the entire link.
+
+const std::string&
+Gogo::unique_prefix() const
+{
+ gcc_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+}
+
+// Set the unique prefix to use before all exported symbols. This
+// comes from the command line option -fgo-prefix=XXX.
+
+void
+Gogo::set_unique_prefix(const std::string& arg)
+{
+ gcc_assert(this->unique_prefix_.empty());
+ this->unique_prefix_ = arg;
+}
+
+// Work out the package priority. It is one more than the maximum
+// priority of an imported package.
+
+int
+Gogo::package_priority() const
+{
+ int priority = 0;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ if (p->second->priority() > priority)
+ priority = p->second->priority();
+ return priority + 1;
+}
+
+// Export identifiers as requested.
+
+void
+Gogo::do_exports()
+{
+ // For now we always stream to a section. Later we may want to
+ // support streaming to a separate file.
+ Stream_to_section stream;
+
+ Export exp(&stream);
+ exp.register_builtin_types(this);
+ exp.export_globals(this->package_name(),
+ this->unique_prefix(),
+ this->package_priority(),
+ (this->need_init_fn_ && this->package_name() != "main"
+ ? this->get_init_fn_name()
+ : ""),
+ this->imported_init_fns_,
+ this->package_->bindings());
+}
+
+// Class Function.
+
+Function::Function(Function_type* type, Function* enclosing, Block* block,
+ source_location location)
+ : type_(type), enclosing_(enclosing), named_results_(NULL),
+ closure_var_(NULL), block_(block), location_(location), fndecl_(NULL),
+ defer_stack_(NULL), calls_recover_(false), is_recover_thunk_(false),
+ has_recover_thunk_(false)
+{
+}
+
+// Create the named result variables.
+
+void
+Function::create_named_result_variables()
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL
+ || results->empty()
+ || results->front().name().empty())
+ return;
+
+ this->named_results_ = new Named_results();
+ this->named_results_->reserve(results->size());
+
+ Block* block = this->block_;
+ int index = 0;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p, ++index)
+ {
+ Result_variable* result = new Result_variable(p->type(), this,
+ index);
+ Named_object* no = block->bindings()->add_result_variable(p->name(),
+ result);
+ this->named_results_->push_back(no);
+ }
+}
+
+// Return the closure variable, creating it if necessary.
+
+Named_object*
+Function::closure_var()
+{
+ if (this->closure_var_ == NULL)
+ {
+ // We don't know the type of the variable yet. We add fields as
+ // we find them.
+ source_location loc = this->type_->location();
+ Struct_field_list* sfl = new Struct_field_list;
+ Type* struct_type = Type::make_struct_type(sfl, loc);
+ Variable* var = new Variable(Type::make_pointer_type(struct_type),
+ NULL, false, true, false, loc);
+ this->closure_var_ = Named_object::make_variable("closure", NULL, var);
+ // Note that the new variable is not in any binding contour.
+ }
+ return this->closure_var_;
+}
+
+// Set the type of the closure variable.
+
+void
+Function::set_closure_type()
+{
+ if (this->closure_var_ == NULL)
+ return;
+ Named_object* closure = this->closure_var_;
+ Struct_type* st = closure->var_value()->type()->deref()->struct_type();
+ unsigned int index = 0;
+ for (Closure_fields::const_iterator p = this->closure_fields_.begin();
+ p != this->closure_fields_.end();
+ ++p, ++index)
+ {
+ Named_object* no = p->first;
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", index);
+ std::string n = no->name() + buf;
+ Type* var_type;
+ if (no->is_variable())
+ var_type = no->var_value()->type();
+ else
+ var_type = no->result_var_value()->type();
+ Type* field_type = Type::make_pointer_type(var_type);
+ st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
+ }
+}
+
+// Return whether this function is a method.
+
+bool
+Function::is_method() const
+{
+ return this->type_->is_method();
+}
+
+// Add a label definition.
+
+Label*
+Function::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (ins.second)
+ {
+ // This is a new label.
+ Label* label = new Label(label_name);
+ label->define(location);
+ ins.first->second = label;
+ return label;
+ }
+ else
+ {
+ // The label was already in the hash table.
+ Label* label = ins.first->second;
+ if (!label->is_defined())
+ {
+ label->define(location);
+ return label;
+ }
+ else
+ {
+ error_at(location, "redefinition of label %qs",
+ Gogo::message_name(label_name).c_str());
+ inform(label->location(), "previous definition of %qs was here",
+ Gogo::message_name(label_name).c_str());
+ return new Label(label_name);
+ }
+ }
+}
+
+// Add a reference to a label.
+
+Label*
+Function::add_label_reference(const std::string& label_name)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (!ins.second)
+ {
+ // The label was already in the hash table.
+ return ins.first->second;
+ }
+ else
+ {
+ gcc_assert(ins.first->second == NULL);
+ Label* label = new Label(label_name);
+ ins.first->second = label;
+ return label;
+ }
+}
+
+// Swap one function with another. This is used when building the
+// thunk we use to call a function which calls recover. It may not
+// work for any other case.
+
+void
+Function::swap_for_recover(Function *x)
+{
+ gcc_assert(this->enclosing_ == x->enclosing_);
+ gcc_assert(this->named_results_ == x->named_results_);
+ std::swap(this->closure_var_, x->closure_var_);
+ std::swap(this->block_, x->block_);
+ gcc_assert(this->location_ == x->location_);
+ gcc_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
+ gcc_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
+}
+
+// Traverse the tree.
+
+int
+Function::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ // FIXME: We should check traverse_functions here if nested
+ // functions are stored in block bindings.
+ if (this->block_ != NULL
+ && (traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Function::determine_types()
+{
+ if (this->block_ != NULL)
+ this->block_->determine_types();
+}
+
+// Export the function.
+
+void
+Function::export_func(Export* exp, const std::string& name) const
+{
+ Function::export_func_with_type(exp, name, this->type_);
+}
+
+// Export a function with a type.
+
+void
+Function::export_func_with_type(Export* exp, const std::string& name,
+ const Function_type* fntype)
+{
+ exp->write_c_string("func ");
+
+ if (fntype->is_method())
+ {
+ exp->write_c_string("(");
+ exp->write_type(fntype->receiver()->type());
+ exp->write_c_string(") ");
+ }
+
+ exp->write_string(name);
+
+ exp->write_c_string(" (");
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != parameters->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ if (results->size() == 1)
+ {
+ exp->write_c_string(" ");
+ exp->write_type(results->begin()->type());
+ }
+ else
+ {
+ exp->write_c_string(" (");
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+ exp->write_c_string(";\n");
+}
+
+// Import a function.
+
+void
+Function::import_func(Import* imp, std::string* pname,
+ Typed_identifier** preceiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults,
+ bool* is_varargs)
+{
+ imp->require_c_string("func ");
+
+ *preceiver = NULL;
+ if (imp->peek_char() == '(')
+ {
+ imp->require_c_string("(");
+ Type* rtype = imp->read_type();
+ *preceiver = new Typed_identifier(Import::import_marker, rtype,
+ imp->location());
+ imp->require_c_string(") ");
+ }
+
+ *pname = imp->read_identifier();
+
+ Typed_identifier_list* parameters;
+ *is_varargs = false;
+ imp->require_c_string(" (");
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ *is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (*is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!*is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+ *pparameters = parameters;
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ imp->require_c_string(" ");
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->require_c_string("(");
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+ imp->require_c_string(";\n");
+ *presults = results;
+}
+
+// Class Block.
+
+Block::Block(Block* enclosing, source_location location)
+ : enclosing_(enclosing), statements_(),
+ bindings_(new Bindings(enclosing == NULL
+ ? NULL
+ : enclosing->bindings())),
+ start_location_(location),
+ end_location_(UNKNOWN_LOCATION)
+{
+}
+
+// Add a statement to a block.
+
+void
+Block::add_statement(Statement* statement)
+{
+ this->statements_.push_back(statement);
+}
+
+// Add a statement to the front of a block. This is slow but is only
+// used for reference counts of parameters.
+
+void
+Block::add_statement_at_front(Statement* statement)
+{
+ this->statements_.insert(this->statements_.begin(), statement);
+}
+
+// Replace a statement in a block.
+
+void
+Block::replace_statement(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_[index] = s;
+}
+
+// Add a statement before another statement.
+
+void
+Block::insert_statement_before(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index, s);
+}
+
+// Add a statement after another statement.
+
+void
+Block::insert_statement_after(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index + 1, s);
+}
+
+// Traverse the tree.
+
+int
+Block::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_blocks) != 0)
+ {
+ int t = traverse->block(this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ switch ((*pb)->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(*pb, false) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = (*pb)->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0)
+ {
+ if ((*pb)->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(*pb) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && ((*pb)->is_result_variable()
+ || (*pb)->var_value()->has_type()))
+ {
+ Type* t = ((*pb)->is_variable()
+ ? (*pb)->var_value()->type()
+ : (*pb)->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((*pb)->is_variable()
+ && ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0))
+ {
+ if ((*pb)->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ // FIXME: Where will nested functions be found?
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse((*pb)->type_value(), traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ case Named_object::NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ default:
+ gcc_unreachable();
+ }
+ }
+ }
+
+ // No point in checking traverse_mask here--if we got here we always
+ // want to walk the statements. The traversal can insert new
+ // statements before or after the current statement. Inserting
+ // statements before the current statement requires updating I via
+ // the pointer; those statements will not be traversed. Any new
+ // statements inserted after the current statement will be traversed
+ // in their turn.
+ for (size_t i = 0; i < this->statements_.size(); ++i)
+ {
+ if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Block::determine_types()
+{
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ if ((*pb)->is_variable())
+ (*pb)->var_value()->determine_type();
+ else if ((*pb)->is_const())
+ (*pb)->const_value()->determine_type();
+ }
+
+ for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
+ ps != this->statements_.end();
+ ++ps)
+ (*ps)->determine_types();
+}
+
+// Return true if the statements in this block may fall through.
+
+bool
+Block::may_fall_through() const
+{
+ if (this->statements_.empty())
+ return true;
+ return this->statements_.back()->may_fall_through();
+}
+
+// Class Variable.
+
+Variable::Variable(Type* type, Expression* init, bool is_global,
+ bool is_parameter, bool is_receiver,
+ source_location location)
+ : type_(type), init_(init), preinit_(NULL), location_(location),
+ is_global_(is_global), is_parameter_(is_parameter),
+ is_receiver_(is_receiver), is_varargs_parameter_(false),
+ is_address_taken_(false), init_is_lowered_(false),
+ type_from_init_tuple_(false), type_from_range_index_(false),
+ type_from_range_value_(false), type_from_chan_element_(false),
+ is_type_switch_var_(false)
+{
+ gcc_assert(type != NULL || init != NULL);
+ gcc_assert(!is_parameter || init == NULL);
+}
+
+// Traverse the initializer expression.
+
+int
+Variable::traverse_expression(Traverse* traverse)
+{
+ if (this->preinit_ != NULL)
+ {
+ if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->init_ != NULL)
+ {
+ if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower the initialization expression after parsing is complete.
+
+void
+Variable::lower_init_expression(Gogo* gogo, Named_object* function)
+{
+ if (this->init_ != NULL && !this->init_is_lowered_)
+ {
+ gogo->lower_expression(function, &this->init_);
+ this->init_is_lowered_ = true;
+ }
+}
+
+// Get the preinit block.
+
+Block*
+Variable::preinit_block()
+{
+ gcc_assert(this->is_global_);
+ if (this->preinit_ == NULL)
+ this->preinit_ = new Block(NULL, this->location());
+ return this->preinit_;
+}
+
+// Add a statement to be run before the initialization expression.
+
+void
+Variable::add_preinit_statement(Statement* s)
+{
+ Block* b = this->preinit_block();
+ b->add_statement(s);
+ b->set_end_location(s->location());
+}
+
+// In an assignment which sets a variable to a tuple of EXPR, return
+// the type of the first element of the tuple.
+
+Type*
+Variable::type_from_tuple(Expression* expr, bool report_error) const
+{
+ if (expr->map_index_expression() != NULL)
+ return expr->map_index_expression()->get_map_type()->val_type();
+ else if (expr->receive_expression() != NULL)
+ {
+ Expression* channel = expr->receive_expression()->channel();
+ return channel->type()->channel_type()->element_type();
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid tuple definition");
+ return Type::make_error_type();
+ }
+}
+
+// Given EXPR used in a range clause, return either the index type or
+// the value type of the range, depending upon GET_INDEX_TYPE.
+
+Type*
+Variable::type_from_range(Expression* expr, bool get_index_type,
+ bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->array_type() != NULL
+ || (t->points_to() != NULL
+ && t->points_to()->array_type() != NULL
+ && !t->points_to()->is_open_array_type()))
+ {
+ if (get_index_type)
+ return Type::lookup_integer_type("int");
+ else
+ return t->deref()->array_type()->element_type();
+ }
+ else if (t->is_string_type())
+ return Type::lookup_integer_type("int");
+ else if (t->map_type() != NULL)
+ {
+ if (get_index_type)
+ return t->map_type()->key_type();
+ else
+ return t->map_type()->val_type();
+ }
+ else if (t->channel_type() != NULL)
+ {
+ if (get_index_type)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(),
+ "invalid definition of value variable for channel range");
+ return Type::make_error_type();
+ }
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid type for range clause");
+ return Type::make_error_type();
+ }
+}
+
+// EXPR should be a channel. Return the channel's element type.
+
+Type*
+Variable::type_from_chan_element(Expression* expr, bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->channel_type() != NULL)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "expected channel");
+ return Type::make_error_type();
+ }
+}
+
+// Return the type of the Variable. This may be called before
+// Variable::determine_type is called, which means that we may need to
+// get the type from the initializer. FIXME: If we combine lowering
+// with type determination, then this should be unnecessary.
+
+Type*
+Variable::type() const
+{
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. This gets fixed up in determine_type, below.
+ Type* type = this->type_;
+ Expression* init = this->init_;
+ if (this->is_type_switch_var_
+ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ gcc_assert(tge != NULL);
+ init = tge->expr();
+ type = NULL;
+ }
+
+ if (type != NULL)
+ return type;
+ else if (this->type_from_init_tuple_)
+ return this->type_from_tuple(init, false);
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ return this->type_from_range(init, this->type_from_range_index_, false);
+ else if (this->type_from_chan_element_)
+ return this->type_from_chan_element(init, false);
+ else
+ {
+ gcc_assert(init != NULL);
+ type = init->type();
+ gcc_assert(type != NULL);
+
+ // Variables should not have abstract types.
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ type = Type::make_error_type();
+
+ return type;
+ }
+}
+
+// Set the type if necessary.
+
+void
+Variable::determine_type()
+{
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. It will have an initializer which is a type guard.
+ // We want to initialize it to the value without the type guard, and
+ // use the type of that value as well.
+ if (this->is_type_switch_var_ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ gcc_assert(tge != NULL);
+ this->type_ = NULL;
+ this->init_ = tge->expr();
+ }
+
+ if (this->init_ == NULL)
+ gcc_assert(this->type_ != NULL && !this->type_->is_abstract());
+ else if (this->type_from_init_tuple_)
+ {
+ Expression *init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_tuple(init, true);
+ this->init_ = NULL;
+ }
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ {
+ Expression* init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_range(init, this->type_from_range_index_,
+ true);
+ this->init_ = NULL;
+ }
+ else
+ {
+ // type_from_chan_element_ should have been cleared during
+ // lowering.
+ gcc_assert(!this->type_from_chan_element_);
+
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ if (this->type_ == NULL)
+ {
+ Type* type = this->init_->type();
+ gcc_assert(type != NULL);
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ {
+ error_at(this->location_, "variable has no type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_nil_type())
+ {
+ error_at(this->location_, "variable defined to nil type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_call_multiple_result_type())
+ {
+ error_at(this->location_,
+ "single variable set to multiple value function call");
+ type = Type::make_error_type();
+ }
+
+ this->type_ = type;
+ }
+ }
+}
+
+// Export the variable
+
+void
+Variable::export_var(Export* exp, const std::string& name) const
+{
+ gcc_assert(this->is_global_);
+ exp->write_c_string("var ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ exp->write_type(this->type());
+ exp->write_c_string(";\n");
+}
+
+// Import a variable.
+
+void
+Variable::import_var(Import* imp, std::string* pname, Type** ptype)
+{
+ imp->require_c_string("var ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ *ptype = imp->read_type();
+ imp->require_c_string(";\n");
+}
+
+// Class Named_constant.
+
+// Traverse the initializer expression.
+
+int
+Named_constant::traverse_expression(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Determine the type of the constant.
+
+void
+Named_constant::determine_type()
+{
+ if (this->type_ != NULL)
+ {
+ Type_context context(this->type_, false);
+ this->expr_->determine_type(&context);
+ }
+ else
+ {
+ // A constant may have an abstract type.
+ Type_context context(NULL, true);
+ this->expr_->determine_type(&context);
+ this->type_ = this->expr_->type();
+ gcc_assert(this->type_ != NULL);
+ }
+}
+
+// Indicate that we found and reported an error for this constant.
+
+void
+Named_constant::set_error()
+{
+ this->type_ = Type::make_error_type();
+ this->expr_ = Expression::make_error(this->location_);
+}
+
+// Export a constant.
+
+void
+Named_constant::export_const(Export* exp, const std::string& name) const
+{
+ exp->write_c_string("const ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ if (!this->type_->is_abstract())
+ {
+ exp->write_type(this->type_);
+ exp->write_c_string(" ");
+ }
+ exp->write_c_string("= ");
+ this->expr()->export_expression(exp);
+ exp->write_c_string(";\n");
+}
+
+// Import a constant.
+
+void
+Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
+ Expression** pexpr)
+{
+ imp->require_c_string("const ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (imp->peek_char() == '=')
+ *ptype = NULL;
+ else
+ {
+ *ptype = imp->read_type();
+ imp->require_c_string(" ");
+ }
+ imp->require_c_string("= ");
+ *pexpr = Expression::import_expression(imp);
+ imp->require_c_string(";\n");
+}
+
+// Add a method.
+
+Named_object*
+Type_declaration::add_method(const std::string& name, Function* function)
+{
+ Named_object* ret = Named_object::make_function(name, NULL, function);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Add a method declaration.
+
+Named_object*
+Type_declaration::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* ret = Named_object::make_function_declaration(name, NULL, type,
+ location);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Return whether any methods ere defined.
+
+bool
+Type_declaration::has_methods() const
+{
+ return !this->methods_.empty();
+}
+
+// Define methods for the real type.
+
+void
+Type_declaration::define_methods(Named_type* nt)
+{
+ for (Methods::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ nt->add_existing_method(*p);
+}
+
+// We are using the type. Return true if we should issue a warning.
+
+bool
+Type_declaration::using_type()
+{
+ bool ret = !this->issued_warning_;
+ this->issued_warning_ = true;
+ return ret;
+}
+
+// Class Unknown_name.
+
+// Set the real named object.
+
+void
+Unknown_name::set_real_named_object(Named_object* no)
+{
+ gcc_assert(this->real_named_object_ == NULL);
+ gcc_assert(!no->is_unknown());
+ this->real_named_object_ = no;
+}
+
+// Class Named_object.
+
+Named_object::Named_object(const std::string& name,
+ const Package* package,
+ Classification classification)
+ : name_(name), package_(package), classification_(classification),
+ tree_(NULL)
+{
+ if (Gogo::is_sink_name(name))
+ gcc_assert(classification == NAMED_OBJECT_SINK);
+}
+
+// Make an unknown name. This is used by the parser. The name must
+// be resolved later. Unknown names are only added in the current
+// package.
+
+Named_object*
+Named_object::make_unknown_name(const std::string& name,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_UNKNOWN);
+ Unknown_name* value = new Unknown_name(location);
+ named_object->u_.unknown_value = value;
+ return named_object;
+}
+
+// Make a constant.
+
+Named_object*
+Named_object::make_constant(const Typed_identifier& tid,
+ const Package* package, Expression* expr,
+ int iota_value)
+{
+ Named_object* named_object = new Named_object(tid.name(), package,
+ NAMED_OBJECT_CONST);
+ Named_constant* named_constant = new Named_constant(tid.type(), expr,
+ iota_value,
+ tid.location());
+ named_object->u_.const_value = named_constant;
+ return named_object;
+}
+
+// Make a named type.
+
+Named_object*
+Named_object::make_type(const std::string& name, const Package* package,
+ Type* type, source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE);
+ Named_type* named_type = Type::make_named_type(named_object, type, location);
+ named_object->u_.type_value = named_type;
+ return named_object;
+}
+
+// Make a type declaration.
+
+Named_object*
+Named_object::make_type_declaration(const std::string& name,
+ const Package* package,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* type_declaration = new Type_declaration(location);
+ named_object->u_.type_declaration = type_declaration;
+ return named_object;
+}
+
+// Make a variable.
+
+Named_object*
+Named_object::make_variable(const std::string& name, const Package* package,
+ Variable* variable)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_VAR);
+ named_object->u_.var_value = variable;
+ return named_object;
+}
+
+// Make a result variable.
+
+Named_object*
+Named_object::make_result_variable(const std::string& name,
+ Result_variable* result)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_RESULT_VAR);
+ named_object->u_.result_var_value = result;
+ return named_object;
+}
+
+// Make a sink. This is used for the special blank identifier _.
+
+Named_object*
+Named_object::make_sink()
+{
+ return new Named_object("_", NULL, NAMED_OBJECT_SINK);
+}
+
+// Make a named function.
+
+Named_object*
+Named_object::make_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC);
+ named_object->u_.func_value = function;
+ return named_object;
+}
+
+// Make a function declaration.
+
+Named_object*
+Named_object::make_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* fntype,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC_DECLARATION);
+ Function_declaration *func_decl = new Function_declaration(fntype, location);
+ named_object->u_.func_declaration_value = func_decl;
+ return named_object;
+}
+
+// Make a package.
+
+Named_object*
+Named_object::make_package(const std::string& alias, Package* package)
+{
+ Named_object* named_object = new Named_object(alias, NULL,
+ NAMED_OBJECT_PACKAGE);
+ named_object->u_.package_value = package;
+ return named_object;
+}
+
+// Return the name to use in an error message.
+
+std::string
+Named_object::message_name() const
+{
+ if (this->package_ == NULL)
+ return Gogo::message_name(this->name_);
+ std::string ret = Gogo::message_name(this->package_->name());
+ ret += '.';
+ ret += Gogo::message_name(this->name_);
+ return ret;
+}
+
+// Set the type when a declaration is defined.
+
+void
+Named_object::set_type_value(Named_type* named_type)
+{
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* td = this->u_.type_declaration;
+ td->define_methods(named_type);
+ Named_object* in_function = td->in_function();
+ if (in_function != NULL)
+ named_type->set_in_function(in_function);
+ delete td;
+ this->classification_ = NAMED_OBJECT_TYPE;
+ this->u_.type_value = named_type;
+}
+
+// Define a function which was previously declared.
+
+void
+Named_object::set_function_value(Function* function)
+{
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ this->classification_ = NAMED_OBJECT_FUNC;
+ // FIXME: We should free the old value.
+ this->u_.func_value = function;
+}
+
+// Return the location of a named object.
+
+source_location
+Named_object::location() const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_UNKNOWN:
+ return this->unknown_value()->location();
+
+ case NAMED_OBJECT_CONST:
+ return this->const_value()->location();
+
+ case NAMED_OBJECT_TYPE:
+ return this->type_value()->location();
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ return this->type_declaration_value()->location();
+
+ case NAMED_OBJECT_VAR:
+ return this->var_value()->location();
+
+ case NAMED_OBJECT_RESULT_VAR:
+ return this->result_var_value()->function()->location();
+
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ return this->func_value()->location();
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ return this->func_declaration_value()->location();
+
+ case NAMED_OBJECT_PACKAGE:
+ return this->package_value()->location();
+ }
+}
+
+// Export a named object.
+
+void
+Named_object::export_named_object(Export* exp) const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ case NAMED_OBJECT_UNKNOWN:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_CONST:
+ this->const_value()->export_const(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ this->type_value()->export_named_type(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error_at(this->type_declaration_value()->location(),
+ "attempt to export %<%s%> which was declared but not defined",
+ this->message_name().c_str());
+ break;
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ this->func_declaration_value()->export_func(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_VAR:
+ this->var_value()->export_var(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_RESULT_VAR:
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ this->func_value()->export_func(exp, this->name_);
+ break;
+ }
+}
+
+// Class Bindings.
+
+Bindings::Bindings(Bindings* enclosing)
+ : enclosing_(enclosing), named_objects_(), bindings_()
+{
+}
+
+// Clear imports.
+
+void
+Bindings::clear_file_scope()
+{
+ Contour::iterator p = this->bindings_.begin();
+ while (p != this->bindings_.end())
+ {
+ bool keep;
+ if (p->second->package() != NULL)
+ keep = false;
+ else if (p->second->is_package())
+ keep = false;
+ else if (p->second->is_function()
+ && !p->second->func_value()->type()->is_method()
+ && Gogo::unpack_hidden_name(p->second->name()) == "init")
+ keep = false;
+ else
+ keep = true;
+
+ if (keep)
+ ++p;
+ else
+ p = this->bindings_.erase(p);
+ }
+}
+
+// Look up a symbol.
+
+Named_object*
+Bindings::lookup(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p != this->bindings_.end())
+ return p->second->resolve();
+ else if (this->enclosing_ != NULL)
+ return this->enclosing_->lookup(name);
+ else
+ return NULL;
+}
+
+// Look up a symbol locally.
+
+Named_object*
+Bindings::lookup_local(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p == this->bindings_.end())
+ return NULL;
+ return p->second;
+}
+
+// Remove an object from a set of bindings. This is used for a
+// special case in thunks for functions which call recover.
+
+void
+Bindings::remove_binding(Named_object* no)
+{
+ Contour::iterator pb = this->bindings_.find(no->name());
+ gcc_assert(pb != this->bindings_.end());
+ this->bindings_.erase(pb);
+ for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
+ pn != this->named_objects_.end();
+ ++pn)
+ {
+ if (*pn == no)
+ {
+ this->named_objects_.erase(pn);
+ return;
+ }
+ }
+ gcc_unreachable();
+}
+
+// Add a method to the list of objects. This is not added to the
+// lookup table. This is so that we have a single list of objects
+// declared at the top level, which we walk through when it's time to
+// convert to trees.
+
+void
+Bindings::add_method(Named_object* method)
+{
+ this->named_objects_.push_back(method);
+}
+
+// Add a generic Named_object to a Contour.
+
+Named_object*
+Bindings::add_named_object_to_contour(Contour* contour,
+ Named_object* named_object)
+{
+ gcc_assert(named_object == named_object->resolve());
+ const std::string& name(named_object->name());
+ gcc_assert(!Gogo::is_sink_name(name));
+
+ std::pair<Contour::iterator, bool> ins =
+ contour->insert(std::make_pair(name, named_object));
+ if (!ins.second)
+ {
+ // The name was already there.
+ if (named_object->package() != NULL
+ && ins.first->second->package() == named_object->package()
+ && (ins.first->second->classification()
+ == named_object->classification()))
+ {
+ // This is a second import of the same object.
+ return ins.first->second;
+ }
+ ins.first->second = this->new_definition(ins.first->second,
+ named_object);
+ return ins.first->second;
+ }
+ else
+ {
+ // Don't push declarations on the list. We push them on when
+ // and if we find the definitions. That way we genericize the
+ // functions in order.
+ if (!named_object->is_type_declaration()
+ && !named_object->is_function_declaration()
+ && !named_object->is_unknown())
+ this->named_objects_.push_back(named_object);
+ return named_object;
+ }
+}
+
+// We had an existing named object OLD_OBJECT, and we've seen a new
+// one NEW_OBJECT with the same name. FIXME: This does not free the
+// new object when we don't need it.
+
+Named_object*
+Bindings::new_definition(Named_object* old_object, Named_object* new_object)
+{
+ std::string reason;
+ switch (old_object->classification())
+ {
+ default:
+ case Named_object::NAMED_OBJECT_UNINITIALIZED:
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ {
+ Named_object* real = old_object->unknown_value()->real_named_object();
+ if (real != NULL)
+ return this->new_definition(real, new_object);
+ gcc_assert(!new_object->is_unknown());
+ old_object->unknown_value()->set_real_named_object(new_object);
+ if (!new_object->is_type_declaration()
+ && !new_object->is_function_declaration())
+ this->named_objects_.push_back(new_object);
+ return new_object;
+ }
+
+ case Named_object::NAMED_OBJECT_CONST:
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if (new_object->is_type_declaration())
+ return old_object;
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (new_object->is_type_declaration())
+ return old_object;
+ if (new_object->is_type())
+ {
+ old_object->set_type_value(new_object->type_value());
+ new_object->type_value()->set_named_object(old_object);
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if (new_object->is_function_declaration())
+ {
+ if (!new_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ Function_type* old_type = old_object->func_value()->type();
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ {
+ Function_type* old_type = old_object->func_declaration_value()->type();
+ if (new_object->is_function_declaration())
+ {
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ if (new_object->is_function())
+ {
+ Function_type* new_type = new_object->func_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ {
+ if (!old_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ old_object->set_function_value(new_object->func_value());
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ }
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (new_object->is_package()
+ && (old_object->package_value()->name()
+ == new_object->package_value()->name()))
+ return old_object;
+
+ break;
+ }
+
+ std::string n = old_object->message_name();
+ if (reason.empty())
+ error_at(new_object->location(), "redefinition of %qs", n.c_str());
+ else
+ error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
+ reason.c_str());
+
+ inform(old_object->location(), "previous definition of %qs was here",
+ n.c_str());
+
+ return old_object;
+}
+
+// Add a named type.
+
+Named_object*
+Bindings::add_named_type(Named_type* named_type)
+{
+ return this->add_named_object(named_type->named_object());
+}
+
+// Add a function.
+
+Named_object*
+Bindings::add_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ return this->add_named_object(Named_object::make_function(name, package,
+ function));
+}
+
+// Add a function declaration.
+
+Named_object*
+Bindings::add_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = Named_object::make_function_declaration(name, package,
+ type, location);
+ return this->add_named_object(no);
+}
+
+// Define a type which was previously declared.
+
+void
+Bindings::define_type(Named_object* no, Named_type* type)
+{
+ no->set_type_value(type);
+ this->named_objects_.push_back(no);
+}
+
+// Traverse bindings.
+
+int
+Bindings::traverse(Traverse* traverse, bool is_global)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ // We don't use an iterator because we permit the traversal to add
+ // new global objects.
+ for (size_t i = 0; i < this->named_objects_.size(); ++i)
+ {
+ Named_object* p = this->named_objects_[i];
+ switch (p->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(p, is_global) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = p->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (p->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(p) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && (p->is_result_variable()
+ || p->var_value()->has_type()))
+ {
+ Type* t = (p->is_variable()
+ ? p->var_value()->type()
+ : p->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (p->is_variable()
+ && (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (p->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if ((traverse_mask & Traverse::traverse_functions) != 0)
+ {
+ int t = traverse->function(p);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ break;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_functions
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (p->func_value()->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ // These are traversed in Gogo::traverse.
+ gcc_assert(is_global);
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse(p->type_value(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ default:
+ gcc_unreachable();
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Class Package.
+
+Package::Package(const std::string& name, const std::string& unique_prefix,
+ source_location location)
+ : name_(name), unique_prefix_(unique_prefix), bindings_(new Bindings(NULL)),
+ priority_(0), location_(location), used_(false), is_imported_(false),
+ uses_sink_alias_(false)
+{
+ gcc_assert(!name.empty() && !unique_prefix.empty());
+}
+
+// Set the priority. We may see multiple priorities for an imported
+// package; we want to use the largest one.
+
+void
+Package::set_priority(int priority)
+{
+ if (priority > this->priority_)
+ this->priority_ = priority;
+}
+
+// Determine types of constants. Everything else in a package
+// (variables, function declarations) should already have a fixed
+// type. Constants may have abstract types.
+
+void
+Package::determine_types()
+{
+ Bindings* bindings = this->bindings_;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+ }
+}
+
+// Class Traverse.
+
+// Destructor.
+
+Traverse::~Traverse()
+{
+ if (this->types_seen_ != NULL)
+ delete this->types_seen_;
+ if (this->expressions_seen_ != NULL)
+ delete this->expressions_seen_;
+}
+
+// Record that we are looking at a type, and return true if we have
+// already seen it.
+
+bool
+Traverse::remember_type(const Type* type)
+{
+ gcc_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ // We only have to remember named types, as they are the only ones
+ // we can see multiple times in a traversal.
+ if (type->classification() != Type::TYPE_NAMED)
+ return false;
+ if (this->types_seen_ == NULL)
+ this->types_seen_ = new Types_seen();
+ std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
+ return !ins.second;
+}
+
+// Record that we are looking at an expression, and return true if we
+// have already seen it.
+
+bool
+Traverse::remember_expression(const Expression* expression)
+{
+ gcc_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ if (this->expressions_seen_ == NULL)
+ this->expressions_seen_ = new Expressions_seen();
+ std::pair<Expressions_seen::iterator, bool> ins =
+ this->expressions_seen_->insert(expression);
+ return !ins.second;
+}
+
+// The default versions of these functions should never be called: the
+// traversal mask indicates which functions may be called.
+
+int
+Traverse::variable(Named_object*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::constant(Named_object*, bool)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::function(Named_object*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::block(Block*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::statement(Block*, size_t*, Statement*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::expression(Expression**)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::type(Type*)
+{
+ gcc_unreachable();
+}
--- /dev/null
+// gogo.cc -- Go frontend parsed representation.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+#include "go-dump.h"
+#include "lex.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "dataflow.h"
+#include "runtime.h"
+#include "import.h"
+#include "export.h"
+#include "backend.h"
+#include "gogo.h"
+
+// Class Gogo.
+
+Gogo::Gogo(Backend* backend, int int_type_size, int pointer_size)
+ : backend_(backend),
+ package_(NULL),
+ functions_(),
+ globals_(new Bindings(NULL)),
+ imports_(),
+ imported_unsafe_(false),
+ packages_(),
+ map_descriptors_(NULL),
+ type_descriptor_decls_(NULL),
+ init_functions_(),
+ need_init_fn_(false),
+ init_fn_name_(),
+ imported_init_fns_(),
+ unique_prefix_(),
+ unique_prefix_specified_(false),
+ interface_types_(),
+ named_types_are_converted_(false)
+{
+ const source_location loc = BUILTINS_LOCATION;
+
+ Named_type* uint8_type = Type::make_integer_type("uint8", true, 8,
+ RUNTIME_TYPE_KIND_UINT8);
+ this->add_named_type(uint8_type);
+ this->add_named_type(Type::make_integer_type("uint16", true, 16,
+ RUNTIME_TYPE_KIND_UINT16));
+ this->add_named_type(Type::make_integer_type("uint32", true, 32,
+ RUNTIME_TYPE_KIND_UINT32));
+ this->add_named_type(Type::make_integer_type("uint64", true, 64,
+ RUNTIME_TYPE_KIND_UINT64));
+
+ this->add_named_type(Type::make_integer_type("int8", false, 8,
+ RUNTIME_TYPE_KIND_INT8));
+ this->add_named_type(Type::make_integer_type("int16", false, 16,
+ RUNTIME_TYPE_KIND_INT16));
+ this->add_named_type(Type::make_integer_type("int32", false, 32,
+ RUNTIME_TYPE_KIND_INT32));
+ this->add_named_type(Type::make_integer_type("int64", false, 64,
+ RUNTIME_TYPE_KIND_INT64));
+
+ this->add_named_type(Type::make_float_type("float32", 32,
+ RUNTIME_TYPE_KIND_FLOAT32));
+ this->add_named_type(Type::make_float_type("float64", 64,
+ RUNTIME_TYPE_KIND_FLOAT64));
+
+ this->add_named_type(Type::make_complex_type("complex64", 64,
+ RUNTIME_TYPE_KIND_COMPLEX64));
+ this->add_named_type(Type::make_complex_type("complex128", 128,
+ RUNTIME_TYPE_KIND_COMPLEX128));
+
+ if (int_type_size < 32)
+ int_type_size = 32;
+ this->add_named_type(Type::make_integer_type("uint", true,
+ int_type_size,
+ RUNTIME_TYPE_KIND_UINT));
+ Named_type* int_type = Type::make_integer_type("int", false, int_type_size,
+ RUNTIME_TYPE_KIND_INT);
+ this->add_named_type(int_type);
+
+ // "byte" is an alias for "uint8". Construct a Named_object which
+ // points to UINT8_TYPE. Note that this breaks the normal pairing
+ // in which a Named_object points to a Named_type which points back
+ // to the same Named_object.
+ Named_object* byte_type = this->declare_type("byte", loc);
+ byte_type->set_type_value(uint8_type);
+
+ this->add_named_type(Type::make_integer_type("uintptr", true,
+ pointer_size,
+ RUNTIME_TYPE_KIND_UINTPTR));
+
+ this->add_named_type(Type::make_named_bool_type());
+
+ this->add_named_type(Type::make_named_string_type());
+
+ this->globals_->add_constant(Typed_identifier("true",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(true, loc),
+ 0);
+ this->globals_->add_constant(Typed_identifier("false",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(false, loc),
+ 0);
+
+ this->globals_->add_constant(Typed_identifier("nil", Type::make_nil_type(),
+ loc),
+ NULL,
+ Expression::make_nil(loc),
+ 0);
+
+ Type* abstract_int_type = Type::make_abstract_integer_type();
+ this->globals_->add_constant(Typed_identifier("iota", abstract_int_type,
+ loc),
+ NULL,
+ Expression::make_iota(),
+ 0);
+
+ Function_type* new_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ new_type->set_is_varargs();
+ new_type->set_is_builtin();
+ this->globals_->add_function_declaration("new", NULL, new_type, loc);
+
+ Function_type* make_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ make_type->set_is_varargs();
+ make_type->set_is_builtin();
+ this->globals_->add_function_declaration("make", NULL, make_type, loc);
+
+ Typed_identifier_list* len_result = new Typed_identifier_list();
+ len_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* len_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ len_type->set_is_builtin();
+ this->globals_->add_function_declaration("len", NULL, len_type, loc);
+
+ Typed_identifier_list* cap_result = new Typed_identifier_list();
+ cap_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* cap_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ cap_type->set_is_builtin();
+ this->globals_->add_function_declaration("cap", NULL, cap_type, loc);
+
+ Function_type* print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("print", NULL, print_type, loc);
+
+ print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("println", NULL, print_type, loc);
+
+ Type *empty = Type::make_interface_type(NULL, loc);
+ Typed_identifier_list* panic_parms = new Typed_identifier_list();
+ panic_parms->push_back(Typed_identifier("e", empty, loc));
+ Function_type *panic_type = Type::make_function_type(NULL, panic_parms,
+ NULL, loc);
+ panic_type->set_is_builtin();
+ this->globals_->add_function_declaration("panic", NULL, panic_type, loc);
+
+ Typed_identifier_list* recover_result = new Typed_identifier_list();
+ recover_result->push_back(Typed_identifier("", empty, loc));
+ Function_type* recover_type = Type::make_function_type(NULL, NULL,
+ recover_result,
+ loc);
+ recover_type->set_is_builtin();
+ this->globals_->add_function_declaration("recover", NULL, recover_type, loc);
+
+ Function_type* close_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ close_type->set_is_varargs();
+ close_type->set_is_builtin();
+ this->globals_->add_function_declaration("close", NULL, close_type, loc);
+
+ Typed_identifier_list* copy_result = new Typed_identifier_list();
+ copy_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* copy_type = Type::make_function_type(NULL, NULL,
+ copy_result, loc);
+ copy_type->set_is_varargs();
+ copy_type->set_is_builtin();
+ this->globals_->add_function_declaration("copy", NULL, copy_type, loc);
+
+ Function_type* append_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ append_type->set_is_varargs();
+ append_type->set_is_builtin();
+ this->globals_->add_function_declaration("append", NULL, append_type, loc);
+
+ Function_type* complex_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ complex_type->set_is_varargs();
+ complex_type->set_is_builtin();
+ this->globals_->add_function_declaration("complex", NULL, complex_type, loc);
+
+ Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ real_type->set_is_varargs();
+ real_type->set_is_builtin();
+ this->globals_->add_function_declaration("real", NULL, real_type, loc);
+
+ Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ imag_type->set_is_varargs();
+ imag_type->set_is_builtin();
+ this->globals_->add_function_declaration("imag", NULL, imag_type, loc);
+
+ this->define_builtin_function_trees();
+}
+
+// Munge name for use in an error message.
+
+std::string
+Gogo::message_name(const std::string& name)
+{
+ return go_localize_identifier(Gogo::unpack_hidden_name(name).c_str());
+}
+
+// Get the package name.
+
+const std::string&
+Gogo::package_name() const
+{
+ go_assert(this->package_ != NULL);
+ return this->package_->name();
+}
+
+// Set the package name.
+
+void
+Gogo::set_package_name(const std::string& package_name,
+ source_location location)
+{
+ if (this->package_ != NULL && this->package_->name() != package_name)
+ {
+ error_at(location, "expected package %<%s%>",
+ Gogo::message_name(this->package_->name()).c_str());
+ return;
+ }
+
+ // If the user did not specify a unique prefix, we always use "go".
+ // This in effect requires that the package name be unique.
+ if (this->unique_prefix_.empty())
+ this->unique_prefix_ = "go";
+
+ this->package_ = this->register_package(package_name, this->unique_prefix_,
+ location);
+
+ // We used to permit people to qualify symbols with the current
+ // package name (e.g., P.x), but we no longer do.
+ // this->globals_->add_package(package_name, this->package_);
+
+ if (this->is_main_package())
+ {
+ // Declare "main" as a function which takes no parameters and
+ // returns no value.
+ this->declare_function("main",
+ Type::make_function_type(NULL, NULL, NULL,
+ BUILTINS_LOCATION),
+ BUILTINS_LOCATION);
+ }
+}
+
+// Return whether this is the "main" package. This is not true if
+// -fgo-prefix was used.
+
+bool
+Gogo::is_main_package() const
+{
+ return this->package_name() == "main" && !this->unique_prefix_specified_;
+}
+
+// Import a package.
+
+void
+Gogo::import_package(const std::string& filename,
+ const std::string& local_name,
+ bool is_local_name_exported,
+ source_location location)
+{
+ if (filename == "unsafe")
+ {
+ this->import_unsafe(local_name, is_local_name_exported, location);
+ return;
+ }
+
+ Imports::const_iterator p = this->imports_.find(filename);
+ if (p != this->imports_.end())
+ {
+ Package* package = p->second;
+ package->set_location(location);
+ package->set_is_imported();
+ std::string ln = local_name;
+ bool is_ln_exported = is_local_name_exported;
+ if (ln.empty())
+ {
+ ln = package->name();
+ is_ln_exported = Lex::is_exported_name(ln);
+ }
+ if (ln == ".")
+ {
+ Bindings* bindings = package->bindings();
+ for (Bindings::const_declarations_iterator p =
+ bindings->begin_declarations();
+ p != bindings->end_declarations();
+ ++p)
+ this->add_named_object(p->second);
+ }
+ else if (ln == "_")
+ package->set_uses_sink_alias();
+ else
+ {
+ ln = this->pack_hidden_name(ln, is_ln_exported);
+ this->package_->bindings()->add_package(ln, package);
+ }
+ return;
+ }
+
+ Import::Stream* stream = Import::open_package(filename, location);
+ if (stream == NULL)
+ {
+ error_at(location, "import file %qs not found", filename.c_str());
+ return;
+ }
+
+ Import imp(stream, location);
+ imp.register_builtin_types(this);
+ Package* package = imp.import(this, local_name, is_local_name_exported);
+ if (package != NULL)
+ {
+ if (package->name() == this->package_name()
+ && package->unique_prefix() == this->unique_prefix())
+ error_at(location,
+ ("imported package uses same package name and prefix "
+ "as package being compiled (see -fgo-prefix option)"));
+
+ this->imports_.insert(std::make_pair(filename, package));
+ package->set_is_imported();
+ }
+
+ delete stream;
+}
+
+// Add an import control function for an imported package to the list.
+
+void
+Gogo::add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio)
+{
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ {
+ if (p->init_name() == init_name
+ && (p->package_name() != package_name || p->priority() != prio))
+ {
+ error("duplicate package initialization name %qs",
+ Gogo::message_name(init_name).c_str());
+ inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
+ Gogo::message_name(p->package_name()).c_str(),
+ p->priority());
+ inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
+ Gogo::message_name(package_name).c_str(), prio);
+ return;
+ }
+ }
+
+ this->imported_init_fns_.insert(Import_init(package_name, init_name,
+ prio));
+}
+
+// Return whether we are at the global binding level.
+
+bool
+Gogo::in_global_scope() const
+{
+ return this->functions_.empty();
+}
+
+// Return the current binding contour.
+
+Bindings*
+Gogo::current_bindings()
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+const Bindings*
+Gogo::current_bindings() const
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+// Return the current block.
+
+Block*
+Gogo::current_block()
+{
+ if (this->functions_.empty())
+ return NULL;
+ else
+ return this->functions_.back().blocks.back();
+}
+
+// Look up a name in the current binding contour. If PFUNCTION is not
+// NULL, set it to the function in which the name is defined, or NULL
+// if the name is defined in global scope.
+
+Named_object*
+Gogo::lookup(const std::string& name, Named_object** pfunction) const
+{
+ if (pfunction != NULL)
+ *pfunction = NULL;
+
+ if (Gogo::is_sink_name(name))
+ return Named_object::make_sink();
+
+ for (Open_functions::const_reverse_iterator p = this->functions_.rbegin();
+ p != this->functions_.rend();
+ ++p)
+ {
+ Named_object* ret = p->blocks.back()->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (pfunction != NULL)
+ *pfunction = p->function;
+ return ret;
+ }
+ }
+
+ if (this->package_ != NULL)
+ {
+ Named_object* ret = this->package_->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (ret->package() != NULL)
+ ret->package()->set_used();
+ return ret;
+ }
+ }
+
+ // We do not look in the global namespace. If we did, the global
+ // namespace would effectively hide names which were defined in
+ // package scope which we have not yet seen. Instead,
+ // define_global_names is called after parsing is over to connect
+ // undefined names at package scope with names defined at global
+ // scope.
+
+ return NULL;
+}
+
+// Look up a name in the current block, without searching enclosing
+// blocks.
+
+Named_object*
+Gogo::lookup_in_block(const std::string& name) const
+{
+ go_assert(!this->functions_.empty());
+ go_assert(!this->functions_.back().blocks.empty());
+ return this->functions_.back().blocks.back()->bindings()->lookup_local(name);
+}
+
+// Look up a name in the global namespace.
+
+Named_object*
+Gogo::lookup_global(const char* name) const
+{
+ return this->globals_->lookup(name);
+}
+
+// Add an imported package.
+
+Package*
+Gogo::add_imported_package(const std::string& real_name,
+ const std::string& alias_arg,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals)
+{
+ // FIXME: Now that we compile packages as a whole, should we permit
+ // importing the current package?
+ if (this->package_name() == real_name
+ && this->unique_prefix() == unique_prefix)
+ {
+ *padd_to_globals = false;
+ if (!alias_arg.empty() && alias_arg != ".")
+ {
+ std::string alias = this->pack_hidden_name(alias_arg,
+ is_alias_exported);
+ this->package_->bindings()->add_package(alias, this->package_);
+ }
+ return this->package_;
+ }
+ else if (alias_arg == ".")
+ {
+ *padd_to_globals = true;
+ return this->register_package(real_name, unique_prefix, location);
+ }
+ else if (alias_arg == "_")
+ {
+ Package* ret = this->register_package(real_name, unique_prefix, location);
+ ret->set_uses_sink_alias();
+ return ret;
+ }
+ else
+ {
+ *padd_to_globals = false;
+ std::string alias = alias_arg;
+ if (alias.empty())
+ {
+ alias = real_name;
+ is_alias_exported = Lex::is_exported_name(alias);
+ }
+ alias = this->pack_hidden_name(alias, is_alias_exported);
+ Named_object* no = this->add_package(real_name, alias, unique_prefix,
+ location);
+ if (!no->is_package())
+ return NULL;
+ return no->package_value();
+ }
+}
+
+// Add a package.
+
+Named_object*
+Gogo::add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location)
+{
+ go_assert(this->in_global_scope());
+
+ // Register the package. Note that we might have already seen it in
+ // an earlier import.
+ Package* package = this->register_package(real_name, unique_prefix, location);
+
+ return this->package_->bindings()->add_package(alias, package);
+}
+
+// Register a package. This package may or may not be imported. This
+// returns the Package structure for the package, creating if it
+// necessary.
+
+Package*
+Gogo::register_package(const std::string& package_name,
+ const std::string& unique_prefix,
+ source_location location)
+{
+ go_assert(!unique_prefix.empty() && !package_name.empty());
+ std::string name = unique_prefix + '.' + package_name;
+ Package* package = NULL;
+ std::pair<Packages::iterator, bool> ins =
+ this->packages_.insert(std::make_pair(name, package));
+ if (!ins.second)
+ {
+ // We have seen this package name before.
+ package = ins.first->second;
+ go_assert(package != NULL);
+ go_assert(package->name() == package_name
+ && package->unique_prefix() == unique_prefix);
+ if (package->location() == UNKNOWN_LOCATION)
+ package->set_location(location);
+ }
+ else
+ {
+ // First time we have seen this package name.
+ package = new Package(package_name, unique_prefix, location);
+ go_assert(ins.first->second == NULL);
+ ins.first->second = package;
+ }
+
+ return package;
+}
+
+// Start compiling a function.
+
+Named_object*
+Gogo::start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location location)
+{
+ bool at_top_level = this->functions_.empty();
+
+ Block* block = new Block(NULL, location);
+
+ Function* enclosing = (at_top_level
+ ? NULL
+ : this->functions_.back().function->func_value());
+
+ Function* function = new Function(type, enclosing, block, location);
+
+ if (type->is_method())
+ {
+ const Typed_identifier* receiver = type->receiver();
+ Variable* this_param = new Variable(receiver->type(), NULL, false,
+ true, true, location);
+ std::string name = receiver->name();
+ if (name.empty())
+ {
+ // We need to give receivers a name since they wind up in
+ // DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "r.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, this_param);
+ }
+
+ const Typed_identifier_list* parameters = type->parameters();
+ bool is_varargs = type->is_varargs();
+ if (parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ Variable* param = new Variable(p->type(), NULL, false, true, false,
+ location);
+ if (is_varargs && p + 1 == parameters->end())
+ param->set_is_varargs_parameter();
+
+ std::string name = p->name();
+ if (name.empty() || Gogo::is_sink_name(name))
+ {
+ // We need to give parameters a name since they wind up
+ // in DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "p.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, param);
+ }
+ }
+
+ function->create_result_variables(this);
+
+ const std::string* pname;
+ std::string nested_name;
+ bool is_init = false;
+ if (Gogo::unpack_hidden_name(name) == "init" && !type->is_method())
+ {
+ if ((type->parameters() != NULL && !type->parameters()->empty())
+ || (type->results() != NULL && !type->results()->empty()))
+ error_at(location,
+ "func init must have no arguments and no return values");
+ // There can be multiple "init" functions, so give them each a
+ // different name.
+ static int init_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$init%d", init_count);
+ ++init_count;
+ nested_name = buf;
+ pname = &nested_name;
+ is_init = true;
+ }
+ else if (!name.empty())
+ pname = &name;
+ else
+ {
+ // Invent a name for a nested function.
+ static int nested_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$nested%d", nested_count);
+ ++nested_count;
+ nested_name = buf;
+ pname = &nested_name;
+ }
+
+ Named_object* ret;
+ if (Gogo::is_sink_name(*pname))
+ {
+ static int sink_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$sink%d", sink_count);
+ ++sink_count;
+ ret = Named_object::make_function(buf, NULL, function);
+ }
+ else if (!type->is_method())
+ {
+ ret = this->package_->bindings()->add_function(*pname, NULL, function);
+ if (!ret->is_function() || ret->func_value() != function)
+ {
+ // Redefinition error. Invent a name to avoid knockon
+ // errors.
+ static int redefinition_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$redefined%d", redefinition_count);
+ ++redefinition_count;
+ ret = this->package_->bindings()->add_function(buf, NULL, function);
+ }
+ }
+ else
+ {
+ if (!add_method_to_type)
+ ret = Named_object::make_function(name, NULL, function);
+ else
+ {
+ go_assert(at_top_level);
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ ret = Named_object::make_function(name, NULL, function);
+ else if (rtype->named_type() != NULL)
+ {
+ ret = rtype->named_type()->add_method(name, function);
+ if (!ret->is_function())
+ {
+ // Redefinition error.
+ ret = Named_object::make_function(name, NULL, function);
+ }
+ }
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Named_object* type_no =
+ rtype->forward_declaration_type()->named_object();
+ if (type_no->is_unknown())
+ {
+ // If we are seeing methods it really must be a
+ // type. Declare it as such. An alternative would
+ // be to support lists of methods for unknown
+ // expressions. Either way the error messages if
+ // this is not a type are going to get confusing.
+ Named_object* declared =
+ this->declare_package_type(type_no->name(),
+ type_no->location());
+ go_assert(declared
+ == type_no->unknown_value()->real_named_object());
+ }
+ ret = rtype->forward_declaration_type()->add_method(name,
+ function);
+ }
+ else
+ go_unreachable();
+ }
+ this->package_->bindings()->add_method(ret);
+ }
+
+ this->functions_.resize(this->functions_.size() + 1);
+ Open_function& of(this->functions_.back());
+ of.function = ret;
+ of.blocks.push_back(block);
+
+ if (is_init)
+ {
+ this->init_functions_.push_back(ret);
+ this->need_init_fn_ = true;
+ }
+
+ return ret;
+}
+
+// Finish compiling a function.
+
+void
+Gogo::finish_function(source_location location)
+{
+ this->finish_block(location);
+ go_assert(this->functions_.back().blocks.empty());
+ this->functions_.pop_back();
+}
+
+// Return the current function.
+
+Named_object*
+Gogo::current_function() const
+{
+ go_assert(!this->functions_.empty());
+ return this->functions_.back().function;
+}
+
+// Start a new block.
+
+void
+Gogo::start_block(source_location location)
+{
+ go_assert(!this->functions_.empty());
+ Block* block = new Block(this->current_block(), location);
+ this->functions_.back().blocks.push_back(block);
+}
+
+// Finish a block.
+
+Block*
+Gogo::finish_block(source_location location)
+{
+ go_assert(!this->functions_.empty());
+ go_assert(!this->functions_.back().blocks.empty());
+ Block* block = this->functions_.back().blocks.back();
+ this->functions_.back().blocks.pop_back();
+ block->set_end_location(location);
+ return block;
+}
+
+// Add an unknown name.
+
+Named_object*
+Gogo::add_unknown_name(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_unknown_name(name, location);
+}
+
+// Declare a function.
+
+Named_object*
+Gogo::declare_function(const std::string& name, Function_type* type,
+ source_location location)
+{
+ if (!type->is_method())
+ return this->current_bindings()->add_function_declaration(name, NULL, type,
+ location);
+ else
+ {
+ // We don't bother to add this to the list of global
+ // declarations.
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ return NULL;
+ else if (rtype->named_type() != NULL)
+ return rtype->named_type()->add_method_declaration(name, NULL, type,
+ location);
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Forward_declaration_type* ftype = rtype->forward_declaration_type();
+ return ftype->add_method_declaration(name, type, location);
+ }
+ else
+ go_unreachable();
+ }
+}
+
+// Add a label definition.
+
+Label*
+Gogo::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ go_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ Label* label = func->add_label_definition(label_name, location);
+ this->add_statement(Statement::make_label_statement(label, location));
+ return label;
+}
+
+// Add a label reference.
+
+Label*
+Gogo::add_label_reference(const std::string& label_name)
+{
+ go_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ return func->add_label_reference(label_name);
+}
+
+// Add a statement.
+
+void
+Gogo::add_statement(Statement* statement)
+{
+ go_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a block.
+
+void
+Gogo::add_block(Block* block, source_location location)
+{
+ go_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ Statement* statement = Statement::make_block_statement(block, location);
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a constant.
+
+Named_object*
+Gogo::add_constant(const Typed_identifier& tid, Expression* expr,
+ int iota_value)
+{
+ return this->current_bindings()->add_constant(tid, NULL, expr, iota_value);
+}
+
+// Add a type.
+
+void
+Gogo::add_type(const std::string& name, Type* type, source_location location)
+{
+ Named_object* no = this->current_bindings()->add_type(name, NULL, type,
+ location);
+ if (!this->in_global_scope() && no->is_type())
+ no->type_value()->set_in_function(this->functions_.back().function);
+}
+
+// Add a named type.
+
+void
+Gogo::add_named_type(Named_type* type)
+{
+ go_assert(this->in_global_scope());
+ this->current_bindings()->add_named_type(type);
+}
+
+// Declare a type.
+
+Named_object*
+Gogo::declare_type(const std::string& name, source_location location)
+{
+ Bindings* bindings = this->current_bindings();
+ Named_object* no = bindings->add_type_declaration(name, NULL, location);
+ if (!this->in_global_scope() && no->is_type_declaration())
+ {
+ Named_object* f = this->functions_.back().function;
+ no->type_declaration_value()->set_in_function(f);
+ }
+ return no;
+}
+
+// Declare a type at the package level.
+
+Named_object*
+Gogo::declare_package_type(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_type_declaration(name, NULL, location);
+}
+
+// Define a type which was already declared.
+
+void
+Gogo::define_type(Named_object* no, Named_type* type)
+{
+ this->current_bindings()->define_type(no, type);
+}
+
+// Add a variable.
+
+Named_object*
+Gogo::add_variable(const std::string& name, Variable* variable)
+{
+ Named_object* no = this->current_bindings()->add_variable(name, NULL,
+ variable);
+
+ // In a function the middle-end wants to see a DECL_EXPR node.
+ if (no != NULL
+ && no->is_variable()
+ && !no->var_value()->is_parameter()
+ && !this->functions_.empty())
+ this->add_statement(Statement::make_variable_declaration(no));
+
+ return no;
+}
+
+// Add a sink--a reference to the blank identifier _.
+
+Named_object*
+Gogo::add_sink()
+{
+ return Named_object::make_sink();
+}
+
+// Add a named object.
+
+void
+Gogo::add_named_object(Named_object* no)
+{
+ this->current_bindings()->add_named_object(no);
+}
+
+// Record that we've seen an interface type.
+
+void
+Gogo::record_interface_type(Interface_type* itype)
+{
+ this->interface_types_.push_back(itype);
+}
+
+// Return a name for a thunk object.
+
+std::string
+Gogo::thunk_name()
+{
+ static int thunk_count;
+ char thunk_name[50];
+ snprintf(thunk_name, sizeof thunk_name, "$thunk%d", thunk_count);
+ ++thunk_count;
+ return thunk_name;
+}
+
+// Return whether a function is a thunk.
+
+bool
+Gogo::is_thunk(const Named_object* no)
+{
+ return no->name().compare(0, 6, "$thunk") == 0;
+}
+
+// Define the global names. We do this only after parsing all the
+// input files, because the program might define the global names
+// itself.
+
+void
+Gogo::define_global_names()
+{
+ for (Bindings::const_declarations_iterator p =
+ this->globals_->begin_declarations();
+ p != this->globals_->end_declarations();
+ ++p)
+ {
+ Named_object* global_no = p->second;
+ std::string name(Gogo::pack_hidden_name(global_no->name(), false));
+ Named_object* no = this->package_->bindings()->lookup(name);
+ if (no == NULL)
+ continue;
+ no = no->resolve();
+ if (no->is_type_declaration())
+ {
+ if (global_no->is_type())
+ {
+ if (no->type_declaration_value()->has_methods())
+ error_at(no->location(),
+ "may not define methods for global type");
+ no->set_type_value(global_no->type_value());
+ }
+ else
+ {
+ error_at(no->location(), "expected type");
+ Type* errtype = Type::make_error_type();
+ Named_object* err = Named_object::make_type("error", NULL,
+ errtype,
+ BUILTINS_LOCATION);
+ no->set_type_value(err->type_value());
+ }
+ }
+ else if (no->is_unknown())
+ no->unknown_value()->set_real_named_object(global_no);
+ }
+}
+
+// Clear out names in file scope.
+
+void
+Gogo::clear_file_scope()
+{
+ this->package_->bindings()->clear_file_scope();
+
+ // Warn about packages which were imported but not used.
+ for (Packages::iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ Package* package = p->second;
+ if (package != this->package_
+ && package->is_imported()
+ && !package->used()
+ && !package->uses_sink_alias()
+ && !saw_errors())
+ error_at(package->location(), "imported and not used: %s",
+ Gogo::message_name(package->name()).c_str());
+ package->clear_is_imported();
+ package->clear_uses_sink_alias();
+ package->clear_used();
+ }
+}
+
+// Traverse the tree.
+
+void
+Gogo::traverse(Traverse* traverse)
+{
+ // Traverse the current package first for consistency. The other
+ // packages will only contain imported types, constants, and
+ // declarations.
+ if (this->package_->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ return;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ if (p->second != this->package_)
+ {
+ if (p->second->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ break;
+ }
+ }
+}
+
+// Traversal class used to verify types.
+
+class Verify_types : public Traverse
+{
+ public:
+ Verify_types()
+ : Traverse(traverse_types)
+ { }
+
+ int
+ type(Type*);
+};
+
+// Verify that a type is correct.
+
+int
+Verify_types::type(Type* t)
+{
+ if (!t->verify())
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that all types are correct.
+
+void
+Gogo::verify_types()
+{
+ Verify_types traverse;
+ this->traverse(&traverse);
+}
+
+// Traversal class used to lower parse tree.
+
+class Lower_parse_tree : public Traverse
+{
+ public:
+ Lower_parse_tree(Gogo* gogo, Named_object* function)
+ : Traverse(traverse_variables
+ | traverse_constants
+ | traverse_functions
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo), function_(function), iota_value_(-1)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ function(Named_object*);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+ // The function we are traversing.
+ Named_object* function_;
+ // Value to use for the predeclared constant iota.
+ int iota_value_;
+};
+
+// Lower variables. We handle variables specially to break loops in
+// which a variable initialization expression refers to itself. The
+// loop breaking is in lower_init_expression.
+
+int
+Lower_parse_tree::variable(Named_object* no)
+{
+ if (no->is_variable())
+ no->var_value()->lower_init_expression(this->gogo_, this->function_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower constants. We handle constants specially so that we can set
+// the right value for the predeclared constant iota. This works in
+// conjunction with the way we lower Const_expression objects.
+
+int
+Lower_parse_tree::constant(Named_object* no, bool)
+{
+ Named_constant* nc = no->const_value();
+
+ // Don't get into trouble if the constant's initializer expression
+ // refers to the constant itself.
+ if (nc->lowering())
+ return TRAVERSE_CONTINUE;
+ nc->set_lowering();
+
+ go_assert(this->iota_value_ == -1);
+ this->iota_value_ = nc->iota_value();
+ nc->traverse_expression(this);
+ this->iota_value_ = -1;
+
+ nc->clear_lowering();
+
+ // We will traverse the expression a second time, but that will be
+ // fast.
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower function closure types. Record the function while lowering
+// it, so that we can pass it down when lowering an expression.
+
+int
+Lower_parse_tree::function(Named_object* no)
+{
+ no->func_value()->set_closure_type();
+
+ go_assert(this->function_ == NULL);
+ this->function_ = no;
+ int t = no->func_value()->traverse(this);
+ this->function_ = NULL;
+
+ if (t == TRAVERSE_EXIT)
+ return t;
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower statement parse trees.
+
+int
+Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
+{
+ // Lower the expressions first.
+ int t = sorig->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+
+ // Keep lowering until nothing changes.
+ Statement* s = sorig;
+ while (true)
+ {
+ Statement* snew = s->lower(this->gogo_, this->function_, block);
+ if (snew == s)
+ break;
+ s = snew;
+ t = s->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+ }
+
+ if (s != sorig)
+ block->replace_statement(*pindex, s);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower expression parse trees.
+
+int
+Lower_parse_tree::expression(Expression** pexpr)
+{
+ // We have to lower all subexpressions first, so that we can get
+ // their type if necessary. This is awkward, because we don't have
+ // a postorder traversal pass.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ // Keep lowering until nothing changes.
+ while (true)
+ {
+ Expression* e = *pexpr;
+ Expression* enew = e->lower(this->gogo_, this->function_,
+ this->iota_value_);
+ if (enew == e)
+ break;
+ *pexpr = enew;
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower the parse tree. This is called after the parse is complete,
+// when all names should be resolved.
+
+void
+Gogo::lower_parse_tree()
+{
+ Lower_parse_tree lower_parse_tree(this, NULL);
+ this->traverse(&lower_parse_tree);
+}
+
+// Lower a block.
+
+void
+Gogo::lower_block(Named_object* function, Block* block)
+{
+ Lower_parse_tree lower_parse_tree(this, function);
+ block->traverse(&lower_parse_tree);
+}
+
+// Lower an expression.
+
+void
+Gogo::lower_expression(Named_object* function, Expression** pexpr)
+{
+ Lower_parse_tree lower_parse_tree(this, function);
+ lower_parse_tree.expression(pexpr);
+}
+
+// Lower a constant. This is called when lowering a reference to a
+// constant. We have to make sure that the constant has already been
+// lowered.
+
+void
+Gogo::lower_constant(Named_object* no)
+{
+ go_assert(no->is_const());
+ Lower_parse_tree lower(this, NULL);
+ lower.constant(no, false);
+}
+
+// Look for interface types to finalize methods of inherited
+// interfaces.
+
+class Finalize_methods : public Traverse
+{
+ public:
+ Finalize_methods(Gogo* gogo)
+ : Traverse(traverse_types),
+ gogo_(gogo)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ Gogo* gogo_;
+};
+
+// Finalize the methods of an interface type.
+
+int
+Finalize_methods::type(Type* t)
+{
+ // Check the classification so that we don't finalize the methods
+ // twice for a named interface type.
+ switch (t->classification())
+ {
+ case Type::TYPE_INTERFACE:
+ t->interface_type()->finalize_methods();
+ break;
+
+ case Type::TYPE_NAMED:
+ {
+ // We have to finalize the methods of the real type first.
+ // But if the real type is a struct type, then we only want to
+ // finalize the methods of the field types, not of the struct
+ // type itself. We don't want to add methods to the struct,
+ // since it has a name.
+ Type* rt = t->named_type()->real_type();
+ if (rt->classification() != Type::TYPE_STRUCT)
+ {
+ if (Type::traverse(rt, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ else
+ {
+ if (rt->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ t->named_type()->finalize_methods(this->gogo_);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ case Type::TYPE_STRUCT:
+ t->struct_type()->finalize_methods(this->gogo_);
+ break;
+
+ default:
+ break;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Finalize method lists and build stub methods for types.
+
+void
+Gogo::finalize_methods()
+{
+ Finalize_methods finalize(this);
+ this->traverse(&finalize);
+}
+
+// Set types for unspecified variables and constants.
+
+void
+Gogo::determine_types()
+{
+ Bindings* bindings = this->current_bindings();
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_function())
+ (*p)->func_value()->determine_types();
+ else if ((*p)->is_variable())
+ (*p)->var_value()->determine_type();
+ else if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+
+ // See if a variable requires us to build an initialization
+ // function. We know that we will see all global variables
+ // here.
+ if (!this->need_init_fn_ && (*p)->is_variable())
+ {
+ Variable* variable = (*p)->var_value();
+
+ // If this is a global variable which requires runtime
+ // initialization, we need an initialization function.
+ if (!variable->is_global())
+ ;
+ else if (variable->init() == NULL)
+ ;
+ else if (variable->type()->interface_type() != NULL)
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_constant())
+ ;
+ else if (!variable->init()->is_composite_literal())
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_nonconstant_composite_literal())
+ this->need_init_fn_ = true;
+
+ // If this is a global variable which holds a pointer value,
+ // then we need an initialization function to register it as a
+ // GC root.
+ if (variable->is_global() && variable->type()->has_pointer())
+ this->need_init_fn_ = true;
+ }
+ }
+
+ // Determine the types of constants in packages.
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ p->second->determine_types();
+}
+
+// Traversal class used for type checking.
+
+class Check_types_traverse : public Traverse
+{
+ public:
+ Check_types_traverse(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_constants
+ | traverse_functions
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ function(Named_object*);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+};
+
+// Check that a variable initializer has the right type.
+
+int
+Check_types_traverse::variable(Named_object* named_object)
+{
+ if (named_object->is_variable())
+ {
+ Variable* var = named_object->var_value();
+ Expression* init = var->init();
+ std::string reason;
+ if (init != NULL
+ && !Type::are_assignable(var->type(), init->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(var->location(), "incompatible type in initialization");
+ else
+ error_at(var->location(),
+ "incompatible type in initialization (%s)",
+ reason.c_str());
+ var->clear_init();
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that a constant initializer has the right type.
+
+int
+Check_types_traverse::constant(Named_object* named_object, bool)
+{
+ Named_constant* constant = named_object->const_value();
+ Type* ctype = constant->type();
+ if (ctype->integer_type() == NULL
+ && ctype->float_type() == NULL
+ && ctype->complex_type() == NULL
+ && !ctype->is_boolean_type()
+ && !ctype->is_string_type())
+ {
+ if (ctype->is_nil_type())
+ error_at(constant->location(), "const initializer cannot be nil");
+ else if (!ctype->is_error())
+ error_at(constant->location(), "invalid constant type");
+ constant->set_error();
+ }
+ else if (!constant->expr()->is_constant())
+ {
+ error_at(constant->expr()->location(), "expression is not constant");
+ constant->set_error();
+ }
+ else if (!Type::are_assignable(constant->type(), constant->expr()->type(),
+ NULL))
+ {
+ error_at(constant->location(),
+ "initialization expression has wrong type");
+ constant->set_error();
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// There are no types to check in a function, but this is where we
+// issue warnings about labels which are defined but not referenced.
+
+int
+Check_types_traverse::function(Named_object* no)
+{
+ no->func_value()->check_labels();
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in a statement.
+
+int
+Check_types_traverse::statement(Block*, size_t*, Statement* s)
+{
+ s->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in an expression.
+
+int
+Check_types_traverse::expression(Expression** expr)
+{
+ (*expr)->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid.
+
+void
+Gogo::check_types()
+{
+ Check_types_traverse traverse(this);
+ this->traverse(&traverse);
+}
+
+// Check the types in a single block.
+
+void
+Gogo::check_types_in_block(Block* block)
+{
+ Check_types_traverse traverse(this);
+ block->traverse(&traverse);
+}
+
+// A traversal class used to find a single shortcut operator within an
+// expression.
+
+class Find_shortcut : public Traverse
+{
+ public:
+ Find_shortcut()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ found_(NULL)
+ { }
+
+ // A pointer to the expression which was found, or NULL if none was
+ // found.
+ Expression**
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ Expression** found_;
+};
+
+// Find a shortcut expression.
+
+int
+Find_shortcut::expression(Expression** pexpr)
+{
+ Expression* expr = *pexpr;
+ Binary_expression* be = expr->binary_expression();
+ if (be == NULL)
+ return TRAVERSE_CONTINUE;
+ Operator op = be->op();
+ if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
+ return TRAVERSE_CONTINUE;
+ go_assert(this->found_ == NULL);
+ this->found_ = pexpr;
+ return TRAVERSE_EXIT;
+}
+
+// A traversal class used to turn shortcut operators into explicit if
+// statements.
+
+class Shortcuts : public Traverse
+{
+ public:
+ Shortcuts(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_statements),
+ gogo_(gogo)
+ { }
+
+ protected:
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+
+ private:
+ // Convert a shortcut operator.
+ Statement*
+ convert_shortcut(Block* enclosing, Expression** pshortcut);
+
+ // The IR.
+ Gogo* gogo_;
+};
+
+// Remove shortcut operators in a single statement.
+
+int
+Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+
+ // If S is a variable declaration, then ordinary traversal won't
+ // do anything. We want to explicitly traverse the
+ // initialization expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_shortcut);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ init->traverse(&init, &find_shortcut);
+ }
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(block, pshortcut);
+ block->insert_statement_before(*pindex, snew);
+ ++*pindex;
+
+ if (pshortcut == &init)
+ vds->var()->var_value()->set_init(init);
+ }
+}
+
+// Remove shortcut operators in the initializer of a global variable.
+
+int
+Shortcuts::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+ init->traverse(&init, &find_shortcut);
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(NULL, pshortcut);
+ var->add_preinit_statement(this->gogo_, snew);
+ if (pshortcut == &init)
+ var->set_init(init);
+ }
+}
+
+// Given an expression which uses a shortcut operator, return a
+// statement which implements it, and update *PSHORTCUT accordingly.
+
+Statement*
+Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
+{
+ Binary_expression* shortcut = (*pshortcut)->binary_expression();
+ Expression* left = shortcut->left();
+ Expression* right = shortcut->right();
+ source_location loc = shortcut->location();
+
+ Block* retblock = new Block(enclosing, loc);
+ retblock->set_end_location(loc);
+
+ Temporary_statement* ts = Statement::make_temporary(Type::lookup_bool_type(),
+ left, loc);
+ retblock->add_statement(ts);
+
+ Block* block = new Block(retblock, loc);
+ block->set_end_location(loc);
+ Expression* tmpref = Expression::make_temporary_reference(ts, loc);
+ Statement* assign = Statement::make_assignment(tmpref, right, loc);
+ block->add_statement(assign);
+
+ Expression* cond = Expression::make_temporary_reference(ts, loc);
+ if (shortcut->binary_expression()->op() == OPERATOR_OROR)
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+
+ Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
+ loc);
+ retblock->add_statement(if_statement);
+
+ *pshortcut = Expression::make_temporary_reference(ts, loc);
+
+ delete shortcut;
+
+ // Now convert any shortcut operators in LEFT and RIGHT.
+ Shortcuts shortcuts(this->gogo_);
+ retblock->traverse(&shortcuts);
+
+ return Statement::make_block_statement(retblock, loc);
+}
+
+// Turn shortcut operators into explicit if statements. Doing this
+// considerably simplifies the order of evaluation rules.
+
+void
+Gogo::remove_shortcuts()
+{
+ Shortcuts shortcuts(this);
+ this->traverse(&shortcuts);
+}
+
+// A traversal class which finds all the expressions which must be
+// evaluated in order within a statement or larger expression. This
+// is used to implement the rules about order of evaluation.
+
+class Find_eval_ordering : public Traverse
+{
+ private:
+ typedef std::vector<Expression**> Expression_pointers;
+
+ public:
+ Find_eval_ordering()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ exprs_()
+ { }
+
+ size_t
+ size() const
+ { return this->exprs_.size(); }
+
+ typedef Expression_pointers::const_iterator const_iterator;
+
+ const_iterator
+ begin() const
+ { return this->exprs_.begin(); }
+
+ const_iterator
+ end() const
+ { return this->exprs_.end(); }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // A list of pointers to expressions with side-effects.
+ Expression_pointers exprs_;
+};
+
+// If an expression must be evaluated in order, put it on the list.
+
+int
+Find_eval_ordering::expression(Expression** expression_pointer)
+{
+ // We have to look at subexpressions before this one.
+ if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*expression_pointer)->must_eval_in_order())
+ this->exprs_.push_back(expression_pointer);
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// A traversal class for ordering evaluations.
+
+class Order_eval : public Traverse
+{
+ public:
+ Order_eval(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_statements),
+ gogo_(gogo)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+
+ private:
+ // The IR.
+ Gogo* gogo_;
+};
+
+// Implement the order of evaluation rules for a statement.
+
+int
+Order_eval::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+
+ // If S is a variable declaration, then ordinary traversal won't do
+ // anything. We want to explicitly traverse the initialization
+ // expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ Expression* orig_init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_eval_ordering);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ orig_init = init;
+
+ // It might seem that this could be
+ // init->traverse_subexpressions. Unfortunately that can fail
+ // in a case like
+ // var err os.Error
+ // newvar, err := call(arg())
+ // Here newvar will have an init of call result 0 of
+ // call(arg()). If we only traverse subexpressions, we will
+ // only find arg(), and we won't bother to move anything out.
+ // Then we get to the assignment to err, we will traverse the
+ // whole statement, and this time we will find both call() and
+ // arg(), and so we will move them out. This will cause them to
+ // be put into temporary variables before the assignment to err
+ // but after the declaration of newvar. To avoid that problem,
+ // we traverse the entire expression here.
+ Expression::traverse(&init, &find_eval_ordering);
+ }
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_CONTINUE;
+ }
+
+ bool is_thunk = s->thunk_statement() != NULL;
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+
+ // The last expression in a thunk will be the call passed to go
+ // or defer, which we must not evaluate early.
+ if (is_thunk && p + 1 == find_eval_ordering.end())
+ break;
+
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ block->insert_statement_before(*pindex, ts);
+ ++*pindex;
+
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ if (init != orig_init)
+ vds->var()->var_value()->set_init(init);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Implement the order of evaluation rules for the initializer of a
+// global variable.
+
+int
+Order_eval::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+ init->traverse_subexpressions(&find_eval_ordering);
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ var->add_preinit_statement(this->gogo_, ts);
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Use temporary variables to implement the order of evaluation rules.
+
+void
+Gogo::order_evaluations()
+{
+ Order_eval order_eval(this);
+ this->traverse(&order_eval);
+}
+
+// Traversal to convert calls to the predeclared recover function to
+// pass in an argument indicating whether it can recover from a panic
+// or not.
+
+class Convert_recover : public Traverse
+{
+ public:
+ Convert_recover(Named_object* arg)
+ : Traverse(traverse_expressions),
+ arg_(arg)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The argument to pass to the function.
+ Named_object* arg_;
+};
+
+// Convert calls to recover.
+
+int
+Convert_recover::expression(Expression** pp)
+{
+ Call_expression* ce = (*pp)->call_expression();
+ if (ce != NULL && ce->is_recover_call())
+ ce->set_recover_arg(Expression::make_var_reference(this->arg_,
+ ce->location()));
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal for build_recover_thunks.
+
+class Build_recover_thunks : public Traverse
+{
+ public:
+ Build_recover_thunks(Gogo* gogo)
+ : Traverse(traverse_functions),
+ gogo_(gogo)
+ { }
+
+ int
+ function(Named_object*);
+
+ private:
+ Expression*
+ can_recover_arg(source_location);
+
+ // General IR.
+ Gogo* gogo_;
+};
+
+// If this function calls recover, turn it into a thunk.
+
+int
+Build_recover_thunks::function(Named_object* orig_no)
+{
+ Function* orig_func = orig_no->func_value();
+ if (!orig_func->calls_recover()
+ || orig_func->is_recover_thunk()
+ || orig_func->has_recover_thunk())
+ return TRAVERSE_CONTINUE;
+
+ Gogo* gogo = this->gogo_;
+ source_location location = orig_func->location();
+
+ static int count;
+ char buf[50];
+
+ Function_type* orig_fntype = orig_func->type();
+ Typed_identifier_list* new_params = new Typed_identifier_list();
+ std::string receiver_name;
+ if (orig_fntype->is_method())
+ {
+ const Typed_identifier* receiver = orig_fntype->receiver();
+ snprintf(buf, sizeof buf, "rt.%u", count);
+ ++count;
+ receiver_name = buf;
+ new_params->push_back(Typed_identifier(receiver_name, receiver->type(),
+ receiver->location()));
+ }
+ const Typed_identifier_list* orig_params = orig_fntype->parameters();
+ if (orig_params != NULL && !orig_params->empty())
+ {
+ for (Typed_identifier_list::const_iterator p = orig_params->begin();
+ p != orig_params->end();
+ ++p)
+ {
+ snprintf(buf, sizeof buf, "pt.%u", count);
+ ++count;
+ new_params->push_back(Typed_identifier(buf, p->type(),
+ p->location()));
+ }
+ }
+ snprintf(buf, sizeof buf, "pr.%u", count);
+ ++count;
+ std::string can_recover_name = buf;
+ new_params->push_back(Typed_identifier(can_recover_name,
+ Type::lookup_bool_type(),
+ orig_fntype->location()));
+
+ const Typed_identifier_list* orig_results = orig_fntype->results();
+ Typed_identifier_list* new_results;
+ if (orig_results == NULL || orig_results->empty())
+ new_results = NULL;
+ else
+ {
+ new_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = orig_results->begin();
+ p != orig_results->end();
+ ++p)
+ new_results->push_back(Typed_identifier("", p->type(), p->location()));
+ }
+
+ Function_type *new_fntype = Type::make_function_type(NULL, new_params,
+ new_results,
+ orig_fntype->location());
+ if (orig_fntype->is_varargs())
+ new_fntype->set_is_varargs();
+
+ std::string name = orig_no->name() + "$recover";
+ Named_object *new_no = gogo->start_function(name, new_fntype, false,
+ location);
+ Function *new_func = new_no->func_value();
+ if (orig_func->enclosing() != NULL)
+ new_func->set_enclosing(orig_func->enclosing());
+
+ // We build the code for the original function attached to the new
+ // function, and then swap the original and new function bodies.
+ // This means that existing references to the original function will
+ // then refer to the new function. That makes this code a little
+ // confusing, in that the reference to NEW_NO really refers to the
+ // other function, not the one we are building.
+
+ Expression* closure = NULL;
+ if (orig_func->needs_closure())
+ {
+ Named_object* orig_closure_no = orig_func->closure_var();
+ Variable* orig_closure_var = orig_closure_no->var_value();
+ Variable* new_var = new Variable(orig_closure_var->type(), NULL, false,
+ true, false, location);
+ snprintf(buf, sizeof buf, "closure.%u", count);
+ ++count;
+ Named_object* new_closure_no = Named_object::make_variable(buf, NULL,
+ new_var);
+ new_func->set_closure_var(new_closure_no);
+ closure = Expression::make_var_reference(new_closure_no, location);
+ }
+
+ Expression* fn = Expression::make_func_reference(new_no, closure, location);
+
+ Expression_list* args = new Expression_list();
+ if (new_params != NULL)
+ {
+ // Note that we skip the last parameter, which is the boolean
+ // indicating whether recover can succed.
+ for (Typed_identifier_list::const_iterator p = new_params->begin();
+ p + 1 != new_params->end();
+ ++p)
+ {
+ Named_object* p_no = gogo->lookup(p->name(), NULL);
+ go_assert(p_no != NULL
+ && p_no->is_variable()
+ && p_no->var_value()->is_parameter());
+ args->push_back(Expression::make_var_reference(p_no, location));
+ }
+ }
+ args->push_back(this->can_recover_arg(location));
+
+ Call_expression* call = Expression::make_call(fn, args, false, location);
+
+ Statement* s;
+ if (orig_fntype->results() == NULL || orig_fntype->results()->empty())
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* vals = new Expression_list();
+ size_t rc = orig_fntype->results()->size();
+ if (rc == 1)
+ vals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < rc; ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ }
+ s = Statement::make_return_statement(vals, location);
+ }
+ s->determine_types();
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ // Swap the function bodies and types.
+ new_func->swap_for_recover(orig_func);
+ orig_func->set_is_recover_thunk();
+ new_func->set_calls_recover();
+ new_func->set_has_recover_thunk();
+
+ Bindings* orig_bindings = orig_func->block()->bindings();
+ Bindings* new_bindings = new_func->block()->bindings();
+ if (orig_fntype->is_method())
+ {
+ // We changed the receiver to be a regular parameter. We have
+ // to update the binding accordingly in both functions.
+ Named_object* orig_rec_no = orig_bindings->lookup_local(receiver_name);
+ go_assert(orig_rec_no != NULL
+ && orig_rec_no->is_variable()
+ && !orig_rec_no->var_value()->is_receiver());
+ orig_rec_no->var_value()->set_is_receiver();
+
+ const std::string& new_receiver_name(orig_fntype->receiver()->name());
+ Named_object* new_rec_no = new_bindings->lookup_local(new_receiver_name);
+ if (new_rec_no == NULL)
+ go_assert(saw_errors());
+ else
+ {
+ go_assert(new_rec_no->is_variable()
+ && new_rec_no->var_value()->is_receiver());
+ new_rec_no->var_value()->set_is_not_receiver();
+ }
+ }
+
+ // Because we flipped blocks but not types, the can_recover
+ // parameter appears in the (now) old bindings as a parameter.
+ // Change it to a local variable, whereupon it will be discarded.
+ Named_object* can_recover_no = orig_bindings->lookup_local(can_recover_name);
+ go_assert(can_recover_no != NULL
+ && can_recover_no->is_variable()
+ && can_recover_no->var_value()->is_parameter());
+ orig_bindings->remove_binding(can_recover_no);
+
+ // Add the can_recover argument to the (now) new bindings, and
+ // attach it to any recover statements.
+ Variable* can_recover_var = new Variable(Type::lookup_bool_type(), NULL,
+ false, true, false, location);
+ can_recover_no = new_bindings->add_variable(can_recover_name, NULL,
+ can_recover_var);
+ Convert_recover convert_recover(can_recover_no);
+ new_func->traverse(&convert_recover);
+
+ // Update the function pointers in any named results.
+ new_func->update_result_variables();
+ orig_func->update_result_variables();
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the expression to pass for the .can_recover parameter to the
+// new function. This indicates whether a call to recover may return
+// non-nil. The expression is
+// __go_can_recover(__builtin_return_address()).
+
+Expression*
+Build_recover_thunks::can_recover_arg(source_location location)
+{
+ static Named_object* builtin_return_address;
+ if (builtin_return_address == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* uint_type = Type::lookup_integer_type("uint");
+ param_types->push_back(Typed_identifier("l", uint_type, bloc));
+
+ Typed_identifier_list* return_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ return_types->push_back(Typed_identifier("", voidptr_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ return_types, bloc);
+ builtin_return_address =
+ Named_object::make_function_declaration("__builtin_return_address",
+ NULL, fntype, bloc);
+ const char* n = "__builtin_return_address";
+ builtin_return_address->func_declaration_value()->set_asm_name(n);
+ }
+
+ static Named_object* can_recover;
+ if (can_recover == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ param_types->push_back(Typed_identifier("a", voidptr_type, bloc));
+ Type* boolean_type = Type::lookup_bool_type();
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", boolean_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ results, bloc);
+ can_recover = Named_object::make_function_declaration("__go_can_recover",
+ NULL, fntype,
+ bloc);
+ can_recover->func_declaration_value()->set_asm_name("__go_can_recover");
+ }
+
+ Expression* fn = Expression::make_func_reference(builtin_return_address,
+ NULL, location);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, location);
+ mpz_clear(zval);
+ Expression_list *args = new Expression_list();
+ args->push_back(zexpr);
+
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ args = new Expression_list();
+ args->push_back(call);
+
+ fn = Expression::make_func_reference(can_recover, NULL, location);
+ return Expression::make_call(fn, args, false, location);
+}
+
+// Build thunks for functions which call recover. We build a new
+// function with an extra parameter, which is whether a call to
+// recover can succeed. We then move the body of this function to
+// that one. We then turn this function into a thunk which calls the
+// new one, passing the value of
+// __go_can_recover(__builtin_return_address()). The function will be
+// marked as not splitting the stack. This will cooperate with the
+// implementation of defer to make recover do the right thing.
+
+void
+Gogo::build_recover_thunks()
+{
+ Build_recover_thunks build_recover_thunks(this);
+ this->traverse(&build_recover_thunks);
+}
+
+// Look for named types to see whether we need to create an interface
+// method table.
+
+class Build_method_tables : public Traverse
+{
+ public:
+ Build_method_tables(Gogo* gogo,
+ const std::vector<Interface_type*>& interfaces)
+ : Traverse(traverse_types),
+ gogo_(gogo), interfaces_(interfaces)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ // The IR.
+ Gogo* gogo_;
+ // A list of locally defined interfaces which have hidden methods.
+ const std::vector<Interface_type*>& interfaces_;
+};
+
+// Build all required interface method tables for types. We need to
+// ensure that we have an interface method table for every interface
+// which has a hidden method, for every named type which implements
+// that interface. Normally we can just build interface method tables
+// as we need them. However, in some cases we can require an
+// interface method table for an interface defined in a different
+// package for a type defined in that package. If that interface and
+// type both use a hidden method, that is OK. However, we will not be
+// able to build that interface method table when we need it, because
+// the type's hidden method will be static. So we have to build it
+// here, and just refer it from other packages as needed.
+
+void
+Gogo::build_interface_method_tables()
+{
+ std::vector<Interface_type*> hidden_interfaces;
+ hidden_interfaces.reserve(this->interface_types_.size());
+ for (std::vector<Interface_type*>::const_iterator pi =
+ this->interface_types_.begin();
+ pi != this->interface_types_.end();
+ ++pi)
+ {
+ const Typed_identifier_list* methods = (*pi)->methods();
+ if (methods == NULL)
+ continue;
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ if (Gogo::is_hidden_name(pm->name()))
+ {
+ hidden_interfaces.push_back(*pi);
+ break;
+ }
+ }
+ }
+
+ if (!hidden_interfaces.empty())
+ {
+ // Now traverse the tree looking for all named types.
+ Build_method_tables bmt(this, hidden_interfaces);
+ this->traverse(&bmt);
+ }
+
+ // We no longer need the list of interfaces.
+
+ this->interface_types_.clear();
+}
+
+// This is called for each type. For a named type, for each of the
+// interfaces with hidden methods that it implements, create the
+// method table.
+
+int
+Build_method_tables::type(Type* type)
+{
+ Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ for (std::vector<Interface_type*>::const_iterator p =
+ this->interfaces_.begin();
+ p != this->interfaces_.end();
+ ++p)
+ {
+ // We ask whether a pointer to the named type implements the
+ // interface, because a pointer can implement more methods
+ // than a value.
+ if ((*p)->implements_interface(Type::make_pointer_type(nt), NULL))
+ {
+ nt->interface_method_table(this->gogo_, *p, false);
+ nt->interface_method_table(this->gogo_, *p, true);
+ }
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal class used to check for return statements.
+
+class Check_return_statements_traverse : public Traverse
+{
+ public:
+ Check_return_statements_traverse()
+ : Traverse(traverse_functions)
+ { }
+
+ int
+ function(Named_object*);
+};
+
+// Check that a function has a return statement if it needs one.
+
+int
+Check_return_statements_traverse::function(Named_object* no)
+{
+ Function* func = no->func_value();
+ const Function_type* fntype = func->type();
+ const Typed_identifier_list* results = fntype->results();
+
+ // We only need a return statement if there is a return value.
+ if (results == NULL || results->empty())
+ return TRAVERSE_CONTINUE;
+
+ if (func->block()->may_fall_through())
+ error_at(func->location(), "control reaches end of non-void function");
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Check return statements.
+
+void
+Gogo::check_return_statements()
+{
+ Check_return_statements_traverse traverse;
+ this->traverse(&traverse);
+}
+
+// Get the unique prefix to use before all exported symbols. This
+// must be unique across the entire link.
+
+const std::string&
+Gogo::unique_prefix() const
+{
+ go_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+}
+
+// Set the unique prefix to use before all exported symbols. This
+// comes from the command line option -fgo-prefix=XXX.
+
+void
+Gogo::set_unique_prefix(const std::string& arg)
+{
+ go_assert(this->unique_prefix_.empty());
+ this->unique_prefix_ = arg;
+ this->unique_prefix_specified_ = true;
+}
+
+// Work out the package priority. It is one more than the maximum
+// priority of an imported package.
+
+int
+Gogo::package_priority() const
+{
+ int priority = 0;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ if (p->second->priority() > priority)
+ priority = p->second->priority();
+ return priority + 1;
+}
+
+// Export identifiers as requested.
+
+void
+Gogo::do_exports()
+{
+ // For now we always stream to a section. Later we may want to
+ // support streaming to a separate file.
+ Stream_to_section stream;
+
+ Export exp(&stream);
+ exp.register_builtin_types(this);
+ exp.export_globals(this->package_name(),
+ this->unique_prefix(),
+ this->package_priority(),
+ (this->need_init_fn_ && !this->is_main_package()
+ ? this->get_init_fn_name()
+ : ""),
+ this->imported_init_fns_,
+ this->package_->bindings());
+}
+
+// Find the blocks in order to convert named types defined in blocks.
+
+class Convert_named_types : public Traverse
+{
+ public:
+ Convert_named_types(Gogo* gogo)
+ : Traverse(traverse_blocks),
+ gogo_(gogo)
+ { }
+
+ protected:
+ int
+ block(Block* block);
+
+ private:
+ Gogo* gogo_;
+};
+
+int
+Convert_named_types::block(Block* block)
+{
+ this->gogo_->convert_named_types_in_bindings(block->bindings());
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert all named types to the backend representation. Since named
+// types can refer to other types, this needs to be done in the right
+// sequence, which is handled by Named_type::convert. Here we arrange
+// to call that for each named type.
+
+void
+Gogo::convert_named_types()
+{
+ this->convert_named_types_in_bindings(this->globals_);
+ for (Packages::iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ Package* package = p->second;
+ this->convert_named_types_in_bindings(package->bindings());
+ }
+
+ Convert_named_types cnt(this);
+ this->traverse(&cnt);
+
+ // Make all the builtin named types used for type descriptors, and
+ // then convert them. They will only be written out if they are
+ // needed.
+ Type::make_type_descriptor_type();
+ Type::make_type_descriptor_ptr_type();
+ Function_type::make_function_type_descriptor_type();
+ Pointer_type::make_pointer_type_descriptor_type();
+ Struct_type::make_struct_type_descriptor_type();
+ Array_type::make_array_type_descriptor_type();
+ Array_type::make_slice_type_descriptor_type();
+ Map_type::make_map_type_descriptor_type();
+ Channel_type::make_chan_type_descriptor_type();
+ Interface_type::make_interface_type_descriptor_type();
+ Type::convert_builtin_named_types(this);
+
+ Runtime::convert_types(this);
+
+ this->named_types_are_converted_ = true;
+}
+
+// Convert all names types in a set of bindings.
+
+void
+Gogo::convert_named_types_in_bindings(Bindings* bindings)
+{
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_type())
+ (*p)->type_value()->convert(this);
+ }
+}
+
+// Class Function.
+
+Function::Function(Function_type* type, Function* enclosing, Block* block,
+ source_location location)
+ : type_(type), enclosing_(enclosing), results_(NULL),
+ closure_var_(NULL), block_(block), location_(location), fndecl_(NULL),
+ defer_stack_(NULL), results_are_named_(false), calls_recover_(false),
+ is_recover_thunk_(false), has_recover_thunk_(false)
+{
+}
+
+// Create the named result variables.
+
+void
+Function::create_result_variables(Gogo* gogo)
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL || results->empty())
+ return;
+
+ if (!results->front().name().empty())
+ this->results_are_named_ = true;
+
+ this->results_ = new Results();
+ this->results_->reserve(results->size());
+
+ Block* block = this->block_;
+ int index = 0;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p, ++index)
+ {
+ std::string name = p->name();
+ if (name.empty() || Gogo::is_sink_name(name))
+ {
+ static int result_counter;
+ char buf[100];
+ snprintf(buf, sizeof buf, "$ret%d", result_counter);
+ ++result_counter;
+ name = gogo->pack_hidden_name(buf, false);
+ }
+ Result_variable* result = new Result_variable(p->type(), this, index,
+ p->location());
+ Named_object* no = block->bindings()->add_result_variable(name, result);
+ if (no->is_result_variable())
+ this->results_->push_back(no);
+ else
+ {
+ static int dummy_result_count;
+ char buf[100];
+ snprintf(buf, sizeof buf, "$dret%d", dummy_result_count);
+ ++dummy_result_count;
+ name = gogo->pack_hidden_name(buf, false);
+ no = block->bindings()->add_result_variable(name, result);
+ go_assert(no->is_result_variable());
+ this->results_->push_back(no);
+ }
+ }
+}
+
+// Update the named result variables when cloning a function which
+// calls recover.
+
+void
+Function::update_result_variables()
+{
+ if (this->results_ == NULL)
+ return;
+
+ for (Results::iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p)
+ (*p)->result_var_value()->set_function(this);
+}
+
+// Return the closure variable, creating it if necessary.
+
+Named_object*
+Function::closure_var()
+{
+ if (this->closure_var_ == NULL)
+ {
+ // We don't know the type of the variable yet. We add fields as
+ // we find them.
+ source_location loc = this->type_->location();
+ Struct_field_list* sfl = new Struct_field_list;
+ Type* struct_type = Type::make_struct_type(sfl, loc);
+ Variable* var = new Variable(Type::make_pointer_type(struct_type),
+ NULL, false, true, false, loc);
+ this->closure_var_ = Named_object::make_variable("closure", NULL, var);
+ // Note that the new variable is not in any binding contour.
+ }
+ return this->closure_var_;
+}
+
+// Set the type of the closure variable.
+
+void
+Function::set_closure_type()
+{
+ if (this->closure_var_ == NULL)
+ return;
+ Named_object* closure = this->closure_var_;
+ Struct_type* st = closure->var_value()->type()->deref()->struct_type();
+ unsigned int index = 0;
+ for (Closure_fields::const_iterator p = this->closure_fields_.begin();
+ p != this->closure_fields_.end();
+ ++p, ++index)
+ {
+ Named_object* no = p->first;
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", index);
+ std::string n = no->name() + buf;
+ Type* var_type;
+ if (no->is_variable())
+ var_type = no->var_value()->type();
+ else
+ var_type = no->result_var_value()->type();
+ Type* field_type = Type::make_pointer_type(var_type);
+ st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
+ }
+}
+
+// Return whether this function is a method.
+
+bool
+Function::is_method() const
+{
+ return this->type_->is_method();
+}
+
+// Add a label definition.
+
+Label*
+Function::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (ins.second)
+ {
+ // This is a new label.
+ Label* label = new Label(label_name);
+ label->define(location);
+ ins.first->second = label;
+ return label;
+ }
+ else
+ {
+ // The label was already in the hash table.
+ Label* label = ins.first->second;
+ if (!label->is_defined())
+ {
+ label->define(location);
+ return label;
+ }
+ else
+ {
+ error_at(location, "label %qs already defined",
+ Gogo::message_name(label_name).c_str());
+ inform(label->location(), "previous definition of %qs was here",
+ Gogo::message_name(label_name).c_str());
+ return new Label(label_name);
+ }
+ }
+}
+
+// Add a reference to a label.
+
+Label*
+Function::add_label_reference(const std::string& label_name)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (!ins.second)
+ {
+ // The label was already in the hash table.
+ Label* label = ins.first->second;
+ label->set_is_used();
+ return label;
+ }
+ else
+ {
+ go_assert(ins.first->second == NULL);
+ Label* label = new Label(label_name);
+ ins.first->second = label;
+ label->set_is_used();
+ return label;
+ }
+}
+
+// Warn about labels that are defined but not used.
+
+void
+Function::check_labels() const
+{
+ for (Labels::const_iterator p = this->labels_.begin();
+ p != this->labels_.end();
+ p++)
+ {
+ Label* label = p->second;
+ if (!label->is_used())
+ error_at(label->location(), "label %qs defined and not used",
+ Gogo::message_name(label->name()).c_str());
+ }
+}
+
+// Swap one function with another. This is used when building the
+// thunk we use to call a function which calls recover. It may not
+// work for any other case.
+
+void
+Function::swap_for_recover(Function *x)
+{
+ go_assert(this->enclosing_ == x->enclosing_);
+ std::swap(this->results_, x->results_);
+ std::swap(this->closure_var_, x->closure_var_);
+ std::swap(this->block_, x->block_);
+ go_assert(this->location_ == x->location_);
+ go_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
+ go_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
+}
+
+// Traverse the tree.
+
+int
+Function::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask
+ & (Traverse::traverse_types | Traverse::traverse_expressions))
+ != 0)
+ {
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ // FIXME: We should check traverse_functions here if nested
+ // functions are stored in block bindings.
+ if (this->block_ != NULL
+ && (traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Function::determine_types()
+{
+ if (this->block_ != NULL)
+ this->block_->determine_types();
+}
+
+// Get a pointer to the variable holding the defer stack for this
+// function, making it if necessary. At least at present, the value
+// of this variable is not used. However, a pointer to this variable
+// is used as a marker for the functions on the defer stack associated
+// with this function. Doing things this way permits inlining a
+// function which uses defer.
+
+Expression*
+Function::defer_stack(source_location location)
+{
+ Type* t = Type::make_pointer_type(Type::make_void_type());
+ if (this->defer_stack_ == NULL)
+ {
+ Expression* n = Expression::make_nil(location);
+ this->defer_stack_ = Statement::make_temporary(t, n, location);
+ this->defer_stack_->set_is_address_taken();
+ }
+ Expression* ref = Expression::make_temporary_reference(this->defer_stack_,
+ location);
+ Expression* addr = Expression::make_unary(OPERATOR_AND, ref, location);
+ return Expression::make_unsafe_cast(t, addr, location);
+}
+
+// Export the function.
+
+void
+Function::export_func(Export* exp, const std::string& name) const
+{
+ Function::export_func_with_type(exp, name, this->type_);
+}
+
+// Export a function with a type.
+
+void
+Function::export_func_with_type(Export* exp, const std::string& name,
+ const Function_type* fntype)
+{
+ exp->write_c_string("func ");
+
+ if (fntype->is_method())
+ {
+ exp->write_c_string("(");
+ exp->write_type(fntype->receiver()->type());
+ exp->write_c_string(") ");
+ }
+
+ exp->write_string(name);
+
+ exp->write_c_string(" (");
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != parameters->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ if (results->size() == 1)
+ {
+ exp->write_c_string(" ");
+ exp->write_type(results->begin()->type());
+ }
+ else
+ {
+ exp->write_c_string(" (");
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+ exp->write_c_string(";\n");
+}
+
+// Import a function.
+
+void
+Function::import_func(Import* imp, std::string* pname,
+ Typed_identifier** preceiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults,
+ bool* is_varargs)
+{
+ imp->require_c_string("func ");
+
+ *preceiver = NULL;
+ if (imp->peek_char() == '(')
+ {
+ imp->require_c_string("(");
+ Type* rtype = imp->read_type();
+ *preceiver = new Typed_identifier(Import::import_marker, rtype,
+ imp->location());
+ imp->require_c_string(") ");
+ }
+
+ *pname = imp->read_identifier();
+
+ Typed_identifier_list* parameters;
+ *is_varargs = false;
+ imp->require_c_string(" (");
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ *is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (*is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ go_assert(!*is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+ *pparameters = parameters;
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ imp->require_c_string(" ");
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->require_c_string("(");
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+ imp->require_c_string(";\n");
+ *presults = results;
+}
+
+// Class Block.
+
+Block::Block(Block* enclosing, source_location location)
+ : enclosing_(enclosing), statements_(),
+ bindings_(new Bindings(enclosing == NULL
+ ? NULL
+ : enclosing->bindings())),
+ start_location_(location),
+ end_location_(UNKNOWN_LOCATION)
+{
+}
+
+// Add a statement to a block.
+
+void
+Block::add_statement(Statement* statement)
+{
+ this->statements_.push_back(statement);
+}
+
+// Add a statement to the front of a block. This is slow but is only
+// used for reference counts of parameters.
+
+void
+Block::add_statement_at_front(Statement* statement)
+{
+ this->statements_.insert(this->statements_.begin(), statement);
+}
+
+// Replace a statement in a block.
+
+void
+Block::replace_statement(size_t index, Statement* s)
+{
+ go_assert(index < this->statements_.size());
+ this->statements_[index] = s;
+}
+
+// Add a statement before another statement.
+
+void
+Block::insert_statement_before(size_t index, Statement* s)
+{
+ go_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index, s);
+}
+
+// Add a statement after another statement.
+
+void
+Block::insert_statement_after(size_t index, Statement* s)
+{
+ go_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index + 1, s);
+}
+
+// Traverse the tree.
+
+int
+Block::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_blocks) != 0)
+ {
+ int t = traverse->block(this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ switch ((*pb)->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(*pb, false) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = (*pb)->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0)
+ {
+ if ((*pb)->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(*pb) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && ((*pb)->is_result_variable()
+ || (*pb)->var_value()->has_type()))
+ {
+ Type* t = ((*pb)->is_variable()
+ ? (*pb)->var_value()->type()
+ : (*pb)->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((*pb)->is_variable()
+ && ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0))
+ {
+ if ((*pb)->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ // FIXME: Where will nested functions be found?
+ go_unreachable();
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse((*pb)->type_value(), traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ case Named_object::NAMED_OBJECT_SINK:
+ go_unreachable();
+
+ default:
+ go_unreachable();
+ }
+ }
+ }
+
+ // No point in checking traverse_mask here--if we got here we always
+ // want to walk the statements. The traversal can insert new
+ // statements before or after the current statement. Inserting
+ // statements before the current statement requires updating I via
+ // the pointer; those statements will not be traversed. Any new
+ // statements inserted after the current statement will be traversed
+ // in their turn.
+ for (size_t i = 0; i < this->statements_.size(); ++i)
+ {
+ if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Block::determine_types()
+{
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ if ((*pb)->is_variable())
+ (*pb)->var_value()->determine_type();
+ else if ((*pb)->is_const())
+ (*pb)->const_value()->determine_type();
+ }
+
+ for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
+ ps != this->statements_.end();
+ ++ps)
+ (*ps)->determine_types();
+}
+
+// Return true if the statements in this block may fall through.
+
+bool
+Block::may_fall_through() const
+{
+ if (this->statements_.empty())
+ return true;
+ return this->statements_.back()->may_fall_through();
+}
+
+// Convert a block to the backend representation.
+
+Bblock*
+Block::get_backend(Translate_context* context)
+{
+ Gogo* gogo = context->gogo();
+ Named_object* function = context->function();
+ std::vector<Bvariable*> vars;
+ vars.reserve(this->bindings_->size_definitions());
+ for (Bindings::const_definitions_iterator pv =
+ this->bindings_->begin_definitions();
+ pv != this->bindings_->end_definitions();
+ ++pv)
+ {
+ if ((*pv)->is_variable() && !(*pv)->var_value()->is_parameter())
+ vars.push_back((*pv)->get_backend_variable(gogo, function));
+ }
+
+ // FIXME: Permitting FUNCTION to be NULL here is a temporary measure
+ // until we have a proper representation of the init function.
+ Bfunction* bfunction;
+ if (function == NULL)
+ bfunction = NULL;
+ else
+ bfunction = tree_to_function(function->func_value()->get_decl());
+ Bblock* ret = context->backend()->block(bfunction, context->bblock(),
+ vars, this->start_location_,
+ this->end_location_);
+
+ Translate_context subcontext(gogo, function, this, ret);
+ std::vector<Bstatement*> bstatements;
+ bstatements.reserve(this->statements_.size());
+ for (std::vector<Statement*>::const_iterator p = this->statements_.begin();
+ p != this->statements_.end();
+ ++p)
+ bstatements.push_back((*p)->get_backend(&subcontext));
+
+ context->backend()->block_add_statements(ret, bstatements);
+
+ return ret;
+}
+
+// Class Variable.
+
+Variable::Variable(Type* type, Expression* init, bool is_global,
+ bool is_parameter, bool is_receiver,
+ source_location location)
+ : type_(type), init_(init), preinit_(NULL), location_(location),
+ backend_(NULL), is_global_(is_global), is_parameter_(is_parameter),
+ is_receiver_(is_receiver), is_varargs_parameter_(false),
+ is_address_taken_(false), seen_(false), init_is_lowered_(false),
+ type_from_init_tuple_(false), type_from_range_index_(false),
+ type_from_range_value_(false), type_from_chan_element_(false),
+ is_type_switch_var_(false), determined_type_(false)
+{
+ go_assert(type != NULL || init != NULL);
+ go_assert(!is_parameter || init == NULL);
+}
+
+// Traverse the initializer expression.
+
+int
+Variable::traverse_expression(Traverse* traverse)
+{
+ if (this->preinit_ != NULL)
+ {
+ if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->init_ != NULL)
+ {
+ if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower the initialization expression after parsing is complete.
+
+void
+Variable::lower_init_expression(Gogo* gogo, Named_object* function)
+{
+ if (this->init_ != NULL && !this->init_is_lowered_)
+ {
+ if (this->seen_)
+ {
+ // We will give an error elsewhere, this is just to prevent
+ // an infinite loop.
+ return;
+ }
+ this->seen_ = true;
+
+ gogo->lower_expression(function, &this->init_);
+
+ this->seen_ = false;
+
+ this->init_is_lowered_ = true;
+ }
+}
+
+// Get the preinit block.
+
+Block*
+Variable::preinit_block(Gogo* gogo)
+{
+ go_assert(this->is_global_);
+ if (this->preinit_ == NULL)
+ this->preinit_ = new Block(NULL, this->location());
+
+ // If a global variable has a preinitialization statement, then we
+ // need to have an initialization function.
+ gogo->set_need_init_fn();
+
+ return this->preinit_;
+}
+
+// Add a statement to be run before the initialization expression.
+
+void
+Variable::add_preinit_statement(Gogo* gogo, Statement* s)
+{
+ Block* b = this->preinit_block(gogo);
+ b->add_statement(s);
+ b->set_end_location(s->location());
+}
+
+// In an assignment which sets a variable to a tuple of EXPR, return
+// the type of the first element of the tuple.
+
+Type*
+Variable::type_from_tuple(Expression* expr, bool report_error) const
+{
+ if (expr->map_index_expression() != NULL)
+ {
+ Map_type* mt = expr->map_index_expression()->get_map_type();
+ if (mt == NULL)
+ return Type::make_error_type();
+ return mt->val_type();
+ }
+ else if (expr->receive_expression() != NULL)
+ {
+ Expression* channel = expr->receive_expression()->channel();
+ Type* channel_type = channel->type();
+ if (channel_type->channel_type() == NULL)
+ return Type::make_error_type();
+ return channel_type->channel_type()->element_type();
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid tuple definition");
+ return Type::make_error_type();
+ }
+}
+
+// Given EXPR used in a range clause, return either the index type or
+// the value type of the range, depending upon GET_INDEX_TYPE.
+
+Type*
+Variable::type_from_range(Expression* expr, bool get_index_type,
+ bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->array_type() != NULL
+ || (t->points_to() != NULL
+ && t->points_to()->array_type() != NULL
+ && !t->points_to()->is_open_array_type()))
+ {
+ if (get_index_type)
+ return Type::lookup_integer_type("int");
+ else
+ return t->deref()->array_type()->element_type();
+ }
+ else if (t->is_string_type())
+ return Type::lookup_integer_type("int");
+ else if (t->map_type() != NULL)
+ {
+ if (get_index_type)
+ return t->map_type()->key_type();
+ else
+ return t->map_type()->val_type();
+ }
+ else if (t->channel_type() != NULL)
+ {
+ if (get_index_type)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(),
+ "invalid definition of value variable for channel range");
+ return Type::make_error_type();
+ }
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid type for range clause");
+ return Type::make_error_type();
+ }
+}
+
+// EXPR should be a channel. Return the channel's element type.
+
+Type*
+Variable::type_from_chan_element(Expression* expr, bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->channel_type() != NULL)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "expected channel");
+ return Type::make_error_type();
+ }
+}
+
+// Return the type of the Variable. This may be called before
+// Variable::determine_type is called, which means that we may need to
+// get the type from the initializer. FIXME: If we combine lowering
+// with type determination, then this should be unnecessary.
+
+Type*
+Variable::type()
+{
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. This gets fixed up in determine_type, below.
+ Type* type = this->type_;
+ Expression* init = this->init_;
+ if (this->is_type_switch_var_
+ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ go_assert(tge != NULL);
+ init = tge->expr();
+ type = NULL;
+ }
+
+ if (this->seen_)
+ {
+ if (this->type_ == NULL || !this->type_->is_error_type())
+ {
+ error_at(this->location_, "variable initializer refers to itself");
+ this->type_ = Type::make_error_type();
+ }
+ return this->type_;
+ }
+
+ this->seen_ = true;
+
+ if (type != NULL)
+ ;
+ else if (this->type_from_init_tuple_)
+ type = this->type_from_tuple(init, false);
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ type = this->type_from_range(init, this->type_from_range_index_, false);
+ else if (this->type_from_chan_element_)
+ type = this->type_from_chan_element(init, false);
+ else
+ {
+ go_assert(init != NULL);
+ type = init->type();
+ go_assert(type != NULL);
+
+ // Variables should not have abstract types.
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ type = Type::make_error_type();
+ }
+
+ this->seen_ = false;
+
+ return type;
+}
+
+// Fetch the type from a const pointer, in which case it should have
+// been set already.
+
+Type*
+Variable::type() const
+{
+ go_assert(this->type_ != NULL);
+ return this->type_;
+}
+
+// Set the type if necessary.
+
+void
+Variable::determine_type()
+{
+ if (this->determined_type_)
+ return;
+ this->determined_type_ = true;
+
+ if (this->preinit_ != NULL)
+ this->preinit_->determine_types();
+
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. It will have an initializer which is a type guard.
+ // We want to initialize it to the value without the type guard, and
+ // use the type of that value as well.
+ if (this->is_type_switch_var_ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ go_assert(tge != NULL);
+ this->type_ = NULL;
+ this->init_ = tge->expr();
+ }
+
+ if (this->init_ == NULL)
+ go_assert(this->type_ != NULL && !this->type_->is_abstract());
+ else if (this->type_from_init_tuple_)
+ {
+ Expression *init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_tuple(init, true);
+ this->init_ = NULL;
+ }
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ {
+ Expression* init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_range(init, this->type_from_range_index_,
+ true);
+ this->init_ = NULL;
+ }
+ else if (this->type_from_chan_element_)
+ {
+ Expression* init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_chan_element(init, true);
+ this->init_ = NULL;
+ }
+ else
+ {
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ if (this->type_ == NULL)
+ {
+ Type* type = this->init_->type();
+ go_assert(type != NULL);
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ {
+ error_at(this->location_, "variable has no type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_nil_type())
+ {
+ error_at(this->location_, "variable defined to nil type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_call_multiple_result_type())
+ {
+ error_at(this->location_,
+ "single variable set to multiple value function call");
+ type = Type::make_error_type();
+ }
+
+ this->type_ = type;
+ }
+ }
+}
+
+// Export the variable
+
+void
+Variable::export_var(Export* exp, const std::string& name) const
+{
+ go_assert(this->is_global_);
+ exp->write_c_string("var ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ exp->write_type(this->type());
+ exp->write_c_string(";\n");
+}
+
+// Import a variable.
+
+void
+Variable::import_var(Import* imp, std::string* pname, Type** ptype)
+{
+ imp->require_c_string("var ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ *ptype = imp->read_type();
+ imp->require_c_string(";\n");
+}
+
+// Convert a variable to the backend representation.
+
+Bvariable*
+Variable::get_backend_variable(Gogo* gogo, Named_object* function,
+ const Package* package, const std::string& name)
+{
+ if (this->backend_ == NULL)
+ {
+ Backend* backend = gogo->backend();
+ Type* type = this->type_;
+ if (type->is_error_type()
+ || (type->is_undefined()
+ && (!this->is_global_ || package == NULL)))
+ this->backend_ = backend->error_variable();
+ else
+ {
+ bool is_parameter = this->is_parameter_;
+ if (this->is_receiver_ && type->points_to() == NULL)
+ is_parameter = false;
+ if (this->is_in_heap())
+ {
+ is_parameter = false;
+ type = Type::make_pointer_type(type);
+ }
+
+ std::string n = Gogo::unpack_hidden_name(name);
+ Btype* btype = tree_to_type(type->get_tree(gogo));
+
+ Bvariable* bvar;
+ if (this->is_global_)
+ bvar = backend->global_variable((package == NULL
+ ? gogo->package_name()
+ : package->name()),
+ (package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix()),
+ n,
+ btype,
+ package != NULL,
+ Gogo::is_hidden_name(name),
+ this->location_);
+ else
+ {
+ tree fndecl = function->func_value()->get_decl();
+ Bfunction* bfunction = tree_to_function(fndecl);
+ if (is_parameter)
+ bvar = backend->parameter_variable(bfunction, n, btype,
+ this->location_);
+ else
+ bvar = backend->local_variable(bfunction, n, btype,
+ this->location_);
+ }
+ this->backend_ = bvar;
+ }
+ }
+ return this->backend_;
+}
+
+// Class Result_variable.
+
+// Convert a result variable to the backend representation.
+
+Bvariable*
+Result_variable::get_backend_variable(Gogo* gogo, Named_object* function,
+ const std::string& name)
+{
+ if (this->backend_ == NULL)
+ {
+ Backend* backend = gogo->backend();
+ Type* type = this->type_;
+ if (type->is_error())
+ this->backend_ = backend->error_variable();
+ else
+ {
+ if (this->is_in_heap())
+ type = Type::make_pointer_type(type);
+ Btype* btype = tree_to_type(type->get_tree(gogo));
+ tree fndecl = function->func_value()->get_decl();
+ Bfunction* bfunction = tree_to_function(fndecl);
+ std::string n = Gogo::unpack_hidden_name(name);
+ this->backend_ = backend->local_variable(bfunction, n, btype,
+ this->location_);
+ }
+ }
+ return this->backend_;
+}
+
+// Class Named_constant.
+
+// Traverse the initializer expression.
+
+int
+Named_constant::traverse_expression(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Determine the type of the constant.
+
+void
+Named_constant::determine_type()
+{
+ if (this->type_ != NULL)
+ {
+ Type_context context(this->type_, false);
+ this->expr_->determine_type(&context);
+ }
+ else
+ {
+ // A constant may have an abstract type.
+ Type_context context(NULL, true);
+ this->expr_->determine_type(&context);
+ this->type_ = this->expr_->type();
+ go_assert(this->type_ != NULL);
+ }
+}
+
+// Indicate that we found and reported an error for this constant.
+
+void
+Named_constant::set_error()
+{
+ this->type_ = Type::make_error_type();
+ this->expr_ = Expression::make_error(this->location_);
+}
+
+// Export a constant.
+
+void
+Named_constant::export_const(Export* exp, const std::string& name) const
+{
+ exp->write_c_string("const ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ if (!this->type_->is_abstract())
+ {
+ exp->write_type(this->type_);
+ exp->write_c_string(" ");
+ }
+ exp->write_c_string("= ");
+ this->expr()->export_expression(exp);
+ exp->write_c_string(";\n");
+}
+
+// Import a constant.
+
+void
+Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
+ Expression** pexpr)
+{
+ imp->require_c_string("const ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (imp->peek_char() == '=')
+ *ptype = NULL;
+ else
+ {
+ *ptype = imp->read_type();
+ imp->require_c_string(" ");
+ }
+ imp->require_c_string("= ");
+ *pexpr = Expression::import_expression(imp);
+ imp->require_c_string(";\n");
+}
+
+// Add a method.
+
+Named_object*
+Type_declaration::add_method(const std::string& name, Function* function)
+{
+ Named_object* ret = Named_object::make_function(name, NULL, function);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Add a method declaration.
+
+Named_object*
+Type_declaration::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* ret = Named_object::make_function_declaration(name, NULL, type,
+ location);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Return whether any methods ere defined.
+
+bool
+Type_declaration::has_methods() const
+{
+ return !this->methods_.empty();
+}
+
+// Define methods for the real type.
+
+void
+Type_declaration::define_methods(Named_type* nt)
+{
+ for (Methods::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ nt->add_existing_method(*p);
+}
+
+// We are using the type. Return true if we should issue a warning.
+
+bool
+Type_declaration::using_type()
+{
+ bool ret = !this->issued_warning_;
+ this->issued_warning_ = true;
+ return ret;
+}
+
+// Class Unknown_name.
+
+// Set the real named object.
+
+void
+Unknown_name::set_real_named_object(Named_object* no)
+{
+ go_assert(this->real_named_object_ == NULL);
+ go_assert(!no->is_unknown());
+ this->real_named_object_ = no;
+}
+
+// Class Named_object.
+
+Named_object::Named_object(const std::string& name,
+ const Package* package,
+ Classification classification)
+ : name_(name), package_(package), classification_(classification),
+ tree_(NULL)
+{
+ if (Gogo::is_sink_name(name))
+ go_assert(classification == NAMED_OBJECT_SINK);
+}
+
+// Make an unknown name. This is used by the parser. The name must
+// be resolved later. Unknown names are only added in the current
+// package.
+
+Named_object*
+Named_object::make_unknown_name(const std::string& name,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_UNKNOWN);
+ Unknown_name* value = new Unknown_name(location);
+ named_object->u_.unknown_value = value;
+ return named_object;
+}
+
+// Make a constant.
+
+Named_object*
+Named_object::make_constant(const Typed_identifier& tid,
+ const Package* package, Expression* expr,
+ int iota_value)
+{
+ Named_object* named_object = new Named_object(tid.name(), package,
+ NAMED_OBJECT_CONST);
+ Named_constant* named_constant = new Named_constant(tid.type(), expr,
+ iota_value,
+ tid.location());
+ named_object->u_.const_value = named_constant;
+ return named_object;
+}
+
+// Make a named type.
+
+Named_object*
+Named_object::make_type(const std::string& name, const Package* package,
+ Type* type, source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE);
+ Named_type* named_type = Type::make_named_type(named_object, type, location);
+ named_object->u_.type_value = named_type;
+ return named_object;
+}
+
+// Make a type declaration.
+
+Named_object*
+Named_object::make_type_declaration(const std::string& name,
+ const Package* package,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* type_declaration = new Type_declaration(location);
+ named_object->u_.type_declaration = type_declaration;
+ return named_object;
+}
+
+// Make a variable.
+
+Named_object*
+Named_object::make_variable(const std::string& name, const Package* package,
+ Variable* variable)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_VAR);
+ named_object->u_.var_value = variable;
+ return named_object;
+}
+
+// Make a result variable.
+
+Named_object*
+Named_object::make_result_variable(const std::string& name,
+ Result_variable* result)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_RESULT_VAR);
+ named_object->u_.result_var_value = result;
+ return named_object;
+}
+
+// Make a sink. This is used for the special blank identifier _.
+
+Named_object*
+Named_object::make_sink()
+{
+ return new Named_object("_", NULL, NAMED_OBJECT_SINK);
+}
+
+// Make a named function.
+
+Named_object*
+Named_object::make_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC);
+ named_object->u_.func_value = function;
+ return named_object;
+}
+
+// Make a function declaration.
+
+Named_object*
+Named_object::make_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* fntype,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC_DECLARATION);
+ Function_declaration *func_decl = new Function_declaration(fntype, location);
+ named_object->u_.func_declaration_value = func_decl;
+ return named_object;
+}
+
+// Make a package.
+
+Named_object*
+Named_object::make_package(const std::string& alias, Package* package)
+{
+ Named_object* named_object = new Named_object(alias, NULL,
+ NAMED_OBJECT_PACKAGE);
+ named_object->u_.package_value = package;
+ return named_object;
+}
+
+// Return the name to use in an error message.
+
+std::string
+Named_object::message_name() const
+{
+ if (this->package_ == NULL)
+ return Gogo::message_name(this->name_);
+ std::string ret = Gogo::message_name(this->package_->name());
+ ret += '.';
+ ret += Gogo::message_name(this->name_);
+ return ret;
+}
+
+// Set the type when a declaration is defined.
+
+void
+Named_object::set_type_value(Named_type* named_type)
+{
+ go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* td = this->u_.type_declaration;
+ td->define_methods(named_type);
+ Named_object* in_function = td->in_function();
+ if (in_function != NULL)
+ named_type->set_in_function(in_function);
+ delete td;
+ this->classification_ = NAMED_OBJECT_TYPE;
+ this->u_.type_value = named_type;
+}
+
+// Define a function which was previously declared.
+
+void
+Named_object::set_function_value(Function* function)
+{
+ go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ this->classification_ = NAMED_OBJECT_FUNC;
+ // FIXME: We should free the old value.
+ this->u_.func_value = function;
+}
+
+// Declare an unknown object as a type declaration.
+
+void
+Named_object::declare_as_type()
+{
+ go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ Unknown_name* unk = this->u_.unknown_value;
+ this->classification_ = NAMED_OBJECT_TYPE_DECLARATION;
+ this->u_.type_declaration = new Type_declaration(unk->location());
+ delete unk;
+}
+
+// Return the location of a named object.
+
+source_location
+Named_object::location() const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ go_unreachable();
+
+ case NAMED_OBJECT_UNKNOWN:
+ return this->unknown_value()->location();
+
+ case NAMED_OBJECT_CONST:
+ return this->const_value()->location();
+
+ case NAMED_OBJECT_TYPE:
+ return this->type_value()->location();
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ return this->type_declaration_value()->location();
+
+ case NAMED_OBJECT_VAR:
+ return this->var_value()->location();
+
+ case NAMED_OBJECT_RESULT_VAR:
+ return this->result_var_value()->location();
+
+ case NAMED_OBJECT_SINK:
+ go_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ return this->func_value()->location();
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ return this->func_declaration_value()->location();
+
+ case NAMED_OBJECT_PACKAGE:
+ return this->package_value()->location();
+ }
+}
+
+// Export a named object.
+
+void
+Named_object::export_named_object(Export* exp) const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ case NAMED_OBJECT_UNKNOWN:
+ go_unreachable();
+
+ case NAMED_OBJECT_CONST:
+ this->const_value()->export_const(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ this->type_value()->export_named_type(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error_at(this->type_declaration_value()->location(),
+ "attempt to export %<%s%> which was declared but not defined",
+ this->message_name().c_str());
+ break;
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ this->func_declaration_value()->export_func(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_VAR:
+ this->var_value()->export_var(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_RESULT_VAR:
+ case NAMED_OBJECT_SINK:
+ go_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ this->func_value()->export_func(exp, this->name_);
+ break;
+ }
+}
+
+// Convert a variable to the backend representation.
+
+Bvariable*
+Named_object::get_backend_variable(Gogo* gogo, Named_object* function)
+{
+ if (this->classification_ == NAMED_OBJECT_VAR)
+ return this->var_value()->get_backend_variable(gogo, function,
+ this->package_, this->name_);
+ else if (this->classification_ == NAMED_OBJECT_RESULT_VAR)
+ return this->result_var_value()->get_backend_variable(gogo, function,
+ this->name_);
+ else
+ go_unreachable();
+}
+
+// Class Bindings.
+
+Bindings::Bindings(Bindings* enclosing)
+ : enclosing_(enclosing), named_objects_(), bindings_()
+{
+}
+
+// Clear imports.
+
+void
+Bindings::clear_file_scope()
+{
+ Contour::iterator p = this->bindings_.begin();
+ while (p != this->bindings_.end())
+ {
+ bool keep;
+ if (p->second->package() != NULL)
+ keep = false;
+ else if (p->second->is_package())
+ keep = false;
+ else if (p->second->is_function()
+ && !p->second->func_value()->type()->is_method()
+ && Gogo::unpack_hidden_name(p->second->name()) == "init")
+ keep = false;
+ else
+ keep = true;
+
+ if (keep)
+ ++p;
+ else
+ p = this->bindings_.erase(p);
+ }
+}
+
+// Look up a symbol.
+
+Named_object*
+Bindings::lookup(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p != this->bindings_.end())
+ return p->second->resolve();
+ else if (this->enclosing_ != NULL)
+ return this->enclosing_->lookup(name);
+ else
+ return NULL;
+}
+
+// Look up a symbol locally.
+
+Named_object*
+Bindings::lookup_local(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p == this->bindings_.end())
+ return NULL;
+ return p->second;
+}
+
+// Remove an object from a set of bindings. This is used for a
+// special case in thunks for functions which call recover.
+
+void
+Bindings::remove_binding(Named_object* no)
+{
+ Contour::iterator pb = this->bindings_.find(no->name());
+ go_assert(pb != this->bindings_.end());
+ this->bindings_.erase(pb);
+ for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
+ pn != this->named_objects_.end();
+ ++pn)
+ {
+ if (*pn == no)
+ {
+ this->named_objects_.erase(pn);
+ return;
+ }
+ }
+ go_unreachable();
+}
+
+// Add a method to the list of objects. This is not added to the
+// lookup table. This is so that we have a single list of objects
+// declared at the top level, which we walk through when it's time to
+// convert to trees.
+
+void
+Bindings::add_method(Named_object* method)
+{
+ this->named_objects_.push_back(method);
+}
+
+// Add a generic Named_object to a Contour.
+
+Named_object*
+Bindings::add_named_object_to_contour(Contour* contour,
+ Named_object* named_object)
+{
+ go_assert(named_object == named_object->resolve());
+ const std::string& name(named_object->name());
+ go_assert(!Gogo::is_sink_name(name));
+
+ std::pair<Contour::iterator, bool> ins =
+ contour->insert(std::make_pair(name, named_object));
+ if (!ins.second)
+ {
+ // The name was already there.
+ if (named_object->package() != NULL
+ && ins.first->second->package() == named_object->package()
+ && (ins.first->second->classification()
+ == named_object->classification()))
+ {
+ // This is a second import of the same object.
+ return ins.first->second;
+ }
+ ins.first->second = this->new_definition(ins.first->second,
+ named_object);
+ return ins.first->second;
+ }
+ else
+ {
+ // Don't push declarations on the list. We push them on when
+ // and if we find the definitions. That way we genericize the
+ // functions in order.
+ if (!named_object->is_type_declaration()
+ && !named_object->is_function_declaration()
+ && !named_object->is_unknown())
+ this->named_objects_.push_back(named_object);
+ return named_object;
+ }
+}
+
+// We had an existing named object OLD_OBJECT, and we've seen a new
+// one NEW_OBJECT with the same name. FIXME: This does not free the
+// new object when we don't need it.
+
+Named_object*
+Bindings::new_definition(Named_object* old_object, Named_object* new_object)
+{
+ std::string reason;
+ switch (old_object->classification())
+ {
+ default:
+ case Named_object::NAMED_OBJECT_UNINITIALIZED:
+ go_unreachable();
+
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ {
+ Named_object* real = old_object->unknown_value()->real_named_object();
+ if (real != NULL)
+ return this->new_definition(real, new_object);
+ go_assert(!new_object->is_unknown());
+ old_object->unknown_value()->set_real_named_object(new_object);
+ if (!new_object->is_type_declaration()
+ && !new_object->is_function_declaration())
+ this->named_objects_.push_back(new_object);
+ return new_object;
+ }
+
+ case Named_object::NAMED_OBJECT_CONST:
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if (new_object->is_type_declaration())
+ return old_object;
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (new_object->is_type_declaration())
+ return old_object;
+ if (new_object->is_type())
+ {
+ old_object->set_type_value(new_object->type_value());
+ new_object->type_value()->set_named_object(old_object);
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ go_unreachable();
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if (new_object->is_function_declaration())
+ {
+ if (!new_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ Function_type* old_type = old_object->func_value()->type();
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ {
+ Function_type* old_type = old_object->func_declaration_value()->type();
+ if (new_object->is_function_declaration())
+ {
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ if (new_object->is_function())
+ {
+ Function_type* new_type = new_object->func_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ {
+ if (!old_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ old_object->set_function_value(new_object->func_value());
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ }
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (new_object->is_package()
+ && (old_object->package_value()->name()
+ == new_object->package_value()->name()))
+ return old_object;
+
+ break;
+ }
+
+ std::string n = old_object->message_name();
+ if (reason.empty())
+ error_at(new_object->location(), "redefinition of %qs", n.c_str());
+ else
+ error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
+ reason.c_str());
+
+ inform(old_object->location(), "previous definition of %qs was here",
+ n.c_str());
+
+ return old_object;
+}
+
+// Add a named type.
+
+Named_object*
+Bindings::add_named_type(Named_type* named_type)
+{
+ return this->add_named_object(named_type->named_object());
+}
+
+// Add a function.
+
+Named_object*
+Bindings::add_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ return this->add_named_object(Named_object::make_function(name, package,
+ function));
+}
+
+// Add a function declaration.
+
+Named_object*
+Bindings::add_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = Named_object::make_function_declaration(name, package,
+ type, location);
+ return this->add_named_object(no);
+}
+
+// Define a type which was previously declared.
+
+void
+Bindings::define_type(Named_object* no, Named_type* type)
+{
+ no->set_type_value(type);
+ this->named_objects_.push_back(no);
+}
+
+// Traverse bindings.
+
+int
+Bindings::traverse(Traverse* traverse, bool is_global)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ // We don't use an iterator because we permit the traversal to add
+ // new global objects.
+ for (size_t i = 0; i < this->named_objects_.size(); ++i)
+ {
+ Named_object* p = this->named_objects_[i];
+ switch (p->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(p, is_global) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = p->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (p->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(p) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && (p->is_result_variable()
+ || p->var_value()->has_type()))
+ {
+ Type* t = (p->is_variable()
+ ? p->var_value()->type()
+ : p->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (p->is_variable()
+ && ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0))
+ {
+ if (p->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if ((traverse_mask & Traverse::traverse_functions) != 0)
+ {
+ int t = traverse->function(p);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ break;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_functions
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (p->func_value()->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ // These are traversed in Gogo::traverse.
+ go_assert(is_global);
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse(p->type_value(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ default:
+ go_unreachable();
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Class Label.
+
+// Get the backend representation for a label.
+
+Blabel*
+Label::get_backend_label(Translate_context* context)
+{
+ if (this->blabel_ == NULL)
+ {
+ Function* function = context->function()->func_value();
+ tree fndecl = function->get_decl();
+ Bfunction* bfunction = tree_to_function(fndecl);
+ this->blabel_ = context->backend()->label(bfunction, this->name_,
+ this->location_);
+ }
+ return this->blabel_;
+}
+
+// Return an expression for the address of this label.
+
+Bexpression*
+Label::get_addr(Translate_context* context, source_location location)
+{
+ Blabel* label = this->get_backend_label(context);
+ return context->backend()->label_address(label, location);
+}
+
+// Class Unnamed_label.
+
+// Get the backend representation for an unnamed label.
+
+Blabel*
+Unnamed_label::get_blabel(Translate_context* context)
+{
+ if (this->blabel_ == NULL)
+ {
+ Function* function = context->function()->func_value();
+ tree fndecl = function->get_decl();
+ Bfunction* bfunction = tree_to_function(fndecl);
+ this->blabel_ = context->backend()->label(bfunction, "",
+ this->location_);
+ }
+ return this->blabel_;
+}
+
+// Return a statement which defines this unnamed label.
+
+Bstatement*
+Unnamed_label::get_definition(Translate_context* context)
+{
+ Blabel* blabel = this->get_blabel(context);
+ return context->backend()->label_definition_statement(blabel);
+}
+
+// Return a goto statement to this unnamed label.
+
+Bstatement*
+Unnamed_label::get_goto(Translate_context* context, source_location location)
+{
+ Blabel* blabel = this->get_blabel(context);
+ return context->backend()->goto_statement(blabel, location);
+}
+
+// Class Package.
+
+Package::Package(const std::string& name, const std::string& unique_prefix,
+ source_location location)
+ : name_(name), unique_prefix_(unique_prefix), bindings_(new Bindings(NULL)),
+ priority_(0), location_(location), used_(false), is_imported_(false),
+ uses_sink_alias_(false)
+{
+ go_assert(!name.empty() && !unique_prefix.empty());
+}
+
+// Set the priority. We may see multiple priorities for an imported
+// package; we want to use the largest one.
+
+void
+Package::set_priority(int priority)
+{
+ if (priority > this->priority_)
+ this->priority_ = priority;
+}
+
+// Determine types of constants. Everything else in a package
+// (variables, function declarations) should already have a fixed
+// type. Constants may have abstract types.
+
+void
+Package::determine_types()
+{
+ Bindings* bindings = this->bindings_;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+ }
+}
+
+// Class Traverse.
+
+// Destructor.
+
+Traverse::~Traverse()
+{
+ if (this->types_seen_ != NULL)
+ delete this->types_seen_;
+ if (this->expressions_seen_ != NULL)
+ delete this->expressions_seen_;
+}
+
+// Record that we are looking at a type, and return true if we have
+// already seen it.
+
+bool
+Traverse::remember_type(const Type* type)
+{
+ if (type->is_error_type())
+ return true;
+ go_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ // We only have to remember named types, as they are the only ones
+ // we can see multiple times in a traversal.
+ if (type->classification() != Type::TYPE_NAMED)
+ return false;
+ if (this->types_seen_ == NULL)
+ this->types_seen_ = new Types_seen();
+ std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
+ return !ins.second;
+}
+
+// Record that we are looking at an expression, and return true if we
+// have already seen it.
+
+bool
+Traverse::remember_expression(const Expression* expression)
+{
+ go_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ if (this->expressions_seen_ == NULL)
+ this->expressions_seen_ = new Expressions_seen();
+ std::pair<Expressions_seen::iterator, bool> ins =
+ this->expressions_seen_->insert(expression);
+ return !ins.second;
+}
+
+// The default versions of these functions should never be called: the
+// traversal mask indicates which functions may be called.
+
+int
+Traverse::variable(Named_object*)
+{
+ go_unreachable();
+}
+
+int
+Traverse::constant(Named_object*, bool)
+{
+ go_unreachable();
+}
+
+int
+Traverse::function(Named_object*)
+{
+ go_unreachable();
+}
+
+int
+Traverse::block(Block*)
+{
+ go_unreachable();
+}
+
+int
+Traverse::statement(Block*, size_t*, Statement*)
+{
+ go_unreachable();
+}
+
+int
+Traverse::expression(Expression**)
+{
+ go_unreachable();
+}
+
+int
+Traverse::type(Type*)
+{
+ go_unreachable();
+}
--- /dev/null
+// gogo.cc -- Go frontend parsed representation.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+#include "go-dump.h"
+#include "lex.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "dataflow.h"
+#include "import.h"
+#include "export.h"
+#include "gogo.h"
+
+// Class Gogo.
+
+Gogo::Gogo(int int_type_size, int pointer_size)
+ : package_(NULL),
+ functions_(),
+ globals_(new Bindings(NULL)),
+ imports_(),
+ imported_unsafe_(false),
+ packages_(),
+ map_descriptors_(NULL),
+ type_descriptor_decls_(NULL),
+ init_functions_(),
+ need_init_fn_(false),
+ init_fn_name_(),
+ imported_init_fns_(),
+ unique_prefix_(),
+ unique_prefix_specified_(false),
+ interface_types_(),
+ named_types_are_converted_(false)
+{
+ const source_location loc = BUILTINS_LOCATION;
+
+ Named_type* uint8_type = Type::make_integer_type("uint8", true, 8,
+ RUNTIME_TYPE_KIND_UINT8);
+ this->add_named_type(uint8_type);
+ this->add_named_type(Type::make_integer_type("uint16", true, 16,
+ RUNTIME_TYPE_KIND_UINT16));
+ this->add_named_type(Type::make_integer_type("uint32", true, 32,
+ RUNTIME_TYPE_KIND_UINT32));
+ this->add_named_type(Type::make_integer_type("uint64", true, 64,
+ RUNTIME_TYPE_KIND_UINT64));
+
+ this->add_named_type(Type::make_integer_type("int8", false, 8,
+ RUNTIME_TYPE_KIND_INT8));
+ this->add_named_type(Type::make_integer_type("int16", false, 16,
+ RUNTIME_TYPE_KIND_INT16));
+ this->add_named_type(Type::make_integer_type("int32", false, 32,
+ RUNTIME_TYPE_KIND_INT32));
+ this->add_named_type(Type::make_integer_type("int64", false, 64,
+ RUNTIME_TYPE_KIND_INT64));
+
+ this->add_named_type(Type::make_float_type("float32", 32,
+ RUNTIME_TYPE_KIND_FLOAT32));
+ this->add_named_type(Type::make_float_type("float64", 64,
+ RUNTIME_TYPE_KIND_FLOAT64));
+
+ this->add_named_type(Type::make_complex_type("complex64", 64,
+ RUNTIME_TYPE_KIND_COMPLEX64));
+ this->add_named_type(Type::make_complex_type("complex128", 128,
+ RUNTIME_TYPE_KIND_COMPLEX128));
+
+ if (int_type_size < 32)
+ int_type_size = 32;
+ this->add_named_type(Type::make_integer_type("uint", true,
+ int_type_size,
+ RUNTIME_TYPE_KIND_UINT));
+ Named_type* int_type = Type::make_integer_type("int", false, int_type_size,
+ RUNTIME_TYPE_KIND_INT);
+ this->add_named_type(int_type);
+
+ // "byte" is an alias for "uint8". Construct a Named_object which
+ // points to UINT8_TYPE. Note that this breaks the normal pairing
+ // in which a Named_object points to a Named_type which points back
+ // to the same Named_object.
+ Named_object* byte_type = this->declare_type("byte", loc);
+ byte_type->set_type_value(uint8_type);
+
+ this->add_named_type(Type::make_integer_type("uintptr", true,
+ pointer_size,
+ RUNTIME_TYPE_KIND_UINTPTR));
+
+ this->add_named_type(Type::make_named_bool_type());
+
+ this->add_named_type(Type::make_named_string_type());
+
+ this->globals_->add_constant(Typed_identifier("true",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(true, loc),
+ 0);
+ this->globals_->add_constant(Typed_identifier("false",
+ Type::make_boolean_type(),
+ loc),
+ NULL,
+ Expression::make_boolean(false, loc),
+ 0);
+
+ this->globals_->add_constant(Typed_identifier("nil", Type::make_nil_type(),
+ loc),
+ NULL,
+ Expression::make_nil(loc),
+ 0);
+
+ Type* abstract_int_type = Type::make_abstract_integer_type();
+ this->globals_->add_constant(Typed_identifier("iota", abstract_int_type,
+ loc),
+ NULL,
+ Expression::make_iota(),
+ 0);
+
+ Function_type* new_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ new_type->set_is_varargs();
+ new_type->set_is_builtin();
+ this->globals_->add_function_declaration("new", NULL, new_type, loc);
+
+ Function_type* make_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ make_type->set_is_varargs();
+ make_type->set_is_builtin();
+ this->globals_->add_function_declaration("make", NULL, make_type, loc);
+
+ Typed_identifier_list* len_result = new Typed_identifier_list();
+ len_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* len_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ len_type->set_is_builtin();
+ this->globals_->add_function_declaration("len", NULL, len_type, loc);
+
+ Typed_identifier_list* cap_result = new Typed_identifier_list();
+ cap_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* cap_type = Type::make_function_type(NULL, NULL, len_result,
+ loc);
+ cap_type->set_is_builtin();
+ this->globals_->add_function_declaration("cap", NULL, cap_type, loc);
+
+ Function_type* print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("print", NULL, print_type, loc);
+
+ print_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ print_type->set_is_varargs();
+ print_type->set_is_builtin();
+ this->globals_->add_function_declaration("println", NULL, print_type, loc);
+
+ Type *empty = Type::make_interface_type(NULL, loc);
+ Typed_identifier_list* panic_parms = new Typed_identifier_list();
+ panic_parms->push_back(Typed_identifier("e", empty, loc));
+ Function_type *panic_type = Type::make_function_type(NULL, panic_parms,
+ NULL, loc);
+ panic_type->set_is_builtin();
+ this->globals_->add_function_declaration("panic", NULL, panic_type, loc);
+
+ Typed_identifier_list* recover_result = new Typed_identifier_list();
+ recover_result->push_back(Typed_identifier("", empty, loc));
+ Function_type* recover_type = Type::make_function_type(NULL, NULL,
+ recover_result,
+ loc);
+ recover_type->set_is_builtin();
+ this->globals_->add_function_declaration("recover", NULL, recover_type, loc);
+
+ Function_type* close_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ close_type->set_is_varargs();
+ close_type->set_is_builtin();
+ this->globals_->add_function_declaration("close", NULL, close_type, loc);
+
+ Typed_identifier_list* copy_result = new Typed_identifier_list();
+ copy_result->push_back(Typed_identifier("", int_type, loc));
+ Function_type* copy_type = Type::make_function_type(NULL, NULL,
+ copy_result, loc);
+ copy_type->set_is_varargs();
+ copy_type->set_is_builtin();
+ this->globals_->add_function_declaration("copy", NULL, copy_type, loc);
+
+ Function_type* append_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ append_type->set_is_varargs();
+ append_type->set_is_builtin();
+ this->globals_->add_function_declaration("append", NULL, append_type, loc);
+
+ Function_type* complex_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ complex_type->set_is_varargs();
+ complex_type->set_is_builtin();
+ this->globals_->add_function_declaration("complex", NULL, complex_type, loc);
+
+ Function_type* real_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ real_type->set_is_varargs();
+ real_type->set_is_builtin();
+ this->globals_->add_function_declaration("real", NULL, real_type, loc);
+
+ Function_type* imag_type = Type::make_function_type(NULL, NULL, NULL, loc);
+ imag_type->set_is_varargs();
+ imag_type->set_is_builtin();
+ this->globals_->add_function_declaration("imag", NULL, imag_type, loc);
+
+ this->define_builtin_function_trees();
+}
+
+// Munge name for use in an error message.
+
+std::string
+Gogo::message_name(const std::string& name)
+{
+ return go_localize_identifier(Gogo::unpack_hidden_name(name).c_str());
+}
+
+// Get the package name.
+
+const std::string&
+Gogo::package_name() const
+{
+ gcc_assert(this->package_ != NULL);
+ return this->package_->name();
+}
+
+// Set the package name.
+
+void
+Gogo::set_package_name(const std::string& package_name,
+ source_location location)
+{
+ if (this->package_ != NULL && this->package_->name() != package_name)
+ {
+ error_at(location, "expected package %<%s%>",
+ Gogo::message_name(this->package_->name()).c_str());
+ return;
+ }
+
+ // If the user did not specify a unique prefix, we always use "go".
+ // This in effect requires that the package name be unique.
+ if (this->unique_prefix_.empty())
+ this->unique_prefix_ = "go";
+
+ this->package_ = this->register_package(package_name, this->unique_prefix_,
+ location);
+
+ // We used to permit people to qualify symbols with the current
+ // package name (e.g., P.x), but we no longer do.
+ // this->globals_->add_package(package_name, this->package_);
+
+ if (this->is_main_package())
+ {
+ // Declare "main" as a function which takes no parameters and
+ // returns no value.
+ this->declare_function("main",
+ Type::make_function_type(NULL, NULL, NULL,
+ BUILTINS_LOCATION),
+ BUILTINS_LOCATION);
+ }
+}
+
+// Return whether this is the "main" package. This is not true if
+// -fgo-prefix was used.
+
+bool
+Gogo::is_main_package() const
+{
+ return this->package_name() == "main" && !this->unique_prefix_specified_;
+}
+
+// Import a package.
+
+void
+Gogo::import_package(const std::string& filename,
+ const std::string& local_name,
+ bool is_local_name_exported,
+ source_location location)
+{
+ if (filename == "unsafe")
+ {
+ this->import_unsafe(local_name, is_local_name_exported, location);
+ return;
+ }
+
+ Imports::const_iterator p = this->imports_.find(filename);
+ if (p != this->imports_.end())
+ {
+ Package* package = p->second;
+ package->set_location(location);
+ package->set_is_imported();
+ std::string ln = local_name;
+ bool is_ln_exported = is_local_name_exported;
+ if (ln.empty())
+ {
+ ln = package->name();
+ is_ln_exported = Lex::is_exported_name(ln);
+ }
+ if (ln == ".")
+ {
+ Bindings* bindings = package->bindings();
+ for (Bindings::const_declarations_iterator p =
+ bindings->begin_declarations();
+ p != bindings->end_declarations();
+ ++p)
+ this->add_named_object(p->second);
+ }
+ else if (ln == "_")
+ package->set_uses_sink_alias();
+ else
+ {
+ ln = this->pack_hidden_name(ln, is_ln_exported);
+ this->package_->bindings()->add_package(ln, package);
+ }
+ return;
+ }
+
+ Import::Stream* stream = Import::open_package(filename, location);
+ if (stream == NULL)
+ {
+ error_at(location, "import file %qs not found", filename.c_str());
+ return;
+ }
+
+ Import imp(stream, location);
+ imp.register_builtin_types(this);
+ Package* package = imp.import(this, local_name, is_local_name_exported);
+ if (package != NULL)
+ {
+ if (package->name() == this->package_name()
+ && package->unique_prefix() == this->unique_prefix())
+ error_at(location,
+ ("imported package uses same package name and prefix "
+ "as package being compiled (see -fgo-prefix option)"));
+
+ this->imports_.insert(std::make_pair(filename, package));
+ package->set_is_imported();
+ }
+
+ delete stream;
+}
+
+// Add an import control function for an imported package to the list.
+
+void
+Gogo::add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio)
+{
+ for (std::set<Import_init>::const_iterator p =
+ this->imported_init_fns_.begin();
+ p != this->imported_init_fns_.end();
+ ++p)
+ {
+ if (p->init_name() == init_name
+ && (p->package_name() != package_name || p->priority() != prio))
+ {
+ error("duplicate package initialization name %qs",
+ Gogo::message_name(init_name).c_str());
+ inform(UNKNOWN_LOCATION, "used by package %qs at priority %d",
+ Gogo::message_name(p->package_name()).c_str(),
+ p->priority());
+ inform(UNKNOWN_LOCATION, " and by package %qs at priority %d",
+ Gogo::message_name(package_name).c_str(), prio);
+ return;
+ }
+ }
+
+ this->imported_init_fns_.insert(Import_init(package_name, init_name,
+ prio));
+}
+
+// Return whether we are at the global binding level.
+
+bool
+Gogo::in_global_scope() const
+{
+ return this->functions_.empty();
+}
+
+// Return the current binding contour.
+
+Bindings*
+Gogo::current_bindings()
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+const Bindings*
+Gogo::current_bindings() const
+{
+ if (!this->functions_.empty())
+ return this->functions_.back().blocks.back()->bindings();
+ else if (this->package_ != NULL)
+ return this->package_->bindings();
+ else
+ return this->globals_;
+}
+
+// Return the current block.
+
+Block*
+Gogo::current_block()
+{
+ if (this->functions_.empty())
+ return NULL;
+ else
+ return this->functions_.back().blocks.back();
+}
+
+// Look up a name in the current binding contour. If PFUNCTION is not
+// NULL, set it to the function in which the name is defined, or NULL
+// if the name is defined in global scope.
+
+Named_object*
+Gogo::lookup(const std::string& name, Named_object** pfunction) const
+{
+ if (pfunction != NULL)
+ *pfunction = NULL;
+
+ if (Gogo::is_sink_name(name))
+ return Named_object::make_sink();
+
+ for (Open_functions::const_reverse_iterator p = this->functions_.rbegin();
+ p != this->functions_.rend();
+ ++p)
+ {
+ Named_object* ret = p->blocks.back()->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (pfunction != NULL)
+ *pfunction = p->function;
+ return ret;
+ }
+ }
+
+ if (this->package_ != NULL)
+ {
+ Named_object* ret = this->package_->bindings()->lookup(name);
+ if (ret != NULL)
+ {
+ if (ret->package() != NULL)
+ ret->package()->set_used();
+ return ret;
+ }
+ }
+
+ // We do not look in the global namespace. If we did, the global
+ // namespace would effectively hide names which were defined in
+ // package scope which we have not yet seen. Instead,
+ // define_global_names is called after parsing is over to connect
+ // undefined names at package scope with names defined at global
+ // scope.
+
+ return NULL;
+}
+
+// Look up a name in the current block, without searching enclosing
+// blocks.
+
+Named_object*
+Gogo::lookup_in_block(const std::string& name) const
+{
+ gcc_assert(!this->functions_.empty());
+ gcc_assert(!this->functions_.back().blocks.empty());
+ return this->functions_.back().blocks.back()->bindings()->lookup_local(name);
+}
+
+// Look up a name in the global namespace.
+
+Named_object*
+Gogo::lookup_global(const char* name) const
+{
+ return this->globals_->lookup(name);
+}
+
+// Add an imported package.
+
+Package*
+Gogo::add_imported_package(const std::string& real_name,
+ const std::string& alias_arg,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals)
+{
+ // FIXME: Now that we compile packages as a whole, should we permit
+ // importing the current package?
+ if (this->package_name() == real_name
+ && this->unique_prefix() == unique_prefix)
+ {
+ *padd_to_globals = false;
+ if (!alias_arg.empty() && alias_arg != ".")
+ {
+ std::string alias = this->pack_hidden_name(alias_arg,
+ is_alias_exported);
+ this->package_->bindings()->add_package(alias, this->package_);
+ }
+ return this->package_;
+ }
+ else if (alias_arg == ".")
+ {
+ *padd_to_globals = true;
+ return this->register_package(real_name, unique_prefix, location);
+ }
+ else if (alias_arg == "_")
+ {
+ Package* ret = this->register_package(real_name, unique_prefix, location);
+ ret->set_uses_sink_alias();
+ return ret;
+ }
+ else
+ {
+ *padd_to_globals = false;
+ std::string alias = alias_arg;
+ if (alias.empty())
+ {
+ alias = real_name;
+ is_alias_exported = Lex::is_exported_name(alias);
+ }
+ alias = this->pack_hidden_name(alias, is_alias_exported);
+ Named_object* no = this->add_package(real_name, alias, unique_prefix,
+ location);
+ if (!no->is_package())
+ return NULL;
+ return no->package_value();
+ }
+}
+
+// Add a package.
+
+Named_object*
+Gogo::add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location)
+{
+ gcc_assert(this->in_global_scope());
+
+ // Register the package. Note that we might have already seen it in
+ // an earlier import.
+ Package* package = this->register_package(real_name, unique_prefix, location);
+
+ return this->package_->bindings()->add_package(alias, package);
+}
+
+// Register a package. This package may or may not be imported. This
+// returns the Package structure for the package, creating if it
+// necessary.
+
+Package*
+Gogo::register_package(const std::string& package_name,
+ const std::string& unique_prefix,
+ source_location location)
+{
+ gcc_assert(!unique_prefix.empty() && !package_name.empty());
+ std::string name = unique_prefix + '.' + package_name;
+ Package* package = NULL;
+ std::pair<Packages::iterator, bool> ins =
+ this->packages_.insert(std::make_pair(name, package));
+ if (!ins.second)
+ {
+ // We have seen this package name before.
+ package = ins.first->second;
+ gcc_assert(package != NULL);
+ gcc_assert(package->name() == package_name
+ && package->unique_prefix() == unique_prefix);
+ if (package->location() == UNKNOWN_LOCATION)
+ package->set_location(location);
+ }
+ else
+ {
+ // First time we have seen this package name.
+ package = new Package(package_name, unique_prefix, location);
+ gcc_assert(ins.first->second == NULL);
+ ins.first->second = package;
+ }
+
+ return package;
+}
+
+// Start compiling a function.
+
+Named_object*
+Gogo::start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location location)
+{
+ bool at_top_level = this->functions_.empty();
+
+ Block* block = new Block(NULL, location);
+
+ Function* enclosing = (at_top_level
+ ? NULL
+ : this->functions_.back().function->func_value());
+
+ Function* function = new Function(type, enclosing, block, location);
+
+ if (type->is_method())
+ {
+ const Typed_identifier* receiver = type->receiver();
+ Variable* this_param = new Variable(receiver->type(), NULL, false,
+ true, true, location);
+ std::string name = receiver->name();
+ if (name.empty())
+ {
+ // We need to give receivers a name since they wind up in
+ // DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "r.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, this_param);
+ }
+
+ const Typed_identifier_list* parameters = type->parameters();
+ bool is_varargs = type->is_varargs();
+ if (parameters != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ Variable* param = new Variable(p->type(), NULL, false, true, false,
+ location);
+ if (is_varargs && p + 1 == parameters->end())
+ param->set_is_varargs_parameter();
+
+ std::string name = p->name();
+ if (name.empty() || Gogo::is_sink_name(name))
+ {
+ // We need to give parameters a name since they wind up
+ // in DECL_ARGUMENTS. FIXME.
+ static unsigned int count;
+ char buf[50];
+ snprintf(buf, sizeof buf, "p.%u", count);
+ ++count;
+ name = buf;
+ }
+ block->bindings()->add_variable(name, NULL, param);
+ }
+ }
+
+ function->create_named_result_variables(this);
+
+ const std::string* pname;
+ std::string nested_name;
+ bool is_init = false;
+ if (Gogo::unpack_hidden_name(name) == "init" && !type->is_method())
+ {
+ if ((type->parameters() != NULL && !type->parameters()->empty())
+ || (type->results() != NULL && !type->results()->empty()))
+ error_at(location,
+ "func init must have no arguments and no return values");
+ // There can be multiple "init" functions, so give them each a
+ // different name.
+ static int init_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$init%d", init_count);
+ ++init_count;
+ nested_name = buf;
+ pname = &nested_name;
+ is_init = true;
+ }
+ else if (!name.empty())
+ pname = &name;
+ else
+ {
+ // Invent a name for a nested function.
+ static int nested_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$nested%d", nested_count);
+ ++nested_count;
+ nested_name = buf;
+ pname = &nested_name;
+ }
+
+ Named_object* ret;
+ if (Gogo::is_sink_name(*pname))
+ {
+ static int sink_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$sink%d", sink_count);
+ ++sink_count;
+ ret = Named_object::make_function(buf, NULL, function);
+ }
+ else if (!type->is_method())
+ {
+ ret = this->package_->bindings()->add_function(*pname, NULL, function);
+ if (!ret->is_function() || ret->func_value() != function)
+ {
+ // Redefinition error. Invent a name to avoid knockon
+ // errors.
+ static int redefinition_count;
+ char buf[30];
+ snprintf(buf, sizeof buf, ".$redefined%d", redefinition_count);
+ ++redefinition_count;
+ ret = this->package_->bindings()->add_function(buf, NULL, function);
+ }
+ }
+ else
+ {
+ if (!add_method_to_type)
+ ret = Named_object::make_function(name, NULL, function);
+ else
+ {
+ gcc_assert(at_top_level);
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ ret = Named_object::make_function(name, NULL, function);
+ else if (rtype->named_type() != NULL)
+ {
+ ret = rtype->named_type()->add_method(name, function);
+ if (!ret->is_function())
+ {
+ // Redefinition error.
+ ret = Named_object::make_function(name, NULL, function);
+ }
+ }
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Named_object* type_no =
+ rtype->forward_declaration_type()->named_object();
+ if (type_no->is_unknown())
+ {
+ // If we are seeing methods it really must be a
+ // type. Declare it as such. An alternative would
+ // be to support lists of methods for unknown
+ // expressions. Either way the error messages if
+ // this is not a type are going to get confusing.
+ Named_object* declared =
+ this->declare_package_type(type_no->name(),
+ type_no->location());
+ gcc_assert(declared
+ == type_no->unknown_value()->real_named_object());
+ }
+ ret = rtype->forward_declaration_type()->add_method(name,
+ function);
+ }
+ else
+ gcc_unreachable();
+ }
+ this->package_->bindings()->add_method(ret);
+ }
+
+ this->functions_.resize(this->functions_.size() + 1);
+ Open_function& of(this->functions_.back());
+ of.function = ret;
+ of.blocks.push_back(block);
+
+ if (is_init)
+ {
+ this->init_functions_.push_back(ret);
+ this->need_init_fn_ = true;
+ }
+
+ return ret;
+}
+
+// Finish compiling a function.
+
+void
+Gogo::finish_function(source_location location)
+{
+ this->finish_block(location);
+ gcc_assert(this->functions_.back().blocks.empty());
+ this->functions_.pop_back();
+}
+
+// Return the current function.
+
+Named_object*
+Gogo::current_function() const
+{
+ gcc_assert(!this->functions_.empty());
+ return this->functions_.back().function;
+}
+
+// Start a new block.
+
+void
+Gogo::start_block(source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ Block* block = new Block(this->current_block(), location);
+ this->functions_.back().blocks.push_back(block);
+}
+
+// Finish a block.
+
+Block*
+Gogo::finish_block(source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ gcc_assert(!this->functions_.back().blocks.empty());
+ Block* block = this->functions_.back().blocks.back();
+ this->functions_.back().blocks.pop_back();
+ block->set_end_location(location);
+ return block;
+}
+
+// Add an unknown name.
+
+Named_object*
+Gogo::add_unknown_name(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_unknown_name(name, location);
+}
+
+// Declare a function.
+
+Named_object*
+Gogo::declare_function(const std::string& name, Function_type* type,
+ source_location location)
+{
+ if (!type->is_method())
+ return this->current_bindings()->add_function_declaration(name, NULL, type,
+ location);
+ else
+ {
+ // We don't bother to add this to the list of global
+ // declarations.
+ Type* rtype = type->receiver()->type();
+
+ // We want to look through the pointer created by the
+ // parser, without getting an error if the type is not yet
+ // defined.
+ if (rtype->classification() == Type::TYPE_POINTER)
+ rtype = rtype->points_to();
+
+ if (rtype->is_error_type())
+ return NULL;
+ else if (rtype->named_type() != NULL)
+ return rtype->named_type()->add_method_declaration(name, NULL, type,
+ location);
+ else if (rtype->forward_declaration_type() != NULL)
+ {
+ Forward_declaration_type* ftype = rtype->forward_declaration_type();
+ return ftype->add_method_declaration(name, type, location);
+ }
+ else
+ gcc_unreachable();
+ }
+}
+
+// Add a label definition.
+
+Label*
+Gogo::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ gcc_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ Label* label = func->add_label_definition(label_name, location);
+ this->add_statement(Statement::make_label_statement(label, location));
+ return label;
+}
+
+// Add a label reference.
+
+Label*
+Gogo::add_label_reference(const std::string& label_name)
+{
+ gcc_assert(!this->functions_.empty());
+ Function* func = this->functions_.back().function->func_value();
+ return func->add_label_reference(label_name);
+}
+
+// Add a statement.
+
+void
+Gogo::add_statement(Statement* statement)
+{
+ gcc_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a block.
+
+void
+Gogo::add_block(Block* block, source_location location)
+{
+ gcc_assert(!this->functions_.empty()
+ && !this->functions_.back().blocks.empty());
+ Statement* statement = Statement::make_block_statement(block, location);
+ this->functions_.back().blocks.back()->add_statement(statement);
+}
+
+// Add a constant.
+
+Named_object*
+Gogo::add_constant(const Typed_identifier& tid, Expression* expr,
+ int iota_value)
+{
+ return this->current_bindings()->add_constant(tid, NULL, expr, iota_value);
+}
+
+// Add a type.
+
+void
+Gogo::add_type(const std::string& name, Type* type, source_location location)
+{
+ Named_object* no = this->current_bindings()->add_type(name, NULL, type,
+ location);
+ if (!this->in_global_scope() && no->is_type())
+ no->type_value()->set_in_function(this->functions_.back().function);
+}
+
+// Add a named type.
+
+void
+Gogo::add_named_type(Named_type* type)
+{
+ gcc_assert(this->in_global_scope());
+ this->current_bindings()->add_named_type(type);
+}
+
+// Declare a type.
+
+Named_object*
+Gogo::declare_type(const std::string& name, source_location location)
+{
+ Bindings* bindings = this->current_bindings();
+ Named_object* no = bindings->add_type_declaration(name, NULL, location);
+ if (!this->in_global_scope() && no->is_type_declaration())
+ {
+ Named_object* f = this->functions_.back().function;
+ no->type_declaration_value()->set_in_function(f);
+ }
+ return no;
+}
+
+// Declare a type at the package level.
+
+Named_object*
+Gogo::declare_package_type(const std::string& name, source_location location)
+{
+ return this->package_->bindings()->add_type_declaration(name, NULL, location);
+}
+
+// Define a type which was already declared.
+
+void
+Gogo::define_type(Named_object* no, Named_type* type)
+{
+ this->current_bindings()->define_type(no, type);
+}
+
+// Add a variable.
+
+Named_object*
+Gogo::add_variable(const std::string& name, Variable* variable)
+{
+ Named_object* no = this->current_bindings()->add_variable(name, NULL,
+ variable);
+
+ // In a function the middle-end wants to see a DECL_EXPR node.
+ if (no != NULL
+ && no->is_variable()
+ && !no->var_value()->is_parameter()
+ && !this->functions_.empty())
+ this->add_statement(Statement::make_variable_declaration(no));
+
+ return no;
+}
+
+// Add a sink--a reference to the blank identifier _.
+
+Named_object*
+Gogo::add_sink()
+{
+ return Named_object::make_sink();
+}
+
+// Add a named object.
+
+void
+Gogo::add_named_object(Named_object* no)
+{
+ this->current_bindings()->add_named_object(no);
+}
+
+// Record that we've seen an interface type.
+
+void
+Gogo::record_interface_type(Interface_type* itype)
+{
+ this->interface_types_.push_back(itype);
+}
+
+// Return a name for a thunk object.
+
+std::string
+Gogo::thunk_name()
+{
+ static int thunk_count;
+ char thunk_name[50];
+ snprintf(thunk_name, sizeof thunk_name, "$thunk%d", thunk_count);
+ ++thunk_count;
+ return thunk_name;
+}
+
+// Return whether a function is a thunk.
+
+bool
+Gogo::is_thunk(const Named_object* no)
+{
+ return no->name().compare(0, 6, "$thunk") == 0;
+}
+
+// Define the global names. We do this only after parsing all the
+// input files, because the program might define the global names
+// itself.
+
+void
+Gogo::define_global_names()
+{
+ for (Bindings::const_declarations_iterator p =
+ this->globals_->begin_declarations();
+ p != this->globals_->end_declarations();
+ ++p)
+ {
+ Named_object* global_no = p->second;
+ std::string name(Gogo::pack_hidden_name(global_no->name(), false));
+ Named_object* no = this->package_->bindings()->lookup(name);
+ if (no == NULL)
+ continue;
+ no = no->resolve();
+ if (no->is_type_declaration())
+ {
+ if (global_no->is_type())
+ {
+ if (no->type_declaration_value()->has_methods())
+ error_at(no->location(),
+ "may not define methods for global type");
+ no->set_type_value(global_no->type_value());
+ }
+ else
+ {
+ error_at(no->location(), "expected type");
+ Type* errtype = Type::make_error_type();
+ Named_object* err = Named_object::make_type("error", NULL,
+ errtype,
+ BUILTINS_LOCATION);
+ no->set_type_value(err->type_value());
+ }
+ }
+ else if (no->is_unknown())
+ no->unknown_value()->set_real_named_object(global_no);
+ }
+}
+
+// Clear out names in file scope.
+
+void
+Gogo::clear_file_scope()
+{
+ this->package_->bindings()->clear_file_scope();
+
+ // Warn about packages which were imported but not used.
+ for (Packages::iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ Package* package = p->second;
+ if (package != this->package_
+ && package->is_imported()
+ && !package->used()
+ && !package->uses_sink_alias()
+ && !saw_errors())
+ error_at(package->location(), "imported and not used: %s",
+ Gogo::message_name(package->name()).c_str());
+ package->clear_is_imported();
+ package->clear_uses_sink_alias();
+ package->clear_used();
+ }
+}
+
+// Traverse the tree.
+
+void
+Gogo::traverse(Traverse* traverse)
+{
+ // Traverse the current package first for consistency. The other
+ // packages will only contain imported types, constants, and
+ // declarations.
+ if (this->package_->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ return;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ if (p->second != this->package_)
+ {
+ if (p->second->bindings()->traverse(traverse, true) == TRAVERSE_EXIT)
+ break;
+ }
+ }
+}
+
+// Traversal class used to verify types.
+
+class Verify_types : public Traverse
+{
+ public:
+ Verify_types()
+ : Traverse(traverse_types)
+ { }
+
+ int
+ type(Type*);
+};
+
+// Verify that a type is correct.
+
+int
+Verify_types::type(Type* t)
+{
+ if (!t->verify())
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that all types are correct.
+
+void
+Gogo::verify_types()
+{
+ Verify_types traverse;
+ this->traverse(&traverse);
+}
+
+// Traversal class used to lower parse tree.
+
+class Lower_parse_tree : public Traverse
+{
+ public:
+ Lower_parse_tree(Gogo* gogo, Named_object* function)
+ : Traverse(traverse_variables
+ | traverse_constants
+ | traverse_functions
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo), function_(function), iota_value_(-1)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ function(Named_object*);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+ // The function we are traversing.
+ Named_object* function_;
+ // Value to use for the predeclared constant iota.
+ int iota_value_;
+};
+
+// Lower variables. We handle variables specially to break loops in
+// which a variable initialization expression refers to itself. The
+// loop breaking is in lower_init_expression.
+
+int
+Lower_parse_tree::variable(Named_object* no)
+{
+ if (no->is_variable())
+ no->var_value()->lower_init_expression(this->gogo_, this->function_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower constants. We handle constants specially so that we can set
+// the right value for the predeclared constant iota. This works in
+// conjunction with the way we lower Const_expression objects.
+
+int
+Lower_parse_tree::constant(Named_object* no, bool)
+{
+ Named_constant* nc = no->const_value();
+
+ // Don't get into trouble if the constant's initializer expression
+ // refers to the constant itself.
+ if (nc->lowering())
+ return TRAVERSE_CONTINUE;
+ nc->set_lowering();
+
+ gcc_assert(this->iota_value_ == -1);
+ this->iota_value_ = nc->iota_value();
+ nc->traverse_expression(this);
+ this->iota_value_ = -1;
+
+ nc->clear_lowering();
+
+ // We will traverse the expression a second time, but that will be
+ // fast.
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower function closure types. Record the function while lowering
+// it, so that we can pass it down when lowering an expression.
+
+int
+Lower_parse_tree::function(Named_object* no)
+{
+ no->func_value()->set_closure_type();
+
+ gcc_assert(this->function_ == NULL);
+ this->function_ = no;
+ int t = no->func_value()->traverse(this);
+ this->function_ = NULL;
+
+ if (t == TRAVERSE_EXIT)
+ return t;
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower statement parse trees.
+
+int
+Lower_parse_tree::statement(Block* block, size_t* pindex, Statement* sorig)
+{
+ // Lower the expressions first.
+ int t = sorig->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+
+ // Keep lowering until nothing changes.
+ Statement* s = sorig;
+ while (true)
+ {
+ Statement* snew = s->lower(this->gogo_, this->function_, block);
+ if (snew == s)
+ break;
+ s = snew;
+ t = s->traverse_contents(this);
+ if (t == TRAVERSE_EXIT)
+ return t;
+ }
+
+ if (s != sorig)
+ block->replace_statement(*pindex, s);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower expression parse trees.
+
+int
+Lower_parse_tree::expression(Expression** pexpr)
+{
+ // We have to lower all subexpressions first, so that we can get
+ // their type if necessary. This is awkward, because we don't have
+ // a postorder traversal pass.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ // Keep lowering until nothing changes.
+ while (true)
+ {
+ Expression* e = *pexpr;
+ Expression* enew = e->lower(this->gogo_, this->function_,
+ this->iota_value_);
+ if (enew == e)
+ break;
+ *pexpr = enew;
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Lower the parse tree. This is called after the parse is complete,
+// when all names should be resolved.
+
+void
+Gogo::lower_parse_tree()
+{
+ Lower_parse_tree lower_parse_tree(this, NULL);
+ this->traverse(&lower_parse_tree);
+}
+
+// Lower a block.
+
+void
+Gogo::lower_block(Named_object* function, Block* block)
+{
+ Lower_parse_tree lower_parse_tree(this, function);
+ block->traverse(&lower_parse_tree);
+}
+
+// Lower an expression.
+
+void
+Gogo::lower_expression(Named_object* function, Expression** pexpr)
+{
+ Lower_parse_tree lower_parse_tree(this, function);
+ lower_parse_tree.expression(pexpr);
+}
+
+// Lower a constant. This is called when lowering a reference to a
+// constant. We have to make sure that the constant has already been
+// lowered.
+
+void
+Gogo::lower_constant(Named_object* no)
+{
+ gcc_assert(no->is_const());
+ Lower_parse_tree lower(this, NULL);
+ lower.constant(no, false);
+}
+
+// Look for interface types to finalize methods of inherited
+// interfaces.
+
+class Finalize_methods : public Traverse
+{
+ public:
+ Finalize_methods(Gogo* gogo)
+ : Traverse(traverse_types),
+ gogo_(gogo)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ Gogo* gogo_;
+};
+
+// Finalize the methods of an interface type.
+
+int
+Finalize_methods::type(Type* t)
+{
+ // Check the classification so that we don't finalize the methods
+ // twice for a named interface type.
+ switch (t->classification())
+ {
+ case Type::TYPE_INTERFACE:
+ t->interface_type()->finalize_methods();
+ break;
+
+ case Type::TYPE_NAMED:
+ {
+ // We have to finalize the methods of the real type first.
+ // But if the real type is a struct type, then we only want to
+ // finalize the methods of the field types, not of the struct
+ // type itself. We don't want to add methods to the struct,
+ // since it has a name.
+ Type* rt = t->named_type()->real_type();
+ if (rt->classification() != Type::TYPE_STRUCT)
+ {
+ if (Type::traverse(rt, this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ else
+ {
+ if (rt->struct_type()->traverse_field_types(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ t->named_type()->finalize_methods(this->gogo_);
+
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ case Type::TYPE_STRUCT:
+ t->struct_type()->finalize_methods(this->gogo_);
+ break;
+
+ default:
+ break;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Finalize method lists and build stub methods for types.
+
+void
+Gogo::finalize_methods()
+{
+ Finalize_methods finalize(this);
+ this->traverse(&finalize);
+}
+
+// Set types for unspecified variables and constants.
+
+void
+Gogo::determine_types()
+{
+ Bindings* bindings = this->current_bindings();
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_function())
+ (*p)->func_value()->determine_types();
+ else if ((*p)->is_variable())
+ (*p)->var_value()->determine_type();
+ else if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+
+ // See if a variable requires us to build an initialization
+ // function. We know that we will see all global variables
+ // here.
+ if (!this->need_init_fn_ && (*p)->is_variable())
+ {
+ Variable* variable = (*p)->var_value();
+
+ // If this is a global variable which requires runtime
+ // initialization, we need an initialization function.
+ if (!variable->is_global())
+ ;
+ else if (variable->init() == NULL)
+ ;
+ else if (variable->type()->interface_type() != NULL)
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_constant())
+ ;
+ else if (!variable->init()->is_composite_literal())
+ this->need_init_fn_ = true;
+ else if (variable->init()->is_nonconstant_composite_literal())
+ this->need_init_fn_ = true;
+
+ // If this is a global variable which holds a pointer value,
+ // then we need an initialization function to register it as a
+ // GC root.
+ if (variable->is_global() && variable->type()->has_pointer())
+ this->need_init_fn_ = true;
+ }
+ }
+
+ // Determine the types of constants in packages.
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ p->second->determine_types();
+}
+
+// Traversal class used for type checking.
+
+class Check_types_traverse : public Traverse
+{
+ public:
+ Check_types_traverse(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_constants
+ | traverse_statements
+ | traverse_expressions),
+ gogo_(gogo)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ constant(Named_object*, bool);
+
+ int
+ statement(Block*, size_t* pindex, Statement*);
+
+ int
+ expression(Expression**);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+};
+
+// Check that a variable initializer has the right type.
+
+int
+Check_types_traverse::variable(Named_object* named_object)
+{
+ if (named_object->is_variable())
+ {
+ Variable* var = named_object->var_value();
+ Expression* init = var->init();
+ std::string reason;
+ if (init != NULL
+ && !Type::are_assignable(var->type(), init->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(var->location(), "incompatible type in initialization");
+ else
+ error_at(var->location(),
+ "incompatible type in initialization (%s)",
+ reason.c_str());
+ var->clear_init();
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that a constant initializer has the right type.
+
+int
+Check_types_traverse::constant(Named_object* named_object, bool)
+{
+ Named_constant* constant = named_object->const_value();
+ Type* ctype = constant->type();
+ if (ctype->integer_type() == NULL
+ && ctype->float_type() == NULL
+ && ctype->complex_type() == NULL
+ && !ctype->is_boolean_type()
+ && !ctype->is_string_type())
+ {
+ if (!ctype->is_error_type())
+ error_at(constant->location(), "invalid constant type");
+ constant->set_error();
+ }
+ else if (!constant->expr()->is_constant())
+ {
+ error_at(constant->expr()->location(), "expression is not constant");
+ constant->set_error();
+ }
+ else if (!Type::are_assignable(constant->type(), constant->expr()->type(),
+ NULL))
+ {
+ error_at(constant->location(),
+ "initialization expression has wrong type");
+ constant->set_error();
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in a statement.
+
+int
+Check_types_traverse::statement(Block*, size_t*, Statement* s)
+{
+ s->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid in an expression.
+
+int
+Check_types_traverse::expression(Expression** expr)
+{
+ (*expr)->check_types(this->gogo_);
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that types are valid.
+
+void
+Gogo::check_types()
+{
+ Check_types_traverse traverse(this);
+ this->traverse(&traverse);
+}
+
+// Check the types in a single block.
+
+void
+Gogo::check_types_in_block(Block* block)
+{
+ Check_types_traverse traverse(this);
+ block->traverse(&traverse);
+}
+
+// A traversal class used to find a single shortcut operator within an
+// expression.
+
+class Find_shortcut : public Traverse
+{
+ public:
+ Find_shortcut()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ found_(NULL)
+ { }
+
+ // A pointer to the expression which was found, or NULL if none was
+ // found.
+ Expression**
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ Expression** found_;
+};
+
+// Find a shortcut expression.
+
+int
+Find_shortcut::expression(Expression** pexpr)
+{
+ Expression* expr = *pexpr;
+ Binary_expression* be = expr->binary_expression();
+ if (be == NULL)
+ return TRAVERSE_CONTINUE;
+ Operator op = be->op();
+ if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
+ return TRAVERSE_CONTINUE;
+ gcc_assert(this->found_ == NULL);
+ this->found_ = pexpr;
+ return TRAVERSE_EXIT;
+}
+
+// A traversal class used to turn shortcut operators into explicit if
+// statements.
+
+class Shortcuts : public Traverse
+{
+ public:
+ Shortcuts(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_statements),
+ gogo_(gogo)
+ { }
+
+ protected:
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+
+ private:
+ // Convert a shortcut operator.
+ Statement*
+ convert_shortcut(Block* enclosing, Expression** pshortcut);
+
+ // The IR.
+ Gogo* gogo_;
+};
+
+// Remove shortcut operators in a single statement.
+
+int
+Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+
+ // If S is a variable declaration, then ordinary traversal won't
+ // do anything. We want to explicitly traverse the
+ // initialization expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_shortcut);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ init->traverse(&init, &find_shortcut);
+ }
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(block, pshortcut);
+ block->insert_statement_before(*pindex, snew);
+ ++*pindex;
+
+ if (pshortcut == &init)
+ vds->var()->var_value()->set_init(init);
+ }
+}
+
+// Remove shortcut operators in the initializer of a global variable.
+
+int
+Shortcuts::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ while (true)
+ {
+ Find_shortcut find_shortcut;
+ init->traverse(&init, &find_shortcut);
+ Expression** pshortcut = find_shortcut.found();
+ if (pshortcut == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Statement* snew = this->convert_shortcut(NULL, pshortcut);
+ var->add_preinit_statement(this->gogo_, snew);
+ if (pshortcut == &init)
+ var->set_init(init);
+ }
+}
+
+// Given an expression which uses a shortcut operator, return a
+// statement which implements it, and update *PSHORTCUT accordingly.
+
+Statement*
+Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
+{
+ Binary_expression* shortcut = (*pshortcut)->binary_expression();
+ Expression* left = shortcut->left();
+ Expression* right = shortcut->right();
+ source_location loc = shortcut->location();
+
+ Block* retblock = new Block(enclosing, loc);
+ retblock->set_end_location(loc);
+
+ Temporary_statement* ts = Statement::make_temporary(Type::lookup_bool_type(),
+ left, loc);
+ retblock->add_statement(ts);
+
+ Block* block = new Block(retblock, loc);
+ block->set_end_location(loc);
+ Expression* tmpref = Expression::make_temporary_reference(ts, loc);
+ Statement* assign = Statement::make_assignment(tmpref, right, loc);
+ block->add_statement(assign);
+
+ Expression* cond = Expression::make_temporary_reference(ts, loc);
+ if (shortcut->binary_expression()->op() == OPERATOR_OROR)
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+
+ Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
+ loc);
+ retblock->add_statement(if_statement);
+
+ *pshortcut = Expression::make_temporary_reference(ts, loc);
+
+ delete shortcut;
+
+ // Now convert any shortcut operators in LEFT and RIGHT.
+ Shortcuts shortcuts(this->gogo_);
+ retblock->traverse(&shortcuts);
+
+ return Statement::make_block_statement(retblock, loc);
+}
+
+// Turn shortcut operators into explicit if statements. Doing this
+// considerably simplifies the order of evaluation rules.
+
+void
+Gogo::remove_shortcuts()
+{
+ Shortcuts shortcuts(this);
+ this->traverse(&shortcuts);
+}
+
+// A traversal class which finds all the expressions which must be
+// evaluated in order within a statement or larger expression. This
+// is used to implement the rules about order of evaluation.
+
+class Find_eval_ordering : public Traverse
+{
+ private:
+ typedef std::vector<Expression**> Expression_pointers;
+
+ public:
+ Find_eval_ordering()
+ : Traverse(traverse_blocks
+ | traverse_statements
+ | traverse_expressions),
+ exprs_()
+ { }
+
+ size_t
+ size() const
+ { return this->exprs_.size(); }
+
+ typedef Expression_pointers::const_iterator const_iterator;
+
+ const_iterator
+ begin() const
+ { return this->exprs_.begin(); }
+
+ const_iterator
+ end() const
+ { return this->exprs_.end(); }
+
+ protected:
+ int
+ block(Block*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ statement(Block*, size_t*, Statement*)
+ { return TRAVERSE_SKIP_COMPONENTS; }
+
+ int
+ expression(Expression**);
+
+ private:
+ // A list of pointers to expressions with side-effects.
+ Expression_pointers exprs_;
+};
+
+// If an expression must be evaluated in order, put it on the list.
+
+int
+Find_eval_ordering::expression(Expression** expression_pointer)
+{
+ // We have to look at subexpressions before this one.
+ if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*expression_pointer)->must_eval_in_order())
+ this->exprs_.push_back(expression_pointer);
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// A traversal class for ordering evaluations.
+
+class Order_eval : public Traverse
+{
+ public:
+ Order_eval(Gogo* gogo)
+ : Traverse(traverse_variables
+ | traverse_statements),
+ gogo_(gogo)
+ { }
+
+ int
+ variable(Named_object*);
+
+ int
+ statement(Block*, size_t*, Statement*);
+
+ private:
+ // The IR.
+ Gogo* gogo_;
+};
+
+// Implement the order of evaluation rules for a statement.
+
+int
+Order_eval::statement(Block* block, size_t* pindex, Statement* s)
+{
+ // FIXME: This approach doesn't work for switch statements, because
+ // we add the new statements before the whole switch when we need to
+ // instead add them just before the switch expression. The right
+ // fix is probably to lower switch statements with nonconstant cases
+ // to a series of conditionals.
+ if (s->switch_statement() != NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+
+ // If S is a variable declaration, then ordinary traversal won't do
+ // anything. We want to explicitly traverse the initialization
+ // expression if there is one.
+ Variable_declaration_statement* vds = s->variable_declaration_statement();
+ Expression* init = NULL;
+ Expression* orig_init = NULL;
+ if (vds == NULL)
+ s->traverse_contents(&find_eval_ordering);
+ else
+ {
+ init = vds->var()->var_value()->init();
+ if (init == NULL)
+ return TRAVERSE_CONTINUE;
+ orig_init = init;
+
+ // It might seem that this could be
+ // init->traverse_subexpressions. Unfortunately that can fail
+ // in a case like
+ // var err os.Error
+ // newvar, err := call(arg())
+ // Here newvar will have an init of call result 0 of
+ // call(arg()). If we only traverse subexpressions, we will
+ // only find arg(), and we won't bother to move anything out.
+ // Then we get to the assignment to err, we will traverse the
+ // whole statement, and this time we will find both call() and
+ // arg(), and so we will move them out. This will cause them to
+ // be put into temporary variables before the assignment to err
+ // but after the declaration of newvar. To avoid that problem,
+ // we traverse the entire expression here.
+ Expression::traverse(&init, &find_eval_ordering);
+ }
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_CONTINUE;
+ }
+
+ bool is_thunk = s->thunk_statement() != NULL;
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+
+ // The last expression in a thunk will be the call passed to go
+ // or defer, which we must not evaluate early.
+ if (is_thunk && p + 1 == find_eval_ordering.end())
+ break;
+
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ block->insert_statement_before(*pindex, ts);
+ ++*pindex;
+
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ if (init != orig_init)
+ vds->var()->var_value()->set_init(init);
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Implement the order of evaluation rules for the initializer of a
+// global variable.
+
+int
+Order_eval::variable(Named_object* no)
+{
+ if (no->is_result_variable())
+ return TRAVERSE_CONTINUE;
+ Variable* var = no->var_value();
+ Expression* init = var->init();
+ if (!var->is_global() || init == NULL)
+ return TRAVERSE_CONTINUE;
+
+ Find_eval_ordering find_eval_ordering;
+ init->traverse_subexpressions(&find_eval_ordering);
+
+ if (find_eval_ordering.size() <= 1)
+ {
+ // If there is only one expression with a side-effect, we can
+ // leave it in place.
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ for (Find_eval_ordering::const_iterator p = find_eval_ordering.begin();
+ p != find_eval_ordering.end();
+ ++p)
+ {
+ Expression** pexpr = *p;
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* ts = Statement::make_temporary(NULL, *pexpr, loc);
+ var->add_preinit_statement(this->gogo_, ts);
+ *pexpr = Expression::make_temporary_reference(ts, loc);
+ }
+
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Use temporary variables to implement the order of evaluation rules.
+
+void
+Gogo::order_evaluations()
+{
+ Order_eval order_eval(this);
+ this->traverse(&order_eval);
+}
+
+// Traversal to convert calls to the predeclared recover function to
+// pass in an argument indicating whether it can recover from a panic
+// or not.
+
+class Convert_recover : public Traverse
+{
+ public:
+ Convert_recover(Named_object* arg)
+ : Traverse(traverse_expressions),
+ arg_(arg)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The argument to pass to the function.
+ Named_object* arg_;
+};
+
+// Convert calls to recover.
+
+int
+Convert_recover::expression(Expression** pp)
+{
+ Call_expression* ce = (*pp)->call_expression();
+ if (ce != NULL && ce->is_recover_call())
+ ce->set_recover_arg(Expression::make_var_reference(this->arg_,
+ ce->location()));
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal for build_recover_thunks.
+
+class Build_recover_thunks : public Traverse
+{
+ public:
+ Build_recover_thunks(Gogo* gogo)
+ : Traverse(traverse_functions),
+ gogo_(gogo)
+ { }
+
+ int
+ function(Named_object*);
+
+ private:
+ Expression*
+ can_recover_arg(source_location);
+
+ // General IR.
+ Gogo* gogo_;
+};
+
+// If this function calls recover, turn it into a thunk.
+
+int
+Build_recover_thunks::function(Named_object* orig_no)
+{
+ Function* orig_func = orig_no->func_value();
+ if (!orig_func->calls_recover()
+ || orig_func->is_recover_thunk()
+ || orig_func->has_recover_thunk())
+ return TRAVERSE_CONTINUE;
+
+ Gogo* gogo = this->gogo_;
+ source_location location = orig_func->location();
+
+ static int count;
+ char buf[50];
+
+ Function_type* orig_fntype = orig_func->type();
+ Typed_identifier_list* new_params = new Typed_identifier_list();
+ std::string receiver_name;
+ if (orig_fntype->is_method())
+ {
+ const Typed_identifier* receiver = orig_fntype->receiver();
+ snprintf(buf, sizeof buf, "rt.%u", count);
+ ++count;
+ receiver_name = buf;
+ new_params->push_back(Typed_identifier(receiver_name, receiver->type(),
+ receiver->location()));
+ }
+ const Typed_identifier_list* orig_params = orig_fntype->parameters();
+ if (orig_params != NULL && !orig_params->empty())
+ {
+ for (Typed_identifier_list::const_iterator p = orig_params->begin();
+ p != orig_params->end();
+ ++p)
+ {
+ snprintf(buf, sizeof buf, "pt.%u", count);
+ ++count;
+ new_params->push_back(Typed_identifier(buf, p->type(),
+ p->location()));
+ }
+ }
+ snprintf(buf, sizeof buf, "pr.%u", count);
+ ++count;
+ std::string can_recover_name = buf;
+ new_params->push_back(Typed_identifier(can_recover_name,
+ Type::lookup_bool_type(),
+ orig_fntype->location()));
+
+ const Typed_identifier_list* orig_results = orig_fntype->results();
+ Typed_identifier_list* new_results;
+ if (orig_results == NULL || orig_results->empty())
+ new_results = NULL;
+ else
+ {
+ new_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = orig_results->begin();
+ p != orig_results->end();
+ ++p)
+ new_results->push_back(Typed_identifier("", p->type(), p->location()));
+ }
+
+ Function_type *new_fntype = Type::make_function_type(NULL, new_params,
+ new_results,
+ orig_fntype->location());
+ if (orig_fntype->is_varargs())
+ new_fntype->set_is_varargs();
+
+ std::string name = orig_no->name() + "$recover";
+ Named_object *new_no = gogo->start_function(name, new_fntype, false,
+ location);
+ Function *new_func = new_no->func_value();
+ if (orig_func->enclosing() != NULL)
+ new_func->set_enclosing(orig_func->enclosing());
+
+ // We build the code for the original function attached to the new
+ // function, and then swap the original and new function bodies.
+ // This means that existing references to the original function will
+ // then refer to the new function. That makes this code a little
+ // confusing, in that the reference to NEW_NO really refers to the
+ // other function, not the one we are building.
+
+ Expression* closure = NULL;
+ if (orig_func->needs_closure())
+ {
+ Named_object* orig_closure_no = orig_func->closure_var();
+ Variable* orig_closure_var = orig_closure_no->var_value();
+ Variable* new_var = new Variable(orig_closure_var->type(), NULL, false,
+ true, false, location);
+ snprintf(buf, sizeof buf, "closure.%u", count);
+ ++count;
+ Named_object* new_closure_no = Named_object::make_variable(buf, NULL,
+ new_var);
+ new_func->set_closure_var(new_closure_no);
+ closure = Expression::make_var_reference(new_closure_no, location);
+ }
+
+ Expression* fn = Expression::make_func_reference(new_no, closure, location);
+
+ Expression_list* args = new Expression_list();
+ if (new_params != NULL)
+ {
+ // Note that we skip the last parameter, which is the boolean
+ // indicating whether recover can succed.
+ for (Typed_identifier_list::const_iterator p = new_params->begin();
+ p + 1 != new_params->end();
+ ++p)
+ {
+ Named_object* p_no = gogo->lookup(p->name(), NULL);
+ gcc_assert(p_no != NULL
+ && p_no->is_variable()
+ && p_no->var_value()->is_parameter());
+ args->push_back(Expression::make_var_reference(p_no, location));
+ }
+ }
+ args->push_back(this->can_recover_arg(location));
+
+ Call_expression* call = Expression::make_call(fn, args, false, location);
+
+ Statement* s;
+ if (orig_fntype->results() == NULL || orig_fntype->results()->empty())
+ s = Statement::make_statement(call);
+ else
+ {
+ Expression_list* vals = new Expression_list();
+ size_t rc = orig_fntype->results()->size();
+ if (rc == 1)
+ vals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < rc; ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ }
+ s = Statement::make_return_statement(new_func->type()->results(),
+ vals, location);
+ }
+ s->determine_types();
+ gogo->add_statement(s);
+
+ gogo->finish_function(location);
+
+ // Swap the function bodies and types.
+ new_func->swap_for_recover(orig_func);
+ orig_func->set_is_recover_thunk();
+ new_func->set_calls_recover();
+ new_func->set_has_recover_thunk();
+
+ Bindings* orig_bindings = orig_func->block()->bindings();
+ Bindings* new_bindings = new_func->block()->bindings();
+ if (orig_fntype->is_method())
+ {
+ // We changed the receiver to be a regular parameter. We have
+ // to update the binding accordingly in both functions.
+ Named_object* orig_rec_no = orig_bindings->lookup_local(receiver_name);
+ gcc_assert(orig_rec_no != NULL
+ && orig_rec_no->is_variable()
+ && !orig_rec_no->var_value()->is_receiver());
+ orig_rec_no->var_value()->set_is_receiver();
+
+ const std::string& new_receiver_name(orig_fntype->receiver()->name());
+ Named_object* new_rec_no = new_bindings->lookup_local(new_receiver_name);
+ if (new_rec_no == NULL)
+ gcc_assert(saw_errors());
+ else
+ {
+ gcc_assert(new_rec_no->is_variable()
+ && new_rec_no->var_value()->is_receiver());
+ new_rec_no->var_value()->set_is_not_receiver();
+ }
+ }
+
+ // Because we flipped blocks but not types, the can_recover
+ // parameter appears in the (now) old bindings as a parameter.
+ // Change it to a local variable, whereupon it will be discarded.
+ Named_object* can_recover_no = orig_bindings->lookup_local(can_recover_name);
+ gcc_assert(can_recover_no != NULL
+ && can_recover_no->is_variable()
+ && can_recover_no->var_value()->is_parameter());
+ orig_bindings->remove_binding(can_recover_no);
+
+ // Add the can_recover argument to the (now) new bindings, and
+ // attach it to any recover statements.
+ Variable* can_recover_var = new Variable(Type::lookup_bool_type(), NULL,
+ false, true, false, location);
+ can_recover_no = new_bindings->add_variable(can_recover_name, NULL,
+ can_recover_var);
+ Convert_recover convert_recover(can_recover_no);
+ new_func->traverse(&convert_recover);
+
+ // Update the function pointers in any named results.
+ new_func->update_named_result_variables();
+ orig_func->update_named_result_variables();
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the expression to pass for the .can_recover parameter to the
+// new function. This indicates whether a call to recover may return
+// non-nil. The expression is
+// __go_can_recover(__builtin_return_address()).
+
+Expression*
+Build_recover_thunks::can_recover_arg(source_location location)
+{
+ static Named_object* builtin_return_address;
+ if (builtin_return_address == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* uint_type = Type::lookup_integer_type("uint");
+ param_types->push_back(Typed_identifier("l", uint_type, bloc));
+
+ Typed_identifier_list* return_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ return_types->push_back(Typed_identifier("", voidptr_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ return_types, bloc);
+ builtin_return_address =
+ Named_object::make_function_declaration("__builtin_return_address",
+ NULL, fntype, bloc);
+ const char* n = "__builtin_return_address";
+ builtin_return_address->func_declaration_value()->set_asm_name(n);
+ }
+
+ static Named_object* can_recover;
+ if (can_recover == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ param_types->push_back(Typed_identifier("a", voidptr_type, bloc));
+ Type* boolean_type = Type::lookup_bool_type();
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", boolean_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ results, bloc);
+ can_recover = Named_object::make_function_declaration("__go_can_recover",
+ NULL, fntype,
+ bloc);
+ can_recover->func_declaration_value()->set_asm_name("__go_can_recover");
+ }
+
+ Expression* fn = Expression::make_func_reference(builtin_return_address,
+ NULL, location);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, location);
+ mpz_clear(zval);
+ Expression_list *args = new Expression_list();
+ args->push_back(zexpr);
+
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ args = new Expression_list();
+ args->push_back(call);
+
+ fn = Expression::make_func_reference(can_recover, NULL, location);
+ return Expression::make_call(fn, args, false, location);
+}
+
+// Build thunks for functions which call recover. We build a new
+// function with an extra parameter, which is whether a call to
+// recover can succeed. We then move the body of this function to
+// that one. We then turn this function into a thunk which calls the
+// new one, passing the value of
+// __go_can_recover(__builtin_return_address()). The function will be
+// marked as not splitting the stack. This will cooperate with the
+// implementation of defer to make recover do the right thing.
+
+void
+Gogo::build_recover_thunks()
+{
+ Build_recover_thunks build_recover_thunks(this);
+ this->traverse(&build_recover_thunks);
+}
+
+// Look for named types to see whether we need to create an interface
+// method table.
+
+class Build_method_tables : public Traverse
+{
+ public:
+ Build_method_tables(Gogo* gogo,
+ const std::vector<Interface_type*>& interfaces)
+ : Traverse(traverse_types),
+ gogo_(gogo), interfaces_(interfaces)
+ { }
+
+ int
+ type(Type*);
+
+ private:
+ // The IR.
+ Gogo* gogo_;
+ // A list of locally defined interfaces which have hidden methods.
+ const std::vector<Interface_type*>& interfaces_;
+};
+
+// Build all required interface method tables for types. We need to
+// ensure that we have an interface method table for every interface
+// which has a hidden method, for every named type which implements
+// that interface. Normally we can just build interface method tables
+// as we need them. However, in some cases we can require an
+// interface method table for an interface defined in a different
+// package for a type defined in that package. If that interface and
+// type both use a hidden method, that is OK. However, we will not be
+// able to build that interface method table when we need it, because
+// the type's hidden method will be static. So we have to build it
+// here, and just refer it from other packages as needed.
+
+void
+Gogo::build_interface_method_tables()
+{
+ std::vector<Interface_type*> hidden_interfaces;
+ hidden_interfaces.reserve(this->interface_types_.size());
+ for (std::vector<Interface_type*>::const_iterator pi =
+ this->interface_types_.begin();
+ pi != this->interface_types_.end();
+ ++pi)
+ {
+ const Typed_identifier_list* methods = (*pi)->methods();
+ if (methods == NULL)
+ continue;
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ if (Gogo::is_hidden_name(pm->name()))
+ {
+ hidden_interfaces.push_back(*pi);
+ break;
+ }
+ }
+ }
+
+ if (!hidden_interfaces.empty())
+ {
+ // Now traverse the tree looking for all named types.
+ Build_method_tables bmt(this, hidden_interfaces);
+ this->traverse(&bmt);
+ }
+
+ // We no longer need the list of interfaces.
+
+ this->interface_types_.clear();
+}
+
+// This is called for each type. For a named type, for each of the
+// interfaces with hidden methods that it implements, create the
+// method table.
+
+int
+Build_method_tables::type(Type* type)
+{
+ Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ for (std::vector<Interface_type*>::const_iterator p =
+ this->interfaces_.begin();
+ p != this->interfaces_.end();
+ ++p)
+ {
+ // We ask whether a pointer to the named type implements the
+ // interface, because a pointer can implement more methods
+ // than a value.
+ if ((*p)->implements_interface(Type::make_pointer_type(nt), NULL))
+ {
+ nt->interface_method_table(this->gogo_, *p, false);
+ nt->interface_method_table(this->gogo_, *p, true);
+ }
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Traversal class used to check for return statements.
+
+class Check_return_statements_traverse : public Traverse
+{
+ public:
+ Check_return_statements_traverse()
+ : Traverse(traverse_functions)
+ { }
+
+ int
+ function(Named_object*);
+};
+
+// Check that a function has a return statement if it needs one.
+
+int
+Check_return_statements_traverse::function(Named_object* no)
+{
+ Function* func = no->func_value();
+ const Function_type* fntype = func->type();
+ const Typed_identifier_list* results = fntype->results();
+
+ // We only need a return statement if there is a return value.
+ if (results == NULL || results->empty())
+ return TRAVERSE_CONTINUE;
+
+ if (func->block()->may_fall_through())
+ error_at(func->location(), "control reaches end of non-void function");
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Check return statements.
+
+void
+Gogo::check_return_statements()
+{
+ Check_return_statements_traverse traverse;
+ this->traverse(&traverse);
+}
+
+// Get the unique prefix to use before all exported symbols. This
+// must be unique across the entire link.
+
+const std::string&
+Gogo::unique_prefix() const
+{
+ gcc_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+}
+
+// Set the unique prefix to use before all exported symbols. This
+// comes from the command line option -fgo-prefix=XXX.
+
+void
+Gogo::set_unique_prefix(const std::string& arg)
+{
+ gcc_assert(this->unique_prefix_.empty());
+ this->unique_prefix_ = arg;
+ this->unique_prefix_specified_ = true;
+}
+
+// Work out the package priority. It is one more than the maximum
+// priority of an imported package.
+
+int
+Gogo::package_priority() const
+{
+ int priority = 0;
+ for (Packages::const_iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ if (p->second->priority() > priority)
+ priority = p->second->priority();
+ return priority + 1;
+}
+
+// Export identifiers as requested.
+
+void
+Gogo::do_exports()
+{
+ // For now we always stream to a section. Later we may want to
+ // support streaming to a separate file.
+ Stream_to_section stream;
+
+ Export exp(&stream);
+ exp.register_builtin_types(this);
+ exp.export_globals(this->package_name(),
+ this->unique_prefix(),
+ this->package_priority(),
+ (this->need_init_fn_ && !this->is_main_package()
+ ? this->get_init_fn_name()
+ : ""),
+ this->imported_init_fns_,
+ this->package_->bindings());
+}
+
+// Find the blocks in order to convert named types defined in blocks.
+
+class Convert_named_types : public Traverse
+{
+ public:
+ Convert_named_types(Gogo* gogo)
+ : Traverse(traverse_blocks),
+ gogo_(gogo)
+ { }
+
+ protected:
+ int
+ block(Block* block);
+
+ private:
+ Gogo* gogo_;
+};
+
+int
+Convert_named_types::block(Block* block)
+{
+ this->gogo_->convert_named_types_in_bindings(block->bindings());
+ return TRAVERSE_CONTINUE;
+}
+
+// Convert all named types to the backend representation. Since named
+// types can refer to other types, this needs to be done in the right
+// sequence, which is handled by Named_type::convert. Here we arrange
+// to call that for each named type.
+
+void
+Gogo::convert_named_types()
+{
+ this->convert_named_types_in_bindings(this->globals_);
+ for (Packages::iterator p = this->packages_.begin();
+ p != this->packages_.end();
+ ++p)
+ {
+ Package* package = p->second;
+ this->convert_named_types_in_bindings(package->bindings());
+ }
+
+ Convert_named_types cnt(this);
+ this->traverse(&cnt);
+
+ // Make all the builtin named types used for type descriptors, and
+ // then convert them. They will only be written out if they are
+ // needed.
+ Type::make_type_descriptor_type();
+ Type::make_type_descriptor_ptr_type();
+ Function_type::make_function_type_descriptor_type();
+ Pointer_type::make_pointer_type_descriptor_type();
+ Struct_type::make_struct_type_descriptor_type();
+ Array_type::make_array_type_descriptor_type();
+ Array_type::make_slice_type_descriptor_type();
+ Map_type::make_map_type_descriptor_type();
+ Channel_type::make_chan_type_descriptor_type();
+ Interface_type::make_interface_type_descriptor_type();
+ Type::convert_builtin_named_types(this);
+
+ this->named_types_are_converted_ = true;
+}
+
+// Convert all names types in a set of bindings.
+
+void
+Gogo::convert_named_types_in_bindings(Bindings* bindings)
+{
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_type())
+ (*p)->type_value()->convert(this);
+ }
+}
+
+// Class Function.
+
+Function::Function(Function_type* type, Function* enclosing, Block* block,
+ source_location location)
+ : type_(type), enclosing_(enclosing), named_results_(NULL),
+ closure_var_(NULL), block_(block), location_(location), fndecl_(NULL),
+ defer_stack_(NULL), calls_recover_(false), is_recover_thunk_(false),
+ has_recover_thunk_(false)
+{
+}
+
+// Create the named result variables.
+
+void
+Function::create_named_result_variables(Gogo* gogo)
+{
+ const Typed_identifier_list* results = this->type_->results();
+ if (results == NULL
+ || results->empty()
+ || results->front().name().empty())
+ return;
+
+ this->named_results_ = new Named_results();
+ this->named_results_->reserve(results->size());
+
+ Block* block = this->block_;
+ int index = 0;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p, ++index)
+ {
+ std::string name = p->name();
+ if (Gogo::is_sink_name(name))
+ {
+ static int unnamed_result_counter;
+ char buf[100];
+ snprintf(buf, sizeof buf, "_$%d", unnamed_result_counter);
+ ++unnamed_result_counter;
+ name = gogo->pack_hidden_name(buf, false);
+ }
+ Result_variable* result = new Result_variable(p->type(), this, index);
+ Named_object* no = block->bindings()->add_result_variable(name, result);
+ if (no->is_result_variable())
+ this->named_results_->push_back(no);
+ }
+}
+
+// Update the named result variables when cloning a function which
+// calls recover.
+
+void
+Function::update_named_result_variables()
+{
+ if (this->named_results_ == NULL)
+ return;
+
+ for (Named_results::iterator p = this->named_results_->begin();
+ p != this->named_results_->end();
+ ++p)
+ (*p)->result_var_value()->set_function(this);
+}
+
+// Return the closure variable, creating it if necessary.
+
+Named_object*
+Function::closure_var()
+{
+ if (this->closure_var_ == NULL)
+ {
+ // We don't know the type of the variable yet. We add fields as
+ // we find them.
+ source_location loc = this->type_->location();
+ Struct_field_list* sfl = new Struct_field_list;
+ Type* struct_type = Type::make_struct_type(sfl, loc);
+ Variable* var = new Variable(Type::make_pointer_type(struct_type),
+ NULL, false, true, false, loc);
+ this->closure_var_ = Named_object::make_variable("closure", NULL, var);
+ // Note that the new variable is not in any binding contour.
+ }
+ return this->closure_var_;
+}
+
+// Set the type of the closure variable.
+
+void
+Function::set_closure_type()
+{
+ if (this->closure_var_ == NULL)
+ return;
+ Named_object* closure = this->closure_var_;
+ Struct_type* st = closure->var_value()->type()->deref()->struct_type();
+ unsigned int index = 0;
+ for (Closure_fields::const_iterator p = this->closure_fields_.begin();
+ p != this->closure_fields_.end();
+ ++p, ++index)
+ {
+ Named_object* no = p->first;
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u", index);
+ std::string n = no->name() + buf;
+ Type* var_type;
+ if (no->is_variable())
+ var_type = no->var_value()->type();
+ else
+ var_type = no->result_var_value()->type();
+ Type* field_type = Type::make_pointer_type(var_type);
+ st->push_field(Struct_field(Typed_identifier(n, field_type, p->second)));
+ }
+}
+
+// Return whether this function is a method.
+
+bool
+Function::is_method() const
+{
+ return this->type_->is_method();
+}
+
+// Add a label definition.
+
+Label*
+Function::add_label_definition(const std::string& label_name,
+ source_location location)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (ins.second)
+ {
+ // This is a new label.
+ Label* label = new Label(label_name);
+ label->define(location);
+ ins.first->second = label;
+ return label;
+ }
+ else
+ {
+ // The label was already in the hash table.
+ Label* label = ins.first->second;
+ if (!label->is_defined())
+ {
+ label->define(location);
+ return label;
+ }
+ else
+ {
+ error_at(location, "redefinition of label %qs",
+ Gogo::message_name(label_name).c_str());
+ inform(label->location(), "previous definition of %qs was here",
+ Gogo::message_name(label_name).c_str());
+ return new Label(label_name);
+ }
+ }
+}
+
+// Add a reference to a label.
+
+Label*
+Function::add_label_reference(const std::string& label_name)
+{
+ Label* lnull = NULL;
+ std::pair<Labels::iterator, bool> ins =
+ this->labels_.insert(std::make_pair(label_name, lnull));
+ if (!ins.second)
+ {
+ // The label was already in the hash table.
+ return ins.first->second;
+ }
+ else
+ {
+ gcc_assert(ins.first->second == NULL);
+ Label* label = new Label(label_name);
+ ins.first->second = label;
+ return label;
+ }
+}
+
+// Swap one function with another. This is used when building the
+// thunk we use to call a function which calls recover. It may not
+// work for any other case.
+
+void
+Function::swap_for_recover(Function *x)
+{
+ gcc_assert(this->enclosing_ == x->enclosing_);
+ std::swap(this->named_results_, x->named_results_);
+ std::swap(this->closure_var_, x->closure_var_);
+ std::swap(this->block_, x->block_);
+ gcc_assert(this->location_ == x->location_);
+ gcc_assert(this->fndecl_ == NULL && x->fndecl_ == NULL);
+ gcc_assert(this->defer_stack_ == NULL && x->defer_stack_ == NULL);
+}
+
+// Traverse the tree.
+
+int
+Function::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask
+ & (Traverse::traverse_types | Traverse::traverse_expressions))
+ != 0)
+ {
+ if (Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ // FIXME: We should check traverse_functions here if nested
+ // functions are stored in block bindings.
+ if (this->block_ != NULL
+ && (traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (this->block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Function::determine_types()
+{
+ if (this->block_ != NULL)
+ this->block_->determine_types();
+}
+
+// Export the function.
+
+void
+Function::export_func(Export* exp, const std::string& name) const
+{
+ Function::export_func_with_type(exp, name, this->type_);
+}
+
+// Export a function with a type.
+
+void
+Function::export_func_with_type(Export* exp, const std::string& name,
+ const Function_type* fntype)
+{
+ exp->write_c_string("func ");
+
+ if (fntype->is_method())
+ {
+ exp->write_c_string("(");
+ exp->write_type(fntype->receiver()->type());
+ exp->write_c_string(") ");
+ }
+
+ exp->write_string(name);
+
+ exp->write_c_string(" (");
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = parameters->begin();
+ p != parameters->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != parameters->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ if (results->size() == 1)
+ {
+ exp->write_c_string(" ");
+ exp->write_type(results->begin()->type());
+ }
+ else
+ {
+ exp->write_c_string(" (");
+ bool first = true;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+ exp->write_c_string(";\n");
+}
+
+// Import a function.
+
+void
+Function::import_func(Import* imp, std::string* pname,
+ Typed_identifier** preceiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults,
+ bool* is_varargs)
+{
+ imp->require_c_string("func ");
+
+ *preceiver = NULL;
+ if (imp->peek_char() == '(')
+ {
+ imp->require_c_string("(");
+ Type* rtype = imp->read_type();
+ *preceiver = new Typed_identifier(Import::import_marker, rtype,
+ imp->location());
+ imp->require_c_string(") ");
+ }
+
+ *pname = imp->read_identifier();
+
+ Typed_identifier_list* parameters;
+ *is_varargs = false;
+ imp->require_c_string(" (");
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ *is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (*is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!*is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+ *pparameters = parameters;
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list();
+ imp->require_c_string(" ");
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->require_c_string("(");
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+ imp->require_c_string(";\n");
+ *presults = results;
+}
+
+// Class Block.
+
+Block::Block(Block* enclosing, source_location location)
+ : enclosing_(enclosing), statements_(),
+ bindings_(new Bindings(enclosing == NULL
+ ? NULL
+ : enclosing->bindings())),
+ start_location_(location),
+ end_location_(UNKNOWN_LOCATION)
+{
+}
+
+// Add a statement to a block.
+
+void
+Block::add_statement(Statement* statement)
+{
+ this->statements_.push_back(statement);
+}
+
+// Add a statement to the front of a block. This is slow but is only
+// used for reference counts of parameters.
+
+void
+Block::add_statement_at_front(Statement* statement)
+{
+ this->statements_.insert(this->statements_.begin(), statement);
+}
+
+// Replace a statement in a block.
+
+void
+Block::replace_statement(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_[index] = s;
+}
+
+// Add a statement before another statement.
+
+void
+Block::insert_statement_before(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index, s);
+}
+
+// Add a statement after another statement.
+
+void
+Block::insert_statement_after(size_t index, Statement* s)
+{
+ gcc_assert(index < this->statements_.size());
+ this->statements_.insert(this->statements_.begin() + index + 1, s);
+}
+
+// Traverse the tree.
+
+int
+Block::traverse(Traverse* traverse)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_blocks) != 0)
+ {
+ int t = traverse->block(this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ switch ((*pb)->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(*pb, false) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = (*pb)->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0)
+ {
+ if ((*pb)->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(*pb) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && ((*pb)->is_result_variable()
+ || (*pb)->var_value()->has_type()))
+ {
+ Type* t = ((*pb)->is_variable()
+ ? (*pb)->var_value()->type()
+ : (*pb)->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((*pb)->is_variable()
+ && ((traverse_mask & Traverse::traverse_expressions) != 0
+ || (traverse_mask & Traverse::traverse_types) != 0))
+ {
+ if ((*pb)->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ // FIXME: Where will nested functions be found?
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse((*pb)->type_value(), traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ case Named_object::NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ default:
+ gcc_unreachable();
+ }
+ }
+ }
+
+ // No point in checking traverse_mask here--if we got here we always
+ // want to walk the statements. The traversal can insert new
+ // statements before or after the current statement. Inserting
+ // statements before the current statement requires updating I via
+ // the pointer; those statements will not be traversed. Any new
+ // statements inserted after the current statement will be traversed
+ // in their turn.
+ for (size_t i = 0; i < this->statements_.size(); ++i)
+ {
+ if (this->statements_[i]->traverse(this, &i, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Work out types for unspecified variables and constants.
+
+void
+Block::determine_types()
+{
+ for (Bindings::const_definitions_iterator pb =
+ this->bindings_->begin_definitions();
+ pb != this->bindings_->end_definitions();
+ ++pb)
+ {
+ if ((*pb)->is_variable())
+ (*pb)->var_value()->determine_type();
+ else if ((*pb)->is_const())
+ (*pb)->const_value()->determine_type();
+ }
+
+ for (std::vector<Statement*>::const_iterator ps = this->statements_.begin();
+ ps != this->statements_.end();
+ ++ps)
+ (*ps)->determine_types();
+}
+
+// Return true if the statements in this block may fall through.
+
+bool
+Block::may_fall_through() const
+{
+ if (this->statements_.empty())
+ return true;
+ return this->statements_.back()->may_fall_through();
+}
+
+// Class Variable.
+
+Variable::Variable(Type* type, Expression* init, bool is_global,
+ bool is_parameter, bool is_receiver,
+ source_location location)
+ : type_(type), init_(init), preinit_(NULL), location_(location),
+ is_global_(is_global), is_parameter_(is_parameter),
+ is_receiver_(is_receiver), is_varargs_parameter_(false),
+ is_address_taken_(false), seen_(false), init_is_lowered_(false),
+ type_from_init_tuple_(false), type_from_range_index_(false),
+ type_from_range_value_(false), type_from_chan_element_(false),
+ is_type_switch_var_(false), determined_type_(false)
+{
+ gcc_assert(type != NULL || init != NULL);
+ gcc_assert(!is_parameter || init == NULL);
+}
+
+// Traverse the initializer expression.
+
+int
+Variable::traverse_expression(Traverse* traverse)
+{
+ if (this->preinit_ != NULL)
+ {
+ if (this->preinit_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->init_ != NULL)
+ {
+ if (Expression::traverse(&this->init_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower the initialization expression after parsing is complete.
+
+void
+Variable::lower_init_expression(Gogo* gogo, Named_object* function)
+{
+ if (this->init_ != NULL && !this->init_is_lowered_)
+ {
+ if (this->seen_)
+ {
+ // We will give an error elsewhere, this is just to prevent
+ // an infinite loop.
+ return;
+ }
+ this->seen_ = true;
+
+ gogo->lower_expression(function, &this->init_);
+
+ this->seen_ = false;
+
+ this->init_is_lowered_ = true;
+ }
+}
+
+// Get the preinit block.
+
+Block*
+Variable::preinit_block(Gogo* gogo)
+{
+ gcc_assert(this->is_global_);
+ if (this->preinit_ == NULL)
+ this->preinit_ = new Block(NULL, this->location());
+
+ // If a global variable has a preinitialization statement, then we
+ // need to have an initialization function.
+ gogo->set_need_init_fn();
+
+ return this->preinit_;
+}
+
+// Add a statement to be run before the initialization expression.
+
+void
+Variable::add_preinit_statement(Gogo* gogo, Statement* s)
+{
+ Block* b = this->preinit_block(gogo);
+ b->add_statement(s);
+ b->set_end_location(s->location());
+}
+
+// In an assignment which sets a variable to a tuple of EXPR, return
+// the type of the first element of the tuple.
+
+Type*
+Variable::type_from_tuple(Expression* expr, bool report_error) const
+{
+ if (expr->map_index_expression() != NULL)
+ {
+ Map_type* mt = expr->map_index_expression()->get_map_type();
+ if (mt == NULL)
+ return Type::make_error_type();
+ return mt->val_type();
+ }
+ else if (expr->receive_expression() != NULL)
+ {
+ Expression* channel = expr->receive_expression()->channel();
+ Type* channel_type = channel->type();
+ if (channel_type->channel_type() == NULL)
+ return Type::make_error_type();
+ return channel_type->channel_type()->element_type();
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid tuple definition");
+ return Type::make_error_type();
+ }
+}
+
+// Given EXPR used in a range clause, return either the index type or
+// the value type of the range, depending upon GET_INDEX_TYPE.
+
+Type*
+Variable::type_from_range(Expression* expr, bool get_index_type,
+ bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->array_type() != NULL
+ || (t->points_to() != NULL
+ && t->points_to()->array_type() != NULL
+ && !t->points_to()->is_open_array_type()))
+ {
+ if (get_index_type)
+ return Type::lookup_integer_type("int");
+ else
+ return t->deref()->array_type()->element_type();
+ }
+ else if (t->is_string_type())
+ return Type::lookup_integer_type("int");
+ else if (t->map_type() != NULL)
+ {
+ if (get_index_type)
+ return t->map_type()->key_type();
+ else
+ return t->map_type()->val_type();
+ }
+ else if (t->channel_type() != NULL)
+ {
+ if (get_index_type)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(),
+ "invalid definition of value variable for channel range");
+ return Type::make_error_type();
+ }
+ }
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "invalid type for range clause");
+ return Type::make_error_type();
+ }
+}
+
+// EXPR should be a channel. Return the channel's element type.
+
+Type*
+Variable::type_from_chan_element(Expression* expr, bool report_error) const
+{
+ Type* t = expr->type();
+ if (t->channel_type() != NULL)
+ return t->channel_type()->element_type();
+ else
+ {
+ if (report_error)
+ error_at(this->location(), "expected channel");
+ return Type::make_error_type();
+ }
+}
+
+// Return the type of the Variable. This may be called before
+// Variable::determine_type is called, which means that we may need to
+// get the type from the initializer. FIXME: If we combine lowering
+// with type determination, then this should be unnecessary.
+
+Type*
+Variable::type()
+{
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. This gets fixed up in determine_type, below.
+ Type* type = this->type_;
+ Expression* init = this->init_;
+ if (this->is_type_switch_var_
+ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ gcc_assert(tge != NULL);
+ init = tge->expr();
+ type = NULL;
+ }
+
+ if (this->seen_)
+ {
+ if (this->type_ == NULL || !this->type_->is_error_type())
+ {
+ error_at(this->location_, "variable initializer refers to itself");
+ this->type_ = Type::make_error_type();
+ }
+ return this->type_;
+ }
+
+ this->seen_ = true;
+
+ if (type != NULL)
+ ;
+ else if (this->type_from_init_tuple_)
+ type = this->type_from_tuple(init, false);
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ type = this->type_from_range(init, this->type_from_range_index_, false);
+ else if (this->type_from_chan_element_)
+ type = this->type_from_chan_element(init, false);
+ else
+ {
+ gcc_assert(init != NULL);
+ type = init->type();
+ gcc_assert(type != NULL);
+
+ // Variables should not have abstract types.
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ type = Type::make_error_type();
+ }
+
+ this->seen_ = false;
+
+ return type;
+}
+
+// Fetch the type from a const pointer, in which case it should have
+// been set already.
+
+Type*
+Variable::type() const
+{
+ gcc_assert(this->type_ != NULL);
+ return this->type_;
+}
+
+// Set the type if necessary.
+
+void
+Variable::determine_type()
+{
+ if (this->determined_type_)
+ return;
+ this->determined_type_ = true;
+
+ if (this->preinit_ != NULL)
+ this->preinit_->determine_types();
+
+ // A variable in a type switch with a nil case will have the wrong
+ // type here. It will have an initializer which is a type guard.
+ // We want to initialize it to the value without the type guard, and
+ // use the type of that value as well.
+ if (this->is_type_switch_var_ && this->type_->is_nil_constant_as_type())
+ {
+ Type_guard_expression* tge = this->init_->type_guard_expression();
+ gcc_assert(tge != NULL);
+ this->type_ = NULL;
+ this->init_ = tge->expr();
+ }
+
+ if (this->init_ == NULL)
+ gcc_assert(this->type_ != NULL && !this->type_->is_abstract());
+ else if (this->type_from_init_tuple_)
+ {
+ Expression *init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_tuple(init, true);
+ this->init_ = NULL;
+ }
+ else if (this->type_from_range_index_ || this->type_from_range_value_)
+ {
+ Expression* init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_range(init, this->type_from_range_index_,
+ true);
+ this->init_ = NULL;
+ }
+ else if (this->type_from_chan_element_)
+ {
+ Expression* init = this->init_;
+ init->determine_type_no_context();
+ this->type_ = this->type_from_chan_element(init, true);
+ this->init_ = NULL;
+ }
+ else
+ {
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ if (this->type_ == NULL)
+ {
+ Type* type = this->init_->type();
+ gcc_assert(type != NULL);
+ if (type->is_abstract())
+ type = type->make_non_abstract_type();
+
+ if (type->is_void_type())
+ {
+ error_at(this->location_, "variable has no type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_nil_type())
+ {
+ error_at(this->location_, "variable defined to nil type");
+ type = Type::make_error_type();
+ }
+ else if (type->is_call_multiple_result_type())
+ {
+ error_at(this->location_,
+ "single variable set to multiple value function call");
+ type = Type::make_error_type();
+ }
+
+ this->type_ = type;
+ }
+ }
+}
+
+// Export the variable
+
+void
+Variable::export_var(Export* exp, const std::string& name) const
+{
+ gcc_assert(this->is_global_);
+ exp->write_c_string("var ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ exp->write_type(this->type());
+ exp->write_c_string(";\n");
+}
+
+// Import a variable.
+
+void
+Variable::import_var(Import* imp, std::string* pname, Type** ptype)
+{
+ imp->require_c_string("var ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ *ptype = imp->read_type();
+ imp->require_c_string(";\n");
+}
+
+// Class Named_constant.
+
+// Traverse the initializer expression.
+
+int
+Named_constant::traverse_expression(Traverse* traverse)
+{
+ return Expression::traverse(&this->expr_, traverse);
+}
+
+// Determine the type of the constant.
+
+void
+Named_constant::determine_type()
+{
+ if (this->type_ != NULL)
+ {
+ Type_context context(this->type_, false);
+ this->expr_->determine_type(&context);
+ }
+ else
+ {
+ // A constant may have an abstract type.
+ Type_context context(NULL, true);
+ this->expr_->determine_type(&context);
+ this->type_ = this->expr_->type();
+ gcc_assert(this->type_ != NULL);
+ }
+}
+
+// Indicate that we found and reported an error for this constant.
+
+void
+Named_constant::set_error()
+{
+ this->type_ = Type::make_error_type();
+ this->expr_ = Expression::make_error(this->location_);
+}
+
+// Export a constant.
+
+void
+Named_constant::export_const(Export* exp, const std::string& name) const
+{
+ exp->write_c_string("const ");
+ exp->write_string(name);
+ exp->write_c_string(" ");
+ if (!this->type_->is_abstract())
+ {
+ exp->write_type(this->type_);
+ exp->write_c_string(" ");
+ }
+ exp->write_c_string("= ");
+ this->expr()->export_expression(exp);
+ exp->write_c_string(";\n");
+}
+
+// Import a constant.
+
+void
+Named_constant::import_const(Import* imp, std::string* pname, Type** ptype,
+ Expression** pexpr)
+{
+ imp->require_c_string("const ");
+ *pname = imp->read_identifier();
+ imp->require_c_string(" ");
+ if (imp->peek_char() == '=')
+ *ptype = NULL;
+ else
+ {
+ *ptype = imp->read_type();
+ imp->require_c_string(" ");
+ }
+ imp->require_c_string("= ");
+ *pexpr = Expression::import_expression(imp);
+ imp->require_c_string(";\n");
+}
+
+// Add a method.
+
+Named_object*
+Type_declaration::add_method(const std::string& name, Function* function)
+{
+ Named_object* ret = Named_object::make_function(name, NULL, function);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Add a method declaration.
+
+Named_object*
+Type_declaration::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* ret = Named_object::make_function_declaration(name, NULL, type,
+ location);
+ this->methods_.push_back(ret);
+ return ret;
+}
+
+// Return whether any methods ere defined.
+
+bool
+Type_declaration::has_methods() const
+{
+ return !this->methods_.empty();
+}
+
+// Define methods for the real type.
+
+void
+Type_declaration::define_methods(Named_type* nt)
+{
+ for (Methods::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ nt->add_existing_method(*p);
+}
+
+// We are using the type. Return true if we should issue a warning.
+
+bool
+Type_declaration::using_type()
+{
+ bool ret = !this->issued_warning_;
+ this->issued_warning_ = true;
+ return ret;
+}
+
+// Class Unknown_name.
+
+// Set the real named object.
+
+void
+Unknown_name::set_real_named_object(Named_object* no)
+{
+ gcc_assert(this->real_named_object_ == NULL);
+ gcc_assert(!no->is_unknown());
+ this->real_named_object_ = no;
+}
+
+// Class Named_object.
+
+Named_object::Named_object(const std::string& name,
+ const Package* package,
+ Classification classification)
+ : name_(name), package_(package), classification_(classification),
+ tree_(NULL)
+{
+ if (Gogo::is_sink_name(name))
+ gcc_assert(classification == NAMED_OBJECT_SINK);
+}
+
+// Make an unknown name. This is used by the parser. The name must
+// be resolved later. Unknown names are only added in the current
+// package.
+
+Named_object*
+Named_object::make_unknown_name(const std::string& name,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_UNKNOWN);
+ Unknown_name* value = new Unknown_name(location);
+ named_object->u_.unknown_value = value;
+ return named_object;
+}
+
+// Make a constant.
+
+Named_object*
+Named_object::make_constant(const Typed_identifier& tid,
+ const Package* package, Expression* expr,
+ int iota_value)
+{
+ Named_object* named_object = new Named_object(tid.name(), package,
+ NAMED_OBJECT_CONST);
+ Named_constant* named_constant = new Named_constant(tid.type(), expr,
+ iota_value,
+ tid.location());
+ named_object->u_.const_value = named_constant;
+ return named_object;
+}
+
+// Make a named type.
+
+Named_object*
+Named_object::make_type(const std::string& name, const Package* package,
+ Type* type, source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE);
+ Named_type* named_type = Type::make_named_type(named_object, type, location);
+ named_object->u_.type_value = named_type;
+ return named_object;
+}
+
+// Make a type declaration.
+
+Named_object*
+Named_object::make_type_declaration(const std::string& name,
+ const Package* package,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* type_declaration = new Type_declaration(location);
+ named_object->u_.type_declaration = type_declaration;
+ return named_object;
+}
+
+// Make a variable.
+
+Named_object*
+Named_object::make_variable(const std::string& name, const Package* package,
+ Variable* variable)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_VAR);
+ named_object->u_.var_value = variable;
+ return named_object;
+}
+
+// Make a result variable.
+
+Named_object*
+Named_object::make_result_variable(const std::string& name,
+ Result_variable* result)
+{
+ Named_object* named_object = new Named_object(name, NULL,
+ NAMED_OBJECT_RESULT_VAR);
+ named_object->u_.result_var_value = result;
+ return named_object;
+}
+
+// Make a sink. This is used for the special blank identifier _.
+
+Named_object*
+Named_object::make_sink()
+{
+ return new Named_object("_", NULL, NAMED_OBJECT_SINK);
+}
+
+// Make a named function.
+
+Named_object*
+Named_object::make_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC);
+ named_object->u_.func_value = function;
+ return named_object;
+}
+
+// Make a function declaration.
+
+Named_object*
+Named_object::make_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* fntype,
+ source_location location)
+{
+ Named_object* named_object = new Named_object(name, package,
+ NAMED_OBJECT_FUNC_DECLARATION);
+ Function_declaration *func_decl = new Function_declaration(fntype, location);
+ named_object->u_.func_declaration_value = func_decl;
+ return named_object;
+}
+
+// Make a package.
+
+Named_object*
+Named_object::make_package(const std::string& alias, Package* package)
+{
+ Named_object* named_object = new Named_object(alias, NULL,
+ NAMED_OBJECT_PACKAGE);
+ named_object->u_.package_value = package;
+ return named_object;
+}
+
+// Return the name to use in an error message.
+
+std::string
+Named_object::message_name() const
+{
+ if (this->package_ == NULL)
+ return Gogo::message_name(this->name_);
+ std::string ret = Gogo::message_name(this->package_->name());
+ ret += '.';
+ ret += Gogo::message_name(this->name_);
+ return ret;
+}
+
+// Set the type when a declaration is defined.
+
+void
+Named_object::set_type_value(Named_type* named_type)
+{
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ Type_declaration* td = this->u_.type_declaration;
+ td->define_methods(named_type);
+ Named_object* in_function = td->in_function();
+ if (in_function != NULL)
+ named_type->set_in_function(in_function);
+ delete td;
+ this->classification_ = NAMED_OBJECT_TYPE;
+ this->u_.type_value = named_type;
+}
+
+// Define a function which was previously declared.
+
+void
+Named_object::set_function_value(Function* function)
+{
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ this->classification_ = NAMED_OBJECT_FUNC;
+ // FIXME: We should free the old value.
+ this->u_.func_value = function;
+}
+
+// Declare an unknown object as a type declaration.
+
+void
+Named_object::declare_as_type()
+{
+ gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ Unknown_name* unk = this->u_.unknown_value;
+ this->classification_ = NAMED_OBJECT_TYPE_DECLARATION;
+ this->u_.type_declaration = new Type_declaration(unk->location());
+ delete unk;
+}
+
+// Return the location of a named object.
+
+source_location
+Named_object::location() const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_UNKNOWN:
+ return this->unknown_value()->location();
+
+ case NAMED_OBJECT_CONST:
+ return this->const_value()->location();
+
+ case NAMED_OBJECT_TYPE:
+ return this->type_value()->location();
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ return this->type_declaration_value()->location();
+
+ case NAMED_OBJECT_VAR:
+ return this->var_value()->location();
+
+ case NAMED_OBJECT_RESULT_VAR:
+ return this->result_var_value()->function()->location();
+
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ return this->func_value()->location();
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ return this->func_declaration_value()->location();
+
+ case NAMED_OBJECT_PACKAGE:
+ return this->package_value()->location();
+ }
+}
+
+// Export a named object.
+
+void
+Named_object::export_named_object(Export* exp) const
+{
+ switch (this->classification_)
+ {
+ default:
+ case NAMED_OBJECT_UNINITIALIZED:
+ case NAMED_OBJECT_UNKNOWN:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_CONST:
+ this->const_value()->export_const(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE:
+ this->type_value()->export_named_type(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_TYPE_DECLARATION:
+ error_at(this->type_declaration_value()->location(),
+ "attempt to export %<%s%> which was declared but not defined",
+ this->message_name().c_str());
+ break;
+
+ case NAMED_OBJECT_FUNC_DECLARATION:
+ this->func_declaration_value()->export_func(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_VAR:
+ this->var_value()->export_var(exp, this->name_);
+ break;
+
+ case NAMED_OBJECT_RESULT_VAR:
+ case NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case NAMED_OBJECT_FUNC:
+ this->func_value()->export_func(exp, this->name_);
+ break;
+ }
+}
+
+// Class Bindings.
+
+Bindings::Bindings(Bindings* enclosing)
+ : enclosing_(enclosing), named_objects_(), bindings_()
+{
+}
+
+// Clear imports.
+
+void
+Bindings::clear_file_scope()
+{
+ Contour::iterator p = this->bindings_.begin();
+ while (p != this->bindings_.end())
+ {
+ bool keep;
+ if (p->second->package() != NULL)
+ keep = false;
+ else if (p->second->is_package())
+ keep = false;
+ else if (p->second->is_function()
+ && !p->second->func_value()->type()->is_method()
+ && Gogo::unpack_hidden_name(p->second->name()) == "init")
+ keep = false;
+ else
+ keep = true;
+
+ if (keep)
+ ++p;
+ else
+ p = this->bindings_.erase(p);
+ }
+}
+
+// Look up a symbol.
+
+Named_object*
+Bindings::lookup(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p != this->bindings_.end())
+ return p->second->resolve();
+ else if (this->enclosing_ != NULL)
+ return this->enclosing_->lookup(name);
+ else
+ return NULL;
+}
+
+// Look up a symbol locally.
+
+Named_object*
+Bindings::lookup_local(const std::string& name) const
+{
+ Contour::const_iterator p = this->bindings_.find(name);
+ if (p == this->bindings_.end())
+ return NULL;
+ return p->second;
+}
+
+// Remove an object from a set of bindings. This is used for a
+// special case in thunks for functions which call recover.
+
+void
+Bindings::remove_binding(Named_object* no)
+{
+ Contour::iterator pb = this->bindings_.find(no->name());
+ gcc_assert(pb != this->bindings_.end());
+ this->bindings_.erase(pb);
+ for (std::vector<Named_object*>::iterator pn = this->named_objects_.begin();
+ pn != this->named_objects_.end();
+ ++pn)
+ {
+ if (*pn == no)
+ {
+ this->named_objects_.erase(pn);
+ return;
+ }
+ }
+ gcc_unreachable();
+}
+
+// Add a method to the list of objects. This is not added to the
+// lookup table. This is so that we have a single list of objects
+// declared at the top level, which we walk through when it's time to
+// convert to trees.
+
+void
+Bindings::add_method(Named_object* method)
+{
+ this->named_objects_.push_back(method);
+}
+
+// Add a generic Named_object to a Contour.
+
+Named_object*
+Bindings::add_named_object_to_contour(Contour* contour,
+ Named_object* named_object)
+{
+ gcc_assert(named_object == named_object->resolve());
+ const std::string& name(named_object->name());
+ gcc_assert(!Gogo::is_sink_name(name));
+
+ std::pair<Contour::iterator, bool> ins =
+ contour->insert(std::make_pair(name, named_object));
+ if (!ins.second)
+ {
+ // The name was already there.
+ if (named_object->package() != NULL
+ && ins.first->second->package() == named_object->package()
+ && (ins.first->second->classification()
+ == named_object->classification()))
+ {
+ // This is a second import of the same object.
+ return ins.first->second;
+ }
+ ins.first->second = this->new_definition(ins.first->second,
+ named_object);
+ return ins.first->second;
+ }
+ else
+ {
+ // Don't push declarations on the list. We push them on when
+ // and if we find the definitions. That way we genericize the
+ // functions in order.
+ if (!named_object->is_type_declaration()
+ && !named_object->is_function_declaration()
+ && !named_object->is_unknown())
+ this->named_objects_.push_back(named_object);
+ return named_object;
+ }
+}
+
+// We had an existing named object OLD_OBJECT, and we've seen a new
+// one NEW_OBJECT with the same name. FIXME: This does not free the
+// new object when we don't need it.
+
+Named_object*
+Bindings::new_definition(Named_object* old_object, Named_object* new_object)
+{
+ std::string reason;
+ switch (old_object->classification())
+ {
+ default:
+ case Named_object::NAMED_OBJECT_UNINITIALIZED:
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ {
+ Named_object* real = old_object->unknown_value()->real_named_object();
+ if (real != NULL)
+ return this->new_definition(real, new_object);
+ gcc_assert(!new_object->is_unknown());
+ old_object->unknown_value()->set_real_named_object(new_object);
+ if (!new_object->is_type_declaration()
+ && !new_object->is_function_declaration())
+ this->named_objects_.push_back(new_object);
+ return new_object;
+ }
+
+ case Named_object::NAMED_OBJECT_CONST:
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if (new_object->is_type_declaration())
+ return old_object;
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ if (new_object->is_type_declaration())
+ return old_object;
+ if (new_object->is_type())
+ {
+ old_object->set_type_value(new_object->type_value());
+ new_object->type_value()->set_named_object(old_object);
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ gcc_unreachable();
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if (new_object->is_function_declaration())
+ {
+ if (!new_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ Function_type* old_type = old_object->func_value()->type();
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ {
+ Function_type* old_type = old_object->func_declaration_value()->type();
+ if (new_object->is_function_declaration())
+ {
+ Function_type* new_type =
+ new_object->func_declaration_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ return old_object;
+ }
+ if (new_object->is_function())
+ {
+ Function_type* new_type = new_object->func_value()->type();
+ if (old_type->is_valid_redeclaration(new_type, &reason))
+ {
+ if (!old_object->func_declaration_value()->asm_name().empty())
+ sorry("__asm__ for function definitions");
+ old_object->set_function_value(new_object->func_value());
+ this->named_objects_.push_back(old_object);
+ return old_object;
+ }
+ }
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ if (new_object->is_package()
+ && (old_object->package_value()->name()
+ == new_object->package_value()->name()))
+ return old_object;
+
+ break;
+ }
+
+ std::string n = old_object->message_name();
+ if (reason.empty())
+ error_at(new_object->location(), "redefinition of %qs", n.c_str());
+ else
+ error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
+ reason.c_str());
+
+ inform(old_object->location(), "previous definition of %qs was here",
+ n.c_str());
+
+ return old_object;
+}
+
+// Add a named type.
+
+Named_object*
+Bindings::add_named_type(Named_type* named_type)
+{
+ return this->add_named_object(named_type->named_object());
+}
+
+// Add a function.
+
+Named_object*
+Bindings::add_function(const std::string& name, const Package* package,
+ Function* function)
+{
+ return this->add_named_object(Named_object::make_function(name, package,
+ function));
+}
+
+// Add a function declaration.
+
+Named_object*
+Bindings::add_function_declaration(const std::string& name,
+ const Package* package,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = Named_object::make_function_declaration(name, package,
+ type, location);
+ return this->add_named_object(no);
+}
+
+// Define a type which was previously declared.
+
+void
+Bindings::define_type(Named_object* no, Named_type* type)
+{
+ no->set_type_value(type);
+ this->named_objects_.push_back(no);
+}
+
+// Traverse bindings.
+
+int
+Bindings::traverse(Traverse* traverse, bool is_global)
+{
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ // We don't use an iterator because we permit the traversal to add
+ // new global objects.
+ for (size_t i = 0; i < this->named_objects_.size(); ++i)
+ {
+ Named_object* p = this->named_objects_[i];
+ switch (p->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ if ((traverse_mask & Traverse::traverse_constants) != 0)
+ {
+ if (traverse->constant(p, is_global) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ Type* t = p->const_value()->type();
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (p->const_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ if ((traverse_mask & Traverse::traverse_variables) != 0)
+ {
+ if (traverse->variable(p) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ && (p->is_result_variable()
+ || p->var_value()->has_type()))
+ {
+ Type* t = (p->is_variable()
+ ? p->var_value()->type()
+ : p->result_var_value()->type());
+ if (t != NULL
+ && Type::traverse(t, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (p->is_variable()
+ && ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0))
+ {
+ if (p->var_value()->traverse_expression(traverse)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_FUNC:
+ if ((traverse_mask & Traverse::traverse_functions) != 0)
+ {
+ int t = traverse->function(p);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ break;
+ }
+
+ if ((traverse_mask
+ & (Traverse::traverse_variables
+ | Traverse::traverse_constants
+ | Traverse::traverse_functions
+ | Traverse::traverse_blocks
+ | Traverse::traverse_statements
+ | Traverse::traverse_expressions
+ | Traverse::traverse_types)) != 0)
+ {
+ if (p->func_value()->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_PACKAGE:
+ // These are traversed in Gogo::traverse.
+ gcc_assert(is_global);
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE:
+ if ((traverse_mask & Traverse::traverse_types) != 0
+ || (traverse_mask & Traverse::traverse_expressions) != 0)
+ {
+ if (Type::traverse(p->type_value(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ break;
+
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ break;
+
+ case Named_object::NAMED_OBJECT_SINK:
+ default:
+ gcc_unreachable();
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Class Package.
+
+Package::Package(const std::string& name, const std::string& unique_prefix,
+ source_location location)
+ : name_(name), unique_prefix_(unique_prefix), bindings_(new Bindings(NULL)),
+ priority_(0), location_(location), used_(false), is_imported_(false),
+ uses_sink_alias_(false)
+{
+ gcc_assert(!name.empty() && !unique_prefix.empty());
+}
+
+// Set the priority. We may see multiple priorities for an imported
+// package; we want to use the largest one.
+
+void
+Package::set_priority(int priority)
+{
+ if (priority > this->priority_)
+ this->priority_ = priority;
+}
+
+// Determine types of constants. Everything else in a package
+// (variables, function declarations) should already have a fixed
+// type. Constants may have abstract types.
+
+void
+Package::determine_types()
+{
+ Bindings* bindings = this->bindings_;
+ for (Bindings::const_definitions_iterator p = bindings->begin_definitions();
+ p != bindings->end_definitions();
+ ++p)
+ {
+ if ((*p)->is_const())
+ (*p)->const_value()->determine_type();
+ }
+}
+
+// Class Traverse.
+
+// Destructor.
+
+Traverse::~Traverse()
+{
+ if (this->types_seen_ != NULL)
+ delete this->types_seen_;
+ if (this->expressions_seen_ != NULL)
+ delete this->expressions_seen_;
+}
+
+// Record that we are looking at a type, and return true if we have
+// already seen it.
+
+bool
+Traverse::remember_type(const Type* type)
+{
+ if (type->is_error_type())
+ return true;
+ gcc_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ // We only have to remember named types, as they are the only ones
+ // we can see multiple times in a traversal.
+ if (type->classification() != Type::TYPE_NAMED)
+ return false;
+ if (this->types_seen_ == NULL)
+ this->types_seen_ = new Types_seen();
+ std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
+ return !ins.second;
+}
+
+// Record that we are looking at an expression, and return true if we
+// have already seen it.
+
+bool
+Traverse::remember_expression(const Expression* expression)
+{
+ gcc_assert((this->traverse_mask() & traverse_types) != 0
+ || (this->traverse_mask() & traverse_expressions) != 0);
+ if (this->expressions_seen_ == NULL)
+ this->expressions_seen_ = new Expressions_seen();
+ std::pair<Expressions_seen::iterator, bool> ins =
+ this->expressions_seen_->insert(expression);
+ return !ins.second;
+}
+
+// The default versions of these functions should never be called: the
+// traversal mask indicates which functions may be called.
+
+int
+Traverse::variable(Named_object*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::constant(Named_object*, bool)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::function(Named_object*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::block(Block*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::statement(Block*, size_t*, Statement*)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::expression(Expression**)
+{
+ gcc_unreachable();
+}
+
+int
+Traverse::type(Type*)
+{
+ gcc_unreachable();
+}
--- /dev/null
+// gogo.h -- Go frontend parsed representation. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_GOGO_H
+#define GO_GOGO_H
+
+class Traverse;
+class Type;
+class Type_hash_identical;
+class Type_equal;
+class Type_identical;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Expression;
+class Statement;
+class Block;
+class Function;
+class Bindings;
+class Package;
+class Variable;
+class Pointer_type;
+class Struct_type;
+class Struct_field;
+class Struct_field_list;
+class Array_type;
+class Map_type;
+class Channel_type;
+class Interface_type;
+class Named_type;
+class Forward_declaration_type;
+class Method;
+class Methods;
+class Named_object;
+class Label;
+class Translate_context;
+class Export;
+class Import;
+
+// This file declares the basic classes used to hold the internal
+// representation of Go which is built by the parser.
+
+// An initialization function for an imported package. This is a
+// magic function which initializes variables and runs the "init"
+// function.
+
+class Import_init
+{
+ public:
+ Import_init(const std::string& package_name, const std::string& init_name,
+ int priority)
+ : package_name_(package_name), init_name_(init_name), priority_(priority)
+ { }
+
+ // The name of the package being imported.
+ const std::string&
+ package_name() const
+ { return this->package_name_; }
+
+ // The name of the package's init function.
+ const std::string&
+ init_name() const
+ { return this->init_name_; }
+
+ // The priority of the initialization function. Functions with a
+ // lower priority number must be run first.
+ int
+ priority() const
+ { return this->priority_; }
+
+ private:
+ // The name of the package being imported.
+ std::string package_name_;
+ // The name of the package's init function.
+ std::string init_name_;
+ // The priority.
+ int priority_;
+};
+
+// For sorting purposes.
+
+inline bool
+operator<(const Import_init& i1, const Import_init& i2)
+{
+ if (i1.priority() < i2.priority())
+ return true;
+ if (i1.priority() > i2.priority())
+ return false;
+ if (i1.package_name() != i2.package_name())
+ return i1.package_name() < i2.package_name();
+ return i1.init_name() < i2.init_name();
+}
+
+// The holder for the internal representation of the entire
+// compilation unit.
+
+class Gogo
+{
+ public:
+ // Create the IR, passing in the sizes of the types "int", "float",
+ // and "uintptr" in bits.
+ Gogo(int int_type_size, int float_type_size, int pointer_size);
+
+ // Get the package name.
+ const std::string&
+ package_name() const;
+
+ // Set the package name.
+ void
+ set_package_name(const std::string&, source_location);
+
+ // If necessary, adjust the name to use for a hidden symbol. We add
+ // a prefix of the package name, so that hidden symbols in different
+ // packages do not collide.
+ std::string
+ pack_hidden_name(const std::string& name, bool is_exported) const
+ {
+ return (is_exported
+ ? name
+ : ('.' + this->unique_prefix()
+ + '.' + this->package_name()
+ + '.' + name));
+ }
+
+ // Unpack a name which may have been hidden. Returns the
+ // user-visible name of the object.
+ static std::string
+ unpack_hidden_name(const std::string& name)
+ { return name[0] != '.' ? name : name.substr(name.rfind('.') + 1); }
+
+ // Return whether a possibly packed name is hidden.
+ static bool
+ is_hidden_name(const std::string& name)
+ { return name[0] == '.'; }
+
+ // Return the package prefix of a hidden name.
+ static std::string
+ hidden_name_prefix(const std::string& name)
+ {
+ gcc_assert(Gogo::is_hidden_name(name));
+ return name.substr(1, name.rfind('.') - 1);
+ }
+
+ // Given a name which may or may not have been hidden, return the
+ // name to use in an error message.
+ static std::string
+ message_name(const std::string& name);
+
+ // Return whether a name is the blank identifier _.
+ static bool
+ is_sink_name(const std::string& name)
+ {
+ return (name[0] == '.'
+ && name[name.length() - 1] == '_'
+ && name[name.length() - 2] == '.');
+ }
+
+ // Return the unique prefix to use for all exported symbols.
+ const std::string&
+ unique_prefix() const;
+
+ // Set the unique prefix.
+ void
+ set_unique_prefix(const std::string&);
+
+ // Return the priority to use for the package we are compiling.
+ // This is two more than the largest priority of any package we
+ // import.
+ int
+ package_priority() const;
+
+ // Import a package. FILENAME is the file name argument, LOCAL_NAME
+ // is the local name to give to the package. If LOCAL_NAME is empty
+ // the declarations are added to the global scope.
+ void
+ import_package(const std::string& filename, const std::string& local_name,
+ bool is_local_name_exported, source_location);
+
+ // Whether we are the global binding level.
+ bool
+ in_global_scope() const;
+
+ // Look up a name in the current binding contours.
+ Named_object*
+ lookup(const std::string&, Named_object** pfunction) const;
+
+ // Look up a name in the current block.
+ Named_object*
+ lookup_in_block(const std::string&) const;
+
+ // Look up a name in the global namespace--the universal scope.
+ Named_object*
+ lookup_global(const char*) const;
+
+ // Add a new imported package. REAL_NAME is the real name of the
+ // package. ALIAS is the alias of the package; this may be the same
+ // as REAL_NAME. This sets *PADD_TO_GLOBALS if symbols added to
+ // this package should be added to the global namespace; this is
+ // true if the alias is ".". LOCATION is the location of the import
+ // statement. This returns the new package, or NULL on error.
+ Package*
+ add_imported_package(const std::string& real_name, const std::string& alias,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals);
+
+ // Register a package. This package may or may not be imported.
+ // This returns the Package structure for the package, creating if
+ // it necessary.
+ Package*
+ register_package(const std::string& name, const std::string& unique_prefix,
+ source_location);
+
+ // Start compiling a function. ADD_METHOD_TO_TYPE is true if a
+ // method function should be added to the type of its receiver.
+ Named_object*
+ start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location);
+
+ // Finish compiling a function.
+ void
+ finish_function(source_location);
+
+ // Return the current function.
+ Named_object*
+ current_function() const;
+
+ // Start a new block. This is not initially associated with a
+ // function.
+ void
+ start_block(source_location);
+
+ // Finish the current block and return it.
+ Block*
+ finish_block(source_location);
+
+ // Declare an unknown name. This is used while parsing. The name
+ // must be resolved by the end of the parse. Unknown names are
+ // always added at the package level.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location);
+
+ // Declare a function.
+ Named_object*
+ declare_function(const std::string&, Function_type*, source_location);
+
+ // Add a label.
+ Label*
+ add_label_definition(const std::string&, source_location);
+
+ // Add a label reference.
+ Label*
+ add_label_reference(const std::string&);
+
+ // Add a statement to the current block.
+ void
+ add_statement(Statement*);
+
+ // Add a block to the current block.
+ void
+ add_block(Block*, source_location);
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier&, Expression*, int iota_value);
+
+ // Add a type.
+ void
+ add_type(const std::string&, Type*, source_location);
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ void
+ add_named_type(Named_type*);
+
+ // Declare a type.
+ Named_object*
+ declare_type(const std::string&, source_location);
+
+ // Declare a type at the package level. This is used when the
+ // parser sees an unknown name where a type name is required.
+ Named_object*
+ declare_package_type(const std::string&, source_location);
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string&, Variable*);
+
+ // Add a sink--a reference to the blank identifier _.
+ Named_object*
+ add_sink();
+
+ // Add a named object to the current namespace. This is used for
+ // import . "package".
+ void
+ add_named_object(Named_object*);
+
+ // Return a name to use for a thunk function. A thunk function is
+ // one we create during the compilation, for a go statement or a
+ // defer statement or a method expression.
+ static std::string
+ thunk_name();
+
+ // Return whether an object is a thunk.
+ static bool
+ is_thunk(const Named_object*);
+
+ // Note that we've seen an interface type. This is used to build
+ // all required interface method tables.
+ void
+ record_interface_type(Interface_type*);
+
+ // Clear out all names in file scope. This is called when we start
+ // parsing a new file.
+ void
+ clear_file_scope();
+
+ // Traverse the tree. See the Traverse class.
+ void
+ traverse(Traverse*);
+
+ // Define the predeclared global names.
+ void
+ define_global_names();
+
+ // Verify and complete all types.
+ void
+ verify_types();
+
+ // Lower the parse tree.
+ void
+ lower_parse_tree();
+
+ // Lower an expression.
+ void
+ lower_expression(Named_object* function, Expression**);
+
+ // Lower a constant.
+ void
+ lower_constant(Named_object*);
+
+ // Finalize the method lists and build stub methods for named types.
+ void
+ finalize_methods();
+
+ // Work out the types to use for unspecified variables and
+ // constants.
+ void
+ determine_types();
+
+ // Type check the program.
+ void
+ check_types();
+
+ // Check the types in a single block. This is used for complicated
+ // go statements.
+ void
+ check_types_in_block(Block*);
+
+ // Check for return statements.
+ void
+ check_return_statements();
+
+ // Do all exports.
+ void
+ do_exports();
+
+ // Add an import control function for an imported package to the
+ // list.
+ void
+ add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio);
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ void
+ remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ void
+ order_evaluations();
+
+ // Build thunks for functions which call recover.
+ void
+ build_recover_thunks();
+
+ // Simplify statements which might use thunks: go and defer
+ // statements.
+ void
+ simplify_thunk_statements();
+
+ // Write out the global values.
+ void
+ write_globals();
+
+ // Build a call to a builtin function. PDECL should point to a NULL
+ // initialized static pointer which will hold the fndecl. NAME is
+ // the name of the function. NARGS is the number of arguments.
+ // RETTYPE is the return type. It is followed by NARGS pairs of
+ // type and argument (both trees).
+ static tree
+ call_builtin(tree* pdecl, source_location, const char* name, int nargs,
+ tree rettype, ...);
+
+ // Build a call to the runtime error function.
+ static tree
+ runtime_error(int code, source_location);
+
+ // Build a builtin struct with a list of fields.
+ static tree
+ builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...);
+
+ // Mark a function declaration as a builtin library function.
+ static void
+ mark_fndecl_as_builtin_library(tree fndecl);
+
+ // Build the type of the struct that holds a slice for the given
+ // element type.
+ tree
+ slice_type_tree(tree element_type_tree);
+
+ // Given a tree for a slice type, return the tree for the element
+ // type.
+ static tree
+ slice_element_type_tree(tree slice_type_tree);
+
+ // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+ // the slice. VALUES points to the values. COUNT is the size,
+ // CAPACITY is the capacity. If CAPACITY is NULL, it is set to
+ // COUNT.
+ static tree
+ slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity);
+
+ // Build a constructor for an empty slice. SLICE_TYPE_TREE is the
+ // type of the slice.
+ static tree
+ empty_slice_constructor(tree slice_type_tree);
+
+ // Build a map descriptor.
+ tree
+ map_descriptor(Map_type*);
+
+ // Return a tree for the type of a map descriptor. This is struct
+ // __go_map_descriptor in libgo/runtime/map.h. This is the same for
+ // all map types.
+ tree
+ map_descriptor_type();
+
+ // Build a type descriptor for TYPE using INITIALIZER as the type
+ // descriptor. This builds a new decl stored in *PDECL.
+ void
+ build_type_descriptor_decl(const Type*, Expression* initializer,
+ tree* pdecl);
+
+ // Build required interface method tables.
+ void
+ build_interface_method_tables();
+
+ // Build an interface method table for a type: a list of function
+ // pointers, one for each interface method. This returns a decl.
+ tree
+ interface_method_table_for_type(const Interface_type*, Named_type*,
+ bool is_pointer);
+
+ // Return a tree which allocate SIZE bytes to hold values of type
+ // TYPE.
+ tree
+ allocate_memory(Type *type, tree size, source_location);
+
+ // Return a type to use for pointer to const char.
+ static tree
+ const_char_pointer_type_tree();
+
+ // Build a string constant with the right type.
+ static tree
+ string_constant_tree(const std::string&);
+
+ // Build a Go string constant. This returns a pointer to the
+ // constant.
+ tree
+ go_string_constant_tree(const std::string&);
+
+ // Send a value on a channel.
+ static tree
+ send_on_channel(tree channel, tree val, bool blocking, bool for_select,
+ source_location);
+
+ // Receive a value from a channel.
+ static tree
+ receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location);
+
+ // Return a tree for receiving an integer on a channel.
+ static tree
+ receive_as_64bit_integer(tree type, tree channel, bool blocking,
+ bool for_select);
+
+
+ // Make a trampoline which calls FNADDR passing CLOSURE.
+ tree
+ make_trampoline(tree fnaddr, tree closure, source_location);
+
+ private:
+ // During parsing, we keep a stack of functions. Each function on
+ // the stack is one that we are currently parsing. For each
+ // function, we keep track of the current stack of blocks.
+ struct Open_function
+ {
+ // The function.
+ Named_object* function;
+ // The stack of active blocks in the function.
+ std::vector<Block*> blocks;
+ };
+
+ // The stack of functions.
+ typedef std::vector<Open_function> Open_functions;
+
+ // Create trees for implicit builtin functions.
+ void
+ define_builtin_function_trees();
+
+ // Set up the built-in unsafe package.
+ void
+ import_unsafe(const std::string&, bool is_exported, source_location);
+
+ // Add a new imported package.
+ Named_object*
+ add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location);
+
+ // Return the current binding contour.
+ Bindings*
+ current_bindings();
+
+ const Bindings*
+ current_bindings() const;
+
+ // Return the current block.
+ Block*
+ current_block();
+
+ // Get the name of the magic initialization function.
+ const std::string&
+ get_init_fn_name();
+
+ // Get the decl for the magic initialization function.
+ tree
+ initialization_function_decl();
+
+ // Write the magic initialization function.
+ void
+ write_initialization_function(tree fndecl, tree init_stmt_list);
+
+ // Initialize imported packages.
+ void
+ init_imports(tree*);
+
+ // Register variables with the garbage collector.
+ void
+ register_gc_vars(const std::vector<Named_object*>&, tree*);
+
+ // Build a pointer to a Go string constant. This returns a pointer
+ // to the pointer.
+ tree
+ ptr_go_string_constant_tree(const std::string&);
+
+ // Return the name to use for a type descriptor decl for an unnamed
+ // type.
+ std::string
+ unnamed_type_descriptor_decl_name(const Type* type);
+
+ // Return the name to use for a type descriptor decl for a type
+ // named NO, defined in IN_FUNCTION.
+ std::string
+ type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function);
+
+ // Where a type descriptor should be defined.
+ enum Type_descriptor_location
+ {
+ // Defined in this file.
+ TYPE_DESCRIPTOR_DEFINED,
+ // Defined in some other file.
+ TYPE_DESCRIPTOR_UNDEFINED,
+ // Common definition which may occur in multiple files.
+ TYPE_DESCRIPTOR_COMMON
+ };
+
+ // Return where the decl for TYPE should be defined.
+ Type_descriptor_location
+ type_descriptor_location(const Type* type);
+
+ // Return the type of a trampoline.
+ static tree
+ trampoline_type_tree();
+
+ // Type used to map import names to packages.
+ typedef std::map<std::string, Package*> Imports;
+
+ // Type used to map package names to packages.
+ typedef std::map<std::string, Package*> Packages;
+
+ // Type used to map special names in the sys package.
+ typedef std::map<std::string, std::string> Sys_names;
+
+ // Hash table mapping map types to map descriptor decls.
+ typedef Unordered_map_hash(const Map_type*, tree, Type_hash_identical,
+ Type_identical) Map_descriptors;
+
+ // Map unnamed types to type descriptor decls.
+ typedef Unordered_map_hash(const Type*, tree, Type_hash_identical,
+ Type_identical) Type_descriptor_decls;
+
+ // The package we are compiling.
+ Package* package_;
+ // The list of currently open functions during parsing.
+ Open_functions functions_;
+ // The global binding contour. This includes the builtin functions
+ // and the package we are compiling.
+ Bindings* globals_;
+ // Mapping from import file names to packages.
+ Imports imports_;
+ // Whether the magic unsafe package was imported.
+ bool imported_unsafe_;
+ // Mapping from package names we have seen to packages. This does
+ // not include the package we are compiling.
+ Packages packages_;
+ // Mapping from map types to map descriptors.
+ Map_descriptors* map_descriptors_;
+ // Mapping from unnamed types to type descriptor decls.
+ Type_descriptor_decls* type_descriptor_decls_;
+ // The functions named "init", if there are any.
+ std::vector<Named_object*> init_functions_;
+ // Whether we need a magic initialization function.
+ bool need_init_fn_;
+ // The name of the magic initialization function.
+ std::string init_fn_name_;
+ // A list of import control variables for packages that we import.
+ std::set<Import_init> imported_init_fns_;
+ // The unique prefix used for all global symbols.
+ std::string unique_prefix_;
+ // A list of interface types defined while parsing.
+ std::vector<Interface_type*> interface_types_;
+};
+
+// A block of statements.
+
+class Block
+{
+ public:
+ Block(Block* enclosing, source_location);
+
+ // Return the enclosing block.
+ const Block*
+ enclosing() const
+ { return this->enclosing_; }
+
+ // Return the bindings of the block.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ const Bindings*
+ bindings() const
+ { return this->bindings_; }
+
+ // Look at the block's statements.
+ const std::vector<Statement*>*
+ statements() const
+ { return &this->statements_; }
+
+ // Return the start location. This is normally the location of the
+ // left curly brace which starts the block.
+ source_location
+ start_location() const
+ { return this->start_location_; }
+
+ // Return the end location. This is normally the location of the
+ // right curly brace which ends the block.
+ source_location
+ end_location() const
+ { return this->end_location_; }
+
+ // Add a statement to the block.
+ void
+ add_statement(Statement*);
+
+ // Add a statement to the front of the block.
+ void
+ add_statement_at_front(Statement*);
+
+ // Replace a statement in a block.
+ void
+ replace_statement(size_t index, Statement*);
+
+ // Add a Statement before statement number INDEX.
+ void
+ insert_statement_before(size_t index, Statement*);
+
+ // Add a Statement after statement number INDEX.
+ void
+ insert_statement_after(size_t index, Statement*);
+
+ // Set the end location of the block.
+ void
+ set_end_location(source_location location)
+ { this->end_location_ = location; }
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Set final types for unspecified variables and constants.
+ void
+ determine_types();
+
+ // Return true if execution of this block may fall through to the
+ // next block.
+ bool
+ may_fall_through() const;
+
+ // Return a tree of the code in this block.
+ tree
+ get_tree(Translate_context*);
+
+ // Iterate over statements.
+
+ typedef std::vector<Statement*>::iterator iterator;
+
+ iterator
+ begin()
+ { return this->statements_.begin(); }
+
+ iterator
+ end()
+ { return this->statements_.end(); }
+
+ private:
+ // Enclosing block.
+ Block* enclosing_;
+ // Statements in the block.
+ std::vector<Statement*> statements_;
+ // Binding contour.
+ Bindings* bindings_;
+ // Location of start of block.
+ source_location start_location_;
+ // Location of end of block.
+ source_location end_location_;
+};
+
+// A function.
+
+class Function
+{
+ public:
+ Function(Function_type* type, Function*, Block*, source_location);
+
+ // Return the function's type.
+ Function_type*
+ type() const
+ { return this->type_; }
+
+ // Return the enclosing function if there is one.
+ Function*
+ enclosing()
+ { return this->enclosing_; }
+
+ // Set the enclosing function. This is used when building thunks
+ // for functions which call recover.
+ void
+ set_enclosing(Function* enclosing)
+ {
+ gcc_assert(this->enclosing_ == NULL);
+ this->enclosing_ = enclosing;
+ }
+
+ // Create the named result variables in the outer block.
+ void
+ create_named_result_variables();
+
+ // Add a new field to the closure variable.
+ void
+ add_closure_field(Named_object* var, source_location loc)
+ { this->closure_fields_.push_back(std::make_pair(var, loc)); }
+
+ // Whether this function needs a closure.
+ bool
+ needs_closure() const
+ { return !this->closure_fields_.empty(); }
+
+ // Return the closure variable, creating it if necessary. This is
+ // passed to the function as a static chain parameter.
+ Named_object*
+ closure_var();
+
+ // Set the closure variable. This is used when building thunks for
+ // functions which call recover.
+ void
+ set_closure_var(Named_object* v)
+ {
+ gcc_assert(this->closure_var_ == NULL);
+ this->closure_var_ = v;
+ }
+
+ // Return the variable for a reference to field INDEX in the closure
+ // variable.
+ Named_object*
+ enclosing_var(unsigned int index)
+ {
+ gcc_assert(index < this->closure_fields_.size());
+ return closure_fields_[index].first;
+ }
+
+ // Set the type of the closure variable if there is one.
+ void
+ set_closure_type();
+
+ // Get the block of statements associated with the function.
+ Block*
+ block() const
+ { return this->block_; }
+
+ // Get the location of the start of the function.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return whether this function is actually a method.
+ bool
+ is_method() const;
+
+ // Add a label definition to the function.
+ Label*
+ add_label_definition(const std::string& label_name, source_location);
+
+ // Add a label reference to a function.
+ Label*
+ add_label_reference(const std::string& label_name);
+
+ // Whether this function calls the predeclared recover function.
+ bool
+ calls_recover() const
+ { return this->calls_recover_; }
+
+ // Record that this function calls the predeclared recover function.
+ // This is set during the lowering pass.
+ void
+ set_calls_recover()
+ { this->calls_recover_ = true; }
+
+ // Whether this is a recover thunk function.
+ bool
+ is_recover_thunk() const
+ { return this->is_recover_thunk_; }
+
+ // Record that this is a thunk built for a function which calls
+ // recover.
+ void
+ set_is_recover_thunk()
+ { this->is_recover_thunk_ = true; }
+
+ // Whether this function already has a recover thunk.
+ bool
+ has_recover_thunk() const
+ { return this->has_recover_thunk_; }
+
+ // Record that this function already has a recover thunk.
+ void
+ set_has_recover_thunk()
+ { this->has_recover_thunk_ = true; }
+
+ // Swap with another function. Used only for the thunk which calls
+ // recover.
+ void
+ swap_for_recover(Function *);
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Determine types in the function.
+ void
+ determine_types();
+
+ // Return the function's decl given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Return the function's decl after it has been built.
+ tree
+ get_decl() const
+ {
+ gcc_assert(this->fndecl_ != NULL);
+ return this->fndecl_;
+ }
+
+ // Set the function decl to hold a tree of the function code.
+ void
+ build_tree(Gogo*, Named_object*);
+
+ // Get the value to return when not explicitly specified. May also
+ // add statements to execute first to STMT_LIST.
+ tree
+ return_value(Gogo*, Named_object*, source_location, tree* stmt_list) const;
+
+ // Get a tree for the variable holding the defer stack.
+ tree
+ defer_stack(source_location);
+
+ // Export the function.
+ void
+ export_func(Export*, const std::string& name) const;
+
+ // Export a function with a type.
+ static void
+ export_func_with_type(Export*, const std::string& name,
+ const Function_type*);
+
+ // Import a function.
+ static void
+ import_func(Import*, std::string* pname, Typed_identifier** receiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults, bool* is_varargs);
+
+ private:
+ // Type for mapping from label names to Label objects.
+ typedef Unordered_map(std::string, Label*) Labels;
+
+ tree
+ make_receiver_parm_decl(Gogo*, Named_object*, tree);
+
+ tree
+ copy_parm_to_heap(Gogo*, Named_object*, tree);
+
+ void
+ build_defer_wrapper(Gogo*, Named_object*, tree*, tree*);
+
+ typedef std::vector<Named_object*> Named_results;
+
+ typedef std::vector<std::pair<Named_object*,
+ source_location> > Closure_fields;
+
+ // The function's type.
+ Function_type* type_;
+ // The enclosing function. This is NULL when there isn't one, which
+ // is the normal case.
+ Function* enclosing_;
+ // The named result variables, if any.
+ Named_results* named_results_;
+ // If there is a closure, this is the list of variables which appear
+ // in the closure. This is created by the parser, and then resolved
+ // to a real type when we lower parse trees.
+ Closure_fields closure_fields_;
+ // The closure variable, passed as a parameter using the static
+ // chain parameter. Normally NULL.
+ Named_object* closure_var_;
+ // The outer block of statements in the function.
+ Block* block_;
+ // The source location of the start of the function.
+ source_location location_;
+ // Labels defined or referenced in the function.
+ Labels labels_;
+ // The function decl.
+ tree fndecl_;
+ // A variable holding the defer stack variable. This is NULL unless
+ // we actually need a defer stack.
+ tree defer_stack_;
+ // True if this function calls the predeclared recover function.
+ bool calls_recover_;
+ // True if this a thunk built for a function which calls recover.
+ bool is_recover_thunk_;
+ // True if this function already has a recover thunk.
+ bool has_recover_thunk_;
+};
+
+// A function declaration.
+
+class Function_declaration
+{
+ public:
+ Function_declaration(Function_type* fntype, source_location location)
+ : fntype_(fntype), location_(location), asm_name_(), fndecl_(NULL)
+ { }
+
+ Function_type*
+ type() const
+ { return this->fntype_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ const std::string&
+ asm_name() const
+ { return this->asm_name_; }
+
+ // Set the assembler name.
+ void
+ set_asm_name(const std::string& asm_name)
+ { this->asm_name_ = asm_name; }
+
+ // Return a decl for the function given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Export a function declaration.
+ void
+ export_func(Export* exp, const std::string& name) const
+ { Function::export_func_with_type(exp, name, this->fntype_); }
+
+ private:
+ // The type of the function.
+ Function_type* fntype_;
+ // The location of the declaration.
+ source_location location_;
+ // The assembler name: this is the name to use in references to the
+ // function. This is normally empty.
+ std::string asm_name_;
+ // The function decl if needed.
+ tree fndecl_;
+};
+
+// A variable.
+
+class Variable
+{
+ public:
+ Variable(Type*, Expression*, bool is_global, bool is_parameter,
+ bool is_receiver, source_location);
+
+ // Get the type of the variable.
+ Type*
+ type() const;
+
+ // Return whether the type is defined yet.
+ bool
+ has_type() const
+ { return this->type_ != NULL; }
+
+ // Get the initial value.
+ Expression*
+ init() const
+ { return this->init_; }
+
+ // Return whether there are any preinit statements.
+ bool
+ has_pre_init() const
+ { return this->preinit_ != NULL; }
+
+ // Return the preinit statements if any.
+ Block*
+ preinit() const
+ { return this->preinit_; }
+
+ // Return whether this is a global variable.
+ bool
+ is_global() const
+ { return this->is_global_; }
+
+ // Return whether this is a function parameter.
+ bool
+ is_parameter() const
+ { return this->is_parameter_; }
+
+ // Return whether this is the receiver parameter of a method.
+ bool
+ is_receiver() const
+ { return this->is_receiver_; }
+
+ // Change this parameter to be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_receiver()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_receiver_ = true;
+ }
+
+ // Change this parameter to not be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_not_receiver()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_receiver_ = false;
+ }
+
+ // Return whether this is the varargs parameter of a function.
+ bool
+ is_varargs_parameter() const
+ { return this->is_varargs_parameter_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_ && !this->is_global_; }
+
+ // Get the source location of the variable's declaration.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Record that this is the varargs parameter of a function.
+ void
+ set_is_varargs_parameter()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_varargs_parameter_ = true;
+ }
+
+ // Clear the initial value; used for error handling.
+ void
+ clear_init()
+ { this->init_ = NULL; }
+
+ // Set the initial value; used for converting shortcuts.
+ void
+ set_init(Expression* init)
+ { this->init_ = init; }
+
+ // Get the preinit block, a block of statements to be run before the
+ // initialization expression.
+ Block*
+ preinit_block();
+
+ // Add a statement to be run before the initialization expression.
+ // This is only used for global variables.
+ void
+ add_preinit_statement(Statement*);
+
+ // Lower the initialization expression after parsing is complete.
+ void
+ lower_init_expression(Gogo*, Named_object*);
+
+ // A special case: the init value is used only to determine the
+ // type. This is used if the variable is defined using := with the
+ // comma-ok form of a map index or a receive expression. The init
+ // value is actually the map index expression or receive expression.
+ // We use this because we may not know the right type at parse time.
+ void
+ set_type_from_init_tuple()
+ { this->type_from_init_tuple_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a range clause. The init value is the range expression. The
+ // type of the variable is the index type of the range expression
+ // (i.e., the first value returned by a range).
+ void
+ set_type_from_range_index()
+ { this->type_from_range_index_ = true; }
+
+ // Another special case: like set_type_from_range_index, but the
+ // type is the value type of the range expression (i.e., the second
+ // value returned by a range).
+ void
+ set_type_from_range_value()
+ { this->type_from_range_value_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a case in a select statement. The init value is the channel.
+ // The type of the variable is the channel's element type.
+ void
+ set_type_from_chan_element()
+ { this->type_from_chan_element_ = true; }
+
+ // After we lower the select statement, we once again set the type
+ // from the initialization expression.
+ void
+ clear_type_from_chan_element()
+ {
+ gcc_assert(this->type_from_chan_element_);
+ this->type_from_chan_element_ = false;
+ }
+
+ // Note that this variable was created for a type switch clause.
+ void
+ set_is_type_switch_var()
+ { this->is_type_switch_var_ = true; }
+
+ // Traverse the initializer expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the variable if necessary.
+ void
+ determine_type();
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Get the initial value of the variable as a tree. This may only
+ // be called if has_pre_init() returns false.
+ tree
+ get_init_tree(Gogo*, Named_object* function);
+
+ // Return a series of statements which sets the value of the
+ // variable in DECL. This should only be called is has_pre_init()
+ // returns true. DECL may be NULL for a sink variable.
+ tree
+ get_init_block(Gogo*, Named_object* function, tree decl);
+
+ // Export the variable.
+ void
+ export_var(Export*, const std::string& name) const;
+
+ // Import a variable.
+ static void
+ import_var(Import*, std::string* pname, Type** ptype);
+
+ private:
+ // The type of a tuple.
+ Type*
+ type_from_tuple(Expression*, bool) const;
+
+ // The type of a range.
+ Type*
+ type_from_range(Expression*, bool, bool) const;
+
+ // The element type of a channel.
+ Type*
+ type_from_chan_element(Expression*, bool) const;
+
+ // The variable's type. This may be NULL if the type is set from
+ // the expression.
+ Type* type_;
+ // The initial value. This may be NULL if the variable should be
+ // initialized to the default value for the type.
+ Expression* init_;
+ // Statements to run before the init statement.
+ Block* preinit_;
+ // Location of variable definition.
+ source_location location_;
+ // Whether this is a global variable.
+ bool is_global_ : 1;
+ // Whether this is a function parameter.
+ bool is_parameter_ : 1;
+ // Whether this is the receiver parameter of a method.
+ bool is_receiver_ : 1;
+ // Whether this is the varargs parameter of a function.
+ bool is_varargs_parameter_ : 1;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_ : 1;
+ // True if we have lowered the initialization expression.
+ bool init_is_lowered_ : 1;
+ // True if init is a tuple used to set the type.
+ bool type_from_init_tuple_ : 1;
+ // True if init is a range clause and the type is the index type.
+ bool type_from_range_index_ : 1;
+ // True if init is a range clause and the type is the value type.
+ bool type_from_range_value_ : 1;
+ // True if init is a channel and the type is the channel's element type.
+ bool type_from_chan_element_ : 1;
+ // True if this is a variable created for a type switch case.
+ bool is_type_switch_var_ : 1;
+};
+
+// A variable which is really the name for a function return value, or
+// part of one.
+
+class Result_variable
+{
+ public:
+ Result_variable(Type* type, Function* function, int index)
+ : type_(type), function_(function), index_(index),
+ is_address_taken_(false)
+ { }
+
+ // Get the type of the result variable.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Get the function that this is associated with.
+ Function*
+ function() const
+ { return this->function_; }
+
+ // Index in the list of function results.
+ int
+ index() const
+ { return this->index_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_; }
+
+ private:
+ // Type of result variable.
+ Type* type_;
+ // Function with which this is associated.
+ Function* function_;
+ // Index in list of results.
+ int index_;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_;
+};
+
+// The value we keep for a named constant. This lets us hold a type
+// and an expression.
+
+class Named_constant
+{
+ public:
+ Named_constant(Type* type, Expression* expr, int iota_value,
+ source_location location)
+ : type_(type), expr_(expr), iota_value_(iota_value), location_(location),
+ lowering_(false)
+ { }
+
+ Type*
+ type() const
+ { return this->type_; }
+
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ int
+ iota_value() const
+ { return this->iota_value_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether we are lowering.
+ bool
+ lowering() const
+ { return this->lowering_; }
+
+ // Set that we are lowering.
+ void
+ set_lowering()
+ { this->lowering_ = true; }
+
+ // We are no longer lowering.
+ void
+ clear_lowering()
+ { this->lowering_ = false; }
+
+ // Traverse the expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the constant if necessary.
+ void
+ determine_type();
+
+ // Indicate that we found and reported an error for this constant.
+ void
+ set_error();
+
+ // Export the constant.
+ void
+ export_const(Export*, const std::string& name) const;
+
+ // Import a constant.
+ static void
+ import_const(Import*, std::string*, Type**, Expression**);
+
+ private:
+ // The type of the constant.
+ Type* type_;
+ // The expression for the constant.
+ Expression* expr_;
+ // If the predeclared constant iota is used in EXPR_, this is the
+ // value it will have. We do this because at parse time we don't
+ // know whether the name "iota" will refer to the predeclared
+ // constant or to something else. We put in the right value in when
+ // we lower.
+ int iota_value_;
+ // The location of the definition.
+ source_location location_;
+ // Whether we are currently lowering this constant.
+ bool lowering_;
+};
+
+// A type declaration.
+
+class Type_declaration
+{
+ public:
+ Type_declaration(source_location location)
+ : location_(location), in_function_(NULL), methods_(),
+ issued_warning_(false)
+ { }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the function in which this type is declared. This will
+ // return NULL for a type declared in global scope.
+ Named_object*
+ in_function()
+ { return this->in_function_; }
+
+ // Set the function in which this type is declared.
+ void
+ set_in_function(Named_object* f)
+ { this->in_function_ = f; }
+
+ // Add a method to this type. This is used when methods are defined
+ // before the type.
+ Named_object*
+ add_method(const std::string& name, Function* function);
+
+ // Add a method declaration to this type.
+ Named_object*
+ add_method_declaration(const std::string& name, Function_type* type,
+ source_location location);
+
+ // Return whether any methods were defined.
+ bool
+ has_methods() const;
+
+ // Define methods when the real type is known.
+ void
+ define_methods(Named_type*);
+
+ // This is called if we are trying to use this type. It returns
+ // true if we should issue a warning.
+ bool
+ using_type();
+
+ private:
+ typedef std::vector<Named_object*> Methods;
+
+ // The location of the type declaration.
+ source_location location_;
+ // If this type is declared in a function, a pointer back to the
+ // function in which it is defined.
+ Named_object* in_function_;
+ // Methods defined before the type is defined.
+ Methods methods_;
+ // True if we have issued a warning about a use of this type
+ // declaration when it is undefined.
+ bool issued_warning_;
+};
+
+// An unknown object. These are created by the parser for forward
+// references to names which have not been seen before. In a correct
+// program, these will always point to a real definition by the end of
+// the parse. Because they point to another Named_object, these may
+// only be referenced by Unknown_expression objects.
+
+class Unknown_name
+{
+ public:
+ Unknown_name(source_location location)
+ : location_(location), real_named_object_(NULL)
+ { }
+
+ // Return the location where this name was first seen.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the real named object that this points to, or NULL if it
+ // was never resolved.
+ Named_object*
+ real_named_object() const
+ { return this->real_named_object_; }
+
+ // Set the real named object that this points to.
+ void
+ set_real_named_object(Named_object* no);
+
+ private:
+ // The location where this name was first seen.
+ source_location location_;
+ // The real named object when it is known.
+ Named_object*
+ real_named_object_;
+};
+
+// A named object named. This is the result of a declaration. We
+// don't use a superclass because they all have to be handled
+// differently.
+
+class Named_object
+{
+ public:
+ enum Classification
+ {
+ // An uninitialized Named_object. We should never see this.
+ NAMED_OBJECT_UNINITIALIZED,
+ // An unknown name. This is used for forward references. In a
+ // correct program, these will all be resolved by the end of the
+ // parse.
+ NAMED_OBJECT_UNKNOWN,
+ // A const.
+ NAMED_OBJECT_CONST,
+ // A type.
+ NAMED_OBJECT_TYPE,
+ // A forward type declaration.
+ NAMED_OBJECT_TYPE_DECLARATION,
+ // A var.
+ NAMED_OBJECT_VAR,
+ // A result variable in a function.
+ NAMED_OBJECT_RESULT_VAR,
+ // The blank identifier--the special variable named _.
+ NAMED_OBJECT_SINK,
+ // A func.
+ NAMED_OBJECT_FUNC,
+ // A forward func declaration.
+ NAMED_OBJECT_FUNC_DECLARATION,
+ // A package.
+ NAMED_OBJECT_PACKAGE
+ };
+
+ // Return the classification.
+ Classification
+ classification() const
+ { return this->classification_; }
+
+ // Classifiers.
+
+ bool
+ is_unknown() const
+ { return this->classification_ == NAMED_OBJECT_UNKNOWN; }
+
+ bool
+ is_const() const
+ { return this->classification_ == NAMED_OBJECT_CONST; }
+
+ bool
+ is_type() const
+ { return this->classification_ == NAMED_OBJECT_TYPE; }
+
+ bool
+ is_type_declaration() const
+ { return this->classification_ == NAMED_OBJECT_TYPE_DECLARATION; }
+
+ bool
+ is_variable() const
+ { return this->classification_ == NAMED_OBJECT_VAR; }
+
+ bool
+ is_result_variable() const
+ { return this->classification_ == NAMED_OBJECT_RESULT_VAR; }
+
+ bool
+ is_sink() const
+ { return this->classification_ == NAMED_OBJECT_SINK; }
+
+ bool
+ is_function() const
+ { return this->classification_ == NAMED_OBJECT_FUNC; }
+
+ bool
+ is_function_declaration() const
+ { return this->classification_ == NAMED_OBJECT_FUNC_DECLARATION; }
+
+ bool
+ is_package() const
+ { return this->classification_ == NAMED_OBJECT_PACKAGE; }
+
+ // Creators.
+
+ static Named_object*
+ make_unknown_name(const std::string& name, source_location);
+
+ static Named_object*
+ make_constant(const Typed_identifier&, const Package*, Expression*,
+ int iota_value);
+
+ static Named_object*
+ make_type(const std::string&, const Package*, Type*, source_location);
+
+ static Named_object*
+ make_type_declaration(const std::string&, const Package*, source_location);
+
+ static Named_object*
+ make_variable(const std::string&, const Package*, Variable*);
+
+ static Named_object*
+ make_result_variable(const std::string&, Result_variable*);
+
+ static Named_object*
+ make_sink();
+
+ static Named_object*
+ make_function(const std::string&, const Package*, Function*);
+
+ static Named_object*
+ make_function_declaration(const std::string&, const Package*, Function_type*,
+ source_location);
+
+ static Named_object*
+ make_package(const std::string& alias, Package* package);
+
+ // Getters.
+
+ Unknown_name*
+ unknown_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ const Unknown_name*
+ unknown_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ Named_constant*
+ const_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ const Named_constant*
+ const_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ Named_type*
+ type_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ const Named_type*
+ type_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ Type_declaration*
+ type_declaration_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ const Type_declaration*
+ type_declaration_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ Variable*
+ var_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ const Variable*
+ var_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ Result_variable*
+ result_var_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ const Result_variable*
+ result_var_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ Function*
+ func_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ const Function*
+ func_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ Function_declaration*
+ func_declaration_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ const Function_declaration*
+ func_declaration_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ Package*
+ package_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const Package*
+ package_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the name to use in an error message. The difference is
+ // that if this Named_object is defined in a different package, this
+ // will return PACKAGE.NAME.
+ std::string
+ message_name() const;
+
+ const Package*
+ package() const
+ { return this->package_; }
+
+ // Resolve an unknown value if possible. This returns the same
+ // Named_object or a new one.
+ Named_object*
+ resolve()
+ {
+ Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ const Named_object*
+ resolve() const
+ {
+ const Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ const Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ // The location where this object was defined or referenced.
+ source_location
+ location() const;
+
+ // Return a tree for the external identifier for this object.
+ tree
+ get_id(Gogo*);
+
+ // Return a tree representing this object.
+ tree
+ get_tree(Gogo*, Named_object* function);
+
+ // Define a type declaration.
+ void
+ set_type_value(Named_type*);
+
+ // Define a function declaration.
+ void
+ set_function_value(Function*);
+
+ // Export this object.
+ void
+ export_named_object(Export*) const;
+
+ private:
+ Named_object(const std::string&, const Package*, Classification);
+
+ // The name of the object.
+ std::string name_;
+ // The package that this object is in. This is NULL if it is in the
+ // file we are compiling.
+ const Package* package_;
+ // The type of object this is.
+ Classification classification_;
+ // The real data.
+ union
+ {
+ Unknown_name* unknown_value;
+ Named_constant* const_value;
+ Named_type* type_value;
+ Type_declaration* type_declaration;
+ Variable* var_value;
+ Result_variable* result_var_value;
+ Function* func_value;
+ Function_declaration* func_declaration_value;
+ Package* package_value;
+ } u_;
+ // The DECL tree for this object if we have already converted it.
+ tree tree_;
+};
+
+// A binding contour. This binds names to objects.
+
+class Bindings
+{
+ public:
+ // Type for mapping from names to objects.
+ typedef Unordered_map(std::string, Named_object*) Contour;
+
+ Bindings(Bindings* enclosing);
+
+ // Add an unknown name.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location location)
+ {
+ return this->add_named_object(Named_object::make_unknown_name(name,
+ location));
+ }
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier& tid, const Package* package,
+ Expression* expr, int iota_value)
+ {
+ return this->add_named_object(Named_object::make_constant(tid, package,
+ expr,
+ iota_value));
+ }
+
+ // Add a type.
+ Named_object*
+ add_type(const std::string& name, const Package* package, Type* type,
+ source_location location)
+ {
+ return this->add_named_object(Named_object::make_type(name, package, type,
+ location));
+ }
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ Named_object*
+ add_named_type(Named_type* named_type);
+
+ // Add a type declaration.
+ Named_object*
+ add_type_declaration(const std::string& name, const Package* package,
+ source_location location)
+ {
+ Named_object* no = Named_object::make_type_declaration(name, package,
+ location);
+ return this->add_named_object(no);
+ }
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string& name, const Package* package,
+ Variable* variable)
+ {
+ return this->add_named_object(Named_object::make_variable(name, package,
+ variable));
+ }
+
+ // Add a result variable.
+ Named_object*
+ add_result_variable(const std::string& name, Result_variable* result)
+ {
+ return this->add_named_object(Named_object::make_result_variable(name,
+ result));
+ }
+
+ // Add a function.
+ Named_object*
+ add_function(const std::string& name, const Package*, Function* function);
+
+ // Add a function declaration.
+ Named_object*
+ add_function_declaration(const std::string& name, const Package* package,
+ Function_type* type, source_location location);
+
+ // Add a package. The location is the location of the import
+ // statement.
+ Named_object*
+ add_package(const std::string& alias, Package* package)
+ {
+ Named_object* no = Named_object::make_package(alias, package);
+ return this->add_named_object(no);
+ }
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a method to the list of objects. This is not added to the
+ // lookup table.
+ void
+ add_method(Named_object*);
+
+ // Add a named object to this binding.
+ Named_object*
+ add_named_object(Named_object* no)
+ { return this->add_named_object_to_contour(&this->bindings_, no); }
+
+ // Clear all names in file scope from the bindings.
+ void
+ clear_file_scope();
+
+ // Look up a name in this binding contour and in any enclosing
+ // binding contours. This returns NULL if the name is not found.
+ Named_object*
+ lookup(const std::string&) const;
+
+ // Look up a name in this binding contour without looking in any
+ // enclosing binding contours. Returns NULL if the name is not found.
+ Named_object*
+ lookup_local(const std::string&) const;
+
+ // Remove a name.
+ void
+ remove_binding(Named_object*);
+
+ // Traverse the tree. See the Traverse class.
+ int
+ traverse(Traverse*, bool is_global);
+
+ // Iterate over definitions. This does not include things which
+ // were only declared.
+
+ typedef std::vector<Named_object*>::const_iterator
+ const_definitions_iterator;
+
+ const_definitions_iterator
+ begin_definitions() const
+ { return this->named_objects_.begin(); }
+
+ const_definitions_iterator
+ end_definitions() const
+ { return this->named_objects_.end(); }
+
+ // Return the number of definitions.
+ size_t
+ size_definitions() const
+ { return this->named_objects_.size(); }
+
+ // Return whether there are no definitions.
+ bool
+ empty_definitions() const
+ { return this->named_objects_.empty(); }
+
+ // Iterate over declarations. This is everything that has been
+ // declared, which includes everything which has been defined.
+
+ typedef Contour::const_iterator const_declarations_iterator;
+
+ const_declarations_iterator
+ begin_declarations() const
+ { return this->bindings_.begin(); }
+
+ const_declarations_iterator
+ end_declarations() const
+ { return this->bindings_.end(); }
+
+ // Return the number of declarations.
+ size_t
+ size_declarations() const
+ { return this->bindings_.size(); }
+
+ // Return whether there are no declarations.
+ bool
+ empty_declarations() const
+ { return this->bindings_.empty(); }
+
+ // Return the first declaration.
+ Named_object*
+ first_declaration()
+ { return this->bindings_.empty() ? NULL : this->bindings_.begin()->second; }
+
+ private:
+ Named_object*
+ add_named_object_to_contour(Contour*, Named_object*);
+
+ Named_object*
+ new_definition(Named_object*, Named_object*);
+
+ // Enclosing bindings.
+ Bindings* enclosing_;
+ // The list of objects.
+ std::vector<Named_object*> named_objects_;
+ // The mapping from names to objects.
+ Contour bindings_;
+};
+
+// A label.
+
+class Label
+{
+ public:
+ Label(const std::string& name)
+ : name_(name), location_(0), decl_(NULL)
+ { }
+
+ // Return the label's name.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return whether the label has been defined.
+ bool
+ is_defined() const
+ { return this->location_ != 0; }
+
+ // Return the location of the definition.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Define the label at LOCATION.
+ void
+ define(source_location location)
+ {
+ gcc_assert(this->location_ == 0);
+ this->location_ = location;
+ }
+
+ // Return the LABEL_DECL for this decl.
+ tree
+ get_decl();
+
+ // Return an expression for the address of this label.
+ tree
+ get_addr(source_location location);
+
+ private:
+ // The name of the label.
+ std::string name_;
+ // The location of the definition. This is 0 if the label has not
+ // yet been defined.
+ source_location location_;
+ // The LABEL_DECL.
+ tree decl_;
+};
+
+// An unnamed label. These are used when lowering loops.
+
+class Unnamed_label
+{
+ public:
+ Unnamed_label(source_location location)
+ : location_(location), decl_(NULL)
+ { }
+
+ // Get the location where the label is defined.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Set the location where the label is defined.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Return a statement which defines this label.
+ tree
+ get_definition();
+
+ // Return a goto to this label from LOCATION.
+ tree
+ get_goto(source_location location);
+
+ private:
+ // Return the LABEL_DECL to use with GOTO_EXPR.
+ tree
+ get_decl();
+
+ // The location where the label is defined.
+ source_location location_;
+ // The LABEL_DECL.
+ tree decl_;
+};
+
+// An imported package.
+
+class Package
+{
+ public:
+ Package(const std::string& name, const std::string& unique_prefix,
+ source_location location);
+
+ // The real name of this package. This may be different from the
+ // name in the associated Named_object if the import statement used
+ // an alias.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the location of the import statement.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Get the unique prefix used for all symbols exported from this
+ // package.
+ const std::string&
+ unique_prefix() const
+ {
+ gcc_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+ }
+
+ // The priority of this package. The init function of packages with
+ // lower priority must be run before the init function of packages
+ // with higher priority.
+ int
+ priority() const
+ { return this->priority_; }
+
+ // Set the priority.
+ void
+ set_priority(int priority);
+
+ // Return the bindings.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ // Whether some symbol from the package was used.
+ bool
+ used() const
+ { return this->used_; }
+
+ // Note that some symbol from this package was used.
+ void
+ set_used() const
+ { this->used_ = true; }
+
+ // Clear the used field for the next file.
+ void
+ clear_used()
+ { this->used_ = false; }
+
+ // Whether this package was imported in the current file.
+ bool
+ is_imported() const
+ { return this->is_imported_; }
+
+ // Note that this package was imported in the current file.
+ void
+ set_is_imported()
+ { this->is_imported_ = true; }
+
+ // Clear the imported field for the next file.
+ void
+ clear_is_imported()
+ { this->is_imported_ = false; }
+
+ // Whether this package was imported with a name of "_".
+ bool
+ uses_sink_alias() const
+ { return this->uses_sink_alias_; }
+
+ // Note that this package was imported with a name of "_".
+ void
+ set_uses_sink_alias()
+ { this->uses_sink_alias_ = true; }
+
+ // Clear the sink alias field for the next file.
+ void
+ clear_uses_sink_alias()
+ { this->uses_sink_alias_ = false; }
+
+ // Look up a name in the package. Returns NULL if the name is not
+ // found.
+ Named_object*
+ lookup(const std::string& name) const
+ { return this->bindings_->lookup(name); }
+
+ // Set the location of the package. This is used if it is seen in a
+ // different import before it is really imported.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Add a constant to the package.
+ Named_object*
+ add_constant(const Typed_identifier& tid, Expression* expr)
+ { return this->bindings_->add_constant(tid, this, expr, 0); }
+
+ // Add a type to the package.
+ Named_object*
+ add_type(const std::string& name, Type* type, source_location location)
+ { return this->bindings_->add_type(name, this, type, location); }
+
+ // Add a type declaration to the package.
+ Named_object*
+ add_type_declaration(const std::string& name, source_location location)
+ { return this->bindings_->add_type_declaration(name, this, location); }
+
+ // Add a variable to the package.
+ Named_object*
+ add_variable(const std::string& name, Variable* variable)
+ { return this->bindings_->add_variable(name, this, variable); }
+
+ // Add a function declaration to the package.
+ Named_object*
+ add_function_declaration(const std::string& name, Function_type* type,
+ source_location loc)
+ { return this->bindings_->add_function_declaration(name, this, type, loc); }
+
+ // Determine types of constants.
+ void
+ determine_types();
+
+ private:
+ // The real name of this package.
+ std::string name_;
+ // The unique prefix for all exported global symbols.
+ std::string unique_prefix_;
+ // The names in this package.
+ Bindings* bindings_;
+ // The priority of this package. A package has a priority higher
+ // than the priority of all of the packages that it imports. This
+ // is used to run init functions in the right order.
+ int priority_;
+ // The location of the import statement.
+ source_location location_;
+ // True if some name from this package was used. This is mutable
+ // because we can use a package even if we have a const pointer to
+ // it.
+ mutable bool used_;
+ // True if this package was imported in the current file.
+ bool is_imported_;
+ // True if this package was imported with a name of "_".
+ bool uses_sink_alias_;
+};
+
+// Return codes for the traversal functions. This is not an enum
+// because we want to be able to declare traversal functions in other
+// header files without including this one.
+
+// Continue traversal as usual.
+const int TRAVERSE_CONTINUE = -1;
+
+// Exit traversal.
+const int TRAVERSE_EXIT = 0;
+
+// Continue traversal, but skip components of the current object.
+// E.g., if this is returned by Traverse::statement, we do not
+// traverse the expressions in the statement even if
+// traverse_expressions is set in the traverse_mask.
+const int TRAVERSE_SKIP_COMPONENTS = 1;
+
+// This class is used when traversing the parse tree. The caller uses
+// a subclass which overrides functions as desired.
+
+class Traverse
+{
+ public:
+ // These bitmasks say what to traverse.
+ static const unsigned int traverse_variables = 0x1;
+ static const unsigned int traverse_constants = 0x2;
+ static const unsigned int traverse_functions = 0x4;
+ static const unsigned int traverse_blocks = 0x8;
+ static const unsigned int traverse_statements = 0x10;
+ static const unsigned int traverse_expressions = 0x20;
+ static const unsigned int traverse_types = 0x40;
+
+ Traverse(unsigned int traverse_mask)
+ : traverse_mask_(traverse_mask), types_seen_(NULL), expressions_seen_(NULL)
+ { }
+
+ virtual ~Traverse();
+
+ // The bitmask of what to traverse.
+ unsigned int
+ traverse_mask() const
+ { return this->traverse_mask_; }
+
+ // Record that we are going to traverse a type. This returns true
+ // if the type has already been seen in this traversal. This is
+ // required because types, unlike expressions, can form a circular
+ // graph.
+ bool
+ remember_type(const Type*);
+
+ // Record that we are going to see an expression. This returns true
+ // if the expression has already been seen in this traversal. This
+ // is only needed for cases where multiple expressions can point to
+ // a single one.
+ bool
+ remember_expression(const Expression*);
+
+ // These functions return one of the TRAVERSE codes defined above.
+
+ // If traverse_variables is set in the mask, this is called for
+ // every variable in the tree.
+ virtual int
+ variable(Named_object*);
+
+ // If traverse_constants is set in the mask, this is called for
+ // every named constant in the tree. The bool parameter is true for
+ // a global constant.
+ virtual int
+ constant(Named_object*, bool);
+
+ // If traverse_functions is set in the mask, this is called for
+ // every function in the tree.
+ virtual int
+ function(Named_object*);
+
+ // If traverse_blocks is set in the mask, this is called for every
+ // block in the tree.
+ virtual int
+ block(Block*);
+
+ // If traverse_statements is set in the mask, this is called for
+ // every statement in the tree.
+ virtual int
+ statement(Block*, size_t* index, Statement*);
+
+ // If traverse_expressions is set in the mask, this is called for
+ // every expression in the tree.
+ virtual int
+ expression(Expression**);
+
+ // If traverse_types is set in the mask, this is called for every
+ // type in the tree.
+ virtual int
+ type(Type*);
+
+ private:
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+
+ typedef Unordered_set(const Expression*) Expressions_seen;
+
+ // Bitmask of what sort of objects to traverse.
+ unsigned int traverse_mask_;
+ // Types which have been seen in this traversal.
+ Types_seen* types_seen_;
+ // Expressions which have been seen in this traversal.
+ Expressions_seen* expressions_seen_;
+};
+
+// When translating the gogo IR into trees, this is the context we
+// pass down the blocks and statements.
+
+class Translate_context
+{
+ public:
+ Translate_context(Gogo* gogo, Named_object* function, Block* block,
+ tree block_tree)
+ : gogo_(gogo), function_(function), block_(block), block_tree_(block_tree),
+ is_const_(false)
+ { }
+
+ // Accessors.
+
+ Gogo*
+ gogo()
+ { return this->gogo_; }
+
+ Named_object*
+ function()
+ { return this->function_; }
+
+ Block*
+ block()
+ { return this->block_; }
+
+ tree
+ block_tree()
+ { return this->block_tree_; }
+
+ bool
+ is_const()
+ { return this->is_const_; }
+
+ // Make a constant context.
+ void
+ set_is_const()
+ { this->is_const_ = true; }
+
+ private:
+ // The IR for the entire compilation unit.
+ Gogo* gogo_;
+ // The function we are currently translating.
+ Named_object* function_;
+ // The block we are currently translating.
+ Block *block_;
+ // The BLOCK node for the current block.
+ tree block_tree_;
+ // Whether this is being evaluated in a constant context. This is
+ // used for type descriptor initializers.
+ bool is_const_;
+};
+
+// Runtime error codes. These must match the values in
+// libgo/runtime/go-runtime-error.c.
+
+// Slice index out of bounds: negative or larger than the length of
+// the slice.
+static const int RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS = 0;
+
+// Array index out of bounds.
+static const int RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS = 1;
+
+// String index out of bounds.
+static const int RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS = 2;
+
+// Slice slice out of bounds: negative or larger than the length of
+// the slice or high bound less than low bound.
+static const int RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS = 3;
+
+// Array slice out of bounds.
+static const int RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS = 4;
+
+// String slice out of bounds.
+static const int RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS = 5;
+
+// Dereference of nil pointer. This is used when there is a
+// dereference of a pointer to a very large struct or array, to ensure
+// that a gigantic array is not used a proxy to access random memory
+// locations.
+static const int RUNTIME_ERROR_NIL_DEREFERENCE = 6;
+
+// Slice length or capacity out of bounds in make: negative or
+// overflow or length greater than capacity.
+static const int RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS = 7;
+
+// Map capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS = 8;
+
+// Channel capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS = 9;
+
+// This is used by some of the langhooks.
+extern Gogo* go_get_gogo();
+
+// Whether we have seen any errors. FIXME: Replace with a backend
+// interface.
+extern bool saw_errors();
+
+#endif // !defined(GO_GOGO_H)
--- /dev/null
+// gogo.h -- Go frontend parsed representation. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_GOGO_H
+#define GO_GOGO_H
+
+class Traverse;
+class Type;
+class Type_hash_identical;
+class Type_equal;
+class Type_identical;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Expression;
+class Statement;
+class Temporary_statement;
+class Block;
+class Function;
+class Bindings;
+class Package;
+class Variable;
+class Pointer_type;
+class Struct_type;
+class Struct_field;
+class Struct_field_list;
+class Array_type;
+class Map_type;
+class Channel_type;
+class Interface_type;
+class Named_type;
+class Forward_declaration_type;
+class Method;
+class Methods;
+class Named_object;
+class Label;
+class Translate_context;
+class Backend;
+class Export;
+class Import;
+class Bexpression;
+class Bstatement;
+class Bblock;
+class Bvariable;
+class Blabel;
+
+// This file declares the basic classes used to hold the internal
+// representation of Go which is built by the parser.
+
+// An initialization function for an imported package. This is a
+// magic function which initializes variables and runs the "init"
+// function.
+
+class Import_init
+{
+ public:
+ Import_init(const std::string& package_name, const std::string& init_name,
+ int priority)
+ : package_name_(package_name), init_name_(init_name), priority_(priority)
+ { }
+
+ // The name of the package being imported.
+ const std::string&
+ package_name() const
+ { return this->package_name_; }
+
+ // The name of the package's init function.
+ const std::string&
+ init_name() const
+ { return this->init_name_; }
+
+ // The priority of the initialization function. Functions with a
+ // lower priority number must be run first.
+ int
+ priority() const
+ { return this->priority_; }
+
+ private:
+ // The name of the package being imported.
+ std::string package_name_;
+ // The name of the package's init function.
+ std::string init_name_;
+ // The priority.
+ int priority_;
+};
+
+// For sorting purposes.
+
+inline bool
+operator<(const Import_init& i1, const Import_init& i2)
+{
+ if (i1.priority() < i2.priority())
+ return true;
+ if (i1.priority() > i2.priority())
+ return false;
+ if (i1.package_name() != i2.package_name())
+ return i1.package_name() < i2.package_name();
+ return i1.init_name() < i2.init_name();
+}
+
+// The holder for the internal representation of the entire
+// compilation unit.
+
+class Gogo
+{
+ public:
+ // Create the IR, passing in the sizes of the types "int" and
+ // "uintptr" in bits.
+ Gogo(Backend* backend, int int_type_size, int pointer_size);
+
+ // Get the backend generator.
+ Backend*
+ backend()
+ { return this->backend_; }
+
+ // Get the package name.
+ const std::string&
+ package_name() const;
+
+ // Set the package name.
+ void
+ set_package_name(const std::string&, source_location);
+
+ // Return whether this is the "main" package.
+ bool
+ is_main_package() const;
+
+ // If necessary, adjust the name to use for a hidden symbol. We add
+ // a prefix of the package name, so that hidden symbols in different
+ // packages do not collide.
+ std::string
+ pack_hidden_name(const std::string& name, bool is_exported) const
+ {
+ return (is_exported
+ ? name
+ : ('.' + this->unique_prefix()
+ + '.' + this->package_name()
+ + '.' + name));
+ }
+
+ // Unpack a name which may have been hidden. Returns the
+ // user-visible name of the object.
+ static std::string
+ unpack_hidden_name(const std::string& name)
+ { return name[0] != '.' ? name : name.substr(name.rfind('.') + 1); }
+
+ // Return whether a possibly packed name is hidden.
+ static bool
+ is_hidden_name(const std::string& name)
+ { return name[0] == '.'; }
+
+ // Return the package prefix of a hidden name.
+ static std::string
+ hidden_name_prefix(const std::string& name)
+ {
+ go_assert(Gogo::is_hidden_name(name));
+ return name.substr(1, name.rfind('.') - 1);
+ }
+
+ // Given a name which may or may not have been hidden, return the
+ // name to use in an error message.
+ static std::string
+ message_name(const std::string& name);
+
+ // Return whether a name is the blank identifier _.
+ static bool
+ is_sink_name(const std::string& name)
+ {
+ return (name[0] == '.'
+ && name[name.length() - 1] == '_'
+ && name[name.length() - 2] == '.');
+ }
+
+ // Return the unique prefix to use for all exported symbols.
+ const std::string&
+ unique_prefix() const;
+
+ // Set the unique prefix.
+ void
+ set_unique_prefix(const std::string&);
+
+ // Return the priority to use for the package we are compiling.
+ // This is two more than the largest priority of any package we
+ // import.
+ int
+ package_priority() const;
+
+ // Import a package. FILENAME is the file name argument, LOCAL_NAME
+ // is the local name to give to the package. If LOCAL_NAME is empty
+ // the declarations are added to the global scope.
+ void
+ import_package(const std::string& filename, const std::string& local_name,
+ bool is_local_name_exported, source_location);
+
+ // Whether we are the global binding level.
+ bool
+ in_global_scope() const;
+
+ // Look up a name in the current binding contours.
+ Named_object*
+ lookup(const std::string&, Named_object** pfunction) const;
+
+ // Look up a name in the current block.
+ Named_object*
+ lookup_in_block(const std::string&) const;
+
+ // Look up a name in the global namespace--the universal scope.
+ Named_object*
+ lookup_global(const char*) const;
+
+ // Add a new imported package. REAL_NAME is the real name of the
+ // package. ALIAS is the alias of the package; this may be the same
+ // as REAL_NAME. This sets *PADD_TO_GLOBALS if symbols added to
+ // this package should be added to the global namespace; this is
+ // true if the alias is ".". LOCATION is the location of the import
+ // statement. This returns the new package, or NULL on error.
+ Package*
+ add_imported_package(const std::string& real_name, const std::string& alias,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals);
+
+ // Register a package. This package may or may not be imported.
+ // This returns the Package structure for the package, creating if
+ // it necessary.
+ Package*
+ register_package(const std::string& name, const std::string& unique_prefix,
+ source_location);
+
+ // Start compiling a function. ADD_METHOD_TO_TYPE is true if a
+ // method function should be added to the type of its receiver.
+ Named_object*
+ start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location);
+
+ // Finish compiling a function.
+ void
+ finish_function(source_location);
+
+ // Return the current function.
+ Named_object*
+ current_function() const;
+
+ // Start a new block. This is not initially associated with a
+ // function.
+ void
+ start_block(source_location);
+
+ // Finish the current block and return it.
+ Block*
+ finish_block(source_location);
+
+ // Declare an unknown name. This is used while parsing. The name
+ // must be resolved by the end of the parse. Unknown names are
+ // always added at the package level.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location);
+
+ // Declare a function.
+ Named_object*
+ declare_function(const std::string&, Function_type*, source_location);
+
+ // Add a label.
+ Label*
+ add_label_definition(const std::string&, source_location);
+
+ // Add a label reference.
+ Label*
+ add_label_reference(const std::string&);
+
+ // Add a statement to the current block.
+ void
+ add_statement(Statement*);
+
+ // Add a block to the current block.
+ void
+ add_block(Block*, source_location);
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier&, Expression*, int iota_value);
+
+ // Add a type.
+ void
+ add_type(const std::string&, Type*, source_location);
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ void
+ add_named_type(Named_type*);
+
+ // Declare a type.
+ Named_object*
+ declare_type(const std::string&, source_location);
+
+ // Declare a type at the package level. This is used when the
+ // parser sees an unknown name where a type name is required.
+ Named_object*
+ declare_package_type(const std::string&, source_location);
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string&, Variable*);
+
+ // Add a sink--a reference to the blank identifier _.
+ Named_object*
+ add_sink();
+
+ // Add a named object to the current namespace. This is used for
+ // import . "package".
+ void
+ add_named_object(Named_object*);
+
+ // Return a name to use for a thunk function. A thunk function is
+ // one we create during the compilation, for a go statement or a
+ // defer statement or a method expression.
+ static std::string
+ thunk_name();
+
+ // Return whether an object is a thunk.
+ static bool
+ is_thunk(const Named_object*);
+
+ // Note that we've seen an interface type. This is used to build
+ // all required interface method tables.
+ void
+ record_interface_type(Interface_type*);
+
+ // Note that we need an initialization function.
+ void
+ set_need_init_fn()
+ { this->need_init_fn_ = true; }
+
+ // Clear out all names in file scope. This is called when we start
+ // parsing a new file.
+ void
+ clear_file_scope();
+
+ // Traverse the tree. See the Traverse class.
+ void
+ traverse(Traverse*);
+
+ // Define the predeclared global names.
+ void
+ define_global_names();
+
+ // Verify and complete all types.
+ void
+ verify_types();
+
+ // Lower the parse tree.
+ void
+ lower_parse_tree();
+
+ // Lower all the statements in a block.
+ void
+ lower_block(Named_object* function, Block*);
+
+ // Lower an expression.
+ void
+ lower_expression(Named_object* function, Expression**);
+
+ // Lower a constant.
+ void
+ lower_constant(Named_object*);
+
+ // Finalize the method lists and build stub methods for named types.
+ void
+ finalize_methods();
+
+ // Work out the types to use for unspecified variables and
+ // constants.
+ void
+ determine_types();
+
+ // Type check the program.
+ void
+ check_types();
+
+ // Check the types in a single block. This is used for complicated
+ // go statements.
+ void
+ check_types_in_block(Block*);
+
+ // Check for return statements.
+ void
+ check_return_statements();
+
+ // Do all exports.
+ void
+ do_exports();
+
+ // Add an import control function for an imported package to the
+ // list.
+ void
+ add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio);
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ void
+ remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ void
+ order_evaluations();
+
+ // Build thunks for functions which call recover.
+ void
+ build_recover_thunks();
+
+ // Simplify statements which might use thunks: go and defer
+ // statements.
+ void
+ simplify_thunk_statements();
+
+ // Convert named types to the backend representation.
+ void
+ convert_named_types();
+
+ // Convert named types in a list of bindings.
+ void
+ convert_named_types_in_bindings(Bindings*);
+
+ // True if named types have been converted to the backend
+ // representation.
+ bool
+ named_types_are_converted() const
+ { return this->named_types_are_converted_; }
+
+ // Write out the global values.
+ void
+ write_globals();
+
+ // Build a call to a builtin function. PDECL should point to a NULL
+ // initialized static pointer which will hold the fndecl. NAME is
+ // the name of the function. NARGS is the number of arguments.
+ // RETTYPE is the return type. It is followed by NARGS pairs of
+ // type and argument (both trees).
+ static tree
+ call_builtin(tree* pdecl, source_location, const char* name, int nargs,
+ tree rettype, ...);
+
+ // Build a call to the runtime error function.
+ static tree
+ runtime_error(int code, source_location);
+
+ // Build a builtin struct with a list of fields.
+ static tree
+ builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...);
+
+ // Mark a function declaration as a builtin library function.
+ static void
+ mark_fndecl_as_builtin_library(tree fndecl);
+
+ // Build the type of the struct that holds a slice for the given
+ // element type.
+ tree
+ slice_type_tree(tree element_type_tree);
+
+ // Given a tree for a slice type, return the tree for the element
+ // type.
+ static tree
+ slice_element_type_tree(tree slice_type_tree);
+
+ // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+ // the slice. VALUES points to the values. COUNT is the size,
+ // CAPACITY is the capacity. If CAPACITY is NULL, it is set to
+ // COUNT.
+ static tree
+ slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity);
+
+ // Build a constructor for an empty slice. SLICE_TYPE_TREE is the
+ // type of the slice.
+ static tree
+ empty_slice_constructor(tree slice_type_tree);
+
+ // Build a map descriptor.
+ tree
+ map_descriptor(Map_type*);
+
+ // Return a tree for the type of a map descriptor. This is struct
+ // __go_map_descriptor in libgo/runtime/map.h. This is the same for
+ // all map types.
+ tree
+ map_descriptor_type();
+
+ // Build a type descriptor for TYPE using INITIALIZER as the type
+ // descriptor. This builds a new decl stored in *PDECL.
+ void
+ build_type_descriptor_decl(const Type*, Expression* initializer,
+ tree* pdecl);
+
+ // Build required interface method tables.
+ void
+ build_interface_method_tables();
+
+ // Build an interface method table for a type: a list of function
+ // pointers, one for each interface method. This returns a decl.
+ tree
+ interface_method_table_for_type(const Interface_type*, Named_type*,
+ bool is_pointer);
+
+ // Return a tree which allocate SIZE bytes to hold values of type
+ // TYPE.
+ tree
+ allocate_memory(Type *type, tree size, source_location);
+
+ // Return a type to use for pointer to const char.
+ static tree
+ const_char_pointer_type_tree();
+
+ // Build a string constant with the right type.
+ static tree
+ string_constant_tree(const std::string&);
+
+ // Build a Go string constant. This returns a pointer to the
+ // constant.
+ tree
+ go_string_constant_tree(const std::string&);
+
+ // Receive a value from a channel.
+ static tree
+ receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location);
+
+ // Return a tree for receiving an integer on a channel.
+ static tree
+ receive_as_64bit_integer(tree type, tree channel, bool blocking,
+ bool for_select);
+
+
+ // Make a trampoline which calls FNADDR passing CLOSURE.
+ tree
+ make_trampoline(tree fnaddr, tree closure, source_location);
+
+ private:
+ // During parsing, we keep a stack of functions. Each function on
+ // the stack is one that we are currently parsing. For each
+ // function, we keep track of the current stack of blocks.
+ struct Open_function
+ {
+ // The function.
+ Named_object* function;
+ // The stack of active blocks in the function.
+ std::vector<Block*> blocks;
+ };
+
+ // The stack of functions.
+ typedef std::vector<Open_function> Open_functions;
+
+ // Create trees for implicit builtin functions.
+ void
+ define_builtin_function_trees();
+
+ // Set up the built-in unsafe package.
+ void
+ import_unsafe(const std::string&, bool is_exported, source_location);
+
+ // Add a new imported package.
+ Named_object*
+ add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location);
+
+ // Return the current binding contour.
+ Bindings*
+ current_bindings();
+
+ const Bindings*
+ current_bindings() const;
+
+ // Return the current block.
+ Block*
+ current_block();
+
+ // Get the name of the magic initialization function.
+ const std::string&
+ get_init_fn_name();
+
+ // Get the decl for the magic initialization function.
+ tree
+ initialization_function_decl();
+
+ // Write the magic initialization function.
+ void
+ write_initialization_function(tree fndecl, tree init_stmt_list);
+
+ // Initialize imported packages.
+ void
+ init_imports(tree*);
+
+ // Register variables with the garbage collector.
+ void
+ register_gc_vars(const std::vector<Named_object*>&, tree*);
+
+ // Build a pointer to a Go string constant. This returns a pointer
+ // to the pointer.
+ tree
+ ptr_go_string_constant_tree(const std::string&);
+
+ // Return the name to use for a type descriptor decl for an unnamed
+ // type.
+ std::string
+ unnamed_type_descriptor_decl_name(const Type* type);
+
+ // Return the name to use for a type descriptor decl for a type
+ // named NO, defined in IN_FUNCTION.
+ std::string
+ type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function);
+
+ // Where a type descriptor should be defined.
+ enum Type_descriptor_location
+ {
+ // Defined in this file.
+ TYPE_DESCRIPTOR_DEFINED,
+ // Defined in some other file.
+ TYPE_DESCRIPTOR_UNDEFINED,
+ // Common definition which may occur in multiple files.
+ TYPE_DESCRIPTOR_COMMON
+ };
+
+ // Return where the decl for TYPE should be defined.
+ Type_descriptor_location
+ type_descriptor_location(const Type* type);
+
+ // Return the type of a trampoline.
+ static tree
+ trampoline_type_tree();
+
+ // Type used to map import names to packages.
+ typedef std::map<std::string, Package*> Imports;
+
+ // Type used to map package names to packages.
+ typedef std::map<std::string, Package*> Packages;
+
+ // Type used to map special names in the sys package.
+ typedef std::map<std::string, std::string> Sys_names;
+
+ // Hash table mapping map types to map descriptor decls.
+ typedef Unordered_map_hash(const Map_type*, tree, Type_hash_identical,
+ Type_identical) Map_descriptors;
+
+ // Map unnamed types to type descriptor decls.
+ typedef Unordered_map_hash(const Type*, tree, Type_hash_identical,
+ Type_identical) Type_descriptor_decls;
+
+ // The backend generator.
+ Backend* backend_;
+ // The package we are compiling.
+ Package* package_;
+ // The list of currently open functions during parsing.
+ Open_functions functions_;
+ // The global binding contour. This includes the builtin functions
+ // and the package we are compiling.
+ Bindings* globals_;
+ // Mapping from import file names to packages.
+ Imports imports_;
+ // Whether the magic unsafe package was imported.
+ bool imported_unsafe_;
+ // Mapping from package names we have seen to packages. This does
+ // not include the package we are compiling.
+ Packages packages_;
+ // Mapping from map types to map descriptors.
+ Map_descriptors* map_descriptors_;
+ // Mapping from unnamed types to type descriptor decls.
+ Type_descriptor_decls* type_descriptor_decls_;
+ // The functions named "init", if there are any.
+ std::vector<Named_object*> init_functions_;
+ // Whether we need a magic initialization function.
+ bool need_init_fn_;
+ // The name of the magic initialization function.
+ std::string init_fn_name_;
+ // A list of import control variables for packages that we import.
+ std::set<Import_init> imported_init_fns_;
+ // The unique prefix used for all global symbols.
+ std::string unique_prefix_;
+ // Whether an explicit unique prefix was set by -fgo-prefix.
+ bool unique_prefix_specified_;
+ // A list of interface types defined while parsing.
+ std::vector<Interface_type*> interface_types_;
+ // Whether named types have been converted.
+ bool named_types_are_converted_;
+};
+
+// A block of statements.
+
+class Block
+{
+ public:
+ Block(Block* enclosing, source_location);
+
+ // Return the enclosing block.
+ const Block*
+ enclosing() const
+ { return this->enclosing_; }
+
+ // Return the bindings of the block.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ const Bindings*
+ bindings() const
+ { return this->bindings_; }
+
+ // Look at the block's statements.
+ const std::vector<Statement*>*
+ statements() const
+ { return &this->statements_; }
+
+ // Return the start location. This is normally the location of the
+ // left curly brace which starts the block.
+ source_location
+ start_location() const
+ { return this->start_location_; }
+
+ // Return the end location. This is normally the location of the
+ // right curly brace which ends the block.
+ source_location
+ end_location() const
+ { return this->end_location_; }
+
+ // Add a statement to the block.
+ void
+ add_statement(Statement*);
+
+ // Add a statement to the front of the block.
+ void
+ add_statement_at_front(Statement*);
+
+ // Replace a statement in a block.
+ void
+ replace_statement(size_t index, Statement*);
+
+ // Add a Statement before statement number INDEX.
+ void
+ insert_statement_before(size_t index, Statement*);
+
+ // Add a Statement after statement number INDEX.
+ void
+ insert_statement_after(size_t index, Statement*);
+
+ // Set the end location of the block.
+ void
+ set_end_location(source_location location)
+ { this->end_location_ = location; }
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Set final types for unspecified variables and constants.
+ void
+ determine_types();
+
+ // Return true if execution of this block may fall through to the
+ // next block.
+ bool
+ may_fall_through() const;
+
+ // Convert the block to the backend representation.
+ Bblock*
+ get_backend(Translate_context*);
+
+ // Iterate over statements.
+
+ typedef std::vector<Statement*>::iterator iterator;
+
+ iterator
+ begin()
+ { return this->statements_.begin(); }
+
+ iterator
+ end()
+ { return this->statements_.end(); }
+
+ private:
+ // Enclosing block.
+ Block* enclosing_;
+ // Statements in the block.
+ std::vector<Statement*> statements_;
+ // Binding contour.
+ Bindings* bindings_;
+ // Location of start of block.
+ source_location start_location_;
+ // Location of end of block.
+ source_location end_location_;
+};
+
+// A function.
+
+class Function
+{
+ public:
+ Function(Function_type* type, Function*, Block*, source_location);
+
+ // Return the function's type.
+ Function_type*
+ type() const
+ { return this->type_; }
+
+ // Return the enclosing function if there is one.
+ Function*
+ enclosing()
+ { return this->enclosing_; }
+
+ // Set the enclosing function. This is used when building thunks
+ // for functions which call recover.
+ void
+ set_enclosing(Function* enclosing)
+ {
+ go_assert(this->enclosing_ == NULL);
+ this->enclosing_ = enclosing;
+ }
+
+ // The result variables.
+ typedef std::vector<Named_object*> Results;
+
+ // Create the result variables in the outer block.
+ void
+ create_result_variables(Gogo*);
+
+ // Update the named result variables when cloning a function which
+ // calls recover.
+ void
+ update_result_variables();
+
+ // Return the result variables.
+ Results*
+ result_variables()
+ { return this->results_; }
+
+ // Whether the result variables have names.
+ bool
+ results_are_named() const
+ { return this->results_are_named_; }
+
+ // Add a new field to the closure variable.
+ void
+ add_closure_field(Named_object* var, source_location loc)
+ { this->closure_fields_.push_back(std::make_pair(var, loc)); }
+
+ // Whether this function needs a closure.
+ bool
+ needs_closure() const
+ { return !this->closure_fields_.empty(); }
+
+ // Return the closure variable, creating it if necessary. This is
+ // passed to the function as a static chain parameter.
+ Named_object*
+ closure_var();
+
+ // Set the closure variable. This is used when building thunks for
+ // functions which call recover.
+ void
+ set_closure_var(Named_object* v)
+ {
+ go_assert(this->closure_var_ == NULL);
+ this->closure_var_ = v;
+ }
+
+ // Return the variable for a reference to field INDEX in the closure
+ // variable.
+ Named_object*
+ enclosing_var(unsigned int index)
+ {
+ go_assert(index < this->closure_fields_.size());
+ return closure_fields_[index].first;
+ }
+
+ // Set the type of the closure variable if there is one.
+ void
+ set_closure_type();
+
+ // Get the block of statements associated with the function.
+ Block*
+ block() const
+ { return this->block_; }
+
+ // Get the location of the start of the function.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return whether this function is actually a method.
+ bool
+ is_method() const;
+
+ // Add a label definition to the function.
+ Label*
+ add_label_definition(const std::string& label_name, source_location);
+
+ // Add a label reference to a function.
+ Label*
+ add_label_reference(const std::string& label_name);
+
+ // Warn about labels that are defined but not used.
+ void
+ check_labels() const;
+
+ // Whether this function calls the predeclared recover function.
+ bool
+ calls_recover() const
+ { return this->calls_recover_; }
+
+ // Record that this function calls the predeclared recover function.
+ // This is set during the lowering pass.
+ void
+ set_calls_recover()
+ { this->calls_recover_ = true; }
+
+ // Whether this is a recover thunk function.
+ bool
+ is_recover_thunk() const
+ { return this->is_recover_thunk_; }
+
+ // Record that this is a thunk built for a function which calls
+ // recover.
+ void
+ set_is_recover_thunk()
+ { this->is_recover_thunk_ = true; }
+
+ // Whether this function already has a recover thunk.
+ bool
+ has_recover_thunk() const
+ { return this->has_recover_thunk_; }
+
+ // Record that this function already has a recover thunk.
+ void
+ set_has_recover_thunk()
+ { this->has_recover_thunk_ = true; }
+
+ // Swap with another function. Used only for the thunk which calls
+ // recover.
+ void
+ swap_for_recover(Function *);
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Determine types in the function.
+ void
+ determine_types();
+
+ // Return the function's decl given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Return the function's decl after it has been built.
+ tree
+ get_decl() const
+ {
+ go_assert(this->fndecl_ != NULL);
+ return this->fndecl_;
+ }
+
+ // Set the function decl to hold a tree of the function code.
+ void
+ build_tree(Gogo*, Named_object*);
+
+ // Get the value to return when not explicitly specified. May also
+ // add statements to execute first to STMT_LIST.
+ tree
+ return_value(Gogo*, Named_object*, source_location, tree* stmt_list) const;
+
+ // Get a tree for the variable holding the defer stack.
+ Expression*
+ defer_stack(source_location);
+
+ // Export the function.
+ void
+ export_func(Export*, const std::string& name) const;
+
+ // Export a function with a type.
+ static void
+ export_func_with_type(Export*, const std::string& name,
+ const Function_type*);
+
+ // Import a function.
+ static void
+ import_func(Import*, std::string* pname, Typed_identifier** receiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults, bool* is_varargs);
+
+ private:
+ // Type for mapping from label names to Label objects.
+ typedef Unordered_map(std::string, Label*) Labels;
+
+ tree
+ make_receiver_parm_decl(Gogo*, Named_object*, tree);
+
+ tree
+ copy_parm_to_heap(Gogo*, Named_object*, tree);
+
+ void
+ build_defer_wrapper(Gogo*, Named_object*, tree*, tree*);
+
+ typedef std::vector<std::pair<Named_object*,
+ source_location> > Closure_fields;
+
+ // The function's type.
+ Function_type* type_;
+ // The enclosing function. This is NULL when there isn't one, which
+ // is the normal case.
+ Function* enclosing_;
+ // The result variables, if any.
+ Results* results_;
+ // If there is a closure, this is the list of variables which appear
+ // in the closure. This is created by the parser, and then resolved
+ // to a real type when we lower parse trees.
+ Closure_fields closure_fields_;
+ // The closure variable, passed as a parameter using the static
+ // chain parameter. Normally NULL.
+ Named_object* closure_var_;
+ // The outer block of statements in the function.
+ Block* block_;
+ // The source location of the start of the function.
+ source_location location_;
+ // Labels defined or referenced in the function.
+ Labels labels_;
+ // The function decl.
+ tree fndecl_;
+ // The defer stack variable. A pointer to this variable is used to
+ // distinguish the defer stack for one function from another. This
+ // is NULL unless we actually need a defer stack.
+ Temporary_statement* defer_stack_;
+ // True if the result variables are named.
+ bool results_are_named_;
+ // True if this function calls the predeclared recover function.
+ bool calls_recover_;
+ // True if this a thunk built for a function which calls recover.
+ bool is_recover_thunk_;
+ // True if this function already has a recover thunk.
+ bool has_recover_thunk_;
+};
+
+// A function declaration.
+
+class Function_declaration
+{
+ public:
+ Function_declaration(Function_type* fntype, source_location location)
+ : fntype_(fntype), location_(location), asm_name_(), fndecl_(NULL)
+ { }
+
+ Function_type*
+ type() const
+ { return this->fntype_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ const std::string&
+ asm_name() const
+ { return this->asm_name_; }
+
+ // Set the assembler name.
+ void
+ set_asm_name(const std::string& asm_name)
+ { this->asm_name_ = asm_name; }
+
+ // Return a decl for the function given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Export a function declaration.
+ void
+ export_func(Export* exp, const std::string& name) const
+ { Function::export_func_with_type(exp, name, this->fntype_); }
+
+ private:
+ // The type of the function.
+ Function_type* fntype_;
+ // The location of the declaration.
+ source_location location_;
+ // The assembler name: this is the name to use in references to the
+ // function. This is normally empty.
+ std::string asm_name_;
+ // The function decl if needed.
+ tree fndecl_;
+};
+
+// A variable.
+
+class Variable
+{
+ public:
+ Variable(Type*, Expression*, bool is_global, bool is_parameter,
+ bool is_receiver, source_location);
+
+ // Get the type of the variable.
+ Type*
+ type();
+
+ Type*
+ type() const;
+
+ // Return whether the type is defined yet.
+ bool
+ has_type() const
+ { return this->type_ != NULL; }
+
+ // Get the initial value.
+ Expression*
+ init() const
+ { return this->init_; }
+
+ // Return whether there are any preinit statements.
+ bool
+ has_pre_init() const
+ { return this->preinit_ != NULL; }
+
+ // Return the preinit statements if any.
+ Block*
+ preinit() const
+ { return this->preinit_; }
+
+ // Return whether this is a global variable.
+ bool
+ is_global() const
+ { return this->is_global_; }
+
+ // Return whether this is a function parameter.
+ bool
+ is_parameter() const
+ { return this->is_parameter_; }
+
+ // Return whether this is the receiver parameter of a method.
+ bool
+ is_receiver() const
+ { return this->is_receiver_; }
+
+ // Change this parameter to be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_receiver()
+ {
+ go_assert(this->is_parameter_);
+ this->is_receiver_ = true;
+ }
+
+ // Change this parameter to not be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_not_receiver()
+ {
+ go_assert(this->is_parameter_);
+ this->is_receiver_ = false;
+ }
+
+ // Return whether this is the varargs parameter of a function.
+ bool
+ is_varargs_parameter() const
+ { return this->is_varargs_parameter_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_ && !this->is_global_; }
+
+ // Get the source location of the variable's declaration.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Record that this is the varargs parameter of a function.
+ void
+ set_is_varargs_parameter()
+ {
+ go_assert(this->is_parameter_);
+ this->is_varargs_parameter_ = true;
+ }
+
+ // Clear the initial value; used for error handling.
+ void
+ clear_init()
+ { this->init_ = NULL; }
+
+ // Set the initial value; used for converting shortcuts.
+ void
+ set_init(Expression* init)
+ { this->init_ = init; }
+
+ // Get the preinit block, a block of statements to be run before the
+ // initialization expression.
+ Block*
+ preinit_block(Gogo*);
+
+ // Add a statement to be run before the initialization expression.
+ // This is only used for global variables.
+ void
+ add_preinit_statement(Gogo*, Statement*);
+
+ // Lower the initialization expression after parsing is complete.
+ void
+ lower_init_expression(Gogo*, Named_object*);
+
+ // A special case: the init value is used only to determine the
+ // type. This is used if the variable is defined using := with the
+ // comma-ok form of a map index or a receive expression. The init
+ // value is actually the map index expression or receive expression.
+ // We use this because we may not know the right type at parse time.
+ void
+ set_type_from_init_tuple()
+ { this->type_from_init_tuple_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a range clause. The init value is the range expression. The
+ // type of the variable is the index type of the range expression
+ // (i.e., the first value returned by a range).
+ void
+ set_type_from_range_index()
+ { this->type_from_range_index_ = true; }
+
+ // Another special case: like set_type_from_range_index, but the
+ // type is the value type of the range expression (i.e., the second
+ // value returned by a range).
+ void
+ set_type_from_range_value()
+ { this->type_from_range_value_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a case in a select statement. The init value is the channel.
+ // The type of the variable is the channel's element type.
+ void
+ set_type_from_chan_element()
+ { this->type_from_chan_element_ = true; }
+
+ // After we lower the select statement, we once again set the type
+ // from the initialization expression.
+ void
+ clear_type_from_chan_element()
+ {
+ go_assert(this->type_from_chan_element_);
+ this->type_from_chan_element_ = false;
+ }
+
+ // Note that this variable was created for a type switch clause.
+ void
+ set_is_type_switch_var()
+ { this->is_type_switch_var_ = true; }
+
+ // Traverse the initializer expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the variable if necessary.
+ void
+ determine_type();
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Get the backend representation of the variable.
+ Bvariable*
+ get_backend_variable(Gogo*, Named_object*, const Package*,
+ const std::string&);
+
+ // Get the initial value of the variable as a tree. This may only
+ // be called if has_pre_init() returns false.
+ tree
+ get_init_tree(Gogo*, Named_object* function);
+
+ // Return a series of statements which sets the value of the
+ // variable in DECL. This should only be called is has_pre_init()
+ // returns true. DECL may be NULL for a sink variable.
+ tree
+ get_init_block(Gogo*, Named_object* function, tree decl);
+
+ // Export the variable.
+ void
+ export_var(Export*, const std::string& name) const;
+
+ // Import a variable.
+ static void
+ import_var(Import*, std::string* pname, Type** ptype);
+
+ private:
+ // The type of a tuple.
+ Type*
+ type_from_tuple(Expression*, bool) const;
+
+ // The type of a range.
+ Type*
+ type_from_range(Expression*, bool, bool) const;
+
+ // The element type of a channel.
+ Type*
+ type_from_chan_element(Expression*, bool) const;
+
+ // The variable's type. This may be NULL if the type is set from
+ // the expression.
+ Type* type_;
+ // The initial value. This may be NULL if the variable should be
+ // initialized to the default value for the type.
+ Expression* init_;
+ // Statements to run before the init statement.
+ Block* preinit_;
+ // Location of variable definition.
+ source_location location_;
+ // Backend representation.
+ Bvariable* backend_;
+ // Whether this is a global variable.
+ bool is_global_ : 1;
+ // Whether this is a function parameter.
+ bool is_parameter_ : 1;
+ // Whether this is the receiver parameter of a method.
+ bool is_receiver_ : 1;
+ // Whether this is the varargs parameter of a function.
+ bool is_varargs_parameter_ : 1;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_ : 1;
+ // True if we have seen this variable in a traversal.
+ bool seen_ : 1;
+ // True if we have lowered the initialization expression.
+ bool init_is_lowered_ : 1;
+ // True if init is a tuple used to set the type.
+ bool type_from_init_tuple_ : 1;
+ // True if init is a range clause and the type is the index type.
+ bool type_from_range_index_ : 1;
+ // True if init is a range clause and the type is the value type.
+ bool type_from_range_value_ : 1;
+ // True if init is a channel and the type is the channel's element type.
+ bool type_from_chan_element_ : 1;
+ // True if this is a variable created for a type switch case.
+ bool is_type_switch_var_ : 1;
+ // True if we have determined types.
+ bool determined_type_ : 1;
+};
+
+// A variable which is really the name for a function return value, or
+// part of one.
+
+class Result_variable
+{
+ public:
+ Result_variable(Type* type, Function* function, int index,
+ source_location location)
+ : type_(type), function_(function), index_(index), location_(location),
+ backend_(NULL), is_address_taken_(false)
+ { }
+
+ // Get the type of the result variable.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Get the function that this is associated with.
+ Function*
+ function() const
+ { return this->function_; }
+
+ // Index in the list of function results.
+ int
+ index() const
+ { return this->index_; }
+
+ // The location of the variable definition.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_; }
+
+ // Set the function. This is used when cloning functions which call
+ // recover.
+ void
+ set_function(Function* function)
+ { this->function_ = function; }
+
+ // Get the backend representation of the variable.
+ Bvariable*
+ get_backend_variable(Gogo*, Named_object*, const std::string&);
+
+ private:
+ // Type of result variable.
+ Type* type_;
+ // Function with which this is associated.
+ Function* function_;
+ // Index in list of results.
+ int index_;
+ // Where the result variable is defined.
+ source_location location_;
+ // Backend representation.
+ Bvariable* backend_;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_;
+};
+
+// The value we keep for a named constant. This lets us hold a type
+// and an expression.
+
+class Named_constant
+{
+ public:
+ Named_constant(Type* type, Expression* expr, int iota_value,
+ source_location location)
+ : type_(type), expr_(expr), iota_value_(iota_value), location_(location),
+ lowering_(false)
+ { }
+
+ Type*
+ type() const
+ { return this->type_; }
+
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ int
+ iota_value() const
+ { return this->iota_value_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether we are lowering.
+ bool
+ lowering() const
+ { return this->lowering_; }
+
+ // Set that we are lowering.
+ void
+ set_lowering()
+ { this->lowering_ = true; }
+
+ // We are no longer lowering.
+ void
+ clear_lowering()
+ { this->lowering_ = false; }
+
+ // Traverse the expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the constant if necessary.
+ void
+ determine_type();
+
+ // Indicate that we found and reported an error for this constant.
+ void
+ set_error();
+
+ // Export the constant.
+ void
+ export_const(Export*, const std::string& name) const;
+
+ // Import a constant.
+ static void
+ import_const(Import*, std::string*, Type**, Expression**);
+
+ private:
+ // The type of the constant.
+ Type* type_;
+ // The expression for the constant.
+ Expression* expr_;
+ // If the predeclared constant iota is used in EXPR_, this is the
+ // value it will have. We do this because at parse time we don't
+ // know whether the name "iota" will refer to the predeclared
+ // constant or to something else. We put in the right value in when
+ // we lower.
+ int iota_value_;
+ // The location of the definition.
+ source_location location_;
+ // Whether we are currently lowering this constant.
+ bool lowering_;
+};
+
+// A type declaration.
+
+class Type_declaration
+{
+ public:
+ Type_declaration(source_location location)
+ : location_(location), in_function_(NULL), methods_(),
+ issued_warning_(false)
+ { }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the function in which this type is declared. This will
+ // return NULL for a type declared in global scope.
+ Named_object*
+ in_function()
+ { return this->in_function_; }
+
+ // Set the function in which this type is declared.
+ void
+ set_in_function(Named_object* f)
+ { this->in_function_ = f; }
+
+ // Add a method to this type. This is used when methods are defined
+ // before the type.
+ Named_object*
+ add_method(const std::string& name, Function* function);
+
+ // Add a method declaration to this type.
+ Named_object*
+ add_method_declaration(const std::string& name, Function_type* type,
+ source_location location);
+
+ // Return whether any methods were defined.
+ bool
+ has_methods() const;
+
+ // Define methods when the real type is known.
+ void
+ define_methods(Named_type*);
+
+ // This is called if we are trying to use this type. It returns
+ // true if we should issue a warning.
+ bool
+ using_type();
+
+ private:
+ typedef std::vector<Named_object*> Methods;
+
+ // The location of the type declaration.
+ source_location location_;
+ // If this type is declared in a function, a pointer back to the
+ // function in which it is defined.
+ Named_object* in_function_;
+ // Methods defined before the type is defined.
+ Methods methods_;
+ // True if we have issued a warning about a use of this type
+ // declaration when it is undefined.
+ bool issued_warning_;
+};
+
+// An unknown object. These are created by the parser for forward
+// references to names which have not been seen before. In a correct
+// program, these will always point to a real definition by the end of
+// the parse. Because they point to another Named_object, these may
+// only be referenced by Unknown_expression objects.
+
+class Unknown_name
+{
+ public:
+ Unknown_name(source_location location)
+ : location_(location), real_named_object_(NULL)
+ { }
+
+ // Return the location where this name was first seen.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the real named object that this points to, or NULL if it
+ // was never resolved.
+ Named_object*
+ real_named_object() const
+ { return this->real_named_object_; }
+
+ // Set the real named object that this points to.
+ void
+ set_real_named_object(Named_object* no);
+
+ private:
+ // The location where this name was first seen.
+ source_location location_;
+ // The real named object when it is known.
+ Named_object*
+ real_named_object_;
+};
+
+// A named object named. This is the result of a declaration. We
+// don't use a superclass because they all have to be handled
+// differently.
+
+class Named_object
+{
+ public:
+ enum Classification
+ {
+ // An uninitialized Named_object. We should never see this.
+ NAMED_OBJECT_UNINITIALIZED,
+ // An unknown name. This is used for forward references. In a
+ // correct program, these will all be resolved by the end of the
+ // parse.
+ NAMED_OBJECT_UNKNOWN,
+ // A const.
+ NAMED_OBJECT_CONST,
+ // A type.
+ NAMED_OBJECT_TYPE,
+ // A forward type declaration.
+ NAMED_OBJECT_TYPE_DECLARATION,
+ // A var.
+ NAMED_OBJECT_VAR,
+ // A result variable in a function.
+ NAMED_OBJECT_RESULT_VAR,
+ // The blank identifier--the special variable named _.
+ NAMED_OBJECT_SINK,
+ // A func.
+ NAMED_OBJECT_FUNC,
+ // A forward func declaration.
+ NAMED_OBJECT_FUNC_DECLARATION,
+ // A package.
+ NAMED_OBJECT_PACKAGE
+ };
+
+ // Return the classification.
+ Classification
+ classification() const
+ { return this->classification_; }
+
+ // Classifiers.
+
+ bool
+ is_unknown() const
+ { return this->classification_ == NAMED_OBJECT_UNKNOWN; }
+
+ bool
+ is_const() const
+ { return this->classification_ == NAMED_OBJECT_CONST; }
+
+ bool
+ is_type() const
+ { return this->classification_ == NAMED_OBJECT_TYPE; }
+
+ bool
+ is_type_declaration() const
+ { return this->classification_ == NAMED_OBJECT_TYPE_DECLARATION; }
+
+ bool
+ is_variable() const
+ { return this->classification_ == NAMED_OBJECT_VAR; }
+
+ bool
+ is_result_variable() const
+ { return this->classification_ == NAMED_OBJECT_RESULT_VAR; }
+
+ bool
+ is_sink() const
+ { return this->classification_ == NAMED_OBJECT_SINK; }
+
+ bool
+ is_function() const
+ { return this->classification_ == NAMED_OBJECT_FUNC; }
+
+ bool
+ is_function_declaration() const
+ { return this->classification_ == NAMED_OBJECT_FUNC_DECLARATION; }
+
+ bool
+ is_package() const
+ { return this->classification_ == NAMED_OBJECT_PACKAGE; }
+
+ // Creators.
+
+ static Named_object*
+ make_unknown_name(const std::string& name, source_location);
+
+ static Named_object*
+ make_constant(const Typed_identifier&, const Package*, Expression*,
+ int iota_value);
+
+ static Named_object*
+ make_type(const std::string&, const Package*, Type*, source_location);
+
+ static Named_object*
+ make_type_declaration(const std::string&, const Package*, source_location);
+
+ static Named_object*
+ make_variable(const std::string&, const Package*, Variable*);
+
+ static Named_object*
+ make_result_variable(const std::string&, Result_variable*);
+
+ static Named_object*
+ make_sink();
+
+ static Named_object*
+ make_function(const std::string&, const Package*, Function*);
+
+ static Named_object*
+ make_function_declaration(const std::string&, const Package*, Function_type*,
+ source_location);
+
+ static Named_object*
+ make_package(const std::string& alias, Package* package);
+
+ // Getters.
+
+ Unknown_name*
+ unknown_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ const Unknown_name*
+ unknown_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ Named_constant*
+ const_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ const Named_constant*
+ const_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ Named_type*
+ type_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ const Named_type*
+ type_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ Type_declaration*
+ type_declaration_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ const Type_declaration*
+ type_declaration_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ Variable*
+ var_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ const Variable*
+ var_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ Result_variable*
+ result_var_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ const Result_variable*
+ result_var_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ Function*
+ func_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ const Function*
+ func_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ Function_declaration*
+ func_declaration_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ const Function_declaration*
+ func_declaration_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ Package*
+ package_value()
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const Package*
+ package_value() const
+ {
+ go_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the name to use in an error message. The difference is
+ // that if this Named_object is defined in a different package, this
+ // will return PACKAGE.NAME.
+ std::string
+ message_name() const;
+
+ const Package*
+ package() const
+ { return this->package_; }
+
+ // Resolve an unknown value if possible. This returns the same
+ // Named_object or a new one.
+ Named_object*
+ resolve()
+ {
+ Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ const Named_object*
+ resolve() const
+ {
+ const Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ const Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ // The location where this object was defined or referenced.
+ source_location
+ location() const;
+
+ // Convert a variable to the backend representation.
+ Bvariable*
+ get_backend_variable(Gogo*, Named_object* function);
+
+ // Return a tree for the external identifier for this object.
+ tree
+ get_id(Gogo*);
+
+ // Return a tree representing this object.
+ tree
+ get_tree(Gogo*, Named_object* function);
+
+ // Define a type declaration.
+ void
+ set_type_value(Named_type*);
+
+ // Define a function declaration.
+ void
+ set_function_value(Function*);
+
+ // Declare an unknown name as a type declaration.
+ void
+ declare_as_type();
+
+ // Export this object.
+ void
+ export_named_object(Export*) const;
+
+ private:
+ Named_object(const std::string&, const Package*, Classification);
+
+ // The name of the object.
+ std::string name_;
+ // The package that this object is in. This is NULL if it is in the
+ // file we are compiling.
+ const Package* package_;
+ // The type of object this is.
+ Classification classification_;
+ // The real data.
+ union
+ {
+ Unknown_name* unknown_value;
+ Named_constant* const_value;
+ Named_type* type_value;
+ Type_declaration* type_declaration;
+ Variable* var_value;
+ Result_variable* result_var_value;
+ Function* func_value;
+ Function_declaration* func_declaration_value;
+ Package* package_value;
+ } u_;
+ // The DECL tree for this object if we have already converted it.
+ tree tree_;
+};
+
+// A binding contour. This binds names to objects.
+
+class Bindings
+{
+ public:
+ // Type for mapping from names to objects.
+ typedef Unordered_map(std::string, Named_object*) Contour;
+
+ Bindings(Bindings* enclosing);
+
+ // Add an unknown name.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location location)
+ {
+ return this->add_named_object(Named_object::make_unknown_name(name,
+ location));
+ }
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier& tid, const Package* package,
+ Expression* expr, int iota_value)
+ {
+ return this->add_named_object(Named_object::make_constant(tid, package,
+ expr,
+ iota_value));
+ }
+
+ // Add a type.
+ Named_object*
+ add_type(const std::string& name, const Package* package, Type* type,
+ source_location location)
+ {
+ return this->add_named_object(Named_object::make_type(name, package, type,
+ location));
+ }
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ Named_object*
+ add_named_type(Named_type* named_type);
+
+ // Add a type declaration.
+ Named_object*
+ add_type_declaration(const std::string& name, const Package* package,
+ source_location location)
+ {
+ Named_object* no = Named_object::make_type_declaration(name, package,
+ location);
+ return this->add_named_object(no);
+ }
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string& name, const Package* package,
+ Variable* variable)
+ {
+ return this->add_named_object(Named_object::make_variable(name, package,
+ variable));
+ }
+
+ // Add a result variable.
+ Named_object*
+ add_result_variable(const std::string& name, Result_variable* result)
+ {
+ return this->add_named_object(Named_object::make_result_variable(name,
+ result));
+ }
+
+ // Add a function.
+ Named_object*
+ add_function(const std::string& name, const Package*, Function* function);
+
+ // Add a function declaration.
+ Named_object*
+ add_function_declaration(const std::string& name, const Package* package,
+ Function_type* type, source_location location);
+
+ // Add a package. The location is the location of the import
+ // statement.
+ Named_object*
+ add_package(const std::string& alias, Package* package)
+ {
+ Named_object* no = Named_object::make_package(alias, package);
+ return this->add_named_object(no);
+ }
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a method to the list of objects. This is not added to the
+ // lookup table.
+ void
+ add_method(Named_object*);
+
+ // Add a named object to this binding.
+ Named_object*
+ add_named_object(Named_object* no)
+ { return this->add_named_object_to_contour(&this->bindings_, no); }
+
+ // Clear all names in file scope from the bindings.
+ void
+ clear_file_scope();
+
+ // Look up a name in this binding contour and in any enclosing
+ // binding contours. This returns NULL if the name is not found.
+ Named_object*
+ lookup(const std::string&) const;
+
+ // Look up a name in this binding contour without looking in any
+ // enclosing binding contours. Returns NULL if the name is not found.
+ Named_object*
+ lookup_local(const std::string&) const;
+
+ // Remove a name.
+ void
+ remove_binding(Named_object*);
+
+ // Traverse the tree. See the Traverse class.
+ int
+ traverse(Traverse*, bool is_global);
+
+ // Iterate over definitions. This does not include things which
+ // were only declared.
+
+ typedef std::vector<Named_object*>::const_iterator
+ const_definitions_iterator;
+
+ const_definitions_iterator
+ begin_definitions() const
+ { return this->named_objects_.begin(); }
+
+ const_definitions_iterator
+ end_definitions() const
+ { return this->named_objects_.end(); }
+
+ // Return the number of definitions.
+ size_t
+ size_definitions() const
+ { return this->named_objects_.size(); }
+
+ // Return whether there are no definitions.
+ bool
+ empty_definitions() const
+ { return this->named_objects_.empty(); }
+
+ // Iterate over declarations. This is everything that has been
+ // declared, which includes everything which has been defined.
+
+ typedef Contour::const_iterator const_declarations_iterator;
+
+ const_declarations_iterator
+ begin_declarations() const
+ { return this->bindings_.begin(); }
+
+ const_declarations_iterator
+ end_declarations() const
+ { return this->bindings_.end(); }
+
+ // Return the number of declarations.
+ size_t
+ size_declarations() const
+ { return this->bindings_.size(); }
+
+ // Return whether there are no declarations.
+ bool
+ empty_declarations() const
+ { return this->bindings_.empty(); }
+
+ // Return the first declaration.
+ Named_object*
+ first_declaration()
+ { return this->bindings_.empty() ? NULL : this->bindings_.begin()->second; }
+
+ private:
+ Named_object*
+ add_named_object_to_contour(Contour*, Named_object*);
+
+ Named_object*
+ new_definition(Named_object*, Named_object*);
+
+ // Enclosing bindings.
+ Bindings* enclosing_;
+ // The list of objects.
+ std::vector<Named_object*> named_objects_;
+ // The mapping from names to objects.
+ Contour bindings_;
+};
+
+// A label.
+
+class Label
+{
+ public:
+ Label(const std::string& name)
+ : name_(name), location_(0), is_used_(false), blabel_(NULL)
+ { }
+
+ // Return the label's name.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return whether the label has been defined.
+ bool
+ is_defined() const
+ { return this->location_ != 0; }
+
+ // Return whether the label has been used.
+ bool
+ is_used() const
+ { return this->is_used_; }
+
+ // Record that the label is used.
+ void
+ set_is_used()
+ { this->is_used_ = true; }
+
+ // Return the location of the definition.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Define the label at LOCATION.
+ void
+ define(source_location location)
+ {
+ go_assert(this->location_ == 0);
+ this->location_ = location;
+ }
+
+ // Return the backend representation for this label.
+ Blabel*
+ get_backend_label(Translate_context*);
+
+ // Return an expression for the address of this label. This is used
+ // to get the return address of a deferred function to see whether
+ // the function may call recover.
+ Bexpression*
+ get_addr(Translate_context*, source_location location);
+
+ private:
+ // The name of the label.
+ std::string name_;
+ // The location of the definition. This is 0 if the label has not
+ // yet been defined.
+ source_location location_;
+ // Whether the label has been used.
+ bool is_used_;
+ // The backend representation.
+ Blabel* blabel_;
+};
+
+// An unnamed label. These are used when lowering loops.
+
+class Unnamed_label
+{
+ public:
+ Unnamed_label(source_location location)
+ : location_(location), blabel_(NULL)
+ { }
+
+ // Get the location where the label is defined.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Set the location where the label is defined.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Return a statement which defines this label.
+ Bstatement*
+ get_definition(Translate_context*);
+
+ // Return a goto to this label from LOCATION.
+ Bstatement*
+ get_goto(Translate_context*, source_location location);
+
+ private:
+ // Return the backend representation.
+ Blabel*
+ get_blabel(Translate_context*);
+
+ // The location where the label is defined.
+ source_location location_;
+ // The backend representation of this label.
+ Blabel* blabel_;
+};
+
+// An imported package.
+
+class Package
+{
+ public:
+ Package(const std::string& name, const std::string& unique_prefix,
+ source_location location);
+
+ // The real name of this package. This may be different from the
+ // name in the associated Named_object if the import statement used
+ // an alias.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the location of the import statement.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Get the unique prefix used for all symbols exported from this
+ // package.
+ const std::string&
+ unique_prefix() const
+ {
+ go_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+ }
+
+ // The priority of this package. The init function of packages with
+ // lower priority must be run before the init function of packages
+ // with higher priority.
+ int
+ priority() const
+ { return this->priority_; }
+
+ // Set the priority.
+ void
+ set_priority(int priority);
+
+ // Return the bindings.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ // Whether some symbol from the package was used.
+ bool
+ used() const
+ { return this->used_; }
+
+ // Note that some symbol from this package was used.
+ void
+ set_used() const
+ { this->used_ = true; }
+
+ // Clear the used field for the next file.
+ void
+ clear_used()
+ { this->used_ = false; }
+
+ // Whether this package was imported in the current file.
+ bool
+ is_imported() const
+ { return this->is_imported_; }
+
+ // Note that this package was imported in the current file.
+ void
+ set_is_imported()
+ { this->is_imported_ = true; }
+
+ // Clear the imported field for the next file.
+ void
+ clear_is_imported()
+ { this->is_imported_ = false; }
+
+ // Whether this package was imported with a name of "_".
+ bool
+ uses_sink_alias() const
+ { return this->uses_sink_alias_; }
+
+ // Note that this package was imported with a name of "_".
+ void
+ set_uses_sink_alias()
+ { this->uses_sink_alias_ = true; }
+
+ // Clear the sink alias field for the next file.
+ void
+ clear_uses_sink_alias()
+ { this->uses_sink_alias_ = false; }
+
+ // Look up a name in the package. Returns NULL if the name is not
+ // found.
+ Named_object*
+ lookup(const std::string& name) const
+ { return this->bindings_->lookup(name); }
+
+ // Set the location of the package. This is used if it is seen in a
+ // different import before it is really imported.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Add a constant to the package.
+ Named_object*
+ add_constant(const Typed_identifier& tid, Expression* expr)
+ { return this->bindings_->add_constant(tid, this, expr, 0); }
+
+ // Add a type to the package.
+ Named_object*
+ add_type(const std::string& name, Type* type, source_location location)
+ { return this->bindings_->add_type(name, this, type, location); }
+
+ // Add a type declaration to the package.
+ Named_object*
+ add_type_declaration(const std::string& name, source_location location)
+ { return this->bindings_->add_type_declaration(name, this, location); }
+
+ // Add a variable to the package.
+ Named_object*
+ add_variable(const std::string& name, Variable* variable)
+ { return this->bindings_->add_variable(name, this, variable); }
+
+ // Add a function declaration to the package.
+ Named_object*
+ add_function_declaration(const std::string& name, Function_type* type,
+ source_location loc)
+ { return this->bindings_->add_function_declaration(name, this, type, loc); }
+
+ // Determine types of constants.
+ void
+ determine_types();
+
+ private:
+ // The real name of this package.
+ std::string name_;
+ // The unique prefix for all exported global symbols.
+ std::string unique_prefix_;
+ // The names in this package.
+ Bindings* bindings_;
+ // The priority of this package. A package has a priority higher
+ // than the priority of all of the packages that it imports. This
+ // is used to run init functions in the right order.
+ int priority_;
+ // The location of the import statement.
+ source_location location_;
+ // True if some name from this package was used. This is mutable
+ // because we can use a package even if we have a const pointer to
+ // it.
+ mutable bool used_;
+ // True if this package was imported in the current file.
+ bool is_imported_;
+ // True if this package was imported with a name of "_".
+ bool uses_sink_alias_;
+};
+
+// Return codes for the traversal functions. This is not an enum
+// because we want to be able to declare traversal functions in other
+// header files without including this one.
+
+// Continue traversal as usual.
+const int TRAVERSE_CONTINUE = -1;
+
+// Exit traversal.
+const int TRAVERSE_EXIT = 0;
+
+// Continue traversal, but skip components of the current object.
+// E.g., if this is returned by Traverse::statement, we do not
+// traverse the expressions in the statement even if
+// traverse_expressions is set in the traverse_mask.
+const int TRAVERSE_SKIP_COMPONENTS = 1;
+
+// This class is used when traversing the parse tree. The caller uses
+// a subclass which overrides functions as desired.
+
+class Traverse
+{
+ public:
+ // These bitmasks say what to traverse.
+ static const unsigned int traverse_variables = 0x1;
+ static const unsigned int traverse_constants = 0x2;
+ static const unsigned int traverse_functions = 0x4;
+ static const unsigned int traverse_blocks = 0x8;
+ static const unsigned int traverse_statements = 0x10;
+ static const unsigned int traverse_expressions = 0x20;
+ static const unsigned int traverse_types = 0x40;
+
+ Traverse(unsigned int traverse_mask)
+ : traverse_mask_(traverse_mask), types_seen_(NULL), expressions_seen_(NULL)
+ { }
+
+ virtual ~Traverse();
+
+ // The bitmask of what to traverse.
+ unsigned int
+ traverse_mask() const
+ { return this->traverse_mask_; }
+
+ // Record that we are going to traverse a type. This returns true
+ // if the type has already been seen in this traversal. This is
+ // required because types, unlike expressions, can form a circular
+ // graph.
+ bool
+ remember_type(const Type*);
+
+ // Record that we are going to see an expression. This returns true
+ // if the expression has already been seen in this traversal. This
+ // is only needed for cases where multiple expressions can point to
+ // a single one.
+ bool
+ remember_expression(const Expression*);
+
+ // These functions return one of the TRAVERSE codes defined above.
+
+ // If traverse_variables is set in the mask, this is called for
+ // every variable in the tree.
+ virtual int
+ variable(Named_object*);
+
+ // If traverse_constants is set in the mask, this is called for
+ // every named constant in the tree. The bool parameter is true for
+ // a global constant.
+ virtual int
+ constant(Named_object*, bool);
+
+ // If traverse_functions is set in the mask, this is called for
+ // every function in the tree.
+ virtual int
+ function(Named_object*);
+
+ // If traverse_blocks is set in the mask, this is called for every
+ // block in the tree.
+ virtual int
+ block(Block*);
+
+ // If traverse_statements is set in the mask, this is called for
+ // every statement in the tree.
+ virtual int
+ statement(Block*, size_t* index, Statement*);
+
+ // If traverse_expressions is set in the mask, this is called for
+ // every expression in the tree.
+ virtual int
+ expression(Expression**);
+
+ // If traverse_types is set in the mask, this is called for every
+ // type in the tree.
+ virtual int
+ type(Type*);
+
+ private:
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+
+ typedef Unordered_set(const Expression*) Expressions_seen;
+
+ // Bitmask of what sort of objects to traverse.
+ unsigned int traverse_mask_;
+ // Types which have been seen in this traversal.
+ Types_seen* types_seen_;
+ // Expressions which have been seen in this traversal.
+ Expressions_seen* expressions_seen_;
+};
+
+// When translating the gogo IR into the backend data structure, this
+// is the context we pass down the blocks and statements.
+
+class Translate_context
+{
+ public:
+ Translate_context(Gogo* gogo, Named_object* function, Block* block,
+ Bblock* bblock)
+ : gogo_(gogo), backend_(gogo->backend()), function_(function),
+ block_(block), bblock_(bblock), is_const_(false)
+ { }
+
+ // Accessors.
+
+ Gogo*
+ gogo()
+ { return this->gogo_; }
+
+ Backend*
+ backend()
+ { return this->backend_; }
+
+ Named_object*
+ function()
+ { return this->function_; }
+
+ Block*
+ block()
+ { return this->block_; }
+
+ Bblock*
+ bblock()
+ { return this->bblock_; }
+
+ bool
+ is_const()
+ { return this->is_const_; }
+
+ // Make a constant context.
+ void
+ set_is_const()
+ { this->is_const_ = true; }
+
+ private:
+ // The IR for the entire compilation unit.
+ Gogo* gogo_;
+ // The generator for the backend data structures.
+ Backend* backend_;
+ // The function we are currently translating. NULL if not in a
+ // function, e.g., the initializer of a global variable.
+ Named_object* function_;
+ // The block we are currently translating. NULL if not in a
+ // function.
+ Block *block_;
+ // The backend representation of the current block. NULL if block_
+ // is NULL.
+ Bblock* bblock_;
+ // Whether this is being evaluated in a constant context. This is
+ // used for type descriptor initializers.
+ bool is_const_;
+};
+
+// Runtime error codes. These must match the values in
+// libgo/runtime/go-runtime-error.c.
+
+// Slice index out of bounds: negative or larger than the length of
+// the slice.
+static const int RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS = 0;
+
+// Array index out of bounds.
+static const int RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS = 1;
+
+// String index out of bounds.
+static const int RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS = 2;
+
+// Slice slice out of bounds: negative or larger than the length of
+// the slice or high bound less than low bound.
+static const int RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS = 3;
+
+// Array slice out of bounds.
+static const int RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS = 4;
+
+// String slice out of bounds.
+static const int RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS = 5;
+
+// Dereference of nil pointer. This is used when there is a
+// dereference of a pointer to a very large struct or array, to ensure
+// that a gigantic array is not used a proxy to access random memory
+// locations.
+static const int RUNTIME_ERROR_NIL_DEREFERENCE = 6;
+
+// Slice length or capacity out of bounds in make: negative or
+// overflow or length greater than capacity.
+static const int RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS = 7;
+
+// Map capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS = 8;
+
+// Channel capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS = 9;
+
+// This is used by some of the langhooks.
+extern Gogo* go_get_gogo();
+
+// Whether we have seen any errors. FIXME: Replace with a backend
+// interface.
+extern bool saw_errors();
+
+#endif // !defined(GO_GOGO_H)
--- /dev/null
+// gogo.h -- Go frontend parsed representation. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_GOGO_H
+#define GO_GOGO_H
+
+class Traverse;
+class Type;
+class Type_hash_identical;
+class Type_equal;
+class Type_identical;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Expression;
+class Statement;
+class Block;
+class Function;
+class Bindings;
+class Package;
+class Variable;
+class Pointer_type;
+class Struct_type;
+class Struct_field;
+class Struct_field_list;
+class Array_type;
+class Map_type;
+class Channel_type;
+class Interface_type;
+class Named_type;
+class Forward_declaration_type;
+class Method;
+class Methods;
+class Named_object;
+class Label;
+class Translate_context;
+class Export;
+class Import;
+
+// This file declares the basic classes used to hold the internal
+// representation of Go which is built by the parser.
+
+// An initialization function for an imported package. This is a
+// magic function which initializes variables and runs the "init"
+// function.
+
+class Import_init
+{
+ public:
+ Import_init(const std::string& package_name, const std::string& init_name,
+ int priority)
+ : package_name_(package_name), init_name_(init_name), priority_(priority)
+ { }
+
+ // The name of the package being imported.
+ const std::string&
+ package_name() const
+ { return this->package_name_; }
+
+ // The name of the package's init function.
+ const std::string&
+ init_name() const
+ { return this->init_name_; }
+
+ // The priority of the initialization function. Functions with a
+ // lower priority number must be run first.
+ int
+ priority() const
+ { return this->priority_; }
+
+ private:
+ // The name of the package being imported.
+ std::string package_name_;
+ // The name of the package's init function.
+ std::string init_name_;
+ // The priority.
+ int priority_;
+};
+
+// For sorting purposes.
+
+inline bool
+operator<(const Import_init& i1, const Import_init& i2)
+{
+ if (i1.priority() < i2.priority())
+ return true;
+ if (i1.priority() > i2.priority())
+ return false;
+ if (i1.package_name() != i2.package_name())
+ return i1.package_name() < i2.package_name();
+ return i1.init_name() < i2.init_name();
+}
+
+// The holder for the internal representation of the entire
+// compilation unit.
+
+class Gogo
+{
+ public:
+ // Create the IR, passing in the sizes of the types "int" and
+ // "uintptr" in bits.
+ Gogo(int int_type_size, int pointer_size);
+
+ // Get the package name.
+ const std::string&
+ package_name() const;
+
+ // Set the package name.
+ void
+ set_package_name(const std::string&, source_location);
+
+ // Return whether this is the "main" package.
+ bool
+ is_main_package() const;
+
+ // If necessary, adjust the name to use for a hidden symbol. We add
+ // a prefix of the package name, so that hidden symbols in different
+ // packages do not collide.
+ std::string
+ pack_hidden_name(const std::string& name, bool is_exported) const
+ {
+ return (is_exported
+ ? name
+ : ('.' + this->unique_prefix()
+ + '.' + this->package_name()
+ + '.' + name));
+ }
+
+ // Unpack a name which may have been hidden. Returns the
+ // user-visible name of the object.
+ static std::string
+ unpack_hidden_name(const std::string& name)
+ { return name[0] != '.' ? name : name.substr(name.rfind('.') + 1); }
+
+ // Return whether a possibly packed name is hidden.
+ static bool
+ is_hidden_name(const std::string& name)
+ { return name[0] == '.'; }
+
+ // Return the package prefix of a hidden name.
+ static std::string
+ hidden_name_prefix(const std::string& name)
+ {
+ gcc_assert(Gogo::is_hidden_name(name));
+ return name.substr(1, name.rfind('.') - 1);
+ }
+
+ // Given a name which may or may not have been hidden, return the
+ // name to use in an error message.
+ static std::string
+ message_name(const std::string& name);
+
+ // Return whether a name is the blank identifier _.
+ static bool
+ is_sink_name(const std::string& name)
+ {
+ return (name[0] == '.'
+ && name[name.length() - 1] == '_'
+ && name[name.length() - 2] == '.');
+ }
+
+ // Return the unique prefix to use for all exported symbols.
+ const std::string&
+ unique_prefix() const;
+
+ // Set the unique prefix.
+ void
+ set_unique_prefix(const std::string&);
+
+ // Return the priority to use for the package we are compiling.
+ // This is two more than the largest priority of any package we
+ // import.
+ int
+ package_priority() const;
+
+ // Import a package. FILENAME is the file name argument, LOCAL_NAME
+ // is the local name to give to the package. If LOCAL_NAME is empty
+ // the declarations are added to the global scope.
+ void
+ import_package(const std::string& filename, const std::string& local_name,
+ bool is_local_name_exported, source_location);
+
+ // Whether we are the global binding level.
+ bool
+ in_global_scope() const;
+
+ // Look up a name in the current binding contours.
+ Named_object*
+ lookup(const std::string&, Named_object** pfunction) const;
+
+ // Look up a name in the current block.
+ Named_object*
+ lookup_in_block(const std::string&) const;
+
+ // Look up a name in the global namespace--the universal scope.
+ Named_object*
+ lookup_global(const char*) const;
+
+ // Add a new imported package. REAL_NAME is the real name of the
+ // package. ALIAS is the alias of the package; this may be the same
+ // as REAL_NAME. This sets *PADD_TO_GLOBALS if symbols added to
+ // this package should be added to the global namespace; this is
+ // true if the alias is ".". LOCATION is the location of the import
+ // statement. This returns the new package, or NULL on error.
+ Package*
+ add_imported_package(const std::string& real_name, const std::string& alias,
+ bool is_alias_exported,
+ const std::string& unique_prefix,
+ source_location location,
+ bool* padd_to_globals);
+
+ // Register a package. This package may or may not be imported.
+ // This returns the Package structure for the package, creating if
+ // it necessary.
+ Package*
+ register_package(const std::string& name, const std::string& unique_prefix,
+ source_location);
+
+ // Start compiling a function. ADD_METHOD_TO_TYPE is true if a
+ // method function should be added to the type of its receiver.
+ Named_object*
+ start_function(const std::string& name, Function_type* type,
+ bool add_method_to_type, source_location);
+
+ // Finish compiling a function.
+ void
+ finish_function(source_location);
+
+ // Return the current function.
+ Named_object*
+ current_function() const;
+
+ // Start a new block. This is not initially associated with a
+ // function.
+ void
+ start_block(source_location);
+
+ // Finish the current block and return it.
+ Block*
+ finish_block(source_location);
+
+ // Declare an unknown name. This is used while parsing. The name
+ // must be resolved by the end of the parse. Unknown names are
+ // always added at the package level.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location);
+
+ // Declare a function.
+ Named_object*
+ declare_function(const std::string&, Function_type*, source_location);
+
+ // Add a label.
+ Label*
+ add_label_definition(const std::string&, source_location);
+
+ // Add a label reference.
+ Label*
+ add_label_reference(const std::string&);
+
+ // Add a statement to the current block.
+ void
+ add_statement(Statement*);
+
+ // Add a block to the current block.
+ void
+ add_block(Block*, source_location);
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier&, Expression*, int iota_value);
+
+ // Add a type.
+ void
+ add_type(const std::string&, Type*, source_location);
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ void
+ add_named_type(Named_type*);
+
+ // Declare a type.
+ Named_object*
+ declare_type(const std::string&, source_location);
+
+ // Declare a type at the package level. This is used when the
+ // parser sees an unknown name where a type name is required.
+ Named_object*
+ declare_package_type(const std::string&, source_location);
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string&, Variable*);
+
+ // Add a sink--a reference to the blank identifier _.
+ Named_object*
+ add_sink();
+
+ // Add a named object to the current namespace. This is used for
+ // import . "package".
+ void
+ add_named_object(Named_object*);
+
+ // Return a name to use for a thunk function. A thunk function is
+ // one we create during the compilation, for a go statement or a
+ // defer statement or a method expression.
+ static std::string
+ thunk_name();
+
+ // Return whether an object is a thunk.
+ static bool
+ is_thunk(const Named_object*);
+
+ // Note that we've seen an interface type. This is used to build
+ // all required interface method tables.
+ void
+ record_interface_type(Interface_type*);
+
+ // Note that we need an initialization function.
+ void
+ set_need_init_fn()
+ { this->need_init_fn_ = true; }
+
+ // Clear out all names in file scope. This is called when we start
+ // parsing a new file.
+ void
+ clear_file_scope();
+
+ // Traverse the tree. See the Traverse class.
+ void
+ traverse(Traverse*);
+
+ // Define the predeclared global names.
+ void
+ define_global_names();
+
+ // Verify and complete all types.
+ void
+ verify_types();
+
+ // Lower the parse tree.
+ void
+ lower_parse_tree();
+
+ // Lower all the statements in a block.
+ void
+ lower_block(Named_object* function, Block*);
+
+ // Lower an expression.
+ void
+ lower_expression(Named_object* function, Expression**);
+
+ // Lower a constant.
+ void
+ lower_constant(Named_object*);
+
+ // Finalize the method lists and build stub methods for named types.
+ void
+ finalize_methods();
+
+ // Work out the types to use for unspecified variables and
+ // constants.
+ void
+ determine_types();
+
+ // Type check the program.
+ void
+ check_types();
+
+ // Check the types in a single block. This is used for complicated
+ // go statements.
+ void
+ check_types_in_block(Block*);
+
+ // Check for return statements.
+ void
+ check_return_statements();
+
+ // Do all exports.
+ void
+ do_exports();
+
+ // Add an import control function for an imported package to the
+ // list.
+ void
+ add_import_init_fn(const std::string& package_name,
+ const std::string& init_name, int prio);
+
+ // Turn short-cut operators (&&, ||) into explicit if statements.
+ void
+ remove_shortcuts();
+
+ // Use temporary variables to force order of evaluation.
+ void
+ order_evaluations();
+
+ // Build thunks for functions which call recover.
+ void
+ build_recover_thunks();
+
+ // Simplify statements which might use thunks: go and defer
+ // statements.
+ void
+ simplify_thunk_statements();
+
+ // Convert named types to the backend representation.
+ void
+ convert_named_types();
+
+ // Convert named types in a list of bindings.
+ void
+ convert_named_types_in_bindings(Bindings*);
+
+ // True if named types have been converted to the backend
+ // representation.
+ bool
+ named_types_are_converted() const
+ { return this->named_types_are_converted_; }
+
+ // Write out the global values.
+ void
+ write_globals();
+
+ // Build a call to a builtin function. PDECL should point to a NULL
+ // initialized static pointer which will hold the fndecl. NAME is
+ // the name of the function. NARGS is the number of arguments.
+ // RETTYPE is the return type. It is followed by NARGS pairs of
+ // type and argument (both trees).
+ static tree
+ call_builtin(tree* pdecl, source_location, const char* name, int nargs,
+ tree rettype, ...);
+
+ // Build a call to the runtime error function.
+ static tree
+ runtime_error(int code, source_location);
+
+ // Build a builtin struct with a list of fields.
+ static tree
+ builtin_struct(tree* ptype, const char* struct_name, tree struct_type,
+ int nfields, ...);
+
+ // Mark a function declaration as a builtin library function.
+ static void
+ mark_fndecl_as_builtin_library(tree fndecl);
+
+ // Build the type of the struct that holds a slice for the given
+ // element type.
+ tree
+ slice_type_tree(tree element_type_tree);
+
+ // Given a tree for a slice type, return the tree for the element
+ // type.
+ static tree
+ slice_element_type_tree(tree slice_type_tree);
+
+ // Build a constructor for a slice. SLICE_TYPE_TREE is the type of
+ // the slice. VALUES points to the values. COUNT is the size,
+ // CAPACITY is the capacity. If CAPACITY is NULL, it is set to
+ // COUNT.
+ static tree
+ slice_constructor(tree slice_type_tree, tree values, tree count,
+ tree capacity);
+
+ // Build a constructor for an empty slice. SLICE_TYPE_TREE is the
+ // type of the slice.
+ static tree
+ empty_slice_constructor(tree slice_type_tree);
+
+ // Build a map descriptor.
+ tree
+ map_descriptor(Map_type*);
+
+ // Return a tree for the type of a map descriptor. This is struct
+ // __go_map_descriptor in libgo/runtime/map.h. This is the same for
+ // all map types.
+ tree
+ map_descriptor_type();
+
+ // Build a type descriptor for TYPE using INITIALIZER as the type
+ // descriptor. This builds a new decl stored in *PDECL.
+ void
+ build_type_descriptor_decl(const Type*, Expression* initializer,
+ tree* pdecl);
+
+ // Build required interface method tables.
+ void
+ build_interface_method_tables();
+
+ // Build an interface method table for a type: a list of function
+ // pointers, one for each interface method. This returns a decl.
+ tree
+ interface_method_table_for_type(const Interface_type*, Named_type*,
+ bool is_pointer);
+
+ // Return a tree which allocate SIZE bytes to hold values of type
+ // TYPE.
+ tree
+ allocate_memory(Type *type, tree size, source_location);
+
+ // Return a type to use for pointer to const char.
+ static tree
+ const_char_pointer_type_tree();
+
+ // Build a string constant with the right type.
+ static tree
+ string_constant_tree(const std::string&);
+
+ // Build a Go string constant. This returns a pointer to the
+ // constant.
+ tree
+ go_string_constant_tree(const std::string&);
+
+ // Send a value on a channel.
+ static tree
+ send_on_channel(tree channel, tree val, bool blocking, bool for_select,
+ source_location);
+
+ // Receive a value from a channel.
+ static tree
+ receive_from_channel(tree type_tree, tree channel, bool for_select,
+ source_location);
+
+ // Return a tree for receiving an integer on a channel.
+ static tree
+ receive_as_64bit_integer(tree type, tree channel, bool blocking,
+ bool for_select);
+
+
+ // Make a trampoline which calls FNADDR passing CLOSURE.
+ tree
+ make_trampoline(tree fnaddr, tree closure, source_location);
+
+ private:
+ // During parsing, we keep a stack of functions. Each function on
+ // the stack is one that we are currently parsing. For each
+ // function, we keep track of the current stack of blocks.
+ struct Open_function
+ {
+ // The function.
+ Named_object* function;
+ // The stack of active blocks in the function.
+ std::vector<Block*> blocks;
+ };
+
+ // The stack of functions.
+ typedef std::vector<Open_function> Open_functions;
+
+ // Create trees for implicit builtin functions.
+ void
+ define_builtin_function_trees();
+
+ // Set up the built-in unsafe package.
+ void
+ import_unsafe(const std::string&, bool is_exported, source_location);
+
+ // Add a new imported package.
+ Named_object*
+ add_package(const std::string& real_name, const std::string& alias,
+ const std::string& unique_prefix, source_location location);
+
+ // Return the current binding contour.
+ Bindings*
+ current_bindings();
+
+ const Bindings*
+ current_bindings() const;
+
+ // Return the current block.
+ Block*
+ current_block();
+
+ // Get the name of the magic initialization function.
+ const std::string&
+ get_init_fn_name();
+
+ // Get the decl for the magic initialization function.
+ tree
+ initialization_function_decl();
+
+ // Write the magic initialization function.
+ void
+ write_initialization_function(tree fndecl, tree init_stmt_list);
+
+ // Initialize imported packages.
+ void
+ init_imports(tree*);
+
+ // Register variables with the garbage collector.
+ void
+ register_gc_vars(const std::vector<Named_object*>&, tree*);
+
+ // Build a pointer to a Go string constant. This returns a pointer
+ // to the pointer.
+ tree
+ ptr_go_string_constant_tree(const std::string&);
+
+ // Return the name to use for a type descriptor decl for an unnamed
+ // type.
+ std::string
+ unnamed_type_descriptor_decl_name(const Type* type);
+
+ // Return the name to use for a type descriptor decl for a type
+ // named NO, defined in IN_FUNCTION.
+ std::string
+ type_descriptor_decl_name(const Named_object* no,
+ const Named_object* in_function);
+
+ // Where a type descriptor should be defined.
+ enum Type_descriptor_location
+ {
+ // Defined in this file.
+ TYPE_DESCRIPTOR_DEFINED,
+ // Defined in some other file.
+ TYPE_DESCRIPTOR_UNDEFINED,
+ // Common definition which may occur in multiple files.
+ TYPE_DESCRIPTOR_COMMON
+ };
+
+ // Return where the decl for TYPE should be defined.
+ Type_descriptor_location
+ type_descriptor_location(const Type* type);
+
+ // Return the type of a trampoline.
+ static tree
+ trampoline_type_tree();
+
+ // Type used to map import names to packages.
+ typedef std::map<std::string, Package*> Imports;
+
+ // Type used to map package names to packages.
+ typedef std::map<std::string, Package*> Packages;
+
+ // Type used to map special names in the sys package.
+ typedef std::map<std::string, std::string> Sys_names;
+
+ // Hash table mapping map types to map descriptor decls.
+ typedef Unordered_map_hash(const Map_type*, tree, Type_hash_identical,
+ Type_identical) Map_descriptors;
+
+ // Map unnamed types to type descriptor decls.
+ typedef Unordered_map_hash(const Type*, tree, Type_hash_identical,
+ Type_identical) Type_descriptor_decls;
+
+ // The package we are compiling.
+ Package* package_;
+ // The list of currently open functions during parsing.
+ Open_functions functions_;
+ // The global binding contour. This includes the builtin functions
+ // and the package we are compiling.
+ Bindings* globals_;
+ // Mapping from import file names to packages.
+ Imports imports_;
+ // Whether the magic unsafe package was imported.
+ bool imported_unsafe_;
+ // Mapping from package names we have seen to packages. This does
+ // not include the package we are compiling.
+ Packages packages_;
+ // Mapping from map types to map descriptors.
+ Map_descriptors* map_descriptors_;
+ // Mapping from unnamed types to type descriptor decls.
+ Type_descriptor_decls* type_descriptor_decls_;
+ // The functions named "init", if there are any.
+ std::vector<Named_object*> init_functions_;
+ // Whether we need a magic initialization function.
+ bool need_init_fn_;
+ // The name of the magic initialization function.
+ std::string init_fn_name_;
+ // A list of import control variables for packages that we import.
+ std::set<Import_init> imported_init_fns_;
+ // The unique prefix used for all global symbols.
+ std::string unique_prefix_;
+ // Whether an explicit unique prefix was set by -fgo-prefix.
+ bool unique_prefix_specified_;
+ // A list of interface types defined while parsing.
+ std::vector<Interface_type*> interface_types_;
+ // Whether named types have been converted.
+ bool named_types_are_converted_;
+};
+
+// A block of statements.
+
+class Block
+{
+ public:
+ Block(Block* enclosing, source_location);
+
+ // Return the enclosing block.
+ const Block*
+ enclosing() const
+ { return this->enclosing_; }
+
+ // Return the bindings of the block.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ const Bindings*
+ bindings() const
+ { return this->bindings_; }
+
+ // Look at the block's statements.
+ const std::vector<Statement*>*
+ statements() const
+ { return &this->statements_; }
+
+ // Return the start location. This is normally the location of the
+ // left curly brace which starts the block.
+ source_location
+ start_location() const
+ { return this->start_location_; }
+
+ // Return the end location. This is normally the location of the
+ // right curly brace which ends the block.
+ source_location
+ end_location() const
+ { return this->end_location_; }
+
+ // Add a statement to the block.
+ void
+ add_statement(Statement*);
+
+ // Add a statement to the front of the block.
+ void
+ add_statement_at_front(Statement*);
+
+ // Replace a statement in a block.
+ void
+ replace_statement(size_t index, Statement*);
+
+ // Add a Statement before statement number INDEX.
+ void
+ insert_statement_before(size_t index, Statement*);
+
+ // Add a Statement after statement number INDEX.
+ void
+ insert_statement_after(size_t index, Statement*);
+
+ // Set the end location of the block.
+ void
+ set_end_location(source_location location)
+ { this->end_location_ = location; }
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Set final types for unspecified variables and constants.
+ void
+ determine_types();
+
+ // Return true if execution of this block may fall through to the
+ // next block.
+ bool
+ may_fall_through() const;
+
+ // Return a tree of the code in this block.
+ tree
+ get_tree(Translate_context*);
+
+ // Iterate over statements.
+
+ typedef std::vector<Statement*>::iterator iterator;
+
+ iterator
+ begin()
+ { return this->statements_.begin(); }
+
+ iterator
+ end()
+ { return this->statements_.end(); }
+
+ private:
+ // Enclosing block.
+ Block* enclosing_;
+ // Statements in the block.
+ std::vector<Statement*> statements_;
+ // Binding contour.
+ Bindings* bindings_;
+ // Location of start of block.
+ source_location start_location_;
+ // Location of end of block.
+ source_location end_location_;
+};
+
+// A function.
+
+class Function
+{
+ public:
+ Function(Function_type* type, Function*, Block*, source_location);
+
+ // Return the function's type.
+ Function_type*
+ type() const
+ { return this->type_; }
+
+ // Return the enclosing function if there is one.
+ Function*
+ enclosing()
+ { return this->enclosing_; }
+
+ // Set the enclosing function. This is used when building thunks
+ // for functions which call recover.
+ void
+ set_enclosing(Function* enclosing)
+ {
+ gcc_assert(this->enclosing_ == NULL);
+ this->enclosing_ = enclosing;
+ }
+
+ // Create the named result variables in the outer block.
+ void
+ create_named_result_variables(Gogo*);
+
+ // Update the named result variables when cloning a function which
+ // calls recover.
+ void
+ update_named_result_variables();
+
+ // Add a new field to the closure variable.
+ void
+ add_closure_field(Named_object* var, source_location loc)
+ { this->closure_fields_.push_back(std::make_pair(var, loc)); }
+
+ // Whether this function needs a closure.
+ bool
+ needs_closure() const
+ { return !this->closure_fields_.empty(); }
+
+ // Return the closure variable, creating it if necessary. This is
+ // passed to the function as a static chain parameter.
+ Named_object*
+ closure_var();
+
+ // Set the closure variable. This is used when building thunks for
+ // functions which call recover.
+ void
+ set_closure_var(Named_object* v)
+ {
+ gcc_assert(this->closure_var_ == NULL);
+ this->closure_var_ = v;
+ }
+
+ // Return the variable for a reference to field INDEX in the closure
+ // variable.
+ Named_object*
+ enclosing_var(unsigned int index)
+ {
+ gcc_assert(index < this->closure_fields_.size());
+ return closure_fields_[index].first;
+ }
+
+ // Set the type of the closure variable if there is one.
+ void
+ set_closure_type();
+
+ // Get the block of statements associated with the function.
+ Block*
+ block() const
+ { return this->block_; }
+
+ // Get the location of the start of the function.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return whether this function is actually a method.
+ bool
+ is_method() const;
+
+ // Add a label definition to the function.
+ Label*
+ add_label_definition(const std::string& label_name, source_location);
+
+ // Add a label reference to a function.
+ Label*
+ add_label_reference(const std::string& label_name);
+
+ // Whether this function calls the predeclared recover function.
+ bool
+ calls_recover() const
+ { return this->calls_recover_; }
+
+ // Record that this function calls the predeclared recover function.
+ // This is set during the lowering pass.
+ void
+ set_calls_recover()
+ { this->calls_recover_ = true; }
+
+ // Whether this is a recover thunk function.
+ bool
+ is_recover_thunk() const
+ { return this->is_recover_thunk_; }
+
+ // Record that this is a thunk built for a function which calls
+ // recover.
+ void
+ set_is_recover_thunk()
+ { this->is_recover_thunk_ = true; }
+
+ // Whether this function already has a recover thunk.
+ bool
+ has_recover_thunk() const
+ { return this->has_recover_thunk_; }
+
+ // Record that this function already has a recover thunk.
+ void
+ set_has_recover_thunk()
+ { this->has_recover_thunk_ = true; }
+
+ // Swap with another function. Used only for the thunk which calls
+ // recover.
+ void
+ swap_for_recover(Function *);
+
+ // Traverse the tree.
+ int
+ traverse(Traverse*);
+
+ // Determine types in the function.
+ void
+ determine_types();
+
+ // Return the function's decl given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Return the function's decl after it has been built.
+ tree
+ get_decl() const
+ {
+ gcc_assert(this->fndecl_ != NULL);
+ return this->fndecl_;
+ }
+
+ // Set the function decl to hold a tree of the function code.
+ void
+ build_tree(Gogo*, Named_object*);
+
+ // Get the value to return when not explicitly specified. May also
+ // add statements to execute first to STMT_LIST.
+ tree
+ return_value(Gogo*, Named_object*, source_location, tree* stmt_list) const;
+
+ // Get a tree for the variable holding the defer stack.
+ tree
+ defer_stack(source_location);
+
+ // Export the function.
+ void
+ export_func(Export*, const std::string& name) const;
+
+ // Export a function with a type.
+ static void
+ export_func_with_type(Export*, const std::string& name,
+ const Function_type*);
+
+ // Import a function.
+ static void
+ import_func(Import*, std::string* pname, Typed_identifier** receiver,
+ Typed_identifier_list** pparameters,
+ Typed_identifier_list** presults, bool* is_varargs);
+
+ private:
+ // Type for mapping from label names to Label objects.
+ typedef Unordered_map(std::string, Label*) Labels;
+
+ tree
+ make_receiver_parm_decl(Gogo*, Named_object*, tree);
+
+ tree
+ copy_parm_to_heap(Gogo*, Named_object*, tree);
+
+ void
+ build_defer_wrapper(Gogo*, Named_object*, tree*, tree*);
+
+ typedef std::vector<Named_object*> Named_results;
+
+ typedef std::vector<std::pair<Named_object*,
+ source_location> > Closure_fields;
+
+ // The function's type.
+ Function_type* type_;
+ // The enclosing function. This is NULL when there isn't one, which
+ // is the normal case.
+ Function* enclosing_;
+ // The named result variables, if any.
+ Named_results* named_results_;
+ // If there is a closure, this is the list of variables which appear
+ // in the closure. This is created by the parser, and then resolved
+ // to a real type when we lower parse trees.
+ Closure_fields closure_fields_;
+ // The closure variable, passed as a parameter using the static
+ // chain parameter. Normally NULL.
+ Named_object* closure_var_;
+ // The outer block of statements in the function.
+ Block* block_;
+ // The source location of the start of the function.
+ source_location location_;
+ // Labels defined or referenced in the function.
+ Labels labels_;
+ // The function decl.
+ tree fndecl_;
+ // A variable holding the defer stack variable. This is NULL unless
+ // we actually need a defer stack.
+ tree defer_stack_;
+ // True if this function calls the predeclared recover function.
+ bool calls_recover_;
+ // True if this a thunk built for a function which calls recover.
+ bool is_recover_thunk_;
+ // True if this function already has a recover thunk.
+ bool has_recover_thunk_;
+};
+
+// A function declaration.
+
+class Function_declaration
+{
+ public:
+ Function_declaration(Function_type* fntype, source_location location)
+ : fntype_(fntype), location_(location), asm_name_(), fndecl_(NULL)
+ { }
+
+ Function_type*
+ type() const
+ { return this->fntype_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ const std::string&
+ asm_name() const
+ { return this->asm_name_; }
+
+ // Set the assembler name.
+ void
+ set_asm_name(const std::string& asm_name)
+ { this->asm_name_ = asm_name; }
+
+ // Return a decl for the function given an identifier.
+ tree
+ get_or_make_decl(Gogo*, Named_object*, tree id);
+
+ // Export a function declaration.
+ void
+ export_func(Export* exp, const std::string& name) const
+ { Function::export_func_with_type(exp, name, this->fntype_); }
+
+ private:
+ // The type of the function.
+ Function_type* fntype_;
+ // The location of the declaration.
+ source_location location_;
+ // The assembler name: this is the name to use in references to the
+ // function. This is normally empty.
+ std::string asm_name_;
+ // The function decl if needed.
+ tree fndecl_;
+};
+
+// A variable.
+
+class Variable
+{
+ public:
+ Variable(Type*, Expression*, bool is_global, bool is_parameter,
+ bool is_receiver, source_location);
+
+ // Get the type of the variable.
+ Type*
+ type();
+
+ Type*
+ type() const;
+
+ // Return whether the type is defined yet.
+ bool
+ has_type() const
+ { return this->type_ != NULL; }
+
+ // Get the initial value.
+ Expression*
+ init() const
+ { return this->init_; }
+
+ // Return whether there are any preinit statements.
+ bool
+ has_pre_init() const
+ { return this->preinit_ != NULL; }
+
+ // Return the preinit statements if any.
+ Block*
+ preinit() const
+ { return this->preinit_; }
+
+ // Return whether this is a global variable.
+ bool
+ is_global() const
+ { return this->is_global_; }
+
+ // Return whether this is a function parameter.
+ bool
+ is_parameter() const
+ { return this->is_parameter_; }
+
+ // Return whether this is the receiver parameter of a method.
+ bool
+ is_receiver() const
+ { return this->is_receiver_; }
+
+ // Change this parameter to be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_receiver()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_receiver_ = true;
+ }
+
+ // Change this parameter to not be a receiver. This is used when
+ // creating the thunks created for functions which call recover.
+ void
+ set_is_not_receiver()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_receiver_ = false;
+ }
+
+ // Return whether this is the varargs parameter of a function.
+ bool
+ is_varargs_parameter() const
+ { return this->is_varargs_parameter_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_ && !this->is_global_; }
+
+ // Get the source location of the variable's declaration.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Record that this is the varargs parameter of a function.
+ void
+ set_is_varargs_parameter()
+ {
+ gcc_assert(this->is_parameter_);
+ this->is_varargs_parameter_ = true;
+ }
+
+ // Clear the initial value; used for error handling.
+ void
+ clear_init()
+ { this->init_ = NULL; }
+
+ // Set the initial value; used for converting shortcuts.
+ void
+ set_init(Expression* init)
+ { this->init_ = init; }
+
+ // Get the preinit block, a block of statements to be run before the
+ // initialization expression.
+ Block*
+ preinit_block(Gogo*);
+
+ // Add a statement to be run before the initialization expression.
+ // This is only used for global variables.
+ void
+ add_preinit_statement(Gogo*, Statement*);
+
+ // Lower the initialization expression after parsing is complete.
+ void
+ lower_init_expression(Gogo*, Named_object*);
+
+ // A special case: the init value is used only to determine the
+ // type. This is used if the variable is defined using := with the
+ // comma-ok form of a map index or a receive expression. The init
+ // value is actually the map index expression or receive expression.
+ // We use this because we may not know the right type at parse time.
+ void
+ set_type_from_init_tuple()
+ { this->type_from_init_tuple_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a range clause. The init value is the range expression. The
+ // type of the variable is the index type of the range expression
+ // (i.e., the first value returned by a range).
+ void
+ set_type_from_range_index()
+ { this->type_from_range_index_ = true; }
+
+ // Another special case: like set_type_from_range_index, but the
+ // type is the value type of the range expression (i.e., the second
+ // value returned by a range).
+ void
+ set_type_from_range_value()
+ { this->type_from_range_value_ = true; }
+
+ // Another special case: the init value is used only to determine
+ // the type. This is used if the variable is defined using := with
+ // a case in a select statement. The init value is the channel.
+ // The type of the variable is the channel's element type.
+ void
+ set_type_from_chan_element()
+ { this->type_from_chan_element_ = true; }
+
+ // After we lower the select statement, we once again set the type
+ // from the initialization expression.
+ void
+ clear_type_from_chan_element()
+ {
+ gcc_assert(this->type_from_chan_element_);
+ this->type_from_chan_element_ = false;
+ }
+
+ // Note that this variable was created for a type switch clause.
+ void
+ set_is_type_switch_var()
+ { this->is_type_switch_var_ = true; }
+
+ // Traverse the initializer expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the variable if necessary.
+ void
+ determine_type();
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Get the initial value of the variable as a tree. This may only
+ // be called if has_pre_init() returns false.
+ tree
+ get_init_tree(Gogo*, Named_object* function);
+
+ // Return a series of statements which sets the value of the
+ // variable in DECL. This should only be called is has_pre_init()
+ // returns true. DECL may be NULL for a sink variable.
+ tree
+ get_init_block(Gogo*, Named_object* function, tree decl);
+
+ // Export the variable.
+ void
+ export_var(Export*, const std::string& name) const;
+
+ // Import a variable.
+ static void
+ import_var(Import*, std::string* pname, Type** ptype);
+
+ private:
+ // The type of a tuple.
+ Type*
+ type_from_tuple(Expression*, bool) const;
+
+ // The type of a range.
+ Type*
+ type_from_range(Expression*, bool, bool) const;
+
+ // The element type of a channel.
+ Type*
+ type_from_chan_element(Expression*, bool) const;
+
+ // The variable's type. This may be NULL if the type is set from
+ // the expression.
+ Type* type_;
+ // The initial value. This may be NULL if the variable should be
+ // initialized to the default value for the type.
+ Expression* init_;
+ // Statements to run before the init statement.
+ Block* preinit_;
+ // Location of variable definition.
+ source_location location_;
+ // Whether this is a global variable.
+ bool is_global_ : 1;
+ // Whether this is a function parameter.
+ bool is_parameter_ : 1;
+ // Whether this is the receiver parameter of a method.
+ bool is_receiver_ : 1;
+ // Whether this is the varargs parameter of a function.
+ bool is_varargs_parameter_ : 1;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_ : 1;
+ // True if we have seen this variable in a traversal.
+ bool seen_ : 1;
+ // True if we have lowered the initialization expression.
+ bool init_is_lowered_ : 1;
+ // True if init is a tuple used to set the type.
+ bool type_from_init_tuple_ : 1;
+ // True if init is a range clause and the type is the index type.
+ bool type_from_range_index_ : 1;
+ // True if init is a range clause and the type is the value type.
+ bool type_from_range_value_ : 1;
+ // True if init is a channel and the type is the channel's element type.
+ bool type_from_chan_element_ : 1;
+ // True if this is a variable created for a type switch case.
+ bool is_type_switch_var_ : 1;
+ // True if we have determined types.
+ bool determined_type_ : 1;
+};
+
+// A variable which is really the name for a function return value, or
+// part of one.
+
+class Result_variable
+{
+ public:
+ Result_variable(Type* type, Function* function, int index)
+ : type_(type), function_(function), index_(index),
+ is_address_taken_(false)
+ { }
+
+ // Get the type of the result variable.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Get the function that this is associated with.
+ Function*
+ function() const
+ { return this->function_; }
+
+ // Index in the list of function results.
+ int
+ index() const
+ { return this->index_; }
+
+ // Whether this variable's address is taken.
+ bool
+ is_address_taken() const
+ { return this->is_address_taken_; }
+
+ // Note that something takes the address of this variable.
+ void
+ set_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Whether this variable should live in the heap.
+ bool
+ is_in_heap() const
+ { return this->is_address_taken_; }
+
+ // Set the function. This is used when cloning functions which call
+ // recover.
+ void
+ set_function(Function* function)
+ { this->function_ = function; }
+
+ private:
+ // Type of result variable.
+ Type* type_;
+ // Function with which this is associated.
+ Function* function_;
+ // Index in list of results.
+ int index_;
+ // Whether something takes the address of this variable.
+ bool is_address_taken_;
+};
+
+// The value we keep for a named constant. This lets us hold a type
+// and an expression.
+
+class Named_constant
+{
+ public:
+ Named_constant(Type* type, Expression* expr, int iota_value,
+ source_location location)
+ : type_(type), expr_(expr), iota_value_(iota_value), location_(location),
+ lowering_(false)
+ { }
+
+ Type*
+ type() const
+ { return this->type_; }
+
+ Expression*
+ expr() const
+ { return this->expr_; }
+
+ int
+ iota_value() const
+ { return this->iota_value_; }
+
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether we are lowering.
+ bool
+ lowering() const
+ { return this->lowering_; }
+
+ // Set that we are lowering.
+ void
+ set_lowering()
+ { this->lowering_ = true; }
+
+ // We are no longer lowering.
+ void
+ clear_lowering()
+ { this->lowering_ = false; }
+
+ // Traverse the expression.
+ int
+ traverse_expression(Traverse*);
+
+ // Determine the type of the constant if necessary.
+ void
+ determine_type();
+
+ // Indicate that we found and reported an error for this constant.
+ void
+ set_error();
+
+ // Export the constant.
+ void
+ export_const(Export*, const std::string& name) const;
+
+ // Import a constant.
+ static void
+ import_const(Import*, std::string*, Type**, Expression**);
+
+ private:
+ // The type of the constant.
+ Type* type_;
+ // The expression for the constant.
+ Expression* expr_;
+ // If the predeclared constant iota is used in EXPR_, this is the
+ // value it will have. We do this because at parse time we don't
+ // know whether the name "iota" will refer to the predeclared
+ // constant or to something else. We put in the right value in when
+ // we lower.
+ int iota_value_;
+ // The location of the definition.
+ source_location location_;
+ // Whether we are currently lowering this constant.
+ bool lowering_;
+};
+
+// A type declaration.
+
+class Type_declaration
+{
+ public:
+ Type_declaration(source_location location)
+ : location_(location), in_function_(NULL), methods_(),
+ issued_warning_(false)
+ { }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the function in which this type is declared. This will
+ // return NULL for a type declared in global scope.
+ Named_object*
+ in_function()
+ { return this->in_function_; }
+
+ // Set the function in which this type is declared.
+ void
+ set_in_function(Named_object* f)
+ { this->in_function_ = f; }
+
+ // Add a method to this type. This is used when methods are defined
+ // before the type.
+ Named_object*
+ add_method(const std::string& name, Function* function);
+
+ // Add a method declaration to this type.
+ Named_object*
+ add_method_declaration(const std::string& name, Function_type* type,
+ source_location location);
+
+ // Return whether any methods were defined.
+ bool
+ has_methods() const;
+
+ // Define methods when the real type is known.
+ void
+ define_methods(Named_type*);
+
+ // This is called if we are trying to use this type. It returns
+ // true if we should issue a warning.
+ bool
+ using_type();
+
+ private:
+ typedef std::vector<Named_object*> Methods;
+
+ // The location of the type declaration.
+ source_location location_;
+ // If this type is declared in a function, a pointer back to the
+ // function in which it is defined.
+ Named_object* in_function_;
+ // Methods defined before the type is defined.
+ Methods methods_;
+ // True if we have issued a warning about a use of this type
+ // declaration when it is undefined.
+ bool issued_warning_;
+};
+
+// An unknown object. These are created by the parser for forward
+// references to names which have not been seen before. In a correct
+// program, these will always point to a real definition by the end of
+// the parse. Because they point to another Named_object, these may
+// only be referenced by Unknown_expression objects.
+
+class Unknown_name
+{
+ public:
+ Unknown_name(source_location location)
+ : location_(location), real_named_object_(NULL)
+ { }
+
+ // Return the location where this name was first seen.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Return the real named object that this points to, or NULL if it
+ // was never resolved.
+ Named_object*
+ real_named_object() const
+ { return this->real_named_object_; }
+
+ // Set the real named object that this points to.
+ void
+ set_real_named_object(Named_object* no);
+
+ private:
+ // The location where this name was first seen.
+ source_location location_;
+ // The real named object when it is known.
+ Named_object*
+ real_named_object_;
+};
+
+// A named object named. This is the result of a declaration. We
+// don't use a superclass because they all have to be handled
+// differently.
+
+class Named_object
+{
+ public:
+ enum Classification
+ {
+ // An uninitialized Named_object. We should never see this.
+ NAMED_OBJECT_UNINITIALIZED,
+ // An unknown name. This is used for forward references. In a
+ // correct program, these will all be resolved by the end of the
+ // parse.
+ NAMED_OBJECT_UNKNOWN,
+ // A const.
+ NAMED_OBJECT_CONST,
+ // A type.
+ NAMED_OBJECT_TYPE,
+ // A forward type declaration.
+ NAMED_OBJECT_TYPE_DECLARATION,
+ // A var.
+ NAMED_OBJECT_VAR,
+ // A result variable in a function.
+ NAMED_OBJECT_RESULT_VAR,
+ // The blank identifier--the special variable named _.
+ NAMED_OBJECT_SINK,
+ // A func.
+ NAMED_OBJECT_FUNC,
+ // A forward func declaration.
+ NAMED_OBJECT_FUNC_DECLARATION,
+ // A package.
+ NAMED_OBJECT_PACKAGE
+ };
+
+ // Return the classification.
+ Classification
+ classification() const
+ { return this->classification_; }
+
+ // Classifiers.
+
+ bool
+ is_unknown() const
+ { return this->classification_ == NAMED_OBJECT_UNKNOWN; }
+
+ bool
+ is_const() const
+ { return this->classification_ == NAMED_OBJECT_CONST; }
+
+ bool
+ is_type() const
+ { return this->classification_ == NAMED_OBJECT_TYPE; }
+
+ bool
+ is_type_declaration() const
+ { return this->classification_ == NAMED_OBJECT_TYPE_DECLARATION; }
+
+ bool
+ is_variable() const
+ { return this->classification_ == NAMED_OBJECT_VAR; }
+
+ bool
+ is_result_variable() const
+ { return this->classification_ == NAMED_OBJECT_RESULT_VAR; }
+
+ bool
+ is_sink() const
+ { return this->classification_ == NAMED_OBJECT_SINK; }
+
+ bool
+ is_function() const
+ { return this->classification_ == NAMED_OBJECT_FUNC; }
+
+ bool
+ is_function_declaration() const
+ { return this->classification_ == NAMED_OBJECT_FUNC_DECLARATION; }
+
+ bool
+ is_package() const
+ { return this->classification_ == NAMED_OBJECT_PACKAGE; }
+
+ // Creators.
+
+ static Named_object*
+ make_unknown_name(const std::string& name, source_location);
+
+ static Named_object*
+ make_constant(const Typed_identifier&, const Package*, Expression*,
+ int iota_value);
+
+ static Named_object*
+ make_type(const std::string&, const Package*, Type*, source_location);
+
+ static Named_object*
+ make_type_declaration(const std::string&, const Package*, source_location);
+
+ static Named_object*
+ make_variable(const std::string&, const Package*, Variable*);
+
+ static Named_object*
+ make_result_variable(const std::string&, Result_variable*);
+
+ static Named_object*
+ make_sink();
+
+ static Named_object*
+ make_function(const std::string&, const Package*, Function*);
+
+ static Named_object*
+ make_function_declaration(const std::string&, const Package*, Function_type*,
+ source_location);
+
+ static Named_object*
+ make_package(const std::string& alias, Package* package);
+
+ // Getters.
+
+ Unknown_name*
+ unknown_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ const Unknown_name*
+ unknown_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_UNKNOWN);
+ return this->u_.unknown_value;
+ }
+
+ Named_constant*
+ const_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ const Named_constant*
+ const_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_CONST);
+ return this->u_.const_value;
+ }
+
+ Named_type*
+ type_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ const Named_type*
+ type_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE);
+ return this->u_.type_value;
+ }
+
+ Type_declaration*
+ type_declaration_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ const Type_declaration*
+ type_declaration_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_TYPE_DECLARATION);
+ return this->u_.type_declaration;
+ }
+
+ Variable*
+ var_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ const Variable*
+ var_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_VAR);
+ return this->u_.var_value;
+ }
+
+ Result_variable*
+ result_var_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ const Result_variable*
+ result_var_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_RESULT_VAR);
+ return this->u_.result_var_value;
+ }
+
+ Function*
+ func_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ const Function*
+ func_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC);
+ return this->u_.func_value;
+ }
+
+ Function_declaration*
+ func_declaration_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ const Function_declaration*
+ func_declaration_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_FUNC_DECLARATION);
+ return this->u_.func_declaration_value;
+ }
+
+ Package*
+ package_value()
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const Package*
+ package_value() const
+ {
+ gcc_assert(this->classification_ == NAMED_OBJECT_PACKAGE);
+ return this->u_.package_value;
+ }
+
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the name to use in an error message. The difference is
+ // that if this Named_object is defined in a different package, this
+ // will return PACKAGE.NAME.
+ std::string
+ message_name() const;
+
+ const Package*
+ package() const
+ { return this->package_; }
+
+ // Resolve an unknown value if possible. This returns the same
+ // Named_object or a new one.
+ Named_object*
+ resolve()
+ {
+ Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ const Named_object*
+ resolve() const
+ {
+ const Named_object* ret = this;
+ if (this->is_unknown())
+ {
+ const Named_object* r = this->unknown_value()->real_named_object();
+ if (r != NULL)
+ ret = r;
+ }
+ return ret;
+ }
+
+ // The location where this object was defined or referenced.
+ source_location
+ location() const;
+
+ // Return a tree for the external identifier for this object.
+ tree
+ get_id(Gogo*);
+
+ // Return a tree representing this object.
+ tree
+ get_tree(Gogo*, Named_object* function);
+
+ // Define a type declaration.
+ void
+ set_type_value(Named_type*);
+
+ // Define a function declaration.
+ void
+ set_function_value(Function*);
+
+ // Declare an unknown name as a type declaration.
+ void
+ declare_as_type();
+
+ // Export this object.
+ void
+ export_named_object(Export*) const;
+
+ private:
+ Named_object(const std::string&, const Package*, Classification);
+
+ // The name of the object.
+ std::string name_;
+ // The package that this object is in. This is NULL if it is in the
+ // file we are compiling.
+ const Package* package_;
+ // The type of object this is.
+ Classification classification_;
+ // The real data.
+ union
+ {
+ Unknown_name* unknown_value;
+ Named_constant* const_value;
+ Named_type* type_value;
+ Type_declaration* type_declaration;
+ Variable* var_value;
+ Result_variable* result_var_value;
+ Function* func_value;
+ Function_declaration* func_declaration_value;
+ Package* package_value;
+ } u_;
+ // The DECL tree for this object if we have already converted it.
+ tree tree_;
+};
+
+// A binding contour. This binds names to objects.
+
+class Bindings
+{
+ public:
+ // Type for mapping from names to objects.
+ typedef Unordered_map(std::string, Named_object*) Contour;
+
+ Bindings(Bindings* enclosing);
+
+ // Add an unknown name.
+ Named_object*
+ add_unknown_name(const std::string& name, source_location location)
+ {
+ return this->add_named_object(Named_object::make_unknown_name(name,
+ location));
+ }
+
+ // Add a constant.
+ Named_object*
+ add_constant(const Typed_identifier& tid, const Package* package,
+ Expression* expr, int iota_value)
+ {
+ return this->add_named_object(Named_object::make_constant(tid, package,
+ expr,
+ iota_value));
+ }
+
+ // Add a type.
+ Named_object*
+ add_type(const std::string& name, const Package* package, Type* type,
+ source_location location)
+ {
+ return this->add_named_object(Named_object::make_type(name, package, type,
+ location));
+ }
+
+ // Add a named type. This is used for builtin types, and to add an
+ // imported type to the global scope.
+ Named_object*
+ add_named_type(Named_type* named_type);
+
+ // Add a type declaration.
+ Named_object*
+ add_type_declaration(const std::string& name, const Package* package,
+ source_location location)
+ {
+ Named_object* no = Named_object::make_type_declaration(name, package,
+ location);
+ return this->add_named_object(no);
+ }
+
+ // Add a variable.
+ Named_object*
+ add_variable(const std::string& name, const Package* package,
+ Variable* variable)
+ {
+ return this->add_named_object(Named_object::make_variable(name, package,
+ variable));
+ }
+
+ // Add a result variable.
+ Named_object*
+ add_result_variable(const std::string& name, Result_variable* result)
+ {
+ return this->add_named_object(Named_object::make_result_variable(name,
+ result));
+ }
+
+ // Add a function.
+ Named_object*
+ add_function(const std::string& name, const Package*, Function* function);
+
+ // Add a function declaration.
+ Named_object*
+ add_function_declaration(const std::string& name, const Package* package,
+ Function_type* type, source_location location);
+
+ // Add a package. The location is the location of the import
+ // statement.
+ Named_object*
+ add_package(const std::string& alias, Package* package)
+ {
+ Named_object* no = Named_object::make_package(alias, package);
+ return this->add_named_object(no);
+ }
+
+ // Define a type which was already declared.
+ void
+ define_type(Named_object*, Named_type*);
+
+ // Add a method to the list of objects. This is not added to the
+ // lookup table.
+ void
+ add_method(Named_object*);
+
+ // Add a named object to this binding.
+ Named_object*
+ add_named_object(Named_object* no)
+ { return this->add_named_object_to_contour(&this->bindings_, no); }
+
+ // Clear all names in file scope from the bindings.
+ void
+ clear_file_scope();
+
+ // Look up a name in this binding contour and in any enclosing
+ // binding contours. This returns NULL if the name is not found.
+ Named_object*
+ lookup(const std::string&) const;
+
+ // Look up a name in this binding contour without looking in any
+ // enclosing binding contours. Returns NULL if the name is not found.
+ Named_object*
+ lookup_local(const std::string&) const;
+
+ // Remove a name.
+ void
+ remove_binding(Named_object*);
+
+ // Traverse the tree. See the Traverse class.
+ int
+ traverse(Traverse*, bool is_global);
+
+ // Iterate over definitions. This does not include things which
+ // were only declared.
+
+ typedef std::vector<Named_object*>::const_iterator
+ const_definitions_iterator;
+
+ const_definitions_iterator
+ begin_definitions() const
+ { return this->named_objects_.begin(); }
+
+ const_definitions_iterator
+ end_definitions() const
+ { return this->named_objects_.end(); }
+
+ // Return the number of definitions.
+ size_t
+ size_definitions() const
+ { return this->named_objects_.size(); }
+
+ // Return whether there are no definitions.
+ bool
+ empty_definitions() const
+ { return this->named_objects_.empty(); }
+
+ // Iterate over declarations. This is everything that has been
+ // declared, which includes everything which has been defined.
+
+ typedef Contour::const_iterator const_declarations_iterator;
+
+ const_declarations_iterator
+ begin_declarations() const
+ { return this->bindings_.begin(); }
+
+ const_declarations_iterator
+ end_declarations() const
+ { return this->bindings_.end(); }
+
+ // Return the number of declarations.
+ size_t
+ size_declarations() const
+ { return this->bindings_.size(); }
+
+ // Return whether there are no declarations.
+ bool
+ empty_declarations() const
+ { return this->bindings_.empty(); }
+
+ // Return the first declaration.
+ Named_object*
+ first_declaration()
+ { return this->bindings_.empty() ? NULL : this->bindings_.begin()->second; }
+
+ private:
+ Named_object*
+ add_named_object_to_contour(Contour*, Named_object*);
+
+ Named_object*
+ new_definition(Named_object*, Named_object*);
+
+ // Enclosing bindings.
+ Bindings* enclosing_;
+ // The list of objects.
+ std::vector<Named_object*> named_objects_;
+ // The mapping from names to objects.
+ Contour bindings_;
+};
+
+// A label.
+
+class Label
+{
+ public:
+ Label(const std::string& name)
+ : name_(name), location_(0), decl_(NULL)
+ { }
+
+ // Return the label's name.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return whether the label has been defined.
+ bool
+ is_defined() const
+ { return this->location_ != 0; }
+
+ // Return the location of the definition.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Define the label at LOCATION.
+ void
+ define(source_location location)
+ {
+ gcc_assert(this->location_ == 0);
+ this->location_ = location;
+ }
+
+ // Return the LABEL_DECL for this decl.
+ tree
+ get_decl();
+
+ // Return an expression for the address of this label.
+ tree
+ get_addr(source_location location);
+
+ private:
+ // The name of the label.
+ std::string name_;
+ // The location of the definition. This is 0 if the label has not
+ // yet been defined.
+ source_location location_;
+ // The LABEL_DECL.
+ tree decl_;
+};
+
+// An unnamed label. These are used when lowering loops.
+
+class Unnamed_label
+{
+ public:
+ Unnamed_label(source_location location)
+ : location_(location), decl_(NULL)
+ { }
+
+ // Get the location where the label is defined.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Set the location where the label is defined.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Return a statement which defines this label.
+ tree
+ get_definition();
+
+ // Return a goto to this label from LOCATION.
+ tree
+ get_goto(source_location location);
+
+ private:
+ // Return the LABEL_DECL to use with GOTO_EXPR.
+ tree
+ get_decl();
+
+ // The location where the label is defined.
+ source_location location_;
+ // The LABEL_DECL.
+ tree decl_;
+};
+
+// An imported package.
+
+class Package
+{
+ public:
+ Package(const std::string& name, const std::string& unique_prefix,
+ source_location location);
+
+ // The real name of this package. This may be different from the
+ // name in the associated Named_object if the import statement used
+ // an alias.
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Return the location of the import statement.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Get the unique prefix used for all symbols exported from this
+ // package.
+ const std::string&
+ unique_prefix() const
+ {
+ gcc_assert(!this->unique_prefix_.empty());
+ return this->unique_prefix_;
+ }
+
+ // The priority of this package. The init function of packages with
+ // lower priority must be run before the init function of packages
+ // with higher priority.
+ int
+ priority() const
+ { return this->priority_; }
+
+ // Set the priority.
+ void
+ set_priority(int priority);
+
+ // Return the bindings.
+ Bindings*
+ bindings()
+ { return this->bindings_; }
+
+ // Whether some symbol from the package was used.
+ bool
+ used() const
+ { return this->used_; }
+
+ // Note that some symbol from this package was used.
+ void
+ set_used() const
+ { this->used_ = true; }
+
+ // Clear the used field for the next file.
+ void
+ clear_used()
+ { this->used_ = false; }
+
+ // Whether this package was imported in the current file.
+ bool
+ is_imported() const
+ { return this->is_imported_; }
+
+ // Note that this package was imported in the current file.
+ void
+ set_is_imported()
+ { this->is_imported_ = true; }
+
+ // Clear the imported field for the next file.
+ void
+ clear_is_imported()
+ { this->is_imported_ = false; }
+
+ // Whether this package was imported with a name of "_".
+ bool
+ uses_sink_alias() const
+ { return this->uses_sink_alias_; }
+
+ // Note that this package was imported with a name of "_".
+ void
+ set_uses_sink_alias()
+ { this->uses_sink_alias_ = true; }
+
+ // Clear the sink alias field for the next file.
+ void
+ clear_uses_sink_alias()
+ { this->uses_sink_alias_ = false; }
+
+ // Look up a name in the package. Returns NULL if the name is not
+ // found.
+ Named_object*
+ lookup(const std::string& name) const
+ { return this->bindings_->lookup(name); }
+
+ // Set the location of the package. This is used if it is seen in a
+ // different import before it is really imported.
+ void
+ set_location(source_location location)
+ { this->location_ = location; }
+
+ // Add a constant to the package.
+ Named_object*
+ add_constant(const Typed_identifier& tid, Expression* expr)
+ { return this->bindings_->add_constant(tid, this, expr, 0); }
+
+ // Add a type to the package.
+ Named_object*
+ add_type(const std::string& name, Type* type, source_location location)
+ { return this->bindings_->add_type(name, this, type, location); }
+
+ // Add a type declaration to the package.
+ Named_object*
+ add_type_declaration(const std::string& name, source_location location)
+ { return this->bindings_->add_type_declaration(name, this, location); }
+
+ // Add a variable to the package.
+ Named_object*
+ add_variable(const std::string& name, Variable* variable)
+ { return this->bindings_->add_variable(name, this, variable); }
+
+ // Add a function declaration to the package.
+ Named_object*
+ add_function_declaration(const std::string& name, Function_type* type,
+ source_location loc)
+ { return this->bindings_->add_function_declaration(name, this, type, loc); }
+
+ // Determine types of constants.
+ void
+ determine_types();
+
+ private:
+ // The real name of this package.
+ std::string name_;
+ // The unique prefix for all exported global symbols.
+ std::string unique_prefix_;
+ // The names in this package.
+ Bindings* bindings_;
+ // The priority of this package. A package has a priority higher
+ // than the priority of all of the packages that it imports. This
+ // is used to run init functions in the right order.
+ int priority_;
+ // The location of the import statement.
+ source_location location_;
+ // True if some name from this package was used. This is mutable
+ // because we can use a package even if we have a const pointer to
+ // it.
+ mutable bool used_;
+ // True if this package was imported in the current file.
+ bool is_imported_;
+ // True if this package was imported with a name of "_".
+ bool uses_sink_alias_;
+};
+
+// Return codes for the traversal functions. This is not an enum
+// because we want to be able to declare traversal functions in other
+// header files without including this one.
+
+// Continue traversal as usual.
+const int TRAVERSE_CONTINUE = -1;
+
+// Exit traversal.
+const int TRAVERSE_EXIT = 0;
+
+// Continue traversal, but skip components of the current object.
+// E.g., if this is returned by Traverse::statement, we do not
+// traverse the expressions in the statement even if
+// traverse_expressions is set in the traverse_mask.
+const int TRAVERSE_SKIP_COMPONENTS = 1;
+
+// This class is used when traversing the parse tree. The caller uses
+// a subclass which overrides functions as desired.
+
+class Traverse
+{
+ public:
+ // These bitmasks say what to traverse.
+ static const unsigned int traverse_variables = 0x1;
+ static const unsigned int traverse_constants = 0x2;
+ static const unsigned int traverse_functions = 0x4;
+ static const unsigned int traverse_blocks = 0x8;
+ static const unsigned int traverse_statements = 0x10;
+ static const unsigned int traverse_expressions = 0x20;
+ static const unsigned int traverse_types = 0x40;
+
+ Traverse(unsigned int traverse_mask)
+ : traverse_mask_(traverse_mask), types_seen_(NULL), expressions_seen_(NULL)
+ { }
+
+ virtual ~Traverse();
+
+ // The bitmask of what to traverse.
+ unsigned int
+ traverse_mask() const
+ { return this->traverse_mask_; }
+
+ // Record that we are going to traverse a type. This returns true
+ // if the type has already been seen in this traversal. This is
+ // required because types, unlike expressions, can form a circular
+ // graph.
+ bool
+ remember_type(const Type*);
+
+ // Record that we are going to see an expression. This returns true
+ // if the expression has already been seen in this traversal. This
+ // is only needed for cases where multiple expressions can point to
+ // a single one.
+ bool
+ remember_expression(const Expression*);
+
+ // These functions return one of the TRAVERSE codes defined above.
+
+ // If traverse_variables is set in the mask, this is called for
+ // every variable in the tree.
+ virtual int
+ variable(Named_object*);
+
+ // If traverse_constants is set in the mask, this is called for
+ // every named constant in the tree. The bool parameter is true for
+ // a global constant.
+ virtual int
+ constant(Named_object*, bool);
+
+ // If traverse_functions is set in the mask, this is called for
+ // every function in the tree.
+ virtual int
+ function(Named_object*);
+
+ // If traverse_blocks is set in the mask, this is called for every
+ // block in the tree.
+ virtual int
+ block(Block*);
+
+ // If traverse_statements is set in the mask, this is called for
+ // every statement in the tree.
+ virtual int
+ statement(Block*, size_t* index, Statement*);
+
+ // If traverse_expressions is set in the mask, this is called for
+ // every expression in the tree.
+ virtual int
+ expression(Expression**);
+
+ // If traverse_types is set in the mask, this is called for every
+ // type in the tree.
+ virtual int
+ type(Type*);
+
+ private:
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+
+ typedef Unordered_set(const Expression*) Expressions_seen;
+
+ // Bitmask of what sort of objects to traverse.
+ unsigned int traverse_mask_;
+ // Types which have been seen in this traversal.
+ Types_seen* types_seen_;
+ // Expressions which have been seen in this traversal.
+ Expressions_seen* expressions_seen_;
+};
+
+// When translating the gogo IR into trees, this is the context we
+// pass down the blocks and statements.
+
+class Translate_context
+{
+ public:
+ Translate_context(Gogo* gogo, Named_object* function, Block* block,
+ tree block_tree)
+ : gogo_(gogo), function_(function), block_(block), block_tree_(block_tree),
+ is_const_(false)
+ { }
+
+ // Accessors.
+
+ Gogo*
+ gogo()
+ { return this->gogo_; }
+
+ Named_object*
+ function()
+ { return this->function_; }
+
+ Block*
+ block()
+ { return this->block_; }
+
+ tree
+ block_tree()
+ { return this->block_tree_; }
+
+ bool
+ is_const()
+ { return this->is_const_; }
+
+ // Make a constant context.
+ void
+ set_is_const()
+ { this->is_const_ = true; }
+
+ private:
+ // The IR for the entire compilation unit.
+ Gogo* gogo_;
+ // The function we are currently translating.
+ Named_object* function_;
+ // The block we are currently translating.
+ Block *block_;
+ // The BLOCK node for the current block.
+ tree block_tree_;
+ // Whether this is being evaluated in a constant context. This is
+ // used for type descriptor initializers.
+ bool is_const_;
+};
+
+// Runtime error codes. These must match the values in
+// libgo/runtime/go-runtime-error.c.
+
+// Slice index out of bounds: negative or larger than the length of
+// the slice.
+static const int RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS = 0;
+
+// Array index out of bounds.
+static const int RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS = 1;
+
+// String index out of bounds.
+static const int RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS = 2;
+
+// Slice slice out of bounds: negative or larger than the length of
+// the slice or high bound less than low bound.
+static const int RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS = 3;
+
+// Array slice out of bounds.
+static const int RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS = 4;
+
+// String slice out of bounds.
+static const int RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS = 5;
+
+// Dereference of nil pointer. This is used when there is a
+// dereference of a pointer to a very large struct or array, to ensure
+// that a gigantic array is not used a proxy to access random memory
+// locations.
+static const int RUNTIME_ERROR_NIL_DEREFERENCE = 6;
+
+// Slice length or capacity out of bounds in make: negative or
+// overflow or length greater than capacity.
+static const int RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS = 7;
+
+// Map capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS = 8;
+
+// Channel capacity out of bounds in make: negative or overflow.
+static const int RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS = 9;
+
+// This is used by some of the langhooks.
+extern Gogo* go_get_gogo();
+
+// Whether we have seen any errors. FIXME: Replace with a backend
+// interface.
+extern bool saw_errors();
+
+#endif // !defined(GO_GOGO_H)
--- /dev/null
+// parse.cc -- Go frontend parser.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "lex.h"
+#include "gogo.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "parse.h"
+
+// Struct Parse::Enclosing_var_comparison.
+
+// Return true if v1 should be considered to be less than v2.
+
+bool
+Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
+ const Enclosing_var& v2)
+{
+ if (v1.var() == v2.var())
+ return false;
+
+ const std::string& n1(v1.var()->name());
+ const std::string& n2(v2.var()->name());
+ int i = n1.compare(n2);
+ if (i < 0)
+ return true;
+ else if (i > 0)
+ return false;
+
+ // If we get here it means that a single nested function refers to
+ // two different variables defined in enclosing functions, and both
+ // variables have the same name. I think this is impossible.
+ gcc_unreachable();
+}
+
+// Class Parse.
+
+Parse::Parse(Lex* lex, Gogo* gogo)
+ : lex_(lex),
+ token_(Token::make_invalid_token(0)),
+ unget_token_(Token::make_invalid_token(0)),
+ unget_token_valid_(false),
+ gogo_(gogo),
+ break_stack_(),
+ continue_stack_(),
+ iota_(0),
+ enclosing_vars_()
+{
+}
+
+// Return the current token.
+
+const Token*
+Parse::peek_token()
+{
+ if (this->unget_token_valid_)
+ return &this->unget_token_;
+ if (this->token_.is_invalid())
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Advance to the next token and return it.
+
+const Token*
+Parse::advance_token()
+{
+ if (this->unget_token_valid_)
+ {
+ this->unget_token_valid_ = false;
+ if (!this->token_.is_invalid())
+ return &this->token_;
+ }
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Push a token back on the input stream.
+
+void
+Parse::unget_token(const Token& token)
+{
+ gcc_assert(!this->unget_token_valid_);
+ this->unget_token_ = token;
+ this->unget_token_valid_ = true;
+}
+
+// The location of the current token.
+
+source_location
+Parse::location()
+{
+ return this->peek_token()->location();
+}
+
+// IdentifierList = identifier { "," identifier } .
+
+void
+Parse::identifier_list(Typed_identifier_list* til)
+{
+ const Token* token = this->peek_token();
+ while (true)
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til->push_back(Typed_identifier(name, NULL, token->location()));
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return;
+ token = this->advance_token();
+ }
+}
+
+// ExpressionList = Expression { "," Expression } .
+
+// If MAY_BE_SINK is true, the expressions in the list may be "_".
+
+Expression_list*
+Parse::expression_list(Expression* first, bool may_be_sink)
+{
+ Expression_list* ret = new Expression_list();
+ if (first != NULL)
+ ret->push_back(first);
+ while (true)
+ {
+ ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink, true,
+ NULL));
+
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return ret;
+
+ // Most expression lists permit a trailing comma.
+ source_location location = token->location();
+ this->advance_token();
+ if (!this->expression_may_start_here())
+ {
+ this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
+ location));
+ return ret;
+ }
+ }
+}
+
+// QualifiedIdent = [ PackageName "." ] identifier .
+// PackageName = identifier .
+
+// This sets *PNAME to the identifier and sets *PPACKAGE to the
+// package or NULL if there isn't one. This returns true on success,
+// false on failure in which case it will have emitted an error
+// message.
+
+bool
+Parse::qualified_ident(std::string* pname, Named_object** ppackage)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT))
+ {
+ *pname = name;
+ *ppackage = NULL;
+ return true;
+ }
+
+ Named_object* package = this->gogo_->lookup(name, NULL);
+ if (package == NULL || !package->is_package())
+ {
+ error_at(this->location(), "expected package");
+ // We expect . IDENTIFIER; skip both.
+ if (this->advance_token()->is_identifier())
+ this->advance_token();
+ return false;
+ }
+
+ package->package_value()->set_used();
+
+ token = this->advance_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ name = token->identifier();
+
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = "blank";
+ }
+
+ if (package->name() == this->gogo_->package_name())
+ name = this->gogo_->pack_hidden_name(name,
+ token->is_identifier_exported());
+
+ *pname = name;
+ *ppackage = package;
+
+ this->advance_token();
+
+ return true;
+}
+
+// Type = TypeName | TypeLit | "(" Type ")" .
+// TypeLit =
+// ArrayType | StructType | PointerType | FunctionType | InterfaceType |
+// SliceType | MapType | ChannelType .
+
+Type*
+Parse::type()
+{
+ const Token* token = this->peek_token();
+ if (token->is_identifier())
+ return this->type_name(true);
+ else if (token->is_op(OPERATOR_LSQUARE))
+ return this->array_type(false);
+ else if (token->is_keyword(KEYWORD_CHAN)
+ || token->is_op(OPERATOR_CHANOP))
+ return this->channel_type();
+ else if (token->is_keyword(KEYWORD_INTERFACE))
+ return this->interface_type();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ {
+ source_location location = token->location();
+ this->advance_token();
+ return this->signature(NULL, location);
+ }
+ else if (token->is_keyword(KEYWORD_MAP))
+ return this->map_type();
+ else if (token->is_keyword(KEYWORD_STRUCT))
+ return this->struct_type();
+ else if (token->is_op(OPERATOR_MULT))
+ return this->pointer_type();
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* ret = this->type();
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (!ret->is_error_type())
+ error_at(this->location(), "expected %<)%>");
+ }
+ return ret;
+ }
+ else
+ {
+ error_at(token->location(), "expected type");
+ return Type::make_error_type();
+ }
+}
+
+bool
+Parse::type_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_identifier()
+ || token->is_op(OPERATOR_LSQUARE)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_keyword(KEYWORD_CHAN)
+ || token->is_keyword(KEYWORD_INTERFACE)
+ || token->is_keyword(KEYWORD_FUNC)
+ || token->is_keyword(KEYWORD_MAP)
+ || token->is_keyword(KEYWORD_STRUCT)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_LPAREN));
+}
+
+// TypeName = QualifiedIdent .
+
+// If MAY_BE_NIL is true, then an identifier with the value of the
+// predefined constant nil is accepted, returning the nil type.
+
+Type*
+Parse::type_name(bool issue_error)
+{
+ source_location location = this->location();
+
+ std::string name;
+ Named_object* package;
+ if (!this->qualified_ident(&name, &package))
+ return Type::make_error_type();
+
+ Named_object* named_object;
+ if (package == NULL)
+ named_object = this->gogo_->lookup(name, NULL);
+ else
+ {
+ named_object = package->package_value()->lookup(name);
+ if (named_object == NULL
+ && issue_error
+ && package->name() != this->gogo_->package_name())
+ {
+ // Check whether the name is there but hidden.
+ std::string s = ('.' + package->package_value()->unique_prefix()
+ + '.' + package->package_value()->name()
+ + '.' + name);
+ named_object = package->package_value()->lookup(s);
+ if (named_object != NULL)
+ {
+ const std::string& packname(package->package_value()->name());
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(packname).c_str(),
+ Gogo::message_name(name).c_str());
+ issue_error = false;
+ }
+ }
+ }
+
+ bool ok = true;
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ ok = false;
+ else
+ named_object = this->gogo_->add_unknown_name(name, location);
+ }
+ else if (named_object->is_type())
+ {
+ if (!named_object->type_value()->is_visible())
+ ok = false;
+ }
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ ;
+ else
+ ok = false;
+
+ if (!ok)
+ {
+ if (issue_error)
+ error_at(location, "expected type");
+ return Type::make_error_type();
+ }
+
+ if (named_object->is_type())
+ return named_object->type_value();
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ return Type::make_forward_declaration(named_object);
+ else
+ gcc_unreachable();
+}
+
+// ArrayType = "[" [ ArrayLength ] "]" ElementType .
+// ArrayLength = Expression .
+// ElementType = CompleteType .
+
+Type*
+Parse::array_type(bool may_use_ellipsis)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ const Token* token = this->advance_token();
+
+ Expression* length = NULL;
+ if (token->is_op(OPERATOR_RSQUARE))
+ this->advance_token();
+ else
+ {
+ if (!token->is_op(OPERATOR_ELLIPSIS))
+ length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else if (may_use_ellipsis)
+ {
+ // An ellipsis is used in composite literals to represent a
+ // fixed array of the size of the number of elements. We
+ // use a length of nil to represent this, and change the
+ // length when parsing the composite literal.
+ length = Expression::make_nil(this->location());
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(),
+ "use of %<[...]%> outside of array literal");
+ length = Expression::make_error(this->location());
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+ }
+
+ Type* element_type = this->type();
+
+ return Type::make_array_type(element_type, length);
+}
+
+// MapType = "map" "[" KeyType "]" ValueType .
+// KeyType = CompleteType .
+// ValueType = CompleteType .
+
+Type*
+Parse::map_type()
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
+ if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
+ {
+ error_at(this->location(), "expected %<[%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* key_type = this->type();
+
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* value_type = this->type();
+
+ if (key_type->is_error_type() || value_type->is_error_type())
+ return Type::make_error_type();
+
+ return Type::make_map_type(key_type, value_type, location);
+}
+
+// StructType = "struct" "{" { FieldDecl ";" } "}" .
+
+Type*
+Parse::struct_type()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
+ source_location location = this->location();
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Struct_field_list* sfl = new Struct_field_list;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->field_decl(sfl);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ for (Struct_field_list::const_iterator pi = sfl->begin();
+ pi != sfl->end();
+ ++pi)
+ {
+ if (pi->type()->is_error_type())
+ return pi->type();
+ for (Struct_field_list::const_iterator pj = pi + 1;
+ pj != sfl->end();
+ ++pj)
+ {
+ if (pi->field_name() == pj->field_name()
+ && !Gogo::is_sink_name(pi->field_name()))
+ error_at(pi->location(), "duplicate field name %<%s%>",
+ Gogo::message_name(pi->field_name()).c_str());
+ }
+ }
+
+ return Type::make_struct_type(sfl, location);
+}
+
+// FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
+// Tag = string_lit .
+
+void
+Parse::field_decl(Struct_field_list* sfl)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ bool is_anonymous;
+ bool is_anonymous_pointer;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_anonymous = true;
+ is_anonymous_pointer = true;
+ }
+ else if (token->is_identifier())
+ {
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+ token = this->advance_token();
+ is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
+ || token->is_op(OPERATOR_RCURLY)
+ || token->is_op(OPERATOR_DOT)
+ || token->is_string());
+ is_anonymous_pointer = false;
+ this->unget_token(Token::make_identifier_token(id, is_id_exported,
+ id_location));
+ }
+ else
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+
+ if (is_anonymous)
+ {
+ if (is_anonymous_pointer)
+ {
+ this->advance_token();
+ if (!this->peek_token()->is_identifier())
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+ }
+ Type* type = this->type_name(true);
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ if (!type->is_error_type())
+ {
+ if (is_anonymous_pointer)
+ type = Type::make_pointer_type(type);
+ sfl->push_back(Struct_field(Typed_identifier("", type, location)));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+ else
+ {
+ Typed_identifier_list til;
+ while (true)
+ {
+ token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til.push_back(Typed_identifier(name, NULL, token->location()));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+
+ Type* type = this->type();
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ for (Typed_identifier_list::iterator p = til.begin();
+ p != til.end();
+ ++p)
+ {
+ p->set_type(type);
+ sfl->push_back(Struct_field(*p));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+}
+
+// PointerType = "*" Type .
+
+Type*
+Parse::pointer_type()
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_MULT));
+ this->advance_token();
+ Type* type = this->type();
+ if (type->is_error_type())
+ return type;
+ return Type::make_pointer_type(type);
+}
+
+// ChannelType = Channel | SendChannel | RecvChannel .
+// Channel = "chan" ElementType .
+// SendChannel = "chan" "<-" ElementType .
+// RecvChannel = "<-" "chan" ElementType .
+
+Type*
+Parse::channel_type()
+{
+ const Token* token = this->peek_token();
+ bool send = true;
+ bool receive = true;
+ if (token->is_op(OPERATOR_CHANOP))
+ {
+ if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
+ {
+ error_at(this->location(), "expected %<chan%>");
+ return Type::make_error_type();
+ }
+ send = false;
+ this->advance_token();
+ }
+ else
+ {
+ gcc_assert(token->is_keyword(KEYWORD_CHAN));
+ if (this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ receive = false;
+ this->advance_token();
+ }
+ }
+ Type* element_type = this->type();
+ return Type::make_channel_type(send, receive, element_type);
+}
+
+// Signature = Parameters [ Result ] .
+
+// RECEIVER is the receiver if there is one, or NULL. LOCATION is the
+// location of the start of the type.
+
+Function_type*
+Parse::signature(Typed_identifier* receiver, source_location location)
+{
+ bool is_varargs = false;
+ Typed_identifier_list* params = this->parameters(&is_varargs);
+
+ Typed_identifier_list* result = NULL;
+ if (this->peek_token()->is_op(OPERATOR_LPAREN)
+ || this->type_may_start_here())
+ result = this->result();
+
+ Function_type* ret = Type::make_function_type(receiver, params, result,
+ location);
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Parameters = "(" [ ParameterList [ "," ] ] ")" .
+
+Typed_identifier_list*
+Parse::parameters(bool* is_varargs)
+{
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return NULL;
+ }
+
+ Typed_identifier_list* params = NULL;
+
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ params = this->parameter_list(is_varargs);
+ token = this->peek_token();
+ }
+
+ // The optional trailing comma is picked up in parameter_list.
+
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+
+ return params;
+}
+
+// ParameterList = ParameterDecl { "," ParameterDecl } .
+
+// This sets *IS_VARARGS if the list ends with an ellipsis.
+// IS_VARARGS will be NULL if varargs are not permitted.
+
+// We pick up an optional trailing comma.
+
+Typed_identifier_list*
+Parse::parameter_list(bool* is_varargs)
+{
+ source_location location = this->location();
+ Typed_identifier_list* ret = new Typed_identifier_list();
+
+ // If we see an identifier and then a comma, then we don't know
+ // whether we are looking at a list of identifiers followed by a
+ // type, or a list of types given by name. We have to do an
+ // arbitrary lookahead to figure it out.
+
+ bool parameters_have_names;
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ // This must be a type which starts with something like '*'.
+ parameters_have_names = false;
+ }
+ else
+ {
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_DOT))
+ {
+ // This is a qualified identifier, which must turn out
+ // to be a type.
+ parameters_have_names = false;
+ }
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ // A single identifier followed by a parenthesis must be
+ // a type name.
+ parameters_have_names = false;
+ }
+ else
+ {
+ // An identifier followed by something other than a
+ // comma or a dot or a right parenthesis must be a
+ // parameter name followed by a type.
+ parameters_have_names = true;
+ }
+
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ }
+ else
+ {
+ // An identifier followed by a comma may be the first in a
+ // list of parameter names followed by a type, or it may be
+ // the first in a list of types without parameter names. To
+ // find out we gather as many identifiers separated by
+ // commas as we can.
+ std::string id_name = this->gogo_->pack_hidden_name(name,
+ is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ bool just_saw_comma = true;
+ while (this->advance_token()->is_identifier())
+ {
+ name = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ location = this->peek_token()->location();
+ id_name = this->gogo_->pack_hidden_name(name, is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ {
+ just_saw_comma = false;
+ break;
+ }
+ }
+
+ if (just_saw_comma)
+ {
+ // We saw ID1 "," ID2 "," followed by something which
+ // was not an identifier. We must be seeing the start
+ // of a type, and ID1 and ID2 must be types, and the
+ // parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
+ // and the parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_DOT))
+ {
+ // We saw ID1 "," ID2 ".". ID2 must be a package name,
+ // ID1 must be a type, and the parameters don't have
+ // names.
+ parameters_have_names = false;
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ ret->pop_back();
+ just_saw_comma = true;
+ }
+ else
+ {
+ // We saw ID1 "," ID2 followed by something other than
+ // ",", ".", or ")". We must be looking at the start of
+ // a type, and ID1 and ID2 must be parameter names.
+ parameters_have_names = true;
+ }
+
+ if (parameters_have_names)
+ {
+ gcc_assert(!just_saw_comma);
+ // We have just seen ID1, ID2 xxx.
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ error_at(this->location(), "%<...%> only permits one name");
+ this->advance_token();
+ type = this->type();
+ }
+ for (size_t i = 0; i < ret->size(); ++i)
+ ret->set_type(i, type);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ return ret;
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ return ret;
+ }
+ else
+ {
+ Typed_identifier_list* tret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = ret->begin();
+ p != ret->end();
+ ++p)
+ {
+ Named_object* no = this->gogo_->lookup(p->name(), NULL);
+ Type* type;
+ if (no == NULL)
+ no = this->gogo_->add_unknown_name(p->name(),
+ p->location());
+
+ if (no->is_type())
+ type = no->type_value();
+ else if (no->is_unknown() || no->is_type_declaration())
+ type = Type::make_forward_declaration(no);
+ else
+ {
+ error_at(p->location(), "expected %<%s%> to be a type",
+ Gogo::message_name(p->name()).c_str());
+ type = Type::make_error_type();
+ }
+ tret->push_back(Typed_identifier("", type, p->location()));
+ }
+ delete ret;
+ ret = tret;
+ if (!just_saw_comma
+ || this->peek_token()->is_op(OPERATOR_RPAREN))
+ return ret;
+ }
+ }
+ }
+
+ bool mix_error = false;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ while (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (is_varargs != NULL && *is_varargs)
+ error_at(this->location(), "%<...%> must be last parameter");
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ break;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ }
+ if (mix_error)
+ error_at(location, "invalid named/anonymous mix");
+ return ret;
+}
+
+// ParameterDecl = [ IdentifierList ] [ "..." ] Type .
+
+void
+Parse::parameter_decl(bool parameters_have_names,
+ Typed_identifier_list* til,
+ bool* is_varargs,
+ bool* mix_error)
+{
+ if (!parameters_have_names)
+ {
+ Type* type;
+ source_location location = this->location();
+ if (!this->peek_token()->is_identifier())
+ {
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ if (is_varargs == NULL
+ && this->peek_token()->is_op(OPERATOR_RPAREN))
+ type = Type::make_error_type();
+ else
+ {
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ }
+ }
+ else
+ {
+ type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN)))
+ {
+ *mix_error = true;
+ while (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ }
+ }
+ if (!type->is_error_type())
+ til->push_back(Typed_identifier("", type, location));
+ }
+ else
+ {
+ size_t orig_count = til->size();
+ if (this->peek_token()->is_identifier())
+ this->identifier_list(til);
+ else
+ *mix_error = true;
+ size_t new_count = til->size();
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else if (new_count > orig_count + 1)
+ error_at(this->location(), "%<...%> only permits one name");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ for (size_t i = orig_count; i < new_count; ++i)
+ til->set_type(i, type);
+ }
+}
+
+// Result = Parameters | Type .
+
+Typed_identifier_list*
+Parse::result()
+{
+ if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ return this->parameters(NULL);
+ else
+ {
+ source_location location = this->location();
+ Typed_identifier_list* til = new Typed_identifier_list();
+ Type* type = this->type();
+ til->push_back(Typed_identifier("", type, location));
+ return til;
+ }
+}
+
+// Block = "{" [ StatementList ] "}" .
+
+// Returns the location of the closing brace.
+
+source_location
+Parse::block()
+{
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return UNKNOWN_LOCATION;
+ }
+ }
+
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ this->statement_list();
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ if (!token->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<}%>");
+
+ // Skip ahead to the end of the block, in hopes of avoiding
+ // lots of meaningless errors.
+ source_location ret = token->location();
+ int nest = 0;
+ while (!token->is_eof())
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++nest;
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ --nest;
+ if (nest < 0)
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ token = this->advance_token();
+ ret = token->location();
+ }
+ return ret;
+ }
+ }
+
+ source_location ret = token->location();
+ this->advance_token();
+ return ret;
+}
+
+// InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
+// MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
+
+Type*
+Parse::interface_type()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
+ source_location location = this->location();
+
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Typed_identifier_list* methods = new Typed_identifier_list();
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->method_spec(methods);
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ break;
+ this->method_spec(methods);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<}%>");
+ while (!this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ return Type::make_error_type();
+ }
+ }
+ }
+ this->advance_token();
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ Interface_type* ret = Type::make_interface_type(methods, location);
+ this->gogo_->record_interface_type(ret);
+ return ret;
+}
+
+// MethodSpec = MethodName Signature | InterfaceTypeName .
+// MethodName = identifier .
+// InterfaceTypeName = TypeName .
+
+bool
+Parse::method_spec(Typed_identifier_list* methods)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ if (this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ // This is a MethodName.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ Function_type* type = this->signature(NULL, location);
+ methods->push_back(Typed_identifier(name, type, location));
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ Type* type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY)))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(),
+ "name list not allowed in interface type");
+ else
+ error_at(location, "expected signature or type name");
+ token = this->peek_token();
+ while (!token->is_eof()
+ && !token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY))
+ token = this->advance_token();
+ return false;
+ }
+ // This must be an interface type, but we can't check that now.
+ // We check it and pull out the methods in
+ // Interface_type::do_verify.
+ methods->push_back(Typed_identifier("", type, location));
+ }
+
+ return false;
+}
+
+// Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
+
+void
+Parse::declaration()
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CONST))
+ this->const_decl();
+ else if (token->is_keyword(KEYWORD_TYPE))
+ this->type_decl();
+ else if (token->is_keyword(KEYWORD_VAR))
+ this->var_decl();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ this->function_decl();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ this->advance_token();
+ }
+}
+
+bool
+Parse::declaration_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_keyword(KEYWORD_CONST)
+ || token->is_keyword(KEYWORD_TYPE)
+ || token->is_keyword(KEYWORD_VAR)
+ || token->is_keyword(KEYWORD_FUNC));
+}
+
+// Decl<P> = P | "(" [ List<P> ] ")" .
+
+void
+Parse::decl(void (Parse::*pfn)(void*), void* varg)
+{
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ (this->*pfn)(varg);
+ else
+ {
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->list(pfn, varg, true);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "missing %<)%>");
+ while (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ if (this->peek_token()->is_eof())
+ return;
+ }
+ }
+ }
+ this->advance_token();
+ }
+}
+
+// List<P> = P { ";" P } [ ";" ] .
+
+// In order to pick up the trailing semicolon we need to know what
+// might follow. This is either a '}' or a ')'.
+
+void
+Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
+{
+ (this->*pfn)(varg);
+ Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ || this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "unexpected comma");
+ if (this->advance_token()->is_op(follow))
+ break;
+ (this->*pfn)(varg);
+ }
+}
+
+// ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
+
+void
+Parse::const_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
+ this->advance_token();
+ this->reset_iota();
+
+ Type* last_type = NULL;
+ Expression_list* last_expr_list = NULL;
+
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ this->const_spec(&last_type, &last_expr_list);
+ else
+ {
+ this->advance_token();
+ while (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->const_spec(&last_type, &last_expr_list);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<;%> or %<)%> or newline");
+ if (!this->skip_past_error(OPERATOR_RPAREN))
+ return;
+ }
+ }
+ this->advance_token();
+ }
+
+ if (last_expr_list != NULL)
+ delete last_expr_list;
+}
+
+// ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
+
+void
+Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
+{
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ Type* type = NULL;
+ if (this->type_may_start_here())
+ {
+ type = this->type();
+ *last_type = NULL;
+ *last_expr_list = NULL;
+ }
+
+ Expression_list *expr_list;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (*last_expr_list == NULL)
+ {
+ error_at(this->location(), "expected %<=%>");
+ return;
+ }
+ type = *last_type;
+ expr_list = new Expression_list;
+ for (Expression_list::const_iterator p = (*last_expr_list)->begin();
+ p != (*last_expr_list)->end();
+ ++p)
+ expr_list->push_back((*p)->copy());
+ }
+ else
+ {
+ this->advance_token();
+ expr_list = this->expression_list(NULL, false);
+ *last_type = type;
+ if (*last_expr_list != NULL)
+ delete *last_expr_list;
+ *last_expr_list = expr_list;
+ }
+
+ Expression_list::const_iterator pe = expr_list->begin();
+ for (Typed_identifier_list::iterator pi = til.begin();
+ pi != til.end();
+ ++pi, ++pe)
+ {
+ if (pe == expr_list->end())
+ {
+ error_at(this->location(), "not enough initializers");
+ return;
+ }
+ if (type != NULL)
+ pi->set_type(type);
+
+ if (!Gogo::is_sink_name(pi->name()))
+ this->gogo_->add_constant(*pi, *pe, this->iota_value());
+ }
+ if (pe != expr_list->end())
+ error_at(this->location(), "too many initializers");
+
+ this->increment_iota();
+
+ return;
+}
+
+// TypeDecl = "type" Decl<TypeSpec> .
+
+void
+Parse::type_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
+ this->advance_token();
+ this->decl(&Parse::type_spec, NULL);
+}
+
+// TypeSpec = identifier Type .
+
+void
+Parse::type_spec(void*)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+
+ // The scope of the type name starts at the point where the
+ // identifier appears in the source code. We implement this by
+ // declaring the type before we read the type definition.
+ Named_object* named_type = NULL;
+ if (name != "_")
+ {
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ named_type = this->gogo_->declare_type(name, location);
+ }
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ type = this->type();
+ else
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline in type declaration");
+ type = Type::make_error_type();
+ this->advance_token();
+ }
+
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+
+ if (name != "_")
+ {
+ if (named_type->is_type_declaration())
+ {
+ Type* ftype = type->forwarded();
+ if (ftype->forward_declaration_type() != NULL
+ && (ftype->forward_declaration_type()->named_object()
+ == named_type))
+ {
+ error_at(location, "invalid recursive type");
+ type = Type::make_error_type();
+ }
+
+ this->gogo_->define_type(named_type,
+ Type::make_named_type(named_type, type,
+ location));
+ gcc_assert(named_type->package() == NULL);
+ }
+ else
+ {
+ // This will probably give a redefinition error.
+ this->gogo_->add_type(name, type, location);
+ }
+ }
+}
+
+// VarDecl = "var" Decl<VarSpec> .
+
+void
+Parse::var_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
+ this->advance_token();
+ this->decl(&Parse::var_spec, NULL);
+}
+
+// VarSpec = IdentifierList
+// ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
+
+void
+Parse::var_spec(void*)
+{
+ // Get the variable names.
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ source_location location = this->location();
+
+ Type* type = NULL;
+ Expression_list* init = NULL;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ type = this->type();
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_EQ)
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+
+ this->init_vars(&til, type, init, false, location);
+
+ if (init != NULL)
+ delete init;
+}
+
+// Create variables. TIL is a list of variable names. If TYPE is not
+// NULL, it is the type of all the variables. If INIT is not NULL, it
+// is an initializer list for the variables.
+
+void
+Parse::init_vars(const Typed_identifier_list* til, Type* type,
+ Expression_list* init, bool is_coloneq,
+ source_location location)
+{
+ // Check for an initialization which can yield multiple values.
+ if (init != NULL && init->size() == 1 && til->size() > 1)
+ {
+ if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_type_guard(til, type, *init->begin(),
+ is_coloneq, location))
+ return;
+ }
+
+ if (init != NULL && init->size() != til->size())
+ {
+ if (init->empty() || !init->front()->is_error_expression())
+ error_at(location, "wrong number of initializations");
+ init = NULL;
+ if (type == NULL)
+ type = Type::make_error_type();
+ }
+
+ // Note that INIT was already parsed with the old name bindings, so
+ // we don't have to worry that it will accidentally refer to the
+ // newly declared variables.
+
+ Expression_list::const_iterator pexpr;
+ if (init != NULL)
+ pexpr = init->begin();
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator p = til->begin();
+ p != til->end();
+ ++p)
+ {
+ if (init != NULL)
+ gcc_assert(pexpr != init->end());
+ this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
+ false, &any_new);
+ if (init != NULL)
+ ++pexpr;
+ }
+ if (init != NULL)
+ gcc_assert(pexpr == init->end());
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// See if we need to initialize a list of variables from a function
+// call. This returns true if we have set up the variables and the
+// initialization.
+
+bool
+Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Call_expression* call = expr->call_expression();
+ if (call == NULL)
+ return false;
+
+ // This is a function call. We can't check here whether it returns
+ // the right number of values, but it might. Declare the variables,
+ // and then assign the results of the call to them.
+
+ unsigned int index = 0;
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator pv = vars->begin();
+ pv != vars->end();
+ ++pv, ++index)
+ {
+ Expression* init = Expression::make_call_result(call, index);
+ this->init_var(*pv, type, init, is_coloneq, false, &any_new);
+ }
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a map index
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Index_expression* index = expr->index_expression();
+ if (index == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is an index which is being assigned to two variables. It
+ // must be a map index. Declare the variables, and then assign the
+ // results of the map index.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? index : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* present_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
+ index, location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else
+ val_no->var_value()->add_preinit_statement(s);
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a receive
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Receive_expression* receive = expr->receive_expression();
+ if (receive == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a receive expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the receive.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? receive : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* received_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_receive_assignment(val_var,
+ received_var,
+ receive->channel(),
+ location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else
+ val_no->var_value()->add_preinit_statement(s);
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a type guard
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
+ Type* type, Expression* expr,
+ bool is_coloneq, source_location location)
+{
+ Type_guard_expression* type_guard = expr->type_guard_expression();
+ if (type_guard == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a type guard expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the type guard.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = type_guard->type();
+ Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* ok_var = Expression::make_var_reference(no, location);
+
+ Expression* texpr = type_guard->expr();
+ Type* t = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
+ texpr, t,
+ location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else
+ val_no->var_value()->add_preinit_statement(s);
+
+ return true;
+}
+
+// Create a single variable. If IS_COLONEQ is true, we permit
+// redeclarations in the same block, and we set *IS_NEW when we find a
+// new variable which is not a redeclaration.
+
+Named_object*
+Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
+ bool is_coloneq, bool type_from_init, bool* is_new)
+{
+ source_location location = tid.location();
+
+ if (Gogo::is_sink_name(tid.name()))
+ {
+ if (!type_from_init && init != NULL)
+ {
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(Statement::make_statement(init));
+ else
+ {
+ // Create a dummy global variable to force the
+ // initializer to be run in the right place.
+ Variable* var = new Variable(type, init, true, false, false,
+ location);
+ static int count;
+ char buf[30];
+ snprintf(buf, sizeof buf, "_.%d", count);
+ ++count;
+ return this->gogo_->add_variable(buf, var);
+ }
+ }
+ return this->gogo_->add_sink();
+ }
+
+ if (is_coloneq)
+ {
+ Named_object* no = this->gogo_->lookup_in_block(tid.name());
+ if (no != NULL
+ && (no->is_variable() || no->is_result_variable()))
+ {
+ // INIT may be NULL even when IS_COLONEQ is true for cases
+ // like v, ok := x.(int).
+ if (!type_from_init && init != NULL)
+ {
+ Expression *v = Expression::make_var_reference(no, location);
+ Statement *s = Statement::make_assignment(v, init, location);
+ this->gogo_->add_statement(s);
+ }
+ return no;
+ }
+ }
+ *is_new = true;
+ Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
+ false, false, location);
+ return this->gogo_->add_variable(tid.name(), var);
+}
+
+// SimpleVarDecl = identifier ":=" Expression .
+
+// We've already seen the identifier.
+
+// FIXME: We also have to implement
+// IdentifierList ":=" ExpressionList
+// In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
+// tuple assignments here as well.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+void
+Parse::simple_var_decl_or_assignment(const std::string& name,
+ source_location location,
+ Range_clause* p_range_clause,
+ Type_switch* p_type_switch)
+{
+ Typed_identifier_list til;
+ til.push_back(Typed_identifier(name, NULL, location));
+
+ // We've seen one identifier. If we see a comma now, this could be
+ // "a, *p = 1, 2".
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ gcc_assert(p_type_switch == NULL);
+ while (true)
+ {
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ break;
+
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+ else
+ this->unget_token(Token::make_identifier_token(id,
+ is_id_exported,
+ id_location));
+ break;
+ }
+
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+
+ // We have a comma separated list of identifiers in TIL. If the
+ // next token is COLONEQ, then this is a simple var decl, and we
+ // have the complete list of identifiers. If the next token is
+ // not COLONEQ, then the only valid parse is a tuple assignment.
+ // The list of identifiers we have so far is really a list of
+ // expressions. There are more expressions following.
+
+ if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
+ {
+ Expression_list* exprs = new Expression_list;
+ for (Typed_identifier_list::const_iterator p = til.begin();
+ p != til.end();
+ ++p)
+ exprs->push_back(this->id_to_expression(p->name(),
+ p->location()));
+
+ Expression_list* more_exprs = this->expression_list(NULL, true);
+ for (Expression_list::const_iterator p = more_exprs->begin();
+ p != more_exprs->end();
+ ++p)
+ exprs->push_back(*p);
+ delete more_exprs;
+
+ this->tuple_assignment(exprs, p_range_clause);
+ return;
+ }
+ }
+
+ gcc_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
+ const Token* token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ this->range_clause_decl(&til, p_range_clause);
+ return;
+ }
+
+ Expression_list* init;
+ if (p_type_switch == NULL)
+ init = this->expression_list(NULL, false);
+ else
+ {
+ bool is_type_switch = false;
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ &is_type_switch);
+ if (is_type_switch)
+ {
+ p_type_switch->found = true;
+ p_type_switch->name = name;
+ p_type_switch->location = location;
+ p_type_switch->expr = expr;
+ return;
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ init = new Expression_list();
+ init->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(expr, false);
+ }
+ }
+
+ this->init_vars(&til, NULL, init, true, location);
+}
+
+// FunctionDecl = "func" identifier Signature [ Block ] .
+// MethodDecl = "func" Receiver identifier Signature [ Block ] .
+
+// gcc extension:
+// FunctionDecl = "func" identifier Signature
+// __asm__ "(" string_lit ")" .
+// This extension means a function whose real name is the identifier
+// inside the asm.
+
+void
+Parse::function_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ Typed_identifier* rec = NULL;
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ rec = this->receiver();
+ token = this->peek_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected function name");
+ return;
+ }
+
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+
+ this->advance_token();
+
+ Function_type* fntype = this->signature(rec, this->location());
+
+ Named_object* named_object = NULL;
+
+ if (this->peek_token()->is_keyword(KEYWORD_ASM))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return;
+ }
+ token = this->advance_token();
+ if (!token->is_string())
+ {
+ error_at(this->location(), "expected string");
+ return;
+ }
+ std::string asm_name = token->string_value();
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<)%>");
+ return;
+ }
+ this->advance_token();
+ named_object = this->gogo_->declare_function(name, fntype, location);
+ if (named_object->is_function_declaration())
+ named_object->func_declaration_value()->set_asm_name(asm_name);
+ }
+
+ // Check for the easy error of a newline before the opening brace.
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (named_object == NULL)
+ named_object = this->gogo_->declare_function(name, fntype, location);
+ }
+ else
+ {
+ this->gogo_->start_function(name, fntype, true, location);
+ source_location end_loc = this->block();
+ this->gogo_->finish_function(end_loc);
+ }
+}
+
+// Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
+// BaseTypeName = identifier .
+
+Typed_identifier*
+Parse::receiver()
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+
+ std::string name;
+ const Token* token = this->advance_token();
+ source_location location = token->location();
+ if (!token->is_op(OPERATOR_MULT))
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "method has no receiver");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+ name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
+ {
+ // An identifier followed by something other than a dot or a
+ // right parenthesis must be a receiver name followed by a
+ // type.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ }
+ else
+ {
+ // This must be a type name.
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ token = this->peek_token();
+ name.clear();
+ }
+ }
+
+ // Here the receiver name is in NAME (it is empty if the receiver is
+ // unnamed) and TOKEN is the first token in the type.
+
+ bool is_pointer = false;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_pointer = true;
+ token = this->advance_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected receiver name or type");
+ int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
+ while (!token->is_eof())
+ {
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ++c;
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ if (c == 0)
+ break;
+ --c;
+ }
+ }
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ Type* type = this->type_name(true);
+
+ if (is_pointer && !type->is_error_type())
+ type = Type::make_pointer_type(type);
+
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "method has multiple receivers");
+ else
+ error_at(this->location(), "expected %<)%>");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ return new Typed_identifier(name, type, location);
+}
+
+// Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
+// Literal = BasicLit | CompositeLit | FunctionLit .
+// BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
+
+// If MAY_BE_SINK is true, this operand may be "_".
+
+Expression*
+Parse::operand(bool may_be_sink)
+{
+ const Token* token = this->peek_token();
+ Expression* ret;
+ switch (token->classification())
+ {
+ case Token::TOKEN_IDENTIFIER:
+ {
+ source_location location = token->location();
+ std::string id = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
+
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(packed, &in_function);
+
+ Package* package = NULL;
+ if (named_object != NULL && named_object->is_package())
+ {
+ if (!this->advance_token()->is_op(OPERATOR_DOT)
+ || !this->advance_token()->is_identifier())
+ {
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ }
+ package = named_object->package_value();
+ package->set_used();
+ id = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ packed = this->gogo_->pack_hidden_name(id, is_exported);
+ named_object = package->lookup(packed);
+ location = this->location();
+ gcc_assert(in_function == NULL);
+ }
+
+ this->advance_token();
+
+ if (named_object != NULL
+ && named_object->is_type()
+ && !named_object->type_value()->is_visible())
+ {
+ gcc_assert(package != NULL);
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(package->name()).c_str(),
+ Gogo::message_name(id).c_str());
+ return Expression::make_error(location);
+ }
+
+
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ {
+ std::string n1 = Gogo::message_name(package->name());
+ std::string n2 = Gogo::message_name(id);
+ if (!is_exported)
+ error_at(location,
+ ("invalid reference to unexported identifier "
+ "%<%s.%s%>"),
+ n1.c_str(), n2.c_str());
+ else
+ error_at(location,
+ "reference to undefined identifier %<%s.%s%>",
+ n1.c_str(), n2.c_str());
+ return Expression::make_error(location);
+ }
+
+ named_object = this->gogo_->add_unknown_name(packed, location);
+ }
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable()
+ || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(named_object->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ {
+ Type* t = Type::make_forward_declaration(named_object);
+ return Expression::make_type(t, location);
+ }
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ if (may_be_sink)
+ return Expression::make_sink(location);
+ else
+ {
+ error_at(location, "cannot use _ as value");
+ return Expression::make_error(location);
+ }
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL,
+ location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ gcc_unreachable();
+ }
+ }
+ gcc_unreachable();
+
+ case Token::TOKEN_STRING:
+ ret = Expression::make_string(token->string_value(), token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_INTEGER:
+ ret = Expression::make_integer(token->integer_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_FLOAT:
+ ret = Expression::make_float(token->float_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_IMAGINARY:
+ {
+ mpfr_t zero;
+ mpfr_init_set_ui(zero, 0, GMP_RNDN);
+ ret = Expression::make_complex(&zero, token->imaginary_value(),
+ NULL, token->location());
+ mpfr_clear(zero);
+ this->advance_token();
+ return ret;
+ }
+
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_FUNC:
+ return this->function_lit();
+ case KEYWORD_CHAN:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ {
+ source_location location = token->location();
+ return Expression::make_type(this->type(), location);
+ }
+ default:
+ break;
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ return ret;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ {
+ // Here we call array_type directly, as this is the only
+ // case where an ellipsis is permitted for an array type.
+ source_location location = token->location();
+ return Expression::make_type(this->array_type(true), location);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ error_at(this->location(), "expected operand");
+ return Expression::make_error(this->location());
+}
+
+// Handle a reference to a variable in an enclosing function. We add
+// it to a list of such variables. We return a reference to a field
+// in a struct which will be passed on the static chain when calling
+// the current function.
+
+Expression*
+Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
+ source_location location)
+{
+ gcc_assert(var->is_variable() || var->is_result_variable());
+
+ Named_object* this_function = this->gogo_->current_function();
+ Named_object* closure = this_function->func_value()->closure_var();
+
+ Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
+ std::pair<Enclosing_vars::iterator, bool> ins =
+ this->enclosing_vars_.insert(ev);
+ if (ins.second)
+ {
+ // This is a variable we have not seen before. Add a new field
+ // to the closure type.
+ this_function->func_value()->add_closure_field(var, location);
+ }
+
+ Expression* closure_ref = Expression::make_var_reference(closure,
+ location);
+ closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
+
+ // The closure structure holds pointers to the variables, so we need
+ // to introduce an indirection.
+ Expression* e = Expression::make_field_reference(closure_ref,
+ ins.first->index(),
+ location);
+ e = Expression::make_unary(OPERATOR_MULT, e, location);
+ return e;
+}
+
+// CompositeLit = LiteralType LiteralValue .
+// LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
+// SliceType | MapType | TypeName .
+// LiteralValue = "{" [ ElementList [ "," ] ] "}" .
+// ElementList = Element { "," Element } .
+// Element = [ Key ":" ] Value .
+// Key = Expression .
+// Value = Expression | LiteralValue .
+
+// We have already seen the type if there is one, and we are now
+// looking at the LiteralValue. The case "[" "..." "]" ElementType
+// will be seen here as an array type whose length is "nil". The
+// DEPTH parameter is non-zero if this is an embedded composite
+// literal and the type was omitted. It gives the number of steps up
+// to the type which was provided. E.g., in [][]int{{1}} it will be
+// 1. In [][][]int{{{1}}} it will be 2.
+
+Expression*
+Parse::composite_lit(Type* type, int depth, source_location location)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ return Expression::make_composite_literal(type, depth, false, NULL,
+ location);
+ }
+
+ bool has_keys = false;
+ Expression_list* vals = new Expression_list;
+ while (true)
+ {
+ Expression* val;
+ bool is_type_omitted = false;
+
+ const Token* token = this->peek_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another composite
+ // literal, with the type omitted for the inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ is_type_omitted = true;
+ }
+
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_COLON))
+ {
+ if (has_keys)
+ vals->push_back(NULL);
+ }
+ else
+ {
+ if (is_type_omitted && !val->is_error_expression())
+ {
+ error_at(this->location(), "unexpected %<:%>");
+ val = Expression::make_error(this->location());
+ }
+
+ this->advance_token();
+
+ if (!has_keys && !vals->empty())
+ {
+ Expression_list* newvals = new Expression_list;
+ for (Expression_list::const_iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ {
+ newvals->push_back(NULL);
+ newvals->push_back(*p);
+ }
+ delete vals;
+ vals = newvals;
+ }
+ has_keys = true;
+
+ if (val->unknown_expression() != NULL)
+ val->unknown_expression()->set_is_composite_literal_key();
+
+ vals->push_back(val);
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another
+ // composite literal, with the type omitted for the
+ // inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ }
+
+ token = this->peek_token();
+ }
+
+ vals->push_back(val);
+
+ if (token->is_op(OPERATOR_COMMA))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<,%> or %<}%>");
+
+ int depth = 0;
+ while (!token->is_eof()
+ && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++depth;
+ else if (token->is_op(OPERATOR_RCURLY))
+ --depth;
+ token = this->advance_token();
+ }
+ if (token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+
+ return Expression::make_error(location);
+ }
+ }
+
+ return Expression::make_composite_literal(type, depth, has_keys, vals,
+ location);
+}
+
+// FunctionLit = "func" Signature Block .
+
+Expression*
+Parse::function_lit()
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ this->advance_token();
+
+ Enclosing_vars hold_enclosing_vars;
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Function_type* type = this->signature(NULL, location);
+
+ // For a function literal, the next token must be a '{'. If we
+ // don't see that, then we may have a type expression.
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ return Expression::make_type(type, location);
+
+ Named_object* no = this->gogo_->start_function("", type, true, location);
+
+ source_location end_loc = this->block();
+
+ this->gogo_->finish_function(end_loc);
+
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Expression* closure = this->create_closure(no, &hold_enclosing_vars,
+ location);
+
+ return Expression::make_func_reference(no, closure, location);
+}
+
+// Create a closure for the nested function FUNCTION. This is based
+// on ENCLOSING_VARS, which is a list of all variables defined in
+// enclosing functions and referenced from FUNCTION. A closure is the
+// address of a struct which contains the addresses of all the
+// referenced variables. This returns NULL if no closure is required.
+
+Expression*
+Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
+ source_location location)
+{
+ if (enclosing_vars->empty())
+ return NULL;
+
+ // Get the variables in order by their field index.
+
+ size_t enclosing_var_count = enclosing_vars->size();
+ std::vector<Enclosing_var> ev(enclosing_var_count);
+ for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
+ p != enclosing_vars->end();
+ ++p)
+ ev[p->index()] = *p;
+
+ // Build an initializer for a composite literal of the closure's
+ // type.
+
+ Named_object* enclosing_function = this->gogo_->current_function();
+ Expression_list* initializer = new Expression_list;
+ for (size_t i = 0; i < enclosing_var_count; ++i)
+ {
+ gcc_assert(ev[i].index() == i);
+ Named_object* var = ev[i].var();
+ Expression* ref;
+ if (ev[i].in_function() == enclosing_function)
+ ref = Expression::make_var_reference(var, location);
+ else
+ ref = this->enclosing_var_reference(ev[i].in_function(), var,
+ location);
+ Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
+ location);
+ initializer->push_back(refaddr);
+ }
+
+ Named_object* closure_var = function->func_value()->closure_var();
+ Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
+ Expression* cv = Expression::make_struct_composite_literal(st, initializer,
+ location);
+ return Expression::make_heap_composite(cv, location);
+}
+
+// PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ source_location start_loc = this->location();
+ bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
+
+ Expression* ret = this->operand(may_be_sink);
+
+ // An unknown name followed by a curly brace must be a composite
+ // literal, and the unknown name must be a type.
+ if (may_be_composite_lit
+ && !is_parenthesized
+ && ret->unknown_expression() != NULL
+ && this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ Named_object* no = ret->unknown_expression()->named_object();
+ Type* type = Type::make_forward_declaration(no);
+ ret = Expression::make_type(type, ret->location());
+ }
+
+ // We handle composite literals and type casts here, as it is the
+ // easiest way to handle types which are in parentheses, as in
+ // "((uint))(1)".
+ if (ret->is_type_expression())
+ {
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (is_parenthesized)
+ error_at(start_loc,
+ "cannot parenthesize type in composite literal");
+ ret = this->composite_lit(ret->type(), 0, ret->location());
+ }
+ else if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ source_location loc = this->location();
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ NULL);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+ if (expr->is_error_expression())
+ return expr;
+ ret = Expression::make_cast(ret->type(), expr, loc);
+ }
+ }
+
+ while (true)
+ {
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ret = this->call(this->verify_not_sink(ret));
+ else if (token->is_op(OPERATOR_DOT))
+ {
+ ret = this->selector(this->verify_not_sink(ret), is_type_switch);
+ if (is_type_switch != NULL && *is_type_switch)
+ break;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ ret = this->index(this->verify_not_sink(ret));
+ else
+ break;
+ }
+
+ return ret;
+}
+
+// Selector = "." identifier .
+// TypeGuard = "." "(" QualifiedIdent ")" .
+
+// Note that Operand can expand to QualifiedIdent, which contains a
+// ".". That is handled directly in operand when it sees a package
+// name.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::selector(Expression* left, bool* is_type_switch)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_DOT));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ if (token->is_identifier())
+ {
+ // This could be a field in a struct, or a method in an
+ // interface, or a method associated with a type. We can't know
+ // which until we have seen all the types.
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ if (token->identifier() == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = this->gogo_->pack_hidden_name("blank", false);
+ }
+ this->advance_token();
+ return Expression::make_selector(left, name, location);
+ }
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* type = NULL;
+ if (is_type_switch == NULL
+ || !this->peek_token()->is_keyword(KEYWORD_TYPE))
+ type = this->type();
+ else
+ {
+ *is_type_switch = true;
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+ return Expression::make_type_guard(left, type, location);
+ }
+ else
+ {
+ error_at(this->location(), "expected identifier or %<(%>");
+ return left;
+ }
+}
+
+// Index = "[" Expression "]" .
+// Slice = "[" Expression ":" [ Expression ] "]" .
+
+Expression*
+Parse::index(Expression* expr)
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ this->advance_token();
+
+ Expression* start;
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ mpz_t zero;
+ mpz_init_set_ui(zero, 0);
+ start = Expression::make_integer(&zero, NULL, location);
+ mpz_clear(zero);
+ }
+
+ Expression* end = NULL;
+ if (this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ // We use nil to indicate a missing high expression.
+ if (this->advance_token()->is_op(OPERATOR_RSQUARE))
+ end = Expression::make_nil(this->location());
+ else
+ end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ error_at(this->location(), "missing %<]%>");
+ else
+ this->advance_token();
+ return Expression::make_index(expr, start, end, location);
+}
+
+// Call = "(" [ ArgumentList [ "," ] ] ")" .
+// ArgumentList = ExpressionList [ "..." ] .
+
+Expression*
+Parse::call(Expression* func)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+ Expression_list* args = NULL;
+ bool is_varargs = false;
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ args = this->expression_list(NULL, false);
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_ELLIPSIS))
+ {
+ is_varargs = true;
+ token = this->advance_token();
+ }
+ }
+ if (token->is_op(OPERATOR_COMMA))
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (func->is_error_expression())
+ return func;
+ return Expression::make_call(func, args, is_varargs, func->location());
+}
+
+// Return an expression for a single unqualified identifier.
+
+Expression*
+Parse::id_to_expression(const std::string& name, source_location location)
+{
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(name, &in_function);
+ if (named_object == NULL)
+ named_object = this->gogo_->add_unknown_name(name, location);
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable() || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ return Expression::make_sink(location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL, location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ error_at(this->location(), "unexpected type of identifier");
+ return Expression::make_error(location);
+ }
+}
+
+// Expression = UnaryExpr { binary_op Expression } .
+
+// PRECEDENCE is the precedence of the current operator.
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::expression(Precedence precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch)
+{
+ Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+
+ while (true)
+ {
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+
+ const Token* token = this->peek_token();
+ if (token->classification() != Token::TOKEN_OPERATOR)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Precedence right_precedence;
+ switch (token->op())
+ {
+ case OPERATOR_OROR:
+ right_precedence = PRECEDENCE_OROR;
+ break;
+ case OPERATOR_ANDAND:
+ right_precedence = PRECEDENCE_ANDAND;
+ break;
+ case OPERATOR_CHANOP:
+ right_precedence = PRECEDENCE_CHANOP;
+ break;
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ right_precedence = PRECEDENCE_RELOP;
+ break;
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ right_precedence = PRECEDENCE_ADDOP;
+ break;
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ right_precedence = PRECEDENCE_MULOP;
+ break;
+ default:
+ right_precedence = PRECEDENCE_INVALID;
+ break;
+ }
+
+ if (right_precedence == PRECEDENCE_INVALID)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Operator op = token->op();
+ source_location binop_location = token->location();
+
+ if (precedence >= right_precedence)
+ {
+ // We've already seen A * B, and we see + C. We want to
+ // return so that A * B becomes a group.
+ return left;
+ }
+
+ this->advance_token();
+
+ left = this->verify_not_sink(left);
+ Expression* right = this->expression(right_precedence, false,
+ may_be_composite_lit,
+ is_type_switch);
+ if (op == OPERATOR_CHANOP)
+ left = Expression::make_send(left, right, binop_location);
+ else
+ left = Expression::make_binary(op, left, right, binop_location);
+ }
+}
+
+bool
+Parse::expression_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_INVALID:
+ case Token::TOKEN_EOF:
+ return false;
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_CHAN:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+ case Token::TOKEN_STRING:
+ return true;
+ case Token::TOKEN_OPERATOR:
+ switch (token->op())
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_CHANOP:
+ case OPERATOR_AND:
+ case OPERATOR_LPAREN:
+ case OPERATOR_LSQUARE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_PLUS)
+ || token->is_op(OPERATOR_MINUS)
+ || token->is_op(OPERATOR_NOT)
+ || token->is_op(OPERATOR_XOR)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_AND))
+ {
+ source_location location = token->location();
+ Operator op = token->op();
+ this->advance_token();
+
+ if (op == OPERATOR_CHANOP
+ && this->peek_token()->is_keyword(KEYWORD_CHAN))
+ {
+ // This is "<- chan" which must be the start of a type.
+ this->unget_token(Token::make_operator_token(op, location));
+ return Expression::make_type(this->type(), location);
+ }
+
+ Expression* expr = this->unary_expr(false, may_be_composite_lit,
+ is_type_switch);
+ if (expr->is_error_expression())
+ ;
+ else if (op == OPERATOR_MULT && expr->is_type_expression())
+ expr = Expression::make_type(Type::make_pointer_type(expr->type()),
+ location);
+ else if (op == OPERATOR_AND && expr->is_composite_literal())
+ expr = Expression::make_heap_composite(expr, location);
+ else if (op != OPERATOR_CHANOP)
+ expr = Expression::make_unary(op, expr, location);
+ else
+ expr = Expression::make_receive(expr, location);
+ return expr;
+ }
+ else
+ return this->primary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+}
+
+// Statement =
+// Declaration | LabeledStmt | SimpleStmt |
+// GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
+// FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
+// DeferStmt .
+
+// LABEL is the label of this statement if it has one.
+
+void
+Parse::statement(const Label* label)
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ this->declaration();
+ break;
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ this->go_or_defer_stat();
+ break;
+ case KEYWORD_RETURN:
+ this->return_stat();
+ break;
+ case KEYWORD_BREAK:
+ this->break_stat();
+ break;
+ case KEYWORD_CONTINUE:
+ this->continue_stat();
+ break;
+ case KEYWORD_GOTO:
+ this->goto_stat();
+ break;
+ case KEYWORD_IF:
+ this->if_stat();
+ break;
+ case KEYWORD_SWITCH:
+ this->switch_stat(label);
+ break;
+ case KEYWORD_SELECT:
+ this->select_stat(label);
+ break;
+ case KEYWORD_FOR:
+ this->for_stat(label);
+ break;
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ if (this->advance_token()->is_op(OPERATOR_COLON))
+ {
+ this->advance_token();
+ this->labeled_stmt(identifier, location);
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ location));
+ this->simple_stat(true, false, NULL, NULL);
+ }
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY))
+ {
+ source_location location = token->location();
+ this->gogo_->start_block(location);
+ source_location end_loc = this->block();
+ this->gogo_->add_block(this->gogo_->finish_block(end_loc),
+ location);
+ }
+ else if (!token->is_op(OPERATOR_SEMICOLON))
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+}
+
+bool
+Parse::statement_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ case KEYWORD_RETURN:
+ case KEYWORD_BREAK:
+ case KEYWORD_CONTINUE:
+ case KEYWORD_GOTO:
+ case KEYWORD_IF:
+ case KEYWORD_SWITCH:
+ case KEYWORD_SELECT:
+ case KEYWORD_FOR:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY)
+ || token->is_op(OPERATOR_SEMICOLON))
+ return true;
+ else
+ return this->expression_may_start_here();
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+// LabeledStmt = Label ":" Statement .
+// Label = identifier .
+
+void
+Parse::labeled_stmt(const std::string& label_name, source_location location)
+{
+ Label* label = this->gogo_->add_label_definition(label_name, location);
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ // This is a label at the end of a block. A program is
+ // permitted to omit a semicolon here.
+ return;
+ }
+
+ if (!this->statement_may_start_here())
+ {
+ error_at(location, "missing statement after label");
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ location));
+ return;
+ }
+
+ this->statement(label);
+}
+
+// SimpleStat =
+// ExpressionStat | IncDecStat | Assignment | SimpleVarDecl .
+
+// In order to make this work for if and switch statements, if
+// RETURN_EXP is true, and we see an ExpressionStat, we return the
+// expression rather than adding an expression statement to the
+// current block. If we see something other than an ExpressionStat,
+// we add the statement and return NULL.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::simple_stat(bool may_be_composite_lit, bool return_exp,
+ Range_clause* p_range_clause, Type_switch* p_type_switch)
+{
+ const Token* token = this->peek_token();
+
+ // An identifier follow by := is a SimpleVarDecl.
+ if (token->is_identifier())
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ)
+ || token->is_op(OPERATOR_COMMA))
+ {
+ identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
+ this->simple_var_decl_or_assignment(identifier, location,
+ p_range_clause,
+ (token->is_op(OPERATOR_COLONEQ)
+ ? p_type_switch
+ : NULL));
+ return NULL;
+ }
+
+ this->unget_token(Token::make_identifier_token(identifier, is_exported,
+ location));
+ }
+
+ Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
+ may_be_composite_lit,
+ (p_type_switch == NULL
+ ? NULL
+ : &p_type_switch->found));
+ if (p_type_switch != NULL && p_type_switch->found)
+ {
+ p_type_switch->name.clear();
+ p_type_switch->location = exp->location();
+ p_type_switch->expr = this->verify_not_sink(exp);
+ return NULL;
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_PLUSPLUS) || token->is_op(OPERATOR_MINUSMINUS))
+ this->inc_dec_stat(this->verify_not_sink(exp));
+ else if (token->is_op(OPERATOR_COMMA)
+ || token->is_op(OPERATOR_EQ))
+ this->assignment(exp, p_range_clause);
+ else if (token->is_op(OPERATOR_PLUSEQ)
+ || token->is_op(OPERATOR_MINUSEQ)
+ || token->is_op(OPERATOR_OREQ)
+ || token->is_op(OPERATOR_XOREQ)
+ || token->is_op(OPERATOR_MULTEQ)
+ || token->is_op(OPERATOR_DIVEQ)
+ || token->is_op(OPERATOR_MODEQ)
+ || token->is_op(OPERATOR_LSHIFTEQ)
+ || token->is_op(OPERATOR_RSHIFTEQ)
+ || token->is_op(OPERATOR_ANDEQ)
+ || token->is_op(OPERATOR_BITCLEAREQ))
+ this->assignment(this->verify_not_sink(exp), p_range_clause);
+ else if (return_exp)
+ return this->verify_not_sink(exp);
+ else
+ this->expression_stat(this->verify_not_sink(exp));
+
+ return NULL;
+}
+
+bool
+Parse::simple_stat_may_start_here()
+{
+ return this->expression_may_start_here();
+}
+
+// Parse { Statement ";" } which is used in a few places. The list of
+// statements may end with a right curly brace, in which case the
+// semicolon may be omitted.
+
+void
+Parse::statement_list()
+{
+ while (this->statement_may_start_here())
+ {
+ this->statement(NULL);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ break;
+ else
+ {
+ if (!this->peek_token()->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return;
+ }
+ }
+}
+
+bool
+Parse::statement_list_may_start_here()
+{
+ return this->statement_may_start_here();
+}
+
+// ExpressionStat = Expression .
+
+void
+Parse::expression_stat(Expression* exp)
+{
+ exp->discarding_value();
+ this->gogo_->add_statement(Statement::make_statement(exp));
+}
+
+// IncDecStat = Expression ( "++" | "--" ) .
+
+void
+Parse::inc_dec_stat(Expression* exp)
+{
+ const Token* token = this->peek_token();
+
+ // Lvalue maps require special handling.
+ if (exp->index_expression() != NULL)
+ exp->index_expression()->set_is_lvalue();
+
+ if (token->is_op(OPERATOR_PLUSPLUS))
+ this->gogo_->add_statement(Statement::make_inc_statement(exp));
+ else if (token->is_op(OPERATOR_MINUSMINUS))
+ this->gogo_->add_statement(Statement::make_dec_statement(exp));
+ else
+ gcc_unreachable();
+ this->advance_token();
+}
+
+// Assignment = ExpressionList assign_op ExpressionList .
+
+// EXP is an expression that we have already parsed.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::assignment(Expression* expr, Range_clause* p_range_clause)
+{
+ Expression_list* vars;
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ vars = new Expression_list();
+ vars->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ vars = this->expression_list(expr, true);
+ }
+
+ this->tuple_assignment(vars, p_range_clause);
+}
+
+// An assignment statement. LHS is the list of expressions which
+// appear on the left hand side.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::tuple_assignment(Expression_list* lhs, Range_clause* p_range_clause)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_EQ)
+ && !token->is_op(OPERATOR_PLUSEQ)
+ && !token->is_op(OPERATOR_MINUSEQ)
+ && !token->is_op(OPERATOR_OREQ)
+ && !token->is_op(OPERATOR_XOREQ)
+ && !token->is_op(OPERATOR_MULTEQ)
+ && !token->is_op(OPERATOR_DIVEQ)
+ && !token->is_op(OPERATOR_MODEQ)
+ && !token->is_op(OPERATOR_LSHIFTEQ)
+ && !token->is_op(OPERATOR_RSHIFTEQ)
+ && !token->is_op(OPERATOR_ANDEQ)
+ && !token->is_op(OPERATOR_BITCLEAREQ))
+ {
+ error_at(this->location(), "expected assignment operator");
+ return;
+ }
+ Operator op = token->op();
+ source_location location = token->location();
+
+ token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ if (op != OPERATOR_EQ)
+ error_at(this->location(), "range clause requires %<=%>");
+ this->range_clause_expr(lhs, p_range_clause);
+ return;
+ }
+
+ Expression_list* vals = this->expression_list(NULL, false);
+
+ // We've parsed everything; check for errors.
+ if (lhs == NULL || vals == NULL)
+ return;
+ for (Expression_list::const_iterator pe = lhs->begin();
+ pe != lhs->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
+ error_at((*pe)->location(), "cannot use _ as value");
+ }
+ for (Expression_list::const_iterator pe = vals->begin();
+ pe != vals->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ }
+
+ // Map expressions act differently when they are lvalues.
+ for (Expression_list::iterator plv = lhs->begin();
+ plv != lhs->end();
+ ++plv)
+ if ((*plv)->index_expression() != NULL)
+ (*plv)->index_expression()->set_is_lvalue();
+
+ Call_expression* call;
+ Index_expression* map_index;
+ Receive_expression* receive;
+ Type_guard_expression* type_guard;
+ if (lhs->size() == vals->size())
+ {
+ Statement* s;
+ if (lhs->size() > 1)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple values only permitted with %<=%>");
+ s = Statement::make_tuple_assignment(lhs, vals, location);
+ }
+ else
+ {
+ if (op == OPERATOR_EQ)
+ s = Statement::make_assignment(lhs->front(), vals->front(),
+ location);
+ else
+ s = Statement::make_assignment_operation(op, lhs->front(),
+ vals->front(), location);
+ delete lhs;
+ delete vals;
+ }
+ this->gogo_->add_statement(s);
+ }
+ else if (vals->size() == 1
+ && (call = (*vals->begin())->call_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple results only permitted with %<=%>");
+ delete vals;
+ vals = new Expression_list;
+ for (unsigned int i = 0; i < lhs->size(); ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ Statement* s = Statement::make_tuple_assignment(lhs, vals, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (map_index = (*vals->begin())->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from map requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* present = lhs->back();
+ Statement* s = Statement::make_tuple_map_assignment(val, present,
+ map_index, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 1
+ && vals->size() == 2
+ && (map_index = lhs->front()->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "assigning tuple to map index requires %<=%>");
+ Expression* val = vals->front();
+ Expression* should_set = vals->back();
+ Statement* s = Statement::make_map_assignment(map_index, val, should_set,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (receive = (*vals->begin())->receive_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from receive requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* success = lhs->back();
+ Expression* channel = receive->channel();
+ Statement* s = Statement::make_tuple_receive_assignment(val, success,
+ channel,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (type_guard = (*vals->begin())->type_guard_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from type guard requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* ok = lhs->back();
+ Expression* expr = type_guard->expr();
+ Type* type = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val, ok,
+ expr, type,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else
+ {
+ error_at(location, "number of variables does not match number of values");
+ }
+}
+
+// GoStat = "go" Expression .
+// DeferStat = "defer" Expression .
+
+void
+Parse::go_or_defer_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_GO)
+ || this->peek_token()->is_keyword(KEYWORD_DEFER));
+ bool is_go = this->peek_token()->is_keyword(KEYWORD_GO);
+ source_location stat_location = this->location();
+ this->advance_token();
+ source_location expr_location = this->location();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ Call_expression* call_expr = expr->call_expression();
+ if (call_expr == NULL)
+ {
+ error_at(expr_location, "expected call expression");
+ return;
+ }
+
+ // Make it easier to simplify go/defer statements by putting every
+ // statement in its own block.
+ this->gogo_->start_block(stat_location);
+ Statement* stat;
+ if (is_go)
+ stat = Statement::make_go_statement(call_expr, stat_location);
+ else
+ stat = Statement::make_defer_statement(call_expr, stat_location);
+ this->gogo_->add_statement(stat);
+ this->gogo_->add_block(this->gogo_->finish_block(stat_location),
+ stat_location);
+}
+
+// ReturnStat = "return" [ ExpressionList ] .
+
+void
+Parse::return_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RETURN));
+ source_location location = this->location();
+ this->advance_token();
+ Expression_list* vals = NULL;
+ if (this->expression_may_start_here())
+ vals = this->expression_list(NULL, false);
+ const Function* function = this->gogo_->current_function()->func_value();
+ const Typed_identifier_list* results = function->type()->results();
+ this->gogo_->add_statement(Statement::make_return_statement(results, vals,
+ location));
+}
+
+// IfStat = "if" [ [ SimpleStat ] ";" ] [ Condition ]
+// Block [ "else" Statement ] .
+
+void
+Parse::if_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_IF));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ Expression* cond = NULL;
+ if (this->simple_stat_may_start_here())
+ cond = this->simple_stat(false, true, NULL, NULL);
+ if (cond != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+ if (cond == NULL)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ cond = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ }
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* then_block = this->gogo_->finish_block(end_loc);
+
+ // Check for the easy error of a newline before "else".
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_keyword(KEYWORD_ELSE))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<else%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ Block* else_block = NULL;
+ if (this->peek_token()->is_keyword(KEYWORD_ELSE))
+ {
+ this->advance_token();
+ // We create a block to gather the statement.
+ this->gogo_->start_block(this->location());
+ this->statement(NULL);
+ else_block = this->gogo_->finish_block(this->location());
+ }
+
+ this->gogo_->add_statement(Statement::make_if_statement(cond, then_block,
+ else_block,
+ location));
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
+// ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
+// "{" { ExprCaseClause } "}" .
+// TypeSwitchStmt = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
+// "{" { TypeCaseClause } "}" .
+// TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
+
+void
+Parse::switch_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ Expression* switch_val = NULL;
+ Type_switch type_switch;
+ if (this->simple_stat_may_start_here())
+ switch_val = this->simple_stat(false, true, NULL, &type_switch);
+ if (switch_val != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(switch_val);
+ switch_val = NULL;
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (this->peek_token()->is_identifier())
+ {
+ const Token* token = this->peek_token();
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location id_loc = token->location();
+
+ token = this->advance_token();
+ bool is_coloneq = token->is_op(OPERATOR_COLONEQ);
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ id_loc));
+ if (is_coloneq)
+ {
+ // This must be a TypeSwitchGuard.
+ switch_val = this->simple_stat(false, true, NULL,
+ &type_switch);
+ if (!type_switch.found
+ && !switch_val->is_error_expression())
+ {
+ error_at(id_loc, "expected type switch assignment");
+ switch_val = Expression::make_error(id_loc);
+ }
+ }
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ switch_val = this->expression(PRECEDENCE_NORMAL, false, false,
+ &type_switch.found);
+ if (type_switch.found)
+ {
+ type_switch.name.clear();
+ type_switch.expr = switch_val;
+ type_switch.location = switch_val->location();
+ }
+ }
+ }
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+ return;
+ }
+ }
+ this->advance_token();
+
+ Statement* statement;
+ if (type_switch.found)
+ statement = this->type_switch_body(label, type_switch, location);
+ else
+ statement = this->expr_switch_body(label, switch_val, location);
+
+ if (statement != NULL)
+ this->gogo_->add_statement(statement);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// The body of an expression switch.
+// "{" { ExprCaseClause } "}"
+
+Statement*
+Parse::expr_switch_body(const Label* label, Expression* switch_val,
+ source_location location)
+{
+ Switch_statement* statement = Statement::make_switch_statement(switch_val,
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Case_clauses* case_clauses = new Case_clauses();
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ if (!saw_errors())
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->expr_case_clause(case_clauses);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
+// FallthroughStat = "fallthrough" .
+
+void
+Parse::expr_case_clause(Case_clauses* clauses)
+{
+ source_location location = this->location();
+
+ bool is_default = false;
+ Expression_list* vals = this->expr_switch_case(&is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<:%>");
+ return;
+ }
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ bool is_fallthrough = false;
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ is_fallthrough = true;
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default || vals != NULL)
+ clauses->add(vals, is_default, statements, is_fallthrough, location);
+}
+
+// ExprSwitchCase = "case" ExpressionList | "default" .
+
+Expression_list*
+Parse::expr_switch_case(bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ return this->expression_list(NULL, false);
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ return NULL;
+ }
+ else
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return NULL;
+ }
+}
+
+// The body of a type switch.
+// "{" { TypeCaseClause } "}" .
+
+Statement*
+Parse::type_switch_body(const Label* label, const Type_switch& type_switch,
+ source_location location)
+{
+ Named_object* switch_no = NULL;
+ if (!type_switch.name.empty())
+ {
+ Variable* switch_var = new Variable(NULL, type_switch.expr, false, false,
+ false, type_switch.location);
+ switch_no = this->gogo_->add_variable(type_switch.name, switch_var);
+ }
+
+ Type_switch_statement* statement =
+ Statement::make_type_switch_statement(switch_no,
+ (switch_no == NULL
+ ? type_switch.expr
+ : NULL),
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Type_case_clauses* case_clauses = new Type_case_clauses();
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->type_case_clause(switch_no, case_clauses);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// TypeCaseClause = TypeSwitchCase ":" [ StatementList ] .
+
+void
+Parse::type_case_clause(Named_object* switch_no, Type_case_clauses* clauses)
+{
+ source_location location = this->location();
+
+ std::vector<Type*> types;
+ bool is_default = false;
+ this->type_switch_case(&types, &is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ error_at(this->location(), "expected %<:%>");
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ if (switch_no != NULL && types.size() == 1)
+ {
+ Type* type = types.front();
+ Expression* init = Expression::make_var_reference(switch_no,
+ location);
+ init = Expression::make_type_guard(init, type, location);
+ Variable* v = new Variable(type, init, false, false, false,
+ location);
+ v->set_is_type_switch_var();
+ this->gogo_->add_variable(switch_no->name(), v);
+ }
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ error_at(this->location(),
+ "fallthrough is not permitted in a type switch");
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default)
+ {
+ gcc_assert(types.empty());
+ clauses->add(NULL, false, true, statements, location);
+ }
+ else if (!types.empty())
+ {
+ for (std::vector<Type*>::const_iterator p = types.begin();
+ p + 1 != types.end();
+ ++p)
+ clauses->add(*p, true, false, NULL, location);
+ clauses->add(types.back(), false, false, statements, location);
+ }
+}
+
+// TypeSwitchCase = "case" type | "default"
+
+// We accept a comma separated list of types.
+
+void
+Parse::type_switch_case(std::vector<Type*>* types, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ while (true)
+ {
+ Type* t = this->type();
+ if (!t->is_error_type())
+ types->push_back(t);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ }
+}
+
+// SelectStat = "select" "{" { CommClause } "}" .
+
+void
+Parse::select_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_SELECT));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = token->location();
+ if (token->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return;
+ }
+ }
+ this->advance_token();
+
+ Select_statement* statement = Statement::make_select_statement(location);
+
+ this->push_break_statement(statement, label);
+
+ Select_clauses* select_clauses = new Select_clauses();
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "expected %<}%>");
+ return;
+ }
+ this->comm_clause(select_clauses);
+ }
+
+ this->advance_token();
+
+ statement->add_clauses(select_clauses);
+
+ this->pop_break_statement();
+
+ this->gogo_->add_statement(statement);
+}
+
+// CommClause = CommCase [ StatementList ] .
+
+void
+Parse::comm_clause(Select_clauses* clauses)
+{
+ source_location location = this->location();
+ bool is_send = false;
+ Expression* channel = NULL;
+ Expression* val = NULL;
+ std::string varname;
+ bool is_default = false;
+ bool got_case = this->comm_case(&is_send, &channel, &val, &varname,
+ &is_default);
+
+ Block* statements = NULL;
+ Named_object* var = NULL;
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+
+ if (!varname.empty())
+ {
+ // FIXME: LOCATION is slightly wrong here.
+ Variable* v = new Variable(NULL, channel, false, false, false,
+ location);
+ v->set_type_from_chan_element();
+ var = this->gogo_->add_variable(varname, v);
+ }
+
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ if (got_case)
+ clauses->add(is_send, channel, val, var, is_default, statements, location);
+}
+
+// CommCase = ( "default" | ( "case" ( SendExpr | RecvExpr) ) ) ":" .
+
+bool
+Parse::comm_case(bool* is_send, Expression** channel, Expression** val,
+ std::string* varname, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ if (!this->send_or_recv_expr(is_send, channel, val, varname))
+ return false;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return false;
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ error_at(this->location(), "expected colon");
+ return false;
+ }
+
+ this->advance_token();
+
+ return true;
+}
+
+// SendExpr = Expression "<-" Expression .
+// RecvExpr = [ Expression ( "=" | ":=" ) ] "<-" Expression .
+
+bool
+Parse::send_or_recv_expr(bool* is_send, Expression** channel, Expression** val,
+ std::string* varname)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ if (token->is_identifier())
+ {
+ std::string recv_var = token->identifier();
+ bool is_var_exported = token->is_identifier_exported();
+ if (!this->advance_token()->is_op(OPERATOR_COLONEQ))
+ this->unget_token(Token::make_identifier_token(recv_var,
+ is_var_exported,
+ location));
+ else
+ {
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "expected %<<-%>");
+ return false;
+ }
+ *is_send = false;
+ *varname = this->gogo_->pack_hidden_name(recv_var, is_var_exported);
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+ }
+
+ if (this->peek_token()->is_op(OPERATOR_CHANOP))
+ {
+ *is_send = false;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ else
+ {
+ Expression* left = this->expression(PRECEDENCE_CHANOP, true, true, NULL);
+
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "missing %<<-%>");
+ return false;
+ }
+ *is_send = false;
+ *val = left;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ else if (this->peek_token()->is_op(OPERATOR_CHANOP))
+ {
+ *is_send = true;
+ *channel = this->verify_not_sink(left);
+ this->advance_token();
+ *val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ else
+ {
+ error_at(this->location(), "expected %<<-%> or %<=%>");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
+// Condition = Expression .
+
+void
+Parse::for_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FOR));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ // Open a block to hold any variables defined in the init statement
+ // of the for statement.
+ this->gogo_->start_block(location);
+
+ Block* init = NULL;
+ Expression* cond = NULL;
+ Block* post = NULL;
+ Range_clause range_clause;
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ if (token->is_keyword(KEYWORD_VAR))
+ {
+ error_at(this->location(),
+ "var declaration not allowed in for initializer");
+ this->var_decl();
+ }
+
+ if (token->is_op(OPERATOR_SEMICOLON))
+ this->for_clause(&cond, &post);
+ else
+ {
+ // We might be looking at a Condition, an InitStat, or a
+ // RangeClause.
+ cond = this->simple_stat(false, true, &range_clause, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (cond == NULL && !range_clause.found)
+ error_at(this->location(), "parse error in for statement");
+ }
+ else
+ {
+ if (range_clause.found)
+ error_at(this->location(), "parse error after range clause");
+
+ if (cond != NULL)
+ {
+ // COND is actually an expression statement for
+ // InitStat at the start of a ForClause.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+
+ this->for_clause(&cond, &post);
+ }
+ }
+ }
+
+ // Build the For_statement and note that it is the current target
+ // for break and continue statements.
+
+ For_statement* sfor;
+ For_range_statement* srange;
+ Statement* s;
+ if (!range_clause.found)
+ {
+ sfor = Statement::make_for_statement(init, cond, post, location);
+ s = sfor;
+ srange = NULL;
+ }
+ else
+ {
+ srange = Statement::make_for_range_statement(range_clause.index,
+ range_clause.value,
+ range_clause.range,
+ location);
+ s = srange;
+ sfor = NULL;
+ }
+
+ this->push_break_statement(s, label);
+ this->push_continue_statement(s, label);
+
+ // Gather the block of statements in the loop and add them to the
+ // For_statement.
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* statements = this->gogo_->finish_block(end_loc);
+
+ if (sfor != NULL)
+ sfor->add_statements(statements);
+ else
+ srange->add_statements(statements);
+
+ // This is no longer the break/continue target.
+ this->pop_break_statement();
+ this->pop_continue_statement();
+
+ // Add the For_statement to the list of statements, and close out
+ // the block we started to hold any variables defined in the for
+ // statement.
+
+ this->gogo_->add_statement(s);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
+// InitStat = SimpleStat .
+// PostStat = SimpleStat .
+
+// We have already read InitStat at this point.
+
+void
+Parse::for_clause(Expression** cond, Block** post)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON));
+ this->advance_token();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ *cond = NULL;
+ else if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ *cond = NULL;
+ *post = NULL;
+ return;
+ }
+ else
+ *cond = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ error_at(this->location(), "expected semicolon");
+ else
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ *post = NULL;
+ else
+ {
+ this->gogo_->start_block(this->location());
+ this->simple_stat(false, false, NULL, NULL);
+ *post = this->gogo_->finish_block(this->location());
+ }
+}
+
+// RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
+
+// This is the := version. It is called with a list of identifiers.
+
+void
+Parse::range_clause_decl(const Typed_identifier_list* til,
+ Range_clause* p_range_clause)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+ source_location location = this->location();
+
+ p_range_clause->found = true;
+
+ gcc_assert(til->size() >= 1);
+ if (til->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ p_range_clause->range = expr;
+
+ bool any_new = false;
+
+ const Typed_identifier* pti = &til->front();
+ Named_object* no = this->init_var(*pti, NULL, expr, true, true, &any_new);
+ if (any_new && no->is_variable())
+ no->var_value()->set_type_from_range_index();
+ p_range_clause->index = Expression::make_var_reference(no, location);
+
+ if (til->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ {
+ pti = &til->back();
+ bool is_new = false;
+ no = this->init_var(*pti, NULL, expr, true, true, &is_new);
+ if (is_new && no->is_variable())
+ no->var_value()->set_type_from_range_value();
+ if (is_new)
+ any_new = true;
+ p_range_clause->value = Expression::make_var_reference(no, location);
+ }
+
+ if (!any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// The = version of RangeClause. This is called with a list of
+// expressions.
+
+void
+Parse::range_clause_expr(const Expression_list* vals,
+ Range_clause* p_range_clause)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+
+ p_range_clause->found = true;
+
+ gcc_assert(vals->size() >= 1);
+ if (vals->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ p_range_clause->range = this->expression(PRECEDENCE_NORMAL, false, false,
+ NULL);
+
+ p_range_clause->index = vals->front();
+ if (vals->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ p_range_clause->value = vals->back();
+}
+
+// Push a statement on the break stack.
+
+void
+Parse::push_break_statement(Statement* enclosing, const Label* label)
+{
+ this->break_stack_.push_back(std::make_pair(enclosing, label));
+}
+
+// Push a statement on the continue stack.
+
+void
+Parse::push_continue_statement(Statement* enclosing, const Label* label)
+{
+ this->continue_stack_.push_back(std::make_pair(enclosing, label));
+}
+
+// Pop the break stack.
+
+void
+Parse::pop_break_statement()
+{
+ this->break_stack_.pop_back();
+}
+
+// Pop the continue stack.
+
+void
+Parse::pop_continue_statement()
+{
+ this->continue_stack_.pop_back();
+}
+
+// Find a break or continue statement given a label name.
+
+Statement*
+Parse::find_bc_statement(const Bc_stack* bc_stack, const std::string& label)
+{
+ for (Bc_stack::const_reverse_iterator p = bc_stack->rbegin();
+ p != bc_stack->rend();
+ ++p)
+ if (p->second != NULL && p->second->name() == label)
+ return p->first;
+ return NULL;
+}
+
+// BreakStat = "break" [ identifier ] .
+
+void
+Parse::break_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_BREAK));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->break_stack_.empty())
+ {
+ error_at(this->location(),
+ "break statement not within for or switch or select");
+ return;
+ }
+ enclosing = this->break_stack_.back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(&this->break_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ error_at(token->location(),
+ ("break label %qs not associated with "
+ "for or switch or select"),
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SWITCH)
+ label = enclosing->switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_TYPE_SWITCH)
+ label = enclosing->type_switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SELECT)
+ label = enclosing->select_statement()->break_label();
+ else
+ gcc_unreachable();
+
+ this->gogo_->add_statement(Statement::make_break_statement(label,
+ location));
+}
+
+// ContinueStat = "continue" [ identifier ] .
+
+void
+Parse::continue_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->continue_stack_.empty())
+ {
+ error_at(this->location(), "continue statement not within for");
+ return;
+ }
+ enclosing = this->continue_stack_.back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(&this->continue_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ error_at(token->location(),
+ "continue label %qs not associated with for",
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->continue_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->continue_label();
+ else
+ gcc_unreachable();
+
+ this->gogo_->add_statement(Statement::make_continue_statement(label,
+ location));
+}
+
+// GotoStat = "goto" identifier .
+
+void
+Parse::goto_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_GOTO));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ error_at(this->location(), "expected label for goto");
+ else
+ {
+ Label* label = this->gogo_->add_label_reference(token->identifier());
+ Statement* s = Statement::make_goto_statement(label, location);
+ this->gogo_->add_statement(s);
+ this->advance_token();
+ }
+}
+
+// PackageClause = "package" PackageName .
+
+void
+Parse::package_clause()
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ std::string name;
+ if (!token->is_keyword(KEYWORD_PACKAGE))
+ {
+ error_at(this->location(), "program must start with package clause");
+ name = "ERROR";
+ }
+ else
+ {
+ token = this->advance_token();
+ if (token->is_identifier())
+ {
+ name = token->identifier();
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid package name _");
+ name = "blank";
+ }
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(), "package name must be an identifier");
+ name = "ERROR";
+ }
+ }
+ this->gogo_->set_package_name(name, location);
+}
+
+// ImportDecl = "import" Decl<ImportSpec> .
+
+void
+Parse::import_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT));
+ this->advance_token();
+ this->decl(&Parse::import_spec, NULL);
+}
+
+// ImportSpec = [ "." | PackageName ] PackageFileName .
+
+void
+Parse::import_spec(void*)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+
+ std::string local_name;
+ bool is_local_name_exported = false;
+ if (token->is_op(OPERATOR_DOT))
+ {
+ local_name = ".";
+ token = this->advance_token();
+ }
+ else if (token->is_identifier())
+ {
+ local_name = token->identifier();
+ is_local_name_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ }
+
+ if (!token->is_string())
+ {
+ error_at(this->location(), "missing import package name");
+ return;
+ }
+
+ this->gogo_->import_package(token->string_value(), local_name,
+ is_local_name_exported, location);
+
+ this->advance_token();
+}
+
+// SourceFile = PackageClause ";" { ImportDecl ";" }
+// { TopLevelDecl ";" } .
+
+void
+Parse::program()
+{
+ this->package_clause();
+
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after package clause");
+
+ while (token->is_keyword(KEYWORD_IMPORT))
+ {
+ this->import_decl();
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after import declaration");
+ }
+
+ while (!token->is_eof())
+ {
+ if (this->declaration_may_start_here())
+ this->declaration();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ do
+ this->advance_token();
+ while (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY));
+ if (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else if (!token->is_eof() || !saw_errors())
+ {
+ error_at(this->location(),
+ "expected %<;%> or newline after top level declaration");
+ this->skip_past_error(OPERATOR_INVALID);
+ }
+ }
+}
+
+// Reset the current iota value.
+
+void
+Parse::reset_iota()
+{
+ this->iota_ = 0;
+}
+
+// Return the current iota value.
+
+int
+Parse::iota_value()
+{
+ return this->iota_;
+}
+
+// Increment the current iota value.
+
+void
+Parse::increment_iota()
+{
+ ++this->iota_;
+}
+
+// Skip forward to a semicolon or OP. OP will normally be
+// OPERATOR_RPAREN or OPERATOR_RCURLY. If we find a semicolon, move
+// past it and return. If we find OP, it will be the next token to
+// read. Return true if we are OK, false if we found EOF.
+
+bool
+Parse::skip_past_error(Operator op)
+{
+ const Token* token = this->peek_token();
+ while (!token->is_op(op))
+ {
+ if (token->is_eof())
+ return false;
+ if (token->is_op(OPERATOR_SEMICOLON))
+ {
+ this->advance_token();
+ return true;
+ }
+ token = this->advance_token();
+ }
+ return true;
+}
+
+// Check that an expression is not a sink.
+
+Expression*
+Parse::verify_not_sink(Expression* expr)
+{
+ if (expr->is_sink_expression())
+ {
+ error_at(expr->location(), "cannot use _ as value");
+ expr = Expression::make_error(expr->location());
+ }
+ return expr;
+}
--- /dev/null
+// parse.cc -- Go frontend parser.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "lex.h"
+#include "gogo.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "parse.h"
+
+// Struct Parse::Enclosing_var_comparison.
+
+// Return true if v1 should be considered to be less than v2.
+
+bool
+Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
+ const Enclosing_var& v2)
+{
+ if (v1.var() == v2.var())
+ return false;
+
+ const std::string& n1(v1.var()->name());
+ const std::string& n2(v2.var()->name());
+ int i = n1.compare(n2);
+ if (i < 0)
+ return true;
+ else if (i > 0)
+ return false;
+
+ // If we get here it means that a single nested function refers to
+ // two different variables defined in enclosing functions, and both
+ // variables have the same name. I think this is impossible.
+ go_unreachable();
+}
+
+// Class Parse.
+
+Parse::Parse(Lex* lex, Gogo* gogo)
+ : lex_(lex),
+ token_(Token::make_invalid_token(0)),
+ unget_token_(Token::make_invalid_token(0)),
+ unget_token_valid_(false),
+ gogo_(gogo),
+ break_stack_(NULL),
+ continue_stack_(NULL),
+ iota_(0),
+ enclosing_vars_()
+{
+}
+
+// Return the current token.
+
+const Token*
+Parse::peek_token()
+{
+ if (this->unget_token_valid_)
+ return &this->unget_token_;
+ if (this->token_.is_invalid())
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Advance to the next token and return it.
+
+const Token*
+Parse::advance_token()
+{
+ if (this->unget_token_valid_)
+ {
+ this->unget_token_valid_ = false;
+ if (!this->token_.is_invalid())
+ return &this->token_;
+ }
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Push a token back on the input stream.
+
+void
+Parse::unget_token(const Token& token)
+{
+ go_assert(!this->unget_token_valid_);
+ this->unget_token_ = token;
+ this->unget_token_valid_ = true;
+}
+
+// The location of the current token.
+
+source_location
+Parse::location()
+{
+ return this->peek_token()->location();
+}
+
+// IdentifierList = identifier { "," identifier } .
+
+void
+Parse::identifier_list(Typed_identifier_list* til)
+{
+ const Token* token = this->peek_token();
+ while (true)
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til->push_back(Typed_identifier(name, NULL, token->location()));
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return;
+ token = this->advance_token();
+ }
+}
+
+// ExpressionList = Expression { "," Expression } .
+
+// If MAY_BE_SINK is true, the expressions in the list may be "_".
+
+Expression_list*
+Parse::expression_list(Expression* first, bool may_be_sink)
+{
+ Expression_list* ret = new Expression_list();
+ if (first != NULL)
+ ret->push_back(first);
+ while (true)
+ {
+ ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink, true,
+ NULL));
+
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return ret;
+
+ // Most expression lists permit a trailing comma.
+ source_location location = token->location();
+ this->advance_token();
+ if (!this->expression_may_start_here())
+ {
+ this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
+ location));
+ return ret;
+ }
+ }
+}
+
+// QualifiedIdent = [ PackageName "." ] identifier .
+// PackageName = identifier .
+
+// This sets *PNAME to the identifier and sets *PPACKAGE to the
+// package or NULL if there isn't one. This returns true on success,
+// false on failure in which case it will have emitted an error
+// message.
+
+bool
+Parse::qualified_ident(std::string* pname, Named_object** ppackage)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT))
+ {
+ *pname = name;
+ *ppackage = NULL;
+ return true;
+ }
+
+ Named_object* package = this->gogo_->lookup(name, NULL);
+ if (package == NULL || !package->is_package())
+ {
+ error_at(this->location(), "expected package");
+ // We expect . IDENTIFIER; skip both.
+ if (this->advance_token()->is_identifier())
+ this->advance_token();
+ return false;
+ }
+
+ package->package_value()->set_used();
+
+ token = this->advance_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ name = token->identifier();
+
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = "blank";
+ }
+
+ if (package->name() == this->gogo_->package_name())
+ name = this->gogo_->pack_hidden_name(name,
+ token->is_identifier_exported());
+
+ *pname = name;
+ *ppackage = package;
+
+ this->advance_token();
+
+ return true;
+}
+
+// Type = TypeName | TypeLit | "(" Type ")" .
+// TypeLit =
+// ArrayType | StructType | PointerType | FunctionType | InterfaceType |
+// SliceType | MapType | ChannelType .
+
+Type*
+Parse::type()
+{
+ const Token* token = this->peek_token();
+ if (token->is_identifier())
+ return this->type_name(true);
+ else if (token->is_op(OPERATOR_LSQUARE))
+ return this->array_type(false);
+ else if (token->is_keyword(KEYWORD_CHAN)
+ || token->is_op(OPERATOR_CHANOP))
+ return this->channel_type();
+ else if (token->is_keyword(KEYWORD_INTERFACE))
+ return this->interface_type();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ {
+ source_location location = token->location();
+ this->advance_token();
+ Type* type = this->signature(NULL, location);
+ if (type == NULL)
+ return Type::make_error_type();
+ return type;
+ }
+ else if (token->is_keyword(KEYWORD_MAP))
+ return this->map_type();
+ else if (token->is_keyword(KEYWORD_STRUCT))
+ return this->struct_type();
+ else if (token->is_op(OPERATOR_MULT))
+ return this->pointer_type();
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* ret = this->type();
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (!ret->is_error_type())
+ error_at(this->location(), "expected %<)%>");
+ }
+ return ret;
+ }
+ else
+ {
+ error_at(token->location(), "expected type");
+ return Type::make_error_type();
+ }
+}
+
+bool
+Parse::type_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_identifier()
+ || token->is_op(OPERATOR_LSQUARE)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_keyword(KEYWORD_CHAN)
+ || token->is_keyword(KEYWORD_INTERFACE)
+ || token->is_keyword(KEYWORD_FUNC)
+ || token->is_keyword(KEYWORD_MAP)
+ || token->is_keyword(KEYWORD_STRUCT)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_LPAREN));
+}
+
+// TypeName = QualifiedIdent .
+
+// If MAY_BE_NIL is true, then an identifier with the value of the
+// predefined constant nil is accepted, returning the nil type.
+
+Type*
+Parse::type_name(bool issue_error)
+{
+ source_location location = this->location();
+
+ std::string name;
+ Named_object* package;
+ if (!this->qualified_ident(&name, &package))
+ return Type::make_error_type();
+
+ Named_object* named_object;
+ if (package == NULL)
+ named_object = this->gogo_->lookup(name, NULL);
+ else
+ {
+ named_object = package->package_value()->lookup(name);
+ if (named_object == NULL
+ && issue_error
+ && package->name() != this->gogo_->package_name())
+ {
+ // Check whether the name is there but hidden.
+ std::string s = ('.' + package->package_value()->unique_prefix()
+ + '.' + package->package_value()->name()
+ + '.' + name);
+ named_object = package->package_value()->lookup(s);
+ if (named_object != NULL)
+ {
+ const std::string& packname(package->package_value()->name());
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(packname).c_str(),
+ Gogo::message_name(name).c_str());
+ issue_error = false;
+ }
+ }
+ }
+
+ bool ok = true;
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ ok = false;
+ else
+ named_object = this->gogo_->add_unknown_name(name, location);
+ }
+ else if (named_object->is_type())
+ {
+ if (!named_object->type_value()->is_visible())
+ ok = false;
+ }
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ ;
+ else
+ ok = false;
+
+ if (!ok)
+ {
+ if (issue_error)
+ error_at(location, "expected type");
+ return Type::make_error_type();
+ }
+
+ if (named_object->is_type())
+ return named_object->type_value();
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ return Type::make_forward_declaration(named_object);
+ else
+ go_unreachable();
+}
+
+// ArrayType = "[" [ ArrayLength ] "]" ElementType .
+// ArrayLength = Expression .
+// ElementType = CompleteType .
+
+Type*
+Parse::array_type(bool may_use_ellipsis)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ const Token* token = this->advance_token();
+
+ Expression* length = NULL;
+ if (token->is_op(OPERATOR_RSQUARE))
+ this->advance_token();
+ else
+ {
+ if (!token->is_op(OPERATOR_ELLIPSIS))
+ length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else if (may_use_ellipsis)
+ {
+ // An ellipsis is used in composite literals to represent a
+ // fixed array of the size of the number of elements. We
+ // use a length of nil to represent this, and change the
+ // length when parsing the composite literal.
+ length = Expression::make_nil(this->location());
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(),
+ "use of %<[...]%> outside of array literal");
+ length = Expression::make_error(this->location());
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+ }
+
+ Type* element_type = this->type();
+
+ return Type::make_array_type(element_type, length);
+}
+
+// MapType = "map" "[" KeyType "]" ValueType .
+// KeyType = CompleteType .
+// ValueType = CompleteType .
+
+Type*
+Parse::map_type()
+{
+ source_location location = this->location();
+ go_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
+ if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
+ {
+ error_at(this->location(), "expected %<[%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* key_type = this->type();
+
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* value_type = this->type();
+
+ if (key_type->is_error_type() || value_type->is_error_type())
+ return Type::make_error_type();
+
+ return Type::make_map_type(key_type, value_type, location);
+}
+
+// StructType = "struct" "{" { FieldDecl ";" } "}" .
+
+Type*
+Parse::struct_type()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
+ source_location location = this->location();
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Struct_field_list* sfl = new Struct_field_list;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->field_decl(sfl);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ for (Struct_field_list::const_iterator pi = sfl->begin();
+ pi != sfl->end();
+ ++pi)
+ {
+ if (pi->type()->is_error_type())
+ return pi->type();
+ for (Struct_field_list::const_iterator pj = pi + 1;
+ pj != sfl->end();
+ ++pj)
+ {
+ if (pi->field_name() == pj->field_name()
+ && !Gogo::is_sink_name(pi->field_name()))
+ error_at(pi->location(), "duplicate field name %<%s%>",
+ Gogo::message_name(pi->field_name()).c_str());
+ }
+ }
+
+ return Type::make_struct_type(sfl, location);
+}
+
+// FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
+// Tag = string_lit .
+
+void
+Parse::field_decl(Struct_field_list* sfl)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ bool is_anonymous;
+ bool is_anonymous_pointer;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_anonymous = true;
+ is_anonymous_pointer = true;
+ }
+ else if (token->is_identifier())
+ {
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+ token = this->advance_token();
+ is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
+ || token->is_op(OPERATOR_RCURLY)
+ || token->is_op(OPERATOR_DOT)
+ || token->is_string());
+ is_anonymous_pointer = false;
+ this->unget_token(Token::make_identifier_token(id, is_id_exported,
+ id_location));
+ }
+ else
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+
+ if (is_anonymous)
+ {
+ if (is_anonymous_pointer)
+ {
+ this->advance_token();
+ if (!this->peek_token()->is_identifier())
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+ }
+ Type* type = this->type_name(true);
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ if (!type->is_error_type())
+ {
+ if (is_anonymous_pointer)
+ type = Type::make_pointer_type(type);
+ sfl->push_back(Struct_field(Typed_identifier("", type, location)));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+ else
+ {
+ Typed_identifier_list til;
+ while (true)
+ {
+ token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til.push_back(Typed_identifier(name, NULL, token->location()));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+
+ Type* type = this->type();
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ for (Typed_identifier_list::iterator p = til.begin();
+ p != til.end();
+ ++p)
+ {
+ p->set_type(type);
+ sfl->push_back(Struct_field(*p));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+}
+
+// PointerType = "*" Type .
+
+Type*
+Parse::pointer_type()
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_MULT));
+ this->advance_token();
+ Type* type = this->type();
+ if (type->is_error_type())
+ return type;
+ return Type::make_pointer_type(type);
+}
+
+// ChannelType = Channel | SendChannel | RecvChannel .
+// Channel = "chan" ElementType .
+// SendChannel = "chan" "<-" ElementType .
+// RecvChannel = "<-" "chan" ElementType .
+
+Type*
+Parse::channel_type()
+{
+ const Token* token = this->peek_token();
+ bool send = true;
+ bool receive = true;
+ if (token->is_op(OPERATOR_CHANOP))
+ {
+ if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
+ {
+ error_at(this->location(), "expected %<chan%>");
+ return Type::make_error_type();
+ }
+ send = false;
+ this->advance_token();
+ }
+ else
+ {
+ go_assert(token->is_keyword(KEYWORD_CHAN));
+ if (this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ receive = false;
+ this->advance_token();
+ }
+ }
+
+ // Better error messages for the common error of omitting the
+ // channel element type.
+ if (!this->type_may_start_here())
+ {
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_RCURLY))
+ error_at(this->location(), "unexpected %<}%> in channel type");
+ else if (token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "unexpected %<)%> in channel type");
+ else if (token->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "unexpected comma in channel type");
+ else
+ error_at(this->location(), "expected channel element type");
+ return Type::make_error_type();
+ }
+
+ Type* element_type = this->type();
+ return Type::make_channel_type(send, receive, element_type);
+}
+
+// Signature = Parameters [ Result ] .
+
+// RECEIVER is the receiver if there is one, or NULL. LOCATION is the
+// location of the start of the type.
+
+// This returns NULL on a parse error.
+
+Function_type*
+Parse::signature(Typed_identifier* receiver, source_location location)
+{
+ bool is_varargs = false;
+ Typed_identifier_list* params;
+ bool params_ok = this->parameters(¶ms, &is_varargs);
+
+ Typed_identifier_list* result = NULL;
+ if (this->peek_token()->is_op(OPERATOR_LPAREN)
+ || this->type_may_start_here())
+ {
+ if (!this->result(&result))
+ return NULL;
+ }
+
+ if (!params_ok)
+ return NULL;
+
+ Function_type* ret = Type::make_function_type(receiver, params, result,
+ location);
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Parameters = "(" [ ParameterList [ "," ] ] ")" .
+
+// This returns false on a parse error.
+
+bool
+Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
+{
+ *pparams = NULL;
+
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return false;
+ }
+
+ Typed_identifier_list* params = NULL;
+ bool saw_error = false;
+
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ params = this->parameter_list(is_varargs);
+ if (params == NULL)
+ saw_error = true;
+ token = this->peek_token();
+ }
+
+ // The optional trailing comma is picked up in parameter_list.
+
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+
+ if (saw_error)
+ return false;
+
+ *pparams = params;
+ return true;
+}
+
+// ParameterList = ParameterDecl { "," ParameterDecl } .
+
+// This sets *IS_VARARGS if the list ends with an ellipsis.
+// IS_VARARGS will be NULL if varargs are not permitted.
+
+// We pick up an optional trailing comma.
+
+// This returns NULL if some error is seen.
+
+Typed_identifier_list*
+Parse::parameter_list(bool* is_varargs)
+{
+ source_location location = this->location();
+ Typed_identifier_list* ret = new Typed_identifier_list();
+
+ bool saw_error = false;
+
+ // If we see an identifier and then a comma, then we don't know
+ // whether we are looking at a list of identifiers followed by a
+ // type, or a list of types given by name. We have to do an
+ // arbitrary lookahead to figure it out.
+
+ bool parameters_have_names;
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ // This must be a type which starts with something like '*'.
+ parameters_have_names = false;
+ }
+ else
+ {
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_DOT))
+ {
+ // This is a qualified identifier, which must turn out
+ // to be a type.
+ parameters_have_names = false;
+ }
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ // A single identifier followed by a parenthesis must be
+ // a type name.
+ parameters_have_names = false;
+ }
+ else
+ {
+ // An identifier followed by something other than a
+ // comma or a dot or a right parenthesis must be a
+ // parameter name followed by a type.
+ parameters_have_names = true;
+ }
+
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ }
+ else
+ {
+ // An identifier followed by a comma may be the first in a
+ // list of parameter names followed by a type, or it may be
+ // the first in a list of types without parameter names. To
+ // find out we gather as many identifiers separated by
+ // commas as we can.
+ std::string id_name = this->gogo_->pack_hidden_name(name,
+ is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ bool just_saw_comma = true;
+ while (this->advance_token()->is_identifier())
+ {
+ name = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ location = this->peek_token()->location();
+ id_name = this->gogo_->pack_hidden_name(name, is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ {
+ just_saw_comma = false;
+ break;
+ }
+ }
+
+ if (just_saw_comma)
+ {
+ // We saw ID1 "," ID2 "," followed by something which
+ // was not an identifier. We must be seeing the start
+ // of a type, and ID1 and ID2 must be types, and the
+ // parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
+ // and the parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_DOT))
+ {
+ // We saw ID1 "," ID2 ".". ID2 must be a package name,
+ // ID1 must be a type, and the parameters don't have
+ // names.
+ parameters_have_names = false;
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ ret->pop_back();
+ just_saw_comma = true;
+ }
+ else
+ {
+ // We saw ID1 "," ID2 followed by something other than
+ // ",", ".", or ")". We must be looking at the start of
+ // a type, and ID1 and ID2 must be parameter names.
+ parameters_have_names = true;
+ }
+
+ if (parameters_have_names)
+ {
+ go_assert(!just_saw_comma);
+ // We have just seen ID1, ID2 xxx.
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ error_at(this->location(), "%<...%> only permits one name");
+ saw_error = true;
+ this->advance_token();
+ type = this->type();
+ }
+ for (size_t i = 0; i < ret->size(); ++i)
+ ret->set_type(i, type);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ return saw_error ? NULL : ret;
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ return saw_error ? NULL : ret;
+ }
+ else
+ {
+ Typed_identifier_list* tret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = ret->begin();
+ p != ret->end();
+ ++p)
+ {
+ Named_object* no = this->gogo_->lookup(p->name(), NULL);
+ Type* type;
+ if (no == NULL)
+ no = this->gogo_->add_unknown_name(p->name(),
+ p->location());
+
+ if (no->is_type())
+ type = no->type_value();
+ else if (no->is_unknown() || no->is_type_declaration())
+ type = Type::make_forward_declaration(no);
+ else
+ {
+ error_at(p->location(), "expected %<%s%> to be a type",
+ Gogo::message_name(p->name()).c_str());
+ saw_error = true;
+ type = Type::make_error_type();
+ }
+ tret->push_back(Typed_identifier("", type, p->location()));
+ }
+ delete ret;
+ ret = tret;
+ if (!just_saw_comma
+ || this->peek_token()->is_op(OPERATOR_RPAREN))
+ return saw_error ? NULL : ret;
+ }
+ }
+ }
+
+ bool mix_error = false;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ while (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (is_varargs != NULL && *is_varargs)
+ {
+ error_at(this->location(), "%<...%> must be last parameter");
+ saw_error = true;
+ }
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ break;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ }
+ if (mix_error)
+ {
+ error_at(location, "invalid named/anonymous mix");
+ saw_error = true;
+ }
+ if (saw_error)
+ {
+ delete ret;
+ return NULL;
+ }
+ return ret;
+}
+
+// ParameterDecl = [ IdentifierList ] [ "..." ] Type .
+
+void
+Parse::parameter_decl(bool parameters_have_names,
+ Typed_identifier_list* til,
+ bool* is_varargs,
+ bool* mix_error)
+{
+ if (!parameters_have_names)
+ {
+ Type* type;
+ source_location location = this->location();
+ if (!this->peek_token()->is_identifier())
+ {
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ if (is_varargs == NULL
+ && this->peek_token()->is_op(OPERATOR_RPAREN))
+ type = Type::make_error_type();
+ else
+ {
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ }
+ }
+ else
+ {
+ type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN)))
+ {
+ *mix_error = true;
+ while (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ }
+ }
+ if (!type->is_error_type())
+ til->push_back(Typed_identifier("", type, location));
+ }
+ else
+ {
+ size_t orig_count = til->size();
+ if (this->peek_token()->is_identifier())
+ this->identifier_list(til);
+ else
+ *mix_error = true;
+ size_t new_count = til->size();
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else if (new_count > orig_count + 1)
+ error_at(this->location(), "%<...%> only permits one name");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ for (size_t i = orig_count; i < new_count; ++i)
+ til->set_type(i, type);
+ }
+}
+
+// Result = Parameters | Type .
+
+// This returns false on a parse error.
+
+bool
+Parse::result(Typed_identifier_list** presults)
+{
+ if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ return this->parameters(presults, NULL);
+ else
+ {
+ source_location location = this->location();
+ Type* type = this->type();
+ if (type->is_error_type())
+ {
+ *presults = NULL;
+ return false;
+ }
+ Typed_identifier_list* til = new Typed_identifier_list();
+ til->push_back(Typed_identifier("", type, location));
+ *presults = til;
+ return true;
+ }
+}
+
+// Block = "{" [ StatementList ] "}" .
+
+// Returns the location of the closing brace.
+
+source_location
+Parse::block()
+{
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return UNKNOWN_LOCATION;
+ }
+ }
+
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ this->statement_list();
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ if (!token->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<}%>");
+
+ // Skip ahead to the end of the block, in hopes of avoiding
+ // lots of meaningless errors.
+ source_location ret = token->location();
+ int nest = 0;
+ while (!token->is_eof())
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++nest;
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ --nest;
+ if (nest < 0)
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ token = this->advance_token();
+ ret = token->location();
+ }
+ return ret;
+ }
+ }
+
+ source_location ret = token->location();
+ this->advance_token();
+ return ret;
+}
+
+// InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
+// MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
+
+Type*
+Parse::interface_type()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
+ source_location location = this->location();
+
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Typed_identifier_list* methods = new Typed_identifier_list();
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->method_spec(methods);
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ break;
+ this->method_spec(methods);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<}%>");
+ while (!this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ return Type::make_error_type();
+ }
+ }
+ }
+ this->advance_token();
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ Interface_type* ret = Type::make_interface_type(methods, location);
+ this->gogo_->record_interface_type(ret);
+ return ret;
+}
+
+// MethodSpec = MethodName Signature | InterfaceTypeName .
+// MethodName = identifier .
+// InterfaceTypeName = TypeName .
+
+void
+Parse::method_spec(Typed_identifier_list* methods)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ if (this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ // This is a MethodName.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ Type* type = this->signature(NULL, location);
+ if (type == NULL)
+ return;
+ methods->push_back(Typed_identifier(name, type, location));
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ Type* type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY)))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(),
+ "name list not allowed in interface type");
+ else
+ error_at(location, "expected signature or type name");
+ token = this->peek_token();
+ while (!token->is_eof()
+ && !token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY))
+ token = this->advance_token();
+ return;
+ }
+ // This must be an interface type, but we can't check that now.
+ // We check it and pull out the methods in
+ // Interface_type::do_verify.
+ methods->push_back(Typed_identifier("", type, location));
+ }
+}
+
+// Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
+
+void
+Parse::declaration()
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CONST))
+ this->const_decl();
+ else if (token->is_keyword(KEYWORD_TYPE))
+ this->type_decl();
+ else if (token->is_keyword(KEYWORD_VAR))
+ this->var_decl();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ this->function_decl();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ this->advance_token();
+ }
+}
+
+bool
+Parse::declaration_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_keyword(KEYWORD_CONST)
+ || token->is_keyword(KEYWORD_TYPE)
+ || token->is_keyword(KEYWORD_VAR)
+ || token->is_keyword(KEYWORD_FUNC));
+}
+
+// Decl<P> = P | "(" [ List<P> ] ")" .
+
+void
+Parse::decl(void (Parse::*pfn)(void*), void* varg)
+{
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ (this->*pfn)(varg);
+ else
+ {
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->list(pfn, varg, true);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "missing %<)%>");
+ while (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ if (this->peek_token()->is_eof())
+ return;
+ }
+ }
+ }
+ this->advance_token();
+ }
+}
+
+// List<P> = P { ";" P } [ ";" ] .
+
+// In order to pick up the trailing semicolon we need to know what
+// might follow. This is either a '}' or a ')'.
+
+void
+Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
+{
+ (this->*pfn)(varg);
+ Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ || this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "unexpected comma");
+ if (this->advance_token()->is_op(follow))
+ break;
+ (this->*pfn)(varg);
+ }
+}
+
+// ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
+
+void
+Parse::const_decl()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
+ this->advance_token();
+ this->reset_iota();
+
+ Type* last_type = NULL;
+ Expression_list* last_expr_list = NULL;
+
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ this->const_spec(&last_type, &last_expr_list);
+ else
+ {
+ this->advance_token();
+ while (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->const_spec(&last_type, &last_expr_list);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<;%> or %<)%> or newline");
+ if (!this->skip_past_error(OPERATOR_RPAREN))
+ return;
+ }
+ }
+ this->advance_token();
+ }
+
+ if (last_expr_list != NULL)
+ delete last_expr_list;
+}
+
+// ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
+
+void
+Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
+{
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ Type* type = NULL;
+ if (this->type_may_start_here())
+ {
+ type = this->type();
+ *last_type = NULL;
+ *last_expr_list = NULL;
+ }
+
+ Expression_list *expr_list;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (*last_expr_list == NULL)
+ {
+ error_at(this->location(), "expected %<=%>");
+ return;
+ }
+ type = *last_type;
+ expr_list = new Expression_list;
+ for (Expression_list::const_iterator p = (*last_expr_list)->begin();
+ p != (*last_expr_list)->end();
+ ++p)
+ expr_list->push_back((*p)->copy());
+ }
+ else
+ {
+ this->advance_token();
+ expr_list = this->expression_list(NULL, false);
+ *last_type = type;
+ if (*last_expr_list != NULL)
+ delete *last_expr_list;
+ *last_expr_list = expr_list;
+ }
+
+ Expression_list::const_iterator pe = expr_list->begin();
+ for (Typed_identifier_list::iterator pi = til.begin();
+ pi != til.end();
+ ++pi, ++pe)
+ {
+ if (pe == expr_list->end())
+ {
+ error_at(this->location(), "not enough initializers");
+ return;
+ }
+ if (type != NULL)
+ pi->set_type(type);
+
+ if (!Gogo::is_sink_name(pi->name()))
+ this->gogo_->add_constant(*pi, *pe, this->iota_value());
+ }
+ if (pe != expr_list->end())
+ error_at(this->location(), "too many initializers");
+
+ this->increment_iota();
+
+ return;
+}
+
+// TypeDecl = "type" Decl<TypeSpec> .
+
+void
+Parse::type_decl()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
+ this->advance_token();
+ this->decl(&Parse::type_spec, NULL);
+}
+
+// TypeSpec = identifier Type .
+
+void
+Parse::type_spec(void*)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+
+ // The scope of the type name starts at the point where the
+ // identifier appears in the source code. We implement this by
+ // declaring the type before we read the type definition.
+ Named_object* named_type = NULL;
+ if (name != "_")
+ {
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ named_type = this->gogo_->declare_type(name, location);
+ }
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ type = this->type();
+ else
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline in type declaration");
+ type = Type::make_error_type();
+ this->advance_token();
+ }
+
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+
+ if (name != "_")
+ {
+ if (named_type->is_type_declaration())
+ {
+ Type* ftype = type->forwarded();
+ if (ftype->forward_declaration_type() != NULL
+ && (ftype->forward_declaration_type()->named_object()
+ == named_type))
+ {
+ error_at(location, "invalid recursive type");
+ type = Type::make_error_type();
+ }
+
+ this->gogo_->define_type(named_type,
+ Type::make_named_type(named_type, type,
+ location));
+ go_assert(named_type->package() == NULL);
+ }
+ else
+ {
+ // This will probably give a redefinition error.
+ this->gogo_->add_type(name, type, location);
+ }
+ }
+}
+
+// VarDecl = "var" Decl<VarSpec> .
+
+void
+Parse::var_decl()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
+ this->advance_token();
+ this->decl(&Parse::var_spec, NULL);
+}
+
+// VarSpec = IdentifierList
+// ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
+
+void
+Parse::var_spec(void*)
+{
+ // Get the variable names.
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ source_location location = this->location();
+
+ Type* type = NULL;
+ Expression_list* init = NULL;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ type = this->type();
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_EQ)
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+
+ this->init_vars(&til, type, init, false, location);
+
+ if (init != NULL)
+ delete init;
+}
+
+// Create variables. TIL is a list of variable names. If TYPE is not
+// NULL, it is the type of all the variables. If INIT is not NULL, it
+// is an initializer list for the variables.
+
+void
+Parse::init_vars(const Typed_identifier_list* til, Type* type,
+ Expression_list* init, bool is_coloneq,
+ source_location location)
+{
+ // Check for an initialization which can yield multiple values.
+ if (init != NULL && init->size() == 1 && til->size() > 1)
+ {
+ if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_type_guard(til, type, *init->begin(),
+ is_coloneq, location))
+ return;
+ }
+
+ if (init != NULL && init->size() != til->size())
+ {
+ if (init->empty() || !init->front()->is_error_expression())
+ error_at(location, "wrong number of initializations");
+ init = NULL;
+ if (type == NULL)
+ type = Type::make_error_type();
+ }
+
+ // Note that INIT was already parsed with the old name bindings, so
+ // we don't have to worry that it will accidentally refer to the
+ // newly declared variables.
+
+ Expression_list::const_iterator pexpr;
+ if (init != NULL)
+ pexpr = init->begin();
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator p = til->begin();
+ p != til->end();
+ ++p)
+ {
+ if (init != NULL)
+ go_assert(pexpr != init->end());
+ this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
+ false, &any_new);
+ if (init != NULL)
+ ++pexpr;
+ }
+ if (init != NULL)
+ go_assert(pexpr == init->end());
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// See if we need to initialize a list of variables from a function
+// call. This returns true if we have set up the variables and the
+// initialization.
+
+bool
+Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Call_expression* call = expr->call_expression();
+ if (call == NULL)
+ return false;
+
+ // This is a function call. We can't check here whether it returns
+ // the right number of values, but it might. Declare the variables,
+ // and then assign the results of the call to them.
+
+ unsigned int index = 0;
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator pv = vars->begin();
+ pv != vars->end();
+ ++pv, ++index)
+ {
+ Expression* init = Expression::make_call_result(call, index);
+ this->init_var(*pv, type, init, is_coloneq, false, &any_new);
+ }
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a map index
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Index_expression* index = expr->index_expression();
+ if (index == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is an index which is being assigned to two variables. It
+ // must be a map index. Declare the variables, and then assign the
+ // results of the map index.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? index : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* present_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
+ index, location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ // Execute the map index expression just so that we can fail if
+ // the map is nil.
+ Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
+ NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a receive
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Receive_expression* receive = expr->receive_expression();
+ if (receive == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a receive expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the receive.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? receive : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* received_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_receive_assignment(val_var,
+ received_var,
+ receive->channel(),
+ false,
+ location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
+ NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a type guard
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
+ Type* type, Expression* expr,
+ bool is_coloneq, source_location location)
+{
+ Type_guard_expression* type_guard = expr->type_guard_expression();
+ if (type_guard == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a type guard expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the type guard.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = type_guard->type();
+ Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* ok_var = Expression::make_var_reference(no, location);
+
+ Expression* texpr = type_guard->expr();
+ Type* t = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
+ texpr, t,
+ location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ Named_object* dummy = this->create_dummy_global(type, NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// Create a single variable. If IS_COLONEQ is true, we permit
+// redeclarations in the same block, and we set *IS_NEW when we find a
+// new variable which is not a redeclaration.
+
+Named_object*
+Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
+ bool is_coloneq, bool type_from_init, bool* is_new)
+{
+ source_location location = tid.location();
+
+ if (Gogo::is_sink_name(tid.name()))
+ {
+ if (!type_from_init && init != NULL)
+ {
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(Statement::make_statement(init));
+ else
+ return this->create_dummy_global(type, init, location);
+ }
+ return this->gogo_->add_sink();
+ }
+
+ if (is_coloneq)
+ {
+ Named_object* no = this->gogo_->lookup_in_block(tid.name());
+ if (no != NULL
+ && (no->is_variable() || no->is_result_variable()))
+ {
+ // INIT may be NULL even when IS_COLONEQ is true for cases
+ // like v, ok := x.(int).
+ if (!type_from_init && init != NULL)
+ {
+ Expression *v = Expression::make_var_reference(no, location);
+ Statement *s = Statement::make_assignment(v, init, location);
+ this->gogo_->add_statement(s);
+ }
+ return no;
+ }
+ }
+ *is_new = true;
+ Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
+ false, false, location);
+ Named_object* no = this->gogo_->add_variable(tid.name(), var);
+ if (!no->is_variable())
+ {
+ // The name is already defined, so we just gave an error.
+ return this->gogo_->add_sink();
+ }
+ return no;
+}
+
+// Create a dummy global variable to force an initializer to be run in
+// the right place. This is used when a sink variable is initialized
+// at global scope.
+
+Named_object*
+Parse::create_dummy_global(Type* type, Expression* init,
+ source_location location)
+{
+ if (type == NULL && init == NULL)
+ type = Type::lookup_bool_type();
+ Variable* var = new Variable(type, init, true, false, false, location);
+ static int count;
+ char buf[30];
+ snprintf(buf, sizeof buf, "_.%d", count);
+ ++count;
+ return this->gogo_->add_variable(buf, var);
+}
+
+// SimpleVarDecl = identifier ":=" Expression .
+
+// We've already seen the identifier.
+
+// FIXME: We also have to implement
+// IdentifierList ":=" ExpressionList
+// In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
+// tuple assignments here as well.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+void
+Parse::simple_var_decl_or_assignment(const std::string& name,
+ source_location location,
+ Range_clause* p_range_clause,
+ Type_switch* p_type_switch)
+{
+ Typed_identifier_list til;
+ til.push_back(Typed_identifier(name, NULL, location));
+
+ // We've seen one identifier. If we see a comma now, this could be
+ // "a, *p = 1, 2".
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ go_assert(p_type_switch == NULL);
+ while (true)
+ {
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ break;
+
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+ else
+ this->unget_token(Token::make_identifier_token(id,
+ is_id_exported,
+ id_location));
+ break;
+ }
+
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+
+ // We have a comma separated list of identifiers in TIL. If the
+ // next token is COLONEQ, then this is a simple var decl, and we
+ // have the complete list of identifiers. If the next token is
+ // not COLONEQ, then the only valid parse is a tuple assignment.
+ // The list of identifiers we have so far is really a list of
+ // expressions. There are more expressions following.
+
+ if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
+ {
+ Expression_list* exprs = new Expression_list;
+ for (Typed_identifier_list::const_iterator p = til.begin();
+ p != til.end();
+ ++p)
+ exprs->push_back(this->id_to_expression(p->name(),
+ p->location()));
+
+ Expression_list* more_exprs = this->expression_list(NULL, true);
+ for (Expression_list::const_iterator p = more_exprs->begin();
+ p != more_exprs->end();
+ ++p)
+ exprs->push_back(*p);
+ delete more_exprs;
+
+ this->tuple_assignment(exprs, p_range_clause);
+ return;
+ }
+ }
+
+ go_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
+ const Token* token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ this->range_clause_decl(&til, p_range_clause);
+ return;
+ }
+
+ Expression_list* init;
+ if (p_type_switch == NULL)
+ init = this->expression_list(NULL, false);
+ else
+ {
+ bool is_type_switch = false;
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ &is_type_switch);
+ if (is_type_switch)
+ {
+ p_type_switch->found = true;
+ p_type_switch->name = name;
+ p_type_switch->location = location;
+ p_type_switch->expr = expr;
+ return;
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ init = new Expression_list();
+ init->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(expr, false);
+ }
+ }
+
+ this->init_vars(&til, NULL, init, true, location);
+}
+
+// FunctionDecl = "func" identifier Signature [ Block ] .
+// MethodDecl = "func" Receiver identifier Signature [ Block ] .
+
+// gcc extension:
+// FunctionDecl = "func" identifier Signature
+// __asm__ "(" string_lit ")" .
+// This extension means a function whose real name is the identifier
+// inside the asm.
+
+void
+Parse::function_decl()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ Typed_identifier* rec = NULL;
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ rec = this->receiver();
+ token = this->peek_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected function name");
+ return;
+ }
+
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+
+ this->advance_token();
+
+ Function_type* fntype = this->signature(rec, this->location());
+ if (fntype == NULL)
+ return;
+
+ Named_object* named_object = NULL;
+
+ if (this->peek_token()->is_keyword(KEYWORD_ASM))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return;
+ }
+ token = this->advance_token();
+ if (!token->is_string())
+ {
+ error_at(this->location(), "expected string");
+ return;
+ }
+ std::string asm_name = token->string_value();
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<)%>");
+ return;
+ }
+ this->advance_token();
+ if (!Gogo::is_sink_name(name))
+ {
+ named_object = this->gogo_->declare_function(name, fntype, location);
+ if (named_object->is_function_declaration())
+ named_object->func_declaration_value()->set_asm_name(asm_name);
+ }
+ }
+
+ // Check for the easy error of a newline before the opening brace.
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (named_object == NULL && !Gogo::is_sink_name(name))
+ this->gogo_->declare_function(name, fntype, location);
+ }
+ else
+ {
+ this->gogo_->start_function(name, fntype, true, location);
+ source_location end_loc = this->block();
+ this->gogo_->finish_function(end_loc);
+ }
+}
+
+// Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
+// BaseTypeName = identifier .
+
+Typed_identifier*
+Parse::receiver()
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+
+ std::string name;
+ const Token* token = this->advance_token();
+ source_location location = token->location();
+ if (!token->is_op(OPERATOR_MULT))
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "method has no receiver");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+ name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
+ {
+ // An identifier followed by something other than a dot or a
+ // right parenthesis must be a receiver name followed by a
+ // type.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ }
+ else
+ {
+ // This must be a type name.
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ token = this->peek_token();
+ name.clear();
+ }
+ }
+
+ // Here the receiver name is in NAME (it is empty if the receiver is
+ // unnamed) and TOKEN is the first token in the type.
+
+ bool is_pointer = false;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_pointer = true;
+ token = this->advance_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected receiver name or type");
+ int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
+ while (!token->is_eof())
+ {
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ++c;
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ if (c == 0)
+ break;
+ --c;
+ }
+ }
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ Type* type = this->type_name(true);
+
+ if (is_pointer && !type->is_error_type())
+ type = Type::make_pointer_type(type);
+
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "method has multiple receivers");
+ else
+ error_at(this->location(), "expected %<)%>");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ return new Typed_identifier(name, type, location);
+}
+
+// Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
+// Literal = BasicLit | CompositeLit | FunctionLit .
+// BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
+
+// If MAY_BE_SINK is true, this operand may be "_".
+
+Expression*
+Parse::operand(bool may_be_sink)
+{
+ const Token* token = this->peek_token();
+ Expression* ret;
+ switch (token->classification())
+ {
+ case Token::TOKEN_IDENTIFIER:
+ {
+ source_location location = token->location();
+ std::string id = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
+
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(packed, &in_function);
+
+ Package* package = NULL;
+ if (named_object != NULL && named_object->is_package())
+ {
+ if (!this->advance_token()->is_op(OPERATOR_DOT)
+ || !this->advance_token()->is_identifier())
+ {
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ }
+ package = named_object->package_value();
+ package->set_used();
+ id = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ packed = this->gogo_->pack_hidden_name(id, is_exported);
+ named_object = package->lookup(packed);
+ location = this->location();
+ go_assert(in_function == NULL);
+ }
+
+ this->advance_token();
+
+ if (named_object != NULL
+ && named_object->is_type()
+ && !named_object->type_value()->is_visible())
+ {
+ go_assert(package != NULL);
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(package->name()).c_str(),
+ Gogo::message_name(id).c_str());
+ return Expression::make_error(location);
+ }
+
+
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ {
+ std::string n1 = Gogo::message_name(package->name());
+ std::string n2 = Gogo::message_name(id);
+ if (!is_exported)
+ error_at(location,
+ ("invalid reference to unexported identifier "
+ "%<%s.%s%>"),
+ n1.c_str(), n2.c_str());
+ else
+ error_at(location,
+ "reference to undefined identifier %<%s.%s%>",
+ n1.c_str(), n2.c_str());
+ return Expression::make_error(location);
+ }
+
+ named_object = this->gogo_->add_unknown_name(packed, location);
+ }
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable()
+ || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(named_object->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ {
+ Type* t = Type::make_forward_declaration(named_object);
+ return Expression::make_type(t, location);
+ }
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ if (may_be_sink)
+ return Expression::make_sink(location);
+ else
+ {
+ error_at(location, "cannot use _ as value");
+ return Expression::make_error(location);
+ }
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL,
+ location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ go_unreachable();
+ }
+ }
+ go_unreachable();
+
+ case Token::TOKEN_STRING:
+ ret = Expression::make_string(token->string_value(), token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_INTEGER:
+ ret = Expression::make_integer(token->integer_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_FLOAT:
+ ret = Expression::make_float(token->float_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_IMAGINARY:
+ {
+ mpfr_t zero;
+ mpfr_init_set_ui(zero, 0, GMP_RNDN);
+ ret = Expression::make_complex(&zero, token->imaginary_value(),
+ NULL, token->location());
+ mpfr_clear(zero);
+ this->advance_token();
+ return ret;
+ }
+
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_FUNC:
+ return this->function_lit();
+ case KEYWORD_CHAN:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ {
+ source_location location = token->location();
+ return Expression::make_type(this->type(), location);
+ }
+ default:
+ break;
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ return ret;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ {
+ // Here we call array_type directly, as this is the only
+ // case where an ellipsis is permitted for an array type.
+ source_location location = token->location();
+ return Expression::make_type(this->array_type(true), location);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ error_at(this->location(), "expected operand");
+ return Expression::make_error(this->location());
+}
+
+// Handle a reference to a variable in an enclosing function. We add
+// it to a list of such variables. We return a reference to a field
+// in a struct which will be passed on the static chain when calling
+// the current function.
+
+Expression*
+Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
+ source_location location)
+{
+ go_assert(var->is_variable() || var->is_result_variable());
+
+ Named_object* this_function = this->gogo_->current_function();
+ Named_object* closure = this_function->func_value()->closure_var();
+
+ Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
+ std::pair<Enclosing_vars::iterator, bool> ins =
+ this->enclosing_vars_.insert(ev);
+ if (ins.second)
+ {
+ // This is a variable we have not seen before. Add a new field
+ // to the closure type.
+ this_function->func_value()->add_closure_field(var, location);
+ }
+
+ Expression* closure_ref = Expression::make_var_reference(closure,
+ location);
+ closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
+
+ // The closure structure holds pointers to the variables, so we need
+ // to introduce an indirection.
+ Expression* e = Expression::make_field_reference(closure_ref,
+ ins.first->index(),
+ location);
+ e = Expression::make_unary(OPERATOR_MULT, e, location);
+ return e;
+}
+
+// CompositeLit = LiteralType LiteralValue .
+// LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
+// SliceType | MapType | TypeName .
+// LiteralValue = "{" [ ElementList [ "," ] ] "}" .
+// ElementList = Element { "," Element } .
+// Element = [ Key ":" ] Value .
+// Key = Expression .
+// Value = Expression | LiteralValue .
+
+// We have already seen the type if there is one, and we are now
+// looking at the LiteralValue. The case "[" "..." "]" ElementType
+// will be seen here as an array type whose length is "nil". The
+// DEPTH parameter is non-zero if this is an embedded composite
+// literal and the type was omitted. It gives the number of steps up
+// to the type which was provided. E.g., in [][]int{{1}} it will be
+// 1. In [][][]int{{{1}}} it will be 2.
+
+Expression*
+Parse::composite_lit(Type* type, int depth, source_location location)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ return Expression::make_composite_literal(type, depth, false, NULL,
+ location);
+ }
+
+ bool has_keys = false;
+ Expression_list* vals = new Expression_list;
+ while (true)
+ {
+ Expression* val;
+ bool is_type_omitted = false;
+
+ const Token* token = this->peek_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another composite
+ // literal, with the type omitted for the inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ is_type_omitted = true;
+ }
+
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_COLON))
+ {
+ if (has_keys)
+ vals->push_back(NULL);
+ }
+ else
+ {
+ if (is_type_omitted && !val->is_error_expression())
+ {
+ error_at(this->location(), "unexpected %<:%>");
+ val = Expression::make_error(this->location());
+ }
+
+ this->advance_token();
+
+ if (!has_keys && !vals->empty())
+ {
+ Expression_list* newvals = new Expression_list;
+ for (Expression_list::const_iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ {
+ newvals->push_back(NULL);
+ newvals->push_back(*p);
+ }
+ delete vals;
+ vals = newvals;
+ }
+ has_keys = true;
+
+ if (val->unknown_expression() != NULL)
+ val->unknown_expression()->set_is_composite_literal_key();
+
+ vals->push_back(val);
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another
+ // composite literal, with the type omitted for the
+ // inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ }
+
+ token = this->peek_token();
+ }
+
+ vals->push_back(val);
+
+ if (token->is_op(OPERATOR_COMMA))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<,%> or %<}%>");
+
+ int depth = 0;
+ while (!token->is_eof()
+ && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++depth;
+ else if (token->is_op(OPERATOR_RCURLY))
+ --depth;
+ token = this->advance_token();
+ }
+ if (token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+
+ return Expression::make_error(location);
+ }
+ }
+
+ return Expression::make_composite_literal(type, depth, has_keys, vals,
+ location);
+}
+
+// FunctionLit = "func" Signature Block .
+
+Expression*
+Parse::function_lit()
+{
+ source_location location = this->location();
+ go_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ this->advance_token();
+
+ Enclosing_vars hold_enclosing_vars;
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Function_type* type = this->signature(NULL, location);
+ if (type == NULL)
+ type = Type::make_function_type(NULL, NULL, NULL, location);
+
+ // For a function literal, the next token must be a '{'. If we
+ // don't see that, then we may have a type expression.
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ return Expression::make_type(type, location);
+
+ Bc_stack* hold_break_stack = this->break_stack_;
+ Bc_stack* hold_continue_stack = this->continue_stack_;
+ this->break_stack_ = NULL;
+ this->continue_stack_ = NULL;
+
+ Named_object* no = this->gogo_->start_function("", type, true, location);
+
+ source_location end_loc = this->block();
+
+ this->gogo_->finish_function(end_loc);
+
+ if (this->break_stack_ != NULL)
+ delete this->break_stack_;
+ if (this->continue_stack_ != NULL)
+ delete this->continue_stack_;
+ this->break_stack_ = hold_break_stack;
+ this->continue_stack_ = hold_continue_stack;
+
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Expression* closure = this->create_closure(no, &hold_enclosing_vars,
+ location);
+
+ return Expression::make_func_reference(no, closure, location);
+}
+
+// Create a closure for the nested function FUNCTION. This is based
+// on ENCLOSING_VARS, which is a list of all variables defined in
+// enclosing functions and referenced from FUNCTION. A closure is the
+// address of a struct which contains the addresses of all the
+// referenced variables. This returns NULL if no closure is required.
+
+Expression*
+Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
+ source_location location)
+{
+ if (enclosing_vars->empty())
+ return NULL;
+
+ // Get the variables in order by their field index.
+
+ size_t enclosing_var_count = enclosing_vars->size();
+ std::vector<Enclosing_var> ev(enclosing_var_count);
+ for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
+ p != enclosing_vars->end();
+ ++p)
+ ev[p->index()] = *p;
+
+ // Build an initializer for a composite literal of the closure's
+ // type.
+
+ Named_object* enclosing_function = this->gogo_->current_function();
+ Expression_list* initializer = new Expression_list;
+ for (size_t i = 0; i < enclosing_var_count; ++i)
+ {
+ go_assert(ev[i].index() == i);
+ Named_object* var = ev[i].var();
+ Expression* ref;
+ if (ev[i].in_function() == enclosing_function)
+ ref = Expression::make_var_reference(var, location);
+ else
+ ref = this->enclosing_var_reference(ev[i].in_function(), var,
+ location);
+ Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
+ location);
+ initializer->push_back(refaddr);
+ }
+
+ Named_object* closure_var = function->func_value()->closure_var();
+ Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
+ Expression* cv = Expression::make_struct_composite_literal(st, initializer,
+ location);
+ return Expression::make_heap_composite(cv, location);
+}
+
+// PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ source_location start_loc = this->location();
+ bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
+
+ Expression* ret = this->operand(may_be_sink);
+
+ // An unknown name followed by a curly brace must be a composite
+ // literal, and the unknown name must be a type.
+ if (may_be_composite_lit
+ && !is_parenthesized
+ && ret->unknown_expression() != NULL
+ && this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ Named_object* no = ret->unknown_expression()->named_object();
+ Type* type = Type::make_forward_declaration(no);
+ ret = Expression::make_type(type, ret->location());
+ }
+
+ // We handle composite literals and type casts here, as it is the
+ // easiest way to handle types which are in parentheses, as in
+ // "((uint))(1)".
+ if (ret->is_type_expression())
+ {
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (is_parenthesized)
+ error_at(start_loc,
+ "cannot parenthesize type in composite literal");
+ ret = this->composite_lit(ret->type(), 0, ret->location());
+ }
+ else if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ source_location loc = this->location();
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ NULL);
+ if (this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ {
+ error_at(this->location(),
+ "invalid use of %<...%> in type conversion");
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+ if (expr->is_error_expression())
+ return expr;
+ ret = Expression::make_cast(ret->type(), expr, loc);
+ }
+ }
+
+ while (true)
+ {
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ret = this->call(this->verify_not_sink(ret));
+ else if (token->is_op(OPERATOR_DOT))
+ {
+ ret = this->selector(this->verify_not_sink(ret), is_type_switch);
+ if (is_type_switch != NULL && *is_type_switch)
+ break;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ ret = this->index(this->verify_not_sink(ret));
+ else
+ break;
+ }
+
+ return ret;
+}
+
+// Selector = "." identifier .
+// TypeGuard = "." "(" QualifiedIdent ")" .
+
+// Note that Operand can expand to QualifiedIdent, which contains a
+// ".". That is handled directly in operand when it sees a package
+// name.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::selector(Expression* left, bool* is_type_switch)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_DOT));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ if (token->is_identifier())
+ {
+ // This could be a field in a struct, or a method in an
+ // interface, or a method associated with a type. We can't know
+ // which until we have seen all the types.
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ if (token->identifier() == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = this->gogo_->pack_hidden_name("blank", false);
+ }
+ this->advance_token();
+ return Expression::make_selector(left, name, location);
+ }
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* type = NULL;
+ if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
+ type = this->type();
+ else
+ {
+ if (is_type_switch != NULL)
+ *is_type_switch = true;
+ else
+ {
+ error_at(this->location(),
+ "use of %<.(type)%> outside type switch");
+ type = Type::make_error_type();
+ }
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+ return Expression::make_type_guard(left, type, location);
+ }
+ else
+ {
+ error_at(this->location(), "expected identifier or %<(%>");
+ return left;
+ }
+}
+
+// Index = "[" Expression "]" .
+// Slice = "[" Expression ":" [ Expression ] "]" .
+
+Expression*
+Parse::index(Expression* expr)
+{
+ source_location location = this->location();
+ go_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ this->advance_token();
+
+ Expression* start;
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ mpz_t zero;
+ mpz_init_set_ui(zero, 0);
+ start = Expression::make_integer(&zero, NULL, location);
+ mpz_clear(zero);
+ }
+
+ Expression* end = NULL;
+ if (this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ // We use nil to indicate a missing high expression.
+ if (this->advance_token()->is_op(OPERATOR_RSQUARE))
+ end = Expression::make_nil(this->location());
+ else
+ end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ error_at(this->location(), "missing %<]%>");
+ else
+ this->advance_token();
+ return Expression::make_index(expr, start, end, location);
+}
+
+// Call = "(" [ ArgumentList [ "," ] ] ")" .
+// ArgumentList = ExpressionList [ "..." ] .
+
+Expression*
+Parse::call(Expression* func)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+ Expression_list* args = NULL;
+ bool is_varargs = false;
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ args = this->expression_list(NULL, false);
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_ELLIPSIS))
+ {
+ is_varargs = true;
+ token = this->advance_token();
+ }
+ }
+ if (token->is_op(OPERATOR_COMMA))
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (func->is_error_expression())
+ return func;
+ return Expression::make_call(func, args, is_varargs, func->location());
+}
+
+// Return an expression for a single unqualified identifier.
+
+Expression*
+Parse::id_to_expression(const std::string& name, source_location location)
+{
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(name, &in_function);
+ if (named_object == NULL)
+ named_object = this->gogo_->add_unknown_name(name, location);
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable() || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ return Expression::make_sink(location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL, location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ error_at(this->location(), "unexpected type of identifier");
+ return Expression::make_error(location);
+ }
+}
+
+// Expression = UnaryExpr { binary_op Expression } .
+
+// PRECEDENCE is the precedence of the current operator.
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::expression(Precedence precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch)
+{
+ Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+
+ while (true)
+ {
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+
+ const Token* token = this->peek_token();
+ if (token->classification() != Token::TOKEN_OPERATOR)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Precedence right_precedence;
+ switch (token->op())
+ {
+ case OPERATOR_OROR:
+ right_precedence = PRECEDENCE_OROR;
+ break;
+ case OPERATOR_ANDAND:
+ right_precedence = PRECEDENCE_ANDAND;
+ break;
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ right_precedence = PRECEDENCE_RELOP;
+ break;
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ right_precedence = PRECEDENCE_ADDOP;
+ break;
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ right_precedence = PRECEDENCE_MULOP;
+ break;
+ default:
+ right_precedence = PRECEDENCE_INVALID;
+ break;
+ }
+
+ if (right_precedence == PRECEDENCE_INVALID)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Operator op = token->op();
+ source_location binop_location = token->location();
+
+ if (precedence >= right_precedence)
+ {
+ // We've already seen A * B, and we see + C. We want to
+ // return so that A * B becomes a group.
+ return left;
+ }
+
+ this->advance_token();
+
+ left = this->verify_not_sink(left);
+ Expression* right = this->expression(right_precedence, false,
+ may_be_composite_lit,
+ NULL);
+ left = Expression::make_binary(op, left, right, binop_location);
+ }
+}
+
+bool
+Parse::expression_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_INVALID:
+ case Token::TOKEN_EOF:
+ return false;
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_CHAN:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+ case Token::TOKEN_STRING:
+ return true;
+ case Token::TOKEN_OPERATOR:
+ switch (token->op())
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_CHANOP:
+ case OPERATOR_AND:
+ case OPERATOR_LPAREN:
+ case OPERATOR_LSQUARE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+ default:
+ go_unreachable();
+ }
+}
+
+// UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_PLUS)
+ || token->is_op(OPERATOR_MINUS)
+ || token->is_op(OPERATOR_NOT)
+ || token->is_op(OPERATOR_XOR)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_AND))
+ {
+ source_location location = token->location();
+ Operator op = token->op();
+ this->advance_token();
+
+ if (op == OPERATOR_CHANOP
+ && this->peek_token()->is_keyword(KEYWORD_CHAN))
+ {
+ // This is "<- chan" which must be the start of a type.
+ this->unget_token(Token::make_operator_token(op, location));
+ return Expression::make_type(this->type(), location);
+ }
+
+ Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
+ if (expr->is_error_expression())
+ ;
+ else if (op == OPERATOR_MULT && expr->is_type_expression())
+ expr = Expression::make_type(Type::make_pointer_type(expr->type()),
+ location);
+ else if (op == OPERATOR_AND && expr->is_composite_literal())
+ expr = Expression::make_heap_composite(expr, location);
+ else if (op != OPERATOR_CHANOP)
+ expr = Expression::make_unary(op, expr, location);
+ else
+ expr = Expression::make_receive(expr, location);
+ return expr;
+ }
+ else
+ return this->primary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+}
+
+// Statement =
+// Declaration | LabeledStmt | SimpleStmt |
+// GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
+// FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
+// DeferStmt .
+
+// LABEL is the label of this statement if it has one.
+
+void
+Parse::statement(Label* label)
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ this->declaration();
+ break;
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ this->simple_stat(true, NULL, NULL, NULL);
+ break;
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ this->go_or_defer_stat();
+ break;
+ case KEYWORD_RETURN:
+ this->return_stat();
+ break;
+ case KEYWORD_BREAK:
+ this->break_stat();
+ break;
+ case KEYWORD_CONTINUE:
+ this->continue_stat();
+ break;
+ case KEYWORD_GOTO:
+ this->goto_stat();
+ break;
+ case KEYWORD_IF:
+ this->if_stat();
+ break;
+ case KEYWORD_SWITCH:
+ this->switch_stat(label);
+ break;
+ case KEYWORD_SELECT:
+ this->select_stat(label);
+ break;
+ case KEYWORD_FOR:
+ this->for_stat(label);
+ break;
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ if (this->advance_token()->is_op(OPERATOR_COLON))
+ {
+ this->advance_token();
+ this->labeled_stmt(identifier, location);
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ location));
+ this->simple_stat(true, NULL, NULL, NULL);
+ }
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY))
+ {
+ source_location location = token->location();
+ this->gogo_->start_block(location);
+ source_location end_loc = this->block();
+ this->gogo_->add_block(this->gogo_->finish_block(end_loc),
+ location);
+ }
+ else if (!token->is_op(OPERATOR_SEMICOLON))
+ this->simple_stat(true, NULL, NULL, NULL);
+ break;
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ this->simple_stat(true, NULL, NULL, NULL);
+ break;
+
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+}
+
+bool
+Parse::statement_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ case KEYWORD_RETURN:
+ case KEYWORD_BREAK:
+ case KEYWORD_CONTINUE:
+ case KEYWORD_GOTO:
+ case KEYWORD_IF:
+ case KEYWORD_SWITCH:
+ case KEYWORD_SELECT:
+ case KEYWORD_FOR:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY)
+ || token->is_op(OPERATOR_SEMICOLON))
+ return true;
+ else
+ return this->expression_may_start_here();
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+// LabeledStmt = Label ":" Statement .
+// Label = identifier .
+
+void
+Parse::labeled_stmt(const std::string& label_name, source_location location)
+{
+ Label* label = this->gogo_->add_label_definition(label_name, location);
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ // This is a label at the end of a block. A program is
+ // permitted to omit a semicolon here.
+ return;
+ }
+
+ if (!this->statement_may_start_here())
+ {
+ // Mark the label as used to avoid a useless error about an
+ // unused label.
+ label->set_is_used();
+
+ error_at(location, "missing statement after label");
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ location));
+ return;
+ }
+
+ this->statement(label);
+}
+
+// SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
+// Assignment | ShortVarDecl .
+
+// EmptyStmt was handled in Parse::statement.
+
+// In order to make this work for if and switch statements, if
+// RETURN_EXP is not NULL, and we see an ExpressionStat, we return the
+// expression rather than adding an expression statement to the
+// current block. If we see something other than an ExpressionStat,
+// we add the statement, set *RETURN_EXP to true if we saw a send
+// statement, and return NULL. The handling of send statements is for
+// better error messages.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::simple_stat(bool may_be_composite_lit, bool* return_exp,
+ Range_clause* p_range_clause, Type_switch* p_type_switch)
+{
+ const Token* token = this->peek_token();
+
+ // An identifier follow by := is a SimpleVarDecl.
+ if (token->is_identifier())
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ)
+ || token->is_op(OPERATOR_COMMA))
+ {
+ identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
+ this->simple_var_decl_or_assignment(identifier, location,
+ p_range_clause,
+ (token->is_op(OPERATOR_COLONEQ)
+ ? p_type_switch
+ : NULL));
+ return NULL;
+ }
+
+ this->unget_token(Token::make_identifier_token(identifier, is_exported,
+ location));
+ }
+
+ Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
+ may_be_composite_lit,
+ (p_type_switch == NULL
+ ? NULL
+ : &p_type_switch->found));
+ if (p_type_switch != NULL && p_type_switch->found)
+ {
+ p_type_switch->name.clear();
+ p_type_switch->location = exp->location();
+ p_type_switch->expr = this->verify_not_sink(exp);
+ return NULL;
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_CHANOP))
+ {
+ this->send_stmt(this->verify_not_sink(exp));
+ if (return_exp != NULL)
+ *return_exp = true;
+ }
+ else if (token->is_op(OPERATOR_PLUSPLUS)
+ || token->is_op(OPERATOR_MINUSMINUS))
+ this->inc_dec_stat(this->verify_not_sink(exp));
+ else if (token->is_op(OPERATOR_COMMA)
+ || token->is_op(OPERATOR_EQ))
+ this->assignment(exp, p_range_clause);
+ else if (token->is_op(OPERATOR_PLUSEQ)
+ || token->is_op(OPERATOR_MINUSEQ)
+ || token->is_op(OPERATOR_OREQ)
+ || token->is_op(OPERATOR_XOREQ)
+ || token->is_op(OPERATOR_MULTEQ)
+ || token->is_op(OPERATOR_DIVEQ)
+ || token->is_op(OPERATOR_MODEQ)
+ || token->is_op(OPERATOR_LSHIFTEQ)
+ || token->is_op(OPERATOR_RSHIFTEQ)
+ || token->is_op(OPERATOR_ANDEQ)
+ || token->is_op(OPERATOR_BITCLEAREQ))
+ this->assignment(this->verify_not_sink(exp), p_range_clause);
+ else if (return_exp != NULL)
+ return this->verify_not_sink(exp);
+ else
+ this->expression_stat(this->verify_not_sink(exp));
+
+ return NULL;
+}
+
+bool
+Parse::simple_stat_may_start_here()
+{
+ return this->expression_may_start_here();
+}
+
+// Parse { Statement ";" } which is used in a few places. The list of
+// statements may end with a right curly brace, in which case the
+// semicolon may be omitted.
+
+void
+Parse::statement_list()
+{
+ while (this->statement_may_start_here())
+ {
+ this->statement(NULL);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ break;
+ else
+ {
+ if (!this->peek_token()->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return;
+ }
+ }
+}
+
+bool
+Parse::statement_list_may_start_here()
+{
+ return this->statement_may_start_here();
+}
+
+// ExpressionStat = Expression .
+
+void
+Parse::expression_stat(Expression* exp)
+{
+ exp->discarding_value();
+ this->gogo_->add_statement(Statement::make_statement(exp));
+}
+
+// SendStmt = Channel "<-" Expression .
+// Channel = Expression .
+
+void
+Parse::send_stmt(Expression* channel)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_CHANOP));
+ source_location loc = this->location();
+ this->advance_token();
+ Expression* val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ Statement* s = Statement::make_send_statement(channel, val, loc);
+ this->gogo_->add_statement(s);
+}
+
+// IncDecStat = Expression ( "++" | "--" ) .
+
+void
+Parse::inc_dec_stat(Expression* exp)
+{
+ const Token* token = this->peek_token();
+
+ // Lvalue maps require special handling.
+ if (exp->index_expression() != NULL)
+ exp->index_expression()->set_is_lvalue();
+
+ if (token->is_op(OPERATOR_PLUSPLUS))
+ this->gogo_->add_statement(Statement::make_inc_statement(exp));
+ else if (token->is_op(OPERATOR_MINUSMINUS))
+ this->gogo_->add_statement(Statement::make_dec_statement(exp));
+ else
+ go_unreachable();
+ this->advance_token();
+}
+
+// Assignment = ExpressionList assign_op ExpressionList .
+
+// EXP is an expression that we have already parsed.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::assignment(Expression* expr, Range_clause* p_range_clause)
+{
+ Expression_list* vars;
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ vars = new Expression_list();
+ vars->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ vars = this->expression_list(expr, true);
+ }
+
+ this->tuple_assignment(vars, p_range_clause);
+}
+
+// An assignment statement. LHS is the list of expressions which
+// appear on the left hand side.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::tuple_assignment(Expression_list* lhs, Range_clause* p_range_clause)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_EQ)
+ && !token->is_op(OPERATOR_PLUSEQ)
+ && !token->is_op(OPERATOR_MINUSEQ)
+ && !token->is_op(OPERATOR_OREQ)
+ && !token->is_op(OPERATOR_XOREQ)
+ && !token->is_op(OPERATOR_MULTEQ)
+ && !token->is_op(OPERATOR_DIVEQ)
+ && !token->is_op(OPERATOR_MODEQ)
+ && !token->is_op(OPERATOR_LSHIFTEQ)
+ && !token->is_op(OPERATOR_RSHIFTEQ)
+ && !token->is_op(OPERATOR_ANDEQ)
+ && !token->is_op(OPERATOR_BITCLEAREQ))
+ {
+ error_at(this->location(), "expected assignment operator");
+ return;
+ }
+ Operator op = token->op();
+ source_location location = token->location();
+
+ token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ if (op != OPERATOR_EQ)
+ error_at(this->location(), "range clause requires %<=%>");
+ this->range_clause_expr(lhs, p_range_clause);
+ return;
+ }
+
+ Expression_list* vals = this->expression_list(NULL, false);
+
+ // We've parsed everything; check for errors.
+ if (lhs == NULL || vals == NULL)
+ return;
+ for (Expression_list::const_iterator pe = lhs->begin();
+ pe != lhs->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
+ error_at((*pe)->location(), "cannot use _ as value");
+ }
+ for (Expression_list::const_iterator pe = vals->begin();
+ pe != vals->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ }
+
+ // Map expressions act differently when they are lvalues.
+ for (Expression_list::iterator plv = lhs->begin();
+ plv != lhs->end();
+ ++plv)
+ if ((*plv)->index_expression() != NULL)
+ (*plv)->index_expression()->set_is_lvalue();
+
+ Call_expression* call;
+ Index_expression* map_index;
+ Receive_expression* receive;
+ Type_guard_expression* type_guard;
+ if (lhs->size() == vals->size())
+ {
+ Statement* s;
+ if (lhs->size() > 1)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple values only permitted with %<=%>");
+ s = Statement::make_tuple_assignment(lhs, vals, location);
+ }
+ else
+ {
+ if (op == OPERATOR_EQ)
+ s = Statement::make_assignment(lhs->front(), vals->front(),
+ location);
+ else
+ s = Statement::make_assignment_operation(op, lhs->front(),
+ vals->front(), location);
+ delete lhs;
+ delete vals;
+ }
+ this->gogo_->add_statement(s);
+ }
+ else if (vals->size() == 1
+ && (call = (*vals->begin())->call_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple results only permitted with %<=%>");
+ delete vals;
+ vals = new Expression_list;
+ for (unsigned int i = 0; i < lhs->size(); ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ Statement* s = Statement::make_tuple_assignment(lhs, vals, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (map_index = (*vals->begin())->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from map requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* present = lhs->back();
+ Statement* s = Statement::make_tuple_map_assignment(val, present,
+ map_index, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 1
+ && vals->size() == 2
+ && (map_index = lhs->front()->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "assigning tuple to map index requires %<=%>");
+ Expression* val = vals->front();
+ Expression* should_set = vals->back();
+ Statement* s = Statement::make_map_assignment(map_index, val, should_set,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (receive = (*vals->begin())->receive_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from receive requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* success = lhs->back();
+ Expression* channel = receive->channel();
+ Statement* s = Statement::make_tuple_receive_assignment(val, success,
+ channel,
+ false,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (type_guard = (*vals->begin())->type_guard_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from type guard requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* ok = lhs->back();
+ Expression* expr = type_guard->expr();
+ Type* type = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val, ok,
+ expr, type,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else
+ {
+ error_at(location, "number of variables does not match number of values");
+ }
+}
+
+// GoStat = "go" Expression .
+// DeferStat = "defer" Expression .
+
+void
+Parse::go_or_defer_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_GO)
+ || this->peek_token()->is_keyword(KEYWORD_DEFER));
+ bool is_go = this->peek_token()->is_keyword(KEYWORD_GO);
+ source_location stat_location = this->location();
+ this->advance_token();
+ source_location expr_location = this->location();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ Call_expression* call_expr = expr->call_expression();
+ if (call_expr == NULL)
+ {
+ error_at(expr_location, "expected call expression");
+ return;
+ }
+
+ // Make it easier to simplify go/defer statements by putting every
+ // statement in its own block.
+ this->gogo_->start_block(stat_location);
+ Statement* stat;
+ if (is_go)
+ stat = Statement::make_go_statement(call_expr, stat_location);
+ else
+ stat = Statement::make_defer_statement(call_expr, stat_location);
+ this->gogo_->add_statement(stat);
+ this->gogo_->add_block(this->gogo_->finish_block(stat_location),
+ stat_location);
+}
+
+// ReturnStat = "return" [ ExpressionList ] .
+
+void
+Parse::return_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_RETURN));
+ source_location location = this->location();
+ this->advance_token();
+ Expression_list* vals = NULL;
+ if (this->expression_may_start_here())
+ vals = this->expression_list(NULL, false);
+ this->gogo_->add_statement(Statement::make_return_statement(vals, location));
+}
+
+// IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" Statement ] .
+
+void
+Parse::if_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_IF));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ bool saw_simple_stat = false;
+ Expression* cond = NULL;
+ bool saw_send_stmt;
+ if (this->simple_stat_may_start_here())
+ {
+ cond = this->simple_stat(false, &saw_send_stmt, NULL, NULL);
+ saw_simple_stat = true;
+ }
+ if (cond != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+ if (cond == NULL)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (saw_simple_stat)
+ {
+ if (saw_send_stmt)
+ error_at(this->location(),
+ ("send statement used as value; "
+ "use select for non-blocking send"));
+ else
+ error_at(this->location(),
+ "expected %<;%> after statement in if expression");
+ if (!this->expression_may_start_here())
+ cond = Expression::make_error(this->location());
+ }
+ if (cond == NULL && this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ error_at(this->location(),
+ "missing condition in if statement");
+ cond = Expression::make_error(this->location());
+ }
+ if (cond == NULL)
+ cond = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ }
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* then_block = this->gogo_->finish_block(end_loc);
+
+ // Check for the easy error of a newline before "else".
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_keyword(KEYWORD_ELSE))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<else%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ Block* else_block = NULL;
+ if (this->peek_token()->is_keyword(KEYWORD_ELSE))
+ {
+ this->advance_token();
+ // We create a block to gather the statement.
+ this->gogo_->start_block(this->location());
+ this->statement(NULL);
+ else_block = this->gogo_->finish_block(this->location());
+ }
+
+ this->gogo_->add_statement(Statement::make_if_statement(cond, then_block,
+ else_block,
+ location));
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
+// ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
+// "{" { ExprCaseClause } "}" .
+// TypeSwitchStmt = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
+// "{" { TypeCaseClause } "}" .
+// TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
+
+void
+Parse::switch_stat(Label* label)
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ bool saw_simple_stat = false;
+ Expression* switch_val = NULL;
+ bool saw_send_stmt;
+ Type_switch type_switch;
+ if (this->simple_stat_may_start_here())
+ {
+ switch_val = this->simple_stat(false, &saw_send_stmt, NULL,
+ &type_switch);
+ saw_simple_stat = true;
+ }
+ if (switch_val != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(switch_val);
+ switch_val = NULL;
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (saw_simple_stat)
+ {
+ if (saw_send_stmt)
+ error_at(this->location(),
+ ("send statement used as value; "
+ "use select for non-blocking send"));
+ else
+ error_at(this->location(),
+ "expected %<;%> after statement in switch expression");
+ }
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (this->peek_token()->is_identifier())
+ {
+ const Token* token = this->peek_token();
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location id_loc = token->location();
+
+ token = this->advance_token();
+ bool is_coloneq = token->is_op(OPERATOR_COLONEQ);
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ id_loc));
+ if (is_coloneq)
+ {
+ // This must be a TypeSwitchGuard.
+ switch_val = this->simple_stat(false, &saw_send_stmt, NULL,
+ &type_switch);
+ if (!type_switch.found)
+ {
+ if (switch_val == NULL
+ || !switch_val->is_error_expression())
+ {
+ error_at(id_loc, "expected type switch assignment");
+ switch_val = Expression::make_error(id_loc);
+ }
+ }
+ }
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ switch_val = this->expression(PRECEDENCE_NORMAL, false, false,
+ &type_switch.found);
+ if (type_switch.found)
+ {
+ type_switch.name.clear();
+ type_switch.expr = switch_val;
+ type_switch.location = switch_val->location();
+ }
+ }
+ }
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else if (this->peek_token()->is_op(OPERATOR_COLONEQ))
+ {
+ error_at(token_loc, "invalid variable name");
+ this->advance_token();
+ this->expression(PRECEDENCE_NORMAL, false, false,
+ &type_switch.found);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ return;
+ if (type_switch.found)
+ type_switch.expr = Expression::make_error(location);
+ }
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+ return;
+ }
+ }
+ this->advance_token();
+
+ Statement* statement;
+ if (type_switch.found)
+ statement = this->type_switch_body(label, type_switch, location);
+ else
+ statement = this->expr_switch_body(label, switch_val, location);
+
+ if (statement != NULL)
+ this->gogo_->add_statement(statement);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// The body of an expression switch.
+// "{" { ExprCaseClause } "}"
+
+Statement*
+Parse::expr_switch_body(Label* label, Expression* switch_val,
+ source_location location)
+{
+ Switch_statement* statement = Statement::make_switch_statement(switch_val,
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Case_clauses* case_clauses = new Case_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ if (!saw_errors())
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->expr_case_clause(case_clauses, &saw_default);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
+// FallthroughStat = "fallthrough" .
+
+void
+Parse::expr_case_clause(Case_clauses* clauses, bool* saw_default)
+{
+ source_location location = this->location();
+
+ bool is_default = false;
+ Expression_list* vals = this->expr_switch_case(&is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<:%>");
+ return;
+ }
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ bool is_fallthrough = false;
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ is_fallthrough = true;
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default)
+ {
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in switch");
+ return;
+ }
+ *saw_default = true;
+ }
+
+ if (is_default || vals != NULL)
+ clauses->add(vals, is_default, statements, is_fallthrough, location);
+}
+
+// ExprSwitchCase = "case" ExpressionList | "default" .
+
+Expression_list*
+Parse::expr_switch_case(bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ return this->expression_list(NULL, false);
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ return NULL;
+ }
+ else
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return NULL;
+ }
+}
+
+// The body of a type switch.
+// "{" { TypeCaseClause } "}" .
+
+Statement*
+Parse::type_switch_body(Label* label, const Type_switch& type_switch,
+ source_location location)
+{
+ Named_object* switch_no = NULL;
+ if (!type_switch.name.empty())
+ {
+ Variable* switch_var = new Variable(NULL, type_switch.expr, false, false,
+ false, type_switch.location);
+ switch_no = this->gogo_->add_variable(type_switch.name, switch_var);
+ }
+
+ Type_switch_statement* statement =
+ Statement::make_type_switch_statement(switch_no,
+ (switch_no == NULL
+ ? type_switch.expr
+ : NULL),
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Type_case_clauses* case_clauses = new Type_case_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->type_case_clause(switch_no, case_clauses, &saw_default);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// TypeCaseClause = TypeSwitchCase ":" [ StatementList ] .
+
+void
+Parse::type_case_clause(Named_object* switch_no, Type_case_clauses* clauses,
+ bool* saw_default)
+{
+ source_location location = this->location();
+
+ std::vector<Type*> types;
+ bool is_default = false;
+ this->type_switch_case(&types, &is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ error_at(this->location(), "expected %<:%>");
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ if (switch_no != NULL && types.size() == 1)
+ {
+ Type* type = types.front();
+ Expression* init = Expression::make_var_reference(switch_no,
+ location);
+ init = Expression::make_type_guard(init, type, location);
+ Variable* v = new Variable(type, init, false, false, false,
+ location);
+ v->set_is_type_switch_var();
+ this->gogo_->add_variable(switch_no->name(), v);
+ }
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ error_at(this->location(),
+ "fallthrough is not permitted in a type switch");
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default)
+ {
+ go_assert(types.empty());
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in type switch");
+ return;
+ }
+ *saw_default = true;
+ clauses->add(NULL, false, true, statements, location);
+ }
+ else if (!types.empty())
+ {
+ for (std::vector<Type*>::const_iterator p = types.begin();
+ p + 1 != types.end();
+ ++p)
+ clauses->add(*p, true, false, NULL, location);
+ clauses->add(types.back(), false, false, statements, location);
+ }
+ else
+ clauses->add(Type::make_error_type(), false, false, statements, location);
+}
+
+// TypeSwitchCase = "case" type | "default"
+
+// We accept a comma separated list of types.
+
+void
+Parse::type_switch_case(std::vector<Type*>* types, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ while (true)
+ {
+ Type* t = this->type();
+ if (!t->is_error_type())
+ types->push_back(t);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ }
+}
+
+// SelectStat = "select" "{" { CommClause } "}" .
+
+void
+Parse::select_stat(Label* label)
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_SELECT));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = token->location();
+ if (token->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return;
+ }
+ }
+ this->advance_token();
+
+ Select_statement* statement = Statement::make_select_statement(location);
+
+ this->push_break_statement(statement, label);
+
+ Select_clauses* select_clauses = new Select_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "expected %<}%>");
+ return;
+ }
+ this->comm_clause(select_clauses, &saw_default);
+ }
+
+ this->advance_token();
+
+ statement->add_clauses(select_clauses);
+
+ this->pop_break_statement();
+
+ this->gogo_->add_statement(statement);
+}
+
+// CommClause = CommCase ":" { Statement ";" } .
+
+void
+Parse::comm_clause(Select_clauses* clauses, bool* saw_default)
+{
+ source_location location = this->location();
+ bool is_send = false;
+ Expression* channel = NULL;
+ Expression* val = NULL;
+ Expression* closed = NULL;
+ std::string varname;
+ std::string closedname;
+ bool is_default = false;
+ bool got_case = this->comm_case(&is_send, &channel, &val, &closed,
+ &varname, &closedname, &is_default);
+
+ if (!is_send
+ && varname.empty()
+ && closedname.empty()
+ && val != NULL
+ && val->index_expression() != NULL)
+ val->index_expression()->set_is_lvalue();
+
+ if (this->peek_token()->is_op(OPERATOR_COLON))
+ this->advance_token();
+ else
+ error_at(this->location(), "expected colon");
+
+ this->gogo_->start_block(this->location());
+
+ Named_object* var = NULL;
+ if (!varname.empty())
+ {
+ // FIXME: LOCATION is slightly wrong here.
+ Variable* v = new Variable(NULL, channel, false, false, false,
+ location);
+ v->set_type_from_chan_element();
+ var = this->gogo_->add_variable(varname, v);
+ }
+
+ Named_object* closedvar = NULL;
+ if (!closedname.empty())
+ {
+ // FIXME: LOCATION is slightly wrong here.
+ Variable* v = new Variable(Type::lookup_bool_type(), NULL,
+ false, false, false, location);
+ closedvar = this->gogo_->add_variable(closedname, v);
+ }
+
+ this->statement_list();
+
+ Block* statements = this->gogo_->finish_block(this->location());
+
+ if (is_default)
+ {
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in select");
+ return;
+ }
+ *saw_default = true;
+ }
+
+ if (got_case)
+ clauses->add(is_send, channel, val, closed, var, closedvar, is_default,
+ statements, location);
+ else if (statements != NULL)
+ {
+ // Add the statements to make sure that any names they define
+ // are traversed.
+ this->gogo_->add_block(statements, location);
+ }
+}
+
+// CommCase = "case" ( SendStmt | RecvStmt ) | "default" .
+
+bool
+Parse::comm_case(bool* is_send, Expression** channel, Expression** val,
+ Expression** closed, std::string* varname,
+ std::string* closedname, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ if (!this->send_or_recv_stmt(is_send, channel, val, closed, varname,
+ closedname))
+ return false;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return false;
+ }
+
+ return true;
+}
+
+// RecvStmt = [ Expression [ "," Expression ] ( "=" | ":=" ) ] RecvExpr .
+// RecvExpr = Expression .
+
+bool
+Parse::send_or_recv_stmt(bool* is_send, Expression** channel, Expression** val,
+ Expression** closed, std::string* varname,
+ std::string* closedname)
+{
+ const Token* token = this->peek_token();
+ bool saw_comma = false;
+ bool closed_is_id = false;
+ if (token->is_identifier())
+ {
+ Gogo* gogo = this->gogo_;
+ std::string recv_var = token->identifier();
+ bool is_rv_exported = token->is_identifier_exported();
+ source_location recv_var_loc = token->location();
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ // case rv := <-c:
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "expected %<<-%>");
+ return false;
+ }
+ if (recv_var == "_")
+ {
+ error_at(recv_var_loc,
+ "no new variables on left side of %<:=%>");
+ recv_var = "blank";
+ }
+ *is_send = false;
+ *varname = gogo->pack_hidden_name(recv_var, is_rv_exported);
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+ else if (token->is_op(OPERATOR_COMMA))
+ {
+ token = this->advance_token();
+ if (token->is_identifier())
+ {
+ std::string recv_closed = token->identifier();
+ bool is_rc_exported = token->is_identifier_exported();
+ source_location recv_closed_loc = token->location();
+ closed_is_id = true;
+
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ // case rv, rc := <-c:
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "expected %<<-%>");
+ return false;
+ }
+ if (recv_var == "_" && recv_closed == "_")
+ {
+ error_at(recv_var_loc,
+ "no new variables on left side of %<:=%>");
+ recv_var = "blank";
+ }
+ *is_send = false;
+ if (recv_var != "_")
+ *varname = gogo->pack_hidden_name(recv_var,
+ is_rv_exported);
+ if (recv_closed != "_")
+ *closedname = gogo->pack_hidden_name(recv_closed,
+ is_rc_exported);
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true,
+ NULL);
+ return true;
+ }
+
+ this->unget_token(Token::make_identifier_token(recv_closed,
+ is_rc_exported,
+ recv_closed_loc));
+ }
+
+ *val = this->id_to_expression(gogo->pack_hidden_name(recv_var,
+ is_rv_exported),
+ recv_var_loc);
+ saw_comma = true;
+ }
+ else
+ this->unget_token(Token::make_identifier_token(recv_var,
+ is_rv_exported,
+ recv_var_loc));
+ }
+
+ // If SAW_COMMA is false, then we are looking at the start of the
+ // send or receive expression. If SAW_COMMA is true, then *VAL is
+ // set and we just read a comma.
+
+ Expression* e;
+ if (saw_comma || !this->peek_token()->is_op(OPERATOR_CHANOP))
+ e = this->expression(PRECEDENCE_NORMAL, true, true, NULL);
+ else
+ {
+ // case <-c:
+ *is_send = false;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+
+ // The next token should be ':'. If it is '<-', then we have
+ // case <-c <- v:
+ // which is to say, send on a channel received from a channel.
+ if (!this->peek_token()->is_op(OPERATOR_CHANOP))
+ return true;
+
+ e = Expression::make_receive(*channel, (*channel)->location());
+ }
+
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "missing %<<-%>");
+ return false;
+ }
+ *is_send = false;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (saw_comma)
+ {
+ // case v, e = <-c:
+ // *VAL is already set.
+ if (!e->is_sink_expression())
+ *closed = e;
+ }
+ else
+ {
+ // case v = <-c:
+ if (!e->is_sink_expression())
+ *val = e;
+ }
+ return true;
+ }
+
+ if (saw_comma)
+ {
+ if (closed_is_id)
+ error_at(this->location(), "expected %<=%> or %<:=%>");
+ else
+ error_at(this->location(), "expected %<=%>");
+ return false;
+ }
+
+ if (this->peek_token()->is_op(OPERATOR_CHANOP))
+ {
+ // case c <- v:
+ *is_send = true;
+ *channel = this->verify_not_sink(e);
+ this->advance_token();
+ *val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+
+ error_at(this->location(), "expected %<<-%> or %<=%>");
+ return false;
+}
+
+// ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
+// Condition = Expression .
+
+void
+Parse::for_stat(Label* label)
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_FOR));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ // Open a block to hold any variables defined in the init statement
+ // of the for statement.
+ this->gogo_->start_block(location);
+
+ Block* init = NULL;
+ Expression* cond = NULL;
+ Block* post = NULL;
+ Range_clause range_clause;
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ if (token->is_keyword(KEYWORD_VAR))
+ {
+ error_at(this->location(),
+ "var declaration not allowed in for initializer");
+ this->var_decl();
+ }
+
+ if (token->is_op(OPERATOR_SEMICOLON))
+ this->for_clause(&cond, &post);
+ else
+ {
+ // We might be looking at a Condition, an InitStat, or a
+ // RangeClause.
+ bool saw_send_stmt;
+ cond = this->simple_stat(false, &saw_send_stmt, &range_clause, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (cond == NULL && !range_clause.found)
+ {
+ if (saw_send_stmt)
+ error_at(this->location(),
+ ("send statement used as value; "
+ "use select for non-blocking send"));
+ else
+ error_at(this->location(), "parse error in for statement");
+ }
+ }
+ else
+ {
+ if (range_clause.found)
+ error_at(this->location(), "parse error after range clause");
+
+ if (cond != NULL)
+ {
+ // COND is actually an expression statement for
+ // InitStat at the start of a ForClause.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+
+ this->for_clause(&cond, &post);
+ }
+ }
+ }
+
+ // Build the For_statement and note that it is the current target
+ // for break and continue statements.
+
+ For_statement* sfor;
+ For_range_statement* srange;
+ Statement* s;
+ if (!range_clause.found)
+ {
+ sfor = Statement::make_for_statement(init, cond, post, location);
+ s = sfor;
+ srange = NULL;
+ }
+ else
+ {
+ srange = Statement::make_for_range_statement(range_clause.index,
+ range_clause.value,
+ range_clause.range,
+ location);
+ s = srange;
+ sfor = NULL;
+ }
+
+ this->push_break_statement(s, label);
+ this->push_continue_statement(s, label);
+
+ // Gather the block of statements in the loop and add them to the
+ // For_statement.
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* statements = this->gogo_->finish_block(end_loc);
+
+ if (sfor != NULL)
+ sfor->add_statements(statements);
+ else
+ srange->add_statements(statements);
+
+ // This is no longer the break/continue target.
+ this->pop_break_statement();
+ this->pop_continue_statement();
+
+ // Add the For_statement to the list of statements, and close out
+ // the block we started to hold any variables defined in the for
+ // statement.
+
+ this->gogo_->add_statement(s);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
+// InitStat = SimpleStat .
+// PostStat = SimpleStat .
+
+// We have already read InitStat at this point.
+
+void
+Parse::for_clause(Expression** cond, Block** post)
+{
+ go_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON));
+ this->advance_token();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ *cond = NULL;
+ else if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ *cond = NULL;
+ *post = NULL;
+ return;
+ }
+ else
+ *cond = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ error_at(this->location(), "expected semicolon");
+ else
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ *post = NULL;
+ else
+ {
+ this->gogo_->start_block(this->location());
+ this->simple_stat(false, NULL, NULL, NULL);
+ *post = this->gogo_->finish_block(this->location());
+ }
+}
+
+// RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
+
+// This is the := version. It is called with a list of identifiers.
+
+void
+Parse::range_clause_decl(const Typed_identifier_list* til,
+ Range_clause* p_range_clause)
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+ source_location location = this->location();
+
+ p_range_clause->found = true;
+
+ go_assert(til->size() >= 1);
+ if (til->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ p_range_clause->range = expr;
+
+ bool any_new = false;
+
+ const Typed_identifier* pti = &til->front();
+ Named_object* no = this->init_var(*pti, NULL, expr, true, true, &any_new);
+ if (any_new && no->is_variable())
+ no->var_value()->set_type_from_range_index();
+ p_range_clause->index = Expression::make_var_reference(no, location);
+
+ if (til->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ {
+ pti = &til->back();
+ bool is_new = false;
+ no = this->init_var(*pti, NULL, expr, true, true, &is_new);
+ if (is_new && no->is_variable())
+ no->var_value()->set_type_from_range_value();
+ if (is_new)
+ any_new = true;
+ p_range_clause->value = Expression::make_var_reference(no, location);
+ }
+
+ if (!any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// The = version of RangeClause. This is called with a list of
+// expressions.
+
+void
+Parse::range_clause_expr(const Expression_list* vals,
+ Range_clause* p_range_clause)
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+
+ p_range_clause->found = true;
+
+ go_assert(vals->size() >= 1);
+ if (vals->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ p_range_clause->range = this->expression(PRECEDENCE_NORMAL, false, false,
+ NULL);
+
+ p_range_clause->index = vals->front();
+ if (vals->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ p_range_clause->value = vals->back();
+}
+
+// Push a statement on the break stack.
+
+void
+Parse::push_break_statement(Statement* enclosing, Label* label)
+{
+ if (this->break_stack_ == NULL)
+ this->break_stack_ = new Bc_stack();
+ this->break_stack_->push_back(std::make_pair(enclosing, label));
+}
+
+// Push a statement on the continue stack.
+
+void
+Parse::push_continue_statement(Statement* enclosing, Label* label)
+{
+ if (this->continue_stack_ == NULL)
+ this->continue_stack_ = new Bc_stack();
+ this->continue_stack_->push_back(std::make_pair(enclosing, label));
+}
+
+// Pop the break stack.
+
+void
+Parse::pop_break_statement()
+{
+ this->break_stack_->pop_back();
+}
+
+// Pop the continue stack.
+
+void
+Parse::pop_continue_statement()
+{
+ this->continue_stack_->pop_back();
+}
+
+// Find a break or continue statement given a label name.
+
+Statement*
+Parse::find_bc_statement(const Bc_stack* bc_stack, const std::string& label)
+{
+ if (bc_stack == NULL)
+ return NULL;
+ for (Bc_stack::const_reverse_iterator p = bc_stack->rbegin();
+ p != bc_stack->rend();
+ ++p)
+ {
+ if (p->second != NULL && p->second->name() == label)
+ {
+ p->second->set_is_used();
+ return p->first;
+ }
+ }
+ return NULL;
+}
+
+// BreakStat = "break" [ identifier ] .
+
+void
+Parse::break_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_BREAK));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->break_stack_ == NULL || this->break_stack_->empty())
+ {
+ error_at(this->location(),
+ "break statement not within for or switch or select");
+ return;
+ }
+ enclosing = this->break_stack_->back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(this->break_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ // If there is a label with this name, mark it as used to
+ // avoid a useless error about an unused label.
+ this->gogo_->add_label_reference(token->identifier());
+
+ error_at(token->location(), "invalid break label %qs",
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SWITCH)
+ label = enclosing->switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_TYPE_SWITCH)
+ label = enclosing->type_switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SELECT)
+ label = enclosing->select_statement()->break_label();
+ else
+ go_unreachable();
+
+ this->gogo_->add_statement(Statement::make_break_statement(label,
+ location));
+}
+
+// ContinueStat = "continue" [ identifier ] .
+
+void
+Parse::continue_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->continue_stack_ == NULL || this->continue_stack_->empty())
+ {
+ error_at(this->location(), "continue statement not within for");
+ return;
+ }
+ enclosing = this->continue_stack_->back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(this->continue_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ // If there is a label with this name, mark it as used to
+ // avoid a useless error about an unused label.
+ this->gogo_->add_label_reference(token->identifier());
+
+ error_at(token->location(), "invalid continue label %qs",
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->continue_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->continue_label();
+ else
+ go_unreachable();
+
+ this->gogo_->add_statement(Statement::make_continue_statement(label,
+ location));
+}
+
+// GotoStat = "goto" identifier .
+
+void
+Parse::goto_stat()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_GOTO));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ error_at(this->location(), "expected label for goto");
+ else
+ {
+ Label* label = this->gogo_->add_label_reference(token->identifier());
+ Statement* s = Statement::make_goto_statement(label, location);
+ this->gogo_->add_statement(s);
+ this->advance_token();
+ }
+}
+
+// PackageClause = "package" PackageName .
+
+void
+Parse::package_clause()
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ std::string name;
+ if (!token->is_keyword(KEYWORD_PACKAGE))
+ {
+ error_at(this->location(), "program must start with package clause");
+ name = "ERROR";
+ }
+ else
+ {
+ token = this->advance_token();
+ if (token->is_identifier())
+ {
+ name = token->identifier();
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid package name _");
+ name = "blank";
+ }
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(), "package name must be an identifier");
+ name = "ERROR";
+ }
+ }
+ this->gogo_->set_package_name(name, location);
+}
+
+// ImportDecl = "import" Decl<ImportSpec> .
+
+void
+Parse::import_decl()
+{
+ go_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT));
+ this->advance_token();
+ this->decl(&Parse::import_spec, NULL);
+}
+
+// ImportSpec = [ "." | PackageName ] PackageFileName .
+
+void
+Parse::import_spec(void*)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+
+ std::string local_name;
+ bool is_local_name_exported = false;
+ if (token->is_op(OPERATOR_DOT))
+ {
+ local_name = ".";
+ token = this->advance_token();
+ }
+ else if (token->is_identifier())
+ {
+ local_name = token->identifier();
+ is_local_name_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ }
+
+ if (!token->is_string())
+ {
+ error_at(this->location(), "missing import package name");
+ return;
+ }
+
+ this->gogo_->import_package(token->string_value(), local_name,
+ is_local_name_exported, location);
+
+ this->advance_token();
+}
+
+// SourceFile = PackageClause ";" { ImportDecl ";" }
+// { TopLevelDecl ";" } .
+
+void
+Parse::program()
+{
+ this->package_clause();
+
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after package clause");
+
+ while (token->is_keyword(KEYWORD_IMPORT))
+ {
+ this->import_decl();
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after import declaration");
+ }
+
+ while (!token->is_eof())
+ {
+ if (this->declaration_may_start_here())
+ this->declaration();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ do
+ this->advance_token();
+ while (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY));
+ if (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else if (!token->is_eof() || !saw_errors())
+ {
+ if (token->is_op(OPERATOR_CHANOP))
+ error_at(this->location(),
+ ("send statement used as value; "
+ "use select for non-blocking send"));
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after top level declaration");
+ this->skip_past_error(OPERATOR_INVALID);
+ }
+ }
+}
+
+// Reset the current iota value.
+
+void
+Parse::reset_iota()
+{
+ this->iota_ = 0;
+}
+
+// Return the current iota value.
+
+int
+Parse::iota_value()
+{
+ return this->iota_;
+}
+
+// Increment the current iota value.
+
+void
+Parse::increment_iota()
+{
+ ++this->iota_;
+}
+
+// Skip forward to a semicolon or OP. OP will normally be
+// OPERATOR_RPAREN or OPERATOR_RCURLY. If we find a semicolon, move
+// past it and return. If we find OP, it will be the next token to
+// read. Return true if we are OK, false if we found EOF.
+
+bool
+Parse::skip_past_error(Operator op)
+{
+ const Token* token = this->peek_token();
+ while (!token->is_op(op))
+ {
+ if (token->is_eof())
+ return false;
+ if (token->is_op(OPERATOR_SEMICOLON))
+ {
+ this->advance_token();
+ return true;
+ }
+ token = this->advance_token();
+ }
+ return true;
+}
+
+// Check that an expression is not a sink.
+
+Expression*
+Parse::verify_not_sink(Expression* expr)
+{
+ if (expr->is_sink_expression())
+ {
+ error_at(expr->location(), "cannot use _ as value");
+ expr = Expression::make_error(expr->location());
+ }
+ return expr;
+}
--- /dev/null
+// parse.cc -- Go frontend parser.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "lex.h"
+#include "gogo.h"
+#include "types.h"
+#include "statements.h"
+#include "expressions.h"
+#include "parse.h"
+
+// Struct Parse::Enclosing_var_comparison.
+
+// Return true if v1 should be considered to be less than v2.
+
+bool
+Parse::Enclosing_var_comparison::operator()(const Enclosing_var& v1,
+ const Enclosing_var& v2)
+{
+ if (v1.var() == v2.var())
+ return false;
+
+ const std::string& n1(v1.var()->name());
+ const std::string& n2(v2.var()->name());
+ int i = n1.compare(n2);
+ if (i < 0)
+ return true;
+ else if (i > 0)
+ return false;
+
+ // If we get here it means that a single nested function refers to
+ // two different variables defined in enclosing functions, and both
+ // variables have the same name. I think this is impossible.
+ gcc_unreachable();
+}
+
+// Class Parse.
+
+Parse::Parse(Lex* lex, Gogo* gogo)
+ : lex_(lex),
+ token_(Token::make_invalid_token(0)),
+ unget_token_(Token::make_invalid_token(0)),
+ unget_token_valid_(false),
+ gogo_(gogo),
+ break_stack_(NULL),
+ continue_stack_(NULL),
+ iota_(0),
+ enclosing_vars_()
+{
+}
+
+// Return the current token.
+
+const Token*
+Parse::peek_token()
+{
+ if (this->unget_token_valid_)
+ return &this->unget_token_;
+ if (this->token_.is_invalid())
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Advance to the next token and return it.
+
+const Token*
+Parse::advance_token()
+{
+ if (this->unget_token_valid_)
+ {
+ this->unget_token_valid_ = false;
+ if (!this->token_.is_invalid())
+ return &this->token_;
+ }
+ this->token_ = this->lex_->next_token();
+ return &this->token_;
+}
+
+// Push a token back on the input stream.
+
+void
+Parse::unget_token(const Token& token)
+{
+ gcc_assert(!this->unget_token_valid_);
+ this->unget_token_ = token;
+ this->unget_token_valid_ = true;
+}
+
+// The location of the current token.
+
+source_location
+Parse::location()
+{
+ return this->peek_token()->location();
+}
+
+// IdentifierList = identifier { "," identifier } .
+
+void
+Parse::identifier_list(Typed_identifier_list* til)
+{
+ const Token* token = this->peek_token();
+ while (true)
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til->push_back(Typed_identifier(name, NULL, token->location()));
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return;
+ token = this->advance_token();
+ }
+}
+
+// ExpressionList = Expression { "," Expression } .
+
+// If MAY_BE_SINK is true, the expressions in the list may be "_".
+
+Expression_list*
+Parse::expression_list(Expression* first, bool may_be_sink)
+{
+ Expression_list* ret = new Expression_list();
+ if (first != NULL)
+ ret->push_back(first);
+ while (true)
+ {
+ ret->push_back(this->expression(PRECEDENCE_NORMAL, may_be_sink, true,
+ NULL));
+
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ return ret;
+
+ // Most expression lists permit a trailing comma.
+ source_location location = token->location();
+ this->advance_token();
+ if (!this->expression_may_start_here())
+ {
+ this->unget_token(Token::make_operator_token(OPERATOR_COMMA,
+ location));
+ return ret;
+ }
+ }
+}
+
+// QualifiedIdent = [ PackageName "." ] identifier .
+// PackageName = identifier .
+
+// This sets *PNAME to the identifier and sets *PPACKAGE to the
+// package or NULL if there isn't one. This returns true on success,
+// false on failure in which case it will have emitted an error
+// message.
+
+bool
+Parse::qualified_ident(std::string* pname, Named_object** ppackage)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT))
+ {
+ *pname = name;
+ *ppackage = NULL;
+ return true;
+ }
+
+ Named_object* package = this->gogo_->lookup(name, NULL);
+ if (package == NULL || !package->is_package())
+ {
+ error_at(this->location(), "expected package");
+ // We expect . IDENTIFIER; skip both.
+ if (this->advance_token()->is_identifier())
+ this->advance_token();
+ return false;
+ }
+
+ package->package_value()->set_used();
+
+ token = this->advance_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return false;
+ }
+
+ name = token->identifier();
+
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = "blank";
+ }
+
+ if (package->name() == this->gogo_->package_name())
+ name = this->gogo_->pack_hidden_name(name,
+ token->is_identifier_exported());
+
+ *pname = name;
+ *ppackage = package;
+
+ this->advance_token();
+
+ return true;
+}
+
+// Type = TypeName | TypeLit | "(" Type ")" .
+// TypeLit =
+// ArrayType | StructType | PointerType | FunctionType | InterfaceType |
+// SliceType | MapType | ChannelType .
+
+Type*
+Parse::type()
+{
+ const Token* token = this->peek_token();
+ if (token->is_identifier())
+ return this->type_name(true);
+ else if (token->is_op(OPERATOR_LSQUARE))
+ return this->array_type(false);
+ else if (token->is_keyword(KEYWORD_CHAN)
+ || token->is_op(OPERATOR_CHANOP))
+ return this->channel_type();
+ else if (token->is_keyword(KEYWORD_INTERFACE))
+ return this->interface_type();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ {
+ source_location location = token->location();
+ this->advance_token();
+ Type* type = this->signature(NULL, location);
+ if (type == NULL)
+ return Type::make_error_type();
+ return type;
+ }
+ else if (token->is_keyword(KEYWORD_MAP))
+ return this->map_type();
+ else if (token->is_keyword(KEYWORD_STRUCT))
+ return this->struct_type();
+ else if (token->is_op(OPERATOR_MULT))
+ return this->pointer_type();
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* ret = this->type();
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (!ret->is_error_type())
+ error_at(this->location(), "expected %<)%>");
+ }
+ return ret;
+ }
+ else
+ {
+ error_at(token->location(), "expected type");
+ return Type::make_error_type();
+ }
+}
+
+bool
+Parse::type_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_identifier()
+ || token->is_op(OPERATOR_LSQUARE)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_keyword(KEYWORD_CHAN)
+ || token->is_keyword(KEYWORD_INTERFACE)
+ || token->is_keyword(KEYWORD_FUNC)
+ || token->is_keyword(KEYWORD_MAP)
+ || token->is_keyword(KEYWORD_STRUCT)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_LPAREN));
+}
+
+// TypeName = QualifiedIdent .
+
+// If MAY_BE_NIL is true, then an identifier with the value of the
+// predefined constant nil is accepted, returning the nil type.
+
+Type*
+Parse::type_name(bool issue_error)
+{
+ source_location location = this->location();
+
+ std::string name;
+ Named_object* package;
+ if (!this->qualified_ident(&name, &package))
+ return Type::make_error_type();
+
+ Named_object* named_object;
+ if (package == NULL)
+ named_object = this->gogo_->lookup(name, NULL);
+ else
+ {
+ named_object = package->package_value()->lookup(name);
+ if (named_object == NULL
+ && issue_error
+ && package->name() != this->gogo_->package_name())
+ {
+ // Check whether the name is there but hidden.
+ std::string s = ('.' + package->package_value()->unique_prefix()
+ + '.' + package->package_value()->name()
+ + '.' + name);
+ named_object = package->package_value()->lookup(s);
+ if (named_object != NULL)
+ {
+ const std::string& packname(package->package_value()->name());
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(packname).c_str(),
+ Gogo::message_name(name).c_str());
+ issue_error = false;
+ }
+ }
+ }
+
+ bool ok = true;
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ ok = false;
+ else
+ named_object = this->gogo_->add_unknown_name(name, location);
+ }
+ else if (named_object->is_type())
+ {
+ if (!named_object->type_value()->is_visible())
+ ok = false;
+ }
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ ;
+ else
+ ok = false;
+
+ if (!ok)
+ {
+ if (issue_error)
+ error_at(location, "expected type");
+ return Type::make_error_type();
+ }
+
+ if (named_object->is_type())
+ return named_object->type_value();
+ else if (named_object->is_unknown() || named_object->is_type_declaration())
+ return Type::make_forward_declaration(named_object);
+ else
+ gcc_unreachable();
+}
+
+// ArrayType = "[" [ ArrayLength ] "]" ElementType .
+// ArrayLength = Expression .
+// ElementType = CompleteType .
+
+Type*
+Parse::array_type(bool may_use_ellipsis)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ const Token* token = this->advance_token();
+
+ Expression* length = NULL;
+ if (token->is_op(OPERATOR_RSQUARE))
+ this->advance_token();
+ else
+ {
+ if (!token->is_op(OPERATOR_ELLIPSIS))
+ length = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else if (may_use_ellipsis)
+ {
+ // An ellipsis is used in composite literals to represent a
+ // fixed array of the size of the number of elements. We
+ // use a length of nil to represent this, and change the
+ // length when parsing the composite literal.
+ length = Expression::make_nil(this->location());
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(),
+ "use of %<[...]%> outside of array literal");
+ length = Expression::make_error(this->location());
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+ }
+
+ Type* element_type = this->type();
+
+ return Type::make_array_type(element_type, length);
+}
+
+// MapType = "map" "[" KeyType "]" ValueType .
+// KeyType = CompleteType .
+// ValueType = CompleteType .
+
+Type*
+Parse::map_type()
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_MAP));
+ if (!this->advance_token()->is_op(OPERATOR_LSQUARE))
+ {
+ error_at(this->location(), "expected %<[%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* key_type = this->type();
+
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ {
+ error_at(this->location(), "expected %<]%>");
+ return Type::make_error_type();
+ }
+ this->advance_token();
+
+ Type* value_type = this->type();
+
+ if (key_type->is_error_type() || value_type->is_error_type())
+ return Type::make_error_type();
+
+ return Type::make_map_type(key_type, value_type, location);
+}
+
+// StructType = "struct" "{" { FieldDecl ";" } "}" .
+
+Type*
+Parse::struct_type()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_STRUCT));
+ source_location location = this->location();
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Struct_field_list* sfl = new Struct_field_list;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->field_decl(sfl);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ for (Struct_field_list::const_iterator pi = sfl->begin();
+ pi != sfl->end();
+ ++pi)
+ {
+ if (pi->type()->is_error_type())
+ return pi->type();
+ for (Struct_field_list::const_iterator pj = pi + 1;
+ pj != sfl->end();
+ ++pj)
+ {
+ if (pi->field_name() == pj->field_name()
+ && !Gogo::is_sink_name(pi->field_name()))
+ error_at(pi->location(), "duplicate field name %<%s%>",
+ Gogo::message_name(pi->field_name()).c_str());
+ }
+ }
+
+ return Type::make_struct_type(sfl, location);
+}
+
+// FieldDecl = (IdentifierList CompleteType | TypeName) [ Tag ] .
+// Tag = string_lit .
+
+void
+Parse::field_decl(Struct_field_list* sfl)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ bool is_anonymous;
+ bool is_anonymous_pointer;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_anonymous = true;
+ is_anonymous_pointer = true;
+ }
+ else if (token->is_identifier())
+ {
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+ token = this->advance_token();
+ is_anonymous = (token->is_op(OPERATOR_SEMICOLON)
+ || token->is_op(OPERATOR_RCURLY)
+ || token->is_op(OPERATOR_DOT)
+ || token->is_string());
+ is_anonymous_pointer = false;
+ this->unget_token(Token::make_identifier_token(id, is_id_exported,
+ id_location));
+ }
+ else
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+
+ if (is_anonymous)
+ {
+ if (is_anonymous_pointer)
+ {
+ this->advance_token();
+ if (!this->peek_token()->is_identifier())
+ {
+ error_at(this->location(), "expected field name");
+ while (!token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY)
+ && !token->is_eof())
+ token = this->advance_token();
+ return;
+ }
+ }
+ Type* type = this->type_name(true);
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ if (!type->is_error_type())
+ {
+ if (is_anonymous_pointer)
+ type = Type::make_pointer_type(type);
+ sfl->push_back(Struct_field(Typed_identifier("", type, location)));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+ else
+ {
+ Typed_identifier_list til;
+ while (true)
+ {
+ token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ til.push_back(Typed_identifier(name, NULL, token->location()));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+
+ Type* type = this->type();
+
+ std::string tag;
+ if (this->peek_token()->is_string())
+ {
+ tag = this->peek_token()->string_value();
+ this->advance_token();
+ }
+
+ for (Typed_identifier_list::iterator p = til.begin();
+ p != til.end();
+ ++p)
+ {
+ p->set_type(type);
+ sfl->push_back(Struct_field(*p));
+ if (!tag.empty())
+ sfl->back().set_tag(tag);
+ }
+ }
+}
+
+// PointerType = "*" Type .
+
+Type*
+Parse::pointer_type()
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_MULT));
+ this->advance_token();
+ Type* type = this->type();
+ if (type->is_error_type())
+ return type;
+ return Type::make_pointer_type(type);
+}
+
+// ChannelType = Channel | SendChannel | RecvChannel .
+// Channel = "chan" ElementType .
+// SendChannel = "chan" "<-" ElementType .
+// RecvChannel = "<-" "chan" ElementType .
+
+Type*
+Parse::channel_type()
+{
+ const Token* token = this->peek_token();
+ bool send = true;
+ bool receive = true;
+ if (token->is_op(OPERATOR_CHANOP))
+ {
+ if (!this->advance_token()->is_keyword(KEYWORD_CHAN))
+ {
+ error_at(this->location(), "expected %<chan%>");
+ return Type::make_error_type();
+ }
+ send = false;
+ this->advance_token();
+ }
+ else
+ {
+ gcc_assert(token->is_keyword(KEYWORD_CHAN));
+ if (this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ receive = false;
+ this->advance_token();
+ }
+ }
+ Type* element_type = this->type();
+ return Type::make_channel_type(send, receive, element_type);
+}
+
+// Signature = Parameters [ Result ] .
+
+// RECEIVER is the receiver if there is one, or NULL. LOCATION is the
+// location of the start of the type.
+
+// This returns NULL on a parse error.
+
+Function_type*
+Parse::signature(Typed_identifier* receiver, source_location location)
+{
+ bool is_varargs = false;
+ Typed_identifier_list* params;
+ bool params_ok = this->parameters(¶ms, &is_varargs);
+
+ Typed_identifier_list* result = NULL;
+ if (this->peek_token()->is_op(OPERATOR_LPAREN)
+ || this->type_may_start_here())
+ {
+ if (!this->result(&result))
+ return NULL;
+ }
+
+ if (!params_ok)
+ return NULL;
+
+ Function_type* ret = Type::make_function_type(receiver, params, result,
+ location);
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Parameters = "(" [ ParameterList [ "," ] ] ")" .
+
+// This returns false on a parse error.
+
+bool
+Parse::parameters(Typed_identifier_list** pparams, bool* is_varargs)
+{
+ *pparams = NULL;
+
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return false;
+ }
+
+ Typed_identifier_list* params = NULL;
+ bool saw_error = false;
+
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ params = this->parameter_list(is_varargs);
+ if (params == NULL)
+ saw_error = true;
+ token = this->peek_token();
+ }
+
+ // The optional trailing comma is picked up in parameter_list.
+
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+
+ if (saw_error)
+ return false;
+
+ *pparams = params;
+ return true;
+}
+
+// ParameterList = ParameterDecl { "," ParameterDecl } .
+
+// This sets *IS_VARARGS if the list ends with an ellipsis.
+// IS_VARARGS will be NULL if varargs are not permitted.
+
+// We pick up an optional trailing comma.
+
+// This returns NULL if some error is seen.
+
+Typed_identifier_list*
+Parse::parameter_list(bool* is_varargs)
+{
+ source_location location = this->location();
+ Typed_identifier_list* ret = new Typed_identifier_list();
+
+ bool saw_error = false;
+
+ // If we see an identifier and then a comma, then we don't know
+ // whether we are looking at a list of identifiers followed by a
+ // type, or a list of types given by name. We have to do an
+ // arbitrary lookahead to figure it out.
+
+ bool parameters_have_names;
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ // This must be a type which starts with something like '*'.
+ parameters_have_names = false;
+ }
+ else
+ {
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_DOT))
+ {
+ // This is a qualified identifier, which must turn out
+ // to be a type.
+ parameters_have_names = false;
+ }
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ // A single identifier followed by a parenthesis must be
+ // a type name.
+ parameters_have_names = false;
+ }
+ else
+ {
+ // An identifier followed by something other than a
+ // comma or a dot or a right parenthesis must be a
+ // parameter name followed by a type.
+ parameters_have_names = true;
+ }
+
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ }
+ else
+ {
+ // An identifier followed by a comma may be the first in a
+ // list of parameter names followed by a type, or it may be
+ // the first in a list of types without parameter names. To
+ // find out we gather as many identifiers separated by
+ // commas as we can.
+ std::string id_name = this->gogo_->pack_hidden_name(name,
+ is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ bool just_saw_comma = true;
+ while (this->advance_token()->is_identifier())
+ {
+ name = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ location = this->peek_token()->location();
+ id_name = this->gogo_->pack_hidden_name(name, is_exported);
+ ret->push_back(Typed_identifier(id_name, NULL, location));
+ if (!this->advance_token()->is_op(OPERATOR_COMMA))
+ {
+ just_saw_comma = false;
+ break;
+ }
+ }
+
+ if (just_saw_comma)
+ {
+ // We saw ID1 "," ID2 "," followed by something which
+ // was not an identifier. We must be seeing the start
+ // of a type, and ID1 and ID2 must be types, and the
+ // parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ // We saw ID1 "," ID2 ")". ID1 and ID2 must be types,
+ // and the parameters don't have names.
+ parameters_have_names = false;
+ }
+ else if (this->peek_token()->is_op(OPERATOR_DOT))
+ {
+ // We saw ID1 "," ID2 ".". ID2 must be a package name,
+ // ID1 must be a type, and the parameters don't have
+ // names.
+ parameters_have_names = false;
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ ret->pop_back();
+ just_saw_comma = true;
+ }
+ else
+ {
+ // We saw ID1 "," ID2 followed by something other than
+ // ",", ".", or ")". We must be looking at the start of
+ // a type, and ID1 and ID2 must be parameter names.
+ parameters_have_names = true;
+ }
+
+ if (parameters_have_names)
+ {
+ gcc_assert(!just_saw_comma);
+ // We have just seen ID1, ID2 xxx.
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ error_at(this->location(), "%<...%> only permits one name");
+ saw_error = true;
+ this->advance_token();
+ type = this->type();
+ }
+ for (size_t i = 0; i < ret->size(); ++i)
+ ret->set_type(i, type);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ return saw_error ? NULL : ret;
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ return saw_error ? NULL : ret;
+ }
+ else
+ {
+ Typed_identifier_list* tret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = ret->begin();
+ p != ret->end();
+ ++p)
+ {
+ Named_object* no = this->gogo_->lookup(p->name(), NULL);
+ Type* type;
+ if (no == NULL)
+ no = this->gogo_->add_unknown_name(p->name(),
+ p->location());
+
+ if (no->is_type())
+ type = no->type_value();
+ else if (no->is_unknown() || no->is_type_declaration())
+ type = Type::make_forward_declaration(no);
+ else
+ {
+ error_at(p->location(), "expected %<%s%> to be a type",
+ Gogo::message_name(p->name()).c_str());
+ saw_error = true;
+ type = Type::make_error_type();
+ }
+ tret->push_back(Typed_identifier("", type, p->location()));
+ }
+ delete ret;
+ ret = tret;
+ if (!just_saw_comma
+ || this->peek_token()->is_op(OPERATOR_RPAREN))
+ return saw_error ? NULL : ret;
+ }
+ }
+ }
+
+ bool mix_error = false;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ while (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (is_varargs != NULL && *is_varargs)
+ {
+ error_at(this->location(), "%<...%> must be last parameter");
+ saw_error = true;
+ }
+ if (this->advance_token()->is_op(OPERATOR_RPAREN))
+ break;
+ this->parameter_decl(parameters_have_names, ret, is_varargs, &mix_error);
+ }
+ if (mix_error)
+ {
+ error_at(location, "invalid named/anonymous mix");
+ saw_error = true;
+ }
+ if (saw_error)
+ {
+ delete ret;
+ return NULL;
+ }
+ return ret;
+}
+
+// ParameterDecl = [ IdentifierList ] [ "..." ] Type .
+
+void
+Parse::parameter_decl(bool parameters_have_names,
+ Typed_identifier_list* til,
+ bool* is_varargs,
+ bool* mix_error)
+{
+ if (!parameters_have_names)
+ {
+ Type* type;
+ source_location location = this->location();
+ if (!this->peek_token()->is_identifier())
+ {
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ if (is_varargs == NULL
+ && this->peek_token()->is_op(OPERATOR_RPAREN))
+ type = Type::make_error_type();
+ else
+ {
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ }
+ }
+ else
+ {
+ type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN)))
+ {
+ *mix_error = true;
+ while (!this->peek_token()->is_op(OPERATOR_COMMA)
+ && !this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ }
+ }
+ if (!type->is_error_type())
+ til->push_back(Typed_identifier("", type, location));
+ }
+ else
+ {
+ size_t orig_count = til->size();
+ if (this->peek_token()->is_identifier())
+ this->identifier_list(til);
+ else
+ *mix_error = true;
+ size_t new_count = til->size();
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_ELLIPSIS))
+ type = this->type();
+ else
+ {
+ if (is_varargs == NULL)
+ error_at(this->location(), "invalid use of %<...%>");
+ else if (new_count > orig_count + 1)
+ error_at(this->location(), "%<...%> only permits one name");
+ else
+ *is_varargs = true;
+ this->advance_token();
+ Type* element_type = this->type();
+ type = Type::make_array_type(element_type, NULL);
+ }
+ for (size_t i = orig_count; i < new_count; ++i)
+ til->set_type(i, type);
+ }
+}
+
+// Result = Parameters | Type .
+
+// This returns false on a parse error.
+
+bool
+Parse::result(Typed_identifier_list** presults)
+{
+ if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ return this->parameters(presults, NULL);
+ else
+ {
+ source_location location = this->location();
+ Type* type = this->type();
+ if (type->is_error_type())
+ {
+ *presults = NULL;
+ return false;
+ }
+ Typed_identifier_list* til = new Typed_identifier_list();
+ til->push_back(Typed_identifier("", type, location));
+ *presults = til;
+ return true;
+ }
+}
+
+// Block = "{" [ StatementList ] "}" .
+
+// Returns the location of the closing brace.
+
+source_location
+Parse::block()
+{
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return UNKNOWN_LOCATION;
+ }
+ }
+
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ this->statement_list();
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_RCURLY))
+ {
+ if (!token->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<}%>");
+
+ // Skip ahead to the end of the block, in hopes of avoiding
+ // lots of meaningless errors.
+ source_location ret = token->location();
+ int nest = 0;
+ while (!token->is_eof())
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++nest;
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ --nest;
+ if (nest < 0)
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ token = this->advance_token();
+ ret = token->location();
+ }
+ return ret;
+ }
+ }
+
+ source_location ret = token->location();
+ this->advance_token();
+ return ret;
+}
+
+// InterfaceType = "interface" "{" [ MethodSpecList ] "}" .
+// MethodSpecList = MethodSpec { ";" MethodSpec } [ ";" ] .
+
+Type*
+Parse::interface_type()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_INTERFACE));
+ source_location location = this->location();
+
+ if (!this->advance_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return Type::make_error_type();
+ }
+ }
+ this->advance_token();
+
+ Typed_identifier_list* methods = new Typed_identifier_list();
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->method_spec(methods);
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ break;
+ this->method_spec(methods);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ error_at(this->location(), "expected %<}%>");
+ while (!this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ return Type::make_error_type();
+ }
+ }
+ }
+ this->advance_token();
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ Interface_type* ret = Type::make_interface_type(methods, location);
+ this->gogo_->record_interface_type(ret);
+ return ret;
+}
+
+// MethodSpec = MethodName Signature | InterfaceTypeName .
+// MethodName = identifier .
+// InterfaceTypeName = TypeName .
+
+void
+Parse::method_spec(Typed_identifier_list* methods)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ if (this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ // This is a MethodName.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ Type* type = this->signature(NULL, location);
+ if (type == NULL)
+ return;
+ methods->push_back(Typed_identifier(name, type, location));
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ Type* type = this->type_name(false);
+ if (type->is_error_type()
+ || (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY)))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(),
+ "name list not allowed in interface type");
+ else
+ error_at(location, "expected signature or type name");
+ token = this->peek_token();
+ while (!token->is_eof()
+ && !token->is_op(OPERATOR_SEMICOLON)
+ && !token->is_op(OPERATOR_RCURLY))
+ token = this->advance_token();
+ return;
+ }
+ // This must be an interface type, but we can't check that now.
+ // We check it and pull out the methods in
+ // Interface_type::do_verify.
+ methods->push_back(Typed_identifier("", type, location));
+ }
+}
+
+// Declaration = ConstDecl | TypeDecl | VarDecl | FunctionDecl | MethodDecl .
+
+void
+Parse::declaration()
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CONST))
+ this->const_decl();
+ else if (token->is_keyword(KEYWORD_TYPE))
+ this->type_decl();
+ else if (token->is_keyword(KEYWORD_VAR))
+ this->var_decl();
+ else if (token->is_keyword(KEYWORD_FUNC))
+ this->function_decl();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ this->advance_token();
+ }
+}
+
+bool
+Parse::declaration_may_start_here()
+{
+ const Token* token = this->peek_token();
+ return (token->is_keyword(KEYWORD_CONST)
+ || token->is_keyword(KEYWORD_TYPE)
+ || token->is_keyword(KEYWORD_VAR)
+ || token->is_keyword(KEYWORD_FUNC));
+}
+
+// Decl<P> = P | "(" [ List<P> ] ")" .
+
+void
+Parse::decl(void (Parse::*pfn)(void*), void* varg)
+{
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ (this->*pfn)(varg);
+ else
+ {
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->list(pfn, varg, true);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "missing %<)%>");
+ while (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ if (this->peek_token()->is_eof())
+ return;
+ }
+ }
+ }
+ this->advance_token();
+ }
+}
+
+// List<P> = P { ";" P } [ ";" ] .
+
+// In order to pick up the trailing semicolon we need to know what
+// might follow. This is either a '}' or a ')'.
+
+void
+Parse::list(void (Parse::*pfn)(void*), void* varg, bool follow_is_paren)
+{
+ (this->*pfn)(varg);
+ Operator follow = follow_is_paren ? OPERATOR_RPAREN : OPERATOR_RCURLY;
+ while (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ || this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "unexpected comma");
+ if (this->advance_token()->is_op(follow))
+ break;
+ (this->*pfn)(varg);
+ }
+}
+
+// ConstDecl = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
+
+void
+Parse::const_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONST));
+ this->advance_token();
+ this->reset_iota();
+
+ Type* last_type = NULL;
+ Expression_list* last_expr_list = NULL;
+
+ if (!this->peek_token()->is_op(OPERATOR_LPAREN))
+ this->const_spec(&last_type, &last_expr_list);
+ else
+ {
+ this->advance_token();
+ while (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ this->const_spec(&last_type, &last_expr_list);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<;%> or %<)%> or newline");
+ if (!this->skip_past_error(OPERATOR_RPAREN))
+ return;
+ }
+ }
+ this->advance_token();
+ }
+
+ if (last_expr_list != NULL)
+ delete last_expr_list;
+}
+
+// ConstSpec = IdentifierList [ [ CompleteType ] "=" ExpressionList ] .
+
+void
+Parse::const_spec(Type** last_type, Expression_list** last_expr_list)
+{
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ Type* type = NULL;
+ if (this->type_may_start_here())
+ {
+ type = this->type();
+ *last_type = NULL;
+ *last_expr_list = NULL;
+ }
+
+ Expression_list *expr_list;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (*last_expr_list == NULL)
+ {
+ error_at(this->location(), "expected %<=%>");
+ return;
+ }
+ type = *last_type;
+ expr_list = new Expression_list;
+ for (Expression_list::const_iterator p = (*last_expr_list)->begin();
+ p != (*last_expr_list)->end();
+ ++p)
+ expr_list->push_back((*p)->copy());
+ }
+ else
+ {
+ this->advance_token();
+ expr_list = this->expression_list(NULL, false);
+ *last_type = type;
+ if (*last_expr_list != NULL)
+ delete *last_expr_list;
+ *last_expr_list = expr_list;
+ }
+
+ Expression_list::const_iterator pe = expr_list->begin();
+ for (Typed_identifier_list::iterator pi = til.begin();
+ pi != til.end();
+ ++pi, ++pe)
+ {
+ if (pe == expr_list->end())
+ {
+ error_at(this->location(), "not enough initializers");
+ return;
+ }
+ if (type != NULL)
+ pi->set_type(type);
+
+ if (!Gogo::is_sink_name(pi->name()))
+ this->gogo_->add_constant(*pi, *pe, this->iota_value());
+ }
+ if (pe != expr_list->end())
+ error_at(this->location(), "too many initializers");
+
+ this->increment_iota();
+
+ return;
+}
+
+// TypeDecl = "type" Decl<TypeSpec> .
+
+void
+Parse::type_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_TYPE));
+ this->advance_token();
+ this->decl(&Parse::type_spec, NULL);
+}
+
+// TypeSpec = identifier Type .
+
+void
+Parse::type_spec(void*)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected identifier");
+ return;
+ }
+ std::string name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ token = this->advance_token();
+
+ // The scope of the type name starts at the point where the
+ // identifier appears in the source code. We implement this by
+ // declaring the type before we read the type definition.
+ Named_object* named_type = NULL;
+ if (name != "_")
+ {
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ named_type = this->gogo_->declare_type(name, location);
+ }
+
+ Type* type;
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ type = this->type();
+ else
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline in type declaration");
+ type = Type::make_error_type();
+ this->advance_token();
+ }
+
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+
+ if (name != "_")
+ {
+ if (named_type->is_type_declaration())
+ {
+ Type* ftype = type->forwarded();
+ if (ftype->forward_declaration_type() != NULL
+ && (ftype->forward_declaration_type()->named_object()
+ == named_type))
+ {
+ error_at(location, "invalid recursive type");
+ type = Type::make_error_type();
+ }
+
+ this->gogo_->define_type(named_type,
+ Type::make_named_type(named_type, type,
+ location));
+ gcc_assert(named_type->package() == NULL);
+ }
+ else
+ {
+ // This will probably give a redefinition error.
+ this->gogo_->add_type(name, type, location);
+ }
+ }
+}
+
+// VarDecl = "var" Decl<VarSpec> .
+
+void
+Parse::var_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_VAR));
+ this->advance_token();
+ this->decl(&Parse::var_spec, NULL);
+}
+
+// VarSpec = IdentifierList
+// ( CompleteType [ "=" ExpressionList ] | "=" ExpressionList ) .
+
+void
+Parse::var_spec(void*)
+{
+ // Get the variable names.
+ Typed_identifier_list til;
+ this->identifier_list(&til);
+
+ source_location location = this->location();
+
+ Type* type = NULL;
+ Expression_list* init = NULL;
+ if (!this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ type = this->type();
+ if (type->is_error_type())
+ {
+ while (!this->peek_token()->is_op(OPERATOR_EQ)
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_eof())
+ this->advance_token();
+ }
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(NULL, false);
+ }
+
+ this->init_vars(&til, type, init, false, location);
+
+ if (init != NULL)
+ delete init;
+}
+
+// Create variables. TIL is a list of variable names. If TYPE is not
+// NULL, it is the type of all the variables. If INIT is not NULL, it
+// is an initializer list for the variables.
+
+void
+Parse::init_vars(const Typed_identifier_list* til, Type* type,
+ Expression_list* init, bool is_coloneq,
+ source_location location)
+{
+ // Check for an initialization which can yield multiple values.
+ if (init != NULL && init->size() == 1 && til->size() > 1)
+ {
+ if (this->init_vars_from_call(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_map(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_receive(til, type, *init->begin(), is_coloneq,
+ location))
+ return;
+ if (this->init_vars_from_type_guard(til, type, *init->begin(),
+ is_coloneq, location))
+ return;
+ }
+
+ if (init != NULL && init->size() != til->size())
+ {
+ if (init->empty() || !init->front()->is_error_expression())
+ error_at(location, "wrong number of initializations");
+ init = NULL;
+ if (type == NULL)
+ type = Type::make_error_type();
+ }
+
+ // Note that INIT was already parsed with the old name bindings, so
+ // we don't have to worry that it will accidentally refer to the
+ // newly declared variables.
+
+ Expression_list::const_iterator pexpr;
+ if (init != NULL)
+ pexpr = init->begin();
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator p = til->begin();
+ p != til->end();
+ ++p)
+ {
+ if (init != NULL)
+ gcc_assert(pexpr != init->end());
+ this->init_var(*p, type, init == NULL ? NULL : *pexpr, is_coloneq,
+ false, &any_new);
+ if (init != NULL)
+ ++pexpr;
+ }
+ if (init != NULL)
+ gcc_assert(pexpr == init->end());
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// See if we need to initialize a list of variables from a function
+// call. This returns true if we have set up the variables and the
+// initialization.
+
+bool
+Parse::init_vars_from_call(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Call_expression* call = expr->call_expression();
+ if (call == NULL)
+ return false;
+
+ // This is a function call. We can't check here whether it returns
+ // the right number of values, but it might. Declare the variables,
+ // and then assign the results of the call to them.
+
+ unsigned int index = 0;
+ bool any_new = false;
+ for (Typed_identifier_list::const_iterator pv = vars->begin();
+ pv != vars->end();
+ ++pv, ++index)
+ {
+ Expression* init = Expression::make_call_result(call, index);
+ this->init_var(*pv, type, init, is_coloneq, false, &any_new);
+ }
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a map index
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_map(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Index_expression* index = expr->index_expression();
+ if (index == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is an index which is being assigned to two variables. It
+ // must be a map index. Declare the variables, and then assign the
+ // results of the map index.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? index : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* present_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_map_assignment(val_var, present_var,
+ index, location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ // Execute the map index expression just so that we can fail if
+ // the map is nil.
+ Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
+ NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a receive
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_receive(const Typed_identifier_list* vars, Type* type,
+ Expression* expr, bool is_coloneq,
+ source_location location)
+{
+ Receive_expression* receive = expr->receive_expression();
+ if (receive == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a receive expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the receive.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Expression* init = type == NULL ? receive : NULL;
+ Named_object* val_no = this->init_var(*p, type, init, is_coloneq,
+ type == NULL, &any_new);
+ if (type == NULL && any_new && val_no->is_variable())
+ val_no->var_value()->set_type_from_init_tuple();
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* received_var = Expression::make_var_reference(no, location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ Statement* s = Statement::make_tuple_receive_assignment(val_var,
+ received_var,
+ receive->channel(),
+ false,
+ location);
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ Named_object* dummy = this->create_dummy_global(Type::lookup_bool_type(),
+ NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// See if we need to initialize a pair of values from a type guard
+// expression. This returns true if we have set up the variables and
+// the initialization.
+
+bool
+Parse::init_vars_from_type_guard(const Typed_identifier_list* vars,
+ Type* type, Expression* expr,
+ bool is_coloneq, source_location location)
+{
+ Type_guard_expression* type_guard = expr->type_guard_expression();
+ if (type_guard == NULL)
+ return false;
+ if (vars->size() != 2)
+ return false;
+
+ // This is a type guard expression which is being assigned to two
+ // variables. Declare the variables, and then assign the results of
+ // the type guard.
+ bool any_new = false;
+ Typed_identifier_list::const_iterator p = vars->begin();
+ Type* var_type = type;
+ if (var_type == NULL)
+ var_type = type_guard->type();
+ Named_object* val_no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* val_var = Expression::make_var_reference(val_no, location);
+
+ ++p;
+ var_type = type;
+ if (var_type == NULL)
+ var_type = Type::lookup_bool_type();
+ Named_object* no = this->init_var(*p, var_type, NULL, is_coloneq, false,
+ &any_new);
+ Expression* ok_var = Expression::make_var_reference(no, location);
+
+ Expression* texpr = type_guard->expr();
+ Type* t = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val_var, ok_var,
+ texpr, t,
+ location);
+
+ if (is_coloneq && !any_new)
+ error_at(location, "variables redeclared but no variable is new");
+
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(s);
+ else if (!val_no->is_sink())
+ {
+ if (val_no->is_variable())
+ val_no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else if (!no->is_sink())
+ {
+ if (no->is_variable())
+ no->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+ else
+ {
+ Named_object* dummy = this->create_dummy_global(type, NULL, location);
+ dummy->var_value()->add_preinit_statement(this->gogo_, s);
+ }
+
+ return true;
+}
+
+// Create a single variable. If IS_COLONEQ is true, we permit
+// redeclarations in the same block, and we set *IS_NEW when we find a
+// new variable which is not a redeclaration.
+
+Named_object*
+Parse::init_var(const Typed_identifier& tid, Type* type, Expression* init,
+ bool is_coloneq, bool type_from_init, bool* is_new)
+{
+ source_location location = tid.location();
+
+ if (Gogo::is_sink_name(tid.name()))
+ {
+ if (!type_from_init && init != NULL)
+ {
+ if (!this->gogo_->in_global_scope())
+ this->gogo_->add_statement(Statement::make_statement(init));
+ else
+ return this->create_dummy_global(type, init, location);
+ }
+ return this->gogo_->add_sink();
+ }
+
+ if (is_coloneq)
+ {
+ Named_object* no = this->gogo_->lookup_in_block(tid.name());
+ if (no != NULL
+ && (no->is_variable() || no->is_result_variable()))
+ {
+ // INIT may be NULL even when IS_COLONEQ is true for cases
+ // like v, ok := x.(int).
+ if (!type_from_init && init != NULL)
+ {
+ Expression *v = Expression::make_var_reference(no, location);
+ Statement *s = Statement::make_assignment(v, init, location);
+ this->gogo_->add_statement(s);
+ }
+ return no;
+ }
+ }
+ *is_new = true;
+ Variable* var = new Variable(type, init, this->gogo_->in_global_scope(),
+ false, false, location);
+ Named_object* no = this->gogo_->add_variable(tid.name(), var);
+ if (!no->is_variable())
+ {
+ // The name is already defined, so we just gave an error.
+ return this->gogo_->add_sink();
+ }
+ return no;
+}
+
+// Create a dummy global variable to force an initializer to be run in
+// the right place. This is used when a sink variable is initialized
+// at global scope.
+
+Named_object*
+Parse::create_dummy_global(Type* type, Expression* init,
+ source_location location)
+{
+ if (type == NULL && init == NULL)
+ type = Type::lookup_bool_type();
+ Variable* var = new Variable(type, init, true, false, false, location);
+ static int count;
+ char buf[30];
+ snprintf(buf, sizeof buf, "_.%d", count);
+ ++count;
+ return this->gogo_->add_variable(buf, var);
+}
+
+// SimpleVarDecl = identifier ":=" Expression .
+
+// We've already seen the identifier.
+
+// FIXME: We also have to implement
+// IdentifierList ":=" ExpressionList
+// In order to support both "a, b := 1, 0" and "a, b = 1, 0" we accept
+// tuple assignments here as well.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+void
+Parse::simple_var_decl_or_assignment(const std::string& name,
+ source_location location,
+ Range_clause* p_range_clause,
+ Type_switch* p_type_switch)
+{
+ Typed_identifier_list til;
+ til.push_back(Typed_identifier(name, NULL, location));
+
+ // We've seen one identifier. If we see a comma now, this could be
+ // "a, *p = 1, 2".
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ gcc_assert(p_type_switch == NULL);
+ while (true)
+ {
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ break;
+
+ std::string id = token->identifier();
+ bool is_id_exported = token->is_identifier_exported();
+ source_location id_location = token->location();
+
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_COMMA))
+ {
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+ else
+ this->unget_token(Token::make_identifier_token(id,
+ is_id_exported,
+ id_location));
+ break;
+ }
+
+ id = this->gogo_->pack_hidden_name(id, is_id_exported);
+ til.push_back(Typed_identifier(id, NULL, location));
+ }
+
+ // We have a comma separated list of identifiers in TIL. If the
+ // next token is COLONEQ, then this is a simple var decl, and we
+ // have the complete list of identifiers. If the next token is
+ // not COLONEQ, then the only valid parse is a tuple assignment.
+ // The list of identifiers we have so far is really a list of
+ // expressions. There are more expressions following.
+
+ if (!this->peek_token()->is_op(OPERATOR_COLONEQ))
+ {
+ Expression_list* exprs = new Expression_list;
+ for (Typed_identifier_list::const_iterator p = til.begin();
+ p != til.end();
+ ++p)
+ exprs->push_back(this->id_to_expression(p->name(),
+ p->location()));
+
+ Expression_list* more_exprs = this->expression_list(NULL, true);
+ for (Expression_list::const_iterator p = more_exprs->begin();
+ p != more_exprs->end();
+ ++p)
+ exprs->push_back(*p);
+ delete more_exprs;
+
+ this->tuple_assignment(exprs, p_range_clause);
+ return;
+ }
+ }
+
+ gcc_assert(this->peek_token()->is_op(OPERATOR_COLONEQ));
+ const Token* token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ this->range_clause_decl(&til, p_range_clause);
+ return;
+ }
+
+ Expression_list* init;
+ if (p_type_switch == NULL)
+ init = this->expression_list(NULL, false);
+ else
+ {
+ bool is_type_switch = false;
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ &is_type_switch);
+ if (is_type_switch)
+ {
+ p_type_switch->found = true;
+ p_type_switch->name = name;
+ p_type_switch->location = location;
+ p_type_switch->expr = expr;
+ return;
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ init = new Expression_list();
+ init->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ init = this->expression_list(expr, false);
+ }
+ }
+
+ this->init_vars(&til, NULL, init, true, location);
+}
+
+// FunctionDecl = "func" identifier Signature [ Block ] .
+// MethodDecl = "func" Receiver identifier Signature [ Block ] .
+
+// gcc extension:
+// FunctionDecl = "func" identifier Signature
+// __asm__ "(" string_lit ")" .
+// This extension means a function whose real name is the identifier
+// inside the asm.
+
+void
+Parse::function_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ Typed_identifier* rec = NULL;
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ rec = this->receiver();
+ token = this->peek_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected function name");
+ return;
+ }
+
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+
+ this->advance_token();
+
+ Function_type* fntype = this->signature(rec, this->location());
+ if (fntype == NULL)
+ return;
+
+ Named_object* named_object = NULL;
+
+ if (this->peek_token()->is_keyword(KEYWORD_ASM))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_LPAREN))
+ {
+ error_at(this->location(), "expected %<(%>");
+ return;
+ }
+ token = this->advance_token();
+ if (!token->is_string())
+ {
+ error_at(this->location(), "expected string");
+ return;
+ }
+ std::string asm_name = token->string_value();
+ if (!this->advance_token()->is_op(OPERATOR_RPAREN))
+ {
+ error_at(this->location(), "expected %<)%>");
+ return;
+ }
+ this->advance_token();
+ if (!Gogo::is_sink_name(name))
+ {
+ named_object = this->gogo_->declare_function(name, fntype, location);
+ if (named_object->is_function_declaration())
+ named_object->func_declaration_value()->set_asm_name(asm_name);
+ }
+ }
+
+ // Check for the easy error of a newline before the opening brace.
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (named_object == NULL && !Gogo::is_sink_name(name))
+ this->gogo_->declare_function(name, fntype, location);
+ }
+ else
+ {
+ this->gogo_->start_function(name, fntype, true, location);
+ source_location end_loc = this->block();
+ this->gogo_->finish_function(end_loc);
+ }
+}
+
+// Receiver = "(" [ identifier ] [ "*" ] BaseTypeName ")" .
+// BaseTypeName = identifier .
+
+Typed_identifier*
+Parse::receiver()
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+
+ std::string name;
+ const Token* token = this->advance_token();
+ source_location location = token->location();
+ if (!token->is_op(OPERATOR_MULT))
+ {
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "method has no receiver");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+ name = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_DOT) && !token->is_op(OPERATOR_RPAREN))
+ {
+ // An identifier followed by something other than a dot or a
+ // right parenthesis must be a receiver name followed by a
+ // type.
+ name = this->gogo_->pack_hidden_name(name, is_exported);
+ }
+ else
+ {
+ // This must be a type name.
+ this->unget_token(Token::make_identifier_token(name, is_exported,
+ location));
+ token = this->peek_token();
+ name.clear();
+ }
+ }
+
+ // Here the receiver name is in NAME (it is empty if the receiver is
+ // unnamed) and TOKEN is the first token in the type.
+
+ bool is_pointer = false;
+ if (token->is_op(OPERATOR_MULT))
+ {
+ is_pointer = true;
+ token = this->advance_token();
+ }
+
+ if (!token->is_identifier())
+ {
+ error_at(this->location(), "expected receiver name or type");
+ int c = token->is_op(OPERATOR_LPAREN) ? 1 : 0;
+ while (!token->is_eof())
+ {
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ++c;
+ else if (token->is_op(OPERATOR_RPAREN))
+ {
+ if (c == 0)
+ break;
+ --c;
+ }
+ }
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ Type* type = this->type_name(true);
+
+ if (is_pointer && !type->is_error_type())
+ type = Type::make_pointer_type(type);
+
+ if (this->peek_token()->is_op(OPERATOR_RPAREN))
+ this->advance_token();
+ else
+ {
+ if (this->peek_token()->is_op(OPERATOR_COMMA))
+ error_at(this->location(), "method has multiple receivers");
+ else
+ error_at(this->location(), "expected %<)%>");
+ while (!token->is_eof() && !token->is_op(OPERATOR_RPAREN))
+ token = this->advance_token();
+ if (!token->is_eof())
+ this->advance_token();
+ return NULL;
+ }
+
+ return new Typed_identifier(name, type, location);
+}
+
+// Operand = Literal | QualifiedIdent | MethodExpr | "(" Expression ")" .
+// Literal = BasicLit | CompositeLit | FunctionLit .
+// BasicLit = int_lit | float_lit | imaginary_lit | char_lit | string_lit .
+
+// If MAY_BE_SINK is true, this operand may be "_".
+
+Expression*
+Parse::operand(bool may_be_sink)
+{
+ const Token* token = this->peek_token();
+ Expression* ret;
+ switch (token->classification())
+ {
+ case Token::TOKEN_IDENTIFIER:
+ {
+ source_location location = token->location();
+ std::string id = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ std::string packed = this->gogo_->pack_hidden_name(id, is_exported);
+
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(packed, &in_function);
+
+ Package* package = NULL;
+ if (named_object != NULL && named_object->is_package())
+ {
+ if (!this->advance_token()->is_op(OPERATOR_DOT)
+ || !this->advance_token()->is_identifier())
+ {
+ error_at(location, "unexpected reference to package");
+ return Expression::make_error(location);
+ }
+ package = named_object->package_value();
+ package->set_used();
+ id = this->peek_token()->identifier();
+ is_exported = this->peek_token()->is_identifier_exported();
+ packed = this->gogo_->pack_hidden_name(id, is_exported);
+ named_object = package->lookup(packed);
+ location = this->location();
+ gcc_assert(in_function == NULL);
+ }
+
+ this->advance_token();
+
+ if (named_object != NULL
+ && named_object->is_type()
+ && !named_object->type_value()->is_visible())
+ {
+ gcc_assert(package != NULL);
+ error_at(location, "invalid reference to hidden type %<%s.%s%>",
+ Gogo::message_name(package->name()).c_str(),
+ Gogo::message_name(id).c_str());
+ return Expression::make_error(location);
+ }
+
+
+ if (named_object == NULL)
+ {
+ if (package != NULL)
+ {
+ std::string n1 = Gogo::message_name(package->name());
+ std::string n2 = Gogo::message_name(id);
+ if (!is_exported)
+ error_at(location,
+ ("invalid reference to unexported identifier "
+ "%<%s.%s%>"),
+ n1.c_str(), n2.c_str());
+ else
+ error_at(location,
+ "reference to undefined identifier %<%s.%s%>",
+ n1.c_str(), n2.c_str());
+ return Expression::make_error(location);
+ }
+
+ named_object = this->gogo_->add_unknown_name(packed, location);
+ }
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable()
+ || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_TYPE:
+ return Expression::make_type(named_object->type_value(), location);
+ case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
+ {
+ Type* t = Type::make_forward_declaration(named_object);
+ return Expression::make_type(t, location);
+ }
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ if (may_be_sink)
+ return Expression::make_sink(location);
+ else
+ {
+ error_at(location, "cannot use _ as value");
+ return Expression::make_error(location);
+ }
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL,
+ location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ gcc_unreachable();
+ }
+ }
+ gcc_unreachable();
+
+ case Token::TOKEN_STRING:
+ ret = Expression::make_string(token->string_value(), token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_INTEGER:
+ ret = Expression::make_integer(token->integer_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_FLOAT:
+ ret = Expression::make_float(token->float_value(), NULL,
+ token->location());
+ this->advance_token();
+ return ret;
+
+ case Token::TOKEN_IMAGINARY:
+ {
+ mpfr_t zero;
+ mpfr_init_set_ui(zero, 0, GMP_RNDN);
+ ret = Expression::make_complex(&zero, token->imaginary_value(),
+ NULL, token->location());
+ mpfr_clear(zero);
+ this->advance_token();
+ return ret;
+ }
+
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_FUNC:
+ return this->function_lit();
+ case KEYWORD_CHAN:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ {
+ source_location location = token->location();
+ return Expression::make_type(this->type(), location);
+ }
+ default:
+ break;
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ ret = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ return ret;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ {
+ // Here we call array_type directly, as this is the only
+ // case where an ellipsis is permitted for an array type.
+ source_location location = token->location();
+ return Expression::make_type(this->array_type(true), location);
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ error_at(this->location(), "expected operand");
+ return Expression::make_error(this->location());
+}
+
+// Handle a reference to a variable in an enclosing function. We add
+// it to a list of such variables. We return a reference to a field
+// in a struct which will be passed on the static chain when calling
+// the current function.
+
+Expression*
+Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
+ source_location location)
+{
+ gcc_assert(var->is_variable() || var->is_result_variable());
+
+ Named_object* this_function = this->gogo_->current_function();
+ Named_object* closure = this_function->func_value()->closure_var();
+
+ Enclosing_var ev(var, in_function, this->enclosing_vars_.size());
+ std::pair<Enclosing_vars::iterator, bool> ins =
+ this->enclosing_vars_.insert(ev);
+ if (ins.second)
+ {
+ // This is a variable we have not seen before. Add a new field
+ // to the closure type.
+ this_function->func_value()->add_closure_field(var, location);
+ }
+
+ Expression* closure_ref = Expression::make_var_reference(closure,
+ location);
+ closure_ref = Expression::make_unary(OPERATOR_MULT, closure_ref, location);
+
+ // The closure structure holds pointers to the variables, so we need
+ // to introduce an indirection.
+ Expression* e = Expression::make_field_reference(closure_ref,
+ ins.first->index(),
+ location);
+ e = Expression::make_unary(OPERATOR_MULT, e, location);
+ return e;
+}
+
+// CompositeLit = LiteralType LiteralValue .
+// LiteralType = StructType | ArrayType | "[" "..." "]" ElementType |
+// SliceType | MapType | TypeName .
+// LiteralValue = "{" [ ElementList [ "," ] ] "}" .
+// ElementList = Element { "," Element } .
+// Element = [ Key ":" ] Value .
+// Key = Expression .
+// Value = Expression | LiteralValue .
+
+// We have already seen the type if there is one, and we are now
+// looking at the LiteralValue. The case "[" "..." "]" ElementType
+// will be seen here as an array type whose length is "nil". The
+// DEPTH parameter is non-zero if this is an embedded composite
+// literal and the type was omitted. It gives the number of steps up
+// to the type which was provided. E.g., in [][]int{{1}} it will be
+// 1. In [][][]int{{{1}}} it will be 2.
+
+Expression*
+Parse::composite_lit(Type* type, int depth, source_location location)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LCURLY));
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ return Expression::make_composite_literal(type, depth, false, NULL,
+ location);
+ }
+
+ bool has_keys = false;
+ Expression_list* vals = new Expression_list;
+ while (true)
+ {
+ Expression* val;
+ bool is_type_omitted = false;
+
+ const Token* token = this->peek_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another composite
+ // literal, with the type omitted for the inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ is_type_omitted = true;
+ }
+
+ token = this->peek_token();
+ if (!token->is_op(OPERATOR_COLON))
+ {
+ if (has_keys)
+ vals->push_back(NULL);
+ }
+ else
+ {
+ if (is_type_omitted && !val->is_error_expression())
+ {
+ error_at(this->location(), "unexpected %<:%>");
+ val = Expression::make_error(this->location());
+ }
+
+ this->advance_token();
+
+ if (!has_keys && !vals->empty())
+ {
+ Expression_list* newvals = new Expression_list;
+ for (Expression_list::const_iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ {
+ newvals->push_back(NULL);
+ newvals->push_back(*p);
+ }
+ delete vals;
+ vals = newvals;
+ }
+ has_keys = true;
+
+ if (val->unknown_expression() != NULL)
+ val->unknown_expression()->set_is_composite_literal_key();
+
+ vals->push_back(val);
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ // This must be a composite literal inside another
+ // composite literal, with the type omitted for the
+ // inner one.
+ val = this->composite_lit(type, depth + 1, token->location());
+ }
+
+ token = this->peek_token();
+ }
+
+ vals->push_back(val);
+
+ if (token->is_op(OPERATOR_COMMA))
+ {
+ if (this->advance_token()->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ }
+ else if (token->is_op(OPERATOR_RCURLY))
+ {
+ this->advance_token();
+ break;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<,%> or %<}%>");
+
+ int depth = 0;
+ while (!token->is_eof()
+ && (depth > 0 || !token->is_op(OPERATOR_RCURLY)))
+ {
+ if (token->is_op(OPERATOR_LCURLY))
+ ++depth;
+ else if (token->is_op(OPERATOR_RCURLY))
+ --depth;
+ token = this->advance_token();
+ }
+ if (token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+
+ return Expression::make_error(location);
+ }
+ }
+
+ return Expression::make_composite_literal(type, depth, has_keys, vals,
+ location);
+}
+
+// FunctionLit = "func" Signature Block .
+
+Expression*
+Parse::function_lit()
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FUNC));
+ this->advance_token();
+
+ Enclosing_vars hold_enclosing_vars;
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Function_type* type = this->signature(NULL, location);
+ if (type == NULL)
+ type = Type::make_function_type(NULL, NULL, NULL, location);
+
+ // For a function literal, the next token must be a '{'. If we
+ // don't see that, then we may have a type expression.
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ return Expression::make_type(type, location);
+
+ Bc_stack* hold_break_stack = this->break_stack_;
+ Bc_stack* hold_continue_stack = this->continue_stack_;
+ this->break_stack_ = NULL;
+ this->continue_stack_ = NULL;
+
+ Named_object* no = this->gogo_->start_function("", type, true, location);
+
+ source_location end_loc = this->block();
+
+ this->gogo_->finish_function(end_loc);
+
+ if (this->break_stack_ != NULL)
+ delete this->break_stack_;
+ if (this->continue_stack_ != NULL)
+ delete this->continue_stack_;
+ this->break_stack_ = hold_break_stack;
+ this->continue_stack_ = hold_continue_stack;
+
+ hold_enclosing_vars.swap(this->enclosing_vars_);
+
+ Expression* closure = this->create_closure(no, &hold_enclosing_vars,
+ location);
+
+ return Expression::make_func_reference(no, closure, location);
+}
+
+// Create a closure for the nested function FUNCTION. This is based
+// on ENCLOSING_VARS, which is a list of all variables defined in
+// enclosing functions and referenced from FUNCTION. A closure is the
+// address of a struct which contains the addresses of all the
+// referenced variables. This returns NULL if no closure is required.
+
+Expression*
+Parse::create_closure(Named_object* function, Enclosing_vars* enclosing_vars,
+ source_location location)
+{
+ if (enclosing_vars->empty())
+ return NULL;
+
+ // Get the variables in order by their field index.
+
+ size_t enclosing_var_count = enclosing_vars->size();
+ std::vector<Enclosing_var> ev(enclosing_var_count);
+ for (Enclosing_vars::const_iterator p = enclosing_vars->begin();
+ p != enclosing_vars->end();
+ ++p)
+ ev[p->index()] = *p;
+
+ // Build an initializer for a composite literal of the closure's
+ // type.
+
+ Named_object* enclosing_function = this->gogo_->current_function();
+ Expression_list* initializer = new Expression_list;
+ for (size_t i = 0; i < enclosing_var_count; ++i)
+ {
+ gcc_assert(ev[i].index() == i);
+ Named_object* var = ev[i].var();
+ Expression* ref;
+ if (ev[i].in_function() == enclosing_function)
+ ref = Expression::make_var_reference(var, location);
+ else
+ ref = this->enclosing_var_reference(ev[i].in_function(), var,
+ location);
+ Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
+ location);
+ initializer->push_back(refaddr);
+ }
+
+ Named_object* closure_var = function->func_value()->closure_var();
+ Struct_type* st = closure_var->var_value()->type()->deref()->struct_type();
+ Expression* cv = Expression::make_struct_composite_literal(st, initializer,
+ location);
+ return Expression::make_heap_composite(cv, location);
+}
+
+// PrimaryExpr = Operand { Selector | Index | Slice | TypeGuard | Call } .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ source_location start_loc = this->location();
+ bool is_parenthesized = this->peek_token()->is_op(OPERATOR_LPAREN);
+
+ Expression* ret = this->operand(may_be_sink);
+
+ // An unknown name followed by a curly brace must be a composite
+ // literal, and the unknown name must be a type.
+ if (may_be_composite_lit
+ && !is_parenthesized
+ && ret->unknown_expression() != NULL
+ && this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ Named_object* no = ret->unknown_expression()->named_object();
+ Type* type = Type::make_forward_declaration(no);
+ ret = Expression::make_type(type, ret->location());
+ }
+
+ // We handle composite literals and type casts here, as it is the
+ // easiest way to handle types which are in parentheses, as in
+ // "((uint))(1)".
+ if (ret->is_type_expression())
+ {
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (is_parenthesized)
+ error_at(start_loc,
+ "cannot parenthesize type in composite literal");
+ ret = this->composite_lit(ret->type(), 0, ret->location());
+ }
+ else if (this->peek_token()->is_op(OPERATOR_LPAREN))
+ {
+ source_location loc = this->location();
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true,
+ NULL);
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "expected %<)%>");
+ else
+ this->advance_token();
+ if (expr->is_error_expression())
+ return expr;
+ ret = Expression::make_cast(ret->type(), expr, loc);
+ }
+ }
+
+ while (true)
+ {
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_LPAREN))
+ ret = this->call(this->verify_not_sink(ret));
+ else if (token->is_op(OPERATOR_DOT))
+ {
+ ret = this->selector(this->verify_not_sink(ret), is_type_switch);
+ if (is_type_switch != NULL && *is_type_switch)
+ break;
+ }
+ else if (token->is_op(OPERATOR_LSQUARE))
+ ret = this->index(this->verify_not_sink(ret));
+ else
+ break;
+ }
+
+ return ret;
+}
+
+// Selector = "." identifier .
+// TypeGuard = "." "(" QualifiedIdent ")" .
+
+// Note that Operand can expand to QualifiedIdent, which contains a
+// ".". That is handled directly in operand when it sees a package
+// name.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::selector(Expression* left, bool* is_type_switch)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_DOT));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ if (token->is_identifier())
+ {
+ // This could be a field in a struct, or a method in an
+ // interface, or a method associated with a type. We can't know
+ // which until we have seen all the types.
+ std::string name =
+ this->gogo_->pack_hidden_name(token->identifier(),
+ token->is_identifier_exported());
+ if (token->identifier() == "_")
+ {
+ error_at(this->location(), "invalid use of %<_%>");
+ name = this->gogo_->pack_hidden_name("blank", false);
+ }
+ this->advance_token();
+ return Expression::make_selector(left, name, location);
+ }
+ else if (token->is_op(OPERATOR_LPAREN))
+ {
+ this->advance_token();
+ Type* type = NULL;
+ if (!this->peek_token()->is_keyword(KEYWORD_TYPE))
+ type = this->type();
+ else
+ {
+ if (is_type_switch != NULL)
+ *is_type_switch = true;
+ else
+ {
+ error_at(this->location(),
+ "use of %<.(type)%> outside type switch");
+ type = Type::make_error_type();
+ }
+ this->advance_token();
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+ return Expression::make_type_guard(left, type, location);
+ }
+ else
+ {
+ error_at(this->location(), "expected identifier or %<(%>");
+ return left;
+ }
+}
+
+// Index = "[" Expression "]" .
+// Slice = "[" Expression ":" [ Expression ] "]" .
+
+Expression*
+Parse::index(Expression* expr)
+{
+ source_location location = this->location();
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LSQUARE));
+ this->advance_token();
+
+ Expression* start;
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ start = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ else
+ {
+ mpz_t zero;
+ mpz_init_set_ui(zero, 0);
+ start = Expression::make_integer(&zero, NULL, location);
+ mpz_clear(zero);
+ }
+
+ Expression* end = NULL;
+ if (this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ // We use nil to indicate a missing high expression.
+ if (this->advance_token()->is_op(OPERATOR_RSQUARE))
+ end = Expression::make_nil(this->location());
+ else
+ end = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ }
+ if (!this->peek_token()->is_op(OPERATOR_RSQUARE))
+ error_at(this->location(), "missing %<]%>");
+ else
+ this->advance_token();
+ return Expression::make_index(expr, start, end, location);
+}
+
+// Call = "(" [ ArgumentList [ "," ] ] ")" .
+// ArgumentList = ExpressionList [ "..." ] .
+
+Expression*
+Parse::call(Expression* func)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_LPAREN));
+ Expression_list* args = NULL;
+ bool is_varargs = false;
+ const Token* token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ {
+ args = this->expression_list(NULL, false);
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_ELLIPSIS))
+ {
+ is_varargs = true;
+ token = this->advance_token();
+ }
+ }
+ if (token->is_op(OPERATOR_COMMA))
+ token = this->advance_token();
+ if (!token->is_op(OPERATOR_RPAREN))
+ error_at(this->location(), "missing %<)%>");
+ else
+ this->advance_token();
+ if (func->is_error_expression())
+ return func;
+ return Expression::make_call(func, args, is_varargs, func->location());
+}
+
+// Return an expression for a single unqualified identifier.
+
+Expression*
+Parse::id_to_expression(const std::string& name, source_location location)
+{
+ Named_object* in_function;
+ Named_object* named_object = this->gogo_->lookup(name, &in_function);
+ if (named_object == NULL)
+ named_object = this->gogo_->add_unknown_name(name, location);
+
+ if (in_function != NULL
+ && in_function != this->gogo_->current_function()
+ && (named_object->is_variable() || named_object->is_result_variable()))
+ return this->enclosing_var_reference(in_function, named_object,
+ location);
+
+ switch (named_object->classification())
+ {
+ case Named_object::NAMED_OBJECT_CONST:
+ return Expression::make_const_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_VAR:
+ case Named_object::NAMED_OBJECT_RESULT_VAR:
+ return Expression::make_var_reference(named_object, location);
+ case Named_object::NAMED_OBJECT_SINK:
+ return Expression::make_sink(location);
+ case Named_object::NAMED_OBJECT_FUNC:
+ case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
+ return Expression::make_func_reference(named_object, NULL, location);
+ case Named_object::NAMED_OBJECT_UNKNOWN:
+ return Expression::make_unknown_reference(named_object, location);
+ default:
+ error_at(this->location(), "unexpected type of identifier");
+ return Expression::make_error(location);
+ }
+}
+
+// Expression = UnaryExpr { binary_op Expression } .
+
+// PRECEDENCE is the precedence of the current operator.
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::expression(Precedence precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch)
+{
+ Expression* left = this->unary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+
+ while (true)
+ {
+ if (is_type_switch != NULL && *is_type_switch)
+ return left;
+
+ const Token* token = this->peek_token();
+ if (token->classification() != Token::TOKEN_OPERATOR)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Precedence right_precedence;
+ switch (token->op())
+ {
+ case OPERATOR_OROR:
+ right_precedence = PRECEDENCE_OROR;
+ break;
+ case OPERATOR_ANDAND:
+ right_precedence = PRECEDENCE_ANDAND;
+ break;
+ case OPERATOR_EQEQ:
+ case OPERATOR_NOTEQ:
+ case OPERATOR_LT:
+ case OPERATOR_LE:
+ case OPERATOR_GT:
+ case OPERATOR_GE:
+ right_precedence = PRECEDENCE_RELOP;
+ break;
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_OR:
+ case OPERATOR_XOR:
+ right_precedence = PRECEDENCE_ADDOP;
+ break;
+ case OPERATOR_MULT:
+ case OPERATOR_DIV:
+ case OPERATOR_MOD:
+ case OPERATOR_LSHIFT:
+ case OPERATOR_RSHIFT:
+ case OPERATOR_AND:
+ case OPERATOR_BITCLEAR:
+ right_precedence = PRECEDENCE_MULOP;
+ break;
+ default:
+ right_precedence = PRECEDENCE_INVALID;
+ break;
+ }
+
+ if (right_precedence == PRECEDENCE_INVALID)
+ {
+ // Not a binary_op.
+ return left;
+ }
+
+ Operator op = token->op();
+ source_location binop_location = token->location();
+
+ if (precedence >= right_precedence)
+ {
+ // We've already seen A * B, and we see + C. We want to
+ // return so that A * B becomes a group.
+ return left;
+ }
+
+ this->advance_token();
+
+ left = this->verify_not_sink(left);
+ Expression* right = this->expression(right_precedence, false,
+ may_be_composite_lit,
+ NULL);
+ left = Expression::make_binary(op, left, right, binop_location);
+ }
+}
+
+bool
+Parse::expression_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_INVALID:
+ case Token::TOKEN_EOF:
+ return false;
+ case Token::TOKEN_KEYWORD:
+ switch (token->keyword())
+ {
+ case KEYWORD_CHAN:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+ case Token::TOKEN_STRING:
+ return true;
+ case Token::TOKEN_OPERATOR:
+ switch (token->op())
+ {
+ case OPERATOR_PLUS:
+ case OPERATOR_MINUS:
+ case OPERATOR_NOT:
+ case OPERATOR_XOR:
+ case OPERATOR_MULT:
+ case OPERATOR_CHANOP:
+ case OPERATOR_AND:
+ case OPERATOR_LPAREN:
+ case OPERATOR_LSQUARE:
+ return true;
+ default:
+ return false;
+ }
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+ default:
+ gcc_unreachable();
+ }
+}
+
+// UnaryExpr = unary_op UnaryExpr | PrimaryExpr .
+
+// If MAY_BE_SINK is true, this expression may be "_".
+
+// If MAY_BE_COMPOSITE_LIT is true, this expression may be a composite
+// literal.
+
+// If IS_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch)
+{
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_PLUS)
+ || token->is_op(OPERATOR_MINUS)
+ || token->is_op(OPERATOR_NOT)
+ || token->is_op(OPERATOR_XOR)
+ || token->is_op(OPERATOR_CHANOP)
+ || token->is_op(OPERATOR_MULT)
+ || token->is_op(OPERATOR_AND))
+ {
+ source_location location = token->location();
+ Operator op = token->op();
+ this->advance_token();
+
+ if (op == OPERATOR_CHANOP
+ && this->peek_token()->is_keyword(KEYWORD_CHAN))
+ {
+ // This is "<- chan" which must be the start of a type.
+ this->unget_token(Token::make_operator_token(op, location));
+ return Expression::make_type(this->type(), location);
+ }
+
+ Expression* expr = this->unary_expr(false, may_be_composite_lit, NULL);
+ if (expr->is_error_expression())
+ ;
+ else if (op == OPERATOR_MULT && expr->is_type_expression())
+ expr = Expression::make_type(Type::make_pointer_type(expr->type()),
+ location);
+ else if (op == OPERATOR_AND && expr->is_composite_literal())
+ expr = Expression::make_heap_composite(expr, location);
+ else if (op != OPERATOR_CHANOP)
+ expr = Expression::make_unary(op, expr, location);
+ else
+ expr = Expression::make_receive(expr, location);
+ return expr;
+ }
+ else
+ return this->primary_expr(may_be_sink, may_be_composite_lit,
+ is_type_switch);
+}
+
+// Statement =
+// Declaration | LabeledStmt | SimpleStmt |
+// GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
+// FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
+// DeferStmt .
+
+// LABEL is the label of this statement if it has one.
+
+void
+Parse::statement(const Label* label)
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ this->declaration();
+ break;
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ this->go_or_defer_stat();
+ break;
+ case KEYWORD_RETURN:
+ this->return_stat();
+ break;
+ case KEYWORD_BREAK:
+ this->break_stat();
+ break;
+ case KEYWORD_CONTINUE:
+ this->continue_stat();
+ break;
+ case KEYWORD_GOTO:
+ this->goto_stat();
+ break;
+ case KEYWORD_IF:
+ this->if_stat();
+ break;
+ case KEYWORD_SWITCH:
+ this->switch_stat(label);
+ break;
+ case KEYWORD_SELECT:
+ this->select_stat(label);
+ break;
+ case KEYWORD_FOR:
+ this->for_stat(label);
+ break;
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+ if (this->advance_token()->is_op(OPERATOR_COLON))
+ {
+ this->advance_token();
+ this->labeled_stmt(identifier, location);
+ }
+ else
+ {
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ location));
+ this->simple_stat(true, false, NULL, NULL);
+ }
+ }
+ break;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY))
+ {
+ source_location location = token->location();
+ this->gogo_->start_block(location);
+ source_location end_loc = this->block();
+ this->gogo_->add_block(this->gogo_->finish_block(end_loc),
+ location);
+ }
+ else if (!token->is_op(OPERATOR_SEMICOLON))
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ this->simple_stat(true, false, NULL, NULL);
+ break;
+
+ default:
+ error_at(this->location(), "expected statement");
+ this->advance_token();
+ break;
+ }
+}
+
+bool
+Parse::statement_may_start_here()
+{
+ const Token* token = this->peek_token();
+ switch (token->classification())
+ {
+ case Token::TOKEN_KEYWORD:
+ {
+ switch (token->keyword())
+ {
+ case KEYWORD_CONST:
+ case KEYWORD_TYPE:
+ case KEYWORD_VAR:
+ case KEYWORD_FUNC:
+ case KEYWORD_MAP:
+ case KEYWORD_STRUCT:
+ case KEYWORD_INTERFACE:
+ case KEYWORD_GO:
+ case KEYWORD_DEFER:
+ case KEYWORD_RETURN:
+ case KEYWORD_BREAK:
+ case KEYWORD_CONTINUE:
+ case KEYWORD_GOTO:
+ case KEYWORD_IF:
+ case KEYWORD_SWITCH:
+ case KEYWORD_SELECT:
+ case KEYWORD_FOR:
+ return true;
+
+ default:
+ return false;
+ }
+ }
+ break;
+
+ case Token::TOKEN_IDENTIFIER:
+ return true;
+
+ case Token::TOKEN_OPERATOR:
+ if (token->is_op(OPERATOR_LCURLY)
+ || token->is_op(OPERATOR_SEMICOLON))
+ return true;
+ else
+ return this->expression_may_start_here();
+
+ case Token::TOKEN_STRING:
+ case Token::TOKEN_INTEGER:
+ case Token::TOKEN_FLOAT:
+ case Token::TOKEN_IMAGINARY:
+ return true;
+
+ default:
+ return false;
+ }
+}
+
+// LabeledStmt = Label ":" Statement .
+// Label = identifier .
+
+void
+Parse::labeled_stmt(const std::string& label_name, source_location location)
+{
+ Label* label = this->gogo_->add_label_definition(label_name, location);
+
+ if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ // This is a label at the end of a block. A program is
+ // permitted to omit a semicolon here.
+ return;
+ }
+
+ if (!this->statement_may_start_here())
+ {
+ error_at(location, "missing statement after label");
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ location));
+ return;
+ }
+
+ this->statement(label);
+}
+
+// SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt |
+// Assignment | ShortVarDecl .
+
+// EmptyStmt was handled in Parse::statement.
+
+// In order to make this work for if and switch statements, if
+// RETURN_EXP is true, and we see an ExpressionStat, we return the
+// expression rather than adding an expression statement to the
+// current block. If we see something other than an ExpressionStat,
+// we add the statement and return NULL.
+
+// If P_RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+// If P_TYPE_SWITCH is not NULL, this will recognize a type switch
+// guard (var := expr.("type") using the literal keyword "type").
+
+Expression*
+Parse::simple_stat(bool may_be_composite_lit, bool return_exp,
+ Range_clause* p_range_clause, Type_switch* p_type_switch)
+{
+ const Token* token = this->peek_token();
+
+ // An identifier follow by := is a SimpleVarDecl.
+ if (token->is_identifier())
+ {
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location location = token->location();
+
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ)
+ || token->is_op(OPERATOR_COMMA))
+ {
+ identifier = this->gogo_->pack_hidden_name(identifier, is_exported);
+ this->simple_var_decl_or_assignment(identifier, location,
+ p_range_clause,
+ (token->is_op(OPERATOR_COLONEQ)
+ ? p_type_switch
+ : NULL));
+ return NULL;
+ }
+
+ this->unget_token(Token::make_identifier_token(identifier, is_exported,
+ location));
+ }
+
+ Expression* exp = this->expression(PRECEDENCE_NORMAL, true,
+ may_be_composite_lit,
+ (p_type_switch == NULL
+ ? NULL
+ : &p_type_switch->found));
+ if (p_type_switch != NULL && p_type_switch->found)
+ {
+ p_type_switch->name.clear();
+ p_type_switch->location = exp->location();
+ p_type_switch->expr = this->verify_not_sink(exp);
+ return NULL;
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_CHANOP))
+ this->send_stmt(this->verify_not_sink(exp));
+ else if (token->is_op(OPERATOR_PLUSPLUS)
+ || token->is_op(OPERATOR_MINUSMINUS))
+ this->inc_dec_stat(this->verify_not_sink(exp));
+ else if (token->is_op(OPERATOR_COMMA)
+ || token->is_op(OPERATOR_EQ))
+ this->assignment(exp, p_range_clause);
+ else if (token->is_op(OPERATOR_PLUSEQ)
+ || token->is_op(OPERATOR_MINUSEQ)
+ || token->is_op(OPERATOR_OREQ)
+ || token->is_op(OPERATOR_XOREQ)
+ || token->is_op(OPERATOR_MULTEQ)
+ || token->is_op(OPERATOR_DIVEQ)
+ || token->is_op(OPERATOR_MODEQ)
+ || token->is_op(OPERATOR_LSHIFTEQ)
+ || token->is_op(OPERATOR_RSHIFTEQ)
+ || token->is_op(OPERATOR_ANDEQ)
+ || token->is_op(OPERATOR_BITCLEAREQ))
+ this->assignment(this->verify_not_sink(exp), p_range_clause);
+ else if (return_exp)
+ return this->verify_not_sink(exp);
+ else
+ this->expression_stat(this->verify_not_sink(exp));
+
+ return NULL;
+}
+
+bool
+Parse::simple_stat_may_start_here()
+{
+ return this->expression_may_start_here();
+}
+
+// Parse { Statement ";" } which is used in a few places. The list of
+// statements may end with a right curly brace, in which case the
+// semicolon may be omitted.
+
+void
+Parse::statement_list()
+{
+ while (this->statement_may_start_here())
+ {
+ this->statement(NULL);
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (this->peek_token()->is_op(OPERATOR_RCURLY))
+ break;
+ else
+ {
+ if (!this->peek_token()->is_eof() || !saw_errors())
+ error_at(this->location(), "expected %<;%> or %<}%> or newline");
+ if (!this->skip_past_error(OPERATOR_RCURLY))
+ return;
+ }
+ }
+}
+
+bool
+Parse::statement_list_may_start_here()
+{
+ return this->statement_may_start_here();
+}
+
+// ExpressionStat = Expression .
+
+void
+Parse::expression_stat(Expression* exp)
+{
+ exp->discarding_value();
+ this->gogo_->add_statement(Statement::make_statement(exp));
+}
+
+// SendStmt = Channel "<-" Expression .
+// Channel = Expression .
+
+void
+Parse::send_stmt(Expression* channel)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_CHANOP));
+ source_location loc = this->location();
+ this->advance_token();
+ Expression* val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ Statement* s = Statement::make_send_statement(channel, val, loc);
+ this->gogo_->add_statement(s);
+}
+
+// IncDecStat = Expression ( "++" | "--" ) .
+
+void
+Parse::inc_dec_stat(Expression* exp)
+{
+ const Token* token = this->peek_token();
+
+ // Lvalue maps require special handling.
+ if (exp->index_expression() != NULL)
+ exp->index_expression()->set_is_lvalue();
+
+ if (token->is_op(OPERATOR_PLUSPLUS))
+ this->gogo_->add_statement(Statement::make_inc_statement(exp));
+ else if (token->is_op(OPERATOR_MINUSMINUS))
+ this->gogo_->add_statement(Statement::make_dec_statement(exp));
+ else
+ gcc_unreachable();
+ this->advance_token();
+}
+
+// Assignment = ExpressionList assign_op ExpressionList .
+
+// EXP is an expression that we have already parsed.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::assignment(Expression* expr, Range_clause* p_range_clause)
+{
+ Expression_list* vars;
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ {
+ vars = new Expression_list();
+ vars->push_back(expr);
+ }
+ else
+ {
+ this->advance_token();
+ vars = this->expression_list(expr, true);
+ }
+
+ this->tuple_assignment(vars, p_range_clause);
+}
+
+// An assignment statement. LHS is the list of expressions which
+// appear on the left hand side.
+
+// If RANGE_CLAUSE is not NULL, then this will recognize a
+// RangeClause.
+
+void
+Parse::tuple_assignment(Expression_list* lhs, Range_clause* p_range_clause)
+{
+ const Token* token = this->peek_token();
+ if (!token->is_op(OPERATOR_EQ)
+ && !token->is_op(OPERATOR_PLUSEQ)
+ && !token->is_op(OPERATOR_MINUSEQ)
+ && !token->is_op(OPERATOR_OREQ)
+ && !token->is_op(OPERATOR_XOREQ)
+ && !token->is_op(OPERATOR_MULTEQ)
+ && !token->is_op(OPERATOR_DIVEQ)
+ && !token->is_op(OPERATOR_MODEQ)
+ && !token->is_op(OPERATOR_LSHIFTEQ)
+ && !token->is_op(OPERATOR_RSHIFTEQ)
+ && !token->is_op(OPERATOR_ANDEQ)
+ && !token->is_op(OPERATOR_BITCLEAREQ))
+ {
+ error_at(this->location(), "expected assignment operator");
+ return;
+ }
+ Operator op = token->op();
+ source_location location = token->location();
+
+ token = this->advance_token();
+
+ if (p_range_clause != NULL && token->is_keyword(KEYWORD_RANGE))
+ {
+ if (op != OPERATOR_EQ)
+ error_at(this->location(), "range clause requires %<=%>");
+ this->range_clause_expr(lhs, p_range_clause);
+ return;
+ }
+
+ Expression_list* vals = this->expression_list(NULL, false);
+
+ // We've parsed everything; check for errors.
+ if (lhs == NULL || vals == NULL)
+ return;
+ for (Expression_list::const_iterator pe = lhs->begin();
+ pe != lhs->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ if (op != OPERATOR_EQ && (*pe)->is_sink_expression())
+ error_at((*pe)->location(), "cannot use _ as value");
+ }
+ for (Expression_list::const_iterator pe = vals->begin();
+ pe != vals->end();
+ ++pe)
+ {
+ if ((*pe)->is_error_expression())
+ return;
+ }
+
+ // Map expressions act differently when they are lvalues.
+ for (Expression_list::iterator plv = lhs->begin();
+ plv != lhs->end();
+ ++plv)
+ if ((*plv)->index_expression() != NULL)
+ (*plv)->index_expression()->set_is_lvalue();
+
+ Call_expression* call;
+ Index_expression* map_index;
+ Receive_expression* receive;
+ Type_guard_expression* type_guard;
+ if (lhs->size() == vals->size())
+ {
+ Statement* s;
+ if (lhs->size() > 1)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple values only permitted with %<=%>");
+ s = Statement::make_tuple_assignment(lhs, vals, location);
+ }
+ else
+ {
+ if (op == OPERATOR_EQ)
+ s = Statement::make_assignment(lhs->front(), vals->front(),
+ location);
+ else
+ s = Statement::make_assignment_operation(op, lhs->front(),
+ vals->front(), location);
+ delete lhs;
+ delete vals;
+ }
+ this->gogo_->add_statement(s);
+ }
+ else if (vals->size() == 1
+ && (call = (*vals->begin())->call_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "multiple results only permitted with %<=%>");
+ delete vals;
+ vals = new Expression_list;
+ for (unsigned int i = 0; i < lhs->size(); ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ Statement* s = Statement::make_tuple_assignment(lhs, vals, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (map_index = (*vals->begin())->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from map requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* present = lhs->back();
+ Statement* s = Statement::make_tuple_map_assignment(val, present,
+ map_index, location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 1
+ && vals->size() == 2
+ && (map_index = lhs->front()->index_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "assigning tuple to map index requires %<=%>");
+ Expression* val = vals->front();
+ Expression* should_set = vals->back();
+ Statement* s = Statement::make_map_assignment(map_index, val, should_set,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (receive = (*vals->begin())->receive_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from receive requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* success = lhs->back();
+ Expression* channel = receive->channel();
+ Statement* s = Statement::make_tuple_receive_assignment(val, success,
+ channel,
+ false,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else if (lhs->size() == 2
+ && vals->size() == 1
+ && (type_guard = (*vals->begin())->type_guard_expression()) != NULL)
+ {
+ if (op != OPERATOR_EQ)
+ error_at(location, "two values from type guard requires %<=%>");
+ Expression* val = lhs->front();
+ Expression* ok = lhs->back();
+ Expression* expr = type_guard->expr();
+ Type* type = type_guard->type();
+ Statement* s = Statement::make_tuple_type_guard_assignment(val, ok,
+ expr, type,
+ location);
+ this->gogo_->add_statement(s);
+ }
+ else
+ {
+ error_at(location, "number of variables does not match number of values");
+ }
+}
+
+// GoStat = "go" Expression .
+// DeferStat = "defer" Expression .
+
+void
+Parse::go_or_defer_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_GO)
+ || this->peek_token()->is_keyword(KEYWORD_DEFER));
+ bool is_go = this->peek_token()->is_keyword(KEYWORD_GO);
+ source_location stat_location = this->location();
+ this->advance_token();
+ source_location expr_location = this->location();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ Call_expression* call_expr = expr->call_expression();
+ if (call_expr == NULL)
+ {
+ error_at(expr_location, "expected call expression");
+ return;
+ }
+
+ // Make it easier to simplify go/defer statements by putting every
+ // statement in its own block.
+ this->gogo_->start_block(stat_location);
+ Statement* stat;
+ if (is_go)
+ stat = Statement::make_go_statement(call_expr, stat_location);
+ else
+ stat = Statement::make_defer_statement(call_expr, stat_location);
+ this->gogo_->add_statement(stat);
+ this->gogo_->add_block(this->gogo_->finish_block(stat_location),
+ stat_location);
+}
+
+// ReturnStat = "return" [ ExpressionList ] .
+
+void
+Parse::return_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RETURN));
+ source_location location = this->location();
+ this->advance_token();
+ Expression_list* vals = NULL;
+ if (this->expression_may_start_here())
+ vals = this->expression_list(NULL, false);
+ const Function* function = this->gogo_->current_function()->func_value();
+ const Typed_identifier_list* results = function->type()->results();
+ this->gogo_->add_statement(Statement::make_return_statement(results, vals,
+ location));
+}
+
+// IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" Statement ] .
+
+void
+Parse::if_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_IF));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ Expression* cond = NULL;
+ if (this->simple_stat_may_start_here())
+ cond = this->simple_stat(false, true, NULL, NULL);
+ if (cond != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+ if (cond == NULL)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ cond = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ }
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* then_block = this->gogo_->finish_block(end_loc);
+
+ // Check for the easy error of a newline before "else".
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ source_location semi_loc = this->location();
+ if (this->advance_token()->is_keyword(KEYWORD_ELSE))
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<else%>");
+ else
+ this->unget_token(Token::make_operator_token(OPERATOR_SEMICOLON,
+ semi_loc));
+ }
+
+ Block* else_block = NULL;
+ if (this->peek_token()->is_keyword(KEYWORD_ELSE))
+ {
+ this->advance_token();
+ // We create a block to gather the statement.
+ this->gogo_->start_block(this->location());
+ this->statement(NULL);
+ else_block = this->gogo_->finish_block(this->location());
+ }
+
+ this->gogo_->add_statement(Statement::make_if_statement(cond, then_block,
+ else_block,
+ location));
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
+// ExprSwitchStmt = "switch" [ [ SimpleStat ] ";" ] [ Expression ]
+// "{" { ExprCaseClause } "}" .
+// TypeSwitchStmt = "switch" [ [ SimpleStat ] ";" ] TypeSwitchGuard
+// "{" { TypeCaseClause } "}" .
+// TypeSwitchGuard = [ identifier ":=" ] Expression "." "(" "type" ")" .
+
+void
+Parse::switch_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_SWITCH));
+ source_location location = this->location();
+ this->advance_token();
+
+ this->gogo_->start_block(location);
+
+ Expression* switch_val = NULL;
+ Type_switch type_switch;
+ if (this->simple_stat_may_start_here())
+ switch_val = this->simple_stat(false, true, NULL, &type_switch);
+ if (switch_val != NULL && this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ // The SimpleStat is an expression statement.
+ this->expression_stat(switch_val);
+ switch_val = NULL;
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ if (this->peek_token()->is_identifier())
+ {
+ const Token* token = this->peek_token();
+ std::string identifier = token->identifier();
+ bool is_exported = token->is_identifier_exported();
+ source_location id_loc = token->location();
+
+ token = this->advance_token();
+ bool is_coloneq = token->is_op(OPERATOR_COLONEQ);
+ this->unget_token(Token::make_identifier_token(identifier,
+ is_exported,
+ id_loc));
+ if (is_coloneq)
+ {
+ // This must be a TypeSwitchGuard.
+ switch_val = this->simple_stat(false, true, NULL,
+ &type_switch);
+ if (!type_switch.found)
+ {
+ if (switch_val == NULL
+ || !switch_val->is_error_expression())
+ {
+ error_at(id_loc, "expected type switch assignment");
+ switch_val = Expression::make_error(id_loc);
+ }
+ }
+ }
+ }
+ if (switch_val == NULL && !type_switch.found)
+ {
+ switch_val = this->expression(PRECEDENCE_NORMAL, false, false,
+ &type_switch.found);
+ if (type_switch.found)
+ {
+ type_switch.name.clear();
+ type_switch.expr = switch_val;
+ type_switch.location = switch_val->location();
+ }
+ }
+ }
+ }
+
+ if (!this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = this->location();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+ return;
+ }
+ }
+ this->advance_token();
+
+ Statement* statement;
+ if (type_switch.found)
+ statement = this->type_switch_body(label, type_switch, location);
+ else
+ statement = this->expr_switch_body(label, switch_val, location);
+
+ if (statement != NULL)
+ this->gogo_->add_statement(statement);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// The body of an expression switch.
+// "{" { ExprCaseClause } "}"
+
+Statement*
+Parse::expr_switch_body(const Label* label, Expression* switch_val,
+ source_location location)
+{
+ Switch_statement* statement = Statement::make_switch_statement(switch_val,
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Case_clauses* case_clauses = new Case_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ if (!saw_errors())
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->expr_case_clause(case_clauses, &saw_default);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// ExprCaseClause = ExprSwitchCase ":" [ StatementList ] .
+// FallthroughStat = "fallthrough" .
+
+void
+Parse::expr_case_clause(Case_clauses* clauses, bool* saw_default)
+{
+ source_location location = this->location();
+
+ bool is_default = false;
+ Expression_list* vals = this->expr_switch_case(&is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<:%>");
+ return;
+ }
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ bool is_fallthrough = false;
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ is_fallthrough = true;
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default)
+ {
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in switch");
+ return;
+ }
+ *saw_default = true;
+ }
+
+ if (is_default || vals != NULL)
+ clauses->add(vals, is_default, statements, is_fallthrough, location);
+}
+
+// ExprSwitchCase = "case" ExpressionList | "default" .
+
+Expression_list*
+Parse::expr_switch_case(bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ return this->expression_list(NULL, false);
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ return NULL;
+ }
+ else
+ {
+ if (!saw_errors())
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return NULL;
+ }
+}
+
+// The body of a type switch.
+// "{" { TypeCaseClause } "}" .
+
+Statement*
+Parse::type_switch_body(const Label* label, const Type_switch& type_switch,
+ source_location location)
+{
+ Named_object* switch_no = NULL;
+ if (!type_switch.name.empty())
+ {
+ Variable* switch_var = new Variable(NULL, type_switch.expr, false, false,
+ false, type_switch.location);
+ switch_no = this->gogo_->add_variable(type_switch.name, switch_var);
+ }
+
+ Type_switch_statement* statement =
+ Statement::make_type_switch_statement(switch_no,
+ (switch_no == NULL
+ ? type_switch.expr
+ : NULL),
+ location);
+
+ this->push_break_statement(statement, label);
+
+ Type_case_clauses* case_clauses = new Type_case_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "missing %<}%>");
+ return NULL;
+ }
+ this->type_case_clause(switch_no, case_clauses, &saw_default);
+ }
+ this->advance_token();
+
+ statement->add_clauses(case_clauses);
+
+ this->pop_break_statement();
+
+ return statement;
+}
+
+// TypeCaseClause = TypeSwitchCase ":" [ StatementList ] .
+
+void
+Parse::type_case_clause(Named_object* switch_no, Type_case_clauses* clauses,
+ bool* saw_default)
+{
+ source_location location = this->location();
+
+ std::vector<Type*> types;
+ bool is_default = false;
+ this->type_switch_case(&types, &is_default);
+
+ if (!this->peek_token()->is_op(OPERATOR_COLON))
+ error_at(this->location(), "expected %<:%>");
+ else
+ this->advance_token();
+
+ Block* statements = NULL;
+ if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+ if (switch_no != NULL && types.size() == 1)
+ {
+ Type* type = types.front();
+ Expression* init = Expression::make_var_reference(switch_no,
+ location);
+ init = Expression::make_type_guard(init, type, location);
+ Variable* v = new Variable(type, init, false, false, false,
+ location);
+ v->set_is_type_switch_var();
+ this->gogo_->add_variable(switch_no->name(), v);
+ }
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ if (this->peek_token()->is_keyword(KEYWORD_FALLTHROUGH))
+ {
+ error_at(this->location(),
+ "fallthrough is not permitted in a type switch");
+ if (this->advance_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+
+ if (is_default)
+ {
+ gcc_assert(types.empty());
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in type switch");
+ return;
+ }
+ *saw_default = true;
+ clauses->add(NULL, false, true, statements, location);
+ }
+ else if (!types.empty())
+ {
+ for (std::vector<Type*>::const_iterator p = types.begin();
+ p + 1 != types.end();
+ ++p)
+ clauses->add(*p, true, false, NULL, location);
+ clauses->add(types.back(), false, false, statements, location);
+ }
+ else
+ clauses->add(Type::make_error_type(), false, false, statements, location);
+}
+
+// TypeSwitchCase = "case" type | "default"
+
+// We accept a comma separated list of types.
+
+void
+Parse::type_switch_case(std::vector<Type*>* types, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ while (true)
+ {
+ Type* t = this->type();
+ if (!t->is_error_type())
+ types->push_back(t);
+ if (!this->peek_token()->is_op(OPERATOR_COMMA))
+ break;
+ this->advance_token();
+ }
+ }
+ else if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ }
+}
+
+// SelectStat = "select" "{" { CommClause } "}" .
+
+void
+Parse::select_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_SELECT));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ source_location token_loc = token->location();
+ if (token->is_op(OPERATOR_SEMICOLON)
+ && this->advance_token()->is_op(OPERATOR_LCURLY))
+ error_at(token_loc, "unexpected semicolon or newline before %<{%>");
+ else
+ {
+ error_at(this->location(), "expected %<{%>");
+ return;
+ }
+ }
+ this->advance_token();
+
+ Select_statement* statement = Statement::make_select_statement(location);
+
+ this->push_break_statement(statement, label);
+
+ Select_clauses* select_clauses = new Select_clauses();
+ bool saw_default = false;
+ while (!this->peek_token()->is_op(OPERATOR_RCURLY))
+ {
+ if (this->peek_token()->is_eof())
+ {
+ error_at(this->location(), "expected %<}%>");
+ return;
+ }
+ this->comm_clause(select_clauses, &saw_default);
+ }
+
+ this->advance_token();
+
+ statement->add_clauses(select_clauses);
+
+ this->pop_break_statement();
+
+ this->gogo_->add_statement(statement);
+}
+
+// CommClause = CommCase ":" { Statement ";" } .
+
+void
+Parse::comm_clause(Select_clauses* clauses, bool* saw_default)
+{
+ source_location location = this->location();
+ bool is_send = false;
+ Expression* channel = NULL;
+ Expression* val = NULL;
+ Expression* closed = NULL;
+ std::string varname;
+ std::string closedname;
+ bool is_default = false;
+ bool got_case = this->comm_case(&is_send, &channel, &val, &closed,
+ &varname, &closedname, &is_default);
+
+ if (this->peek_token()->is_op(OPERATOR_COLON))
+ this->advance_token();
+ else
+ error_at(this->location(), "expected colon");
+
+ Block* statements = NULL;
+ Named_object* var = NULL;
+ Named_object* closedvar = NULL;
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ else if (this->statement_list_may_start_here())
+ {
+ this->gogo_->start_block(this->location());
+
+ if (!varname.empty())
+ {
+ // FIXME: LOCATION is slightly wrong here.
+ Variable* v = new Variable(NULL, channel, false, false, false,
+ location);
+ v->set_type_from_chan_element();
+ var = this->gogo_->add_variable(varname, v);
+ }
+
+ if (!closedname.empty())
+ {
+ // FIXME: LOCATION is slightly wrong here.
+ Variable* v = new Variable(Type::lookup_bool_type(), NULL,
+ false, false, false, location);
+ closedvar = this->gogo_->add_variable(closedname, v);
+ }
+
+ this->statement_list();
+ statements = this->gogo_->finish_block(this->location());
+ }
+
+ if (is_default)
+ {
+ if (*saw_default)
+ {
+ error_at(location, "multiple defaults in select");
+ return;
+ }
+ *saw_default = true;
+ }
+
+ if (got_case)
+ clauses->add(is_send, channel, val, closed, var, closedvar, is_default,
+ statements, location);
+ else if (statements != NULL)
+ {
+ // Add the statements to make sure that any names they define
+ // are traversed.
+ this->gogo_->add_block(statements, location);
+ }
+}
+
+// CommCase = "case" ( SendStmt | RecvStmt ) | "default" .
+
+bool
+Parse::comm_case(bool* is_send, Expression** channel, Expression** val,
+ Expression** closed, std::string* varname,
+ std::string* closedname, bool* is_default)
+{
+ const Token* token = this->peek_token();
+ if (token->is_keyword(KEYWORD_DEFAULT))
+ {
+ this->advance_token();
+ *is_default = true;
+ }
+ else if (token->is_keyword(KEYWORD_CASE))
+ {
+ this->advance_token();
+ if (!this->send_or_recv_stmt(is_send, channel, val, closed, varname,
+ closedname))
+ return false;
+ }
+ else
+ {
+ error_at(this->location(), "expected %<case%> or %<default%>");
+ if (!token->is_op(OPERATOR_RCURLY))
+ this->advance_token();
+ return false;
+ }
+
+ return true;
+}
+
+// RecvStmt = [ Expression [ "," Expression ] ( "=" | ":=" ) ] RecvExpr .
+// RecvExpr = Expression .
+
+bool
+Parse::send_or_recv_stmt(bool* is_send, Expression** channel, Expression** val,
+ Expression** closed, std::string* varname,
+ std::string* closedname)
+{
+ const Token* token = this->peek_token();
+ bool saw_comma = false;
+ bool closed_is_id = false;
+ if (token->is_identifier())
+ {
+ Gogo* gogo = this->gogo_;
+ std::string recv_var = token->identifier();
+ bool is_rv_exported = token->is_identifier_exported();
+ source_location recv_var_loc = token->location();
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ // case rv := <-c:
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "expected %<<-%>");
+ return false;
+ }
+ if (recv_var == "_")
+ {
+ error_at(recv_var_loc,
+ "no new variables on left side of %<:=%>");
+ recv_var = "blank";
+ }
+ *is_send = false;
+ *varname = gogo->pack_hidden_name(recv_var, is_rv_exported);
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+ else if (token->is_op(OPERATOR_COMMA))
+ {
+ token = this->advance_token();
+ if (token->is_identifier())
+ {
+ std::string recv_closed = token->identifier();
+ bool is_rc_exported = token->is_identifier_exported();
+ source_location recv_closed_loc = token->location();
+ closed_is_id = true;
+
+ token = this->advance_token();
+ if (token->is_op(OPERATOR_COLONEQ))
+ {
+ // case rv, rc := <-c:
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "expected %<<-%>");
+ return false;
+ }
+ if (recv_var == "_" && recv_closed == "_")
+ {
+ error_at(recv_var_loc,
+ "no new variables on left side of %<:=%>");
+ recv_var = "blank";
+ }
+ *is_send = false;
+ if (recv_var != "_")
+ *varname = gogo->pack_hidden_name(recv_var,
+ is_rv_exported);
+ if (recv_closed != "_")
+ *closedname = gogo->pack_hidden_name(recv_closed,
+ is_rc_exported);
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true,
+ NULL);
+ return true;
+ }
+
+ this->unget_token(Token::make_identifier_token(recv_closed,
+ is_rc_exported,
+ recv_closed_loc));
+ }
+
+ *val = this->id_to_expression(gogo->pack_hidden_name(recv_var,
+ is_rv_exported),
+ recv_var_loc);
+ saw_comma = true;
+ }
+ else
+ this->unget_token(Token::make_identifier_token(recv_var,
+ is_rv_exported,
+ recv_var_loc));
+ }
+
+ // If SAW_COMMA is false, then we are looking at the start of the
+ // send or receive expression. If SAW_COMMA is true, then *VAL is
+ // set and we just read a comma.
+
+ if (!saw_comma && this->peek_token()->is_op(OPERATOR_CHANOP))
+ {
+ // case <-c:
+ *is_send = false;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+
+ Expression* e = this->expression(PRECEDENCE_NORMAL, true, true, NULL);
+
+ if (this->peek_token()->is_op(OPERATOR_EQ))
+ {
+ if (!this->advance_token()->is_op(OPERATOR_CHANOP))
+ {
+ error_at(this->location(), "missing %<<-%>");
+ return false;
+ }
+ *is_send = false;
+ this->advance_token();
+ *channel = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (saw_comma)
+ {
+ // case v, e = <-c:
+ // *VAL is already set.
+ if (!e->is_sink_expression())
+ *closed = e;
+ }
+ else
+ {
+ // case v = <-c:
+ if (!e->is_sink_expression())
+ *val = e;
+ }
+ return true;
+ }
+
+ if (saw_comma)
+ {
+ if (closed_is_id)
+ error_at(this->location(), "expected %<=%> or %<:=%>");
+ else
+ error_at(this->location(), "expected %<=%>");
+ return false;
+ }
+
+ if (this->peek_token()->is_op(OPERATOR_CHANOP))
+ {
+ // case c <- v:
+ *is_send = true;
+ *channel = this->verify_not_sink(e);
+ this->advance_token();
+ *val = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ return true;
+ }
+
+ error_at(this->location(), "expected %<<-%> or %<=%>");
+ return false;
+}
+
+// ForStat = "for" [ Condition | ForClause | RangeClause ] Block .
+// Condition = Expression .
+
+void
+Parse::for_stat(const Label* label)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_FOR));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+
+ // Open a block to hold any variables defined in the init statement
+ // of the for statement.
+ this->gogo_->start_block(location);
+
+ Block* init = NULL;
+ Expression* cond = NULL;
+ Block* post = NULL;
+ Range_clause range_clause;
+
+ if (!token->is_op(OPERATOR_LCURLY))
+ {
+ if (token->is_keyword(KEYWORD_VAR))
+ {
+ error_at(this->location(),
+ "var declaration not allowed in for initializer");
+ this->var_decl();
+ }
+
+ if (token->is_op(OPERATOR_SEMICOLON))
+ this->for_clause(&cond, &post);
+ else
+ {
+ // We might be looking at a Condition, an InitStat, or a
+ // RangeClause.
+ cond = this->simple_stat(false, true, &range_clause, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ {
+ if (cond == NULL && !range_clause.found)
+ error_at(this->location(), "parse error in for statement");
+ }
+ else
+ {
+ if (range_clause.found)
+ error_at(this->location(), "parse error after range clause");
+
+ if (cond != NULL)
+ {
+ // COND is actually an expression statement for
+ // InitStat at the start of a ForClause.
+ this->expression_stat(cond);
+ cond = NULL;
+ }
+
+ this->for_clause(&cond, &post);
+ }
+ }
+ }
+
+ // Build the For_statement and note that it is the current target
+ // for break and continue statements.
+
+ For_statement* sfor;
+ For_range_statement* srange;
+ Statement* s;
+ if (!range_clause.found)
+ {
+ sfor = Statement::make_for_statement(init, cond, post, location);
+ s = sfor;
+ srange = NULL;
+ }
+ else
+ {
+ srange = Statement::make_for_range_statement(range_clause.index,
+ range_clause.value,
+ range_clause.range,
+ location);
+ s = srange;
+ sfor = NULL;
+ }
+
+ this->push_break_statement(s, label);
+ this->push_continue_statement(s, label);
+
+ // Gather the block of statements in the loop and add them to the
+ // For_statement.
+
+ this->gogo_->start_block(this->location());
+ source_location end_loc = this->block();
+ Block* statements = this->gogo_->finish_block(end_loc);
+
+ if (sfor != NULL)
+ sfor->add_statements(statements);
+ else
+ srange->add_statements(statements);
+
+ // This is no longer the break/continue target.
+ this->pop_break_statement();
+ this->pop_continue_statement();
+
+ // Add the For_statement to the list of statements, and close out
+ // the block we started to hold any variables defined in the for
+ // statement.
+
+ this->gogo_->add_statement(s);
+
+ this->gogo_->add_block(this->gogo_->finish_block(this->location()),
+ location);
+}
+
+// ForClause = [ InitStat ] ";" [ Condition ] ";" [ PostStat ] .
+// InitStat = SimpleStat .
+// PostStat = SimpleStat .
+
+// We have already read InitStat at this point.
+
+void
+Parse::for_clause(Expression** cond, Block** post)
+{
+ gcc_assert(this->peek_token()->is_op(OPERATOR_SEMICOLON));
+ this->advance_token();
+ if (this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ *cond = NULL;
+ else if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ {
+ error_at(this->location(),
+ "unexpected semicolon or newline before %<{%>");
+ *cond = NULL;
+ *post = NULL;
+ return;
+ }
+ else
+ *cond = this->expression(PRECEDENCE_NORMAL, false, true, NULL);
+ if (!this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ error_at(this->location(), "expected semicolon");
+ else
+ this->advance_token();
+
+ if (this->peek_token()->is_op(OPERATOR_LCURLY))
+ *post = NULL;
+ else
+ {
+ this->gogo_->start_block(this->location());
+ this->simple_stat(false, false, NULL, NULL);
+ *post = this->gogo_->finish_block(this->location());
+ }
+}
+
+// RangeClause = IdentifierList ( "=" | ":=" ) "range" Expression .
+
+// This is the := version. It is called with a list of identifiers.
+
+void
+Parse::range_clause_decl(const Typed_identifier_list* til,
+ Range_clause* p_range_clause)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+ source_location location = this->location();
+
+ p_range_clause->found = true;
+
+ gcc_assert(til->size() >= 1);
+ if (til->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ Expression* expr = this->expression(PRECEDENCE_NORMAL, false, false, NULL);
+ p_range_clause->range = expr;
+
+ bool any_new = false;
+
+ const Typed_identifier* pti = &til->front();
+ Named_object* no = this->init_var(*pti, NULL, expr, true, true, &any_new);
+ if (any_new && no->is_variable())
+ no->var_value()->set_type_from_range_index();
+ p_range_clause->index = Expression::make_var_reference(no, location);
+
+ if (til->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ {
+ pti = &til->back();
+ bool is_new = false;
+ no = this->init_var(*pti, NULL, expr, true, true, &is_new);
+ if (is_new && no->is_variable())
+ no->var_value()->set_type_from_range_value();
+ if (is_new)
+ any_new = true;
+ p_range_clause->value = Expression::make_var_reference(no, location);
+ }
+
+ if (!any_new)
+ error_at(location, "variables redeclared but no variable is new");
+}
+
+// The = version of RangeClause. This is called with a list of
+// expressions.
+
+void
+Parse::range_clause_expr(const Expression_list* vals,
+ Range_clause* p_range_clause)
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_RANGE));
+
+ p_range_clause->found = true;
+
+ gcc_assert(vals->size() >= 1);
+ if (vals->size() > 2)
+ error_at(this->location(), "too many variables for range clause");
+
+ this->advance_token();
+ p_range_clause->range = this->expression(PRECEDENCE_NORMAL, false, false,
+ NULL);
+
+ p_range_clause->index = vals->front();
+ if (vals->size() == 1)
+ p_range_clause->value = NULL;
+ else
+ p_range_clause->value = vals->back();
+}
+
+// Push a statement on the break stack.
+
+void
+Parse::push_break_statement(Statement* enclosing, const Label* label)
+{
+ if (this->break_stack_ == NULL)
+ this->break_stack_ = new Bc_stack();
+ this->break_stack_->push_back(std::make_pair(enclosing, label));
+}
+
+// Push a statement on the continue stack.
+
+void
+Parse::push_continue_statement(Statement* enclosing, const Label* label)
+{
+ if (this->continue_stack_ == NULL)
+ this->continue_stack_ = new Bc_stack();
+ this->continue_stack_->push_back(std::make_pair(enclosing, label));
+}
+
+// Pop the break stack.
+
+void
+Parse::pop_break_statement()
+{
+ this->break_stack_->pop_back();
+}
+
+// Pop the continue stack.
+
+void
+Parse::pop_continue_statement()
+{
+ this->continue_stack_->pop_back();
+}
+
+// Find a break or continue statement given a label name.
+
+Statement*
+Parse::find_bc_statement(const Bc_stack* bc_stack, const std::string& label)
+{
+ if (bc_stack == NULL)
+ return NULL;
+ for (Bc_stack::const_reverse_iterator p = bc_stack->rbegin();
+ p != bc_stack->rend();
+ ++p)
+ if (p->second != NULL && p->second->name() == label)
+ return p->first;
+ return NULL;
+}
+
+// BreakStat = "break" [ identifier ] .
+
+void
+Parse::break_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_BREAK));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->break_stack_ == NULL || this->break_stack_->empty())
+ {
+ error_at(this->location(),
+ "break statement not within for or switch or select");
+ return;
+ }
+ enclosing = this->break_stack_->back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(this->break_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ error_at(token->location(),
+ ("break label %qs not associated with "
+ "for or switch or select"),
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SWITCH)
+ label = enclosing->switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_TYPE_SWITCH)
+ label = enclosing->type_switch_statement()->break_label();
+ else if (enclosing->classification() == Statement::STATEMENT_SELECT)
+ label = enclosing->select_statement()->break_label();
+ else
+ gcc_unreachable();
+
+ this->gogo_->add_statement(Statement::make_break_statement(label,
+ location));
+}
+
+// ContinueStat = "continue" [ identifier ] .
+
+void
+Parse::continue_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_CONTINUE));
+ source_location location = this->location();
+
+ const Token* token = this->advance_token();
+ Statement* enclosing;
+ if (!token->is_identifier())
+ {
+ if (this->continue_stack_ == NULL || this->continue_stack_->empty())
+ {
+ error_at(this->location(), "continue statement not within for");
+ return;
+ }
+ enclosing = this->continue_stack_->back().first;
+ }
+ else
+ {
+ enclosing = this->find_bc_statement(this->continue_stack_,
+ token->identifier());
+ if (enclosing == NULL)
+ {
+ error_at(token->location(),
+ "continue label %qs not associated with for",
+ Gogo::message_name(token->identifier()).c_str());
+ this->advance_token();
+ return;
+ }
+ this->advance_token();
+ }
+
+ Unnamed_label* label;
+ if (enclosing->classification() == Statement::STATEMENT_FOR)
+ label = enclosing->for_statement()->continue_label();
+ else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
+ label = enclosing->for_range_statement()->continue_label();
+ else
+ gcc_unreachable();
+
+ this->gogo_->add_statement(Statement::make_continue_statement(label,
+ location));
+}
+
+// GotoStat = "goto" identifier .
+
+void
+Parse::goto_stat()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_GOTO));
+ source_location location = this->location();
+ const Token* token = this->advance_token();
+ if (!token->is_identifier())
+ error_at(this->location(), "expected label for goto");
+ else
+ {
+ Label* label = this->gogo_->add_label_reference(token->identifier());
+ Statement* s = Statement::make_goto_statement(label, location);
+ this->gogo_->add_statement(s);
+ this->advance_token();
+ }
+}
+
+// PackageClause = "package" PackageName .
+
+void
+Parse::package_clause()
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+ std::string name;
+ if (!token->is_keyword(KEYWORD_PACKAGE))
+ {
+ error_at(this->location(), "program must start with package clause");
+ name = "ERROR";
+ }
+ else
+ {
+ token = this->advance_token();
+ if (token->is_identifier())
+ {
+ name = token->identifier();
+ if (name == "_")
+ {
+ error_at(this->location(), "invalid package name _");
+ name = "blank";
+ }
+ this->advance_token();
+ }
+ else
+ {
+ error_at(this->location(), "package name must be an identifier");
+ name = "ERROR";
+ }
+ }
+ this->gogo_->set_package_name(name, location);
+}
+
+// ImportDecl = "import" Decl<ImportSpec> .
+
+void
+Parse::import_decl()
+{
+ gcc_assert(this->peek_token()->is_keyword(KEYWORD_IMPORT));
+ this->advance_token();
+ this->decl(&Parse::import_spec, NULL);
+}
+
+// ImportSpec = [ "." | PackageName ] PackageFileName .
+
+void
+Parse::import_spec(void*)
+{
+ const Token* token = this->peek_token();
+ source_location location = token->location();
+
+ std::string local_name;
+ bool is_local_name_exported = false;
+ if (token->is_op(OPERATOR_DOT))
+ {
+ local_name = ".";
+ token = this->advance_token();
+ }
+ else if (token->is_identifier())
+ {
+ local_name = token->identifier();
+ is_local_name_exported = token->is_identifier_exported();
+ token = this->advance_token();
+ }
+
+ if (!token->is_string())
+ {
+ error_at(this->location(), "missing import package name");
+ return;
+ }
+
+ this->gogo_->import_package(token->string_value(), local_name,
+ is_local_name_exported, location);
+
+ this->advance_token();
+}
+
+// SourceFile = PackageClause ";" { ImportDecl ";" }
+// { TopLevelDecl ";" } .
+
+void
+Parse::program()
+{
+ this->package_clause();
+
+ const Token* token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after package clause");
+
+ while (token->is_keyword(KEYWORD_IMPORT))
+ {
+ this->import_decl();
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else
+ error_at(this->location(),
+ "expected %<;%> or newline after import declaration");
+ }
+
+ while (!token->is_eof())
+ {
+ if (this->declaration_may_start_here())
+ this->declaration();
+ else
+ {
+ error_at(this->location(), "expected declaration");
+ do
+ this->advance_token();
+ while (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON)
+ && !this->peek_token()->is_op(OPERATOR_RCURLY));
+ if (!this->peek_token()->is_eof()
+ && !this->peek_token()->is_op(OPERATOR_SEMICOLON))
+ this->advance_token();
+ }
+ token = this->peek_token();
+ if (token->is_op(OPERATOR_SEMICOLON))
+ token = this->advance_token();
+ else if (!token->is_eof() || !saw_errors())
+ {
+ error_at(this->location(),
+ "expected %<;%> or newline after top level declaration");
+ this->skip_past_error(OPERATOR_INVALID);
+ }
+ }
+}
+
+// Reset the current iota value.
+
+void
+Parse::reset_iota()
+{
+ this->iota_ = 0;
+}
+
+// Return the current iota value.
+
+int
+Parse::iota_value()
+{
+ return this->iota_;
+}
+
+// Increment the current iota value.
+
+void
+Parse::increment_iota()
+{
+ ++this->iota_;
+}
+
+// Skip forward to a semicolon or OP. OP will normally be
+// OPERATOR_RPAREN or OPERATOR_RCURLY. If we find a semicolon, move
+// past it and return. If we find OP, it will be the next token to
+// read. Return true if we are OK, false if we found EOF.
+
+bool
+Parse::skip_past_error(Operator op)
+{
+ const Token* token = this->peek_token();
+ while (!token->is_op(op))
+ {
+ if (token->is_eof())
+ return false;
+ if (token->is_op(OPERATOR_SEMICOLON))
+ {
+ this->advance_token();
+ return true;
+ }
+ token = this->advance_token();
+ }
+ return true;
+}
+
+// Check that an expression is not a sink.
+
+Expression*
+Parse::verify_not_sink(Expression* expr)
+{
+ if (expr->is_sink_expression())
+ {
+ error_at(expr->location(), "cannot use _ as value");
+ expr = Expression::make_error(expr->location());
+ }
+ return expr;
+}
--- /dev/null
+// parse.h -- Go frontend parser. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_PARSE_H
+#define GO_PARSE_H
+
+class Set_iota_traverse;
+class Lex;
+class Gogo;
+class Named_object;
+class Type;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Block;
+class Expression;
+class Expression_list;
+class Struct_field_list;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Statement;
+class Label;
+
+// Parse the program.
+
+class Parse
+{
+ public:
+ Parse(Lex*, Gogo*);
+
+ // Parse a program.
+ void
+ program();
+
+ private:
+ // Precedence values.
+ enum Precedence
+ {
+ PRECEDENCE_INVALID = -1,
+ PRECEDENCE_NORMAL = 0,
+ PRECEDENCE_OROR,
+ PRECEDENCE_ANDAND,
+ PRECEDENCE_CHANOP,
+ PRECEDENCE_RELOP,
+ PRECEDENCE_ADDOP,
+ PRECEDENCE_MULOP
+ };
+
+ // We use this when parsing the range clause of a for statement.
+ struct Range_clause
+ {
+ // Set to true if we found a range clause.
+ bool found;
+ // The index expression.
+ Expression* index;
+ // The value expression.
+ Expression* value;
+ // The range expression.
+ Expression* range;
+
+ Range_clause()
+ : found(false), index(NULL), value(NULL), range(NULL)
+ { }
+ };
+
+ // We use this when parsing the statement at the start of a switch,
+ // in order to recognize type switches.
+ struct Type_switch
+ {
+ // Set to true if we find a type switch.
+ bool found;
+ // The variable name.
+ std::string name;
+ // The location of the variable.
+ source_location location;
+ // The expression.
+ Expression* expr;
+
+ Type_switch()
+ : found(false), name(), location(UNKNOWN_LOCATION), expr(NULL)
+ { }
+ };
+
+ // A variable defined in an enclosing function referenced by the
+ // current function.
+ class Enclosing_var
+ {
+ public:
+ Enclosing_var(Named_object* var, Named_object* in_function,
+ unsigned int index)
+ : var_(var), in_function_(in_function), index_(index)
+ { }
+
+ // We put these in a vector, so we need a default constructor.
+ Enclosing_var()
+ : var_(NULL), in_function_(NULL), index_(-1U)
+ { }
+
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ Named_object*
+ in_function() const
+ { return this->in_function_; }
+
+ unsigned int
+ index() const
+ { return this->index_; }
+
+ private:
+ // The variable which is being referred to.
+ Named_object* var_;
+ // The function where the variable is defined.
+ Named_object* in_function_;
+ // The index of the field in this function's closure struct for
+ // this variable.
+ unsigned int index_;
+ };
+
+ // We store Enclosing_var entries in a set, so we need a comparator.
+ struct Enclosing_var_comparison
+ {
+ bool
+ operator()(const Enclosing_var&, const Enclosing_var&);
+ };
+
+ // A set of Enclosing_var entries.
+ typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
+
+ // Peek at the current token from the lexer.
+ const Token*
+ peek_token();
+
+ // Consume the current token, return the next one.
+ const Token*
+ advance_token();
+
+ // Push a token back on the input stream.
+ void
+ unget_token(const Token&);
+
+ // The location of the current token.
+ source_location
+ location();
+
+ // For break and continue we keep a stack of statements with
+ // associated labels (if any). The top of the stack is used for a
+ // break or continue statement with no label.
+ typedef std::vector<std::pair<Statement*, const Label*> > Bc_stack;
+
+ // Parser nonterminals.
+ void identifier_list(Typed_identifier_list*);
+ Expression_list* expression_list(Expression*, bool may_be_sink);
+ bool qualified_ident(std::string*, Named_object**);
+ Type* type();
+ bool type_may_start_here();
+ Type* type_name(bool issue_error);
+ Type* array_type(bool may_use_ellipsis);
+ Type* map_type();
+ Type* struct_type();
+ void field_decl(Struct_field_list*);
+ Type* pointer_type();
+ Type* channel_type();
+ Function_type* signature(Typed_identifier*, source_location);
+ Typed_identifier_list* parameters(bool* is_varargs);
+ Typed_identifier_list* parameter_list(bool* is_varargs);
+ void parameter_decl(bool, Typed_identifier_list*, bool*, bool*);
+ Typed_identifier_list* result();
+ source_location block();
+ Type* interface_type();
+ bool method_spec(Typed_identifier_list*);
+ void declaration();
+ bool declaration_may_start_here();
+ void decl(void (Parse::*)(void*), void*);
+ void list(void (Parse::*)(void*), void*, bool);
+ void const_decl();
+ void const_spec(Type**, Expression_list**);
+ void type_decl();
+ void type_spec(void*);
+ void var_decl();
+ void var_spec(void*);
+ void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_receive(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq, source_location);
+ bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq,
+ source_location);
+ Named_object* init_var(const Typed_identifier&, Type*, Expression*,
+ bool is_coloneq, bool type_from_init, bool* is_new);
+ void simple_var_decl_or_assignment(const std::string&, source_location,
+ Range_clause*, Type_switch*);
+ void function_decl();
+ Typed_identifier* receiver();
+ Expression* operand(bool may_be_sink);
+ Expression* enclosing_var_reference(Named_object*, Named_object*,
+ source_location);
+ Expression* composite_lit(Type*, int depth, source_location);
+ Expression* function_lit();
+ Expression* create_closure(Named_object* function, Enclosing_vars*,
+ source_location);
+ Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* selector(Expression*, bool* is_type_switch);
+ Expression* index(Expression*);
+ Expression* call(Expression*);
+ Expression* expression(Precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch);
+ bool expression_may_start_here();
+ Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* qualified_expr(Expression*, source_location);
+ Expression* id_to_expression(const std::string&, source_location);
+ void statement(const Label*);
+ bool statement_may_start_here();
+ void labeled_stmt(const std::string&, source_location);
+ Expression* simple_stat(bool, bool, Range_clause*, Type_switch*);
+ bool simple_stat_may_start_here();
+ void statement_list();
+ bool statement_list_may_start_here();
+ void expression_stat(Expression*);
+ void inc_dec_stat(Expression*);
+ void assignment(Expression*, Range_clause*);
+ void tuple_assignment(Expression_list*, Range_clause*);
+ void send();
+ void go_or_defer_stat();
+ void return_stat();
+ void if_stat();
+ void switch_stat(const Label*);
+ Statement* expr_switch_body(const Label*, Expression*, source_location);
+ void expr_case_clause(Case_clauses*);
+ Expression_list* expr_switch_case(bool*);
+ Statement* type_switch_body(const Label*, const Type_switch&,
+ source_location);
+ void type_case_clause(Named_object*, Type_case_clauses*);
+ void type_switch_case(std::vector<Type*>*, bool*);
+ void select_stat(const Label*);
+ void comm_clause(Select_clauses*);
+ bool comm_case(bool*, Expression**, Expression**, std::string*, bool*);
+ bool send_or_recv_expr(bool*, Expression**, Expression**, std::string*);
+ void for_stat(const Label*);
+ void for_clause(Expression**, Block**);
+ void range_clause_decl(const Typed_identifier_list*, Range_clause*);
+ void range_clause_expr(const Expression_list*, Range_clause*);
+ void push_break_statement(Statement*, const Label*);
+ void push_continue_statement(Statement*, const Label*);
+ void pop_break_statement();
+ void pop_continue_statement();
+ Statement* find_bc_statement(const Bc_stack*, const std::string&);
+ void break_stat();
+ void continue_stat();
+ void goto_stat();
+ void package_clause();
+ void import_decl();
+ void import_spec(void*);
+
+ void reset_iota();
+ int iota_value();
+ void increment_iota();
+
+ // Skip past an error looking for a semicolon or OP. Return true if
+ // all is well, false if we found EOF.
+ bool
+ skip_past_error(Operator op);
+
+ // Verify that an expression is not a sink, and return either the
+ // expression or an error.
+ Expression*
+ verify_not_sink(Expression*);
+
+ // Return the statement associated with a label in a Bc_stack, or
+ // NULL.
+ Statement*
+ find_bc_statement(const Bc_stack*, const std::string&) const;
+
+ // The lexer output we are parsing.
+ Lex* lex_;
+ // The current token.
+ Token token_;
+ // A token pushed back on the input stream.
+ Token unget_token_;
+ // Whether unget_token_ is valid.
+ bool unget_token_valid_;
+ // The code we are generating.
+ Gogo* gogo_;
+ // A stack of statements for which break may be used.
+ Bc_stack break_stack_;
+ // A stack of statements for which continue may be used.
+ Bc_stack continue_stack_;
+ // The current iota value.
+ int iota_;
+ // References from the local function to variables defined in
+ // enclosing functions.
+ Enclosing_vars enclosing_vars_;
+};
+
+
+#endif // !defined(GO_PARSE_H)
--- /dev/null
+// parse.h -- Go frontend parser. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_PARSE_H
+#define GO_PARSE_H
+
+class Set_iota_traverse;
+class Lex;
+class Gogo;
+class Named_object;
+class Type;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Block;
+class Expression;
+class Expression_list;
+class Struct_field_list;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Statement;
+class Label;
+
+// Parse the program.
+
+class Parse
+{
+ public:
+ Parse(Lex*, Gogo*);
+
+ // Parse a program.
+ void
+ program();
+
+ private:
+ // Precedence values.
+ enum Precedence
+ {
+ PRECEDENCE_INVALID = -1,
+ PRECEDENCE_NORMAL = 0,
+ PRECEDENCE_OROR,
+ PRECEDENCE_ANDAND,
+ PRECEDENCE_RELOP,
+ PRECEDENCE_ADDOP,
+ PRECEDENCE_MULOP
+ };
+
+ // We use this when parsing the range clause of a for statement.
+ struct Range_clause
+ {
+ // Set to true if we found a range clause.
+ bool found;
+ // The index expression.
+ Expression* index;
+ // The value expression.
+ Expression* value;
+ // The range expression.
+ Expression* range;
+
+ Range_clause()
+ : found(false), index(NULL), value(NULL), range(NULL)
+ { }
+ };
+
+ // We use this when parsing the statement at the start of a switch,
+ // in order to recognize type switches.
+ struct Type_switch
+ {
+ // Set to true if we find a type switch.
+ bool found;
+ // The variable name.
+ std::string name;
+ // The location of the variable.
+ source_location location;
+ // The expression.
+ Expression* expr;
+
+ Type_switch()
+ : found(false), name(), location(UNKNOWN_LOCATION), expr(NULL)
+ { }
+ };
+
+ // A variable defined in an enclosing function referenced by the
+ // current function.
+ class Enclosing_var
+ {
+ public:
+ Enclosing_var(Named_object* var, Named_object* in_function,
+ unsigned int index)
+ : var_(var), in_function_(in_function), index_(index)
+ { }
+
+ // We put these in a vector, so we need a default constructor.
+ Enclosing_var()
+ : var_(NULL), in_function_(NULL), index_(-1U)
+ { }
+
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ Named_object*
+ in_function() const
+ { return this->in_function_; }
+
+ unsigned int
+ index() const
+ { return this->index_; }
+
+ private:
+ // The variable which is being referred to.
+ Named_object* var_;
+ // The function where the variable is defined.
+ Named_object* in_function_;
+ // The index of the field in this function's closure struct for
+ // this variable.
+ unsigned int index_;
+ };
+
+ // We store Enclosing_var entries in a set, so we need a comparator.
+ struct Enclosing_var_comparison
+ {
+ bool
+ operator()(const Enclosing_var&, const Enclosing_var&);
+ };
+
+ // A set of Enclosing_var entries.
+ typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
+
+ // Peek at the current token from the lexer.
+ const Token*
+ peek_token();
+
+ // Consume the current token, return the next one.
+ const Token*
+ advance_token();
+
+ // Push a token back on the input stream.
+ void
+ unget_token(const Token&);
+
+ // The location of the current token.
+ source_location
+ location();
+
+ // For break and continue we keep a stack of statements with
+ // associated labels (if any). The top of the stack is used for a
+ // break or continue statement with no label.
+ typedef std::vector<std::pair<Statement*, Label*> > Bc_stack;
+
+ // Parser nonterminals.
+ void identifier_list(Typed_identifier_list*);
+ Expression_list* expression_list(Expression*, bool may_be_sink);
+ bool qualified_ident(std::string*, Named_object**);
+ Type* type();
+ bool type_may_start_here();
+ Type* type_name(bool issue_error);
+ Type* array_type(bool may_use_ellipsis);
+ Type* map_type();
+ Type* struct_type();
+ void field_decl(Struct_field_list*);
+ Type* pointer_type();
+ Type* channel_type();
+ Function_type* signature(Typed_identifier*, source_location);
+ bool parameters(Typed_identifier_list**, bool* is_varargs);
+ Typed_identifier_list* parameter_list(bool* is_varargs);
+ void parameter_decl(bool, Typed_identifier_list*, bool*, bool*);
+ bool result(Typed_identifier_list**);
+ source_location block();
+ Type* interface_type();
+ void method_spec(Typed_identifier_list*);
+ void declaration();
+ bool declaration_may_start_here();
+ void decl(void (Parse::*)(void*), void*);
+ void list(void (Parse::*)(void*), void*, bool);
+ void const_decl();
+ void const_spec(Type**, Expression_list**);
+ void type_decl();
+ void type_spec(void*);
+ void var_decl();
+ void var_spec(void*);
+ void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_receive(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq, source_location);
+ bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq,
+ source_location);
+ Named_object* init_var(const Typed_identifier&, Type*, Expression*,
+ bool is_coloneq, bool type_from_init, bool* is_new);
+ Named_object* create_dummy_global(Type*, Expression*, source_location);
+ void simple_var_decl_or_assignment(const std::string&, source_location,
+ Range_clause*, Type_switch*);
+ void function_decl();
+ Typed_identifier* receiver();
+ Expression* operand(bool may_be_sink);
+ Expression* enclosing_var_reference(Named_object*, Named_object*,
+ source_location);
+ Expression* composite_lit(Type*, int depth, source_location);
+ Expression* function_lit();
+ Expression* create_closure(Named_object* function, Enclosing_vars*,
+ source_location);
+ Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* selector(Expression*, bool* is_type_switch);
+ Expression* index(Expression*);
+ Expression* call(Expression*);
+ Expression* expression(Precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch);
+ bool expression_may_start_here();
+ Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* qualified_expr(Expression*, source_location);
+ Expression* id_to_expression(const std::string&, source_location);
+ void statement(Label*);
+ bool statement_may_start_here();
+ void labeled_stmt(const std::string&, source_location);
+ Expression* simple_stat(bool, bool*, Range_clause*, Type_switch*);
+ bool simple_stat_may_start_here();
+ void statement_list();
+ bool statement_list_may_start_here();
+ void expression_stat(Expression*);
+ void send_stmt(Expression*);
+ void inc_dec_stat(Expression*);
+ void assignment(Expression*, Range_clause*);
+ void tuple_assignment(Expression_list*, Range_clause*);
+ void send();
+ void go_or_defer_stat();
+ void return_stat();
+ void if_stat();
+ void switch_stat(Label*);
+ Statement* expr_switch_body(Label*, Expression*, source_location);
+ void expr_case_clause(Case_clauses*, bool* saw_default);
+ Expression_list* expr_switch_case(bool*);
+ Statement* type_switch_body(Label*, const Type_switch&, source_location);
+ void type_case_clause(Named_object*, Type_case_clauses*, bool* saw_default);
+ void type_switch_case(std::vector<Type*>*, bool*);
+ void select_stat(Label*);
+ void comm_clause(Select_clauses*, bool* saw_default);
+ bool comm_case(bool*, Expression**, Expression**, Expression**,
+ std::string*, std::string*, bool*);
+ bool send_or_recv_stmt(bool*, Expression**, Expression**, Expression**,
+ std::string*, std::string*);
+ void for_stat(Label*);
+ void for_clause(Expression**, Block**);
+ void range_clause_decl(const Typed_identifier_list*, Range_clause*);
+ void range_clause_expr(const Expression_list*, Range_clause*);
+ void push_break_statement(Statement*, Label*);
+ void push_continue_statement(Statement*, Label*);
+ void pop_break_statement();
+ void pop_continue_statement();
+ Statement* find_bc_statement(const Bc_stack*, const std::string&);
+ void break_stat();
+ void continue_stat();
+ void goto_stat();
+ void package_clause();
+ void import_decl();
+ void import_spec(void*);
+
+ void reset_iota();
+ int iota_value();
+ void increment_iota();
+
+ // Skip past an error looking for a semicolon or OP. Return true if
+ // all is well, false if we found EOF.
+ bool
+ skip_past_error(Operator op);
+
+ // Verify that an expression is not a sink, and return either the
+ // expression or an error.
+ Expression*
+ verify_not_sink(Expression*);
+
+ // Return the statement associated with a label in a Bc_stack, or
+ // NULL.
+ Statement*
+ find_bc_statement(const Bc_stack*, const std::string&) const;
+
+ // The lexer output we are parsing.
+ Lex* lex_;
+ // The current token.
+ Token token_;
+ // A token pushed back on the input stream.
+ Token unget_token_;
+ // Whether unget_token_ is valid.
+ bool unget_token_valid_;
+ // The code we are generating.
+ Gogo* gogo_;
+ // A stack of statements for which break may be used.
+ Bc_stack* break_stack_;
+ // A stack of statements for which continue may be used.
+ Bc_stack* continue_stack_;
+ // The current iota value.
+ int iota_;
+ // References from the local function to variables defined in
+ // enclosing functions.
+ Enclosing_vars enclosing_vars_;
+};
+
+
+#endif // !defined(GO_PARSE_H)
--- /dev/null
+// parse.h -- Go frontend parser. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_PARSE_H
+#define GO_PARSE_H
+
+class Set_iota_traverse;
+class Lex;
+class Gogo;
+class Named_object;
+class Type;
+class Typed_identifier;
+class Typed_identifier_list;
+class Function_type;
+class Block;
+class Expression;
+class Expression_list;
+class Struct_field_list;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Statement;
+class Label;
+
+// Parse the program.
+
+class Parse
+{
+ public:
+ Parse(Lex*, Gogo*);
+
+ // Parse a program.
+ void
+ program();
+
+ private:
+ // Precedence values.
+ enum Precedence
+ {
+ PRECEDENCE_INVALID = -1,
+ PRECEDENCE_NORMAL = 0,
+ PRECEDENCE_OROR,
+ PRECEDENCE_ANDAND,
+ PRECEDENCE_RELOP,
+ PRECEDENCE_ADDOP,
+ PRECEDENCE_MULOP
+ };
+
+ // We use this when parsing the range clause of a for statement.
+ struct Range_clause
+ {
+ // Set to true if we found a range clause.
+ bool found;
+ // The index expression.
+ Expression* index;
+ // The value expression.
+ Expression* value;
+ // The range expression.
+ Expression* range;
+
+ Range_clause()
+ : found(false), index(NULL), value(NULL), range(NULL)
+ { }
+ };
+
+ // We use this when parsing the statement at the start of a switch,
+ // in order to recognize type switches.
+ struct Type_switch
+ {
+ // Set to true if we find a type switch.
+ bool found;
+ // The variable name.
+ std::string name;
+ // The location of the variable.
+ source_location location;
+ // The expression.
+ Expression* expr;
+
+ Type_switch()
+ : found(false), name(), location(UNKNOWN_LOCATION), expr(NULL)
+ { }
+ };
+
+ // A variable defined in an enclosing function referenced by the
+ // current function.
+ class Enclosing_var
+ {
+ public:
+ Enclosing_var(Named_object* var, Named_object* in_function,
+ unsigned int index)
+ : var_(var), in_function_(in_function), index_(index)
+ { }
+
+ // We put these in a vector, so we need a default constructor.
+ Enclosing_var()
+ : var_(NULL), in_function_(NULL), index_(-1U)
+ { }
+
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ Named_object*
+ in_function() const
+ { return this->in_function_; }
+
+ unsigned int
+ index() const
+ { return this->index_; }
+
+ private:
+ // The variable which is being referred to.
+ Named_object* var_;
+ // The function where the variable is defined.
+ Named_object* in_function_;
+ // The index of the field in this function's closure struct for
+ // this variable.
+ unsigned int index_;
+ };
+
+ // We store Enclosing_var entries in a set, so we need a comparator.
+ struct Enclosing_var_comparison
+ {
+ bool
+ operator()(const Enclosing_var&, const Enclosing_var&);
+ };
+
+ // A set of Enclosing_var entries.
+ typedef std::set<Enclosing_var, Enclosing_var_comparison> Enclosing_vars;
+
+ // Peek at the current token from the lexer.
+ const Token*
+ peek_token();
+
+ // Consume the current token, return the next one.
+ const Token*
+ advance_token();
+
+ // Push a token back on the input stream.
+ void
+ unget_token(const Token&);
+
+ // The location of the current token.
+ source_location
+ location();
+
+ // For break and continue we keep a stack of statements with
+ // associated labels (if any). The top of the stack is used for a
+ // break or continue statement with no label.
+ typedef std::vector<std::pair<Statement*, const Label*> > Bc_stack;
+
+ // Parser nonterminals.
+ void identifier_list(Typed_identifier_list*);
+ Expression_list* expression_list(Expression*, bool may_be_sink);
+ bool qualified_ident(std::string*, Named_object**);
+ Type* type();
+ bool type_may_start_here();
+ Type* type_name(bool issue_error);
+ Type* array_type(bool may_use_ellipsis);
+ Type* map_type();
+ Type* struct_type();
+ void field_decl(Struct_field_list*);
+ Type* pointer_type();
+ Type* channel_type();
+ Function_type* signature(Typed_identifier*, source_location);
+ bool parameters(Typed_identifier_list**, bool* is_varargs);
+ Typed_identifier_list* parameter_list(bool* is_varargs);
+ void parameter_decl(bool, Typed_identifier_list*, bool*, bool*);
+ bool result(Typed_identifier_list**);
+ source_location block();
+ Type* interface_type();
+ void method_spec(Typed_identifier_list*);
+ void declaration();
+ bool declaration_may_start_here();
+ void decl(void (Parse::*)(void*), void*);
+ void list(void (Parse::*)(void*), void*, bool);
+ void const_decl();
+ void const_spec(Type**, Expression_list**);
+ void type_decl();
+ void type_spec(void*);
+ void var_decl();
+ void var_spec(void*);
+ void init_vars(const Typed_identifier_list*, Type*, Expression_list*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_call(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_map(const Typed_identifier_list*, Type*, Expression*,
+ bool is_coloneq, source_location);
+ bool init_vars_from_receive(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq, source_location);
+ bool init_vars_from_type_guard(const Typed_identifier_list*, Type*,
+ Expression*, bool is_coloneq,
+ source_location);
+ Named_object* init_var(const Typed_identifier&, Type*, Expression*,
+ bool is_coloneq, bool type_from_init, bool* is_new);
+ Named_object* create_dummy_global(Type*, Expression*, source_location);
+ void simple_var_decl_or_assignment(const std::string&, source_location,
+ Range_clause*, Type_switch*);
+ void function_decl();
+ Typed_identifier* receiver();
+ Expression* operand(bool may_be_sink);
+ Expression* enclosing_var_reference(Named_object*, Named_object*,
+ source_location);
+ Expression* composite_lit(Type*, int depth, source_location);
+ Expression* function_lit();
+ Expression* create_closure(Named_object* function, Enclosing_vars*,
+ source_location);
+ Expression* primary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* selector(Expression*, bool* is_type_switch);
+ Expression* index(Expression*);
+ Expression* call(Expression*);
+ Expression* expression(Precedence, bool may_be_sink,
+ bool may_be_composite_lit, bool* is_type_switch);
+ bool expression_may_start_here();
+ Expression* unary_expr(bool may_be_sink, bool may_be_composite_lit,
+ bool* is_type_switch);
+ Expression* qualified_expr(Expression*, source_location);
+ Expression* id_to_expression(const std::string&, source_location);
+ void statement(const Label*);
+ bool statement_may_start_here();
+ void labeled_stmt(const std::string&, source_location);
+ Expression* simple_stat(bool, bool, Range_clause*, Type_switch*);
+ bool simple_stat_may_start_here();
+ void statement_list();
+ bool statement_list_may_start_here();
+ void expression_stat(Expression*);
+ void send_stmt(Expression*);
+ void inc_dec_stat(Expression*);
+ void assignment(Expression*, Range_clause*);
+ void tuple_assignment(Expression_list*, Range_clause*);
+ void send();
+ void go_or_defer_stat();
+ void return_stat();
+ void if_stat();
+ void switch_stat(const Label*);
+ Statement* expr_switch_body(const Label*, Expression*, source_location);
+ void expr_case_clause(Case_clauses*, bool* saw_default);
+ Expression_list* expr_switch_case(bool*);
+ Statement* type_switch_body(const Label*, const Type_switch&,
+ source_location);
+ void type_case_clause(Named_object*, Type_case_clauses*, bool* saw_default);
+ void type_switch_case(std::vector<Type*>*, bool*);
+ void select_stat(const Label*);
+ void comm_clause(Select_clauses*, bool* saw_default);
+ bool comm_case(bool*, Expression**, Expression**, Expression**,
+ std::string*, std::string*, bool*);
+ bool send_or_recv_stmt(bool*, Expression**, Expression**, Expression**,
+ std::string*, std::string*);
+ void for_stat(const Label*);
+ void for_clause(Expression**, Block**);
+ void range_clause_decl(const Typed_identifier_list*, Range_clause*);
+ void range_clause_expr(const Expression_list*, Range_clause*);
+ void push_break_statement(Statement*, const Label*);
+ void push_continue_statement(Statement*, const Label*);
+ void pop_break_statement();
+ void pop_continue_statement();
+ Statement* find_bc_statement(const Bc_stack*, const std::string&);
+ void break_stat();
+ void continue_stat();
+ void goto_stat();
+ void package_clause();
+ void import_decl();
+ void import_spec(void*);
+
+ void reset_iota();
+ int iota_value();
+ void increment_iota();
+
+ // Skip past an error looking for a semicolon or OP. Return true if
+ // all is well, false if we found EOF.
+ bool
+ skip_past_error(Operator op);
+
+ // Verify that an expression is not a sink, and return either the
+ // expression or an error.
+ Expression*
+ verify_not_sink(Expression*);
+
+ // Return the statement associated with a label in a Bc_stack, or
+ // NULL.
+ Statement*
+ find_bc_statement(const Bc_stack*, const std::string&) const;
+
+ // The lexer output we are parsing.
+ Lex* lex_;
+ // The current token.
+ Token token_;
+ // A token pushed back on the input stream.
+ Token unget_token_;
+ // Whether unget_token_ is valid.
+ bool unget_token_valid_;
+ // The code we are generating.
+ Gogo* gogo_;
+ // A stack of statements for which break may be used.
+ Bc_stack* break_stack_;
+ // A stack of statements for which continue may be used.
+ Bc_stack* continue_stack_;
+ // The current iota value.
+ int iota_;
+ // References from the local function to variables defined in
+ // enclosing functions.
+ Enclosing_vars enclosing_vars_;
+};
+
+
+#endif // !defined(GO_PARSE_H)
--- /dev/null
+// statements.cc -- Go frontend statements.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "convert.h"
+#include "tree-iterator.h"
+#include "tree-flow.h"
+#include "real.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "gogo.h"
+#include "statements.h"
+
+// Class Statement.
+
+Statement::Statement(Statement_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Statement::~Statement()
+{
+}
+
+// Traverse the tree. The work of walking the components is handled
+// by the subclasses.
+
+int
+Statement::traverse(Block* block, size_t* pindex, Traverse* traverse)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return TRAVERSE_CONTINUE;
+
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_statements) != 0)
+ {
+ int t = traverse->statement(block, pindex, this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ // No point in checking traverse_mask here--a statement may contain
+ // other blocks or statements, and if we got here we always want to
+ // walk them.
+ return this->do_traverse(traverse);
+}
+
+// Traverse the contents of a statement.
+
+int
+Statement::traverse_contents(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Traverse assignments.
+
+bool
+Statement::traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return false;
+ return this->do_traverse_assignments(tassign);
+}
+
+// Traverse an expression in a statement. This is a helper function
+// for child classes.
+
+int
+Statement::traverse_expression(Traverse* traverse, Expression** expr)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Expression::traverse(expr, traverse);
+}
+
+// Traverse an expression list in a statement. This is a helper
+// function for child classes.
+
+int
+Statement::traverse_expression_list(Traverse* traverse,
+ Expression_list* expr_list)
+{
+ if (expr_list == NULL)
+ return TRAVERSE_CONTINUE;
+ if ((traverse->traverse_mask() & Traverse::traverse_expressions) == 0)
+ return TRAVERSE_CONTINUE;
+ return expr_list->traverse(traverse);
+}
+
+// Traverse a type in a statement. This is a helper function for
+// child classes.
+
+int
+Statement::traverse_type(Traverse* traverse, Type* type)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Type::traverse(type, traverse);
+}
+
+// Set type information for unnamed constants. This is really done by
+// the child class.
+
+void
+Statement::determine_types()
+{
+ this->do_determine_types();
+}
+
+// If this is a thunk statement, return it.
+
+Thunk_statement*
+Statement::thunk_statement()
+{
+ Thunk_statement* ret = this->convert<Thunk_statement, STATEMENT_GO>();
+ if (ret == NULL)
+ ret = this->convert<Thunk_statement, STATEMENT_DEFER>();
+ return ret;
+}
+
+// Get a tree for a Statement. This is really done by the child
+// class.
+
+tree
+Statement::get_tree(Translate_context* context)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return error_mark_node;
+
+ return this->do_get_tree(context);
+}
+
+// Build tree nodes and set locations.
+
+tree
+Statement::build_stmt_1(int tree_code_value, tree node)
+{
+ tree ret = build1(static_cast<tree_code>(tree_code_value),
+ void_type_node, node);
+ SET_EXPR_LOCATION(ret, this->location_);
+ return ret;
+}
+
+// Note that this statement is erroneous. This is called by children
+// when they discover an error.
+
+void
+Statement::set_is_error()
+{
+ this->classification_ = STATEMENT_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Statement::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// An error statement, used to avoid crashing after we report an
+// error.
+
+class Error_statement : public Statement
+{
+ public:
+ Error_statement(source_location location)
+ : Statement(STATEMENT_ERROR, location)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+};
+
+// Make an error statement.
+
+Statement*
+Statement::make_error_statement(source_location location)
+{
+ return new Error_statement(location);
+}
+
+// Class Variable_declaration_statement.
+
+Variable_declaration_statement::Variable_declaration_statement(
+ Named_object* var)
+ : Statement(STATEMENT_VARIABLE_DECLARATION, var->var_value()->location()),
+ var_(var)
+{
+}
+
+// We don't actually traverse the variable here; it was traversed
+// while traversing the Block.
+
+int
+Variable_declaration_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Traverse the assignments in a variable declaration. Note that this
+// traversal is different from the usual traversal.
+
+bool
+Variable_declaration_statement::do_traverse_assignments(
+ Traverse_assignments* tassign)
+{
+ tassign->initialize_variable(this->var_);
+ return true;
+}
+
+// Return the tree for a variable declaration.
+
+tree
+Variable_declaration_statement::do_get_tree(Translate_context* context)
+{
+ tree val = this->var_->get_tree(context->gogo(), context->function());
+ if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
+ return error_mark_node;
+ Variable* variable = this->var_->var_value();
+
+ tree init = variable->get_init_tree(context->gogo(), context->function());
+ if (init == error_mark_node)
+ return error_mark_node;
+
+ // If this variable lives on the heap, we need to allocate it now.
+ if (!variable->is_in_heap())
+ {
+ DECL_INITIAL(val) = init;
+ return this->build_stmt_1(DECL_EXPR, val);
+ }
+ else
+ {
+ gcc_assert(TREE_CODE(val) == INDIRECT_REF);
+ tree decl = TREE_OPERAND(val, 0);
+ gcc_assert(TREE_CODE(decl) == VAR_DECL);
+ tree type = TREE_TYPE(decl);
+ gcc_assert(POINTER_TYPE_P(type));
+ tree size = TYPE_SIZE_UNIT(TREE_TYPE(type));
+ tree space = context->gogo()->allocate_memory(variable->type(), size,
+ this->location());
+ space = fold_convert(TREE_TYPE(decl), space);
+ DECL_INITIAL(decl) = space;
+ return build2(COMPOUND_EXPR, void_type_node,
+ this->build_stmt_1(DECL_EXPR, decl),
+ build2(MODIFY_EXPR, void_type_node, val, init));
+ }
+}
+
+// Make a variable declaration.
+
+Statement*
+Statement::make_variable_declaration(Named_object* var)
+{
+ return new Variable_declaration_statement(var);
+}
+
+// Class Temporary_statement.
+
+// Return the type of the temporary variable.
+
+Type*
+Temporary_statement::type() const
+{
+ return this->type_ != NULL ? this->type_ : this->init_->type();
+}
+
+// Traversal.
+
+int
+Temporary_statement::do_traverse(Traverse* traverse)
+{
+ if (this->init_ == NULL)
+ return TRAVERSE_CONTINUE;
+ else
+ return this->traverse_expression(traverse, &this->init_);
+}
+
+// Traverse assignments.
+
+bool
+Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->init_ == NULL)
+ return false;
+ tassign->value(&this->init_, true, true);
+ return true;
+}
+
+// Determine types.
+
+void
+Temporary_statement::do_determine_types()
+{
+ if (this->init_ != NULL)
+ {
+ if (this->type_ == NULL)
+ this->init_->determine_type_no_context();
+ else
+ {
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ }
+ }
+
+ if (this->type_ == NULL)
+ this->type_ = this->init_->type();
+
+ if (this->type_->is_abstract())
+ this->type_ = this->type_->make_non_abstract_type();
+}
+
+// Check types.
+
+void
+Temporary_statement::do_check_types(Gogo*)
+{
+ if (this->type_ != NULL && this->init_ != NULL)
+ gcc_assert(Type::are_assignable(this->type_, this->init_->type(), NULL));
+}
+
+// Return a tree.
+
+tree
+Temporary_statement::do_get_tree(Translate_context* context)
+{
+ gcc_assert(this->decl_ == NULL_TREE);
+ tree type_tree = this->type()->get_tree(context->gogo());
+ if (type_tree == error_mark_node)
+ {
+ this->decl_ = error_mark_node;
+ return error_mark_node;
+ }
+ // We can only use create_tmp_var if the type is not addressable.
+ if (!TREE_ADDRESSABLE(type_tree))
+ {
+ this->decl_ = create_tmp_var(type_tree, "GOTMP");
+ DECL_SOURCE_LOCATION(this->decl_) = this->location();
+ }
+ else
+ {
+ gcc_assert(context->function() != NULL && context->block() != NULL);
+ tree decl = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("GOTMP"),
+ type_tree);
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_IGNORED_P(decl) = 1;
+ TREE_USED(decl) = 1;
+ gcc_assert(current_function_decl != NULL_TREE);
+ DECL_CONTEXT(decl) = current_function_decl;
+
+ // We have to add this variable to the block so that it winds up
+ // in a BIND_EXPR.
+ tree block_tree = context->block_tree();
+ gcc_assert(block_tree != NULL_TREE);
+ DECL_CHAIN(decl) = BLOCK_VARS(block_tree);
+ BLOCK_VARS(block_tree) = decl;
+
+ this->decl_ = decl;
+ }
+ if (this->init_ != NULL)
+ DECL_INITIAL(this->decl_) =
+ Expression::convert_for_assignment(context, this->type(),
+ this->init_->type(),
+ this->init_->get_tree(context),
+ this->location());
+ if (this->is_address_taken_)
+ TREE_ADDRESSABLE(this->decl_) = 1;
+ return this->build_stmt_1(DECL_EXPR, this->decl_);
+}
+
+// Make and initialize a temporary variable in BLOCK.
+
+Temporary_statement*
+Statement::make_temporary(Type* type, Expression* init,
+ source_location location)
+{
+ return new Temporary_statement(type, init, location);
+}
+
+// An assignment statement.
+
+class Assignment_statement : public Statement
+{
+ public:
+ Assignment_statement(Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // Left hand side--the lvalue.
+ Expression* lhs_;
+ // Right hand side--the rvalue.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+bool
+Assignment_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ tassign->assignment(&this->lhs_, &this->rhs_);
+ return true;
+}
+
+// Set types for the assignment.
+
+void
+Assignment_statement::do_determine_types()
+{
+ this->lhs_->determine_type_no_context();
+ Type_context context(this->lhs_->type(), false);
+ this->rhs_->determine_type(&context);
+}
+
+// Check types for an assignment.
+
+void
+Assignment_statement::do_check_types(Gogo*)
+{
+ // The left hand side must be either addressable, a map index
+ // expression, or the blank identifier.
+ if (!this->lhs_->is_addressable()
+ && this->lhs_->map_index_expression() == NULL
+ && !this->lhs_->is_sink_expression())
+ {
+ if (!this->lhs_->type()->is_error_type())
+ this->report_error(_("invalid left hand side of assignment"));
+ return;
+ }
+
+ Type* lhs_type = this->lhs_->type();
+ Type* rhs_type = this->rhs_->type();
+ std::string reason;
+ if (!Type::are_assignable(lhs_type, rhs_type, &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(), "incompatible types in assignment");
+ else
+ error_at(this->location(), "incompatible types in assignment (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+
+ if (lhs_type->is_error_type()
+ || rhs_type->is_error_type()
+ || lhs_type->is_undefined()
+ || rhs_type->is_undefined())
+ {
+ // Make sure we get the error for an undefined type.
+ lhs_type->base();
+ rhs_type->base();
+ this->set_is_error();
+ }
+}
+
+// Build a tree for an assignment statement.
+
+tree
+Assignment_statement::do_get_tree(Translate_context* context)
+{
+ tree rhs_tree = this->rhs_->get_tree(context);
+
+ if (this->lhs_->is_sink_expression())
+ return rhs_tree;
+
+ tree lhs_tree = this->lhs_->get_tree(context);
+
+ if (lhs_tree == error_mark_node || rhs_tree == error_mark_node)
+ return error_mark_node;
+
+ rhs_tree = Expression::convert_for_assignment(context, this->lhs_->type(),
+ this->rhs_->type(), rhs_tree,
+ this->location());
+ if (rhs_tree == error_mark_node)
+ return error_mark_node;
+
+ return fold_build2_loc(this->location(), MODIFY_EXPR, void_type_node,
+ lhs_tree, rhs_tree);
+}
+
+// Make an assignment statement.
+
+Statement*
+Statement::make_assignment(Expression* lhs, Expression* rhs,
+ source_location location)
+{
+ return new Assignment_statement(lhs, rhs, location);
+}
+
+// The Move_ordered_evals class is used to find any subexpressions of
+// an expression that have an evaluation order dependency. It creates
+// temporary variables to hold them.
+
+class Move_ordered_evals : public Traverse
+{
+ public:
+ Move_ordered_evals(Block* block)
+ : Traverse(traverse_expressions),
+ block_(block)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The block where new temporary variables should be added.
+ Block* block_;
+};
+
+int
+Move_ordered_evals::expression(Expression** pexpr)
+{
+ // We have to look at subexpressions first.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*pexpr)->must_eval_in_order())
+ {
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc);
+ this->block_->add_statement(temp);
+ *pexpr = Expression::make_temporary_reference(temp, loc);
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// An assignment operation statement.
+
+class Assignment_operation_statement : public Statement
+{
+ public:
+ Assignment_operation_statement(Operator op, Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT_OPERATION, location),
+ op_(op), lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The operator (OPERATOR_PLUSEQ, etc.).
+ Operator op_;
+ // Left hand side.
+ Expression* lhs_;
+ // Right hand side.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_operation_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+// Lower an assignment operation statement to a regular assignment
+// statement.
+
+Statement*
+Assignment_operation_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ // We have to evaluate the left hand side expression only once. We
+ // do this by moving out any expression with side effects.
+ Block* b = new Block(enclosing, loc);
+ Move_ordered_evals moe(b);
+ this->lhs_->traverse_subexpressions(&moe);
+
+ Expression* lval = this->lhs_->copy();
+
+ Operator op;
+ switch (this->op_)
+ {
+ case OPERATOR_PLUSEQ:
+ op = OPERATOR_PLUS;
+ break;
+ case OPERATOR_MINUSEQ:
+ op = OPERATOR_MINUS;
+ break;
+ case OPERATOR_OREQ:
+ op = OPERATOR_OR;
+ break;
+ case OPERATOR_XOREQ:
+ op = OPERATOR_XOR;
+ break;
+ case OPERATOR_MULTEQ:
+ op = OPERATOR_MULT;
+ break;
+ case OPERATOR_DIVEQ:
+ op = OPERATOR_DIV;
+ break;
+ case OPERATOR_MODEQ:
+ op = OPERATOR_MOD;
+ break;
+ case OPERATOR_LSHIFTEQ:
+ op = OPERATOR_LSHIFT;
+ break;
+ case OPERATOR_RSHIFTEQ:
+ op = OPERATOR_RSHIFT;
+ break;
+ case OPERATOR_ANDEQ:
+ op = OPERATOR_AND;
+ break;
+ case OPERATOR_BITCLEAREQ:
+ op = OPERATOR_BITCLEAR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc);
+ Statement* s = Statement::make_assignment(this->lhs_, binop, loc);
+ if (b->statements()->empty())
+ {
+ delete b;
+ return s;
+ }
+ else
+ {
+ b->add_statement(s);
+ return Statement::make_block_statement(b, loc);
+ }
+}
+
+// Make an assignment operation statement.
+
+Statement*
+Statement::make_assignment_operation(Operator op, Expression* lhs,
+ Expression* rhs, source_location location)
+{
+ return new Assignment_operation_statement(op, lhs, rhs, location);
+}
+
+// A tuple assignment statement. This differs from an assignment
+// statement in that the right-hand-side expressions are evaluated in
+// parallel.
+
+class Tuple_assignment_statement : public Statement
+{
+ public:
+ Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Left hand side--a list of lvalues.
+ Expression_list* lhs_;
+ // Right hand side--a list of rvalues.
+ Expression_list* rhs_;
+};
+
+// Traversal.
+
+int
+Tuple_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression_list(traverse, this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression_list(traverse, this->rhs_);
+}
+
+// Lower a tuple assignment. We use temporary variables to split it
+// up into a set of single assignments.
+
+Statement*
+Tuple_assignment_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, loc);
+
+ // First move out any subexpressions on the left hand side. The
+ // right hand side will be evaluated in the required order anyhow.
+ Move_ordered_evals moe(b);
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs)
+ (*plhs)->traverse_subexpressions(&moe);
+
+ std::vector<Temporary_statement*> temps;
+ temps.reserve(this->lhs_->size());
+
+ Expression_list::const_iterator prhs = this->rhs_->begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ gcc_assert(prhs != this->rhs_->end());
+
+ if ((*plhs)->is_sink_expression())
+ {
+ b->add_statement(Statement::make_statement(*prhs));
+ continue;
+ }
+
+ Temporary_statement* temp = Statement::make_temporary((*plhs)->type(),
+ *prhs, loc);
+ b->add_statement(temp);
+ temps.push_back(temp);
+
+ }
+ gcc_assert(prhs == this->rhs_->end());
+
+ prhs = this->rhs_->begin();
+ std::vector<Temporary_statement*>::const_iterator ptemp = temps.begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ if ((*plhs)->is_sink_expression())
+ continue;
+
+ Expression* ref = Expression::make_temporary_reference(*ptemp, loc);
+ Statement* s = Statement::make_assignment(*plhs, ref, loc);
+ b->add_statement(s);
+ ++ptemp;
+ }
+ gcc_assert(ptemp == temps.end());
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a tuple assignment statement.
+
+Statement*
+Statement::make_tuple_assignment(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+{
+ return new Tuple_assignment_statement(lhs, rhs, location);
+}
+
+// A tuple assignment from a map index expression.
+// v, ok = m[k]
+
+class Tuple_map_assignment_statement : public Statement
+{
+public:
+ Tuple_map_assignment_statement(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_MAP_ASSIGNMENT, location),
+ val_(val), present_(present), map_index_(map_index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the map.
+ Expression* val_;
+ // Lvalue which receives whether the key value was present.
+ Expression* present_;
+ // The map index expression.
+ Expression* map_index_;
+};
+
+// Traversal.
+
+int
+Tuple_map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->present_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->map_index_);
+}
+
+// Lower a tuple map assignment.
+
+Statement*
+Tuple_map_assignment_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on right hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+
+ Block* b = new Block(enclosing, loc);
+
+ // Move out any subexpressions to make sure that functions are
+ // called in the required order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->present_->traverse_subexpressions(&moe);
+
+ // Copy the key value into a temporary so that we can take its
+ // address without pushing the value onto the heap.
+
+ // var key_temp KEY_TYPE = MAP_INDEX
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp VAL_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var present_temp bool
+ Temporary_statement* present_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(present_temp);
+
+ // func mapaccess2(hmap map[k]v, key *k, val *v) bool
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hmap", map_type, bloc));
+ Type* pkey_type = Type::make_pointer_type(map_type->key_type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ Type* pval_type = Type::make_pointer_type(map_type->val_type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", Type::make_boolean_type(), bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* mapaccess2 =
+ Named_object::make_function_declaration("mapaccess2", NULL, fntype, bloc);
+ mapaccess2->func_declaration_value()->set_asm_name("runtime.mapaccess2");
+
+ // present_temp = mapaccess2(MAP, &key_temp, &val_temp)
+ Expression* func = Expression::make_func_reference(mapaccess2, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(map_index->map());
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // present = present_temp
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ s = Statement::make_assignment(this->present_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a map assignment statement which returns a pair of values.
+
+Statement*
+Statement::make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+{
+ return new Tuple_map_assignment_statement(val, present, map_index, location);
+}
+
+// Assign a pair of entries to a map.
+// m[k] = v, p
+
+class Map_assignment_statement : public Statement
+{
+ public:
+ Map_assignment_statement(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+ : Statement(STATEMENT_MAP_ASSIGNMENT, location),
+ map_index_(map_index), val_(val), should_set_(should_set)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // A reference to the map index which should be set or deleted.
+ Expression* map_index_;
+ // The value to add to the map.
+ Expression* val_;
+ // Whether or not to add the value.
+ Expression* should_set_;
+};
+
+// Traverse a map assignment.
+
+int
+Map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->map_index_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->should_set_);
+}
+
+// Lower a map assignment to a function call.
+
+Statement*
+Map_assignment_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on left hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+
+ Block* b = new Block(enclosing, loc);
+
+ // Evaluate the map first to get order of evaluation right.
+ // map_temp := m // we are evaluating m[k] = v, p
+ Temporary_statement* map_temp = Statement::make_temporary(map_type,
+ map_index->map(),
+ loc);
+ b->add_statement(map_temp);
+
+ // var key_temp MAP_KEY_TYPE = k
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp MAP_VAL_TYPE = v
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), this->val_, loc);
+ b->add_statement(val_temp);
+
+ // func mapassign2(hmap map[k]v, key *k, val *v, p)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hmap", map_type, bloc));
+ Type* pkey_type = Type::make_pointer_type(map_type->key_type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ Type* pval_type = Type::make_pointer_type(map_type->val_type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+ param_types->push_back(Typed_identifier("p", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ NULL, bloc);
+ Named_object* mapassign2 =
+ Named_object::make_function_declaration("mapassign2", NULL, fntype, bloc);
+ mapassign2->func_declaration_value()->set_asm_name("runtime.mapassign2");
+
+ // mapassign2(map_temp, &key_temp, &val_temp, p)
+ Expression* func = Expression::make_func_reference(mapassign2, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_temporary_reference(map_temp, loc));
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ params->push_back(this->should_set_);
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Statement* s = Statement::make_statement(call);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a statement which assigns a pair of entries to a map.
+
+Statement*
+Statement::make_map_assignment(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+{
+ return new Map_assignment_statement(map_index, val, should_set, location);
+}
+
+// A tuple assignment from a receive statement.
+
+class Tuple_receive_assignment_statement : public Statement
+{
+ public:
+ Tuple_receive_assignment_statement(Expression* val, Expression* success,
+ Expression* channel,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_RECEIVE_ASSIGNMENT, location),
+ val_(val), success_(success), channel_(channel)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the channel.
+ Expression* val_;
+ // Lvalue which receives whether the read succeeded or failed.
+ Expression* success_;
+ // The channel on which we receive the value.
+ Expression* channel_;
+};
+
+// Traversal.
+
+int
+Tuple_receive_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->success_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->channel_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_receive_assignment_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return Statement::make_error_statement(loc);
+ }
+ if (!channel_type->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->success_->traverse_subexpressions(&moe);
+
+ // var val_temp ELEMENT_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(channel_type->element_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var success_temp bool
+ Temporary_statement* success_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(success_temp);
+
+ // func chanrecv2(c chan T, val *T) bool
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("c", channel_type, bloc));
+ Type* pelement_type = Type::make_pointer_type(channel_type->element_type());
+ param_types->push_back(Typed_identifier("val", pelement_type, bloc));
+
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* chanrecv2 =
+ Named_object::make_function_declaration("chanrecv2", NULL, fntype, bloc);
+ chanrecv2->func_declaration_value()->set_asm_name("runtime.chanrecv2");
+
+ // success_temp = chanrecv2(channel, &val_temp)
+ Expression* func = Expression::make_func_reference(chanrecv2, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->channel_);
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ ref = Expression::make_temporary_reference(success_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // success = success_temp
+ ref = Expression::make_temporary_reference(success_temp, loc);
+ s = Statement::make_assignment(this->success_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a nonblocking receive statement.
+
+Statement*
+Statement::make_tuple_receive_assignment(Expression* val, Expression* success,
+ Expression* channel,
+ source_location location)
+{
+ return new Tuple_receive_assignment_statement(val, success, channel,
+ location);
+}
+
+// An assignment to a pair of values from a type guard. This is a
+// conditional type guard. v, ok = i.(type).
+
+class Tuple_type_guard_assignment_statement : public Statement
+{
+ public:
+ Tuple_type_guard_assignment_statement(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT, location),
+ val_(val), ok_(ok), expr_(expr), type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ Call_expression*
+ lower_to_empty_interface(const char*);
+
+ Call_expression*
+ lower_to_type(const char*);
+
+ void
+ lower_to_object_type(Block*, const char*);
+
+ // The variable which recieves the converted value.
+ Expression* val_;
+ // The variable which receives the indication of success.
+ Expression* ok_;
+ // The expression being converted.
+ Expression* expr_;
+ // The type to which the expression is being converted.
+ Type* type_;
+};
+
+// Traverse a type guard tuple assignment.
+
+int
+Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->ok_) == TRAVERSE_EXIT
+ || this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->expr_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_type_guard_assignment_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Type* expr_type = this->expr_->type();
+ if (expr_type->interface_type() == NULL)
+ {
+ this->report_error(_("type assertion only valid for interface types"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->ok_->traverse_subexpressions(&moe);
+
+ bool expr_is_empty = expr_type->interface_type()->is_empty();
+ Call_expression* call;
+ if (this->type_->interface_type() != NULL)
+ {
+ if (this->type_->interface_type()->is_empty())
+ call = this->lower_to_empty_interface(expr_is_empty
+ ? "ifaceE2E2"
+ : "ifaceI2E2");
+ else
+ call = this->lower_to_type(expr_is_empty ? "ifaceE2I2" : "ifaceI2I2");
+ }
+ else if (this->type_->points_to() != NULL)
+ call = this->lower_to_type(expr_is_empty ? "ifaceE2T2P" : "ifaceI2T2P");
+ else
+ {
+ this->lower_to_object_type(b, expr_is_empty ? "ifaceE2T2" : "ifaceI2T2");
+ call = NULL;
+ }
+
+ if (call != NULL)
+ {
+ Expression* res = Expression::make_call_result(call, 0);
+ Statement* s = Statement::make_assignment(this->val_, res, loc);
+ b->add_statement(s);
+
+ res = Expression::make_call_result(call, 1);
+ s = Statement::make_assignment(this->ok_, res, loc);
+ b->add_statement(s);
+ }
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Lower a conversion to an empty interface type.
+
+Call_expression*
+Tuple_type_guard_assignment_statement::lower_to_empty_interface(
+ const char *fnname)
+{
+ source_location loc = this->location();
+
+ // func FNNAME(interface) (empty, bool)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ret", this->type_, bloc));
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // val, ok = FNNAME(expr)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->expr_);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a conversion to a non-empty interface type or a pointer type.
+
+Call_expression*
+Tuple_type_guard_assignment_statement::lower_to_type(const char* fnname)
+{
+ source_location loc = this->location();
+
+ // func FNNAME(*descriptor, interface) (interface, bool)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("inter",
+ Type::make_type_descriptor_ptr_type(),
+ bloc));
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ret", this->type_, bloc));
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // val, ok = FNNAME(type_descriptor, expr)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(this->type_, loc));
+ params->push_back(this->expr_);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a conversion to a non-interface non-pointer type.
+
+void
+Tuple_type_guard_assignment_statement::lower_to_object_type(Block* b,
+ const char *fnname)
+{
+ source_location loc = this->location();
+
+ // var val_temp TYPE
+ Temporary_statement* val_temp = Statement::make_temporary(this->type_,
+ NULL, loc);
+ b->add_statement(val_temp);
+
+ // func FNNAME(*descriptor, interface, *T) bool
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("inter",
+ Type::make_type_descriptor_ptr_type(),
+ bloc));
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Type* ptype = Type::make_pointer_type(this->type_);
+ param_types->push_back(Typed_identifier("v", ptype, bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // ok = FNNAME(type_descriptor, expr, &val_temp)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(this->type_, loc));
+ params->push_back(this->expr_);
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Statement* s = Statement::make_assignment(this->ok_, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+}
+
+// Make an assignment from a type guard to a pair of variables.
+
+Statement*
+Statement::make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+{
+ return new Tuple_type_guard_assignment_statement(val, ok, expr, type,
+ location);
+}
+
+// An expression statement.
+
+class Expression_statement : public Statement
+{
+ public:
+ Expression_statement(Expression* expr)
+ : Statement(STATEMENT_EXPRESSION, expr->location()),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ void
+ do_determine_types()
+ { this->expr_->determine_type_no_context(); }
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->expr_->get_tree(context); }
+
+ private:
+ Expression* expr_;
+};
+
+// An expression statement may fall through unless it is a call to a
+// function which does not return.
+
+bool
+Expression_statement::do_may_fall_through() const
+{
+ const Call_expression* call = this->expr_->call_expression();
+ if (call != NULL)
+ {
+ const Expression* fn = call->fn();
+ const Func_expression* fe = fn->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* no = fe->named_object();
+
+ Function_type* fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ fntype = NULL;
+
+ // The builtin function panic does not return.
+ if (fntype != NULL && fntype->is_builtin() && no->name() == "panic")
+ return false;
+ }
+ }
+ return true;
+}
+
+// Make an expression statement from an Expression.
+
+Statement*
+Statement::make_statement(Expression* expr)
+{
+ return new Expression_statement(expr);
+}
+
+// A block statement--a list of statements which may include variable
+// definitions.
+
+class Block_statement : public Statement
+{
+ public:
+ Block_statement(Block* block, source_location location)
+ : Statement(STATEMENT_BLOCK, location),
+ block_(block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->block_->traverse(traverse); }
+
+ void
+ do_determine_types()
+ { this->block_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->block_->may_fall_through(); }
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->block_->get_tree(context); }
+
+ private:
+ Block* block_;
+};
+
+// Make a block statement.
+
+Statement*
+Statement::make_block_statement(Block* block, source_location location)
+{
+ return new Block_statement(block, location);
+}
+
+// An increment or decrement statement.
+
+class Inc_dec_statement : public Statement
+{
+ public:
+ Inc_dec_statement(bool is_inc, Expression* expr)
+ : Statement(STATEMENT_INCDEC, expr->location()),
+ expr_(expr), is_inc_(is_inc)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The l-value to increment or decrement.
+ Expression* expr_;
+ // Whether to increment or decrement.
+ bool is_inc_;
+};
+
+// Lower to += or -=.
+
+Statement*
+Inc_dec_statement::do_lower(Gogo*, Block*)
+{
+ source_location loc = this->location();
+
+ mpz_t oval;
+ mpz_init_set_ui(oval, 1UL);
+ Expression* oexpr = Expression::make_integer(&oval, NULL, loc);
+ mpz_clear(oval);
+
+ Operator op = this->is_inc_ ? OPERATOR_PLUSEQ : OPERATOR_MINUSEQ;
+ return Statement::make_assignment_operation(op, this->expr_, oexpr, loc);
+}
+
+// Make an increment statement.
+
+Statement*
+Statement::make_inc_statement(Expression* expr)
+{
+ return new Inc_dec_statement(true, expr);
+}
+
+// Make a decrement statement.
+
+Statement*
+Statement::make_dec_statement(Expression* expr)
+{
+ return new Inc_dec_statement(false, expr);
+}
+
+// Class Thunk_statement. This is the base class for go and defer
+// statements.
+
+const char* const Thunk_statement::thunk_field_fn = "fn";
+
+const char* const Thunk_statement::thunk_field_receiver = "receiver";
+
+// Constructor.
+
+Thunk_statement::Thunk_statement(Statement_classification classification,
+ Call_expression* call,
+ source_location location)
+ : Statement(classification, location),
+ call_(call), struct_type_(NULL)
+{
+}
+
+// Return whether this is a simple statement which does not require a
+// thunk.
+
+bool
+Thunk_statement::is_simple(Function_type* fntype) const
+{
+ // We need a thunk to call a method, or to pass a variable number of
+ // arguments.
+ if (fntype->is_method() || fntype->is_varargs())
+ return false;
+
+ // A defer statement requires a thunk to set up for whether the
+ // function can call recover.
+ if (this->classification() == STATEMENT_DEFER)
+ return false;
+
+ // We can only permit a single parameter of pointer type.
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL
+ && (parameters->size() > 1
+ || (parameters->size() == 1
+ && parameters->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If the function returns multiple values, or returns a type other
+ // than integer, floating point, or pointer, then it may get a
+ // hidden first parameter, in which case we need the more
+ // complicated approach. This is true even though we are going to
+ // ignore the return value.
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL
+ && (results->size() > 1
+ || (results->size() == 1
+ && !results->begin()->type()->is_basic_type()
+ && results->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If this calls something which is not a simple function, then we
+ // need a thunk.
+ Expression* fn = this->call_->call_expression()->fn();
+ if (fn->bound_method_expression() != NULL
+ || fn->interface_field_reference_expression() != NULL)
+ return false;
+
+ return true;
+}
+
+// Traverse a thunk statement.
+
+int
+Thunk_statement::do_traverse(Traverse* traverse)
+{
+ return this->traverse_expression(traverse, &this->call_);
+}
+
+// We implement traverse_assignment for a thunk statement because it
+// effectively copies the function call.
+
+bool
+Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression* fn = this->call_->call_expression()->fn();
+ Expression* fn2 = fn;
+ tassign->value(&fn2, true, false);
+ return true;
+}
+
+// Determine types in a thunk statement.
+
+void
+Thunk_statement::do_determine_types()
+{
+ this->call_->determine_type_no_context();
+
+ // Now that we know the types of the call, build the struct used to
+ // pass parameters.
+ Function_type* fntype =
+ this->call_->call_expression()->get_function_type();
+ if (fntype != NULL && !this->is_simple(fntype))
+ this->struct_type_ = this->build_struct(fntype);
+}
+
+// Check types in a thunk statement.
+
+void
+Thunk_statement::do_check_types(Gogo*)
+{
+ Call_expression* ce = this->call_->call_expression();
+ Function_type* fntype = ce->get_function_type();
+ if (fntype != NULL && fntype->is_method())
+ {
+ Expression* fn = ce->fn();
+ if (fn->bound_method_expression() == NULL
+ && fn->interface_field_reference_expression() == NULL)
+ this->report_error(_("no object for method call"));
+ }
+}
+
+// The Traverse class used to find and simplify thunk statements.
+
+class Simplify_thunk_traverse : public Traverse
+{
+ public:
+ Simplify_thunk_traverse(Gogo* gogo)
+ : Traverse(traverse_blocks),
+ gogo_(gogo)
+ { }
+
+ int
+ block(Block*);
+
+ private:
+ Gogo* gogo_;
+};
+
+int
+Simplify_thunk_traverse::block(Block* b)
+{
+ // The parser ensures that thunk statements always appear at the end
+ // of a block.
+ if (b->statements()->size() < 1)
+ return TRAVERSE_CONTINUE;
+ Thunk_statement* stat = b->statements()->back()->thunk_statement();
+ if (stat == NULL)
+ return TRAVERSE_CONTINUE;
+ if (stat->simplify_statement(this->gogo_, b))
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Simplify all thunk statements.
+
+void
+Gogo::simplify_thunk_statements()
+{
+ Simplify_thunk_traverse thunk_traverse(this);
+ this->traverse(&thunk_traverse);
+}
+
+// Simplify complex thunk statements into simple ones. A complicated
+// thunk statement is one which takes anything other than zero
+// parameters or a single pointer parameter. We rewrite it into code
+// which allocates a struct, stores the parameter values into the
+// struct, and does a simple go or defer statement which passes the
+// struct to a thunk. The thunk does the real call.
+
+bool
+Thunk_statement::simplify_statement(Gogo* gogo, Block* block)
+{
+ if (this->classification() == STATEMENT_ERROR)
+ return false;
+ if (this->call_->is_error_expression())
+ return false;
+
+ Call_expression* ce = this->call_->call_expression();
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL || this->is_simple(fntype))
+ return false;
+
+ Expression* fn = ce->fn();
+ Bound_method_expression* bound_method = fn->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+
+ source_location location = this->location();
+
+ std::string thunk_name = Gogo::thunk_name();
+
+ // Build the thunk.
+ this->build_thunk(gogo, thunk_name, fntype);
+
+ // Generate code to call the thunk.
+
+ // Get the values to store into the struct which is the single
+ // argument to the thunk.
+
+ Expression_list* vals = new Expression_list();
+ if (fntype->is_builtin())
+ ;
+ else if (!is_method)
+ vals->push_back(fn);
+ else if (interface_method != NULL)
+ vals->push_back(interface_method->expr());
+ else if (bound_method != NULL)
+ {
+ vals->push_back(bound_method->method());
+ Expression* first_arg = bound_method->first_argument();
+
+ // We always pass a pointer when calling a method.
+ if (first_arg->type()->points_to() == NULL)
+ first_arg = Expression::make_unary(OPERATOR_AND, first_arg, location);
+
+ // If we are calling a method which was inherited from an
+ // embedded struct, and the method did not get a stub, then the
+ // first type may be wrong.
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ Type* unsafe = Type::make_pointer_type(Type::make_void_type());
+ first_arg = Expression::make_cast(unsafe, first_arg, location);
+ first_arg = Expression::make_cast(fatype, first_arg, location);
+ }
+
+ vals->push_back(first_arg);
+ }
+ else
+ gcc_unreachable();
+
+ if (ce->args() != NULL)
+ {
+ for (Expression_list::const_iterator p = ce->args()->begin();
+ p != ce->args()->end();
+ ++p)
+ vals->push_back(*p);
+ }
+
+ // Build the struct.
+ Expression* constructor =
+ Expression::make_struct_composite_literal(this->struct_type_, vals,
+ location);
+
+ // Allocate the initialized struct on the heap.
+ constructor = Expression::make_heap_composite(constructor, location);
+
+ // Look up the thunk.
+ Named_object* named_thunk = gogo->lookup(thunk_name, NULL);
+ gcc_assert(named_thunk != NULL && named_thunk->is_function());
+
+ // Build the call.
+ Expression* func = Expression::make_func_reference(named_thunk, NULL,
+ location);
+ Expression_list* params = new Expression_list();
+ params->push_back(constructor);
+ Call_expression* call = Expression::make_call(func, params, false, location);
+
+ // Build the simple go or defer statement.
+ Statement* s;
+ if (this->classification() == STATEMENT_GO)
+ s = Statement::make_go_statement(call, location);
+ else if (this->classification() == STATEMENT_DEFER)
+ s = Statement::make_defer_statement(call, location);
+ else
+ gcc_unreachable();
+
+ // The current block should end with the go statement.
+ gcc_assert(block->statements()->size() >= 1);
+ gcc_assert(block->statements()->back() == this);
+ block->replace_statement(block->statements()->size() - 1, s);
+
+ // We already ran the determine_types pass, so we need to run it now
+ // for the new statement.
+ s->determine_types();
+
+ // Sanity check.
+ gogo->check_types_in_block(block);
+
+ // Return true to tell the block not to keep looking at statements.
+ return true;
+}
+
+// Set the name to use for thunk parameter N.
+
+void
+Thunk_statement::thunk_field_param(int n, char* buf, size_t buflen)
+{
+ snprintf(buf, buflen, "a%d", n);
+}
+
+// Build a new struct type to hold the parameters for a complicated
+// thunk statement. FNTYPE is the type of the function call.
+
+Struct_type*
+Thunk_statement::build_struct(Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Struct_field_list* fields = new Struct_field_list();
+
+ Call_expression* ce = this->call_->call_expression();
+ Expression* fn = ce->fn();
+
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ if (interface_method != NULL)
+ {
+ // If this thunk statement calls a method on an interface, we
+ // pass the interface object to the thunk.
+ Typed_identifier tid(Thunk_statement::thunk_field_fn,
+ interface_method->expr()->type(),
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (!fntype->is_builtin())
+ {
+ // The function to call.
+ Typed_identifier tid(Go_statement::thunk_field_fn, fntype, location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (ce->is_recover_call())
+ {
+ // The predeclared recover function has no argument. However,
+ // we add an argument when building recover thunks. Handle that
+ // here.
+ fields->push_back(Struct_field(Typed_identifier("can_recover",
+ Type::make_boolean_type(),
+ location)));
+ }
+
+ if (fn->bound_method_expression() != NULL)
+ {
+ gcc_assert(fntype->is_method());
+ Type* rtype = fntype->receiver()->type();
+ // We always pass the receiver as a pointer.
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ Typed_identifier tid(Thunk_statement::thunk_field_receiver, rtype,
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+
+ const Expression_list* args = ce->args();
+ if (args != NULL)
+ {
+ int i = 0;
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p, ++i)
+ {
+ char buf[50];
+ this->thunk_field_param(i, buf, sizeof buf);
+ fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(),
+ location)));
+ }
+ }
+
+ return Type::make_struct_type(fields, location);
+}
+
+// Build the thunk we are going to call. This is a brand new, albeit
+// artificial, function.
+
+void
+Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
+ Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Call_expression* ce = this->call_->call_expression();
+
+ bool may_call_recover = false;
+ if (this->classification() == STATEMENT_DEFER)
+ {
+ Func_expression* fn = ce->fn()->func_expression();
+ if (fn == NULL)
+ may_call_recover = true;
+ else
+ {
+ const Named_object* no = fn->named_object();
+ if (!no->is_function())
+ may_call_recover = true;
+ else
+ may_call_recover = no->func_value()->calls_recover();
+ }
+ }
+
+ // Build the type of the thunk. The thunk takes a single parameter,
+ // which is a pointer to the special structure we build.
+ const char* const parameter_name = "__go_thunk_parameter";
+ Typed_identifier_list* thunk_parameters = new Typed_identifier_list();
+ Type* pointer_to_struct_type = Type::make_pointer_type(this->struct_type_);
+ thunk_parameters->push_back(Typed_identifier(parameter_name,
+ pointer_to_struct_type,
+ location));
+
+ Typed_identifier_list* thunk_results = NULL;
+ if (may_call_recover)
+ {
+ // When deferring a function which may call recover, add a
+ // return value, to disable tail call optimizations which will
+ // break the way we check whether recover is permitted.
+ thunk_results = new Typed_identifier_list();
+ thunk_results->push_back(Typed_identifier("", Type::make_boolean_type(),
+ location));
+ }
+
+ Function_type* thunk_type = Type::make_function_type(NULL, thunk_parameters,
+ thunk_results,
+ location);
+
+ // Start building the thunk.
+ Named_object* function = gogo->start_function(thunk_name, thunk_type, true,
+ location);
+
+ // For a defer statement, start with a call to
+ // __go_set_defer_retaddr. */
+ Label* retaddr_label = NULL;
+ if (may_call_recover)
+ {
+ retaddr_label = gogo->add_label_reference("retaddr");
+ Expression* arg = Expression::make_label_addr(retaddr_label, location);
+ Expression_list* args = new Expression_list();
+ args->push_back(arg);
+
+ static Named_object* set_defer_retaddr;
+ if (set_defer_retaddr == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type *voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ param_types->push_back(Typed_identifier("r", voidptr_type, bloc));
+
+ Typed_identifier_list* result_types = new Typed_identifier_list();
+ result_types->push_back(Typed_identifier("",
+ Type::make_boolean_type(),
+ bloc));
+
+ Function_type* t = Type::make_function_type(NULL, param_types,
+ result_types, bloc);
+ set_defer_retaddr =
+ Named_object::make_function_declaration("__go_set_defer_retaddr",
+ NULL, t, bloc);
+ const char* n = "__go_set_defer_retaddr";
+ set_defer_retaddr->func_declaration_value()->set_asm_name(n);
+ }
+
+ Expression* fn = Expression::make_func_reference(set_defer_retaddr,
+ NULL, location);
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ // This is a hack to prevent the middle-end from deleting the
+ // label.
+ gogo->start_block(location);
+ gogo->add_statement(Statement::make_goto_statement(retaddr_label,
+ location));
+ Block* then_block = gogo->finish_block(location);
+ then_block->determine_types();
+
+ Statement* s = Statement::make_if_statement(call, then_block, NULL,
+ location);
+ s->determine_types();
+ gogo->add_statement(s);
+ }
+
+ // Get a reference to the parameter.
+ Named_object* named_parameter = gogo->lookup(parameter_name, NULL);
+ gcc_assert(named_parameter != NULL && named_parameter->is_variable());
+
+ // Build the call. Note that the field names are the same as the
+ // ones used in build_struct.
+ Expression* thunk_parameter = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_parameter = Expression::make_unary(OPERATOR_MULT, thunk_parameter,
+ location);
+
+ Bound_method_expression* bound_method = ce->fn()->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ ce->fn()->interface_field_reference_expression();
+
+ Expression* func_to_call;
+ unsigned int next_index;
+ if (!fntype->is_builtin())
+ {
+ func_to_call = Expression::make_field_reference(thunk_parameter,
+ 0, location);
+ next_index = 1;
+ }
+ else
+ {
+ gcc_assert(bound_method == NULL && interface_method == NULL);
+ func_to_call = ce->fn();
+ next_index = 0;
+ }
+
+ if (bound_method != NULL)
+ {
+ Expression* r = Expression::make_field_reference(thunk_parameter, 1,
+ location);
+ // The main program passes in a function pointer from the
+ // interface expression, so here we can make a bound method in
+ // all cases.
+ func_to_call = Expression::make_bound_method(r, func_to_call,
+ location);
+ next_index = 2;
+ }
+ else if (interface_method != NULL)
+ {
+ // The main program passes the interface object.
+ const std::string& name(interface_method->name());
+ func_to_call = Expression::make_interface_field_reference(func_to_call,
+ name,
+ location);
+ }
+
+ Expression_list* call_params = new Expression_list();
+ const Struct_field_list* fields = this->struct_type_->fields();
+ Struct_field_list::const_iterator p = fields->begin();
+ for (unsigned int i = 0; i < next_index; ++i)
+ ++p;
+ for (; p != fields->end(); ++p, ++next_index)
+ {
+ Expression* thunk_param = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_param = Expression::make_unary(OPERATOR_MULT, thunk_param,
+ location);
+ Expression* param = Expression::make_field_reference(thunk_param,
+ next_index,
+ location);
+ call_params->push_back(param);
+ }
+
+ Expression* call = Expression::make_call(func_to_call, call_params, false,
+ location);
+ // We need to lower in case this is a builtin function.
+ call = call->lower(gogo, function, -1);
+ if (may_call_recover)
+ {
+ Call_expression* ce = call->call_expression();
+ if (ce != NULL)
+ ce->set_is_deferred();
+ }
+
+ Statement* call_statement = Statement::make_statement(call);
+
+ // We already ran the determine_types pass, so we need to run it
+ // just for this statement now.
+ call_statement->determine_types();
+
+ gogo->add_statement(call_statement);
+
+ // If this is a defer statement, the label comes immediately after
+ // the call.
+ if (may_call_recover)
+ {
+ gogo->add_label_definition("retaddr", location);
+
+ Expression_list* vals = new Expression_list();
+ vals->push_back(Expression::make_boolean(false, location));
+ const Typed_identifier_list* results =
+ function->func_value()->type()->results();
+ gogo->add_statement(Statement::make_return_statement(results, vals,
+ location));
+ }
+
+ // That is all the thunk has to do.
+ gogo->finish_function(location);
+}
+
+// Get the function and argument trees.
+
+void
+Thunk_statement::get_fn_and_arg(Translate_context* context, tree* pfn,
+ tree* parg)
+{
+ if (this->call_->is_error_expression())
+ {
+ *pfn = error_mark_node;
+ *parg = error_mark_node;
+ return;
+ }
+
+ Call_expression* ce = this->call_->call_expression();
+
+ Expression* fn = ce->fn();
+ *pfn = fn->get_tree(context);
+
+ const Expression_list* args = ce->args();
+ if (args == NULL || args->empty())
+ *parg = null_pointer_node;
+ else
+ {
+ gcc_assert(args->size() == 1);
+ *parg = args->front()->get_tree(context);
+ }
+}
+
+// Class Go_statement.
+
+tree
+Go_statement::do_get_tree(Translate_context* context)
+{
+ tree fn_tree;
+ tree arg_tree;
+ this->get_fn_and_arg(context, &fn_tree, &arg_tree);
+
+ static tree go_fndecl;
+
+ tree fn_arg_type = NULL_TREE;
+ if (go_fndecl == NULL_TREE)
+ {
+ // Only build FN_ARG_TYPE if we need it.
+ tree subargtypes = tree_cons(NULL_TREE, ptr_type_node, void_list_node);
+ tree subfntype = build_function_type(ptr_type_node, subargtypes);
+ fn_arg_type = build_pointer_type(subfntype);
+ }
+
+ return Gogo::call_builtin(&go_fndecl,
+ this->location(),
+ "__go_go",
+ 2,
+ void_type_node,
+ fn_arg_type,
+ fn_tree,
+ ptr_type_node,
+ arg_tree);
+}
+
+// Make a go statement.
+
+Statement*
+Statement::make_go_statement(Call_expression* call, source_location location)
+{
+ return new Go_statement(call, location);
+}
+
+// Class Defer_statement.
+
+tree
+Defer_statement::do_get_tree(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ tree fn_tree;
+ tree arg_tree;
+ this->get_fn_and_arg(context, &fn_tree, &arg_tree);
+ if (fn_tree == error_mark_node || arg_tree == error_mark_node)
+ return error_mark_node;
+
+ static tree defer_fndecl;
+
+ tree fn_arg_type = NULL_TREE;
+ if (defer_fndecl == NULL_TREE)
+ {
+ // Only build FN_ARG_TYPE if we need it.
+ tree subargtypes = tree_cons(NULL_TREE, ptr_type_node, void_list_node);
+ tree subfntype = build_function_type(ptr_type_node, subargtypes);
+ fn_arg_type = build_pointer_type(subfntype);
+ }
+
+ tree defer_stack = context->function()->func_value()->defer_stack(loc);
+
+ return Gogo::call_builtin(&defer_fndecl,
+ loc,
+ "__go_defer",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ defer_stack,
+ fn_arg_type,
+ fn_tree,
+ ptr_type_node,
+ arg_tree);
+}
+
+// Make a defer statement.
+
+Statement*
+Statement::make_defer_statement(Call_expression* call,
+ source_location location)
+{
+ return new Defer_statement(call, location);
+}
+
+// Class Return_statement.
+
+// Traverse assignments. We treat each return value as a top level
+// RHS in an expression.
+
+bool
+Return_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression_list* vals = this->vals_;
+ if (vals != NULL)
+ {
+ for (Expression_list::iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ tassign->value(&*p, true, true);
+ }
+ return true;
+}
+
+// Lower a return statement. If we are returning a function call
+// which returns multiple values which match the current function,
+// split up the call's results. If the function has named result
+// variables, and the return statement lists explicit values, then
+// implement it by assigning the values to the result variables and
+// changing the statement to not list any values. This lets
+// panic/recover work correctly.
+
+Statement*
+Return_statement::do_lower(Gogo*, Block* enclosing)
+{
+ if (this->vals_ == NULL)
+ return this;
+
+ const Typed_identifier_list* results = this->results_;
+ if (results == NULL || results->empty())
+ return this;
+
+ // If the current function has multiple return values, and we are
+ // returning a single call expression, split up the call expression.
+ size_t results_count = results->size();
+ if (results_count > 1
+ && this->vals_->size() == 1
+ && this->vals_->front()->call_expression() != NULL)
+ {
+ Call_expression* call = this->vals_->front()->call_expression();
+ size_t count = results->size();
+ Expression_list* vals = new Expression_list;
+ for (size_t i = 0; i < count; ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ delete this->vals_;
+ this->vals_ = vals;
+ }
+
+ if (results->front().name().empty())
+ return this;
+
+ if (results_count != this->vals_->size())
+ {
+ // Presumably an error which will be reported in check_types.
+ return this;
+ }
+
+ // Assign to named return values and then return them.
+
+ source_location loc = this->location();
+ const Block* top = enclosing;
+ while (top->enclosing() != NULL)
+ top = top->enclosing();
+
+ const Bindings *bindings = top->bindings();
+ Block* b = new Block(enclosing, loc);
+
+ Expression_list* lhs = new Expression_list();
+ Expression_list* rhs = new Expression_list();
+
+ Expression_list::const_iterator pe = this->vals_->begin();
+ int i = 1;
+ for (Typed_identifier_list::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++pe, ++i)
+ {
+ Named_object* rv = bindings->lookup_local(pr->name());
+ if (rv == NULL || !rv->is_result_variable())
+ {
+ // Presumably an error.
+ delete b;
+ delete lhs;
+ delete rhs;
+ return this;
+ }
+
+ Expression* e = *pe;
+
+ // Check types now so that we give a good error message. The
+ // result type is known. We determine the expression type
+ // early.
+
+ Type *rvtype = rv->result_var_value()->type();
+ Type_context type_context(rvtype, false);
+ e->determine_type(&type_context);
+
+ std::string reason;
+ if (Type::are_assignable(rvtype, e->type(), &reason))
+ {
+ Expression* ve = Expression::make_var_reference(rv, e->location());
+ lhs->push_back(ve);
+ rhs->push_back(e);
+ }
+ else
+ {
+ if (reason.empty())
+ error_at(e->location(), "incompatible type for return value %d", i);
+ else
+ error_at(e->location(),
+ "incompatible type for return value %d (%s)",
+ i, reason.c_str());
+ }
+ }
+ gcc_assert(lhs->size() == rhs->size());
+
+ if (lhs->empty())
+ ;
+ else if (lhs->size() == 1)
+ {
+ b->add_statement(Statement::make_assignment(lhs->front(), rhs->front(),
+ loc));
+ delete lhs;
+ delete rhs;
+ }
+ else
+ b->add_statement(Statement::make_tuple_assignment(lhs, rhs, loc));
+
+ b->add_statement(Statement::make_return_statement(this->results_, NULL,
+ loc));
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Determine types.
+
+void
+Return_statement::do_determine_types()
+{
+ if (this->vals_ == NULL)
+ return;
+ const Typed_identifier_list* results = this->results_;
+
+ Typed_identifier_list::const_iterator pt;
+ if (results != NULL)
+ pt = results->begin();
+ for (Expression_list::iterator pe = this->vals_->begin();
+ pe != this->vals_->end();
+ ++pe)
+ {
+ if (results == NULL || pt == results->end())
+ (*pe)->determine_type_no_context();
+ else
+ {
+ Type_context context(pt->type(), false);
+ (*pe)->determine_type(&context);
+ ++pt;
+ }
+ }
+}
+
+// Check types.
+
+void
+Return_statement::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ const Typed_identifier_list* results = this->results_;
+ if (results == NULL)
+ {
+ this->report_error(_("return with value in function "
+ "with no return type"));
+ return;
+ }
+
+ int i = 1;
+ Typed_identifier_list::const_iterator pt = results->begin();
+ for (Expression_list::const_iterator pe = this->vals_->begin();
+ pe != this->vals_->end();
+ ++pe, ++pt, ++i)
+ {
+ if (pt == results->end())
+ {
+ this->report_error(_("too many values in return statement"));
+ return;
+ }
+ std::string reason;
+ if (!Type::are_assignable(pt->type(), (*pe)->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(),
+ "incompatible type for return value %d",
+ i);
+ else
+ error_at(this->location(),
+ "incompatible type for return value %d (%s)",
+ i, reason.c_str());
+ this->set_is_error();
+ }
+ else if (pt->type()->is_error_type()
+ || (*pe)->type()->is_error_type()
+ || pt->type()->is_undefined()
+ || (*pe)->type()->is_undefined())
+ {
+ // Make sure we get the error for an undefined type.
+ pt->type()->base();
+ (*pe)->type()->base();
+ this->set_is_error();
+ }
+ }
+
+ if (pt != results->end())
+ this->report_error(_("not enough values in return statement"));
+}
+
+// Build a RETURN_EXPR tree.
+
+tree
+Return_statement::do_get_tree(Translate_context* context)
+{
+ Function* function = context->function()->func_value();
+ tree fndecl = function->get_decl();
+
+ const Typed_identifier_list* results = this->results_;
+
+ if (this->vals_ == NULL)
+ {
+ tree stmt_list = NULL_TREE;
+ tree retval = function->return_value(context->gogo(),
+ context->function(),
+ this->location(),
+ &stmt_list);
+ tree set;
+ if (retval == NULL_TREE)
+ set = NULL_TREE;
+ else
+ set = fold_build2_loc(this->location(), MODIFY_EXPR, void_type_node,
+ DECL_RESULT(fndecl), retval);
+ append_to_statement_list(this->build_stmt_1(RETURN_EXPR, set),
+ &stmt_list);
+ return stmt_list;
+ }
+ else if (this->vals_->size() == 1)
+ {
+ gcc_assert(!VOID_TYPE_P(TREE_TYPE(TREE_TYPE(fndecl))));
+ tree val = (*this->vals_->begin())->get_tree(context);
+ if (val == error_mark_node)
+ return error_mark_node;
+ gcc_assert(results != NULL && results->size() == 1);
+ val = Expression::convert_for_assignment(context,
+ results->begin()->type(),
+ (*this->vals_->begin())->type(),
+ val, this->location());
+ tree set = build2(MODIFY_EXPR, void_type_node,
+ DECL_RESULT(fndecl), val);
+ SET_EXPR_LOCATION(set, this->location());
+ return this->build_stmt_1(RETURN_EXPR, set);
+ }
+ else
+ {
+ gcc_assert(!VOID_TYPE_P(TREE_TYPE(TREE_TYPE(fndecl))));
+ tree stmt_list = NULL_TREE;
+ tree rettype = TREE_TYPE(DECL_RESULT(fndecl));
+ tree retvar = create_tmp_var(rettype, "RESULT");
+ gcc_assert(results != NULL && results->size() == this->vals_->size());
+ Expression_list::const_iterator pv = this->vals_->begin();
+ Typed_identifier_list::const_iterator pr = results->begin();
+ for (tree field = TYPE_FIELDS(rettype);
+ field != NULL_TREE;
+ ++pv, ++pr, field = DECL_CHAIN(field))
+ {
+ gcc_assert(pv != this->vals_->end());
+ tree val = (*pv)->get_tree(context);
+ if (val == error_mark_node)
+ return error_mark_node;
+ val = Expression::convert_for_assignment(context, pr->type(),
+ (*pv)->type(), val,
+ this->location());
+ tree set = build2(MODIFY_EXPR, void_type_node,
+ build3(COMPONENT_REF, TREE_TYPE(field),
+ retvar, field, NULL_TREE),
+ val);
+ SET_EXPR_LOCATION(set, this->location());
+ append_to_statement_list(set, &stmt_list);
+ }
+ tree set = build2(MODIFY_EXPR, void_type_node, DECL_RESULT(fndecl),
+ retvar);
+ append_to_statement_list(this->build_stmt_1(RETURN_EXPR, set),
+ &stmt_list);
+ return stmt_list;
+ }
+}
+
+// Make a return statement.
+
+Statement*
+Statement::make_return_statement(const Typed_identifier_list* results,
+ Expression_list* vals,
+ source_location location)
+{
+ return new Return_statement(results, vals, location);
+}
+
+// A break or continue statement.
+
+class Bc_statement : public Statement
+{
+ public:
+ Bc_statement(bool is_break, Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_BREAK_OR_CONTINUE, location),
+ label_(label), is_break_(is_break)
+ { }
+
+ bool
+ is_break() const
+ { return this->is_break_; }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_goto(this->location()); }
+
+ private:
+ // The label that this branches to.
+ Unnamed_label* label_;
+ // True if this is "break", false if it is "continue".
+ bool is_break_;
+};
+
+// Make a break statement.
+
+Statement*
+Statement::make_break_statement(Unnamed_label* label, source_location location)
+{
+ return new Bc_statement(true, label, location);
+}
+
+// Make a continue statement.
+
+Statement*
+Statement::make_continue_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Bc_statement(false, label, location);
+}
+
+// A goto statement.
+
+class Goto_statement : public Statement
+{
+ public:
+ Goto_statement(Label* label, source_location location)
+ : Statement(STATEMENT_GOTO, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Label* label_;
+};
+
+// Check types for a label. There aren't any types per se, but we use
+// this to give an error if the label was never defined.
+
+void
+Goto_statement::do_check_types(Gogo*)
+{
+ if (!this->label_->is_defined())
+ {
+ error_at(this->location(), "reference to undefined label %qs",
+ Gogo::message_name(this->label_->name()).c_str());
+ this->set_is_error();
+ }
+}
+
+// Return the tree for the goto statement.
+
+tree
+Goto_statement::do_get_tree(Translate_context*)
+{
+ return this->build_stmt_1(GOTO_EXPR, this->label_->get_decl());
+}
+
+// Make a goto statement.
+
+Statement*
+Statement::make_goto_statement(Label* label, source_location location)
+{
+ return new Goto_statement(label, location);
+}
+
+// A goto statement to an unnamed label.
+
+class Goto_unnamed_statement : public Statement
+{
+ public:
+ Goto_unnamed_statement(Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_GOTO_UNNAMED, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_goto(this->location()); }
+
+ private:
+ Unnamed_label* label_;
+};
+
+// Make a goto statement to an unnamed label.
+
+Statement*
+Statement::make_goto_unnamed_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Goto_unnamed_statement(label, location);
+}
+
+// Class Label_statement.
+
+// Traversal.
+
+int
+Label_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return a tree defining this label.
+
+tree
+Label_statement::do_get_tree(Translate_context*)
+{
+ return this->build_stmt_1(LABEL_EXPR, this->label_->get_decl());
+}
+
+// Make a label statement.
+
+Statement*
+Statement::make_label_statement(Label* label, source_location location)
+{
+ return new Label_statement(label, location);
+}
+
+// An unnamed label statement.
+
+class Unnamed_label_statement : public Statement
+{
+ public:
+ Unnamed_label_statement(Unnamed_label* label)
+ : Statement(STATEMENT_UNNAMED_LABEL, label->location()),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_definition(); }
+
+ private:
+ // The label.
+ Unnamed_label* label_;
+};
+
+// Make an unnamed label statement.
+
+Statement*
+Statement::make_unnamed_label_statement(Unnamed_label* label)
+{
+ return new Unnamed_label_statement(label);
+}
+
+// An if statement.
+
+class If_statement : public Statement
+{
+ public:
+ If_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location location)
+ : Statement(STATEMENT_IF, location),
+ cond_(cond), then_block_(then_block), else_block_(else_block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Expression* cond_;
+ Block* then_block_;
+ Block* else_block_;
+};
+
+// Traversal.
+
+int
+If_statement::do_traverse(Traverse* traverse)
+{
+ if (this->cond_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->then_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->else_block_ != NULL)
+ {
+ if (this->else_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+void
+If_statement::do_determine_types()
+{
+ if (this->cond_ != NULL)
+ {
+ Type_context context(Type::lookup_bool_type(), false);
+ this->cond_->determine_type(&context);
+ }
+ this->then_block_->determine_types();
+ if (this->else_block_ != NULL)
+ this->else_block_->determine_types();
+}
+
+// Check types.
+
+void
+If_statement::do_check_types(Gogo*)
+{
+ if (this->cond_ != NULL)
+ {
+ Type* type = this->cond_->type();
+ if (type->is_error_type())
+ this->set_is_error();
+ else if (!type->is_boolean_type())
+ this->report_error(_("expected boolean expression"));
+ }
+}
+
+// Whether the overall statement may fall through.
+
+bool
+If_statement::do_may_fall_through() const
+{
+ return (this->else_block_ == NULL
+ || this->then_block_->may_fall_through()
+ || this->else_block_->may_fall_through());
+}
+
+// Get tree.
+
+tree
+If_statement::do_get_tree(Translate_context* context)
+{
+ gcc_assert(this->cond_ == NULL || this->cond_->type()->is_boolean_type());
+ tree ret = build3(COND_EXPR, void_type_node,
+ (this->cond_ == NULL
+ ? boolean_true_node
+ : this->cond_->get_tree(context)),
+ this->then_block_->get_tree(context),
+ (this->else_block_ == NULL
+ ? NULL_TREE
+ : this->else_block_->get_tree(context)));
+ SET_EXPR_LOCATION(ret, this->location());
+ return ret;
+}
+
+// Make an if statement.
+
+Statement*
+Statement::make_if_statement(Expression* cond, Block* then_block,
+ Block* else_block, source_location location)
+{
+ return new If_statement(cond, then_block, else_block, location);
+}
+
+// Class Case_clauses::Case_clause.
+
+// Traversal.
+
+int
+Case_clauses::Case_clause::traverse(Traverse* traverse)
+{
+ if (this->cases_ != NULL
+ && (traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
+ {
+ if (this->cases_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are integer constants.
+
+bool
+Case_clauses::Case_clause::is_constant() const
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ if (!(*p)->is_constant() || (*p)->type()->integer_type() == NULL)
+ return false;
+ }
+ return true;
+}
+
+// Lower a case clause for a nonconstant switch. VAL_TEMP is the
+// value we are switching on; it may be NULL. If START_LABEL is not
+// NULL, it goes at the start of the statements, after the condition
+// test. We branch to FINISH_LABEL at the end of the statements.
+
+void
+Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* start_label,
+ Unnamed_label* finish_label) const
+{
+ source_location loc = this->location_;
+ Unnamed_label* next_case_label;
+ if (this->cases_ == NULL || this->cases_->empty())
+ {
+ gcc_assert(this->is_default_);
+ next_case_label = NULL;
+ }
+ else
+ {
+ Expression* cond = NULL;
+
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Expression* this_cond;
+ if (val_temp == NULL)
+ this_cond = *p;
+ else
+ {
+ Expression* ref = Expression::make_temporary_reference(val_temp,
+ loc);
+ this_cond = Expression::make_binary(OPERATOR_EQEQ, ref, *p, loc);
+ }
+
+ if (cond == NULL)
+ cond = this_cond;
+ else
+ cond = Expression::make_binary(OPERATOR_OROR, cond, this_cond, loc);
+ }
+
+ Block* then_block = new Block(b, loc);
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ Statement* s = Statement::make_goto_unnamed_statement(next_case_label,
+ loc);
+ then_block->add_statement(s);
+
+ // if !COND { goto NEXT_CASE_LABEL }
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (start_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(start_label));
+
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ Statement* s = Statement::make_goto_unnamed_statement(finish_label, loc);
+ b->add_statement(s);
+
+ if (next_case_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(next_case_label));
+}
+
+// Determine types.
+
+void
+Case_clauses::Case_clause::determine_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ Type_context case_context(type, false);
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ (*p)->determine_type(&case_context);
+ }
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::Case_clause::check_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ if (!Type::are_assignable(type, (*p)->type(), NULL)
+ && !Type::are_assignable((*p)->type(), type, NULL))
+ {
+ error_at((*p)->location(),
+ "type mismatch between switch value and case clause");
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Return true if this clause may fall through to the following
+// statements. Note that this is not the same as whether the case
+// uses the "fallthrough" keyword.
+
+bool
+Case_clauses::Case_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Build up the body of a SWITCH_EXPR.
+
+void
+Case_clauses::Case_clause::get_constant_tree(Translate_context* context,
+ Unnamed_label* break_label,
+ Case_constants* case_constants,
+ tree* stmt_list) const
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Type* itype;
+ mpz_t ival;
+ mpz_init(ival);
+ if (!(*p)->integer_constant_value(true, ival, &itype))
+ gcc_unreachable();
+ gcc_assert(itype != NULL);
+ tree type_tree = itype->get_tree(context->gogo());
+ tree val = Expression::integer_constant_tree(ival, type_tree);
+ mpz_clear(ival);
+
+ if (val != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(val) == INTEGER_CST);
+
+ std::pair<Case_constants::iterator, bool> ins =
+ case_constants->insert(val);
+ if (!ins.second)
+ {
+ // Value was already present.
+ warning_at(this->location_, 0,
+ "duplicate case value will never match");
+ continue;
+ }
+
+ tree label = create_artificial_label(this->location_);
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ val, NULL_TREE, label),
+ stmt_list);
+ }
+ }
+ }
+
+ if (this->is_default_)
+ {
+ tree label = create_artificial_label(this->location_);
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ NULL_TREE, NULL_TREE, label),
+ stmt_list);
+ }
+
+ if (this->statements_ != NULL)
+ {
+ tree block_tree = this->statements_->get_tree(context);
+ if (block_tree != error_mark_node)
+ append_to_statement_list(block_tree, stmt_list);
+ }
+
+ if (!this->is_fallthrough_)
+ append_to_statement_list(break_label->get_goto(this->location_), stmt_list);
+}
+
+// Class Case_clauses.
+
+// Traversal.
+
+int
+Case_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are constant.
+
+bool
+Case_clauses::is_constant() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (!p->is_constant())
+ return false;
+ return true;
+}
+
+// Lower case clauses for a nonconstant switch.
+
+void
+Case_clauses::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* break_label) const
+{
+ // The default case.
+ const Case_clause* default_case = NULL;
+
+ // The label for the fallthrough of the previous case.
+ Unnamed_label* last_fallthrough_label = NULL;
+
+ // The label for the start of the default case. This is used if the
+ // case before the default case falls through.
+ Unnamed_label* default_start_label = NULL;
+
+ // The label for the end of the default case. This normally winds
+ // up as BREAK_LABEL, but it will be different if the default case
+ // falls through.
+ Unnamed_label* default_finish_label = NULL;
+
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ // The label to use for the start of the statements for this
+ // case. This is NULL unless the previous case falls through.
+ Unnamed_label* start_label = last_fallthrough_label;
+
+ // The label to jump to after the end of the statements for this
+ // case.
+ Unnamed_label* finish_label = break_label;
+
+ last_fallthrough_label = NULL;
+ if (p->is_fallthrough() && p + 1 != this->clauses_.end())
+ {
+ finish_label = new Unnamed_label(p->location());
+ last_fallthrough_label = finish_label;
+ }
+
+ if (!p->is_default())
+ p->lower(b, val_temp, start_label, finish_label);
+ else
+ {
+ // We have to move the default case to the end, so that we
+ // only use it if all the other tests fail.
+ default_case = &*p;
+ default_start_label = start_label;
+ default_finish_label = finish_label;
+ }
+ }
+
+ if (default_case != NULL)
+ default_case->lower(b, val_temp, default_start_label,
+ default_finish_label);
+
+}
+
+// Determine types.
+
+void
+Case_clauses::determine_types(Type* type)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types(type);
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::check_types(Type* type)
+{
+ bool ret = true;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->check_types(type))
+ ret = false;
+ }
+ return ret;
+}
+
+// Return true if these clauses may fall through to the statements
+// following the switch statement.
+
+bool
+Case_clauses::may_fall_through() const
+{
+ bool found_default = false;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->may_fall_through() && !p->is_fallthrough())
+ return true;
+ if (p->is_default())
+ found_default = true;
+ }
+ return !found_default;
+}
+
+// Return a tree when all case expressions are constants.
+
+tree
+Case_clauses::get_constant_tree(Translate_context* context,
+ Unnamed_label* break_label) const
+{
+ Case_constants case_constants;
+ tree stmt_list = NULL_TREE;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->get_constant_tree(context, break_label, &case_constants,
+ &stmt_list);
+ return stmt_list;
+}
+
+// A constant switch statement. A Switch_statement is lowered to this
+// when all the cases are constants.
+
+class Constant_switch_statement : public Statement
+{
+ public:
+ Constant_switch_statement(Expression* val, Case_clauses* clauses,
+ Unnamed_label* break_label,
+ source_location location)
+ : Statement(STATEMENT_CONSTANT_SWITCH, location),
+ val_(val), clauses_(clauses), break_label_(break_label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The value to switch on.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Traversal.
+
+int
+Constant_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->clauses_->traverse(traverse);
+}
+
+// Determine types.
+
+void
+Constant_switch_statement::do_determine_types()
+{
+ this->val_->determine_type_no_context();
+ this->clauses_->determine_types(this->val_->type());
+}
+
+// Check types.
+
+void
+Constant_switch_statement::do_check_types(Gogo*)
+{
+ if (!this->clauses_->check_types(this->val_->type()))
+ this->set_is_error();
+}
+
+// Return whether this switch may fall through.
+
+bool
+Constant_switch_statement::do_may_fall_through() const
+{
+ if (this->clauses_ == NULL)
+ return true;
+
+ // If we have a break label, then some case needed it. That implies
+ // that the switch statement as a whole can fall through.
+ if (this->break_label_ != NULL)
+ return true;
+
+ return this->clauses_->may_fall_through();
+}
+
+// Convert to GENERIC.
+
+tree
+Constant_switch_statement::do_get_tree(Translate_context* context)
+{
+ tree switch_val_tree = this->val_->get_tree(context);
+
+ Unnamed_label* break_label = this->break_label_;
+ if (break_label == NULL)
+ break_label = new Unnamed_label(this->location());
+
+ tree stmt_list = NULL_TREE;
+ tree s = build3(SWITCH_EXPR, void_type_node, switch_val_tree,
+ this->clauses_->get_constant_tree(context, break_label),
+ NULL_TREE);
+ SET_EXPR_LOCATION(s, this->location());
+ append_to_statement_list(s, &stmt_list);
+
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+
+ return stmt_list;
+}
+
+// Class Switch_statement.
+
+// Traversal.
+
+int
+Switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->val_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->clauses_->traverse(traverse);
+}
+
+// Lower a Switch_statement to a Constant_switch_statement or a series
+// of if statements.
+
+Statement*
+Switch_statement::do_lower(Gogo*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ if (this->val_ != NULL
+ && (this->val_->is_error_expression()
+ || this->val_->type()->is_error_type()))
+ return Statement::make_error_statement(loc);
+
+ if (this->val_ != NULL
+ && this->val_->type()->integer_type() != NULL
+ && !this->clauses_->empty()
+ && this->clauses_->is_constant())
+ return new Constant_switch_statement(this->val_, this->clauses_,
+ this->break_label_, loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ if (this->clauses_->empty())
+ {
+ Expression* val = this->val_;
+ if (val == NULL)
+ val = Expression::make_boolean(true, loc);
+ return Statement::make_statement(val);
+ }
+
+ Temporary_statement* val_temp;
+ if (this->val_ == NULL)
+ val_temp = NULL;
+ else
+ {
+ // var val_temp VAL_TYPE = VAL
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ this->clauses_->lower(b, val_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a switch statement.
+
+Switch_statement*
+Statement::make_switch_statement(Expression* val, source_location location)
+{
+ return new Switch_statement(val, location);
+}
+
+// Class Type_case_clauses::Type_case_clause.
+
+// Traversal.
+
+int
+Type_case_clauses::Type_case_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_default_
+ && ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ && Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->statements_ != NULL)
+ return this->statements_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower one clause in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+// *STMTS_LABEL, if not NULL, is a label to put at the start of the
+// statements.
+
+void
+Type_case_clauses::Type_case_clause::lower(Block* b,
+ Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label,
+ Unnamed_label** stmts_label) const
+{
+ source_location loc = this->location_;
+
+ Unnamed_label* next_case_label = NULL;
+ if (!this->is_default_)
+ {
+ Type* type = this->type_;
+
+ Expression* cond;
+ // The language permits case nil, which is of course a constant
+ // rather than a type. It will appear here as an invalid
+ // forwarding type.
+ if (type->is_nil_constant_as_type())
+ {
+ Expression* ref =
+ Expression::make_temporary_reference(descriptor_temp, loc);
+ cond = Expression::make_binary(OPERATOR_EQEQ, ref,
+ Expression::make_nil(loc),
+ loc);
+ }
+ else
+ {
+ Expression* func;
+ if (type->interface_type() == NULL)
+ {
+ // func ifacetypeeq(*descriptor, *descriptor) bool
+ static Named_object* ifacetypeeq;
+ if (ifacetypeeq == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types =
+ new Typed_identifier_list();
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ param_types->push_back(Typed_identifier("a", descriptor_type,
+ bloc));
+ param_types->push_back(Typed_identifier("b", descriptor_type,
+ bloc));
+ Typed_identifier_list* ret_types =
+ new Typed_identifier_list();
+ Type* bool_type = Type::lookup_bool_type();
+ ret_types->push_back(Typed_identifier("", bool_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL,
+ param_types,
+ ret_types,
+ bloc);
+ ifacetypeeq =
+ Named_object::make_function_declaration("ifacetypeeq", NULL,
+ fntype, bloc);
+ const char* n = "runtime.ifacetypeeq";
+ ifacetypeeq->func_declaration_value()->set_asm_name(n);
+ }
+
+ // ifacetypeeq(descriptor_temp, DESCRIPTOR)
+ func = Expression::make_func_reference(ifacetypeeq, NULL, loc);
+ }
+ else
+ {
+ // func ifaceI2Tp(*descriptor, *descriptor) bool
+ static Named_object* ifaceI2Tp;
+ if (ifaceI2Tp == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types =
+ new Typed_identifier_list();
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ param_types->push_back(Typed_identifier("a", descriptor_type,
+ bloc));
+ param_types->push_back(Typed_identifier("b", descriptor_type,
+ bloc));
+ Typed_identifier_list* ret_types =
+ new Typed_identifier_list();
+ Type* bool_type = Type::lookup_bool_type();
+ ret_types->push_back(Typed_identifier("", bool_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL,
+ param_types,
+ ret_types,
+ bloc);
+ ifaceI2Tp =
+ Named_object::make_function_declaration("ifaceI2Tp", NULL,
+ fntype, bloc);
+ const char* n = "runtime.ifaceI2Tp";
+ ifaceI2Tp->func_declaration_value()->set_asm_name(n);
+ }
+
+ // ifaceI2Tp(descriptor_temp, DESCRIPTOR)
+ func = Expression::make_func_reference(ifaceI2Tp, NULL, loc);
+ }
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(type, loc));
+ Expression* ref =
+ Expression::make_temporary_reference(descriptor_temp, loc);
+ params->push_back(ref);
+ cond = Expression::make_call(func, params, false, loc);
+ }
+
+ Unnamed_label* dest;
+ if (!this->is_fallthrough_)
+ {
+ // if !COND { goto NEXT_CASE_LABEL }
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = next_case_label;
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ }
+ else
+ {
+ // if COND { goto STMTS_LABEL }
+ gcc_assert(stmts_label != NULL);
+ if (*stmts_label == NULL)
+ *stmts_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = *stmts_label;
+ }
+ Block* then_block = new Block(b, loc);
+ Statement* s = Statement::make_goto_unnamed_statement(dest, loc);
+ then_block->add_statement(s);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (this->statements_ != NULL
+ || (!this->is_fallthrough_
+ && stmts_label != NULL
+ && *stmts_label != NULL))
+ {
+ gcc_assert(!this->is_fallthrough_);
+ if (stmts_label != NULL && *stmts_label != NULL)
+ {
+ gcc_assert(!this->is_default_);
+ if (this->statements_ != NULL)
+ (*stmts_label)->set_location(this->statements_->start_location());
+ Statement* s = Statement::make_unnamed_label_statement(*stmts_label);
+ b->add_statement(s);
+ *stmts_label = NULL;
+ }
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+ }
+
+ if (this->is_fallthrough_)
+ gcc_assert(next_case_label == NULL);
+ else
+ {
+ source_location gloc = (this->statements_ == NULL
+ ? loc
+ : this->statements_->end_location());
+ b->add_statement(Statement::make_goto_unnamed_statement(break_label,
+ gloc));
+ if (next_case_label != NULL)
+ {
+ Statement* s =
+ Statement::make_unnamed_label_statement(next_case_label);
+ b->add_statement(s);
+ }
+ }
+}
+
+// Class Type_case_clauses.
+
+// Traversal.
+
+int
+Type_case_clauses::traverse(Traverse* traverse)
+{
+ for (Type_clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check for duplicate types.
+
+void
+Type_case_clauses::check_duplicates() const
+{
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+ Types_seen types_seen;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t == NULL)
+ continue;
+ if (t->is_nil_constant_as_type())
+ t = Type::make_nil_type();
+ std::pair<Types_seen::iterator, bool> ins = types_seen.insert(t);
+ if (!ins.second)
+ error_at(p->location(), "duplicate type in switch");
+ }
+}
+
+// Lower the clauses in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+
+void
+Type_case_clauses::lower(Block* b, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const
+{
+ const Type_case_clause* default_case = NULL;
+
+ Unnamed_label* stmts_label = NULL;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ p->lower(b, descriptor_temp, break_label, &stmts_label);
+ else
+ {
+ // We are generating a series of tests, which means that we
+ // need to move the default case to the end.
+ default_case = &*p;
+ }
+ }
+ gcc_assert(stmts_label == NULL);
+
+ if (default_case != NULL)
+ default_case->lower(b, descriptor_temp, break_label, NULL);
+}
+
+// Class Type_switch_statement.
+
+// Traversal.
+
+int
+Type_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->var_ == NULL)
+ {
+ if (this->traverse_expression(traverse, &this->expr_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->clauses_ != NULL)
+ return this->clauses_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a type switch statement to a series of if statements. The gc
+// compiler is able to generate a table in some cases. However, that
+// does not work for us because we may have type descriptors in
+// different shared libraries, so we can't compare them with simple
+// equality testing.
+
+Statement*
+Type_switch_statement::do_lower(Gogo*, Block* enclosing)
+{
+ const source_location loc = this->location();
+
+ if (this->clauses_ != NULL)
+ this->clauses_->check_duplicates();
+
+ Block* b = new Block(enclosing, loc);
+
+ Type* val_type = (this->var_ != NULL
+ ? this->var_->var_value()->type()
+ : this->expr_->type());
+
+ // var descriptor_temp DESCRIPTOR_TYPE
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ Temporary_statement* descriptor_temp =
+ Statement::make_temporary(descriptor_type, NULL, loc);
+ b->add_statement(descriptor_temp);
+
+ if (val_type->interface_type() == NULL)
+ {
+ // Doing a type switch on a non-interface type. Should we issue
+ // a warning for this case?
+ // descriptor_temp = DESCRIPTOR
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Expression* rhs = Expression::make_type_descriptor(val_type, loc);
+ Statement* s = Statement::make_assignment(lhs, rhs, loc);
+ b->add_statement(s);
+ }
+ else
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+
+ // func {efacetype,ifacetype}(*interface) *descriptor
+ // FIXME: This should be inlined.
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("i", val_type, bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", descriptor_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ bool is_empty = val_type->interface_type()->is_empty();
+ const char* fnname = is_empty ? "efacetype" : "ifacetype";
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ const char* asm_name = (is_empty
+ ? "runtime.efacetype"
+ : "runtime.ifacetype");
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // descriptor_temp = ifacetype(val_temp)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ Expression* ref;
+ if (this->var_ == NULL)
+ ref = this->expr_;
+ else
+ ref = Expression::make_var_reference(this->var_, loc);
+ params->push_back(ref);
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Statement* s = Statement::make_assignment(lhs, call, loc);
+ b->add_statement(s);
+ }
+
+ if (this->clauses_ != NULL)
+ this->clauses_->lower(b, descriptor_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this type switch statement, creating it
+// if necessary.
+
+Unnamed_label*
+Type_switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a type switch statement.
+
+Type_switch_statement*
+Statement::make_type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+{
+ return new Type_switch_statement(var, expr, location);
+}
+
+// Class Select_clauses::Select_clause.
+
+// Traversal.
+
+int
+Select_clauses::Select_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_lowered_
+ && (traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
+ {
+ if (this->channel_ != NULL)
+ {
+ if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->val_ != NULL)
+ {
+ if (Expression::traverse(&this->val_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::Select_clause::lower(Block* b)
+{
+ if (this->is_default_)
+ {
+ gcc_assert(this->channel_ == NULL && this->val_ == NULL);
+ this->is_lowered_ = true;
+ return;
+ }
+
+ source_location loc = this->location_;
+
+ // Evaluate the channel before the select statement.
+ Temporary_statement* channel_temp = Statement::make_temporary(NULL,
+ this->channel_,
+ loc);
+ b->add_statement(channel_temp);
+ this->channel_ = Expression::make_temporary_reference(channel_temp, loc);
+
+ // If this is a send clause, evaluate the value to send before the
+ // select statement.
+ Temporary_statement* val_temp = NULL;
+ if (this->is_send_)
+ {
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ // Add the send or receive before the rest of the statements if any.
+ Block *init = new Block(b, loc);
+ Expression* ref = Expression::make_temporary_reference(channel_temp, loc);
+ if (this->is_send_)
+ {
+ Expression* ref2 = Expression::make_temporary_reference(val_temp, loc);
+ Send_expression* send = Expression::make_send(ref, ref2, loc);
+ send->discarding_value();
+ send->set_for_select();
+ init->add_statement(Statement::make_statement(send));
+ }
+ else
+ {
+ Receive_expression* recv = Expression::make_receive(ref, loc);
+ recv->set_for_select();
+ if (this->val_ != NULL)
+ {
+ gcc_assert(this->var_ == NULL);
+ init->add_statement(Statement::make_assignment(this->val_, recv,
+ loc));
+ }
+ else if (this->var_ != NULL)
+ {
+ this->var_->var_value()->set_init(recv);
+ this->var_->var_value()->clear_type_from_chan_element();
+ }
+ else
+ {
+ recv->discarding_value();
+ init->add_statement(Statement::make_statement(recv));
+ }
+ }
+
+ if (this->statements_ != NULL)
+ init->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+
+ this->statements_ = init;
+
+ // Now all references should be handled through the statements, not
+ // through here.
+ this->is_lowered_ = true;
+ this->val_ = NULL;
+ this->var_ = NULL;
+}
+
+// Determine types.
+
+void
+Select_clauses::Select_clause::determine_types()
+{
+ gcc_assert(this->is_lowered_);
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Whether this clause may fall through to the statement which follows
+// the overall select statement.
+
+bool
+Select_clauses::Select_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Return a tree for the statements to execute.
+
+tree
+Select_clauses::Select_clause::get_statements_tree(Translate_context* context)
+{
+ if (this->statements_ == NULL)
+ return NULL_TREE;
+ return this->statements_->get_tree(context);
+}
+
+// Class Select_clauses.
+
+// Traversal.
+
+int
+Select_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::lower(Block* b)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->lower(b);
+}
+
+// Determine types.
+
+void
+Select_clauses::determine_types()
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types();
+}
+
+// Return whether these select clauses fall through to the statement
+// following the overall select statement.
+
+bool
+Select_clauses::may_fall_through() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (p->may_fall_through())
+ return true;
+ return false;
+}
+
+// Return a tree. We build a call to
+// size_t __go_select(size_t count, _Bool has_default,
+// channel* channels, _Bool* is_send)
+//
+// There are COUNT entries in the CHANNELS and IS_SEND arrays. The
+// value in the IS_SEND array is true for send, false for receive.
+// __go_select returns an integer from 0 to COUNT, inclusive. A
+// return of 0 means that the default case should be run; this only
+// happens if HAS_DEFAULT is non-zero. Otherwise the number indicates
+// the case to run.
+
+// FIXME: This doesn't handle channels which send interface types
+// where the receiver has a static type which matches that interface.
+
+tree
+Select_clauses::get_tree(Translate_context* context,
+ Unnamed_label *break_label,
+ source_location location)
+{
+ size_t count = this->clauses_.size();
+ VEC(constructor_elt, gc)* chan_init = VEC_alloc(constructor_elt, gc, count);
+ VEC(constructor_elt, gc)* is_send_init = VEC_alloc(constructor_elt, gc,
+ count);
+ Select_clause* default_clause = NULL;
+ tree final_stmt_list = NULL_TREE;
+ tree channel_type_tree = NULL_TREE;
+
+ size_t i = 0;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->is_default())
+ {
+ default_clause = &*p;
+ --count;
+ continue;
+ }
+
+ tree channel_tree = p->channel()->get_tree(context);
+ if (channel_tree == error_mark_node)
+ return error_mark_node;
+ channel_type_tree = TREE_TYPE(channel_tree);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, chan_init, NULL);
+ elt->index = build_int_cstu(sizetype, i);
+ elt->value = channel_tree;
+
+ elt = VEC_quick_push(constructor_elt, is_send_init, NULL);
+ elt->index = build_int_cstu(sizetype, i);
+ elt->value = p->is_send() ? boolean_true_node : boolean_false_node;
+
+ ++i;
+ }
+ gcc_assert(i == count);
+
+ if (i == 0 && default_clause != NULL)
+ {
+ // There is only a default clause.
+ gcc_assert(final_stmt_list == NULL_TREE);
+ tree stmt_list = NULL_TREE;
+ append_to_statement_list(default_clause->get_statements_tree(context),
+ &stmt_list);
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+ return stmt_list;
+ }
+
+ tree pointer_chan_type_tree = (channel_type_tree == NULL_TREE
+ ? ptr_type_node
+ : build_pointer_type(channel_type_tree));
+ tree chans_arg;
+ tree pointer_boolean_type_tree = build_pointer_type(boolean_type_node);
+ tree is_sends_arg;
+
+ if (i == 0)
+ {
+ chans_arg = fold_convert_loc(location, pointer_chan_type_tree,
+ null_pointer_node);
+ is_sends_arg = fold_convert_loc(location, pointer_boolean_type_tree,
+ null_pointer_node);
+ }
+ else
+ {
+ tree index_type_tree = build_index_type(size_int(count - 1));
+ tree chan_array_type_tree = build_array_type(channel_type_tree,
+ index_type_tree);
+ tree chan_constructor = build_constructor(chan_array_type_tree,
+ chan_init);
+ tree chan_var = create_tmp_var(chan_array_type_tree, "CHAN");
+ DECL_IGNORED_P(chan_var) = 0;
+ DECL_INITIAL(chan_var) = chan_constructor;
+ DECL_SOURCE_LOCATION(chan_var) = location;
+ TREE_ADDRESSABLE(chan_var) = 1;
+ tree decl_expr = build1(DECL_EXPR, void_type_node, chan_var);
+ SET_EXPR_LOCATION(decl_expr, location);
+ append_to_statement_list(decl_expr, &final_stmt_list);
+
+ tree is_send_array_type_tree = build_array_type(boolean_type_node,
+ index_type_tree);
+ tree is_send_constructor = build_constructor(is_send_array_type_tree,
+ is_send_init);
+ tree is_send_var = create_tmp_var(is_send_array_type_tree, "ISSEND");
+ DECL_IGNORED_P(is_send_var) = 0;
+ DECL_INITIAL(is_send_var) = is_send_constructor;
+ DECL_SOURCE_LOCATION(is_send_var) = location;
+ TREE_ADDRESSABLE(is_send_var) = 1;
+ decl_expr = build1(DECL_EXPR, void_type_node, is_send_var);
+ SET_EXPR_LOCATION(decl_expr, location);
+ append_to_statement_list(decl_expr, &final_stmt_list);
+
+ chans_arg = fold_convert_loc(location, pointer_chan_type_tree,
+ build_fold_addr_expr_loc(location,
+ chan_var));
+ is_sends_arg = fold_convert_loc(location, pointer_boolean_type_tree,
+ build_fold_addr_expr_loc(location,
+ is_send_var));
+ }
+
+ static tree select_fndecl;
+ tree call = Gogo::call_builtin(&select_fndecl,
+ location,
+ "__go_select",
+ 4,
+ sizetype,
+ sizetype,
+ size_int(count),
+ boolean_type_node,
+ (default_clause == NULL
+ ? boolean_false_node
+ : boolean_true_node),
+ pointer_chan_type_tree,
+ chans_arg,
+ pointer_boolean_type_tree,
+ is_sends_arg);
+
+ tree stmt_list = NULL_TREE;
+
+ if (default_clause != NULL)
+ this->add_clause_tree(context, 0, default_clause, break_label, &stmt_list);
+
+ i = 1;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ {
+ this->add_clause_tree(context, i, &*p, break_label, &stmt_list);
+ ++i;
+ }
+ }
+
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+
+ tree switch_stmt = build3(SWITCH_EXPR, sizetype, call, stmt_list, NULL_TREE);
+ SET_EXPR_LOCATION(switch_stmt, location);
+ append_to_statement_list(switch_stmt, &final_stmt_list);
+
+ return final_stmt_list;
+}
+
+// Add the tree for CLAUSE to STMT_LIST.
+
+void
+Select_clauses::add_clause_tree(Translate_context* context, int case_index,
+ Select_clause* clause,
+ Unnamed_label* bottom_label, tree* stmt_list)
+{
+ tree label = create_artificial_label(clause->location());
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ build_int_cst(sizetype, case_index),
+ NULL_TREE, label),
+ stmt_list);
+ append_to_statement_list(clause->get_statements_tree(context), stmt_list);
+ tree g = bottom_label->get_goto(clause->statements() == NULL
+ ? clause->location()
+ : clause->statements()->end_location());
+ append_to_statement_list(g, stmt_list);
+}
+
+// Class Select_statement.
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Select_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Lower a select statement. This will still return a select
+// statement, but it will be modified to implement the order of
+// evaluation rules, and to include the send and receive statements as
+// explicit statements in the clauses.
+
+Statement*
+Select_statement::do_lower(Gogo*, Block* enclosing)
+{
+ if (this->is_lowered_)
+ return this;
+ Block* b = new Block(enclosing, this->location());
+ this->clauses_->lower(b);
+ this->is_lowered_ = true;
+ b->add_statement(this);
+ return Statement::make_block_statement(b, this->location());
+}
+
+// Return the tree for a select statement.
+
+tree
+Select_statement::do_get_tree(Translate_context* context)
+{
+ return this->clauses_->get_tree(context, this->break_label(),
+ this->location());
+}
+
+// Make a select statement.
+
+Select_statement*
+Statement::make_select_statement(source_location location)
+{
+ return new Select_statement(location);
+}
+
+// Class For_statement.
+
+// Traversal.
+
+int
+For_statement::do_traverse(Traverse* traverse)
+{
+ if (this->init_ != NULL)
+ {
+ if (this->init_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->cond_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->post_ != NULL)
+ {
+ if (this->post_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a For_statement into if statements and gotos. Getting rid of
+// complex statements make it easier to handle garbage collection.
+
+Statement*
+For_statement::do_lower(Gogo*, Block* enclosing)
+{
+ Statement* s;
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, this->location());
+ if (this->init_ != NULL)
+ {
+ s = Statement::make_block_statement(this->init_,
+ this->init_->start_location());
+ b->add_statement(s);
+ }
+
+ Unnamed_label* entry = NULL;
+ if (this->cond_ != NULL)
+ {
+ entry = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_goto_unnamed_statement(entry, loc));
+ }
+
+ Unnamed_label* top = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_unnamed_label_statement(top));
+
+ s = Statement::make_block_statement(this->statements_,
+ this->statements_->start_location());
+ b->add_statement(s);
+
+ source_location end_loc = this->statements_->end_location();
+
+ Unnamed_label* cont = this->continue_label_;
+ if (cont != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(cont));
+
+ if (this->post_ != NULL)
+ {
+ s = Statement::make_block_statement(this->post_,
+ this->post_->start_location());
+ b->add_statement(s);
+ end_loc = this->post_->end_location();
+ }
+
+ if (this->cond_ == NULL)
+ b->add_statement(Statement::make_goto_unnamed_statement(top, end_loc));
+ else
+ {
+ b->add_statement(Statement::make_unnamed_label_statement(entry));
+
+ source_location cond_loc = this->cond_->location();
+ Block* then_block = new Block(b, cond_loc);
+ s = Statement::make_goto_unnamed_statement(top, cond_loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(this->cond_, then_block, NULL, cond_loc);
+ b->add_statement(s);
+ }
+
+ Unnamed_label* brk = this->break_label_;
+ if (brk != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(brk));
+
+ b->set_end_location(end_loc);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label, creating it if necessary.
+
+Unnamed_label*
+For_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Set the break and continue labels a for statement. This is used
+// when lowering a for range statement.
+
+void
+For_statement::set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label)
+{
+ gcc_assert(this->break_label_ == NULL && this->continue_label_ == NULL);
+ this->break_label_ = break_label;
+ this->continue_label_ = continue_label;
+}
+
+// Make a for statement.
+
+For_statement*
+Statement::make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+{
+ return new For_statement(init, cond, post, location);
+}
+
+// Class For_range_statement.
+
+// Traversal.
+
+int
+For_range_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->index_var_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->value_var_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->value_var_)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->traverse_expression(traverse, &this->range_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a for range statement. For simplicity we lower this into a
+// for statement, which will then be lowered in turn to goto
+// statements.
+
+Statement*
+For_range_statement::do_lower(Gogo* gogo, Block* enclosing)
+{
+ Type* range_type = this->range_->type();
+ if (range_type->points_to() != NULL
+ && range_type->points_to()->array_type() != NULL
+ && !range_type->points_to()->is_open_array_type())
+ range_type = range_type->points_to();
+
+ Type* index_type;
+ Type* value_type = NULL;
+ if (range_type->array_type() != NULL)
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = range_type->array_type()->element_type();
+ }
+ else if (range_type->is_string_type())
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = index_type;
+ }
+ else if (range_type->map_type() != NULL)
+ {
+ index_type = range_type->map_type()->key_type();
+ value_type = range_type->map_type()->val_type();
+ }
+ else if (range_type->channel_type() != NULL)
+ {
+ index_type = range_type->channel_type()->element_type();
+ if (this->value_var_ != NULL)
+ {
+ if (!this->value_var_->type()->is_error_type())
+ this->report_error(_("too many variables for range clause "
+ "with channel"));
+ return Statement::make_error_statement(this->location());
+ }
+ }
+ else
+ {
+ this->report_error(_("range clause must have "
+ "array, slice, setring, map, or channel type"));
+ return Statement::make_error_statement(this->location());
+ }
+
+ source_location loc = this->location();
+ Block* temp_block = new Block(enclosing, loc);
+
+ Named_object* range_object = NULL;
+ Temporary_statement* range_temp = NULL;
+ Var_expression* ve = this->range_->var_expression();
+ if (ve != NULL)
+ range_object = ve->named_object();
+ else
+ {
+ range_temp = Statement::make_temporary(NULL, this->range_, loc);
+ temp_block->add_statement(range_temp);
+ }
+
+ Temporary_statement* index_temp = Statement::make_temporary(index_type,
+ NULL, loc);
+ temp_block->add_statement(index_temp);
+
+ Temporary_statement* value_temp = NULL;
+ if (this->value_var_ != NULL)
+ {
+ value_temp = Statement::make_temporary(value_type, NULL, loc);
+ temp_block->add_statement(value_temp);
+ }
+
+ Block* body = new Block(temp_block, loc);
+
+ Block* init;
+ Expression* cond;
+ Block* iter_init;
+ Block* post;
+
+ // Arrange to do a loop appropriate for the type. We will produce
+ // for INIT ; COND ; POST {
+ // ITER_INIT
+ // INDEX = INDEX_TEMP
+ // VALUE = VALUE_TEMP // If there is a value
+ // original statements
+ // }
+
+ if (range_type->array_type() != NULL)
+ this->lower_range_array(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->is_string_type())
+ this->lower_range_string(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->map_type() != NULL)
+ this->lower_range_map(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->channel_type() != NULL)
+ this->lower_range_channel(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else
+ gcc_unreachable();
+
+ if (iter_init != NULL)
+ body->add_statement(Statement::make_block_statement(iter_init, loc));
+
+ Statement* assign;
+ Expression* index_ref = Expression::make_temporary_reference(index_temp, loc);
+ if (this->value_var_ == NULL)
+ {
+ assign = Statement::make_assignment(this->index_var_, index_ref, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(this->index_var_);
+ lhs->push_back(this->value_var_);
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(index_ref);
+ rhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ assign = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ body->add_statement(assign);
+
+ body->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ body->set_end_location(this->statements_->end_location());
+
+ For_statement* loop = Statement::make_for_statement(init, cond, post,
+ this->location());
+ loop->add_statements(body);
+ loop->set_break_continue_labels(this->break_label_, this->continue_label_);
+
+ temp_block->add_statement(loop);
+
+ return Statement::make_block_statement(temp_block, loc);
+}
+
+// Return a reference to the range, which may be in RANGE_OBJECT or in
+// RANGE_TEMP.
+
+Expression*
+For_range_statement::make_range_ref(Named_object* range_object,
+ Temporary_statement* range_temp,
+ source_location loc)
+{
+ if (range_object != NULL)
+ return Expression::make_var_reference(range_object, loc);
+ else
+ return Expression::make_temporary_reference(range_temp, loc);
+}
+
+// Return a call to the predeclared function FUNCNAME passing a
+// reference to the temporary variable ARG.
+
+Expression*
+For_range_statement::call_builtin(Gogo* gogo, const char* funcname,
+ Expression* arg,
+ source_location loc)
+{
+ Named_object* no = gogo->lookup_global(funcname);
+ gcc_assert(no != NULL && no->is_function_declaration());
+ Expression* func = Expression::make_func_reference(no, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(arg);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a for range over an array or slice.
+
+void
+For_range_statement::lower_range_array(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // len_temp := len(range)
+ // for index_temp = 0; index_temp < len_temp; index_temp++ {
+ // value_temp = range[index_temp]
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var len_temp int
+ // len_temp = len(range)
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Expression* ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* len_call = this->call_builtin(gogo, "len", ref, loc);
+ Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(),
+ len_call, loc);
+ init->add_statement(len_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+ init->add_statement(s);
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // index_temp < len_temp
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(len_temp, loc);
+ Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc);
+
+ *pcond = lt;
+
+ // Set *PITER_INIT to
+ // value_temp = range[index_temp]
+
+ Block* iter_init = NULL;
+ if (value_temp != NULL)
+ {
+ iter_init = new Block(body_block, loc);
+
+ ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(index_temp, loc);
+ Expression* index = Expression::make_index(ref, ref2, NULL, loc);
+
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ s = Statement::make_assignment(ref, index, loc);
+
+ iter_init->add_statement(s);
+ }
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp++
+
+ Block* post = new Block(enclosing, loc);
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ s = Statement::make_inc_statement(ref);
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a string.
+
+void
+For_range_statement::lower_range_string(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // var next_index_temp int
+ // for index_temp = 0; ; index_temp = next_index_temp {
+ // next_index_temp, value_temp = stringiter2(range, index_temp)
+ // if next_index_temp == 0 {
+ // break
+ // }
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var next_index_temp int
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Temporary_statement* next_index_temp =
+ Statement::make_temporary(index_temp->type(), NULL, loc);
+ init->add_statement(next_index_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+
+ Expression* ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+
+ init->add_statement(s);
+ *pinit = init;
+
+ // The loop has no condition.
+
+ *pcond = NULL;
+
+ // Set *PITER_INIT to
+ // next_index_temp = runtime.stringiter(range, index_temp)
+ // or
+ // next_index_temp, value_temp = runtime.stringiter2(range, index_temp)
+ // followed by
+ // if next_index_temp == 0 {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Named_object* no;
+ if (value_temp == NULL)
+ {
+ static Named_object* stringiter;
+ if (stringiter == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+ Type* int_type = gogo->lookup_global("int")->type_value();
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("s", Type::make_string_type(),
+ bloc));
+ params->push_back(Typed_identifier("k", int_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", int_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, params,
+ results, bloc);
+ stringiter = Named_object::make_function_declaration("stringiter",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.stringiter";
+ stringiter->func_declaration_value()->set_asm_name(n);
+ }
+ no = stringiter;
+ }
+ else
+ {
+ static Named_object* stringiter2;
+ if (stringiter2 == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+ Type* int_type = gogo->lookup_global("int")->type_value();
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("s", Type::make_string_type(),
+ bloc));
+ params->push_back(Typed_identifier("k", int_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", int_type, bloc));
+ results->push_back(Typed_identifier("", int_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, params,
+ results, bloc);
+ stringiter2 = Named_object::make_function_declaration("stringiter",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.stringiter2";
+ stringiter2->func_declaration_value()->set_asm_name(n);
+ }
+ no = stringiter2;
+ }
+
+ Expression* func = Expression::make_func_reference(no, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->make_range_ref(range_object, range_temp, loc));
+ params->push_back(Expression::make_temporary_reference(index_temp, loc));
+ Call_expression* call = Expression::make_call(func, params, false, loc);
+
+ if (value_temp == NULL)
+ {
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(ref, call, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(Expression::make_temporary_reference(next_index_temp,
+ loc));
+ lhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(Expression::make_call_result(call, 0));
+ rhs->push_back(Expression::make_call_result(call, 1));
+
+ s = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ iter_init->add_statement(s);
+
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+ Expression* equals = Expression::make_binary(OPERATOR_EQEQ, ref, zexpr, loc);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(equals, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp = next_index_temp
+
+ Block* post = new Block(enclosing, loc);
+
+ Expression* lhs = Expression::make_temporary_reference(index_temp, loc);
+ Expression* rhs = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(lhs, rhs, loc);
+
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a map.
+
+void
+For_range_statement::lower_range_map(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The runtime uses a struct to handle ranges over a map. The
+ // struct is four pointers long. The first pointer is NULL when we
+ // have completed the iteration.
+
+ // The loop we generate:
+ // var hiter map_iteration_struct
+ // for mapiterinit(range, &hiter); hiter[0] != nil; mapiternext(&hiter) {
+ // mapiter2(hiter, &index_temp, &value_temp)
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var hiter map_iteration_struct
+ // runtime.mapiterinit(range, &hiter)
+
+ Block* init = new Block(enclosing, loc);
+
+ const unsigned long map_iteration_size = 4;
+
+ mpz_t ival;
+ mpz_init_set_ui(ival, map_iteration_size);
+ Expression* iexpr = Expression::make_integer(&ival, NULL, loc);
+ mpz_clear(ival);
+
+ Type* byte_type = gogo->lookup_global("byte")->type_value();
+ Type* ptr_type = Type::make_pointer_type(byte_type);
+
+ Type* map_iteration_type = Type::make_array_type(ptr_type, iexpr);
+ Type* map_iteration_ptr = Type::make_pointer_type(map_iteration_type);
+
+ Temporary_statement* hiter = Statement::make_temporary(map_iteration_type,
+ NULL, loc);
+ init->add_statement(hiter);
+
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("map", this->range_->type(), bloc));
+ param_types->push_back(Typed_identifier("it", map_iteration_ptr, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types, NULL,
+ bloc);
+
+ Named_object* mapiterinit =
+ Named_object::make_function_declaration("mapiterinit", NULL, fntype, bloc);
+ const char* n = "runtime.mapiterinit";
+ mapiterinit->func_declaration_value()->set_asm_name(n);
+
+ Expression* func = Expression::make_func_reference(mapiterinit, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->make_range_ref(range_object, range_temp, loc));
+ Expression* ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ init->add_statement(Statement::make_statement(call));
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // hiter[0] != nil
+
+ ref = Expression::make_temporary_reference(hiter, loc);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ Expression* index = Expression::make_index(ref, zexpr, NULL, loc);
+
+ Expression* ne = Expression::make_binary(OPERATOR_NOTEQ, index,
+ Expression::make_nil(loc),
+ loc);
+
+ *pcond = ne;
+
+ // Set *PITER_INIT to
+ // mapiter1(hiter, &index_temp)
+ // or
+ // mapiter2(hiter, &index_temp, &value_temp)
+
+ Block* iter_init = new Block(body_block, loc);
+
+ param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hiter", map_iteration_ptr, bloc));
+ Type* pkey_type = Type::make_pointer_type(index_temp->type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ if (value_temp != NULL)
+ {
+ Type* pval_type = Type::make_pointer_type(value_temp->type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+ }
+ fntype = Type::make_function_type(NULL, param_types, NULL, bloc);
+ n = value_temp == NULL ? "mapiter1" : "mapiter2";
+ Named_object* mapiter = Named_object::make_function_declaration(n, NULL,
+ fntype, bloc);
+ n = value_temp == NULL ? "runtime.mapiter1" : "runtime.mapiter2";
+ mapiter->func_declaration_value()->set_asm_name(n);
+
+ func = Expression::make_func_reference(mapiter, NULL, loc);
+ params = new Expression_list();
+ ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ if (value_temp != NULL)
+ {
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ }
+ call = Expression::make_call(func, params, false, loc);
+ iter_init->add_statement(Statement::make_statement(call));
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // mapiternext(&hiter)
+
+ Block* post = new Block(enclosing, loc);
+
+ static Named_object* mapiternext;
+ if (mapiternext == NULL)
+ {
+ param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("it", map_iteration_ptr, bloc));
+ fntype = Type::make_function_type(NULL, param_types, NULL, bloc);
+ mapiternext = Named_object::make_function_declaration("mapiternext",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.mapiternext";
+ mapiternext->func_declaration_value()->set_asm_name(n);
+ }
+
+ func = Expression::make_func_reference(mapiternext, NULL, loc);
+ params = new Expression_list();
+ ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ call = Expression::make_call(func, params, false, loc);
+ post->add_statement(Statement::make_statement(call));
+
+ *ppost = post;
+}
+
+// Lower a for range over a channel.
+
+void
+For_range_statement::lower_range_channel(Gogo* gogo,
+ Block*,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ gcc_assert(value_temp == NULL);
+
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // for {
+ // index_temp = <-range
+ // if closed(range) {
+ // break
+ // }
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // We have no initialization code, no condition, and no post code.
+
+ *pinit = NULL;
+ *pcond = NULL;
+ *ppost = NULL;
+
+ // Set *PITER_INIT to
+ // index_temp = <-range
+ // if closed(range) {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Expression* ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* cond = this->call_builtin(gogo, "closed", ref, loc);
+
+ ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* recv = Expression::make_receive(ref, loc);
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, recv, loc);
+ iter_init->add_statement(s);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+}
+
+// Return the break LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Make a for statement with a range clause.
+
+For_range_statement*
+Statement::make_for_range_statement(Expression* index_var,
+ Expression* value_var,
+ Expression* range,
+ source_location location)
+{
+ return new For_range_statement(index_var, value_var, range, location);
+}
--- /dev/null
+// statements.cc -- Go frontend statements.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "gogo.h"
+#include "runtime.h"
+#include "backend.h"
+#include "statements.h"
+
+// Class Statement.
+
+Statement::Statement(Statement_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Statement::~Statement()
+{
+}
+
+// Traverse the tree. The work of walking the components is handled
+// by the subclasses.
+
+int
+Statement::traverse(Block* block, size_t* pindex, Traverse* traverse)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return TRAVERSE_CONTINUE;
+
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_statements) != 0)
+ {
+ int t = traverse->statement(block, pindex, this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ // No point in checking traverse_mask here--a statement may contain
+ // other blocks or statements, and if we got here we always want to
+ // walk them.
+ return this->do_traverse(traverse);
+}
+
+// Traverse the contents of a statement.
+
+int
+Statement::traverse_contents(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Traverse assignments.
+
+bool
+Statement::traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return false;
+ return this->do_traverse_assignments(tassign);
+}
+
+// Traverse an expression in a statement. This is a helper function
+// for child classes.
+
+int
+Statement::traverse_expression(Traverse* traverse, Expression** expr)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Expression::traverse(expr, traverse);
+}
+
+// Traverse an expression list in a statement. This is a helper
+// function for child classes.
+
+int
+Statement::traverse_expression_list(Traverse* traverse,
+ Expression_list* expr_list)
+{
+ if (expr_list == NULL)
+ return TRAVERSE_CONTINUE;
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return expr_list->traverse(traverse);
+}
+
+// Traverse a type in a statement. This is a helper function for
+// child classes.
+
+int
+Statement::traverse_type(Traverse* traverse, Type* type)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Type::traverse(type, traverse);
+}
+
+// Set type information for unnamed constants. This is really done by
+// the child class.
+
+void
+Statement::determine_types()
+{
+ this->do_determine_types();
+}
+
+// If this is a thunk statement, return it.
+
+Thunk_statement*
+Statement::thunk_statement()
+{
+ Thunk_statement* ret = this->convert<Thunk_statement, STATEMENT_GO>();
+ if (ret == NULL)
+ ret = this->convert<Thunk_statement, STATEMENT_DEFER>();
+ return ret;
+}
+
+// Convert a Statement to the backend representation. This is really
+// done by the child class.
+
+Bstatement*
+Statement::get_backend(Translate_context* context)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return context->backend()->error_statement();
+ return this->do_get_backend(context);
+}
+
+// Note that this statement is erroneous. This is called by children
+// when they discover an error.
+
+void
+Statement::set_is_error()
+{
+ this->classification_ = STATEMENT_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Statement::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// An error statement, used to avoid crashing after we report an
+// error.
+
+class Error_statement : public Statement
+{
+ public:
+ Error_statement(source_location location)
+ : Statement(STATEMENT_ERROR, location)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+};
+
+// Make an error statement.
+
+Statement*
+Statement::make_error_statement(source_location location)
+{
+ return new Error_statement(location);
+}
+
+// Class Variable_declaration_statement.
+
+Variable_declaration_statement::Variable_declaration_statement(
+ Named_object* var)
+ : Statement(STATEMENT_VARIABLE_DECLARATION, var->var_value()->location()),
+ var_(var)
+{
+}
+
+// We don't actually traverse the variable here; it was traversed
+// while traversing the Block.
+
+int
+Variable_declaration_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Traverse the assignments in a variable declaration. Note that this
+// traversal is different from the usual traversal.
+
+bool
+Variable_declaration_statement::do_traverse_assignments(
+ Traverse_assignments* tassign)
+{
+ tassign->initialize_variable(this->var_);
+ return true;
+}
+
+// Convert a variable declaration to the backend representation.
+
+Bstatement*
+Variable_declaration_statement::do_get_backend(Translate_context* context)
+{
+ Variable* var = this->var_->var_value();
+ Bvariable* bvar = this->var_->get_backend_variable(context->gogo(),
+ context->function());
+ tree init = var->get_init_tree(context->gogo(), context->function());
+ Bexpression* binit = init == NULL ? NULL : tree_to_expr(init);
+
+ if (!var->is_in_heap())
+ {
+ go_assert(binit != NULL);
+ return context->backend()->init_statement(bvar, binit);
+ }
+
+ // Something takes the address of this variable, so the value is
+ // stored in the heap. Initialize it to newly allocated memory
+ // space, and assign the initial value to the new space.
+ source_location loc = this->location();
+ Named_object* newfn = context->gogo()->lookup_global("new");
+ go_assert(newfn != NULL && newfn->is_function_declaration());
+ Expression* func = Expression::make_func_reference(newfn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type(var->type(), loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ context->gogo()->lower_expression(context->function(), &call);
+ Temporary_statement* temp = Statement::make_temporary(NULL, call, loc);
+ Bstatement* btemp = temp->get_backend(context);
+
+ Bstatement* set = NULL;
+ if (binit != NULL)
+ {
+ Expression* e = Expression::make_temporary_reference(temp, loc);
+ e = Expression::make_unary(OPERATOR_MULT, e, loc);
+ Bexpression* be = tree_to_expr(e->get_tree(context));
+ set = context->backend()->assignment_statement(be, binit, loc);
+ }
+
+ Expression* ref = Expression::make_temporary_reference(temp, loc);
+ Bexpression* bref = tree_to_expr(ref->get_tree(context));
+ Bstatement* sinit = context->backend()->init_statement(bvar, bref);
+
+ std::vector<Bstatement*> stats;
+ stats.reserve(3);
+ stats.push_back(btemp);
+ if (set != NULL)
+ stats.push_back(set);
+ stats.push_back(sinit);
+ return context->backend()->statement_list(stats);
+}
+
+// Make a variable declaration.
+
+Statement*
+Statement::make_variable_declaration(Named_object* var)
+{
+ return new Variable_declaration_statement(var);
+}
+
+// Class Temporary_statement.
+
+// Return the type of the temporary variable.
+
+Type*
+Temporary_statement::type() const
+{
+ return this->type_ != NULL ? this->type_ : this->init_->type();
+}
+
+// Traversal.
+
+int
+Temporary_statement::do_traverse(Traverse* traverse)
+{
+ if (this->type_ != NULL
+ && this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->init_ == NULL)
+ return TRAVERSE_CONTINUE;
+ else
+ return this->traverse_expression(traverse, &this->init_);
+}
+
+// Traverse assignments.
+
+bool
+Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->init_ == NULL)
+ return false;
+ tassign->value(&this->init_, true, true);
+ return true;
+}
+
+// Determine types.
+
+void
+Temporary_statement::do_determine_types()
+{
+ if (this->type_ != NULL && this->type_->is_abstract())
+ this->type_ = this->type_->make_non_abstract_type();
+
+ if (this->init_ != NULL)
+ {
+ if (this->type_ == NULL)
+ this->init_->determine_type_no_context();
+ else
+ {
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ }
+ }
+
+ if (this->type_ == NULL)
+ {
+ this->type_ = this->init_->type();
+ go_assert(!this->type_->is_abstract());
+ }
+}
+
+// Check types.
+
+void
+Temporary_statement::do_check_types(Gogo*)
+{
+ if (this->type_ != NULL && this->init_ != NULL)
+ {
+ std::string reason;
+ if (!Type::are_assignable(this->type_, this->init_->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(), "incompatible types in assignment");
+ else
+ error_at(this->location(), "incompatible types in assignment (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Convert to backend representation.
+
+Bstatement*
+Temporary_statement::do_get_backend(Translate_context* context)
+{
+ go_assert(this->bvariable_ == NULL);
+
+ // FIXME: Permitting FUNCTION to be NULL here is a temporary measure
+ // until we have a better representation of the init function.
+ Named_object* function = context->function();
+ Bfunction* bfunction;
+ if (function == NULL)
+ bfunction = NULL;
+ else
+ bfunction = tree_to_function(function->func_value()->get_decl());
+
+ Btype* btype = tree_to_type(this->type()->get_tree(context->gogo()));
+
+ Bexpression* binit;
+ if (this->init_ == NULL)
+ binit = NULL;
+ else if (this->type_ == NULL)
+ binit = tree_to_expr(this->init_->get_tree(context));
+ else
+ {
+ Expression* init = Expression::make_cast(this->type_, this->init_,
+ this->location());
+ context->gogo()->lower_expression(context->function(), &init);
+ binit = tree_to_expr(init->get_tree(context));
+ }
+
+ Bstatement* statement;
+ this->bvariable_ =
+ context->backend()->temporary_variable(bfunction, context->bblock(),
+ btype, binit,
+ this->is_address_taken_,
+ this->location(), &statement);
+ return statement;
+}
+
+// Return the backend variable.
+
+Bvariable*
+Temporary_statement::get_backend_variable(Translate_context* context) const
+{
+ if (this->bvariable_ == NULL)
+ {
+ go_assert(saw_errors());
+ return context->backend()->error_variable();
+ }
+ return this->bvariable_;
+}
+
+// Make and initialize a temporary variable in BLOCK.
+
+Temporary_statement*
+Statement::make_temporary(Type* type, Expression* init,
+ source_location location)
+{
+ return new Temporary_statement(type, init, location);
+}
+
+// An assignment statement.
+
+class Assignment_statement : public Statement
+{
+ public:
+ Assignment_statement(Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // Left hand side--the lvalue.
+ Expression* lhs_;
+ // Right hand side--the rvalue.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+bool
+Assignment_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ tassign->assignment(&this->lhs_, &this->rhs_);
+ return true;
+}
+
+// Set types for the assignment.
+
+void
+Assignment_statement::do_determine_types()
+{
+ this->lhs_->determine_type_no_context();
+ Type_context context(this->lhs_->type(), false);
+ this->rhs_->determine_type(&context);
+}
+
+// Check types for an assignment.
+
+void
+Assignment_statement::do_check_types(Gogo*)
+{
+ // The left hand side must be either addressable, a map index
+ // expression, or the blank identifier.
+ if (!this->lhs_->is_addressable()
+ && this->lhs_->map_index_expression() == NULL
+ && !this->lhs_->is_sink_expression())
+ {
+ if (!this->lhs_->type()->is_error())
+ this->report_error(_("invalid left hand side of assignment"));
+ return;
+ }
+
+ Type* lhs_type = this->lhs_->type();
+ Type* rhs_type = this->rhs_->type();
+ std::string reason;
+ if (!Type::are_assignable(lhs_type, rhs_type, &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(), "incompatible types in assignment");
+ else
+ error_at(this->location(), "incompatible types in assignment (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+
+ if (lhs_type->is_error() || rhs_type->is_error())
+ this->set_is_error();
+}
+
+// Convert an assignment statement to the backend representation.
+
+Bstatement*
+Assignment_statement::do_get_backend(Translate_context* context)
+{
+ tree rhs_tree = this->rhs_->get_tree(context);
+ if (this->lhs_->is_sink_expression())
+ return context->backend()->expression_statement(tree_to_expr(rhs_tree));
+ tree lhs_tree = this->lhs_->get_tree(context);
+ rhs_tree = Expression::convert_for_assignment(context, this->lhs_->type(),
+ this->rhs_->type(), rhs_tree,
+ this->location());
+ return context->backend()->assignment_statement(tree_to_expr(lhs_tree),
+ tree_to_expr(rhs_tree),
+ this->location());
+}
+
+// Make an assignment statement.
+
+Statement*
+Statement::make_assignment(Expression* lhs, Expression* rhs,
+ source_location location)
+{
+ return new Assignment_statement(lhs, rhs, location);
+}
+
+// The Move_ordered_evals class is used to find any subexpressions of
+// an expression that have an evaluation order dependency. It creates
+// temporary variables to hold them.
+
+class Move_ordered_evals : public Traverse
+{
+ public:
+ Move_ordered_evals(Block* block)
+ : Traverse(traverse_expressions),
+ block_(block)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The block where new temporary variables should be added.
+ Block* block_;
+};
+
+int
+Move_ordered_evals::expression(Expression** pexpr)
+{
+ // We have to look at subexpressions first.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*pexpr)->must_eval_in_order())
+ {
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc);
+ this->block_->add_statement(temp);
+ *pexpr = Expression::make_temporary_reference(temp, loc);
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// An assignment operation statement.
+
+class Assignment_operation_statement : public Statement
+{
+ public:
+ Assignment_operation_statement(Operator op, Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT_OPERATION, location),
+ op_(op), lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The operator (OPERATOR_PLUSEQ, etc.).
+ Operator op_;
+ // Left hand side.
+ Expression* lhs_;
+ // Right hand side.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_operation_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+// Lower an assignment operation statement to a regular assignment
+// statement.
+
+Statement*
+Assignment_operation_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ // We have to evaluate the left hand side expression only once. We
+ // do this by moving out any expression with side effects.
+ Block* b = new Block(enclosing, loc);
+ Move_ordered_evals moe(b);
+ this->lhs_->traverse_subexpressions(&moe);
+
+ Expression* lval = this->lhs_->copy();
+
+ Operator op;
+ switch (this->op_)
+ {
+ case OPERATOR_PLUSEQ:
+ op = OPERATOR_PLUS;
+ break;
+ case OPERATOR_MINUSEQ:
+ op = OPERATOR_MINUS;
+ break;
+ case OPERATOR_OREQ:
+ op = OPERATOR_OR;
+ break;
+ case OPERATOR_XOREQ:
+ op = OPERATOR_XOR;
+ break;
+ case OPERATOR_MULTEQ:
+ op = OPERATOR_MULT;
+ break;
+ case OPERATOR_DIVEQ:
+ op = OPERATOR_DIV;
+ break;
+ case OPERATOR_MODEQ:
+ op = OPERATOR_MOD;
+ break;
+ case OPERATOR_LSHIFTEQ:
+ op = OPERATOR_LSHIFT;
+ break;
+ case OPERATOR_RSHIFTEQ:
+ op = OPERATOR_RSHIFT;
+ break;
+ case OPERATOR_ANDEQ:
+ op = OPERATOR_AND;
+ break;
+ case OPERATOR_BITCLEAREQ:
+ op = OPERATOR_BITCLEAR;
+ break;
+ default:
+ go_unreachable();
+ }
+
+ Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc);
+ Statement* s = Statement::make_assignment(this->lhs_, binop, loc);
+ if (b->statements()->empty())
+ {
+ delete b;
+ return s;
+ }
+ else
+ {
+ b->add_statement(s);
+ return Statement::make_block_statement(b, loc);
+ }
+}
+
+// Make an assignment operation statement.
+
+Statement*
+Statement::make_assignment_operation(Operator op, Expression* lhs,
+ Expression* rhs, source_location location)
+{
+ return new Assignment_operation_statement(op, lhs, rhs, location);
+}
+
+// A tuple assignment statement. This differs from an assignment
+// statement in that the right-hand-side expressions are evaluated in
+// parallel.
+
+class Tuple_assignment_statement : public Statement
+{
+ public:
+ Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // Left hand side--a list of lvalues.
+ Expression_list* lhs_;
+ // Right hand side--a list of rvalues.
+ Expression_list* rhs_;
+};
+
+// Traversal.
+
+int
+Tuple_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression_list(traverse, this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression_list(traverse, this->rhs_);
+}
+
+// Lower a tuple assignment. We use temporary variables to split it
+// up into a set of single assignments.
+
+Statement*
+Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, loc);
+
+ // First move out any subexpressions on the left hand side. The
+ // right hand side will be evaluated in the required order anyhow.
+ Move_ordered_evals moe(b);
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs)
+ (*plhs)->traverse_subexpressions(&moe);
+
+ std::vector<Temporary_statement*> temps;
+ temps.reserve(this->lhs_->size());
+
+ Expression_list::const_iterator prhs = this->rhs_->begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ go_assert(prhs != this->rhs_->end());
+
+ if ((*plhs)->is_error_expression()
+ || (*plhs)->type()->is_error()
+ || (*prhs)->is_error_expression()
+ || (*prhs)->type()->is_error())
+ continue;
+
+ if ((*plhs)->is_sink_expression())
+ {
+ b->add_statement(Statement::make_statement(*prhs));
+ continue;
+ }
+
+ Temporary_statement* temp = Statement::make_temporary((*plhs)->type(),
+ *prhs, loc);
+ b->add_statement(temp);
+ temps.push_back(temp);
+
+ }
+ go_assert(prhs == this->rhs_->end());
+
+ prhs = this->rhs_->begin();
+ std::vector<Temporary_statement*>::const_iterator ptemp = temps.begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ if ((*plhs)->is_error_expression()
+ || (*plhs)->type()->is_error()
+ || (*prhs)->is_error_expression()
+ || (*prhs)->type()->is_error())
+ continue;
+
+ if ((*plhs)->is_sink_expression())
+ continue;
+
+ Expression* ref = Expression::make_temporary_reference(*ptemp, loc);
+ Statement* s = Statement::make_assignment(*plhs, ref, loc);
+ b->add_statement(s);
+ ++ptemp;
+ }
+ go_assert(ptemp == temps.end());
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a tuple assignment statement.
+
+Statement*
+Statement::make_tuple_assignment(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+{
+ return new Tuple_assignment_statement(lhs, rhs, location);
+}
+
+// A tuple assignment from a map index expression.
+// v, ok = m[k]
+
+class Tuple_map_assignment_statement : public Statement
+{
+public:
+ Tuple_map_assignment_statement(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_MAP_ASSIGNMENT, location),
+ val_(val), present_(present), map_index_(map_index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the map.
+ Expression* val_;
+ // Lvalue which receives whether the key value was present.
+ Expression* present_;
+ // The map index expression.
+ Expression* map_index_;
+};
+
+// Traversal.
+
+int
+Tuple_map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->present_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->map_index_);
+}
+
+// Lower a tuple map assignment.
+
+Statement*
+Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on right hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+ if (map_type == NULL)
+ return Statement::make_error_statement(loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ // Move out any subexpressions to make sure that functions are
+ // called in the required order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->present_->traverse_subexpressions(&moe);
+
+ // Copy the key value into a temporary so that we can take its
+ // address without pushing the value onto the heap.
+
+ // var key_temp KEY_TYPE = MAP_INDEX
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp VAL_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var present_temp bool
+ Temporary_statement* present_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(present_temp);
+
+ // present_temp = mapaccess2(MAP, &key_temp, &val_temp)
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ Expression* a1 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ Expression* a2 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ Expression* call = Runtime::make_call(Runtime::MAPACCESS2, loc, 3,
+ map_index->map(), a1, a2);
+
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // present = present_temp
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ s = Statement::make_assignment(this->present_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a map assignment statement which returns a pair of values.
+
+Statement*
+Statement::make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+{
+ return new Tuple_map_assignment_statement(val, present, map_index, location);
+}
+
+// Assign a pair of entries to a map.
+// m[k] = v, p
+
+class Map_assignment_statement : public Statement
+{
+ public:
+ Map_assignment_statement(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+ : Statement(STATEMENT_MAP_ASSIGNMENT, location),
+ map_index_(map_index), val_(val), should_set_(should_set)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // A reference to the map index which should be set or deleted.
+ Expression* map_index_;
+ // The value to add to the map.
+ Expression* val_;
+ // Whether or not to add the value.
+ Expression* should_set_;
+};
+
+// Traverse a map assignment.
+
+int
+Map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->map_index_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->should_set_);
+}
+
+// Lower a map assignment to a function call.
+
+Statement*
+Map_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on left hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+ if (map_type == NULL)
+ return Statement::make_error_statement(loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ // Evaluate the map first to get order of evaluation right.
+ // map_temp := m // we are evaluating m[k] = v, p
+ Temporary_statement* map_temp = Statement::make_temporary(map_type,
+ map_index->map(),
+ loc);
+ b->add_statement(map_temp);
+
+ // var key_temp MAP_KEY_TYPE = k
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp MAP_VAL_TYPE = v
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), this->val_, loc);
+ b->add_statement(val_temp);
+
+ // var insert_temp bool = p
+ Temporary_statement* insert_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), this->should_set_,
+ loc);
+ b->add_statement(insert_temp);
+
+ // mapassign2(map_temp, &key_temp, &val_temp, p)
+ Expression* p1 = Expression::make_temporary_reference(map_temp, loc);
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ Expression* p4 = Expression::make_temporary_reference(insert_temp, loc);
+ Expression* call = Runtime::make_call(Runtime::MAPASSIGN2, loc, 4,
+ p1, p2, p3, p4);
+ Statement* s = Statement::make_statement(call);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a statement which assigns a pair of entries to a map.
+
+Statement*
+Statement::make_map_assignment(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+{
+ return new Map_assignment_statement(map_index, val, should_set, location);
+}
+
+// A tuple assignment from a receive statement.
+
+class Tuple_receive_assignment_statement : public Statement
+{
+ public:
+ Tuple_receive_assignment_statement(Expression* val, Expression* closed,
+ Expression* channel, bool for_select,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_RECEIVE_ASSIGNMENT, location),
+ val_(val), closed_(closed), channel_(channel), for_select_(for_select)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the channel.
+ Expression* val_;
+ // Lvalue which receives whether the channel is closed.
+ Expression* closed_;
+ // The channel on which we receive the value.
+ Expression* channel_;
+ // Whether this is for a select statement.
+ bool for_select_;
+};
+
+// Traversal.
+
+int
+Tuple_receive_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->closed_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->channel_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return Statement::make_error_statement(loc);
+ }
+ if (!channel_type->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->closed_->traverse_subexpressions(&moe);
+
+ // var val_temp ELEMENT_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(channel_type->element_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var closed_temp bool
+ Temporary_statement* closed_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(closed_temp);
+
+ // closed_temp = chanrecv[23](channel, &val_temp)
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ Expression* call = Runtime::make_call((this->for_select_
+ ? Runtime::CHANRECV3
+ : Runtime::CHANRECV2),
+ loc, 2, this->channel_, p2);
+ ref = Expression::make_temporary_reference(closed_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // closed = closed_temp
+ ref = Expression::make_temporary_reference(closed_temp, loc);
+ s = Statement::make_assignment(this->closed_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a nonblocking receive statement.
+
+Statement*
+Statement::make_tuple_receive_assignment(Expression* val, Expression* closed,
+ Expression* channel,
+ bool for_select,
+ source_location location)
+{
+ return new Tuple_receive_assignment_statement(val, closed, channel,
+ for_select, location);
+}
+
+// An assignment to a pair of values from a type guard. This is a
+// conditional type guard. v, ok = i.(type).
+
+class Tuple_type_guard_assignment_statement : public Statement
+{
+ public:
+ Tuple_type_guard_assignment_statement(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT, location),
+ val_(val), ok_(ok), expr_(expr), type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ Call_expression*
+ lower_to_type(Runtime::Function);
+
+ void
+ lower_to_object_type(Block*, Runtime::Function);
+
+ // The variable which recieves the converted value.
+ Expression* val_;
+ // The variable which receives the indication of success.
+ Expression* ok_;
+ // The expression being converted.
+ Expression* expr_;
+ // The type to which the expression is being converted.
+ Type* type_;
+};
+
+// Traverse a type guard tuple assignment.
+
+int
+Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->ok_) == TRAVERSE_EXIT
+ || this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->expr_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Type* expr_type = this->expr_->type();
+ if (expr_type->interface_type() == NULL)
+ {
+ if (!expr_type->is_error() && !this->type_->is_error())
+ this->report_error(_("type assertion only valid for interface types"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->ok_->traverse_subexpressions(&moe);
+
+ bool expr_is_empty = expr_type->interface_type()->is_empty();
+ Call_expression* call;
+ if (this->type_->interface_type() != NULL)
+ {
+ if (this->type_->interface_type()->is_empty())
+ call = Runtime::make_call((expr_is_empty
+ ? Runtime::IFACEE2E2
+ : Runtime::IFACEI2E2),
+ loc, 1, this->expr_);
+ else
+ call = this->lower_to_type(expr_is_empty
+ ? Runtime::IFACEE2I2
+ : Runtime::IFACEI2I2);
+ }
+ else if (this->type_->points_to() != NULL)
+ call = this->lower_to_type(expr_is_empty
+ ? Runtime::IFACEE2T2P
+ : Runtime::IFACEI2T2P);
+ else
+ {
+ this->lower_to_object_type(b,
+ (expr_is_empty
+ ? Runtime::IFACEE2T2
+ : Runtime::IFACEI2T2));
+ call = NULL;
+ }
+
+ if (call != NULL)
+ {
+ Expression* res = Expression::make_call_result(call, 0);
+ res = Expression::make_unsafe_cast(this->type_, res, loc);
+ Statement* s = Statement::make_assignment(this->val_, res, loc);
+ b->add_statement(s);
+
+ res = Expression::make_call_result(call, 1);
+ s = Statement::make_assignment(this->ok_, res, loc);
+ b->add_statement(s);
+ }
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Lower a conversion to a non-empty interface type or a pointer type.
+
+Call_expression*
+Tuple_type_guard_assignment_statement::lower_to_type(Runtime::Function code)
+{
+ source_location loc = this->location();
+ return Runtime::make_call(code, loc, 2,
+ Expression::make_type_descriptor(this->type_, loc),
+ this->expr_);
+}
+
+// Lower a conversion to a non-interface non-pointer type.
+
+void
+Tuple_type_guard_assignment_statement::lower_to_object_type(
+ Block* b,
+ Runtime::Function code)
+{
+ source_location loc = this->location();
+
+ // var val_temp TYPE
+ Temporary_statement* val_temp = Statement::make_temporary(this->type_,
+ NULL, loc);
+ b->add_statement(val_temp);
+
+ // ok = CODE(type_descriptor, expr, &val_temp)
+ Expression* p1 = Expression::make_type_descriptor(this->type_, loc);
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ Expression* call = Runtime::make_call(code, loc, 3, p1, this->expr_, p3);
+ Statement* s = Statement::make_assignment(this->ok_, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+}
+
+// Make an assignment from a type guard to a pair of variables.
+
+Statement*
+Statement::make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+{
+ return new Tuple_type_guard_assignment_statement(val, ok, expr, type,
+ location);
+}
+
+// An expression statement.
+
+class Expression_statement : public Statement
+{
+ public:
+ Expression_statement(Expression* expr)
+ : Statement(STATEMENT_EXPRESSION, expr->location()),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ void
+ do_determine_types()
+ { this->expr_->determine_type_no_context(); }
+
+ bool
+ do_may_fall_through() const;
+
+ Bstatement*
+ do_get_backend(Translate_context* context);
+
+ private:
+ Expression* expr_;
+};
+
+// An expression statement may fall through unless it is a call to a
+// function which does not return.
+
+bool
+Expression_statement::do_may_fall_through() const
+{
+ const Call_expression* call = this->expr_->call_expression();
+ if (call != NULL)
+ {
+ const Expression* fn = call->fn();
+ const Func_expression* fe = fn->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* no = fe->named_object();
+
+ Function_type* fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ fntype = NULL;
+
+ // The builtin function panic does not return.
+ if (fntype != NULL && fntype->is_builtin() && no->name() == "panic")
+ return false;
+ }
+ }
+ return true;
+}
+
+// Convert to backend representation.
+
+Bstatement*
+Expression_statement::do_get_backend(Translate_context* context)
+{
+ tree expr_tree = this->expr_->get_tree(context);
+ return context->backend()->expression_statement(tree_to_expr(expr_tree));
+}
+
+// Make an expression statement from an Expression.
+
+Statement*
+Statement::make_statement(Expression* expr)
+{
+ return new Expression_statement(expr);
+}
+
+// A block statement--a list of statements which may include variable
+// definitions.
+
+class Block_statement : public Statement
+{
+ public:
+ Block_statement(Block* block, source_location location)
+ : Statement(STATEMENT_BLOCK, location),
+ block_(block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->block_->traverse(traverse); }
+
+ void
+ do_determine_types()
+ { this->block_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->block_->may_fall_through(); }
+
+ Bstatement*
+ do_get_backend(Translate_context* context);
+
+ private:
+ Block* block_;
+};
+
+// Convert a block to the backend representation of a statement.
+
+Bstatement*
+Block_statement::do_get_backend(Translate_context* context)
+{
+ Bblock* bblock = this->block_->get_backend(context);
+ return context->backend()->block_statement(bblock);
+}
+
+// Make a block statement.
+
+Statement*
+Statement::make_block_statement(Block* block, source_location location)
+{
+ return new Block_statement(block, location);
+}
+
+// An increment or decrement statement.
+
+class Inc_dec_statement : public Statement
+{
+ public:
+ Inc_dec_statement(bool is_inc, Expression* expr)
+ : Statement(STATEMENT_INCDEC, expr->location()),
+ expr_(expr), is_inc_(is_inc)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The l-value to increment or decrement.
+ Expression* expr_;
+ // Whether to increment or decrement.
+ bool is_inc_;
+};
+
+// Lower to += or -=.
+
+Statement*
+Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*)
+{
+ source_location loc = this->location();
+
+ mpz_t oval;
+ mpz_init_set_ui(oval, 1UL);
+ Expression* oexpr = Expression::make_integer(&oval, NULL, loc);
+ mpz_clear(oval);
+
+ Operator op = this->is_inc_ ? OPERATOR_PLUSEQ : OPERATOR_MINUSEQ;
+ return Statement::make_assignment_operation(op, this->expr_, oexpr, loc);
+}
+
+// Make an increment statement.
+
+Statement*
+Statement::make_inc_statement(Expression* expr)
+{
+ return new Inc_dec_statement(true, expr);
+}
+
+// Make a decrement statement.
+
+Statement*
+Statement::make_dec_statement(Expression* expr)
+{
+ return new Inc_dec_statement(false, expr);
+}
+
+// Class Thunk_statement. This is the base class for go and defer
+// statements.
+
+const char* const Thunk_statement::thunk_field_fn = "fn";
+
+const char* const Thunk_statement::thunk_field_receiver = "receiver";
+
+// Constructor.
+
+Thunk_statement::Thunk_statement(Statement_classification classification,
+ Call_expression* call,
+ source_location location)
+ : Statement(classification, location),
+ call_(call), struct_type_(NULL)
+{
+}
+
+// Return whether this is a simple statement which does not require a
+// thunk.
+
+bool
+Thunk_statement::is_simple(Function_type* fntype) const
+{
+ // We need a thunk to call a method, or to pass a variable number of
+ // arguments.
+ if (fntype->is_method() || fntype->is_varargs())
+ return false;
+
+ // A defer statement requires a thunk to set up for whether the
+ // function can call recover.
+ if (this->classification() == STATEMENT_DEFER)
+ return false;
+
+ // We can only permit a single parameter of pointer type.
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL
+ && (parameters->size() > 1
+ || (parameters->size() == 1
+ && parameters->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If the function returns multiple values, or returns a type other
+ // than integer, floating point, or pointer, then it may get a
+ // hidden first parameter, in which case we need the more
+ // complicated approach. This is true even though we are going to
+ // ignore the return value.
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL
+ && (results->size() > 1
+ || (results->size() == 1
+ && !results->begin()->type()->is_basic_type()
+ && results->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If this calls something which is not a simple function, then we
+ // need a thunk.
+ Expression* fn = this->call_->call_expression()->fn();
+ if (fn->bound_method_expression() != NULL
+ || fn->interface_field_reference_expression() != NULL)
+ return false;
+
+ return true;
+}
+
+// Traverse a thunk statement.
+
+int
+Thunk_statement::do_traverse(Traverse* traverse)
+{
+ return this->traverse_expression(traverse, &this->call_);
+}
+
+// We implement traverse_assignment for a thunk statement because it
+// effectively copies the function call.
+
+bool
+Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression* fn = this->call_->call_expression()->fn();
+ Expression* fn2 = fn;
+ tassign->value(&fn2, true, false);
+ return true;
+}
+
+// Determine types in a thunk statement.
+
+void
+Thunk_statement::do_determine_types()
+{
+ this->call_->determine_type_no_context();
+
+ // Now that we know the types of the call, build the struct used to
+ // pass parameters.
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ return;
+ Function_type* fntype = ce->get_function_type();
+ if (fntype != NULL && !this->is_simple(fntype))
+ this->struct_type_ = this->build_struct(fntype);
+}
+
+// Check types in a thunk statement.
+
+void
+Thunk_statement::do_check_types(Gogo*)
+{
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ {
+ if (!this->call_->is_error_expression())
+ this->report_error("expected call expression");
+ return;
+ }
+ Function_type* fntype = ce->get_function_type();
+ if (fntype != NULL && fntype->is_method())
+ {
+ Expression* fn = ce->fn();
+ if (fn->bound_method_expression() == NULL
+ && fn->interface_field_reference_expression() == NULL)
+ this->report_error(_("no object for method call"));
+ }
+}
+
+// The Traverse class used to find and simplify thunk statements.
+
+class Simplify_thunk_traverse : public Traverse
+{
+ public:
+ Simplify_thunk_traverse(Gogo* gogo)
+ : Traverse(traverse_functions | traverse_blocks),
+ gogo_(gogo), function_(NULL)
+ { }
+
+ int
+ function(Named_object*);
+
+ int
+ block(Block*);
+
+ private:
+ // General IR.
+ Gogo* gogo_;
+ // The function we are traversing.
+ Named_object* function_;
+};
+
+// Keep track of the current function while looking for thunks.
+
+int
+Simplify_thunk_traverse::function(Named_object* no)
+{
+ go_assert(this->function_ == NULL);
+ this->function_ = no;
+ int t = no->func_value()->traverse(this);
+ this->function_ = NULL;
+ if (t == TRAVERSE_EXIT)
+ return t;
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// Look for thunks in a block.
+
+int
+Simplify_thunk_traverse::block(Block* b)
+{
+ // The parser ensures that thunk statements always appear at the end
+ // of a block.
+ if (b->statements()->size() < 1)
+ return TRAVERSE_CONTINUE;
+ Thunk_statement* stat = b->statements()->back()->thunk_statement();
+ if (stat == NULL)
+ return TRAVERSE_CONTINUE;
+ if (stat->simplify_statement(this->gogo_, this->function_, b))
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Simplify all thunk statements.
+
+void
+Gogo::simplify_thunk_statements()
+{
+ Simplify_thunk_traverse thunk_traverse(this);
+ this->traverse(&thunk_traverse);
+}
+
+// Simplify complex thunk statements into simple ones. A complicated
+// thunk statement is one which takes anything other than zero
+// parameters or a single pointer parameter. We rewrite it into code
+// which allocates a struct, stores the parameter values into the
+// struct, and does a simple go or defer statement which passes the
+// struct to a thunk. The thunk does the real call.
+
+bool
+Thunk_statement::simplify_statement(Gogo* gogo, Named_object* function,
+ Block* block)
+{
+ if (this->classification() == STATEMENT_ERROR)
+ return false;
+ if (this->call_->is_error_expression())
+ return false;
+
+ if (this->classification() == STATEMENT_DEFER)
+ {
+ // Make sure that the defer stack exists for the function. We
+ // will use when converting this statement to the backend
+ // representation, but we want it to exist when we start
+ // converting the function.
+ function->func_value()->defer_stack(this->location());
+ }
+
+ Call_expression* ce = this->call_->call_expression();
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL)
+ {
+ go_assert(saw_errors());
+ this->set_is_error();
+ return false;
+ }
+ if (this->is_simple(fntype))
+ return false;
+
+ Expression* fn = ce->fn();
+ Bound_method_expression* bound_method = fn->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+
+ source_location location = this->location();
+
+ std::string thunk_name = Gogo::thunk_name();
+
+ // Build the thunk.
+ this->build_thunk(gogo, thunk_name, fntype);
+
+ // Generate code to call the thunk.
+
+ // Get the values to store into the struct which is the single
+ // argument to the thunk.
+
+ Expression_list* vals = new Expression_list();
+ if (fntype->is_builtin())
+ ;
+ else if (!is_method)
+ vals->push_back(fn);
+ else if (interface_method != NULL)
+ vals->push_back(interface_method->expr());
+ else if (bound_method != NULL)
+ {
+ vals->push_back(bound_method->method());
+ Expression* first_arg = bound_method->first_argument();
+
+ // We always pass a pointer when calling a method.
+ if (first_arg->type()->points_to() == NULL)
+ first_arg = Expression::make_unary(OPERATOR_AND, first_arg, location);
+
+ // If we are calling a method which was inherited from an
+ // embedded struct, and the method did not get a stub, then the
+ // first type may be wrong.
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ Type* unsafe = Type::make_pointer_type(Type::make_void_type());
+ first_arg = Expression::make_cast(unsafe, first_arg, location);
+ first_arg = Expression::make_cast(fatype, first_arg, location);
+ }
+
+ vals->push_back(first_arg);
+ }
+ else
+ go_unreachable();
+
+ if (ce->args() != NULL)
+ {
+ for (Expression_list::const_iterator p = ce->args()->begin();
+ p != ce->args()->end();
+ ++p)
+ vals->push_back(*p);
+ }
+
+ // Build the struct.
+ Expression* constructor =
+ Expression::make_struct_composite_literal(this->struct_type_, vals,
+ location);
+
+ // Allocate the initialized struct on the heap.
+ constructor = Expression::make_heap_composite(constructor, location);
+
+ // Look up the thunk.
+ Named_object* named_thunk = gogo->lookup(thunk_name, NULL);
+ go_assert(named_thunk != NULL && named_thunk->is_function());
+
+ // Build the call.
+ Expression* func = Expression::make_func_reference(named_thunk, NULL,
+ location);
+ Expression_list* params = new Expression_list();
+ params->push_back(constructor);
+ Call_expression* call = Expression::make_call(func, params, false, location);
+
+ // Build the simple go or defer statement.
+ Statement* s;
+ if (this->classification() == STATEMENT_GO)
+ s = Statement::make_go_statement(call, location);
+ else if (this->classification() == STATEMENT_DEFER)
+ s = Statement::make_defer_statement(call, location);
+ else
+ go_unreachable();
+
+ // The current block should end with the go statement.
+ go_assert(block->statements()->size() >= 1);
+ go_assert(block->statements()->back() == this);
+ block->replace_statement(block->statements()->size() - 1, s);
+
+ // We already ran the determine_types pass, so we need to run it now
+ // for the new statement.
+ s->determine_types();
+
+ // Sanity check.
+ gogo->check_types_in_block(block);
+
+ // Return true to tell the block not to keep looking at statements.
+ return true;
+}
+
+// Set the name to use for thunk parameter N.
+
+void
+Thunk_statement::thunk_field_param(int n, char* buf, size_t buflen)
+{
+ snprintf(buf, buflen, "a%d", n);
+}
+
+// Build a new struct type to hold the parameters for a complicated
+// thunk statement. FNTYPE is the type of the function call.
+
+Struct_type*
+Thunk_statement::build_struct(Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Struct_field_list* fields = new Struct_field_list();
+
+ Call_expression* ce = this->call_->call_expression();
+ Expression* fn = ce->fn();
+
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ if (interface_method != NULL)
+ {
+ // If this thunk statement calls a method on an interface, we
+ // pass the interface object to the thunk.
+ Typed_identifier tid(Thunk_statement::thunk_field_fn,
+ interface_method->expr()->type(),
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (!fntype->is_builtin())
+ {
+ // The function to call.
+ Typed_identifier tid(Go_statement::thunk_field_fn, fntype, location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (ce->is_recover_call())
+ {
+ // The predeclared recover function has no argument. However,
+ // we add an argument when building recover thunks. Handle that
+ // here.
+ fields->push_back(Struct_field(Typed_identifier("can_recover",
+ Type::lookup_bool_type(),
+ location)));
+ }
+
+ if (fn->bound_method_expression() != NULL)
+ {
+ go_assert(fntype->is_method());
+ Type* rtype = fntype->receiver()->type();
+ // We always pass the receiver as a pointer.
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ Typed_identifier tid(Thunk_statement::thunk_field_receiver, rtype,
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+
+ const Expression_list* args = ce->args();
+ if (args != NULL)
+ {
+ int i = 0;
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p, ++i)
+ {
+ char buf[50];
+ this->thunk_field_param(i, buf, sizeof buf);
+ fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(),
+ location)));
+ }
+ }
+
+ return Type::make_struct_type(fields, location);
+}
+
+// Build the thunk we are going to call. This is a brand new, albeit
+// artificial, function.
+
+void
+Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
+ Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Call_expression* ce = this->call_->call_expression();
+
+ bool may_call_recover = false;
+ if (this->classification() == STATEMENT_DEFER)
+ {
+ Func_expression* fn = ce->fn()->func_expression();
+ if (fn == NULL)
+ may_call_recover = true;
+ else
+ {
+ const Named_object* no = fn->named_object();
+ if (!no->is_function())
+ may_call_recover = true;
+ else
+ may_call_recover = no->func_value()->calls_recover();
+ }
+ }
+
+ // Build the type of the thunk. The thunk takes a single parameter,
+ // which is a pointer to the special structure we build.
+ const char* const parameter_name = "__go_thunk_parameter";
+ Typed_identifier_list* thunk_parameters = new Typed_identifier_list();
+ Type* pointer_to_struct_type = Type::make_pointer_type(this->struct_type_);
+ thunk_parameters->push_back(Typed_identifier(parameter_name,
+ pointer_to_struct_type,
+ location));
+
+ Typed_identifier_list* thunk_results = NULL;
+ if (may_call_recover)
+ {
+ // When deferring a function which may call recover, add a
+ // return value, to disable tail call optimizations which will
+ // break the way we check whether recover is permitted.
+ thunk_results = new Typed_identifier_list();
+ thunk_results->push_back(Typed_identifier("", Type::lookup_bool_type(),
+ location));
+ }
+
+ Function_type* thunk_type = Type::make_function_type(NULL, thunk_parameters,
+ thunk_results,
+ location);
+
+ // Start building the thunk.
+ Named_object* function = gogo->start_function(thunk_name, thunk_type, true,
+ location);
+
+ // For a defer statement, start with a call to
+ // __go_set_defer_retaddr. */
+ Label* retaddr_label = NULL;
+ if (may_call_recover)
+ {
+ retaddr_label = gogo->add_label_reference("retaddr");
+ Expression* arg = Expression::make_label_addr(retaddr_label, location);
+ Expression* call = Runtime::make_call(Runtime::SET_DEFER_RETADDR,
+ location, 1, arg);
+
+ // This is a hack to prevent the middle-end from deleting the
+ // label.
+ gogo->start_block(location);
+ gogo->add_statement(Statement::make_goto_statement(retaddr_label,
+ location));
+ Block* then_block = gogo->finish_block(location);
+ then_block->determine_types();
+
+ Statement* s = Statement::make_if_statement(call, then_block, NULL,
+ location);
+ s->determine_types();
+ gogo->add_statement(s);
+ }
+
+ // Get a reference to the parameter.
+ Named_object* named_parameter = gogo->lookup(parameter_name, NULL);
+ go_assert(named_parameter != NULL && named_parameter->is_variable());
+
+ // Build the call. Note that the field names are the same as the
+ // ones used in build_struct.
+ Expression* thunk_parameter = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_parameter = Expression::make_unary(OPERATOR_MULT, thunk_parameter,
+ location);
+
+ Bound_method_expression* bound_method = ce->fn()->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ ce->fn()->interface_field_reference_expression();
+
+ Expression* func_to_call;
+ unsigned int next_index;
+ if (!fntype->is_builtin())
+ {
+ func_to_call = Expression::make_field_reference(thunk_parameter,
+ 0, location);
+ next_index = 1;
+ }
+ else
+ {
+ go_assert(bound_method == NULL && interface_method == NULL);
+ func_to_call = ce->fn();
+ next_index = 0;
+ }
+
+ if (bound_method != NULL)
+ {
+ Expression* r = Expression::make_field_reference(thunk_parameter, 1,
+ location);
+ // The main program passes in a function pointer from the
+ // interface expression, so here we can make a bound method in
+ // all cases.
+ func_to_call = Expression::make_bound_method(r, func_to_call,
+ location);
+ next_index = 2;
+ }
+ else if (interface_method != NULL)
+ {
+ // The main program passes the interface object.
+ const std::string& name(interface_method->name());
+ func_to_call = Expression::make_interface_field_reference(func_to_call,
+ name,
+ location);
+ }
+
+ Expression_list* call_params = new Expression_list();
+ const Struct_field_list* fields = this->struct_type_->fields();
+ Struct_field_list::const_iterator p = fields->begin();
+ for (unsigned int i = 0; i < next_index; ++i)
+ ++p;
+ bool is_recover_call = ce->is_recover_call();
+ Expression* recover_arg = NULL;
+ for (; p != fields->end(); ++p, ++next_index)
+ {
+ Expression* thunk_param = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_param = Expression::make_unary(OPERATOR_MULT, thunk_param,
+ location);
+ Expression* param = Expression::make_field_reference(thunk_param,
+ next_index,
+ location);
+ if (!is_recover_call)
+ call_params->push_back(param);
+ else
+ {
+ go_assert(call_params->empty());
+ recover_arg = param;
+ }
+ }
+
+ if (call_params->empty())
+ {
+ delete call_params;
+ call_params = NULL;
+ }
+
+ Expression* call = Expression::make_call(func_to_call, call_params, false,
+ location);
+ // We need to lower in case this is a builtin function.
+ call = call->lower(gogo, function, -1);
+ Call_expression* call_ce = call->call_expression();
+ if (call_ce != NULL && may_call_recover)
+ call_ce->set_is_deferred();
+
+ Statement* call_statement = Statement::make_statement(call);
+
+ // We already ran the determine_types pass, so we need to run it
+ // just for this statement now.
+ call_statement->determine_types();
+
+ // Sanity check.
+ call->check_types(gogo);
+
+ if (call_ce != NULL && recover_arg != NULL)
+ call_ce->set_recover_arg(recover_arg);
+
+ gogo->add_statement(call_statement);
+
+ // If this is a defer statement, the label comes immediately after
+ // the call.
+ if (may_call_recover)
+ {
+ gogo->add_label_definition("retaddr", location);
+
+ Expression_list* vals = new Expression_list();
+ vals->push_back(Expression::make_boolean(false, location));
+ gogo->add_statement(Statement::make_return_statement(vals, location));
+ }
+
+ // That is all the thunk has to do.
+ gogo->finish_function(location);
+}
+
+// Get the function and argument expressions.
+
+bool
+Thunk_statement::get_fn_and_arg(Expression** pfn, Expression** parg)
+{
+ if (this->call_->is_error_expression())
+ return false;
+
+ Call_expression* ce = this->call_->call_expression();
+
+ *pfn = ce->fn();
+
+ const Expression_list* args = ce->args();
+ if (args == NULL || args->empty())
+ *parg = Expression::make_nil(this->location());
+ else
+ {
+ go_assert(args->size() == 1);
+ *parg = args->front();
+ }
+
+ return true;
+}
+
+// Class Go_statement.
+
+Bstatement*
+Go_statement::do_get_backend(Translate_context* context)
+{
+ Expression* fn;
+ Expression* arg;
+ if (!this->get_fn_and_arg(&fn, &arg))
+ return context->backend()->error_statement();
+
+ Expression* call = Runtime::make_call(Runtime::GO, this->location(), 2,
+ fn, arg);
+ tree call_tree = call->get_tree(context);
+ Bexpression* call_bexpr = tree_to_expr(call_tree);
+ return context->backend()->expression_statement(call_bexpr);
+}
+
+// Make a go statement.
+
+Statement*
+Statement::make_go_statement(Call_expression* call, source_location location)
+{
+ return new Go_statement(call, location);
+}
+
+// Class Defer_statement.
+
+Bstatement*
+Defer_statement::do_get_backend(Translate_context* context)
+{
+ Expression* fn;
+ Expression* arg;
+ if (!this->get_fn_and_arg(&fn, &arg))
+ return context->backend()->error_statement();
+
+ source_location loc = this->location();
+ Expression* ds = context->function()->func_value()->defer_stack(loc);
+
+ Expression* call = Runtime::make_call(Runtime::DEFER, loc, 3,
+ ds, fn, arg);
+ tree call_tree = call->get_tree(context);
+ Bexpression* call_bexpr = tree_to_expr(call_tree);
+ return context->backend()->expression_statement(call_bexpr);
+}
+
+// Make a defer statement.
+
+Statement*
+Statement::make_defer_statement(Call_expression* call,
+ source_location location)
+{
+ return new Defer_statement(call, location);
+}
+
+// Class Return_statement.
+
+// Traverse assignments. We treat each return value as a top level
+// RHS in an expression.
+
+bool
+Return_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression_list* vals = this->vals_;
+ if (vals != NULL)
+ {
+ for (Expression_list::iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ tassign->value(&*p, true, true);
+ }
+ return true;
+}
+
+// Lower a return statement. If we are returning a function call
+// which returns multiple values which match the current function,
+// split up the call's results. If the function has named result
+// variables, and the return statement lists explicit values, then
+// implement it by assigning the values to the result variables and
+// changing the statement to not list any values. This lets
+// panic/recover work correctly.
+
+Statement*
+Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing)
+{
+ if (this->is_lowered_)
+ return this;
+
+ Expression_list* vals = this->vals_;
+ this->vals_ = NULL;
+ this->is_lowered_ = true;
+
+ source_location loc = this->location();
+
+ size_t vals_count = vals == NULL ? 0 : vals->size();
+ Function::Results* results = function->func_value()->result_variables();
+ size_t results_count = results == NULL ? 0 : results->size();
+
+ if (vals_count == 0)
+ {
+ if (results_count > 0 && !function->func_value()->results_are_named())
+ {
+ this->report_error(_("not enough arguments to return"));
+ return this;
+ }
+ return this;
+ }
+
+ if (results_count == 0)
+ {
+ this->report_error(_("return with value in function "
+ "with no return type"));
+ return this;
+ }
+
+ // If the current function has multiple return values, and we are
+ // returning a single call expression, split up the call expression.
+ if (results_count > 1
+ && vals->size() == 1
+ && vals->front()->call_expression() != NULL)
+ {
+ Call_expression* call = vals->front()->call_expression();
+ delete vals;
+ vals = new Expression_list;
+ for (size_t i = 0; i < results_count; ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ vals_count = results_count;
+ }
+
+ if (vals_count < results_count)
+ {
+ this->report_error(_("not enough arguments to return"));
+ return this;
+ }
+
+ if (vals_count > results_count)
+ {
+ this->report_error(_("too many values in return statement"));
+ return this;
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ Expression_list* lhs = new Expression_list();
+ Expression_list* rhs = new Expression_list();
+
+ Expression_list::const_iterator pe = vals->begin();
+ int i = 1;
+ for (Function::Results::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++pe, ++i)
+ {
+ Named_object* rv = *pr;
+ Expression* e = *pe;
+
+ // Check types now so that we give a good error message. The
+ // result type is known. We determine the expression type
+ // early.
+
+ Type *rvtype = rv->result_var_value()->type();
+ Type_context type_context(rvtype, false);
+ e->determine_type(&type_context);
+
+ std::string reason;
+ if (Type::are_assignable(rvtype, e->type(), &reason))
+ {
+ Expression* ve = Expression::make_var_reference(rv, e->location());
+ lhs->push_back(ve);
+ rhs->push_back(e);
+ }
+ else
+ {
+ if (reason.empty())
+ error_at(e->location(), "incompatible type for return value %d", i);
+ else
+ error_at(e->location(),
+ "incompatible type for return value %d (%s)",
+ i, reason.c_str());
+ }
+ }
+ go_assert(lhs->size() == rhs->size());
+
+ if (lhs->empty())
+ ;
+ else if (lhs->size() == 1)
+ {
+ b->add_statement(Statement::make_assignment(lhs->front(), rhs->front(),
+ loc));
+ delete lhs;
+ delete rhs;
+ }
+ else
+ b->add_statement(Statement::make_tuple_assignment(lhs, rhs, loc));
+
+ b->add_statement(this);
+
+ delete vals;
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Convert a return statement to the backend representation.
+
+Bstatement*
+Return_statement::do_get_backend(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ Function* function = context->function()->func_value();
+ tree fndecl = function->get_decl();
+
+ Function::Results* results = function->result_variables();
+ std::vector<Bexpression*> retvals;
+ if (results != NULL && !results->empty())
+ {
+ retvals.reserve(results->size());
+ for (Function::Results::const_iterator p = results->begin();
+ p != results->end();
+ p++)
+ {
+ Expression* vr = Expression::make_var_reference(*p, loc);
+ retvals.push_back(tree_to_expr(vr->get_tree(context)));
+ }
+ }
+
+ return context->backend()->return_statement(tree_to_function(fndecl),
+ retvals, loc);
+}
+
+// Make a return statement.
+
+Statement*
+Statement::make_return_statement(Expression_list* vals,
+ source_location location)
+{
+ return new Return_statement(vals, location);
+}
+
+// A break or continue statement.
+
+class Bc_statement : public Statement
+{
+ public:
+ Bc_statement(bool is_break, Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_BREAK_OR_CONTINUE, location),
+ label_(label), is_break_(is_break)
+ { }
+
+ bool
+ is_break() const
+ { return this->is_break_; }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ Bstatement*
+ do_get_backend(Translate_context* context)
+ { return this->label_->get_goto(context, this->location()); }
+
+ private:
+ // The label that this branches to.
+ Unnamed_label* label_;
+ // True if this is "break", false if it is "continue".
+ bool is_break_;
+};
+
+// Make a break statement.
+
+Statement*
+Statement::make_break_statement(Unnamed_label* label, source_location location)
+{
+ return new Bc_statement(true, label, location);
+}
+
+// Make a continue statement.
+
+Statement*
+Statement::make_continue_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Bc_statement(false, label, location);
+}
+
+// A goto statement.
+
+class Goto_statement : public Statement
+{
+ public:
+ Goto_statement(Label* label, source_location location)
+ : Statement(STATEMENT_GOTO, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ Label* label_;
+};
+
+// Check types for a label. There aren't any types per se, but we use
+// this to give an error if the label was never defined.
+
+void
+Goto_statement::do_check_types(Gogo*)
+{
+ if (!this->label_->is_defined())
+ {
+ error_at(this->location(), "reference to undefined label %qs",
+ Gogo::message_name(this->label_->name()).c_str());
+ this->set_is_error();
+ }
+}
+
+// Convert the goto statement to the backend representation.
+
+Bstatement*
+Goto_statement::do_get_backend(Translate_context* context)
+{
+ Blabel* blabel = this->label_->get_backend_label(context);
+ return context->backend()->goto_statement(blabel, this->location());
+}
+
+// Make a goto statement.
+
+Statement*
+Statement::make_goto_statement(Label* label, source_location location)
+{
+ return new Goto_statement(label, location);
+}
+
+// A goto statement to an unnamed label.
+
+class Goto_unnamed_statement : public Statement
+{
+ public:
+ Goto_unnamed_statement(Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_GOTO_UNNAMED, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ Bstatement*
+ do_get_backend(Translate_context* context)
+ { return this->label_->get_goto(context, this->location()); }
+
+ private:
+ Unnamed_label* label_;
+};
+
+// Make a goto statement to an unnamed label.
+
+Statement*
+Statement::make_goto_unnamed_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Goto_unnamed_statement(label, location);
+}
+
+// Class Label_statement.
+
+// Traversal.
+
+int
+Label_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return the backend representation of the statement defining this
+// label.
+
+Bstatement*
+Label_statement::do_get_backend(Translate_context* context)
+{
+ Blabel* blabel = this->label_->get_backend_label(context);
+ return context->backend()->label_definition_statement(blabel);
+}
+
+// Make a label statement.
+
+Statement*
+Statement::make_label_statement(Label* label, source_location location)
+{
+ return new Label_statement(label, location);
+}
+
+// An unnamed label statement.
+
+class Unnamed_label_statement : public Statement
+{
+ public:
+ Unnamed_label_statement(Unnamed_label* label)
+ : Statement(STATEMENT_UNNAMED_LABEL, label->location()),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ Bstatement*
+ do_get_backend(Translate_context* context)
+ { return this->label_->get_definition(context); }
+
+ private:
+ // The label.
+ Unnamed_label* label_;
+};
+
+// Make an unnamed label statement.
+
+Statement*
+Statement::make_unnamed_label_statement(Unnamed_label* label)
+{
+ return new Unnamed_label_statement(label);
+}
+
+// An if statement.
+
+class If_statement : public Statement
+{
+ public:
+ If_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location location)
+ : Statement(STATEMENT_IF, location),
+ cond_(cond), then_block_(then_block), else_block_(else_block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ Expression* cond_;
+ Block* then_block_;
+ Block* else_block_;
+};
+
+// Traversal.
+
+int
+If_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT
+ || this->then_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->else_block_ != NULL)
+ {
+ if (this->else_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+void
+If_statement::do_determine_types()
+{
+ Type_context context(Type::lookup_bool_type(), false);
+ this->cond_->determine_type(&context);
+ this->then_block_->determine_types();
+ if (this->else_block_ != NULL)
+ this->else_block_->determine_types();
+}
+
+// Check types.
+
+void
+If_statement::do_check_types(Gogo*)
+{
+ Type* type = this->cond_->type();
+ if (type->is_error())
+ this->set_is_error();
+ else if (!type->is_boolean_type())
+ this->report_error(_("expected boolean expression"));
+}
+
+// Whether the overall statement may fall through.
+
+bool
+If_statement::do_may_fall_through() const
+{
+ return (this->else_block_ == NULL
+ || this->then_block_->may_fall_through()
+ || this->else_block_->may_fall_through());
+}
+
+// Get the backend representation.
+
+Bstatement*
+If_statement::do_get_backend(Translate_context* context)
+{
+ go_assert(this->cond_->type()->is_boolean_type()
+ || this->cond_->type()->is_error());
+ tree cond_tree = this->cond_->get_tree(context);
+ Bexpression* cond_expr = tree_to_expr(cond_tree);
+ Bblock* then_block = this->then_block_->get_backend(context);
+ Bblock* else_block = (this->else_block_ == NULL
+ ? NULL
+ : this->else_block_->get_backend(context));
+ return context->backend()->if_statement(cond_expr, then_block,
+ else_block, this->location());
+}
+
+// Make an if statement.
+
+Statement*
+Statement::make_if_statement(Expression* cond, Block* then_block,
+ Block* else_block, source_location location)
+{
+ return new If_statement(cond, then_block, else_block, location);
+}
+
+// Class Case_clauses::Hash_integer_value.
+
+class Case_clauses::Hash_integer_value
+{
+ public:
+ size_t
+ operator()(Expression*) const;
+};
+
+size_t
+Case_clauses::Hash_integer_value::operator()(Expression* pe) const
+{
+ Type* itype;
+ mpz_t ival;
+ mpz_init(ival);
+ if (!pe->integer_constant_value(true, ival, &itype))
+ go_unreachable();
+ size_t ret = mpz_get_ui(ival);
+ mpz_clear(ival);
+ return ret;
+}
+
+// Class Case_clauses::Eq_integer_value.
+
+class Case_clauses::Eq_integer_value
+{
+ public:
+ bool
+ operator()(Expression*, Expression*) const;
+};
+
+bool
+Case_clauses::Eq_integer_value::operator()(Expression* a, Expression* b) const
+{
+ Type* atype;
+ Type* btype;
+ mpz_t aval;
+ mpz_t bval;
+ mpz_init(aval);
+ mpz_init(bval);
+ if (!a->integer_constant_value(true, aval, &atype)
+ || !b->integer_constant_value(true, bval, &btype))
+ go_unreachable();
+ bool ret = mpz_cmp(aval, bval) == 0;
+ mpz_clear(aval);
+ mpz_clear(bval);
+ return ret;
+}
+
+// Class Case_clauses::Case_clause.
+
+// Traversal.
+
+int
+Case_clauses::Case_clause::traverse(Traverse* traverse)
+{
+ if (this->cases_ != NULL
+ && (traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ {
+ if (this->cases_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are integer constants.
+
+bool
+Case_clauses::Case_clause::is_constant() const
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ if (!(*p)->is_constant() || (*p)->type()->integer_type() == NULL)
+ return false;
+ }
+ return true;
+}
+
+// Lower a case clause for a nonconstant switch. VAL_TEMP is the
+// value we are switching on; it may be NULL. If START_LABEL is not
+// NULL, it goes at the start of the statements, after the condition
+// test. We branch to FINISH_LABEL at the end of the statements.
+
+void
+Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* start_label,
+ Unnamed_label* finish_label) const
+{
+ source_location loc = this->location_;
+ Unnamed_label* next_case_label;
+ if (this->cases_ == NULL || this->cases_->empty())
+ {
+ go_assert(this->is_default_);
+ next_case_label = NULL;
+ }
+ else
+ {
+ Expression* cond = NULL;
+
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Expression* this_cond;
+ if (val_temp == NULL)
+ this_cond = *p;
+ else
+ {
+ Expression* ref = Expression::make_temporary_reference(val_temp,
+ loc);
+ this_cond = Expression::make_binary(OPERATOR_EQEQ, ref, *p, loc);
+ }
+
+ if (cond == NULL)
+ cond = this_cond;
+ else
+ cond = Expression::make_binary(OPERATOR_OROR, cond, this_cond, loc);
+ }
+
+ Block* then_block = new Block(b, loc);
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ Statement* s = Statement::make_goto_unnamed_statement(next_case_label,
+ loc);
+ then_block->add_statement(s);
+
+ // if !COND { goto NEXT_CASE_LABEL }
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (start_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(start_label));
+
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ Statement* s = Statement::make_goto_unnamed_statement(finish_label, loc);
+ b->add_statement(s);
+
+ if (next_case_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(next_case_label));
+}
+
+// Determine types.
+
+void
+Case_clauses::Case_clause::determine_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ Type_context case_context(type, false);
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ (*p)->determine_type(&case_context);
+ }
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::Case_clause::check_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ if (!Type::are_assignable(type, (*p)->type(), NULL)
+ && !Type::are_assignable((*p)->type(), type, NULL))
+ {
+ error_at((*p)->location(),
+ "type mismatch between switch value and case clause");
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Return true if this clause may fall through to the following
+// statements. Note that this is not the same as whether the case
+// uses the "fallthrough" keyword.
+
+bool
+Case_clauses::Case_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Convert the case values and statements to the backend
+// representation. BREAK_LABEL is the label which break statements
+// should branch to. CASE_CONSTANTS is used to detect duplicate
+// constants. *CASES should be passed as an empty vector; the values
+// for this case will be added to it. If this is the default case,
+// *CASES will remain empty. This returns the statement to execute if
+// one of these cases is selected.
+
+Bstatement*
+Case_clauses::Case_clause::get_backend(Translate_context* context,
+ Unnamed_label* break_label,
+ Case_constants* case_constants,
+ std::vector<Bexpression*>* cases) const
+{
+ if (this->cases_ != NULL)
+ {
+ go_assert(!this->is_default_);
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Expression* e = *p;
+ if (e->classification() != Expression::EXPRESSION_INTEGER)
+ {
+ Type* itype;
+ mpz_t ival;
+ mpz_init(ival);
+ if (!(*p)->integer_constant_value(true, ival, &itype))
+ {
+ // Something went wrong. This can happen with a
+ // negative constant and an unsigned switch value.
+ go_assert(saw_errors());
+ continue;
+ }
+ go_assert(itype != NULL);
+ e = Expression::make_integer(&ival, itype, e->location());
+ mpz_clear(ival);
+ }
+
+ std::pair<Case_constants::iterator, bool> ins =
+ case_constants->insert(e);
+ if (!ins.second)
+ {
+ // Value was already present.
+ error_at(this->location_, "duplicate case in switch");
+ continue;
+ }
+
+ tree case_tree = e->get_tree(context);
+ Bexpression* case_expr = tree_to_expr(case_tree);
+ cases->push_back(case_expr);
+ }
+ }
+
+ Bstatement* statements;
+ if (this->statements_ == NULL)
+ statements = NULL;
+ else
+ {
+ Bblock* bblock = this->statements_->get_backend(context);
+ statements = context->backend()->block_statement(bblock);
+ }
+
+ Bstatement* break_stat;
+ if (this->is_fallthrough_)
+ break_stat = NULL;
+ else
+ break_stat = break_label->get_goto(context, this->location_);
+
+ if (statements == NULL)
+ return break_stat;
+ else if (break_stat == NULL)
+ return statements;
+ else
+ return context->backend()->compound_statement(statements, break_stat);
+}
+
+// Class Case_clauses.
+
+// Traversal.
+
+int
+Case_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are constant.
+
+bool
+Case_clauses::is_constant() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (!p->is_constant())
+ return false;
+ return true;
+}
+
+// Lower case clauses for a nonconstant switch.
+
+void
+Case_clauses::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* break_label) const
+{
+ // The default case.
+ const Case_clause* default_case = NULL;
+
+ // The label for the fallthrough of the previous case.
+ Unnamed_label* last_fallthrough_label = NULL;
+
+ // The label for the start of the default case. This is used if the
+ // case before the default case falls through.
+ Unnamed_label* default_start_label = NULL;
+
+ // The label for the end of the default case. This normally winds
+ // up as BREAK_LABEL, but it will be different if the default case
+ // falls through.
+ Unnamed_label* default_finish_label = NULL;
+
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ // The label to use for the start of the statements for this
+ // case. This is NULL unless the previous case falls through.
+ Unnamed_label* start_label = last_fallthrough_label;
+
+ // The label to jump to after the end of the statements for this
+ // case.
+ Unnamed_label* finish_label = break_label;
+
+ last_fallthrough_label = NULL;
+ if (p->is_fallthrough() && p + 1 != this->clauses_.end())
+ {
+ finish_label = new Unnamed_label(p->location());
+ last_fallthrough_label = finish_label;
+ }
+
+ if (!p->is_default())
+ p->lower(b, val_temp, start_label, finish_label);
+ else
+ {
+ // We have to move the default case to the end, so that we
+ // only use it if all the other tests fail.
+ default_case = &*p;
+ default_start_label = start_label;
+ default_finish_label = finish_label;
+ }
+ }
+
+ if (default_case != NULL)
+ default_case->lower(b, val_temp, default_start_label,
+ default_finish_label);
+
+}
+
+// Determine types.
+
+void
+Case_clauses::determine_types(Type* type)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types(type);
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::check_types(Type* type)
+{
+ bool ret = true;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->check_types(type))
+ ret = false;
+ }
+ return ret;
+}
+
+// Return true if these clauses may fall through to the statements
+// following the switch statement.
+
+bool
+Case_clauses::may_fall_through() const
+{
+ bool found_default = false;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->may_fall_through() && !p->is_fallthrough())
+ return true;
+ if (p->is_default())
+ found_default = true;
+ }
+ return !found_default;
+}
+
+// Convert the cases to the backend representation. This sets
+// *ALL_CASES and *ALL_STATEMENTS.
+
+void
+Case_clauses::get_backend(Translate_context* context,
+ Unnamed_label* break_label,
+ std::vector<std::vector<Bexpression*> >* all_cases,
+ std::vector<Bstatement*>* all_statements) const
+{
+ Case_constants case_constants;
+
+ size_t c = this->clauses_.size();
+ all_cases->resize(c);
+ all_statements->resize(c);
+
+ size_t i = 0;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p, ++i)
+ {
+ std::vector<Bexpression*> cases;
+ Bstatement* stat = p->get_backend(context, break_label, &case_constants,
+ &cases);
+ (*all_cases)[i].swap(cases);
+ (*all_statements)[i] = stat;
+ }
+}
+
+// A constant switch statement. A Switch_statement is lowered to this
+// when all the cases are constants.
+
+class Constant_switch_statement : public Statement
+{
+ public:
+ Constant_switch_statement(Expression* val, Case_clauses* clauses,
+ Unnamed_label* break_label,
+ source_location location)
+ : Statement(STATEMENT_CONSTANT_SWITCH, location),
+ val_(val), clauses_(clauses), break_label_(break_label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // The value to switch on.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Traversal.
+
+int
+Constant_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->clauses_->traverse(traverse);
+}
+
+// Determine types.
+
+void
+Constant_switch_statement::do_determine_types()
+{
+ this->val_->determine_type_no_context();
+ this->clauses_->determine_types(this->val_->type());
+}
+
+// Check types.
+
+void
+Constant_switch_statement::do_check_types(Gogo*)
+{
+ if (!this->clauses_->check_types(this->val_->type()))
+ this->set_is_error();
+}
+
+// Return whether this switch may fall through.
+
+bool
+Constant_switch_statement::do_may_fall_through() const
+{
+ if (this->clauses_ == NULL)
+ return true;
+
+ // If we have a break label, then some case needed it. That implies
+ // that the switch statement as a whole can fall through.
+ if (this->break_label_ != NULL)
+ return true;
+
+ return this->clauses_->may_fall_through();
+}
+
+// Convert to GENERIC.
+
+Bstatement*
+Constant_switch_statement::do_get_backend(Translate_context* context)
+{
+ tree switch_val_tree = this->val_->get_tree(context);
+ Bexpression* switch_val_expr = tree_to_expr(switch_val_tree);
+
+ Unnamed_label* break_label = this->break_label_;
+ if (break_label == NULL)
+ break_label = new Unnamed_label(this->location());
+
+ std::vector<std::vector<Bexpression*> > all_cases;
+ std::vector<Bstatement*> all_statements;
+ this->clauses_->get_backend(context, break_label, &all_cases,
+ &all_statements);
+
+ Bstatement* switch_statement;
+ switch_statement = context->backend()->switch_statement(switch_val_expr,
+ all_cases,
+ all_statements,
+ this->location());
+ Bstatement* ldef = break_label->get_definition(context);
+ return context->backend()->compound_statement(switch_statement, ldef);
+}
+
+// Class Switch_statement.
+
+// Traversal.
+
+int
+Switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->val_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->clauses_->traverse(traverse);
+}
+
+// Lower a Switch_statement to a Constant_switch_statement or a series
+// of if statements.
+
+Statement*
+Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ if (this->val_ != NULL
+ && (this->val_->is_error_expression()
+ || this->val_->type()->is_error()))
+ return Statement::make_error_statement(loc);
+
+ if (this->val_ != NULL
+ && this->val_->type()->integer_type() != NULL
+ && !this->clauses_->empty()
+ && this->clauses_->is_constant())
+ return new Constant_switch_statement(this->val_, this->clauses_,
+ this->break_label_, loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ if (this->clauses_->empty())
+ {
+ Expression* val = this->val_;
+ if (val == NULL)
+ val = Expression::make_boolean(true, loc);
+ return Statement::make_statement(val);
+ }
+
+ Temporary_statement* val_temp;
+ if (this->val_ == NULL)
+ val_temp = NULL;
+ else
+ {
+ // var val_temp VAL_TYPE = VAL
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ this->clauses_->lower(b, val_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a switch statement.
+
+Switch_statement*
+Statement::make_switch_statement(Expression* val, source_location location)
+{
+ return new Switch_statement(val, location);
+}
+
+// Class Type_case_clauses::Type_case_clause.
+
+// Traversal.
+
+int
+Type_case_clauses::Type_case_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_default_
+ && ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ && Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->statements_ != NULL)
+ return this->statements_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower one clause in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+// *STMTS_LABEL, if not NULL, is a label to put at the start of the
+// statements.
+
+void
+Type_case_clauses::Type_case_clause::lower(Block* b,
+ Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label,
+ Unnamed_label** stmts_label) const
+{
+ source_location loc = this->location_;
+
+ Unnamed_label* next_case_label = NULL;
+ if (!this->is_default_)
+ {
+ Type* type = this->type_;
+
+ Expression* ref = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+
+ Expression* cond;
+ // The language permits case nil, which is of course a constant
+ // rather than a type. It will appear here as an invalid
+ // forwarding type.
+ if (type->is_nil_constant_as_type())
+ cond = Expression::make_binary(OPERATOR_EQEQ, ref,
+ Expression::make_nil(loc),
+ loc);
+ else
+ cond = Runtime::make_call((type->interface_type() == NULL
+ ? Runtime::IFACETYPEEQ
+ : Runtime::IFACEI2TP),
+ loc, 2,
+ Expression::make_type_descriptor(type, loc),
+ ref);
+
+ Unnamed_label* dest;
+ if (!this->is_fallthrough_)
+ {
+ // if !COND { goto NEXT_CASE_LABEL }
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = next_case_label;
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ }
+ else
+ {
+ // if COND { goto STMTS_LABEL }
+ go_assert(stmts_label != NULL);
+ if (*stmts_label == NULL)
+ *stmts_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = *stmts_label;
+ }
+ Block* then_block = new Block(b, loc);
+ Statement* s = Statement::make_goto_unnamed_statement(dest, loc);
+ then_block->add_statement(s);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (this->statements_ != NULL
+ || (!this->is_fallthrough_
+ && stmts_label != NULL
+ && *stmts_label != NULL))
+ {
+ go_assert(!this->is_fallthrough_);
+ if (stmts_label != NULL && *stmts_label != NULL)
+ {
+ go_assert(!this->is_default_);
+ if (this->statements_ != NULL)
+ (*stmts_label)->set_location(this->statements_->start_location());
+ Statement* s = Statement::make_unnamed_label_statement(*stmts_label);
+ b->add_statement(s);
+ *stmts_label = NULL;
+ }
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+ }
+
+ if (this->is_fallthrough_)
+ go_assert(next_case_label == NULL);
+ else
+ {
+ source_location gloc = (this->statements_ == NULL
+ ? loc
+ : this->statements_->end_location());
+ b->add_statement(Statement::make_goto_unnamed_statement(break_label,
+ gloc));
+ if (next_case_label != NULL)
+ {
+ Statement* s =
+ Statement::make_unnamed_label_statement(next_case_label);
+ b->add_statement(s);
+ }
+ }
+}
+
+// Class Type_case_clauses.
+
+// Traversal.
+
+int
+Type_case_clauses::traverse(Traverse* traverse)
+{
+ for (Type_clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check for duplicate types.
+
+void
+Type_case_clauses::check_duplicates() const
+{
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+ Types_seen types_seen;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t == NULL)
+ continue;
+ if (t->is_nil_constant_as_type())
+ t = Type::make_nil_type();
+ std::pair<Types_seen::iterator, bool> ins = types_seen.insert(t);
+ if (!ins.second)
+ error_at(p->location(), "duplicate type in switch");
+ }
+}
+
+// Lower the clauses in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+
+void
+Type_case_clauses::lower(Block* b, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const
+{
+ const Type_case_clause* default_case = NULL;
+
+ Unnamed_label* stmts_label = NULL;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ p->lower(b, descriptor_temp, break_label, &stmts_label);
+ else
+ {
+ // We are generating a series of tests, which means that we
+ // need to move the default case to the end.
+ default_case = &*p;
+ }
+ }
+ go_assert(stmts_label == NULL);
+
+ if (default_case != NULL)
+ default_case->lower(b, descriptor_temp, break_label, NULL);
+}
+
+// Class Type_switch_statement.
+
+// Traversal.
+
+int
+Type_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->var_ == NULL)
+ {
+ if (this->traverse_expression(traverse, &this->expr_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->clauses_ != NULL)
+ return this->clauses_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a type switch statement to a series of if statements. The gc
+// compiler is able to generate a table in some cases. However, that
+// does not work for us because we may have type descriptors in
+// different shared libraries, so we can't compare them with simple
+// equality testing.
+
+Statement*
+Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ const source_location loc = this->location();
+
+ if (this->clauses_ != NULL)
+ this->clauses_->check_duplicates();
+
+ Block* b = new Block(enclosing, loc);
+
+ Type* val_type = (this->var_ != NULL
+ ? this->var_->var_value()->type()
+ : this->expr_->type());
+
+ // var descriptor_temp DESCRIPTOR_TYPE
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ Temporary_statement* descriptor_temp =
+ Statement::make_temporary(descriptor_type, NULL, loc);
+ b->add_statement(descriptor_temp);
+
+ if (val_type->interface_type() == NULL)
+ {
+ // Doing a type switch on a non-interface type. Should we issue
+ // a warning for this case?
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Expression* rhs;
+ if (val_type->is_nil_type())
+ rhs = Expression::make_nil(loc);
+ else
+ {
+ if (val_type->is_abstract())
+ val_type = val_type->make_non_abstract_type();
+ rhs = Expression::make_type_descriptor(val_type, loc);
+ }
+ Statement* s = Statement::make_assignment(lhs, rhs, loc);
+ b->add_statement(s);
+ }
+ else
+ {
+ // descriptor_temp = ifacetype(val_temp)
+ // FIXME: This should be inlined.
+ bool is_empty = val_type->interface_type()->is_empty();
+ Expression* ref;
+ if (this->var_ == NULL)
+ ref = this->expr_;
+ else
+ ref = Expression::make_var_reference(this->var_, loc);
+ Expression* call = Runtime::make_call((is_empty
+ ? Runtime::EFACETYPE
+ : Runtime::IFACETYPE),
+ loc, 1, ref);
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Statement* s = Statement::make_assignment(lhs, call, loc);
+ b->add_statement(s);
+ }
+
+ if (this->clauses_ != NULL)
+ this->clauses_->lower(b, descriptor_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this type switch statement, creating it
+// if necessary.
+
+Unnamed_label*
+Type_switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a type switch statement.
+
+Type_switch_statement*
+Statement::make_type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+{
+ return new Type_switch_statement(var, expr, location);
+}
+
+// Class Send_statement.
+
+// Traversal.
+
+int
+Send_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->channel_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->val_);
+}
+
+// Determine types.
+
+void
+Send_statement::do_determine_types()
+{
+ this->channel_->determine_type_no_context();
+ Type* type = this->channel_->type();
+ Type_context context;
+ if (type->channel_type() != NULL)
+ context.type = type->channel_type()->element_type();
+ this->val_->determine_type(&context);
+}
+
+// Check types.
+
+void
+Send_statement::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error())
+ {
+ this->set_is_error();
+ return;
+ }
+ Channel_type* channel_type = type->channel_type();
+ if (channel_type == NULL)
+ {
+ error_at(this->location(), "left operand of %<<-%> must be channel");
+ this->set_is_error();
+ return;
+ }
+ Type* element_type = channel_type->element_type();
+ if (!Type::are_assignable(element_type, this->val_->type(), NULL))
+ {
+ this->report_error(_("incompatible types in send"));
+ return;
+ }
+ if (!channel_type->may_send())
+ {
+ this->report_error(_("invalid send on receive-only channel"));
+ return;
+ }
+}
+
+// Convert a send statement to the backend representation.
+
+Bstatement*
+Send_statement::do_get_backend(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ Type* element_type = channel_type->element_type();
+ Expression* val = Expression::make_cast(element_type, this->val_, loc);
+
+ bool is_small;
+ bool can_take_address;
+ switch (element_type->base()->classification())
+ {
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ is_small = true;
+ can_take_address = false;
+ break;
+
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_STRING:
+ case Type::TYPE_INTERFACE:
+ is_small = false;
+ can_take_address = false;
+ break;
+
+ case Type::TYPE_STRUCT:
+ is_small = false;
+ can_take_address = true;
+ break;
+
+ case Type::TYPE_ARRAY:
+ is_small = false;
+ can_take_address = !element_type->is_open_array_type();
+ break;
+
+ default:
+ case Type::TYPE_ERROR:
+ case Type::TYPE_VOID:
+ case Type::TYPE_SINK:
+ case Type::TYPE_NIL:
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ go_assert(saw_errors());
+ return context->backend()->error_statement();
+ }
+
+ // Only try to take the address of a variable. We have already
+ // moved variables to the heap, so this should not cause that to
+ // happen unnecessarily.
+ if (can_take_address
+ && val->var_expression() == NULL
+ && val->temporary_reference_expression() == NULL)
+ can_take_address = false;
+
+ Runtime::Function code;
+ Bstatement* btemp = NULL;
+ Expression* call;
+ if (is_small)
+ {
+ // Type is small enough to handle as uint64.
+ code = Runtime::SEND_SMALL;
+ val = Expression::make_unsafe_cast(Type::lookup_integer_type("uint64"),
+ val, loc);
+ }
+ else if (can_take_address)
+ {
+ // Must pass address of value. The function doesn't change the
+ // value, so just take its address directly.
+ code = Runtime::SEND_BIG;
+ val = Expression::make_unary(OPERATOR_AND, val, loc);
+ }
+ else
+ {
+ // Must pass address of value, but the value is small enough
+ // that it might be in registers. Copy value into temporary
+ // variable to take address.
+ code = Runtime::SEND_BIG;
+ Temporary_statement* temp = Statement::make_temporary(element_type,
+ val, loc);
+ Expression* ref = Expression::make_temporary_reference(temp, loc);
+ val = Expression::make_unary(OPERATOR_AND, ref, loc);
+ btemp = temp->get_backend(context);
+ }
+
+ call = Runtime::make_call(code, loc, 3, this->channel_, val,
+ Expression::make_boolean(this->for_select_, loc));
+
+ context->gogo()->lower_expression(context->function(), &call);
+ Bexpression* bcall = tree_to_expr(call->get_tree(context));
+ Bstatement* s = context->backend()->expression_statement(bcall);
+
+ if (btemp == NULL)
+ return s;
+ else
+ return context->backend()->compound_statement(btemp, s);
+}
+
+// Make a send statement.
+
+Send_statement*
+Statement::make_send_statement(Expression* channel, Expression* val,
+ source_location location)
+{
+ return new Send_statement(channel, val, location);
+}
+
+// Class Select_clauses::Select_clause.
+
+// Traversal.
+
+int
+Select_clauses::Select_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_lowered_
+ && (traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ {
+ if (this->channel_ != NULL)
+ {
+ if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->val_ != NULL)
+ {
+ if (Expression::traverse(&this->val_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->closed_ != NULL)
+ {
+ if (Expression::traverse(&this->closed_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
+ Block* b)
+{
+ if (this->is_default_)
+ {
+ go_assert(this->channel_ == NULL && this->val_ == NULL);
+ this->is_lowered_ = true;
+ return;
+ }
+
+ source_location loc = this->location_;
+
+ // Evaluate the channel before the select statement.
+ Temporary_statement* channel_temp = Statement::make_temporary(NULL,
+ this->channel_,
+ loc);
+ b->add_statement(channel_temp);
+ this->channel_ = Expression::make_temporary_reference(channel_temp, loc);
+
+ // If this is a send clause, evaluate the value to send before the
+ // select statement.
+ Temporary_statement* val_temp = NULL;
+ if (this->is_send_ && !this->val_->is_constant())
+ {
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ // Add the send or receive before the rest of the statements if any.
+ Block *init = new Block(b, loc);
+ Expression* ref = Expression::make_temporary_reference(channel_temp, loc);
+ if (this->is_send_)
+ {
+ Expression* ref2;
+ if (val_temp == NULL)
+ ref2 = this->val_;
+ else
+ ref2 = Expression::make_temporary_reference(val_temp, loc);
+ Send_statement* send = Statement::make_send_statement(ref, ref2, loc);
+ send->set_for_select();
+ init->add_statement(send);
+ }
+ else if (this->closed_ != NULL && !this->closed_->is_sink_expression())
+ {
+ go_assert(this->var_ == NULL && this->closedvar_ == NULL);
+ if (this->val_ == NULL)
+ this->val_ = Expression::make_sink(loc);
+ Statement* s = Statement::make_tuple_receive_assignment(this->val_,
+ this->closed_,
+ ref, true, loc);
+ init->add_statement(s);
+ }
+ else if (this->closedvar_ != NULL)
+ {
+ go_assert(this->val_ == NULL);
+ Expression* val;
+ if (this->var_ == NULL)
+ val = Expression::make_sink(loc);
+ else
+ val = Expression::make_var_reference(this->var_, loc);
+ Expression* closed = Expression::make_var_reference(this->closedvar_,
+ loc);
+ Statement* s = Statement::make_tuple_receive_assignment(val, closed, ref,
+ true, loc);
+ // We have to put S in STATEMENTS_, because that is where the
+ // variables are declared.
+ go_assert(this->statements_ != NULL);
+ this->statements_->add_statement_at_front(s);
+ // We have to lower STATEMENTS_ again, to lower the tuple
+ // receive assignment we just added.
+ gogo->lower_block(function, this->statements_);
+ }
+ else
+ {
+ Receive_expression* recv = Expression::make_receive(ref, loc);
+ recv->set_for_select();
+ if (this->val_ != NULL)
+ {
+ go_assert(this->var_ == NULL);
+ init->add_statement(Statement::make_assignment(this->val_, recv,
+ loc));
+ }
+ else if (this->var_ != NULL)
+ {
+ this->var_->var_value()->set_init(recv);
+ this->var_->var_value()->clear_type_from_chan_element();
+ }
+ else
+ {
+ init->add_statement(Statement::make_statement(recv));
+ }
+ }
+
+ // Lower any statements we just created.
+ gogo->lower_block(function, init);
+
+ if (this->statements_ != NULL)
+ init->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+
+ this->statements_ = init;
+
+ // Now all references should be handled through the statements, not
+ // through here.
+ this->is_lowered_ = true;
+ this->val_ = NULL;
+ this->var_ = NULL;
+}
+
+// Determine types.
+
+void
+Select_clauses::Select_clause::determine_types()
+{
+ go_assert(this->is_lowered_);
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Whether this clause may fall through to the statement which follows
+// the overall select statement.
+
+bool
+Select_clauses::Select_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Return the backend representation for the statements to execute.
+
+Bstatement*
+Select_clauses::Select_clause::get_statements_backend(
+ Translate_context* context)
+{
+ if (this->statements_ == NULL)
+ return NULL;
+ Bblock* bblock = this->statements_->get_backend(context);
+ return context->backend()->block_statement(bblock);
+}
+
+// Class Select_clauses.
+
+// Traversal.
+
+int
+Select_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->lower(gogo, function, b);
+}
+
+// Determine types.
+
+void
+Select_clauses::determine_types()
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types();
+}
+
+// Return whether these select clauses fall through to the statement
+// following the overall select statement.
+
+bool
+Select_clauses::may_fall_through() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (p->may_fall_through())
+ return true;
+ return false;
+}
+
+// Convert to the backend representation. We build a call to
+// size_t __go_select(size_t count, _Bool has_default,
+// channel* channels, _Bool* is_send)
+//
+// There are COUNT entries in the CHANNELS and IS_SEND arrays. The
+// value in the IS_SEND array is true for send, false for receive.
+// __go_select returns an integer from 0 to COUNT, inclusive. A
+// return of 0 means that the default case should be run; this only
+// happens if HAS_DEFAULT is non-zero. Otherwise the number indicates
+// the case to run.
+
+// FIXME: This doesn't handle channels which send interface types
+// where the receiver has a static type which matches that interface.
+
+Bstatement*
+Select_clauses::get_backend(Translate_context* context,
+ Unnamed_label *break_label,
+ source_location location)
+{
+ size_t count = this->clauses_.size();
+
+ Expression_list* chan_init = new Expression_list();
+ chan_init->reserve(count);
+
+ Expression_list* is_send_init = new Expression_list();
+ is_send_init->reserve(count);
+
+ Select_clause *default_clause = NULL;
+
+ Type* runtime_chanptr_type = Runtime::chanptr_type();
+ Type* runtime_chan_type = runtime_chanptr_type->points_to();
+
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->is_default())
+ {
+ default_clause = &*p;
+ --count;
+ continue;
+ }
+
+ if (p->channel()->type()->channel_type() == NULL)
+ {
+ // We should have given an error in the send or receive
+ // statement we created via lowering.
+ go_assert(saw_errors());
+ return context->backend()->error_statement();
+ }
+
+ Expression* c = p->channel();
+ c = Expression::make_unsafe_cast(runtime_chan_type, c, p->location());
+ chan_init->push_back(c);
+
+ is_send_init->push_back(Expression::make_boolean(p->is_send(),
+ p->location()));
+ }
+
+ if (chan_init->empty())
+ {
+ go_assert(count == 0);
+ Bstatement* s;
+ Bstatement* ldef = break_label->get_definition(context);
+ if (default_clause != NULL)
+ {
+ // There is a default clause and no cases. Just execute the
+ // default clause.
+ s = default_clause->get_statements_backend(context);
+ }
+ else
+ {
+ // There isn't even a default clause. In this case select
+ // pauses forever. Call the runtime function with nils.
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0);
+ Expression* zero = Expression::make_integer(&zval, NULL, location);
+ mpz_clear(zval);
+ Expression* default_arg = Expression::make_boolean(false, location);
+ Expression* nil1 = Expression::make_nil(location);
+ Expression* nil2 = nil1->copy();
+ Expression* call = Runtime::make_call(Runtime::SELECT, location, 4,
+ zero, default_arg, nil1, nil2);
+ context->gogo()->lower_expression(context->function(), &call);
+ Bexpression* bcall = tree_to_expr(call->get_tree(context));
+ s = context->backend()->expression_statement(bcall);
+ }
+ if (s == NULL)
+ return ldef;
+ return context->backend()->compound_statement(s, ldef);
+ }
+ go_assert(count > 0);
+
+ std::vector<Bstatement*> statements;
+
+ mpz_t ival;
+ mpz_init_set_ui(ival, count);
+ Expression* ecount = Expression::make_integer(&ival, NULL, location);
+ mpz_clear(ival);
+
+ Type* chan_array_type = Type::make_array_type(runtime_chan_type, ecount);
+ Expression* chans = Expression::make_composite_literal(chan_array_type, 0,
+ false, chan_init,
+ location);
+ context->gogo()->lower_expression(context->function(), &chans);
+ Temporary_statement* chan_temp = Statement::make_temporary(chan_array_type,
+ chans,
+ location);
+ statements.push_back(chan_temp->get_backend(context));
+
+ Type* is_send_array_type = Type::make_array_type(Type::lookup_bool_type(),
+ ecount->copy());
+ Expression* is_sends = Expression::make_composite_literal(is_send_array_type,
+ 0, false,
+ is_send_init,
+ location);
+ context->gogo()->lower_expression(context->function(), &is_sends);
+ Temporary_statement* is_send_temp =
+ Statement::make_temporary(is_send_array_type, is_sends, location);
+ statements.push_back(is_send_temp->get_backend(context));
+
+ mpz_init_set_ui(ival, 0);
+ Expression* zero = Expression::make_integer(&ival, NULL, location);
+ mpz_clear(ival);
+
+ Expression* ref = Expression::make_temporary_reference(chan_temp, location);
+ Expression* chan_arg = Expression::make_array_index(ref, zero, NULL,
+ location);
+ chan_arg = Expression::make_unary(OPERATOR_AND, chan_arg, location);
+ chan_arg = Expression::make_unsafe_cast(runtime_chanptr_type, chan_arg,
+ location);
+
+ ref = Expression::make_temporary_reference(is_send_temp, location);
+ Expression* is_send_arg = Expression::make_array_index(ref, zero->copy(),
+ NULL, location);
+ is_send_arg = Expression::make_unary(OPERATOR_AND, is_send_arg, location);
+
+ Expression* default_arg = Expression::make_boolean(default_clause != NULL,
+ location);
+ Expression* call = Runtime::make_call(Runtime::SELECT, location, 4,
+ ecount->copy(), default_arg,
+ chan_arg, is_send_arg);
+ context->gogo()->lower_expression(context->function(), &call);
+ Bexpression* bcall = tree_to_expr(call->get_tree(context));
+
+ std::vector<std::vector<Bexpression*> > cases;
+ std::vector<Bstatement*> clauses;
+
+ cases.resize(count + (default_clause != NULL ? 1 : 0));
+ clauses.resize(count + (default_clause != NULL ? 1 : 0));
+
+ int index = 0;
+
+ if (default_clause != NULL)
+ {
+ this->add_clause_backend(context, location, index, 0, default_clause,
+ break_label, &cases, &clauses);
+ ++index;
+ }
+
+ int i = 1;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ {
+ this->add_clause_backend(context, location, index, i, &*p,
+ break_label, &cases, &clauses);
+ ++i;
+ ++index;
+ }
+ }
+
+ Bstatement* switch_stmt = context->backend()->switch_statement(bcall,
+ cases,
+ clauses,
+ location);
+ statements.push_back(switch_stmt);
+
+ Bstatement* ldef = break_label->get_definition(context);
+ statements.push_back(ldef);
+
+ return context->backend()->statement_list(statements);
+}
+
+// Add CLAUSE to CASES/CLAUSES at INDEX.
+
+void
+Select_clauses::add_clause_backend(
+ Translate_context* context,
+ source_location location,
+ int index,
+ int case_value,
+ Select_clause* clause,
+ Unnamed_label* bottom_label,
+ std::vector<std::vector<Bexpression*> > *cases,
+ std::vector<Bstatement*>* clauses)
+{
+ mpz_t ival;
+ mpz_init_set_ui(ival, case_value);
+ Expression* e = Expression::make_integer(&ival, NULL, location);
+ mpz_clear(ival);
+ (*cases)[index].push_back(tree_to_expr(e->get_tree(context)));
+
+ Bstatement* s = clause->get_statements_backend(context);
+
+ source_location gloc = (clause->statements() == NULL
+ ? clause->location()
+ : clause->statements()->end_location());
+ Bstatement* g = bottom_label->get_goto(context, gloc);
+
+ if (s == NULL)
+ (*clauses)[index] = g;
+ else
+ (*clauses)[index] = context->backend()->compound_statement(s, g);
+}
+
+// Class Select_statement.
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Select_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Lower a select statement. This will still return a select
+// statement, but it will be modified to implement the order of
+// evaluation rules, and to include the send and receive statements as
+// explicit statements in the clauses.
+
+Statement*
+Select_statement::do_lower(Gogo* gogo, Named_object* function,
+ Block* enclosing)
+{
+ if (this->is_lowered_)
+ return this;
+ Block* b = new Block(enclosing, this->location());
+ this->clauses_->lower(gogo, function, b);
+ this->is_lowered_ = true;
+ b->add_statement(this);
+ return Statement::make_block_statement(b, this->location());
+}
+
+// Return the backend representation for a select statement.
+
+Bstatement*
+Select_statement::do_get_backend(Translate_context* context)
+{
+ return this->clauses_->get_backend(context, this->break_label(),
+ this->location());
+}
+
+// Make a select statement.
+
+Select_statement*
+Statement::make_select_statement(source_location location)
+{
+ return new Select_statement(location);
+}
+
+// Class For_statement.
+
+// Traversal.
+
+int
+For_statement::do_traverse(Traverse* traverse)
+{
+ if (this->init_ != NULL)
+ {
+ if (this->init_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->cond_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->post_ != NULL)
+ {
+ if (this->post_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a For_statement into if statements and gotos. Getting rid of
+// complex statements make it easier to handle garbage collection.
+
+Statement*
+For_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ Statement* s;
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, this->location());
+ if (this->init_ != NULL)
+ {
+ s = Statement::make_block_statement(this->init_,
+ this->init_->start_location());
+ b->add_statement(s);
+ }
+
+ Unnamed_label* entry = NULL;
+ if (this->cond_ != NULL)
+ {
+ entry = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_goto_unnamed_statement(entry, loc));
+ }
+
+ Unnamed_label* top = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_unnamed_label_statement(top));
+
+ s = Statement::make_block_statement(this->statements_,
+ this->statements_->start_location());
+ b->add_statement(s);
+
+ source_location end_loc = this->statements_->end_location();
+
+ Unnamed_label* cont = this->continue_label_;
+ if (cont != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(cont));
+
+ if (this->post_ != NULL)
+ {
+ s = Statement::make_block_statement(this->post_,
+ this->post_->start_location());
+ b->add_statement(s);
+ end_loc = this->post_->end_location();
+ }
+
+ if (this->cond_ == NULL)
+ b->add_statement(Statement::make_goto_unnamed_statement(top, end_loc));
+ else
+ {
+ b->add_statement(Statement::make_unnamed_label_statement(entry));
+
+ source_location cond_loc = this->cond_->location();
+ Block* then_block = new Block(b, cond_loc);
+ s = Statement::make_goto_unnamed_statement(top, cond_loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(this->cond_, then_block, NULL, cond_loc);
+ b->add_statement(s);
+ }
+
+ Unnamed_label* brk = this->break_label_;
+ if (brk != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(brk));
+
+ b->set_end_location(end_loc);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label, creating it if necessary.
+
+Unnamed_label*
+For_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Set the break and continue labels a for statement. This is used
+// when lowering a for range statement.
+
+void
+For_statement::set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label)
+{
+ go_assert(this->break_label_ == NULL && this->continue_label_ == NULL);
+ this->break_label_ = break_label;
+ this->continue_label_ = continue_label;
+}
+
+// Make a for statement.
+
+For_statement*
+Statement::make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+{
+ return new For_statement(init, cond, post, location);
+}
+
+// Class For_range_statement.
+
+// Traversal.
+
+int
+For_range_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->index_var_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->value_var_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->value_var_)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->traverse_expression(traverse, &this->range_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a for range statement. For simplicity we lower this into a
+// for statement, which will then be lowered in turn to goto
+// statements.
+
+Statement*
+For_range_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing)
+{
+ Type* range_type = this->range_->type();
+ if (range_type->points_to() != NULL
+ && range_type->points_to()->array_type() != NULL
+ && !range_type->points_to()->is_open_array_type())
+ range_type = range_type->points_to();
+
+ Type* index_type;
+ Type* value_type = NULL;
+ if (range_type->array_type() != NULL)
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = range_type->array_type()->element_type();
+ }
+ else if (range_type->is_string_type())
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = index_type;
+ }
+ else if (range_type->map_type() != NULL)
+ {
+ index_type = range_type->map_type()->key_type();
+ value_type = range_type->map_type()->val_type();
+ }
+ else if (range_type->channel_type() != NULL)
+ {
+ index_type = range_type->channel_type()->element_type();
+ if (this->value_var_ != NULL)
+ {
+ if (!this->value_var_->type()->is_error())
+ this->report_error(_("too many variables for range clause "
+ "with channel"));
+ return Statement::make_error_statement(this->location());
+ }
+ }
+ else
+ {
+ this->report_error(_("range clause must have "
+ "array, slice, setring, map, or channel type"));
+ return Statement::make_error_statement(this->location());
+ }
+
+ source_location loc = this->location();
+ Block* temp_block = new Block(enclosing, loc);
+
+ Named_object* range_object = NULL;
+ Temporary_statement* range_temp = NULL;
+ Var_expression* ve = this->range_->var_expression();
+ if (ve != NULL)
+ range_object = ve->named_object();
+ else
+ {
+ range_temp = Statement::make_temporary(NULL, this->range_, loc);
+ temp_block->add_statement(range_temp);
+ }
+
+ Temporary_statement* index_temp = Statement::make_temporary(index_type,
+ NULL, loc);
+ temp_block->add_statement(index_temp);
+
+ Temporary_statement* value_temp = NULL;
+ if (this->value_var_ != NULL)
+ {
+ value_temp = Statement::make_temporary(value_type, NULL, loc);
+ temp_block->add_statement(value_temp);
+ }
+
+ Block* body = new Block(temp_block, loc);
+
+ Block* init;
+ Expression* cond;
+ Block* iter_init;
+ Block* post;
+
+ // Arrange to do a loop appropriate for the type. We will produce
+ // for INIT ; COND ; POST {
+ // ITER_INIT
+ // INDEX = INDEX_TEMP
+ // VALUE = VALUE_TEMP // If there is a value
+ // original statements
+ // }
+
+ if (range_type->array_type() != NULL)
+ this->lower_range_array(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->is_string_type())
+ this->lower_range_string(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->map_type() != NULL)
+ this->lower_range_map(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->channel_type() != NULL)
+ this->lower_range_channel(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else
+ go_unreachable();
+
+ if (iter_init != NULL)
+ body->add_statement(Statement::make_block_statement(iter_init, loc));
+
+ Statement* assign;
+ Expression* index_ref = Expression::make_temporary_reference(index_temp, loc);
+ if (this->value_var_ == NULL)
+ {
+ assign = Statement::make_assignment(this->index_var_, index_ref, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(this->index_var_);
+ lhs->push_back(this->value_var_);
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(index_ref);
+ rhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ assign = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ body->add_statement(assign);
+
+ body->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ body->set_end_location(this->statements_->end_location());
+
+ For_statement* loop = Statement::make_for_statement(init, cond, post,
+ this->location());
+ loop->add_statements(body);
+ loop->set_break_continue_labels(this->break_label_, this->continue_label_);
+
+ temp_block->add_statement(loop);
+
+ return Statement::make_block_statement(temp_block, loc);
+}
+
+// Return a reference to the range, which may be in RANGE_OBJECT or in
+// RANGE_TEMP.
+
+Expression*
+For_range_statement::make_range_ref(Named_object* range_object,
+ Temporary_statement* range_temp,
+ source_location loc)
+{
+ if (range_object != NULL)
+ return Expression::make_var_reference(range_object, loc);
+ else
+ return Expression::make_temporary_reference(range_temp, loc);
+}
+
+// Return a call to the predeclared function FUNCNAME passing a
+// reference to the temporary variable ARG.
+
+Expression*
+For_range_statement::call_builtin(Gogo* gogo, const char* funcname,
+ Expression* arg,
+ source_location loc)
+{
+ Named_object* no = gogo->lookup_global(funcname);
+ go_assert(no != NULL && no->is_function_declaration());
+ Expression* func = Expression::make_func_reference(no, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(arg);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a for range over an array or slice.
+
+void
+For_range_statement::lower_range_array(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // len_temp := len(range)
+ // for index_temp = 0; index_temp < len_temp; index_temp++ {
+ // value_temp = range[index_temp]
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var len_temp int
+ // len_temp = len(range)
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Expression* ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* len_call = this->call_builtin(gogo, "len", ref, loc);
+ Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(),
+ len_call, loc);
+ init->add_statement(len_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+ init->add_statement(s);
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // index_temp < len_temp
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(len_temp, loc);
+ Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc);
+
+ *pcond = lt;
+
+ // Set *PITER_INIT to
+ // value_temp = range[index_temp]
+
+ Block* iter_init = NULL;
+ if (value_temp != NULL)
+ {
+ iter_init = new Block(body_block, loc);
+
+ ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(index_temp, loc);
+ Expression* index = Expression::make_index(ref, ref2, NULL, loc);
+
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ s = Statement::make_assignment(ref, index, loc);
+
+ iter_init->add_statement(s);
+ }
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp++
+
+ Block* post = new Block(enclosing, loc);
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ s = Statement::make_inc_statement(ref);
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a string.
+
+void
+For_range_statement::lower_range_string(Gogo*,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // var next_index_temp int
+ // for index_temp = 0; ; index_temp = next_index_temp {
+ // next_index_temp, value_temp = stringiter2(range, index_temp)
+ // if next_index_temp == 0 {
+ // break
+ // }
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var next_index_temp int
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Temporary_statement* next_index_temp =
+ Statement::make_temporary(index_temp->type(), NULL, loc);
+ init->add_statement(next_index_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+
+ Expression* ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+
+ init->add_statement(s);
+ *pinit = init;
+
+ // The loop has no condition.
+
+ *pcond = NULL;
+
+ // Set *PITER_INIT to
+ // next_index_temp = runtime.stringiter(range, index_temp)
+ // or
+ // next_index_temp, value_temp = runtime.stringiter2(range, index_temp)
+ // followed by
+ // if next_index_temp == 0 {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Expression* p1 = this->make_range_ref(range_object, range_temp, loc);
+ Expression* p2 = Expression::make_temporary_reference(index_temp, loc);
+ Call_expression* call = Runtime::make_call((value_temp == NULL
+ ? Runtime::STRINGITER
+ : Runtime::STRINGITER2),
+ loc, 2, p1, p2);
+
+ if (value_temp == NULL)
+ {
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(ref, call, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(Expression::make_temporary_reference(next_index_temp,
+ loc));
+ lhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(Expression::make_call_result(call, 0));
+ rhs->push_back(Expression::make_call_result(call, 1));
+
+ s = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ iter_init->add_statement(s);
+
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+ Expression* equals = Expression::make_binary(OPERATOR_EQEQ, ref, zexpr, loc);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(equals, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp = next_index_temp
+
+ Block* post = new Block(enclosing, loc);
+
+ Expression* lhs = Expression::make_temporary_reference(index_temp, loc);
+ Expression* rhs = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(lhs, rhs, loc);
+
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a map.
+
+void
+For_range_statement::lower_range_map(Gogo*,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The runtime uses a struct to handle ranges over a map. The
+ // struct is four pointers long. The first pointer is NULL when we
+ // have completed the iteration.
+
+ // The loop we generate:
+ // var hiter map_iteration_struct
+ // for mapiterinit(range, &hiter); hiter[0] != nil; mapiternext(&hiter) {
+ // mapiter2(hiter, &index_temp, &value_temp)
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var hiter map_iteration_struct
+ // runtime.mapiterinit(range, &hiter)
+
+ Block* init = new Block(enclosing, loc);
+
+ Type* map_iteration_type = Runtime::map_iteration_type();
+ Temporary_statement* hiter = Statement::make_temporary(map_iteration_type,
+ NULL, loc);
+ init->add_statement(hiter);
+
+ Expression* p1 = this->make_range_ref(range_object, range_temp, loc);
+ Expression* ref = Expression::make_temporary_reference(hiter, loc);
+ Expression* p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ Expression* call = Runtime::make_call(Runtime::MAPITERINIT, loc, 2, p1, p2);
+ init->add_statement(Statement::make_statement(call));
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // hiter[0] != nil
+
+ ref = Expression::make_temporary_reference(hiter, loc);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ Expression* index = Expression::make_index(ref, zexpr, NULL, loc);
+
+ Expression* ne = Expression::make_binary(OPERATOR_NOTEQ, index,
+ Expression::make_nil(loc),
+ loc);
+
+ *pcond = ne;
+
+ // Set *PITER_INIT to
+ // mapiter1(hiter, &index_temp)
+ // or
+ // mapiter2(hiter, &index_temp, &value_temp)
+
+ Block* iter_init = new Block(body_block, loc);
+
+ ref = Expression::make_temporary_reference(hiter, loc);
+ p1 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ p2 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ if (value_temp == NULL)
+ call = Runtime::make_call(Runtime::MAPITER1, loc, 2, p1, p2);
+ else
+ {
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ Expression* p3 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ call = Runtime::make_call(Runtime::MAPITER2, loc, 3, p1, p2, p3);
+ }
+ iter_init->add_statement(Statement::make_statement(call));
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // mapiternext(&hiter)
+
+ Block* post = new Block(enclosing, loc);
+
+ ref = Expression::make_temporary_reference(hiter, loc);
+ p1 = Expression::make_unary(OPERATOR_AND, ref, loc);
+ call = Runtime::make_call(Runtime::MAPITERNEXT, loc, 1, p1);
+ post->add_statement(Statement::make_statement(call));
+
+ *ppost = post;
+}
+
+// Lower a for range over a channel.
+
+void
+For_range_statement::lower_range_channel(Gogo*,
+ Block*,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ go_assert(value_temp == NULL);
+
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // for {
+ // index_temp, ok_temp = <-range
+ // if !ok_temp {
+ // break
+ // }
+ // index = index_temp
+ // original body
+ // }
+
+ // We have no initialization code, no condition, and no post code.
+
+ *pinit = NULL;
+ *pcond = NULL;
+ *ppost = NULL;
+
+ // Set *PITER_INIT to
+ // index_temp, ok_temp = <-range
+ // if !ok_temp {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Temporary_statement* ok_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ iter_init->add_statement(ok_temp);
+
+ Expression* cref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* iref = Expression::make_temporary_reference(index_temp, loc);
+ Expression* oref = Expression::make_temporary_reference(ok_temp, loc);
+ Statement* s = Statement::make_tuple_receive_assignment(iref, oref, cref,
+ false, loc);
+ iter_init->add_statement(s);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ oref = Expression::make_temporary_reference(ok_temp, loc);
+ Expression* cond = Expression::make_unary(OPERATOR_NOT, oref, loc);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+}
+
+// Return the break LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Make a for statement with a range clause.
+
+For_range_statement*
+Statement::make_for_range_statement(Expression* index_var,
+ Expression* value_var,
+ Expression* range,
+ source_location location)
+{
+ return new For_range_statement(index_var, value_var, range, location);
+}
--- /dev/null
+// statements.cc -- Go frontend statements.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "convert.h"
+#include "tree-iterator.h"
+#include "tree-flow.h"
+#include "real.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "types.h"
+#include "expressions.h"
+#include "gogo.h"
+#include "statements.h"
+
+// Class Statement.
+
+Statement::Statement(Statement_classification classification,
+ source_location location)
+ : classification_(classification), location_(location)
+{
+}
+
+Statement::~Statement()
+{
+}
+
+// Traverse the tree. The work of walking the components is handled
+// by the subclasses.
+
+int
+Statement::traverse(Block* block, size_t* pindex, Traverse* traverse)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return TRAVERSE_CONTINUE;
+
+ unsigned int traverse_mask = traverse->traverse_mask();
+
+ if ((traverse_mask & Traverse::traverse_statements) != 0)
+ {
+ int t = traverse->statement(block, pindex, this);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+
+ // No point in checking traverse_mask here--a statement may contain
+ // other blocks or statements, and if we got here we always want to
+ // walk them.
+ return this->do_traverse(traverse);
+}
+
+// Traverse the contents of a statement.
+
+int
+Statement::traverse_contents(Traverse* traverse)
+{
+ return this->do_traverse(traverse);
+}
+
+// Traverse assignments.
+
+bool
+Statement::traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return false;
+ return this->do_traverse_assignments(tassign);
+}
+
+// Traverse an expression in a statement. This is a helper function
+// for child classes.
+
+int
+Statement::traverse_expression(Traverse* traverse, Expression** expr)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Expression::traverse(expr, traverse);
+}
+
+// Traverse an expression list in a statement. This is a helper
+// function for child classes.
+
+int
+Statement::traverse_expression_list(Traverse* traverse,
+ Expression_list* expr_list)
+{
+ if (expr_list == NULL)
+ return TRAVERSE_CONTINUE;
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return expr_list->traverse(traverse);
+}
+
+// Traverse a type in a statement. This is a helper function for
+// child classes.
+
+int
+Statement::traverse_type(Traverse* traverse, Type* type)
+{
+ if ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) == 0)
+ return TRAVERSE_CONTINUE;
+ return Type::traverse(type, traverse);
+}
+
+// Set type information for unnamed constants. This is really done by
+// the child class.
+
+void
+Statement::determine_types()
+{
+ this->do_determine_types();
+}
+
+// If this is a thunk statement, return it.
+
+Thunk_statement*
+Statement::thunk_statement()
+{
+ Thunk_statement* ret = this->convert<Thunk_statement, STATEMENT_GO>();
+ if (ret == NULL)
+ ret = this->convert<Thunk_statement, STATEMENT_DEFER>();
+ return ret;
+}
+
+// Get a tree for a Statement. This is really done by the child
+// class.
+
+tree
+Statement::get_tree(Translate_context* context)
+{
+ if (this->classification_ == STATEMENT_ERROR)
+ return error_mark_node;
+
+ return this->do_get_tree(context);
+}
+
+// Build tree nodes and set locations.
+
+tree
+Statement::build_stmt_1(int tree_code_value, tree node)
+{
+ tree ret = build1(static_cast<tree_code>(tree_code_value),
+ void_type_node, node);
+ SET_EXPR_LOCATION(ret, this->location_);
+ return ret;
+}
+
+// Note that this statement is erroneous. This is called by children
+// when they discover an error.
+
+void
+Statement::set_is_error()
+{
+ this->classification_ = STATEMENT_ERROR;
+}
+
+// For children to call to report an error conveniently.
+
+void
+Statement::report_error(const char* msg)
+{
+ error_at(this->location_, "%s", msg);
+ this->set_is_error();
+}
+
+// An error statement, used to avoid crashing after we report an
+// error.
+
+class Error_statement : public Statement
+{
+ public:
+ Error_statement(source_location location)
+ : Statement(STATEMENT_ERROR, location)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+};
+
+// Make an error statement.
+
+Statement*
+Statement::make_error_statement(source_location location)
+{
+ return new Error_statement(location);
+}
+
+// Class Variable_declaration_statement.
+
+Variable_declaration_statement::Variable_declaration_statement(
+ Named_object* var)
+ : Statement(STATEMENT_VARIABLE_DECLARATION, var->var_value()->location()),
+ var_(var)
+{
+}
+
+// We don't actually traverse the variable here; it was traversed
+// while traversing the Block.
+
+int
+Variable_declaration_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Traverse the assignments in a variable declaration. Note that this
+// traversal is different from the usual traversal.
+
+bool
+Variable_declaration_statement::do_traverse_assignments(
+ Traverse_assignments* tassign)
+{
+ tassign->initialize_variable(this->var_);
+ return true;
+}
+
+// Return the tree for a variable declaration.
+
+tree
+Variable_declaration_statement::do_get_tree(Translate_context* context)
+{
+ tree val = this->var_->get_tree(context->gogo(), context->function());
+ if (val == error_mark_node || TREE_TYPE(val) == error_mark_node)
+ return error_mark_node;
+ Variable* variable = this->var_->var_value();
+
+ tree init = variable->get_init_tree(context->gogo(), context->function());
+ if (init == error_mark_node)
+ return error_mark_node;
+
+ // If this variable lives on the heap, we need to allocate it now.
+ if (!variable->is_in_heap())
+ {
+ DECL_INITIAL(val) = init;
+ return this->build_stmt_1(DECL_EXPR, val);
+ }
+ else
+ {
+ gcc_assert(TREE_CODE(val) == INDIRECT_REF);
+ tree decl = TREE_OPERAND(val, 0);
+ gcc_assert(TREE_CODE(decl) == VAR_DECL);
+ tree type = TREE_TYPE(decl);
+ gcc_assert(POINTER_TYPE_P(type));
+ tree size = TYPE_SIZE_UNIT(TREE_TYPE(type));
+ tree space = context->gogo()->allocate_memory(variable->type(), size,
+ this->location());
+ space = fold_convert(TREE_TYPE(decl), space);
+ DECL_INITIAL(decl) = space;
+ return build2(COMPOUND_EXPR, void_type_node,
+ this->build_stmt_1(DECL_EXPR, decl),
+ build2(MODIFY_EXPR, void_type_node, val, init));
+ }
+}
+
+// Make a variable declaration.
+
+Statement*
+Statement::make_variable_declaration(Named_object* var)
+{
+ return new Variable_declaration_statement(var);
+}
+
+// Class Temporary_statement.
+
+// Return the type of the temporary variable.
+
+Type*
+Temporary_statement::type() const
+{
+ return this->type_ != NULL ? this->type_ : this->init_->type();
+}
+
+// Return the tree for the temporary variable.
+
+tree
+Temporary_statement::get_decl() const
+{
+ if (this->decl_ == NULL)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+ return this->decl_;
+}
+
+// Traversal.
+
+int
+Temporary_statement::do_traverse(Traverse* traverse)
+{
+ if (this->type_ != NULL
+ && this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->init_ == NULL)
+ return TRAVERSE_CONTINUE;
+ else
+ return this->traverse_expression(traverse, &this->init_);
+}
+
+// Traverse assignments.
+
+bool
+Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ if (this->init_ == NULL)
+ return false;
+ tassign->value(&this->init_, true, true);
+ return true;
+}
+
+// Determine types.
+
+void
+Temporary_statement::do_determine_types()
+{
+ if (this->type_ != NULL && this->type_->is_abstract())
+ this->type_ = this->type_->make_non_abstract_type();
+
+ if (this->init_ != NULL)
+ {
+ if (this->type_ == NULL)
+ this->init_->determine_type_no_context();
+ else
+ {
+ Type_context context(this->type_, false);
+ this->init_->determine_type(&context);
+ }
+ }
+
+ if (this->type_ == NULL)
+ {
+ this->type_ = this->init_->type();
+ gcc_assert(!this->type_->is_abstract());
+ }
+}
+
+// Check types.
+
+void
+Temporary_statement::do_check_types(Gogo*)
+{
+ if (this->type_ != NULL && this->init_ != NULL)
+ {
+ std::string reason;
+ if (!Type::are_assignable(this->type_, this->init_->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(), "incompatible types in assignment");
+ else
+ error_at(this->location(), "incompatible types in assignment (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+ }
+}
+
+// Return a tree.
+
+tree
+Temporary_statement::do_get_tree(Translate_context* context)
+{
+ gcc_assert(this->decl_ == NULL_TREE);
+ tree type_tree = this->type()->get_tree(context->gogo());
+ tree init_tree = (this->init_ == NULL
+ ? NULL_TREE
+ : this->init_->get_tree(context));
+ if (type_tree == error_mark_node || init_tree == error_mark_node)
+ {
+ this->decl_ = error_mark_node;
+ return error_mark_node;
+ }
+ // We can only use create_tmp_var if the type is not addressable.
+ if (!TREE_ADDRESSABLE(type_tree))
+ {
+ this->decl_ = create_tmp_var(type_tree, "GOTMP");
+ DECL_SOURCE_LOCATION(this->decl_) = this->location();
+ }
+ else
+ {
+ gcc_assert(context->function() != NULL && context->block() != NULL);
+ tree decl = build_decl(this->location(), VAR_DECL,
+ create_tmp_var_name("GOTMP"),
+ type_tree);
+ DECL_ARTIFICIAL(decl) = 1;
+ DECL_IGNORED_P(decl) = 1;
+ TREE_USED(decl) = 1;
+ gcc_assert(current_function_decl != NULL_TREE);
+ DECL_CONTEXT(decl) = current_function_decl;
+
+ // We have to add this variable to the block so that it winds up
+ // in a BIND_EXPR.
+ tree block_tree = context->block_tree();
+ gcc_assert(block_tree != NULL_TREE);
+ DECL_CHAIN(decl) = BLOCK_VARS(block_tree);
+ BLOCK_VARS(block_tree) = decl;
+
+ this->decl_ = decl;
+ }
+ if (init_tree != NULL_TREE)
+ DECL_INITIAL(this->decl_) =
+ Expression::convert_for_assignment(context, this->type(),
+ this->init_->type(), init_tree,
+ this->location());
+ if (this->is_address_taken_)
+ TREE_ADDRESSABLE(this->decl_) = 1;
+ return this->build_stmt_1(DECL_EXPR, this->decl_);
+}
+
+// Make and initialize a temporary variable in BLOCK.
+
+Temporary_statement*
+Statement::make_temporary(Type* type, Expression* init,
+ source_location location)
+{
+ return new Temporary_statement(type, init, location);
+}
+
+// An assignment statement.
+
+class Assignment_statement : public Statement
+{
+ public:
+ Assignment_statement(Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // Left hand side--the lvalue.
+ Expression* lhs_;
+ // Right hand side--the rvalue.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+bool
+Assignment_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ tassign->assignment(&this->lhs_, &this->rhs_);
+ return true;
+}
+
+// Set types for the assignment.
+
+void
+Assignment_statement::do_determine_types()
+{
+ this->lhs_->determine_type_no_context();
+ Type_context context(this->lhs_->type(), false);
+ this->rhs_->determine_type(&context);
+}
+
+// Check types for an assignment.
+
+void
+Assignment_statement::do_check_types(Gogo*)
+{
+ // The left hand side must be either addressable, a map index
+ // expression, or the blank identifier.
+ if (!this->lhs_->is_addressable()
+ && this->lhs_->map_index_expression() == NULL
+ && !this->lhs_->is_sink_expression())
+ {
+ if (!this->lhs_->type()->is_error_type())
+ this->report_error(_("invalid left hand side of assignment"));
+ return;
+ }
+
+ Type* lhs_type = this->lhs_->type();
+ Type* rhs_type = this->rhs_->type();
+ std::string reason;
+ if (!Type::are_assignable(lhs_type, rhs_type, &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(), "incompatible types in assignment");
+ else
+ error_at(this->location(), "incompatible types in assignment (%s)",
+ reason.c_str());
+ this->set_is_error();
+ }
+
+ if (lhs_type->is_error_type()
+ || rhs_type->is_error_type()
+ || lhs_type->is_undefined()
+ || rhs_type->is_undefined())
+ {
+ // Make sure we get the error for an undefined type.
+ lhs_type->base();
+ rhs_type->base();
+ this->set_is_error();
+ }
+}
+
+// Build a tree for an assignment statement.
+
+tree
+Assignment_statement::do_get_tree(Translate_context* context)
+{
+ tree rhs_tree = this->rhs_->get_tree(context);
+
+ if (this->lhs_->is_sink_expression())
+ return rhs_tree;
+
+ tree lhs_tree = this->lhs_->get_tree(context);
+
+ if (lhs_tree == error_mark_node || rhs_tree == error_mark_node)
+ return error_mark_node;
+
+ rhs_tree = Expression::convert_for_assignment(context, this->lhs_->type(),
+ this->rhs_->type(), rhs_tree,
+ this->location());
+ if (rhs_tree == error_mark_node)
+ return error_mark_node;
+
+ return fold_build2_loc(this->location(), MODIFY_EXPR, void_type_node,
+ lhs_tree, rhs_tree);
+}
+
+// Make an assignment statement.
+
+Statement*
+Statement::make_assignment(Expression* lhs, Expression* rhs,
+ source_location location)
+{
+ return new Assignment_statement(lhs, rhs, location);
+}
+
+// The Move_ordered_evals class is used to find any subexpressions of
+// an expression that have an evaluation order dependency. It creates
+// temporary variables to hold them.
+
+class Move_ordered_evals : public Traverse
+{
+ public:
+ Move_ordered_evals(Block* block)
+ : Traverse(traverse_expressions),
+ block_(block)
+ { }
+
+ protected:
+ int
+ expression(Expression**);
+
+ private:
+ // The block where new temporary variables should be added.
+ Block* block_;
+};
+
+int
+Move_ordered_evals::expression(Expression** pexpr)
+{
+ // We have to look at subexpressions first.
+ if ((*pexpr)->traverse_subexpressions(this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if ((*pexpr)->must_eval_in_order())
+ {
+ source_location loc = (*pexpr)->location();
+ Temporary_statement* temp = Statement::make_temporary(NULL, *pexpr, loc);
+ this->block_->add_statement(temp);
+ *pexpr = Expression::make_temporary_reference(temp, loc);
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+}
+
+// An assignment operation statement.
+
+class Assignment_operation_statement : public Statement
+{
+ public:
+ Assignment_operation_statement(Operator op, Expression* lhs, Expression* rhs,
+ source_location location)
+ : Statement(STATEMENT_ASSIGNMENT_OPERATION, location),
+ op_(op), lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The operator (OPERATOR_PLUSEQ, etc.).
+ Operator op_;
+ // Left hand side.
+ Expression* lhs_;
+ // Right hand side.
+ Expression* rhs_;
+};
+
+// Traversal.
+
+int
+Assignment_operation_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->rhs_);
+}
+
+// Lower an assignment operation statement to a regular assignment
+// statement.
+
+Statement*
+Assignment_operation_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ // We have to evaluate the left hand side expression only once. We
+ // do this by moving out any expression with side effects.
+ Block* b = new Block(enclosing, loc);
+ Move_ordered_evals moe(b);
+ this->lhs_->traverse_subexpressions(&moe);
+
+ Expression* lval = this->lhs_->copy();
+
+ Operator op;
+ switch (this->op_)
+ {
+ case OPERATOR_PLUSEQ:
+ op = OPERATOR_PLUS;
+ break;
+ case OPERATOR_MINUSEQ:
+ op = OPERATOR_MINUS;
+ break;
+ case OPERATOR_OREQ:
+ op = OPERATOR_OR;
+ break;
+ case OPERATOR_XOREQ:
+ op = OPERATOR_XOR;
+ break;
+ case OPERATOR_MULTEQ:
+ op = OPERATOR_MULT;
+ break;
+ case OPERATOR_DIVEQ:
+ op = OPERATOR_DIV;
+ break;
+ case OPERATOR_MODEQ:
+ op = OPERATOR_MOD;
+ break;
+ case OPERATOR_LSHIFTEQ:
+ op = OPERATOR_LSHIFT;
+ break;
+ case OPERATOR_RSHIFTEQ:
+ op = OPERATOR_RSHIFT;
+ break;
+ case OPERATOR_ANDEQ:
+ op = OPERATOR_AND;
+ break;
+ case OPERATOR_BITCLEAREQ:
+ op = OPERATOR_BITCLEAR;
+ break;
+ default:
+ gcc_unreachable();
+ }
+
+ Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc);
+ Statement* s = Statement::make_assignment(this->lhs_, binop, loc);
+ if (b->statements()->empty())
+ {
+ delete b;
+ return s;
+ }
+ else
+ {
+ b->add_statement(s);
+ return Statement::make_block_statement(b, loc);
+ }
+}
+
+// Make an assignment operation statement.
+
+Statement*
+Statement::make_assignment_operation(Operator op, Expression* lhs,
+ Expression* rhs, source_location location)
+{
+ return new Assignment_operation_statement(op, lhs, rhs, location);
+}
+
+// A tuple assignment statement. This differs from an assignment
+// statement in that the right-hand-side expressions are evaluated in
+// parallel.
+
+class Tuple_assignment_statement : public Statement
+{
+ public:
+ Tuple_assignment_statement(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_ASSIGNMENT, location),
+ lhs_(lhs), rhs_(rhs)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Left hand side--a list of lvalues.
+ Expression_list* lhs_;
+ // Right hand side--a list of rvalues.
+ Expression_list* rhs_;
+};
+
+// Traversal.
+
+int
+Tuple_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression_list(traverse, this->lhs_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression_list(traverse, this->rhs_);
+}
+
+// Lower a tuple assignment. We use temporary variables to split it
+// up into a set of single assignments.
+
+Statement*
+Tuple_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, loc);
+
+ // First move out any subexpressions on the left hand side. The
+ // right hand side will be evaluated in the required order anyhow.
+ Move_ordered_evals moe(b);
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs)
+ (*plhs)->traverse_subexpressions(&moe);
+
+ std::vector<Temporary_statement*> temps;
+ temps.reserve(this->lhs_->size());
+
+ Expression_list::const_iterator prhs = this->rhs_->begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ gcc_assert(prhs != this->rhs_->end());
+
+ if ((*plhs)->is_error_expression()
+ || (*plhs)->type()->is_error_type()
+ || (*prhs)->is_error_expression()
+ || (*prhs)->type()->is_error_type())
+ continue;
+
+ if ((*plhs)->is_sink_expression())
+ {
+ b->add_statement(Statement::make_statement(*prhs));
+ continue;
+ }
+
+ Temporary_statement* temp = Statement::make_temporary((*plhs)->type(),
+ *prhs, loc);
+ b->add_statement(temp);
+ temps.push_back(temp);
+
+ }
+ gcc_assert(prhs == this->rhs_->end());
+
+ prhs = this->rhs_->begin();
+ std::vector<Temporary_statement*>::const_iterator ptemp = temps.begin();
+ for (Expression_list::const_iterator plhs = this->lhs_->begin();
+ plhs != this->lhs_->end();
+ ++plhs, ++prhs)
+ {
+ if ((*plhs)->is_error_expression()
+ || (*plhs)->type()->is_error_type()
+ || (*prhs)->is_error_expression()
+ || (*prhs)->type()->is_error_type())
+ continue;
+
+ if ((*plhs)->is_sink_expression())
+ continue;
+
+ Expression* ref = Expression::make_temporary_reference(*ptemp, loc);
+ Statement* s = Statement::make_assignment(*plhs, ref, loc);
+ b->add_statement(s);
+ ++ptemp;
+ }
+ gcc_assert(ptemp == temps.end());
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a tuple assignment statement.
+
+Statement*
+Statement::make_tuple_assignment(Expression_list* lhs, Expression_list* rhs,
+ source_location location)
+{
+ return new Tuple_assignment_statement(lhs, rhs, location);
+}
+
+// A tuple assignment from a map index expression.
+// v, ok = m[k]
+
+class Tuple_map_assignment_statement : public Statement
+{
+public:
+ Tuple_map_assignment_statement(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_MAP_ASSIGNMENT, location),
+ val_(val), present_(present), map_index_(map_index)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the map.
+ Expression* val_;
+ // Lvalue which receives whether the key value was present.
+ Expression* present_;
+ // The map index expression.
+ Expression* map_index_;
+};
+
+// Traversal.
+
+int
+Tuple_map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->present_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->map_index_);
+}
+
+// Lower a tuple map assignment.
+
+Statement*
+Tuple_map_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on right hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+ if (map_type == NULL)
+ return Statement::make_error_statement(loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ // Move out any subexpressions to make sure that functions are
+ // called in the required order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->present_->traverse_subexpressions(&moe);
+
+ // Copy the key value into a temporary so that we can take its
+ // address without pushing the value onto the heap.
+
+ // var key_temp KEY_TYPE = MAP_INDEX
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp VAL_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var present_temp bool
+ Temporary_statement* present_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(present_temp);
+
+ // func mapaccess2(hmap map[k]v, key *k, val *v) bool
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hmap", map_type, bloc));
+ Type* pkey_type = Type::make_pointer_type(map_type->key_type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ Type* pval_type = Type::make_pointer_type(map_type->val_type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* mapaccess2 =
+ Named_object::make_function_declaration("mapaccess2", NULL, fntype, bloc);
+ mapaccess2->func_declaration_value()->set_asm_name("runtime.mapaccess2");
+
+ // present_temp = mapaccess2(MAP, &key_temp, &val_temp)
+ Expression* func = Expression::make_func_reference(mapaccess2, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(map_index->map());
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // present = present_temp
+ ref = Expression::make_temporary_reference(present_temp, loc);
+ s = Statement::make_assignment(this->present_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a map assignment statement which returns a pair of values.
+
+Statement*
+Statement::make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression* map_index,
+ source_location location)
+{
+ return new Tuple_map_assignment_statement(val, present, map_index, location);
+}
+
+// Assign a pair of entries to a map.
+// m[k] = v, p
+
+class Map_assignment_statement : public Statement
+{
+ public:
+ Map_assignment_statement(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+ : Statement(STATEMENT_MAP_ASSIGNMENT, location),
+ map_index_(map_index), val_(val), should_set_(should_set)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // A reference to the map index which should be set or deleted.
+ Expression* map_index_;
+ // The value to add to the map.
+ Expression* val_;
+ // Whether or not to add the value.
+ Expression* should_set_;
+};
+
+// Traverse a map assignment.
+
+int
+Map_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->map_index_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->should_set_);
+}
+
+// Lower a map assignment to a function call.
+
+Statement*
+Map_assignment_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Map_index_expression* map_index = this->map_index_->map_index_expression();
+ if (map_index == NULL)
+ {
+ this->report_error(_("expected map index on left hand side"));
+ return Statement::make_error_statement(loc);
+ }
+ Map_type* map_type = map_index->get_map_type();
+ if (map_type == NULL)
+ return Statement::make_error_statement(loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ // Evaluate the map first to get order of evaluation right.
+ // map_temp := m // we are evaluating m[k] = v, p
+ Temporary_statement* map_temp = Statement::make_temporary(map_type,
+ map_index->map(),
+ loc);
+ b->add_statement(map_temp);
+
+ // var key_temp MAP_KEY_TYPE = k
+ Temporary_statement* key_temp =
+ Statement::make_temporary(map_type->key_type(), map_index->index(), loc);
+ b->add_statement(key_temp);
+
+ // var val_temp MAP_VAL_TYPE = v
+ Temporary_statement* val_temp =
+ Statement::make_temporary(map_type->val_type(), this->val_, loc);
+ b->add_statement(val_temp);
+
+ // func mapassign2(hmap map[k]v, key *k, val *v, p)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hmap", map_type, bloc));
+ Type* pkey_type = Type::make_pointer_type(map_type->key_type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ Type* pval_type = Type::make_pointer_type(map_type->val_type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+ param_types->push_back(Typed_identifier("p", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ NULL, bloc);
+ Named_object* mapassign2 =
+ Named_object::make_function_declaration("mapassign2", NULL, fntype, bloc);
+ mapassign2->func_declaration_value()->set_asm_name("runtime.mapassign2");
+
+ // mapassign2(map_temp, &key_temp, &val_temp, p)
+ Expression* func = Expression::make_func_reference(mapassign2, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_temporary_reference(map_temp, loc));
+ Expression* ref = Expression::make_temporary_reference(key_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ params->push_back(this->should_set_);
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Statement* s = Statement::make_statement(call);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a statement which assigns a pair of entries to a map.
+
+Statement*
+Statement::make_map_assignment(Expression* map_index,
+ Expression* val, Expression* should_set,
+ source_location location)
+{
+ return new Map_assignment_statement(map_index, val, should_set, location);
+}
+
+// A tuple assignment from a receive statement.
+
+class Tuple_receive_assignment_statement : public Statement
+{
+ public:
+ Tuple_receive_assignment_statement(Expression* val, Expression* closed,
+ Expression* channel, bool for_select,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_RECEIVE_ASSIGNMENT, location),
+ val_(val), closed_(closed), channel_(channel), for_select_(for_select)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Lvalue which receives the value from the channel.
+ Expression* val_;
+ // Lvalue which receives whether the channel is closed.
+ Expression* closed_;
+ // The channel on which we receive the value.
+ Expression* channel_;
+ // Whether this is for a select statement.
+ bool for_select_;
+};
+
+// Traversal.
+
+int
+Tuple_receive_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->closed_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->channel_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_receive_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ if (channel_type == NULL)
+ {
+ this->report_error(_("expected channel"));
+ return Statement::make_error_statement(loc);
+ }
+ if (!channel_type->may_receive())
+ {
+ this->report_error(_("invalid receive on send-only channel"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->closed_->traverse_subexpressions(&moe);
+
+ // var val_temp ELEMENT_TYPE
+ Temporary_statement* val_temp =
+ Statement::make_temporary(channel_type->element_type(), NULL, loc);
+ b->add_statement(val_temp);
+
+ // var closed_temp bool
+ Temporary_statement* closed_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ b->add_statement(closed_temp);
+
+ // func chanrecv2(c chan T, val *T) bool
+ // func chanrecv3(c chan T, val *T) bool (if for_select)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("c", channel_type, bloc));
+ Type* pelement_type = Type::make_pointer_type(channel_type->element_type());
+ param_types->push_back(Typed_identifier("val", pelement_type, bloc));
+
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* chanrecv;
+ if (!this->for_select_)
+ {
+ chanrecv = Named_object::make_function_declaration("chanrecv2", NULL,
+ fntype, bloc);
+ chanrecv->func_declaration_value()->set_asm_name("runtime.chanrecv2");
+ }
+ else
+ {
+ chanrecv = Named_object::make_function_declaration("chanrecv3", NULL,
+ fntype, bloc);
+ chanrecv->func_declaration_value()->set_asm_name("runtime.chanrecv3");
+ }
+
+ // closed_temp = chanrecv[23](channel, &val_temp)
+ Expression* func = Expression::make_func_reference(chanrecv, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->channel_);
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ ref = Expression::make_temporary_reference(closed_temp, loc);
+ Statement* s = Statement::make_assignment(ref, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+
+ // closed = closed_temp
+ ref = Expression::make_temporary_reference(closed_temp, loc);
+ s = Statement::make_assignment(this->closed_, ref, loc);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Make a nonblocking receive statement.
+
+Statement*
+Statement::make_tuple_receive_assignment(Expression* val, Expression* closed,
+ Expression* channel,
+ bool for_select,
+ source_location location)
+{
+ return new Tuple_receive_assignment_statement(val, closed, channel,
+ for_select, location);
+}
+
+// An assignment to a pair of values from a type guard. This is a
+// conditional type guard. v, ok = i.(type).
+
+class Tuple_type_guard_assignment_statement : public Statement
+{
+ public:
+ Tuple_type_guard_assignment_statement(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+ : Statement(STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT, location),
+ val_(val), ok_(ok), expr_(expr), type_(type)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ Call_expression*
+ lower_to_empty_interface(const char*);
+
+ Call_expression*
+ lower_to_type(const char*);
+
+ void
+ lower_to_object_type(Block*, const char*);
+
+ // The variable which recieves the converted value.
+ Expression* val_;
+ // The variable which receives the indication of success.
+ Expression* ok_;
+ // The expression being converted.
+ Expression* expr_;
+ // The type to which the expression is being converted.
+ Type* type_;
+};
+
+// Traverse a type guard tuple assignment.
+
+int
+Tuple_type_guard_assignment_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT
+ || this->traverse_expression(traverse, &this->ok_) == TRAVERSE_EXIT
+ || this->traverse_type(traverse, this->type_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->expr_);
+}
+
+// Lower to a function call.
+
+Statement*
+Tuple_type_guard_assignment_statement::do_lower(Gogo*, Named_object*,
+ Block* enclosing)
+{
+ source_location loc = this->location();
+
+ Type* expr_type = this->expr_->type();
+ if (expr_type->interface_type() == NULL)
+ {
+ if (!expr_type->is_error_type() && !this->type_->is_error_type())
+ this->report_error(_("type assertion only valid for interface types"));
+ return Statement::make_error_statement(loc);
+ }
+
+ Block* b = new Block(enclosing, loc);
+
+ // Make sure that any subexpressions on the left hand side are
+ // evaluated in the right order.
+ Move_ordered_evals moe(b);
+ this->val_->traverse_subexpressions(&moe);
+ this->ok_->traverse_subexpressions(&moe);
+
+ bool expr_is_empty = expr_type->interface_type()->is_empty();
+ Call_expression* call;
+ if (this->type_->interface_type() != NULL)
+ {
+ if (this->type_->interface_type()->is_empty())
+ call = this->lower_to_empty_interface(expr_is_empty
+ ? "ifaceE2E2"
+ : "ifaceI2E2");
+ else
+ call = this->lower_to_type(expr_is_empty ? "ifaceE2I2" : "ifaceI2I2");
+ }
+ else if (this->type_->points_to() != NULL)
+ call = this->lower_to_type(expr_is_empty ? "ifaceE2T2P" : "ifaceI2T2P");
+ else
+ {
+ this->lower_to_object_type(b, expr_is_empty ? "ifaceE2T2" : "ifaceI2T2");
+ call = NULL;
+ }
+
+ if (call != NULL)
+ {
+ Expression* res = Expression::make_call_result(call, 0);
+ Statement* s = Statement::make_assignment(this->val_, res, loc);
+ b->add_statement(s);
+
+ res = Expression::make_call_result(call, 1);
+ s = Statement::make_assignment(this->ok_, res, loc);
+ b->add_statement(s);
+ }
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Lower a conversion to an empty interface type.
+
+Call_expression*
+Tuple_type_guard_assignment_statement::lower_to_empty_interface(
+ const char *fnname)
+{
+ source_location loc = this->location();
+
+ // func FNNAME(interface) (empty, bool)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ret", this->type_, bloc));
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // val, ok = FNNAME(expr)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->expr_);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a conversion to a non-empty interface type or a pointer type.
+
+Call_expression*
+Tuple_type_guard_assignment_statement::lower_to_type(const char* fnname)
+{
+ source_location loc = this->location();
+
+ // func FNNAME(*descriptor, interface) (interface, bool)
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("inter",
+ Type::make_type_descriptor_ptr_type(),
+ bloc));
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ret", this->type_, bloc));
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // val, ok = FNNAME(type_descriptor, expr)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(this->type_, loc));
+ params->push_back(this->expr_);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a conversion to a non-interface non-pointer type.
+
+void
+Tuple_type_guard_assignment_statement::lower_to_object_type(Block* b,
+ const char *fnname)
+{
+ source_location loc = this->location();
+
+ // var val_temp TYPE
+ Temporary_statement* val_temp = Statement::make_temporary(this->type_,
+ NULL, loc);
+ b->add_statement(val_temp);
+
+ // func FNNAME(*descriptor, interface, *T) bool
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("inter",
+ Type::make_type_descriptor_ptr_type(),
+ bloc));
+ param_types->push_back(Typed_identifier("i", this->expr_->type(), bloc));
+ Type* ptype = Type::make_pointer_type(this->type_);
+ param_types->push_back(Typed_identifier("v", ptype, bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("ok", Type::lookup_bool_type(), bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ std::string asm_name = "runtime.";
+ asm_name += fnname;
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // ok = FNNAME(type_descriptor, expr, &val_temp)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(this->type_, loc));
+ params->push_back(this->expr_);
+ Expression* ref = Expression::make_temporary_reference(val_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Statement* s = Statement::make_assignment(this->ok_, call, loc);
+ b->add_statement(s);
+
+ // val = val_temp
+ ref = Expression::make_temporary_reference(val_temp, loc);
+ s = Statement::make_assignment(this->val_, ref, loc);
+ b->add_statement(s);
+}
+
+// Make an assignment from a type guard to a pair of variables.
+
+Statement*
+Statement::make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location location)
+{
+ return new Tuple_type_guard_assignment_statement(val, ok, expr, type,
+ location);
+}
+
+// An expression statement.
+
+class Expression_statement : public Statement
+{
+ public:
+ Expression_statement(Expression* expr)
+ : Statement(STATEMENT_EXPRESSION, expr->location()),
+ expr_(expr)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ void
+ do_determine_types()
+ { this->expr_->determine_type_no_context(); }
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->expr_->get_tree(context); }
+
+ private:
+ Expression* expr_;
+};
+
+// An expression statement may fall through unless it is a call to a
+// function which does not return.
+
+bool
+Expression_statement::do_may_fall_through() const
+{
+ const Call_expression* call = this->expr_->call_expression();
+ if (call != NULL)
+ {
+ const Expression* fn = call->fn();
+ const Func_expression* fe = fn->func_expression();
+ if (fe != NULL)
+ {
+ const Named_object* no = fe->named_object();
+
+ Function_type* fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ fntype = NULL;
+
+ // The builtin function panic does not return.
+ if (fntype != NULL && fntype->is_builtin() && no->name() == "panic")
+ return false;
+ }
+ }
+ return true;
+}
+
+// Make an expression statement from an Expression.
+
+Statement*
+Statement::make_statement(Expression* expr)
+{
+ return new Expression_statement(expr);
+}
+
+// A block statement--a list of statements which may include variable
+// definitions.
+
+class Block_statement : public Statement
+{
+ public:
+ Block_statement(Block* block, source_location location)
+ : Statement(STATEMENT_BLOCK, location),
+ block_(block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->block_->traverse(traverse); }
+
+ void
+ do_determine_types()
+ { this->block_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->block_->may_fall_through(); }
+
+ tree
+ do_get_tree(Translate_context* context)
+ { return this->block_->get_tree(context); }
+
+ private:
+ Block* block_;
+};
+
+// Make a block statement.
+
+Statement*
+Statement::make_block_statement(Block* block, source_location location)
+{
+ return new Block_statement(block, location);
+}
+
+// An increment or decrement statement.
+
+class Inc_dec_statement : public Statement
+{
+ public:
+ Inc_dec_statement(bool is_inc, Expression* expr)
+ : Statement(STATEMENT_INCDEC, expr->location()),
+ expr_(expr), is_inc_(is_inc)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression(traverse, &this->expr_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The l-value to increment or decrement.
+ Expression* expr_;
+ // Whether to increment or decrement.
+ bool is_inc_;
+};
+
+// Lower to += or -=.
+
+Statement*
+Inc_dec_statement::do_lower(Gogo*, Named_object*, Block*)
+{
+ source_location loc = this->location();
+
+ mpz_t oval;
+ mpz_init_set_ui(oval, 1UL);
+ Expression* oexpr = Expression::make_integer(&oval, NULL, loc);
+ mpz_clear(oval);
+
+ Operator op = this->is_inc_ ? OPERATOR_PLUSEQ : OPERATOR_MINUSEQ;
+ return Statement::make_assignment_operation(op, this->expr_, oexpr, loc);
+}
+
+// Make an increment statement.
+
+Statement*
+Statement::make_inc_statement(Expression* expr)
+{
+ return new Inc_dec_statement(true, expr);
+}
+
+// Make a decrement statement.
+
+Statement*
+Statement::make_dec_statement(Expression* expr)
+{
+ return new Inc_dec_statement(false, expr);
+}
+
+// Class Thunk_statement. This is the base class for go and defer
+// statements.
+
+const char* const Thunk_statement::thunk_field_fn = "fn";
+
+const char* const Thunk_statement::thunk_field_receiver = "receiver";
+
+// Constructor.
+
+Thunk_statement::Thunk_statement(Statement_classification classification,
+ Call_expression* call,
+ source_location location)
+ : Statement(classification, location),
+ call_(call), struct_type_(NULL)
+{
+}
+
+// Return whether this is a simple statement which does not require a
+// thunk.
+
+bool
+Thunk_statement::is_simple(Function_type* fntype) const
+{
+ // We need a thunk to call a method, or to pass a variable number of
+ // arguments.
+ if (fntype->is_method() || fntype->is_varargs())
+ return false;
+
+ // A defer statement requires a thunk to set up for whether the
+ // function can call recover.
+ if (this->classification() == STATEMENT_DEFER)
+ return false;
+
+ // We can only permit a single parameter of pointer type.
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL
+ && (parameters->size() > 1
+ || (parameters->size() == 1
+ && parameters->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If the function returns multiple values, or returns a type other
+ // than integer, floating point, or pointer, then it may get a
+ // hidden first parameter, in which case we need the more
+ // complicated approach. This is true even though we are going to
+ // ignore the return value.
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL
+ && (results->size() > 1
+ || (results->size() == 1
+ && !results->begin()->type()->is_basic_type()
+ && results->begin()->type()->points_to() == NULL)))
+ return false;
+
+ // If this calls something which is not a simple function, then we
+ // need a thunk.
+ Expression* fn = this->call_->call_expression()->fn();
+ if (fn->bound_method_expression() != NULL
+ || fn->interface_field_reference_expression() != NULL)
+ return false;
+
+ return true;
+}
+
+// Traverse a thunk statement.
+
+int
+Thunk_statement::do_traverse(Traverse* traverse)
+{
+ return this->traverse_expression(traverse, &this->call_);
+}
+
+// We implement traverse_assignment for a thunk statement because it
+// effectively copies the function call.
+
+bool
+Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression* fn = this->call_->call_expression()->fn();
+ Expression* fn2 = fn;
+ tassign->value(&fn2, true, false);
+ return true;
+}
+
+// Determine types in a thunk statement.
+
+void
+Thunk_statement::do_determine_types()
+{
+ this->call_->determine_type_no_context();
+
+ // Now that we know the types of the call, build the struct used to
+ // pass parameters.
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ return;
+ Function_type* fntype = ce->get_function_type();
+ if (fntype != NULL && !this->is_simple(fntype))
+ this->struct_type_ = this->build_struct(fntype);
+}
+
+// Check types in a thunk statement.
+
+void
+Thunk_statement::do_check_types(Gogo*)
+{
+ Call_expression* ce = this->call_->call_expression();
+ if (ce == NULL)
+ {
+ if (!this->call_->is_error_expression())
+ this->report_error("expected call expression");
+ return;
+ }
+ Function_type* fntype = ce->get_function_type();
+ if (fntype != NULL && fntype->is_method())
+ {
+ Expression* fn = ce->fn();
+ if (fn->bound_method_expression() == NULL
+ && fn->interface_field_reference_expression() == NULL)
+ this->report_error(_("no object for method call"));
+ }
+}
+
+// The Traverse class used to find and simplify thunk statements.
+
+class Simplify_thunk_traverse : public Traverse
+{
+ public:
+ Simplify_thunk_traverse(Gogo* gogo)
+ : Traverse(traverse_blocks),
+ gogo_(gogo)
+ { }
+
+ int
+ block(Block*);
+
+ private:
+ Gogo* gogo_;
+};
+
+int
+Simplify_thunk_traverse::block(Block* b)
+{
+ // The parser ensures that thunk statements always appear at the end
+ // of a block.
+ if (b->statements()->size() < 1)
+ return TRAVERSE_CONTINUE;
+ Thunk_statement* stat = b->statements()->back()->thunk_statement();
+ if (stat == NULL)
+ return TRAVERSE_CONTINUE;
+ if (stat->simplify_statement(this->gogo_, b))
+ return TRAVERSE_SKIP_COMPONENTS;
+ return TRAVERSE_CONTINUE;
+}
+
+// Simplify all thunk statements.
+
+void
+Gogo::simplify_thunk_statements()
+{
+ Simplify_thunk_traverse thunk_traverse(this);
+ this->traverse(&thunk_traverse);
+}
+
+// Simplify complex thunk statements into simple ones. A complicated
+// thunk statement is one which takes anything other than zero
+// parameters or a single pointer parameter. We rewrite it into code
+// which allocates a struct, stores the parameter values into the
+// struct, and does a simple go or defer statement which passes the
+// struct to a thunk. The thunk does the real call.
+
+bool
+Thunk_statement::simplify_statement(Gogo* gogo, Block* block)
+{
+ if (this->classification() == STATEMENT_ERROR)
+ return false;
+ if (this->call_->is_error_expression())
+ return false;
+
+ Call_expression* ce = this->call_->call_expression();
+ Function_type* fntype = ce->get_function_type();
+ if (fntype == NULL)
+ {
+ gcc_assert(saw_errors());
+ this->set_is_error();
+ return false;
+ }
+ if (this->is_simple(fntype))
+ return false;
+
+ Expression* fn = ce->fn();
+ Bound_method_expression* bound_method = fn->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ const bool is_method = bound_method != NULL || interface_method != NULL;
+
+ source_location location = this->location();
+
+ std::string thunk_name = Gogo::thunk_name();
+
+ // Build the thunk.
+ this->build_thunk(gogo, thunk_name, fntype);
+
+ // Generate code to call the thunk.
+
+ // Get the values to store into the struct which is the single
+ // argument to the thunk.
+
+ Expression_list* vals = new Expression_list();
+ if (fntype->is_builtin())
+ ;
+ else if (!is_method)
+ vals->push_back(fn);
+ else if (interface_method != NULL)
+ vals->push_back(interface_method->expr());
+ else if (bound_method != NULL)
+ {
+ vals->push_back(bound_method->method());
+ Expression* first_arg = bound_method->first_argument();
+
+ // We always pass a pointer when calling a method.
+ if (first_arg->type()->points_to() == NULL)
+ first_arg = Expression::make_unary(OPERATOR_AND, first_arg, location);
+
+ // If we are calling a method which was inherited from an
+ // embedded struct, and the method did not get a stub, then the
+ // first type may be wrong.
+ Type* fatype = bound_method->first_argument_type();
+ if (fatype != NULL)
+ {
+ if (fatype->points_to() == NULL)
+ fatype = Type::make_pointer_type(fatype);
+ Type* unsafe = Type::make_pointer_type(Type::make_void_type());
+ first_arg = Expression::make_cast(unsafe, first_arg, location);
+ first_arg = Expression::make_cast(fatype, first_arg, location);
+ }
+
+ vals->push_back(first_arg);
+ }
+ else
+ gcc_unreachable();
+
+ if (ce->args() != NULL)
+ {
+ for (Expression_list::const_iterator p = ce->args()->begin();
+ p != ce->args()->end();
+ ++p)
+ vals->push_back(*p);
+ }
+
+ // Build the struct.
+ Expression* constructor =
+ Expression::make_struct_composite_literal(this->struct_type_, vals,
+ location);
+
+ // Allocate the initialized struct on the heap.
+ constructor = Expression::make_heap_composite(constructor, location);
+
+ // Look up the thunk.
+ Named_object* named_thunk = gogo->lookup(thunk_name, NULL);
+ gcc_assert(named_thunk != NULL && named_thunk->is_function());
+
+ // Build the call.
+ Expression* func = Expression::make_func_reference(named_thunk, NULL,
+ location);
+ Expression_list* params = new Expression_list();
+ params->push_back(constructor);
+ Call_expression* call = Expression::make_call(func, params, false, location);
+
+ // Build the simple go or defer statement.
+ Statement* s;
+ if (this->classification() == STATEMENT_GO)
+ s = Statement::make_go_statement(call, location);
+ else if (this->classification() == STATEMENT_DEFER)
+ s = Statement::make_defer_statement(call, location);
+ else
+ gcc_unreachable();
+
+ // The current block should end with the go statement.
+ gcc_assert(block->statements()->size() >= 1);
+ gcc_assert(block->statements()->back() == this);
+ block->replace_statement(block->statements()->size() - 1, s);
+
+ // We already ran the determine_types pass, so we need to run it now
+ // for the new statement.
+ s->determine_types();
+
+ // Sanity check.
+ gogo->check_types_in_block(block);
+
+ // Return true to tell the block not to keep looking at statements.
+ return true;
+}
+
+// Set the name to use for thunk parameter N.
+
+void
+Thunk_statement::thunk_field_param(int n, char* buf, size_t buflen)
+{
+ snprintf(buf, buflen, "a%d", n);
+}
+
+// Build a new struct type to hold the parameters for a complicated
+// thunk statement. FNTYPE is the type of the function call.
+
+Struct_type*
+Thunk_statement::build_struct(Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Struct_field_list* fields = new Struct_field_list();
+
+ Call_expression* ce = this->call_->call_expression();
+ Expression* fn = ce->fn();
+
+ Interface_field_reference_expression* interface_method =
+ fn->interface_field_reference_expression();
+ if (interface_method != NULL)
+ {
+ // If this thunk statement calls a method on an interface, we
+ // pass the interface object to the thunk.
+ Typed_identifier tid(Thunk_statement::thunk_field_fn,
+ interface_method->expr()->type(),
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (!fntype->is_builtin())
+ {
+ // The function to call.
+ Typed_identifier tid(Go_statement::thunk_field_fn, fntype, location);
+ fields->push_back(Struct_field(tid));
+ }
+ else if (ce->is_recover_call())
+ {
+ // The predeclared recover function has no argument. However,
+ // we add an argument when building recover thunks. Handle that
+ // here.
+ fields->push_back(Struct_field(Typed_identifier("can_recover",
+ Type::lookup_bool_type(),
+ location)));
+ }
+
+ if (fn->bound_method_expression() != NULL)
+ {
+ gcc_assert(fntype->is_method());
+ Type* rtype = fntype->receiver()->type();
+ // We always pass the receiver as a pointer.
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ Typed_identifier tid(Thunk_statement::thunk_field_receiver, rtype,
+ location);
+ fields->push_back(Struct_field(tid));
+ }
+
+ const Expression_list* args = ce->args();
+ if (args != NULL)
+ {
+ int i = 0;
+ for (Expression_list::const_iterator p = args->begin();
+ p != args->end();
+ ++p, ++i)
+ {
+ char buf[50];
+ this->thunk_field_param(i, buf, sizeof buf);
+ fields->push_back(Struct_field(Typed_identifier(buf, (*p)->type(),
+ location)));
+ }
+ }
+
+ return Type::make_struct_type(fields, location);
+}
+
+// Build the thunk we are going to call. This is a brand new, albeit
+// artificial, function.
+
+void
+Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name,
+ Function_type* fntype)
+{
+ source_location location = this->location();
+
+ Call_expression* ce = this->call_->call_expression();
+
+ bool may_call_recover = false;
+ if (this->classification() == STATEMENT_DEFER)
+ {
+ Func_expression* fn = ce->fn()->func_expression();
+ if (fn == NULL)
+ may_call_recover = true;
+ else
+ {
+ const Named_object* no = fn->named_object();
+ if (!no->is_function())
+ may_call_recover = true;
+ else
+ may_call_recover = no->func_value()->calls_recover();
+ }
+ }
+
+ // Build the type of the thunk. The thunk takes a single parameter,
+ // which is a pointer to the special structure we build.
+ const char* const parameter_name = "__go_thunk_parameter";
+ Typed_identifier_list* thunk_parameters = new Typed_identifier_list();
+ Type* pointer_to_struct_type = Type::make_pointer_type(this->struct_type_);
+ thunk_parameters->push_back(Typed_identifier(parameter_name,
+ pointer_to_struct_type,
+ location));
+
+ Typed_identifier_list* thunk_results = NULL;
+ if (may_call_recover)
+ {
+ // When deferring a function which may call recover, add a
+ // return value, to disable tail call optimizations which will
+ // break the way we check whether recover is permitted.
+ thunk_results = new Typed_identifier_list();
+ thunk_results->push_back(Typed_identifier("", Type::lookup_bool_type(),
+ location));
+ }
+
+ Function_type* thunk_type = Type::make_function_type(NULL, thunk_parameters,
+ thunk_results,
+ location);
+
+ // Start building the thunk.
+ Named_object* function = gogo->start_function(thunk_name, thunk_type, true,
+ location);
+
+ // For a defer statement, start with a call to
+ // __go_set_defer_retaddr. */
+ Label* retaddr_label = NULL;
+ if (may_call_recover)
+ {
+ retaddr_label = gogo->add_label_reference("retaddr");
+ Expression* arg = Expression::make_label_addr(retaddr_label, location);
+ Expression_list* args = new Expression_list();
+ args->push_back(arg);
+
+ static Named_object* set_defer_retaddr;
+ if (set_defer_retaddr == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ Type *voidptr_type = Type::make_pointer_type(Type::make_void_type());
+ param_types->push_back(Typed_identifier("r", voidptr_type, bloc));
+
+ Typed_identifier_list* result_types = new Typed_identifier_list();
+ result_types->push_back(Typed_identifier("",
+ Type::lookup_bool_type(),
+ bloc));
+
+ Function_type* t = Type::make_function_type(NULL, param_types,
+ result_types, bloc);
+ set_defer_retaddr =
+ Named_object::make_function_declaration("__go_set_defer_retaddr",
+ NULL, t, bloc);
+ const char* n = "__go_set_defer_retaddr";
+ set_defer_retaddr->func_declaration_value()->set_asm_name(n);
+ }
+
+ Expression* fn = Expression::make_func_reference(set_defer_retaddr,
+ NULL, location);
+ Expression* call = Expression::make_call(fn, args, false, location);
+
+ // This is a hack to prevent the middle-end from deleting the
+ // label.
+ gogo->start_block(location);
+ gogo->add_statement(Statement::make_goto_statement(retaddr_label,
+ location));
+ Block* then_block = gogo->finish_block(location);
+ then_block->determine_types();
+
+ Statement* s = Statement::make_if_statement(call, then_block, NULL,
+ location);
+ s->determine_types();
+ gogo->add_statement(s);
+ }
+
+ // Get a reference to the parameter.
+ Named_object* named_parameter = gogo->lookup(parameter_name, NULL);
+ gcc_assert(named_parameter != NULL && named_parameter->is_variable());
+
+ // Build the call. Note that the field names are the same as the
+ // ones used in build_struct.
+ Expression* thunk_parameter = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_parameter = Expression::make_unary(OPERATOR_MULT, thunk_parameter,
+ location);
+
+ Bound_method_expression* bound_method = ce->fn()->bound_method_expression();
+ Interface_field_reference_expression* interface_method =
+ ce->fn()->interface_field_reference_expression();
+
+ Expression* func_to_call;
+ unsigned int next_index;
+ if (!fntype->is_builtin())
+ {
+ func_to_call = Expression::make_field_reference(thunk_parameter,
+ 0, location);
+ next_index = 1;
+ }
+ else
+ {
+ gcc_assert(bound_method == NULL && interface_method == NULL);
+ func_to_call = ce->fn();
+ next_index = 0;
+ }
+
+ if (bound_method != NULL)
+ {
+ Expression* r = Expression::make_field_reference(thunk_parameter, 1,
+ location);
+ // The main program passes in a function pointer from the
+ // interface expression, so here we can make a bound method in
+ // all cases.
+ func_to_call = Expression::make_bound_method(r, func_to_call,
+ location);
+ next_index = 2;
+ }
+ else if (interface_method != NULL)
+ {
+ // The main program passes the interface object.
+ const std::string& name(interface_method->name());
+ func_to_call = Expression::make_interface_field_reference(func_to_call,
+ name,
+ location);
+ }
+
+ Expression_list* call_params = new Expression_list();
+ const Struct_field_list* fields = this->struct_type_->fields();
+ Struct_field_list::const_iterator p = fields->begin();
+ for (unsigned int i = 0; i < next_index; ++i)
+ ++p;
+ bool is_recover_call = ce->is_recover_call();
+ Expression* recover_arg = NULL;
+ for (; p != fields->end(); ++p, ++next_index)
+ {
+ Expression* thunk_param = Expression::make_var_reference(named_parameter,
+ location);
+ thunk_param = Expression::make_unary(OPERATOR_MULT, thunk_param,
+ location);
+ Expression* param = Expression::make_field_reference(thunk_param,
+ next_index,
+ location);
+ if (!is_recover_call)
+ call_params->push_back(param);
+ else
+ {
+ gcc_assert(call_params->empty());
+ recover_arg = param;
+ }
+ }
+
+ if (call_params->empty())
+ {
+ delete call_params;
+ call_params = NULL;
+ }
+
+ Expression* call = Expression::make_call(func_to_call, call_params, false,
+ location);
+ // We need to lower in case this is a builtin function.
+ call = call->lower(gogo, function, -1);
+ Call_expression* call_ce = call->call_expression();
+ if (call_ce != NULL && may_call_recover)
+ call_ce->set_is_deferred();
+
+ Statement* call_statement = Statement::make_statement(call);
+
+ // We already ran the determine_types pass, so we need to run it
+ // just for this statement now.
+ call_statement->determine_types();
+
+ // Sanity check.
+ call->check_types(gogo);
+
+ if (call_ce != NULL && recover_arg != NULL)
+ call_ce->set_recover_arg(recover_arg);
+
+ gogo->add_statement(call_statement);
+
+ // If this is a defer statement, the label comes immediately after
+ // the call.
+ if (may_call_recover)
+ {
+ gogo->add_label_definition("retaddr", location);
+
+ Expression_list* vals = new Expression_list();
+ vals->push_back(Expression::make_boolean(false, location));
+ const Typed_identifier_list* results =
+ function->func_value()->type()->results();
+ gogo->add_statement(Statement::make_return_statement(results, vals,
+ location));
+ }
+
+ // That is all the thunk has to do.
+ gogo->finish_function(location);
+}
+
+// Get the function and argument trees.
+
+void
+Thunk_statement::get_fn_and_arg(Translate_context* context, tree* pfn,
+ tree* parg)
+{
+ if (this->call_->is_error_expression())
+ {
+ *pfn = error_mark_node;
+ *parg = error_mark_node;
+ return;
+ }
+
+ Call_expression* ce = this->call_->call_expression();
+
+ Expression* fn = ce->fn();
+ *pfn = fn->get_tree(context);
+
+ const Expression_list* args = ce->args();
+ if (args == NULL || args->empty())
+ *parg = null_pointer_node;
+ else
+ {
+ gcc_assert(args->size() == 1);
+ *parg = args->front()->get_tree(context);
+ }
+}
+
+// Class Go_statement.
+
+tree
+Go_statement::do_get_tree(Translate_context* context)
+{
+ tree fn_tree;
+ tree arg_tree;
+ this->get_fn_and_arg(context, &fn_tree, &arg_tree);
+
+ static tree go_fndecl;
+
+ tree fn_arg_type = NULL_TREE;
+ if (go_fndecl == NULL_TREE)
+ {
+ // Only build FN_ARG_TYPE if we need it.
+ tree subargtypes = tree_cons(NULL_TREE, ptr_type_node, void_list_node);
+ tree subfntype = build_function_type(ptr_type_node, subargtypes);
+ fn_arg_type = build_pointer_type(subfntype);
+ }
+
+ return Gogo::call_builtin(&go_fndecl,
+ this->location(),
+ "__go_go",
+ 2,
+ void_type_node,
+ fn_arg_type,
+ fn_tree,
+ ptr_type_node,
+ arg_tree);
+}
+
+// Make a go statement.
+
+Statement*
+Statement::make_go_statement(Call_expression* call, source_location location)
+{
+ return new Go_statement(call, location);
+}
+
+// Class Defer_statement.
+
+tree
+Defer_statement::do_get_tree(Translate_context* context)
+{
+ source_location loc = this->location();
+
+ tree fn_tree;
+ tree arg_tree;
+ this->get_fn_and_arg(context, &fn_tree, &arg_tree);
+ if (fn_tree == error_mark_node || arg_tree == error_mark_node)
+ return error_mark_node;
+
+ static tree defer_fndecl;
+
+ tree fn_arg_type = NULL_TREE;
+ if (defer_fndecl == NULL_TREE)
+ {
+ // Only build FN_ARG_TYPE if we need it.
+ tree subargtypes = tree_cons(NULL_TREE, ptr_type_node, void_list_node);
+ tree subfntype = build_function_type(ptr_type_node, subargtypes);
+ fn_arg_type = build_pointer_type(subfntype);
+ }
+
+ tree defer_stack = context->function()->func_value()->defer_stack(loc);
+
+ return Gogo::call_builtin(&defer_fndecl,
+ loc,
+ "__go_defer",
+ 3,
+ void_type_node,
+ ptr_type_node,
+ defer_stack,
+ fn_arg_type,
+ fn_tree,
+ ptr_type_node,
+ arg_tree);
+}
+
+// Make a defer statement.
+
+Statement*
+Statement::make_defer_statement(Call_expression* call,
+ source_location location)
+{
+ return new Defer_statement(call, location);
+}
+
+// Class Return_statement.
+
+// Traverse assignments. We treat each return value as a top level
+// RHS in an expression.
+
+bool
+Return_statement::do_traverse_assignments(Traverse_assignments* tassign)
+{
+ Expression_list* vals = this->vals_;
+ if (vals != NULL)
+ {
+ for (Expression_list::iterator p = vals->begin();
+ p != vals->end();
+ ++p)
+ tassign->value(&*p, true, true);
+ }
+ return true;
+}
+
+// Lower a return statement. If we are returning a function call
+// which returns multiple values which match the current function,
+// split up the call's results. If the function has named result
+// variables, and the return statement lists explicit values, then
+// implement it by assigning the values to the result variables and
+// changing the statement to not list any values. This lets
+// panic/recover work correctly.
+
+Statement*
+Return_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ if (this->vals_ == NULL)
+ return this;
+
+ const Typed_identifier_list* results = this->results_;
+ if (results == NULL || results->empty())
+ return this;
+
+ // If the current function has multiple return values, and we are
+ // returning a single call expression, split up the call expression.
+ size_t results_count = results->size();
+ if (results_count > 1
+ && this->vals_->size() == 1
+ && this->vals_->front()->call_expression() != NULL)
+ {
+ Call_expression* call = this->vals_->front()->call_expression();
+ size_t count = results->size();
+ Expression_list* vals = new Expression_list;
+ for (size_t i = 0; i < count; ++i)
+ vals->push_back(Expression::make_call_result(call, i));
+ delete this->vals_;
+ this->vals_ = vals;
+ }
+
+ if (results->front().name().empty())
+ return this;
+
+ if (results_count != this->vals_->size())
+ {
+ // Presumably an error which will be reported in check_types.
+ return this;
+ }
+
+ // Assign to named return values and then return them.
+
+ source_location loc = this->location();
+ const Block* top = enclosing;
+ while (top->enclosing() != NULL)
+ top = top->enclosing();
+
+ const Bindings *bindings = top->bindings();
+ Block* b = new Block(enclosing, loc);
+
+ Expression_list* lhs = new Expression_list();
+ Expression_list* rhs = new Expression_list();
+
+ Expression_list::const_iterator pe = this->vals_->begin();
+ int i = 1;
+ for (Typed_identifier_list::const_iterator pr = results->begin();
+ pr != results->end();
+ ++pr, ++pe, ++i)
+ {
+ Named_object* rv = bindings->lookup_local(pr->name());
+ if (rv == NULL || !rv->is_result_variable())
+ {
+ // Presumably an error.
+ delete b;
+ delete lhs;
+ delete rhs;
+ return this;
+ }
+
+ Expression* e = *pe;
+
+ // Check types now so that we give a good error message. The
+ // result type is known. We determine the expression type
+ // early.
+
+ Type *rvtype = rv->result_var_value()->type();
+ Type_context type_context(rvtype, false);
+ e->determine_type(&type_context);
+
+ std::string reason;
+ if (Type::are_assignable(rvtype, e->type(), &reason))
+ {
+ Expression* ve = Expression::make_var_reference(rv, e->location());
+ lhs->push_back(ve);
+ rhs->push_back(e);
+ }
+ else
+ {
+ if (reason.empty())
+ error_at(e->location(), "incompatible type for return value %d", i);
+ else
+ error_at(e->location(),
+ "incompatible type for return value %d (%s)",
+ i, reason.c_str());
+ }
+ }
+ gcc_assert(lhs->size() == rhs->size());
+
+ if (lhs->empty())
+ ;
+ else if (lhs->size() == 1)
+ {
+ b->add_statement(Statement::make_assignment(lhs->front(), rhs->front(),
+ loc));
+ delete lhs;
+ delete rhs;
+ }
+ else
+ b->add_statement(Statement::make_tuple_assignment(lhs, rhs, loc));
+
+ b->add_statement(Statement::make_return_statement(this->results_, NULL,
+ loc));
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Determine types.
+
+void
+Return_statement::do_determine_types()
+{
+ if (this->vals_ == NULL)
+ return;
+ const Typed_identifier_list* results = this->results_;
+
+ Typed_identifier_list::const_iterator pt;
+ if (results != NULL)
+ pt = results->begin();
+ for (Expression_list::iterator pe = this->vals_->begin();
+ pe != this->vals_->end();
+ ++pe)
+ {
+ if (results == NULL || pt == results->end())
+ (*pe)->determine_type_no_context();
+ else
+ {
+ Type_context context(pt->type(), false);
+ (*pe)->determine_type(&context);
+ ++pt;
+ }
+ }
+}
+
+// Check types.
+
+void
+Return_statement::do_check_types(Gogo*)
+{
+ if (this->vals_ == NULL)
+ return;
+
+ const Typed_identifier_list* results = this->results_;
+ if (results == NULL)
+ {
+ this->report_error(_("return with value in function "
+ "with no return type"));
+ return;
+ }
+
+ int i = 1;
+ Typed_identifier_list::const_iterator pt = results->begin();
+ for (Expression_list::const_iterator pe = this->vals_->begin();
+ pe != this->vals_->end();
+ ++pe, ++pt, ++i)
+ {
+ if (pt == results->end())
+ {
+ this->report_error(_("too many values in return statement"));
+ return;
+ }
+ std::string reason;
+ if (!Type::are_assignable(pt->type(), (*pe)->type(), &reason))
+ {
+ if (reason.empty())
+ error_at(this->location(),
+ "incompatible type for return value %d",
+ i);
+ else
+ error_at(this->location(),
+ "incompatible type for return value %d (%s)",
+ i, reason.c_str());
+ this->set_is_error();
+ }
+ else if (pt->type()->is_error_type()
+ || (*pe)->type()->is_error_type()
+ || pt->type()->is_undefined()
+ || (*pe)->type()->is_undefined())
+ {
+ // Make sure we get the error for an undefined type.
+ pt->type()->base();
+ (*pe)->type()->base();
+ this->set_is_error();
+ }
+ }
+
+ if (pt != results->end())
+ this->report_error(_("not enough values in return statement"));
+}
+
+// Build a RETURN_EXPR tree.
+
+tree
+Return_statement::do_get_tree(Translate_context* context)
+{
+ Function* function = context->function()->func_value();
+ tree fndecl = function->get_decl();
+ if (fndecl == error_mark_node || DECL_RESULT(fndecl) == error_mark_node)
+ return error_mark_node;
+
+ const Typed_identifier_list* results = this->results_;
+
+ if (this->vals_ == NULL)
+ {
+ tree stmt_list = NULL_TREE;
+ tree retval = function->return_value(context->gogo(),
+ context->function(),
+ this->location(),
+ &stmt_list);
+ tree set;
+ if (retval == NULL_TREE)
+ set = NULL_TREE;
+ else if (retval == error_mark_node)
+ return error_mark_node;
+ else
+ set = fold_build2_loc(this->location(), MODIFY_EXPR, void_type_node,
+ DECL_RESULT(fndecl), retval);
+ append_to_statement_list(this->build_stmt_1(RETURN_EXPR, set),
+ &stmt_list);
+ return stmt_list;
+ }
+ else if (this->vals_->size() == 1)
+ {
+ gcc_assert(!VOID_TYPE_P(TREE_TYPE(TREE_TYPE(fndecl))));
+ tree val = (*this->vals_->begin())->get_tree(context);
+ gcc_assert(results != NULL && results->size() == 1);
+ val = Expression::convert_for_assignment(context,
+ results->begin()->type(),
+ (*this->vals_->begin())->type(),
+ val, this->location());
+ if (val == error_mark_node)
+ return error_mark_node;
+ tree set = build2(MODIFY_EXPR, void_type_node,
+ DECL_RESULT(fndecl), val);
+ SET_EXPR_LOCATION(set, this->location());
+ return this->build_stmt_1(RETURN_EXPR, set);
+ }
+ else
+ {
+ gcc_assert(!VOID_TYPE_P(TREE_TYPE(TREE_TYPE(fndecl))));
+ tree stmt_list = NULL_TREE;
+ tree rettype = TREE_TYPE(DECL_RESULT(fndecl));
+ tree retvar = create_tmp_var(rettype, "RESULT");
+ gcc_assert(results != NULL && results->size() == this->vals_->size());
+ Expression_list::const_iterator pv = this->vals_->begin();
+ Typed_identifier_list::const_iterator pr = results->begin();
+ for (tree field = TYPE_FIELDS(rettype);
+ field != NULL_TREE;
+ ++pv, ++pr, field = DECL_CHAIN(field))
+ {
+ gcc_assert(pv != this->vals_->end());
+ tree val = (*pv)->get_tree(context);
+ val = Expression::convert_for_assignment(context, pr->type(),
+ (*pv)->type(), val,
+ this->location());
+ if (val == error_mark_node)
+ return error_mark_node;
+ tree set = build2(MODIFY_EXPR, void_type_node,
+ build3(COMPONENT_REF, TREE_TYPE(field),
+ retvar, field, NULL_TREE),
+ val);
+ SET_EXPR_LOCATION(set, this->location());
+ append_to_statement_list(set, &stmt_list);
+ }
+ tree set = build2(MODIFY_EXPR, void_type_node, DECL_RESULT(fndecl),
+ retvar);
+ append_to_statement_list(this->build_stmt_1(RETURN_EXPR, set),
+ &stmt_list);
+ return stmt_list;
+ }
+}
+
+// Make a return statement.
+
+Statement*
+Statement::make_return_statement(const Typed_identifier_list* results,
+ Expression_list* vals,
+ source_location location)
+{
+ return new Return_statement(results, vals, location);
+}
+
+// A break or continue statement.
+
+class Bc_statement : public Statement
+{
+ public:
+ Bc_statement(bool is_break, Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_BREAK_OR_CONTINUE, location),
+ label_(label), is_break_(is_break)
+ { }
+
+ bool
+ is_break() const
+ { return this->is_break_; }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_goto(this->location()); }
+
+ private:
+ // The label that this branches to.
+ Unnamed_label* label_;
+ // True if this is "break", false if it is "continue".
+ bool is_break_;
+};
+
+// Make a break statement.
+
+Statement*
+Statement::make_break_statement(Unnamed_label* label, source_location location)
+{
+ return new Bc_statement(true, label, location);
+}
+
+// Make a continue statement.
+
+Statement*
+Statement::make_continue_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Bc_statement(false, label, location);
+}
+
+// A goto statement.
+
+class Goto_statement : public Statement
+{
+ public:
+ Goto_statement(Label* label, source_location location)
+ : Statement(STATEMENT_GOTO, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Label* label_;
+};
+
+// Check types for a label. There aren't any types per se, but we use
+// this to give an error if the label was never defined.
+
+void
+Goto_statement::do_check_types(Gogo*)
+{
+ if (!this->label_->is_defined())
+ {
+ error_at(this->location(), "reference to undefined label %qs",
+ Gogo::message_name(this->label_->name()).c_str());
+ this->set_is_error();
+ }
+}
+
+// Return the tree for the goto statement.
+
+tree
+Goto_statement::do_get_tree(Translate_context*)
+{
+ return this->build_stmt_1(GOTO_EXPR, this->label_->get_decl());
+}
+
+// Make a goto statement.
+
+Statement*
+Statement::make_goto_statement(Label* label, source_location location)
+{
+ return new Goto_statement(label, location);
+}
+
+// A goto statement to an unnamed label.
+
+class Goto_unnamed_statement : public Statement
+{
+ public:
+ Goto_unnamed_statement(Unnamed_label* label, source_location location)
+ : Statement(STATEMENT_GOTO_UNNAMED, location),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_goto(this->location()); }
+
+ private:
+ Unnamed_label* label_;
+};
+
+// Make a goto statement to an unnamed label.
+
+Statement*
+Statement::make_goto_unnamed_statement(Unnamed_label* label,
+ source_location location)
+{
+ return new Goto_unnamed_statement(label, location);
+}
+
+// Class Label_statement.
+
+// Traversal.
+
+int
+Label_statement::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return a tree defining this label.
+
+tree
+Label_statement::do_get_tree(Translate_context*)
+{
+ return this->build_stmt_1(LABEL_EXPR, this->label_->get_decl());
+}
+
+// Make a label statement.
+
+Statement*
+Statement::make_label_statement(Label* label, source_location location)
+{
+ return new Label_statement(label, location);
+}
+
+// An unnamed label statement.
+
+class Unnamed_label_statement : public Statement
+{
+ public:
+ Unnamed_label_statement(Unnamed_label* label)
+ : Statement(STATEMENT_UNNAMED_LABEL, label->location()),
+ label_(label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*)
+ { return TRAVERSE_CONTINUE; }
+
+ tree
+ do_get_tree(Translate_context*)
+ { return this->label_->get_definition(); }
+
+ private:
+ // The label.
+ Unnamed_label* label_;
+};
+
+// Make an unnamed label statement.
+
+Statement*
+Statement::make_unnamed_label_statement(Unnamed_label* label)
+{
+ return new Unnamed_label_statement(label);
+}
+
+// An if statement.
+
+class If_statement : public Statement
+{
+ public:
+ If_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location location)
+ : Statement(STATEMENT_IF, location),
+ cond_(cond), then_block_(then_block), else_block_(else_block)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Expression* cond_;
+ Block* then_block_;
+ Block* else_block_;
+};
+
+// Traversal.
+
+int
+If_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT
+ || this->then_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->else_block_ != NULL)
+ {
+ if (this->else_block_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+void
+If_statement::do_determine_types()
+{
+ Type_context context(Type::lookup_bool_type(), false);
+ this->cond_->determine_type(&context);
+ this->then_block_->determine_types();
+ if (this->else_block_ != NULL)
+ this->else_block_->determine_types();
+}
+
+// Check types.
+
+void
+If_statement::do_check_types(Gogo*)
+{
+ Type* type = this->cond_->type();
+ if (type->is_error_type())
+ this->set_is_error();
+ else if (!type->is_boolean_type())
+ this->report_error(_("expected boolean expression"));
+}
+
+// Whether the overall statement may fall through.
+
+bool
+If_statement::do_may_fall_through() const
+{
+ return (this->else_block_ == NULL
+ || this->then_block_->may_fall_through()
+ || this->else_block_->may_fall_through());
+}
+
+// Get tree.
+
+tree
+If_statement::do_get_tree(Translate_context* context)
+{
+ gcc_assert(this->cond_->type()->is_boolean_type()
+ || this->cond_->type()->is_error_type());
+ tree cond_tree = this->cond_->get_tree(context);
+ tree then_tree = this->then_block_->get_tree(context);
+ tree else_tree = (this->else_block_ == NULL
+ ? NULL_TREE
+ : this->else_block_->get_tree(context));
+ if (cond_tree == error_mark_node
+ || then_tree == error_mark_node
+ || else_tree == error_mark_node)
+ return error_mark_node;
+ tree ret = build3(COND_EXPR, void_type_node, cond_tree, then_tree,
+ else_tree);
+ SET_EXPR_LOCATION(ret, this->location());
+ return ret;
+}
+
+// Make an if statement.
+
+Statement*
+Statement::make_if_statement(Expression* cond, Block* then_block,
+ Block* else_block, source_location location)
+{
+ return new If_statement(cond, then_block, else_block, location);
+}
+
+// Class Case_clauses::Case_clause.
+
+// Traversal.
+
+int
+Case_clauses::Case_clause::traverse(Traverse* traverse)
+{
+ if (this->cases_ != NULL
+ && (traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ {
+ if (this->cases_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are integer constants.
+
+bool
+Case_clauses::Case_clause::is_constant() const
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ if (!(*p)->is_constant() || (*p)->type()->integer_type() == NULL)
+ return false;
+ }
+ return true;
+}
+
+// Lower a case clause for a nonconstant switch. VAL_TEMP is the
+// value we are switching on; it may be NULL. If START_LABEL is not
+// NULL, it goes at the start of the statements, after the condition
+// test. We branch to FINISH_LABEL at the end of the statements.
+
+void
+Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* start_label,
+ Unnamed_label* finish_label) const
+{
+ source_location loc = this->location_;
+ Unnamed_label* next_case_label;
+ if (this->cases_ == NULL || this->cases_->empty())
+ {
+ gcc_assert(this->is_default_);
+ next_case_label = NULL;
+ }
+ else
+ {
+ Expression* cond = NULL;
+
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Expression* this_cond;
+ if (val_temp == NULL)
+ this_cond = *p;
+ else
+ {
+ Expression* ref = Expression::make_temporary_reference(val_temp,
+ loc);
+ this_cond = Expression::make_binary(OPERATOR_EQEQ, ref, *p, loc);
+ }
+
+ if (cond == NULL)
+ cond = this_cond;
+ else
+ cond = Expression::make_binary(OPERATOR_OROR, cond, this_cond, loc);
+ }
+
+ Block* then_block = new Block(b, loc);
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ Statement* s = Statement::make_goto_unnamed_statement(next_case_label,
+ loc);
+ then_block->add_statement(s);
+
+ // if !COND { goto NEXT_CASE_LABEL }
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (start_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(start_label));
+
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ Statement* s = Statement::make_goto_unnamed_statement(finish_label, loc);
+ b->add_statement(s);
+
+ if (next_case_label != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(next_case_label));
+}
+
+// Determine types.
+
+void
+Case_clauses::Case_clause::determine_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ Type_context case_context(type, false);
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ (*p)->determine_type(&case_context);
+ }
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::Case_clause::check_types(Type* type)
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ if (!Type::are_assignable(type, (*p)->type(), NULL)
+ && !Type::are_assignable((*p)->type(), type, NULL))
+ {
+ error_at((*p)->location(),
+ "type mismatch between switch value and case clause");
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Return true if this clause may fall through to the following
+// statements. Note that this is not the same as whether the case
+// uses the "fallthrough" keyword.
+
+bool
+Case_clauses::Case_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Build up the body of a SWITCH_EXPR.
+
+void
+Case_clauses::Case_clause::get_constant_tree(Translate_context* context,
+ Unnamed_label* break_label,
+ Case_constants* case_constants,
+ tree* stmt_list) const
+{
+ if (this->cases_ != NULL)
+ {
+ for (Expression_list::const_iterator p = this->cases_->begin();
+ p != this->cases_->end();
+ ++p)
+ {
+ Type* itype;
+ mpz_t ival;
+ mpz_init(ival);
+ if (!(*p)->integer_constant_value(true, ival, &itype))
+ {
+ // Something went wrong. This can happen with a
+ // negative constant and an unsigned switch value.
+ gcc_assert(saw_errors());
+ continue;
+ }
+ gcc_assert(itype != NULL);
+ tree type_tree = itype->get_tree(context->gogo());
+ tree val = Expression::integer_constant_tree(ival, type_tree);
+ mpz_clear(ival);
+
+ if (val != error_mark_node)
+ {
+ gcc_assert(TREE_CODE(val) == INTEGER_CST);
+
+ std::pair<Case_constants::iterator, bool> ins =
+ case_constants->insert(val);
+ if (!ins.second)
+ {
+ // Value was already present.
+ warning_at(this->location_, 0,
+ "duplicate case value will never match");
+ continue;
+ }
+
+ tree label = create_artificial_label(this->location_);
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ val, NULL_TREE, label),
+ stmt_list);
+ }
+ }
+ }
+
+ if (this->is_default_)
+ {
+ tree label = create_artificial_label(this->location_);
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ NULL_TREE, NULL_TREE, label),
+ stmt_list);
+ }
+
+ if (this->statements_ != NULL)
+ {
+ tree block_tree = this->statements_->get_tree(context);
+ if (block_tree != error_mark_node)
+ append_to_statement_list(block_tree, stmt_list);
+ }
+
+ if (!this->is_fallthrough_)
+ append_to_statement_list(break_label->get_goto(this->location_), stmt_list);
+}
+
+// Class Case_clauses.
+
+// Traversal.
+
+int
+Case_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check whether all the case expressions are constant.
+
+bool
+Case_clauses::is_constant() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (!p->is_constant())
+ return false;
+ return true;
+}
+
+// Lower case clauses for a nonconstant switch.
+
+void
+Case_clauses::lower(Block* b, Temporary_statement* val_temp,
+ Unnamed_label* break_label) const
+{
+ // The default case.
+ const Case_clause* default_case = NULL;
+
+ // The label for the fallthrough of the previous case.
+ Unnamed_label* last_fallthrough_label = NULL;
+
+ // The label for the start of the default case. This is used if the
+ // case before the default case falls through.
+ Unnamed_label* default_start_label = NULL;
+
+ // The label for the end of the default case. This normally winds
+ // up as BREAK_LABEL, but it will be different if the default case
+ // falls through.
+ Unnamed_label* default_finish_label = NULL;
+
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ // The label to use for the start of the statements for this
+ // case. This is NULL unless the previous case falls through.
+ Unnamed_label* start_label = last_fallthrough_label;
+
+ // The label to jump to after the end of the statements for this
+ // case.
+ Unnamed_label* finish_label = break_label;
+
+ last_fallthrough_label = NULL;
+ if (p->is_fallthrough() && p + 1 != this->clauses_.end())
+ {
+ finish_label = new Unnamed_label(p->location());
+ last_fallthrough_label = finish_label;
+ }
+
+ if (!p->is_default())
+ p->lower(b, val_temp, start_label, finish_label);
+ else
+ {
+ // We have to move the default case to the end, so that we
+ // only use it if all the other tests fail.
+ default_case = &*p;
+ default_start_label = start_label;
+ default_finish_label = finish_label;
+ }
+ }
+
+ if (default_case != NULL)
+ default_case->lower(b, val_temp, default_start_label,
+ default_finish_label);
+
+}
+
+// Determine types.
+
+void
+Case_clauses::determine_types(Type* type)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types(type);
+}
+
+// Check types. Returns false if there was an error.
+
+bool
+Case_clauses::check_types(Type* type)
+{
+ bool ret = true;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->check_types(type))
+ ret = false;
+ }
+ return ret;
+}
+
+// Return true if these clauses may fall through to the statements
+// following the switch statement.
+
+bool
+Case_clauses::may_fall_through() const
+{
+ bool found_default = false;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->may_fall_through() && !p->is_fallthrough())
+ return true;
+ if (p->is_default())
+ found_default = true;
+ }
+ return !found_default;
+}
+
+// Return a tree when all case expressions are constants.
+
+tree
+Case_clauses::get_constant_tree(Translate_context* context,
+ Unnamed_label* break_label) const
+{
+ Case_constants case_constants;
+ tree stmt_list = NULL_TREE;
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->get_constant_tree(context, break_label, &case_constants,
+ &stmt_list);
+ return stmt_list;
+}
+
+// A constant switch statement. A Switch_statement is lowered to this
+// when all the cases are constants.
+
+class Constant_switch_statement : public Statement
+{
+ public:
+ Constant_switch_statement(Expression* val, Case_clauses* clauses,
+ Unnamed_label* break_label,
+ source_location location)
+ : Statement(STATEMENT_CONSTANT_SWITCH, location),
+ val_(val), clauses_(clauses), break_label_(break_label)
+ { }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const;
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The value to switch on.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Traversal.
+
+int
+Constant_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->clauses_->traverse(traverse);
+}
+
+// Determine types.
+
+void
+Constant_switch_statement::do_determine_types()
+{
+ this->val_->determine_type_no_context();
+ this->clauses_->determine_types(this->val_->type());
+}
+
+// Check types.
+
+void
+Constant_switch_statement::do_check_types(Gogo*)
+{
+ if (!this->clauses_->check_types(this->val_->type()))
+ this->set_is_error();
+}
+
+// Return whether this switch may fall through.
+
+bool
+Constant_switch_statement::do_may_fall_through() const
+{
+ if (this->clauses_ == NULL)
+ return true;
+
+ // If we have a break label, then some case needed it. That implies
+ // that the switch statement as a whole can fall through.
+ if (this->break_label_ != NULL)
+ return true;
+
+ return this->clauses_->may_fall_through();
+}
+
+// Convert to GENERIC.
+
+tree
+Constant_switch_statement::do_get_tree(Translate_context* context)
+{
+ tree switch_val_tree = this->val_->get_tree(context);
+
+ Unnamed_label* break_label = this->break_label_;
+ if (break_label == NULL)
+ break_label = new Unnamed_label(this->location());
+
+ tree stmt_list = NULL_TREE;
+ tree s = build3(SWITCH_EXPR, void_type_node, switch_val_tree,
+ this->clauses_->get_constant_tree(context, break_label),
+ NULL_TREE);
+ SET_EXPR_LOCATION(s, this->location());
+ append_to_statement_list(s, &stmt_list);
+
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+
+ return stmt_list;
+}
+
+// Class Switch_statement.
+
+// Traversal.
+
+int
+Switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->val_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->val_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->clauses_->traverse(traverse);
+}
+
+// Lower a Switch_statement to a Constant_switch_statement or a series
+// of if statements.
+
+Statement*
+Switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ source_location loc = this->location();
+
+ if (this->val_ != NULL
+ && (this->val_->is_error_expression()
+ || this->val_->type()->is_error_type()))
+ return Statement::make_error_statement(loc);
+
+ if (this->val_ != NULL
+ && this->val_->type()->integer_type() != NULL
+ && !this->clauses_->empty()
+ && this->clauses_->is_constant())
+ return new Constant_switch_statement(this->val_, this->clauses_,
+ this->break_label_, loc);
+
+ Block* b = new Block(enclosing, loc);
+
+ if (this->clauses_->empty())
+ {
+ Expression* val = this->val_;
+ if (val == NULL)
+ val = Expression::make_boolean(true, loc);
+ return Statement::make_statement(val);
+ }
+
+ Temporary_statement* val_temp;
+ if (this->val_ == NULL)
+ val_temp = NULL;
+ else
+ {
+ // var val_temp VAL_TYPE = VAL
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ this->clauses_->lower(b, val_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a switch statement.
+
+Switch_statement*
+Statement::make_switch_statement(Expression* val, source_location location)
+{
+ return new Switch_statement(val, location);
+}
+
+// Class Type_case_clauses::Type_case_clause.
+
+// Traversal.
+
+int
+Type_case_clauses::Type_case_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_default_
+ && ((traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ && Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->statements_ != NULL)
+ return this->statements_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower one clause in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+// *STMTS_LABEL, if not NULL, is a label to put at the start of the
+// statements.
+
+void
+Type_case_clauses::Type_case_clause::lower(Block* b,
+ Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label,
+ Unnamed_label** stmts_label) const
+{
+ source_location loc = this->location_;
+
+ Unnamed_label* next_case_label = NULL;
+ if (!this->is_default_)
+ {
+ Type* type = this->type_;
+
+ Expression* cond;
+ // The language permits case nil, which is of course a constant
+ // rather than a type. It will appear here as an invalid
+ // forwarding type.
+ if (type->is_nil_constant_as_type())
+ {
+ Expression* ref =
+ Expression::make_temporary_reference(descriptor_temp, loc);
+ cond = Expression::make_binary(OPERATOR_EQEQ, ref,
+ Expression::make_nil(loc),
+ loc);
+ }
+ else
+ {
+ Expression* func;
+ if (type->interface_type() == NULL)
+ {
+ // func ifacetypeeq(*descriptor, *descriptor) bool
+ static Named_object* ifacetypeeq;
+ if (ifacetypeeq == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types =
+ new Typed_identifier_list();
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ param_types->push_back(Typed_identifier("a", descriptor_type,
+ bloc));
+ param_types->push_back(Typed_identifier("b", descriptor_type,
+ bloc));
+ Typed_identifier_list* ret_types =
+ new Typed_identifier_list();
+ Type* bool_type = Type::lookup_bool_type();
+ ret_types->push_back(Typed_identifier("", bool_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL,
+ param_types,
+ ret_types,
+ bloc);
+ ifacetypeeq =
+ Named_object::make_function_declaration("ifacetypeeq", NULL,
+ fntype, bloc);
+ const char* n = "runtime.ifacetypeeq";
+ ifacetypeeq->func_declaration_value()->set_asm_name(n);
+ }
+
+ // ifacetypeeq(descriptor_temp, DESCRIPTOR)
+ func = Expression::make_func_reference(ifacetypeeq, NULL, loc);
+ }
+ else
+ {
+ // func ifaceI2Tp(*descriptor, *descriptor) bool
+ static Named_object* ifaceI2Tp;
+ if (ifaceI2Tp == NULL)
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types =
+ new Typed_identifier_list();
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ param_types->push_back(Typed_identifier("a", descriptor_type,
+ bloc));
+ param_types->push_back(Typed_identifier("b", descriptor_type,
+ bloc));
+ Typed_identifier_list* ret_types =
+ new Typed_identifier_list();
+ Type* bool_type = Type::lookup_bool_type();
+ ret_types->push_back(Typed_identifier("", bool_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL,
+ param_types,
+ ret_types,
+ bloc);
+ ifaceI2Tp =
+ Named_object::make_function_declaration("ifaceI2Tp", NULL,
+ fntype, bloc);
+ const char* n = "runtime.ifaceI2Tp";
+ ifaceI2Tp->func_declaration_value()->set_asm_name(n);
+ }
+
+ // ifaceI2Tp(descriptor_temp, DESCRIPTOR)
+ func = Expression::make_func_reference(ifaceI2Tp, NULL, loc);
+ }
+ Expression_list* params = new Expression_list();
+ params->push_back(Expression::make_type_descriptor(type, loc));
+ Expression* ref =
+ Expression::make_temporary_reference(descriptor_temp, loc);
+ params->push_back(ref);
+ cond = Expression::make_call(func, params, false, loc);
+ }
+
+ Unnamed_label* dest;
+ if (!this->is_fallthrough_)
+ {
+ // if !COND { goto NEXT_CASE_LABEL }
+ next_case_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = next_case_label;
+ cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+ }
+ else
+ {
+ // if COND { goto STMTS_LABEL }
+ gcc_assert(stmts_label != NULL);
+ if (*stmts_label == NULL)
+ *stmts_label = new Unnamed_label(UNKNOWN_LOCATION);
+ dest = *stmts_label;
+ }
+ Block* then_block = new Block(b, loc);
+ Statement* s = Statement::make_goto_unnamed_statement(dest, loc);
+ then_block->add_statement(s);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ b->add_statement(s);
+ }
+
+ if (this->statements_ != NULL
+ || (!this->is_fallthrough_
+ && stmts_label != NULL
+ && *stmts_label != NULL))
+ {
+ gcc_assert(!this->is_fallthrough_);
+ if (stmts_label != NULL && *stmts_label != NULL)
+ {
+ gcc_assert(!this->is_default_);
+ if (this->statements_ != NULL)
+ (*stmts_label)->set_location(this->statements_->start_location());
+ Statement* s = Statement::make_unnamed_label_statement(*stmts_label);
+ b->add_statement(s);
+ *stmts_label = NULL;
+ }
+ if (this->statements_ != NULL)
+ b->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+ }
+
+ if (this->is_fallthrough_)
+ gcc_assert(next_case_label == NULL);
+ else
+ {
+ source_location gloc = (this->statements_ == NULL
+ ? loc
+ : this->statements_->end_location());
+ b->add_statement(Statement::make_goto_unnamed_statement(break_label,
+ gloc));
+ if (next_case_label != NULL)
+ {
+ Statement* s =
+ Statement::make_unnamed_label_statement(next_case_label);
+ b->add_statement(s);
+ }
+ }
+}
+
+// Class Type_case_clauses.
+
+// Traversal.
+
+int
+Type_case_clauses::traverse(Traverse* traverse)
+{
+ for (Type_clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Check for duplicate types.
+
+void
+Type_case_clauses::check_duplicates() const
+{
+ typedef Unordered_set_hash(const Type*, Type_hash_identical,
+ Type_identical) Types_seen;
+ Types_seen types_seen;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t == NULL)
+ continue;
+ if (t->is_nil_constant_as_type())
+ t = Type::make_nil_type();
+ std::pair<Types_seen::iterator, bool> ins = types_seen.insert(t);
+ if (!ins.second)
+ error_at(p->location(), "duplicate type in switch");
+ }
+}
+
+// Lower the clauses in a type switch. Add statements to the block B.
+// The type descriptor we are switching on is in DESCRIPTOR_TEMP.
+// BREAK_LABEL is the label at the end of the type switch.
+
+void
+Type_case_clauses::lower(Block* b, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const
+{
+ const Type_case_clause* default_case = NULL;
+
+ Unnamed_label* stmts_label = NULL;
+ for (Type_clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ p->lower(b, descriptor_temp, break_label, &stmts_label);
+ else
+ {
+ // We are generating a series of tests, which means that we
+ // need to move the default case to the end.
+ default_case = &*p;
+ }
+ }
+ gcc_assert(stmts_label == NULL);
+
+ if (default_case != NULL)
+ default_case->lower(b, descriptor_temp, break_label, NULL);
+}
+
+// Class Type_switch_statement.
+
+// Traversal.
+
+int
+Type_switch_statement::do_traverse(Traverse* traverse)
+{
+ if (this->var_ == NULL)
+ {
+ if (this->traverse_expression(traverse, &this->expr_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->clauses_ != NULL)
+ return this->clauses_->traverse(traverse);
+ return TRAVERSE_CONTINUE;
+}
+
+// Lower a type switch statement to a series of if statements. The gc
+// compiler is able to generate a table in some cases. However, that
+// does not work for us because we may have type descriptors in
+// different shared libraries, so we can't compare them with simple
+// equality testing.
+
+Statement*
+Type_switch_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ const source_location loc = this->location();
+
+ if (this->clauses_ != NULL)
+ this->clauses_->check_duplicates();
+
+ Block* b = new Block(enclosing, loc);
+
+ Type* val_type = (this->var_ != NULL
+ ? this->var_->var_value()->type()
+ : this->expr_->type());
+
+ // var descriptor_temp DESCRIPTOR_TYPE
+ Type* descriptor_type = Type::make_type_descriptor_ptr_type();
+ Temporary_statement* descriptor_temp =
+ Statement::make_temporary(descriptor_type, NULL, loc);
+ b->add_statement(descriptor_temp);
+
+ if (val_type->interface_type() == NULL)
+ {
+ // Doing a type switch on a non-interface type. Should we issue
+ // a warning for this case?
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Expression* rhs;
+ if (val_type->is_nil_type())
+ rhs = Expression::make_nil(loc);
+ else
+ {
+ if (val_type->is_abstract())
+ val_type = val_type->make_non_abstract_type();
+ rhs = Expression::make_type_descriptor(val_type, loc);
+ }
+ Statement* s = Statement::make_assignment(lhs, rhs, loc);
+ b->add_statement(s);
+ }
+ else
+ {
+ const source_location bloc = BUILTINS_LOCATION;
+
+ // func {efacetype,ifacetype}(*interface) *descriptor
+ // FIXME: This should be inlined.
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("i", val_type, bloc));
+ Typed_identifier_list* ret_types = new Typed_identifier_list();
+ ret_types->push_back(Typed_identifier("", descriptor_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types,
+ ret_types, bloc);
+ bool is_empty = val_type->interface_type()->is_empty();
+ const char* fnname = is_empty ? "efacetype" : "ifacetype";
+ Named_object* fn =
+ Named_object::make_function_declaration(fnname, NULL, fntype, bloc);
+ const char* asm_name = (is_empty
+ ? "runtime.efacetype"
+ : "runtime.ifacetype");
+ fn->func_declaration_value()->set_asm_name(asm_name);
+
+ // descriptor_temp = ifacetype(val_temp)
+ Expression* func = Expression::make_func_reference(fn, NULL, loc);
+ Expression_list* params = new Expression_list();
+ Expression* ref;
+ if (this->var_ == NULL)
+ ref = this->expr_;
+ else
+ ref = Expression::make_var_reference(this->var_, loc);
+ params->push_back(ref);
+ Expression* call = Expression::make_call(func, params, false, loc);
+ Expression* lhs = Expression::make_temporary_reference(descriptor_temp,
+ loc);
+ Statement* s = Statement::make_assignment(lhs, call, loc);
+ b->add_statement(s);
+ }
+
+ if (this->clauses_ != NULL)
+ this->clauses_->lower(b, descriptor_temp, this->break_label());
+
+ Statement* s = Statement::make_unnamed_label_statement(this->break_label_);
+ b->add_statement(s);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label for this type switch statement, creating it
+// if necessary.
+
+Unnamed_label*
+Type_switch_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Make a type switch statement.
+
+Type_switch_statement*
+Statement::make_type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+{
+ return new Type_switch_statement(var, expr, location);
+}
+
+// Class Send_statement.
+
+// Traversal.
+
+int
+Send_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->channel_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->traverse_expression(traverse, &this->val_);
+}
+
+// Determine types.
+
+void
+Send_statement::do_determine_types()
+{
+ this->channel_->determine_type_no_context();
+ Type* type = this->channel_->type();
+ Type_context context;
+ if (type->channel_type() != NULL)
+ context.type = type->channel_type()->element_type();
+ this->val_->determine_type(&context);
+}
+
+// Check types.
+
+void
+Send_statement::do_check_types(Gogo*)
+{
+ Type* type = this->channel_->type();
+ if (type->is_error_type())
+ {
+ this->set_is_error();
+ return;
+ }
+ Channel_type* channel_type = type->channel_type();
+ if (channel_type == NULL)
+ {
+ error_at(this->location(), "left operand of %<<-%> must be channel");
+ this->set_is_error();
+ return;
+ }
+ Type* element_type = channel_type->element_type();
+ if (!Type::are_assignable(element_type, this->val_->type(), NULL))
+ {
+ this->report_error(_("incompatible types in send"));
+ return;
+ }
+ if (!channel_type->may_send())
+ {
+ this->report_error(_("invalid send on receive-only channel"));
+ return;
+ }
+}
+
+// Get a tree for a send statement.
+
+tree
+Send_statement::do_get_tree(Translate_context* context)
+{
+ tree channel = this->channel_->get_tree(context);
+ tree val = this->val_->get_tree(context);
+ if (channel == error_mark_node || val == error_mark_node)
+ return error_mark_node;
+ Channel_type* channel_type = this->channel_->type()->channel_type();
+ val = Expression::convert_for_assignment(context,
+ channel_type->element_type(),
+ this->val_->type(),
+ val,
+ this->location());
+ return Gogo::send_on_channel(channel, val, true, this->for_select_,
+ this->location());
+}
+
+// Make a send statement.
+
+Send_statement*
+Statement::make_send_statement(Expression* channel, Expression* val,
+ source_location location)
+{
+ return new Send_statement(channel, val, location);
+}
+
+// Class Select_clauses::Select_clause.
+
+// Traversal.
+
+int
+Select_clauses::Select_clause::traverse(Traverse* traverse)
+{
+ if (!this->is_lowered_
+ && (traverse->traverse_mask()
+ & (Traverse::traverse_types | Traverse::traverse_expressions)) != 0)
+ {
+ if (this->channel_ != NULL)
+ {
+ if (Expression::traverse(&this->channel_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->val_ != NULL)
+ {
+ if (Expression::traverse(&this->val_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->closed_ != NULL)
+ {
+ if (Expression::traverse(&this->closed_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ if (this->statements_ != NULL)
+ {
+ if (this->statements_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::Select_clause::lower(Gogo* gogo, Named_object* function,
+ Block* b)
+{
+ if (this->is_default_)
+ {
+ gcc_assert(this->channel_ == NULL && this->val_ == NULL);
+ this->is_lowered_ = true;
+ return;
+ }
+
+ source_location loc = this->location_;
+
+ // Evaluate the channel before the select statement.
+ Temporary_statement* channel_temp = Statement::make_temporary(NULL,
+ this->channel_,
+ loc);
+ b->add_statement(channel_temp);
+ this->channel_ = Expression::make_temporary_reference(channel_temp, loc);
+
+ // If this is a send clause, evaluate the value to send before the
+ // select statement.
+ Temporary_statement* val_temp = NULL;
+ if (this->is_send_ && !this->val_->is_constant())
+ {
+ val_temp = Statement::make_temporary(NULL, this->val_, loc);
+ b->add_statement(val_temp);
+ }
+
+ // Add the send or receive before the rest of the statements if any.
+ Block *init = new Block(b, loc);
+ Expression* ref = Expression::make_temporary_reference(channel_temp, loc);
+ if (this->is_send_)
+ {
+ Expression* ref2;
+ if (val_temp == NULL)
+ ref2 = this->val_;
+ else
+ ref2 = Expression::make_temporary_reference(val_temp, loc);
+ Send_statement* send = Statement::make_send_statement(ref, ref2, loc);
+ send->set_for_select();
+ init->add_statement(send);
+ }
+ else if (this->closed_ != NULL && !this->closed_->is_sink_expression())
+ {
+ gcc_assert(this->var_ == NULL && this->closedvar_ == NULL);
+ if (this->val_ == NULL)
+ this->val_ = Expression::make_sink(loc);
+ Statement* s = Statement::make_tuple_receive_assignment(this->val_,
+ this->closed_,
+ ref, true, loc);
+ init->add_statement(s);
+ }
+ else if (this->closedvar_ != NULL)
+ {
+ gcc_assert(this->val_ == NULL);
+ Expression* val;
+ if (this->var_ == NULL)
+ val = Expression::make_sink(loc);
+ else
+ val = Expression::make_var_reference(this->var_, loc);
+ Expression* closed = Expression::make_var_reference(this->closedvar_,
+ loc);
+ Statement* s = Statement::make_tuple_receive_assignment(val, closed, ref,
+ true, loc);
+ // We have to put S in STATEMENTS_, because that is where the
+ // variables are declared.
+ gcc_assert(this->statements_ != NULL);
+ this->statements_->add_statement_at_front(s);
+ // We have to lower STATEMENTS_ again, to lower the tuple
+ // receive assignment we just added.
+ gogo->lower_block(function, this->statements_);
+ }
+ else
+ {
+ Receive_expression* recv = Expression::make_receive(ref, loc);
+ recv->set_for_select();
+ if (this->val_ != NULL)
+ {
+ gcc_assert(this->var_ == NULL);
+ init->add_statement(Statement::make_assignment(this->val_, recv,
+ loc));
+ }
+ else if (this->var_ != NULL)
+ {
+ this->var_->var_value()->set_init(recv);
+ this->var_->var_value()->clear_type_from_chan_element();
+ }
+ else
+ {
+ init->add_statement(Statement::make_statement(recv));
+ }
+ }
+
+ // Lower any statements we just created.
+ gogo->lower_block(function, init);
+
+ if (this->statements_ != NULL)
+ init->add_statement(Statement::make_block_statement(this->statements_,
+ loc));
+
+ this->statements_ = init;
+
+ // Now all references should be handled through the statements, not
+ // through here.
+ this->is_lowered_ = true;
+ this->val_ = NULL;
+ this->var_ = NULL;
+}
+
+// Determine types.
+
+void
+Select_clauses::Select_clause::determine_types()
+{
+ gcc_assert(this->is_lowered_);
+ if (this->statements_ != NULL)
+ this->statements_->determine_types();
+}
+
+// Whether this clause may fall through to the statement which follows
+// the overall select statement.
+
+bool
+Select_clauses::Select_clause::may_fall_through() const
+{
+ if (this->statements_ == NULL)
+ return true;
+ return this->statements_->may_fall_through();
+}
+
+// Return a tree for the statements to execute.
+
+tree
+Select_clauses::Select_clause::get_statements_tree(Translate_context* context)
+{
+ if (this->statements_ == NULL)
+ return NULL_TREE;
+ return this->statements_->get_tree(context);
+}
+
+// Class Select_clauses.
+
+// Traversal.
+
+int
+Select_clauses::traverse(Traverse* traverse)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Lowering. Here we pull out the channel and the send values, to
+// enforce the order of evaluation. We also add explicit send and
+// receive statements to the clauses.
+
+void
+Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b)
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->lower(gogo, function, b);
+}
+
+// Determine types.
+
+void
+Select_clauses::determine_types()
+{
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ p->determine_types();
+}
+
+// Return whether these select clauses fall through to the statement
+// following the overall select statement.
+
+bool
+Select_clauses::may_fall_through() const
+{
+ for (Clauses::const_iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ if (p->may_fall_through())
+ return true;
+ return false;
+}
+
+// Return a tree. We build a call to
+// size_t __go_select(size_t count, _Bool has_default,
+// channel* channels, _Bool* is_send)
+//
+// There are COUNT entries in the CHANNELS and IS_SEND arrays. The
+// value in the IS_SEND array is true for send, false for receive.
+// __go_select returns an integer from 0 to COUNT, inclusive. A
+// return of 0 means that the default case should be run; this only
+// happens if HAS_DEFAULT is non-zero. Otherwise the number indicates
+// the case to run.
+
+// FIXME: This doesn't handle channels which send interface types
+// where the receiver has a static type which matches that interface.
+
+tree
+Select_clauses::get_tree(Translate_context* context,
+ Unnamed_label *break_label,
+ source_location location)
+{
+ size_t count = this->clauses_.size();
+ VEC(constructor_elt, gc)* chan_init = VEC_alloc(constructor_elt, gc, count);
+ VEC(constructor_elt, gc)* is_send_init = VEC_alloc(constructor_elt, gc,
+ count);
+ Select_clause* default_clause = NULL;
+ tree final_stmt_list = NULL_TREE;
+ tree channel_type_tree = NULL_TREE;
+
+ size_t i = 0;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (p->is_default())
+ {
+ default_clause = &*p;
+ --count;
+ continue;
+ }
+
+ if (p->channel()->type()->channel_type() == NULL)
+ {
+ // We should have given an error in the send or receive
+ // statement we created via lowering.
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ tree channel_tree = p->channel()->get_tree(context);
+ if (channel_tree == error_mark_node)
+ return error_mark_node;
+ channel_type_tree = TREE_TYPE(channel_tree);
+
+ constructor_elt* elt = VEC_quick_push(constructor_elt, chan_init, NULL);
+ elt->index = build_int_cstu(sizetype, i);
+ elt->value = channel_tree;
+
+ elt = VEC_quick_push(constructor_elt, is_send_init, NULL);
+ elt->index = build_int_cstu(sizetype, i);
+ elt->value = p->is_send() ? boolean_true_node : boolean_false_node;
+
+ ++i;
+ }
+ gcc_assert(i == count);
+
+ if (i == 0 && default_clause != NULL)
+ {
+ // There is only a default clause.
+ gcc_assert(final_stmt_list == NULL_TREE);
+ tree stmt_list = NULL_TREE;
+ append_to_statement_list(default_clause->get_statements_tree(context),
+ &stmt_list);
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+ return stmt_list;
+ }
+
+ tree pointer_chan_type_tree = (channel_type_tree == NULL_TREE
+ ? ptr_type_node
+ : build_pointer_type(channel_type_tree));
+ tree chans_arg;
+ tree pointer_boolean_type_tree = build_pointer_type(boolean_type_node);
+ tree is_sends_arg;
+
+ if (i == 0)
+ {
+ chans_arg = fold_convert_loc(location, pointer_chan_type_tree,
+ null_pointer_node);
+ is_sends_arg = fold_convert_loc(location, pointer_boolean_type_tree,
+ null_pointer_node);
+ }
+ else
+ {
+ tree index_type_tree = build_index_type(size_int(count - 1));
+ tree chan_array_type_tree = build_array_type(channel_type_tree,
+ index_type_tree);
+ tree chan_constructor = build_constructor(chan_array_type_tree,
+ chan_init);
+ tree chan_var = create_tmp_var(chan_array_type_tree, "CHAN");
+ DECL_IGNORED_P(chan_var) = 0;
+ DECL_INITIAL(chan_var) = chan_constructor;
+ DECL_SOURCE_LOCATION(chan_var) = location;
+ TREE_ADDRESSABLE(chan_var) = 1;
+ tree decl_expr = build1(DECL_EXPR, void_type_node, chan_var);
+ SET_EXPR_LOCATION(decl_expr, location);
+ append_to_statement_list(decl_expr, &final_stmt_list);
+
+ tree is_send_array_type_tree = build_array_type(boolean_type_node,
+ index_type_tree);
+ tree is_send_constructor = build_constructor(is_send_array_type_tree,
+ is_send_init);
+ tree is_send_var = create_tmp_var(is_send_array_type_tree, "ISSEND");
+ DECL_IGNORED_P(is_send_var) = 0;
+ DECL_INITIAL(is_send_var) = is_send_constructor;
+ DECL_SOURCE_LOCATION(is_send_var) = location;
+ TREE_ADDRESSABLE(is_send_var) = 1;
+ decl_expr = build1(DECL_EXPR, void_type_node, is_send_var);
+ SET_EXPR_LOCATION(decl_expr, location);
+ append_to_statement_list(decl_expr, &final_stmt_list);
+
+ chans_arg = fold_convert_loc(location, pointer_chan_type_tree,
+ build_fold_addr_expr_loc(location,
+ chan_var));
+ is_sends_arg = fold_convert_loc(location, pointer_boolean_type_tree,
+ build_fold_addr_expr_loc(location,
+ is_send_var));
+ }
+
+ static tree select_fndecl;
+ tree call = Gogo::call_builtin(&select_fndecl,
+ location,
+ "__go_select",
+ 4,
+ sizetype,
+ sizetype,
+ size_int(count),
+ boolean_type_node,
+ (default_clause == NULL
+ ? boolean_false_node
+ : boolean_true_node),
+ pointer_chan_type_tree,
+ chans_arg,
+ pointer_boolean_type_tree,
+ is_sends_arg);
+ if (call == error_mark_node)
+ return error_mark_node;
+
+ tree stmt_list = NULL_TREE;
+
+ if (default_clause != NULL)
+ this->add_clause_tree(context, 0, default_clause, break_label, &stmt_list);
+
+ i = 1;
+ for (Clauses::iterator p = this->clauses_.begin();
+ p != this->clauses_.end();
+ ++p)
+ {
+ if (!p->is_default())
+ {
+ this->add_clause_tree(context, i, &*p, break_label, &stmt_list);
+ ++i;
+ }
+ }
+
+ append_to_statement_list(break_label->get_definition(), &stmt_list);
+
+ tree switch_stmt = build3(SWITCH_EXPR, sizetype, call, stmt_list, NULL_TREE);
+ SET_EXPR_LOCATION(switch_stmt, location);
+ append_to_statement_list(switch_stmt, &final_stmt_list);
+
+ return final_stmt_list;
+}
+
+// Add the tree for CLAUSE to STMT_LIST.
+
+void
+Select_clauses::add_clause_tree(Translate_context* context, int case_index,
+ Select_clause* clause,
+ Unnamed_label* bottom_label, tree* stmt_list)
+{
+ tree label = create_artificial_label(clause->location());
+ append_to_statement_list(build3(CASE_LABEL_EXPR, void_type_node,
+ build_int_cst(sizetype, case_index),
+ NULL_TREE, label),
+ stmt_list);
+ append_to_statement_list(clause->get_statements_tree(context), stmt_list);
+ tree g = bottom_label->get_goto(clause->statements() == NULL
+ ? clause->location()
+ : clause->statements()->end_location());
+ append_to_statement_list(g, stmt_list);
+}
+
+// Class Select_statement.
+
+// Return the break label for this switch statement, creating it if
+// necessary.
+
+Unnamed_label*
+Select_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Lower a select statement. This will still return a select
+// statement, but it will be modified to implement the order of
+// evaluation rules, and to include the send and receive statements as
+// explicit statements in the clauses.
+
+Statement*
+Select_statement::do_lower(Gogo* gogo, Named_object* function,
+ Block* enclosing)
+{
+ if (this->is_lowered_)
+ return this;
+ Block* b = new Block(enclosing, this->location());
+ this->clauses_->lower(gogo, function, b);
+ this->is_lowered_ = true;
+ b->add_statement(this);
+ return Statement::make_block_statement(b, this->location());
+}
+
+// Return the tree for a select statement.
+
+tree
+Select_statement::do_get_tree(Translate_context* context)
+{
+ return this->clauses_->get_tree(context, this->break_label(),
+ this->location());
+}
+
+// Make a select statement.
+
+Select_statement*
+Statement::make_select_statement(source_location location)
+{
+ return new Select_statement(location);
+}
+
+// Class For_statement.
+
+// Traversal.
+
+int
+For_statement::do_traverse(Traverse* traverse)
+{
+ if (this->init_ != NULL)
+ {
+ if (this->init_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->cond_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->cond_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->post_ != NULL)
+ {
+ if (this->post_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a For_statement into if statements and gotos. Getting rid of
+// complex statements make it easier to handle garbage collection.
+
+Statement*
+For_statement::do_lower(Gogo*, Named_object*, Block* enclosing)
+{
+ Statement* s;
+ source_location loc = this->location();
+
+ Block* b = new Block(enclosing, this->location());
+ if (this->init_ != NULL)
+ {
+ s = Statement::make_block_statement(this->init_,
+ this->init_->start_location());
+ b->add_statement(s);
+ }
+
+ Unnamed_label* entry = NULL;
+ if (this->cond_ != NULL)
+ {
+ entry = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_goto_unnamed_statement(entry, loc));
+ }
+
+ Unnamed_label* top = new Unnamed_label(this->location());
+ b->add_statement(Statement::make_unnamed_label_statement(top));
+
+ s = Statement::make_block_statement(this->statements_,
+ this->statements_->start_location());
+ b->add_statement(s);
+
+ source_location end_loc = this->statements_->end_location();
+
+ Unnamed_label* cont = this->continue_label_;
+ if (cont != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(cont));
+
+ if (this->post_ != NULL)
+ {
+ s = Statement::make_block_statement(this->post_,
+ this->post_->start_location());
+ b->add_statement(s);
+ end_loc = this->post_->end_location();
+ }
+
+ if (this->cond_ == NULL)
+ b->add_statement(Statement::make_goto_unnamed_statement(top, end_loc));
+ else
+ {
+ b->add_statement(Statement::make_unnamed_label_statement(entry));
+
+ source_location cond_loc = this->cond_->location();
+ Block* then_block = new Block(b, cond_loc);
+ s = Statement::make_goto_unnamed_statement(top, cond_loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(this->cond_, then_block, NULL, cond_loc);
+ b->add_statement(s);
+ }
+
+ Unnamed_label* brk = this->break_label_;
+ if (brk != NULL)
+ b->add_statement(Statement::make_unnamed_label_statement(brk));
+
+ b->set_end_location(end_loc);
+
+ return Statement::make_block_statement(b, loc);
+}
+
+// Return the break label, creating it if necessary.
+
+Unnamed_label*
+For_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Set the break and continue labels a for statement. This is used
+// when lowering a for range statement.
+
+void
+For_statement::set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label)
+{
+ gcc_assert(this->break_label_ == NULL && this->continue_label_ == NULL);
+ this->break_label_ = break_label;
+ this->continue_label_ = continue_label;
+}
+
+// Make a for statement.
+
+For_statement*
+Statement::make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+{
+ return new For_statement(init, cond, post, location);
+}
+
+// Class For_range_statement.
+
+// Traversal.
+
+int
+For_range_statement::do_traverse(Traverse* traverse)
+{
+ if (this->traverse_expression(traverse, &this->index_var_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->value_var_ != NULL)
+ {
+ if (this->traverse_expression(traverse, &this->value_var_)
+ == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ if (this->traverse_expression(traverse, &this->range_) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return this->statements_->traverse(traverse);
+}
+
+// Lower a for range statement. For simplicity we lower this into a
+// for statement, which will then be lowered in turn to goto
+// statements.
+
+Statement*
+For_range_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing)
+{
+ Type* range_type = this->range_->type();
+ if (range_type->points_to() != NULL
+ && range_type->points_to()->array_type() != NULL
+ && !range_type->points_to()->is_open_array_type())
+ range_type = range_type->points_to();
+
+ Type* index_type;
+ Type* value_type = NULL;
+ if (range_type->array_type() != NULL)
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = range_type->array_type()->element_type();
+ }
+ else if (range_type->is_string_type())
+ {
+ index_type = Type::lookup_integer_type("int");
+ value_type = index_type;
+ }
+ else if (range_type->map_type() != NULL)
+ {
+ index_type = range_type->map_type()->key_type();
+ value_type = range_type->map_type()->val_type();
+ }
+ else if (range_type->channel_type() != NULL)
+ {
+ index_type = range_type->channel_type()->element_type();
+ if (this->value_var_ != NULL)
+ {
+ if (!this->value_var_->type()->is_error_type())
+ this->report_error(_("too many variables for range clause "
+ "with channel"));
+ return Statement::make_error_statement(this->location());
+ }
+ }
+ else
+ {
+ this->report_error(_("range clause must have "
+ "array, slice, setring, map, or channel type"));
+ return Statement::make_error_statement(this->location());
+ }
+
+ source_location loc = this->location();
+ Block* temp_block = new Block(enclosing, loc);
+
+ Named_object* range_object = NULL;
+ Temporary_statement* range_temp = NULL;
+ Var_expression* ve = this->range_->var_expression();
+ if (ve != NULL)
+ range_object = ve->named_object();
+ else
+ {
+ range_temp = Statement::make_temporary(NULL, this->range_, loc);
+ temp_block->add_statement(range_temp);
+ }
+
+ Temporary_statement* index_temp = Statement::make_temporary(index_type,
+ NULL, loc);
+ temp_block->add_statement(index_temp);
+
+ Temporary_statement* value_temp = NULL;
+ if (this->value_var_ != NULL)
+ {
+ value_temp = Statement::make_temporary(value_type, NULL, loc);
+ temp_block->add_statement(value_temp);
+ }
+
+ Block* body = new Block(temp_block, loc);
+
+ Block* init;
+ Expression* cond;
+ Block* iter_init;
+ Block* post;
+
+ // Arrange to do a loop appropriate for the type. We will produce
+ // for INIT ; COND ; POST {
+ // ITER_INIT
+ // INDEX = INDEX_TEMP
+ // VALUE = VALUE_TEMP // If there is a value
+ // original statements
+ // }
+
+ if (range_type->array_type() != NULL)
+ this->lower_range_array(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->is_string_type())
+ this->lower_range_string(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->map_type() != NULL)
+ this->lower_range_map(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else if (range_type->channel_type() != NULL)
+ this->lower_range_channel(gogo, temp_block, body, range_object, range_temp,
+ index_temp, value_temp, &init, &cond, &iter_init,
+ &post);
+ else
+ gcc_unreachable();
+
+ if (iter_init != NULL)
+ body->add_statement(Statement::make_block_statement(iter_init, loc));
+
+ Statement* assign;
+ Expression* index_ref = Expression::make_temporary_reference(index_temp, loc);
+ if (this->value_var_ == NULL)
+ {
+ assign = Statement::make_assignment(this->index_var_, index_ref, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(this->index_var_);
+ lhs->push_back(this->value_var_);
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(index_ref);
+ rhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ assign = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ body->add_statement(assign);
+
+ body->add_statement(Statement::make_block_statement(this->statements_, loc));
+
+ body->set_end_location(this->statements_->end_location());
+
+ For_statement* loop = Statement::make_for_statement(init, cond, post,
+ this->location());
+ loop->add_statements(body);
+ loop->set_break_continue_labels(this->break_label_, this->continue_label_);
+
+ temp_block->add_statement(loop);
+
+ return Statement::make_block_statement(temp_block, loc);
+}
+
+// Return a reference to the range, which may be in RANGE_OBJECT or in
+// RANGE_TEMP.
+
+Expression*
+For_range_statement::make_range_ref(Named_object* range_object,
+ Temporary_statement* range_temp,
+ source_location loc)
+{
+ if (range_object != NULL)
+ return Expression::make_var_reference(range_object, loc);
+ else
+ return Expression::make_temporary_reference(range_temp, loc);
+}
+
+// Return a call to the predeclared function FUNCNAME passing a
+// reference to the temporary variable ARG.
+
+Expression*
+For_range_statement::call_builtin(Gogo* gogo, const char* funcname,
+ Expression* arg,
+ source_location loc)
+{
+ Named_object* no = gogo->lookup_global(funcname);
+ gcc_assert(no != NULL && no->is_function_declaration());
+ Expression* func = Expression::make_func_reference(no, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(arg);
+ return Expression::make_call(func, params, false, loc);
+}
+
+// Lower a for range over an array or slice.
+
+void
+For_range_statement::lower_range_array(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // len_temp := len(range)
+ // for index_temp = 0; index_temp < len_temp; index_temp++ {
+ // value_temp = range[index_temp]
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var len_temp int
+ // len_temp = len(range)
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Expression* ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* len_call = this->call_builtin(gogo, "len", ref, loc);
+ Temporary_statement* len_temp = Statement::make_temporary(index_temp->type(),
+ len_call, loc);
+ init->add_statement(len_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+ init->add_statement(s);
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // index_temp < len_temp
+
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(len_temp, loc);
+ Expression* lt = Expression::make_binary(OPERATOR_LT, ref, ref2, loc);
+
+ *pcond = lt;
+
+ // Set *PITER_INIT to
+ // value_temp = range[index_temp]
+
+ Block* iter_init = NULL;
+ if (value_temp != NULL)
+ {
+ iter_init = new Block(body_block, loc);
+
+ ref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* ref2 = Expression::make_temporary_reference(index_temp, loc);
+ Expression* index = Expression::make_index(ref, ref2, NULL, loc);
+
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ s = Statement::make_assignment(ref, index, loc);
+
+ iter_init->add_statement(s);
+ }
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp++
+
+ Block* post = new Block(enclosing, loc);
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ s = Statement::make_inc_statement(ref);
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a string.
+
+void
+For_range_statement::lower_range_string(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // var next_index_temp int
+ // for index_temp = 0; ; index_temp = next_index_temp {
+ // next_index_temp, value_temp = stringiter2(range, index_temp)
+ // if next_index_temp == 0 {
+ // break
+ // }
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var next_index_temp int
+ // index_temp = 0
+
+ Block* init = new Block(enclosing, loc);
+
+ Temporary_statement* next_index_temp =
+ Statement::make_temporary(index_temp->type(), NULL, loc);
+ init->add_statement(next_index_temp);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+
+ Expression* ref = Expression::make_temporary_reference(index_temp, loc);
+ Statement* s = Statement::make_assignment(ref, zexpr, loc);
+
+ init->add_statement(s);
+ *pinit = init;
+
+ // The loop has no condition.
+
+ *pcond = NULL;
+
+ // Set *PITER_INIT to
+ // next_index_temp = runtime.stringiter(range, index_temp)
+ // or
+ // next_index_temp, value_temp = runtime.stringiter2(range, index_temp)
+ // followed by
+ // if next_index_temp == 0 {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Named_object* no;
+ if (value_temp == NULL)
+ {
+ static Named_object* stringiter;
+ if (stringiter == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+ Type* int_type = gogo->lookup_global("int")->type_value();
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("s", Type::make_string_type(),
+ bloc));
+ params->push_back(Typed_identifier("k", int_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", int_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, params,
+ results, bloc);
+ stringiter = Named_object::make_function_declaration("stringiter",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.stringiter";
+ stringiter->func_declaration_value()->set_asm_name(n);
+ }
+ no = stringiter;
+ }
+ else
+ {
+ static Named_object* stringiter2;
+ if (stringiter2 == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+ Type* int_type = gogo->lookup_global("int")->type_value();
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("s", Type::make_string_type(),
+ bloc));
+ params->push_back(Typed_identifier("k", int_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", int_type, bloc));
+ results->push_back(Typed_identifier("", int_type, bloc));
+
+ Function_type* fntype = Type::make_function_type(NULL, params,
+ results, bloc);
+ stringiter2 = Named_object::make_function_declaration("stringiter",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.stringiter2";
+ stringiter2->func_declaration_value()->set_asm_name(n);
+ }
+ no = stringiter2;
+ }
+
+ Expression* func = Expression::make_func_reference(no, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->make_range_ref(range_object, range_temp, loc));
+ params->push_back(Expression::make_temporary_reference(index_temp, loc));
+ Call_expression* call = Expression::make_call(func, params, false, loc);
+
+ if (value_temp == NULL)
+ {
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(ref, call, loc);
+ }
+ else
+ {
+ Expression_list* lhs = new Expression_list();
+ lhs->push_back(Expression::make_temporary_reference(next_index_temp,
+ loc));
+ lhs->push_back(Expression::make_temporary_reference(value_temp, loc));
+
+ Expression_list* rhs = new Expression_list();
+ rhs->push_back(Expression::make_call_result(call, 0));
+ rhs->push_back(Expression::make_call_result(call, 1));
+
+ s = Statement::make_tuple_assignment(lhs, rhs, loc);
+ }
+ iter_init->add_statement(s);
+
+ ref = Expression::make_temporary_reference(next_index_temp, loc);
+ zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+ Expression* equals = Expression::make_binary(OPERATOR_EQEQ, ref, zexpr, loc);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ s = Statement::make_if_statement(equals, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // index_temp = next_index_temp
+
+ Block* post = new Block(enclosing, loc);
+
+ Expression* lhs = Expression::make_temporary_reference(index_temp, loc);
+ Expression* rhs = Expression::make_temporary_reference(next_index_temp, loc);
+ s = Statement::make_assignment(lhs, rhs, loc);
+
+ post->add_statement(s);
+ *ppost = post;
+}
+
+// Lower a for range over a map.
+
+void
+For_range_statement::lower_range_map(Gogo* gogo,
+ Block* enclosing,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ source_location loc = this->location();
+
+ // The runtime uses a struct to handle ranges over a map. The
+ // struct is four pointers long. The first pointer is NULL when we
+ // have completed the iteration.
+
+ // The loop we generate:
+ // var hiter map_iteration_struct
+ // for mapiterinit(range, &hiter); hiter[0] != nil; mapiternext(&hiter) {
+ // mapiter2(hiter, &index_temp, &value_temp)
+ // index = index_temp
+ // value = value_temp
+ // original body
+ // }
+
+ // Set *PINIT to
+ // var hiter map_iteration_struct
+ // runtime.mapiterinit(range, &hiter)
+
+ Block* init = new Block(enclosing, loc);
+
+ const unsigned long map_iteration_size = 4;
+
+ mpz_t ival;
+ mpz_init_set_ui(ival, map_iteration_size);
+ Expression* iexpr = Expression::make_integer(&ival, NULL, loc);
+ mpz_clear(ival);
+
+ Type* byte_type = gogo->lookup_global("byte")->type_value();
+ Type* ptr_type = Type::make_pointer_type(byte_type);
+
+ Type* map_iteration_type = Type::make_array_type(ptr_type, iexpr);
+ Type* map_iteration_ptr = Type::make_pointer_type(map_iteration_type);
+
+ Temporary_statement* hiter = Statement::make_temporary(map_iteration_type,
+ NULL, loc);
+ init->add_statement(hiter);
+
+ source_location bloc = BUILTINS_LOCATION;
+ Typed_identifier_list* param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("map", this->range_->type(), bloc));
+ param_types->push_back(Typed_identifier("it", map_iteration_ptr, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, param_types, NULL,
+ bloc);
+
+ Named_object* mapiterinit =
+ Named_object::make_function_declaration("mapiterinit", NULL, fntype, bloc);
+ const char* n = "runtime.mapiterinit";
+ mapiterinit->func_declaration_value()->set_asm_name(n);
+
+ Expression* func = Expression::make_func_reference(mapiterinit, NULL, loc);
+ Expression_list* params = new Expression_list();
+ params->push_back(this->make_range_ref(range_object, range_temp, loc));
+ Expression* ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ Expression* call = Expression::make_call(func, params, false, loc);
+ init->add_statement(Statement::make_statement(call));
+
+ *pinit = init;
+
+ // Set *PCOND to
+ // hiter[0] != nil
+
+ ref = Expression::make_temporary_reference(hiter, loc);
+
+ mpz_t zval;
+ mpz_init_set_ui(zval, 0UL);
+ Expression* zexpr = Expression::make_integer(&zval, NULL, loc);
+ mpz_clear(zval);
+
+ Expression* index = Expression::make_index(ref, zexpr, NULL, loc);
+
+ Expression* ne = Expression::make_binary(OPERATOR_NOTEQ, index,
+ Expression::make_nil(loc),
+ loc);
+
+ *pcond = ne;
+
+ // Set *PITER_INIT to
+ // mapiter1(hiter, &index_temp)
+ // or
+ // mapiter2(hiter, &index_temp, &value_temp)
+
+ Block* iter_init = new Block(body_block, loc);
+
+ param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("hiter", map_iteration_ptr, bloc));
+ Type* pkey_type = Type::make_pointer_type(index_temp->type());
+ param_types->push_back(Typed_identifier("key", pkey_type, bloc));
+ if (value_temp != NULL)
+ {
+ Type* pval_type = Type::make_pointer_type(value_temp->type());
+ param_types->push_back(Typed_identifier("val", pval_type, bloc));
+ }
+ fntype = Type::make_function_type(NULL, param_types, NULL, bloc);
+ n = value_temp == NULL ? "mapiter1" : "mapiter2";
+ Named_object* mapiter = Named_object::make_function_declaration(n, NULL,
+ fntype, bloc);
+ n = value_temp == NULL ? "runtime.mapiter1" : "runtime.mapiter2";
+ mapiter->func_declaration_value()->set_asm_name(n);
+
+ func = Expression::make_func_reference(mapiter, NULL, loc);
+ params = new Expression_list();
+ ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ ref = Expression::make_temporary_reference(index_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ if (value_temp != NULL)
+ {
+ ref = Expression::make_temporary_reference(value_temp, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ }
+ call = Expression::make_call(func, params, false, loc);
+ iter_init->add_statement(Statement::make_statement(call));
+
+ *piter_init = iter_init;
+
+ // Set *PPOST to
+ // mapiternext(&hiter)
+
+ Block* post = new Block(enclosing, loc);
+
+ static Named_object* mapiternext;
+ if (mapiternext == NULL)
+ {
+ param_types = new Typed_identifier_list();
+ param_types->push_back(Typed_identifier("it", map_iteration_ptr, bloc));
+ fntype = Type::make_function_type(NULL, param_types, NULL, bloc);
+ mapiternext = Named_object::make_function_declaration("mapiternext",
+ NULL, fntype,
+ bloc);
+ const char* n = "runtime.mapiternext";
+ mapiternext->func_declaration_value()->set_asm_name(n);
+ }
+
+ func = Expression::make_func_reference(mapiternext, NULL, loc);
+ params = new Expression_list();
+ ref = Expression::make_temporary_reference(hiter, loc);
+ params->push_back(Expression::make_unary(OPERATOR_AND, ref, loc));
+ call = Expression::make_call(func, params, false, loc);
+ post->add_statement(Statement::make_statement(call));
+
+ *ppost = post;
+}
+
+// Lower a for range over a channel.
+
+void
+For_range_statement::lower_range_channel(Gogo*,
+ Block*,
+ Block* body_block,
+ Named_object* range_object,
+ Temporary_statement* range_temp,
+ Temporary_statement* index_temp,
+ Temporary_statement* value_temp,
+ Block** pinit,
+ Expression** pcond,
+ Block** piter_init,
+ Block** ppost)
+{
+ gcc_assert(value_temp == NULL);
+
+ source_location loc = this->location();
+
+ // The loop we generate:
+ // for {
+ // index_temp, ok_temp = <-range
+ // if !ok_temp {
+ // break
+ // }
+ // index = index_temp
+ // original body
+ // }
+
+ // We have no initialization code, no condition, and no post code.
+
+ *pinit = NULL;
+ *pcond = NULL;
+ *ppost = NULL;
+
+ // Set *PITER_INIT to
+ // index_temp, ok_temp = <-range
+ // if !ok_temp {
+ // break
+ // }
+
+ Block* iter_init = new Block(body_block, loc);
+
+ Temporary_statement* ok_temp =
+ Statement::make_temporary(Type::lookup_bool_type(), NULL, loc);
+ iter_init->add_statement(ok_temp);
+
+ Expression* cref = this->make_range_ref(range_object, range_temp, loc);
+ Expression* iref = Expression::make_temporary_reference(index_temp, loc);
+ Expression* oref = Expression::make_temporary_reference(ok_temp, loc);
+ Statement* s = Statement::make_tuple_receive_assignment(iref, oref, cref,
+ false, loc);
+ iter_init->add_statement(s);
+
+ Block* then_block = new Block(iter_init, loc);
+ s = Statement::make_break_statement(this->break_label(), loc);
+ then_block->add_statement(s);
+
+ oref = Expression::make_temporary_reference(ok_temp, loc);
+ Expression* cond = Expression::make_unary(OPERATOR_NOT, oref, loc);
+ s = Statement::make_if_statement(cond, then_block, NULL, loc);
+ iter_init->add_statement(s);
+
+ *piter_init = iter_init;
+}
+
+// Return the break LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::break_label()
+{
+ if (this->break_label_ == NULL)
+ this->break_label_ = new Unnamed_label(this->location());
+ return this->break_label_;
+}
+
+// Return the continue LABEL_EXPR.
+
+Unnamed_label*
+For_range_statement::continue_label()
+{
+ if (this->continue_label_ == NULL)
+ this->continue_label_ = new Unnamed_label(this->location());
+ return this->continue_label_;
+}
+
+// Make a for statement with a range clause.
+
+For_range_statement*
+Statement::make_for_range_statement(Expression* index_var,
+ Expression* value_var,
+ Expression* range,
+ source_location location)
+{
+ return new For_range_statement(index_var, value_var, range, location);
+}
--- /dev/null
+// statements.h -- Go frontend statements. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_STATEMENTS_H
+#define GO_STATEMENTS_H
+
+#include "operator.h"
+
+class Gogo;
+class Traverse;
+class Block;
+class Function;
+class Unnamed_label;
+class Temporary_statement;
+class Variable_declaration_statement;
+class Return_statement;
+class Thunk_statement;
+class Label_statement;
+class For_statement;
+class For_range_statement;
+class Switch_statement;
+class Type_switch_statement;
+class Select_statement;
+class Variable;
+class Named_object;
+class Label;
+class Translate_context;
+class Expression;
+class Expression_list;
+class Struct_type;
+class Call_expression;
+class Map_index_expression;
+class Receive_expression;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Typed_identifier_list;
+
+// This class is used to traverse assignments made by a statement
+// which makes assignments.
+
+class Traverse_assignments
+{
+ public:
+ Traverse_assignments()
+ { }
+
+ virtual ~Traverse_assignments()
+ { }
+
+ // This is called for a variable initialization.
+ virtual void
+ initialize_variable(Named_object*) = 0;
+
+ // This is called for each assignment made by the statement. PLHS
+ // points to the left hand side, and PRHS points to the right hand
+ // side. PRHS may be NULL if there is no associated expression, as
+ // in the bool set by a non-blocking receive.
+ virtual void
+ assignment(Expression** plhs, Expression** prhs) = 0;
+
+ // This is called for each expression which is not passed to the
+ // assignment function. This is used for some of the statements
+ // which assign two values, for which there is no expression which
+ // describes the value. For ++ and -- the value is passed to both
+ // the assignment method and the rhs method. IS_STORED is true if
+ // this value is being stored directly. It is false if the value is
+ // computed but not stored. IS_LOCAL is true if the value is being
+ // stored in a local variable or this is being called by a return
+ // statement.
+ virtual void
+ value(Expression**, bool is_stored, bool is_local) = 0;
+};
+
+// A single statement.
+
+class Statement
+{
+ public:
+ // The types of statements.
+ enum Statement_classification
+ {
+ STATEMENT_ERROR,
+ STATEMENT_VARIABLE_DECLARATION,
+ STATEMENT_TEMPORARY,
+ STATEMENT_ASSIGNMENT,
+ STATEMENT_EXPRESSION,
+ STATEMENT_BLOCK,
+ STATEMENT_GO,
+ STATEMENT_DEFER,
+ STATEMENT_RETURN,
+ STATEMENT_BREAK_OR_CONTINUE,
+ STATEMENT_GOTO,
+ STATEMENT_GOTO_UNNAMED,
+ STATEMENT_LABEL,
+ STATEMENT_UNNAMED_LABEL,
+ STATEMENT_IF,
+ STATEMENT_CONSTANT_SWITCH,
+ STATEMENT_SELECT,
+
+ // These statements types are created by the parser, but they
+ // disappear during the lowering pass.
+ STATEMENT_ASSIGNMENT_OPERATION,
+ STATEMENT_TUPLE_ASSIGNMENT,
+ STATEMENT_TUPLE_MAP_ASSIGNMENT,
+ STATEMENT_MAP_ASSIGNMENT,
+ STATEMENT_TUPLE_RECEIVE_ASSIGNMENT,
+ STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT,
+ STATEMENT_INCDEC,
+ STATEMENT_FOR,
+ STATEMENT_FOR_RANGE,
+ STATEMENT_SWITCH,
+ STATEMENT_TYPE_SWITCH
+ };
+
+ Statement(Statement_classification, source_location);
+
+ virtual ~Statement();
+
+ // Make a variable declaration.
+ static Statement*
+ make_variable_declaration(Named_object*);
+
+ // Make a statement which creates a temporary variable and
+ // initializes it to an expression. The block is used if the
+ // temporary variable has to be explicitly destroyed; the variable
+ // must still be added to the block. References to the temporary
+ // variable may be constructed using make_temporary_reference.
+ // Either the type or the initialization expression may be NULL, but
+ // not both.
+ static Temporary_statement*
+ make_temporary(Type*, Expression*, source_location);
+
+ // Make an assignment statement.
+ static Statement*
+ make_assignment(Expression*, Expression*, source_location);
+
+ // Make an assignment operation (+=, etc.).
+ static Statement*
+ make_assignment_operation(Operator, Expression*, Expression*,
+ source_location);
+
+ // Make a tuple assignment statement.
+ static Statement*
+ make_tuple_assignment(Expression_list*, Expression_list*, source_location);
+
+ // Make an assignment from a map index to a pair of variables.
+ static Statement*
+ make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression*, source_location);
+
+ // Make a statement which assigns a pair of values to a map.
+ static Statement*
+ make_map_assignment(Expression*, Expression* val,
+ Expression* should_set, source_location);
+
+ // Make an assignment from a nonblocking receive to a pair of
+ // variables.
+ static Statement*
+ make_tuple_receive_assignment(Expression* val, Expression* success,
+ Expression* channel, source_location);
+
+ // Make an assignment from a type guard to a pair of variables.
+ static Statement*
+ make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location);
+
+ // Make an expression statement from an Expression.
+ static Statement*
+ make_statement(Expression*);
+
+ // Make a block statement from a Block. This is an embedded list of
+ // statements which may also include variable definitions.
+ static Statement*
+ make_block_statement(Block*, source_location);
+
+ // Make an increment statement.
+ static Statement*
+ make_inc_statement(Expression*);
+
+ // Make a decrement statement.
+ static Statement*
+ make_dec_statement(Expression*);
+
+ // Make a go statement.
+ static Statement*
+ make_go_statement(Call_expression* call, source_location);
+
+ // Make a defer statement.
+ static Statement*
+ make_defer_statement(Call_expression* call, source_location);
+
+ // Make a return statement.
+ static Statement*
+ make_return_statement(const Typed_identifier_list*, Expression_list*,
+ source_location);
+
+ // Make a break statement.
+ static Statement*
+ make_break_statement(Unnamed_label* label, source_location);
+
+ // Make a continue statement.
+ static Statement*
+ make_continue_statement(Unnamed_label* label, source_location);
+
+ // Make a goto statement.
+ static Statement*
+ make_goto_statement(Label* label, source_location);
+
+ // Make a goto statement to an unnamed label.
+ static Statement*
+ make_goto_unnamed_statement(Unnamed_label* label, source_location);
+
+ // Make a label statement--where the label is defined.
+ static Statement*
+ make_label_statement(Label* label, source_location);
+
+ // Make an unnamed label statement--where the label is defined.
+ static Statement*
+ make_unnamed_label_statement(Unnamed_label* label);
+
+ // Make an if statement.
+ static Statement*
+ make_if_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location);
+
+ // Make a switch statement.
+ static Switch_statement*
+ make_switch_statement(Expression* switch_val, source_location);
+
+ // Make a type switch statement.
+ static Type_switch_statement*
+ make_type_switch_statement(Named_object* var, Expression*, source_location);
+
+ // Make a select statement.
+ static Select_statement*
+ make_select_statement(source_location);
+
+ // Make a for statement.
+ static For_statement*
+ make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location);
+
+ // Make a for statement with a range clause.
+ static For_range_statement*
+ make_for_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location);
+
+ // Return the statement classification.
+ Statement_classification
+ classification() const
+ { return this->classification_; }
+
+ // Get the statement location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traverse the tree.
+ int
+ traverse(Block*, size_t* index, Traverse*);
+
+ // Traverse the contents of this statement--the expressions and
+ // statements which it contains.
+ int
+ traverse_contents(Traverse*);
+
+ // If this statement assigns some values, it calls a function for
+ // each value to which this statement assigns a value, and returns
+ // true. If this statement does not assign any values, it returns
+ // false.
+ bool
+ traverse_assignments(Traverse_assignments* tassign);
+
+ // Lower a statement. This is called immediately after parsing to
+ // simplify statements for further processing. It returns the same
+ // Statement or a new one. BLOCK is the block containing this
+ // statement.
+ Statement*
+ lower(Gogo* gogo, Block* block)
+ { return this->do_lower(gogo, block); }
+
+ // Set type information for unnamed constants.
+ void
+ determine_types();
+
+ // Check types in a statement. This simply checks that any
+ // expressions used by the statement have the right type.
+ void
+ check_types(Gogo* gogo)
+ { this->do_check_types(gogo); }
+
+ // Return whether this is a block statement.
+ bool
+ is_block_statement() const
+ { return this->classification_ == STATEMENT_BLOCK; }
+
+ // If this is a variable declaration statement, return it.
+ // Otherwise return NULL.
+ Variable_declaration_statement*
+ variable_declaration_statement()
+ {
+ return this->convert<Variable_declaration_statement,
+ STATEMENT_VARIABLE_DECLARATION>();
+ }
+
+ // If this is a return statement, return it. Otherwise return NULL.
+ Return_statement*
+ return_statement()
+ { return this->convert<Return_statement, STATEMENT_RETURN>(); }
+
+ // If this is a thunk statement (a go or defer statement), return
+ // it. Otherwise return NULL.
+ Thunk_statement*
+ thunk_statement();
+
+ // If this is a label statement, return it. Otherwise return NULL.
+ Label_statement*
+ label_statement()
+ { return this->convert<Label_statement, STATEMENT_LABEL>(); }
+
+ // If this is a for statement, return it. Otherwise return NULL.
+ For_statement*
+ for_statement()
+ { return this->convert<For_statement, STATEMENT_FOR>(); }
+
+ // If this is a for statement over a range clause, return it.
+ // Otherwise return NULL.
+ For_range_statement*
+ for_range_statement()
+ { return this->convert<For_range_statement, STATEMENT_FOR_RANGE>(); }
+
+ // If this is a switch statement, return it. Otherwise return NULL.
+ Switch_statement*
+ switch_statement()
+ { return this->convert<Switch_statement, STATEMENT_SWITCH>(); }
+
+ // If this is a type switch statement, return it. Otherwise return
+ // NULL.
+ Type_switch_statement*
+ type_switch_statement()
+ { return this->convert<Type_switch_statement, STATEMENT_TYPE_SWITCH>(); }
+
+ // If this is a select statement, return it. Otherwise return NULL.
+ Select_statement*
+ select_statement()
+ { return this->convert<Select_statement, STATEMENT_SELECT>(); }
+
+ // Return true if this statement may fall through--if after
+ // executing this statement we may go on to execute the following
+ // statement, if any.
+ bool
+ may_fall_through() const
+ { return this->do_may_fall_through(); }
+
+ // Return the tree for a statement. BLOCK is the enclosing block.
+ tree
+ get_tree(Translate_context*);
+
+ protected:
+ // Implemented by child class: traverse the tree.
+ virtual int
+ do_traverse(Traverse*) = 0;
+
+ // Implemented by child class: traverse assignments. Any statement
+ // which includes an assignment should implement this.
+ virtual bool
+ do_traverse_assignments(Traverse_assignments*)
+ { return false; }
+
+ // Implemented by the child class: lower this statement to a simpler
+ // one.
+ virtual Statement*
+ do_lower(Gogo*, Block*)
+ { return this; }
+
+ // Implemented by child class: set type information for unnamed
+ // constants. Any statement which includes an expression needs to
+ // implement this.
+ virtual void
+ do_determine_types()
+ { }
+
+ // Implemented by child class: check types of expressions used in a
+ // statement.
+ virtual void
+ do_check_types(Gogo*)
+ { }
+
+ // Implemented by child class: return true if this statement may
+ // fall through.
+ virtual bool
+ do_may_fall_through() const
+ { return true; }
+
+ // Implemented by child class: return a tree.
+ virtual tree
+ do_get_tree(Translate_context*) = 0;
+
+ // Traverse an expression in a statement.
+ int
+ traverse_expression(Traverse*, Expression**);
+
+ // Traverse an expression list in a statement. The Expression_list
+ // may be NULL.
+ int
+ traverse_expression_list(Traverse*, Expression_list*);
+
+ // Traverse a type in a statement.
+ int
+ traverse_type(Traverse*, Type*);
+
+ // Build a tree node with one operand, setting the location. The
+ // first operand really has type "enum tree_code", but that enum is
+ // not defined here.
+ tree
+ build_stmt_1(int tree_code_value, tree);
+
+ // For children to call when they detect that they are in error.
+ void
+ set_is_error();
+
+ // For children to call to report an error conveniently.
+ void
+ report_error(const char*);
+
+ // For children to return an error statement from lower().
+ static Statement*
+ make_error_statement(source_location);
+
+ private:
+ // Convert to the desired statement classification, or return NULL.
+ // This is a controlled dynamic cast.
+ template<typename Statement_class, Statement_classification sc>
+ Statement_class*
+ convert()
+ {
+ return (this->classification_ == sc
+ ? static_cast<Statement_class*>(this)
+ : NULL);
+ }
+
+ template<typename Statement_class, Statement_classification sc>
+ const Statement_class*
+ convert() const
+ {
+ return (this->classification_ == sc
+ ? static_cast<const Statement_class*>(this)
+ : NULL);
+ }
+
+ // The statement classification.
+ Statement_classification classification_;
+ // The location in the input file of the start of this statement.
+ source_location location_;
+};
+
+// A statement which creates and initializes a temporary variable.
+
+class Temporary_statement : public Statement
+{
+ public:
+ Temporary_statement(Type* type, Expression* init, source_location location)
+ : Statement(STATEMENT_TEMPORARY, location),
+ type_(type), init_(init), decl_(NULL), is_address_taken_(false)
+ { }
+
+ // Return the type of the temporary variable.
+ Type*
+ type() const;
+
+ // Return the initialization expression.
+ Expression*
+ init() const
+ { return this->init_; }
+
+ // Record that something takes the address of this temporary
+ // variable.
+ void
+ set_is_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Return the tree for the temporary variable itself. This should
+ // not be called until after the statement itself has been expanded.
+ tree
+ get_decl() const
+ {
+ gcc_assert(this->decl_ != NULL);
+ return this->decl_;
+ }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type of the temporary variable.
+ Type* type_;
+ // The initial value of the temporary variable. This may be NULL.
+ Expression* init_;
+ // The DECL for the temporary variable.
+ tree decl_;
+ // True if something takes the address of this temporary variable.
+ bool is_address_taken_;
+};
+
+// A variable declaration. This marks the point in the code where a
+// variable is declared. The Variable is also attached to a Block.
+
+class Variable_declaration_statement : public Statement
+{
+ public:
+ Variable_declaration_statement(Named_object* var);
+
+ // The variable being declared.
+ Named_object*
+ var()
+ { return this->var_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Named_object* var_;
+};
+
+// A return statement.
+
+class Return_statement : public Statement
+{
+ public:
+ Return_statement(const Typed_identifier_list* results, Expression_list* vals,
+ source_location location)
+ : Statement(STATEMENT_RETURN, location),
+ results_(results), vals_(vals)
+ { }
+
+ // The list of values being returned. This may be NULL.
+ const Expression_list*
+ vals() const
+ { return this->vals_; }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression_list(traverse, this->vals_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The result types of the function we are returning from. This is
+ // here because in some of the traversals it is inconvenient to get
+ // it.
+ const Typed_identifier_list* results_;
+ // Return values. This may be NULL.
+ Expression_list* vals_;
+};
+
+// Select_clauses holds the clauses of a select statement. This is
+// built by the parser.
+
+class Select_clauses
+{
+ public:
+ Select_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. IS_SEND is true if this is a send clause,
+ // false for a receive clause. For a send clause CHANNEL is the
+ // channel and VAL is the value to send. For a receive clause
+ // CHANNEL is the channel and VAL is either NULL or a Var_expression
+ // for the variable to set; if VAL is NULL, VAR may be a variable
+ // which is initialized with the received value. IS_DEFAULT is true
+ // if this is the default clause. STATEMENTS is the list of
+ // statements to execute.
+ void
+ add(bool is_send, Expression* channel, Expression* val, Named_object* var,
+ bool is_default, Block* statements, source_location location)
+ {
+ this->clauses_.push_back(Select_clause(is_send, channel, val, var,
+ is_default, statements, location));
+ }
+
+ // Traverse the select clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Whether the select clauses may fall through to the statement
+ // which follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Return a tree implementing the select statement.
+ tree
+ get_tree(Translate_context*, Unnamed_label* break_label, source_location);
+
+ private:
+ // A single clause.
+ class Select_clause
+ {
+ public:
+ Select_clause()
+ : channel_(NULL), val_(NULL), var_(NULL), statements_(NULL),
+ is_send_(false), is_default_(false)
+ { }
+
+ Select_clause(bool is_send, Expression* channel, Expression* val,
+ Named_object* var, bool is_default, Block* statements,
+ source_location location)
+ : channel_(channel), val_(val), var_(var), statements_(statements),
+ location_(location), is_send_(is_send), is_default_(is_default),
+ is_lowered_(false)
+ { gcc_assert(is_default ? channel == NULL : channel != NULL); }
+
+ // Traverse the select clause.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Return true if this is the default clause.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // Return the channel. This will return NULL for the default
+ // clause.
+ Expression*
+ channel() const
+ { return this->channel_; }
+
+ // Return the value. This will return NULL for the default
+ // clause, or for a receive clause for which no value was given.
+ Expression*
+ val() const
+ { return this->val_; }
+
+ // Return the variable to set when a receive clause is also a
+ // variable definition (v := <- ch). This will return NULL for
+ // the default case, or for a send clause, or for a receive clause
+ // which does not define a variable.
+ Named_object*
+ var() const
+ { return this->var_; }
+
+ // Return true for a send, false for a receive.
+ bool
+ is_send() const
+ {
+ gcc_assert(!this->is_default_);
+ return this->is_send_;
+ }
+
+ // Return the statements.
+ const Block*
+ statements() const
+ { return this->statements_; }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether this clause may fall through to the statement which
+ // follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Return a tree for the statements to execute.
+ tree
+ get_statements_tree(Translate_context*);
+
+ private:
+ // The channel.
+ Expression* channel_;
+ // The value to send or the variable to set.
+ Expression* val_;
+ // The variable to initialize, for "case a := <- ch".
+ Named_object* var_;
+ // The statements to execute.
+ Block* statements_;
+ // The location of this clause.
+ source_location location_;
+ // Whether this is a send or a receive.
+ bool is_send_;
+ // Whether this is the default.
+ bool is_default_;
+ // Whether this has been lowered.
+ bool is_lowered_;
+ };
+
+ void
+ add_clause_tree(Translate_context*, int, Select_clause*, Unnamed_label*,
+ tree*);
+
+ typedef std::vector<Select_clause> Clauses;
+
+ Clauses clauses_;
+};
+
+// A select statement.
+
+class Select_statement : public Statement
+{
+ public:
+ Select_statement(source_location location)
+ : Statement(STATEMENT_SELECT, location),
+ clauses_(NULL), break_label_(NULL), is_lowered_(false)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Select_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this select statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->clauses_->traverse(traverse); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ void
+ do_determine_types()
+ { this->clauses_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->clauses_->may_fall_through(); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The select clauses.
+ Select_clauses* clauses_;
+ // The break label.
+ Unnamed_label* break_label_;
+ // Whether this statement has been lowered.
+ bool is_lowered_;
+};
+
+// A statement which requires a thunk: go or defer.
+
+class Thunk_statement : public Statement
+{
+ public:
+ Thunk_statement(Statement_classification, Call_expression*,
+ source_location);
+
+ // Return the call expression.
+ Expression*
+ call()
+ { return this->call_; }
+
+ // Simplify a go or defer statement so that it only uses a single
+ // parameter.
+ bool
+ simplify_statement(Gogo*, Block*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ // Return the function and argument trees for the call.
+ void
+ get_fn_and_arg(Translate_context*, tree* pfn, tree* parg);
+
+ private:
+ // Return whether this is a simple go statement.
+ bool
+ is_simple(Function_type*) const;
+
+ // Build the struct to use for a complex case.
+ Struct_type*
+ build_struct(Function_type* fntype);
+
+ // Build the thunk.
+ void
+ build_thunk(Gogo*, const std::string&, Function_type* fntype);
+
+ // The field name used in the thunk structure for the function
+ // pointer.
+ static const char* const thunk_field_fn;
+
+ // The field name used in the thunk structure for the receiver, if
+ // there is one.
+ static const char* const thunk_field_receiver;
+
+ // Set the name to use for thunk field N.
+ void
+ thunk_field_param(int n, char* buf, size_t buflen);
+
+ // The function call to be executed in a separate thread (go) or
+ // later (defer).
+ Expression* call_;
+ // The type used for a struct to pass to a thunk, if this is not a
+ // simple call.
+ Struct_type* struct_type_;
+};
+
+// A go statement.
+
+class Go_statement : public Thunk_statement
+{
+ public:
+ Go_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_GO, call, location)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// A defer statement.
+
+class Defer_statement : public Thunk_statement
+{
+ public:
+ Defer_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_DEFER, call, location)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// A label statement.
+
+class Label_statement : public Statement
+{
+ public:
+ Label_statement(Label* label, source_location location)
+ : Statement(STATEMENT_LABEL, location),
+ label_(label)
+ { }
+
+ // Return the label itself.
+ const Label*
+ label() const
+ { return this->label_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The label.
+ Label* label_;
+};
+
+// A for statement.
+
+class For_statement : public Statement
+{
+ public:
+ For_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+ : Statement(STATEMENT_FOR, location),
+ init_(init), cond_(cond), post_(post), statements_(NULL),
+ break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ gcc_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ // Set the break and continue labels for this statement.
+ void
+ set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label);
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The initialization statements. This may be NULL.
+ Block* init_;
+ // The condition. This may be NULL.
+ Expression* cond_;
+ // The statements to run after each iteration. This may be NULL.
+ Block* post_;
+ // The statements in the loop itself.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// A for statement over a range clause.
+
+class For_range_statement : public Statement
+{
+ public:
+ For_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location location)
+ : Statement(STATEMENT_FOR_RANGE, location),
+ index_var_(index_var), value_var_(value_var), range_(range),
+ statements_(NULL), break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ gcc_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ Expression*
+ make_range_ref(Named_object*, Temporary_statement*, source_location);
+
+ Expression*
+ call_builtin(Gogo*, const char* funcname, Expression* arg, source_location);
+
+ void
+ lower_range_array(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_string(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_map(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_channel(Gogo*, Block*, Block*, Named_object*,
+ Temporary_statement*, Temporary_statement*,
+ Temporary_statement*, Block**, Expression**, Block**,
+ Block**);
+
+ // The variable which is set to the index value.
+ Expression* index_var_;
+ // The variable which is set to the element value. This may be
+ // NULL.
+ Expression* value_var_;
+ // The expression we are ranging over.
+ Expression* range_;
+ // The statements in the block.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// Class Case_clauses holds the clauses of a switch statement. This
+// is built by the parser.
+
+class Case_clauses
+{
+ public:
+ Case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. CASES is a list of case expressions; it may be
+ // NULL. IS_DEFAULT is true if this is the default case.
+ // STATEMENTS is a block of statements. IS_FALLTHROUGH is true if
+ // after the statements the case clause should fall through to the
+ // next clause.
+ void
+ add(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ {
+ this->clauses_.push_back(Case_clause(cases, is_default, statements,
+ is_fallthrough, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the case clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*) const;
+
+ // Determine types of expressions. The Type parameter is the type
+ // of the switch value.
+ void
+ determine_types(Type*);
+
+ // Check types. The Type parameter is the type of the switch value.
+ bool
+ check_types(Type*);
+
+ // Return true if all the clauses are constant values.
+ bool
+ is_constant() const;
+
+ // Return true if these clauses may fall through to the statements
+ // following the switch statement.
+ bool
+ may_fall_through() const;
+
+ // Return the body of a SWITCH_EXPR when all the clauses are
+ // constants.
+ tree
+ get_constant_tree(Translate_context*, Unnamed_label* break_label) const;
+
+ private:
+ // For a constant tree we need to keep a record of constants we have
+ // already seen. Note that INTEGER_CST trees are interned.
+ typedef Unordered_set(tree) Case_constants;
+
+ // One case clause.
+ class Case_clause
+ {
+ public:
+ Case_clause()
+ : cases_(NULL), statements_(NULL), is_default_(false),
+ is_fallthrough_(false), location_(UNKNOWN_LOCATION)
+ { }
+
+ Case_clause(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ : cases_(cases), statements_(statements), is_default_(is_default),
+ is_fallthrough_(is_fallthrough), location_(location)
+ { }
+
+ // Whether this clause falls through to the next clause.
+ bool
+ is_fallthrough() const
+ { return this->is_fallthrough_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*, Unnamed_label*) const;
+
+ // Determine types.
+ void
+ determine_types(Type*);
+
+ // Check types.
+ bool
+ check_types(Type*);
+
+ // Return true if all the case expressions are constant.
+ bool
+ is_constant() const;
+
+ // Return true if this clause may fall through to execute the
+ // statements following the switch statement. This is not the
+ // same as whether this clause falls through to the next clause.
+ bool
+ may_fall_through() const;
+
+ // Build up the body of a SWITCH_EXPR when the case expressions
+ // are constant.
+ void
+ get_constant_tree(Translate_context*, Unnamed_label* break_label,
+ Case_constants* case_constants, tree* stmt_list) const;
+
+ private:
+ // The list of case expressions.
+ Expression_list* cases_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this is the default case.
+ bool is_default_;
+ // Whether this falls through after the statements.
+ bool is_fallthrough_;
+ // The location of this case clause.
+ source_location location_;
+ };
+
+ friend class Case_clause;
+
+ // The type of the list of clauses.
+ typedef std::vector<Case_clause> Clauses;
+
+ // All the case clauses.
+ Clauses clauses_;
+};
+
+// A switch statement.
+
+class Switch_statement : public Statement
+{
+ public:
+ Switch_statement(Expression* val, source_location location)
+ : Statement(STATEMENT_SWITCH, location),
+ val_(val), clauses_(NULL), break_label_(NULL)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Case_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The value to switch on. This may be NULL.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Class Type_case_clauses holds the clauses of a type switch
+// statement. This is built by the parser.
+
+class Type_case_clauses
+{
+ public:
+ Type_case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. TYPE is the type for this clause; it may be
+ // NULL. IS_FALLTHROUGH is true if this falls through to the next
+ // clause; in this case STATEMENTS will be NULL. IS_DEFAULT is true
+ // if this is the default case. STATEMENTS is a block of
+ // statements; it may be NULL.
+ void
+ add(Type* type, bool is_fallthrough, bool is_default, Block* statements,
+ source_location location)
+ {
+ this->clauses_.push_back(Type_case_clause(type, is_fallthrough, is_default,
+ statements, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the type case clauses.
+ int
+ traverse(Traverse*);
+
+ // Check for duplicates.
+ void
+ check_duplicates() const;
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const;
+
+ private:
+ // One type case clause.
+ class Type_case_clause
+ {
+ public:
+ Type_case_clause()
+ : type_(NULL), statements_(NULL), is_default_(false),
+ location_(UNKNOWN_LOCATION)
+ { }
+
+ Type_case_clause(Type* type, bool is_fallthrough, bool is_default,
+ Block* statements, source_location location)
+ : type_(type), statements_(statements), is_fallthrough_(is_fallthrough),
+ is_default_(is_default), location_(location)
+ { }
+
+ // The type.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this type clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label, Unnamed_label** stmts_label) const;
+
+ private:
+ // The type for this type clause.
+ Type* type_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this falls through--this is true for "case T1, T2".
+ bool is_fallthrough_;
+ // Whether this is the default case.
+ bool is_default_;
+ // The location of this type case clause.
+ source_location location_;
+ };
+
+ friend class Type_case_clause;
+
+ // The type of the list of type clauses.
+ typedef std::vector<Type_case_clause> Type_clauses;
+
+ // All the type case clauses.
+ Type_clauses clauses_;
+};
+
+// A type switch statement.
+
+class Type_switch_statement : public Statement
+{
+ public:
+ Type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+ : Statement(STATEMENT_TYPE_SWITCH, location),
+ var_(var), expr_(expr), clauses_(NULL), break_label_(NULL)
+ { gcc_assert(var == NULL || expr == NULL); }
+
+ // Add the clauses.
+ void
+ add_clauses(Type_case_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this type switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Get the type descriptor.
+ tree
+ get_type_descriptor(Translate_context*, Type*, tree);
+
+ // The variable holding the value we are switching on.
+ Named_object* var_;
+ // The expression we are switching on if there is no variable.
+ Expression* expr_;
+ // The type case clauses.
+ Type_case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+#endif // !defined(GO_STATEMENTS_H)
--- /dev/null
+// statements.h -- Go frontend statements. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_STATEMENTS_H
+#define GO_STATEMENTS_H
+
+#include "operator.h"
+
+class Gogo;
+class Traverse;
+class Block;
+class Function;
+class Unnamed_label;
+class Temporary_statement;
+class Variable_declaration_statement;
+class Return_statement;
+class Thunk_statement;
+class Label_statement;
+class For_statement;
+class For_range_statement;
+class Switch_statement;
+class Type_switch_statement;
+class Send_statement;
+class Select_statement;
+class Variable;
+class Named_object;
+class Label;
+class Translate_context;
+class Expression;
+class Expression_list;
+class Struct_type;
+class Call_expression;
+class Map_index_expression;
+class Receive_expression;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Typed_identifier_list;
+class Bexpression;
+class Bstatement;
+class Bvariable;
+
+// This class is used to traverse assignments made by a statement
+// which makes assignments.
+
+class Traverse_assignments
+{
+ public:
+ Traverse_assignments()
+ { }
+
+ virtual ~Traverse_assignments()
+ { }
+
+ // This is called for a variable initialization.
+ virtual void
+ initialize_variable(Named_object*) = 0;
+
+ // This is called for each assignment made by the statement. PLHS
+ // points to the left hand side, and PRHS points to the right hand
+ // side. PRHS may be NULL if there is no associated expression, as
+ // in the bool set by a non-blocking receive.
+ virtual void
+ assignment(Expression** plhs, Expression** prhs) = 0;
+
+ // This is called for each expression which is not passed to the
+ // assignment function. This is used for some of the statements
+ // which assign two values, for which there is no expression which
+ // describes the value. For ++ and -- the value is passed to both
+ // the assignment method and the rhs method. IS_STORED is true if
+ // this value is being stored directly. It is false if the value is
+ // computed but not stored. IS_LOCAL is true if the value is being
+ // stored in a local variable or this is being called by a return
+ // statement.
+ virtual void
+ value(Expression**, bool is_stored, bool is_local) = 0;
+};
+
+// A single statement.
+
+class Statement
+{
+ public:
+ // The types of statements.
+ enum Statement_classification
+ {
+ STATEMENT_ERROR,
+ STATEMENT_VARIABLE_DECLARATION,
+ STATEMENT_TEMPORARY,
+ STATEMENT_ASSIGNMENT,
+ STATEMENT_EXPRESSION,
+ STATEMENT_BLOCK,
+ STATEMENT_GO,
+ STATEMENT_DEFER,
+ STATEMENT_RETURN,
+ STATEMENT_BREAK_OR_CONTINUE,
+ STATEMENT_GOTO,
+ STATEMENT_GOTO_UNNAMED,
+ STATEMENT_LABEL,
+ STATEMENT_UNNAMED_LABEL,
+ STATEMENT_IF,
+ STATEMENT_CONSTANT_SWITCH,
+ STATEMENT_SEND,
+ STATEMENT_SELECT,
+
+ // These statements types are created by the parser, but they
+ // disappear during the lowering pass.
+ STATEMENT_ASSIGNMENT_OPERATION,
+ STATEMENT_TUPLE_ASSIGNMENT,
+ STATEMENT_TUPLE_MAP_ASSIGNMENT,
+ STATEMENT_MAP_ASSIGNMENT,
+ STATEMENT_TUPLE_RECEIVE_ASSIGNMENT,
+ STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT,
+ STATEMENT_INCDEC,
+ STATEMENT_FOR,
+ STATEMENT_FOR_RANGE,
+ STATEMENT_SWITCH,
+ STATEMENT_TYPE_SWITCH
+ };
+
+ Statement(Statement_classification, source_location);
+
+ virtual ~Statement();
+
+ // Make a variable declaration.
+ static Statement*
+ make_variable_declaration(Named_object*);
+
+ // Make a statement which creates a temporary variable and
+ // initializes it to an expression. The block is used if the
+ // temporary variable has to be explicitly destroyed; the variable
+ // must still be added to the block. References to the temporary
+ // variable may be constructed using make_temporary_reference.
+ // Either the type or the initialization expression may be NULL, but
+ // not both.
+ static Temporary_statement*
+ make_temporary(Type*, Expression*, source_location);
+
+ // Make an assignment statement.
+ static Statement*
+ make_assignment(Expression*, Expression*, source_location);
+
+ // Make an assignment operation (+=, etc.).
+ static Statement*
+ make_assignment_operation(Operator, Expression*, Expression*,
+ source_location);
+
+ // Make a tuple assignment statement.
+ static Statement*
+ make_tuple_assignment(Expression_list*, Expression_list*, source_location);
+
+ // Make an assignment from a map index to a pair of variables.
+ static Statement*
+ make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression*, source_location);
+
+ // Make a statement which assigns a pair of values to a map.
+ static Statement*
+ make_map_assignment(Expression*, Expression* val,
+ Expression* should_set, source_location);
+
+ // Make an assignment from a nonblocking receive to a pair of
+ // variables. FOR_SELECT is true is this is being created for a
+ // case x, ok := <-c in a select statement.
+ static Statement*
+ make_tuple_receive_assignment(Expression* val, Expression* closed,
+ Expression* channel, bool for_select,
+ source_location);
+
+ // Make an assignment from a type guard to a pair of variables.
+ static Statement*
+ make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location);
+
+ // Make an expression statement from an Expression.
+ static Statement*
+ make_statement(Expression*);
+
+ // Make a block statement from a Block. This is an embedded list of
+ // statements which may also include variable definitions.
+ static Statement*
+ make_block_statement(Block*, source_location);
+
+ // Make an increment statement.
+ static Statement*
+ make_inc_statement(Expression*);
+
+ // Make a decrement statement.
+ static Statement*
+ make_dec_statement(Expression*);
+
+ // Make a go statement.
+ static Statement*
+ make_go_statement(Call_expression* call, source_location);
+
+ // Make a defer statement.
+ static Statement*
+ make_defer_statement(Call_expression* call, source_location);
+
+ // Make a return statement.
+ static Statement*
+ make_return_statement(Expression_list*, source_location);
+
+ // Make a break statement.
+ static Statement*
+ make_break_statement(Unnamed_label* label, source_location);
+
+ // Make a continue statement.
+ static Statement*
+ make_continue_statement(Unnamed_label* label, source_location);
+
+ // Make a goto statement.
+ static Statement*
+ make_goto_statement(Label* label, source_location);
+
+ // Make a goto statement to an unnamed label.
+ static Statement*
+ make_goto_unnamed_statement(Unnamed_label* label, source_location);
+
+ // Make a label statement--where the label is defined.
+ static Statement*
+ make_label_statement(Label* label, source_location);
+
+ // Make an unnamed label statement--where the label is defined.
+ static Statement*
+ make_unnamed_label_statement(Unnamed_label* label);
+
+ // Make an if statement.
+ static Statement*
+ make_if_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location);
+
+ // Make a switch statement.
+ static Switch_statement*
+ make_switch_statement(Expression* switch_val, source_location);
+
+ // Make a type switch statement.
+ static Type_switch_statement*
+ make_type_switch_statement(Named_object* var, Expression*, source_location);
+
+ // Make a send statement.
+ static Send_statement*
+ make_send_statement(Expression* channel, Expression* val, source_location);
+
+ // Make a select statement.
+ static Select_statement*
+ make_select_statement(source_location);
+
+ // Make a for statement.
+ static For_statement*
+ make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location);
+
+ // Make a for statement with a range clause.
+ static For_range_statement*
+ make_for_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location);
+
+ // Return the statement classification.
+ Statement_classification
+ classification() const
+ { return this->classification_; }
+
+ // Get the statement location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traverse the tree.
+ int
+ traverse(Block*, size_t* index, Traverse*);
+
+ // Traverse the contents of this statement--the expressions and
+ // statements which it contains.
+ int
+ traverse_contents(Traverse*);
+
+ // If this statement assigns some values, it calls a function for
+ // each value to which this statement assigns a value, and returns
+ // true. If this statement does not assign any values, it returns
+ // false.
+ bool
+ traverse_assignments(Traverse_assignments* tassign);
+
+ // Lower a statement. This is called immediately after parsing to
+ // simplify statements for further processing. It returns the same
+ // Statement or a new one. FUNCTION is the function containing this
+ // statement. BLOCK is the block containing this statement.
+ Statement*
+ lower(Gogo* gogo, Named_object* function, Block* block)
+ { return this->do_lower(gogo, function, block); }
+
+ // Set type information for unnamed constants.
+ void
+ determine_types();
+
+ // Check types in a statement. This simply checks that any
+ // expressions used by the statement have the right type.
+ void
+ check_types(Gogo* gogo)
+ { this->do_check_types(gogo); }
+
+ // Return whether this is a block statement.
+ bool
+ is_block_statement() const
+ { return this->classification_ == STATEMENT_BLOCK; }
+
+ // If this is a variable declaration statement, return it.
+ // Otherwise return NULL.
+ Variable_declaration_statement*
+ variable_declaration_statement()
+ {
+ return this->convert<Variable_declaration_statement,
+ STATEMENT_VARIABLE_DECLARATION>();
+ }
+
+ // If this is a return statement, return it. Otherwise return NULL.
+ Return_statement*
+ return_statement()
+ { return this->convert<Return_statement, STATEMENT_RETURN>(); }
+
+ // If this is a thunk statement (a go or defer statement), return
+ // it. Otherwise return NULL.
+ Thunk_statement*
+ thunk_statement();
+
+ // If this is a label statement, return it. Otherwise return NULL.
+ Label_statement*
+ label_statement()
+ { return this->convert<Label_statement, STATEMENT_LABEL>(); }
+
+ // If this is a for statement, return it. Otherwise return NULL.
+ For_statement*
+ for_statement()
+ { return this->convert<For_statement, STATEMENT_FOR>(); }
+
+ // If this is a for statement over a range clause, return it.
+ // Otherwise return NULL.
+ For_range_statement*
+ for_range_statement()
+ { return this->convert<For_range_statement, STATEMENT_FOR_RANGE>(); }
+
+ // If this is a switch statement, return it. Otherwise return NULL.
+ Switch_statement*
+ switch_statement()
+ { return this->convert<Switch_statement, STATEMENT_SWITCH>(); }
+
+ // If this is a type switch statement, return it. Otherwise return
+ // NULL.
+ Type_switch_statement*
+ type_switch_statement()
+ { return this->convert<Type_switch_statement, STATEMENT_TYPE_SWITCH>(); }
+
+ // If this is a select statement, return it. Otherwise return NULL.
+ Select_statement*
+ select_statement()
+ { return this->convert<Select_statement, STATEMENT_SELECT>(); }
+
+ // Return true if this statement may fall through--if after
+ // executing this statement we may go on to execute the following
+ // statement, if any.
+ bool
+ may_fall_through() const
+ { return this->do_may_fall_through(); }
+
+ // Convert the statement to the backend representation.
+ Bstatement*
+ get_backend(Translate_context*);
+
+ protected:
+ // Implemented by child class: traverse the tree.
+ virtual int
+ do_traverse(Traverse*) = 0;
+
+ // Implemented by child class: traverse assignments. Any statement
+ // which includes an assignment should implement this.
+ virtual bool
+ do_traverse_assignments(Traverse_assignments*)
+ { return false; }
+
+ // Implemented by the child class: lower this statement to a simpler
+ // one.
+ virtual Statement*
+ do_lower(Gogo*, Named_object*, Block*)
+ { return this; }
+
+ // Implemented by child class: set type information for unnamed
+ // constants. Any statement which includes an expression needs to
+ // implement this.
+ virtual void
+ do_determine_types()
+ { }
+
+ // Implemented by child class: check types of expressions used in a
+ // statement.
+ virtual void
+ do_check_types(Gogo*)
+ { }
+
+ // Implemented by child class: return true if this statement may
+ // fall through.
+ virtual bool
+ do_may_fall_through() const
+ { return true; }
+
+ // Implemented by child class: convert to backend representation.
+ virtual Bstatement*
+ do_get_backend(Translate_context*) = 0;
+
+ // Traverse an expression in a statement.
+ int
+ traverse_expression(Traverse*, Expression**);
+
+ // Traverse an expression list in a statement. The Expression_list
+ // may be NULL.
+ int
+ traverse_expression_list(Traverse*, Expression_list*);
+
+ // Traverse a type in a statement.
+ int
+ traverse_type(Traverse*, Type*);
+
+ // For children to call when they detect that they are in error.
+ void
+ set_is_error();
+
+ // For children to call to report an error conveniently.
+ void
+ report_error(const char*);
+
+ // For children to return an error statement from lower().
+ static Statement*
+ make_error_statement(source_location);
+
+ private:
+ // Convert to the desired statement classification, or return NULL.
+ // This is a controlled dynamic cast.
+ template<typename Statement_class, Statement_classification sc>
+ Statement_class*
+ convert()
+ {
+ return (this->classification_ == sc
+ ? static_cast<Statement_class*>(this)
+ : NULL);
+ }
+
+ template<typename Statement_class, Statement_classification sc>
+ const Statement_class*
+ convert() const
+ {
+ return (this->classification_ == sc
+ ? static_cast<const Statement_class*>(this)
+ : NULL);
+ }
+
+ // The statement classification.
+ Statement_classification classification_;
+ // The location in the input file of the start of this statement.
+ source_location location_;
+};
+
+// A statement which creates and initializes a temporary variable.
+
+class Temporary_statement : public Statement
+{
+ public:
+ Temporary_statement(Type* type, Expression* init, source_location location)
+ : Statement(STATEMENT_TEMPORARY, location),
+ type_(type), init_(init), bvariable_(NULL), is_address_taken_(false)
+ { }
+
+ // Return the type of the temporary variable.
+ Type*
+ type() const;
+
+ // Record that something takes the address of this temporary
+ // variable.
+ void
+ set_is_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Return the temporary variable. This should not be called until
+ // after the statement itself has been converted.
+ Bvariable*
+ get_backend_variable(Translate_context*) const;
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // The type of the temporary variable.
+ Type* type_;
+ // The initial value of the temporary variable. This may be NULL.
+ Expression* init_;
+ // The backend representation of the temporary variable.
+ Bvariable* bvariable_;
+ // True if something takes the address of this temporary variable.
+ bool is_address_taken_;
+};
+
+// A variable declaration. This marks the point in the code where a
+// variable is declared. The Variable is also attached to a Block.
+
+class Variable_declaration_statement : public Statement
+{
+ public:
+ Variable_declaration_statement(Named_object* var);
+
+ // The variable being declared.
+ Named_object*
+ var()
+ { return this->var_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ Named_object* var_;
+};
+
+// A return statement.
+
+class Return_statement : public Statement
+{
+ public:
+ Return_statement(Expression_list* vals, source_location location)
+ : Statement(STATEMENT_RETURN, location),
+ vals_(vals), is_lowered_(false)
+ { }
+
+ // The list of values being returned. This may be NULL.
+ const Expression_list*
+ vals() const
+ { return this->vals_; }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression_list(traverse, this->vals_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // Return values. This may be NULL.
+ Expression_list* vals_;
+ // True if this statement has been lowered.
+ bool is_lowered_;
+};
+
+// A send statement.
+
+class Send_statement : public Statement
+{
+ public:
+ Send_statement(Expression* channel, Expression* val,
+ source_location location)
+ : Statement(STATEMENT_SEND, location),
+ channel_(channel), val_(val), for_select_(false)
+ { }
+
+ // Note that this is for a select statement.
+ void
+ set_for_select()
+ { this->for_select_ = true; }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // The channel on which to send the value.
+ Expression* channel_;
+ // The value to send.
+ Expression* val_;
+ // Whether this is for a select statement.
+ bool for_select_;
+};
+
+// Select_clauses holds the clauses of a select statement. This is
+// built by the parser.
+
+class Select_clauses
+{
+ public:
+ Select_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. IS_SEND is true if this is a send clause,
+ // false for a receive clause. For a send clause CHANNEL is the
+ // channel and VAL is the value to send. For a receive clause
+ // CHANNEL is the channel, VAL is either NULL or a Var_expression
+ // for the variable to set, and CLOSED is either NULL or a
+ // Var_expression to set to whether the channel is closed. If VAL
+ // is NULL, VAR may be a variable to be initialized with the
+ // received value, and CLOSEDVAR ma be a variable to be initialized
+ // with whether the channel is closed. IS_DEFAULT is true if this
+ // is the default clause. STATEMENTS is the list of statements to
+ // execute.
+ void
+ add(bool is_send, Expression* channel, Expression* val, Expression* closed,
+ Named_object* var, Named_object* closedvar, bool is_default,
+ Block* statements, source_location location)
+ {
+ this->clauses_.push_back(Select_clause(is_send, channel, val, closed, var,
+ closedvar, is_default, statements,
+ location));
+ }
+
+ // Traverse the select clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Gogo*, Named_object*, Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Whether the select clauses may fall through to the statement
+ // which follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Convert to the backend representation.
+ Bstatement*
+ get_backend(Translate_context*, Unnamed_label* break_label, source_location);
+
+ private:
+ // A single clause.
+ class Select_clause
+ {
+ public:
+ Select_clause()
+ : channel_(NULL), val_(NULL), closed_(NULL), var_(NULL),
+ closedvar_(NULL), statements_(NULL), is_send_(false),
+ is_default_(false)
+ { }
+
+ Select_clause(bool is_send, Expression* channel, Expression* val,
+ Expression* closed, Named_object* var,
+ Named_object* closedvar, bool is_default, Block* statements,
+ source_location location)
+ : channel_(channel), val_(val), closed_(closed), var_(var),
+ closedvar_(closedvar), statements_(statements), location_(location),
+ is_send_(is_send), is_default_(is_default), is_lowered_(false)
+ { go_assert(is_default ? channel == NULL : channel != NULL); }
+
+ // Traverse the select clause.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Gogo*, Named_object*, Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Return true if this is the default clause.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // Return the channel. This will return NULL for the default
+ // clause.
+ Expression*
+ channel() const
+ { return this->channel_; }
+
+ // Return true for a send, false for a receive.
+ bool
+ is_send() const
+ {
+ go_assert(!this->is_default_);
+ return this->is_send_;
+ }
+
+ // Return the statements.
+ const Block*
+ statements() const
+ { return this->statements_; }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether this clause may fall through to the statement which
+ // follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Convert the statements to the backend representation.
+ Bstatement*
+ get_statements_backend(Translate_context*);
+
+ private:
+ // The channel.
+ Expression* channel_;
+ // The value to send or the lvalue to receive into.
+ Expression* val_;
+ // The lvalue to set to whether the channel is closed on a
+ // receive.
+ Expression* closed_;
+ // The variable to initialize, for "case a := <-ch".
+ Named_object* var_;
+ // The variable to initialize to whether the channel is closed,
+ // for "case a, c := <-ch".
+ Named_object* closedvar_;
+ // The statements to execute.
+ Block* statements_;
+ // The location of this clause.
+ source_location location_;
+ // Whether this is a send or a receive.
+ bool is_send_;
+ // Whether this is the default.
+ bool is_default_;
+ // Whether this has been lowered.
+ bool is_lowered_;
+ };
+
+ void
+ add_clause_backend(Translate_context*, source_location, int index,
+ int case_value, Select_clause*, Unnamed_label*,
+ std::vector<std::vector<Bexpression*> >* cases,
+ std::vector<Bstatement*>* clauses);
+
+ typedef std::vector<Select_clause> Clauses;
+
+ Clauses clauses_;
+};
+
+// A select statement.
+
+class Select_statement : public Statement
+{
+ public:
+ Select_statement(source_location location)
+ : Statement(STATEMENT_SELECT, location),
+ clauses_(NULL), break_label_(NULL), is_lowered_(false)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Select_clauses* clauses)
+ {
+ go_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this select statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->clauses_->traverse(traverse); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ void
+ do_determine_types()
+ { this->clauses_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->clauses_->may_fall_through(); }
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // The select clauses.
+ Select_clauses* clauses_;
+ // The break label.
+ Unnamed_label* break_label_;
+ // Whether this statement has been lowered.
+ bool is_lowered_;
+};
+
+// A statement which requires a thunk: go or defer.
+
+class Thunk_statement : public Statement
+{
+ public:
+ Thunk_statement(Statement_classification, Call_expression*,
+ source_location);
+
+ // Return the call expression.
+ Expression*
+ call()
+ { return this->call_; }
+
+ // Simplify a go or defer statement so that it only uses a single
+ // parameter.
+ bool
+ simplify_statement(Gogo*, Named_object*, Block*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ // Return the function and argument for the call.
+ bool
+ get_fn_and_arg(Expression** pfn, Expression** parg);
+
+ private:
+ // Return whether this is a simple go statement.
+ bool
+ is_simple(Function_type*) const;
+
+ // Build the struct to use for a complex case.
+ Struct_type*
+ build_struct(Function_type* fntype);
+
+ // Build the thunk.
+ void
+ build_thunk(Gogo*, const std::string&, Function_type* fntype);
+
+ // The field name used in the thunk structure for the function
+ // pointer.
+ static const char* const thunk_field_fn;
+
+ // The field name used in the thunk structure for the receiver, if
+ // there is one.
+ static const char* const thunk_field_receiver;
+
+ // Set the name to use for thunk field N.
+ void
+ thunk_field_param(int n, char* buf, size_t buflen);
+
+ // The function call to be executed in a separate thread (go) or
+ // later (defer).
+ Expression* call_;
+ // The type used for a struct to pass to a thunk, if this is not a
+ // simple call.
+ Struct_type* struct_type_;
+};
+
+// A go statement.
+
+class Go_statement : public Thunk_statement
+{
+ public:
+ Go_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_GO, call, location)
+ { }
+
+ protected:
+ Bstatement*
+ do_get_backend(Translate_context*);
+};
+
+// A defer statement.
+
+class Defer_statement : public Thunk_statement
+{
+ public:
+ Defer_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_DEFER, call, location)
+ { }
+
+ protected:
+ Bstatement*
+ do_get_backend(Translate_context*);
+};
+
+// A label statement.
+
+class Label_statement : public Statement
+{
+ public:
+ Label_statement(Label* label, source_location location)
+ : Statement(STATEMENT_LABEL, location),
+ label_(label)
+ { }
+
+ // Return the label itself.
+ const Label*
+ label() const
+ { return this->label_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Bstatement*
+ do_get_backend(Translate_context*);
+
+ private:
+ // The label.
+ Label* label_;
+};
+
+// A for statement.
+
+class For_statement : public Statement
+{
+ public:
+ For_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+ : Statement(STATEMENT_FOR, location),
+ init_(init), cond_(cond), post_(post), statements_(NULL),
+ break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ go_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ // Set the break and continue labels for this statement.
+ void
+ set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label);
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The initialization statements. This may be NULL.
+ Block* init_;
+ // The condition. This may be NULL.
+ Expression* cond_;
+ // The statements to run after each iteration. This may be NULL.
+ Block* post_;
+ // The statements in the loop itself.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// A for statement over a range clause.
+
+class For_range_statement : public Statement
+{
+ public:
+ For_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location location)
+ : Statement(STATEMENT_FOR_RANGE, location),
+ index_var_(index_var), value_var_(value_var), range_(range),
+ statements_(NULL), break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ go_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { go_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ Expression*
+ make_range_ref(Named_object*, Temporary_statement*, source_location);
+
+ Expression*
+ call_builtin(Gogo*, const char* funcname, Expression* arg, source_location);
+
+ void
+ lower_range_array(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_string(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_map(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_channel(Gogo*, Block*, Block*, Named_object*,
+ Temporary_statement*, Temporary_statement*,
+ Temporary_statement*, Block**, Expression**, Block**,
+ Block**);
+
+ // The variable which is set to the index value.
+ Expression* index_var_;
+ // The variable which is set to the element value. This may be
+ // NULL.
+ Expression* value_var_;
+ // The expression we are ranging over.
+ Expression* range_;
+ // The statements in the block.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// Class Case_clauses holds the clauses of a switch statement. This
+// is built by the parser.
+
+class Case_clauses
+{
+ public:
+ Case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. CASES is a list of case expressions; it may be
+ // NULL. IS_DEFAULT is true if this is the default case.
+ // STATEMENTS is a block of statements. IS_FALLTHROUGH is true if
+ // after the statements the case clause should fall through to the
+ // next clause.
+ void
+ add(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ {
+ this->clauses_.push_back(Case_clause(cases, is_default, statements,
+ is_fallthrough, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the case clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*) const;
+
+ // Determine types of expressions. The Type parameter is the type
+ // of the switch value.
+ void
+ determine_types(Type*);
+
+ // Check types. The Type parameter is the type of the switch value.
+ bool
+ check_types(Type*);
+
+ // Return true if all the clauses are constant values.
+ bool
+ is_constant() const;
+
+ // Return true if these clauses may fall through to the statements
+ // following the switch statement.
+ bool
+ may_fall_through() const;
+
+ // Return the body of a SWITCH_EXPR when all the clauses are
+ // constants.
+ void
+ get_backend(Translate_context*, Unnamed_label* break_label,
+ std::vector<std::vector<Bexpression*> >* all_cases,
+ std::vector<Bstatement*>* all_statements) const;
+
+ private:
+ // For a constant switch we need to keep a record of constants we
+ // have already seen.
+ class Hash_integer_value;
+ class Eq_integer_value;
+ typedef Unordered_set_hash(Expression*, Hash_integer_value,
+ Eq_integer_value) Case_constants;
+
+ // One case clause.
+ class Case_clause
+ {
+ public:
+ Case_clause()
+ : cases_(NULL), statements_(NULL), is_default_(false),
+ is_fallthrough_(false), location_(UNKNOWN_LOCATION)
+ { }
+
+ Case_clause(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ : cases_(cases), statements_(statements), is_default_(is_default),
+ is_fallthrough_(is_fallthrough), location_(location)
+ { }
+
+ // Whether this clause falls through to the next clause.
+ bool
+ is_fallthrough() const
+ { return this->is_fallthrough_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*, Unnamed_label*) const;
+
+ // Determine types.
+ void
+ determine_types(Type*);
+
+ // Check types.
+ bool
+ check_types(Type*);
+
+ // Return true if all the case expressions are constant.
+ bool
+ is_constant() const;
+
+ // Return true if this clause may fall through to execute the
+ // statements following the switch statement. This is not the
+ // same as whether this clause falls through to the next clause.
+ bool
+ may_fall_through() const;
+
+ // Convert the case values and statements to the backend
+ // representation.
+ Bstatement*
+ get_backend(Translate_context*, Unnamed_label* break_label,
+ Case_constants*, std::vector<Bexpression*>* cases) const;
+
+ private:
+ // The list of case expressions.
+ Expression_list* cases_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this is the default case.
+ bool is_default_;
+ // Whether this falls through after the statements.
+ bool is_fallthrough_;
+ // The location of this case clause.
+ source_location location_;
+ };
+
+ friend class Case_clause;
+
+ // The type of the list of clauses.
+ typedef std::vector<Case_clause> Clauses;
+
+ // All the case clauses.
+ Clauses clauses_;
+};
+
+// A switch statement.
+
+class Switch_statement : public Statement
+{
+ public:
+ Switch_statement(Expression* val, source_location location)
+ : Statement(STATEMENT_SWITCH, location),
+ val_(val), clauses_(NULL), break_label_(NULL)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Case_clauses* clauses)
+ {
+ go_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The value to switch on. This may be NULL.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Class Type_case_clauses holds the clauses of a type switch
+// statement. This is built by the parser.
+
+class Type_case_clauses
+{
+ public:
+ Type_case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. TYPE is the type for this clause; it may be
+ // NULL. IS_FALLTHROUGH is true if this falls through to the next
+ // clause; in this case STATEMENTS will be NULL. IS_DEFAULT is true
+ // if this is the default case. STATEMENTS is a block of
+ // statements; it may be NULL.
+ void
+ add(Type* type, bool is_fallthrough, bool is_default, Block* statements,
+ source_location location)
+ {
+ this->clauses_.push_back(Type_case_clause(type, is_fallthrough, is_default,
+ statements, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the type case clauses.
+ int
+ traverse(Traverse*);
+
+ // Check for duplicates.
+ void
+ check_duplicates() const;
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const;
+
+ private:
+ // One type case clause.
+ class Type_case_clause
+ {
+ public:
+ Type_case_clause()
+ : type_(NULL), statements_(NULL), is_default_(false),
+ location_(UNKNOWN_LOCATION)
+ { }
+
+ Type_case_clause(Type* type, bool is_fallthrough, bool is_default,
+ Block* statements, source_location location)
+ : type_(type), statements_(statements), is_fallthrough_(is_fallthrough),
+ is_default_(is_default), location_(location)
+ { }
+
+ // The type.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this type clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label, Unnamed_label** stmts_label) const;
+
+ private:
+ // The type for this type clause.
+ Type* type_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this falls through--this is true for "case T1, T2".
+ bool is_fallthrough_;
+ // Whether this is the default case.
+ bool is_default_;
+ // The location of this type case clause.
+ source_location location_;
+ };
+
+ friend class Type_case_clause;
+
+ // The type of the list of type clauses.
+ typedef std::vector<Type_case_clause> Type_clauses;
+
+ // All the type case clauses.
+ Type_clauses clauses_;
+};
+
+// A type switch statement.
+
+class Type_switch_statement : public Statement
+{
+ public:
+ Type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+ : Statement(STATEMENT_TYPE_SWITCH, location),
+ var_(var), expr_(expr), clauses_(NULL), break_label_(NULL)
+ { go_assert(var == NULL || expr == NULL); }
+
+ // Add the clauses.
+ void
+ add_clauses(Type_case_clauses* clauses)
+ {
+ go_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this type switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ Bstatement*
+ do_get_backend(Translate_context*)
+ { go_unreachable(); }
+
+ private:
+ // The variable holding the value we are switching on.
+ Named_object* var_;
+ // The expression we are switching on if there is no variable.
+ Expression* expr_;
+ // The type case clauses.
+ Type_case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+#endif // !defined(GO_STATEMENTS_H)
--- /dev/null
+// statements.h -- Go frontend statements. -*- C++ -*-
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef GO_STATEMENTS_H
+#define GO_STATEMENTS_H
+
+#include "operator.h"
+
+class Gogo;
+class Traverse;
+class Block;
+class Function;
+class Unnamed_label;
+class Temporary_statement;
+class Variable_declaration_statement;
+class Return_statement;
+class Thunk_statement;
+class Label_statement;
+class For_statement;
+class For_range_statement;
+class Switch_statement;
+class Type_switch_statement;
+class Send_statement;
+class Select_statement;
+class Variable;
+class Named_object;
+class Label;
+class Translate_context;
+class Expression;
+class Expression_list;
+class Struct_type;
+class Call_expression;
+class Map_index_expression;
+class Receive_expression;
+class Case_clauses;
+class Type_case_clauses;
+class Select_clauses;
+class Typed_identifier_list;
+
+// This class is used to traverse assignments made by a statement
+// which makes assignments.
+
+class Traverse_assignments
+{
+ public:
+ Traverse_assignments()
+ { }
+
+ virtual ~Traverse_assignments()
+ { }
+
+ // This is called for a variable initialization.
+ virtual void
+ initialize_variable(Named_object*) = 0;
+
+ // This is called for each assignment made by the statement. PLHS
+ // points to the left hand side, and PRHS points to the right hand
+ // side. PRHS may be NULL if there is no associated expression, as
+ // in the bool set by a non-blocking receive.
+ virtual void
+ assignment(Expression** plhs, Expression** prhs) = 0;
+
+ // This is called for each expression which is not passed to the
+ // assignment function. This is used for some of the statements
+ // which assign two values, for which there is no expression which
+ // describes the value. For ++ and -- the value is passed to both
+ // the assignment method and the rhs method. IS_STORED is true if
+ // this value is being stored directly. It is false if the value is
+ // computed but not stored. IS_LOCAL is true if the value is being
+ // stored in a local variable or this is being called by a return
+ // statement.
+ virtual void
+ value(Expression**, bool is_stored, bool is_local) = 0;
+};
+
+// A single statement.
+
+class Statement
+{
+ public:
+ // The types of statements.
+ enum Statement_classification
+ {
+ STATEMENT_ERROR,
+ STATEMENT_VARIABLE_DECLARATION,
+ STATEMENT_TEMPORARY,
+ STATEMENT_ASSIGNMENT,
+ STATEMENT_EXPRESSION,
+ STATEMENT_BLOCK,
+ STATEMENT_GO,
+ STATEMENT_DEFER,
+ STATEMENT_RETURN,
+ STATEMENT_BREAK_OR_CONTINUE,
+ STATEMENT_GOTO,
+ STATEMENT_GOTO_UNNAMED,
+ STATEMENT_LABEL,
+ STATEMENT_UNNAMED_LABEL,
+ STATEMENT_IF,
+ STATEMENT_CONSTANT_SWITCH,
+ STATEMENT_SEND,
+ STATEMENT_SELECT,
+
+ // These statements types are created by the parser, but they
+ // disappear during the lowering pass.
+ STATEMENT_ASSIGNMENT_OPERATION,
+ STATEMENT_TUPLE_ASSIGNMENT,
+ STATEMENT_TUPLE_MAP_ASSIGNMENT,
+ STATEMENT_MAP_ASSIGNMENT,
+ STATEMENT_TUPLE_RECEIVE_ASSIGNMENT,
+ STATEMENT_TUPLE_TYPE_GUARD_ASSIGNMENT,
+ STATEMENT_INCDEC,
+ STATEMENT_FOR,
+ STATEMENT_FOR_RANGE,
+ STATEMENT_SWITCH,
+ STATEMENT_TYPE_SWITCH
+ };
+
+ Statement(Statement_classification, source_location);
+
+ virtual ~Statement();
+
+ // Make a variable declaration.
+ static Statement*
+ make_variable_declaration(Named_object*);
+
+ // Make a statement which creates a temporary variable and
+ // initializes it to an expression. The block is used if the
+ // temporary variable has to be explicitly destroyed; the variable
+ // must still be added to the block. References to the temporary
+ // variable may be constructed using make_temporary_reference.
+ // Either the type or the initialization expression may be NULL, but
+ // not both.
+ static Temporary_statement*
+ make_temporary(Type*, Expression*, source_location);
+
+ // Make an assignment statement.
+ static Statement*
+ make_assignment(Expression*, Expression*, source_location);
+
+ // Make an assignment operation (+=, etc.).
+ static Statement*
+ make_assignment_operation(Operator, Expression*, Expression*,
+ source_location);
+
+ // Make a tuple assignment statement.
+ static Statement*
+ make_tuple_assignment(Expression_list*, Expression_list*, source_location);
+
+ // Make an assignment from a map index to a pair of variables.
+ static Statement*
+ make_tuple_map_assignment(Expression* val, Expression* present,
+ Expression*, source_location);
+
+ // Make a statement which assigns a pair of values to a map.
+ static Statement*
+ make_map_assignment(Expression*, Expression* val,
+ Expression* should_set, source_location);
+
+ // Make an assignment from a nonblocking receive to a pair of
+ // variables. FOR_SELECT is true is this is being created for a
+ // case x, ok := <-c in a select statement.
+ static Statement*
+ make_tuple_receive_assignment(Expression* val, Expression* closed,
+ Expression* channel, bool for_select,
+ source_location);
+
+ // Make an assignment from a type guard to a pair of variables.
+ static Statement*
+ make_tuple_type_guard_assignment(Expression* val, Expression* ok,
+ Expression* expr, Type* type,
+ source_location);
+
+ // Make an expression statement from an Expression.
+ static Statement*
+ make_statement(Expression*);
+
+ // Make a block statement from a Block. This is an embedded list of
+ // statements which may also include variable definitions.
+ static Statement*
+ make_block_statement(Block*, source_location);
+
+ // Make an increment statement.
+ static Statement*
+ make_inc_statement(Expression*);
+
+ // Make a decrement statement.
+ static Statement*
+ make_dec_statement(Expression*);
+
+ // Make a go statement.
+ static Statement*
+ make_go_statement(Call_expression* call, source_location);
+
+ // Make a defer statement.
+ static Statement*
+ make_defer_statement(Call_expression* call, source_location);
+
+ // Make a return statement.
+ static Statement*
+ make_return_statement(const Typed_identifier_list*, Expression_list*,
+ source_location);
+
+ // Make a break statement.
+ static Statement*
+ make_break_statement(Unnamed_label* label, source_location);
+
+ // Make a continue statement.
+ static Statement*
+ make_continue_statement(Unnamed_label* label, source_location);
+
+ // Make a goto statement.
+ static Statement*
+ make_goto_statement(Label* label, source_location);
+
+ // Make a goto statement to an unnamed label.
+ static Statement*
+ make_goto_unnamed_statement(Unnamed_label* label, source_location);
+
+ // Make a label statement--where the label is defined.
+ static Statement*
+ make_label_statement(Label* label, source_location);
+
+ // Make an unnamed label statement--where the label is defined.
+ static Statement*
+ make_unnamed_label_statement(Unnamed_label* label);
+
+ // Make an if statement.
+ static Statement*
+ make_if_statement(Expression* cond, Block* then_block, Block* else_block,
+ source_location);
+
+ // Make a switch statement.
+ static Switch_statement*
+ make_switch_statement(Expression* switch_val, source_location);
+
+ // Make a type switch statement.
+ static Type_switch_statement*
+ make_type_switch_statement(Named_object* var, Expression*, source_location);
+
+ // Make a send statement.
+ static Send_statement*
+ make_send_statement(Expression* channel, Expression* val, source_location);
+
+ // Make a select statement.
+ static Select_statement*
+ make_select_statement(source_location);
+
+ // Make a for statement.
+ static For_statement*
+ make_for_statement(Block* init, Expression* cond, Block* post,
+ source_location location);
+
+ // Make a for statement with a range clause.
+ static For_range_statement*
+ make_for_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location);
+
+ // Return the statement classification.
+ Statement_classification
+ classification() const
+ { return this->classification_; }
+
+ // Get the statement location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traverse the tree.
+ int
+ traverse(Block*, size_t* index, Traverse*);
+
+ // Traverse the contents of this statement--the expressions and
+ // statements which it contains.
+ int
+ traverse_contents(Traverse*);
+
+ // If this statement assigns some values, it calls a function for
+ // each value to which this statement assigns a value, and returns
+ // true. If this statement does not assign any values, it returns
+ // false.
+ bool
+ traverse_assignments(Traverse_assignments* tassign);
+
+ // Lower a statement. This is called immediately after parsing to
+ // simplify statements for further processing. It returns the same
+ // Statement or a new one. FUNCTION is the function containing this
+ // statement. BLOCK is the block containing this statement.
+ Statement*
+ lower(Gogo* gogo, Named_object* function, Block* block)
+ { return this->do_lower(gogo, function, block); }
+
+ // Set type information for unnamed constants.
+ void
+ determine_types();
+
+ // Check types in a statement. This simply checks that any
+ // expressions used by the statement have the right type.
+ void
+ check_types(Gogo* gogo)
+ { this->do_check_types(gogo); }
+
+ // Return whether this is a block statement.
+ bool
+ is_block_statement() const
+ { return this->classification_ == STATEMENT_BLOCK; }
+
+ // If this is a variable declaration statement, return it.
+ // Otherwise return NULL.
+ Variable_declaration_statement*
+ variable_declaration_statement()
+ {
+ return this->convert<Variable_declaration_statement,
+ STATEMENT_VARIABLE_DECLARATION>();
+ }
+
+ // If this is a return statement, return it. Otherwise return NULL.
+ Return_statement*
+ return_statement()
+ { return this->convert<Return_statement, STATEMENT_RETURN>(); }
+
+ // If this is a thunk statement (a go or defer statement), return
+ // it. Otherwise return NULL.
+ Thunk_statement*
+ thunk_statement();
+
+ // If this is a label statement, return it. Otherwise return NULL.
+ Label_statement*
+ label_statement()
+ { return this->convert<Label_statement, STATEMENT_LABEL>(); }
+
+ // If this is a for statement, return it. Otherwise return NULL.
+ For_statement*
+ for_statement()
+ { return this->convert<For_statement, STATEMENT_FOR>(); }
+
+ // If this is a for statement over a range clause, return it.
+ // Otherwise return NULL.
+ For_range_statement*
+ for_range_statement()
+ { return this->convert<For_range_statement, STATEMENT_FOR_RANGE>(); }
+
+ // If this is a switch statement, return it. Otherwise return NULL.
+ Switch_statement*
+ switch_statement()
+ { return this->convert<Switch_statement, STATEMENT_SWITCH>(); }
+
+ // If this is a type switch statement, return it. Otherwise return
+ // NULL.
+ Type_switch_statement*
+ type_switch_statement()
+ { return this->convert<Type_switch_statement, STATEMENT_TYPE_SWITCH>(); }
+
+ // If this is a select statement, return it. Otherwise return NULL.
+ Select_statement*
+ select_statement()
+ { return this->convert<Select_statement, STATEMENT_SELECT>(); }
+
+ // Return true if this statement may fall through--if after
+ // executing this statement we may go on to execute the following
+ // statement, if any.
+ bool
+ may_fall_through() const
+ { return this->do_may_fall_through(); }
+
+ // Return the tree for a statement. BLOCK is the enclosing block.
+ tree
+ get_tree(Translate_context*);
+
+ protected:
+ // Implemented by child class: traverse the tree.
+ virtual int
+ do_traverse(Traverse*) = 0;
+
+ // Implemented by child class: traverse assignments. Any statement
+ // which includes an assignment should implement this.
+ virtual bool
+ do_traverse_assignments(Traverse_assignments*)
+ { return false; }
+
+ // Implemented by the child class: lower this statement to a simpler
+ // one.
+ virtual Statement*
+ do_lower(Gogo*, Named_object*, Block*)
+ { return this; }
+
+ // Implemented by child class: set type information for unnamed
+ // constants. Any statement which includes an expression needs to
+ // implement this.
+ virtual void
+ do_determine_types()
+ { }
+
+ // Implemented by child class: check types of expressions used in a
+ // statement.
+ virtual void
+ do_check_types(Gogo*)
+ { }
+
+ // Implemented by child class: return true if this statement may
+ // fall through.
+ virtual bool
+ do_may_fall_through() const
+ { return true; }
+
+ // Implemented by child class: return a tree.
+ virtual tree
+ do_get_tree(Translate_context*) = 0;
+
+ // Traverse an expression in a statement.
+ int
+ traverse_expression(Traverse*, Expression**);
+
+ // Traverse an expression list in a statement. The Expression_list
+ // may be NULL.
+ int
+ traverse_expression_list(Traverse*, Expression_list*);
+
+ // Traverse a type in a statement.
+ int
+ traverse_type(Traverse*, Type*);
+
+ // Build a tree node with one operand, setting the location. The
+ // first operand really has type "enum tree_code", but that enum is
+ // not defined here.
+ tree
+ build_stmt_1(int tree_code_value, tree);
+
+ // For children to call when they detect that they are in error.
+ void
+ set_is_error();
+
+ // For children to call to report an error conveniently.
+ void
+ report_error(const char*);
+
+ // For children to return an error statement from lower().
+ static Statement*
+ make_error_statement(source_location);
+
+ private:
+ // Convert to the desired statement classification, or return NULL.
+ // This is a controlled dynamic cast.
+ template<typename Statement_class, Statement_classification sc>
+ Statement_class*
+ convert()
+ {
+ return (this->classification_ == sc
+ ? static_cast<Statement_class*>(this)
+ : NULL);
+ }
+
+ template<typename Statement_class, Statement_classification sc>
+ const Statement_class*
+ convert() const
+ {
+ return (this->classification_ == sc
+ ? static_cast<const Statement_class*>(this)
+ : NULL);
+ }
+
+ // The statement classification.
+ Statement_classification classification_;
+ // The location in the input file of the start of this statement.
+ source_location location_;
+};
+
+// A statement which creates and initializes a temporary variable.
+
+class Temporary_statement : public Statement
+{
+ public:
+ Temporary_statement(Type* type, Expression* init, source_location location)
+ : Statement(STATEMENT_TEMPORARY, location),
+ type_(type), init_(init), decl_(NULL), is_address_taken_(false)
+ { }
+
+ // Return the type of the temporary variable.
+ Type*
+ type() const;
+
+ // Return the initialization expression.
+ Expression*
+ init() const
+ { return this->init_; }
+
+ // Record that something takes the address of this temporary
+ // variable.
+ void
+ set_is_address_taken()
+ { this->is_address_taken_ = true; }
+
+ // Return the tree for the temporary variable itself. This should
+ // not be called until after the statement itself has been expanded.
+ tree
+ get_decl() const;
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The type of the temporary variable.
+ Type* type_;
+ // The initial value of the temporary variable. This may be NULL.
+ Expression* init_;
+ // The DECL for the temporary variable.
+ tree decl_;
+ // True if something takes the address of this temporary variable.
+ bool is_address_taken_;
+};
+
+// A variable declaration. This marks the point in the code where a
+// variable is declared. The Variable is also attached to a Block.
+
+class Variable_declaration_statement : public Statement
+{
+ public:
+ Variable_declaration_statement(Named_object* var);
+
+ // The variable being declared.
+ Named_object*
+ var()
+ { return this->var_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ Named_object* var_;
+};
+
+// A return statement.
+
+class Return_statement : public Statement
+{
+ public:
+ Return_statement(const Typed_identifier_list* results, Expression_list* vals,
+ source_location location)
+ : Statement(STATEMENT_RETURN, location),
+ results_(results), vals_(vals)
+ { }
+
+ // The list of values being returned. This may be NULL.
+ const Expression_list*
+ vals() const
+ { return this->vals_; }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->traverse_expression_list(traverse, this->vals_); }
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ bool
+ do_may_fall_through() const
+ { return false; }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The result types of the function we are returning from. This is
+ // here because in some of the traversals it is inconvenient to get
+ // it.
+ const Typed_identifier_list* results_;
+ // Return values. This may be NULL.
+ Expression_list* vals_;
+};
+
+// A send statement.
+
+class Send_statement : public Statement
+{
+ public:
+ Send_statement(Expression* channel, Expression* val,
+ source_location location)
+ : Statement(STATEMENT_SEND, location),
+ channel_(channel), val_(val), for_select_(false)
+ { }
+
+ // Note that this is for a select statement.
+ void
+ set_for_select()
+ { this->for_select_ = true; }
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The channel on which to send the value.
+ Expression* channel_;
+ // The value to send.
+ Expression* val_;
+ // Whether this is for a select statement.
+ bool for_select_;
+};
+
+// Select_clauses holds the clauses of a select statement. This is
+// built by the parser.
+
+class Select_clauses
+{
+ public:
+ Select_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. IS_SEND is true if this is a send clause,
+ // false for a receive clause. For a send clause CHANNEL is the
+ // channel and VAL is the value to send. For a receive clause
+ // CHANNEL is the channel, VAL is either NULL or a Var_expression
+ // for the variable to set, and CLOSED is either NULL or a
+ // Var_expression to set to whether the channel is closed. If VAL
+ // is NULL, VAR may be a variable to be initialized with the
+ // received value, and CLOSEDVAR ma be a variable to be initialized
+ // with whether the channel is closed. IS_DEFAULT is true if this
+ // is the default clause. STATEMENTS is the list of statements to
+ // execute.
+ void
+ add(bool is_send, Expression* channel, Expression* val, Expression* closed,
+ Named_object* var, Named_object* closedvar, bool is_default,
+ Block* statements, source_location location)
+ {
+ this->clauses_.push_back(Select_clause(is_send, channel, val, closed, var,
+ closedvar, is_default, statements,
+ location));
+ }
+
+ // Traverse the select clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Gogo*, Named_object*, Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Whether the select clauses may fall through to the statement
+ // which follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Return a tree implementing the select statement.
+ tree
+ get_tree(Translate_context*, Unnamed_label* break_label, source_location);
+
+ private:
+ // A single clause.
+ class Select_clause
+ {
+ public:
+ Select_clause()
+ : channel_(NULL), val_(NULL), closed_(NULL), var_(NULL),
+ closedvar_(NULL), statements_(NULL), is_send_(false),
+ is_default_(false)
+ { }
+
+ Select_clause(bool is_send, Expression* channel, Expression* val,
+ Expression* closed, Named_object* var,
+ Named_object* closedvar, bool is_default, Block* statements,
+ source_location location)
+ : channel_(channel), val_(val), closed_(closed), var_(var),
+ closedvar_(closedvar), statements_(statements), location_(location),
+ is_send_(is_send), is_default_(is_default), is_lowered_(false)
+ { gcc_assert(is_default ? channel == NULL : channel != NULL); }
+
+ // Traverse the select clause.
+ int
+ traverse(Traverse*);
+
+ // Lower statements.
+ void
+ lower(Gogo*, Named_object*, Block*);
+
+ // Determine types.
+ void
+ determine_types();
+
+ // Return true if this is the default clause.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // Return the channel. This will return NULL for the default
+ // clause.
+ Expression*
+ channel() const
+ { return this->channel_; }
+
+ // Return true for a send, false for a receive.
+ bool
+ is_send() const
+ {
+ gcc_assert(!this->is_default_);
+ return this->is_send_;
+ }
+
+ // Return the statements.
+ const Block*
+ statements() const
+ { return this->statements_; }
+
+ // Return the location.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Whether this clause may fall through to the statement which
+ // follows the overall select statement.
+ bool
+ may_fall_through() const;
+
+ // Return a tree for the statements to execute.
+ tree
+ get_statements_tree(Translate_context*);
+
+ private:
+ // The channel.
+ Expression* channel_;
+ // The value to send or the lvalue to receive into.
+ Expression* val_;
+ // The lvalue to set to whether the channel is closed on a
+ // receive.
+ Expression* closed_;
+ // The variable to initialize, for "case a := <-ch".
+ Named_object* var_;
+ // The variable to initialize to whether the channel is closed,
+ // for "case a, c := <-ch".
+ Named_object* closedvar_;
+ // The statements to execute.
+ Block* statements_;
+ // The location of this clause.
+ source_location location_;
+ // Whether this is a send or a receive.
+ bool is_send_;
+ // Whether this is the default.
+ bool is_default_;
+ // Whether this has been lowered.
+ bool is_lowered_;
+ };
+
+ void
+ add_clause_tree(Translate_context*, int, Select_clause*, Unnamed_label*,
+ tree*);
+
+ typedef std::vector<Select_clause> Clauses;
+
+ Clauses clauses_;
+};
+
+// A select statement.
+
+class Select_statement : public Statement
+{
+ public:
+ Select_statement(source_location location)
+ : Statement(STATEMENT_SELECT, location),
+ clauses_(NULL), break_label_(NULL), is_lowered_(false)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Select_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this select statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse* traverse)
+ { return this->clauses_->traverse(traverse); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ void
+ do_determine_types()
+ { this->clauses_->determine_types(); }
+
+ bool
+ do_may_fall_through() const
+ { return this->clauses_->may_fall_through(); }
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The select clauses.
+ Select_clauses* clauses_;
+ // The break label.
+ Unnamed_label* break_label_;
+ // Whether this statement has been lowered.
+ bool is_lowered_;
+};
+
+// A statement which requires a thunk: go or defer.
+
+class Thunk_statement : public Statement
+{
+ public:
+ Thunk_statement(Statement_classification, Call_expression*,
+ source_location);
+
+ // Return the call expression.
+ Expression*
+ call()
+ { return this->call_; }
+
+ // Simplify a go or defer statement so that it only uses a single
+ // parameter.
+ bool
+ simplify_statement(Gogo*, Block*);
+
+ protected:
+ int
+ do_traverse(Traverse* traverse);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*);
+
+ void
+ do_determine_types();
+
+ void
+ do_check_types(Gogo*);
+
+ // Return the function and argument trees for the call.
+ void
+ get_fn_and_arg(Translate_context*, tree* pfn, tree* parg);
+
+ private:
+ // Return whether this is a simple go statement.
+ bool
+ is_simple(Function_type*) const;
+
+ // Build the struct to use for a complex case.
+ Struct_type*
+ build_struct(Function_type* fntype);
+
+ // Build the thunk.
+ void
+ build_thunk(Gogo*, const std::string&, Function_type* fntype);
+
+ // The field name used in the thunk structure for the function
+ // pointer.
+ static const char* const thunk_field_fn;
+
+ // The field name used in the thunk structure for the receiver, if
+ // there is one.
+ static const char* const thunk_field_receiver;
+
+ // Set the name to use for thunk field N.
+ void
+ thunk_field_param(int n, char* buf, size_t buflen);
+
+ // The function call to be executed in a separate thread (go) or
+ // later (defer).
+ Expression* call_;
+ // The type used for a struct to pass to a thunk, if this is not a
+ // simple call.
+ Struct_type* struct_type_;
+};
+
+// A go statement.
+
+class Go_statement : public Thunk_statement
+{
+ public:
+ Go_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_GO, call, location)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// A defer statement.
+
+class Defer_statement : public Thunk_statement
+{
+ public:
+ Defer_statement(Call_expression* call, source_location location)
+ : Thunk_statement(STATEMENT_DEFER, call, location)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Translate_context*);
+};
+
+// A label statement.
+
+class Label_statement : public Statement
+{
+ public:
+ Label_statement(Label* label, source_location location)
+ : Statement(STATEMENT_LABEL, location),
+ label_(label)
+ { }
+
+ // Return the label itself.
+ const Label*
+ label() const
+ { return this->label_; }
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ tree
+ do_get_tree(Translate_context*);
+
+ private:
+ // The label.
+ Label* label_;
+};
+
+// A for statement.
+
+class For_statement : public Statement
+{
+ public:
+ For_statement(Block* init, Expression* cond, Block* post,
+ source_location location)
+ : Statement(STATEMENT_FOR, location),
+ init_(init), cond_(cond), post_(post), statements_(NULL),
+ break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ gcc_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ // Set the break and continue labels for this statement.
+ void
+ set_break_continue_labels(Unnamed_label* break_label,
+ Unnamed_label* continue_label);
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The initialization statements. This may be NULL.
+ Block* init_;
+ // The condition. This may be NULL.
+ Expression* cond_;
+ // The statements to run after each iteration. This may be NULL.
+ Block* post_;
+ // The statements in the loop itself.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// A for statement over a range clause.
+
+class For_range_statement : public Statement
+{
+ public:
+ For_range_statement(Expression* index_var, Expression* value_var,
+ Expression* range, source_location location)
+ : Statement(STATEMENT_FOR_RANGE, location),
+ index_var_(index_var), value_var_(value_var), range_(range),
+ statements_(NULL), break_label_(NULL), continue_label_(NULL)
+ { }
+
+ // Add the statements.
+ void
+ add_statements(Block* statements)
+ {
+ gcc_assert(this->statements_ == NULL);
+ this->statements_ = statements;
+ }
+
+ // Return the break label for this for statement.
+ Unnamed_label*
+ break_label();
+
+ // Return the continue label for this for statement.
+ Unnamed_label*
+ continue_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ bool
+ do_traverse_assignments(Traverse_assignments*)
+ { gcc_unreachable(); }
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ Expression*
+ make_range_ref(Named_object*, Temporary_statement*, source_location);
+
+ Expression*
+ call_builtin(Gogo*, const char* funcname, Expression* arg, source_location);
+
+ void
+ lower_range_array(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_string(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_map(Gogo*, Block*, Block*, Named_object*, Temporary_statement*,
+ Temporary_statement*, Temporary_statement*,
+ Block**, Expression**, Block**, Block**);
+
+ void
+ lower_range_channel(Gogo*, Block*, Block*, Named_object*,
+ Temporary_statement*, Temporary_statement*,
+ Temporary_statement*, Block**, Expression**, Block**,
+ Block**);
+
+ // The variable which is set to the index value.
+ Expression* index_var_;
+ // The variable which is set to the element value. This may be
+ // NULL.
+ Expression* value_var_;
+ // The expression we are ranging over.
+ Expression* range_;
+ // The statements in the block.
+ Block* statements_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+ // The continue label, if needed.
+ Unnamed_label* continue_label_;
+};
+
+// Class Case_clauses holds the clauses of a switch statement. This
+// is built by the parser.
+
+class Case_clauses
+{
+ public:
+ Case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. CASES is a list of case expressions; it may be
+ // NULL. IS_DEFAULT is true if this is the default case.
+ // STATEMENTS is a block of statements. IS_FALLTHROUGH is true if
+ // after the statements the case clause should fall through to the
+ // next clause.
+ void
+ add(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ {
+ this->clauses_.push_back(Case_clause(cases, is_default, statements,
+ is_fallthrough, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the case clauses.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*) const;
+
+ // Determine types of expressions. The Type parameter is the type
+ // of the switch value.
+ void
+ determine_types(Type*);
+
+ // Check types. The Type parameter is the type of the switch value.
+ bool
+ check_types(Type*);
+
+ // Return true if all the clauses are constant values.
+ bool
+ is_constant() const;
+
+ // Return true if these clauses may fall through to the statements
+ // following the switch statement.
+ bool
+ may_fall_through() const;
+
+ // Return the body of a SWITCH_EXPR when all the clauses are
+ // constants.
+ tree
+ get_constant_tree(Translate_context*, Unnamed_label* break_label) const;
+
+ private:
+ // For a constant tree we need to keep a record of constants we have
+ // already seen. Note that INTEGER_CST trees are interned.
+ typedef Unordered_set(tree) Case_constants;
+
+ // One case clause.
+ class Case_clause
+ {
+ public:
+ Case_clause()
+ : cases_(NULL), statements_(NULL), is_default_(false),
+ is_fallthrough_(false), location_(UNKNOWN_LOCATION)
+ { }
+
+ Case_clause(Expression_list* cases, bool is_default, Block* statements,
+ bool is_fallthrough, source_location location)
+ : cases_(cases), statements_(statements), is_default_(is_default),
+ is_fallthrough_(is_fallthrough), location_(location)
+ { }
+
+ // Whether this clause falls through to the next clause.
+ bool
+ is_fallthrough() const
+ { return this->is_fallthrough_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower for a nonconstant switch.
+ void
+ lower(Block*, Temporary_statement*, Unnamed_label*, Unnamed_label*) const;
+
+ // Determine types.
+ void
+ determine_types(Type*);
+
+ // Check types.
+ bool
+ check_types(Type*);
+
+ // Return true if all the case expressions are constant.
+ bool
+ is_constant() const;
+
+ // Return true if this clause may fall through to execute the
+ // statements following the switch statement. This is not the
+ // same as whether this clause falls through to the next clause.
+ bool
+ may_fall_through() const;
+
+ // Build up the body of a SWITCH_EXPR when the case expressions
+ // are constant.
+ void
+ get_constant_tree(Translate_context*, Unnamed_label* break_label,
+ Case_constants* case_constants, tree* stmt_list) const;
+
+ private:
+ // The list of case expressions.
+ Expression_list* cases_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this is the default case.
+ bool is_default_;
+ // Whether this falls through after the statements.
+ bool is_fallthrough_;
+ // The location of this case clause.
+ source_location location_;
+ };
+
+ friend class Case_clause;
+
+ // The type of the list of clauses.
+ typedef std::vector<Case_clause> Clauses;
+
+ // All the case clauses.
+ Clauses clauses_;
+};
+
+// A switch statement.
+
+class Switch_statement : public Statement
+{
+ public:
+ Switch_statement(Expression* val, source_location location)
+ : Statement(STATEMENT_SWITCH, location),
+ val_(val), clauses_(NULL), break_label_(NULL)
+ { }
+
+ // Add the clauses.
+ void
+ add_clauses(Case_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // The value to switch on. This may be NULL.
+ Expression* val_;
+ // The case clauses.
+ Case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+// Class Type_case_clauses holds the clauses of a type switch
+// statement. This is built by the parser.
+
+class Type_case_clauses
+{
+ public:
+ Type_case_clauses()
+ : clauses_()
+ { }
+
+ // Add a new clause. TYPE is the type for this clause; it may be
+ // NULL. IS_FALLTHROUGH is true if this falls through to the next
+ // clause; in this case STATEMENTS will be NULL. IS_DEFAULT is true
+ // if this is the default case. STATEMENTS is a block of
+ // statements; it may be NULL.
+ void
+ add(Type* type, bool is_fallthrough, bool is_default, Block* statements,
+ source_location location)
+ {
+ this->clauses_.push_back(Type_case_clause(type, is_fallthrough, is_default,
+ statements, location));
+ }
+
+ // Return whether there are no clauses.
+ bool
+ empty() const
+ { return this->clauses_.empty(); }
+
+ // Traverse the type case clauses.
+ int
+ traverse(Traverse*);
+
+ // Check for duplicates.
+ void
+ check_duplicates() const;
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label) const;
+
+ private:
+ // One type case clause.
+ class Type_case_clause
+ {
+ public:
+ Type_case_clause()
+ : type_(NULL), statements_(NULL), is_default_(false),
+ location_(UNKNOWN_LOCATION)
+ { }
+
+ Type_case_clause(Type* type, bool is_fallthrough, bool is_default,
+ Block* statements, source_location location)
+ : type_(type), statements_(statements), is_fallthrough_(is_fallthrough),
+ is_default_(is_default), location_(location)
+ { }
+
+ // The type.
+ Type*
+ type() const
+ { return this->type_; }
+
+ // Whether this is the default.
+ bool
+ is_default() const
+ { return this->is_default_; }
+
+ // The location of this type clause.
+ source_location
+ location() const
+ { return this->location_; }
+
+ // Traversal.
+ int
+ traverse(Traverse*);
+
+ // Lower to if and goto statements.
+ void
+ lower(Block*, Temporary_statement* descriptor_temp,
+ Unnamed_label* break_label, Unnamed_label** stmts_label) const;
+
+ private:
+ // The type for this type clause.
+ Type* type_;
+ // The statements to execute.
+ Block* statements_;
+ // Whether this falls through--this is true for "case T1, T2".
+ bool is_fallthrough_;
+ // Whether this is the default case.
+ bool is_default_;
+ // The location of this type case clause.
+ source_location location_;
+ };
+
+ friend class Type_case_clause;
+
+ // The type of the list of type clauses.
+ typedef std::vector<Type_case_clause> Type_clauses;
+
+ // All the type case clauses.
+ Type_clauses clauses_;
+};
+
+// A type switch statement.
+
+class Type_switch_statement : public Statement
+{
+ public:
+ Type_switch_statement(Named_object* var, Expression* expr,
+ source_location location)
+ : Statement(STATEMENT_TYPE_SWITCH, location),
+ var_(var), expr_(expr), clauses_(NULL), break_label_(NULL)
+ { gcc_assert(var == NULL || expr == NULL); }
+
+ // Add the clauses.
+ void
+ add_clauses(Type_case_clauses* clauses)
+ {
+ gcc_assert(this->clauses_ == NULL);
+ this->clauses_ = clauses;
+ }
+
+ // Return the break label for this type switch statement.
+ Unnamed_label*
+ break_label();
+
+ protected:
+ int
+ do_traverse(Traverse*);
+
+ Statement*
+ do_lower(Gogo*, Named_object*, Block*);
+
+ tree
+ do_get_tree(Translate_context*)
+ { gcc_unreachable(); }
+
+ private:
+ // Get the type descriptor.
+ tree
+ get_type_descriptor(Translate_context*, Type*, tree);
+
+ // The variable holding the value we are switching on.
+ Named_object* var_;
+ // The expression we are switching on if there is no variable.
+ Expression* expr_;
+ // The type case clauses.
+ Type_case_clauses* clauses_;
+ // The break label, if needed.
+ Unnamed_label* break_label_;
+};
+
+#endif // !defined(GO_STATEMENTS_H)
--- /dev/null
+// types.cc -- Go frontend types.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "real.h"
+#include "convert.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "operator.h"
+#include "expressions.h"
+#include "statements.h"
+#include "export.h"
+#include "import.h"
+#include "types.h"
+
+// Class Type.
+
+Type::Type(Type_classification classification)
+ : classification_(classification), tree_(NULL_TREE),
+ type_descriptor_decl_(NULL_TREE)
+{
+}
+
+Type::~Type()
+{
+}
+
+// Get the base type for a type--skip names and forward declarations.
+
+Type*
+Type::base()
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return static_cast<Named_type*>(this)->real_type()->base();
+ case TYPE_FORWARD:
+ return static_cast<Forward_declaration_type*>(this)->real_type()->base();
+ default:
+ return this;
+ }
+}
+
+const Type*
+Type::base() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return static_cast<const Named_type*>(this)->real_type()->base();
+ case TYPE_FORWARD:
+ {
+ const Forward_declaration_type* ftype =
+ static_cast<const Forward_declaration_type*>(this);
+ return ftype->real_type()->base();
+ }
+ default:
+ return this;
+ }
+}
+
+// Skip defined forward declarations.
+
+Type*
+Type::forwarded()
+{
+ Type* t = this;
+ Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+const Type*
+Type::forwarded() const
+{
+ const Type* t = this;
+ const Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+// If this is a named type, return it. Otherwise, return NULL.
+
+Named_type*
+Type::named_type()
+{
+ return this->forwarded()->convert_no_base<Named_type, TYPE_NAMED>();
+}
+
+const Named_type*
+Type::named_type() const
+{
+ return this->forwarded()->convert_no_base<const Named_type, TYPE_NAMED>();
+}
+
+// Return true if this type is not defined.
+
+bool
+Type::is_undefined() const
+{
+ return this->forwarded()->forward_declaration_type() != NULL;
+}
+
+// Return true if this is a basic type: a type which is not composed
+// of other types, and is not void.
+
+bool
+Type::is_basic_type() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ return true;
+
+ case TYPE_ERROR:
+ case TYPE_VOID:
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ case TYPE_STRUCT:
+ case TYPE_ARRAY:
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ case TYPE_INTERFACE:
+ return false;
+
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ return this->base()->is_basic_type();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if this is an abstract type.
+
+bool
+Type::is_abstract() const
+{
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return this->integer_type()->is_abstract();
+ case TYPE_FLOAT:
+ return this->float_type()->is_abstract();
+ case TYPE_COMPLEX:
+ return this->complex_type()->is_abstract();
+ case TYPE_STRING:
+ return this->is_abstract_string_type();
+ case TYPE_BOOLEAN:
+ return this->is_abstract_boolean_type();
+ default:
+ return false;
+ }
+}
+
+// Return a non-abstract version of an abstract type.
+
+Type*
+Type::make_non_abstract_type()
+{
+ gcc_assert(this->is_abstract());
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return Type::lookup_integer_type("int");
+ case TYPE_FLOAT:
+ return Type::lookup_float_type("float");
+ case TYPE_COMPLEX:
+ return Type::lookup_complex_type("complex");
+ case TYPE_STRING:
+ return Type::lookup_string_type();
+ case TYPE_BOOLEAN:
+ return Type::lookup_bool_type();
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if this is an error type. Don't give an error if we
+// try to dereference an undefined forwarding type, as this is called
+// in the parser when the type may legitimately be undefined.
+
+bool
+Type::is_error_type() const
+{
+ const Type* t = this->forwarded();
+ // Note that we return false for an undefined forward type.
+ switch (t->classification_)
+ {
+ case TYPE_ERROR:
+ return true;
+ case TYPE_NAMED:
+ return t->named_type()->real_type()->is_error_type();
+ default:
+ return false;
+ }
+}
+
+// If this is a pointer type, return the type to which it points.
+// Otherwise, return NULL.
+
+Type*
+Type::points_to() const
+{
+ const Pointer_type* ptype = this->convert<const Pointer_type,
+ TYPE_POINTER>();
+ return ptype == NULL ? NULL : ptype->points_to();
+}
+
+// Return whether this is an open array type.
+
+bool
+Type::is_open_array_type() const
+{
+ return this->array_type() != NULL && this->array_type()->length() == NULL;
+}
+
+// Return whether this is the predeclared constant nil being used as a
+// type.
+
+bool
+Type::is_nil_constant_as_type() const
+{
+ const Type* t = this->forwarded();
+ if (t->forward_declaration_type() != NULL)
+ {
+ const Named_object* no = t->forward_declaration_type()->named_object();
+ if (no->is_unknown())
+ no = no->unknown_value()->real_named_object();
+ if (no != NULL
+ && no->is_const()
+ && no->const_value()->expr()->is_nil_expression())
+ return true;
+ }
+ return false;
+}
+
+// Traverse a type.
+
+int
+Type::traverse(Type* type, Traverse* traverse)
+{
+ gcc_assert((traverse->traverse_mask() & Traverse::traverse_types) != 0
+ || (traverse->traverse_mask()
+ & Traverse::traverse_expressions) != 0);
+ if (traverse->remember_type(type))
+ {
+ // We have already traversed this type.
+ return TRAVERSE_CONTINUE;
+ }
+ if ((traverse->traverse_mask() & Traverse::traverse_types) != 0)
+ {
+ int t = traverse->type(type);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ // An array type has an expression which we need to traverse if
+ // traverse_expressions is set.
+ if (type->do_traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Default implementation for do_traverse for child class.
+
+int
+Type::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether two types are identical. If REASON is not NULL,
+// optionally set *REASON to the reason the types are not identical.
+
+bool
+Type::are_identical(const Type* t1, const Type* t2, std::string* reason)
+{
+ if (t1 == NULL || t2 == NULL)
+ {
+ // Something is wrong. Return true to avoid cascading errors.
+ return true;
+ }
+
+ // Skip defined forward declarations.
+ t1 = t1->forwarded();
+ t2 = t2->forwarded();
+
+ if (t1 == t2)
+ return true;
+
+ // An undefined forward declaration is an error, so we return true
+ // to avoid cascading errors.
+ if (t1->forward_declaration_type() != NULL
+ || t2->forward_declaration_type() != NULL)
+ return true;
+
+ // Avoid cascading errors with error types.
+ if (t1->is_error_type() || t2->is_error_type())
+ return true;
+
+ // Get a good reason for the sink type. Note that the sink type on
+ // the left hand side of an assignment is handled in are_assignable.
+ if (t1->is_sink_type() || t2->is_sink_type())
+ {
+ if (reason != NULL)
+ *reason = "invalid use of _";
+ return false;
+ }
+
+ // A named type is only identical to itself.
+ if (t1->named_type() != NULL || t2->named_type() != NULL)
+ return false;
+
+ // Check type shapes.
+ if (t1->classification() != t2->classification())
+ return false;
+
+ switch (t1->classification())
+ {
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These types are always identical.
+ return true;
+
+ case TYPE_INTEGER:
+ return t1->integer_type()->is_identical(t2->integer_type());
+
+ case TYPE_FLOAT:
+ return t1->float_type()->is_identical(t2->float_type());
+
+ case TYPE_COMPLEX:
+ return t1->complex_type()->is_identical(t2->complex_type());
+
+ case TYPE_FUNCTION:
+ return t1->function_type()->is_identical(t2->function_type(),
+ false,
+ reason);
+
+ case TYPE_POINTER:
+ return Type::are_identical(t1->points_to(), t2->points_to(), reason);
+
+ case TYPE_STRUCT:
+ return t1->struct_type()->is_identical(t2->struct_type());
+
+ case TYPE_ARRAY:
+ return t1->array_type()->is_identical(t2->array_type());
+
+ case TYPE_MAP:
+ return t1->map_type()->is_identical(t2->map_type());
+
+ case TYPE_CHANNEL:
+ return t1->channel_type()->is_identical(t2->channel_type());
+
+ case TYPE_INTERFACE:
+ return t1->interface_type()->is_identical(t2->interface_type());
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if it's OK to have a binary operation with types LHS
+// and RHS. This is not used for shifts or comparisons.
+
+bool
+Type::are_compatible_for_binop(const Type* lhs, const Type* rhs)
+{
+ if (Type::are_identical(lhs, rhs, NULL))
+ return true;
+
+ // A constant of abstract bool type may be mixed with any bool type.
+ if ((rhs->is_abstract_boolean_type() && lhs->is_boolean_type())
+ || (lhs->is_abstract_boolean_type() && rhs->is_boolean_type()))
+ return true;
+
+ // A constant of abstract string type may be mixed with any string
+ // type.
+ if ((rhs->is_abstract_string_type() && lhs->is_string_type())
+ || (lhs->is_abstract_string_type() && rhs->is_string_type()))
+ return true;
+
+ lhs = lhs->base();
+ rhs = rhs->base();
+
+ // A constant of abstract integer, float, or complex type may be
+ // mixed with an integer, float, or complex type.
+ if ((rhs->is_abstract()
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ || (lhs->is_abstract()
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL)
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)))
+ return true;
+
+ // The nil type may be compared to a pointer, an interface type, a
+ // slice type, a channel type, a map type, or a function type.
+ if (lhs->is_nil_type()
+ && (rhs->points_to() != NULL
+ || rhs->interface_type() != NULL
+ || rhs->is_open_array_type()
+ || rhs->map_type() != NULL
+ || rhs->channel_type() != NULL
+ || rhs->function_type() != NULL))
+ return true;
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->interface_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->function_type() != NULL))
+ return true;
+
+ return false;
+}
+
+// Return true if a value with type RHS may be assigned to a variable
+// with type LHS. If REASON is not NULL, set *REASON to the reason
+// the types are not assignable.
+
+bool
+Type::are_assignable(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ // Do some checks first. Make sure the types are defined.
+ if (lhs != NULL && lhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ // Any value may be assigned to the blank identifier.
+ if (lhs->is_sink_type())
+ return true;
+
+ // All fields of a struct must be exported, or the assignment
+ // must be in the same package.
+ if (rhs != NULL && rhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ if (lhs->has_hidden_fields(NULL, reason)
+ || rhs->has_hidden_fields(NULL, reason))
+ return false;
+ }
+ }
+
+ // Identical types are assignable.
+ if (Type::are_identical(lhs, rhs, reason))
+ return true;
+
+ // The types are assignable if they have identical underlying types
+ // and either LHS or RHS is not a named type.
+ if (((lhs->named_type() != NULL && rhs->named_type() == NULL)
+ || (rhs->named_type() != NULL && lhs->named_type() == NULL))
+ && Type::are_identical(lhs->base(), rhs->base(), reason))
+ return true;
+
+ // The types are assignable if LHS is an interface type and RHS
+ // implements the required methods.
+ const Interface_type* lhs_interface_type = lhs->interface_type();
+ if (lhs_interface_type != NULL)
+ {
+ if (lhs_interface_type->implements_interface(rhs, reason))
+ return true;
+ const Interface_type* rhs_interface_type = rhs->interface_type();
+ if (rhs_interface_type != NULL
+ && lhs_interface_type->is_compatible_for_assign(rhs_interface_type,
+ reason))
+ return true;
+ }
+
+ // The type are assignable if RHS is a bidirectional channel type,
+ // LHS is a channel type, they have identical element types, and
+ // either LHS or RHS is not a named type.
+ if (lhs->channel_type() != NULL
+ && rhs->channel_type() != NULL
+ && rhs->channel_type()->may_send()
+ && rhs->channel_type()->may_receive()
+ && (lhs->named_type() == NULL || rhs->named_type() == NULL)
+ && Type::are_identical(lhs->channel_type()->element_type(),
+ rhs->channel_type()->element_type(),
+ reason))
+ return true;
+
+ // The nil type may be assigned to a pointer, function, slice, map,
+ // channel, or interface type.
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->function_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->interface_type() != NULL))
+ return true;
+
+ // An untyped constant may be assigned to a numeric type if it is
+ // representable in that type.
+ if (rhs->is_abstract()
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ return true;
+
+
+ // Give some better error messages.
+ if (reason != NULL && reason->empty())
+ {
+ if (rhs->interface_type() != NULL)
+ reason->assign(_("need explicit conversion"));
+ else if (rhs->is_call_multiple_result_type())
+ reason->assign(_("multiple value function call in "
+ "single value context"));
+ else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
+ {
+ size_t len = (lhs->named_type()->name().length()
+ + rhs->named_type()->name().length()
+ + 100);
+ char* buf = new char[len];
+ snprintf(buf, len, _("cannot use type %s as type %s"),
+ rhs->named_type()->message_name().c_str(),
+ lhs->named_type()->message_name().c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ }
+
+ return false;
+}
+
+// Return true if a value with type RHS may be converted to type LHS.
+// If REASON is not NULL, set *REASON to the reason the types are not
+// convertible.
+
+bool
+Type::are_convertible(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ // The types are convertible if they are assignable.
+ if (Type::are_assignable(lhs, rhs, reason))
+ return true;
+
+ // The types are convertible if they have identical underlying
+ // types.
+ if ((lhs->named_type() != NULL || rhs->named_type() != NULL)
+ && Type::are_identical(lhs->base(), rhs->base(), reason))
+ return true;
+
+ // The types are convertible if they are both unnamed pointer types
+ // and their pointer base types have identical underlying types.
+ if (lhs->named_type() == NULL
+ && rhs->named_type() == NULL
+ && lhs->points_to() != NULL
+ && rhs->points_to() != NULL
+ && (lhs->points_to()->named_type() != NULL
+ || rhs->points_to()->named_type() != NULL)
+ && Type::are_identical(lhs->points_to()->base(),
+ rhs->points_to()->base(),
+ reason))
+ return true;
+
+ // Integer and floating point types are convertible to each other.
+ if ((lhs->integer_type() != NULL || lhs->float_type() != NULL)
+ && (rhs->integer_type() != NULL || rhs->float_type() != NULL))
+ return true;
+
+ // Complex types are convertible to each other.
+ if (lhs->complex_type() != NULL && rhs->complex_type() != NULL)
+ return true;
+
+ // An integer, or []byte, or []int, may be converted to a string.
+ if (lhs->is_string_type())
+ {
+ if (rhs->integer_type() != NULL)
+ return true;
+ if (rhs->is_open_array_type() && rhs->named_type() == NULL)
+ {
+ const Type* e = rhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+ }
+
+ // A string may be converted to []byte or []int.
+ if (rhs->is_string_type()
+ && lhs->is_open_array_type()
+ && lhs->named_type() == NULL)
+ {
+ const Type* e = lhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+
+ // An unsafe.Pointer type may be converted to any pointer type or to
+ // uintptr, and vice-versa.
+ if (lhs->is_unsafe_pointer_type()
+ && (rhs->points_to() != NULL
+ || (rhs->integer_type() != NULL
+ && rhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+ if (rhs->is_unsafe_pointer_type()
+ && (lhs->points_to() != NULL
+ || (lhs->integer_type() != NULL
+ && lhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+
+ // Give a better error message.
+ if (reason != NULL)
+ {
+ if (reason->empty())
+ *reason = "invalid type conversion";
+ else
+ {
+ std::string s = "invalid type conversion (";
+ s += *reason;
+ s += ')';
+ *reason = s;
+ }
+ }
+
+ return false;
+}
+
+// Return whether this type has any hidden fields. This is only a
+// possibility for a few types.
+
+bool
+Type::has_hidden_fields(const Named_type* within, std::string* reason) const
+{
+ switch (this->forwarded()->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_type_has_hidden_fields(reason);
+ case TYPE_STRUCT:
+ return this->struct_type()->struct_has_hidden_fields(within, reason);
+ case TYPE_ARRAY:
+ return this->array_type()->array_has_hidden_fields(within, reason);
+ default:
+ return false;
+ }
+}
+
+// Return a hash code for the type to be used for method lookup.
+
+unsigned int
+Type::hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->classification_ != TYPE_FORWARD)
+ ret += this->classification_;
+ return ret + this->do_hash_for_method(gogo);
+}
+
+// Default implementation of do_hash_for_method. This is appropriate
+// for types with no subfields.
+
+unsigned int
+Type::do_hash_for_method(Gogo*) const
+{
+ return 0;
+}
+
+// Return a hash code for a string, given a starting hash.
+
+unsigned int
+Type::hash_string(const std::string& s, unsigned int h)
+{
+ const char* p = s.data();
+ size_t len = s.length();
+ for (; len > 0; --len)
+ {
+ h ^= *p++;
+ h*= 16777619;
+ }
+ return h;
+}
+
+// Default check for the expression passed to make. Any type which
+// may be used with make implements its own version of this.
+
+bool
+Type::do_check_make_expression(Expression_list*, source_location)
+{
+ gcc_unreachable();
+}
+
+// Return whether an expression has an integer value. Report an error
+// if not. This is used when handling calls to the predeclared make
+// function.
+
+bool
+Type::check_int_value(Expression* e, const char* errmsg,
+ source_location location)
+{
+ if (e->type()->integer_type() != NULL)
+ return true;
+
+ // Check for a floating point constant with integer value.
+ mpfr_t fval;
+ mpfr_init(fval);
+
+ Type* dummy;
+ if (e->float_constant_value(fval, &dummy))
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ bool ok = false;
+
+ mpfr_clear_overflow();
+ mpfr_clear_erangeflag();
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!mpfr_overflow_p()
+ && !mpfr_erangeflag_p()
+ && mpz_sgn(ival) >= 0)
+ {
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ }
+ mpz_clear(ival);
+
+ if (ok)
+ {
+ mpfr_clear(fval);
+ return true;
+ }
+ }
+
+ mpfr_clear(fval);
+
+ error_at(location, "%s", errmsg);
+ return false;
+}
+
+// A hash table mapping unnamed types to trees.
+
+Type::Type_trees Type::type_trees;
+
+// Return a tree representing this type.
+
+tree
+Type::get_tree(Gogo* gogo)
+{
+ if (this->tree_ != NULL)
+ return this->tree_;
+
+ if (this->forward_declaration_type() != NULL
+ || this->named_type() != NULL)
+ return this->get_tree_without_hash(gogo);
+
+ // To avoid confusing GIMPLE, we need to translate all identical Go
+ // types to the same GIMPLE type. We use a hash table to do that.
+ // There is no need to use the hash table for named types, as named
+ // types are only identical to themselves.
+
+ std::pair<Type*, tree> val(this, NULL);
+ std::pair<Type_trees::iterator, bool> ins =
+ Type::type_trees.insert(val);
+ if (!ins.second && ins.first->second != NULL_TREE)
+ {
+ this->tree_ = ins.first->second;
+ return this->tree_;
+ }
+
+ tree t = this->get_tree_without_hash(gogo);
+
+ if (ins.first->second == NULL_TREE)
+ ins.first->second = t;
+ else
+ {
+ // We have already created a tree for this type. This can
+ // happen when an unnamed type is defined using a named type
+ // which in turns uses an identical unnamed type. Use the tree
+ // we created earlier and ignore the one we just built.
+ t = ins.first->second;
+ this->tree_ = t;
+ }
+
+ return t;
+}
+
+// Return a tree for a type without looking in the hash table for
+// identical types. This is used for named types, since there is no
+// point to looking in the hash table for them.
+
+tree
+Type::get_tree_without_hash(Gogo* gogo)
+{
+ if (this->tree_ == NULL_TREE)
+ {
+ tree t = this->do_get_tree(gogo);
+
+ // For a recursive function or pointer type, we will temporarily
+ // return ptr_type_node during the recursion. We don't want to
+ // record that for a forwarding type, as it may confuse us
+ // later.
+ if (t == ptr_type_node && this->forward_declaration_type() != NULL)
+ return t;
+
+ this->tree_ = t;
+ go_preserve_from_gc(t);
+ }
+
+ return this->tree_;
+}
+
+// Return a tree representing a zero initialization for this type.
+
+tree
+Type::get_init_tree(Gogo* gogo, bool is_clear)
+{
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ return this->do_get_init_tree(gogo, type_tree, is_clear);
+}
+
+// Any type which supports the builtin make function must implement
+// this.
+
+tree
+Type::do_make_expression_tree(Translate_context*, Expression_list*,
+ source_location)
+{
+ gcc_unreachable();
+}
+
+// Return a pointer to the type descriptor for this type.
+
+tree
+Type::type_descriptor_pointer(Gogo* gogo)
+{
+ Type* t = this->forwarded();
+ if (t->type_descriptor_decl_ == NULL_TREE)
+ {
+ Expression* e = t->do_type_descriptor(gogo, NULL);
+ gogo->build_type_descriptor_decl(t, e, &t->type_descriptor_decl_);
+ gcc_assert(t->type_descriptor_decl_ != NULL_TREE
+ && (t->type_descriptor_decl_ == error_mark_node
+ || DECL_P(t->type_descriptor_decl_)));
+ }
+ if (t->type_descriptor_decl_ == error_mark_node)
+ return error_mark_node;
+ return build_fold_addr_expr(t->type_descriptor_decl_);
+}
+
+// Return a composite literal for a type descriptor.
+
+Expression*
+Type::type_descriptor(Gogo* gogo, Type* type)
+{
+ return type->do_type_descriptor(gogo, NULL);
+}
+
+// Return a composite literal for a type descriptor with a name.
+
+Expression*
+Type::named_type_descriptor(Gogo* gogo, Type* type, Named_type* name)
+{
+ gcc_assert(name != NULL && type->named_type() != name);
+ return type->do_type_descriptor(gogo, name);
+}
+
+// Make a builtin struct type from a list of fields. The fields are
+// pairs of a name and a type.
+
+Struct_type*
+Type::make_builtin_struct_type(int nfields, ...)
+{
+ va_list ap;
+ va_start(ap, nfields);
+
+ source_location bloc = BUILTINS_LOCATION;
+ Struct_field_list* sfl = new Struct_field_list();
+ for (int i = 0; i < nfields; i++)
+ {
+ const char* field_name = va_arg(ap, const char *);
+ Type* type = va_arg(ap, Type*);
+ sfl->push_back(Struct_field(Typed_identifier(field_name, type, bloc)));
+ }
+
+ va_end(ap);
+
+ return Type::make_struct_type(sfl, bloc);
+}
+
+// Make a builtin named type.
+
+Named_type*
+Type::make_builtin_named_type(const char* name, Type* type)
+{
+ source_location bloc = BUILTINS_LOCATION;
+ Named_object* no = Named_object::make_type(name, NULL, type, bloc);
+ return no->type_value();
+}
+
+// Return the type of a type descriptor. We should really tie this to
+// runtime.Type rather than copying it. This must match commonType in
+// libgo/go/runtime/type.go.
+
+Type*
+Type::make_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* uint8_type = Type::lookup_integer_type("uint8");
+ Type* uint32_type = Type::lookup_integer_type("uint32");
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ // This is an unnamed version of unsafe.Pointer. Perhaps we
+ // should use the named version instead, although that would
+ // require us to create the unsafe package if it has not been
+ // imported. It probably doesn't matter.
+ Type* void_type = Type::make_void_type();
+ Type* unsafe_pointer_type = Type::make_pointer_type(void_type);
+
+ // Forward declaration for the type descriptor type.
+ Named_object* named_type_descriptor_type =
+ Named_object::make_type_declaration("commonType", NULL, bloc);
+ Type* ft = Type::make_forward_declaration(named_type_descriptor_type);
+ Type* pointer_type_descriptor_type = Type::make_pointer_type(ft);
+
+ // The type of a method on a concrete type.
+ Struct_type* method_type =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "mtyp", pointer_type_descriptor_type,
+ "typ", pointer_type_descriptor_type,
+ "tfn", unsafe_pointer_type);
+ Named_type* named_method_type =
+ Type::make_builtin_named_type("method", method_type);
+
+ // Information for types with a name or methods.
+ Type* slice_named_method_type =
+ Type::make_array_type(named_method_type, NULL);
+ Struct_type* uncommon_type =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "methods", slice_named_method_type);
+ Named_type* named_uncommon_type =
+ Type::make_builtin_named_type("uncommonType", uncommon_type);
+
+ Type* pointer_uncommon_type =
+ Type::make_pointer_type(named_uncommon_type);
+
+ // The type descriptor type.
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Type* hashfn_type = Type::make_function_type(NULL, params, results, bloc);
+
+ params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Type* equalfn_type = Type::make_function_type(NULL, params, results,
+ bloc);
+
+ Struct_type* type_descriptor_type =
+ Type::make_builtin_struct_type(9,
+ "Kind", uint8_type,
+ "align", uint8_type,
+ "fieldAlign", uint8_type,
+ "size", uintptr_type,
+ "hash", uint32_type,
+ "hashfn", hashfn_type,
+ "equalfn", equalfn_type,
+ "string", pointer_string_type,
+ "", pointer_uncommon_type);
+
+ Named_type* named = Type::make_builtin_named_type("commonType",
+ type_descriptor_type);
+
+ named_type_descriptor_type->set_type_value(named);
+
+ ret = named;
+ }
+
+ return ret;
+}
+
+// Make the type of a pointer to a type descriptor as represented in
+// Go.
+
+Type*
+Type::make_type_descriptor_ptr_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ ret = Type::make_pointer_type(Type::make_type_descriptor_type());
+ return ret;
+}
+
+// Return the names of runtime functions which compute a hash code for
+// this type and which compare whether two values of this type are
+// equal.
+
+void
+Type::type_functions(const char** hash_fn, const char** equal_fn) const
+{
+ switch (this->base()->classification())
+ {
+ case Type::TYPE_ERROR:
+ case Type::TYPE_VOID:
+ case Type::TYPE_NIL:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ *hash_fn = "__go_type_hash_identity";
+ *equal_fn = "__go_type_equal_identity";
+ break;
+
+ case Type::TYPE_STRING:
+ *hash_fn = "__go_type_hash_string";
+ *equal_fn = "__go_type_equal_string";
+ break;
+
+ case Type::TYPE_STRUCT:
+ case Type::TYPE_ARRAY:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_INTERFACE:
+ if (this->interface_type()->is_empty())
+ {
+ *hash_fn = "__go_type_hash_empty_interface";
+ *equal_fn = "__go_type_equal_empty_interface";
+ }
+ else
+ {
+ *hash_fn = "__go_type_hash_interface";
+ *equal_fn = "__go_type_equal_interface";
+ }
+ break;
+
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ gcc_unreachable();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return a composite literal for the type descriptor for a plain type
+// of kind RUNTIME_TYPE_KIND named NAME.
+
+Expression*
+Type::type_descriptor_constructor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* td_type = Type::make_type_descriptor_type();
+ const Struct_field_list* fields = td_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(9);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "Kind");
+ mpz_t iv;
+ mpz_init_set_ui(iv, runtime_type_kind);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "align");
+ Expression::Type_info type_info = Expression::TYPE_INFO_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "fieldAlign");
+ type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "size");
+ type_info = Expression::TYPE_INFO_SIZE;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "hash");
+ mpz_set_ui(iv, this->hash_for_method(gogo));
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ const char* hash_fn;
+ const char* equal_fn;
+ this->type_functions(&hash_fn, &equal_fn);
+
+ ++p;
+ gcc_assert(p->field_name() == "hashfn");
+ Function_type* fntype = p->type()->function_type();
+ Named_object* no = Named_object::make_function_declaration(hash_fn, NULL,
+ fntype,
+ bloc);
+ no->func_declaration_value()->set_asm_name(hash_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "equalfn");
+ fntype = p->type()->function_type();
+ no = Named_object::make_function_declaration(equal_fn, NULL, fntype, bloc);
+ no->func_declaration_value()->set_asm_name(equal_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "string");
+ Expression* s = Expression::make_string((name != NULL
+ ? name->reflection(gogo)
+ : this->reflection(gogo)),
+ bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "uncommonType");
+ if (name == NULL && methods == NULL)
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ if (methods == NULL)
+ methods = name->methods();
+ vals->push_back(this->uncommon_type_constructor(gogo,
+ p->type()->deref(),
+ name, methods,
+ only_value_methods));
+ }
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ mpz_clear(iv);
+
+ return Expression::make_struct_composite_literal(td_type, vals, bloc);
+}
+
+// Return a composite literal for the uncommon type information for
+// this type. UNCOMMON_STRUCT_TYPE is the type of the uncommon type
+// struct. If name is not NULL, it is the name of the type. If
+// METHODS is not NULL, it is the list of methods. ONLY_VALUE_METHODS
+// is true if only value methods should be included. At least one of
+// NAME and METHODS must not be NULL.
+
+Expression*
+Type::uncommon_type_constructor(Gogo* gogo, Type* uncommon_type,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = uncommon_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "name");
+
+ ++p;
+ gcc_assert(p->field_name() == "pkgPath");
+
+ if (name == NULL)
+ {
+ vals->push_back(Expression::make_nil(bloc));
+ vals->push_back(Expression::make_nil(bloc));
+ }
+ else
+ {
+ Named_object* no = name->named_object();
+ std::string n = Gogo::unpack_hidden_name(no->name());
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ if (name->is_builtin())
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ const Package* package = no->package();
+ const std::string& unique_prefix(package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix());
+ const std::string& package_name(package == NULL
+ ? gogo->package_name()
+ : package->name());
+ n.assign(unique_prefix);
+ n.append(1, '.');
+ n.append(package_name);
+ if (name->in_function() != NULL)
+ {
+ n.append(1, '.');
+ n.append(Gogo::unpack_hidden_name(name->in_function()->name()));
+ }
+ s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+ }
+
+ ++p;
+ gcc_assert(p->field_name() == "methods");
+ vals->push_back(this->methods_constructor(gogo, p->type(), methods,
+ only_value_methods));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ Expression* r = Expression::make_struct_composite_literal(uncommon_type,
+ vals, bloc);
+ return Expression::make_unary(OPERATOR_AND, r, bloc);
+}
+
+// Sort methods by name.
+
+class Sort_methods
+{
+ public:
+ bool
+ operator()(const std::pair<std::string, const Method*>& m1,
+ const std::pair<std::string, const Method*>& m2) const
+ { return m1.first < m2.first; }
+};
+
+// Return a composite literal for the type method table for this type.
+// METHODS_TYPE is the type of the table, and is a slice type.
+// METHODS is the list of methods. If ONLY_VALUE_METHODS is true,
+// then only value methods are used.
+
+Expression*
+Type::methods_constructor(Gogo* gogo, Type* methods_type,
+ const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ std::vector<std::pair<std::string, const Method*> > smethods;
+ if (methods != NULL)
+ {
+ smethods.reserve(methods->count());
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->second->is_ambiguous())
+ continue;
+ if (only_value_methods && !p->second->is_value_method())
+ continue;
+ smethods.push_back(std::make_pair(p->first, p->second));
+ }
+ }
+
+ if (smethods.empty())
+ return Expression::make_slice_composite_literal(methods_type, NULL, bloc);
+
+ std::sort(smethods.begin(), smethods.end(), Sort_methods());
+
+ Type* method_type = methods_type->array_type()->element_type();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(smethods.size());
+ for (std::vector<std::pair<std::string, const Method*> >::const_iterator p
+ = smethods.begin();
+ p != smethods.end();
+ ++p)
+ vals->push_back(this->method_constructor(gogo, method_type, p->first,
+ p->second));
+
+ return Expression::make_slice_composite_literal(methods_type, vals, bloc);
+}
+
+// Return a composite literal for a single method. METHOD_TYPE is the
+// type of the entry. METHOD_NAME is the name of the method and M is
+// the method information.
+
+Expression*
+Type::method_constructor(Gogo*, Type* method_type,
+ const std::string& method_name,
+ const Method* m) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = method_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(5);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "name");
+ const std::string n = Gogo::unpack_hidden_name(method_name);
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(method_name))
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Expression::make_string(Gogo::hidden_name_prefix(method_name), bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ Named_object* no = (m->needs_stub_method()
+ ? m->stub_object()
+ : m->named_object());
+
+ Function_type* mtype;
+ if (no->is_function())
+ mtype = no->func_value()->type();
+ else
+ mtype = no->func_declaration_value()->type();
+ gcc_assert(mtype->is_method());
+ Type* nonmethod_type = mtype->copy_without_receiver();
+
+ ++p;
+ gcc_assert(p->field_name() == "mtyp");
+ vals->push_back(Expression::make_type_descriptor(nonmethod_type, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "typ");
+ vals->push_back(Expression::make_type_descriptor(mtype, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "tfn");
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(method_type, vals, bloc);
+}
+
+// Return a composite literal for the type descriptor of a plain type.
+// RUNTIME_TYPE_KIND is the value of the kind field. If NAME is not
+// NULL, it is the name to use as well as the list of methods.
+
+Expression*
+Type::plain_type_descriptor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name)
+{
+ return this->type_descriptor_constructor(gogo, runtime_type_kind,
+ name, NULL, true);
+}
+
+// Return the type reflection string for this type.
+
+std::string
+Type::reflection(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_reflection virtual function should set RET to the
+ // reflection string.
+ this->do_reflection(gogo, &ret);
+
+ return ret;
+}
+
+// Return a mangled name for the type.
+
+std::string
+Type::mangled_name(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_mangled_name virtual function should set RET to the
+ // mangled name. For a composite type it should append a code for
+ // the composition and then call do_mangled_name on the components.
+ this->do_mangled_name(gogo, &ret);
+
+ return ret;
+}
+
+// Default function to export a type.
+
+void
+Type::do_export(Export*) const
+{
+ gcc_unreachable();
+}
+
+// Import a type.
+
+Type*
+Type::import_type(Import* imp)
+{
+ if (imp->match_c_string("("))
+ return Function_type::do_import(imp);
+ else if (imp->match_c_string("*"))
+ return Pointer_type::do_import(imp);
+ else if (imp->match_c_string("struct "))
+ return Struct_type::do_import(imp);
+ else if (imp->match_c_string("["))
+ return Array_type::do_import(imp);
+ else if (imp->match_c_string("map "))
+ return Map_type::do_import(imp);
+ else if (imp->match_c_string("chan "))
+ return Channel_type::do_import(imp);
+ else if (imp->match_c_string("interface"))
+ return Interface_type::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected type");
+ return Type::make_error_type();
+ }
+}
+
+// A type used to indicate a parsing error. This exists to simplify
+// later error detection.
+
+class Error_type : public Type
+{
+ public:
+ Error_type()
+ : Type(TYPE_ERROR)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return error_mark_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { return error_mark_node; }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { return Expression::make_error(BUILTINS_LOCATION); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_assert(saw_errors()); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('E'); }
+};
+
+Type*
+Type::make_error_type()
+{
+ static Error_type singleton_error_type;
+ return &singleton_error_type;
+}
+
+// The void type.
+
+class Void_type : public Type
+{
+ public:
+ Void_type()
+ : Type(TYPE_VOID)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return void_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { gcc_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('v'); }
+};
+
+Type*
+Type::make_void_type()
+{
+ static Void_type singleton_void_type;
+ return &singleton_void_type;
+}
+
+// The boolean type.
+
+class Boolean_type : public Type
+{
+ public:
+ Boolean_type()
+ : Type(TYPE_BOOLEAN)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return boolean_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, boolean_false_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type* name);
+
+ // We should not be asked for the reflection string of a basic type.
+ void
+ do_reflection(Gogo*, std::string* ret) const
+ { ret->append("bool"); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('b'); }
+};
+
+// Make the type descriptor.
+
+Expression*
+Boolean_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_BOOL, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("bool");
+ gcc_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+Type*
+Type::make_boolean_type()
+{
+ static Boolean_type boolean_type;
+ return &boolean_type;
+}
+
+// The named type "bool".
+
+static Named_type* named_bool_type;
+
+// Get the named type "bool".
+
+Named_type*
+Type::lookup_bool_type()
+{
+ return named_bool_type;
+}
+
+// Make the named type "bool".
+
+Named_type*
+Type::make_named_bool_type()
+{
+ Type* bool_type = Type::make_boolean_type();
+ Named_object* named_object = Named_object::make_type("bool", NULL,
+ bool_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_bool_type = named_type;
+ return named_type;
+}
+
+// Class Integer_type.
+
+Integer_type::Named_integer_types Integer_type::named_integer_types;
+
+// Create a new integer type. Non-abstract integer types always have
+// names.
+
+Named_type*
+Integer_type::create_integer_type(const char* name, bool is_unsigned,
+ int bits, int runtime_type_kind)
+{
+ Integer_type* integer_type = new Integer_type(false, is_unsigned, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ integer_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_integer_types::iterator, bool> ins =
+ Integer_type::named_integer_types.insert(std::make_pair(sname, named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing integer type.
+
+Named_type*
+Integer_type::lookup_integer_type(const char* name)
+{
+ Named_integer_types::const_iterator p =
+ Integer_type::named_integer_types.find(name);
+ gcc_assert(p != Integer_type::named_integer_types.end());
+ return p->second;
+}
+
+// Create a new abstract integer type.
+
+Integer_type*
+Integer_type::create_abstract_integer_type()
+{
+ static Integer_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Integer_type(true, false, INT_TYPE_SIZE,
+ RUNTIME_TYPE_KIND_INT);
+ return abstract_type;
+}
+
+// Integer type compatibility.
+
+bool
+Integer_type::is_identical(const Integer_type* t) const
+{
+ if (this->is_unsigned_ != t->is_unsigned_ || this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Integer_type::do_hash_for_method(Gogo*) const
+{
+ return ((this->bits_ << 4)
+ + ((this->is_unsigned_ ? 1 : 0) << 8)
+ + ((this->is_abstract_ ? 1 : 0) << 9));
+}
+
+// Get the tree for an Integer_type.
+
+tree
+Integer_type::do_get_tree(Gogo*)
+{
+ gcc_assert(!this->is_abstract_);
+ if (this->is_unsigned_)
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return unsigned_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return unsigned_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_unsigned_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_unsigned_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_unsigned_type_node;
+ else
+ return make_unsigned_type(this->bits_);
+ }
+ else
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return integer_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return signed_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_integer_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_integer_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_integer_type_node;
+ else
+ return make_signed_type(this->bits_);
+ }
+}
+
+tree
+Integer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ return is_clear ? NULL : build_int_cst(type_tree, 0);
+}
+
+// The type descriptor for an integer type. Integer types are always
+// named.
+
+Expression*
+Integer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Integer_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_unreachable();
+}
+
+// Mangled name.
+
+void
+Integer_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "i%s%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->is_unsigned_ ? "u" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make an integer type.
+
+Named_type*
+Type::make_integer_type(const char* name, bool is_unsigned, int bits,
+ int runtime_type_kind)
+{
+ return Integer_type::create_integer_type(name, is_unsigned, bits,
+ runtime_type_kind);
+}
+
+// Make an abstract integer type.
+
+Integer_type*
+Type::make_abstract_integer_type()
+{
+ return Integer_type::create_abstract_integer_type();
+}
+
+// Look up an integer type.
+
+Named_type*
+Type::lookup_integer_type(const char* name)
+{
+ return Integer_type::lookup_integer_type(name);
+}
+
+// Class Float_type.
+
+Float_type::Named_float_types Float_type::named_float_types;
+
+// Create a new float type. Non-abstract float types always have
+// names.
+
+Named_type*
+Float_type::create_float_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Float_type* float_type = new Float_type(false, bits, runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL, float_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_float_types::iterator, bool> ins =
+ Float_type::named_float_types.insert(std::make_pair(sname, named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing float type.
+
+Named_type*
+Float_type::lookup_float_type(const char* name)
+{
+ Named_float_types::const_iterator p =
+ Float_type::named_float_types.find(name);
+ gcc_assert(p != Float_type::named_float_types.end());
+ return p->second;
+}
+
+// Create a new abstract float type.
+
+Float_type*
+Float_type::create_abstract_float_type()
+{
+ static Float_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Float_type(true, FLOAT_TYPE_SIZE,
+ RUNTIME_TYPE_KIND_FLOAT);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Float_type::is_identical(const Float_type* t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Float_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Float_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE)
+ return float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE)
+ return double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE)
+ return long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_;
+ layout_type(ret);
+ return ret;
+ }
+}
+
+// Get a tree.
+
+tree
+Float_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+tree
+Float_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(type_tree), 0, 0, 0);
+ return build_real(type_tree, r);
+}
+
+// The type descriptor for a float type. Float types are always named.
+
+Expression*
+Float_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Float_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_unreachable();
+}
+
+// Mangled name.
+
+void
+Float_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "f%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a floating point type.
+
+Named_type*
+Type::make_float_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Float_type::create_float_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract float type.
+
+Float_type*
+Type::make_abstract_float_type()
+{
+ return Float_type::create_abstract_float_type();
+}
+
+// Look up a float type.
+
+Named_type*
+Type::lookup_float_type(const char* name)
+{
+ return Float_type::lookup_float_type(name);
+}
+
+// Class Complex_type.
+
+Complex_type::Named_complex_types Complex_type::named_complex_types;
+
+// Create a new complex type. Non-abstract complex types always have
+// names.
+
+Named_type*
+Complex_type::create_complex_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Complex_type* complex_type = new Complex_type(false, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ complex_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_complex_types::iterator, bool> ins =
+ Complex_type::named_complex_types.insert(std::make_pair(sname,
+ named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing complex type.
+
+Named_type*
+Complex_type::lookup_complex_type(const char* name)
+{
+ Named_complex_types::const_iterator p =
+ Complex_type::named_complex_types.find(name);
+ gcc_assert(p != Complex_type::named_complex_types.end());
+ return p->second;
+}
+
+// Create a new abstract complex type.
+
+Complex_type*
+Complex_type::create_abstract_complex_type()
+{
+ static Complex_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Complex_type(true, FLOAT_TYPE_SIZE * 2,
+ RUNTIME_TYPE_KIND_FLOAT);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Complex_type::is_identical(const Complex_type *t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Complex_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Complex_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE * 2)
+ return complex_float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE * 2)
+ return complex_double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE * 2)
+ return complex_long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_ / 2;
+ layout_type(ret);
+ return build_complex_type(ret);
+ }
+}
+
+// Get a tree.
+
+tree
+Complex_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+// Zero initializer.
+
+tree
+Complex_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(TREE_TYPE(type_tree)), 0, 0, 0);
+ return build_complex(type_tree, build_real(TREE_TYPE(type_tree), r),
+ build_real(TREE_TYPE(type_tree), r));
+}
+
+// The type descriptor for a complex type. Complex types are always
+// named.
+
+Expression*
+Complex_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Complex_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_unreachable();
+}
+
+// Mangled name.
+
+void
+Complex_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "c%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a complex type.
+
+Named_type*
+Type::make_complex_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Complex_type::create_complex_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract complex type.
+
+Complex_type*
+Type::make_abstract_complex_type()
+{
+ return Complex_type::create_abstract_complex_type();
+}
+
+// Look up a complex type.
+
+Named_type*
+Type::lookup_complex_type(const char* name)
+{
+ return Complex_type::lookup_complex_type(name);
+}
+
+// Class String_type.
+
+// Return the tree for String_type. A string is a struct with two
+// fields: a pointer to the characters and a length.
+
+tree
+String_type::do_get_tree(Gogo*)
+{
+ static tree struct_type;
+ return Gogo::builtin_struct(&struct_type, "__go_string", NULL_TREE, 2,
+ "__data",
+ build_pointer_type(unsigned_char_type_node),
+ "__length",
+ integer_type_node);
+}
+
+// Return a tree for the length of STRING.
+
+tree
+String_type::length_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ gcc_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree length_field = DECL_CHAIN(TYPE_FIELDS(string_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(length_field)),
+ "__length") == 0);
+ return fold_build3(COMPONENT_REF, integer_type_node, string,
+ length_field, NULL_TREE);
+}
+
+// Return a tree for a pointer to the bytes of STRING.
+
+tree
+String_type::bytes_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ gcc_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree bytes_field = TYPE_FIELDS(string_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(bytes_field)),
+ "__data") == 0);
+ return fold_build3(COMPONENT_REF, TREE_TYPE(bytes_field), string,
+ bytes_field, NULL_TREE);
+}
+
+// We initialize a string to { NULL, 0 }.
+
+tree
+String_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL_TREE;
+
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type descriptor for the string type.
+
+Expression*
+String_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_STRING, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("string");
+ gcc_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+String_type::do_reflection(Gogo*, std::string* ret) const
+{
+ ret->append("string");
+}
+
+// Mangled name of a string type.
+
+void
+String_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ ret->push_back('z');
+}
+
+// Make a string type.
+
+Type*
+Type::make_string_type()
+{
+ static String_type string_type;
+ return &string_type;
+}
+
+// The named type "string".
+
+static Named_type* named_string_type;
+
+// Get the named type "string".
+
+Named_type*
+Type::lookup_string_type()
+{
+ return named_string_type;
+}
+
+// Make the named type string.
+
+Named_type*
+Type::make_named_string_type()
+{
+ Type* string_type = Type::make_string_type();
+ Named_object* named_object = Named_object::make_type("string", NULL,
+ string_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_string_type = named_type;
+ return named_type;
+}
+
+// The sink type. This is the type of the blank identifier _. Any
+// type may be assigned to it.
+
+class Sink_type : public Type
+{
+ public:
+ Sink_type()
+ : Type(TYPE_SINK)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { gcc_unreachable(); }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { gcc_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+};
+
+// Make the sink type.
+
+Type*
+Type::make_sink_type()
+{
+ static Sink_type sink_type;
+ return &sink_type;
+}
+
+// Class Function_type.
+
+// Traversal.
+
+int
+Function_type::do_traverse(Traverse* traverse)
+{
+ if (this->receiver_ != NULL
+ && Type::traverse(this->receiver_->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->parameters_ != NULL
+ && this->parameters_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->results_ != NULL
+ && this->results_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Returns whether T is a valid redeclaration of this type. If this
+// returns false, and REASON is not NULL, *REASON may be set to a
+// brief explanation of why it returned false.
+
+bool
+Function_type::is_valid_redeclaration(const Function_type* t,
+ std::string* reason) const
+{
+ if (!this->is_identical(t, false, reason))
+ return false;
+
+ // A redeclaration of a function is required to use the same names
+ // for the receiver and parameters.
+ if (this->receiver() != NULL
+ && this->receiver()->name() != t->receiver()->name()
+ && this->receiver()->name() != Import::import_marker
+ && t->receiver()->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "receiver name changed";
+ return false;
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1->name() != p2->name()
+ && p1->name() != Import::import_marker
+ && p2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "parameter name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = p1->type()->forwarded();
+ Type* t2 = p2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1->name() != res2->name()
+ && res1->name() != Import::import_marker
+ && res2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "result name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = res1->type()->forwarded();
+ Type* t2 = res2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check whether T is the same as this type.
+
+bool
+Function_type::is_identical(const Function_type* t, bool ignore_receiver,
+ std::string* reason) const
+{
+ if (!ignore_receiver)
+ {
+ const Typed_identifier* r1 = this->receiver();
+ const Typed_identifier* r2 = t->receiver();
+ if ((r1 != NULL) != (r2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different receiver types");
+ return false;
+ }
+ if (r1 != NULL)
+ {
+ if (!Type::are_identical(r1->type(), r2->type(), reason))
+ {
+ if (reason != NULL && !reason->empty())
+ *reason = "receiver: " + *reason;
+ return false;
+ }
+ }
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if ((parms1 != NULL) != (parms2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1 == parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+
+ if (!Type::are_identical(p1->type(), p2->type(), NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different parameter types");
+ return false;
+ }
+ }
+ if (p1 != parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ }
+
+ if (this->is_varargs() != t->is_varargs())
+ {
+ if (reason != NULL)
+ *reason = _("different varargs");
+ return false;
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if ((results1 != NULL) != (results2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1 == results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+
+ if (!Type::are_identical(res1->type(), res2->type(), NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different result types");
+ return false;
+ }
+ }
+ if (res1 != results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Function_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ // We ignore the receiver type for hash codes, because we need to
+ // get the same hash code for a method in an interface and a method
+ // declared for a type. The former will not have a receiver.
+ if (this->parameters_ != NULL)
+ {
+ int shift = 1;
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->results_ != NULL)
+ {
+ int shift = 2;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->is_varargs_)
+ ret += 1;
+ ret <<= 4;
+ return ret;
+}
+
+// Get the tree for a function type.
+
+tree
+Function_type::do_get_tree(Gogo* gogo)
+{
+ tree args = NULL_TREE;
+ tree* pp = &args;
+
+ if (this->receiver_ != NULL)
+ {
+ Type* rtype = this->receiver_->type();
+ tree ptype = rtype->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+
+ // We always pass the address of the receiver parameter, in
+ // order to make interface calls work with unknown types.
+ if (rtype->points_to() == NULL)
+ ptype = build_pointer_type(ptype);
+
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+
+ if (this->parameters_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ tree ptype = p->type()->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+ }
+
+ // Varargs is handled entirely at the Go level. At the tree level,
+ // functions are not varargs.
+ *pp = void_list_node;
+
+ tree result;
+ if (this->results_ == NULL)
+ result = void_type_node;
+ else if (this->results_->size() == 1)
+ result = this->results_->begin()->type()->get_tree(gogo);
+ else
+ {
+ result = make_node(RECORD_TYPE);
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p)
+ {
+ const std::string name = (p->name().empty()
+ ? "UNNAMED"
+ : Gogo::unpack_hidden_name(p->name()));
+ tree name_tree = get_identifier_with_length(name.data(),
+ name.length());
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = result;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+ TYPE_FIELDS(result) = field_trees;
+ layout_type(result);
+ }
+
+ if (result == error_mark_node)
+ return error_mark_node;
+
+ tree fntype = build_function_type(result, args);
+ if (fntype == error_mark_node)
+ return fntype;
+
+ return build_pointer_type(fntype);
+}
+
+// Functions are initialized to NULL.
+
+tree
+Function_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a function type descriptor.
+
+Type*
+Function_type::make_function_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* bool_type = Type::lookup_bool_type();
+
+ Type* slice_type = Type::make_array_type(ptdt, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(4,
+ "", tdt,
+ "dotdotdot", bool_type,
+ "in", slice_type,
+ "out", slice_type);
+
+ ret = Type::make_builtin_named_type("FuncType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a function type.
+
+Expression*
+Function_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ftdt = Function_type::make_function_type_descriptor_type();
+
+ const Struct_field_list* fields = ftdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(4);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_FUNC,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "dotdotdot");
+ vals->push_back(Expression::make_boolean(this->is_varargs(), bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "in");
+ vals->push_back(this->type_descriptor_params(p->type(), this->receiver(),
+ this->parameters()));
+
+ ++p;
+ gcc_assert(p->field_name() == "out");
+ vals->push_back(this->type_descriptor_params(p->type(), NULL,
+ this->results()));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ftdt, vals, bloc);
+}
+
+// Return a composite literal for the parameters or results of a type
+// descriptor.
+
+Expression*
+Function_type::type_descriptor_params(Type* params_type,
+ const Typed_identifier* receiver,
+ const Typed_identifier_list* params)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ if (receiver == NULL && params == NULL)
+ return Expression::make_slice_composite_literal(params_type, NULL, bloc);
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve((params == NULL ? 0 : params->size())
+ + (receiver != NULL ? 1 : 0));
+
+ if (receiver != NULL)
+ {
+ Type* rtype = receiver->type();
+ // The receiver is always passed as a pointer. FIXME: Is this
+ // right? Should that fact affect the type descriptor?
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ vals->push_back(Expression::make_type_descriptor(rtype, bloc));
+ }
+
+ if (params != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ vals->push_back(Expression::make_type_descriptor(p->type(), bloc));
+ }
+
+ return Expression::make_slice_composite_literal(params_type, vals, bloc);
+}
+
+// The reflection string.
+
+void
+Function_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ // FIXME: Turn this off until we straighten out the type of the
+ // struct field used in a go statement which calls a method.
+ // gcc_assert(this->receiver_ == NULL);
+
+ ret->append("func");
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('(');
+ this->append_reflection(this->receiver_->type(), gogo, ret);
+ ret->push_back(')');
+ }
+
+ ret->push_back('(');
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ if (p != params->begin())
+ ret->append(", ");
+ if (!is_varargs || p + 1 != params->end())
+ this->append_reflection(p->type(), gogo, ret);
+ else
+ {
+ ret->append("...");
+ this->append_reflection(p->type()->array_type()->element_type(),
+ gogo, ret);
+ }
+ }
+ }
+ ret->push_back(')');
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL && !results->empty())
+ {
+ if (results->size() == 1)
+ ret->push_back(' ');
+ else
+ ret->append(" (");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (p != results->begin())
+ ret->append(", ");
+ this->append_reflection(p->type(), gogo, ret);
+ }
+ if (results->size() > 1)
+ ret->push_back(')');
+ }
+}
+
+// Mangled name.
+
+void
+Function_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('F');
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('m');
+ this->append_mangled_name(this->receiver_->type(), gogo, ret);
+ }
+
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ ret->push_back('p');
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (this->is_varargs_)
+ ret->push_back('V');
+ ret->push_back('e');
+ }
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL)
+ {
+ ret->push_back('r');
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ ret->push_back('e');
+ }
+
+ ret->push_back('e');
+}
+
+// Export a function type.
+
+void
+Function_type::do_export(Export* exp) const
+{
+ // We don't write out the receiver. The only function types which
+ // should have a receiver are the ones associated with explicitly
+ // defined methods. For those the receiver type is written out by
+ // Function::export_func.
+
+ exp->write_c_string("(");
+ bool first = true;
+ if (this->parameters_ != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p =
+ this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != this->parameters_->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = this->results_;
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+}
+
+// Import a function type.
+
+Function_type*
+Function_type::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ imp->advance(1);
+ results = new Typed_identifier_list;
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* ret = Type::make_function_type(NULL, parameters, results,
+ imp->location());
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Make a copy of a function type without a receiver.
+
+Function_type*
+Function_type::copy_without_receiver() const
+{
+ gcc_assert(this->is_method());
+ Function_type *ret = Type::make_function_type(NULL, this->parameters_,
+ this->results_,
+ this->location_);
+ if (this->is_varargs())
+ ret->set_is_varargs();
+ if (this->is_builtin())
+ ret->set_is_builtin();
+ return ret;
+}
+
+// Make a copy of a function type with a receiver.
+
+Function_type*
+Function_type::copy_with_receiver(Type* receiver_type) const
+{
+ gcc_assert(!this->is_method());
+ Typed_identifier* receiver = new Typed_identifier("", receiver_type,
+ this->location_);
+ return Type::make_function_type(receiver, this->parameters_,
+ this->results_, this->location_);
+}
+
+// Make a function type.
+
+Function_type*
+Type::make_function_type(Typed_identifier* receiver,
+ Typed_identifier_list* parameters,
+ Typed_identifier_list* results,
+ source_location location)
+{
+ return new Function_type(receiver, parameters, results, location);
+}
+
+// Class Pointer_type.
+
+// Traversal.
+
+int
+Pointer_type::do_traverse(Traverse* traverse)
+{
+ return Type::traverse(this->to_type_, traverse);
+}
+
+// Hash code.
+
+unsigned int
+Pointer_type::do_hash_for_method(Gogo* gogo) const
+{
+ return this->to_type_->hash_for_method(gogo) << 4;
+}
+
+// The tree for a pointer type.
+
+tree
+Pointer_type::do_get_tree(Gogo* gogo)
+{
+ return build_pointer_type(this->to_type_->get_tree(gogo));
+}
+
+// Initialize a pointer type.
+
+tree
+Pointer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a pointer type descriptor.
+
+Type*
+Pointer_type::make_pointer_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("PtrType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a pointer type.
+
+Expression*
+Pointer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->is_unsafe_pointer_type())
+ {
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo,
+ RUNTIME_TYPE_KIND_UNSAFE_POINTER,
+ name);
+ }
+ else
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Methods* methods;
+ Type* deref = this->points_to();
+ if (deref->named_type() != NULL)
+ methods = deref->named_type()->methods();
+ else if (deref->struct_type() != NULL)
+ methods = deref->struct_type()->methods();
+ else
+ methods = NULL;
+
+ Type* ptr_tdt = Pointer_type::make_pointer_type_descriptor_type();
+
+ const Struct_field_list* fields = ptr_tdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_PTR,
+ name, methods, false));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(deref, bloc));
+
+ return Expression::make_struct_composite_literal(ptr_tdt, vals, bloc);
+ }
+}
+
+// Reflection string.
+
+void
+Pointer_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('*');
+ this->append_reflection(this->to_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Pointer_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('p');
+ this->append_mangled_name(this->to_type_, gogo, ret);
+}
+
+// Export.
+
+void
+Pointer_type::do_export(Export* exp) const
+{
+ exp->write_c_string("*");
+ if (this->is_unsafe_pointer_type())
+ exp->write_c_string("any");
+ else
+ exp->write_type(this->to_type_);
+}
+
+// Import.
+
+Pointer_type*
+Pointer_type::do_import(Import* imp)
+{
+ imp->require_c_string("*");
+ if (imp->match_c_string("any"))
+ {
+ imp->advance(3);
+ return Type::make_pointer_type(Type::make_void_type());
+ }
+ Type* to = imp->read_type();
+ return Type::make_pointer_type(to);
+}
+
+// Make a pointer type.
+
+Pointer_type*
+Type::make_pointer_type(Type* to_type)
+{
+ typedef Unordered_map(Type*, Pointer_type*) Hashtable;
+ static Hashtable pointer_types;
+ Hashtable::const_iterator p = pointer_types.find(to_type);
+ if (p != pointer_types.end())
+ return p->second;
+ Pointer_type* ret = new Pointer_type(to_type);
+ pointer_types[to_type] = ret;
+ return ret;
+}
+
+// The nil type. We use a special type for nil because it is not the
+// same as any other type. In C term nil has type void*, but there is
+// no such type in Go.
+
+class Nil_type : public Type
+{
+ public:
+ Nil_type()
+ : Type(TYPE_NIL)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return ptr_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, null_pointer_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('n'); }
+};
+
+// Make the nil type.
+
+Type*
+Type::make_nil_type()
+{
+ static Nil_type singleton_nil_type;
+ return &singleton_nil_type;
+}
+
+// The type of a function call which returns multiple values. This is
+// really a struct, but we don't want to confuse a function call which
+// returns a struct with a function call which returns multiple
+// values.
+
+class Call_multiple_result_type : public Type
+{
+ public:
+ Call_multiple_result_type(Call_expression* call)
+ : Type(TYPE_CALL_MULTIPLE_RESULT),
+ call_(call)
+ { }
+
+ protected:
+ bool
+ do_has_pointer() const
+ { gcc_unreachable(); }
+
+ tree
+ do_get_tree(Gogo*);
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { gcc_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ private:
+ // The expression being called.
+ Call_expression* call_;
+};
+
+// Return the tree for a call result.
+
+tree
+Call_multiple_result_type::do_get_tree(Gogo* gogo)
+{
+ Function_type* fntype = this->call_->get_function_type();
+ gcc_assert(fntype != NULL);
+ const Typed_identifier_list* results = fntype->results();
+ gcc_assert(results != NULL && results->size() > 1);
+
+ Struct_field_list* sfl = new Struct_field_list;
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ const std::string name = ((p->name().empty()
+ || p->name() == Import::import_marker)
+ ? "UNNAMED"
+ : p->name());
+ sfl->push_back(Struct_field(Typed_identifier(name, p->type(),
+ this->call_->location())));
+ }
+ return Type::make_struct_type(sfl, this->call_->location())->get_tree(gogo);
+}
+
+// Make a call result type.
+
+Type*
+Type::make_call_multiple_result_type(Call_expression* call)
+{
+ return new Call_multiple_result_type(call);
+}
+
+// Class Struct_field.
+
+// Get the name of a field.
+
+const std::string&
+Struct_field::field_name() const
+{
+ const std::string& name(this->typed_identifier_.name());
+ if (!name.empty())
+ return name;
+ else
+ {
+ // This is called during parsing, before anything is lowered, so
+ // we have to be pretty careful to avoid dereferencing an
+ // unknown type name.
+ Type* t = this->typed_identifier_.type();
+ Type* dt = t;
+ if (t->classification() == Type::TYPE_POINTER)
+ {
+ // Very ugly.
+ Pointer_type* ptype = static_cast<Pointer_type*>(t);
+ dt = ptype->points_to();
+ }
+ if (dt->forward_declaration_type() != NULL)
+ return dt->forward_declaration_type()->name();
+ else if (dt->named_type() != NULL)
+ return dt->named_type()->name();
+ else if (t->is_error_type() || dt->is_error_type())
+ {
+ static const std::string error_string = "*error*";
+ return error_string;
+ }
+ else
+ {
+ // Avoid crashing in the erroneous case where T is named but
+ // DT is not.
+ gcc_assert(t != dt);
+ if (t->forward_declaration_type() != NULL)
+ return t->forward_declaration_type()->name();
+ else if (t->named_type() != NULL)
+ return t->named_type()->name();
+ else
+ gcc_unreachable();
+ }
+ }
+}
+
+// Class Struct_type.
+
+// Traversal.
+
+int
+Struct_type::do_traverse(Traverse* traverse)
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that the struct type is complete and valid.
+
+bool
+Struct_type::do_verify()
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return true;
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t->is_undefined())
+ {
+ error_at(p->location(), "struct field type is incomplete");
+ p->set_type(Type::make_error_type());
+ return false;
+ }
+ else if (p->is_anonymous())
+ {
+ if (t->named_type() != NULL && t->points_to() != NULL)
+ {
+ error_at(p->location(), "embedded type may not be a pointer");
+ p->set_type(Type::make_error_type());
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+// Whether this contains a pointer.
+
+bool
+Struct_type::do_has_pointer() const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->type()->has_pointer())
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical to T.
+
+bool
+Struct_type::is_identical(const Struct_type* t) const
+{
+ const Struct_field_list* fields1 = this->fields();
+ const Struct_field_list* fields2 = t->fields();
+ if (fields1 == NULL || fields2 == NULL)
+ return fields1 == fields2;
+ Struct_field_list::const_iterator pf2 = fields2->begin();
+ for (Struct_field_list::const_iterator pf1 = fields1->begin();
+ pf1 != fields1->end();
+ ++pf1, ++pf2)
+ {
+ if (pf2 == fields2->end())
+ return false;
+ if (pf1->field_name() != pf2->field_name())
+ return false;
+ if (pf1->is_anonymous() != pf2->is_anonymous()
+ || !Type::are_identical(pf1->type(), pf2->type(), NULL))
+ return false;
+ if (!pf1->has_tag())
+ {
+ if (pf2->has_tag())
+ return false;
+ }
+ else
+ {
+ if (!pf2->has_tag())
+ return false;
+ if (pf1->tag() != pf2->tag())
+ return false;
+ }
+ }
+ if (pf2 != fields2->end())
+ return false;
+ return true;
+}
+
+// Whether this struct type has any hidden fields.
+
+bool
+Struct_type::struct_has_hidden_fields(const Named_type* within,
+ std::string* reason) const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ const Package* within_package = (within == NULL
+ ? NULL
+ : within->named_object()->package());
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (within_package != NULL
+ && !pf->is_anonymous()
+ && Gogo::is_hidden_name(pf->field_name()))
+ {
+ if (reason != NULL)
+ {
+ std::string within_name = within->named_object()->message_name();
+ std::string name = Gogo::message_name(pf->field_name());
+ size_t bufsize = 200 + within_name.length() + name.length();
+ char* buf = new char[bufsize];
+ snprintf(buf, bufsize,
+ _("implicit assignment of %s%s%s hidden field %s%s%s"),
+ open_quote, within_name.c_str(), close_quote,
+ open_quote, name.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return true;
+ }
+
+ if (pf->type()->has_hidden_fields(within, reason))
+ return true;
+ }
+
+ return false;
+}
+
+// Hash code.
+
+unsigned int
+Struct_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->fields() != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = this->fields()->begin();
+ pf != this->fields()->end();
+ ++pf)
+ ret = (ret << 1) + pf->type()->hash_for_method(gogo);
+ }
+ return ret <<= 2;
+}
+
+// Find the local field NAME.
+
+const Struct_field*
+Struct_type::find_local_field(const std::string& name,
+ unsigned int *pindex) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ if (pindex != NULL)
+ *pindex = i;
+ return &*pf;
+ }
+ }
+ return NULL;
+}
+
+// Return an expression for field NAME in STRUCT_EXPR, or NULL.
+
+Field_reference_expression*
+Struct_type::field_reference(Expression* struct_expr, const std::string& name,
+ source_location location) const
+{
+ unsigned int depth;
+ return this->field_reference_depth(struct_expr, name, location, &depth);
+}
+
+// Return an expression for a field, along with the depth at which it
+// was found.
+
+Field_reference_expression*
+Struct_type::field_reference_depth(Expression* struct_expr,
+ const std::string& name,
+ source_location location,
+ unsigned int* depth) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+
+ // Look for a field with this name.
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ *depth = 0;
+ return Expression::make_field_reference(struct_expr, i, location);
+ }
+ }
+
+ // Look for an anonymous field which contains a field with this
+ // name.
+ unsigned int found_depth = 0;
+ Field_reference_expression* ret = NULL;
+ i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Struct_type* st = pf->type()->deref()->struct_type();
+ if (st == NULL)
+ continue;
+
+ // Look for a reference using a NULL struct expression. If we
+ // find one, fill in the struct expression with a reference to
+ // this field.
+ unsigned int subdepth;
+ Field_reference_expression* sub = st->field_reference_depth(NULL, name,
+ location,
+ &subdepth);
+ if (sub == NULL)
+ continue;
+
+ if (ret == NULL || subdepth < found_depth)
+ {
+ if (ret != NULL)
+ delete ret;
+ ret = sub;
+ found_depth = subdepth;
+ Expression* here = Expression::make_field_reference(struct_expr, i,
+ location);
+ if (pf->type()->points_to() != NULL)
+ here = Expression::make_unary(OPERATOR_MULT, here, location);
+ while (sub->expr() != NULL)
+ {
+ sub = sub->expr()->deref()->field_reference_expression();
+ gcc_assert(sub != NULL);
+ }
+ sub->set_struct_expression(here);
+ }
+ else if (subdepth > found_depth)
+ delete sub;
+ else
+ {
+ // We do not handle ambiguity here--it should be handled by
+ // Type::bind_field_or_method.
+ delete sub;
+ found_depth = 0;
+ ret = NULL;
+ }
+ }
+
+ if (ret != NULL)
+ *depth = found_depth + 1;
+
+ return ret;
+}
+
+// Return the total number of fields, including embedded fields.
+
+unsigned int
+Struct_type::total_field_count() const
+{
+ if (this->fields_ == NULL)
+ return 0;
+ unsigned int ret = 0;
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ if (!pf->is_anonymous() || pf->type()->deref()->struct_type() == NULL)
+ ++ret;
+ else
+ ret += pf->type()->struct_type()->total_field_count();
+ }
+ return ret;
+}
+
+// Return whether NAME is an unexported field, for better error reporting.
+
+bool
+Struct_type::is_unexported_local_field(Gogo* gogo,
+ const std::string& name) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ const std::string& field_name(pf->field_name());
+ if (Gogo::is_hidden_name(field_name)
+ && name == Gogo::unpack_hidden_name(field_name)
+ && gogo->pack_hidden_name(name, false) != field_name)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Finalize the methods of an unnamed struct.
+
+void
+Struct_type::finalize_methods(Gogo* gogo)
+{
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Struct_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Get the tree for a struct type.
+
+tree
+Struct_type::do_get_tree(Gogo* gogo)
+{
+ tree type = make_node(RECORD_TYPE);
+ return this->fill_in_tree(gogo, type);
+}
+
+// Fill in the fields for a struct type.
+
+tree
+Struct_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->field_name());
+ tree name_tree = get_identifier_with_length(name.data(), name.length());
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = build_decl(p->location(), FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = type;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+
+ TYPE_FIELDS(type) = field_trees;
+
+ layout_type(type);
+
+ return type;
+}
+
+// Initialize struct fields.
+
+tree
+Struct_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->fields_ == NULL || this->fields_->empty())
+ {
+ if (is_clear)
+ return NULL;
+ else
+ {
+ tree ret = build_constructor(type_tree,
+ VEC_alloc(constructor_elt, gc, 0));
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ }
+
+ bool is_constant = true;
+ bool any_fields_set = false;
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc,
+ this->fields_->size());
+ Struct_field_list::const_iterator p = this->fields_->begin();
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field), ++p)
+ {
+ gcc_assert(p != this->fields_->end());
+ tree value = p->type()->get_init_tree(gogo, is_clear);
+ if (value != NULL)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = value;
+ any_fields_set = true;
+ if (!TREE_CONSTANT(value))
+ is_constant = false;
+ }
+ }
+ gcc_assert(p == this->fields_->end());
+
+ if (!any_fields_set)
+ {
+ gcc_assert(is_clear);
+ VEC_free(constructor_elt, gc, init);
+ return NULL;
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of a struct type descriptor.
+
+Type*
+Struct_type::make_struct_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt,
+ "tag", pointer_string_type,
+ "offset", uintptr_type);
+ Type* nsf = Type::make_builtin_named_type("structField", sf);
+
+ Type* slice_type = Type::make_array_type(nsf, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "fields", slice_type);
+
+ ret = Type::make_builtin_named_type("StructType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a struct type.
+
+Expression*
+Struct_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Struct_type::make_struct_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ const Methods* methods = this->methods();
+ // A named struct should not have methods--the methods should attach
+ // to the named type.
+ gcc_assert(methods == NULL || name == NULL);
+
+ Struct_field_list::const_iterator ps = fields->begin();
+ gcc_assert(ps->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_STRUCT,
+ name, methods, true));
+
+ ++ps;
+ gcc_assert(ps->field_name() == "fields");
+
+ Expression_list* elements = new Expression_list();
+ elements->reserve(this->fields_->size());
+ Type* element_type = ps->type()->array_type()->element_type();
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ const Struct_field_list* f = element_type->struct_type()->fields();
+
+ Expression_list* fvals = new Expression_list();
+ fvals->reserve(5);
+
+ Struct_field_list::const_iterator q = f->begin();
+ gcc_assert(q->field_name() == "name");
+ if (pf->is_anonymous())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pf->field_name()))
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::hidden_name_prefix(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "typ");
+ fvals->push_back(Expression::make_type_descriptor(pf->type(), bloc));
+
+ ++q;
+ gcc_assert(q->field_name() == "tag");
+ if (!pf->has_tag())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ Expression* s = Expression::make_string(pf->tag(), bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "offset");
+ fvals->push_back(Expression::make_struct_field_offset(this, &*pf));
+
+ Expression* v = Expression::make_struct_composite_literal(element_type,
+ fvals, bloc);
+ elements->push_back(v);
+ }
+
+ vals->push_back(Expression::make_slice_composite_literal(ps->type(),
+ elements, bloc));
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Struct_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("struct { ");
+
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ if (p != this->fields_->begin())
+ ret->append("; ");
+ if (p->is_anonymous())
+ ret->push_back('?');
+ else
+ ret->append(Gogo::unpack_hidden_name(p->field_name()));
+ ret->push_back(' ');
+ this->append_reflection(p->type(), gogo, ret);
+
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ ret->append(" \"");
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (*p == '\0')
+ ret->append("\\x00");
+ else if (*p == '\n')
+ ret->append("\\n");
+ else if (*p == '\t')
+ ret->append("\\t");
+ else if (*p == '"')
+ ret->append("\\\"");
+ else if (*p == '\\')
+ ret->append("\\\\");
+ else
+ ret->push_back(*p);
+ }
+ ret->push_back('"');
+ }
+ }
+
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Struct_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('S');
+
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ ret->append("0_");
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(p->field_name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ }
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ std::string out;
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (ISALNUM(*p) || *p == '_')
+ out.push_back(*p);
+ else
+ {
+ char buf[20];
+ snprintf(buf, sizeof buf, ".%x.",
+ static_cast<unsigned int>(*p));
+ out.append(buf);
+ }
+ }
+ char buf[20];
+ snprintf(buf, sizeof buf, "T%u_",
+ static_cast<unsigned int>(out.length()));
+ ret->append(buf);
+ ret->append(out);
+ }
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Struct_type::do_export(Export* exp) const
+{
+ exp->write_c_string("struct { ");
+ const Struct_field_list* fields = this->fields_;
+ gcc_assert(fields != NULL);
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ exp->write_string("? ");
+ else
+ {
+ exp->write_string(p->field_name());
+ exp->write_c_string(" ");
+ }
+ exp->write_type(p->type());
+
+ if (p->has_tag())
+ {
+ exp->write_c_string(" ");
+ Expression* expr = Expression::make_string(p->tag(),
+ BUILTINS_LOCATION);
+ expr->export_expression(exp);
+ delete expr;
+ }
+
+ exp->write_c_string("; ");
+ }
+ exp->write_c_string("}");
+}
+
+// Import.
+
+Struct_type*
+Struct_type::do_import(Import* imp)
+{
+ imp->require_c_string("struct { ");
+ Struct_field_list* fields = new Struct_field_list;
+ if (imp->peek_char() != '}')
+ {
+ while (true)
+ {
+ std::string name;
+ if (imp->match_c_string("? "))
+ imp->advance(2);
+ else
+ {
+ name = imp->read_identifier();
+ imp->require_c_string(" ");
+ }
+ Type* ftype = imp->read_type();
+
+ Struct_field sf(Typed_identifier(name, ftype, imp->location()));
+
+ if (imp->peek_char() == ' ')
+ {
+ imp->advance(1);
+ Expression* expr = Expression::import_expression(imp);
+ String_expression* sexpr = expr->string_expression();
+ gcc_assert(sexpr != NULL);
+ sf.set_tag(sexpr->val());
+ delete sexpr;
+ }
+
+ imp->require_c_string("; ");
+ fields->push_back(sf);
+ if (imp->peek_char() == '}')
+ break;
+ }
+ }
+ imp->require_c_string("}");
+
+ return Type::make_struct_type(fields, imp->location());
+}
+
+// Make a struct type.
+
+Struct_type*
+Type::make_struct_type(Struct_field_list* fields,
+ source_location location)
+{
+ return new Struct_type(fields, location);
+}
+
+// Class Array_type.
+
+// Whether two array types are identical.
+
+bool
+Array_type::is_identical(const Array_type* t) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(), NULL))
+ return false;
+
+ Expression* l1 = this->length();
+ Expression* l2 = t->length();
+
+ // Slices of the same element type are identical.
+ if (l1 == NULL && l2 == NULL)
+ return true;
+
+ // Arrays of the same element type are identical if they have the
+ // same length.
+ if (l1 != NULL && l2 != NULL)
+ {
+ if (l1 == l2)
+ return true;
+
+ // Try to determine the lengths. If we can't, assume the arrays
+ // are not identical.
+ bool ret = false;
+ mpz_t v1;
+ mpz_init(v1);
+ Type* type1;
+ mpz_t v2;
+ mpz_init(v2);
+ Type* type2;
+ if (l1->integer_constant_value(true, v1, &type1)
+ && l2->integer_constant_value(true, v2, &type2))
+ ret = mpz_cmp(v1, v2) == 0;
+ mpz_clear(v1);
+ mpz_clear(v2);
+ return ret;
+ }
+
+ // Otherwise the arrays are not identical.
+ return false;
+}
+
+// Traversal.
+
+int
+Array_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->element_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->length_ != NULL
+ && Expression::traverse(&this->length_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the length is valid.
+
+bool
+Array_type::verify_length()
+{
+ if (this->length_ == NULL)
+ return true;
+ if (!this->length_->is_constant())
+ {
+ error_at(this->length_->location(), "array bound is not constant");
+ return false;
+ }
+
+ mpz_t val;
+
+ Type* t = this->length_->type();
+ if (t->integer_type() != NULL)
+ {
+ Type* vt;
+ mpz_init(val);
+ if (!this->length_->integer_constant_value(true, val, &vt))
+ {
+ error_at(this->length_->location(),
+ "array bound is not constant");
+ mpz_clear(val);
+ return false;
+ }
+ }
+ else if (t->float_type() != NULL)
+ {
+ Type* vt;
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (!this->length_->float_constant_value(fval, &vt))
+ {
+ error_at(this->length_->location(),
+ "array bound is not constant");
+ mpfr_clear(fval);
+ return false;
+ }
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(this->length_->location(),
+ "array bound truncated to integer");
+ mpfr_clear(fval);
+ return false;
+ }
+ mpz_init(val);
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ }
+ else
+ {
+ if (!t->is_error_type())
+ error_at(this->length_->location(), "array bound is not numeric");
+ return false;
+ }
+
+ if (mpz_sgn(val) < 0)
+ {
+ error_at(this->length_->location(), "negative array bound");
+ mpz_clear(val);
+ return false;
+ }
+
+ Type* int_type = Type::lookup_integer_type("int");
+ int tbits = int_type->integer_type()->bits();
+ int vbits = mpz_sizeinbase(val, 2);
+ if (vbits + 1 > tbits)
+ {
+ error_at(this->length_->location(), "array bound overflows");
+ mpz_clear(val);
+ return false;
+ }
+
+ mpz_clear(val);
+
+ return true;
+}
+
+// Verify the type.
+
+bool
+Array_type::do_verify()
+{
+ if (!this->verify_length())
+ {
+ this->length_ = Expression::make_error(this->length_->location());
+ return false;
+ }
+ return true;
+}
+
+// Array type hash code.
+
+unsigned int
+Array_type::do_hash_for_method(Gogo* gogo) const
+{
+ // There is no very convenient way to get a hash code for the
+ // length.
+ return this->element_type_->hash_for_method(gogo) + 1;
+}
+
+// See if the expression passed to make is suitable. The first
+// argument is required, and gives the length. An optional second
+// argument is permitted for the capacity.
+
+bool
+Array_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ gcc_assert(this->length_ == NULL);
+ if (args == NULL || args->empty())
+ {
+ error_at(location, "length required when allocating a slice");
+ return false;
+ }
+ else if (args->size() > 2)
+ {
+ error_at(location, "too many expressions passed to make");
+ return false;
+ }
+ else
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad length when making slice"), location))
+ return false;
+
+ if (args->size() > 1)
+ {
+ if (!Type::check_int_value(args->back(),
+ _("bad capacity when making slice"),
+ location))
+ return false;
+ }
+
+ return true;
+ }
+}
+
+// Get a tree for the length of a fixed array. The length may be
+// computed using a function call, so we must only evaluate it once.
+
+tree
+Array_type::get_length_tree(Gogo* gogo)
+{
+ gcc_assert(this->length_ != NULL);
+ if (this->length_tree_ == NULL_TREE)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* t;
+ if (this->length_->integer_constant_value(true, val, &t))
+ {
+ if (t == NULL)
+ t = Type::lookup_integer_type("int");
+ else if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ tree tt = t->get_tree(gogo);
+ this->length_tree_ = Expression::integer_constant_tree(val, tt);
+ mpz_clear(val);
+ }
+ else
+ {
+ mpz_clear(val);
+
+ // Make up a translation context for the array length
+ // expression. FIXME: This won't work in general.
+ Translate_context context(gogo, NULL, NULL, NULL_TREE);
+ tree len = this->length_->get_tree(&context);
+ len = convert_to_integer(integer_type_node, len);
+ this->length_tree_ = save_expr(len);
+ }
+ }
+ return this->length_tree_;
+}
+
+// Get a tree for the type of this array. A fixed array is simply
+// represented as ARRAY_TYPE with the appropriate index--i.e., it is
+// just like an array in C. An open array is a struct with three
+// fields: a data pointer, the length, and the capacity.
+
+tree
+Array_type::do_get_tree(Gogo* gogo)
+{
+ if (this->length_ == NULL)
+ {
+ tree struct_type = gogo->slice_type_tree(void_type_node);
+ return this->fill_in_tree(gogo, struct_type);
+ }
+ else
+ {
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ tree length_tree = this->get_length_tree(gogo);
+ if (element_type_tree == error_mark_node
+ || length_tree == error_mark_node)
+ return error_mark_node;
+
+ length_tree = fold_convert(sizetype, length_tree);
+
+ // build_index_type takes the maximum index, which is one less
+ // than the length.
+ tree index_type = build_index_type(fold_build2(MINUS_EXPR, sizetype,
+ length_tree,
+ size_one_node));
+
+ return build_array_type(element_type_tree, index_type);
+ }
+}
+
+// Fill in the fields for a slice type. This is used for named slice
+// types.
+
+tree
+Array_type::fill_in_tree(Gogo* gogo, tree struct_type)
+{
+ gcc_assert(this->length_ == NULL);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ tree field = TYPE_FIELDS(struct_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(field))
+ && TREE_TYPE(TREE_TYPE(field)) == void_type_node);
+ TREE_TYPE(field) = build_pointer_type(element_type_tree);
+
+ return struct_type;
+}
+
+// Return an initializer for an array type.
+
+tree
+Array_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->length_ == NULL)
+ {
+ // Open array.
+
+ if (is_clear)
+ return NULL;
+
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init,
+ NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ else
+ {
+ // Fixed array.
+
+ tree value = this->element_type_->get_init_tree(gogo, is_clear);
+ if (value == NULL)
+ return NULL;
+
+ tree length_tree = this->get_length_tree(gogo);
+ length_tree = fold_convert(sizetype, length_tree);
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node,
+ fold_build2(MINUS_EXPR, sizetype,
+ length_tree, size_one_node));
+ tree ret = build_constructor_single(type_tree, range, value);
+ if (TREE_CONSTANT(value))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+}
+
+// Handle the builtin make function for a slice.
+
+tree
+Array_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ gcc_assert(this->length_ == NULL);
+
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree values_field = TYPE_FIELDS(type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(values_field)),
+ "__values") == 0);
+
+ tree count_field = DECL_CHAIN(values_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(count_field)),
+ "__count") == 0);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size_tree = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree value = this->element_type_->get_init_tree(gogo, true);
+
+ // The first argument is the number of elements, the optional second
+ // argument is the capacity.
+ gcc_assert(args != NULL && args->size() >= 1 && args->size() <= 2);
+
+ tree length_tree = args->front()->get_tree(context);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(length_tree))
+ length_tree = save_expr(length_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(length_tree)))
+ length_tree = convert_to_integer(TREE_TYPE(count_field), length_tree);
+
+ tree bad_index = Expression::check_bounds(length_tree,
+ TREE_TYPE(count_field),
+ NULL_TREE, location);
+
+ length_tree = fold_convert_loc(location, TREE_TYPE(count_field), length_tree);
+ tree capacity_tree;
+ if (args->size() == 1)
+ capacity_tree = length_tree;
+ else
+ {
+ capacity_tree = args->back()->get_tree(context);
+ if (capacity_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(capacity_tree))
+ capacity_tree = save_expr(capacity_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(capacity_tree)))
+ capacity_tree = convert_to_integer(TREE_TYPE(count_field),
+ capacity_tree);
+
+ bad_index = Expression::check_bounds(capacity_tree,
+ TREE_TYPE(count_field),
+ bad_index, location);
+
+ tree chktype = (((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ > TYPE_SIZE(TREE_TYPE(length_tree)))
+ || ((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ == TYPE_SIZE(TREE_TYPE(length_tree)))
+ && TYPE_UNSIGNED(TREE_TYPE(capacity_tree))))
+ ? TREE_TYPE(capacity_tree)
+ : TREE_TYPE(length_tree));
+ tree chk = fold_build2_loc(location, LT_EXPR, boolean_type_node,
+ fold_convert_loc(location, chktype,
+ capacity_tree),
+ fold_convert_loc(location, chktype,
+ length_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ capacity_tree = fold_convert_loc(location, TREE_TYPE(count_field),
+ capacity_tree);
+ }
+
+ tree size_tree = fold_build2_loc(location, MULT_EXPR, sizetype,
+ element_size_tree,
+ fold_convert_loc(location, sizetype,
+ capacity_tree));
+
+ tree chk = fold_build2_loc(location, TRUTH_AND_EXPR, boolean_type_node,
+ fold_build2_loc(location, GT_EXPR,
+ boolean_type_node,
+ fold_convert_loc(location,
+ sizetype,
+ capacity_tree),
+ size_zero_node),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ size_tree, element_size_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ tree space = context->gogo()->allocate_memory(this->element_type_,
+ size_tree, location);
+
+ if (value != NULL_TREE)
+ space = save_expr(space);
+
+ space = fold_convert(TREE_TYPE(values_field), space);
+
+ if (bad_index != NULL_TREE && bad_index != boolean_false_node)
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS,
+ location);
+ space = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ space);
+ }
+
+ tree constructor = gogo->slice_constructor(type_tree, space, length_tree,
+ capacity_tree);
+
+ if (value == NULL_TREE)
+ {
+ // The array contents are zero initialized.
+ return constructor;
+ }
+
+ // The elements must be initialized.
+
+ tree max = fold_build2_loc(location, MINUS_EXPR, TREE_TYPE(count_field),
+ capacity_tree,
+ fold_convert_loc(location, TREE_TYPE(count_field),
+ integer_one_node));
+
+ tree array_type = build_array_type(element_type_tree,
+ build_index_type(max));
+
+ tree value_pointer = fold_convert_loc(location,
+ build_pointer_type(array_type),
+ space);
+
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node, max);
+ tree space_init = build_constructor_single(array_type, range, value);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build2(MODIFY_EXPR, void_type_node,
+ build_fold_indirect_ref(value_pointer),
+ space_init),
+ constructor);
+}
+
+// Return a tree for a pointer to the values in ARRAY.
+
+tree
+Array_type::value_pointer_tree(Gogo*, tree array) const
+{
+ tree ret;
+ if (this->length() != NULL)
+ {
+ // Fixed array.
+ ret = fold_convert(build_pointer_type(TREE_TYPE(TREE_TYPE(array))),
+ build_fold_addr_expr(array));
+ }
+ else
+ {
+ // Open array.
+ tree field = TYPE_FIELDS(TREE_TYPE(array));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ ret = fold_build3(COMPONENT_REF, TREE_TYPE(field), array, field,
+ NULL_TREE);
+ }
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the length of the array ARRAY which has this
+// type.
+
+tree
+Array_type::length_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ {
+ if (TREE_CODE(array) == SAVE_EXPR)
+ return fold_convert(integer_type_node, this->get_length_tree(gogo));
+ else
+ return omit_one_operand(integer_type_node,
+ this->get_length_tree(gogo), array);
+ }
+
+ // This is an open array. We need to read the length field.
+
+ tree type = TREE_TYPE(array);
+ gcc_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+
+ tree ret = build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the capacity of the array ARRAY which has this
+// type.
+
+tree
+Array_type::capacity_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ return omit_one_operand(sizetype, this->get_length_tree(gogo), array);
+
+ // This is an open array. We need to read the capacity field.
+
+ tree type = TREE_TYPE(array);
+ gcc_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(DECL_CHAIN(TYPE_FIELDS(type)));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+}
+
+// Export.
+
+void
+Array_type::do_export(Export* exp) const
+{
+ exp->write_c_string("[");
+ if (this->length_ != NULL)
+ this->length_->export_expression(exp);
+ exp->write_c_string("] ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Array_type*
+Array_type::do_import(Import* imp)
+{
+ imp->require_c_string("[");
+ Expression* length;
+ if (imp->peek_char() == ']')
+ length = NULL;
+ else
+ length = Expression::import_expression(imp);
+ imp->require_c_string("] ");
+ Type* element_type = imp->read_type();
+ return Type::make_array_type(element_type, length);
+}
+
+// The type of an array type descriptor.
+
+Type*
+Array_type::make_array_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "len", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ArrayType", sf);
+ }
+
+ return ret;
+}
+
+// The type of an slice type descriptor.
+
+Type*
+Array_type::make_slice_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("SliceType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an array/slice type.
+
+Expression*
+Array_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->length_ != NULL)
+ return this->array_type_descriptor(gogo, name);
+ else
+ return this->slice_type_descriptor(gogo, name);
+}
+
+// Build a type descriptor for an array type.
+
+Expression*
+Array_type::array_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* atdt = Array_type::make_array_type_descriptor_type();
+
+ const Struct_field_list* fields = atdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_ARRAY,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "len");
+ vals->push_back(this->length_);
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(atdt, vals, bloc);
+}
+
+// Build a type descriptor for a slice type.
+
+Expression*
+Array_type::slice_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Array_type::make_slice_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_SLICE,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Array_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('[');
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array length is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back(']');
+
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Array_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('A');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array size is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back('e');
+}
+
+// Make an array type.
+
+Array_type*
+Type::make_array_type(Type* element_type, Expression* length)
+{
+ return new Array_type(element_type, length);
+}
+
+// Class Map_type.
+
+// Traversal.
+
+int
+Map_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->key_type_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->val_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the map type is OK.
+
+bool
+Map_type::do_verify()
+{
+ if (this->key_type_->struct_type() != NULL
+ || this->key_type_->array_type() != NULL)
+ {
+ error_at(this->location_, "invalid map key type");
+ return false;
+ }
+ return true;
+}
+
+// Whether two map types are identical.
+
+bool
+Map_type::is_identical(const Map_type* t) const
+{
+ return (Type::are_identical(this->key_type(), t->key_type(), NULL)
+ && Type::are_identical(this->val_type(), t->val_type(), NULL));
+}
+
+// Hash code.
+
+unsigned int
+Map_type::do_hash_for_method(Gogo* gogo) const
+{
+ return (this->key_type_->hash_for_method(gogo)
+ + this->val_type_->hash_for_method(gogo)
+ + 2);
+}
+
+// Check that a call to the builtin make function is valid. For a map
+// the optional argument is the number of spaces to preallocate for
+// values.
+
+bool
+Map_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(), _("bad size when making map"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making map");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Get a tree for a map type. A map type is represented as a pointer
+// to a struct. The struct is __go_map in libgo/map.h.
+
+tree
+Map_type::do_get_tree(Gogo* gogo)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree struct_type = make_node(RECORD_TYPE);
+
+ tree map_descriptor_type = gogo->map_descriptor_type();
+ tree const_map_descriptor_type =
+ build_qualified_type(map_descriptor_type, TYPE_QUAL_CONST);
+ tree name = get_identifier("__descriptor");
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(const_map_descriptor_type));
+ DECL_CONTEXT(field) = struct_type;
+ TYPE_FIELDS(struct_type) = field;
+ tree last_field = field;
+
+ name = get_identifier("__element_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__bucket_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__buckets");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(ptr_type_node));
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+
+ layout_type(struct_type);
+
+ // Give the struct a name for better debugging info.
+ name = get_identifier("__go_map");
+ tree type_decl = build_decl(BUILTINS_LOCATION, TYPE_DECL, name,
+ struct_type);
+ DECL_ARTIFICIAL(type_decl) = 1;
+ TYPE_NAME(struct_type) = type_decl;
+ go_preserve_from_gc(type_decl);
+ rest_of_decl_compilation(type_decl, 1, 0);
+
+ type_tree = build_pointer_type(struct_type);
+ go_preserve_from_gc(type_tree);
+ }
+
+ return type_tree;
+}
+
+// Initialize a map.
+
+tree
+Map_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Return an expression for a newly allocated map.
+
+tree
+Map_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ tree map_type = this->get_tree(context->gogo());
+
+ static tree new_map_fndecl;
+ tree ret = Gogo::call_builtin(&new_map_fndecl,
+ location,
+ "__go_new_map",
+ 2,
+ map_type,
+ TREE_TYPE(TYPE_FIELDS(TREE_TYPE(map_type))),
+ context->gogo()->map_descriptor(this),
+ sizetype,
+ expr_tree);
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_map_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// The type of a map type descriptor.
+
+Type*
+Map_type::make_map_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "key", ptdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("MapType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Map_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* mtdt = Map_type::make_map_type_descriptor_type();
+
+ const Struct_field_list* fields = mtdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_MAP,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "key");
+ vals->push_back(Expression::make_type_descriptor(this->key_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->val_type_, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(mtdt, vals, bloc);
+}
+
+// Reflection string for a map.
+
+void
+Map_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("map[");
+ this->append_reflection(this->key_type_, gogo, ret);
+ ret->append("] ");
+ this->append_reflection(this->val_type_, gogo, ret);
+}
+
+// Mangled name for a map.
+
+void
+Map_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('M');
+ this->append_mangled_name(this->key_type_, gogo, ret);
+ ret->append("__");
+ this->append_mangled_name(this->val_type_, gogo, ret);
+}
+
+// Export a map type.
+
+void
+Map_type::do_export(Export* exp) const
+{
+ exp->write_c_string("map [");
+ exp->write_type(this->key_type_);
+ exp->write_c_string("] ");
+ exp->write_type(this->val_type_);
+}
+
+// Import a map type.
+
+Map_type*
+Map_type::do_import(Import* imp)
+{
+ imp->require_c_string("map [");
+ Type* key_type = imp->read_type();
+ imp->require_c_string("] ");
+ Type* val_type = imp->read_type();
+ return Type::make_map_type(key_type, val_type, imp->location());
+}
+
+// Make a map type.
+
+Map_type*
+Type::make_map_type(Type* key_type, Type* val_type, source_location location)
+{
+ return new Map_type(key_type, val_type, location);
+}
+
+// Class Channel_type.
+
+// Hash code.
+
+unsigned int
+Channel_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->may_send_)
+ ret += 1;
+ if (this->may_receive_)
+ ret += 2;
+ if (this->element_type_ != NULL)
+ ret += this->element_type_->hash_for_method(gogo) << 2;
+ return ret << 3;
+}
+
+// Whether this type is the same as T.
+
+bool
+Channel_type::is_identical(const Channel_type* t) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(), NULL))
+ return false;
+ return (this->may_send_ == t->may_send_
+ && this->may_receive_ == t->may_receive_);
+}
+
+// Check whether the parameters for a call to the builtin function
+// make are OK for a channel. A channel can take an optional single
+// parameter which is the buffer size.
+
+bool
+Channel_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad buffer size when making channel"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making channel");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Return the tree for a channel type. A channel is a pointer to a
+// __go_channel struct. The __go_channel struct is defined in
+// libgo/runtime/channel.h.
+
+tree
+Channel_type::do_get_tree(Gogo*)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree ret = make_node(RECORD_TYPE);
+ TYPE_NAME(ret) = get_identifier("__go_channel");
+ TYPE_STUB_DECL(ret) = build_decl(BUILTINS_LOCATION, TYPE_DECL, NULL_TREE,
+ ret);
+ type_tree = build_pointer_type(ret);
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Initialize a channel variable.
+
+tree
+Channel_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Handle the builtin function make for a channel.
+
+tree
+Channel_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree channel_type = this->get_tree(gogo);
+
+ tree element_tree = this->element_type_->get_tree(gogo);
+ tree element_size_tree = size_in_bytes(element_tree);
+
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ static tree new_channel_fndecl;
+ tree ret = Gogo::call_builtin(&new_channel_fndecl,
+ location,
+ "__go_new_channel",
+ 2,
+ channel_type,
+ sizetype,
+ element_size_tree,
+ sizetype,
+ expr_tree);
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_channel_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Build a type descriptor for a channel type.
+
+Type*
+Channel_type::make_chan_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "dir", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ChanType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Channel_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ctdt = Channel_type::make_chan_type_descriptor_type();
+
+ const Struct_field_list* fields = ctdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_CHAN,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "dir");
+ // These bits must match the ones in libgo/runtime/go-type.h.
+ int val = 0;
+ if (this->may_receive_)
+ val |= 1;
+ if (this->may_send_)
+ val |= 2;
+ mpz_t iv;
+ mpz_init_set_ui(iv, val);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+ mpz_clear(iv);
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ctdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Channel_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (!this->may_send_)
+ ret->append("<-");
+ ret->append("chan");
+ if (!this->may_receive_)
+ ret->append("<-");
+ ret->push_back(' ');
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Channel_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('C');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->may_send_)
+ ret->push_back('s');
+ if (this->may_receive_)
+ ret->push_back('r');
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Channel_type::do_export(Export* exp) const
+{
+ exp->write_c_string("chan ");
+ if (this->may_send_ && !this->may_receive_)
+ exp->write_c_string("-< ");
+ else if (this->may_receive_ && !this->may_send_)
+ exp->write_c_string("<- ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Channel_type*
+Channel_type::do_import(Import* imp)
+{
+ imp->require_c_string("chan ");
+
+ bool may_send;
+ bool may_receive;
+ if (imp->match_c_string("-< "))
+ {
+ imp->advance(3);
+ may_send = true;
+ may_receive = false;
+ }
+ else if (imp->match_c_string("<- "))
+ {
+ imp->advance(3);
+ may_receive = true;
+ may_send = false;
+ }
+ else
+ {
+ may_send = true;
+ may_receive = true;
+ }
+
+ Type* element_type = imp->read_type();
+
+ return Type::make_channel_type(may_send, may_receive, element_type);
+}
+
+// Make a new channel type.
+
+Channel_type*
+Type::make_channel_type(bool send, bool receive, Type* element_type)
+{
+ return new Channel_type(send, receive, element_type);
+}
+
+// Class Interface_type.
+
+// Traversal.
+
+int
+Interface_type::do_traverse(Traverse* traverse)
+{
+ if (this->methods_ == NULL)
+ return TRAVERSE_CONTINUE;
+ return this->methods_->traverse(traverse);
+}
+
+// Finalize the methods. This handles interface inheritance.
+
+void
+Interface_type::finalize_methods()
+{
+ if (this->methods_ == NULL)
+ return;
+ bool is_recursive = false;
+ size_t from = 0;
+ size_t to = 0;
+ while (from < this->methods_->size())
+ {
+ const Typed_identifier* p = &this->methods_->at(from);
+ if (!p->name().empty())
+ {
+ if (from != to)
+ this->methods_->set(to, *p);
+ ++from;
+ ++to;
+ continue;
+ }
+ Interface_type* it = p->type()->interface_type();
+ if (it == NULL)
+ {
+ error_at(p->location(), "interface contains embedded non-interface");
+ ++from;
+ continue;
+ }
+ if (it == this)
+ {
+ if (!is_recursive)
+ {
+ error_at(p->location(), "invalid recursive interface");
+ is_recursive = true;
+ }
+ ++from;
+ continue;
+ }
+ const Typed_identifier_list* methods = it->methods();
+ if (methods == NULL)
+ {
+ ++from;
+ continue;
+ }
+ for (Typed_identifier_list::const_iterator q = methods->begin();
+ q != methods->end();
+ ++q)
+ {
+ if (q->name().empty() || this->find_method(q->name()) == NULL)
+ this->methods_->push_back(Typed_identifier(q->name(), q->type(),
+ p->location()));
+ else
+ {
+ if (!is_recursive)
+ error_at(p->location(), "inherited method %qs is ambiguous",
+ Gogo::message_name(q->name()).c_str());
+ }
+ }
+ ++from;
+ }
+ if (to == 0)
+ {
+ delete this->methods_;
+ this->methods_ = NULL;
+ }
+ else
+ {
+ this->methods_->resize(to);
+ this->methods_->sort_by_name();
+ }
+}
+
+// Return the method NAME, or NULL.
+
+const Typed_identifier*
+Interface_type::find_method(const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return NULL;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ if (p->name() == name)
+ return &*p;
+ return NULL;
+}
+
+// Return the method index.
+
+size_t
+Interface_type::method_index(const std::string& name) const
+{
+ gcc_assert(this->methods_ != NULL);
+ size_t ret = 0;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p, ++ret)
+ if (p->name() == name)
+ return ret;
+ gcc_unreachable();
+}
+
+// Return whether NAME is an unexported method, for better error
+// reporting.
+
+bool
+Interface_type::is_unexported_method(Gogo* gogo, const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return false;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ const std::string& method_name(p->name());
+ if (Gogo::is_hidden_name(method_name)
+ && name == Gogo::unpack_hidden_name(method_name)
+ && gogo->pack_hidden_name(name, false) != method_name)
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical with T.
+
+bool
+Interface_type::is_identical(const Interface_type* t) const
+{
+ // We require the same methods with the same types. The methods
+ // have already been sorted.
+ if (this->methods() == NULL || t->methods() == NULL)
+ return this->methods() == t->methods();
+
+ Typed_identifier_list::const_iterator p1 = this->methods()->begin();
+ for (Typed_identifier_list::const_iterator p2 = t->methods()->begin();
+ p2 != t->methods()->end();
+ ++p1, ++p2)
+ {
+ if (p1 == this->methods()->end())
+ return false;
+ if (p1->name() != p2->name()
+ || !Type::are_identical(p1->type(), p2->type(), NULL))
+ return false;
+ }
+ if (p1 != this->methods()->end())
+ return false;
+ return true;
+}
+
+// Whether we can assign the interface type T to this type. The types
+// are known to not be identical. An interface assignment is only
+// permitted if T is known to implement all methods in THIS.
+// Otherwise a type guard is required.
+
+bool
+Interface_type::is_compatible_for_assign(const Interface_type* t,
+ std::string* reason) const
+{
+ if (this->methods() == NULL)
+ return true;
+ for (Typed_identifier_list::const_iterator p = this->methods()->begin();
+ p != this->methods()->end();
+ ++p)
+ {
+ const Typed_identifier* m = t->find_method(p->name());
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ char buf[200];
+ snprintf(buf, sizeof buf,
+ _("need explicit conversion; missing method %s%s%s"),
+ open_quote, Gogo::message_name(p->name()).c_str(),
+ close_quote);
+ reason->assign(buf);
+ }
+ return false;
+ }
+
+ std::string subreason;
+ if (!Type::are_identical(p->type(), m->type(), &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Interface_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ ret = Type::hash_string(p->name(), ret);
+ ret += p->type()->hash_for_method(gogo);
+ ret <<= 1;
+ }
+ }
+ return ret;
+}
+
+// Return true if T implements the interface. If it does not, and
+// REASON is not NULL, set *REASON to a useful error message.
+
+bool
+Interface_type::implements_interface(const Type* t, std::string* reason) const
+{
+ if (this->methods_ == NULL)
+ return true;
+
+ bool is_pointer = false;
+ const Named_type* nt = t->named_type();
+ const Struct_type* st = t->struct_type();
+ // If we start with a named type, we don't dereference it to find
+ // methods.
+ if (nt == NULL)
+ {
+ const Type* pt = t->points_to();
+ if (pt != NULL)
+ {
+ // If T is a pointer to a named type, then we need to look at
+ // the type to which it points.
+ is_pointer = true;
+ nt = pt->named_type();
+ st = pt->struct_type();
+ }
+ }
+
+ // If we have a named type, get the methods from it rather than from
+ // any struct type.
+ if (nt != NULL)
+ st = NULL;
+
+ // Only named and struct types have methods.
+ if (nt == NULL && st == NULL)
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ if (nt != NULL ? !nt->has_any_methods() : !st->has_any_methods())
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ bool is_ambiguous = false;
+ Method* m = (nt != NULL
+ ? nt->method_function(p->name(), &is_ambiguous)
+ : st->method_function(p->name(), &is_ambiguous));
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = n.length() + 100;
+ char* buf = new char[len];
+ if (is_ambiguous)
+ snprintf(buf, len, _("ambiguous method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len, _("missing method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ Function_type *p_fn_type = p->type()->function_type();
+ Function_type* m_fn_type = m->type()->function_type();
+ gcc_assert(p_fn_type != NULL && m_fn_type != NULL);
+ std::string subreason;
+ if (!p_fn_type->is_identical(m_fn_type, true, &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ if (!is_pointer && !m->is_value_method())
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length();
+ char* buf = new char[len];
+ snprintf(buf, len, _("method %s%s%s requires a pointer"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Return a tree for an interface type. An interface is a pointer to
+// a struct. The struct has three fields. The first field is a
+// pointer to the type descriptor for the dynamic type of the object.
+// The second field is a pointer to a table of methods for the
+// interface to be used with the object. The third field is the value
+// of the object itself.
+
+tree
+Interface_type::do_get_tree(Gogo* gogo)
+{
+ if (this->methods_ == NULL)
+ {
+ // At the tree level, use the same type for all empty
+ // interfaces. This lets us assign them to each other directly
+ // without triggering GIMPLE type errors.
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ static tree empty_interface;
+ return Gogo::builtin_struct(&empty_interface, "__go_empty_interface",
+ NULL_TREE, 2,
+ "__type_descriptor",
+ dtype,
+ "__object",
+ ptr_type_node);
+ }
+
+ return this->fill_in_tree(gogo, make_node(RECORD_TYPE));
+}
+
+// Fill in the tree for an interface type. This is used for named
+// interface types.
+
+tree
+Interface_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ gcc_assert(this->methods_ != NULL);
+
+ // Build the type of the table of methods.
+
+ tree method_table = make_node(RECORD_TYPE);
+
+ // The first field is a pointer to the type descriptor.
+ tree name_tree = get_identifier("__type_descriptor");
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree, dtype);
+ DECL_CONTEXT(field) = method_table;
+ TYPE_FIELDS(method_table) = field;
+
+ std::string last_name = "";
+ tree* pp = &DECL_CHAIN(field);
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->name());
+ name_tree = get_identifier_with_length(name.data(), name.length());
+ tree field_type = p->type()->get_tree(gogo);
+ if (field_type == error_mark_node)
+ return error_mark_node;
+ field = build_decl(this->location_, FIELD_DECL, name_tree, field_type);
+ DECL_CONTEXT(field) = method_table;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ // Sanity check: the names should be sorted.
+ gcc_assert(p->name() > last_name);
+ last_name = p->name();
+ }
+ layout_type(method_table);
+
+ tree mtype = build_pointer_type(method_table);
+
+ tree field_trees = NULL_TREE;
+ pp = &field_trees;
+
+ name_tree = get_identifier("__methods");
+ field = build_decl(this->location_, FIELD_DECL, name_tree, mtype);
+ DECL_CONTEXT(field) = type;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+
+ name_tree = get_identifier("__object");
+ field = build_decl(this->location_, FIELD_DECL, name_tree, ptr_type_node);
+ DECL_CONTEXT(field) = type;
+ *pp = field;
+
+ TYPE_FIELDS(type) = field_trees;
+
+ layout_type(type);
+
+ return type;
+}
+
+// Initialization value.
+
+tree
+Interface_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of an interface type descriptor.
+
+Type*
+Interface_type::make_interface_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sm =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt);
+
+ Type* nsm = Type::make_builtin_named_type("imethod", sm);
+
+ Type* slice_nsm = Type::make_array_type(nsm, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "methods", slice_nsm);
+
+ ret = Type::make_builtin_named_type("InterfaceType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an interface type.
+
+Expression*
+Interface_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* itdt = Interface_type::make_interface_type_descriptor_type();
+
+ const Struct_field_list* ifields = itdt->struct_type()->fields();
+
+ Expression_list* ivals = new Expression_list();
+ ivals->reserve(2);
+
+ Struct_field_list::const_iterator pif = ifields->begin();
+ gcc_assert(pif->field_name() == "commonType");
+ ivals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_INTERFACE,
+ name, NULL, true));
+
+ ++pif;
+ gcc_assert(pif->field_name() == "methods");
+
+ Expression_list* methods = new Expression_list();
+ if (this->methods_ != NULL && !this->methods_->empty())
+ {
+ Type* elemtype = pif->type()->array_type()->element_type();
+
+ methods->reserve(this->methods_->size());
+ for (Typed_identifier_list::const_iterator pm = this->methods_->begin();
+ pm != this->methods_->end();
+ ++pm)
+ {
+ const Struct_field_list* mfields = elemtype->struct_type()->fields();
+
+ Expression_list* mvals = new Expression_list();
+ mvals->reserve(3);
+
+ Struct_field_list::const_iterator pmf = mfields->begin();
+ gcc_assert(pmf->field_name() == "name");
+ std::string s = Gogo::unpack_hidden_name(pm->name());
+ Expression* e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+
+ ++pmf;
+ gcc_assert(pmf->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pm->name()))
+ mvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Gogo::hidden_name_prefix(pm->name());
+ e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+ }
+
+ ++pmf;
+ gcc_assert(pmf->field_name() == "typ");
+ mvals->push_back(Expression::make_type_descriptor(pm->type(), bloc));
+
+ ++pmf;
+ gcc_assert(pmf == mfields->end());
+
+ e = Expression::make_struct_composite_literal(elemtype, mvals,
+ bloc);
+ methods->push_back(e);
+ }
+ }
+
+ ivals->push_back(Expression::make_slice_composite_literal(pif->type(),
+ methods, bloc));
+
+ ++pif;
+ gcc_assert(pif == ifields->end());
+
+ return Expression::make_struct_composite_literal(itdt, ivals, bloc);
+}
+
+// Reflection string.
+
+void
+Interface_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("interface {");
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ if (p != this->methods_->begin())
+ ret->append(";");
+ ret->push_back(' ');
+ ret->append(Gogo::unpack_hidden_name(p->name()));
+ std::string sub = p->type()->reflection(gogo);
+ gcc_assert(sub.compare(0, 4, "func") == 0);
+ sub = sub.substr(4);
+ ret->append(sub);
+ }
+ }
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Interface_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('I');
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ std::string n = Gogo::unpack_hidden_name(p->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ this->append_mangled_name(p->type(), gogo, ret);
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Interface_type::do_export(Export* exp) const
+{
+ exp->write_c_string("interface { ");
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ exp->write_string(pm->name());
+ exp->write_c_string(" (");
+
+ const Function_type* fntype = pm->type()->function_type();
+
+ bool first = true;
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ for (Typed_identifier_list::const_iterator pp =
+ parameters->begin();
+ pp != parameters->end();
+ ++pp)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || pp + 1 != parameters->end())
+ exp->write_type(pp->type());
+ else
+ {
+ exp->write_c_string("...");
+ Type *pptype = pp->type();
+ exp->write_type(pptype->array_type()->element_type());
+ }
+ }
+ }
+
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p =
+ results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+
+ exp->write_c_string("; ");
+ }
+ }
+
+ exp->write_c_string("}");
+}
+
+// Import an interface type.
+
+Interface_type*
+Interface_type::do_import(Import* imp)
+{
+ imp->require_c_string("interface { ");
+
+ Typed_identifier_list* methods = new Typed_identifier_list;
+ while (imp->peek_char() != '}')
+ {
+ std::string name = imp->read_identifier();
+ imp->require_c_string(" (");
+
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list;
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list;
+ imp->advance(1);
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters,
+ results,
+ imp->location());
+ if (is_varargs)
+ fntype->set_is_varargs();
+ methods->push_back(Typed_identifier(name, fntype, imp->location()));
+
+ imp->require_c_string("; ");
+ }
+
+ imp->require_c_string("}");
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ return Type::make_interface_type(methods, imp->location());
+}
+
+// Make an interface type.
+
+Interface_type*
+Type::make_interface_type(Typed_identifier_list* methods,
+ source_location location)
+{
+ return new Interface_type(methods, location);
+}
+
+// Class Method.
+
+// Bind a method to an object.
+
+Expression*
+Method::bind_method(Expression* expr, source_location location) const
+{
+ if (this->stub_ == NULL)
+ {
+ // When there is no stub object, the binding is determined by
+ // the child class.
+ return this->do_bind_method(expr, location);
+ }
+
+ Expression* func = Expression::make_func_reference(this->stub_, NULL,
+ location);
+ return Expression::make_bound_method(expr, func, location);
+}
+
+// Return the named object associated with a method. This may only be
+// called after methods are finalized.
+
+Named_object*
+Method::named_object() const
+{
+ if (this->stub_ != NULL)
+ return this->stub_;
+ return this->do_named_object();
+}
+
+// Class Named_method.
+
+// The type of the method.
+
+Function_type*
+Named_method::do_type() const
+{
+ if (this->named_object_->is_function())
+ return this->named_object_->func_value()->type();
+ else if (this->named_object_->is_function_declaration())
+ return this->named_object_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Return the location of the method receiver.
+
+source_location
+Named_method::do_receiver_location() const
+{
+ return this->do_type()->receiver()->location();
+}
+
+// Bind a method to an object.
+
+Expression*
+Named_method::do_bind_method(Expression* expr, source_location location) const
+{
+ Expression* func = Expression::make_func_reference(this->named_object_, NULL,
+ location);
+ Bound_method_expression* bme = Expression::make_bound_method(expr, func,
+ location);
+ // If this is not a local method, and it does not use a stub, then
+ // the real method expects a different type. We need to cast the
+ // first argument.
+ if (this->depth() > 0 && !this->needs_stub_method())
+ {
+ Function_type* ftype = this->do_type();
+ gcc_assert(ftype->is_method());
+ Type* frtype = ftype->receiver()->type();
+ bme->set_first_argument_type(frtype);
+ }
+ return bme;
+}
+
+// Class Interface_method.
+
+// Bind a method to an object.
+
+Expression*
+Interface_method::do_bind_method(Expression* expr,
+ source_location location) const
+{
+ return Expression::make_interface_field_reference(expr, this->name_,
+ location);
+}
+
+// Class Methods.
+
+// Insert a new method. Return true if it was inserted, false
+// otherwise.
+
+bool
+Methods::insert(const std::string& name, Method* m)
+{
+ std::pair<Method_map::iterator, bool> ins =
+ this->methods_.insert(std::make_pair(name, m));
+ if (ins.second)
+ return true;
+ else
+ {
+ Method* old_method = ins.first->second;
+ if (m->depth() < old_method->depth())
+ {
+ delete old_method;
+ ins.first->second = m;
+ return true;
+ }
+ else
+ {
+ if (m->depth() == old_method->depth())
+ old_method->set_is_ambiguous();
+ return false;
+ }
+ }
+}
+
+// Return the number of unambiguous methods.
+
+size_t
+Methods::count() const
+{
+ size_t ret = 0;
+ for (Method_map::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ if (!p->second->is_ambiguous())
+ ++ret;
+ return ret;
+}
+
+// Class Named_type.
+
+// Return the name of the type.
+
+const std::string&
+Named_type::name() const
+{
+ return this->named_object_->name();
+}
+
+// Return the name of the type to use in an error message.
+
+std::string
+Named_type::message_name() const
+{
+ return this->named_object_->message_name();
+}
+
+// Add a method to this type.
+
+Named_object*
+Named_type::add_method(const std::string& name, Function* function)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function(name, NULL, function);
+}
+
+// Add a method declaration to this type.
+
+Named_object*
+Named_type::add_method_declaration(const std::string& name, Package* package,
+ Function_type* type,
+ source_location location)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function_declaration(name, package, type,
+ location);
+}
+
+// Add an existing method to this type.
+
+void
+Named_type::add_existing_method(Named_object* no)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ this->local_methods_->add_named_object(no);
+}
+
+// Look for a local method NAME, and returns its named object, or NULL
+// if not there.
+
+Named_object*
+Named_type::find_local_method(const std::string& name) const
+{
+ if (this->local_methods_ == NULL)
+ return NULL;
+ return this->local_methods_->lookup(name);
+}
+
+// Return whether NAME is an unexported field or method, for better
+// error reporting.
+
+bool
+Named_type::is_unexported_local_method(Gogo* gogo,
+ const std::string& name) const
+{
+ Bindings* methods = this->local_methods_;
+ if (methods != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->first)
+ && name == Gogo::unpack_hidden_name(p->first)
+ && gogo->pack_hidden_name(name, false) != p->first)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Build the complete list of methods for this type, which means
+// recursively including all methods for anonymous fields. Create all
+// stub methods.
+
+void
+Named_type::finalize_methods(Gogo* gogo)
+{
+ if (this->local_methods_ != NULL
+ && (this->points_to() != NULL || this->interface_type() != NULL))
+ {
+ const Bindings* lm = this->local_methods_;
+ for (Bindings::const_declarations_iterator p = lm->begin_declarations();
+ p != lm->end_declarations();
+ ++p)
+ error_at(p->second->location(),
+ "invalid pointer or interface receiver type");
+ delete this->local_methods_;
+ this->local_methods_ = NULL;
+ return;
+ }
+
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Named_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Return a pointer to the interface method table for this type for
+// the interface INTERFACE. IS_POINTER is true if this is for a
+// pointer to THIS.
+
+tree
+Named_type::interface_method_table(Gogo* gogo, const Interface_type* interface,
+ bool is_pointer)
+{
+ gcc_assert(!interface->is_empty());
+
+ Interface_method_tables** pimt = (is_pointer
+ ? &this->interface_method_tables_
+ : &this->pointer_interface_method_tables_);
+
+ if (*pimt == NULL)
+ *pimt = new Interface_method_tables(5);
+
+ std::pair<const Interface_type*, tree> val(interface, NULL_TREE);
+ std::pair<Interface_method_tables::iterator, bool> ins = (*pimt)->insert(val);
+
+ if (ins.second)
+ {
+ // This is a new entry in the hash table.
+ gcc_assert(ins.first->second == NULL_TREE);
+ ins.first->second = gogo->interface_method_table_for_type(interface,
+ this,
+ is_pointer);
+ }
+
+ tree decl = ins.first->second;
+ if (decl == error_mark_node)
+ return error_mark_node;
+ gcc_assert(decl != NULL_TREE && TREE_CODE(decl) == VAR_DECL);
+ return build_fold_addr_expr(decl);
+}
+
+// Return whether a named type has any hidden fields.
+
+bool
+Named_type::named_type_has_hidden_fields(std::string* reason) const
+{
+ if (this->seen_)
+ return false;
+ this->seen_ = true;
+ bool ret = this->type_->has_hidden_fields(this, reason);
+ this->seen_ = false;
+ return ret;
+}
+
+// Look for a use of a complete type within another type. This is
+// used to check that we don't try to use a type within itself.
+
+class Find_type_use : public Traverse
+{
+ public:
+ Find_type_use(Type* find_type)
+ : Traverse(traverse_types),
+ find_type_(find_type), found_(false)
+ { }
+
+ // Whether we found the type.
+ bool
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ type(Type*);
+
+ private:
+ // The type we are looking for.
+ Type* find_type_;
+ // Whether we found the type.
+ bool found_;
+};
+
+// Check for FIND_TYPE in TYPE.
+
+int
+Find_type_use::type(Type* type)
+{
+ if (this->find_type_ == type)
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+ // It's OK if we see a reference to the type in any type which is
+ // essentially a pointer: a pointer, a slice, a function, a map, or
+ // a channel.
+ if (type->points_to() != NULL
+ || type->is_open_array_type()
+ || type->function_type() != NULL
+ || type->map_type() != NULL
+ || type->channel_type() != NULL)
+ return TRAVERSE_SKIP_COMPONENTS;
+
+ // For an interface, a reference to the type in a method type should
+ // be ignored, but we have to consider direct inheritance. When
+ // this is called, there may be cases of direct inheritance
+ // represented as a method with no name.
+ if (type->interface_type() != NULL)
+ {
+ const Typed_identifier_list* methods = type->interface_type()->methods();
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->name().empty())
+ {
+ if (Type::traverse(p->type(), this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that a named type does not refer to itself.
+
+bool
+Named_type::do_verify()
+{
+ Find_type_use find(this);
+ Type::traverse(this->type_, &find);
+ if (find.found())
+ {
+ error_at(this->location_, "invalid recursive type %qs",
+ this->message_name().c_str());
+ this->is_error_ = true;
+ return false;
+ }
+
+ // Check whether any of the local methods overloads an existing
+ // struct field or interface method. We don't need to check the
+ // list of methods against itself: that is handled by the Bindings
+ // code.
+ if (this->local_methods_ != NULL)
+ {
+ Struct_type* st = this->type_->struct_type();
+ Interface_type* it = this->type_->interface_type();
+ bool found_dup = false;
+ if (st != NULL || it != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ this->local_methods_->begin_declarations();
+ p != this->local_methods_->end_declarations();
+ ++p)
+ {
+ const std::string& name(p->first);
+ if (st != NULL && st->find_local_field(name, NULL) != NULL)
+ {
+ error_at(p->second->location(),
+ "method %qs redeclares struct field name",
+ Gogo::message_name(name).c_str());
+ found_dup = true;
+ }
+ if (it != NULL && it->find_method(name) != NULL)
+ {
+ error_at(p->second->location(),
+ "method %qs redeclares interface method name",
+ Gogo::message_name(name).c_str());
+ found_dup = true;
+ }
+ }
+ }
+ if (found_dup)
+ return false;
+ }
+
+ return true;
+}
+
+// Return a hash code. This is used for method lookup. We simply
+// hash on the name itself.
+
+unsigned int
+Named_type::do_hash_for_method(Gogo* gogo) const
+{
+ const std::string& name(this->named_object()->name());
+ unsigned int ret = Type::hash_string(name, 0);
+
+ // GOGO will be NULL here when called from Type_hash_identical.
+ // That is OK because that is only used for internal hash tables
+ // where we are going to be comparing named types for equality. In
+ // other cases, which are cases where the runtime is going to
+ // compare hash codes to see if the types are the same, we need to
+ // include the package prefix and name in the hash.
+ if (gogo != NULL && !Gogo::is_hidden_name(name) && !this->is_builtin())
+ {
+ const Package* package = this->named_object()->package();
+ if (package == NULL)
+ {
+ ret = Type::hash_string(gogo->unique_prefix(), ret);
+ ret = Type::hash_string(gogo->package_name(), ret);
+ }
+ else
+ {
+ ret = Type::hash_string(package->unique_prefix(), ret);
+ ret = Type::hash_string(package->name(), ret);
+ }
+ }
+
+ return ret;
+}
+
+// Get a tree for a named type.
+
+tree
+Named_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_error_)
+ return error_mark_node;
+
+ // Go permits types to refer to themselves in various ways. Break
+ // the recursion here.
+ tree t;
+ switch (this->type_->forwarded()->classification())
+ {
+ case TYPE_ERROR:
+ return error_mark_node;
+
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These types can not refer to themselves.
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ // All maps and channels have the same type in GENERIC.
+ t = Type::get_named_type_tree(gogo, this->type_);
+ if (t == error_mark_node)
+ return error_mark_node;
+ // Build a copy to set TYPE_NAME.
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_FUNCTION:
+ // GENERIC can't handle a pointer to a function type whose
+ // return type is a pointer to the function type itself. It
+ // does into infinite loops when walking the types.
+ if (this->seen_
+ && this->function_type()->results() != NULL
+ && this->function_type()->results()->size() == 1
+ && (this->function_type()->results()->front().type()->forwarded()
+ == this))
+ return ptr_type_node;
+ this->seen_ = true;
+ t = Type::get_named_type_tree(gogo, this->type_);
+ this->seen_ = false;
+ if (t == error_mark_node)
+ return error_mark_node;
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_POINTER:
+ // GENERIC can't handle a pointer type which points to itself.
+ // It goes into infinite loops when walking the types.
+ if (this->seen_ && this->points_to()->forwarded() == this)
+ return ptr_type_node;
+ this->seen_ = true;
+ t = Type::get_named_type_tree(gogo, this->type_);
+ this->seen_ = false;
+ if (t == error_mark_node)
+ return error_mark_node;
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_STRUCT:
+ if (this->named_tree_ != NULL_TREE)
+ return this->named_tree_;
+ t = make_node(RECORD_TYPE);
+ this->named_tree_ = t;
+ this->type_->struct_type()->fill_in_tree(gogo, t);
+ break;
+
+ case TYPE_ARRAY:
+ if (!this->is_open_array_type())
+ t = Type::get_named_type_tree(gogo, this->type_);
+ else
+ {
+ if (this->named_tree_ != NULL_TREE)
+ return this->named_tree_;
+ t = gogo->slice_type_tree(void_type_node);
+ this->named_tree_ = t;
+ t = this->type_->array_type()->fill_in_tree(gogo, t);
+ }
+ if (t == error_mark_node)
+ return error_mark_node;
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_INTERFACE:
+ if (this->type_->interface_type()->is_empty())
+ {
+ t = Type::get_named_type_tree(gogo, this->type_);
+ if (t == error_mark_node)
+ return error_mark_node;
+ t = build_variant_type_copy(t);
+ }
+ else
+ {
+ if (this->named_tree_ != NULL_TREE)
+ return this->named_tree_;
+ t = make_node(RECORD_TYPE);
+ this->named_tree_ = t;
+ t = this->type_->interface_type()->fill_in_tree(gogo, t);
+ }
+ break;
+
+ case TYPE_NAMED:
+ {
+ // When a named type T1 is defined as another named type T2,
+ // the definition must simply be "type T1 T2". If the
+ // definition of T2 may refer to T1, then we must simply
+ // return the type for T2 here. It's not precisely correct,
+ // but it's as close as we can get with GENERIC.
+ bool was_seen = this->seen_;
+ this->seen_ = true;
+ t = Type::get_named_type_tree(gogo, this->type_);
+ this->seen_ = was_seen;
+ if (was_seen)
+ return t;
+ if (t == error_mark_node)
+ return error_mark_node;
+ t = build_variant_type_copy(t);
+ }
+ break;
+
+ case TYPE_FORWARD:
+ // An undefined forwarding type. Make sure the error is
+ // emitted.
+ this->type_->forward_declaration_type()->real_type();
+ return error_mark_node;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ gcc_unreachable();
+ }
+
+ tree id = this->named_object_->get_id(gogo);
+ tree decl = build_decl(this->location_, TYPE_DECL, id, t);
+ TYPE_NAME(t) = decl;
+
+ return t;
+}
+
+// Build a type descriptor for a named type.
+
+Expression*
+Named_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ // If NAME is not NULL, then we don't really want the type
+ // descriptor for this type; we want the descriptor for the
+ // underlying type, giving it the name NAME.
+ return this->named_type_descriptor(gogo, this->type_,
+ name == NULL ? this : name);
+}
+
+// Add to the reflection string. This is used mostly for the name of
+// the type used in a type descriptor, not for actual reflection
+// strings.
+
+void
+Named_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (this->location() != BUILTINS_LOCATION)
+ {
+ const Package* package = this->named_object_->package();
+ if (package != NULL)
+ ret->append(package->name());
+ else
+ ret->append(gogo->package_name());
+ ret->push_back('.');
+ }
+ if (this->in_function_ != NULL)
+ {
+ ret->append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ ret->push_back('$');
+ }
+ ret->append(Gogo::unpack_hidden_name(this->named_object_->name()));
+}
+
+// Get the mangled name.
+
+void
+Named_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ Named_object* no = this->named_object_;
+ std::string name;
+ if (this->location() == BUILTINS_LOCATION)
+ gcc_assert(this->in_function_ == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? gogo->package_name()
+ : no->package()->name());
+ name = unique_prefix;
+ name.append(1, '.');
+ name.append(package_name);
+ name.append(1, '.');
+ if (this->in_function_ != NULL)
+ {
+ name.append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ name.append(1, '$');
+ }
+ }
+ name.append(Gogo::unpack_hidden_name(no->name()));
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_", static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+}
+
+// Export the type. This is called to export a global type.
+
+void
+Named_type::export_named_type(Export* exp, const std::string&) const
+{
+ // We don't need to write the name of the type here, because it will
+ // be written by Export::write_type anyhow.
+ exp->write_c_string("type ");
+ exp->write_type(this);
+ exp->write_c_string(";\n");
+}
+
+// Import a named type.
+
+void
+Named_type::import_named_type(Import* imp, Named_type** ptype)
+{
+ imp->require_c_string("type ");
+ Type *type = imp->read_type();
+ *ptype = type->named_type();
+ gcc_assert(*ptype != NULL);
+ imp->require_c_string(";\n");
+}
+
+// Export the type when it is referenced by another type. In this
+// case Export::export_type will already have issued the name.
+
+void
+Named_type::do_export(Export* exp) const
+{
+ exp->write_type(this->type_);
+
+ // To save space, we only export the methods directly attached to
+ // this type.
+ Bindings* methods = this->local_methods_;
+ if (methods == NULL)
+ return;
+
+ exp->write_c_string("\n");
+ for (Bindings::const_definitions_iterator p = methods->begin_definitions();
+ p != methods->end_definitions();
+ ++p)
+ {
+ exp->write_c_string(" ");
+ (*p)->export_named_object(exp);
+ }
+
+ for (Bindings::const_declarations_iterator p = methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (p->second->is_function_declaration())
+ {
+ exp->write_c_string(" ");
+ p->second->export_named_object(exp);
+ }
+ }
+}
+
+// Make a named type.
+
+Named_type*
+Type::make_named_type(Named_object* named_object, Type* type,
+ source_location location)
+{
+ return new Named_type(named_object, type, location);
+}
+
+// Finalize the methods for TYPE. It will be a named type or a struct
+// type. This sets *ALL_METHODS to the list of methods, and builds
+// all required stubs.
+
+void
+Type::finalize_methods(Gogo* gogo, const Type* type, source_location location,
+ Methods** all_methods)
+{
+ *all_methods = NULL;
+ Types_seen types_seen;
+ Type::add_methods_for_type(type, NULL, 0, false, false, &types_seen,
+ all_methods);
+ Type::build_stub_methods(gogo, type, *all_methods, location);
+}
+
+// Add the methods for TYPE to *METHODS. FIELD_INDEXES is used to
+// build up the struct field indexes as we go. DEPTH is the depth of
+// the field within TYPE. IS_EMBEDDED_POINTER is true if we are
+// adding these methods for an anonymous field with pointer type.
+// NEEDS_STUB_METHOD is true if we need to use a stub method which
+// calls the real method. TYPES_SEEN is used to avoid infinite
+// recursion.
+
+void
+Type::add_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Pointer types may not have methods.
+ if (type->points_to() != NULL)
+ return;
+
+ const Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ std::pair<Types_seen::iterator, bool> ins = types_seen->insert(nt);
+ if (!ins.second)
+ return;
+ }
+
+ if (nt != NULL)
+ Type::add_local_methods_for_type(nt, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ methods);
+
+ Type::add_embedded_methods_for_type(type, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ types_seen, methods);
+
+ // If we are called with depth > 0, then we are looking at an
+ // anonymous field of a struct. If such a field has interface type,
+ // then we need to add the interface methods. We don't want to add
+ // them when depth == 0, because we will already handle them
+ // following the usual rules for an interface type.
+ if (depth > 0)
+ Type::add_interface_methods_for_type(type, field_indexes, depth, methods);
+}
+
+// Add the local methods for the named type NT to *METHODS. The
+// parameters are as for add_methods_to_type.
+
+void
+Type::add_local_methods_for_type(const Named_type* nt,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Methods** methods)
+{
+ const Bindings* local_methods = nt->local_methods();
+ if (local_methods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Bindings::const_declarations_iterator p =
+ local_methods->begin_declarations();
+ p != local_methods->end_declarations();
+ ++p)
+ {
+ Named_object* no = p->second;
+ bool is_value_method = (is_embedded_pointer
+ || !Type::method_expects_pointer(no));
+ Method* m = new Named_method(no, field_indexes, depth, is_value_method,
+ (needs_stub_method
+ || (depth > 0 && is_value_method)));
+ if (!(*methods)->insert(no->name(), m))
+ delete m;
+ }
+}
+
+// Add the embedded methods for TYPE to *METHODS. These are the
+// methods attached to anonymous fields. The parameters are as for
+// add_methods_to_type.
+
+void
+Type::add_embedded_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Look for anonymous fields in TYPE. TYPE has fields if it is a
+ // struct.
+ const Struct_type* st = type->struct_type();
+ if (st == NULL)
+ return;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return;
+
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Type* ftype = pf->type();
+ bool is_pointer = false;
+ if (ftype->points_to() != NULL)
+ {
+ ftype = ftype->points_to();
+ is_pointer = true;
+ }
+ Named_type* fnt = ftype->named_type();
+ if (fnt == NULL)
+ {
+ // This is an error, but it will be diagnosed elsewhere.
+ continue;
+ }
+
+ Method::Field_indexes* sub_field_indexes = new Method::Field_indexes();
+ sub_field_indexes->next = field_indexes;
+ sub_field_indexes->field_index = i;
+
+ Type::add_methods_for_type(fnt, sub_field_indexes, depth + 1,
+ (is_embedded_pointer || is_pointer),
+ (needs_stub_method
+ || is_pointer
+ || i > 0),
+ types_seen,
+ methods);
+ }
+}
+
+// If TYPE is an interface type, then add its method to *METHODS.
+// This is for interface methods attached to an anonymous field. The
+// parameters are as for add_methods_for_type.
+
+void
+Type::add_interface_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ Methods** methods)
+{
+ const Interface_type* it = type->interface_type();
+ if (it == NULL)
+ return;
+
+ const Typed_identifier_list* imethods = it->methods();
+ if (imethods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Typed_identifier_list::const_iterator pm = imethods->begin();
+ pm != imethods->end();
+ ++pm)
+ {
+ Function_type* fntype = pm->type()->function_type();
+ gcc_assert(fntype != NULL && !fntype->is_method());
+ fntype = fntype->copy_with_receiver(const_cast<Type*>(type));
+ Method* m = new Interface_method(pm->name(), pm->location(), fntype,
+ field_indexes, depth);
+ if (!(*methods)->insert(pm->name(), m))
+ delete m;
+ }
+}
+
+// Build stub methods for TYPE as needed. METHODS is the set of
+// methods for the type. A stub method may be needed when a type
+// inherits a method from an anonymous field. When we need the
+// address of the method, as in a type descriptor, we need to build a
+// little stub which does the required field dereferences and jumps to
+// the real method. LOCATION is the location of the type definition.
+
+void
+Type::build_stub_methods(Gogo* gogo, const Type* type, const Methods* methods,
+ source_location location)
+{
+ if (methods == NULL)
+ return;
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ Method* m = p->second;
+ if (m->is_ambiguous() || !m->needs_stub_method())
+ continue;
+
+ const std::string& name(p->first);
+
+ // Build a stub method.
+
+ const Function_type* fntype = m->type();
+
+ static unsigned int counter;
+ char buf[100];
+ snprintf(buf, sizeof buf, "$this%u", counter);
+ ++counter;
+
+ Type* receiver_type = const_cast<Type*>(type);
+ if (!m->is_value_method())
+ receiver_type = Type::make_pointer_type(receiver_type);
+ source_location receiver_location = m->receiver_location();
+ Typed_identifier* receiver = new Typed_identifier(buf, receiver_type,
+ receiver_location);
+
+ const Typed_identifier_list* fnparams = fntype->parameters();
+ Typed_identifier_list* stub_params;
+ if (fnparams == NULL || fnparams->empty())
+ stub_params = NULL;
+ else
+ {
+ // We give each stub parameter a unique name.
+ stub_params = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pp = fnparams->begin();
+ pp != fnparams->end();
+ ++pp)
+ {
+ char pbuf[100];
+ snprintf(pbuf, sizeof pbuf, "$p%u", counter);
+ stub_params->push_back(Typed_identifier(pbuf, pp->type(),
+ pp->location()));
+ ++counter;
+ }
+ }
+
+ const Typed_identifier_list* fnresults = fntype->results();
+ Typed_identifier_list* stub_results;
+ if (fnresults == NULL || fnresults->empty())
+ stub_results = NULL;
+ else
+ {
+ // We create the result parameters without any names, since
+ // we won't refer to them.
+ stub_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pr = fnresults->begin();
+ pr != fnresults->end();
+ ++pr)
+ stub_results->push_back(Typed_identifier("", pr->type(),
+ pr->location()));
+ }
+
+ Function_type* stub_type = Type::make_function_type(receiver,
+ stub_params,
+ stub_results,
+ fntype->location());
+ if (fntype->is_varargs())
+ stub_type->set_is_varargs();
+
+ // We only create the function in the package which creates the
+ // type.
+ const Package* package;
+ if (type->named_type() == NULL)
+ package = NULL;
+ else
+ package = type->named_type()->named_object()->package();
+ Named_object* stub;
+ if (package != NULL)
+ stub = Named_object::make_function_declaration(name, package,
+ stub_type, location);
+ else
+ {
+ stub = gogo->start_function(name, stub_type, false,
+ fntype->location());
+ Type::build_one_stub_method(gogo, m, buf, stub_params,
+ fntype->is_varargs(), location);
+ gogo->finish_function(fntype->location());
+ }
+
+ m->set_stub_object(stub);
+ }
+}
+
+// Build a stub method which adjusts the receiver as required to call
+// METHOD. RECEIVER_NAME is the name we used for the receiver.
+// PARAMS is the list of function parameters.
+
+void
+Type::build_one_stub_method(Gogo* gogo, Method* method,
+ const char* receiver_name,
+ const Typed_identifier_list* params,
+ bool is_varargs,
+ source_location location)
+{
+ Named_object* receiver_object = gogo->lookup(receiver_name, NULL);
+ gcc_assert(receiver_object != NULL);
+
+ Expression* expr = Expression::make_var_reference(receiver_object, location);
+ expr = Type::apply_field_indexes(expr, method->field_indexes(), location);
+ if (expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+
+ Expression_list* arguments;
+ if (params == NULL || params->empty())
+ arguments = NULL;
+ else
+ {
+ arguments = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ Named_object* param = gogo->lookup(p->name(), NULL);
+ gcc_assert(param != NULL);
+ Expression* param_ref = Expression::make_var_reference(param,
+ location);
+ arguments->push_back(param_ref);
+ }
+ }
+
+ Expression* func = method->bind_method(expr, location);
+ gcc_assert(func != NULL);
+ Call_expression* call = Expression::make_call(func, arguments, is_varargs,
+ location);
+ size_t count = call->result_count();
+ if (count == 0)
+ gogo->add_statement(Statement::make_statement(call));
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ const Function* function = gogo->current_function()->func_value();
+ const Typed_identifier_list* results = function->type()->results();
+ Statement* retstat = Statement::make_return_statement(results, retvals,
+ location);
+ gogo->add_statement(retstat);
+ }
+}
+
+// Apply FIELD_INDEXES to EXPR. The field indexes have to be applied
+// in reverse order.
+
+Expression*
+Type::apply_field_indexes(Expression* expr,
+ const Method::Field_indexes* field_indexes,
+ source_location location)
+{
+ if (field_indexes == NULL)
+ return expr;
+ expr = Type::apply_field_indexes(expr, field_indexes->next, location);
+ Struct_type* stype = expr->type()->deref()->struct_type();
+ gcc_assert(stype != NULL
+ && field_indexes->field_index < stype->field_count());
+ if (expr->type()->struct_type() == NULL)
+ {
+ gcc_assert(expr->type()->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ gcc_assert(expr->type()->struct_type() == stype);
+ }
+ return Expression::make_field_reference(expr, field_indexes->field_index,
+ location);
+}
+
+// Return whether NO is a method for which the receiver is a pointer.
+
+bool
+Type::method_expects_pointer(const Named_object* no)
+{
+ const Function_type *fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+ return fntype->receiver()->type()->points_to() != NULL;
+}
+
+// Given a set of methods for a type, METHODS, return the method NAME,
+// or NULL if there isn't one or if it is ambiguous. If IS_AMBIGUOUS
+// is not NULL, then set *IS_AMBIGUOUS to true if the method exists
+// but is ambiguous (and return NULL).
+
+Method*
+Type::method_function(const Methods* methods, const std::string& name,
+ bool* is_ambiguous)
+{
+ if (is_ambiguous != NULL)
+ *is_ambiguous = false;
+ if (methods == NULL)
+ return NULL;
+ Methods::const_iterator p = methods->find(name);
+ if (p == methods->end())
+ return NULL;
+ Method* m = p->second;
+ if (m->is_ambiguous())
+ {
+ if (is_ambiguous != NULL)
+ *is_ambiguous = true;
+ return NULL;
+ }
+ return m;
+}
+
+// Look for field or method NAME for TYPE. Return an Expression for
+// the field or method bound to EXPR. If there is no such field or
+// method, give an appropriate error and return an error expression.
+
+Expression*
+Type::bind_field_or_method(Gogo* gogo, const Type* type, Expression* expr,
+ const std::string& name,
+ source_location location)
+{
+ if (type->is_error_type())
+ return Expression::make_error(location);
+
+ const Named_type* nt = type->named_type();
+ if (nt == NULL)
+ nt = type->deref()->named_type();
+ const Struct_type* st = type->deref()->struct_type();
+ const Interface_type* it = type->deref()->interface_type();
+
+ // If this is a pointer to a pointer, then it is possible that the
+ // pointed-to type has methods.
+ if (nt == NULL
+ && st == NULL
+ && it == NULL
+ && type->points_to() != NULL
+ && type->points_to()->points_to() != NULL)
+ {
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ type = type->points_to();
+ nt = type->points_to()->named_type();
+ st = type->points_to()->struct_type();
+ it = type->points_to()->interface_type();
+ }
+
+ bool receiver_can_be_pointer = (expr->type()->points_to() != NULL
+ || expr->is_addressable());
+ bool is_method = false;
+ bool found_pointer_method = false;
+ std::string ambig1;
+ std::string ambig2;
+ if (Type::find_field_or_method(type, name, receiver_can_be_pointer, NULL,
+ &is_method, &found_pointer_method,
+ &ambig1, &ambig2))
+ {
+ Expression* ret;
+ if (!is_method)
+ {
+ gcc_assert(st != NULL);
+ if (type->struct_type() == NULL)
+ {
+ gcc_assert(type->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr,
+ location);
+ gcc_assert(expr->type()->struct_type() == st);
+ }
+ ret = st->field_reference(expr, name, location);
+ }
+ else if (it != NULL && it->find_method(name) != NULL)
+ ret = Expression::make_interface_field_reference(expr, name,
+ location);
+ else
+ {
+ Method* m;
+ if (nt != NULL)
+ m = nt->method_function(name, NULL);
+ else if (st != NULL)
+ m = st->method_function(name, NULL);
+ else
+ gcc_unreachable();
+ gcc_assert(m != NULL);
+ if (!m->is_value_method() && expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+ ret = m->bind_method(expr, location);
+ }
+ gcc_assert(ret != NULL);
+ return ret;
+ }
+ else
+ {
+ if (!ambig1.empty())
+ error_at(location, "%qs is ambiguous via %qs and %qs",
+ Gogo::message_name(name).c_str(),
+ Gogo::message_name(ambig1).c_str(),
+ Gogo::message_name(ambig2).c_str());
+ else if (found_pointer_method)
+ error_at(location, "method requires a pointer");
+ else if (nt == NULL && st == NULL && it == NULL)
+ error_at(location,
+ ("reference to field %qs in object which "
+ "has no fields or methods"),
+ Gogo::message_name(name).c_str());
+ else
+ {
+ bool is_unexported;
+ if (!Gogo::is_hidden_name(name))
+ is_unexported = false;
+ else
+ {
+ std::string unpacked = Gogo::unpack_hidden_name(name);
+ is_unexported = Type::is_unexported_field_or_method(gogo, type,
+ unpacked);
+ }
+ if (is_unexported)
+ error_at(location, "reference to unexported field or method %qs",
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "reference to undefined field or method %qs",
+ Gogo::message_name(name).c_str());
+ }
+ return Expression::make_error(location);
+ }
+}
+
+// Look in TYPE for a field or method named NAME, return true if one
+// is found. This looks through embedded anonymous fields and handles
+// ambiguity. If a method is found, sets *IS_METHOD to true;
+// otherwise, if a field is found, set it to false. If
+// RECEIVER_CAN_BE_POINTER is false, then the receiver is a value
+// whose address can not be taken. When returning false, this sets
+// *FOUND_POINTER_METHOD if we found a method we couldn't use because
+// it requires a pointer. LEVEL is used for recursive calls, and can
+// be NULL for a non-recursive call. When this function returns false
+// because it finds that the name is ambiguous, it will store a path
+// to the ambiguous names in *AMBIG1 and *AMBIG2. If the name is not
+// found at all, *AMBIG1 and *AMBIG2 will be unchanged.
+
+// This function just returns whether or not there is a field or
+// method, and whether it is a field or method. It doesn't build an
+// expression to refer to it. If it is a method, we then look in the
+// list of all methods for the type. If it is a field, the search has
+// to be done again, looking only for fields, and building up the
+// expression as we go.
+
+bool
+Type::find_field_or_method(const Type* type,
+ const std::string& name,
+ bool receiver_can_be_pointer,
+ int* level,
+ bool* is_method,
+ bool* found_pointer_method,
+ std::string* ambig1,
+ std::string* ambig2)
+{
+ // Named types can have locally defined methods.
+ const Named_type* nt = type->named_type();
+ if (nt == NULL && type->points_to() != NULL)
+ nt = type->points_to()->named_type();
+ if (nt != NULL)
+ {
+ Named_object* no = nt->find_local_method(name);
+ if (no != NULL)
+ {
+ if (receiver_can_be_pointer || !Type::method_expects_pointer(no))
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Record that we have found a pointer method in order to
+ // give a better error message if we don't find anything
+ // else.
+ *found_pointer_method = true;
+ }
+ }
+
+ // Interface types can have methods.
+ const Interface_type* it = type->deref()->interface_type();
+ if (it != NULL && it->find_method(name) != NULL)
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Struct types can have fields. They can also inherit fields and
+ // methods from anonymous fields.
+ const Struct_type* st = type->deref()->struct_type();
+ if (st == NULL)
+ return false;
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ int found_level = 0;
+ bool found_is_method = false;
+ std::string found_ambig1;
+ std::string found_ambig2;
+ const Struct_field* found_parent = NULL;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->field_name() == name)
+ {
+ *is_method = false;
+ return true;
+ }
+
+ if (!pf->is_anonymous())
+ continue;
+
+ Named_type* fnt = pf->type()->deref()->named_type();
+ gcc_assert(fnt != NULL);
+
+ int sublevel = level == NULL ? 1 : *level + 1;
+ bool sub_is_method;
+ std::string subambig1;
+ std::string subambig2;
+ bool subfound = Type::find_field_or_method(fnt,
+ name,
+ receiver_can_be_pointer,
+ &sublevel,
+ &sub_is_method,
+ found_pointer_method,
+ &subambig1,
+ &subambig2);
+ if (!subfound)
+ {
+ if (!subambig1.empty())
+ {
+ // The name was found via this field, but is ambiguous.
+ // if the ambiguity is lower or at the same level as
+ // anything else we have already found, then we want to
+ // pass the ambiguity back to the caller.
+ if (found_level == 0 || sublevel <= found_level)
+ {
+ found_ambig1 = pf->field_name() + '.' + subambig1;
+ found_ambig2 = pf->field_name() + '.' + subambig2;
+ found_level = sublevel;
+ }
+ }
+ }
+ else
+ {
+ // The name was found via this field. Use the level to see
+ // if we want to use this one, or whether it introduces an
+ // ambiguity.
+ if (found_level == 0 || sublevel < found_level)
+ {
+ found_level = sublevel;
+ found_is_method = sub_is_method;
+ found_ambig1.clear();
+ found_ambig2.clear();
+ found_parent = &*pf;
+ }
+ else if (sublevel > found_level)
+ ;
+ else if (found_ambig1.empty())
+ {
+ // We found an ambiguity.
+ gcc_assert(found_parent != NULL);
+ found_ambig1 = found_parent->field_name();
+ found_ambig2 = pf->field_name();
+ }
+ else
+ {
+ // We found an ambiguity, but we already know of one.
+ // Just report the earlier one.
+ }
+ }
+ }
+
+ // Here if we didn't find anything FOUND_LEVEL is 0. If we found
+ // something ambiguous, FOUND_LEVEL is not 0 and FOUND_AMBIG1 and
+ // FOUND_AMBIG2 are not empty. If we found the field, FOUND_LEVEL
+ // is not 0 and FOUND_AMBIG1 and FOUND_AMBIG2 are empty.
+
+ if (found_level == 0)
+ return false;
+ else if (!found_ambig1.empty())
+ {
+ gcc_assert(!found_ambig1.empty());
+ ambig1->assign(found_ambig1);
+ ambig2->assign(found_ambig2);
+ if (level != NULL)
+ *level = found_level;
+ return false;
+ }
+ else
+ {
+ if (level != NULL)
+ *level = found_level;
+ *is_method = found_is_method;
+ return true;
+ }
+}
+
+// Return whether NAME is an unexported field or method for TYPE.
+
+bool
+Type::is_unexported_field_or_method(Gogo* gogo, const Type* type,
+ const std::string& name)
+{
+ type = type->deref();
+
+ const Named_type* nt = type->named_type();
+ if (nt != NULL && nt->is_unexported_local_method(gogo, name))
+ return true;
+
+ const Interface_type* it = type->interface_type();
+ if (it != NULL && it->is_unexported_method(gogo, name))
+ return true;
+
+ const Struct_type* st = type->struct_type();
+ if (st != NULL && st->is_unexported_local_field(gogo, name))
+ return true;
+
+ if (st == NULL)
+ return false;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->is_anonymous())
+ {
+ Named_type* subtype = pf->type()->deref()->named_type();
+ gcc_assert(subtype != NULL);
+ if (Type::is_unexported_field_or_method(gogo, subtype, name))
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// Class Forward_declaration.
+
+Forward_declaration_type::Forward_declaration_type(Named_object* named_object)
+ : Type(TYPE_FORWARD),
+ named_object_(named_object->resolve()), warned_(false)
+{
+ gcc_assert(this->named_object_->is_unknown()
+ || this->named_object_->is_type_declaration());
+}
+
+// Return the named object.
+
+Named_object*
+Forward_declaration_type::named_object()
+{
+ return this->named_object_->resolve();
+}
+
+const Named_object*
+Forward_declaration_type::named_object() const
+{
+ return this->named_object_->resolve();
+}
+
+// Return the name of the forward declared type.
+
+const std::string&
+Forward_declaration_type::name() const
+{
+ return this->named_object()->name();
+}
+
+// Warn about a use of a type which has been declared but not defined.
+
+void
+Forward_declaration_type::warn() const
+{
+ Named_object* no = this->named_object_->resolve();
+ if (no->is_unknown())
+ {
+ // The name was not defined anywhere.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else if (no->is_type_declaration())
+ {
+ // The name was seen as a type, but the type was never defined.
+ if (no->type_declaration_value()->using_type())
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else
+ {
+ // The name was defined, but not as a type.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(), "expected type");
+ this->warned_ = true;
+ }
+ }
+}
+
+// Get the base type of a declaration. This gives an error if the
+// type has not yet been defined.
+
+Type*
+Forward_declaration_type::real_type()
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+const Type*
+Forward_declaration_type::real_type() const
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+// Return whether the base type is defined.
+
+bool
+Forward_declaration_type::is_defined() const
+{
+ return this->named_object()->is_type();
+}
+
+// Add a method. This is used when methods are defined before the
+// type.
+
+Named_object*
+Forward_declaration_type::add_method(const std::string& name,
+ Function* function)
+{
+ Named_object* no = this->named_object();
+ gcc_assert(no->is_type_declaration());
+ return no->type_declaration_value()->add_method(name, function);
+}
+
+// Add a method declaration. This is used when methods are declared
+// before the type.
+
+Named_object*
+Forward_declaration_type::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = this->named_object();
+ gcc_assert(no->is_type_declaration());
+ Type_declaration* td = no->type_declaration_value();
+ return td->add_method_declaration(name, type, location);
+}
+
+// Traversal.
+
+int
+Forward_declaration_type::do_traverse(Traverse* traverse)
+{
+ if (this->is_defined()
+ && Type::traverse(this->real_type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Get a tree for the type.
+
+tree
+Forward_declaration_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_defined())
+ return Type::get_named_type_tree(gogo, this->real_type());
+
+ if (this->warned_)
+ return error_mark_node;
+
+ // We represent an undefined type as a struct with no fields. That
+ // should work fine for the middle-end, since the same case can
+ // arise in C.
+ Named_object* no = this->named_object();
+ tree type_tree = make_node(RECORD_TYPE);
+ tree id = no->get_id(gogo);
+ tree decl = build_decl(no->location(), TYPE_DECL, id, type_tree);
+ TYPE_NAME(type_tree) = decl;
+ return type_tree;
+}
+
+// Build a type descriptor for a forwarded type.
+
+Expression*
+Forward_declaration_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (!this->is_defined())
+ return Expression::make_nil(BUILTINS_LOCATION);
+ else
+ {
+ Type* t = this->real_type();
+ if (name != NULL)
+ return this->named_type_descriptor(gogo, t, name);
+ else
+ return Expression::make_type_descriptor(t, BUILTINS_LOCATION);
+ }
+}
+
+// The reflection string.
+
+void
+Forward_declaration_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ this->append_reflection(this->real_type(), gogo, ret);
+}
+
+// The mangled name.
+
+void
+Forward_declaration_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ if (this->is_defined())
+ this->append_mangled_name(this->real_type(), gogo, ret);
+ else
+ {
+ const Named_object* no = this->named_object();
+ std::string name;
+ if (no->package() == NULL)
+ name = gogo->package_name();
+ else
+ name = no->package()->name();
+ name += '.';
+ name += Gogo::unpack_hidden_name(no->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_",
+ static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+ }
+}
+
+// Export a forward declaration. This can happen when a defined type
+// refers to a type which is only declared (and is presumably defined
+// in some other file in the same package).
+
+void
+Forward_declaration_type::do_export(Export*) const
+{
+ // If there is a base type, that should be exported instead of this.
+ gcc_assert(!this->is_defined());
+
+ // We don't output anything.
+}
+
+// Make a forward declaration.
+
+Type*
+Type::make_forward_declaration(Named_object* named_object)
+{
+ return new Forward_declaration_type(named_object);
+}
+
+// Class Typed_identifier_list.
+
+// Sort the entries by name.
+
+struct Typed_identifier_list_sort
+{
+ public:
+ bool
+ operator()(const Typed_identifier& t1, const Typed_identifier& t2) const
+ { return t1.name() < t2.name(); }
+};
+
+void
+Typed_identifier_list::sort_by_name()
+{
+ std::sort(this->entries_.begin(), this->entries_.end(),
+ Typed_identifier_list_sort());
+}
+
+// Traverse types.
+
+int
+Typed_identifier_list::traverse(Traverse* traverse)
+{
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Typed_identifier_list*
+Typed_identifier_list::copy() const
+{
+ Typed_identifier_list* ret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ ret->push_back(Typed_identifier(p->name(), p->type(), p->location()));
+ return ret;
+}
--- /dev/null
+// types.cc -- Go frontend types.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "real.h"
+#include "convert.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "operator.h"
+#include "expressions.h"
+#include "statements.h"
+#include "export.h"
+#include "import.h"
+#include "types.h"
+
+// Class Type.
+
+Type::Type(Type_classification classification)
+ : classification_(classification), tree_(NULL_TREE),
+ type_descriptor_decl_(NULL_TREE)
+{
+}
+
+Type::~Type()
+{
+}
+
+// Get the base type for a type--skip names and forward declarations.
+
+Type*
+Type::base()
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_base();
+ case TYPE_FORWARD:
+ return this->forward_declaration_type()->real_type()->base();
+ default:
+ return this;
+ }
+}
+
+const Type*
+Type::base() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_base();
+ case TYPE_FORWARD:
+ return this->forward_declaration_type()->real_type()->base();
+ default:
+ return this;
+ }
+}
+
+// Skip defined forward declarations.
+
+Type*
+Type::forwarded()
+{
+ Type* t = this;
+ Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+const Type*
+Type::forwarded() const
+{
+ const Type* t = this;
+ const Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+// If this is a named type, return it. Otherwise, return NULL.
+
+Named_type*
+Type::named_type()
+{
+ return this->forwarded()->convert_no_base<Named_type, TYPE_NAMED>();
+}
+
+const Named_type*
+Type::named_type() const
+{
+ return this->forwarded()->convert_no_base<const Named_type, TYPE_NAMED>();
+}
+
+// Return true if this type is not defined.
+
+bool
+Type::is_undefined() const
+{
+ return this->forwarded()->forward_declaration_type() != NULL;
+}
+
+// Return true if this is a basic type: a type which is not composed
+// of other types, and is not void.
+
+bool
+Type::is_basic_type() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ return true;
+
+ case TYPE_ERROR:
+ case TYPE_VOID:
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ case TYPE_STRUCT:
+ case TYPE_ARRAY:
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ case TYPE_INTERFACE:
+ return false;
+
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ return this->base()->is_basic_type();
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Return true if this is an abstract type.
+
+bool
+Type::is_abstract() const
+{
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return this->integer_type()->is_abstract();
+ case TYPE_FLOAT:
+ return this->float_type()->is_abstract();
+ case TYPE_COMPLEX:
+ return this->complex_type()->is_abstract();
+ case TYPE_STRING:
+ return this->is_abstract_string_type();
+ case TYPE_BOOLEAN:
+ return this->is_abstract_boolean_type();
+ default:
+ return false;
+ }
+}
+
+// Return a non-abstract version of an abstract type.
+
+Type*
+Type::make_non_abstract_type()
+{
+ go_assert(this->is_abstract());
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return Type::lookup_integer_type("int");
+ case TYPE_FLOAT:
+ return Type::lookup_float_type("float64");
+ case TYPE_COMPLEX:
+ return Type::lookup_complex_type("complex128");
+ case TYPE_STRING:
+ return Type::lookup_string_type();
+ case TYPE_BOOLEAN:
+ return Type::lookup_bool_type();
+ default:
+ go_unreachable();
+ }
+}
+
+// Return true if this is an error type. Don't give an error if we
+// try to dereference an undefined forwarding type, as this is called
+// in the parser when the type may legitimately be undefined.
+
+bool
+Type::is_error_type() const
+{
+ const Type* t = this->forwarded();
+ // Note that we return false for an undefined forward type.
+ switch (t->classification_)
+ {
+ case TYPE_ERROR:
+ return true;
+ case TYPE_NAMED:
+ return t->named_type()->is_named_error_type();
+ default:
+ return false;
+ }
+}
+
+// If this is a pointer type, return the type to which it points.
+// Otherwise, return NULL.
+
+Type*
+Type::points_to() const
+{
+ const Pointer_type* ptype = this->convert<const Pointer_type,
+ TYPE_POINTER>();
+ return ptype == NULL ? NULL : ptype->points_to();
+}
+
+// Return whether this is an open array type.
+
+bool
+Type::is_open_array_type() const
+{
+ return this->array_type() != NULL && this->array_type()->length() == NULL;
+}
+
+// Return whether this is the predeclared constant nil being used as a
+// type.
+
+bool
+Type::is_nil_constant_as_type() const
+{
+ const Type* t = this->forwarded();
+ if (t->forward_declaration_type() != NULL)
+ {
+ const Named_object* no = t->forward_declaration_type()->named_object();
+ if (no->is_unknown())
+ no = no->unknown_value()->real_named_object();
+ if (no != NULL
+ && no->is_const()
+ && no->const_value()->expr()->is_nil_expression())
+ return true;
+ }
+ return false;
+}
+
+// Traverse a type.
+
+int
+Type::traverse(Type* type, Traverse* traverse)
+{
+ go_assert((traverse->traverse_mask() & Traverse::traverse_types) != 0
+ || (traverse->traverse_mask()
+ & Traverse::traverse_expressions) != 0);
+ if (traverse->remember_type(type))
+ {
+ // We have already traversed this type.
+ return TRAVERSE_CONTINUE;
+ }
+ if ((traverse->traverse_mask() & Traverse::traverse_types) != 0)
+ {
+ int t = traverse->type(type);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ // An array type has an expression which we need to traverse if
+ // traverse_expressions is set.
+ if (type->do_traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Default implementation for do_traverse for child class.
+
+int
+Type::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether two types are identical. If ERRORS_ARE_IDENTICAL,
+// then return true for all erroneous types; this is used to avoid
+// cascading errors. If REASON is not NULL, optionally set *REASON to
+// the reason the types are not identical.
+
+bool
+Type::are_identical(const Type* t1, const Type* t2, bool errors_are_identical,
+ std::string* reason)
+{
+ if (t1 == NULL || t2 == NULL)
+ {
+ // Something is wrong.
+ return errors_are_identical ? true : t1 == t2;
+ }
+
+ // Skip defined forward declarations.
+ t1 = t1->forwarded();
+ t2 = t2->forwarded();
+
+ if (t1 == t2)
+ return true;
+
+ // An undefined forward declaration is an error.
+ if (t1->forward_declaration_type() != NULL
+ || t2->forward_declaration_type() != NULL)
+ return errors_are_identical;
+
+ // Avoid cascading errors with error types.
+ if (t1->is_error_type() || t2->is_error_type())
+ {
+ if (errors_are_identical)
+ return true;
+ return t1->is_error_type() && t2->is_error_type();
+ }
+
+ // Get a good reason for the sink type. Note that the sink type on
+ // the left hand side of an assignment is handled in are_assignable.
+ if (t1->is_sink_type() || t2->is_sink_type())
+ {
+ if (reason != NULL)
+ *reason = "invalid use of _";
+ return false;
+ }
+
+ // A named type is only identical to itself.
+ if (t1->named_type() != NULL || t2->named_type() != NULL)
+ return false;
+
+ // Check type shapes.
+ if (t1->classification() != t2->classification())
+ return false;
+
+ switch (t1->classification())
+ {
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These types are always identical.
+ return true;
+
+ case TYPE_INTEGER:
+ return t1->integer_type()->is_identical(t2->integer_type());
+
+ case TYPE_FLOAT:
+ return t1->float_type()->is_identical(t2->float_type());
+
+ case TYPE_COMPLEX:
+ return t1->complex_type()->is_identical(t2->complex_type());
+
+ case TYPE_FUNCTION:
+ return t1->function_type()->is_identical(t2->function_type(),
+ false,
+ errors_are_identical,
+ reason);
+
+ case TYPE_POINTER:
+ return Type::are_identical(t1->points_to(), t2->points_to(),
+ errors_are_identical, reason);
+
+ case TYPE_STRUCT:
+ return t1->struct_type()->is_identical(t2->struct_type(),
+ errors_are_identical);
+
+ case TYPE_ARRAY:
+ return t1->array_type()->is_identical(t2->array_type(),
+ errors_are_identical);
+
+ case TYPE_MAP:
+ return t1->map_type()->is_identical(t2->map_type(),
+ errors_are_identical);
+
+ case TYPE_CHANNEL:
+ return t1->channel_type()->is_identical(t2->channel_type(),
+ errors_are_identical);
+
+ case TYPE_INTERFACE:
+ return t1->interface_type()->is_identical(t2->interface_type(),
+ errors_are_identical);
+
+ case TYPE_CALL_MULTIPLE_RESULT:
+ if (reason != NULL)
+ *reason = "invalid use of multiple value function call";
+ return false;
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Return true if it's OK to have a binary operation with types LHS
+// and RHS. This is not used for shifts or comparisons.
+
+bool
+Type::are_compatible_for_binop(const Type* lhs, const Type* rhs)
+{
+ if (Type::are_identical(lhs, rhs, true, NULL))
+ return true;
+
+ // A constant of abstract bool type may be mixed with any bool type.
+ if ((rhs->is_abstract_boolean_type() && lhs->is_boolean_type())
+ || (lhs->is_abstract_boolean_type() && rhs->is_boolean_type()))
+ return true;
+
+ // A constant of abstract string type may be mixed with any string
+ // type.
+ if ((rhs->is_abstract_string_type() && lhs->is_string_type())
+ || (lhs->is_abstract_string_type() && rhs->is_string_type()))
+ return true;
+
+ lhs = lhs->base();
+ rhs = rhs->base();
+
+ // A constant of abstract integer, float, or complex type may be
+ // mixed with an integer, float, or complex type.
+ if ((rhs->is_abstract()
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ || (lhs->is_abstract()
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL)
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)))
+ return true;
+
+ // The nil type may be compared to a pointer, an interface type, a
+ // slice type, a channel type, a map type, or a function type.
+ if (lhs->is_nil_type()
+ && (rhs->points_to() != NULL
+ || rhs->interface_type() != NULL
+ || rhs->is_open_array_type()
+ || rhs->map_type() != NULL
+ || rhs->channel_type() != NULL
+ || rhs->function_type() != NULL))
+ return true;
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->interface_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->function_type() != NULL))
+ return true;
+
+ return false;
+}
+
+// Return true if a value with type RHS may be assigned to a variable
+// with type LHS. If CHECK_HIDDEN_FIELDS is true, check whether any
+// hidden fields are modified. If REASON is not NULL, set *REASON to
+// the reason the types are not assignable.
+
+bool
+Type::are_assignable_check_hidden(const Type* lhs, const Type* rhs,
+ bool check_hidden_fields,
+ std::string* reason)
+{
+ // Do some checks first. Make sure the types are defined.
+ if (rhs != NULL
+ && rhs->forwarded()->forward_declaration_type() == NULL
+ && rhs->is_void_type())
+ {
+ if (reason != NULL)
+ *reason = "non-value used as value";
+ return false;
+ }
+
+ if (lhs != NULL && lhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ // Any value may be assigned to the blank identifier.
+ if (lhs->is_sink_type())
+ return true;
+
+ // All fields of a struct must be exported, or the assignment
+ // must be in the same package.
+ if (check_hidden_fields
+ && rhs != NULL
+ && rhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ if (lhs->has_hidden_fields(NULL, reason)
+ || rhs->has_hidden_fields(NULL, reason))
+ return false;
+ }
+ }
+
+ // Identical types are assignable.
+ if (Type::are_identical(lhs, rhs, true, reason))
+ return true;
+
+ // The types are assignable if they have identical underlying types
+ // and either LHS or RHS is not a named type.
+ if (((lhs->named_type() != NULL && rhs->named_type() == NULL)
+ || (rhs->named_type() != NULL && lhs->named_type() == NULL))
+ && Type::are_identical(lhs->base(), rhs->base(), true, reason))
+ return true;
+
+ // The types are assignable if LHS is an interface type and RHS
+ // implements the required methods.
+ const Interface_type* lhs_interface_type = lhs->interface_type();
+ if (lhs_interface_type != NULL)
+ {
+ if (lhs_interface_type->implements_interface(rhs, reason))
+ return true;
+ const Interface_type* rhs_interface_type = rhs->interface_type();
+ if (rhs_interface_type != NULL
+ && lhs_interface_type->is_compatible_for_assign(rhs_interface_type,
+ reason))
+ return true;
+ }
+
+ // The type are assignable if RHS is a bidirectional channel type,
+ // LHS is a channel type, they have identical element types, and
+ // either LHS or RHS is not a named type.
+ if (lhs->channel_type() != NULL
+ && rhs->channel_type() != NULL
+ && rhs->channel_type()->may_send()
+ && rhs->channel_type()->may_receive()
+ && (lhs->named_type() == NULL || rhs->named_type() == NULL)
+ && Type::are_identical(lhs->channel_type()->element_type(),
+ rhs->channel_type()->element_type(),
+ true,
+ reason))
+ return true;
+
+ // The nil type may be assigned to a pointer, function, slice, map,
+ // channel, or interface type.
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->function_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->interface_type() != NULL))
+ return true;
+
+ // An untyped numeric constant may be assigned to a numeric type if
+ // it is representable in that type.
+ if ((rhs->is_abstract()
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL))
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ return true;
+
+ // Give some better error messages.
+ if (reason != NULL && reason->empty())
+ {
+ if (rhs->interface_type() != NULL)
+ reason->assign(_("need explicit conversion"));
+ else if (rhs->is_call_multiple_result_type())
+ reason->assign(_("multiple value function call in "
+ "single value context"));
+ else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
+ {
+ size_t len = (lhs->named_type()->name().length()
+ + rhs->named_type()->name().length()
+ + 100);
+ char* buf = new char[len];
+ snprintf(buf, len, _("cannot use type %s as type %s"),
+ rhs->named_type()->message_name().c_str(),
+ lhs->named_type()->message_name().c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ }
+
+ return false;
+}
+
+// Return true if a value with type RHS may be assigned to a variable
+// with type LHS. If REASON is not NULL, set *REASON to the reason
+// the types are not assignable.
+
+bool
+Type::are_assignable(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ return Type::are_assignable_check_hidden(lhs, rhs, true, reason);
+}
+
+// Like are_assignable but don't check for hidden fields.
+
+bool
+Type::are_assignable_hidden_ok(const Type* lhs, const Type* rhs,
+ std::string* reason)
+{
+ return Type::are_assignable_check_hidden(lhs, rhs, false, reason);
+}
+
+// Return true if a value with type RHS may be converted to type LHS.
+// If REASON is not NULL, set *REASON to the reason the types are not
+// convertible.
+
+bool
+Type::are_convertible(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ // The types are convertible if they are assignable.
+ if (Type::are_assignable(lhs, rhs, reason))
+ return true;
+
+ // The types are convertible if they have identical underlying
+ // types.
+ if ((lhs->named_type() != NULL || rhs->named_type() != NULL)
+ && Type::are_identical(lhs->base(), rhs->base(), true, reason))
+ return true;
+
+ // The types are convertible if they are both unnamed pointer types
+ // and their pointer base types have identical underlying types.
+ if (lhs->named_type() == NULL
+ && rhs->named_type() == NULL
+ && lhs->points_to() != NULL
+ && rhs->points_to() != NULL
+ && (lhs->points_to()->named_type() != NULL
+ || rhs->points_to()->named_type() != NULL)
+ && Type::are_identical(lhs->points_to()->base(),
+ rhs->points_to()->base(),
+ true,
+ reason))
+ return true;
+
+ // Integer and floating point types are convertible to each other.
+ if ((lhs->integer_type() != NULL || lhs->float_type() != NULL)
+ && (rhs->integer_type() != NULL || rhs->float_type() != NULL))
+ return true;
+
+ // Complex types are convertible to each other.
+ if (lhs->complex_type() != NULL && rhs->complex_type() != NULL)
+ return true;
+
+ // An integer, or []byte, or []int, may be converted to a string.
+ if (lhs->is_string_type())
+ {
+ if (rhs->integer_type() != NULL)
+ return true;
+ if (rhs->is_open_array_type() && rhs->named_type() == NULL)
+ {
+ const Type* e = rhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+ }
+
+ // A string may be converted to []byte or []int.
+ if (rhs->is_string_type()
+ && lhs->is_open_array_type()
+ && lhs->named_type() == NULL)
+ {
+ const Type* e = lhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+
+ // An unsafe.Pointer type may be converted to any pointer type or to
+ // uintptr, and vice-versa.
+ if (lhs->is_unsafe_pointer_type()
+ && (rhs->points_to() != NULL
+ || (rhs->integer_type() != NULL
+ && rhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+ if (rhs->is_unsafe_pointer_type()
+ && (lhs->points_to() != NULL
+ || (lhs->integer_type() != NULL
+ && lhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+
+ // Give a better error message.
+ if (reason != NULL)
+ {
+ if (reason->empty())
+ *reason = "invalid type conversion";
+ else
+ {
+ std::string s = "invalid type conversion (";
+ s += *reason;
+ s += ')';
+ *reason = s;
+ }
+ }
+
+ return false;
+}
+
+// Return whether this type has any hidden fields. This is only a
+// possibility for a few types.
+
+bool
+Type::has_hidden_fields(const Named_type* within, std::string* reason) const
+{
+ switch (this->forwarded()->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_type_has_hidden_fields(reason);
+ case TYPE_STRUCT:
+ return this->struct_type()->struct_has_hidden_fields(within, reason);
+ case TYPE_ARRAY:
+ return this->array_type()->array_has_hidden_fields(within, reason);
+ default:
+ return false;
+ }
+}
+
+// Return a hash code for the type to be used for method lookup.
+
+unsigned int
+Type::hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->classification_ != TYPE_FORWARD)
+ ret += this->classification_;
+ return ret + this->do_hash_for_method(gogo);
+}
+
+// Default implementation of do_hash_for_method. This is appropriate
+// for types with no subfields.
+
+unsigned int
+Type::do_hash_for_method(Gogo*) const
+{
+ return 0;
+}
+
+// Return a hash code for a string, given a starting hash.
+
+unsigned int
+Type::hash_string(const std::string& s, unsigned int h)
+{
+ const char* p = s.data();
+ size_t len = s.length();
+ for (; len > 0; --len)
+ {
+ h ^= *p++;
+ h*= 16777619;
+ }
+ return h;
+}
+
+// Default check for the expression passed to make. Any type which
+// may be used with make implements its own version of this.
+
+bool
+Type::do_check_make_expression(Expression_list*, source_location)
+{
+ go_unreachable();
+}
+
+// Return whether an expression has an integer value. Report an error
+// if not. This is used when handling calls to the predeclared make
+// function.
+
+bool
+Type::check_int_value(Expression* e, const char* errmsg,
+ source_location location)
+{
+ if (e->type()->integer_type() != NULL)
+ return true;
+
+ // Check for a floating point constant with integer value.
+ mpfr_t fval;
+ mpfr_init(fval);
+
+ Type* dummy;
+ if (e->float_constant_value(fval, &dummy) && mpfr_integer_p(fval))
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ bool ok = false;
+
+ mpfr_clear_overflow();
+ mpfr_clear_erangeflag();
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!mpfr_overflow_p()
+ && !mpfr_erangeflag_p()
+ && mpz_sgn(ival) >= 0)
+ {
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ }
+ mpz_clear(ival);
+
+ if (ok)
+ {
+ mpfr_clear(fval);
+ return true;
+ }
+ }
+
+ mpfr_clear(fval);
+
+ error_at(location, "%s", errmsg);
+ return false;
+}
+
+// A hash table mapping unnamed types to trees.
+
+Type::Type_trees Type::type_trees;
+
+// Return a tree representing this type.
+
+tree
+Type::get_tree(Gogo* gogo)
+{
+ if (this->tree_ != NULL)
+ return this->tree_;
+
+ if (this->forward_declaration_type() != NULL
+ || this->named_type() != NULL)
+ return this->get_tree_without_hash(gogo);
+
+ if (this->is_error_type())
+ return error_mark_node;
+
+ // To avoid confusing GIMPLE, we need to translate all identical Go
+ // types to the same GIMPLE type. We use a hash table to do that.
+ // There is no need to use the hash table for named types, as named
+ // types are only identical to themselves.
+
+ std::pair<Type*, tree> val(this, NULL);
+ std::pair<Type_trees::iterator, bool> ins =
+ Type::type_trees.insert(val);
+ if (!ins.second && ins.first->second != NULL_TREE)
+ {
+ if (gogo != NULL && gogo->named_types_are_converted())
+ this->tree_ = ins.first->second;
+ return ins.first->second;
+ }
+
+ tree t = this->get_tree_without_hash(gogo);
+
+ if (ins.first->second == NULL_TREE)
+ ins.first->second = t;
+ else
+ {
+ // We have already created a tree for this type. This can
+ // happen when an unnamed type is defined using a named type
+ // which in turns uses an identical unnamed type. Use the tree
+ // we created earlier and ignore the one we just built.
+ t = ins.first->second;
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ return t;
+ this->tree_ = t;
+ }
+
+ return t;
+}
+
+// Return a tree for a type without looking in the hash table for
+// identical types. This is used for named types, since there is no
+// point to looking in the hash table for them.
+
+tree
+Type::get_tree_without_hash(Gogo* gogo)
+{
+ if (this->tree_ == NULL_TREE)
+ {
+ tree t = this->do_get_tree(gogo);
+
+ // For a recursive function or pointer type, we will temporarily
+ // return ptr_type_node during the recursion. We don't want to
+ // record that for a forwarding type, as it may confuse us
+ // later.
+ if (t == ptr_type_node && this->forward_declaration_type() != NULL)
+ return t;
+
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ return t;
+
+ this->tree_ = t;
+ go_preserve_from_gc(t);
+ }
+
+ return this->tree_;
+}
+
+// Return a tree representing a zero initialization for this type.
+
+tree
+Type::get_init_tree(Gogo* gogo, bool is_clear)
+{
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ return this->do_get_init_tree(gogo, type_tree, is_clear);
+}
+
+// Any type which supports the builtin make function must implement
+// this.
+
+tree
+Type::do_make_expression_tree(Translate_context*, Expression_list*,
+ source_location)
+{
+ go_unreachable();
+}
+
+// Return a pointer to the type descriptor for this type.
+
+tree
+Type::type_descriptor_pointer(Gogo* gogo)
+{
+ Type* t = this->forwarded();
+ if (t->type_descriptor_decl_ == NULL_TREE)
+ {
+ Expression* e = t->do_type_descriptor(gogo, NULL);
+ gogo->build_type_descriptor_decl(t, e, &t->type_descriptor_decl_);
+ go_assert(t->type_descriptor_decl_ != NULL_TREE
+ && (t->type_descriptor_decl_ == error_mark_node
+ || DECL_P(t->type_descriptor_decl_)));
+ }
+ if (t->type_descriptor_decl_ == error_mark_node)
+ return error_mark_node;
+ return build_fold_addr_expr(t->type_descriptor_decl_);
+}
+
+// Return a composite literal for a type descriptor.
+
+Expression*
+Type::type_descriptor(Gogo* gogo, Type* type)
+{
+ return type->do_type_descriptor(gogo, NULL);
+}
+
+// Return a composite literal for a type descriptor with a name.
+
+Expression*
+Type::named_type_descriptor(Gogo* gogo, Type* type, Named_type* name)
+{
+ go_assert(name != NULL && type->named_type() != name);
+ return type->do_type_descriptor(gogo, name);
+}
+
+// Make a builtin struct type from a list of fields. The fields are
+// pairs of a name and a type.
+
+Struct_type*
+Type::make_builtin_struct_type(int nfields, ...)
+{
+ va_list ap;
+ va_start(ap, nfields);
+
+ source_location bloc = BUILTINS_LOCATION;
+ Struct_field_list* sfl = new Struct_field_list();
+ for (int i = 0; i < nfields; i++)
+ {
+ const char* field_name = va_arg(ap, const char *);
+ Type* type = va_arg(ap, Type*);
+ sfl->push_back(Struct_field(Typed_identifier(field_name, type, bloc)));
+ }
+
+ va_end(ap);
+
+ return Type::make_struct_type(sfl, bloc);
+}
+
+// A list of builtin named types.
+
+std::vector<Named_type*> Type::named_builtin_types;
+
+// Make a builtin named type.
+
+Named_type*
+Type::make_builtin_named_type(const char* name, Type* type)
+{
+ source_location bloc = BUILTINS_LOCATION;
+ Named_object* no = Named_object::make_type(name, NULL, type, bloc);
+ Named_type* ret = no->type_value();
+ Type::named_builtin_types.push_back(ret);
+ return ret;
+}
+
+// Convert the named builtin types.
+
+void
+Type::convert_builtin_named_types(Gogo* gogo)
+{
+ for (std::vector<Named_type*>::const_iterator p =
+ Type::named_builtin_types.begin();
+ p != Type::named_builtin_types.end();
+ ++p)
+ {
+ bool r = (*p)->verify();
+ go_assert(r);
+ (*p)->convert(gogo);
+ }
+}
+
+// Return the type of a type descriptor. We should really tie this to
+// runtime.Type rather than copying it. This must match commonType in
+// libgo/go/runtime/type.go.
+
+Type*
+Type::make_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* uint8_type = Type::lookup_integer_type("uint8");
+ Type* uint32_type = Type::lookup_integer_type("uint32");
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ // This is an unnamed version of unsafe.Pointer. Perhaps we
+ // should use the named version instead, although that would
+ // require us to create the unsafe package if it has not been
+ // imported. It probably doesn't matter.
+ Type* void_type = Type::make_void_type();
+ Type* unsafe_pointer_type = Type::make_pointer_type(void_type);
+
+ // Forward declaration for the type descriptor type.
+ Named_object* named_type_descriptor_type =
+ Named_object::make_type_declaration("commonType", NULL, bloc);
+ Type* ft = Type::make_forward_declaration(named_type_descriptor_type);
+ Type* pointer_type_descriptor_type = Type::make_pointer_type(ft);
+
+ // The type of a method on a concrete type.
+ Struct_type* method_type =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "mtyp", pointer_type_descriptor_type,
+ "typ", pointer_type_descriptor_type,
+ "tfn", unsafe_pointer_type);
+ Named_type* named_method_type =
+ Type::make_builtin_named_type("method", method_type);
+
+ // Information for types with a name or methods.
+ Type* slice_named_method_type =
+ Type::make_array_type(named_method_type, NULL);
+ Struct_type* uncommon_type =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "methods", slice_named_method_type);
+ Named_type* named_uncommon_type =
+ Type::make_builtin_named_type("uncommonType", uncommon_type);
+
+ Type* pointer_uncommon_type =
+ Type::make_pointer_type(named_uncommon_type);
+
+ // The type descriptor type.
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Type* hashfn_type = Type::make_function_type(NULL, params, results, bloc);
+
+ params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Type* equalfn_type = Type::make_function_type(NULL, params, results,
+ bloc);
+
+ Struct_type* type_descriptor_type =
+ Type::make_builtin_struct_type(10,
+ "Kind", uint8_type,
+ "align", uint8_type,
+ "fieldAlign", uint8_type,
+ "size", uintptr_type,
+ "hash", uint32_type,
+ "hashfn", hashfn_type,
+ "equalfn", equalfn_type,
+ "string", pointer_string_type,
+ "", pointer_uncommon_type,
+ "ptrToThis",
+ pointer_type_descriptor_type);
+
+ Named_type* named = Type::make_builtin_named_type("commonType",
+ type_descriptor_type);
+
+ named_type_descriptor_type->set_type_value(named);
+
+ ret = named;
+ }
+
+ return ret;
+}
+
+// Make the type of a pointer to a type descriptor as represented in
+// Go.
+
+Type*
+Type::make_type_descriptor_ptr_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ ret = Type::make_pointer_type(Type::make_type_descriptor_type());
+ return ret;
+}
+
+// Return the names of runtime functions which compute a hash code for
+// this type and which compare whether two values of this type are
+// equal.
+
+void
+Type::type_functions(const char** hash_fn, const char** equal_fn) const
+{
+ switch (this->base()->classification())
+ {
+ case Type::TYPE_ERROR:
+ case Type::TYPE_VOID:
+ case Type::TYPE_NIL:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ *hash_fn = "__go_type_hash_identity";
+ *equal_fn = "__go_type_equal_identity";
+ break;
+
+ case Type::TYPE_STRING:
+ *hash_fn = "__go_type_hash_string";
+ *equal_fn = "__go_type_equal_string";
+ break;
+
+ case Type::TYPE_STRUCT:
+ case Type::TYPE_ARRAY:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_INTERFACE:
+ if (this->interface_type()->is_empty())
+ {
+ *hash_fn = "__go_type_hash_empty_interface";
+ *equal_fn = "__go_type_equal_empty_interface";
+ }
+ else
+ {
+ *hash_fn = "__go_type_hash_interface";
+ *equal_fn = "__go_type_equal_interface";
+ }
+ break;
+
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ go_unreachable();
+
+ default:
+ go_unreachable();
+ }
+}
+
+// Return a composite literal for the type descriptor for a plain type
+// of kind RUNTIME_TYPE_KIND named NAME.
+
+Expression*
+Type::type_descriptor_constructor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* td_type = Type::make_type_descriptor_type();
+ const Struct_field_list* fields = td_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(9);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "Kind");
+ mpz_t iv;
+ mpz_init_set_ui(iv, runtime_type_kind);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ ++p;
+ go_assert(p->field_name() == "align");
+ Expression::Type_info type_info = Expression::TYPE_INFO_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ go_assert(p->field_name() == "fieldAlign");
+ type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ go_assert(p->field_name() == "size");
+ type_info = Expression::TYPE_INFO_SIZE;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ go_assert(p->field_name() == "hash");
+ mpz_set_ui(iv, this->hash_for_method(gogo));
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ const char* hash_fn;
+ const char* equal_fn;
+ this->type_functions(&hash_fn, &equal_fn);
+
+ ++p;
+ go_assert(p->field_name() == "hashfn");
+ Function_type* fntype = p->type()->function_type();
+ Named_object* no = Named_object::make_function_declaration(hash_fn, NULL,
+ fntype,
+ bloc);
+ no->func_declaration_value()->set_asm_name(hash_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "equalfn");
+ fntype = p->type()->function_type();
+ no = Named_object::make_function_declaration(equal_fn, NULL, fntype, bloc);
+ no->func_declaration_value()->set_asm_name(equal_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "string");
+ Expression* s = Expression::make_string((name != NULL
+ ? name->reflection(gogo)
+ : this->reflection(gogo)),
+ bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "uncommonType");
+ if (name == NULL && methods == NULL)
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ if (methods == NULL)
+ methods = name->methods();
+ vals->push_back(this->uncommon_type_constructor(gogo,
+ p->type()->deref(),
+ name, methods,
+ only_value_methods));
+ }
+
+ ++p;
+ go_assert(p->field_name() == "ptrToThis");
+ if (name == NULL)
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ Type* pt = Type::make_pointer_type(name);
+ vals->push_back(Expression::make_type_descriptor(pt, bloc));
+ }
+
+ ++p;
+ go_assert(p == fields->end());
+
+ mpz_clear(iv);
+
+ return Expression::make_struct_composite_literal(td_type, vals, bloc);
+}
+
+// Return a composite literal for the uncommon type information for
+// this type. UNCOMMON_STRUCT_TYPE is the type of the uncommon type
+// struct. If name is not NULL, it is the name of the type. If
+// METHODS is not NULL, it is the list of methods. ONLY_VALUE_METHODS
+// is true if only value methods should be included. At least one of
+// NAME and METHODS must not be NULL.
+
+Expression*
+Type::uncommon_type_constructor(Gogo* gogo, Type* uncommon_type,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = uncommon_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "name");
+
+ ++p;
+ go_assert(p->field_name() == "pkgPath");
+
+ if (name == NULL)
+ {
+ vals->push_back(Expression::make_nil(bloc));
+ vals->push_back(Expression::make_nil(bloc));
+ }
+ else
+ {
+ Named_object* no = name->named_object();
+ std::string n = Gogo::unpack_hidden_name(no->name());
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ if (name->is_builtin())
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ const Package* package = no->package();
+ const std::string& unique_prefix(package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix());
+ const std::string& package_name(package == NULL
+ ? gogo->package_name()
+ : package->name());
+ n.assign(unique_prefix);
+ n.append(1, '.');
+ n.append(package_name);
+ if (name->in_function() != NULL)
+ {
+ n.append(1, '.');
+ n.append(Gogo::unpack_hidden_name(name->in_function()->name()));
+ }
+ s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+ }
+
+ ++p;
+ go_assert(p->field_name() == "methods");
+ vals->push_back(this->methods_constructor(gogo, p->type(), methods,
+ only_value_methods));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ Expression* r = Expression::make_struct_composite_literal(uncommon_type,
+ vals, bloc);
+ return Expression::make_unary(OPERATOR_AND, r, bloc);
+}
+
+// Sort methods by name.
+
+class Sort_methods
+{
+ public:
+ bool
+ operator()(const std::pair<std::string, const Method*>& m1,
+ const std::pair<std::string, const Method*>& m2) const
+ { return m1.first < m2.first; }
+};
+
+// Return a composite literal for the type method table for this type.
+// METHODS_TYPE is the type of the table, and is a slice type.
+// METHODS is the list of methods. If ONLY_VALUE_METHODS is true,
+// then only value methods are used.
+
+Expression*
+Type::methods_constructor(Gogo* gogo, Type* methods_type,
+ const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ std::vector<std::pair<std::string, const Method*> > smethods;
+ if (methods != NULL)
+ {
+ smethods.reserve(methods->count());
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->second->is_ambiguous())
+ continue;
+ if (only_value_methods && !p->second->is_value_method())
+ continue;
+ smethods.push_back(std::make_pair(p->first, p->second));
+ }
+ }
+
+ if (smethods.empty())
+ return Expression::make_slice_composite_literal(methods_type, NULL, bloc);
+
+ std::sort(smethods.begin(), smethods.end(), Sort_methods());
+
+ Type* method_type = methods_type->array_type()->element_type();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(smethods.size());
+ for (std::vector<std::pair<std::string, const Method*> >::const_iterator p
+ = smethods.begin();
+ p != smethods.end();
+ ++p)
+ vals->push_back(this->method_constructor(gogo, method_type, p->first,
+ p->second));
+
+ return Expression::make_slice_composite_literal(methods_type, vals, bloc);
+}
+
+// Return a composite literal for a single method. METHOD_TYPE is the
+// type of the entry. METHOD_NAME is the name of the method and M is
+// the method information.
+
+Expression*
+Type::method_constructor(Gogo*, Type* method_type,
+ const std::string& method_name,
+ const Method* m) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = method_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(5);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "name");
+ const std::string n = Gogo::unpack_hidden_name(method_name);
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(method_name))
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Expression::make_string(Gogo::hidden_name_prefix(method_name), bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ Named_object* no = (m->needs_stub_method()
+ ? m->stub_object()
+ : m->named_object());
+
+ Function_type* mtype;
+ if (no->is_function())
+ mtype = no->func_value()->type();
+ else
+ mtype = no->func_declaration_value()->type();
+ go_assert(mtype->is_method());
+ Type* nonmethod_type = mtype->copy_without_receiver();
+
+ ++p;
+ go_assert(p->field_name() == "mtyp");
+ vals->push_back(Expression::make_type_descriptor(nonmethod_type, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "typ");
+ vals->push_back(Expression::make_type_descriptor(mtype, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "tfn");
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(method_type, vals, bloc);
+}
+
+// Return a composite literal for the type descriptor of a plain type.
+// RUNTIME_TYPE_KIND is the value of the kind field. If NAME is not
+// NULL, it is the name to use as well as the list of methods.
+
+Expression*
+Type::plain_type_descriptor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name)
+{
+ return this->type_descriptor_constructor(gogo, runtime_type_kind,
+ name, NULL, true);
+}
+
+// Return the type reflection string for this type.
+
+std::string
+Type::reflection(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_reflection virtual function should set RET to the
+ // reflection string.
+ this->do_reflection(gogo, &ret);
+
+ return ret;
+}
+
+// Return a mangled name for the type.
+
+std::string
+Type::mangled_name(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_mangled_name virtual function should set RET to the
+ // mangled name. For a composite type it should append a code for
+ // the composition and then call do_mangled_name on the components.
+ this->do_mangled_name(gogo, &ret);
+
+ return ret;
+}
+
+// Default function to export a type.
+
+void
+Type::do_export(Export*) const
+{
+ go_unreachable();
+}
+
+// Import a type.
+
+Type*
+Type::import_type(Import* imp)
+{
+ if (imp->match_c_string("("))
+ return Function_type::do_import(imp);
+ else if (imp->match_c_string("*"))
+ return Pointer_type::do_import(imp);
+ else if (imp->match_c_string("struct "))
+ return Struct_type::do_import(imp);
+ else if (imp->match_c_string("["))
+ return Array_type::do_import(imp);
+ else if (imp->match_c_string("map "))
+ return Map_type::do_import(imp);
+ else if (imp->match_c_string("chan "))
+ return Channel_type::do_import(imp);
+ else if (imp->match_c_string("interface"))
+ return Interface_type::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected type");
+ return Type::make_error_type();
+ }
+}
+
+// A type used to indicate a parsing error. This exists to simplify
+// later error detection.
+
+class Error_type : public Type
+{
+ public:
+ Error_type()
+ : Type(TYPE_ERROR)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return error_mark_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { return error_mark_node; }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { return Expression::make_error(BUILTINS_LOCATION); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { go_assert(saw_errors()); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('E'); }
+};
+
+Type*
+Type::make_error_type()
+{
+ static Error_type singleton_error_type;
+ return &singleton_error_type;
+}
+
+// The void type.
+
+class Void_type : public Type
+{
+ public:
+ Void_type()
+ : Type(TYPE_VOID)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return void_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { go_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { go_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('v'); }
+};
+
+Type*
+Type::make_void_type()
+{
+ static Void_type singleton_void_type;
+ return &singleton_void_type;
+}
+
+// The boolean type.
+
+class Boolean_type : public Type
+{
+ public:
+ Boolean_type()
+ : Type(TYPE_BOOLEAN)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return boolean_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, boolean_false_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type* name);
+
+ // We should not be asked for the reflection string of a basic type.
+ void
+ do_reflection(Gogo*, std::string* ret) const
+ { ret->append("bool"); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('b'); }
+};
+
+// Make the type descriptor.
+
+Expression*
+Boolean_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_BOOL, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("bool");
+ go_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+Type*
+Type::make_boolean_type()
+{
+ static Boolean_type boolean_type;
+ return &boolean_type;
+}
+
+// The named type "bool".
+
+static Named_type* named_bool_type;
+
+// Get the named type "bool".
+
+Named_type*
+Type::lookup_bool_type()
+{
+ return named_bool_type;
+}
+
+// Make the named type "bool".
+
+Named_type*
+Type::make_named_bool_type()
+{
+ Type* bool_type = Type::make_boolean_type();
+ Named_object* named_object = Named_object::make_type("bool", NULL,
+ bool_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_bool_type = named_type;
+ return named_type;
+}
+
+// Class Integer_type.
+
+Integer_type::Named_integer_types Integer_type::named_integer_types;
+
+// Create a new integer type. Non-abstract integer types always have
+// names.
+
+Named_type*
+Integer_type::create_integer_type(const char* name, bool is_unsigned,
+ int bits, int runtime_type_kind)
+{
+ Integer_type* integer_type = new Integer_type(false, is_unsigned, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ integer_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_integer_types::iterator, bool> ins =
+ Integer_type::named_integer_types.insert(std::make_pair(sname, named_type));
+ go_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing integer type.
+
+Named_type*
+Integer_type::lookup_integer_type(const char* name)
+{
+ Named_integer_types::const_iterator p =
+ Integer_type::named_integer_types.find(name);
+ go_assert(p != Integer_type::named_integer_types.end());
+ return p->second;
+}
+
+// Create a new abstract integer type.
+
+Integer_type*
+Integer_type::create_abstract_integer_type()
+{
+ static Integer_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Integer_type(true, false, INT_TYPE_SIZE,
+ RUNTIME_TYPE_KIND_INT);
+ return abstract_type;
+}
+
+// Integer type compatibility.
+
+bool
+Integer_type::is_identical(const Integer_type* t) const
+{
+ if (this->is_unsigned_ != t->is_unsigned_ || this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Integer_type::do_hash_for_method(Gogo*) const
+{
+ return ((this->bits_ << 4)
+ + ((this->is_unsigned_ ? 1 : 0) << 8)
+ + ((this->is_abstract_ ? 1 : 0) << 9));
+}
+
+// Get the tree for an Integer_type.
+
+tree
+Integer_type::do_get_tree(Gogo*)
+{
+ if (this->is_abstract_)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ if (this->is_unsigned_)
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return unsigned_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return unsigned_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_unsigned_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_unsigned_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_unsigned_type_node;
+ else
+ return make_unsigned_type(this->bits_);
+ }
+ else
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return integer_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return signed_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_integer_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_integer_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_integer_type_node;
+ else
+ return make_signed_type(this->bits_);
+ }
+}
+
+tree
+Integer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ return is_clear ? NULL : build_int_cst(type_tree, 0);
+}
+
+// The type descriptor for an integer type. Integer types are always
+// named.
+
+Expression*
+Integer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ go_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Integer_type::do_reflection(Gogo*, std::string*) const
+{
+ go_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Integer_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "i%s%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->is_unsigned_ ? "u" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make an integer type.
+
+Named_type*
+Type::make_integer_type(const char* name, bool is_unsigned, int bits,
+ int runtime_type_kind)
+{
+ return Integer_type::create_integer_type(name, is_unsigned, bits,
+ runtime_type_kind);
+}
+
+// Make an abstract integer type.
+
+Integer_type*
+Type::make_abstract_integer_type()
+{
+ return Integer_type::create_abstract_integer_type();
+}
+
+// Look up an integer type.
+
+Named_type*
+Type::lookup_integer_type(const char* name)
+{
+ return Integer_type::lookup_integer_type(name);
+}
+
+// Class Float_type.
+
+Float_type::Named_float_types Float_type::named_float_types;
+
+// Create a new float type. Non-abstract float types always have
+// names.
+
+Named_type*
+Float_type::create_float_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Float_type* float_type = new Float_type(false, bits, runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL, float_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_float_types::iterator, bool> ins =
+ Float_type::named_float_types.insert(std::make_pair(sname, named_type));
+ go_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing float type.
+
+Named_type*
+Float_type::lookup_float_type(const char* name)
+{
+ Named_float_types::const_iterator p =
+ Float_type::named_float_types.find(name);
+ go_assert(p != Float_type::named_float_types.end());
+ return p->second;
+}
+
+// Create a new abstract float type.
+
+Float_type*
+Float_type::create_abstract_float_type()
+{
+ static Float_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Float_type(true, 64, RUNTIME_TYPE_KIND_FLOAT64);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Float_type::is_identical(const Float_type* t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Float_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Float_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE)
+ return float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE)
+ return double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE)
+ return long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_;
+ layout_type(ret);
+ return ret;
+ }
+}
+
+// Get a tree.
+
+tree
+Float_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+tree
+Float_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(type_tree), 0, 0, 0);
+ return build_real(type_tree, r);
+}
+
+// The type descriptor for a float type. Float types are always named.
+
+Expression*
+Float_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ go_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Float_type::do_reflection(Gogo*, std::string*) const
+{
+ go_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Float_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "f%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a floating point type.
+
+Named_type*
+Type::make_float_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Float_type::create_float_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract float type.
+
+Float_type*
+Type::make_abstract_float_type()
+{
+ return Float_type::create_abstract_float_type();
+}
+
+// Look up a float type.
+
+Named_type*
+Type::lookup_float_type(const char* name)
+{
+ return Float_type::lookup_float_type(name);
+}
+
+// Class Complex_type.
+
+Complex_type::Named_complex_types Complex_type::named_complex_types;
+
+// Create a new complex type. Non-abstract complex types always have
+// names.
+
+Named_type*
+Complex_type::create_complex_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Complex_type* complex_type = new Complex_type(false, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ complex_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_complex_types::iterator, bool> ins =
+ Complex_type::named_complex_types.insert(std::make_pair(sname,
+ named_type));
+ go_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing complex type.
+
+Named_type*
+Complex_type::lookup_complex_type(const char* name)
+{
+ Named_complex_types::const_iterator p =
+ Complex_type::named_complex_types.find(name);
+ go_assert(p != Complex_type::named_complex_types.end());
+ return p->second;
+}
+
+// Create a new abstract complex type.
+
+Complex_type*
+Complex_type::create_abstract_complex_type()
+{
+ static Complex_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Complex_type(true, 128, RUNTIME_TYPE_KIND_COMPLEX128);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Complex_type::is_identical(const Complex_type *t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Complex_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Complex_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE * 2)
+ return complex_float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE * 2)
+ return complex_double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE * 2)
+ return complex_long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_ / 2;
+ layout_type(ret);
+ return build_complex_type(ret);
+ }
+}
+
+// Get a tree.
+
+tree
+Complex_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+// Zero initializer.
+
+tree
+Complex_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(TREE_TYPE(type_tree)), 0, 0, 0);
+ return build_complex(type_tree, build_real(TREE_TYPE(type_tree), r),
+ build_real(TREE_TYPE(type_tree), r));
+}
+
+// The type descriptor for a complex type. Complex types are always
+// named.
+
+Expression*
+Complex_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ go_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Complex_type::do_reflection(Gogo*, std::string*) const
+{
+ go_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Complex_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "c%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a complex type.
+
+Named_type*
+Type::make_complex_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Complex_type::create_complex_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract complex type.
+
+Complex_type*
+Type::make_abstract_complex_type()
+{
+ return Complex_type::create_abstract_complex_type();
+}
+
+// Look up a complex type.
+
+Named_type*
+Type::lookup_complex_type(const char* name)
+{
+ return Complex_type::lookup_complex_type(name);
+}
+
+// Class String_type.
+
+// Return the tree for String_type. A string is a struct with two
+// fields: a pointer to the characters and a length.
+
+tree
+String_type::do_get_tree(Gogo*)
+{
+ static tree struct_type;
+ return Gogo::builtin_struct(&struct_type, "__go_string", NULL_TREE, 2,
+ "__data",
+ build_pointer_type(unsigned_char_type_node),
+ "__length",
+ integer_type_node);
+}
+
+// Return a tree for the length of STRING.
+
+tree
+String_type::length_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ go_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree length_field = DECL_CHAIN(TYPE_FIELDS(string_type));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(length_field)),
+ "__length") == 0);
+ return fold_build3(COMPONENT_REF, integer_type_node, string,
+ length_field, NULL_TREE);
+}
+
+// Return a tree for a pointer to the bytes of STRING.
+
+tree
+String_type::bytes_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ go_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree bytes_field = TYPE_FIELDS(string_type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(bytes_field)),
+ "__data") == 0);
+ return fold_build3(COMPONENT_REF, TREE_TYPE(bytes_field), string,
+ bytes_field, NULL_TREE);
+}
+
+// We initialize a string to { NULL, 0 }.
+
+tree
+String_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL_TREE;
+
+ go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type descriptor for the string type.
+
+Expression*
+String_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_STRING, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("string");
+ go_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+String_type::do_reflection(Gogo*, std::string* ret) const
+{
+ ret->append("string");
+}
+
+// Mangled name of a string type.
+
+void
+String_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ ret->push_back('z');
+}
+
+// Make a string type.
+
+Type*
+Type::make_string_type()
+{
+ static String_type string_type;
+ return &string_type;
+}
+
+// The named type "string".
+
+static Named_type* named_string_type;
+
+// Get the named type "string".
+
+Named_type*
+Type::lookup_string_type()
+{
+ return named_string_type;
+}
+
+// Make the named type string.
+
+Named_type*
+Type::make_named_string_type()
+{
+ Type* string_type = Type::make_string_type();
+ Named_object* named_object = Named_object::make_type("string", NULL,
+ string_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_string_type = named_type;
+ return named_type;
+}
+
+// The sink type. This is the type of the blank identifier _. Any
+// type may be assigned to it.
+
+class Sink_type : public Type
+{
+ public:
+ Sink_type()
+ : Type(TYPE_SINK)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { go_unreachable(); }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { go_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { go_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { go_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { go_unreachable(); }
+};
+
+// Make the sink type.
+
+Type*
+Type::make_sink_type()
+{
+ static Sink_type sink_type;
+ return &sink_type;
+}
+
+// Class Function_type.
+
+// Traversal.
+
+int
+Function_type::do_traverse(Traverse* traverse)
+{
+ if (this->receiver_ != NULL
+ && Type::traverse(this->receiver_->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->parameters_ != NULL
+ && this->parameters_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->results_ != NULL
+ && this->results_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Returns whether T is a valid redeclaration of this type. If this
+// returns false, and REASON is not NULL, *REASON may be set to a
+// brief explanation of why it returned false.
+
+bool
+Function_type::is_valid_redeclaration(const Function_type* t,
+ std::string* reason) const
+{
+ if (!this->is_identical(t, false, true, reason))
+ return false;
+
+ // A redeclaration of a function is required to use the same names
+ // for the receiver and parameters.
+ if (this->receiver() != NULL
+ && this->receiver()->name() != t->receiver()->name()
+ && this->receiver()->name() != Import::import_marker
+ && t->receiver()->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "receiver name changed";
+ return false;
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1->name() != p2->name()
+ && p1->name() != Import::import_marker
+ && p2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "parameter name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = p1->type()->forwarded();
+ Type* t2 = p2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1->name() != res2->name()
+ && res1->name() != Import::import_marker
+ && res2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "result name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = res1->type()->forwarded();
+ Type* t2 = res2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check whether T is the same as this type.
+
+bool
+Function_type::is_identical(const Function_type* t, bool ignore_receiver,
+ bool errors_are_identical,
+ std::string* reason) const
+{
+ if (!ignore_receiver)
+ {
+ const Typed_identifier* r1 = this->receiver();
+ const Typed_identifier* r2 = t->receiver();
+ if ((r1 != NULL) != (r2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different receiver types");
+ return false;
+ }
+ if (r1 != NULL)
+ {
+ if (!Type::are_identical(r1->type(), r2->type(), errors_are_identical,
+ reason))
+ {
+ if (reason != NULL && !reason->empty())
+ *reason = "receiver: " + *reason;
+ return false;
+ }
+ }
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if ((parms1 != NULL) != (parms2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1 == parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+
+ if (!Type::are_identical(p1->type(), p2->type(),
+ errors_are_identical, NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different parameter types");
+ return false;
+ }
+ }
+ if (p1 != parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ }
+
+ if (this->is_varargs() != t->is_varargs())
+ {
+ if (reason != NULL)
+ *reason = _("different varargs");
+ return false;
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if ((results1 != NULL) != (results2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1 == results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+
+ if (!Type::are_identical(res1->type(), res2->type(),
+ errors_are_identical, NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different result types");
+ return false;
+ }
+ }
+ if (res1 != results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Function_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ // We ignore the receiver type for hash codes, because we need to
+ // get the same hash code for a method in an interface and a method
+ // declared for a type. The former will not have a receiver.
+ if (this->parameters_ != NULL)
+ {
+ int shift = 1;
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->results_ != NULL)
+ {
+ int shift = 2;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->is_varargs_)
+ ret += 1;
+ ret <<= 4;
+ return ret;
+}
+
+// Get the tree for a function type.
+
+tree
+Function_type::do_get_tree(Gogo* gogo)
+{
+ tree args = NULL_TREE;
+ tree* pp = &args;
+
+ if (this->receiver_ != NULL)
+ {
+ Type* rtype = this->receiver_->type();
+ tree ptype = rtype->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+
+ // We always pass the address of the receiver parameter, in
+ // order to make interface calls work with unknown types.
+ if (rtype->points_to() == NULL)
+ ptype = build_pointer_type(ptype);
+
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+
+ if (this->parameters_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ tree ptype = p->type()->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+ }
+
+ // Varargs is handled entirely at the Go level. At the tree level,
+ // functions are not varargs.
+ *pp = void_list_node;
+
+ tree result;
+ if (this->results_ == NULL)
+ result = void_type_node;
+ else if (this->results_->size() == 1)
+ result = this->results_->begin()->type()->get_tree(gogo);
+ else
+ {
+ result = make_node(RECORD_TYPE);
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p)
+ {
+ const std::string name = (p->name().empty()
+ ? "UNNAMED"
+ : Gogo::unpack_hidden_name(p->name()));
+ tree name_tree = get_identifier_with_length(name.data(),
+ name.length());
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = result;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+ TYPE_FIELDS(result) = field_trees;
+ layout_type(result);
+ }
+
+ if (result == error_mark_node)
+ return error_mark_node;
+
+ tree fntype = build_function_type(result, args);
+ if (fntype == error_mark_node)
+ return fntype;
+
+ return build_pointer_type(fntype);
+}
+
+// Functions are initialized to NULL.
+
+tree
+Function_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a function type descriptor.
+
+Type*
+Function_type::make_function_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* bool_type = Type::lookup_bool_type();
+
+ Type* slice_type = Type::make_array_type(ptdt, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(4,
+ "", tdt,
+ "dotdotdot", bool_type,
+ "in", slice_type,
+ "out", slice_type);
+
+ ret = Type::make_builtin_named_type("FuncType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a function type.
+
+Expression*
+Function_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ftdt = Function_type::make_function_type_descriptor_type();
+
+ const Struct_field_list* fields = ftdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(4);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_FUNC,
+ name, NULL, true));
+
+ ++p;
+ go_assert(p->field_name() == "dotdotdot");
+ vals->push_back(Expression::make_boolean(this->is_varargs(), bloc));
+
+ ++p;
+ go_assert(p->field_name() == "in");
+ vals->push_back(this->type_descriptor_params(p->type(), this->receiver(),
+ this->parameters()));
+
+ ++p;
+ go_assert(p->field_name() == "out");
+ vals->push_back(this->type_descriptor_params(p->type(), NULL,
+ this->results()));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ftdt, vals, bloc);
+}
+
+// Return a composite literal for the parameters or results of a type
+// descriptor.
+
+Expression*
+Function_type::type_descriptor_params(Type* params_type,
+ const Typed_identifier* receiver,
+ const Typed_identifier_list* params)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ if (receiver == NULL && params == NULL)
+ return Expression::make_slice_composite_literal(params_type, NULL, bloc);
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve((params == NULL ? 0 : params->size())
+ + (receiver != NULL ? 1 : 0));
+
+ if (receiver != NULL)
+ {
+ Type* rtype = receiver->type();
+ // The receiver is always passed as a pointer. FIXME: Is this
+ // right? Should that fact affect the type descriptor?
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ vals->push_back(Expression::make_type_descriptor(rtype, bloc));
+ }
+
+ if (params != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ vals->push_back(Expression::make_type_descriptor(p->type(), bloc));
+ }
+
+ return Expression::make_slice_composite_literal(params_type, vals, bloc);
+}
+
+// The reflection string.
+
+void
+Function_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ // FIXME: Turn this off until we straighten out the type of the
+ // struct field used in a go statement which calls a method.
+ // go_assert(this->receiver_ == NULL);
+
+ ret->append("func");
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('(');
+ this->append_reflection(this->receiver_->type(), gogo, ret);
+ ret->push_back(')');
+ }
+
+ ret->push_back('(');
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ if (p != params->begin())
+ ret->append(", ");
+ if (!is_varargs || p + 1 != params->end())
+ this->append_reflection(p->type(), gogo, ret);
+ else
+ {
+ ret->append("...");
+ this->append_reflection(p->type()->array_type()->element_type(),
+ gogo, ret);
+ }
+ }
+ }
+ ret->push_back(')');
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL && !results->empty())
+ {
+ if (results->size() == 1)
+ ret->push_back(' ');
+ else
+ ret->append(" (");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (p != results->begin())
+ ret->append(", ");
+ this->append_reflection(p->type(), gogo, ret);
+ }
+ if (results->size() > 1)
+ ret->push_back(')');
+ }
+}
+
+// Mangled name.
+
+void
+Function_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('F');
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('m');
+ this->append_mangled_name(this->receiver_->type(), gogo, ret);
+ }
+
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ ret->push_back('p');
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (this->is_varargs_)
+ ret->push_back('V');
+ ret->push_back('e');
+ }
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL)
+ {
+ ret->push_back('r');
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ ret->push_back('e');
+ }
+
+ ret->push_back('e');
+}
+
+// Export a function type.
+
+void
+Function_type::do_export(Export* exp) const
+{
+ // We don't write out the receiver. The only function types which
+ // should have a receiver are the ones associated with explicitly
+ // defined methods. For those the receiver type is written out by
+ // Function::export_func.
+
+ exp->write_c_string("(");
+ bool first = true;
+ if (this->parameters_ != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p =
+ this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != this->parameters_->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = this->results_;
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+}
+
+// Import a function type.
+
+Function_type*
+Function_type::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ go_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ imp->advance(1);
+ results = new Typed_identifier_list;
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* ret = Type::make_function_type(NULL, parameters, results,
+ imp->location());
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Make a copy of a function type without a receiver.
+
+Function_type*
+Function_type::copy_without_receiver() const
+{
+ go_assert(this->is_method());
+ Function_type *ret = Type::make_function_type(NULL, this->parameters_,
+ this->results_,
+ this->location_);
+ if (this->is_varargs())
+ ret->set_is_varargs();
+ if (this->is_builtin())
+ ret->set_is_builtin();
+ return ret;
+}
+
+// Make a copy of a function type with a receiver.
+
+Function_type*
+Function_type::copy_with_receiver(Type* receiver_type) const
+{
+ go_assert(!this->is_method());
+ Typed_identifier* receiver = new Typed_identifier("", receiver_type,
+ this->location_);
+ return Type::make_function_type(receiver, this->parameters_,
+ this->results_, this->location_);
+}
+
+// Make a function type.
+
+Function_type*
+Type::make_function_type(Typed_identifier* receiver,
+ Typed_identifier_list* parameters,
+ Typed_identifier_list* results,
+ source_location location)
+{
+ return new Function_type(receiver, parameters, results, location);
+}
+
+// Class Pointer_type.
+
+// Traversal.
+
+int
+Pointer_type::do_traverse(Traverse* traverse)
+{
+ return Type::traverse(this->to_type_, traverse);
+}
+
+// Hash code.
+
+unsigned int
+Pointer_type::do_hash_for_method(Gogo* gogo) const
+{
+ return this->to_type_->hash_for_method(gogo) << 4;
+}
+
+// The tree for a pointer type.
+
+tree
+Pointer_type::do_get_tree(Gogo* gogo)
+{
+ return build_pointer_type(this->to_type_->get_tree(gogo));
+}
+
+// Initialize a pointer type.
+
+tree
+Pointer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a pointer type descriptor.
+
+Type*
+Pointer_type::make_pointer_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("PtrType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a pointer type.
+
+Expression*
+Pointer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->is_unsafe_pointer_type())
+ {
+ go_assert(name != NULL);
+ return this->plain_type_descriptor(gogo,
+ RUNTIME_TYPE_KIND_UNSAFE_POINTER,
+ name);
+ }
+ else
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Methods* methods;
+ Type* deref = this->points_to();
+ if (deref->named_type() != NULL)
+ methods = deref->named_type()->methods();
+ else if (deref->struct_type() != NULL)
+ methods = deref->struct_type()->methods();
+ else
+ methods = NULL;
+
+ Type* ptr_tdt = Pointer_type::make_pointer_type_descriptor_type();
+
+ const Struct_field_list* fields = ptr_tdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_PTR,
+ name, methods, false));
+
+ ++p;
+ go_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(deref, bloc));
+
+ return Expression::make_struct_composite_literal(ptr_tdt, vals, bloc);
+ }
+}
+
+// Reflection string.
+
+void
+Pointer_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('*');
+ this->append_reflection(this->to_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Pointer_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('p');
+ this->append_mangled_name(this->to_type_, gogo, ret);
+}
+
+// Export.
+
+void
+Pointer_type::do_export(Export* exp) const
+{
+ exp->write_c_string("*");
+ if (this->is_unsafe_pointer_type())
+ exp->write_c_string("any");
+ else
+ exp->write_type(this->to_type_);
+}
+
+// Import.
+
+Pointer_type*
+Pointer_type::do_import(Import* imp)
+{
+ imp->require_c_string("*");
+ if (imp->match_c_string("any"))
+ {
+ imp->advance(3);
+ return Type::make_pointer_type(Type::make_void_type());
+ }
+ Type* to = imp->read_type();
+ return Type::make_pointer_type(to);
+}
+
+// Make a pointer type.
+
+Pointer_type*
+Type::make_pointer_type(Type* to_type)
+{
+ typedef Unordered_map(Type*, Pointer_type*) Hashtable;
+ static Hashtable pointer_types;
+ Hashtable::const_iterator p = pointer_types.find(to_type);
+ if (p != pointer_types.end())
+ return p->second;
+ Pointer_type* ret = new Pointer_type(to_type);
+ pointer_types[to_type] = ret;
+ return ret;
+}
+
+// The nil type. We use a special type for nil because it is not the
+// same as any other type. In C term nil has type void*, but there is
+// no such type in Go.
+
+class Nil_type : public Type
+{
+ public:
+ Nil_type()
+ : Type(TYPE_NIL)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return ptr_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, null_pointer_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { go_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { go_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('n'); }
+};
+
+// Make the nil type.
+
+Type*
+Type::make_nil_type()
+{
+ static Nil_type singleton_nil_type;
+ return &singleton_nil_type;
+}
+
+// The type of a function call which returns multiple values. This is
+// really a struct, but we don't want to confuse a function call which
+// returns a struct with a function call which returns multiple
+// values.
+
+class Call_multiple_result_type : public Type
+{
+ public:
+ Call_multiple_result_type(Call_expression* call)
+ : Type(TYPE_CALL_MULTIPLE_RESULT),
+ call_(call)
+ { }
+
+ protected:
+ bool
+ do_has_pointer() const
+ {
+ go_assert(saw_errors());
+ return false;
+ }
+
+ tree
+ do_get_tree(Gogo*);
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ {
+ go_assert(saw_errors());
+ return Expression::make_error(UNKNOWN_LOCATION);
+ }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { go_assert(saw_errors()); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { go_assert(saw_errors()); }
+
+ private:
+ // The expression being called.
+ Call_expression* call_;
+};
+
+// Return the tree for a call result.
+
+tree
+Call_multiple_result_type::do_get_tree(Gogo* gogo)
+{
+ Function_type* fntype = this->call_->get_function_type();
+ go_assert(fntype != NULL);
+ const Typed_identifier_list* results = fntype->results();
+ go_assert(results != NULL && results->size() > 1);
+ tree fntype_tree = fntype->get_tree(gogo);
+ if (fntype_tree == error_mark_node)
+ return error_mark_node;
+ return TREE_TYPE(fntype_tree);
+}
+
+// Make a call result type.
+
+Type*
+Type::make_call_multiple_result_type(Call_expression* call)
+{
+ return new Call_multiple_result_type(call);
+}
+
+// Class Struct_field.
+
+// Get the name of a field.
+
+const std::string&
+Struct_field::field_name() const
+{
+ const std::string& name(this->typed_identifier_.name());
+ if (!name.empty())
+ return name;
+ else
+ {
+ // This is called during parsing, before anything is lowered, so
+ // we have to be pretty careful to avoid dereferencing an
+ // unknown type name.
+ Type* t = this->typed_identifier_.type();
+ Type* dt = t;
+ if (t->classification() == Type::TYPE_POINTER)
+ {
+ // Very ugly.
+ Pointer_type* ptype = static_cast<Pointer_type*>(t);
+ dt = ptype->points_to();
+ }
+ if (dt->forward_declaration_type() != NULL)
+ return dt->forward_declaration_type()->name();
+ else if (dt->named_type() != NULL)
+ return dt->named_type()->name();
+ else if (t->is_error_type() || dt->is_error_type())
+ {
+ static const std::string error_string = "*error*";
+ return error_string;
+ }
+ else
+ {
+ // Avoid crashing in the erroneous case where T is named but
+ // DT is not.
+ go_assert(t != dt);
+ if (t->forward_declaration_type() != NULL)
+ return t->forward_declaration_type()->name();
+ else if (t->named_type() != NULL)
+ return t->named_type()->name();
+ else
+ go_unreachable();
+ }
+ }
+}
+
+// Class Struct_type.
+
+// Traversal.
+
+int
+Struct_type::do_traverse(Traverse* traverse)
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that the struct type is complete and valid.
+
+bool
+Struct_type::do_verify()
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return true;
+ bool ret = true;
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t->is_undefined())
+ {
+ error_at(p->location(), "struct field type is incomplete");
+ p->set_type(Type::make_error_type());
+ ret = false;
+ }
+ else if (p->is_anonymous())
+ {
+ if (t->named_type() != NULL && t->points_to() != NULL)
+ {
+ error_at(p->location(), "embedded type may not be a pointer");
+ p->set_type(Type::make_error_type());
+ return false;
+ }
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ {
+ error_at(p->location(),
+ "embedded type may not be pointer to interface");
+ p->set_type(Type::make_error_type());
+ return false;
+ }
+ }
+ }
+ return ret;
+}
+
+// Whether this contains a pointer.
+
+bool
+Struct_type::do_has_pointer() const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->type()->has_pointer())
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical to T.
+
+bool
+Struct_type::is_identical(const Struct_type* t,
+ bool errors_are_identical) const
+{
+ const Struct_field_list* fields1 = this->fields();
+ const Struct_field_list* fields2 = t->fields();
+ if (fields1 == NULL || fields2 == NULL)
+ return fields1 == fields2;
+ Struct_field_list::const_iterator pf2 = fields2->begin();
+ for (Struct_field_list::const_iterator pf1 = fields1->begin();
+ pf1 != fields1->end();
+ ++pf1, ++pf2)
+ {
+ if (pf2 == fields2->end())
+ return false;
+ if (pf1->field_name() != pf2->field_name())
+ return false;
+ if (pf1->is_anonymous() != pf2->is_anonymous()
+ || !Type::are_identical(pf1->type(), pf2->type(),
+ errors_are_identical, NULL))
+ return false;
+ if (!pf1->has_tag())
+ {
+ if (pf2->has_tag())
+ return false;
+ }
+ else
+ {
+ if (!pf2->has_tag())
+ return false;
+ if (pf1->tag() != pf2->tag())
+ return false;
+ }
+ }
+ if (pf2 != fields2->end())
+ return false;
+ return true;
+}
+
+// Whether this struct type has any hidden fields.
+
+bool
+Struct_type::struct_has_hidden_fields(const Named_type* within,
+ std::string* reason) const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ const Package* within_package = (within == NULL
+ ? NULL
+ : within->named_object()->package());
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (within_package != NULL
+ && !pf->is_anonymous()
+ && Gogo::is_hidden_name(pf->field_name()))
+ {
+ if (reason != NULL)
+ {
+ std::string within_name = within->named_object()->message_name();
+ std::string name = Gogo::message_name(pf->field_name());
+ size_t bufsize = 200 + within_name.length() + name.length();
+ char* buf = new char[bufsize];
+ snprintf(buf, bufsize,
+ _("implicit assignment of %s%s%s hidden field %s%s%s"),
+ open_quote, within_name.c_str(), close_quote,
+ open_quote, name.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return true;
+ }
+
+ if (pf->type()->has_hidden_fields(within, reason))
+ return true;
+ }
+
+ return false;
+}
+
+// Hash code.
+
+unsigned int
+Struct_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->fields() != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = this->fields()->begin();
+ pf != this->fields()->end();
+ ++pf)
+ ret = (ret << 1) + pf->type()->hash_for_method(gogo);
+ }
+ return ret <<= 2;
+}
+
+// Find the local field NAME.
+
+const Struct_field*
+Struct_type::find_local_field(const std::string& name,
+ unsigned int *pindex) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ if (pindex != NULL)
+ *pindex = i;
+ return &*pf;
+ }
+ }
+ return NULL;
+}
+
+// Return an expression for field NAME in STRUCT_EXPR, or NULL.
+
+Field_reference_expression*
+Struct_type::field_reference(Expression* struct_expr, const std::string& name,
+ source_location location) const
+{
+ unsigned int depth;
+ return this->field_reference_depth(struct_expr, name, location, NULL,
+ &depth);
+}
+
+// Return an expression for a field, along with the depth at which it
+// was found.
+
+Field_reference_expression*
+Struct_type::field_reference_depth(Expression* struct_expr,
+ const std::string& name,
+ source_location location,
+ Saw_named_type* saw,
+ unsigned int* depth) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+
+ // Look for a field with this name.
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ *depth = 0;
+ return Expression::make_field_reference(struct_expr, i, location);
+ }
+ }
+
+ // Look for an anonymous field which contains a field with this
+ // name.
+ unsigned int found_depth = 0;
+ Field_reference_expression* ret = NULL;
+ i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Struct_type* st = pf->type()->deref()->struct_type();
+ if (st == NULL)
+ continue;
+
+ Saw_named_type* hold_saw = saw;
+ Saw_named_type saw_here;
+ Named_type* nt = pf->type()->named_type();
+ if (nt == NULL)
+ nt = pf->type()->deref()->named_type();
+ if (nt != NULL)
+ {
+ Saw_named_type* q;
+ for (q = saw; q != NULL; q = q->next)
+ {
+ if (q->nt == nt)
+ {
+ // If this is an error, it will be reported
+ // elsewhere.
+ break;
+ }
+ }
+ if (q != NULL)
+ continue;
+ saw_here.next = saw;
+ saw_here.nt = nt;
+ saw = &saw_here;
+ }
+
+ // Look for a reference using a NULL struct expression. If we
+ // find one, fill in the struct expression with a reference to
+ // this field.
+ unsigned int subdepth;
+ Field_reference_expression* sub = st->field_reference_depth(NULL, name,
+ location,
+ saw,
+ &subdepth);
+
+ saw = hold_saw;
+
+ if (sub == NULL)
+ continue;
+
+ if (ret == NULL || subdepth < found_depth)
+ {
+ if (ret != NULL)
+ delete ret;
+ ret = sub;
+ found_depth = subdepth;
+ Expression* here = Expression::make_field_reference(struct_expr, i,
+ location);
+ if (pf->type()->points_to() != NULL)
+ here = Expression::make_unary(OPERATOR_MULT, here, location);
+ while (sub->expr() != NULL)
+ {
+ sub = sub->expr()->deref()->field_reference_expression();
+ go_assert(sub != NULL);
+ }
+ sub->set_struct_expression(here);
+ }
+ else if (subdepth > found_depth)
+ delete sub;
+ else
+ {
+ // We do not handle ambiguity here--it should be handled by
+ // Type::bind_field_or_method.
+ delete sub;
+ found_depth = 0;
+ ret = NULL;
+ }
+ }
+
+ if (ret != NULL)
+ *depth = found_depth + 1;
+
+ return ret;
+}
+
+// Return the total number of fields, including embedded fields.
+
+unsigned int
+Struct_type::total_field_count() const
+{
+ if (this->fields_ == NULL)
+ return 0;
+ unsigned int ret = 0;
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ if (!pf->is_anonymous() || pf->type()->deref()->struct_type() == NULL)
+ ++ret;
+ else
+ ret += pf->type()->struct_type()->total_field_count();
+ }
+ return ret;
+}
+
+// Return whether NAME is an unexported field, for better error reporting.
+
+bool
+Struct_type::is_unexported_local_field(Gogo* gogo,
+ const std::string& name) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ const std::string& field_name(pf->field_name());
+ if (Gogo::is_hidden_name(field_name)
+ && name == Gogo::unpack_hidden_name(field_name)
+ && gogo->pack_hidden_name(name, false) != field_name)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Finalize the methods of an unnamed struct.
+
+void
+Struct_type::finalize_methods(Gogo* gogo)
+{
+ if (this->all_methods_ != NULL)
+ return;
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Struct_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Get the tree for a struct type.
+
+tree
+Struct_type::do_get_tree(Gogo* gogo)
+{
+ tree type = make_node(RECORD_TYPE);
+ return this->fill_in_tree(gogo, type);
+}
+
+// Fill in the fields for a struct type.
+
+tree
+Struct_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->field_name());
+ tree name_tree = get_identifier_with_length(name.data(), name.length());
+
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ go_assert(TYPE_SIZE(field_type_tree) != NULL_TREE);
+
+ tree field = build_decl(p->location(), FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = type;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+
+ TYPE_FIELDS(type) = field_trees;
+
+ layout_type(type);
+
+ return type;
+}
+
+// Initialize struct fields.
+
+tree
+Struct_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->fields_ == NULL || this->fields_->empty())
+ {
+ if (is_clear)
+ return NULL;
+ else
+ {
+ tree ret = build_constructor(type_tree,
+ VEC_alloc(constructor_elt, gc, 0));
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ }
+
+ bool is_constant = true;
+ bool any_fields_set = false;
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc,
+ this->fields_->size());
+
+ tree field = TYPE_FIELDS(type_tree);
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p, field = DECL_CHAIN(field))
+ {
+ tree value = p->type()->get_init_tree(gogo, is_clear);
+ if (value == error_mark_node)
+ return error_mark_node;
+ go_assert(field != NULL_TREE);
+ if (value != NULL)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = value;
+ any_fields_set = true;
+ if (!TREE_CONSTANT(value))
+ is_constant = false;
+ }
+ }
+ go_assert(field == NULL_TREE);
+
+ if (!any_fields_set)
+ {
+ go_assert(is_clear);
+ VEC_free(constructor_elt, gc, init);
+ return NULL;
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of a struct type descriptor.
+
+Type*
+Struct_type::make_struct_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt,
+ "tag", pointer_string_type,
+ "offset", uintptr_type);
+ Type* nsf = Type::make_builtin_named_type("structField", sf);
+
+ Type* slice_type = Type::make_array_type(nsf, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "fields", slice_type);
+
+ ret = Type::make_builtin_named_type("StructType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a struct type.
+
+Expression*
+Struct_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Struct_type::make_struct_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ const Methods* methods = this->methods();
+ // A named struct should not have methods--the methods should attach
+ // to the named type.
+ go_assert(methods == NULL || name == NULL);
+
+ Struct_field_list::const_iterator ps = fields->begin();
+ go_assert(ps->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_STRUCT,
+ name, methods, true));
+
+ ++ps;
+ go_assert(ps->field_name() == "fields");
+
+ Expression_list* elements = new Expression_list();
+ elements->reserve(this->fields_->size());
+ Type* element_type = ps->type()->array_type()->element_type();
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ const Struct_field_list* f = element_type->struct_type()->fields();
+
+ Expression_list* fvals = new Expression_list();
+ fvals->reserve(5);
+
+ Struct_field_list::const_iterator q = f->begin();
+ go_assert(q->field_name() == "name");
+ if (pf->is_anonymous())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ go_assert(q->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pf->field_name()))
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::hidden_name_prefix(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ go_assert(q->field_name() == "typ");
+ fvals->push_back(Expression::make_type_descriptor(pf->type(), bloc));
+
+ ++q;
+ go_assert(q->field_name() == "tag");
+ if (!pf->has_tag())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ Expression* s = Expression::make_string(pf->tag(), bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ go_assert(q->field_name() == "offset");
+ fvals->push_back(Expression::make_struct_field_offset(this, &*pf));
+
+ Expression* v = Expression::make_struct_composite_literal(element_type,
+ fvals, bloc);
+ elements->push_back(v);
+ }
+
+ vals->push_back(Expression::make_slice_composite_literal(ps->type(),
+ elements, bloc));
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Struct_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("struct { ");
+
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ if (p != this->fields_->begin())
+ ret->append("; ");
+ if (p->is_anonymous())
+ ret->push_back('?');
+ else
+ ret->append(Gogo::unpack_hidden_name(p->field_name()));
+ ret->push_back(' ');
+ this->append_reflection(p->type(), gogo, ret);
+
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ ret->append(" \"");
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (*p == '\0')
+ ret->append("\\x00");
+ else if (*p == '\n')
+ ret->append("\\n");
+ else if (*p == '\t')
+ ret->append("\\t");
+ else if (*p == '"')
+ ret->append("\\\"");
+ else if (*p == '\\')
+ ret->append("\\\\");
+ else
+ ret->push_back(*p);
+ }
+ ret->push_back('"');
+ }
+ }
+
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Struct_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('S');
+
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ ret->append("0_");
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(p->field_name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ }
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ std::string out;
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (ISALNUM(*p) || *p == '_')
+ out.push_back(*p);
+ else
+ {
+ char buf[20];
+ snprintf(buf, sizeof buf, ".%x.",
+ static_cast<unsigned int>(*p));
+ out.append(buf);
+ }
+ }
+ char buf[20];
+ snprintf(buf, sizeof buf, "T%u_",
+ static_cast<unsigned int>(out.length()));
+ ret->append(buf);
+ ret->append(out);
+ }
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Struct_type::do_export(Export* exp) const
+{
+ exp->write_c_string("struct { ");
+ const Struct_field_list* fields = this->fields_;
+ go_assert(fields != NULL);
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ exp->write_string("? ");
+ else
+ {
+ exp->write_string(p->field_name());
+ exp->write_c_string(" ");
+ }
+ exp->write_type(p->type());
+
+ if (p->has_tag())
+ {
+ exp->write_c_string(" ");
+ Expression* expr = Expression::make_string(p->tag(),
+ BUILTINS_LOCATION);
+ expr->export_expression(exp);
+ delete expr;
+ }
+
+ exp->write_c_string("; ");
+ }
+ exp->write_c_string("}");
+}
+
+// Import.
+
+Struct_type*
+Struct_type::do_import(Import* imp)
+{
+ imp->require_c_string("struct { ");
+ Struct_field_list* fields = new Struct_field_list;
+ if (imp->peek_char() != '}')
+ {
+ while (true)
+ {
+ std::string name;
+ if (imp->match_c_string("? "))
+ imp->advance(2);
+ else
+ {
+ name = imp->read_identifier();
+ imp->require_c_string(" ");
+ }
+ Type* ftype = imp->read_type();
+
+ Struct_field sf(Typed_identifier(name, ftype, imp->location()));
+
+ if (imp->peek_char() == ' ')
+ {
+ imp->advance(1);
+ Expression* expr = Expression::import_expression(imp);
+ String_expression* sexpr = expr->string_expression();
+ go_assert(sexpr != NULL);
+ sf.set_tag(sexpr->val());
+ delete sexpr;
+ }
+
+ imp->require_c_string("; ");
+ fields->push_back(sf);
+ if (imp->peek_char() == '}')
+ break;
+ }
+ }
+ imp->require_c_string("}");
+
+ return Type::make_struct_type(fields, imp->location());
+}
+
+// Make a struct type.
+
+Struct_type*
+Type::make_struct_type(Struct_field_list* fields,
+ source_location location)
+{
+ return new Struct_type(fields, location);
+}
+
+// Class Array_type.
+
+// Whether two array types are identical.
+
+bool
+Array_type::is_identical(const Array_type* t, bool errors_are_identical) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(),
+ errors_are_identical, NULL))
+ return false;
+
+ Expression* l1 = this->length();
+ Expression* l2 = t->length();
+
+ // Slices of the same element type are identical.
+ if (l1 == NULL && l2 == NULL)
+ return true;
+
+ // Arrays of the same element type are identical if they have the
+ // same length.
+ if (l1 != NULL && l2 != NULL)
+ {
+ if (l1 == l2)
+ return true;
+
+ // Try to determine the lengths. If we can't, assume the arrays
+ // are not identical.
+ bool ret = false;
+ mpz_t v1;
+ mpz_init(v1);
+ Type* type1;
+ mpz_t v2;
+ mpz_init(v2);
+ Type* type2;
+ if (l1->integer_constant_value(true, v1, &type1)
+ && l2->integer_constant_value(true, v2, &type2))
+ ret = mpz_cmp(v1, v2) == 0;
+ mpz_clear(v1);
+ mpz_clear(v2);
+ return ret;
+ }
+
+ // Otherwise the arrays are not identical.
+ return false;
+}
+
+// Traversal.
+
+int
+Array_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->element_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->length_ != NULL
+ && Expression::traverse(&this->length_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the length is valid.
+
+bool
+Array_type::verify_length()
+{
+ if (this->length_ == NULL)
+ return true;
+
+ Type_context context(Type::lookup_integer_type("int"), false);
+ this->length_->determine_type(&context);
+
+ if (!this->length_->is_constant())
+ {
+ error_at(this->length_->location(), "array bound is not constant");
+ return false;
+ }
+
+ mpz_t val;
+ mpz_init(val);
+ Type* vt;
+ if (!this->length_->integer_constant_value(true, val, &vt))
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (!this->length_->float_constant_value(fval, &vt))
+ {
+ if (this->length_->type()->integer_type() != NULL
+ || this->length_->type()->float_type() != NULL)
+ error_at(this->length_->location(),
+ "array bound is not constant");
+ else
+ error_at(this->length_->location(),
+ "array bound is not numeric");
+ mpfr_clear(fval);
+ mpz_clear(val);
+ return false;
+ }
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(this->length_->location(),
+ "array bound truncated to integer");
+ mpfr_clear(fval);
+ mpz_clear(val);
+ return false;
+ }
+ mpz_init(val);
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ }
+
+ if (mpz_sgn(val) < 0)
+ {
+ error_at(this->length_->location(), "negative array bound");
+ mpz_clear(val);
+ return false;
+ }
+
+ Type* int_type = Type::lookup_integer_type("int");
+ int tbits = int_type->integer_type()->bits();
+ int vbits = mpz_sizeinbase(val, 2);
+ if (vbits + 1 > tbits)
+ {
+ error_at(this->length_->location(), "array bound overflows");
+ mpz_clear(val);
+ return false;
+ }
+
+ mpz_clear(val);
+
+ return true;
+}
+
+// Verify the type.
+
+bool
+Array_type::do_verify()
+{
+ if (!this->verify_length())
+ {
+ this->length_ = Expression::make_error(this->length_->location());
+ return false;
+ }
+ return true;
+}
+
+// Array type hash code.
+
+unsigned int
+Array_type::do_hash_for_method(Gogo* gogo) const
+{
+ // There is no very convenient way to get a hash code for the
+ // length.
+ return this->element_type_->hash_for_method(gogo) + 1;
+}
+
+// See if the expression passed to make is suitable. The first
+// argument is required, and gives the length. An optional second
+// argument is permitted for the capacity.
+
+bool
+Array_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ go_assert(this->length_ == NULL);
+ if (args == NULL || args->empty())
+ {
+ error_at(location, "length required when allocating a slice");
+ return false;
+ }
+ else if (args->size() > 2)
+ {
+ error_at(location, "too many expressions passed to make");
+ return false;
+ }
+ else
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad length when making slice"), location))
+ return false;
+
+ if (args->size() > 1)
+ {
+ if (!Type::check_int_value(args->back(),
+ _("bad capacity when making slice"),
+ location))
+ return false;
+ }
+
+ return true;
+ }
+}
+
+// Get a tree for the length of a fixed array. The length may be
+// computed using a function call, so we must only evaluate it once.
+
+tree
+Array_type::get_length_tree(Gogo* gogo)
+{
+ go_assert(this->length_ != NULL);
+ if (this->length_tree_ == NULL_TREE)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* t;
+ if (this->length_->integer_constant_value(true, val, &t))
+ {
+ if (t == NULL)
+ t = Type::lookup_integer_type("int");
+ else if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ tree tt = t->get_tree(gogo);
+ this->length_tree_ = Expression::integer_constant_tree(val, tt);
+ mpz_clear(val);
+ }
+ else
+ {
+ mpz_clear(val);
+
+ // Make up a translation context for the array length
+ // expression. FIXME: This won't work in general.
+ Translate_context context(gogo, NULL, NULL, NULL);
+ tree len = this->length_->get_tree(&context);
+ if (len != error_mark_node)
+ {
+ len = convert_to_integer(integer_type_node, len);
+ len = save_expr(len);
+ }
+ this->length_tree_ = len;
+ }
+ }
+ return this->length_tree_;
+}
+
+// Get a tree for the type of this array. A fixed array is simply
+// represented as ARRAY_TYPE with the appropriate index--i.e., it is
+// just like an array in C. An open array is a struct with three
+// fields: a data pointer, the length, and the capacity.
+
+tree
+Array_type::do_get_tree(Gogo* gogo)
+{
+ if (this->length_ == NULL)
+ {
+ tree struct_type = gogo->slice_type_tree(void_type_node);
+ return this->fill_in_slice_tree(gogo, struct_type);
+ }
+ else
+ {
+ tree array_type = make_node(ARRAY_TYPE);
+ return this->fill_in_array_tree(gogo, array_type);
+ }
+}
+
+// Fill in the fields for an array type. This is used for named array
+// types.
+
+tree
+Array_type::fill_in_array_tree(Gogo* gogo, tree array_type)
+{
+ go_assert(this->length_ != NULL);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ tree length_tree = this->get_length_tree(gogo);
+ if (element_type_tree == error_mark_node
+ || length_tree == error_mark_node)
+ return error_mark_node;
+
+ go_assert(TYPE_SIZE(element_type_tree) != NULL_TREE);
+
+ length_tree = fold_convert(sizetype, length_tree);
+
+ // build_index_type takes the maximum index, which is one less than
+ // the length.
+ tree index_type = build_index_type(fold_build2(MINUS_EXPR, sizetype,
+ length_tree,
+ size_one_node));
+
+ TREE_TYPE(array_type) = element_type_tree;
+ TYPE_DOMAIN(array_type) = index_type;
+ TYPE_ADDR_SPACE(array_type) = TYPE_ADDR_SPACE(element_type_tree);
+ layout_type(array_type);
+
+ if (TYPE_STRUCTURAL_EQUALITY_P(element_type_tree)
+ || TYPE_STRUCTURAL_EQUALITY_P(index_type))
+ SET_TYPE_STRUCTURAL_EQUALITY(array_type);
+ else if (TYPE_CANONICAL(element_type_tree) != element_type_tree
+ || TYPE_CANONICAL(index_type) != index_type)
+ TYPE_CANONICAL(array_type) =
+ build_array_type(TYPE_CANONICAL(element_type_tree),
+ TYPE_CANONICAL(index_type));
+
+ return array_type;
+}
+
+// Fill in the fields for a slice type. This is used for named slice
+// types.
+
+tree
+Array_type::fill_in_slice_tree(Gogo* gogo, tree struct_type)
+{
+ go_assert(this->length_ == NULL);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = TYPE_FIELDS(struct_type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ go_assert(POINTER_TYPE_P(TREE_TYPE(field))
+ && TREE_TYPE(TREE_TYPE(field)) == void_type_node);
+ TREE_TYPE(field) = build_pointer_type(element_type_tree);
+
+ return struct_type;
+}
+
+// Return an initializer for an array type.
+
+tree
+Array_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->length_ == NULL)
+ {
+ // Open array.
+
+ if (is_clear)
+ return NULL;
+
+ go_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init,
+ NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ else
+ {
+ // Fixed array.
+
+ tree value = this->element_type_->get_init_tree(gogo, is_clear);
+ if (value == NULL)
+ return NULL;
+ if (value == error_mark_node)
+ return error_mark_node;
+
+ tree length_tree = this->get_length_tree(gogo);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+
+ length_tree = fold_convert(sizetype, length_tree);
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node,
+ fold_build2(MINUS_EXPR, sizetype,
+ length_tree, size_one_node));
+ tree ret = build_constructor_single(type_tree, range, value);
+ if (TREE_CONSTANT(value))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+}
+
+// Handle the builtin make function for a slice.
+
+tree
+Array_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ go_assert(this->length_ == NULL);
+
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree values_field = TYPE_FIELDS(type_tree);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(values_field)),
+ "__values") == 0);
+
+ tree count_field = DECL_CHAIN(values_field);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(count_field)),
+ "__count") == 0);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size_tree = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree value = this->element_type_->get_init_tree(gogo, true);
+ if (value == error_mark_node)
+ return error_mark_node;
+
+ // The first argument is the number of elements, the optional second
+ // argument is the capacity.
+ go_assert(args != NULL && args->size() >= 1 && args->size() <= 2);
+
+ tree length_tree = args->front()->get_tree(context);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(length_tree))
+ length_tree = save_expr(length_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(length_tree)))
+ length_tree = convert_to_integer(TREE_TYPE(count_field), length_tree);
+
+ tree bad_index = Expression::check_bounds(length_tree,
+ TREE_TYPE(count_field),
+ NULL_TREE, location);
+
+ length_tree = fold_convert_loc(location, TREE_TYPE(count_field), length_tree);
+ tree capacity_tree;
+ if (args->size() == 1)
+ capacity_tree = length_tree;
+ else
+ {
+ capacity_tree = args->back()->get_tree(context);
+ if (capacity_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(capacity_tree))
+ capacity_tree = save_expr(capacity_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(capacity_tree)))
+ capacity_tree = convert_to_integer(TREE_TYPE(count_field),
+ capacity_tree);
+
+ bad_index = Expression::check_bounds(capacity_tree,
+ TREE_TYPE(count_field),
+ bad_index, location);
+
+ tree chktype = (((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ > TYPE_SIZE(TREE_TYPE(length_tree)))
+ || ((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ == TYPE_SIZE(TREE_TYPE(length_tree)))
+ && TYPE_UNSIGNED(TREE_TYPE(capacity_tree))))
+ ? TREE_TYPE(capacity_tree)
+ : TREE_TYPE(length_tree));
+ tree chk = fold_build2_loc(location, LT_EXPR, boolean_type_node,
+ fold_convert_loc(location, chktype,
+ capacity_tree),
+ fold_convert_loc(location, chktype,
+ length_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ capacity_tree = fold_convert_loc(location, TREE_TYPE(count_field),
+ capacity_tree);
+ }
+
+ tree size_tree = fold_build2_loc(location, MULT_EXPR, sizetype,
+ element_size_tree,
+ fold_convert_loc(location, sizetype,
+ capacity_tree));
+
+ tree chk = fold_build2_loc(location, TRUTH_AND_EXPR, boolean_type_node,
+ fold_build2_loc(location, GT_EXPR,
+ boolean_type_node,
+ fold_convert_loc(location,
+ sizetype,
+ capacity_tree),
+ size_zero_node),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ size_tree, element_size_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ tree space = context->gogo()->allocate_memory(this->element_type_,
+ size_tree, location);
+
+ if (value != NULL_TREE)
+ space = save_expr(space);
+
+ space = fold_convert(TREE_TYPE(values_field), space);
+
+ if (bad_index != NULL_TREE && bad_index != boolean_false_node)
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS,
+ location);
+ space = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ space);
+ }
+
+ tree constructor = gogo->slice_constructor(type_tree, space, length_tree,
+ capacity_tree);
+
+ if (value == NULL_TREE)
+ {
+ // The array contents are zero initialized.
+ return constructor;
+ }
+
+ // The elements must be initialized.
+
+ tree max = fold_build2_loc(location, MINUS_EXPR, TREE_TYPE(count_field),
+ capacity_tree,
+ fold_convert_loc(location, TREE_TYPE(count_field),
+ integer_one_node));
+
+ tree array_type = build_array_type(element_type_tree,
+ build_index_type(max));
+
+ tree value_pointer = fold_convert_loc(location,
+ build_pointer_type(array_type),
+ space);
+
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node, max);
+ tree space_init = build_constructor_single(array_type, range, value);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(constructor),
+ build2(MODIFY_EXPR, void_type_node,
+ build_fold_indirect_ref(value_pointer),
+ space_init),
+ constructor);
+}
+
+// Return a tree for a pointer to the values in ARRAY.
+
+tree
+Array_type::value_pointer_tree(Gogo*, tree array) const
+{
+ tree ret;
+ if (this->length() != NULL)
+ {
+ // Fixed array.
+ ret = fold_convert(build_pointer_type(TREE_TYPE(TREE_TYPE(array))),
+ build_fold_addr_expr(array));
+ }
+ else
+ {
+ // Open array.
+ tree field = TYPE_FIELDS(TREE_TYPE(array));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ ret = fold_build3(COMPONENT_REF, TREE_TYPE(field), array, field,
+ NULL_TREE);
+ }
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the length of the array ARRAY which has this
+// type.
+
+tree
+Array_type::length_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ {
+ if (TREE_CODE(array) == SAVE_EXPR)
+ return fold_convert(integer_type_node, this->get_length_tree(gogo));
+ else
+ return omit_one_operand(integer_type_node,
+ this->get_length_tree(gogo), array);
+ }
+
+ // This is an open array. We need to read the length field.
+
+ tree type = TREE_TYPE(array);
+ go_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(type));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+
+ tree ret = build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the capacity of the array ARRAY which has this
+// type.
+
+tree
+Array_type::capacity_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ return omit_one_operand(sizetype, this->get_length_tree(gogo), array);
+
+ // This is an open array. We need to read the capacity field.
+
+ tree type = TREE_TYPE(array);
+ go_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(DECL_CHAIN(TYPE_FIELDS(type)));
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+}
+
+// Export.
+
+void
+Array_type::do_export(Export* exp) const
+{
+ exp->write_c_string("[");
+ if (this->length_ != NULL)
+ this->length_->export_expression(exp);
+ exp->write_c_string("] ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Array_type*
+Array_type::do_import(Import* imp)
+{
+ imp->require_c_string("[");
+ Expression* length;
+ if (imp->peek_char() == ']')
+ length = NULL;
+ else
+ length = Expression::import_expression(imp);
+ imp->require_c_string("] ");
+ Type* element_type = imp->read_type();
+ return Type::make_array_type(element_type, length);
+}
+
+// The type of an array type descriptor.
+
+Type*
+Array_type::make_array_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "len", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ArrayType", sf);
+ }
+
+ return ret;
+}
+
+// The type of an slice type descriptor.
+
+Type*
+Array_type::make_slice_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("SliceType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an array/slice type.
+
+Expression*
+Array_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->length_ != NULL)
+ return this->array_type_descriptor(gogo, name);
+ else
+ return this->slice_type_descriptor(gogo, name);
+}
+
+// Build a type descriptor for an array type.
+
+Expression*
+Array_type::array_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* atdt = Array_type::make_array_type_descriptor_type();
+
+ const Struct_field_list* fields = atdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_ARRAY,
+ name, NULL, true));
+
+ ++p;
+ go_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "len");
+ vals->push_back(Expression::make_cast(p->type(), this->length_, bloc));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(atdt, vals, bloc);
+}
+
+// Build a type descriptor for a slice type.
+
+Expression*
+Array_type::slice_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Array_type::make_slice_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_SLICE,
+ name, NULL, true));
+
+ ++p;
+ go_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Array_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('[');
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array length is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back(']');
+
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Array_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('A');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array size is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back('e');
+}
+
+// Make an array type.
+
+Array_type*
+Type::make_array_type(Type* element_type, Expression* length)
+{
+ return new Array_type(element_type, length);
+}
+
+// Class Map_type.
+
+// Traversal.
+
+int
+Map_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->key_type_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->val_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the map type is OK.
+
+bool
+Map_type::do_verify()
+{
+ if (this->key_type_->struct_type() != NULL
+ || this->key_type_->array_type() != NULL)
+ {
+ error_at(this->location_, "invalid map key type");
+ return false;
+ }
+ return true;
+}
+
+// Whether two map types are identical.
+
+bool
+Map_type::is_identical(const Map_type* t, bool errors_are_identical) const
+{
+ return (Type::are_identical(this->key_type(), t->key_type(),
+ errors_are_identical, NULL)
+ && Type::are_identical(this->val_type(), t->val_type(),
+ errors_are_identical, NULL));
+}
+
+// Hash code.
+
+unsigned int
+Map_type::do_hash_for_method(Gogo* gogo) const
+{
+ return (this->key_type_->hash_for_method(gogo)
+ + this->val_type_->hash_for_method(gogo)
+ + 2);
+}
+
+// Check that a call to the builtin make function is valid. For a map
+// the optional argument is the number of spaces to preallocate for
+// values.
+
+bool
+Map_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(), _("bad size when making map"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making map");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Get a tree for a map type. A map type is represented as a pointer
+// to a struct. The struct is __go_map in libgo/map.h.
+
+tree
+Map_type::do_get_tree(Gogo* gogo)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree struct_type = make_node(RECORD_TYPE);
+
+ tree map_descriptor_type = gogo->map_descriptor_type();
+ tree const_map_descriptor_type =
+ build_qualified_type(map_descriptor_type, TYPE_QUAL_CONST);
+ tree name = get_identifier("__descriptor");
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(const_map_descriptor_type));
+ DECL_CONTEXT(field) = struct_type;
+ TYPE_FIELDS(struct_type) = field;
+ tree last_field = field;
+
+ name = get_identifier("__element_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__bucket_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__buckets");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(ptr_type_node));
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+
+ layout_type(struct_type);
+
+ // Give the struct a name for better debugging info.
+ name = get_identifier("__go_map");
+ tree type_decl = build_decl(BUILTINS_LOCATION, TYPE_DECL, name,
+ struct_type);
+ DECL_ARTIFICIAL(type_decl) = 1;
+ TYPE_NAME(struct_type) = type_decl;
+ go_preserve_from_gc(type_decl);
+ rest_of_decl_compilation(type_decl, 1, 0);
+
+ type_tree = build_pointer_type(struct_type);
+ go_preserve_from_gc(type_tree);
+ }
+
+ return type_tree;
+}
+
+// Initialize a map.
+
+tree
+Map_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Return an expression for a newly allocated map.
+
+tree
+Map_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ tree map_type = this->get_tree(context->gogo());
+
+ static tree new_map_fndecl;
+ tree ret = Gogo::call_builtin(&new_map_fndecl,
+ location,
+ "__go_new_map",
+ 2,
+ map_type,
+ TREE_TYPE(TYPE_FIELDS(TREE_TYPE(map_type))),
+ context->gogo()->map_descriptor(this),
+ sizetype,
+ expr_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_map_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// The type of a map type descriptor.
+
+Type*
+Map_type::make_map_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "key", ptdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("MapType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Map_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* mtdt = Map_type::make_map_type_descriptor_type();
+
+ const Struct_field_list* fields = mtdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_MAP,
+ name, NULL, true));
+
+ ++p;
+ go_assert(p->field_name() == "key");
+ vals->push_back(Expression::make_type_descriptor(this->key_type_, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->val_type_, bloc));
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(mtdt, vals, bloc);
+}
+
+// Reflection string for a map.
+
+void
+Map_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("map[");
+ this->append_reflection(this->key_type_, gogo, ret);
+ ret->append("] ");
+ this->append_reflection(this->val_type_, gogo, ret);
+}
+
+// Mangled name for a map.
+
+void
+Map_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('M');
+ this->append_mangled_name(this->key_type_, gogo, ret);
+ ret->append("__");
+ this->append_mangled_name(this->val_type_, gogo, ret);
+}
+
+// Export a map type.
+
+void
+Map_type::do_export(Export* exp) const
+{
+ exp->write_c_string("map [");
+ exp->write_type(this->key_type_);
+ exp->write_c_string("] ");
+ exp->write_type(this->val_type_);
+}
+
+// Import a map type.
+
+Map_type*
+Map_type::do_import(Import* imp)
+{
+ imp->require_c_string("map [");
+ Type* key_type = imp->read_type();
+ imp->require_c_string("] ");
+ Type* val_type = imp->read_type();
+ return Type::make_map_type(key_type, val_type, imp->location());
+}
+
+// Make a map type.
+
+Map_type*
+Type::make_map_type(Type* key_type, Type* val_type, source_location location)
+{
+ return new Map_type(key_type, val_type, location);
+}
+
+// Class Channel_type.
+
+// Hash code.
+
+unsigned int
+Channel_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->may_send_)
+ ret += 1;
+ if (this->may_receive_)
+ ret += 2;
+ if (this->element_type_ != NULL)
+ ret += this->element_type_->hash_for_method(gogo) << 2;
+ return ret << 3;
+}
+
+// Whether this type is the same as T.
+
+bool
+Channel_type::is_identical(const Channel_type* t,
+ bool errors_are_identical) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(),
+ errors_are_identical, NULL))
+ return false;
+ return (this->may_send_ == t->may_send_
+ && this->may_receive_ == t->may_receive_);
+}
+
+// Check whether the parameters for a call to the builtin function
+// make are OK for a channel. A channel can take an optional single
+// parameter which is the buffer size.
+
+bool
+Channel_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad buffer size when making channel"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making channel");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Return the tree for a channel type. A channel is a pointer to a
+// __go_channel struct. The __go_channel struct is defined in
+// libgo/runtime/channel.h.
+
+tree
+Channel_type::do_get_tree(Gogo*)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree ret = make_node(RECORD_TYPE);
+ TYPE_NAME(ret) = get_identifier("__go_channel");
+ TYPE_STUB_DECL(ret) = build_decl(BUILTINS_LOCATION, TYPE_DECL, NULL_TREE,
+ ret);
+ type_tree = build_pointer_type(ret);
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Initialize a channel variable.
+
+tree
+Channel_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Handle the builtin function make for a channel.
+
+tree
+Channel_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree channel_type = this->get_tree(gogo);
+
+ tree element_tree = this->element_type_->get_tree(gogo);
+ tree element_size_tree = size_in_bytes(element_tree);
+
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ static tree new_channel_fndecl;
+ tree ret = Gogo::call_builtin(&new_channel_fndecl,
+ location,
+ "__go_new_channel",
+ 2,
+ channel_type,
+ sizetype,
+ element_size_tree,
+ sizetype,
+ expr_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_channel_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Build a type descriptor for a channel type.
+
+Type*
+Channel_type::make_chan_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "dir", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ChanType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Channel_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ctdt = Channel_type::make_chan_type_descriptor_type();
+
+ const Struct_field_list* fields = ctdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ go_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_CHAN,
+ name, NULL, true));
+
+ ++p;
+ go_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ go_assert(p->field_name() == "dir");
+ // These bits must match the ones in libgo/runtime/go-type.h.
+ int val = 0;
+ if (this->may_receive_)
+ val |= 1;
+ if (this->may_send_)
+ val |= 2;
+ mpz_t iv;
+ mpz_init_set_ui(iv, val);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+ mpz_clear(iv);
+
+ ++p;
+ go_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ctdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Channel_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (!this->may_send_)
+ ret->append("<-");
+ ret->append("chan");
+ if (!this->may_receive_)
+ ret->append("<-");
+ ret->push_back(' ');
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Channel_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('C');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->may_send_)
+ ret->push_back('s');
+ if (this->may_receive_)
+ ret->push_back('r');
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Channel_type::do_export(Export* exp) const
+{
+ exp->write_c_string("chan ");
+ if (this->may_send_ && !this->may_receive_)
+ exp->write_c_string("-< ");
+ else if (this->may_receive_ && !this->may_send_)
+ exp->write_c_string("<- ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Channel_type*
+Channel_type::do_import(Import* imp)
+{
+ imp->require_c_string("chan ");
+
+ bool may_send;
+ bool may_receive;
+ if (imp->match_c_string("-< "))
+ {
+ imp->advance(3);
+ may_send = true;
+ may_receive = false;
+ }
+ else if (imp->match_c_string("<- "))
+ {
+ imp->advance(3);
+ may_receive = true;
+ may_send = false;
+ }
+ else
+ {
+ may_send = true;
+ may_receive = true;
+ }
+
+ Type* element_type = imp->read_type();
+
+ return Type::make_channel_type(may_send, may_receive, element_type);
+}
+
+// Make a new channel type.
+
+Channel_type*
+Type::make_channel_type(bool send, bool receive, Type* element_type)
+{
+ return new Channel_type(send, receive, element_type);
+}
+
+// Class Interface_type.
+
+// Traversal.
+
+int
+Interface_type::do_traverse(Traverse* traverse)
+{
+ if (this->methods_ == NULL)
+ return TRAVERSE_CONTINUE;
+ return this->methods_->traverse(traverse);
+}
+
+// Finalize the methods. This handles interface inheritance.
+
+void
+Interface_type::finalize_methods()
+{
+ if (this->methods_ == NULL)
+ return;
+ std::vector<Named_type*> seen;
+ bool is_recursive = false;
+ size_t from = 0;
+ size_t to = 0;
+ while (from < this->methods_->size())
+ {
+ const Typed_identifier* p = &this->methods_->at(from);
+ if (!p->name().empty())
+ {
+ size_t i;
+ for (i = 0; i < to; ++i)
+ {
+ if (this->methods_->at(i).name() == p->name())
+ {
+ error_at(p->location(), "duplicate method %qs",
+ Gogo::message_name(p->name()).c_str());
+ break;
+ }
+ }
+ if (i == to)
+ {
+ if (from != to)
+ this->methods_->set(to, *p);
+ ++to;
+ }
+ ++from;
+ continue;
+ }
+
+ Interface_type* it = p->type()->interface_type();
+ if (it == NULL)
+ {
+ error_at(p->location(), "interface contains embedded non-interface");
+ ++from;
+ continue;
+ }
+ if (it == this)
+ {
+ if (!is_recursive)
+ {
+ error_at(p->location(), "invalid recursive interface");
+ is_recursive = true;
+ }
+ ++from;
+ continue;
+ }
+
+ Named_type* nt = p->type()->named_type();
+ if (nt != NULL)
+ {
+ std::vector<Named_type*>::const_iterator q;
+ for (q = seen.begin(); q != seen.end(); ++q)
+ {
+ if (*q == nt)
+ {
+ error_at(p->location(), "inherited interface loop");
+ break;
+ }
+ }
+ if (q != seen.end())
+ {
+ ++from;
+ continue;
+ }
+ seen.push_back(nt);
+ }
+
+ const Typed_identifier_list* methods = it->methods();
+ if (methods == NULL)
+ {
+ ++from;
+ continue;
+ }
+ for (Typed_identifier_list::const_iterator q = methods->begin();
+ q != methods->end();
+ ++q)
+ {
+ if (q->name().empty())
+ {
+ if (q->type()->forwarded() == p->type()->forwarded())
+ error_at(p->location(), "interface inheritance loop");
+ else
+ {
+ size_t i;
+ for (i = from + 1; i < this->methods_->size(); ++i)
+ {
+ const Typed_identifier* r = &this->methods_->at(i);
+ if (r->name().empty()
+ && r->type()->forwarded() == q->type()->forwarded())
+ {
+ error_at(p->location(),
+ "inherited interface listed twice");
+ break;
+ }
+ }
+ if (i == this->methods_->size())
+ this->methods_->push_back(Typed_identifier(q->name(),
+ q->type(),
+ p->location()));
+ }
+ }
+ else if (this->find_method(q->name()) == NULL)
+ this->methods_->push_back(Typed_identifier(q->name(), q->type(),
+ p->location()));
+ else
+ {
+ if (!is_recursive)
+ error_at(p->location(), "inherited method %qs is ambiguous",
+ Gogo::message_name(q->name()).c_str());
+ }
+ }
+ ++from;
+ }
+ if (to == 0)
+ {
+ delete this->methods_;
+ this->methods_ = NULL;
+ }
+ else
+ {
+ this->methods_->resize(to);
+ this->methods_->sort_by_name();
+ }
+}
+
+// Return the method NAME, or NULL.
+
+const Typed_identifier*
+Interface_type::find_method(const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return NULL;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ if (p->name() == name)
+ return &*p;
+ return NULL;
+}
+
+// Return the method index.
+
+size_t
+Interface_type::method_index(const std::string& name) const
+{
+ go_assert(this->methods_ != NULL);
+ size_t ret = 0;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p, ++ret)
+ if (p->name() == name)
+ return ret;
+ go_unreachable();
+}
+
+// Return whether NAME is an unexported method, for better error
+// reporting.
+
+bool
+Interface_type::is_unexported_method(Gogo* gogo, const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return false;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ const std::string& method_name(p->name());
+ if (Gogo::is_hidden_name(method_name)
+ && name == Gogo::unpack_hidden_name(method_name)
+ && gogo->pack_hidden_name(name, false) != method_name)
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical with T.
+
+bool
+Interface_type::is_identical(const Interface_type* t,
+ bool errors_are_identical) const
+{
+ // We require the same methods with the same types. The methods
+ // have already been sorted.
+ if (this->methods() == NULL || t->methods() == NULL)
+ return this->methods() == t->methods();
+
+ Typed_identifier_list::const_iterator p1 = this->methods()->begin();
+ for (Typed_identifier_list::const_iterator p2 = t->methods()->begin();
+ p2 != t->methods()->end();
+ ++p1, ++p2)
+ {
+ if (p1 == this->methods()->end())
+ return false;
+ if (p1->name() != p2->name()
+ || !Type::are_identical(p1->type(), p2->type(),
+ errors_are_identical, NULL))
+ return false;
+ }
+ if (p1 != this->methods()->end())
+ return false;
+ return true;
+}
+
+// Whether we can assign the interface type T to this type. The types
+// are known to not be identical. An interface assignment is only
+// permitted if T is known to implement all methods in THIS.
+// Otherwise a type guard is required.
+
+bool
+Interface_type::is_compatible_for_assign(const Interface_type* t,
+ std::string* reason) const
+{
+ if (this->methods() == NULL)
+ return true;
+ for (Typed_identifier_list::const_iterator p = this->methods()->begin();
+ p != this->methods()->end();
+ ++p)
+ {
+ const Typed_identifier* m = t->find_method(p->name());
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ char buf[200];
+ snprintf(buf, sizeof buf,
+ _("need explicit conversion; missing method %s%s%s"),
+ open_quote, Gogo::message_name(p->name()).c_str(),
+ close_quote);
+ reason->assign(buf);
+ }
+ return false;
+ }
+
+ std::string subreason;
+ if (!Type::are_identical(p->type(), m->type(), true, &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Interface_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ ret = Type::hash_string(p->name(), ret);
+ ret += p->type()->hash_for_method(gogo);
+ ret <<= 1;
+ }
+ }
+ return ret;
+}
+
+// Return true if T implements the interface. If it does not, and
+// REASON is not NULL, set *REASON to a useful error message.
+
+bool
+Interface_type::implements_interface(const Type* t, std::string* reason) const
+{
+ if (this->methods_ == NULL)
+ return true;
+
+ bool is_pointer = false;
+ const Named_type* nt = t->named_type();
+ const Struct_type* st = t->struct_type();
+ // If we start with a named type, we don't dereference it to find
+ // methods.
+ if (nt == NULL)
+ {
+ const Type* pt = t->points_to();
+ if (pt != NULL)
+ {
+ // If T is a pointer to a named type, then we need to look at
+ // the type to which it points.
+ is_pointer = true;
+ nt = pt->named_type();
+ st = pt->struct_type();
+ }
+ }
+
+ // If we have a named type, get the methods from it rather than from
+ // any struct type.
+ if (nt != NULL)
+ st = NULL;
+
+ // Only named and struct types have methods.
+ if (nt == NULL && st == NULL)
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ if (nt != NULL ? !nt->has_any_methods() : !st->has_any_methods())
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ bool is_ambiguous = false;
+ Method* m = (nt != NULL
+ ? nt->method_function(p->name(), &is_ambiguous)
+ : st->method_function(p->name(), &is_ambiguous));
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = n.length() + 100;
+ char* buf = new char[len];
+ if (is_ambiguous)
+ snprintf(buf, len, _("ambiguous method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len, _("missing method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ Function_type *p_fn_type = p->type()->function_type();
+ Function_type* m_fn_type = m->type()->function_type();
+ go_assert(p_fn_type != NULL && m_fn_type != NULL);
+ std::string subreason;
+ if (!p_fn_type->is_identical(m_fn_type, true, true, &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ if (!is_pointer && !m->is_value_method())
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length();
+ char* buf = new char[len];
+ snprintf(buf, len, _("method %s%s%s requires a pointer"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Return a tree for an interface type. An interface is a pointer to
+// a struct. The struct has three fields. The first field is a
+// pointer to the type descriptor for the dynamic type of the object.
+// The second field is a pointer to a table of methods for the
+// interface to be used with the object. The third field is the value
+// of the object itself.
+
+tree
+Interface_type::do_get_tree(Gogo* gogo)
+{
+ if (this->methods_ == NULL)
+ return Interface_type::empty_type_tree(gogo);
+ else
+ {
+ tree t = Interface_type::non_empty_type_tree(this->location_);
+ return this->fill_in_tree(gogo, t);
+ }
+}
+
+// Return a singleton struct for an empty interface type. We use the
+// same type for all empty interfaces. This lets us assign them to
+// each other directly without triggering GIMPLE type errors.
+
+tree
+Interface_type::empty_type_tree(Gogo* gogo)
+{
+ static tree empty_interface;
+ if (empty_interface != NULL_TREE)
+ return empty_interface;
+
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ return Gogo::builtin_struct(&empty_interface, "__go_empty_interface",
+ NULL_TREE, 2,
+ "__type_descriptor",
+ dtype,
+ "__object",
+ ptr_type_node);
+}
+
+// Return a new struct for a non-empty interface type. The correct
+// values are filled in by fill_in_tree.
+
+tree
+Interface_type::non_empty_type_tree(source_location location)
+{
+ tree ret = make_node(RECORD_TYPE);
+
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+
+ tree name_tree = get_identifier("__methods");
+ tree field = build_decl(location, FIELD_DECL, name_tree, ptr_type_node);
+ DECL_CONTEXT(field) = ret;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+
+ name_tree = get_identifier("__object");
+ field = build_decl(location, FIELD_DECL, name_tree, ptr_type_node);
+ DECL_CONTEXT(field) = ret;
+ *pp = field;
+
+ TYPE_FIELDS(ret) = field_trees;
+
+ layout_type(ret);
+
+ return ret;
+}
+
+// Fill in the tree for an interface type. This is used for named
+// interface types.
+
+tree
+Interface_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ go_assert(this->methods_ != NULL);
+
+ // Build the type of the table of methods.
+
+ tree method_table = make_node(RECORD_TYPE);
+
+ // The first field is a pointer to the type descriptor.
+ tree name_tree = get_identifier("__type_descriptor");
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree, dtype);
+ DECL_CONTEXT(field) = method_table;
+ TYPE_FIELDS(method_table) = field;
+
+ std::string last_name = "";
+ tree* pp = &DECL_CHAIN(field);
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->name());
+ name_tree = get_identifier_with_length(name.data(), name.length());
+ tree field_type = p->type()->get_tree(gogo);
+ if (field_type == error_mark_node)
+ return error_mark_node;
+ field = build_decl(this->location_, FIELD_DECL, name_tree, field_type);
+ DECL_CONTEXT(field) = method_table;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ // Sanity check: the names should be sorted.
+ go_assert(p->name() > last_name);
+ last_name = p->name();
+ }
+ layout_type(method_table);
+
+ // Update the type of the __methods field from a generic pointer to
+ // a pointer to the method table.
+ field = TYPE_FIELDS(type);
+ go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods") == 0);
+
+ TREE_TYPE(field) = build_pointer_type(method_table);
+
+ return type;
+}
+
+// Initialization value.
+
+tree
+Interface_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of an interface type descriptor.
+
+Type*
+Interface_type::make_interface_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sm =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt);
+
+ Type* nsm = Type::make_builtin_named_type("imethod", sm);
+
+ Type* slice_nsm = Type::make_array_type(nsm, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "methods", slice_nsm);
+
+ ret = Type::make_builtin_named_type("InterfaceType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an interface type.
+
+Expression*
+Interface_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* itdt = Interface_type::make_interface_type_descriptor_type();
+
+ const Struct_field_list* ifields = itdt->struct_type()->fields();
+
+ Expression_list* ivals = new Expression_list();
+ ivals->reserve(2);
+
+ Struct_field_list::const_iterator pif = ifields->begin();
+ go_assert(pif->field_name() == "commonType");
+ ivals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_INTERFACE,
+ name, NULL, true));
+
+ ++pif;
+ go_assert(pif->field_name() == "methods");
+
+ Expression_list* methods = new Expression_list();
+ if (this->methods_ != NULL && !this->methods_->empty())
+ {
+ Type* elemtype = pif->type()->array_type()->element_type();
+
+ methods->reserve(this->methods_->size());
+ for (Typed_identifier_list::const_iterator pm = this->methods_->begin();
+ pm != this->methods_->end();
+ ++pm)
+ {
+ const Struct_field_list* mfields = elemtype->struct_type()->fields();
+
+ Expression_list* mvals = new Expression_list();
+ mvals->reserve(3);
+
+ Struct_field_list::const_iterator pmf = mfields->begin();
+ go_assert(pmf->field_name() == "name");
+ std::string s = Gogo::unpack_hidden_name(pm->name());
+ Expression* e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+
+ ++pmf;
+ go_assert(pmf->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pm->name()))
+ mvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Gogo::hidden_name_prefix(pm->name());
+ e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+ }
+
+ ++pmf;
+ go_assert(pmf->field_name() == "typ");
+ mvals->push_back(Expression::make_type_descriptor(pm->type(), bloc));
+
+ ++pmf;
+ go_assert(pmf == mfields->end());
+
+ e = Expression::make_struct_composite_literal(elemtype, mvals,
+ bloc);
+ methods->push_back(e);
+ }
+ }
+
+ ivals->push_back(Expression::make_slice_composite_literal(pif->type(),
+ methods, bloc));
+
+ ++pif;
+ go_assert(pif == ifields->end());
+
+ return Expression::make_struct_composite_literal(itdt, ivals, bloc);
+}
+
+// Reflection string.
+
+void
+Interface_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("interface {");
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ if (p != this->methods_->begin())
+ ret->append(";");
+ ret->push_back(' ');
+ ret->append(Gogo::unpack_hidden_name(p->name()));
+ std::string sub = p->type()->reflection(gogo);
+ go_assert(sub.compare(0, 4, "func") == 0);
+ sub = sub.substr(4);
+ ret->append(sub);
+ }
+ }
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Interface_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('I');
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ std::string n = Gogo::unpack_hidden_name(p->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ this->append_mangled_name(p->type(), gogo, ret);
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Interface_type::do_export(Export* exp) const
+{
+ exp->write_c_string("interface { ");
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ exp->write_string(pm->name());
+ exp->write_c_string(" (");
+
+ const Function_type* fntype = pm->type()->function_type();
+
+ bool first = true;
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ for (Typed_identifier_list::const_iterator pp =
+ parameters->begin();
+ pp != parameters->end();
+ ++pp)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || pp + 1 != parameters->end())
+ exp->write_type(pp->type());
+ else
+ {
+ exp->write_c_string("...");
+ Type *pptype = pp->type();
+ exp->write_type(pptype->array_type()->element_type());
+ }
+ }
+ }
+
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p =
+ results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+
+ exp->write_c_string("; ");
+ }
+ }
+
+ exp->write_c_string("}");
+}
+
+// Import an interface type.
+
+Interface_type*
+Interface_type::do_import(Import* imp)
+{
+ imp->require_c_string("interface { ");
+
+ Typed_identifier_list* methods = new Typed_identifier_list;
+ while (imp->peek_char() != '}')
+ {
+ std::string name = imp->read_identifier();
+ imp->require_c_string(" (");
+
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list;
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ go_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list;
+ imp->advance(1);
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters,
+ results,
+ imp->location());
+ if (is_varargs)
+ fntype->set_is_varargs();
+ methods->push_back(Typed_identifier(name, fntype, imp->location()));
+
+ imp->require_c_string("; ");
+ }
+
+ imp->require_c_string("}");
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ return Type::make_interface_type(methods, imp->location());
+}
+
+// Make an interface type.
+
+Interface_type*
+Type::make_interface_type(Typed_identifier_list* methods,
+ source_location location)
+{
+ return new Interface_type(methods, location);
+}
+
+// Class Method.
+
+// Bind a method to an object.
+
+Expression*
+Method::bind_method(Expression* expr, source_location location) const
+{
+ if (this->stub_ == NULL)
+ {
+ // When there is no stub object, the binding is determined by
+ // the child class.
+ return this->do_bind_method(expr, location);
+ }
+
+ Expression* func = Expression::make_func_reference(this->stub_, NULL,
+ location);
+ return Expression::make_bound_method(expr, func, location);
+}
+
+// Return the named object associated with a method. This may only be
+// called after methods are finalized.
+
+Named_object*
+Method::named_object() const
+{
+ if (this->stub_ != NULL)
+ return this->stub_;
+ return this->do_named_object();
+}
+
+// Class Named_method.
+
+// The type of the method.
+
+Function_type*
+Named_method::do_type() const
+{
+ if (this->named_object_->is_function())
+ return this->named_object_->func_value()->type();
+ else if (this->named_object_->is_function_declaration())
+ return this->named_object_->func_declaration_value()->type();
+ else
+ go_unreachable();
+}
+
+// Return the location of the method receiver.
+
+source_location
+Named_method::do_receiver_location() const
+{
+ return this->do_type()->receiver()->location();
+}
+
+// Bind a method to an object.
+
+Expression*
+Named_method::do_bind_method(Expression* expr, source_location location) const
+{
+ Expression* func = Expression::make_func_reference(this->named_object_, NULL,
+ location);
+ Bound_method_expression* bme = Expression::make_bound_method(expr, func,
+ location);
+ // If this is not a local method, and it does not use a stub, then
+ // the real method expects a different type. We need to cast the
+ // first argument.
+ if (this->depth() > 0 && !this->needs_stub_method())
+ {
+ Function_type* ftype = this->do_type();
+ go_assert(ftype->is_method());
+ Type* frtype = ftype->receiver()->type();
+ bme->set_first_argument_type(frtype);
+ }
+ return bme;
+}
+
+// Class Interface_method.
+
+// Bind a method to an object.
+
+Expression*
+Interface_method::do_bind_method(Expression* expr,
+ source_location location) const
+{
+ return Expression::make_interface_field_reference(expr, this->name_,
+ location);
+}
+
+// Class Methods.
+
+// Insert a new method. Return true if it was inserted, false
+// otherwise.
+
+bool
+Methods::insert(const std::string& name, Method* m)
+{
+ std::pair<Method_map::iterator, bool> ins =
+ this->methods_.insert(std::make_pair(name, m));
+ if (ins.second)
+ return true;
+ else
+ {
+ Method* old_method = ins.first->second;
+ if (m->depth() < old_method->depth())
+ {
+ delete old_method;
+ ins.first->second = m;
+ return true;
+ }
+ else
+ {
+ if (m->depth() == old_method->depth())
+ old_method->set_is_ambiguous();
+ return false;
+ }
+ }
+}
+
+// Return the number of unambiguous methods.
+
+size_t
+Methods::count() const
+{
+ size_t ret = 0;
+ for (Method_map::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ if (!p->second->is_ambiguous())
+ ++ret;
+ return ret;
+}
+
+// Class Named_type.
+
+// Return the name of the type.
+
+const std::string&
+Named_type::name() const
+{
+ return this->named_object_->name();
+}
+
+// Return the name of the type to use in an error message.
+
+std::string
+Named_type::message_name() const
+{
+ return this->named_object_->message_name();
+}
+
+// Return the base type for this type. We have to be careful about
+// circular type definitions, which are invalid but may be seen here.
+
+Type*
+Named_type::named_base()
+{
+ if (this->seen_ > 0)
+ return this;
+ ++this->seen_;
+ Type* ret = this->type_->base();
+ --this->seen_;
+ return ret;
+}
+
+const Type*
+Named_type::named_base() const
+{
+ if (this->seen_ > 0)
+ return this;
+ ++this->seen_;
+ const Type* ret = this->type_->base();
+ --this->seen_;
+ return ret;
+}
+
+// Return whether this is an error type. We have to be careful about
+// circular type definitions, which are invalid but may be seen here.
+
+bool
+Named_type::is_named_error_type() const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->is_error_type();
+ --this->seen_;
+ return ret;
+}
+
+// Add a method to this type.
+
+Named_object*
+Named_type::add_method(const std::string& name, Function* function)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function(name, NULL, function);
+}
+
+// Add a method declaration to this type.
+
+Named_object*
+Named_type::add_method_declaration(const std::string& name, Package* package,
+ Function_type* type,
+ source_location location)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function_declaration(name, package, type,
+ location);
+}
+
+// Add an existing method to this type.
+
+void
+Named_type::add_existing_method(Named_object* no)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ this->local_methods_->add_named_object(no);
+}
+
+// Look for a local method NAME, and returns its named object, or NULL
+// if not there.
+
+Named_object*
+Named_type::find_local_method(const std::string& name) const
+{
+ if (this->local_methods_ == NULL)
+ return NULL;
+ return this->local_methods_->lookup(name);
+}
+
+// Return whether NAME is an unexported field or method, for better
+// error reporting.
+
+bool
+Named_type::is_unexported_local_method(Gogo* gogo,
+ const std::string& name) const
+{
+ Bindings* methods = this->local_methods_;
+ if (methods != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->first)
+ && name == Gogo::unpack_hidden_name(p->first)
+ && gogo->pack_hidden_name(name, false) != p->first)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Build the complete list of methods for this type, which means
+// recursively including all methods for anonymous fields. Create all
+// stub methods.
+
+void
+Named_type::finalize_methods(Gogo* gogo)
+{
+ if (this->all_methods_ != NULL)
+ return;
+
+ if (this->local_methods_ != NULL
+ && (this->points_to() != NULL || this->interface_type() != NULL))
+ {
+ const Bindings* lm = this->local_methods_;
+ for (Bindings::const_declarations_iterator p = lm->begin_declarations();
+ p != lm->end_declarations();
+ ++p)
+ error_at(p->second->location(),
+ "invalid pointer or interface receiver type");
+ delete this->local_methods_;
+ this->local_methods_ = NULL;
+ return;
+ }
+
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Named_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Return a pointer to the interface method table for this type for
+// the interface INTERFACE. IS_POINTER is true if this is for a
+// pointer to THIS.
+
+tree
+Named_type::interface_method_table(Gogo* gogo, const Interface_type* interface,
+ bool is_pointer)
+{
+ go_assert(!interface->is_empty());
+
+ Interface_method_tables** pimt = (is_pointer
+ ? &this->interface_method_tables_
+ : &this->pointer_interface_method_tables_);
+
+ if (*pimt == NULL)
+ *pimt = new Interface_method_tables(5);
+
+ std::pair<const Interface_type*, tree> val(interface, NULL_TREE);
+ std::pair<Interface_method_tables::iterator, bool> ins = (*pimt)->insert(val);
+
+ if (ins.second)
+ {
+ // This is a new entry in the hash table.
+ go_assert(ins.first->second == NULL_TREE);
+ ins.first->second = gogo->interface_method_table_for_type(interface,
+ this,
+ is_pointer);
+ }
+
+ tree decl = ins.first->second;
+ if (decl == error_mark_node)
+ return error_mark_node;
+ go_assert(decl != NULL_TREE && TREE_CODE(decl) == VAR_DECL);
+ return build_fold_addr_expr(decl);
+}
+
+// Return whether a named type has any hidden fields.
+
+bool
+Named_type::named_type_has_hidden_fields(std::string* reason) const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->has_hidden_fields(this, reason);
+ --this->seen_;
+ return ret;
+}
+
+// Look for a use of a complete type within another type. This is
+// used to check that we don't try to use a type within itself.
+
+class Find_type_use : public Traverse
+{
+ public:
+ Find_type_use(Named_type* find_type)
+ : Traverse(traverse_types),
+ find_type_(find_type), found_(false)
+ { }
+
+ // Whether we found the type.
+ bool
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ type(Type*);
+
+ private:
+ // The type we are looking for.
+ Named_type* find_type_;
+ // Whether we found the type.
+ bool found_;
+};
+
+// Check for FIND_TYPE in TYPE.
+
+int
+Find_type_use::type(Type* type)
+{
+ if (type->named_type() != NULL && this->find_type_ == type->named_type())
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+
+ // It's OK if we see a reference to the type in any type which is
+ // essentially a pointer: a pointer, a slice, a function, a map, or
+ // a channel.
+ if (type->points_to() != NULL
+ || type->is_open_array_type()
+ || type->function_type() != NULL
+ || type->map_type() != NULL
+ || type->channel_type() != NULL)
+ return TRAVERSE_SKIP_COMPONENTS;
+
+ // For an interface, a reference to the type in a method type should
+ // be ignored, but we have to consider direct inheritance. When
+ // this is called, there may be cases of direct inheritance
+ // represented as a method with no name.
+ if (type->interface_type() != NULL)
+ {
+ const Typed_identifier_list* methods = type->interface_type()->methods();
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->name().empty())
+ {
+ if (Type::traverse(p->type(), this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ // Otherwise, FIND_TYPE_ depends on TYPE, in the sense that we need
+ // to convert TYPE to the backend representation before we convert
+ // FIND_TYPE_.
+ if (type->named_type() != NULL)
+ {
+ switch (type->base()->classification())
+ {
+ case Type::TYPE_ERROR:
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_STRING:
+ case Type::TYPE_NIL:
+ break;
+
+ case Type::TYPE_ARRAY:
+ case Type::TYPE_STRUCT:
+ this->find_type_->add_dependency(type->named_type());
+ break;
+
+ case Type::TYPE_VOID:
+ case Type::TYPE_SINK:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_CALL_MULTIPLE_RESULT:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ case Type::TYPE_INTERFACE:
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ default:
+ go_unreachable();
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that a named type does not refer to itself.
+
+bool
+Named_type::do_verify()
+{
+ Find_type_use find(this);
+ Type::traverse(this->type_, &find);
+ if (find.found())
+ {
+ error_at(this->location_, "invalid recursive type %qs",
+ this->message_name().c_str());
+ this->is_error_ = true;
+ return false;
+ }
+
+ // Check whether any of the local methods overloads an existing
+ // struct field or interface method. We don't need to check the
+ // list of methods against itself: that is handled by the Bindings
+ // code.
+ if (this->local_methods_ != NULL)
+ {
+ Struct_type* st = this->type_->struct_type();
+ bool found_dup = false;
+ if (st != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ this->local_methods_->begin_declarations();
+ p != this->local_methods_->end_declarations();
+ ++p)
+ {
+ const std::string& name(p->first);
+ if (st != NULL && st->find_local_field(name, NULL) != NULL)
+ {
+ error_at(p->second->location(),
+ "method %qs redeclares struct field name",
+ Gogo::message_name(name).c_str());
+ found_dup = true;
+ }
+ }
+ }
+ if (found_dup)
+ return false;
+ }
+
+ return true;
+}
+
+// Return whether this type is or contains a pointer.
+
+bool
+Named_type::do_has_pointer() const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->has_pointer();
+ --this->seen_;
+ return ret;
+}
+
+// Return a hash code. This is used for method lookup. We simply
+// hash on the name itself.
+
+unsigned int
+Named_type::do_hash_for_method(Gogo* gogo) const
+{
+ const std::string& name(this->named_object()->name());
+ unsigned int ret = Type::hash_string(name, 0);
+
+ // GOGO will be NULL here when called from Type_hash_identical.
+ // That is OK because that is only used for internal hash tables
+ // where we are going to be comparing named types for equality. In
+ // other cases, which are cases where the runtime is going to
+ // compare hash codes to see if the types are the same, we need to
+ // include the package prefix and name in the hash.
+ if (gogo != NULL && !Gogo::is_hidden_name(name) && !this->is_builtin())
+ {
+ const Package* package = this->named_object()->package();
+ if (package == NULL)
+ {
+ ret = Type::hash_string(gogo->unique_prefix(), ret);
+ ret = Type::hash_string(gogo->package_name(), ret);
+ }
+ else
+ {
+ ret = Type::hash_string(package->unique_prefix(), ret);
+ ret = Type::hash_string(package->name(), ret);
+ }
+ }
+
+ return ret;
+}
+
+// Convert a named type to the backend representation. In order to
+// get dependencies right, we fill in a dummy structure for this type,
+// then convert all the dependencies, then complete this type. When
+// this function is complete, the size of the type is known.
+
+void
+Named_type::convert(Gogo* gogo)
+{
+ if (this->is_error_ || this->is_converted_)
+ return;
+
+ this->create_placeholder(gogo);
+
+ // Convert all the dependencies. If they refer indirectly back to
+ // this type, they will pick up the intermediate tree we just
+ // created.
+ for (std::vector<Named_type*>::const_iterator p = this->dependencies_.begin();
+ p != this->dependencies_.end();
+ ++p)
+ (*p)->convert(gogo);
+
+ // Complete this type.
+ tree t = this->named_tree_;
+ Type* base = this->type_->base();
+ switch (base->classification())
+ {
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ break;
+
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ // The size of these types is already correct.
+ break;
+
+ case TYPE_STRUCT:
+ t = base->struct_type()->fill_in_tree(gogo, t);
+ break;
+
+ case TYPE_ARRAY:
+ if (!base->is_open_array_type())
+ t = base->array_type()->fill_in_array_tree(gogo, t);
+ break;
+
+ case TYPE_INTERFACE:
+ if (!base->interface_type()->is_empty())
+ t = base->interface_type()->fill_in_tree(gogo, t);
+ break;
+
+ case TYPE_ERROR:
+ return;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ go_unreachable();
+ }
+
+ this->named_tree_ = t;
+
+ if (t == error_mark_node)
+ this->is_error_ = true;
+ else
+ go_assert(TYPE_SIZE(t) != NULL_TREE);
+
+ this->is_converted_ = true;
+}
+
+// Create the placeholder for a named type. This is the first step in
+// converting to the backend representation.
+
+void
+Named_type::create_placeholder(Gogo* gogo)
+{
+ if (this->is_error_)
+ this->named_tree_ = error_mark_node;
+
+ if (this->named_tree_ != NULL_TREE)
+ return;
+
+ // Create the structure for this type. Note that because we call
+ // base() here, we don't attempt to represent a named type defined
+ // as another named type. Instead both named types will point to
+ // different base representations.
+ Type* base = this->type_->base();
+ tree t;
+ switch (base->classification())
+ {
+ case TYPE_ERROR:
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These are simple basic types, we can just create them
+ // directly.
+ t = Type::get_named_type_tree(gogo, base);
+ if (t == error_mark_node)
+ {
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+ }
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ // All maps and channels have the same type in GENERIC.
+ t = Type::get_named_type_tree(gogo, base);
+ if (t == error_mark_node)
+ {
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+ }
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ t = build_variant_type_copy(ptr_type_node);
+ break;
+
+ case TYPE_STRUCT:
+ t = make_node(RECORD_TYPE);
+ break;
+
+ case TYPE_ARRAY:
+ if (base->is_open_array_type())
+ t = gogo->slice_type_tree(void_type_node);
+ else
+ t = make_node(ARRAY_TYPE);
+ break;
+
+ case TYPE_INTERFACE:
+ if (base->interface_type()->is_empty())
+ {
+ t = Interface_type::empty_type_tree(gogo);
+ t = build_variant_type_copy(t);
+ }
+ else
+ {
+ source_location loc = base->interface_type()->location();
+ t = Interface_type::non_empty_type_tree(loc);
+ }
+ break;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ go_unreachable();
+ }
+
+ // Create the named type.
+
+ tree id = this->named_object_->get_id(gogo);
+ tree decl = build_decl(this->location_, TYPE_DECL, id, t);
+ TYPE_NAME(t) = decl;
+
+ this->named_tree_ = t;
+}
+
+// Get a tree for a named type.
+
+tree
+Named_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_error_)
+ return error_mark_node;
+
+ tree t = this->named_tree_;
+
+ // FIXME: GOGO can be NULL when called from go_type_for_size, which
+ // is only used for basic types.
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ {
+ // We have not completed converting named types. NAMED_TREE_ is
+ // a placeholder and we shouldn't do anything further.
+ if (t != NULL_TREE)
+ return t;
+
+ // We don't build dependencies for types whose sizes do not
+ // change or are not relevant, so we may see them here while
+ // converting types.
+ this->create_placeholder(gogo);
+ t = this->named_tree_;
+ go_assert(t != NULL_TREE);
+ return t;
+ }
+
+ // We are not converting types. This should only be called if the
+ // type has already been converted.
+ if (!this->is_converted_)
+ {
+ go_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ go_assert(t != NULL_TREE && TYPE_SIZE(t) != NULL_TREE);
+
+ // Complete the tree.
+ Type* base = this->type_->base();
+ tree t1;
+ switch (base->classification())
+ {
+ case TYPE_ERROR:
+ return error_mark_node;
+
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ case TYPE_STRUCT:
+ case TYPE_INTERFACE:
+ return t;
+
+ case TYPE_FUNCTION:
+ // Don't build a circular data structure. GENERIC can't handle
+ // it.
+ if (this->seen_ > 0)
+ {
+ this->is_circular_ = true;
+ return ptr_type_node;
+ }
+ ++this->seen_;
+ t1 = Type::get_named_type_tree(gogo, base);
+ --this->seen_;
+ if (t1 == error_mark_node)
+ return error_mark_node;
+ if (this->is_circular_)
+ t1 = ptr_type_node;
+ go_assert(t != NULL_TREE && TREE_CODE(t) == POINTER_TYPE);
+ go_assert(TREE_CODE(t1) == POINTER_TYPE);
+ TREE_TYPE(t) = TREE_TYPE(t1);
+ return t;
+
+ case TYPE_POINTER:
+ // Don't build a circular data structure. GENERIC can't handle
+ // it.
+ if (this->seen_ > 0)
+ {
+ this->is_circular_ = true;
+ return ptr_type_node;
+ }
+ ++this->seen_;
+ t1 = Type::get_named_type_tree(gogo, base);
+ --this->seen_;
+ if (t1 == error_mark_node)
+ return error_mark_node;
+ if (this->is_circular_)
+ t1 = ptr_type_node;
+ go_assert(t != NULL_TREE && TREE_CODE(t) == POINTER_TYPE);
+ go_assert(TREE_CODE(t1) == POINTER_TYPE);
+ TREE_TYPE(t) = TREE_TYPE(t1);
+ return t;
+
+ case TYPE_ARRAY:
+ if (base->is_open_array_type())
+ {
+ if (this->seen_ > 0)
+ return t;
+ else
+ {
+ ++this->seen_;
+ t = base->array_type()->fill_in_slice_tree(gogo, t);
+ --this->seen_;
+ }
+ }
+ return t;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ go_unreachable();
+ }
+
+ go_unreachable();
+}
+
+// Build a type descriptor for a named type.
+
+Expression*
+Named_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ // If NAME is not NULL, then we don't really want the type
+ // descriptor for this type; we want the descriptor for the
+ // underlying type, giving it the name NAME.
+ return this->named_type_descriptor(gogo, this->type_,
+ name == NULL ? this : name);
+}
+
+// Add to the reflection string. This is used mostly for the name of
+// the type used in a type descriptor, not for actual reflection
+// strings.
+
+void
+Named_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (this->location() != BUILTINS_LOCATION)
+ {
+ const Package* package = this->named_object_->package();
+ if (package != NULL)
+ ret->append(package->name());
+ else
+ ret->append(gogo->package_name());
+ ret->push_back('.');
+ }
+ if (this->in_function_ != NULL)
+ {
+ ret->append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ ret->push_back('$');
+ }
+ ret->append(Gogo::unpack_hidden_name(this->named_object_->name()));
+}
+
+// Get the mangled name.
+
+void
+Named_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ Named_object* no = this->named_object_;
+ std::string name;
+ if (this->location() == BUILTINS_LOCATION)
+ go_assert(this->in_function_ == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? gogo->package_name()
+ : no->package()->name());
+ name = unique_prefix;
+ name.append(1, '.');
+ name.append(package_name);
+ name.append(1, '.');
+ if (this->in_function_ != NULL)
+ {
+ name.append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ name.append(1, '$');
+ }
+ }
+ name.append(Gogo::unpack_hidden_name(no->name()));
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_", static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+}
+
+// Export the type. This is called to export a global type.
+
+void
+Named_type::export_named_type(Export* exp, const std::string&) const
+{
+ // We don't need to write the name of the type here, because it will
+ // be written by Export::write_type anyhow.
+ exp->write_c_string("type ");
+ exp->write_type(this);
+ exp->write_c_string(";\n");
+}
+
+// Import a named type.
+
+void
+Named_type::import_named_type(Import* imp, Named_type** ptype)
+{
+ imp->require_c_string("type ");
+ Type *type = imp->read_type();
+ *ptype = type->named_type();
+ go_assert(*ptype != NULL);
+ imp->require_c_string(";\n");
+}
+
+// Export the type when it is referenced by another type. In this
+// case Export::export_type will already have issued the name.
+
+void
+Named_type::do_export(Export* exp) const
+{
+ exp->write_type(this->type_);
+
+ // To save space, we only export the methods directly attached to
+ // this type.
+ Bindings* methods = this->local_methods_;
+ if (methods == NULL)
+ return;
+
+ exp->write_c_string("\n");
+ for (Bindings::const_definitions_iterator p = methods->begin_definitions();
+ p != methods->end_definitions();
+ ++p)
+ {
+ exp->write_c_string(" ");
+ (*p)->export_named_object(exp);
+ }
+
+ for (Bindings::const_declarations_iterator p = methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (p->second->is_function_declaration())
+ {
+ exp->write_c_string(" ");
+ p->second->export_named_object(exp);
+ }
+ }
+}
+
+// Make a named type.
+
+Named_type*
+Type::make_named_type(Named_object* named_object, Type* type,
+ source_location location)
+{
+ return new Named_type(named_object, type, location);
+}
+
+// Finalize the methods for TYPE. It will be a named type or a struct
+// type. This sets *ALL_METHODS to the list of methods, and builds
+// all required stubs.
+
+void
+Type::finalize_methods(Gogo* gogo, const Type* type, source_location location,
+ Methods** all_methods)
+{
+ *all_methods = NULL;
+ Types_seen types_seen;
+ Type::add_methods_for_type(type, NULL, 0, false, false, &types_seen,
+ all_methods);
+ Type::build_stub_methods(gogo, type, *all_methods, location);
+}
+
+// Add the methods for TYPE to *METHODS. FIELD_INDEXES is used to
+// build up the struct field indexes as we go. DEPTH is the depth of
+// the field within TYPE. IS_EMBEDDED_POINTER is true if we are
+// adding these methods for an anonymous field with pointer type.
+// NEEDS_STUB_METHOD is true if we need to use a stub method which
+// calls the real method. TYPES_SEEN is used to avoid infinite
+// recursion.
+
+void
+Type::add_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Pointer types may not have methods.
+ if (type->points_to() != NULL)
+ return;
+
+ const Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ std::pair<Types_seen::iterator, bool> ins = types_seen->insert(nt);
+ if (!ins.second)
+ return;
+ }
+
+ if (nt != NULL)
+ Type::add_local_methods_for_type(nt, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ methods);
+
+ Type::add_embedded_methods_for_type(type, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ types_seen, methods);
+
+ // If we are called with depth > 0, then we are looking at an
+ // anonymous field of a struct. If such a field has interface type,
+ // then we need to add the interface methods. We don't want to add
+ // them when depth == 0, because we will already handle them
+ // following the usual rules for an interface type.
+ if (depth > 0)
+ Type::add_interface_methods_for_type(type, field_indexes, depth, methods);
+}
+
+// Add the local methods for the named type NT to *METHODS. The
+// parameters are as for add_methods_to_type.
+
+void
+Type::add_local_methods_for_type(const Named_type* nt,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Methods** methods)
+{
+ const Bindings* local_methods = nt->local_methods();
+ if (local_methods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Bindings::const_declarations_iterator p =
+ local_methods->begin_declarations();
+ p != local_methods->end_declarations();
+ ++p)
+ {
+ Named_object* no = p->second;
+ bool is_value_method = (is_embedded_pointer
+ || !Type::method_expects_pointer(no));
+ Method* m = new Named_method(no, field_indexes, depth, is_value_method,
+ (needs_stub_method
+ || (depth > 0 && is_value_method)));
+ if (!(*methods)->insert(no->name(), m))
+ delete m;
+ }
+}
+
+// Add the embedded methods for TYPE to *METHODS. These are the
+// methods attached to anonymous fields. The parameters are as for
+// add_methods_to_type.
+
+void
+Type::add_embedded_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Look for anonymous fields in TYPE. TYPE has fields if it is a
+ // struct.
+ const Struct_type* st = type->struct_type();
+ if (st == NULL)
+ return;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return;
+
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Type* ftype = pf->type();
+ bool is_pointer = false;
+ if (ftype->points_to() != NULL)
+ {
+ ftype = ftype->points_to();
+ is_pointer = true;
+ }
+ Named_type* fnt = ftype->named_type();
+ if (fnt == NULL)
+ {
+ // This is an error, but it will be diagnosed elsewhere.
+ continue;
+ }
+
+ Method::Field_indexes* sub_field_indexes = new Method::Field_indexes();
+ sub_field_indexes->next = field_indexes;
+ sub_field_indexes->field_index = i;
+
+ Type::add_methods_for_type(fnt, sub_field_indexes, depth + 1,
+ (is_embedded_pointer || is_pointer),
+ (needs_stub_method
+ || is_pointer
+ || i > 0),
+ types_seen,
+ methods);
+ }
+}
+
+// If TYPE is an interface type, then add its method to *METHODS.
+// This is for interface methods attached to an anonymous field. The
+// parameters are as for add_methods_for_type.
+
+void
+Type::add_interface_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ Methods** methods)
+{
+ const Interface_type* it = type->interface_type();
+ if (it == NULL)
+ return;
+
+ const Typed_identifier_list* imethods = it->methods();
+ if (imethods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Typed_identifier_list::const_iterator pm = imethods->begin();
+ pm != imethods->end();
+ ++pm)
+ {
+ Function_type* fntype = pm->type()->function_type();
+ if (fntype == NULL)
+ {
+ // This is an error, but it should be reported elsewhere
+ // when we look at the methods for IT.
+ continue;
+ }
+ go_assert(!fntype->is_method());
+ fntype = fntype->copy_with_receiver(const_cast<Type*>(type));
+ Method* m = new Interface_method(pm->name(), pm->location(), fntype,
+ field_indexes, depth);
+ if (!(*methods)->insert(pm->name(), m))
+ delete m;
+ }
+}
+
+// Build stub methods for TYPE as needed. METHODS is the set of
+// methods for the type. A stub method may be needed when a type
+// inherits a method from an anonymous field. When we need the
+// address of the method, as in a type descriptor, we need to build a
+// little stub which does the required field dereferences and jumps to
+// the real method. LOCATION is the location of the type definition.
+
+void
+Type::build_stub_methods(Gogo* gogo, const Type* type, const Methods* methods,
+ source_location location)
+{
+ if (methods == NULL)
+ return;
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ Method* m = p->second;
+ if (m->is_ambiguous() || !m->needs_stub_method())
+ continue;
+
+ const std::string& name(p->first);
+
+ // Build a stub method.
+
+ const Function_type* fntype = m->type();
+
+ static unsigned int counter;
+ char buf[100];
+ snprintf(buf, sizeof buf, "$this%u", counter);
+ ++counter;
+
+ Type* receiver_type = const_cast<Type*>(type);
+ if (!m->is_value_method())
+ receiver_type = Type::make_pointer_type(receiver_type);
+ source_location receiver_location = m->receiver_location();
+ Typed_identifier* receiver = new Typed_identifier(buf, receiver_type,
+ receiver_location);
+
+ const Typed_identifier_list* fnparams = fntype->parameters();
+ Typed_identifier_list* stub_params;
+ if (fnparams == NULL || fnparams->empty())
+ stub_params = NULL;
+ else
+ {
+ // We give each stub parameter a unique name.
+ stub_params = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pp = fnparams->begin();
+ pp != fnparams->end();
+ ++pp)
+ {
+ char pbuf[100];
+ snprintf(pbuf, sizeof pbuf, "$p%u", counter);
+ stub_params->push_back(Typed_identifier(pbuf, pp->type(),
+ pp->location()));
+ ++counter;
+ }
+ }
+
+ const Typed_identifier_list* fnresults = fntype->results();
+ Typed_identifier_list* stub_results;
+ if (fnresults == NULL || fnresults->empty())
+ stub_results = NULL;
+ else
+ {
+ // We create the result parameters without any names, since
+ // we won't refer to them.
+ stub_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pr = fnresults->begin();
+ pr != fnresults->end();
+ ++pr)
+ stub_results->push_back(Typed_identifier("", pr->type(),
+ pr->location()));
+ }
+
+ Function_type* stub_type = Type::make_function_type(receiver,
+ stub_params,
+ stub_results,
+ fntype->location());
+ if (fntype->is_varargs())
+ stub_type->set_is_varargs();
+
+ // We only create the function in the package which creates the
+ // type.
+ const Package* package;
+ if (type->named_type() == NULL)
+ package = NULL;
+ else
+ package = type->named_type()->named_object()->package();
+ Named_object* stub;
+ if (package != NULL)
+ stub = Named_object::make_function_declaration(name, package,
+ stub_type, location);
+ else
+ {
+ stub = gogo->start_function(name, stub_type, false,
+ fntype->location());
+ Type::build_one_stub_method(gogo, m, buf, stub_params,
+ fntype->is_varargs(), location);
+ gogo->finish_function(fntype->location());
+ }
+
+ m->set_stub_object(stub);
+ }
+}
+
+// Build a stub method which adjusts the receiver as required to call
+// METHOD. RECEIVER_NAME is the name we used for the receiver.
+// PARAMS is the list of function parameters.
+
+void
+Type::build_one_stub_method(Gogo* gogo, Method* method,
+ const char* receiver_name,
+ const Typed_identifier_list* params,
+ bool is_varargs,
+ source_location location)
+{
+ Named_object* receiver_object = gogo->lookup(receiver_name, NULL);
+ go_assert(receiver_object != NULL);
+
+ Expression* expr = Expression::make_var_reference(receiver_object, location);
+ expr = Type::apply_field_indexes(expr, method->field_indexes(), location);
+ if (expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+
+ Expression_list* arguments;
+ if (params == NULL || params->empty())
+ arguments = NULL;
+ else
+ {
+ arguments = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ Named_object* param = gogo->lookup(p->name(), NULL);
+ go_assert(param != NULL);
+ Expression* param_ref = Expression::make_var_reference(param,
+ location);
+ arguments->push_back(param_ref);
+ }
+ }
+
+ Expression* func = method->bind_method(expr, location);
+ go_assert(func != NULL);
+ Call_expression* call = Expression::make_call(func, arguments, is_varargs,
+ location);
+ size_t count = call->result_count();
+ if (count == 0)
+ gogo->add_statement(Statement::make_statement(call));
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ Statement* retstat = Statement::make_return_statement(retvals, location);
+ gogo->add_statement(retstat);
+ }
+}
+
+// Apply FIELD_INDEXES to EXPR. The field indexes have to be applied
+// in reverse order.
+
+Expression*
+Type::apply_field_indexes(Expression* expr,
+ const Method::Field_indexes* field_indexes,
+ source_location location)
+{
+ if (field_indexes == NULL)
+ return expr;
+ expr = Type::apply_field_indexes(expr, field_indexes->next, location);
+ Struct_type* stype = expr->type()->deref()->struct_type();
+ go_assert(stype != NULL
+ && field_indexes->field_index < stype->field_count());
+ if (expr->type()->struct_type() == NULL)
+ {
+ go_assert(expr->type()->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ go_assert(expr->type()->struct_type() == stype);
+ }
+ return Expression::make_field_reference(expr, field_indexes->field_index,
+ location);
+}
+
+// Return whether NO is a method for which the receiver is a pointer.
+
+bool
+Type::method_expects_pointer(const Named_object* no)
+{
+ const Function_type *fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ go_unreachable();
+ return fntype->receiver()->type()->points_to() != NULL;
+}
+
+// Given a set of methods for a type, METHODS, return the method NAME,
+// or NULL if there isn't one or if it is ambiguous. If IS_AMBIGUOUS
+// is not NULL, then set *IS_AMBIGUOUS to true if the method exists
+// but is ambiguous (and return NULL).
+
+Method*
+Type::method_function(const Methods* methods, const std::string& name,
+ bool* is_ambiguous)
+{
+ if (is_ambiguous != NULL)
+ *is_ambiguous = false;
+ if (methods == NULL)
+ return NULL;
+ Methods::const_iterator p = methods->find(name);
+ if (p == methods->end())
+ return NULL;
+ Method* m = p->second;
+ if (m->is_ambiguous())
+ {
+ if (is_ambiguous != NULL)
+ *is_ambiguous = true;
+ return NULL;
+ }
+ return m;
+}
+
+// Look for field or method NAME for TYPE. Return an Expression for
+// the field or method bound to EXPR. If there is no such field or
+// method, give an appropriate error and return an error expression.
+
+Expression*
+Type::bind_field_or_method(Gogo* gogo, const Type* type, Expression* expr,
+ const std::string& name,
+ source_location location)
+{
+ if (type->deref()->is_error_type())
+ return Expression::make_error(location);
+
+ const Named_type* nt = type->deref()->named_type();
+ const Struct_type* st = type->deref()->struct_type();
+ const Interface_type* it = type->interface_type();
+
+ // If this is a pointer to a pointer, then it is possible that the
+ // pointed-to type has methods.
+ if (nt == NULL
+ && st == NULL
+ && it == NULL
+ && type->points_to() != NULL
+ && type->points_to()->points_to() != NULL)
+ {
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ type = type->points_to();
+ if (type->deref()->is_error_type())
+ return Expression::make_error(location);
+ nt = type->points_to()->named_type();
+ st = type->points_to()->struct_type();
+ }
+
+ bool receiver_can_be_pointer = (expr->type()->points_to() != NULL
+ || expr->is_addressable());
+ std::vector<const Named_type*> seen;
+ bool is_method = false;
+ bool found_pointer_method = false;
+ std::string ambig1;
+ std::string ambig2;
+ if (Type::find_field_or_method(type, name, receiver_can_be_pointer,
+ &seen, NULL, &is_method,
+ &found_pointer_method, &ambig1, &ambig2))
+ {
+ Expression* ret;
+ if (!is_method)
+ {
+ go_assert(st != NULL);
+ if (type->struct_type() == NULL)
+ {
+ go_assert(type->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr,
+ location);
+ go_assert(expr->type()->struct_type() == st);
+ }
+ ret = st->field_reference(expr, name, location);
+ }
+ else if (it != NULL && it->find_method(name) != NULL)
+ ret = Expression::make_interface_field_reference(expr, name,
+ location);
+ else
+ {
+ Method* m;
+ if (nt != NULL)
+ m = nt->method_function(name, NULL);
+ else if (st != NULL)
+ m = st->method_function(name, NULL);
+ else
+ go_unreachable();
+ go_assert(m != NULL);
+ if (!m->is_value_method() && expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+ ret = m->bind_method(expr, location);
+ }
+ go_assert(ret != NULL);
+ return ret;
+ }
+ else
+ {
+ if (!ambig1.empty())
+ error_at(location, "%qs is ambiguous via %qs and %qs",
+ Gogo::message_name(name).c_str(),
+ Gogo::message_name(ambig1).c_str(),
+ Gogo::message_name(ambig2).c_str());
+ else if (found_pointer_method)
+ error_at(location, "method requires a pointer");
+ else if (nt == NULL && st == NULL && it == NULL)
+ error_at(location,
+ ("reference to field %qs in object which "
+ "has no fields or methods"),
+ Gogo::message_name(name).c_str());
+ else
+ {
+ bool is_unexported;
+ if (!Gogo::is_hidden_name(name))
+ is_unexported = false;
+ else
+ {
+ std::string unpacked = Gogo::unpack_hidden_name(name);
+ seen.clear();
+ is_unexported = Type::is_unexported_field_or_method(gogo, type,
+ unpacked,
+ &seen);
+ }
+ if (is_unexported)
+ error_at(location, "reference to unexported field or method %qs",
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "reference to undefined field or method %qs",
+ Gogo::message_name(name).c_str());
+ }
+ return Expression::make_error(location);
+ }
+}
+
+// Look in TYPE for a field or method named NAME, return true if one
+// is found. This looks through embedded anonymous fields and handles
+// ambiguity. If a method is found, sets *IS_METHOD to true;
+// otherwise, if a field is found, set it to false. If
+// RECEIVER_CAN_BE_POINTER is false, then the receiver is a value
+// whose address can not be taken. SEEN is used to avoid infinite
+// recursion on invalid types.
+
+// When returning false, this sets *FOUND_POINTER_METHOD if we found a
+// method we couldn't use because it requires a pointer. LEVEL is
+// used for recursive calls, and can be NULL for a non-recursive call.
+// When this function returns false because it finds that the name is
+// ambiguous, it will store a path to the ambiguous names in *AMBIG1
+// and *AMBIG2. If the name is not found at all, *AMBIG1 and *AMBIG2
+// will be unchanged.
+
+// This function just returns whether or not there is a field or
+// method, and whether it is a field or method. It doesn't build an
+// expression to refer to it. If it is a method, we then look in the
+// list of all methods for the type. If it is a field, the search has
+// to be done again, looking only for fields, and building up the
+// expression as we go.
+
+bool
+Type::find_field_or_method(const Type* type,
+ const std::string& name,
+ bool receiver_can_be_pointer,
+ std::vector<const Named_type*>* seen,
+ int* level,
+ bool* is_method,
+ bool* found_pointer_method,
+ std::string* ambig1,
+ std::string* ambig2)
+{
+ // Named types can have locally defined methods.
+ const Named_type* nt = type->named_type();
+ if (nt == NULL && type->points_to() != NULL)
+ nt = type->points_to()->named_type();
+ if (nt != NULL)
+ {
+ Named_object* no = nt->find_local_method(name);
+ if (no != NULL)
+ {
+ if (receiver_can_be_pointer || !Type::method_expects_pointer(no))
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Record that we have found a pointer method in order to
+ // give a better error message if we don't find anything
+ // else.
+ *found_pointer_method = true;
+ }
+
+ for (std::vector<const Named_type*>::const_iterator p = seen->begin();
+ p != seen->end();
+ ++p)
+ {
+ if (*p == nt)
+ {
+ // We've already seen this type when searching for methods.
+ return false;
+ }
+ }
+ }
+
+ // Interface types can have methods.
+ const Interface_type* it = type->interface_type();
+ if (it != NULL && it->find_method(name) != NULL)
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Struct types can have fields. They can also inherit fields and
+ // methods from anonymous fields.
+ const Struct_type* st = type->deref()->struct_type();
+ if (st == NULL)
+ return false;
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ if (nt != NULL)
+ seen->push_back(nt);
+
+ int found_level = 0;
+ bool found_is_method = false;
+ std::string found_ambig1;
+ std::string found_ambig2;
+ const Struct_field* found_parent = NULL;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->field_name() == name)
+ {
+ *is_method = false;
+ if (nt != NULL)
+ seen->pop_back();
+ return true;
+ }
+
+ if (!pf->is_anonymous())
+ continue;
+
+ if (pf->type()->deref()->is_error_type()
+ || pf->type()->deref()->is_undefined())
+ continue;
+
+ Named_type* fnt = pf->type()->named_type();
+ if (fnt == NULL)
+ fnt = pf->type()->deref()->named_type();
+ go_assert(fnt != NULL);
+
+ int sublevel = level == NULL ? 1 : *level + 1;
+ bool sub_is_method;
+ std::string subambig1;
+ std::string subambig2;
+ bool subfound = Type::find_field_or_method(fnt,
+ name,
+ receiver_can_be_pointer,
+ seen,
+ &sublevel,
+ &sub_is_method,
+ found_pointer_method,
+ &subambig1,
+ &subambig2);
+ if (!subfound)
+ {
+ if (!subambig1.empty())
+ {
+ // The name was found via this field, but is ambiguous.
+ // if the ambiguity is lower or at the same level as
+ // anything else we have already found, then we want to
+ // pass the ambiguity back to the caller.
+ if (found_level == 0 || sublevel <= found_level)
+ {
+ found_ambig1 = pf->field_name() + '.' + subambig1;
+ found_ambig2 = pf->field_name() + '.' + subambig2;
+ found_level = sublevel;
+ }
+ }
+ }
+ else
+ {
+ // The name was found via this field. Use the level to see
+ // if we want to use this one, or whether it introduces an
+ // ambiguity.
+ if (found_level == 0 || sublevel < found_level)
+ {
+ found_level = sublevel;
+ found_is_method = sub_is_method;
+ found_ambig1.clear();
+ found_ambig2.clear();
+ found_parent = &*pf;
+ }
+ else if (sublevel > found_level)
+ ;
+ else if (found_ambig1.empty())
+ {
+ // We found an ambiguity.
+ go_assert(found_parent != NULL);
+ found_ambig1 = found_parent->field_name();
+ found_ambig2 = pf->field_name();
+ }
+ else
+ {
+ // We found an ambiguity, but we already know of one.
+ // Just report the earlier one.
+ }
+ }
+ }
+
+ // Here if we didn't find anything FOUND_LEVEL is 0. If we found
+ // something ambiguous, FOUND_LEVEL is not 0 and FOUND_AMBIG1 and
+ // FOUND_AMBIG2 are not empty. If we found the field, FOUND_LEVEL
+ // is not 0 and FOUND_AMBIG1 and FOUND_AMBIG2 are empty.
+
+ if (nt != NULL)
+ seen->pop_back();
+
+ if (found_level == 0)
+ return false;
+ else if (!found_ambig1.empty())
+ {
+ go_assert(!found_ambig1.empty());
+ ambig1->assign(found_ambig1);
+ ambig2->assign(found_ambig2);
+ if (level != NULL)
+ *level = found_level;
+ return false;
+ }
+ else
+ {
+ if (level != NULL)
+ *level = found_level;
+ *is_method = found_is_method;
+ return true;
+ }
+}
+
+// Return whether NAME is an unexported field or method for TYPE.
+
+bool
+Type::is_unexported_field_or_method(Gogo* gogo, const Type* type,
+ const std::string& name,
+ std::vector<const Named_type*>* seen)
+{
+ const Named_type* nt = type->named_type();
+ if (nt == NULL)
+ nt = type->deref()->named_type();
+ if (nt != NULL)
+ {
+ if (nt->is_unexported_local_method(gogo, name))
+ return true;
+
+ for (std::vector<const Named_type*>::const_iterator p = seen->begin();
+ p != seen->end();
+ ++p)
+ {
+ if (*p == nt)
+ {
+ // We've already seen this type.
+ return false;
+ }
+ }
+ }
+
+ const Interface_type* it = type->interface_type();
+ if (it != NULL && it->is_unexported_method(gogo, name))
+ return true;
+
+ type = type->deref();
+
+ const Struct_type* st = type->struct_type();
+ if (st != NULL && st->is_unexported_local_field(gogo, name))
+ return true;
+
+ if (st == NULL)
+ return false;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ if (nt != NULL)
+ seen->push_back(nt);
+
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->is_anonymous()
+ && !pf->type()->deref()->is_error_type()
+ && !pf->type()->deref()->is_undefined())
+ {
+ Named_type* subtype = pf->type()->named_type();
+ if (subtype == NULL)
+ subtype = pf->type()->deref()->named_type();
+ if (subtype == NULL)
+ {
+ // This is an error, but it will be diagnosed elsewhere.
+ continue;
+ }
+ if (Type::is_unexported_field_or_method(gogo, subtype, name, seen))
+ {
+ if (nt != NULL)
+ seen->pop_back();
+ return true;
+ }
+ }
+ }
+
+ if (nt != NULL)
+ seen->pop_back();
+
+ return false;
+}
+
+// Class Forward_declaration.
+
+Forward_declaration_type::Forward_declaration_type(Named_object* named_object)
+ : Type(TYPE_FORWARD),
+ named_object_(named_object->resolve()), warned_(false)
+{
+ go_assert(this->named_object_->is_unknown()
+ || this->named_object_->is_type_declaration());
+}
+
+// Return the named object.
+
+Named_object*
+Forward_declaration_type::named_object()
+{
+ return this->named_object_->resolve();
+}
+
+const Named_object*
+Forward_declaration_type::named_object() const
+{
+ return this->named_object_->resolve();
+}
+
+// Return the name of the forward declared type.
+
+const std::string&
+Forward_declaration_type::name() const
+{
+ return this->named_object()->name();
+}
+
+// Warn about a use of a type which has been declared but not defined.
+
+void
+Forward_declaration_type::warn() const
+{
+ Named_object* no = this->named_object_->resolve();
+ if (no->is_unknown())
+ {
+ // The name was not defined anywhere.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else if (no->is_type_declaration())
+ {
+ // The name was seen as a type, but the type was never defined.
+ if (no->type_declaration_value()->using_type())
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else
+ {
+ // The name was defined, but not as a type.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(), "expected type");
+ this->warned_ = true;
+ }
+ }
+}
+
+// Get the base type of a declaration. This gives an error if the
+// type has not yet been defined.
+
+Type*
+Forward_declaration_type::real_type()
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+const Type*
+Forward_declaration_type::real_type() const
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+// Return whether the base type is defined.
+
+bool
+Forward_declaration_type::is_defined() const
+{
+ return this->named_object()->is_type();
+}
+
+// Add a method. This is used when methods are defined before the
+// type.
+
+Named_object*
+Forward_declaration_type::add_method(const std::string& name,
+ Function* function)
+{
+ Named_object* no = this->named_object();
+ if (no->is_unknown())
+ no->declare_as_type();
+ return no->type_declaration_value()->add_method(name, function);
+}
+
+// Add a method declaration. This is used when methods are declared
+// before the type.
+
+Named_object*
+Forward_declaration_type::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = this->named_object();
+ if (no->is_unknown())
+ no->declare_as_type();
+ Type_declaration* td = no->type_declaration_value();
+ return td->add_method_declaration(name, type, location);
+}
+
+// Traversal.
+
+int
+Forward_declaration_type::do_traverse(Traverse* traverse)
+{
+ if (this->is_defined()
+ && Type::traverse(this->real_type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Get a tree for the type.
+
+tree
+Forward_declaration_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_defined())
+ return Type::get_named_type_tree(gogo, this->real_type());
+
+ if (this->warned_)
+ return error_mark_node;
+
+ // We represent an undefined type as a struct with no fields. That
+ // should work fine for the middle-end, since the same case can
+ // arise in C.
+ Named_object* no = this->named_object();
+ tree type_tree = make_node(RECORD_TYPE);
+ tree id = no->get_id(gogo);
+ tree decl = build_decl(no->location(), TYPE_DECL, id, type_tree);
+ TYPE_NAME(type_tree) = decl;
+ layout_type(type_tree);
+ return type_tree;
+}
+
+// Build a type descriptor for a forwarded type.
+
+Expression*
+Forward_declaration_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (!this->is_defined())
+ return Expression::make_nil(BUILTINS_LOCATION);
+ else
+ {
+ Type* t = this->real_type();
+ if (name != NULL)
+ return this->named_type_descriptor(gogo, t, name);
+ else
+ return Expression::make_type_descriptor(t, BUILTINS_LOCATION);
+ }
+}
+
+// The reflection string.
+
+void
+Forward_declaration_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ this->append_reflection(this->real_type(), gogo, ret);
+}
+
+// The mangled name.
+
+void
+Forward_declaration_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ if (this->is_defined())
+ this->append_mangled_name(this->real_type(), gogo, ret);
+ else
+ {
+ const Named_object* no = this->named_object();
+ std::string name;
+ if (no->package() == NULL)
+ name = gogo->package_name();
+ else
+ name = no->package()->name();
+ name += '.';
+ name += Gogo::unpack_hidden_name(no->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_",
+ static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+ }
+}
+
+// Export a forward declaration. This can happen when a defined type
+// refers to a type which is only declared (and is presumably defined
+// in some other file in the same package).
+
+void
+Forward_declaration_type::do_export(Export*) const
+{
+ // If there is a base type, that should be exported instead of this.
+ go_assert(!this->is_defined());
+
+ // We don't output anything.
+}
+
+// Make a forward declaration.
+
+Type*
+Type::make_forward_declaration(Named_object* named_object)
+{
+ return new Forward_declaration_type(named_object);
+}
+
+// Class Typed_identifier_list.
+
+// Sort the entries by name.
+
+struct Typed_identifier_list_sort
+{
+ public:
+ bool
+ operator()(const Typed_identifier& t1, const Typed_identifier& t2) const
+ { return t1.name() < t2.name(); }
+};
+
+void
+Typed_identifier_list::sort_by_name()
+{
+ std::sort(this->entries_.begin(), this->entries_.end(),
+ Typed_identifier_list_sort());
+}
+
+// Traverse types.
+
+int
+Typed_identifier_list::traverse(Traverse* traverse)
+{
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Typed_identifier_list*
+Typed_identifier_list::copy() const
+{
+ Typed_identifier_list* ret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ ret->push_back(Typed_identifier(p->name(), p->type(), p->location()));
+ return ret;
+}
--- /dev/null
+// types.cc -- Go frontend types.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include <gmp.h>
+
+#ifndef ENABLE_BUILD_WITH_CXX
+extern "C"
+{
+#endif
+
+#include "toplev.h"
+#include "intl.h"
+#include "tree.h"
+#include "gimple.h"
+#include "real.h"
+#include "convert.h"
+
+#ifndef ENABLE_BUILD_WITH_CXX
+}
+#endif
+
+#include "go-c.h"
+#include "gogo.h"
+#include "operator.h"
+#include "expressions.h"
+#include "statements.h"
+#include "export.h"
+#include "import.h"
+#include "types.h"
+
+// Class Type.
+
+Type::Type(Type_classification classification)
+ : classification_(classification), tree_(NULL_TREE),
+ type_descriptor_decl_(NULL_TREE)
+{
+}
+
+Type::~Type()
+{
+}
+
+// Get the base type for a type--skip names and forward declarations.
+
+Type*
+Type::base()
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_base();
+ case TYPE_FORWARD:
+ return this->forward_declaration_type()->real_type()->base();
+ default:
+ return this;
+ }
+}
+
+const Type*
+Type::base() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_base();
+ case TYPE_FORWARD:
+ return this->forward_declaration_type()->real_type()->base();
+ default:
+ return this;
+ }
+}
+
+// Skip defined forward declarations.
+
+Type*
+Type::forwarded()
+{
+ Type* t = this;
+ Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+const Type*
+Type::forwarded() const
+{
+ const Type* t = this;
+ const Forward_declaration_type* ftype = t->forward_declaration_type();
+ while (ftype != NULL && ftype->is_defined())
+ {
+ t = ftype->real_type();
+ ftype = t->forward_declaration_type();
+ }
+ return t;
+}
+
+// If this is a named type, return it. Otherwise, return NULL.
+
+Named_type*
+Type::named_type()
+{
+ return this->forwarded()->convert_no_base<Named_type, TYPE_NAMED>();
+}
+
+const Named_type*
+Type::named_type() const
+{
+ return this->forwarded()->convert_no_base<const Named_type, TYPE_NAMED>();
+}
+
+// Return true if this type is not defined.
+
+bool
+Type::is_undefined() const
+{
+ return this->forwarded()->forward_declaration_type() != NULL;
+}
+
+// Return true if this is a basic type: a type which is not composed
+// of other types, and is not void.
+
+bool
+Type::is_basic_type() const
+{
+ switch (this->classification_)
+ {
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ return true;
+
+ case TYPE_ERROR:
+ case TYPE_VOID:
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ case TYPE_STRUCT:
+ case TYPE_ARRAY:
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ case TYPE_INTERFACE:
+ return false;
+
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ return this->base()->is_basic_type();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if this is an abstract type.
+
+bool
+Type::is_abstract() const
+{
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return this->integer_type()->is_abstract();
+ case TYPE_FLOAT:
+ return this->float_type()->is_abstract();
+ case TYPE_COMPLEX:
+ return this->complex_type()->is_abstract();
+ case TYPE_STRING:
+ return this->is_abstract_string_type();
+ case TYPE_BOOLEAN:
+ return this->is_abstract_boolean_type();
+ default:
+ return false;
+ }
+}
+
+// Return a non-abstract version of an abstract type.
+
+Type*
+Type::make_non_abstract_type()
+{
+ gcc_assert(this->is_abstract());
+ switch (this->classification())
+ {
+ case TYPE_INTEGER:
+ return Type::lookup_integer_type("int");
+ case TYPE_FLOAT:
+ return Type::lookup_float_type("float64");
+ case TYPE_COMPLEX:
+ return Type::lookup_complex_type("complex128");
+ case TYPE_STRING:
+ return Type::lookup_string_type();
+ case TYPE_BOOLEAN:
+ return Type::lookup_bool_type();
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if this is an error type. Don't give an error if we
+// try to dereference an undefined forwarding type, as this is called
+// in the parser when the type may legitimately be undefined.
+
+bool
+Type::is_error_type() const
+{
+ const Type* t = this->forwarded();
+ // Note that we return false for an undefined forward type.
+ switch (t->classification_)
+ {
+ case TYPE_ERROR:
+ return true;
+ case TYPE_NAMED:
+ return t->named_type()->is_named_error_type();
+ default:
+ return false;
+ }
+}
+
+// If this is a pointer type, return the type to which it points.
+// Otherwise, return NULL.
+
+Type*
+Type::points_to() const
+{
+ const Pointer_type* ptype = this->convert<const Pointer_type,
+ TYPE_POINTER>();
+ return ptype == NULL ? NULL : ptype->points_to();
+}
+
+// Return whether this is an open array type.
+
+bool
+Type::is_open_array_type() const
+{
+ return this->array_type() != NULL && this->array_type()->length() == NULL;
+}
+
+// Return whether this is the predeclared constant nil being used as a
+// type.
+
+bool
+Type::is_nil_constant_as_type() const
+{
+ const Type* t = this->forwarded();
+ if (t->forward_declaration_type() != NULL)
+ {
+ const Named_object* no = t->forward_declaration_type()->named_object();
+ if (no->is_unknown())
+ no = no->unknown_value()->real_named_object();
+ if (no != NULL
+ && no->is_const()
+ && no->const_value()->expr()->is_nil_expression())
+ return true;
+ }
+ return false;
+}
+
+// Traverse a type.
+
+int
+Type::traverse(Type* type, Traverse* traverse)
+{
+ gcc_assert((traverse->traverse_mask() & Traverse::traverse_types) != 0
+ || (traverse->traverse_mask()
+ & Traverse::traverse_expressions) != 0);
+ if (traverse->remember_type(type))
+ {
+ // We have already traversed this type.
+ return TRAVERSE_CONTINUE;
+ }
+ if ((traverse->traverse_mask() & Traverse::traverse_types) != 0)
+ {
+ int t = traverse->type(type);
+ if (t == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ else if (t == TRAVERSE_SKIP_COMPONENTS)
+ return TRAVERSE_CONTINUE;
+ }
+ // An array type has an expression which we need to traverse if
+ // traverse_expressions is set.
+ if (type->do_traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Default implementation for do_traverse for child class.
+
+int
+Type::do_traverse(Traverse*)
+{
+ return TRAVERSE_CONTINUE;
+}
+
+// Return whether two types are identical. If ERRORS_ARE_IDENTICAL,
+// then return true for all erroneous types; this is used to avoid
+// cascading errors. If REASON is not NULL, optionally set *REASON to
+// the reason the types are not identical.
+
+bool
+Type::are_identical(const Type* t1, const Type* t2, bool errors_are_identical,
+ std::string* reason)
+{
+ if (t1 == NULL || t2 == NULL)
+ {
+ // Something is wrong.
+ return errors_are_identical ? true : t1 == t2;
+ }
+
+ // Skip defined forward declarations.
+ t1 = t1->forwarded();
+ t2 = t2->forwarded();
+
+ if (t1 == t2)
+ return true;
+
+ // An undefined forward declaration is an error.
+ if (t1->forward_declaration_type() != NULL
+ || t2->forward_declaration_type() != NULL)
+ return errors_are_identical;
+
+ // Avoid cascading errors with error types.
+ if (t1->is_error_type() || t2->is_error_type())
+ {
+ if (errors_are_identical)
+ return true;
+ return t1->is_error_type() && t2->is_error_type();
+ }
+
+ // Get a good reason for the sink type. Note that the sink type on
+ // the left hand side of an assignment is handled in are_assignable.
+ if (t1->is_sink_type() || t2->is_sink_type())
+ {
+ if (reason != NULL)
+ *reason = "invalid use of _";
+ return false;
+ }
+
+ // A named type is only identical to itself.
+ if (t1->named_type() != NULL || t2->named_type() != NULL)
+ return false;
+
+ // Check type shapes.
+ if (t1->classification() != t2->classification())
+ return false;
+
+ switch (t1->classification())
+ {
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These types are always identical.
+ return true;
+
+ case TYPE_INTEGER:
+ return t1->integer_type()->is_identical(t2->integer_type());
+
+ case TYPE_FLOAT:
+ return t1->float_type()->is_identical(t2->float_type());
+
+ case TYPE_COMPLEX:
+ return t1->complex_type()->is_identical(t2->complex_type());
+
+ case TYPE_FUNCTION:
+ return t1->function_type()->is_identical(t2->function_type(),
+ false,
+ errors_are_identical,
+ reason);
+
+ case TYPE_POINTER:
+ return Type::are_identical(t1->points_to(), t2->points_to(),
+ errors_are_identical, reason);
+
+ case TYPE_STRUCT:
+ return t1->struct_type()->is_identical(t2->struct_type(),
+ errors_are_identical);
+
+ case TYPE_ARRAY:
+ return t1->array_type()->is_identical(t2->array_type(),
+ errors_are_identical);
+
+ case TYPE_MAP:
+ return t1->map_type()->is_identical(t2->map_type(),
+ errors_are_identical);
+
+ case TYPE_CHANNEL:
+ return t1->channel_type()->is_identical(t2->channel_type(),
+ errors_are_identical);
+
+ case TYPE_INTERFACE:
+ return t1->interface_type()->is_identical(t2->interface_type(),
+ errors_are_identical);
+
+ case TYPE_CALL_MULTIPLE_RESULT:
+ if (reason != NULL)
+ *reason = "invalid use of multiple value function call";
+ return false;
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return true if it's OK to have a binary operation with types LHS
+// and RHS. This is not used for shifts or comparisons.
+
+bool
+Type::are_compatible_for_binop(const Type* lhs, const Type* rhs)
+{
+ if (Type::are_identical(lhs, rhs, true, NULL))
+ return true;
+
+ // A constant of abstract bool type may be mixed with any bool type.
+ if ((rhs->is_abstract_boolean_type() && lhs->is_boolean_type())
+ || (lhs->is_abstract_boolean_type() && rhs->is_boolean_type()))
+ return true;
+
+ // A constant of abstract string type may be mixed with any string
+ // type.
+ if ((rhs->is_abstract_string_type() && lhs->is_string_type())
+ || (lhs->is_abstract_string_type() && rhs->is_string_type()))
+ return true;
+
+ lhs = lhs->base();
+ rhs = rhs->base();
+
+ // A constant of abstract integer, float, or complex type may be
+ // mixed with an integer, float, or complex type.
+ if ((rhs->is_abstract()
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ || (lhs->is_abstract()
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL)
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL)))
+ return true;
+
+ // The nil type may be compared to a pointer, an interface type, a
+ // slice type, a channel type, a map type, or a function type.
+ if (lhs->is_nil_type()
+ && (rhs->points_to() != NULL
+ || rhs->interface_type() != NULL
+ || rhs->is_open_array_type()
+ || rhs->map_type() != NULL
+ || rhs->channel_type() != NULL
+ || rhs->function_type() != NULL))
+ return true;
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->interface_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->function_type() != NULL))
+ return true;
+
+ return false;
+}
+
+// Return true if a value with type RHS may be assigned to a variable
+// with type LHS. If REASON is not NULL, set *REASON to the reason
+// the types are not assignable.
+
+bool
+Type::are_assignable(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ // Do some checks first. Make sure the types are defined.
+ if (rhs != NULL
+ && rhs->forwarded()->forward_declaration_type() == NULL
+ && rhs->is_void_type())
+ {
+ if (reason != NULL)
+ *reason = "non-value used as value";
+ return false;
+ }
+
+ if (lhs != NULL && lhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ // Any value may be assigned to the blank identifier.
+ if (lhs->is_sink_type())
+ return true;
+
+ // All fields of a struct must be exported, or the assignment
+ // must be in the same package.
+ if (rhs != NULL && rhs->forwarded()->forward_declaration_type() == NULL)
+ {
+ if (lhs->has_hidden_fields(NULL, reason)
+ || rhs->has_hidden_fields(NULL, reason))
+ return false;
+ }
+ }
+
+ // Identical types are assignable.
+ if (Type::are_identical(lhs, rhs, true, reason))
+ return true;
+
+ // The types are assignable if they have identical underlying types
+ // and either LHS or RHS is not a named type.
+ if (((lhs->named_type() != NULL && rhs->named_type() == NULL)
+ || (rhs->named_type() != NULL && lhs->named_type() == NULL))
+ && Type::are_identical(lhs->base(), rhs->base(), true, reason))
+ return true;
+
+ // The types are assignable if LHS is an interface type and RHS
+ // implements the required methods.
+ const Interface_type* lhs_interface_type = lhs->interface_type();
+ if (lhs_interface_type != NULL)
+ {
+ if (lhs_interface_type->implements_interface(rhs, reason))
+ return true;
+ const Interface_type* rhs_interface_type = rhs->interface_type();
+ if (rhs_interface_type != NULL
+ && lhs_interface_type->is_compatible_for_assign(rhs_interface_type,
+ reason))
+ return true;
+ }
+
+ // The type are assignable if RHS is a bidirectional channel type,
+ // LHS is a channel type, they have identical element types, and
+ // either LHS or RHS is not a named type.
+ if (lhs->channel_type() != NULL
+ && rhs->channel_type() != NULL
+ && rhs->channel_type()->may_send()
+ && rhs->channel_type()->may_receive()
+ && (lhs->named_type() == NULL || rhs->named_type() == NULL)
+ && Type::are_identical(lhs->channel_type()->element_type(),
+ rhs->channel_type()->element_type(),
+ true,
+ reason))
+ return true;
+
+ // The nil type may be assigned to a pointer, function, slice, map,
+ // channel, or interface type.
+ if (rhs->is_nil_type()
+ && (lhs->points_to() != NULL
+ || lhs->function_type() != NULL
+ || lhs->is_open_array_type()
+ || lhs->map_type() != NULL
+ || lhs->channel_type() != NULL
+ || lhs->interface_type() != NULL))
+ return true;
+
+ // An untyped numeric constant may be assigned to a numeric type if
+ // it is representable in that type.
+ if ((rhs->is_abstract()
+ && (rhs->integer_type() != NULL
+ || rhs->float_type() != NULL
+ || rhs->complex_type() != NULL))
+ && (lhs->integer_type() != NULL
+ || lhs->float_type() != NULL
+ || lhs->complex_type() != NULL))
+ return true;
+
+ // Give some better error messages.
+ if (reason != NULL && reason->empty())
+ {
+ if (rhs->interface_type() != NULL)
+ reason->assign(_("need explicit conversion"));
+ else if (rhs->is_call_multiple_result_type())
+ reason->assign(_("multiple value function call in "
+ "single value context"));
+ else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
+ {
+ size_t len = (lhs->named_type()->name().length()
+ + rhs->named_type()->name().length()
+ + 100);
+ char* buf = new char[len];
+ snprintf(buf, len, _("cannot use type %s as type %s"),
+ rhs->named_type()->message_name().c_str(),
+ lhs->named_type()->message_name().c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ }
+
+ return false;
+}
+
+// Return true if a value with type RHS may be converted to type LHS.
+// If REASON is not NULL, set *REASON to the reason the types are not
+// convertible.
+
+bool
+Type::are_convertible(const Type* lhs, const Type* rhs, std::string* reason)
+{
+ // The types are convertible if they are assignable.
+ if (Type::are_assignable(lhs, rhs, reason))
+ return true;
+
+ // The types are convertible if they have identical underlying
+ // types.
+ if ((lhs->named_type() != NULL || rhs->named_type() != NULL)
+ && Type::are_identical(lhs->base(), rhs->base(), true, reason))
+ return true;
+
+ // The types are convertible if they are both unnamed pointer types
+ // and their pointer base types have identical underlying types.
+ if (lhs->named_type() == NULL
+ && rhs->named_type() == NULL
+ && lhs->points_to() != NULL
+ && rhs->points_to() != NULL
+ && (lhs->points_to()->named_type() != NULL
+ || rhs->points_to()->named_type() != NULL)
+ && Type::are_identical(lhs->points_to()->base(),
+ rhs->points_to()->base(),
+ true,
+ reason))
+ return true;
+
+ // Integer and floating point types are convertible to each other.
+ if ((lhs->integer_type() != NULL || lhs->float_type() != NULL)
+ && (rhs->integer_type() != NULL || rhs->float_type() != NULL))
+ return true;
+
+ // Complex types are convertible to each other.
+ if (lhs->complex_type() != NULL && rhs->complex_type() != NULL)
+ return true;
+
+ // An integer, or []byte, or []int, may be converted to a string.
+ if (lhs->is_string_type())
+ {
+ if (rhs->integer_type() != NULL)
+ return true;
+ if (rhs->is_open_array_type() && rhs->named_type() == NULL)
+ {
+ const Type* e = rhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+ }
+
+ // A string may be converted to []byte or []int.
+ if (rhs->is_string_type()
+ && lhs->is_open_array_type()
+ && lhs->named_type() == NULL)
+ {
+ const Type* e = lhs->array_type()->element_type()->forwarded();
+ if (e->integer_type() != NULL
+ && (e == Type::lookup_integer_type("uint8")
+ || e == Type::lookup_integer_type("int")))
+ return true;
+ }
+
+ // An unsafe.Pointer type may be converted to any pointer type or to
+ // uintptr, and vice-versa.
+ if (lhs->is_unsafe_pointer_type()
+ && (rhs->points_to() != NULL
+ || (rhs->integer_type() != NULL
+ && rhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+ if (rhs->is_unsafe_pointer_type()
+ && (lhs->points_to() != NULL
+ || (lhs->integer_type() != NULL
+ && lhs->forwarded() == Type::lookup_integer_type("uintptr"))))
+ return true;
+
+ // Give a better error message.
+ if (reason != NULL)
+ {
+ if (reason->empty())
+ *reason = "invalid type conversion";
+ else
+ {
+ std::string s = "invalid type conversion (";
+ s += *reason;
+ s += ')';
+ *reason = s;
+ }
+ }
+
+ return false;
+}
+
+// Return whether this type has any hidden fields. This is only a
+// possibility for a few types.
+
+bool
+Type::has_hidden_fields(const Named_type* within, std::string* reason) const
+{
+ switch (this->forwarded()->classification_)
+ {
+ case TYPE_NAMED:
+ return this->named_type()->named_type_has_hidden_fields(reason);
+ case TYPE_STRUCT:
+ return this->struct_type()->struct_has_hidden_fields(within, reason);
+ case TYPE_ARRAY:
+ return this->array_type()->array_has_hidden_fields(within, reason);
+ default:
+ return false;
+ }
+}
+
+// Return a hash code for the type to be used for method lookup.
+
+unsigned int
+Type::hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->classification_ != TYPE_FORWARD)
+ ret += this->classification_;
+ return ret + this->do_hash_for_method(gogo);
+}
+
+// Default implementation of do_hash_for_method. This is appropriate
+// for types with no subfields.
+
+unsigned int
+Type::do_hash_for_method(Gogo*) const
+{
+ return 0;
+}
+
+// Return a hash code for a string, given a starting hash.
+
+unsigned int
+Type::hash_string(const std::string& s, unsigned int h)
+{
+ const char* p = s.data();
+ size_t len = s.length();
+ for (; len > 0; --len)
+ {
+ h ^= *p++;
+ h*= 16777619;
+ }
+ return h;
+}
+
+// Default check for the expression passed to make. Any type which
+// may be used with make implements its own version of this.
+
+bool
+Type::do_check_make_expression(Expression_list*, source_location)
+{
+ gcc_unreachable();
+}
+
+// Return whether an expression has an integer value. Report an error
+// if not. This is used when handling calls to the predeclared make
+// function.
+
+bool
+Type::check_int_value(Expression* e, const char* errmsg,
+ source_location location)
+{
+ if (e->type()->integer_type() != NULL)
+ return true;
+
+ // Check for a floating point constant with integer value.
+ mpfr_t fval;
+ mpfr_init(fval);
+
+ Type* dummy;
+ if (e->float_constant_value(fval, &dummy) && mpfr_integer_p(fval))
+ {
+ mpz_t ival;
+ mpz_init(ival);
+
+ bool ok = false;
+
+ mpfr_clear_overflow();
+ mpfr_clear_erangeflag();
+ mpfr_get_z(ival, fval, GMP_RNDN);
+ if (!mpfr_overflow_p()
+ && !mpfr_erangeflag_p()
+ && mpz_sgn(ival) >= 0)
+ {
+ Named_type* ntype = Type::lookup_integer_type("int");
+ Integer_type* inttype = ntype->integer_type();
+ mpz_t max;
+ mpz_init_set_ui(max, 1);
+ mpz_mul_2exp(max, max, inttype->bits() - 1);
+ ok = mpz_cmp(ival, max) < 0;
+ mpz_clear(max);
+ }
+ mpz_clear(ival);
+
+ if (ok)
+ {
+ mpfr_clear(fval);
+ return true;
+ }
+ }
+
+ mpfr_clear(fval);
+
+ error_at(location, "%s", errmsg);
+ return false;
+}
+
+// A hash table mapping unnamed types to trees.
+
+Type::Type_trees Type::type_trees;
+
+// Return a tree representing this type.
+
+tree
+Type::get_tree(Gogo* gogo)
+{
+ if (this->tree_ != NULL)
+ return this->tree_;
+
+ if (this->forward_declaration_type() != NULL
+ || this->named_type() != NULL)
+ return this->get_tree_without_hash(gogo);
+
+ if (this->is_error_type())
+ return error_mark_node;
+
+ // To avoid confusing GIMPLE, we need to translate all identical Go
+ // types to the same GIMPLE type. We use a hash table to do that.
+ // There is no need to use the hash table for named types, as named
+ // types are only identical to themselves.
+
+ std::pair<Type*, tree> val(this, NULL);
+ std::pair<Type_trees::iterator, bool> ins =
+ Type::type_trees.insert(val);
+ if (!ins.second && ins.first->second != NULL_TREE)
+ {
+ if (gogo != NULL && gogo->named_types_are_converted())
+ this->tree_ = ins.first->second;
+ return ins.first->second;
+ }
+
+ tree t = this->get_tree_without_hash(gogo);
+
+ if (ins.first->second == NULL_TREE)
+ ins.first->second = t;
+ else
+ {
+ // We have already created a tree for this type. This can
+ // happen when an unnamed type is defined using a named type
+ // which in turns uses an identical unnamed type. Use the tree
+ // we created earlier and ignore the one we just built.
+ t = ins.first->second;
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ return t;
+ this->tree_ = t;
+ }
+
+ return t;
+}
+
+// Return a tree for a type without looking in the hash table for
+// identical types. This is used for named types, since there is no
+// point to looking in the hash table for them.
+
+tree
+Type::get_tree_without_hash(Gogo* gogo)
+{
+ if (this->tree_ == NULL_TREE)
+ {
+ tree t = this->do_get_tree(gogo);
+
+ // For a recursive function or pointer type, we will temporarily
+ // return ptr_type_node during the recursion. We don't want to
+ // record that for a forwarding type, as it may confuse us
+ // later.
+ if (t == ptr_type_node && this->forward_declaration_type() != NULL)
+ return t;
+
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ return t;
+
+ this->tree_ = t;
+ go_preserve_from_gc(t);
+ }
+
+ return this->tree_;
+}
+
+// Return a tree representing a zero initialization for this type.
+
+tree
+Type::get_init_tree(Gogo* gogo, bool is_clear)
+{
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+ return this->do_get_init_tree(gogo, type_tree, is_clear);
+}
+
+// Any type which supports the builtin make function must implement
+// this.
+
+tree
+Type::do_make_expression_tree(Translate_context*, Expression_list*,
+ source_location)
+{
+ gcc_unreachable();
+}
+
+// Return a pointer to the type descriptor for this type.
+
+tree
+Type::type_descriptor_pointer(Gogo* gogo)
+{
+ Type* t = this->forwarded();
+ if (t->type_descriptor_decl_ == NULL_TREE)
+ {
+ Expression* e = t->do_type_descriptor(gogo, NULL);
+ gogo->build_type_descriptor_decl(t, e, &t->type_descriptor_decl_);
+ gcc_assert(t->type_descriptor_decl_ != NULL_TREE
+ && (t->type_descriptor_decl_ == error_mark_node
+ || DECL_P(t->type_descriptor_decl_)));
+ }
+ if (t->type_descriptor_decl_ == error_mark_node)
+ return error_mark_node;
+ return build_fold_addr_expr(t->type_descriptor_decl_);
+}
+
+// Return a composite literal for a type descriptor.
+
+Expression*
+Type::type_descriptor(Gogo* gogo, Type* type)
+{
+ return type->do_type_descriptor(gogo, NULL);
+}
+
+// Return a composite literal for a type descriptor with a name.
+
+Expression*
+Type::named_type_descriptor(Gogo* gogo, Type* type, Named_type* name)
+{
+ gcc_assert(name != NULL && type->named_type() != name);
+ return type->do_type_descriptor(gogo, name);
+}
+
+// Make a builtin struct type from a list of fields. The fields are
+// pairs of a name and a type.
+
+Struct_type*
+Type::make_builtin_struct_type(int nfields, ...)
+{
+ va_list ap;
+ va_start(ap, nfields);
+
+ source_location bloc = BUILTINS_LOCATION;
+ Struct_field_list* sfl = new Struct_field_list();
+ for (int i = 0; i < nfields; i++)
+ {
+ const char* field_name = va_arg(ap, const char *);
+ Type* type = va_arg(ap, Type*);
+ sfl->push_back(Struct_field(Typed_identifier(field_name, type, bloc)));
+ }
+
+ va_end(ap);
+
+ return Type::make_struct_type(sfl, bloc);
+}
+
+// A list of builtin named types.
+
+std::vector<Named_type*> Type::named_builtin_types;
+
+// Make a builtin named type.
+
+Named_type*
+Type::make_builtin_named_type(const char* name, Type* type)
+{
+ source_location bloc = BUILTINS_LOCATION;
+ Named_object* no = Named_object::make_type(name, NULL, type, bloc);
+ Named_type* ret = no->type_value();
+ Type::named_builtin_types.push_back(ret);
+ return ret;
+}
+
+// Convert the named builtin types.
+
+void
+Type::convert_builtin_named_types(Gogo* gogo)
+{
+ for (std::vector<Named_type*>::const_iterator p =
+ Type::named_builtin_types.begin();
+ p != Type::named_builtin_types.end();
+ ++p)
+ {
+ bool r = (*p)->verify();
+ gcc_assert(r);
+ (*p)->convert(gogo);
+ }
+}
+
+// Return the type of a type descriptor. We should really tie this to
+// runtime.Type rather than copying it. This must match commonType in
+// libgo/go/runtime/type.go.
+
+Type*
+Type::make_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* uint8_type = Type::lookup_integer_type("uint8");
+ Type* uint32_type = Type::lookup_integer_type("uint32");
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ // This is an unnamed version of unsafe.Pointer. Perhaps we
+ // should use the named version instead, although that would
+ // require us to create the unsafe package if it has not been
+ // imported. It probably doesn't matter.
+ Type* void_type = Type::make_void_type();
+ Type* unsafe_pointer_type = Type::make_pointer_type(void_type);
+
+ // Forward declaration for the type descriptor type.
+ Named_object* named_type_descriptor_type =
+ Named_object::make_type_declaration("commonType", NULL, bloc);
+ Type* ft = Type::make_forward_declaration(named_type_descriptor_type);
+ Type* pointer_type_descriptor_type = Type::make_pointer_type(ft);
+
+ // The type of a method on a concrete type.
+ Struct_type* method_type =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "mtyp", pointer_type_descriptor_type,
+ "typ", pointer_type_descriptor_type,
+ "tfn", unsafe_pointer_type);
+ Named_type* named_method_type =
+ Type::make_builtin_named_type("method", method_type);
+
+ // Information for types with a name or methods.
+ Type* slice_named_method_type =
+ Type::make_array_type(named_method_type, NULL);
+ Struct_type* uncommon_type =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "methods", slice_named_method_type);
+ Named_type* named_uncommon_type =
+ Type::make_builtin_named_type("uncommonType", uncommon_type);
+
+ Type* pointer_uncommon_type =
+ Type::make_pointer_type(named_uncommon_type);
+
+ // The type descriptor type.
+
+ Typed_identifier_list* params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Typed_identifier_list* results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ Type* hashfn_type = Type::make_function_type(NULL, params, results, bloc);
+
+ params = new Typed_identifier_list();
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", unsafe_pointer_type, bloc));
+ params->push_back(Typed_identifier("", uintptr_type, bloc));
+
+ results = new Typed_identifier_list();
+ results->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
+
+ Type* equalfn_type = Type::make_function_type(NULL, params, results,
+ bloc);
+
+ Struct_type* type_descriptor_type =
+ Type::make_builtin_struct_type(10,
+ "Kind", uint8_type,
+ "align", uint8_type,
+ "fieldAlign", uint8_type,
+ "size", uintptr_type,
+ "hash", uint32_type,
+ "hashfn", hashfn_type,
+ "equalfn", equalfn_type,
+ "string", pointer_string_type,
+ "", pointer_uncommon_type,
+ "ptrToThis",
+ pointer_type_descriptor_type);
+
+ Named_type* named = Type::make_builtin_named_type("commonType",
+ type_descriptor_type);
+
+ named_type_descriptor_type->set_type_value(named);
+
+ ret = named;
+ }
+
+ return ret;
+}
+
+// Make the type of a pointer to a type descriptor as represented in
+// Go.
+
+Type*
+Type::make_type_descriptor_ptr_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ ret = Type::make_pointer_type(Type::make_type_descriptor_type());
+ return ret;
+}
+
+// Return the names of runtime functions which compute a hash code for
+// this type and which compare whether two values of this type are
+// equal.
+
+void
+Type::type_functions(const char** hash_fn, const char** equal_fn) const
+{
+ switch (this->base()->classification())
+ {
+ case Type::TYPE_ERROR:
+ case Type::TYPE_VOID:
+ case Type::TYPE_NIL:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ *hash_fn = "__go_type_hash_identity";
+ *equal_fn = "__go_type_equal_identity";
+ break;
+
+ case Type::TYPE_STRING:
+ *hash_fn = "__go_type_hash_string";
+ *equal_fn = "__go_type_equal_string";
+ break;
+
+ case Type::TYPE_STRUCT:
+ case Type::TYPE_ARRAY:
+ // These types can not be hashed or compared.
+ *hash_fn = "__go_type_hash_error";
+ *equal_fn = "__go_type_equal_error";
+ break;
+
+ case Type::TYPE_INTERFACE:
+ if (this->interface_type()->is_empty())
+ {
+ *hash_fn = "__go_type_hash_empty_interface";
+ *equal_fn = "__go_type_equal_empty_interface";
+ }
+ else
+ {
+ *hash_fn = "__go_type_hash_interface";
+ *equal_fn = "__go_type_equal_interface";
+ }
+ break;
+
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ gcc_unreachable();
+
+ default:
+ gcc_unreachable();
+ }
+}
+
+// Return a composite literal for the type descriptor for a plain type
+// of kind RUNTIME_TYPE_KIND named NAME.
+
+Expression*
+Type::type_descriptor_constructor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* td_type = Type::make_type_descriptor_type();
+ const Struct_field_list* fields = td_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(9);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "Kind");
+ mpz_t iv;
+ mpz_init_set_ui(iv, runtime_type_kind);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "align");
+ Expression::Type_info type_info = Expression::TYPE_INFO_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "fieldAlign");
+ type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "size");
+ type_info = Expression::TYPE_INFO_SIZE;
+ vals->push_back(Expression::make_type_info(this, type_info));
+
+ ++p;
+ gcc_assert(p->field_name() == "hash");
+ mpz_set_ui(iv, this->hash_for_method(gogo));
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+
+ const char* hash_fn;
+ const char* equal_fn;
+ this->type_functions(&hash_fn, &equal_fn);
+
+ ++p;
+ gcc_assert(p->field_name() == "hashfn");
+ Function_type* fntype = p->type()->function_type();
+ Named_object* no = Named_object::make_function_declaration(hash_fn, NULL,
+ fntype,
+ bloc);
+ no->func_declaration_value()->set_asm_name(hash_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "equalfn");
+ fntype = p->type()->function_type();
+ no = Named_object::make_function_declaration(equal_fn, NULL, fntype, bloc);
+ no->func_declaration_value()->set_asm_name(equal_fn);
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "string");
+ Expression* s = Expression::make_string((name != NULL
+ ? name->reflection(gogo)
+ : this->reflection(gogo)),
+ bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "uncommonType");
+ if (name == NULL && methods == NULL)
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ if (methods == NULL)
+ methods = name->methods();
+ vals->push_back(this->uncommon_type_constructor(gogo,
+ p->type()->deref(),
+ name, methods,
+ only_value_methods));
+ }
+
+ ++p;
+ gcc_assert(p->field_name() == "ptrToThis");
+ if (name == NULL)
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ Type* pt = Type::make_pointer_type(name);
+ vals->push_back(Expression::make_type_descriptor(pt, bloc));
+ }
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ mpz_clear(iv);
+
+ return Expression::make_struct_composite_literal(td_type, vals, bloc);
+}
+
+// Return a composite literal for the uncommon type information for
+// this type. UNCOMMON_STRUCT_TYPE is the type of the uncommon type
+// struct. If name is not NULL, it is the name of the type. If
+// METHODS is not NULL, it is the list of methods. ONLY_VALUE_METHODS
+// is true if only value methods should be included. At least one of
+// NAME and METHODS must not be NULL.
+
+Expression*
+Type::uncommon_type_constructor(Gogo* gogo, Type* uncommon_type,
+ Named_type* name, const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = uncommon_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "name");
+
+ ++p;
+ gcc_assert(p->field_name() == "pkgPath");
+
+ if (name == NULL)
+ {
+ vals->push_back(Expression::make_nil(bloc));
+ vals->push_back(Expression::make_nil(bloc));
+ }
+ else
+ {
+ Named_object* no = name->named_object();
+ std::string n = Gogo::unpack_hidden_name(no->name());
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ if (name->is_builtin())
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ const Package* package = no->package();
+ const std::string& unique_prefix(package == NULL
+ ? gogo->unique_prefix()
+ : package->unique_prefix());
+ const std::string& package_name(package == NULL
+ ? gogo->package_name()
+ : package->name());
+ n.assign(unique_prefix);
+ n.append(1, '.');
+ n.append(package_name);
+ if (name->in_function() != NULL)
+ {
+ n.append(1, '.');
+ n.append(Gogo::unpack_hidden_name(name->in_function()->name()));
+ }
+ s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+ }
+
+ ++p;
+ gcc_assert(p->field_name() == "methods");
+ vals->push_back(this->methods_constructor(gogo, p->type(), methods,
+ only_value_methods));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ Expression* r = Expression::make_struct_composite_literal(uncommon_type,
+ vals, bloc);
+ return Expression::make_unary(OPERATOR_AND, r, bloc);
+}
+
+// Sort methods by name.
+
+class Sort_methods
+{
+ public:
+ bool
+ operator()(const std::pair<std::string, const Method*>& m1,
+ const std::pair<std::string, const Method*>& m2) const
+ { return m1.first < m2.first; }
+};
+
+// Return a composite literal for the type method table for this type.
+// METHODS_TYPE is the type of the table, and is a slice type.
+// METHODS is the list of methods. If ONLY_VALUE_METHODS is true,
+// then only value methods are used.
+
+Expression*
+Type::methods_constructor(Gogo* gogo, Type* methods_type,
+ const Methods* methods,
+ bool only_value_methods) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ std::vector<std::pair<std::string, const Method*> > smethods;
+ if (methods != NULL)
+ {
+ smethods.reserve(methods->count());
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->second->is_ambiguous())
+ continue;
+ if (only_value_methods && !p->second->is_value_method())
+ continue;
+ smethods.push_back(std::make_pair(p->first, p->second));
+ }
+ }
+
+ if (smethods.empty())
+ return Expression::make_slice_composite_literal(methods_type, NULL, bloc);
+
+ std::sort(smethods.begin(), smethods.end(), Sort_methods());
+
+ Type* method_type = methods_type->array_type()->element_type();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(smethods.size());
+ for (std::vector<std::pair<std::string, const Method*> >::const_iterator p
+ = smethods.begin();
+ p != smethods.end();
+ ++p)
+ vals->push_back(this->method_constructor(gogo, method_type, p->first,
+ p->second));
+
+ return Expression::make_slice_composite_literal(methods_type, vals, bloc);
+}
+
+// Return a composite literal for a single method. METHOD_TYPE is the
+// type of the entry. METHOD_NAME is the name of the method and M is
+// the method information.
+
+Expression*
+Type::method_constructor(Gogo*, Type* method_type,
+ const std::string& method_name,
+ const Method* m) const
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Struct_field_list* fields = method_type->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(5);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "name");
+ const std::string n = Gogo::unpack_hidden_name(method_name);
+ Expression* s = Expression::make_string(n, bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(method_name))
+ vals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Expression::make_string(Gogo::hidden_name_prefix(method_name), bloc);
+ vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ Named_object* no = (m->needs_stub_method()
+ ? m->stub_object()
+ : m->named_object());
+
+ Function_type* mtype;
+ if (no->is_function())
+ mtype = no->func_value()->type();
+ else
+ mtype = no->func_declaration_value()->type();
+ gcc_assert(mtype->is_method());
+ Type* nonmethod_type = mtype->copy_without_receiver();
+
+ ++p;
+ gcc_assert(p->field_name() == "mtyp");
+ vals->push_back(Expression::make_type_descriptor(nonmethod_type, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "typ");
+ vals->push_back(Expression::make_type_descriptor(mtype, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "tfn");
+ vals->push_back(Expression::make_func_reference(no, NULL, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(method_type, vals, bloc);
+}
+
+// Return a composite literal for the type descriptor of a plain type.
+// RUNTIME_TYPE_KIND is the value of the kind field. If NAME is not
+// NULL, it is the name to use as well as the list of methods.
+
+Expression*
+Type::plain_type_descriptor(Gogo* gogo, int runtime_type_kind,
+ Named_type* name)
+{
+ return this->type_descriptor_constructor(gogo, runtime_type_kind,
+ name, NULL, true);
+}
+
+// Return the type reflection string for this type.
+
+std::string
+Type::reflection(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_reflection virtual function should set RET to the
+ // reflection string.
+ this->do_reflection(gogo, &ret);
+
+ return ret;
+}
+
+// Return a mangled name for the type.
+
+std::string
+Type::mangled_name(Gogo* gogo) const
+{
+ std::string ret;
+
+ // The do_mangled_name virtual function should set RET to the
+ // mangled name. For a composite type it should append a code for
+ // the composition and then call do_mangled_name on the components.
+ this->do_mangled_name(gogo, &ret);
+
+ return ret;
+}
+
+// Default function to export a type.
+
+void
+Type::do_export(Export*) const
+{
+ gcc_unreachable();
+}
+
+// Import a type.
+
+Type*
+Type::import_type(Import* imp)
+{
+ if (imp->match_c_string("("))
+ return Function_type::do_import(imp);
+ else if (imp->match_c_string("*"))
+ return Pointer_type::do_import(imp);
+ else if (imp->match_c_string("struct "))
+ return Struct_type::do_import(imp);
+ else if (imp->match_c_string("["))
+ return Array_type::do_import(imp);
+ else if (imp->match_c_string("map "))
+ return Map_type::do_import(imp);
+ else if (imp->match_c_string("chan "))
+ return Channel_type::do_import(imp);
+ else if (imp->match_c_string("interface"))
+ return Interface_type::do_import(imp);
+ else
+ {
+ error_at(imp->location(), "import error: expected type");
+ return Type::make_error_type();
+ }
+}
+
+// A type used to indicate a parsing error. This exists to simplify
+// later error detection.
+
+class Error_type : public Type
+{
+ public:
+ Error_type()
+ : Type(TYPE_ERROR)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return error_mark_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { return error_mark_node; }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { return Expression::make_error(BUILTINS_LOCATION); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_assert(saw_errors()); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('E'); }
+};
+
+Type*
+Type::make_error_type()
+{
+ static Error_type singleton_error_type;
+ return &singleton_error_type;
+}
+
+// The void type.
+
+class Void_type : public Type
+{
+ public:
+ Void_type()
+ : Type(TYPE_VOID)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return void_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { gcc_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('v'); }
+};
+
+Type*
+Type::make_void_type()
+{
+ static Void_type singleton_void_type;
+ return &singleton_void_type;
+}
+
+// The boolean type.
+
+class Boolean_type : public Type
+{
+ public:
+ Boolean_type()
+ : Type(TYPE_BOOLEAN)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return boolean_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, boolean_false_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type* name);
+
+ // We should not be asked for the reflection string of a basic type.
+ void
+ do_reflection(Gogo*, std::string* ret) const
+ { ret->append("bool"); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('b'); }
+};
+
+// Make the type descriptor.
+
+Expression*
+Boolean_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_BOOL, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("bool");
+ gcc_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+Type*
+Type::make_boolean_type()
+{
+ static Boolean_type boolean_type;
+ return &boolean_type;
+}
+
+// The named type "bool".
+
+static Named_type* named_bool_type;
+
+// Get the named type "bool".
+
+Named_type*
+Type::lookup_bool_type()
+{
+ return named_bool_type;
+}
+
+// Make the named type "bool".
+
+Named_type*
+Type::make_named_bool_type()
+{
+ Type* bool_type = Type::make_boolean_type();
+ Named_object* named_object = Named_object::make_type("bool", NULL,
+ bool_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_bool_type = named_type;
+ return named_type;
+}
+
+// Class Integer_type.
+
+Integer_type::Named_integer_types Integer_type::named_integer_types;
+
+// Create a new integer type. Non-abstract integer types always have
+// names.
+
+Named_type*
+Integer_type::create_integer_type(const char* name, bool is_unsigned,
+ int bits, int runtime_type_kind)
+{
+ Integer_type* integer_type = new Integer_type(false, is_unsigned, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ integer_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_integer_types::iterator, bool> ins =
+ Integer_type::named_integer_types.insert(std::make_pair(sname, named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing integer type.
+
+Named_type*
+Integer_type::lookup_integer_type(const char* name)
+{
+ Named_integer_types::const_iterator p =
+ Integer_type::named_integer_types.find(name);
+ gcc_assert(p != Integer_type::named_integer_types.end());
+ return p->second;
+}
+
+// Create a new abstract integer type.
+
+Integer_type*
+Integer_type::create_abstract_integer_type()
+{
+ static Integer_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Integer_type(true, false, INT_TYPE_SIZE,
+ RUNTIME_TYPE_KIND_INT);
+ return abstract_type;
+}
+
+// Integer type compatibility.
+
+bool
+Integer_type::is_identical(const Integer_type* t) const
+{
+ if (this->is_unsigned_ != t->is_unsigned_ || this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Integer_type::do_hash_for_method(Gogo*) const
+{
+ return ((this->bits_ << 4)
+ + ((this->is_unsigned_ ? 1 : 0) << 8)
+ + ((this->is_abstract_ ? 1 : 0) << 9));
+}
+
+// Get the tree for an Integer_type.
+
+tree
+Integer_type::do_get_tree(Gogo*)
+{
+ if (this->is_abstract_)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ if (this->is_unsigned_)
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return unsigned_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return unsigned_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_unsigned_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_unsigned_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_unsigned_type_node;
+ else
+ return make_unsigned_type(this->bits_);
+ }
+ else
+ {
+ if (this->bits_ == INT_TYPE_SIZE)
+ return integer_type_node;
+ else if (this->bits_ == CHAR_TYPE_SIZE)
+ return signed_char_type_node;
+ else if (this->bits_ == SHORT_TYPE_SIZE)
+ return short_integer_type_node;
+ else if (this->bits_ == LONG_TYPE_SIZE)
+ return long_integer_type_node;
+ else if (this->bits_ == LONG_LONG_TYPE_SIZE)
+ return long_long_integer_type_node;
+ else
+ return make_signed_type(this->bits_);
+ }
+}
+
+tree
+Integer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ return is_clear ? NULL : build_int_cst(type_tree, 0);
+}
+
+// The type descriptor for an integer type. Integer types are always
+// named.
+
+Expression*
+Integer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Integer_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Integer_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "i%s%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->is_unsigned_ ? "u" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make an integer type.
+
+Named_type*
+Type::make_integer_type(const char* name, bool is_unsigned, int bits,
+ int runtime_type_kind)
+{
+ return Integer_type::create_integer_type(name, is_unsigned, bits,
+ runtime_type_kind);
+}
+
+// Make an abstract integer type.
+
+Integer_type*
+Type::make_abstract_integer_type()
+{
+ return Integer_type::create_abstract_integer_type();
+}
+
+// Look up an integer type.
+
+Named_type*
+Type::lookup_integer_type(const char* name)
+{
+ return Integer_type::lookup_integer_type(name);
+}
+
+// Class Float_type.
+
+Float_type::Named_float_types Float_type::named_float_types;
+
+// Create a new float type. Non-abstract float types always have
+// names.
+
+Named_type*
+Float_type::create_float_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Float_type* float_type = new Float_type(false, bits, runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL, float_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_float_types::iterator, bool> ins =
+ Float_type::named_float_types.insert(std::make_pair(sname, named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing float type.
+
+Named_type*
+Float_type::lookup_float_type(const char* name)
+{
+ Named_float_types::const_iterator p =
+ Float_type::named_float_types.find(name);
+ gcc_assert(p != Float_type::named_float_types.end());
+ return p->second;
+}
+
+// Create a new abstract float type.
+
+Float_type*
+Float_type::create_abstract_float_type()
+{
+ static Float_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Float_type(true, 64, RUNTIME_TYPE_KIND_FLOAT64);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Float_type::is_identical(const Float_type* t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Float_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Float_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE)
+ return float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE)
+ return double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE)
+ return long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_;
+ layout_type(ret);
+ return ret;
+ }
+}
+
+// Get a tree.
+
+tree
+Float_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+tree
+Float_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(type_tree), 0, 0, 0);
+ return build_real(type_tree, r);
+}
+
+// The type descriptor for a float type. Float types are always named.
+
+Expression*
+Float_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Float_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Float_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "f%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a floating point type.
+
+Named_type*
+Type::make_float_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Float_type::create_float_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract float type.
+
+Float_type*
+Type::make_abstract_float_type()
+{
+ return Float_type::create_abstract_float_type();
+}
+
+// Look up a float type.
+
+Named_type*
+Type::lookup_float_type(const char* name)
+{
+ return Float_type::lookup_float_type(name);
+}
+
+// Class Complex_type.
+
+Complex_type::Named_complex_types Complex_type::named_complex_types;
+
+// Create a new complex type. Non-abstract complex types always have
+// names.
+
+Named_type*
+Complex_type::create_complex_type(const char* name, int bits,
+ int runtime_type_kind)
+{
+ Complex_type* complex_type = new Complex_type(false, bits,
+ runtime_type_kind);
+ std::string sname(name);
+ Named_object* named_object = Named_object::make_type(sname, NULL,
+ complex_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ std::pair<Named_complex_types::iterator, bool> ins =
+ Complex_type::named_complex_types.insert(std::make_pair(sname,
+ named_type));
+ gcc_assert(ins.second);
+ return named_type;
+}
+
+// Look up an existing complex type.
+
+Named_type*
+Complex_type::lookup_complex_type(const char* name)
+{
+ Named_complex_types::const_iterator p =
+ Complex_type::named_complex_types.find(name);
+ gcc_assert(p != Complex_type::named_complex_types.end());
+ return p->second;
+}
+
+// Create a new abstract complex type.
+
+Complex_type*
+Complex_type::create_abstract_complex_type()
+{
+ static Complex_type* abstract_type;
+ if (abstract_type == NULL)
+ abstract_type = new Complex_type(true, 128, RUNTIME_TYPE_KIND_COMPLEX128);
+ return abstract_type;
+}
+
+// Whether this type is identical with T.
+
+bool
+Complex_type::is_identical(const Complex_type *t) const
+{
+ if (this->bits_ != t->bits_)
+ return false;
+ return this->is_abstract_ == t->is_abstract_;
+}
+
+// Hash code.
+
+unsigned int
+Complex_type::do_hash_for_method(Gogo*) const
+{
+ return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
+}
+
+// Get a tree without using a Gogo*.
+
+tree
+Complex_type::type_tree() const
+{
+ if (this->bits_ == FLOAT_TYPE_SIZE * 2)
+ return complex_float_type_node;
+ else if (this->bits_ == DOUBLE_TYPE_SIZE * 2)
+ return complex_double_type_node;
+ else if (this->bits_ == LONG_DOUBLE_TYPE_SIZE * 2)
+ return complex_long_double_type_node;
+ else
+ {
+ tree ret = make_node(REAL_TYPE);
+ TYPE_PRECISION(ret) = this->bits_ / 2;
+ layout_type(ret);
+ return build_complex_type(ret);
+ }
+}
+
+// Get a tree.
+
+tree
+Complex_type::do_get_tree(Gogo*)
+{
+ return this->type_tree();
+}
+
+// Zero initializer.
+
+tree
+Complex_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ REAL_VALUE_TYPE r;
+ real_from_integer(&r, TYPE_MODE(TREE_TYPE(type_tree)), 0, 0, 0);
+ return build_complex(type_tree, build_real(TREE_TYPE(type_tree), r),
+ build_real(TREE_TYPE(type_tree), r));
+}
+
+// The type descriptor for a complex type. Complex types are always
+// named.
+
+Expression*
+Complex_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+Complex_type::do_reflection(Gogo*, std::string*) const
+{
+ gcc_assert(saw_errors());
+}
+
+// Mangled name.
+
+void
+Complex_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ char buf[100];
+ snprintf(buf, sizeof buf, "c%s%de",
+ this->is_abstract_ ? "a" : "",
+ this->bits_);
+ ret->append(buf);
+}
+
+// Make a complex type.
+
+Named_type*
+Type::make_complex_type(const char* name, int bits, int runtime_type_kind)
+{
+ return Complex_type::create_complex_type(name, bits, runtime_type_kind);
+}
+
+// Make an abstract complex type.
+
+Complex_type*
+Type::make_abstract_complex_type()
+{
+ return Complex_type::create_abstract_complex_type();
+}
+
+// Look up a complex type.
+
+Named_type*
+Type::lookup_complex_type(const char* name)
+{
+ return Complex_type::lookup_complex_type(name);
+}
+
+// Class String_type.
+
+// Return the tree for String_type. A string is a struct with two
+// fields: a pointer to the characters and a length.
+
+tree
+String_type::do_get_tree(Gogo*)
+{
+ static tree struct_type;
+ return Gogo::builtin_struct(&struct_type, "__go_string", NULL_TREE, 2,
+ "__data",
+ build_pointer_type(unsigned_char_type_node),
+ "__length",
+ integer_type_node);
+}
+
+// Return a tree for the length of STRING.
+
+tree
+String_type::length_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ gcc_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree length_field = DECL_CHAIN(TYPE_FIELDS(string_type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(length_field)),
+ "__length") == 0);
+ return fold_build3(COMPONENT_REF, integer_type_node, string,
+ length_field, NULL_TREE);
+}
+
+// Return a tree for a pointer to the bytes of STRING.
+
+tree
+String_type::bytes_tree(Gogo*, tree string)
+{
+ tree string_type = TREE_TYPE(string);
+ gcc_assert(TREE_CODE(string_type) == RECORD_TYPE);
+ tree bytes_field = TYPE_FIELDS(string_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(bytes_field)),
+ "__data") == 0);
+ return fold_build3(COMPONENT_REF, TREE_TYPE(bytes_field), string,
+ bytes_field, NULL_TREE);
+}
+
+// We initialize a string to { NULL, 0 }.
+
+tree
+String_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL_TREE;
+
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt, gc)* init = VEC_alloc(constructor_elt, gc, 2);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type descriptor for the string type.
+
+Expression*
+String_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (name != NULL)
+ return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_STRING, name);
+ else
+ {
+ Named_object* no = gogo->lookup_global("string");
+ gcc_assert(no != NULL);
+ return Type::type_descriptor(gogo, no->type_value());
+ }
+}
+
+// We should not be asked for the reflection string of a basic type.
+
+void
+String_type::do_reflection(Gogo*, std::string* ret) const
+{
+ ret->append("string");
+}
+
+// Mangled name of a string type.
+
+void
+String_type::do_mangled_name(Gogo*, std::string* ret) const
+{
+ ret->push_back('z');
+}
+
+// Make a string type.
+
+Type*
+Type::make_string_type()
+{
+ static String_type string_type;
+ return &string_type;
+}
+
+// The named type "string".
+
+static Named_type* named_string_type;
+
+// Get the named type "string".
+
+Named_type*
+Type::lookup_string_type()
+{
+ return named_string_type;
+}
+
+// Make the named type string.
+
+Named_type*
+Type::make_named_string_type()
+{
+ Type* string_type = Type::make_string_type();
+ Named_object* named_object = Named_object::make_type("string", NULL,
+ string_type,
+ BUILTINS_LOCATION);
+ Named_type* named_type = named_object->type_value();
+ named_string_type = named_type;
+ return named_type;
+}
+
+// The sink type. This is the type of the blank identifier _. Any
+// type may be assigned to it.
+
+class Sink_type : public Type
+{
+ public:
+ Sink_type()
+ : Type(TYPE_SINK)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { gcc_unreachable(); }
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ { gcc_unreachable(); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+};
+
+// Make the sink type.
+
+Type*
+Type::make_sink_type()
+{
+ static Sink_type sink_type;
+ return &sink_type;
+}
+
+// Class Function_type.
+
+// Traversal.
+
+int
+Function_type::do_traverse(Traverse* traverse)
+{
+ if (this->receiver_ != NULL
+ && Type::traverse(this->receiver_->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->parameters_ != NULL
+ && this->parameters_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->results_ != NULL
+ && this->results_->traverse(traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Returns whether T is a valid redeclaration of this type. If this
+// returns false, and REASON is not NULL, *REASON may be set to a
+// brief explanation of why it returned false.
+
+bool
+Function_type::is_valid_redeclaration(const Function_type* t,
+ std::string* reason) const
+{
+ if (!this->is_identical(t, false, true, reason))
+ return false;
+
+ // A redeclaration of a function is required to use the same names
+ // for the receiver and parameters.
+ if (this->receiver() != NULL
+ && this->receiver()->name() != t->receiver()->name()
+ && this->receiver()->name() != Import::import_marker
+ && t->receiver()->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "receiver name changed";
+ return false;
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1->name() != p2->name()
+ && p1->name() != Import::import_marker
+ && p2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "parameter name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = p1->type()->forwarded();
+ Type* t2 = p2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1->name() != res2->name()
+ && res1->name() != Import::import_marker
+ && res2->name() != Import::import_marker)
+ {
+ if (reason != NULL)
+ *reason = "result name changed";
+ return false;
+ }
+
+ // This is called at parse time, so we may have unknown
+ // types.
+ Type* t1 = res1->type()->forwarded();
+ Type* t2 = res2->type()->forwarded();
+ if (t1 != t2
+ && t1->forward_declaration_type() != NULL
+ && (t2->forward_declaration_type() == NULL
+ || (t1->forward_declaration_type()->named_object()
+ != t2->forward_declaration_type()->named_object())))
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Check whether T is the same as this type.
+
+bool
+Function_type::is_identical(const Function_type* t, bool ignore_receiver,
+ bool errors_are_identical,
+ std::string* reason) const
+{
+ if (!ignore_receiver)
+ {
+ const Typed_identifier* r1 = this->receiver();
+ const Typed_identifier* r2 = t->receiver();
+ if ((r1 != NULL) != (r2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different receiver types");
+ return false;
+ }
+ if (r1 != NULL)
+ {
+ if (!Type::are_identical(r1->type(), r2->type(), errors_are_identical,
+ reason))
+ {
+ if (reason != NULL && !reason->empty())
+ *reason = "receiver: " + *reason;
+ return false;
+ }
+ }
+ }
+
+ const Typed_identifier_list* parms1 = this->parameters();
+ const Typed_identifier_list* parms2 = t->parameters();
+ if ((parms1 != NULL) != (parms2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ if (parms1 != NULL)
+ {
+ Typed_identifier_list::const_iterator p1 = parms1->begin();
+ for (Typed_identifier_list::const_iterator p2 = parms2->begin();
+ p2 != parms2->end();
+ ++p2, ++p1)
+ {
+ if (p1 == parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+
+ if (!Type::are_identical(p1->type(), p2->type(),
+ errors_are_identical, NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different parameter types");
+ return false;
+ }
+ }
+ if (p1 != parms1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of parameters");
+ return false;
+ }
+ }
+
+ if (this->is_varargs() != t->is_varargs())
+ {
+ if (reason != NULL)
+ *reason = _("different varargs");
+ return false;
+ }
+
+ const Typed_identifier_list* results1 = this->results();
+ const Typed_identifier_list* results2 = t->results();
+ if ((results1 != NULL) != (results2 != NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ if (results1 != NULL)
+ {
+ Typed_identifier_list::const_iterator res1 = results1->begin();
+ for (Typed_identifier_list::const_iterator res2 = results2->begin();
+ res2 != results2->end();
+ ++res2, ++res1)
+ {
+ if (res1 == results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+
+ if (!Type::are_identical(res1->type(), res2->type(),
+ errors_are_identical, NULL))
+ {
+ if (reason != NULL)
+ *reason = _("different result types");
+ return false;
+ }
+ }
+ if (res1 != results1->end())
+ {
+ if (reason != NULL)
+ *reason = _("different number of results");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Function_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ // We ignore the receiver type for hash codes, because we need to
+ // get the same hash code for a method in an interface and a method
+ // declared for a type. The former will not have a receiver.
+ if (this->parameters_ != NULL)
+ {
+ int shift = 1;
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->results_ != NULL)
+ {
+ int shift = 2;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p, ++shift)
+ ret += p->type()->hash_for_method(gogo) << shift;
+ }
+ if (this->is_varargs_)
+ ret += 1;
+ ret <<= 4;
+ return ret;
+}
+
+// Get the tree for a function type.
+
+tree
+Function_type::do_get_tree(Gogo* gogo)
+{
+ tree args = NULL_TREE;
+ tree* pp = &args;
+
+ if (this->receiver_ != NULL)
+ {
+ Type* rtype = this->receiver_->type();
+ tree ptype = rtype->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+
+ // We always pass the address of the receiver parameter, in
+ // order to make interface calls work with unknown types.
+ if (rtype->points_to() == NULL)
+ ptype = build_pointer_type(ptype);
+
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+
+ if (this->parameters_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ tree ptype = p->type()->get_tree(gogo);
+ if (ptype == error_mark_node)
+ return error_mark_node;
+ *pp = tree_cons (NULL_TREE, ptype, NULL_TREE);
+ pp = &TREE_CHAIN (*pp);
+ }
+ }
+
+ // Varargs is handled entirely at the Go level. At the tree level,
+ // functions are not varargs.
+ *pp = void_list_node;
+
+ tree result;
+ if (this->results_ == NULL)
+ result = void_type_node;
+ else if (this->results_->size() == 1)
+ result = this->results_->begin()->type()->get_tree(gogo);
+ else
+ {
+ result = make_node(RECORD_TYPE);
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Typed_identifier_list::const_iterator p = this->results_->begin();
+ p != this->results_->end();
+ ++p)
+ {
+ const std::string name = (p->name().empty()
+ ? "UNNAMED"
+ : Gogo::unpack_hidden_name(p->name()));
+ tree name_tree = get_identifier_with_length(name.data(),
+ name.length());
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = result;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+ TYPE_FIELDS(result) = field_trees;
+ layout_type(result);
+ }
+
+ if (result == error_mark_node)
+ return error_mark_node;
+
+ tree fntype = build_function_type(result, args);
+ if (fntype == error_mark_node)
+ return fntype;
+
+ return build_pointer_type(fntype);
+}
+
+// Functions are initialized to NULL.
+
+tree
+Function_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a function type descriptor.
+
+Type*
+Function_type::make_function_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* bool_type = Type::lookup_bool_type();
+
+ Type* slice_type = Type::make_array_type(ptdt, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(4,
+ "", tdt,
+ "dotdotdot", bool_type,
+ "in", slice_type,
+ "out", slice_type);
+
+ ret = Type::make_builtin_named_type("FuncType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a function type.
+
+Expression*
+Function_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ftdt = Function_type::make_function_type_descriptor_type();
+
+ const Struct_field_list* fields = ftdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(4);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_FUNC,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "dotdotdot");
+ vals->push_back(Expression::make_boolean(this->is_varargs(), bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "in");
+ vals->push_back(this->type_descriptor_params(p->type(), this->receiver(),
+ this->parameters()));
+
+ ++p;
+ gcc_assert(p->field_name() == "out");
+ vals->push_back(this->type_descriptor_params(p->type(), NULL,
+ this->results()));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ftdt, vals, bloc);
+}
+
+// Return a composite literal for the parameters or results of a type
+// descriptor.
+
+Expression*
+Function_type::type_descriptor_params(Type* params_type,
+ const Typed_identifier* receiver,
+ const Typed_identifier_list* params)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ if (receiver == NULL && params == NULL)
+ return Expression::make_slice_composite_literal(params_type, NULL, bloc);
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve((params == NULL ? 0 : params->size())
+ + (receiver != NULL ? 1 : 0));
+
+ if (receiver != NULL)
+ {
+ Type* rtype = receiver->type();
+ // The receiver is always passed as a pointer. FIXME: Is this
+ // right? Should that fact affect the type descriptor?
+ if (rtype->points_to() == NULL)
+ rtype = Type::make_pointer_type(rtype);
+ vals->push_back(Expression::make_type_descriptor(rtype, bloc));
+ }
+
+ if (params != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ vals->push_back(Expression::make_type_descriptor(p->type(), bloc));
+ }
+
+ return Expression::make_slice_composite_literal(params_type, vals, bloc);
+}
+
+// The reflection string.
+
+void
+Function_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ // FIXME: Turn this off until we straighten out the type of the
+ // struct field used in a go statement which calls a method.
+ // gcc_assert(this->receiver_ == NULL);
+
+ ret->append("func");
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('(');
+ this->append_reflection(this->receiver_->type(), gogo, ret);
+ ret->push_back(')');
+ }
+
+ ret->push_back('(');
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ if (p != params->begin())
+ ret->append(", ");
+ if (!is_varargs || p + 1 != params->end())
+ this->append_reflection(p->type(), gogo, ret);
+ else
+ {
+ ret->append("...");
+ this->append_reflection(p->type()->array_type()->element_type(),
+ gogo, ret);
+ }
+ }
+ }
+ ret->push_back(')');
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL && !results->empty())
+ {
+ if (results->size() == 1)
+ ret->push_back(' ');
+ else
+ ret->append(" (");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (p != results->begin())
+ ret->append(", ");
+ this->append_reflection(p->type(), gogo, ret);
+ }
+ if (results->size() > 1)
+ ret->push_back(')');
+ }
+}
+
+// Mangled name.
+
+void
+Function_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('F');
+
+ if (this->receiver_ != NULL)
+ {
+ ret->push_back('m');
+ this->append_mangled_name(this->receiver_->type(), gogo, ret);
+ }
+
+ const Typed_identifier_list* params = this->parameters();
+ if (params != NULL)
+ {
+ ret->push_back('p');
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (this->is_varargs_)
+ ret->push_back('V');
+ ret->push_back('e');
+ }
+
+ const Typed_identifier_list* results = this->results();
+ if (results != NULL)
+ {
+ ret->push_back('r');
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ this->append_mangled_name(p->type(), gogo, ret);
+ ret->push_back('e');
+ }
+
+ ret->push_back('e');
+}
+
+// Export a function type.
+
+void
+Function_type::do_export(Export* exp) const
+{
+ // We don't write out the receiver. The only function types which
+ // should have a receiver are the ones associated with explicitly
+ // defined methods. For those the receiver type is written out by
+ // Function::export_func.
+
+ exp->write_c_string("(");
+ bool first = true;
+ if (this->parameters_ != NULL)
+ {
+ bool is_varargs = this->is_varargs_;
+ for (Typed_identifier_list::const_iterator p =
+ this->parameters_->begin();
+ p != this->parameters_->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || p + 1 != this->parameters_->end())
+ exp->write_type(p->type());
+ else
+ {
+ exp->write_c_string("...");
+ exp->write_type(p->type()->array_type()->element_type());
+ }
+ }
+ }
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = this->results_;
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p = results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+}
+
+// Import a function type.
+
+Function_type*
+Function_type::do_import(Import* imp)
+{
+ imp->require_c_string("(");
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list();
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ imp->advance(1);
+ results = new Typed_identifier_list;
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker, rtype,
+ imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* ret = Type::make_function_type(NULL, parameters, results,
+ imp->location());
+ if (is_varargs)
+ ret->set_is_varargs();
+ return ret;
+}
+
+// Make a copy of a function type without a receiver.
+
+Function_type*
+Function_type::copy_without_receiver() const
+{
+ gcc_assert(this->is_method());
+ Function_type *ret = Type::make_function_type(NULL, this->parameters_,
+ this->results_,
+ this->location_);
+ if (this->is_varargs())
+ ret->set_is_varargs();
+ if (this->is_builtin())
+ ret->set_is_builtin();
+ return ret;
+}
+
+// Make a copy of a function type with a receiver.
+
+Function_type*
+Function_type::copy_with_receiver(Type* receiver_type) const
+{
+ gcc_assert(!this->is_method());
+ Typed_identifier* receiver = new Typed_identifier("", receiver_type,
+ this->location_);
+ return Type::make_function_type(receiver, this->parameters_,
+ this->results_, this->location_);
+}
+
+// Make a function type.
+
+Function_type*
+Type::make_function_type(Typed_identifier* receiver,
+ Typed_identifier_list* parameters,
+ Typed_identifier_list* results,
+ source_location location)
+{
+ return new Function_type(receiver, parameters, results, location);
+}
+
+// Class Pointer_type.
+
+// Traversal.
+
+int
+Pointer_type::do_traverse(Traverse* traverse)
+{
+ return Type::traverse(this->to_type_, traverse);
+}
+
+// Hash code.
+
+unsigned int
+Pointer_type::do_hash_for_method(Gogo* gogo) const
+{
+ return this->to_type_->hash_for_method(gogo) << 4;
+}
+
+// The tree for a pointer type.
+
+tree
+Pointer_type::do_get_tree(Gogo* gogo)
+{
+ return build_pointer_type(this->to_type_->get_tree(gogo));
+}
+
+// Initialize a pointer type.
+
+tree
+Pointer_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// The type of a pointer type descriptor.
+
+Type*
+Pointer_type::make_pointer_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("PtrType", s);
+ }
+
+ return ret;
+}
+
+// The type descriptor for a pointer type.
+
+Expression*
+Pointer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->is_unsafe_pointer_type())
+ {
+ gcc_assert(name != NULL);
+ return this->plain_type_descriptor(gogo,
+ RUNTIME_TYPE_KIND_UNSAFE_POINTER,
+ name);
+ }
+ else
+ {
+ source_location bloc = BUILTINS_LOCATION;
+
+ const Methods* methods;
+ Type* deref = this->points_to();
+ if (deref->named_type() != NULL)
+ methods = deref->named_type()->methods();
+ else if (deref->struct_type() != NULL)
+ methods = deref->struct_type()->methods();
+ else
+ methods = NULL;
+
+ Type* ptr_tdt = Pointer_type::make_pointer_type_descriptor_type();
+
+ const Struct_field_list* fields = ptr_tdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_PTR,
+ name, methods, false));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(deref, bloc));
+
+ return Expression::make_struct_composite_literal(ptr_tdt, vals, bloc);
+ }
+}
+
+// Reflection string.
+
+void
+Pointer_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('*');
+ this->append_reflection(this->to_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Pointer_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('p');
+ this->append_mangled_name(this->to_type_, gogo, ret);
+}
+
+// Export.
+
+void
+Pointer_type::do_export(Export* exp) const
+{
+ exp->write_c_string("*");
+ if (this->is_unsafe_pointer_type())
+ exp->write_c_string("any");
+ else
+ exp->write_type(this->to_type_);
+}
+
+// Import.
+
+Pointer_type*
+Pointer_type::do_import(Import* imp)
+{
+ imp->require_c_string("*");
+ if (imp->match_c_string("any"))
+ {
+ imp->advance(3);
+ return Type::make_pointer_type(Type::make_void_type());
+ }
+ Type* to = imp->read_type();
+ return Type::make_pointer_type(to);
+}
+
+// Make a pointer type.
+
+Pointer_type*
+Type::make_pointer_type(Type* to_type)
+{
+ typedef Unordered_map(Type*, Pointer_type*) Hashtable;
+ static Hashtable pointer_types;
+ Hashtable::const_iterator p = pointer_types.find(to_type);
+ if (p != pointer_types.end())
+ return p->second;
+ Pointer_type* ret = new Pointer_type(to_type);
+ pointer_types[to_type] = ret;
+ return ret;
+}
+
+// The nil type. We use a special type for nil because it is not the
+// same as any other type. In C term nil has type void*, but there is
+// no such type in Go.
+
+class Nil_type : public Type
+{
+ public:
+ Nil_type()
+ : Type(TYPE_NIL)
+ { }
+
+ protected:
+ tree
+ do_get_tree(Gogo*)
+ { return ptr_type_node; }
+
+ tree
+ do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+ { return is_clear ? NULL : fold_convert(type_tree, null_pointer_node); }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ { gcc_unreachable(); }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_unreachable(); }
+
+ void
+ do_mangled_name(Gogo*, std::string* ret) const
+ { ret->push_back('n'); }
+};
+
+// Make the nil type.
+
+Type*
+Type::make_nil_type()
+{
+ static Nil_type singleton_nil_type;
+ return &singleton_nil_type;
+}
+
+// The type of a function call which returns multiple values. This is
+// really a struct, but we don't want to confuse a function call which
+// returns a struct with a function call which returns multiple
+// values.
+
+class Call_multiple_result_type : public Type
+{
+ public:
+ Call_multiple_result_type(Call_expression* call)
+ : Type(TYPE_CALL_MULTIPLE_RESULT),
+ call_(call)
+ { }
+
+ protected:
+ bool
+ do_has_pointer() const
+ {
+ gcc_assert(saw_errors());
+ return false;
+ }
+
+ tree
+ do_get_tree(Gogo*);
+
+ tree
+ do_get_init_tree(Gogo*, tree, bool)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ Expression*
+ do_type_descriptor(Gogo*, Named_type*)
+ {
+ gcc_assert(saw_errors());
+ return Expression::make_error(UNKNOWN_LOCATION);
+ }
+
+ void
+ do_reflection(Gogo*, std::string*) const
+ { gcc_assert(saw_errors()); }
+
+ void
+ do_mangled_name(Gogo*, std::string*) const
+ { gcc_assert(saw_errors()); }
+
+ private:
+ // The expression being called.
+ Call_expression* call_;
+};
+
+// Return the tree for a call result.
+
+tree
+Call_multiple_result_type::do_get_tree(Gogo* gogo)
+{
+ Function_type* fntype = this->call_->get_function_type();
+ gcc_assert(fntype != NULL);
+ const Typed_identifier_list* results = fntype->results();
+ gcc_assert(results != NULL && results->size() > 1);
+ tree fntype_tree = fntype->get_tree(gogo);
+ if (fntype_tree == error_mark_node)
+ return error_mark_node;
+ return TREE_TYPE(fntype_tree);
+}
+
+// Make a call result type.
+
+Type*
+Type::make_call_multiple_result_type(Call_expression* call)
+{
+ return new Call_multiple_result_type(call);
+}
+
+// Class Struct_field.
+
+// Get the name of a field.
+
+const std::string&
+Struct_field::field_name() const
+{
+ const std::string& name(this->typed_identifier_.name());
+ if (!name.empty())
+ return name;
+ else
+ {
+ // This is called during parsing, before anything is lowered, so
+ // we have to be pretty careful to avoid dereferencing an
+ // unknown type name.
+ Type* t = this->typed_identifier_.type();
+ Type* dt = t;
+ if (t->classification() == Type::TYPE_POINTER)
+ {
+ // Very ugly.
+ Pointer_type* ptype = static_cast<Pointer_type*>(t);
+ dt = ptype->points_to();
+ }
+ if (dt->forward_declaration_type() != NULL)
+ return dt->forward_declaration_type()->name();
+ else if (dt->named_type() != NULL)
+ return dt->named_type()->name();
+ else if (t->is_error_type() || dt->is_error_type())
+ {
+ static const std::string error_string = "*error*";
+ return error_string;
+ }
+ else
+ {
+ // Avoid crashing in the erroneous case where T is named but
+ // DT is not.
+ gcc_assert(t != dt);
+ if (t->forward_declaration_type() != NULL)
+ return t->forward_declaration_type()->name();
+ else if (t->named_type() != NULL)
+ return t->named_type()->name();
+ else
+ gcc_unreachable();
+ }
+ }
+}
+
+// Class Struct_type.
+
+// Traversal.
+
+int
+Struct_type::do_traverse(Traverse* traverse)
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that the struct type is complete and valid.
+
+bool
+Struct_type::do_verify()
+{
+ Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return true;
+ bool ret = true;
+ for (Struct_field_list::iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ Type* t = p->type();
+ if (t->is_undefined())
+ {
+ error_at(p->location(), "struct field type is incomplete");
+ p->set_type(Type::make_error_type());
+ ret = false;
+ }
+ else if (p->is_anonymous())
+ {
+ if (t->named_type() != NULL && t->points_to() != NULL)
+ {
+ error_at(p->location(), "embedded type may not be a pointer");
+ p->set_type(Type::make_error_type());
+ return false;
+ }
+ }
+ }
+ return ret;
+}
+
+// Whether this contains a pointer.
+
+bool
+Struct_type::do_has_pointer() const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->type()->has_pointer())
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical to T.
+
+bool
+Struct_type::is_identical(const Struct_type* t,
+ bool errors_are_identical) const
+{
+ const Struct_field_list* fields1 = this->fields();
+ const Struct_field_list* fields2 = t->fields();
+ if (fields1 == NULL || fields2 == NULL)
+ return fields1 == fields2;
+ Struct_field_list::const_iterator pf2 = fields2->begin();
+ for (Struct_field_list::const_iterator pf1 = fields1->begin();
+ pf1 != fields1->end();
+ ++pf1, ++pf2)
+ {
+ if (pf2 == fields2->end())
+ return false;
+ if (pf1->field_name() != pf2->field_name())
+ return false;
+ if (pf1->is_anonymous() != pf2->is_anonymous()
+ || !Type::are_identical(pf1->type(), pf2->type(),
+ errors_are_identical, NULL))
+ return false;
+ if (!pf1->has_tag())
+ {
+ if (pf2->has_tag())
+ return false;
+ }
+ else
+ {
+ if (!pf2->has_tag())
+ return false;
+ if (pf1->tag() != pf2->tag())
+ return false;
+ }
+ }
+ if (pf2 != fields2->end())
+ return false;
+ return true;
+}
+
+// Whether this struct type has any hidden fields.
+
+bool
+Struct_type::struct_has_hidden_fields(const Named_type* within,
+ std::string* reason) const
+{
+ const Struct_field_list* fields = this->fields();
+ if (fields == NULL)
+ return false;
+ const Package* within_package = (within == NULL
+ ? NULL
+ : within->named_object()->package());
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (within_package != NULL
+ && !pf->is_anonymous()
+ && Gogo::is_hidden_name(pf->field_name()))
+ {
+ if (reason != NULL)
+ {
+ std::string within_name = within->named_object()->message_name();
+ std::string name = Gogo::message_name(pf->field_name());
+ size_t bufsize = 200 + within_name.length() + name.length();
+ char* buf = new char[bufsize];
+ snprintf(buf, bufsize,
+ _("implicit assignment of %s%s%s hidden field %s%s%s"),
+ open_quote, within_name.c_str(), close_quote,
+ open_quote, name.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return true;
+ }
+
+ if (pf->type()->has_hidden_fields(within, reason))
+ return true;
+ }
+
+ return false;
+}
+
+// Hash code.
+
+unsigned int
+Struct_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->fields() != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = this->fields()->begin();
+ pf != this->fields()->end();
+ ++pf)
+ ret = (ret << 1) + pf->type()->hash_for_method(gogo);
+ }
+ return ret <<= 2;
+}
+
+// Find the local field NAME.
+
+const Struct_field*
+Struct_type::find_local_field(const std::string& name,
+ unsigned int *pindex) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ if (pindex != NULL)
+ *pindex = i;
+ return &*pf;
+ }
+ }
+ return NULL;
+}
+
+// Return an expression for field NAME in STRUCT_EXPR, or NULL.
+
+Field_reference_expression*
+Struct_type::field_reference(Expression* struct_expr, const std::string& name,
+ source_location location) const
+{
+ unsigned int depth;
+ return this->field_reference_depth(struct_expr, name, location, NULL,
+ &depth);
+}
+
+// Return an expression for a field, along with the depth at which it
+// was found.
+
+Field_reference_expression*
+Struct_type::field_reference_depth(Expression* struct_expr,
+ const std::string& name,
+ source_location location,
+ Saw_named_type* saw,
+ unsigned int* depth) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields == NULL)
+ return NULL;
+
+ // Look for a field with this name.
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (pf->field_name() == name)
+ {
+ *depth = 0;
+ return Expression::make_field_reference(struct_expr, i, location);
+ }
+ }
+
+ // Look for an anonymous field which contains a field with this
+ // name.
+ unsigned int found_depth = 0;
+ Field_reference_expression* ret = NULL;
+ i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Struct_type* st = pf->type()->deref()->struct_type();
+ if (st == NULL)
+ continue;
+
+ Saw_named_type* hold_saw = saw;
+ Saw_named_type saw_here;
+ Named_type* nt = pf->type()->named_type();
+ if (nt == NULL)
+ nt = pf->type()->deref()->named_type();
+ if (nt != NULL)
+ {
+ Saw_named_type* q;
+ for (q = saw; q != NULL; q = q->next)
+ {
+ if (q->nt == nt)
+ {
+ // If this is an error, it will be reported
+ // elsewhere.
+ break;
+ }
+ }
+ if (q != NULL)
+ continue;
+ saw_here.next = saw;
+ saw_here.nt = nt;
+ saw = &saw_here;
+ }
+
+ // Look for a reference using a NULL struct expression. If we
+ // find one, fill in the struct expression with a reference to
+ // this field.
+ unsigned int subdepth;
+ Field_reference_expression* sub = st->field_reference_depth(NULL, name,
+ location,
+ saw,
+ &subdepth);
+
+ saw = hold_saw;
+
+ if (sub == NULL)
+ continue;
+
+ if (ret == NULL || subdepth < found_depth)
+ {
+ if (ret != NULL)
+ delete ret;
+ ret = sub;
+ found_depth = subdepth;
+ Expression* here = Expression::make_field_reference(struct_expr, i,
+ location);
+ if (pf->type()->points_to() != NULL)
+ here = Expression::make_unary(OPERATOR_MULT, here, location);
+ while (sub->expr() != NULL)
+ {
+ sub = sub->expr()->deref()->field_reference_expression();
+ gcc_assert(sub != NULL);
+ }
+ sub->set_struct_expression(here);
+ }
+ else if (subdepth > found_depth)
+ delete sub;
+ else
+ {
+ // We do not handle ambiguity here--it should be handled by
+ // Type::bind_field_or_method.
+ delete sub;
+ found_depth = 0;
+ ret = NULL;
+ }
+ }
+
+ if (ret != NULL)
+ *depth = found_depth + 1;
+
+ return ret;
+}
+
+// Return the total number of fields, including embedded fields.
+
+unsigned int
+Struct_type::total_field_count() const
+{
+ if (this->fields_ == NULL)
+ return 0;
+ unsigned int ret = 0;
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ if (!pf->is_anonymous() || pf->type()->deref()->struct_type() == NULL)
+ ++ret;
+ else
+ ret += pf->type()->struct_type()->total_field_count();
+ }
+ return ret;
+}
+
+// Return whether NAME is an unexported field, for better error reporting.
+
+bool
+Struct_type::is_unexported_local_field(Gogo* gogo,
+ const std::string& name) const
+{
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ const std::string& field_name(pf->field_name());
+ if (Gogo::is_hidden_name(field_name)
+ && name == Gogo::unpack_hidden_name(field_name)
+ && gogo->pack_hidden_name(name, false) != field_name)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Finalize the methods of an unnamed struct.
+
+void
+Struct_type::finalize_methods(Gogo* gogo)
+{
+ if (this->all_methods_ != NULL)
+ return;
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Struct_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Get the tree for a struct type.
+
+tree
+Struct_type::do_get_tree(Gogo* gogo)
+{
+ tree type = make_node(RECORD_TYPE);
+ return this->fill_in_tree(gogo, type);
+}
+
+// Fill in the fields for a struct type.
+
+tree
+Struct_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->field_name());
+ tree name_tree = get_identifier_with_length(name.data(), name.length());
+
+ tree field_type_tree = p->type()->get_tree(gogo);
+ if (field_type_tree == error_mark_node)
+ return error_mark_node;
+ gcc_assert(TYPE_SIZE(field_type_tree) != NULL_TREE);
+
+ tree field = build_decl(p->location(), FIELD_DECL, name_tree,
+ field_type_tree);
+ DECL_CONTEXT(field) = type;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ }
+
+ TYPE_FIELDS(type) = field_trees;
+
+ layout_type(type);
+
+ return type;
+}
+
+// Initialize struct fields.
+
+tree
+Struct_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->fields_ == NULL || this->fields_->empty())
+ {
+ if (is_clear)
+ return NULL;
+ else
+ {
+ tree ret = build_constructor(type_tree,
+ VEC_alloc(constructor_elt, gc, 0));
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ }
+
+ bool is_constant = true;
+ bool any_fields_set = false;
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc,
+ this->fields_->size());
+
+ tree field = TYPE_FIELDS(type_tree);
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p, field = DECL_CHAIN(field))
+ {
+ tree value = p->type()->get_init_tree(gogo, is_clear);
+ if (value == error_mark_node)
+ return error_mark_node;
+ gcc_assert(field != NULL_TREE);
+ if (value != NULL)
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = value;
+ any_fields_set = true;
+ if (!TREE_CONSTANT(value))
+ is_constant = false;
+ }
+ }
+ gcc_assert(field == NULL_TREE);
+
+ if (!any_fields_set)
+ {
+ gcc_assert(is_clear);
+ VEC_free(constructor_elt, gc, init);
+ return NULL;
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ if (is_constant)
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of a struct type descriptor.
+
+Type*
+Struct_type::make_struct_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(5,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt,
+ "tag", pointer_string_type,
+ "offset", uintptr_type);
+ Type* nsf = Type::make_builtin_named_type("structField", sf);
+
+ Type* slice_type = Type::make_array_type(nsf, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "fields", slice_type);
+
+ ret = Type::make_builtin_named_type("StructType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a struct type.
+
+Expression*
+Struct_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Struct_type::make_struct_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ const Methods* methods = this->methods();
+ // A named struct should not have methods--the methods should attach
+ // to the named type.
+ gcc_assert(methods == NULL || name == NULL);
+
+ Struct_field_list::const_iterator ps = fields->begin();
+ gcc_assert(ps->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_STRUCT,
+ name, methods, true));
+
+ ++ps;
+ gcc_assert(ps->field_name() == "fields");
+
+ Expression_list* elements = new Expression_list();
+ elements->reserve(this->fields_->size());
+ Type* element_type = ps->type()->array_type()->element_type();
+ for (Struct_field_list::const_iterator pf = this->fields_->begin();
+ pf != this->fields_->end();
+ ++pf)
+ {
+ const Struct_field_list* f = element_type->struct_type()->fields();
+
+ Expression_list* fvals = new Expression_list();
+ fvals->reserve(5);
+
+ Struct_field_list::const_iterator q = f->begin();
+ gcc_assert(q->field_name() == "name");
+ if (pf->is_anonymous())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pf->field_name()))
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ std::string n = Gogo::hidden_name_prefix(pf->field_name());
+ Expression* s = Expression::make_string(n, bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "typ");
+ fvals->push_back(Expression::make_type_descriptor(pf->type(), bloc));
+
+ ++q;
+ gcc_assert(q->field_name() == "tag");
+ if (!pf->has_tag())
+ fvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ Expression* s = Expression::make_string(pf->tag(), bloc);
+ fvals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
+ }
+
+ ++q;
+ gcc_assert(q->field_name() == "offset");
+ fvals->push_back(Expression::make_struct_field_offset(this, &*pf));
+
+ Expression* v = Expression::make_struct_composite_literal(element_type,
+ fvals, bloc);
+ elements->push_back(v);
+ }
+
+ vals->push_back(Expression::make_slice_composite_literal(ps->type(),
+ elements, bloc));
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Struct_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("struct { ");
+
+ for (Struct_field_list::const_iterator p = this->fields_->begin();
+ p != this->fields_->end();
+ ++p)
+ {
+ if (p != this->fields_->begin())
+ ret->append("; ");
+ if (p->is_anonymous())
+ ret->push_back('?');
+ else
+ ret->append(Gogo::unpack_hidden_name(p->field_name()));
+ ret->push_back(' ');
+ this->append_reflection(p->type(), gogo, ret);
+
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ ret->append(" \"");
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (*p == '\0')
+ ret->append("\\x00");
+ else if (*p == '\n')
+ ret->append("\\n");
+ else if (*p == '\t')
+ ret->append("\\t");
+ else if (*p == '"')
+ ret->append("\\\"");
+ else if (*p == '\\')
+ ret->append("\\\\");
+ else
+ ret->push_back(*p);
+ }
+ ret->push_back('"');
+ }
+ }
+
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Struct_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('S');
+
+ const Struct_field_list* fields = this->fields_;
+ if (fields != NULL)
+ {
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ ret->append("0_");
+ else
+ {
+ std::string n = Gogo::unpack_hidden_name(p->field_name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ }
+ this->append_mangled_name(p->type(), gogo, ret);
+ if (p->has_tag())
+ {
+ const std::string& tag(p->tag());
+ std::string out;
+ for (std::string::const_iterator p = tag.begin();
+ p != tag.end();
+ ++p)
+ {
+ if (ISALNUM(*p) || *p == '_')
+ out.push_back(*p);
+ else
+ {
+ char buf[20];
+ snprintf(buf, sizeof buf, ".%x.",
+ static_cast<unsigned int>(*p));
+ out.append(buf);
+ }
+ }
+ char buf[20];
+ snprintf(buf, sizeof buf, "T%u_",
+ static_cast<unsigned int>(out.length()));
+ ret->append(buf);
+ ret->append(out);
+ }
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Struct_type::do_export(Export* exp) const
+{
+ exp->write_c_string("struct { ");
+ const Struct_field_list* fields = this->fields_;
+ gcc_assert(fields != NULL);
+ for (Struct_field_list::const_iterator p = fields->begin();
+ p != fields->end();
+ ++p)
+ {
+ if (p->is_anonymous())
+ exp->write_string("? ");
+ else
+ {
+ exp->write_string(p->field_name());
+ exp->write_c_string(" ");
+ }
+ exp->write_type(p->type());
+
+ if (p->has_tag())
+ {
+ exp->write_c_string(" ");
+ Expression* expr = Expression::make_string(p->tag(),
+ BUILTINS_LOCATION);
+ expr->export_expression(exp);
+ delete expr;
+ }
+
+ exp->write_c_string("; ");
+ }
+ exp->write_c_string("}");
+}
+
+// Import.
+
+Struct_type*
+Struct_type::do_import(Import* imp)
+{
+ imp->require_c_string("struct { ");
+ Struct_field_list* fields = new Struct_field_list;
+ if (imp->peek_char() != '}')
+ {
+ while (true)
+ {
+ std::string name;
+ if (imp->match_c_string("? "))
+ imp->advance(2);
+ else
+ {
+ name = imp->read_identifier();
+ imp->require_c_string(" ");
+ }
+ Type* ftype = imp->read_type();
+
+ Struct_field sf(Typed_identifier(name, ftype, imp->location()));
+
+ if (imp->peek_char() == ' ')
+ {
+ imp->advance(1);
+ Expression* expr = Expression::import_expression(imp);
+ String_expression* sexpr = expr->string_expression();
+ gcc_assert(sexpr != NULL);
+ sf.set_tag(sexpr->val());
+ delete sexpr;
+ }
+
+ imp->require_c_string("; ");
+ fields->push_back(sf);
+ if (imp->peek_char() == '}')
+ break;
+ }
+ }
+ imp->require_c_string("}");
+
+ return Type::make_struct_type(fields, imp->location());
+}
+
+// Make a struct type.
+
+Struct_type*
+Type::make_struct_type(Struct_field_list* fields,
+ source_location location)
+{
+ return new Struct_type(fields, location);
+}
+
+// Class Array_type.
+
+// Whether two array types are identical.
+
+bool
+Array_type::is_identical(const Array_type* t, bool errors_are_identical) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(),
+ errors_are_identical, NULL))
+ return false;
+
+ Expression* l1 = this->length();
+ Expression* l2 = t->length();
+
+ // Slices of the same element type are identical.
+ if (l1 == NULL && l2 == NULL)
+ return true;
+
+ // Arrays of the same element type are identical if they have the
+ // same length.
+ if (l1 != NULL && l2 != NULL)
+ {
+ if (l1 == l2)
+ return true;
+
+ // Try to determine the lengths. If we can't, assume the arrays
+ // are not identical.
+ bool ret = false;
+ mpz_t v1;
+ mpz_init(v1);
+ Type* type1;
+ mpz_t v2;
+ mpz_init(v2);
+ Type* type2;
+ if (l1->integer_constant_value(true, v1, &type1)
+ && l2->integer_constant_value(true, v2, &type2))
+ ret = mpz_cmp(v1, v2) == 0;
+ mpz_clear(v1);
+ mpz_clear(v2);
+ return ret;
+ }
+
+ // Otherwise the arrays are not identical.
+ return false;
+}
+
+// Traversal.
+
+int
+Array_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->element_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ if (this->length_ != NULL
+ && Expression::traverse(&this->length_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the length is valid.
+
+bool
+Array_type::verify_length()
+{
+ if (this->length_ == NULL)
+ return true;
+
+ Type_context context(Type::lookup_integer_type("int"), false);
+ this->length_->determine_type(&context);
+
+ if (!this->length_->is_constant())
+ {
+ error_at(this->length_->location(), "array bound is not constant");
+ return false;
+ }
+
+ mpz_t val;
+ mpz_init(val);
+ Type* vt;
+ if (!this->length_->integer_constant_value(true, val, &vt))
+ {
+ mpfr_t fval;
+ mpfr_init(fval);
+ if (!this->length_->float_constant_value(fval, &vt))
+ {
+ if (this->length_->type()->integer_type() != NULL
+ || this->length_->type()->float_type() != NULL)
+ error_at(this->length_->location(),
+ "array bound is not constant");
+ else
+ error_at(this->length_->location(),
+ "array bound is not numeric");
+ mpfr_clear(fval);
+ mpz_clear(val);
+ return false;
+ }
+ if (!mpfr_integer_p(fval))
+ {
+ error_at(this->length_->location(),
+ "array bound truncated to integer");
+ mpfr_clear(fval);
+ mpz_clear(val);
+ return false;
+ }
+ mpz_init(val);
+ mpfr_get_z(val, fval, GMP_RNDN);
+ mpfr_clear(fval);
+ }
+
+ if (mpz_sgn(val) < 0)
+ {
+ error_at(this->length_->location(), "negative array bound");
+ mpz_clear(val);
+ return false;
+ }
+
+ Type* int_type = Type::lookup_integer_type("int");
+ int tbits = int_type->integer_type()->bits();
+ int vbits = mpz_sizeinbase(val, 2);
+ if (vbits + 1 > tbits)
+ {
+ error_at(this->length_->location(), "array bound overflows");
+ mpz_clear(val);
+ return false;
+ }
+
+ mpz_clear(val);
+
+ return true;
+}
+
+// Verify the type.
+
+bool
+Array_type::do_verify()
+{
+ if (!this->verify_length())
+ {
+ this->length_ = Expression::make_error(this->length_->location());
+ return false;
+ }
+ return true;
+}
+
+// Array type hash code.
+
+unsigned int
+Array_type::do_hash_for_method(Gogo* gogo) const
+{
+ // There is no very convenient way to get a hash code for the
+ // length.
+ return this->element_type_->hash_for_method(gogo) + 1;
+}
+
+// See if the expression passed to make is suitable. The first
+// argument is required, and gives the length. An optional second
+// argument is permitted for the capacity.
+
+bool
+Array_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ gcc_assert(this->length_ == NULL);
+ if (args == NULL || args->empty())
+ {
+ error_at(location, "length required when allocating a slice");
+ return false;
+ }
+ else if (args->size() > 2)
+ {
+ error_at(location, "too many expressions passed to make");
+ return false;
+ }
+ else
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad length when making slice"), location))
+ return false;
+
+ if (args->size() > 1)
+ {
+ if (!Type::check_int_value(args->back(),
+ _("bad capacity when making slice"),
+ location))
+ return false;
+ }
+
+ return true;
+ }
+}
+
+// Get a tree for the length of a fixed array. The length may be
+// computed using a function call, so we must only evaluate it once.
+
+tree
+Array_type::get_length_tree(Gogo* gogo)
+{
+ gcc_assert(this->length_ != NULL);
+ if (this->length_tree_ == NULL_TREE)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* t;
+ if (this->length_->integer_constant_value(true, val, &t))
+ {
+ if (t == NULL)
+ t = Type::lookup_integer_type("int");
+ else if (t->is_abstract())
+ t = t->make_non_abstract_type();
+ tree tt = t->get_tree(gogo);
+ this->length_tree_ = Expression::integer_constant_tree(val, tt);
+ mpz_clear(val);
+ }
+ else
+ {
+ mpz_clear(val);
+
+ // Make up a translation context for the array length
+ // expression. FIXME: This won't work in general.
+ Translate_context context(gogo, NULL, NULL, NULL_TREE);
+ tree len = this->length_->get_tree(&context);
+ if (len != error_mark_node)
+ {
+ len = convert_to_integer(integer_type_node, len);
+ len = save_expr(len);
+ }
+ this->length_tree_ = len;
+ }
+ }
+ return this->length_tree_;
+}
+
+// Get a tree for the type of this array. A fixed array is simply
+// represented as ARRAY_TYPE with the appropriate index--i.e., it is
+// just like an array in C. An open array is a struct with three
+// fields: a data pointer, the length, and the capacity.
+
+tree
+Array_type::do_get_tree(Gogo* gogo)
+{
+ if (this->length_ == NULL)
+ {
+ tree struct_type = gogo->slice_type_tree(void_type_node);
+ return this->fill_in_slice_tree(gogo, struct_type);
+ }
+ else
+ {
+ tree array_type = make_node(ARRAY_TYPE);
+ return this->fill_in_array_tree(gogo, array_type);
+ }
+}
+
+// Fill in the fields for an array type. This is used for named array
+// types.
+
+tree
+Array_type::fill_in_array_tree(Gogo* gogo, tree array_type)
+{
+ gcc_assert(this->length_ != NULL);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ tree length_tree = this->get_length_tree(gogo);
+ if (element_type_tree == error_mark_node
+ || length_tree == error_mark_node)
+ return error_mark_node;
+
+ gcc_assert(TYPE_SIZE(element_type_tree) != NULL_TREE);
+
+ length_tree = fold_convert(sizetype, length_tree);
+
+ // build_index_type takes the maximum index, which is one less than
+ // the length.
+ tree index_type = build_index_type(fold_build2(MINUS_EXPR, sizetype,
+ length_tree,
+ size_one_node));
+
+ TREE_TYPE(array_type) = element_type_tree;
+ TYPE_DOMAIN(array_type) = index_type;
+ TYPE_ADDR_SPACE(array_type) = TYPE_ADDR_SPACE(element_type_tree);
+ layout_type(array_type);
+
+ if (TYPE_STRUCTURAL_EQUALITY_P(element_type_tree)
+ || TYPE_STRUCTURAL_EQUALITY_P(index_type))
+ SET_TYPE_STRUCTURAL_EQUALITY(array_type);
+ else if (TYPE_CANONICAL(element_type_tree) != element_type_tree
+ || TYPE_CANONICAL(index_type) != index_type)
+ TYPE_CANONICAL(array_type) =
+ build_array_type(TYPE_CANONICAL(element_type_tree),
+ TYPE_CANONICAL(index_type));
+
+ return array_type;
+}
+
+// Fill in the fields for a slice type. This is used for named slice
+// types.
+
+tree
+Array_type::fill_in_slice_tree(Gogo* gogo, tree struct_type)
+{
+ gcc_assert(this->length_ == NULL);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree field = TYPE_FIELDS(struct_type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__values") == 0);
+ gcc_assert(POINTER_TYPE_P(TREE_TYPE(field))
+ && TREE_TYPE(TREE_TYPE(field)) == void_type_node);
+ TREE_TYPE(field) = build_pointer_type(element_type_tree);
+
+ return struct_type;
+}
+
+// Return an initializer for an array type.
+
+tree
+Array_type::do_get_init_tree(Gogo* gogo, tree type_tree, bool is_clear)
+{
+ if (this->length_ == NULL)
+ {
+ // Open array.
+
+ if (is_clear)
+ return NULL;
+
+ gcc_assert(TREE_CODE(type_tree) == RECORD_TYPE);
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
+
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init,
+ NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), size_zero_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+ else
+ {
+ // Fixed array.
+
+ tree value = this->element_type_->get_init_tree(gogo, is_clear);
+ if (value == NULL)
+ return NULL;
+ if (value == error_mark_node)
+ return error_mark_node;
+
+ tree length_tree = this->get_length_tree(gogo);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+
+ length_tree = fold_convert(sizetype, length_tree);
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node,
+ fold_build2(MINUS_EXPR, sizetype,
+ length_tree, size_one_node));
+ tree ret = build_constructor_single(type_tree, range, value);
+ if (TREE_CONSTANT(value))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+ }
+}
+
+// Handle the builtin make function for a slice.
+
+tree
+Array_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ gcc_assert(this->length_ == NULL);
+
+ Gogo* gogo = context->gogo();
+ tree type_tree = this->get_tree(gogo);
+ if (type_tree == error_mark_node)
+ return error_mark_node;
+
+ tree values_field = TYPE_FIELDS(type_tree);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(values_field)),
+ "__values") == 0);
+
+ tree count_field = DECL_CHAIN(values_field);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(count_field)),
+ "__count") == 0);
+
+ tree element_type_tree = this->element_type_->get_tree(gogo);
+ if (element_type_tree == error_mark_node)
+ return error_mark_node;
+ tree element_size_tree = TYPE_SIZE_UNIT(element_type_tree);
+
+ tree value = this->element_type_->get_init_tree(gogo, true);
+ if (value == error_mark_node)
+ return error_mark_node;
+
+ // The first argument is the number of elements, the optional second
+ // argument is the capacity.
+ gcc_assert(args != NULL && args->size() >= 1 && args->size() <= 2);
+
+ tree length_tree = args->front()->get_tree(context);
+ if (length_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(length_tree))
+ length_tree = save_expr(length_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(length_tree)))
+ length_tree = convert_to_integer(TREE_TYPE(count_field), length_tree);
+
+ tree bad_index = Expression::check_bounds(length_tree,
+ TREE_TYPE(count_field),
+ NULL_TREE, location);
+
+ length_tree = fold_convert_loc(location, TREE_TYPE(count_field), length_tree);
+ tree capacity_tree;
+ if (args->size() == 1)
+ capacity_tree = length_tree;
+ else
+ {
+ capacity_tree = args->back()->get_tree(context);
+ if (capacity_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(capacity_tree))
+ capacity_tree = save_expr(capacity_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(capacity_tree)))
+ capacity_tree = convert_to_integer(TREE_TYPE(count_field),
+ capacity_tree);
+
+ bad_index = Expression::check_bounds(capacity_tree,
+ TREE_TYPE(count_field),
+ bad_index, location);
+
+ tree chktype = (((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ > TYPE_SIZE(TREE_TYPE(length_tree)))
+ || ((TYPE_SIZE(TREE_TYPE(capacity_tree))
+ == TYPE_SIZE(TREE_TYPE(length_tree)))
+ && TYPE_UNSIGNED(TREE_TYPE(capacity_tree))))
+ ? TREE_TYPE(capacity_tree)
+ : TREE_TYPE(length_tree));
+ tree chk = fold_build2_loc(location, LT_EXPR, boolean_type_node,
+ fold_convert_loc(location, chktype,
+ capacity_tree),
+ fold_convert_loc(location, chktype,
+ length_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ capacity_tree = fold_convert_loc(location, TREE_TYPE(count_field),
+ capacity_tree);
+ }
+
+ tree size_tree = fold_build2_loc(location, MULT_EXPR, sizetype,
+ element_size_tree,
+ fold_convert_loc(location, sizetype,
+ capacity_tree));
+
+ tree chk = fold_build2_loc(location, TRUTH_AND_EXPR, boolean_type_node,
+ fold_build2_loc(location, GT_EXPR,
+ boolean_type_node,
+ fold_convert_loc(location,
+ sizetype,
+ capacity_tree),
+ size_zero_node),
+ fold_build2_loc(location, LT_EXPR,
+ boolean_type_node,
+ size_tree, element_size_tree));
+ if (bad_index == NULL_TREE)
+ bad_index = chk;
+ else
+ bad_index = fold_build2_loc(location, TRUTH_OR_EXPR, boolean_type_node,
+ bad_index, chk);
+
+ tree space = context->gogo()->allocate_memory(this->element_type_,
+ size_tree, location);
+
+ if (value != NULL_TREE)
+ space = save_expr(space);
+
+ space = fold_convert(TREE_TYPE(values_field), space);
+
+ if (bad_index != NULL_TREE && bad_index != boolean_false_node)
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_SLICE_OUT_OF_BOUNDS,
+ location);
+ space = build2(COMPOUND_EXPR, TREE_TYPE(space),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ space);
+ }
+
+ tree constructor = gogo->slice_constructor(type_tree, space, length_tree,
+ capacity_tree);
+
+ if (value == NULL_TREE)
+ {
+ // The array contents are zero initialized.
+ return constructor;
+ }
+
+ // The elements must be initialized.
+
+ tree max = fold_build2_loc(location, MINUS_EXPR, TREE_TYPE(count_field),
+ capacity_tree,
+ fold_convert_loc(location, TREE_TYPE(count_field),
+ integer_one_node));
+
+ tree array_type = build_array_type(element_type_tree,
+ build_index_type(max));
+
+ tree value_pointer = fold_convert_loc(location,
+ build_pointer_type(array_type),
+ space);
+
+ tree range = build2(RANGE_EXPR, sizetype, size_zero_node, max);
+ tree space_init = build_constructor_single(array_type, range, value);
+
+ return build2(COMPOUND_EXPR, TREE_TYPE(constructor),
+ build2(MODIFY_EXPR, void_type_node,
+ build_fold_indirect_ref(value_pointer),
+ space_init),
+ constructor);
+}
+
+// Return a tree for a pointer to the values in ARRAY.
+
+tree
+Array_type::value_pointer_tree(Gogo*, tree array) const
+{
+ tree ret;
+ if (this->length() != NULL)
+ {
+ // Fixed array.
+ ret = fold_convert(build_pointer_type(TREE_TYPE(TREE_TYPE(array))),
+ build_fold_addr_expr(array));
+ }
+ else
+ {
+ // Open array.
+ tree field = TYPE_FIELDS(TREE_TYPE(array));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
+ "__values") == 0);
+ ret = fold_build3(COMPONENT_REF, TREE_TYPE(field), array, field,
+ NULL_TREE);
+ }
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the length of the array ARRAY which has this
+// type.
+
+tree
+Array_type::length_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ {
+ if (TREE_CODE(array) == SAVE_EXPR)
+ return fold_convert(integer_type_node, this->get_length_tree(gogo));
+ else
+ return omit_one_operand(integer_type_node,
+ this->get_length_tree(gogo), array);
+ }
+
+ // This is an open array. We need to read the length field.
+
+ tree type = TREE_TYPE(array);
+ gcc_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(TYPE_FIELDS(type));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__count") == 0);
+
+ tree ret = build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+ if (TREE_CONSTANT(array))
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// Return a tree for the capacity of the array ARRAY which has this
+// type.
+
+tree
+Array_type::capacity_tree(Gogo* gogo, tree array)
+{
+ if (this->length_ != NULL)
+ return omit_one_operand(sizetype, this->get_length_tree(gogo), array);
+
+ // This is an open array. We need to read the capacity field.
+
+ tree type = TREE_TYPE(array);
+ gcc_assert(TREE_CODE(type) == RECORD_TYPE);
+
+ tree field = DECL_CHAIN(DECL_CHAIN(TYPE_FIELDS(type)));
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__capacity") == 0);
+
+ return build3(COMPONENT_REF, TREE_TYPE(field), array, field, NULL_TREE);
+}
+
+// Export.
+
+void
+Array_type::do_export(Export* exp) const
+{
+ exp->write_c_string("[");
+ if (this->length_ != NULL)
+ this->length_->export_expression(exp);
+ exp->write_c_string("] ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Array_type*
+Array_type::do_import(Import* imp)
+{
+ imp->require_c_string("[");
+ Expression* length;
+ if (imp->peek_char() == ']')
+ length = NULL;
+ else
+ length = Expression::import_expression(imp);
+ imp->require_c_string("] ");
+ Type* element_type = imp->read_type();
+ return Type::make_array_type(element_type, length);
+}
+
+// The type of an array type descriptor.
+
+Type*
+Array_type::make_array_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "len", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ArrayType", sf);
+ }
+
+ return ret;
+}
+
+// The type of an slice type descriptor.
+
+Type*
+Array_type::make_slice_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(2,
+ "", tdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("SliceType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an array/slice type.
+
+Expression*
+Array_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (this->length_ != NULL)
+ return this->array_type_descriptor(gogo, name);
+ else
+ return this->slice_type_descriptor(gogo, name);
+}
+
+// Build a type descriptor for an array type.
+
+Expression*
+Array_type::array_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* atdt = Array_type::make_array_type_descriptor_type();
+
+ const Struct_field_list* fields = atdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_ARRAY,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "len");
+ vals->push_back(Expression::make_cast(p->type(), this->length_, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(atdt, vals, bloc);
+}
+
+// Build a type descriptor for a slice type.
+
+Expression*
+Array_type::slice_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* stdt = Array_type::make_slice_type_descriptor_type();
+
+ const Struct_field_list* fields = stdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(2);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_SLICE,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(stdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Array_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('[');
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array length is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back(']');
+
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Array_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('A');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->length_ != NULL)
+ {
+ mpz_t val;
+ mpz_init(val);
+ Type* type;
+ if (!this->length_->integer_constant_value(true, val, &type))
+ error_at(this->length_->location(),
+ "array length must be integer constant expression");
+ else if (mpz_cmp_si(val, 0) < 0)
+ error_at(this->length_->location(), "array length is negative");
+ else if (mpz_cmp_ui(val, mpz_get_ui(val)) != 0)
+ error_at(this->length_->location(), "array size is too large");
+ else
+ {
+ char buf[50];
+ snprintf(buf, sizeof buf, "%lu", mpz_get_ui(val));
+ ret->append(buf);
+ }
+ mpz_clear(val);
+ }
+ ret->push_back('e');
+}
+
+// Make an array type.
+
+Array_type*
+Type::make_array_type(Type* element_type, Expression* length)
+{
+ return new Array_type(element_type, length);
+}
+
+// Class Map_type.
+
+// Traversal.
+
+int
+Map_type::do_traverse(Traverse* traverse)
+{
+ if (Type::traverse(this->key_type_, traverse) == TRAVERSE_EXIT
+ || Type::traverse(this->val_type_, traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Check that the map type is OK.
+
+bool
+Map_type::do_verify()
+{
+ if (this->key_type_->struct_type() != NULL
+ || this->key_type_->array_type() != NULL)
+ {
+ error_at(this->location_, "invalid map key type");
+ return false;
+ }
+ return true;
+}
+
+// Whether two map types are identical.
+
+bool
+Map_type::is_identical(const Map_type* t, bool errors_are_identical) const
+{
+ return (Type::are_identical(this->key_type(), t->key_type(),
+ errors_are_identical, NULL)
+ && Type::are_identical(this->val_type(), t->val_type(),
+ errors_are_identical, NULL));
+}
+
+// Hash code.
+
+unsigned int
+Map_type::do_hash_for_method(Gogo* gogo) const
+{
+ return (this->key_type_->hash_for_method(gogo)
+ + this->val_type_->hash_for_method(gogo)
+ + 2);
+}
+
+// Check that a call to the builtin make function is valid. For a map
+// the optional argument is the number of spaces to preallocate for
+// values.
+
+bool
+Map_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(), _("bad size when making map"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making map");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Get a tree for a map type. A map type is represented as a pointer
+// to a struct. The struct is __go_map in libgo/map.h.
+
+tree
+Map_type::do_get_tree(Gogo* gogo)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree struct_type = make_node(RECORD_TYPE);
+
+ tree map_descriptor_type = gogo->map_descriptor_type();
+ tree const_map_descriptor_type =
+ build_qualified_type(map_descriptor_type, TYPE_QUAL_CONST);
+ tree name = get_identifier("__descriptor");
+ tree field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(const_map_descriptor_type));
+ DECL_CONTEXT(field) = struct_type;
+ TYPE_FIELDS(struct_type) = field;
+ tree last_field = field;
+
+ name = get_identifier("__element_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__bucket_count");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name, sizetype);
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+ last_field = field;
+
+ name = get_identifier("__buckets");
+ field = build_decl(BUILTINS_LOCATION, FIELD_DECL, name,
+ build_pointer_type(ptr_type_node));
+ DECL_CONTEXT(field) = struct_type;
+ DECL_CHAIN(last_field) = field;
+
+ layout_type(struct_type);
+
+ // Give the struct a name for better debugging info.
+ name = get_identifier("__go_map");
+ tree type_decl = build_decl(BUILTINS_LOCATION, TYPE_DECL, name,
+ struct_type);
+ DECL_ARTIFICIAL(type_decl) = 1;
+ TYPE_NAME(struct_type) = type_decl;
+ go_preserve_from_gc(type_decl);
+ rest_of_decl_compilation(type_decl, 1, 0);
+
+ type_tree = build_pointer_type(struct_type);
+ go_preserve_from_gc(type_tree);
+ }
+
+ return type_tree;
+}
+
+// Initialize a map.
+
+tree
+Map_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Return an expression for a newly allocated map.
+
+tree
+Map_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ tree map_type = this->get_tree(context->gogo());
+
+ static tree new_map_fndecl;
+ tree ret = Gogo::call_builtin(&new_map_fndecl,
+ location,
+ "__go_new_map",
+ 2,
+ map_type,
+ TREE_TYPE(TYPE_FIELDS(TREE_TYPE(map_type))),
+ context->gogo()->map_descriptor(this),
+ sizetype,
+ expr_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_map_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_MAP_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// The type of a map type descriptor.
+
+Type*
+Map_type::make_map_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "key", ptdt,
+ "elem", ptdt);
+
+ ret = Type::make_builtin_named_type("MapType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Map_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* mtdt = Map_type::make_map_type_descriptor_type();
+
+ const Struct_field_list* fields = mtdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_MAP,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "key");
+ vals->push_back(Expression::make_type_descriptor(this->key_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->val_type_, bloc));
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(mtdt, vals, bloc);
+}
+
+// Reflection string for a map.
+
+void
+Map_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("map[");
+ this->append_reflection(this->key_type_, gogo, ret);
+ ret->append("] ");
+ this->append_reflection(this->val_type_, gogo, ret);
+}
+
+// Mangled name for a map.
+
+void
+Map_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('M');
+ this->append_mangled_name(this->key_type_, gogo, ret);
+ ret->append("__");
+ this->append_mangled_name(this->val_type_, gogo, ret);
+}
+
+// Export a map type.
+
+void
+Map_type::do_export(Export* exp) const
+{
+ exp->write_c_string("map [");
+ exp->write_type(this->key_type_);
+ exp->write_c_string("] ");
+ exp->write_type(this->val_type_);
+}
+
+// Import a map type.
+
+Map_type*
+Map_type::do_import(Import* imp)
+{
+ imp->require_c_string("map [");
+ Type* key_type = imp->read_type();
+ imp->require_c_string("] ");
+ Type* val_type = imp->read_type();
+ return Type::make_map_type(key_type, val_type, imp->location());
+}
+
+// Make a map type.
+
+Map_type*
+Type::make_map_type(Type* key_type, Type* val_type, source_location location)
+{
+ return new Map_type(key_type, val_type, location);
+}
+
+// Class Channel_type.
+
+// Hash code.
+
+unsigned int
+Channel_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->may_send_)
+ ret += 1;
+ if (this->may_receive_)
+ ret += 2;
+ if (this->element_type_ != NULL)
+ ret += this->element_type_->hash_for_method(gogo) << 2;
+ return ret << 3;
+}
+
+// Whether this type is the same as T.
+
+bool
+Channel_type::is_identical(const Channel_type* t,
+ bool errors_are_identical) const
+{
+ if (!Type::are_identical(this->element_type(), t->element_type(),
+ errors_are_identical, NULL))
+ return false;
+ return (this->may_send_ == t->may_send_
+ && this->may_receive_ == t->may_receive_);
+}
+
+// Check whether the parameters for a call to the builtin function
+// make are OK for a channel. A channel can take an optional single
+// parameter which is the buffer size.
+
+bool
+Channel_type::do_check_make_expression(Expression_list* args,
+ source_location location)
+{
+ if (args != NULL && !args->empty())
+ {
+ if (!Type::check_int_value(args->front(),
+ _("bad buffer size when making channel"),
+ location))
+ return false;
+ else if (args->size() > 1)
+ {
+ error_at(location, "too many arguments when making channel");
+ return false;
+ }
+ }
+ return true;
+}
+
+// Return the tree for a channel type. A channel is a pointer to a
+// __go_channel struct. The __go_channel struct is defined in
+// libgo/runtime/channel.h.
+
+tree
+Channel_type::do_get_tree(Gogo*)
+{
+ static tree type_tree;
+ if (type_tree == NULL_TREE)
+ {
+ tree ret = make_node(RECORD_TYPE);
+ TYPE_NAME(ret) = get_identifier("__go_channel");
+ TYPE_STUB_DECL(ret) = build_decl(BUILTINS_LOCATION, TYPE_DECL, NULL_TREE,
+ ret);
+ type_tree = build_pointer_type(ret);
+ go_preserve_from_gc(type_tree);
+ }
+ return type_tree;
+}
+
+// Initialize a channel variable.
+
+tree
+Channel_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+ return fold_convert(type_tree, null_pointer_node);
+}
+
+// Handle the builtin function make for a channel.
+
+tree
+Channel_type::do_make_expression_tree(Translate_context* context,
+ Expression_list* args,
+ source_location location)
+{
+ Gogo* gogo = context->gogo();
+ tree channel_type = this->get_tree(gogo);
+
+ tree element_tree = this->element_type_->get_tree(gogo);
+ tree element_size_tree = size_in_bytes(element_tree);
+
+ tree bad_index = NULL_TREE;
+
+ tree expr_tree;
+ if (args == NULL || args->empty())
+ expr_tree = size_zero_node;
+ else
+ {
+ expr_tree = args->front()->get_tree(context);
+ if (expr_tree == error_mark_node)
+ return error_mark_node;
+ if (!DECL_P(expr_tree))
+ expr_tree = save_expr(expr_tree);
+ if (!INTEGRAL_TYPE_P(TREE_TYPE(expr_tree)))
+ expr_tree = convert_to_integer(sizetype, expr_tree);
+ bad_index = Expression::check_bounds(expr_tree, sizetype, bad_index,
+ location);
+ }
+
+ static tree new_channel_fndecl;
+ tree ret = Gogo::call_builtin(&new_channel_fndecl,
+ location,
+ "__go_new_channel",
+ 2,
+ channel_type,
+ sizetype,
+ element_size_tree,
+ sizetype,
+ expr_tree);
+ if (ret == error_mark_node)
+ return error_mark_node;
+ // This can panic if the capacity is out of range.
+ TREE_NOTHROW(new_channel_fndecl) = 0;
+
+ if (bad_index == NULL_TREE)
+ return ret;
+ else
+ {
+ tree crash = Gogo::runtime_error(RUNTIME_ERROR_MAKE_CHAN_OUT_OF_BOUNDS,
+ location);
+ return build2(COMPOUND_EXPR, TREE_TYPE(ret),
+ build3(COND_EXPR, void_type_node,
+ bad_index, crash, NULL_TREE),
+ ret);
+ }
+}
+
+// Build a type descriptor for a channel type.
+
+Type*
+Channel_type::make_chan_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* uintptr_type = Type::lookup_integer_type("uintptr");
+
+ Struct_type* sf =
+ Type::make_builtin_struct_type(3,
+ "", tdt,
+ "elem", ptdt,
+ "dir", uintptr_type);
+
+ ret = Type::make_builtin_named_type("ChanType", sf);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for a map type.
+
+Expression*
+Channel_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* ctdt = Channel_type::make_chan_type_descriptor_type();
+
+ const Struct_field_list* fields = ctdt->struct_type()->fields();
+
+ Expression_list* vals = new Expression_list();
+ vals->reserve(3);
+
+ Struct_field_list::const_iterator p = fields->begin();
+ gcc_assert(p->field_name() == "commonType");
+ vals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_CHAN,
+ name, NULL, true));
+
+ ++p;
+ gcc_assert(p->field_name() == "elem");
+ vals->push_back(Expression::make_type_descriptor(this->element_type_, bloc));
+
+ ++p;
+ gcc_assert(p->field_name() == "dir");
+ // These bits must match the ones in libgo/runtime/go-type.h.
+ int val = 0;
+ if (this->may_receive_)
+ val |= 1;
+ if (this->may_send_)
+ val |= 2;
+ mpz_t iv;
+ mpz_init_set_ui(iv, val);
+ vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
+ mpz_clear(iv);
+
+ ++p;
+ gcc_assert(p == fields->end());
+
+ return Expression::make_struct_composite_literal(ctdt, vals, bloc);
+}
+
+// Reflection string.
+
+void
+Channel_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (!this->may_send_)
+ ret->append("<-");
+ ret->append("chan");
+ if (!this->may_receive_)
+ ret->append("<-");
+ ret->push_back(' ');
+ this->append_reflection(this->element_type_, gogo, ret);
+}
+
+// Mangled name.
+
+void
+Channel_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('C');
+ this->append_mangled_name(this->element_type_, gogo, ret);
+ if (this->may_send_)
+ ret->push_back('s');
+ if (this->may_receive_)
+ ret->push_back('r');
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Channel_type::do_export(Export* exp) const
+{
+ exp->write_c_string("chan ");
+ if (this->may_send_ && !this->may_receive_)
+ exp->write_c_string("-< ");
+ else if (this->may_receive_ && !this->may_send_)
+ exp->write_c_string("<- ");
+ exp->write_type(this->element_type_);
+}
+
+// Import.
+
+Channel_type*
+Channel_type::do_import(Import* imp)
+{
+ imp->require_c_string("chan ");
+
+ bool may_send;
+ bool may_receive;
+ if (imp->match_c_string("-< "))
+ {
+ imp->advance(3);
+ may_send = true;
+ may_receive = false;
+ }
+ else if (imp->match_c_string("<- "))
+ {
+ imp->advance(3);
+ may_receive = true;
+ may_send = false;
+ }
+ else
+ {
+ may_send = true;
+ may_receive = true;
+ }
+
+ Type* element_type = imp->read_type();
+
+ return Type::make_channel_type(may_send, may_receive, element_type);
+}
+
+// Make a new channel type.
+
+Channel_type*
+Type::make_channel_type(bool send, bool receive, Type* element_type)
+{
+ return new Channel_type(send, receive, element_type);
+}
+
+// Class Interface_type.
+
+// Traversal.
+
+int
+Interface_type::do_traverse(Traverse* traverse)
+{
+ if (this->methods_ == NULL)
+ return TRAVERSE_CONTINUE;
+ return this->methods_->traverse(traverse);
+}
+
+// Finalize the methods. This handles interface inheritance.
+
+void
+Interface_type::finalize_methods()
+{
+ if (this->methods_ == NULL)
+ return;
+ std::vector<Named_type*> seen;
+ bool is_recursive = false;
+ size_t from = 0;
+ size_t to = 0;
+ while (from < this->methods_->size())
+ {
+ const Typed_identifier* p = &this->methods_->at(from);
+ if (!p->name().empty())
+ {
+ size_t i;
+ for (i = 0; i < to; ++i)
+ {
+ if (this->methods_->at(i).name() == p->name())
+ {
+ error_at(p->location(), "duplicate method %qs",
+ Gogo::message_name(p->name()).c_str());
+ break;
+ }
+ }
+ if (i == to)
+ {
+ if (from != to)
+ this->methods_->set(to, *p);
+ ++to;
+ }
+ ++from;
+ continue;
+ }
+
+ Interface_type* it = p->type()->interface_type();
+ if (it == NULL)
+ {
+ error_at(p->location(), "interface contains embedded non-interface");
+ ++from;
+ continue;
+ }
+ if (it == this)
+ {
+ if (!is_recursive)
+ {
+ error_at(p->location(), "invalid recursive interface");
+ is_recursive = true;
+ }
+ ++from;
+ continue;
+ }
+
+ Named_type* nt = p->type()->named_type();
+ if (nt != NULL)
+ {
+ std::vector<Named_type*>::const_iterator q;
+ for (q = seen.begin(); q != seen.end(); ++q)
+ {
+ if (*q == nt)
+ {
+ error_at(p->location(), "inherited interface loop");
+ break;
+ }
+ }
+ if (q != seen.end())
+ {
+ ++from;
+ continue;
+ }
+ seen.push_back(nt);
+ }
+
+ const Typed_identifier_list* methods = it->methods();
+ if (methods == NULL)
+ {
+ ++from;
+ continue;
+ }
+ for (Typed_identifier_list::const_iterator q = methods->begin();
+ q != methods->end();
+ ++q)
+ {
+ if (q->name().empty())
+ {
+ if (q->type()->forwarded() == p->type()->forwarded())
+ error_at(p->location(), "interface inheritance loop");
+ else
+ {
+ size_t i;
+ for (i = from + 1; i < this->methods_->size(); ++i)
+ {
+ const Typed_identifier* r = &this->methods_->at(i);
+ if (r->name().empty()
+ && r->type()->forwarded() == q->type()->forwarded())
+ {
+ error_at(p->location(),
+ "inherited interface listed twice");
+ break;
+ }
+ }
+ if (i == this->methods_->size())
+ this->methods_->push_back(Typed_identifier(q->name(),
+ q->type(),
+ p->location()));
+ }
+ }
+ else if (this->find_method(q->name()) == NULL)
+ this->methods_->push_back(Typed_identifier(q->name(), q->type(),
+ p->location()));
+ else
+ {
+ if (!is_recursive)
+ error_at(p->location(), "inherited method %qs is ambiguous",
+ Gogo::message_name(q->name()).c_str());
+ }
+ }
+ ++from;
+ }
+ if (to == 0)
+ {
+ delete this->methods_;
+ this->methods_ = NULL;
+ }
+ else
+ {
+ this->methods_->resize(to);
+ this->methods_->sort_by_name();
+ }
+}
+
+// Return the method NAME, or NULL.
+
+const Typed_identifier*
+Interface_type::find_method(const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return NULL;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ if (p->name() == name)
+ return &*p;
+ return NULL;
+}
+
+// Return the method index.
+
+size_t
+Interface_type::method_index(const std::string& name) const
+{
+ gcc_assert(this->methods_ != NULL);
+ size_t ret = 0;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p, ++ret)
+ if (p->name() == name)
+ return ret;
+ gcc_unreachable();
+}
+
+// Return whether NAME is an unexported method, for better error
+// reporting.
+
+bool
+Interface_type::is_unexported_method(Gogo* gogo, const std::string& name) const
+{
+ if (this->methods_ == NULL)
+ return false;
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ const std::string& method_name(p->name());
+ if (Gogo::is_hidden_name(method_name)
+ && name == Gogo::unpack_hidden_name(method_name)
+ && gogo->pack_hidden_name(name, false) != method_name)
+ return true;
+ }
+ return false;
+}
+
+// Whether this type is identical with T.
+
+bool
+Interface_type::is_identical(const Interface_type* t,
+ bool errors_are_identical) const
+{
+ // We require the same methods with the same types. The methods
+ // have already been sorted.
+ if (this->methods() == NULL || t->methods() == NULL)
+ return this->methods() == t->methods();
+
+ Typed_identifier_list::const_iterator p1 = this->methods()->begin();
+ for (Typed_identifier_list::const_iterator p2 = t->methods()->begin();
+ p2 != t->methods()->end();
+ ++p1, ++p2)
+ {
+ if (p1 == this->methods()->end())
+ return false;
+ if (p1->name() != p2->name()
+ || !Type::are_identical(p1->type(), p2->type(),
+ errors_are_identical, NULL))
+ return false;
+ }
+ if (p1 != this->methods()->end())
+ return false;
+ return true;
+}
+
+// Whether we can assign the interface type T to this type. The types
+// are known to not be identical. An interface assignment is only
+// permitted if T is known to implement all methods in THIS.
+// Otherwise a type guard is required.
+
+bool
+Interface_type::is_compatible_for_assign(const Interface_type* t,
+ std::string* reason) const
+{
+ if (this->methods() == NULL)
+ return true;
+ for (Typed_identifier_list::const_iterator p = this->methods()->begin();
+ p != this->methods()->end();
+ ++p)
+ {
+ const Typed_identifier* m = t->find_method(p->name());
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ char buf[200];
+ snprintf(buf, sizeof buf,
+ _("need explicit conversion; missing method %s%s%s"),
+ open_quote, Gogo::message_name(p->name()).c_str(),
+ close_quote);
+ reason->assign(buf);
+ }
+ return false;
+ }
+
+ std::string subreason;
+ if (!Type::are_identical(p->type(), m->type(), true, &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Hash code.
+
+unsigned int
+Interface_type::do_hash_for_method(Gogo* gogo) const
+{
+ unsigned int ret = 0;
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ ret = Type::hash_string(p->name(), ret);
+ ret += p->type()->hash_for_method(gogo);
+ ret <<= 1;
+ }
+ }
+ return ret;
+}
+
+// Return true if T implements the interface. If it does not, and
+// REASON is not NULL, set *REASON to a useful error message.
+
+bool
+Interface_type::implements_interface(const Type* t, std::string* reason) const
+{
+ if (this->methods_ == NULL)
+ return true;
+
+ bool is_pointer = false;
+ const Named_type* nt = t->named_type();
+ const Struct_type* st = t->struct_type();
+ // If we start with a named type, we don't dereference it to find
+ // methods.
+ if (nt == NULL)
+ {
+ const Type* pt = t->points_to();
+ if (pt != NULL)
+ {
+ // If T is a pointer to a named type, then we need to look at
+ // the type to which it points.
+ is_pointer = true;
+ nt = pt->named_type();
+ st = pt->struct_type();
+ }
+ }
+
+ // If we have a named type, get the methods from it rather than from
+ // any struct type.
+ if (nt != NULL)
+ st = NULL;
+
+ // Only named and struct types have methods.
+ if (nt == NULL && st == NULL)
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ if (nt != NULL ? !nt->has_any_methods() : !st->has_any_methods())
+ {
+ if (reason != NULL)
+ {
+ if (t->points_to() != NULL
+ && t->points_to()->interface_type() != NULL)
+ reason->assign(_("pointer to interface type has no methods"));
+ else
+ reason->assign(_("type has no methods"));
+ }
+ return false;
+ }
+
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ bool is_ambiguous = false;
+ Method* m = (nt != NULL
+ ? nt->method_function(p->name(), &is_ambiguous)
+ : st->method_function(p->name(), &is_ambiguous));
+ if (m == NULL)
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = n.length() + 100;
+ char* buf = new char[len];
+ if (is_ambiguous)
+ snprintf(buf, len, _("ambiguous method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len, _("missing method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ Function_type *p_fn_type = p->type()->function_type();
+ Function_type* m_fn_type = m->type()->function_type();
+ gcc_assert(p_fn_type != NULL && m_fn_type != NULL);
+ std::string subreason;
+ if (!p_fn_type->is_identical(m_fn_type, true, true, &subreason))
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length() + subreason.length();
+ char* buf = new char[len];
+ if (subreason.empty())
+ snprintf(buf, len, _("incompatible type for method %s%s%s"),
+ open_quote, n.c_str(), close_quote);
+ else
+ snprintf(buf, len,
+ _("incompatible type for method %s%s%s (%s)"),
+ open_quote, n.c_str(), close_quote,
+ subreason.c_str());
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+
+ if (!is_pointer && !m->is_value_method())
+ {
+ if (reason != NULL)
+ {
+ std::string n = Gogo::message_name(p->name());
+ size_t len = 100 + n.length();
+ char* buf = new char[len];
+ snprintf(buf, len, _("method %s%s%s requires a pointer"),
+ open_quote, n.c_str(), close_quote);
+ reason->assign(buf);
+ delete[] buf;
+ }
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Return a tree for an interface type. An interface is a pointer to
+// a struct. The struct has three fields. The first field is a
+// pointer to the type descriptor for the dynamic type of the object.
+// The second field is a pointer to a table of methods for the
+// interface to be used with the object. The third field is the value
+// of the object itself.
+
+tree
+Interface_type::do_get_tree(Gogo* gogo)
+{
+ if (this->methods_ == NULL)
+ return Interface_type::empty_type_tree(gogo);
+ else
+ {
+ tree t = Interface_type::non_empty_type_tree(this->location_);
+ return this->fill_in_tree(gogo, t);
+ }
+}
+
+// Return a singleton struct for an empty interface type. We use the
+// same type for all empty interfaces. This lets us assign them to
+// each other directly without triggering GIMPLE type errors.
+
+tree
+Interface_type::empty_type_tree(Gogo* gogo)
+{
+ static tree empty_interface;
+ if (empty_interface != NULL_TREE)
+ return empty_interface;
+
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ return Gogo::builtin_struct(&empty_interface, "__go_empty_interface",
+ NULL_TREE, 2,
+ "__type_descriptor",
+ dtype,
+ "__object",
+ ptr_type_node);
+}
+
+// Return a new struct for a non-empty interface type. The correct
+// values are filled in by fill_in_tree.
+
+tree
+Interface_type::non_empty_type_tree(source_location location)
+{
+ tree ret = make_node(RECORD_TYPE);
+
+ tree field_trees = NULL_TREE;
+ tree* pp = &field_trees;
+
+ tree name_tree = get_identifier("__methods");
+ tree field = build_decl(location, FIELD_DECL, name_tree, ptr_type_node);
+ DECL_CONTEXT(field) = ret;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+
+ name_tree = get_identifier("__object");
+ field = build_decl(location, FIELD_DECL, name_tree, ptr_type_node);
+ DECL_CONTEXT(field) = ret;
+ *pp = field;
+
+ TYPE_FIELDS(ret) = field_trees;
+
+ layout_type(ret);
+
+ return ret;
+}
+
+// Fill in the tree for an interface type. This is used for named
+// interface types.
+
+tree
+Interface_type::fill_in_tree(Gogo* gogo, tree type)
+{
+ gcc_assert(this->methods_ != NULL);
+
+ // Build the type of the table of methods.
+
+ tree method_table = make_node(RECORD_TYPE);
+
+ // The first field is a pointer to the type descriptor.
+ tree name_tree = get_identifier("__type_descriptor");
+ tree dtype = Type::make_type_descriptor_type()->get_tree(gogo);
+ dtype = build_pointer_type(build_qualified_type(dtype, TYPE_QUAL_CONST));
+ tree field = build_decl(this->location_, FIELD_DECL, name_tree, dtype);
+ DECL_CONTEXT(field) = method_table;
+ TYPE_FIELDS(method_table) = field;
+
+ std::string last_name = "";
+ tree* pp = &DECL_CHAIN(field);
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ std::string name = Gogo::unpack_hidden_name(p->name());
+ name_tree = get_identifier_with_length(name.data(), name.length());
+ tree field_type = p->type()->get_tree(gogo);
+ if (field_type == error_mark_node)
+ return error_mark_node;
+ field = build_decl(this->location_, FIELD_DECL, name_tree, field_type);
+ DECL_CONTEXT(field) = method_table;
+ *pp = field;
+ pp = &DECL_CHAIN(field);
+ // Sanity check: the names should be sorted.
+ gcc_assert(p->name() > last_name);
+ last_name = p->name();
+ }
+ layout_type(method_table);
+
+ // Update the type of the __methods field from a generic pointer to
+ // a pointer to the method table.
+ field = TYPE_FIELDS(type);
+ gcc_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods") == 0);
+
+ TREE_TYPE(field) = build_pointer_type(method_table);
+
+ return type;
+}
+
+// Initialization value.
+
+tree
+Interface_type::do_get_init_tree(Gogo*, tree type_tree, bool is_clear)
+{
+ if (is_clear)
+ return NULL;
+
+ VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
+ for (tree field = TYPE_FIELDS(type_tree);
+ field != NULL_TREE;
+ field = DECL_CHAIN(field))
+ {
+ constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
+ elt->index = field;
+ elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
+ }
+
+ tree ret = build_constructor(type_tree, init);
+ TREE_CONSTANT(ret) = 1;
+ return ret;
+}
+
+// The type of an interface type descriptor.
+
+Type*
+Interface_type::make_interface_type_descriptor_type()
+{
+ static Type* ret;
+ if (ret == NULL)
+ {
+ Type* tdt = Type::make_type_descriptor_type();
+ Type* ptdt = Type::make_type_descriptor_ptr_type();
+
+ Type* string_type = Type::lookup_string_type();
+ Type* pointer_string_type = Type::make_pointer_type(string_type);
+
+ Struct_type* sm =
+ Type::make_builtin_struct_type(3,
+ "name", pointer_string_type,
+ "pkgPath", pointer_string_type,
+ "typ", ptdt);
+
+ Type* nsm = Type::make_builtin_named_type("imethod", sm);
+
+ Type* slice_nsm = Type::make_array_type(nsm, NULL);
+
+ Struct_type* s = Type::make_builtin_struct_type(2,
+ "", tdt,
+ "methods", slice_nsm);
+
+ ret = Type::make_builtin_named_type("InterfaceType", s);
+ }
+
+ return ret;
+}
+
+// Build a type descriptor for an interface type.
+
+Expression*
+Interface_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ source_location bloc = BUILTINS_LOCATION;
+
+ Type* itdt = Interface_type::make_interface_type_descriptor_type();
+
+ const Struct_field_list* ifields = itdt->struct_type()->fields();
+
+ Expression_list* ivals = new Expression_list();
+ ivals->reserve(2);
+
+ Struct_field_list::const_iterator pif = ifields->begin();
+ gcc_assert(pif->field_name() == "commonType");
+ ivals->push_back(this->type_descriptor_constructor(gogo,
+ RUNTIME_TYPE_KIND_INTERFACE,
+ name, NULL, true));
+
+ ++pif;
+ gcc_assert(pif->field_name() == "methods");
+
+ Expression_list* methods = new Expression_list();
+ if (this->methods_ != NULL && !this->methods_->empty())
+ {
+ Type* elemtype = pif->type()->array_type()->element_type();
+
+ methods->reserve(this->methods_->size());
+ for (Typed_identifier_list::const_iterator pm = this->methods_->begin();
+ pm != this->methods_->end();
+ ++pm)
+ {
+ const Struct_field_list* mfields = elemtype->struct_type()->fields();
+
+ Expression_list* mvals = new Expression_list();
+ mvals->reserve(3);
+
+ Struct_field_list::const_iterator pmf = mfields->begin();
+ gcc_assert(pmf->field_name() == "name");
+ std::string s = Gogo::unpack_hidden_name(pm->name());
+ Expression* e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+
+ ++pmf;
+ gcc_assert(pmf->field_name() == "pkgPath");
+ if (!Gogo::is_hidden_name(pm->name()))
+ mvals->push_back(Expression::make_nil(bloc));
+ else
+ {
+ s = Gogo::hidden_name_prefix(pm->name());
+ e = Expression::make_string(s, bloc);
+ mvals->push_back(Expression::make_unary(OPERATOR_AND, e, bloc));
+ }
+
+ ++pmf;
+ gcc_assert(pmf->field_name() == "typ");
+ mvals->push_back(Expression::make_type_descriptor(pm->type(), bloc));
+
+ ++pmf;
+ gcc_assert(pmf == mfields->end());
+
+ e = Expression::make_struct_composite_literal(elemtype, mvals,
+ bloc);
+ methods->push_back(e);
+ }
+ }
+
+ ivals->push_back(Expression::make_slice_composite_literal(pif->type(),
+ methods, bloc));
+
+ ++pif;
+ gcc_assert(pif == ifields->end());
+
+ return Expression::make_struct_composite_literal(itdt, ivals, bloc);
+}
+
+// Reflection string.
+
+void
+Interface_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ ret->append("interface {");
+ if (this->methods_ != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = this->methods_->begin();
+ p != this->methods_->end();
+ ++p)
+ {
+ if (p != this->methods_->begin())
+ ret->append(";");
+ ret->push_back(' ');
+ ret->append(Gogo::unpack_hidden_name(p->name()));
+ std::string sub = p->type()->reflection(gogo);
+ gcc_assert(sub.compare(0, 4, "func") == 0);
+ sub = sub.substr(4);
+ ret->append(sub);
+ }
+ }
+ ret->append(" }");
+}
+
+// Mangled name.
+
+void
+Interface_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ ret->push_back('I');
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ std::string n = Gogo::unpack_hidden_name(p->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "%u_",
+ static_cast<unsigned int>(n.length()));
+ ret->append(buf);
+ ret->append(n);
+ this->append_mangled_name(p->type(), gogo, ret);
+ }
+ }
+
+ ret->push_back('e');
+}
+
+// Export.
+
+void
+Interface_type::do_export(Export* exp) const
+{
+ exp->write_c_string("interface { ");
+
+ const Typed_identifier_list* methods = this->methods_;
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator pm = methods->begin();
+ pm != methods->end();
+ ++pm)
+ {
+ exp->write_string(pm->name());
+ exp->write_c_string(" (");
+
+ const Function_type* fntype = pm->type()->function_type();
+
+ bool first = true;
+ const Typed_identifier_list* parameters = fntype->parameters();
+ if (parameters != NULL)
+ {
+ bool is_varargs = fntype->is_varargs();
+ for (Typed_identifier_list::const_iterator pp =
+ parameters->begin();
+ pp != parameters->end();
+ ++pp)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ if (!is_varargs || pp + 1 != parameters->end())
+ exp->write_type(pp->type());
+ else
+ {
+ exp->write_c_string("...");
+ Type *pptype = pp->type();
+ exp->write_type(pptype->array_type()->element_type());
+ }
+ }
+ }
+
+ exp->write_c_string(")");
+
+ const Typed_identifier_list* results = fntype->results();
+ if (results != NULL)
+ {
+ exp->write_c_string(" ");
+ if (results->size() == 1)
+ exp->write_type(results->begin()->type());
+ else
+ {
+ first = true;
+ exp->write_c_string("(");
+ for (Typed_identifier_list::const_iterator p =
+ results->begin();
+ p != results->end();
+ ++p)
+ {
+ if (first)
+ first = false;
+ else
+ exp->write_c_string(", ");
+ exp->write_type(p->type());
+ }
+ exp->write_c_string(")");
+ }
+ }
+
+ exp->write_c_string("; ");
+ }
+ }
+
+ exp->write_c_string("}");
+}
+
+// Import an interface type.
+
+Interface_type*
+Interface_type::do_import(Import* imp)
+{
+ imp->require_c_string("interface { ");
+
+ Typed_identifier_list* methods = new Typed_identifier_list;
+ while (imp->peek_char() != '}')
+ {
+ std::string name = imp->read_identifier();
+ imp->require_c_string(" (");
+
+ Typed_identifier_list* parameters;
+ bool is_varargs = false;
+ if (imp->peek_char() == ')')
+ parameters = NULL;
+ else
+ {
+ parameters = new Typed_identifier_list;
+ while (true)
+ {
+ if (imp->match_c_string("..."))
+ {
+ imp->advance(3);
+ is_varargs = true;
+ }
+
+ Type* ptype = imp->read_type();
+ if (is_varargs)
+ ptype = Type::make_array_type(ptype, NULL);
+ parameters->push_back(Typed_identifier(Import::import_marker,
+ ptype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ gcc_assert(!is_varargs);
+ imp->require_c_string(", ");
+ }
+ }
+ imp->require_c_string(")");
+
+ Typed_identifier_list* results;
+ if (imp->peek_char() != ' ')
+ results = NULL;
+ else
+ {
+ results = new Typed_identifier_list;
+ imp->advance(1);
+ if (imp->peek_char() != '(')
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ }
+ else
+ {
+ imp->advance(1);
+ while (true)
+ {
+ Type* rtype = imp->read_type();
+ results->push_back(Typed_identifier(Import::import_marker,
+ rtype, imp->location()));
+ if (imp->peek_char() != ',')
+ break;
+ imp->require_c_string(", ");
+ }
+ imp->require_c_string(")");
+ }
+ }
+
+ Function_type* fntype = Type::make_function_type(NULL, parameters,
+ results,
+ imp->location());
+ if (is_varargs)
+ fntype->set_is_varargs();
+ methods->push_back(Typed_identifier(name, fntype, imp->location()));
+
+ imp->require_c_string("; ");
+ }
+
+ imp->require_c_string("}");
+
+ if (methods->empty())
+ {
+ delete methods;
+ methods = NULL;
+ }
+
+ return Type::make_interface_type(methods, imp->location());
+}
+
+// Make an interface type.
+
+Interface_type*
+Type::make_interface_type(Typed_identifier_list* methods,
+ source_location location)
+{
+ return new Interface_type(methods, location);
+}
+
+// Class Method.
+
+// Bind a method to an object.
+
+Expression*
+Method::bind_method(Expression* expr, source_location location) const
+{
+ if (this->stub_ == NULL)
+ {
+ // When there is no stub object, the binding is determined by
+ // the child class.
+ return this->do_bind_method(expr, location);
+ }
+
+ Expression* func = Expression::make_func_reference(this->stub_, NULL,
+ location);
+ return Expression::make_bound_method(expr, func, location);
+}
+
+// Return the named object associated with a method. This may only be
+// called after methods are finalized.
+
+Named_object*
+Method::named_object() const
+{
+ if (this->stub_ != NULL)
+ return this->stub_;
+ return this->do_named_object();
+}
+
+// Class Named_method.
+
+// The type of the method.
+
+Function_type*
+Named_method::do_type() const
+{
+ if (this->named_object_->is_function())
+ return this->named_object_->func_value()->type();
+ else if (this->named_object_->is_function_declaration())
+ return this->named_object_->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+}
+
+// Return the location of the method receiver.
+
+source_location
+Named_method::do_receiver_location() const
+{
+ return this->do_type()->receiver()->location();
+}
+
+// Bind a method to an object.
+
+Expression*
+Named_method::do_bind_method(Expression* expr, source_location location) const
+{
+ Expression* func = Expression::make_func_reference(this->named_object_, NULL,
+ location);
+ Bound_method_expression* bme = Expression::make_bound_method(expr, func,
+ location);
+ // If this is not a local method, and it does not use a stub, then
+ // the real method expects a different type. We need to cast the
+ // first argument.
+ if (this->depth() > 0 && !this->needs_stub_method())
+ {
+ Function_type* ftype = this->do_type();
+ gcc_assert(ftype->is_method());
+ Type* frtype = ftype->receiver()->type();
+ bme->set_first_argument_type(frtype);
+ }
+ return bme;
+}
+
+// Class Interface_method.
+
+// Bind a method to an object.
+
+Expression*
+Interface_method::do_bind_method(Expression* expr,
+ source_location location) const
+{
+ return Expression::make_interface_field_reference(expr, this->name_,
+ location);
+}
+
+// Class Methods.
+
+// Insert a new method. Return true if it was inserted, false
+// otherwise.
+
+bool
+Methods::insert(const std::string& name, Method* m)
+{
+ std::pair<Method_map::iterator, bool> ins =
+ this->methods_.insert(std::make_pair(name, m));
+ if (ins.second)
+ return true;
+ else
+ {
+ Method* old_method = ins.first->second;
+ if (m->depth() < old_method->depth())
+ {
+ delete old_method;
+ ins.first->second = m;
+ return true;
+ }
+ else
+ {
+ if (m->depth() == old_method->depth())
+ old_method->set_is_ambiguous();
+ return false;
+ }
+ }
+}
+
+// Return the number of unambiguous methods.
+
+size_t
+Methods::count() const
+{
+ size_t ret = 0;
+ for (Method_map::const_iterator p = this->methods_.begin();
+ p != this->methods_.end();
+ ++p)
+ if (!p->second->is_ambiguous())
+ ++ret;
+ return ret;
+}
+
+// Class Named_type.
+
+// Return the name of the type.
+
+const std::string&
+Named_type::name() const
+{
+ return this->named_object_->name();
+}
+
+// Return the name of the type to use in an error message.
+
+std::string
+Named_type::message_name() const
+{
+ return this->named_object_->message_name();
+}
+
+// Return the base type for this type. We have to be careful about
+// circular type definitions, which are invalid but may be seen here.
+
+Type*
+Named_type::named_base()
+{
+ if (this->seen_ > 0)
+ return this;
+ ++this->seen_;
+ Type* ret = this->type_->base();
+ --this->seen_;
+ return ret;
+}
+
+const Type*
+Named_type::named_base() const
+{
+ if (this->seen_ > 0)
+ return this;
+ ++this->seen_;
+ const Type* ret = this->type_->base();
+ --this->seen_;
+ return ret;
+}
+
+// Return whether this is an error type. We have to be careful about
+// circular type definitions, which are invalid but may be seen here.
+
+bool
+Named_type::is_named_error_type() const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->is_error_type();
+ --this->seen_;
+ return ret;
+}
+
+// Add a method to this type.
+
+Named_object*
+Named_type::add_method(const std::string& name, Function* function)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function(name, NULL, function);
+}
+
+// Add a method declaration to this type.
+
+Named_object*
+Named_type::add_method_declaration(const std::string& name, Package* package,
+ Function_type* type,
+ source_location location)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ return this->local_methods_->add_function_declaration(name, package, type,
+ location);
+}
+
+// Add an existing method to this type.
+
+void
+Named_type::add_existing_method(Named_object* no)
+{
+ if (this->local_methods_ == NULL)
+ this->local_methods_ = new Bindings(NULL);
+ this->local_methods_->add_named_object(no);
+}
+
+// Look for a local method NAME, and returns its named object, or NULL
+// if not there.
+
+Named_object*
+Named_type::find_local_method(const std::string& name) const
+{
+ if (this->local_methods_ == NULL)
+ return NULL;
+ return this->local_methods_->lookup(name);
+}
+
+// Return whether NAME is an unexported field or method, for better
+// error reporting.
+
+bool
+Named_type::is_unexported_local_method(Gogo* gogo,
+ const std::string& name) const
+{
+ Bindings* methods = this->local_methods_;
+ if (methods != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (Gogo::is_hidden_name(p->first)
+ && name == Gogo::unpack_hidden_name(p->first)
+ && gogo->pack_hidden_name(name, false) != p->first)
+ return true;
+ }
+ }
+ return false;
+}
+
+// Build the complete list of methods for this type, which means
+// recursively including all methods for anonymous fields. Create all
+// stub methods.
+
+void
+Named_type::finalize_methods(Gogo* gogo)
+{
+ if (this->all_methods_ != NULL)
+ return;
+
+ if (this->local_methods_ != NULL
+ && (this->points_to() != NULL || this->interface_type() != NULL))
+ {
+ const Bindings* lm = this->local_methods_;
+ for (Bindings::const_declarations_iterator p = lm->begin_declarations();
+ p != lm->end_declarations();
+ ++p)
+ error_at(p->second->location(),
+ "invalid pointer or interface receiver type");
+ delete this->local_methods_;
+ this->local_methods_ = NULL;
+ return;
+ }
+
+ Type::finalize_methods(gogo, this, this->location_, &this->all_methods_);
+}
+
+// Return the method NAME, or NULL if there isn't one or if it is
+// ambiguous. Set *IS_AMBIGUOUS if the method exists but is
+// ambiguous.
+
+Method*
+Named_type::method_function(const std::string& name, bool* is_ambiguous) const
+{
+ return Type::method_function(this->all_methods_, name, is_ambiguous);
+}
+
+// Return a pointer to the interface method table for this type for
+// the interface INTERFACE. IS_POINTER is true if this is for a
+// pointer to THIS.
+
+tree
+Named_type::interface_method_table(Gogo* gogo, const Interface_type* interface,
+ bool is_pointer)
+{
+ gcc_assert(!interface->is_empty());
+
+ Interface_method_tables** pimt = (is_pointer
+ ? &this->interface_method_tables_
+ : &this->pointer_interface_method_tables_);
+
+ if (*pimt == NULL)
+ *pimt = new Interface_method_tables(5);
+
+ std::pair<const Interface_type*, tree> val(interface, NULL_TREE);
+ std::pair<Interface_method_tables::iterator, bool> ins = (*pimt)->insert(val);
+
+ if (ins.second)
+ {
+ // This is a new entry in the hash table.
+ gcc_assert(ins.first->second == NULL_TREE);
+ ins.first->second = gogo->interface_method_table_for_type(interface,
+ this,
+ is_pointer);
+ }
+
+ tree decl = ins.first->second;
+ if (decl == error_mark_node)
+ return error_mark_node;
+ gcc_assert(decl != NULL_TREE && TREE_CODE(decl) == VAR_DECL);
+ return build_fold_addr_expr(decl);
+}
+
+// Return whether a named type has any hidden fields.
+
+bool
+Named_type::named_type_has_hidden_fields(std::string* reason) const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->has_hidden_fields(this, reason);
+ --this->seen_;
+ return ret;
+}
+
+// Look for a use of a complete type within another type. This is
+// used to check that we don't try to use a type within itself.
+
+class Find_type_use : public Traverse
+{
+ public:
+ Find_type_use(Named_type* find_type)
+ : Traverse(traverse_types),
+ find_type_(find_type), found_(false)
+ { }
+
+ // Whether we found the type.
+ bool
+ found() const
+ { return this->found_; }
+
+ protected:
+ int
+ type(Type*);
+
+ private:
+ // The type we are looking for.
+ Named_type* find_type_;
+ // Whether we found the type.
+ bool found_;
+};
+
+// Check for FIND_TYPE in TYPE.
+
+int
+Find_type_use::type(Type* type)
+{
+ if (type->named_type() != NULL && this->find_type_ == type->named_type())
+ {
+ this->found_ = true;
+ return TRAVERSE_EXIT;
+ }
+
+ // It's OK if we see a reference to the type in any type which is
+ // essentially a pointer: a pointer, a slice, a function, a map, or
+ // a channel.
+ if (type->points_to() != NULL
+ || type->is_open_array_type()
+ || type->function_type() != NULL
+ || type->map_type() != NULL
+ || type->channel_type() != NULL)
+ return TRAVERSE_SKIP_COMPONENTS;
+
+ // For an interface, a reference to the type in a method type should
+ // be ignored, but we have to consider direct inheritance. When
+ // this is called, there may be cases of direct inheritance
+ // represented as a method with no name.
+ if (type->interface_type() != NULL)
+ {
+ const Typed_identifier_list* methods = type->interface_type()->methods();
+ if (methods != NULL)
+ {
+ for (Typed_identifier_list::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ if (p->name().empty())
+ {
+ if (Type::traverse(p->type(), this) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ }
+ }
+ return TRAVERSE_SKIP_COMPONENTS;
+ }
+
+ // Otherwise, FIND_TYPE_ depends on TYPE, in the sense that we need
+ // to convert TYPE to the backend representation before we convert
+ // FIND_TYPE_.
+ if (type->named_type() != NULL)
+ {
+ switch (type->base()->classification())
+ {
+ case Type::TYPE_ERROR:
+ case Type::TYPE_BOOLEAN:
+ case Type::TYPE_INTEGER:
+ case Type::TYPE_FLOAT:
+ case Type::TYPE_COMPLEX:
+ case Type::TYPE_STRING:
+ case Type::TYPE_NIL:
+ break;
+
+ case Type::TYPE_ARRAY:
+ case Type::TYPE_STRUCT:
+ this->find_type_->add_dependency(type->named_type());
+ break;
+
+ case Type::TYPE_VOID:
+ case Type::TYPE_SINK:
+ case Type::TYPE_FUNCTION:
+ case Type::TYPE_POINTER:
+ case Type::TYPE_CALL_MULTIPLE_RESULT:
+ case Type::TYPE_MAP:
+ case Type::TYPE_CHANNEL:
+ case Type::TYPE_INTERFACE:
+ case Type::TYPE_NAMED:
+ case Type::TYPE_FORWARD:
+ default:
+ gcc_unreachable();
+ }
+ }
+
+ return TRAVERSE_CONTINUE;
+}
+
+// Verify that a named type does not refer to itself.
+
+bool
+Named_type::do_verify()
+{
+ Find_type_use find(this);
+ Type::traverse(this->type_, &find);
+ if (find.found())
+ {
+ error_at(this->location_, "invalid recursive type %qs",
+ this->message_name().c_str());
+ this->is_error_ = true;
+ return false;
+ }
+
+ // Check whether any of the local methods overloads an existing
+ // struct field or interface method. We don't need to check the
+ // list of methods against itself: that is handled by the Bindings
+ // code.
+ if (this->local_methods_ != NULL)
+ {
+ Struct_type* st = this->type_->struct_type();
+ Interface_type* it = this->type_->interface_type();
+ bool found_dup = false;
+ if (st != NULL || it != NULL)
+ {
+ for (Bindings::const_declarations_iterator p =
+ this->local_methods_->begin_declarations();
+ p != this->local_methods_->end_declarations();
+ ++p)
+ {
+ const std::string& name(p->first);
+ if (st != NULL && st->find_local_field(name, NULL) != NULL)
+ {
+ error_at(p->second->location(),
+ "method %qs redeclares struct field name",
+ Gogo::message_name(name).c_str());
+ found_dup = true;
+ }
+ if (it != NULL && it->find_method(name) != NULL)
+ {
+ error_at(p->second->location(),
+ "method %qs redeclares interface method name",
+ Gogo::message_name(name).c_str());
+ found_dup = true;
+ }
+ }
+ }
+ if (found_dup)
+ return false;
+ }
+
+ return true;
+}
+
+// Return whether this type is or contains a pointer.
+
+bool
+Named_type::do_has_pointer() const
+{
+ if (this->seen_ > 0)
+ return false;
+ ++this->seen_;
+ bool ret = this->type_->has_pointer();
+ --this->seen_;
+ return ret;
+}
+
+// Return a hash code. This is used for method lookup. We simply
+// hash on the name itself.
+
+unsigned int
+Named_type::do_hash_for_method(Gogo* gogo) const
+{
+ const std::string& name(this->named_object()->name());
+ unsigned int ret = Type::hash_string(name, 0);
+
+ // GOGO will be NULL here when called from Type_hash_identical.
+ // That is OK because that is only used for internal hash tables
+ // where we are going to be comparing named types for equality. In
+ // other cases, which are cases where the runtime is going to
+ // compare hash codes to see if the types are the same, we need to
+ // include the package prefix and name in the hash.
+ if (gogo != NULL && !Gogo::is_hidden_name(name) && !this->is_builtin())
+ {
+ const Package* package = this->named_object()->package();
+ if (package == NULL)
+ {
+ ret = Type::hash_string(gogo->unique_prefix(), ret);
+ ret = Type::hash_string(gogo->package_name(), ret);
+ }
+ else
+ {
+ ret = Type::hash_string(package->unique_prefix(), ret);
+ ret = Type::hash_string(package->name(), ret);
+ }
+ }
+
+ return ret;
+}
+
+// Convert a named type to the backend representation. In order to
+// get dependencies right, we fill in a dummy structure for this type,
+// then convert all the dependencies, then complete this type. When
+// this function is complete, the size of the type is known.
+
+void
+Named_type::convert(Gogo* gogo)
+{
+ if (this->is_error_ || this->is_converted_)
+ return;
+
+ this->create_placeholder(gogo);
+
+ // Convert all the dependencies. If they refer indirectly back to
+ // this type, they will pick up the intermediate tree we just
+ // created.
+ for (std::vector<Named_type*>::const_iterator p = this->dependencies_.begin();
+ p != this->dependencies_.end();
+ ++p)
+ (*p)->convert(gogo);
+
+ // Complete this type.
+ tree t = this->named_tree_;
+ Type* base = this->type_->base();
+ switch (base->classification())
+ {
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ break;
+
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ // The size of these types is already correct.
+ break;
+
+ case TYPE_STRUCT:
+ t = base->struct_type()->fill_in_tree(gogo, t);
+ break;
+
+ case TYPE_ARRAY:
+ if (!base->is_open_array_type())
+ t = base->array_type()->fill_in_array_tree(gogo, t);
+ break;
+
+ case TYPE_INTERFACE:
+ if (!base->interface_type()->is_empty())
+ t = base->interface_type()->fill_in_tree(gogo, t);
+ break;
+
+ case TYPE_ERROR:
+ return;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ gcc_unreachable();
+ }
+
+ this->named_tree_ = t;
+
+ if (t == error_mark_node)
+ this->is_error_ = true;
+ else
+ gcc_assert(TYPE_SIZE(t) != NULL_TREE);
+
+ this->is_converted_ = true;
+}
+
+// Create the placeholder for a named type. This is the first step in
+// converting to the backend representation.
+
+void
+Named_type::create_placeholder(Gogo* gogo)
+{
+ if (this->is_error_)
+ this->named_tree_ = error_mark_node;
+
+ if (this->named_tree_ != NULL_TREE)
+ return;
+
+ // Create the structure for this type. Note that because we call
+ // base() here, we don't attempt to represent a named type defined
+ // as another named type. Instead both named types will point to
+ // different base representations.
+ Type* base = this->type_->base();
+ tree t;
+ switch (base->classification())
+ {
+ case TYPE_ERROR:
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ // These are simple basic types, we can just create them
+ // directly.
+ t = Type::get_named_type_tree(gogo, base);
+ if (t == error_mark_node)
+ {
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+ }
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ // All maps and channels have the same type in GENERIC.
+ t = Type::get_named_type_tree(gogo, base);
+ if (t == error_mark_node)
+ {
+ this->is_error_ = true;
+ this->named_tree_ = error_mark_node;
+ return;
+ }
+ t = build_variant_type_copy(t);
+ break;
+
+ case TYPE_FUNCTION:
+ case TYPE_POINTER:
+ t = build_variant_type_copy(ptr_type_node);
+ break;
+
+ case TYPE_STRUCT:
+ t = make_node(RECORD_TYPE);
+ break;
+
+ case TYPE_ARRAY:
+ if (base->is_open_array_type())
+ t = gogo->slice_type_tree(void_type_node);
+ else
+ t = make_node(ARRAY_TYPE);
+ break;
+
+ case TYPE_INTERFACE:
+ if (base->interface_type()->is_empty())
+ {
+ t = Interface_type::empty_type_tree(gogo);
+ t = build_variant_type_copy(t);
+ }
+ else
+ {
+ source_location loc = base->interface_type()->location();
+ t = Interface_type::non_empty_type_tree(loc);
+ }
+ break;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ gcc_unreachable();
+ }
+
+ // Create the named type.
+
+ tree id = this->named_object_->get_id(gogo);
+ tree decl = build_decl(this->location_, TYPE_DECL, id, t);
+ TYPE_NAME(t) = decl;
+
+ this->named_tree_ = t;
+}
+
+// Get a tree for a named type.
+
+tree
+Named_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_error_)
+ return error_mark_node;
+
+ tree t = this->named_tree_;
+
+ // FIXME: GOGO can be NULL when called from go_type_for_size, which
+ // is only used for basic types.
+ if (gogo == NULL || !gogo->named_types_are_converted())
+ {
+ // We have not completed converting named types. NAMED_TREE_ is
+ // a placeholder and we shouldn't do anything further.
+ if (t != NULL_TREE)
+ return t;
+
+ // We don't build dependencies for types whose sizes do not
+ // change or are not relevant, so we may see them here while
+ // converting types.
+ this->create_placeholder(gogo);
+ t = this->named_tree_;
+ gcc_assert(t != NULL_TREE);
+ return t;
+ }
+
+ // We are not converting types. This should only be called if the
+ // type has already been converted.
+ if (!this->is_converted_)
+ {
+ gcc_assert(saw_errors());
+ return error_mark_node;
+ }
+
+ gcc_assert(t != NULL_TREE && TYPE_SIZE(t) != NULL_TREE);
+
+ // Complete the tree.
+ Type* base = this->type_->base();
+ tree t1;
+ switch (base->classification())
+ {
+ case TYPE_ERROR:
+ return error_mark_node;
+
+ case TYPE_VOID:
+ case TYPE_BOOLEAN:
+ case TYPE_INTEGER:
+ case TYPE_FLOAT:
+ case TYPE_COMPLEX:
+ case TYPE_STRING:
+ case TYPE_NIL:
+ case TYPE_MAP:
+ case TYPE_CHANNEL:
+ case TYPE_STRUCT:
+ case TYPE_INTERFACE:
+ return t;
+
+ case TYPE_FUNCTION:
+ // Don't build a circular data structure. GENERIC can't handle
+ // it.
+ if (this->seen_ > 0)
+ {
+ this->is_circular_ = true;
+ return ptr_type_node;
+ }
+ ++this->seen_;
+ t1 = Type::get_named_type_tree(gogo, base);
+ --this->seen_;
+ if (t1 == error_mark_node)
+ return error_mark_node;
+ if (this->is_circular_)
+ t1 = ptr_type_node;
+ gcc_assert(t != NULL_TREE && TREE_CODE(t) == POINTER_TYPE);
+ gcc_assert(TREE_CODE(t1) == POINTER_TYPE);
+ TREE_TYPE(t) = TREE_TYPE(t1);
+ return t;
+
+ case TYPE_POINTER:
+ // Don't build a circular data structure. GENERIC can't handle
+ // it.
+ if (this->seen_ > 0)
+ {
+ this->is_circular_ = true;
+ return ptr_type_node;
+ }
+ ++this->seen_;
+ t1 = Type::get_named_type_tree(gogo, base);
+ --this->seen_;
+ if (t1 == error_mark_node)
+ return error_mark_node;
+ if (this->is_circular_)
+ t1 = ptr_type_node;
+ gcc_assert(t != NULL_TREE && TREE_CODE(t) == POINTER_TYPE);
+ gcc_assert(TREE_CODE(t1) == POINTER_TYPE);
+ TREE_TYPE(t) = TREE_TYPE(t1);
+ return t;
+
+ case TYPE_ARRAY:
+ if (base->is_open_array_type())
+ {
+ if (this->seen_ > 0)
+ return t;
+ else
+ {
+ ++this->seen_;
+ t = base->array_type()->fill_in_slice_tree(gogo, t);
+ --this->seen_;
+ }
+ }
+ return t;
+
+ default:
+ case TYPE_SINK:
+ case TYPE_CALL_MULTIPLE_RESULT:
+ case TYPE_NAMED:
+ case TYPE_FORWARD:
+ gcc_unreachable();
+ }
+
+ gcc_unreachable();
+}
+
+// Build a type descriptor for a named type.
+
+Expression*
+Named_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ // If NAME is not NULL, then we don't really want the type
+ // descriptor for this type; we want the descriptor for the
+ // underlying type, giving it the name NAME.
+ return this->named_type_descriptor(gogo, this->type_,
+ name == NULL ? this : name);
+}
+
+// Add to the reflection string. This is used mostly for the name of
+// the type used in a type descriptor, not for actual reflection
+// strings.
+
+void
+Named_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ if (this->location() != BUILTINS_LOCATION)
+ {
+ const Package* package = this->named_object_->package();
+ if (package != NULL)
+ ret->append(package->name());
+ else
+ ret->append(gogo->package_name());
+ ret->push_back('.');
+ }
+ if (this->in_function_ != NULL)
+ {
+ ret->append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ ret->push_back('$');
+ }
+ ret->append(Gogo::unpack_hidden_name(this->named_object_->name()));
+}
+
+// Get the mangled name.
+
+void
+Named_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ Named_object* no = this->named_object_;
+ std::string name;
+ if (this->location() == BUILTINS_LOCATION)
+ gcc_assert(this->in_function_ == NULL);
+ else
+ {
+ const std::string& unique_prefix(no->package() == NULL
+ ? gogo->unique_prefix()
+ : no->package()->unique_prefix());
+ const std::string& package_name(no->package() == NULL
+ ? gogo->package_name()
+ : no->package()->name());
+ name = unique_prefix;
+ name.append(1, '.');
+ name.append(package_name);
+ name.append(1, '.');
+ if (this->in_function_ != NULL)
+ {
+ name.append(Gogo::unpack_hidden_name(this->in_function_->name()));
+ name.append(1, '$');
+ }
+ }
+ name.append(Gogo::unpack_hidden_name(no->name()));
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_", static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+}
+
+// Export the type. This is called to export a global type.
+
+void
+Named_type::export_named_type(Export* exp, const std::string&) const
+{
+ // We don't need to write the name of the type here, because it will
+ // be written by Export::write_type anyhow.
+ exp->write_c_string("type ");
+ exp->write_type(this);
+ exp->write_c_string(";\n");
+}
+
+// Import a named type.
+
+void
+Named_type::import_named_type(Import* imp, Named_type** ptype)
+{
+ imp->require_c_string("type ");
+ Type *type = imp->read_type();
+ *ptype = type->named_type();
+ gcc_assert(*ptype != NULL);
+ imp->require_c_string(";\n");
+}
+
+// Export the type when it is referenced by another type. In this
+// case Export::export_type will already have issued the name.
+
+void
+Named_type::do_export(Export* exp) const
+{
+ exp->write_type(this->type_);
+
+ // To save space, we only export the methods directly attached to
+ // this type.
+ Bindings* methods = this->local_methods_;
+ if (methods == NULL)
+ return;
+
+ exp->write_c_string("\n");
+ for (Bindings::const_definitions_iterator p = methods->begin_definitions();
+ p != methods->end_definitions();
+ ++p)
+ {
+ exp->write_c_string(" ");
+ (*p)->export_named_object(exp);
+ }
+
+ for (Bindings::const_declarations_iterator p = methods->begin_declarations();
+ p != methods->end_declarations();
+ ++p)
+ {
+ if (p->second->is_function_declaration())
+ {
+ exp->write_c_string(" ");
+ p->second->export_named_object(exp);
+ }
+ }
+}
+
+// Make a named type.
+
+Named_type*
+Type::make_named_type(Named_object* named_object, Type* type,
+ source_location location)
+{
+ return new Named_type(named_object, type, location);
+}
+
+// Finalize the methods for TYPE. It will be a named type or a struct
+// type. This sets *ALL_METHODS to the list of methods, and builds
+// all required stubs.
+
+void
+Type::finalize_methods(Gogo* gogo, const Type* type, source_location location,
+ Methods** all_methods)
+{
+ *all_methods = NULL;
+ Types_seen types_seen;
+ Type::add_methods_for_type(type, NULL, 0, false, false, &types_seen,
+ all_methods);
+ Type::build_stub_methods(gogo, type, *all_methods, location);
+}
+
+// Add the methods for TYPE to *METHODS. FIELD_INDEXES is used to
+// build up the struct field indexes as we go. DEPTH is the depth of
+// the field within TYPE. IS_EMBEDDED_POINTER is true if we are
+// adding these methods for an anonymous field with pointer type.
+// NEEDS_STUB_METHOD is true if we need to use a stub method which
+// calls the real method. TYPES_SEEN is used to avoid infinite
+// recursion.
+
+void
+Type::add_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Pointer types may not have methods.
+ if (type->points_to() != NULL)
+ return;
+
+ const Named_type* nt = type->named_type();
+ if (nt != NULL)
+ {
+ std::pair<Types_seen::iterator, bool> ins = types_seen->insert(nt);
+ if (!ins.second)
+ return;
+ }
+
+ if (nt != NULL)
+ Type::add_local_methods_for_type(nt, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ methods);
+
+ Type::add_embedded_methods_for_type(type, field_indexes, depth,
+ is_embedded_pointer, needs_stub_method,
+ types_seen, methods);
+
+ // If we are called with depth > 0, then we are looking at an
+ // anonymous field of a struct. If such a field has interface type,
+ // then we need to add the interface methods. We don't want to add
+ // them when depth == 0, because we will already handle them
+ // following the usual rules for an interface type.
+ if (depth > 0)
+ Type::add_interface_methods_for_type(type, field_indexes, depth, methods);
+}
+
+// Add the local methods for the named type NT to *METHODS. The
+// parameters are as for add_methods_to_type.
+
+void
+Type::add_local_methods_for_type(const Named_type* nt,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Methods** methods)
+{
+ const Bindings* local_methods = nt->local_methods();
+ if (local_methods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Bindings::const_declarations_iterator p =
+ local_methods->begin_declarations();
+ p != local_methods->end_declarations();
+ ++p)
+ {
+ Named_object* no = p->second;
+ bool is_value_method = (is_embedded_pointer
+ || !Type::method_expects_pointer(no));
+ Method* m = new Named_method(no, field_indexes, depth, is_value_method,
+ (needs_stub_method
+ || (depth > 0 && is_value_method)));
+ if (!(*methods)->insert(no->name(), m))
+ delete m;
+ }
+}
+
+// Add the embedded methods for TYPE to *METHODS. These are the
+// methods attached to anonymous fields. The parameters are as for
+// add_methods_to_type.
+
+void
+Type::add_embedded_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ bool is_embedded_pointer,
+ bool needs_stub_method,
+ Types_seen* types_seen,
+ Methods** methods)
+{
+ // Look for anonymous fields in TYPE. TYPE has fields if it is a
+ // struct.
+ const Struct_type* st = type->struct_type();
+ if (st == NULL)
+ return;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return;
+
+ unsigned int i = 0;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf, ++i)
+ {
+ if (!pf->is_anonymous())
+ continue;
+
+ Type* ftype = pf->type();
+ bool is_pointer = false;
+ if (ftype->points_to() != NULL)
+ {
+ ftype = ftype->points_to();
+ is_pointer = true;
+ }
+ Named_type* fnt = ftype->named_type();
+ if (fnt == NULL)
+ {
+ // This is an error, but it will be diagnosed elsewhere.
+ continue;
+ }
+
+ Method::Field_indexes* sub_field_indexes = new Method::Field_indexes();
+ sub_field_indexes->next = field_indexes;
+ sub_field_indexes->field_index = i;
+
+ Type::add_methods_for_type(fnt, sub_field_indexes, depth + 1,
+ (is_embedded_pointer || is_pointer),
+ (needs_stub_method
+ || is_pointer
+ || i > 0),
+ types_seen,
+ methods);
+ }
+}
+
+// If TYPE is an interface type, then add its method to *METHODS.
+// This is for interface methods attached to an anonymous field. The
+// parameters are as for add_methods_for_type.
+
+void
+Type::add_interface_methods_for_type(const Type* type,
+ const Method::Field_indexes* field_indexes,
+ unsigned int depth,
+ Methods** methods)
+{
+ const Interface_type* it = type->interface_type();
+ if (it == NULL)
+ return;
+
+ const Typed_identifier_list* imethods = it->methods();
+ if (imethods == NULL)
+ return;
+
+ if (*methods == NULL)
+ *methods = new Methods();
+
+ for (Typed_identifier_list::const_iterator pm = imethods->begin();
+ pm != imethods->end();
+ ++pm)
+ {
+ Function_type* fntype = pm->type()->function_type();
+ if (fntype == NULL)
+ {
+ // This is an error, but it should be reported elsewhere
+ // when we look at the methods for IT.
+ continue;
+ }
+ gcc_assert(!fntype->is_method());
+ fntype = fntype->copy_with_receiver(const_cast<Type*>(type));
+ Method* m = new Interface_method(pm->name(), pm->location(), fntype,
+ field_indexes, depth);
+ if (!(*methods)->insert(pm->name(), m))
+ delete m;
+ }
+}
+
+// Build stub methods for TYPE as needed. METHODS is the set of
+// methods for the type. A stub method may be needed when a type
+// inherits a method from an anonymous field. When we need the
+// address of the method, as in a type descriptor, we need to build a
+// little stub which does the required field dereferences and jumps to
+// the real method. LOCATION is the location of the type definition.
+
+void
+Type::build_stub_methods(Gogo* gogo, const Type* type, const Methods* methods,
+ source_location location)
+{
+ if (methods == NULL)
+ return;
+ for (Methods::const_iterator p = methods->begin();
+ p != methods->end();
+ ++p)
+ {
+ Method* m = p->second;
+ if (m->is_ambiguous() || !m->needs_stub_method())
+ continue;
+
+ const std::string& name(p->first);
+
+ // Build a stub method.
+
+ const Function_type* fntype = m->type();
+
+ static unsigned int counter;
+ char buf[100];
+ snprintf(buf, sizeof buf, "$this%u", counter);
+ ++counter;
+
+ Type* receiver_type = const_cast<Type*>(type);
+ if (!m->is_value_method())
+ receiver_type = Type::make_pointer_type(receiver_type);
+ source_location receiver_location = m->receiver_location();
+ Typed_identifier* receiver = new Typed_identifier(buf, receiver_type,
+ receiver_location);
+
+ const Typed_identifier_list* fnparams = fntype->parameters();
+ Typed_identifier_list* stub_params;
+ if (fnparams == NULL || fnparams->empty())
+ stub_params = NULL;
+ else
+ {
+ // We give each stub parameter a unique name.
+ stub_params = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pp = fnparams->begin();
+ pp != fnparams->end();
+ ++pp)
+ {
+ char pbuf[100];
+ snprintf(pbuf, sizeof pbuf, "$p%u", counter);
+ stub_params->push_back(Typed_identifier(pbuf, pp->type(),
+ pp->location()));
+ ++counter;
+ }
+ }
+
+ const Typed_identifier_list* fnresults = fntype->results();
+ Typed_identifier_list* stub_results;
+ if (fnresults == NULL || fnresults->empty())
+ stub_results = NULL;
+ else
+ {
+ // We create the result parameters without any names, since
+ // we won't refer to them.
+ stub_results = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator pr = fnresults->begin();
+ pr != fnresults->end();
+ ++pr)
+ stub_results->push_back(Typed_identifier("", pr->type(),
+ pr->location()));
+ }
+
+ Function_type* stub_type = Type::make_function_type(receiver,
+ stub_params,
+ stub_results,
+ fntype->location());
+ if (fntype->is_varargs())
+ stub_type->set_is_varargs();
+
+ // We only create the function in the package which creates the
+ // type.
+ const Package* package;
+ if (type->named_type() == NULL)
+ package = NULL;
+ else
+ package = type->named_type()->named_object()->package();
+ Named_object* stub;
+ if (package != NULL)
+ stub = Named_object::make_function_declaration(name, package,
+ stub_type, location);
+ else
+ {
+ stub = gogo->start_function(name, stub_type, false,
+ fntype->location());
+ Type::build_one_stub_method(gogo, m, buf, stub_params,
+ fntype->is_varargs(), location);
+ gogo->finish_function(fntype->location());
+ }
+
+ m->set_stub_object(stub);
+ }
+}
+
+// Build a stub method which adjusts the receiver as required to call
+// METHOD. RECEIVER_NAME is the name we used for the receiver.
+// PARAMS is the list of function parameters.
+
+void
+Type::build_one_stub_method(Gogo* gogo, Method* method,
+ const char* receiver_name,
+ const Typed_identifier_list* params,
+ bool is_varargs,
+ source_location location)
+{
+ Named_object* receiver_object = gogo->lookup(receiver_name, NULL);
+ gcc_assert(receiver_object != NULL);
+
+ Expression* expr = Expression::make_var_reference(receiver_object, location);
+ expr = Type::apply_field_indexes(expr, method->field_indexes(), location);
+ if (expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+
+ Expression_list* arguments;
+ if (params == NULL || params->empty())
+ arguments = NULL;
+ else
+ {
+ arguments = new Expression_list();
+ for (Typed_identifier_list::const_iterator p = params->begin();
+ p != params->end();
+ ++p)
+ {
+ Named_object* param = gogo->lookup(p->name(), NULL);
+ gcc_assert(param != NULL);
+ Expression* param_ref = Expression::make_var_reference(param,
+ location);
+ arguments->push_back(param_ref);
+ }
+ }
+
+ Expression* func = method->bind_method(expr, location);
+ gcc_assert(func != NULL);
+ Call_expression* call = Expression::make_call(func, arguments, is_varargs,
+ location);
+ size_t count = call->result_count();
+ if (count == 0)
+ gogo->add_statement(Statement::make_statement(call));
+ else
+ {
+ Expression_list* retvals = new Expression_list();
+ if (count <= 1)
+ retvals->push_back(call);
+ else
+ {
+ for (size_t i = 0; i < count; ++i)
+ retvals->push_back(Expression::make_call_result(call, i));
+ }
+ const Function* function = gogo->current_function()->func_value();
+ const Typed_identifier_list* results = function->type()->results();
+ Statement* retstat = Statement::make_return_statement(results, retvals,
+ location);
+ gogo->add_statement(retstat);
+ }
+}
+
+// Apply FIELD_INDEXES to EXPR. The field indexes have to be applied
+// in reverse order.
+
+Expression*
+Type::apply_field_indexes(Expression* expr,
+ const Method::Field_indexes* field_indexes,
+ source_location location)
+{
+ if (field_indexes == NULL)
+ return expr;
+ expr = Type::apply_field_indexes(expr, field_indexes->next, location);
+ Struct_type* stype = expr->type()->deref()->struct_type();
+ gcc_assert(stype != NULL
+ && field_indexes->field_index < stype->field_count());
+ if (expr->type()->struct_type() == NULL)
+ {
+ gcc_assert(expr->type()->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ gcc_assert(expr->type()->struct_type() == stype);
+ }
+ return Expression::make_field_reference(expr, field_indexes->field_index,
+ location);
+}
+
+// Return whether NO is a method for which the receiver is a pointer.
+
+bool
+Type::method_expects_pointer(const Named_object* no)
+{
+ const Function_type *fntype;
+ if (no->is_function())
+ fntype = no->func_value()->type();
+ else if (no->is_function_declaration())
+ fntype = no->func_declaration_value()->type();
+ else
+ gcc_unreachable();
+ return fntype->receiver()->type()->points_to() != NULL;
+}
+
+// Given a set of methods for a type, METHODS, return the method NAME,
+// or NULL if there isn't one or if it is ambiguous. If IS_AMBIGUOUS
+// is not NULL, then set *IS_AMBIGUOUS to true if the method exists
+// but is ambiguous (and return NULL).
+
+Method*
+Type::method_function(const Methods* methods, const std::string& name,
+ bool* is_ambiguous)
+{
+ if (is_ambiguous != NULL)
+ *is_ambiguous = false;
+ if (methods == NULL)
+ return NULL;
+ Methods::const_iterator p = methods->find(name);
+ if (p == methods->end())
+ return NULL;
+ Method* m = p->second;
+ if (m->is_ambiguous())
+ {
+ if (is_ambiguous != NULL)
+ *is_ambiguous = true;
+ return NULL;
+ }
+ return m;
+}
+
+// Look for field or method NAME for TYPE. Return an Expression for
+// the field or method bound to EXPR. If there is no such field or
+// method, give an appropriate error and return an error expression.
+
+Expression*
+Type::bind_field_or_method(Gogo* gogo, const Type* type, Expression* expr,
+ const std::string& name,
+ source_location location)
+{
+ if (type->deref()->is_error_type())
+ return Expression::make_error(location);
+
+ const Named_type* nt = type->deref()->named_type();
+ const Struct_type* st = type->deref()->struct_type();
+ const Interface_type* it = type->deref()->interface_type();
+
+ // If this is a pointer to a pointer, then it is possible that the
+ // pointed-to type has methods.
+ if (nt == NULL
+ && st == NULL
+ && it == NULL
+ && type->points_to() != NULL
+ && type->points_to()->points_to() != NULL)
+ {
+ expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+ type = type->points_to();
+ if (type->deref()->is_error_type())
+ return Expression::make_error(location);
+ nt = type->points_to()->named_type();
+ st = type->points_to()->struct_type();
+ it = type->points_to()->interface_type();
+ }
+
+ bool receiver_can_be_pointer = (expr->type()->points_to() != NULL
+ || expr->is_addressable());
+ std::vector<const Named_type*> seen;
+ bool is_method = false;
+ bool found_pointer_method = false;
+ std::string ambig1;
+ std::string ambig2;
+ if (Type::find_field_or_method(type, name, receiver_can_be_pointer,
+ &seen, NULL, &is_method,
+ &found_pointer_method, &ambig1, &ambig2))
+ {
+ Expression* ret;
+ if (!is_method)
+ {
+ gcc_assert(st != NULL);
+ if (type->struct_type() == NULL)
+ {
+ gcc_assert(type->points_to() != NULL);
+ expr = Expression::make_unary(OPERATOR_MULT, expr,
+ location);
+ gcc_assert(expr->type()->struct_type() == st);
+ }
+ ret = st->field_reference(expr, name, location);
+ }
+ else if (it != NULL && it->find_method(name) != NULL)
+ ret = Expression::make_interface_field_reference(expr, name,
+ location);
+ else
+ {
+ Method* m;
+ if (nt != NULL)
+ m = nt->method_function(name, NULL);
+ else if (st != NULL)
+ m = st->method_function(name, NULL);
+ else
+ gcc_unreachable();
+ gcc_assert(m != NULL);
+ if (!m->is_value_method() && expr->type()->points_to() == NULL)
+ expr = Expression::make_unary(OPERATOR_AND, expr, location);
+ ret = m->bind_method(expr, location);
+ }
+ gcc_assert(ret != NULL);
+ return ret;
+ }
+ else
+ {
+ if (!ambig1.empty())
+ error_at(location, "%qs is ambiguous via %qs and %qs",
+ Gogo::message_name(name).c_str(),
+ Gogo::message_name(ambig1).c_str(),
+ Gogo::message_name(ambig2).c_str());
+ else if (found_pointer_method)
+ error_at(location, "method requires a pointer");
+ else if (nt == NULL && st == NULL && it == NULL)
+ error_at(location,
+ ("reference to field %qs in object which "
+ "has no fields or methods"),
+ Gogo::message_name(name).c_str());
+ else
+ {
+ bool is_unexported;
+ if (!Gogo::is_hidden_name(name))
+ is_unexported = false;
+ else
+ {
+ std::string unpacked = Gogo::unpack_hidden_name(name);
+ seen.clear();
+ is_unexported = Type::is_unexported_field_or_method(gogo, type,
+ unpacked,
+ &seen);
+ }
+ if (is_unexported)
+ error_at(location, "reference to unexported field or method %qs",
+ Gogo::message_name(name).c_str());
+ else
+ error_at(location, "reference to undefined field or method %qs",
+ Gogo::message_name(name).c_str());
+ }
+ return Expression::make_error(location);
+ }
+}
+
+// Look in TYPE for a field or method named NAME, return true if one
+// is found. This looks through embedded anonymous fields and handles
+// ambiguity. If a method is found, sets *IS_METHOD to true;
+// otherwise, if a field is found, set it to false. If
+// RECEIVER_CAN_BE_POINTER is false, then the receiver is a value
+// whose address can not be taken. SEEN is used to avoid infinite
+// recursion on invalid types.
+
+// When returning false, this sets *FOUND_POINTER_METHOD if we found a
+// method we couldn't use because it requires a pointer. LEVEL is
+// used for recursive calls, and can be NULL for a non-recursive call.
+// When this function returns false because it finds that the name is
+// ambiguous, it will store a path to the ambiguous names in *AMBIG1
+// and *AMBIG2. If the name is not found at all, *AMBIG1 and *AMBIG2
+// will be unchanged.
+
+// This function just returns whether or not there is a field or
+// method, and whether it is a field or method. It doesn't build an
+// expression to refer to it. If it is a method, we then look in the
+// list of all methods for the type. If it is a field, the search has
+// to be done again, looking only for fields, and building up the
+// expression as we go.
+
+bool
+Type::find_field_or_method(const Type* type,
+ const std::string& name,
+ bool receiver_can_be_pointer,
+ std::vector<const Named_type*>* seen,
+ int* level,
+ bool* is_method,
+ bool* found_pointer_method,
+ std::string* ambig1,
+ std::string* ambig2)
+{
+ // Named types can have locally defined methods.
+ const Named_type* nt = type->named_type();
+ if (nt == NULL && type->points_to() != NULL)
+ nt = type->points_to()->named_type();
+ if (nt != NULL)
+ {
+ Named_object* no = nt->find_local_method(name);
+ if (no != NULL)
+ {
+ if (receiver_can_be_pointer || !Type::method_expects_pointer(no))
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Record that we have found a pointer method in order to
+ // give a better error message if we don't find anything
+ // else.
+ *found_pointer_method = true;
+ }
+
+ for (std::vector<const Named_type*>::const_iterator p = seen->begin();
+ p != seen->end();
+ ++p)
+ {
+ if (*p == nt)
+ {
+ // We've already seen this type when searching for methods.
+ return false;
+ }
+ }
+ }
+
+ // Interface types can have methods.
+ const Interface_type* it = type->deref()->interface_type();
+ if (it != NULL && it->find_method(name) != NULL)
+ {
+ *is_method = true;
+ return true;
+ }
+
+ // Struct types can have fields. They can also inherit fields and
+ // methods from anonymous fields.
+ const Struct_type* st = type->deref()->struct_type();
+ if (st == NULL)
+ return false;
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ if (nt != NULL)
+ seen->push_back(nt);
+
+ int found_level = 0;
+ bool found_is_method = false;
+ std::string found_ambig1;
+ std::string found_ambig2;
+ const Struct_field* found_parent = NULL;
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->field_name() == name)
+ {
+ *is_method = false;
+ if (nt != NULL)
+ seen->pop_back();
+ return true;
+ }
+
+ if (!pf->is_anonymous())
+ continue;
+
+ if (pf->type()->deref()->is_error_type()
+ || pf->type()->deref()->is_undefined())
+ continue;
+
+ Named_type* fnt = pf->type()->named_type();
+ if (fnt == NULL)
+ fnt = pf->type()->deref()->named_type();
+ gcc_assert(fnt != NULL);
+
+ int sublevel = level == NULL ? 1 : *level + 1;
+ bool sub_is_method;
+ std::string subambig1;
+ std::string subambig2;
+ bool subfound = Type::find_field_or_method(fnt,
+ name,
+ receiver_can_be_pointer,
+ seen,
+ &sublevel,
+ &sub_is_method,
+ found_pointer_method,
+ &subambig1,
+ &subambig2);
+ if (!subfound)
+ {
+ if (!subambig1.empty())
+ {
+ // The name was found via this field, but is ambiguous.
+ // if the ambiguity is lower or at the same level as
+ // anything else we have already found, then we want to
+ // pass the ambiguity back to the caller.
+ if (found_level == 0 || sublevel <= found_level)
+ {
+ found_ambig1 = pf->field_name() + '.' + subambig1;
+ found_ambig2 = pf->field_name() + '.' + subambig2;
+ found_level = sublevel;
+ }
+ }
+ }
+ else
+ {
+ // The name was found via this field. Use the level to see
+ // if we want to use this one, or whether it introduces an
+ // ambiguity.
+ if (found_level == 0 || sublevel < found_level)
+ {
+ found_level = sublevel;
+ found_is_method = sub_is_method;
+ found_ambig1.clear();
+ found_ambig2.clear();
+ found_parent = &*pf;
+ }
+ else if (sublevel > found_level)
+ ;
+ else if (found_ambig1.empty())
+ {
+ // We found an ambiguity.
+ gcc_assert(found_parent != NULL);
+ found_ambig1 = found_parent->field_name();
+ found_ambig2 = pf->field_name();
+ }
+ else
+ {
+ // We found an ambiguity, but we already know of one.
+ // Just report the earlier one.
+ }
+ }
+ }
+
+ // Here if we didn't find anything FOUND_LEVEL is 0. If we found
+ // something ambiguous, FOUND_LEVEL is not 0 and FOUND_AMBIG1 and
+ // FOUND_AMBIG2 are not empty. If we found the field, FOUND_LEVEL
+ // is not 0 and FOUND_AMBIG1 and FOUND_AMBIG2 are empty.
+
+ if (nt != NULL)
+ seen->pop_back();
+
+ if (found_level == 0)
+ return false;
+ else if (!found_ambig1.empty())
+ {
+ gcc_assert(!found_ambig1.empty());
+ ambig1->assign(found_ambig1);
+ ambig2->assign(found_ambig2);
+ if (level != NULL)
+ *level = found_level;
+ return false;
+ }
+ else
+ {
+ if (level != NULL)
+ *level = found_level;
+ *is_method = found_is_method;
+ return true;
+ }
+}
+
+// Return whether NAME is an unexported field or method for TYPE.
+
+bool
+Type::is_unexported_field_or_method(Gogo* gogo, const Type* type,
+ const std::string& name,
+ std::vector<const Named_type*>* seen)
+{
+ const Named_type* nt = type->named_type();
+ if (nt == NULL)
+ nt = type->deref()->named_type();
+ if (nt != NULL)
+ {
+ if (nt->is_unexported_local_method(gogo, name))
+ return true;
+
+ for (std::vector<const Named_type*>::const_iterator p = seen->begin();
+ p != seen->end();
+ ++p)
+ {
+ if (*p == nt)
+ {
+ // We've already seen this type.
+ return false;
+ }
+ }
+ }
+
+ type = type->deref();
+
+ const Interface_type* it = type->interface_type();
+ if (it != NULL && it->is_unexported_method(gogo, name))
+ return true;
+
+ const Struct_type* st = type->struct_type();
+ if (st != NULL && st->is_unexported_local_field(gogo, name))
+ return true;
+
+ if (st == NULL)
+ return false;
+
+ const Struct_field_list* fields = st->fields();
+ if (fields == NULL)
+ return false;
+
+ if (nt != NULL)
+ seen->push_back(nt);
+
+ for (Struct_field_list::const_iterator pf = fields->begin();
+ pf != fields->end();
+ ++pf)
+ {
+ if (pf->is_anonymous()
+ && !pf->type()->deref()->is_error_type()
+ && !pf->type()->deref()->is_undefined())
+ {
+ Named_type* subtype = pf->type()->named_type();
+ if (subtype == NULL)
+ subtype = pf->type()->deref()->named_type();
+ if (subtype == NULL)
+ {
+ // This is an error, but it will be diagnosed elsewhere.
+ continue;
+ }
+ if (Type::is_unexported_field_or_method(gogo, subtype, name, seen))
+ {
+ if (nt != NULL)
+ seen->pop_back();
+ return true;
+ }
+ }
+ }
+
+ if (nt != NULL)
+ seen->pop_back();
+
+ return false;
+}
+
+// Class Forward_declaration.
+
+Forward_declaration_type::Forward_declaration_type(Named_object* named_object)
+ : Type(TYPE_FORWARD),
+ named_object_(named_object->resolve()), warned_(false)
+{
+ gcc_assert(this->named_object_->is_unknown()
+ || this->named_object_->is_type_declaration());
+}
+
+// Return the named object.
+
+Named_object*
+Forward_declaration_type::named_object()
+{
+ return this->named_object_->resolve();
+}
+
+const Named_object*
+Forward_declaration_type::named_object() const
+{
+ return this->named_object_->resolve();
+}
+
+// Return the name of the forward declared type.
+
+const std::string&
+Forward_declaration_type::name() const
+{
+ return this->named_object()->name();
+}
+
+// Warn about a use of a type which has been declared but not defined.
+
+void
+Forward_declaration_type::warn() const
+{
+ Named_object* no = this->named_object_->resolve();
+ if (no->is_unknown())
+ {
+ // The name was not defined anywhere.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else if (no->is_type_declaration())
+ {
+ // The name was seen as a type, but the type was never defined.
+ if (no->type_declaration_value()->using_type())
+ {
+ error_at(this->named_object_->location(),
+ "use of undefined type %qs",
+ no->message_name().c_str());
+ this->warned_ = true;
+ }
+ }
+ else
+ {
+ // The name was defined, but not as a type.
+ if (!this->warned_)
+ {
+ error_at(this->named_object_->location(), "expected type");
+ this->warned_ = true;
+ }
+ }
+}
+
+// Get the base type of a declaration. This gives an error if the
+// type has not yet been defined.
+
+Type*
+Forward_declaration_type::real_type()
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+const Type*
+Forward_declaration_type::real_type() const
+{
+ if (this->is_defined())
+ return this->named_object()->type_value();
+ else
+ {
+ this->warn();
+ return Type::make_error_type();
+ }
+}
+
+// Return whether the base type is defined.
+
+bool
+Forward_declaration_type::is_defined() const
+{
+ return this->named_object()->is_type();
+}
+
+// Add a method. This is used when methods are defined before the
+// type.
+
+Named_object*
+Forward_declaration_type::add_method(const std::string& name,
+ Function* function)
+{
+ Named_object* no = this->named_object();
+ if (no->is_unknown())
+ no->declare_as_type();
+ return no->type_declaration_value()->add_method(name, function);
+}
+
+// Add a method declaration. This is used when methods are declared
+// before the type.
+
+Named_object*
+Forward_declaration_type::add_method_declaration(const std::string& name,
+ Function_type* type,
+ source_location location)
+{
+ Named_object* no = this->named_object();
+ if (no->is_unknown())
+ no->declare_as_type();
+ Type_declaration* td = no->type_declaration_value();
+ return td->add_method_declaration(name, type, location);
+}
+
+// Traversal.
+
+int
+Forward_declaration_type::do_traverse(Traverse* traverse)
+{
+ if (this->is_defined()
+ && Type::traverse(this->real_type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ return TRAVERSE_CONTINUE;
+}
+
+// Get a tree for the type.
+
+tree
+Forward_declaration_type::do_get_tree(Gogo* gogo)
+{
+ if (this->is_defined())
+ return Type::get_named_type_tree(gogo, this->real_type());
+
+ if (this->warned_)
+ return error_mark_node;
+
+ // We represent an undefined type as a struct with no fields. That
+ // should work fine for the middle-end, since the same case can
+ // arise in C.
+ Named_object* no = this->named_object();
+ tree type_tree = make_node(RECORD_TYPE);
+ tree id = no->get_id(gogo);
+ tree decl = build_decl(no->location(), TYPE_DECL, id, type_tree);
+ TYPE_NAME(type_tree) = decl;
+ layout_type(type_tree);
+ return type_tree;
+}
+
+// Build a type descriptor for a forwarded type.
+
+Expression*
+Forward_declaration_type::do_type_descriptor(Gogo* gogo, Named_type* name)
+{
+ if (!this->is_defined())
+ return Expression::make_nil(BUILTINS_LOCATION);
+ else
+ {
+ Type* t = this->real_type();
+ if (name != NULL)
+ return this->named_type_descriptor(gogo, t, name);
+ else
+ return Expression::make_type_descriptor(t, BUILTINS_LOCATION);
+ }
+}
+
+// The reflection string.
+
+void
+Forward_declaration_type::do_reflection(Gogo* gogo, std::string* ret) const
+{
+ this->append_reflection(this->real_type(), gogo, ret);
+}
+
+// The mangled name.
+
+void
+Forward_declaration_type::do_mangled_name(Gogo* gogo, std::string* ret) const
+{
+ if (this->is_defined())
+ this->append_mangled_name(this->real_type(), gogo, ret);
+ else
+ {
+ const Named_object* no = this->named_object();
+ std::string name;
+ if (no->package() == NULL)
+ name = gogo->package_name();
+ else
+ name = no->package()->name();
+ name += '.';
+ name += Gogo::unpack_hidden_name(no->name());
+ char buf[20];
+ snprintf(buf, sizeof buf, "N%u_",
+ static_cast<unsigned int>(name.length()));
+ ret->append(buf);
+ ret->append(name);
+ }
+}
+
+// Export a forward declaration. This can happen when a defined type
+// refers to a type which is only declared (and is presumably defined
+// in some other file in the same package).
+
+void
+Forward_declaration_type::do_export(Export*) const
+{
+ // If there is a base type, that should be exported instead of this.
+ gcc_assert(!this->is_defined());
+
+ // We don't output anything.
+}
+
+// Make a forward declaration.
+
+Type*
+Type::make_forward_declaration(Named_object* named_object)
+{
+ return new Forward_declaration_type(named_object);
+}
+
+// Class Typed_identifier_list.
+
+// Sort the entries by name.
+
+struct Typed_identifier_list_sort
+{
+ public:
+ bool
+ operator()(const Typed_identifier& t1, const Typed_identifier& t2) const
+ { return t1.name() < t2.name(); }
+};
+
+void
+Typed_identifier_list::sort_by_name()
+{
+ std::sort(this->entries_.begin(), this->entries_.end(),
+ Typed_identifier_list_sort());
+}
+
+// Traverse types.
+
+int
+Typed_identifier_list::traverse(Traverse* traverse)
+{
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ {
+ if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
+ return TRAVERSE_EXIT;
+ }
+ return TRAVERSE_CONTINUE;
+}
+
+// Copy the list.
+
+Typed_identifier_list*
+Typed_identifier_list::copy() const
+{
+ Typed_identifier_list* ret = new Typed_identifier_list();
+ for (Typed_identifier_list::const_iterator p = this->begin();
+ p != this->end();
+ ++p)
+ ret->push_back(Typed_identifier(p->name(), p->type(), p->location()));
+ return ret;
+}
--- /dev/null
+// unsafe.cc -- Go frontend builtin unsafe package.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "types.h"
+#include "gogo.h"
+
+// Set up the builtin unsafe package. This should probably be driven
+// by a table.
+
+void
+Gogo::import_unsafe(const std::string& local_name, bool is_local_name_exported,
+ source_location location)
+{
+ location_t bloc = BUILTINS_LOCATION;
+
+ bool add_to_globals;
+ Package* package = this->add_imported_package("unsafe", local_name,
+ is_local_name_exported,
+ "libgo_unsafe",
+ location, &add_to_globals);
+ package->set_is_imported();
+
+ Bindings* bindings = package->bindings();
+
+ // The type may have already been created by an import.
+ Named_object* no = package->bindings()->lookup("Pointer");
+ if (no == NULL)
+ {
+ Type* type = Type::make_pointer_type(Type::make_void_type());
+ no = bindings->add_type("Pointer", package, type, UNKNOWN_LOCATION);
+ }
+ else
+ {
+ gcc_assert(no->package() == package);
+ gcc_assert(no->is_type());
+ gcc_assert(no->type_value()->is_unsafe_pointer_type());
+ no->type_value()->set_is_visible();
+ }
+ Named_type* pointer_type = no->type_value();
+ if (add_to_globals)
+ this->add_named_type(pointer_type);
+
+ Type* int_type = this->lookup_global("int")->type_value();
+
+ // Sizeof.
+ Typed_identifier_list* results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Sizeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Offsetof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Offsetof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Alignof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Alignof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Typeof.
+ Type* empty_interface = Type::make_interface_type(NULL, bloc);
+ Typed_identifier_list* parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("i", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Typeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Reflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("it", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Reflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Unreflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("addr", pointer_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Unreflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // New.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("New", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // NewArray.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("n", int_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("NewArray", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ this->imported_unsafe_ = true;
+}
--- /dev/null
+// unsafe.cc -- Go frontend builtin unsafe package.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+#include "types.h"
+#include "gogo.h"
+
+// Set up the builtin unsafe package. This should probably be driven
+// by a table.
+
+void
+Gogo::import_unsafe(const std::string& local_name, bool is_local_name_exported,
+ source_location location)
+{
+ location_t bloc = BUILTINS_LOCATION;
+
+ bool add_to_globals;
+ Package* package = this->add_imported_package("unsafe", local_name,
+ is_local_name_exported,
+ "libgo_unsafe",
+ location, &add_to_globals);
+
+ if (package == NULL)
+ {
+ go_assert(saw_errors());
+ return;
+ }
+
+ package->set_is_imported();
+
+ Bindings* bindings = package->bindings();
+
+ // The type may have already been created by an import.
+ Named_object* no = package->bindings()->lookup("Pointer");
+ if (no == NULL)
+ {
+ Type* type = Type::make_pointer_type(Type::make_void_type());
+ no = bindings->add_type("Pointer", package, type, UNKNOWN_LOCATION);
+ }
+ else
+ {
+ go_assert(no->package() == package);
+ go_assert(no->is_type());
+ go_assert(no->type_value()->is_unsafe_pointer_type());
+ no->type_value()->set_is_visible();
+ }
+ Named_type* pointer_type = no->type_value();
+ if (add_to_globals)
+ this->add_named_type(pointer_type);
+
+ Type* int_type = this->lookup_global("int")->type_value();
+
+ // Sizeof.
+ Typed_identifier_list* results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Sizeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Offsetof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Offsetof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Alignof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Alignof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Typeof.
+ Type* empty_interface = Type::make_interface_type(NULL, bloc);
+ Typed_identifier_list* parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("i", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Typeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Reflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("it", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Reflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Unreflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("addr", pointer_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Unreflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // New.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("New", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // NewArray.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("n", int_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("NewArray", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ if (!this->imported_unsafe_)
+ {
+ go_imported_unsafe();
+ this->imported_unsafe_ = true;
+ }
+}
--- /dev/null
+// unsafe.cc -- Go frontend builtin unsafe package.
+
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go-system.h"
+
+#include "go-c.h"
+#include "types.h"
+#include "gogo.h"
+
+// Set up the builtin unsafe package. This should probably be driven
+// by a table.
+
+void
+Gogo::import_unsafe(const std::string& local_name, bool is_local_name_exported,
+ source_location location)
+{
+ location_t bloc = BUILTINS_LOCATION;
+
+ bool add_to_globals;
+ Package* package = this->add_imported_package("unsafe", local_name,
+ is_local_name_exported,
+ "libgo_unsafe",
+ location, &add_to_globals);
+
+ if (package == NULL)
+ {
+ gcc_assert(saw_errors());
+ return;
+ }
+
+ package->set_is_imported();
+
+ Bindings* bindings = package->bindings();
+
+ // The type may have already been created by an import.
+ Named_object* no = package->bindings()->lookup("Pointer");
+ if (no == NULL)
+ {
+ Type* type = Type::make_pointer_type(Type::make_void_type());
+ no = bindings->add_type("Pointer", package, type, UNKNOWN_LOCATION);
+ }
+ else
+ {
+ gcc_assert(no->package() == package);
+ gcc_assert(no->is_type());
+ gcc_assert(no->type_value()->is_unsafe_pointer_type());
+ no->type_value()->set_is_visible();
+ }
+ Named_type* pointer_type = no->type_value();
+ if (add_to_globals)
+ this->add_named_type(pointer_type);
+
+ Type* int_type = this->lookup_global("int")->type_value();
+
+ // Sizeof.
+ Typed_identifier_list* results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ Function_type* fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Sizeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Offsetof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Offsetof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Alignof.
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", int_type, bloc));
+ fntype = Type::make_function_type(NULL, NULL, results, bloc);
+ fntype->set_is_varargs();
+ fntype->set_is_builtin();
+ no = bindings->add_function_declaration("Alignof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Typeof.
+ Type* empty_interface = Type::make_interface_type(NULL, bloc);
+ Typed_identifier_list* parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("i", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Typeof", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Reflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("it", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Reflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // Unreflect.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("addr", pointer_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", empty_interface, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("Unreflect", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // New.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("New", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ // NewArray.
+ parameters = new Typed_identifier_list;
+ parameters->push_back(Typed_identifier("typ", empty_interface, bloc));
+ parameters->push_back(Typed_identifier("n", int_type, bloc));
+ results = new Typed_identifier_list;
+ results->push_back(Typed_identifier("", pointer_type, bloc));
+ fntype = Type::make_function_type(NULL, parameters, results, bloc);
+ no = bindings->add_function_declaration("NewArray", package, fntype, bloc);
+ if (add_to_globals)
+ this->add_named_object(no);
+
+ if (!this->imported_unsafe_)
+ {
+ go_imported_unsafe();
+ this->imported_unsafe_ = true;
+ }
+}
projects / gcc.git / commitdiff