CbC/CbC_gcc: gcc/go/gofrontend/types.cc comparison

comparison gcc/go/gofrontend/types.cc @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 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;
+}
+// Skip alias definitions.
+Type*
+Type::unalias()
+{
+Type* t = this->forwarded();
+Named_type* nt = t->named_type();
+while (nt != NULL && nt->is_alias())
+{
+t = nt->real_type()->forwarded();
+nt = t->named_type();
+}
+return t;
+}
+const Type*
+Type::unalias() const
+{
+const Type* t = this->forwarded();
+const Named_type* nt = t->named_type();
+while (nt != NULL && nt->is_alias())
+{
+t = nt->real_type()->forwarded();
+nt = t->named_type();
 }
 return t;
 }
 // If this is a named type, return it.  Otherwise, return NULL.
 Type::do_traverse(Traverse*)
 {
 return TRAVERSE_CONTINUE;
 }
-// Return whether two types are identical.  If ERRORS_ARE_IDENTICAL,
+// Return whether two types are identical.  If REASON is not NULL,
-// then return true for all erroneous types; this is used to avoid
+// optionally set *REASON to the reason the types are not identical.
-// 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,
+Type::are_identical(const Type* t1, const Type* t2, int flags,
 		    std::string* reason)
 {
-return Type::are_identical_cmp_tags(t1, t2, COMPARE_TAGS,
-				      errors_are_identical, reason);
-}
-// Like are_identical, but with a CMP_TAGS parameter.
-bool
-Type::are_identical_cmp_tags(const Type* t1, const Type* t2, Cmp_tags cmp_tags,
-			     bool errors_are_identical, std::string* reason)
-{
 if (t1 == NULL || t2 == NULL)
 {
 // Something is wrong.
-return errors_are_identical ? true : t1 == t2;
+return (flags & COMPARE_ERRORS) == 0 ? true : t1 == t2;
 }
 // Skip defined forward declarations.
 t1 = t1->forwarded();
 t2 = t2->forwarded();
-// Ignore aliases for purposes of type identity.
+if ((flags & COMPARE_ALIASES) == 0)
-while (t1->named_type() != NULL && t1->named_type()->is_alias())
+{
-t1 = t1->named_type()->real_type()->forwarded();
+// Ignore aliases.
-while (t2->named_type() != NULL && t2->named_type()->is_alias())
+t1 = t1->unalias();
-t2 = t2->named_type()->real_type()->forwarded();
+t2 = t2->unalias();
+}
 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;
+return (flags & COMPARE_ERRORS) == 0;
 // Avoid cascading errors with error types.
 if (t1->is_error_type() || t2->is_error_type())
 {
-if (errors_are_identical)
+if ((flags & COMPARE_ERRORS) == 0)
 	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
 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,
+					       false, flags, reason);
-					       cmp_tags,
-					       errors_are_identical,
-					       reason);
 case TYPE_POINTER:
-return Type::are_identical_cmp_tags(t1->points_to(), t2->points_to(),
+return Type::are_identical(t1->points_to(), t2->points_to(), flags,
-					  cmp_tags, errors_are_identical,
+				 reason);
-					  reason);
 case TYPE_STRUCT:
-return t1->struct_type()->is_identical(t2->struct_type(), cmp_tags,
+return t1->struct_type()->is_identical(t2->struct_type(), flags);
-					     errors_are_identical);
 case TYPE_ARRAY:
-return t1->array_type()->is_identical(t2->array_type(), cmp_tags,
+return t1->array_type()->is_identical(t2->array_type(), flags);
-					    errors_are_identical);
 case TYPE_MAP:
-return t1->map_type()->is_identical(t2->map_type(), cmp_tags,
+return t1->map_type()->is_identical(t2->map_type(), flags);
-					  errors_are_identical);
 case TYPE_CHANNEL:
-return t1->channel_type()->is_identical(t2->channel_type(), cmp_tags,
+return t1->channel_type()->is_identical(t2->channel_type(), flags);
-					      errors_are_identical);
 case TYPE_INTERFACE:
-return t1->interface_type()->is_identical(t2->interface_type(), cmp_tags,
+return t1->interface_type()->is_identical(t2->interface_type(), flags);
-						errors_are_identical);
 case TYPE_CALL_MULTIPLE_RESULT:
 if (reason != NULL)
 	*reason = "invalid use of multiple-value function call";
 return false;
 // 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))
+if (Type::are_identical(lhs, rhs, Type::COMPARE_TAGS, 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()))
 	  if (reason != NULL)
 	    *reason = _("invalid comparison of non-comparable type");
 	  return false;
 	}
-if (t1->named_type() != NULL)
+if (t1->unalias()->named_type() != NULL)
-	return t1->named_type()->named_type_is_comparable(reason);
+	return t1->unalias()->named_type()->named_type_is_comparable(reason);
-else if (t2->named_type() != NULL)
+else if (t2->unalias()->named_type() != NULL)
-	return t2->named_type()->named_type_is_comparable(reason);
+	return t2->unalias()->named_type()->named_type_is_comparable(reason);
 else if (t1->struct_type() != NULL)
 	{
 	  if (t1->struct_type()->is_struct_incomparable())
 	    {
 	      if (reason != NULL)
 && !lhs->is_undefined()
 && lhs->is_sink_type())
 return true;
 // Identical types are assignable.
-if (Type::are_identical(lhs, rhs, true, reason))
+if (Type::are_identical(lhs, rhs, Type::COMPARE_TAGS, reason))
 return true;
+// Ignore aliases, except for error messages.
+const Type* lhs_orig = lhs;
+const Type* rhs_orig = rhs;
+lhs = lhs->unalias();
+rhs = rhs->unalias();
 // 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))
+&& Type::are_identical(lhs->base(), rhs->base(), Type::COMPARE_TAGS,
+			     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();
 && 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,
+			     Type::COMPARE_TAGS,
 			     reason))
 return true;
 // The nil type may be assigned to a pointer, function, slice, map,
 // channel, or interface type.
 // Give some better error messages.
 if (reason != NULL && reason->empty())
 {
 if (rhs->interface_type() != NULL)
 	reason->assign(_("need explicit conversion"));
-else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
+else if (lhs_orig->named_type() != NULL
-	{
+	       && rhs_orig->named_type() != NULL)
-	  size_t len = (lhs->named_type()->name().length()
+	{
-			+ rhs->named_type()->name().length()
+	  size_t len = (lhs_orig->named_type()->name().length()
+			+ rhs_orig->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(),
+		   rhs_orig->named_type()->message_name().c_str(),
-		   lhs->named_type()->message_name().c_str());
+		   lhs_orig->named_type()->message_name().c_str());
 	  reason->assign(buf);
 	  delete[] buf;
 	}
 }
 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;
+// Ignore aliases.
+lhs = lhs->unalias();
+rhs = rhs->unalias();
 // A pointer to a regular type may not be converted to a pointer to
 // a type that may not live in the heap, except when converting from
 // unsafe.Pointer.
 if (lhs->points_to() != NULL
 }
 // The types are convertible if they have identical underlying
 // types, ignoring struct field tags.
 if ((lhs->named_type() != NULL || rhs->named_type() != NULL)
-&& Type::are_identical_cmp_tags(lhs->base(), rhs->base(), IGNORE_TAGS,
+&& Type::are_identical(lhs->base(), rhs->base(), 0, reason))
-				      true, reason))
 return true;
 // The types are convertible if they are both unnamed pointer types
 // and their pointer base types have identical underlying types,
 // ignoring struct field tags.
 && 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_cmp_tags(lhs->points_to()->base(),
+&& Type::are_identical(lhs->points_to()->base(),
-				      rhs->points_to()->base(),
+			     rhs->points_to()->base(),
-				      IGNORE_TAGS,
+			     0, reason))
-				      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 false;
 }
+// Copy expressions if it may change the size.
+//
+// The only type that has an expression is an array type.  The only
+// types whose size can be changed by the size of an array type are an
+// array type itself, or a struct type with an array field.
+Type*
+Type::copy_expressions()
+{
+// This is run during parsing, so types may not be valid yet.
+// We only have to worry about array type literals.
+switch (this->classification_)
+{
+default:
+return this;
+case TYPE_ARRAY:
+{
+	Array_type* at = this->array_type();
+	if (at->length() == NULL)
+	  return this;
+	Expression* len = at->length()->copy();
+	if (at->length() == len)
+	  return this;
+	return Type::make_array_type(at->element_type(), len);
+}
+case TYPE_STRUCT:
+{
+	Struct_type* st = this->struct_type();
+	const Struct_field_list* sfl = st->fields();
+	if (sfl == NULL)
+	  return this;
+	bool changed = false;
+	Struct_field_list *nsfl = new Struct_field_list();
+	for (Struct_field_list::const_iterator pf = sfl->begin();
+	     pf != sfl->end();
+	     ++pf)
+	  {
+	    Type* ft = pf->type()->copy_expressions();
+	    Struct_field nf(Typed_identifier((pf->is_anonymous()
+					      ? ""
+					      : pf->field_name()),
+					     ft,
+					     pf->location()));
+	    if (pf->has_tag())
+	      nf.set_tag(pf->tag());
+	    nsfl->push_back(nf);
+	    if (ft != pf->type())
+	      changed = true;
+	  }
+	if (!changed)
+	  {
+	    delete(nsfl);
+	    return this;
+	  }
+	return Type::make_struct_type(nsfl, st->location());
+}
+}
+go_unreachable();
+}
 // Return a hash code for the type to be used for method lookup.
 unsigned int
-Type::hash_for_method(Gogo* gogo) const
+Type::hash_for_method(Gogo* gogo, int flags) const
 {
-if (this->named_type() != NULL && this->named_type()->is_alias())
+const Type* t = this->forwarded();
-return this->named_type()->real_type()->hash_for_method(gogo);
+if (t->named_type() != NULL && t->named_type()->is_alias())
-unsigned int ret = 0;
+{
-if (this->classification_ != TYPE_FORWARD)
+unsigned int r =
-ret += this->classification_;
+	t->named_type()->real_type()->hash_for_method(gogo, flags);
-return ret + this->do_hash_for_method(gogo);
+if ((flags & Type::COMPARE_ALIASES) != 0)
+	r += TYPE_FORWARD;
+return r;
+}
+unsigned int ret = t->classification_;
+return ret + t->do_hash_for_method(gogo, flags);
 }
 // Default implementation of do_hash_for_method.  This is appropriate
 // for types with no subfields.
 unsigned int
-Type::do_hash_for_method(Gogo*) const
+Type::do_hash_for_method(Gogo*, int) const
 {
 return 0;
 }
 // Return a hash code for a string, given a starting hash.
 Btype*
 Type::get_backend(Gogo* gogo)
 {
 if (this->btype_ != NULL)
 return this->btype_;
+if (this->named_type() != NULL && this->named_type()->is_alias()) {
+Btype* bt = this->unalias()->get_backend(gogo);
+if (gogo != NULL && gogo->named_types_are_converted())
+this->btype_ = bt;
+return bt;
+}
 if (this->forward_declaration_type() != NULL
 || this->named_type() != NULL)
 return this->get_btype_without_hash(gogo);
 case TYPE_NAMED:
 case TYPE_FORWARD:
 // Named types keep track of their own dependencies and manage
 // their own placeholders.
+if (this->named_type() != NULL && this->named_type()->is_alias())
+return this->unalias()->get_backend_placeholder(gogo);
 return this->get_backend(gogo);
 case TYPE_INTERFACE:
 if (this->interface_type()->is_empty())
 	return Interface_type::get_backend_empty_interface_type(gogo);
 // Return a pointer to the type descriptor for this type.
 Bexpression*
 Type::type_descriptor_pointer(Gogo* gogo, Location location)
 {
-Type* t = this->forwarded();
+Type* t = this->unalias();
-while (t->named_type() != NULL && t->named_type()->is_alias())
-t = t->named_type()->real_type()->forwarded();
 if (t->type_descriptor_var_ == NULL)
 {
 t->make_type_descriptor_var(gogo);
 go_assert(t->type_descriptor_var_ != NULL);
 }
 Bexpression* var_expr =
-gogo->backend()->var_expression(t->type_descriptor_var_,
+gogo->backend()->var_expression(t->type_descriptor_var_, location);
-VE_rvalue, location);
 Bexpression* var_addr =
 gogo->backend()->address_expression(var_expr, location);
 Type* td_type = Type::make_type_descriptor_type();
 Btype* td_btype = td_type->get_backend(gogo);
 Btype* ptd_btype = gogo->backend()->pointer_type(td_btype);
 void
 Type::type_functions(Gogo* gogo, Named_type* name, Function_type* hash_fntype,
 		     Function_type* equal_fntype, Named_object** hash_fn,
 		     Named_object** equal_fn)
 {
-// If this loop leaves NAME as NULL, then the type does not have a
+// If the unaliased type is not a named type, then the type does not
-// name after all.
+// have a name after all.
-while (name != NULL && name->is_alias())
+if (name != NULL)
-name = name->real_type()->named_type();
+name = name->unalias()->named_type();
 if (!this->is_comparable())
 {
 *hash_fn = NULL;
 *equal_fn = NULL;
 Temporary_statement* p2 = Statement::make_temporary(pt, ref, bloc);
 gogo->add_statement(p2);
 // Compare the values for equality.
 Expression* t1 = Expression::make_temporary_reference(p1, bloc);
-t1 = Expression::make_unary(OPERATOR_MULT, t1, bloc);
+t1 = Expression::make_dereference(t1, Expression::NIL_CHECK_NOT_NEEDED, bloc);
 Expression* t2 = Expression::make_temporary_reference(p2, bloc);
-t2 = Expression::make_unary(OPERATOR_MULT, t2, bloc);
+t2 = Expression::make_dereference(t2, Expression::NIL_CHECK_NOT_NEEDED, bloc);
 Expression* cond = Expression::make_binary(OPERATOR_EQEQ, t1, t2, bloc);
 // Return the equality comparison.
 Expression_list* vals = new Expression_list();
 ++p;
 go_assert(p->is_field_name("hash"));
 unsigned int h;
 if (name != NULL)
-h = name->hash_for_method(gogo);
+h = name->hash_for_method(gogo, Type::COMPARE_TAGS);
 else
-h = this->hash_for_method(gogo);
+h = this->hash_for_method(gogo, Type::COMPARE_TAGS);
 vals->push_back(Expression::make_integer_ul(h, p->type(), bloc));
 ++p;
 go_assert(p->is_field_name("kind"));
 vals->push_back(Expression::make_integer_ul(runtime_type_kind, p->type(),
 // Return a pointer to the Garbage Collection information for this type.
 Bexpression*
 Type::gc_symbol_pointer(Gogo* gogo)
 {
-Type* t = this->forwarded();
+Type* t = this->unalias();
-while (t->named_type() != NULL && t->named_type()->is_alias())
-t = t->named_type()->real_type()->forwarded();
 if (!t->has_pointer())
 return gogo->backend()->nil_pointer_expression();
 if (t->gc_symbol_var_ == NULL)
 t->make_gc_symbol_var(gogo);
 go_assert(t->gc_symbol_var_ != NULL);
 }
 Location bloc = Linemap::predeclared_location();
 Bexpression* var_expr =
-gogo->backend()->var_expression(t->gc_symbol_var_, VE_rvalue, bloc);
+gogo->backend()->var_expression(t->gc_symbol_var_, bloc);
 Bexpression* addr_expr =
 gogo->backend()->address_expression(var_expr, bloc);
 Type* uint8_type = Type::lookup_integer_type("uint8");
 Type* pointer_uint8_type = Type::make_pointer_type(uint8_type);
 }
 // Return a symbol name for this ptrmask.  This is used to coalesce
 // identical ptrmasks, which are common.  The symbol name must use
 // only characters that are valid in symbols.  It's nice if it's
-// short.  We convert it to a base64 string.
+// short.  We convert it to a string that uses only 32 characters,
+// avoiding digits and u and U.
 std::string
 Ptrmask::symname() const
 {
-const char chars[65] =
+const char chars[33] = "abcdefghijklmnopqrstvwxyzABCDEFG";
-"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_.";
+go_assert(chars[32] == '\0');
-go_assert(chars[64] == '\0');
 std::string ret;
 unsigned int b = 0;
 int remaining = 0;
 for (std::vector<unsigned char>::const_iterator p = this->bits_.begin();
 p != this->bits_.end();
 ++p)
 {
 b |= *p << remaining;
 remaining += 8;
-while (remaining >= 6)
+while (remaining >= 5)
 	{
-	  ret += chars[b & 0x3f];
+	  ret += chars[b & 0x1f];
-	  b >>= 6;
+	  b >>= 5;
-	  remaining -= 6;
+	  remaining -= 5;
 	}
 }
 while (remaining > 0)
 {
-ret += chars[b & 0x3f];
+ret += chars[b & 0x1f];
-b >>= 6;
+b >>= 5;
-remaining -= 6;
+remaining -= 5;
 }
 return ret;
 }
 // Return a constructor for this ptrmask.  This will be used to
 }
 // Hash code.
 unsigned int
-Integer_type::do_hash_for_method(Gogo*) const
+Integer_type::do_hash_for_method(Gogo*, int) const
 {
 return ((this->bits_ << 4)
 	  + ((this->is_unsigned_ ? 1 : 0) << 8)
 	  + ((this->is_abstract_ ? 1 : 0) << 9));
 }
 }
 // Hash code.
 unsigned int
-Float_type::do_hash_for_method(Gogo*) const
+Float_type::do_hash_for_method(Gogo*, int) const
 {
 return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
 }
 // Convert to the backend representation.
 }
 // Hash code.
 unsigned int
-Complex_type::do_hash_for_method(Gogo*) const
+Complex_type::do_hash_for_method(Gogo*, int) const
 {
 return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
 }
 // Convert to the backend representation.
 bool
 Function_type::is_valid_redeclaration(const Function_type* t,
 				      std::string* reason) const
 {
-if (!this->is_identical(t, false, COMPARE_TAGS, true, reason))
+if (!this->is_identical(t, false, COMPARE_TAGS, reason))
 return false;
 // A redeclaration of a function is required to use the same names
 // for the receiver and parameters.
 if (this->receiver() != NULL
 // Check whether T is the same as this type.
 bool
 Function_type::is_identical(const Function_type* t, bool ignore_receiver,
-			    Cmp_tags cmp_tags, bool errors_are_identical,
+			    int flags, std::string* reason) const
-			    std::string* reason) const
+{
-{
+if (this->is_backend_function_type() != t->is_backend_function_type())
+return false;
 if (!ignore_receiver)
 {
 const Typed_identifier* r1 = this->receiver();
 const Typed_identifier* r2 = t->receiver();
 if ((r1 != NULL) != (r2 != NULL))
 	    *reason = _("different receiver types");
 	  return false;
 	}
 if (r1 != NULL)
 	{
-	  if (!Type::are_identical_cmp_tags(r1->type(), r2->type(), cmp_tags,
+	  if (!Type::are_identical(r1->type(), r2->type(), flags, reason))
-					    errors_are_identical, reason))
 	    {
 	      if (reason != NULL && !reason->empty())
 		*reason = "receiver: " + *reason;
 	      return false;
 	    }
 	}
 }
 const Typed_identifier_list* parms1 = this->parameters();
+if (parms1 != NULL && parms1->empty())
+parms1 = NULL;
 const Typed_identifier_list* parms2 = t->parameters();
+if (parms2 != NULL && parms2->empty())
+parms2 = NULL;
 if ((parms1 != NULL) != (parms2 != NULL))
 {
 if (reason != NULL)
 	*reason = _("different number of parameters");
 return false;
 	      if (reason != NULL)
 		*reason = _("different number of parameters");
 	      return false;
 	    }
-	  if (!Type::are_identical_cmp_tags(p1->type(), p2->type(), cmp_tags,
+	  if (!Type::are_identical(p1->type(), p2->type(), flags, NULL))
-					    errors_are_identical, NULL))
 	    {
 	      if (reason != NULL)
 		*reason = _("different parameter types");
 	      return false;
 	    }
 	*reason = _("different varargs");
 return false;
 }
 const Typed_identifier_list* results1 = this->results();
+if (results1 != NULL && results1->empty())
+results1 = NULL;
 const Typed_identifier_list* results2 = t->results();
+if (results2 != NULL && results2->empty())
+results2 = NULL;
 if ((results1 != NULL) != (results2 != NULL))
 {
 if (reason != NULL)
 	*reason = _("different number of results");
 return false;
 	      if (reason != NULL)
 		*reason = _("different number of results");
 	      return false;
 	    }
-	  if (!Type::are_identical_cmp_tags(res1->type(), res2->type(),
+	  if (!Type::are_identical(res1->type(), res2->type(), flags, NULL))
-					    cmp_tags, errors_are_identical,
-					    NULL))
 	    {
 	      if (reason != NULL)
 		*reason = _("different result types");
 	      return false;
 	    }
 }
 // Hash code.
 unsigned int
-Function_type::do_hash_for_method(Gogo* gogo) const
+Function_type::do_hash_for_method(Gogo* gogo, int flags) 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.
 {
 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;
+	ret += p->type()->hash_for_method(gogo, flags) << 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;
+	ret += p->type()->hash_for_method(gogo, flags) << shift;
 }
 if (this->is_varargs_)
 ret += 1;
 ret <<= 4;
 return ret;
 p != t->end();
 ++p)
 {
 hash <<= 2;
 hash = Type::hash_string(p->name(), hash);
-hash += p->type()->hash_for_method(NULL);
+hash += p->type()->hash_for_method(NULL, Type::COMPARE_TAGS);
 }
 return hash;
 }
 // Compare result parameters so that can map identical result
 for (Typed_identifier_list::const_iterator pb = b->begin();
 pb != b->end();
 ++pa, ++pb)
 {
 if (pa->name() != pb->name()
-	  || !Type::are_identical(pa->type(), pb->type(), true, NULL))
+	  || !Type::are_identical(pa->type(), pb->type(), Type::COMPARE_TAGS,
+				  NULL))
 	return false;
 }
 return true;
 }
 }
 // Hash code.
 unsigned int
-Pointer_type::do_hash_for_method(Gogo* gogo) const
+Pointer_type::do_hash_for_method(Gogo* gogo, int flags) const
 {
-return this->to_type_->hash_for_method(gogo) << 4;
+return this->to_type_->hash_for_method(gogo, flags) << 4;
 }
 // Get the backend representation for a pointer type.
 Btype*
 }
 // Whether this type is identical to T.
 bool
-Struct_type::is_identical(const Struct_type* t, Cmp_tags cmp_tags,
+Struct_type::is_identical(const Struct_type* t, int flags) const
-			  bool errors_are_identical) const
 {
 if (this->is_struct_incomparable_ != t->is_struct_incomparable_)
 return false;
 const Struct_field_list* fields1 = this->fields();
 const Struct_field_list* fields2 = t->fields();
 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_cmp_tags(pf1->type(), pf2->type(), cmp_tags,
+	  || !Type::are_identical(pf1->type(), pf2->type(), flags, NULL))
-					   errors_are_identical, NULL))
 	return false;
-if (cmp_tags == COMPARE_TAGS)
+if ((flags & Type::COMPARE_TAGS) != 0)
 	{
 	  if (!pf1->has_tag())
 	    {
 	      if (pf2->has_tag())
 		return false;
 // Build identity and hash functions for this struct.
 // Hash code.
 unsigned int
-Struct_type::do_hash_for_method(Gogo* gogo) const
+Struct_type::do_hash_for_method(Gogo* gogo, int flags) 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);
+	ret = (ret << 1) + pf->type()->hash_for_method(gogo, flags);
 }
 ret <<= 2;
 if (this->is_struct_incomparable_)
 ret <<= 1;
 return 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);
+here = Expression::make_dereference(here,
+Expression::NIL_CHECK_DEFAULT,
+location);
 	  while (sub->expr() != NULL)
 	    {
 	      sub = sub->expr()->deref()->field_reference_expression();
 	      go_assert(sub != NULL);
 	    }
 if (Gogo::is_sink_name(pf->field_name()))
 	continue;
 // Compare one field in both P1 and P2.
 Expression* f1 = Expression::make_temporary_reference(p1, bloc);
-f1 = Expression::make_unary(OPERATOR_MULT, f1, bloc);
+f1 = Expression::make_dereference(f1, Expression::NIL_CHECK_DEFAULT,
+bloc);
 f1 = Expression::make_field_reference(f1, field_index, bloc);
 Expression* f2 = Expression::make_temporary_reference(p2, bloc);
-f2 = Expression::make_unary(OPERATOR_MULT, f2, bloc);
+f2 = Expression::make_dereference(f2, Expression::NIL_CHECK_DEFAULT,
+bloc);
 f2 = Expression::make_field_reference(f2, field_index, bloc);
 Expression* cond = Expression::make_binary(OPERATOR_NOTEQ, f1, f2, bloc);
 // If the values are not equal, return false.
 ++p)
 {
 if (p != this->fields_->begin())
 	ret->push_back(';');
 ret->push_back(' ');
-if (p->is_anonymous())
+if (!p->is_anonymous())
-	ret->push_back('?');
+	{
-else
+	  ret->append(Gogo::unpack_hidden_name(p->field_name()));
-	ret->append(Gogo::unpack_hidden_name(p->field_name()));
+	  ret->push_back(' ');
-ret->push_back(' ');
+	}
 if (p->is_anonymous()
 	  && p->type()->named_type() != NULL
 	  && p->type()->named_type()->is_alias())
 	p->type()->named_type()->append_reflection_type_name(gogo, true, ret);
 else
 }
 // Whether two array types are identical.
 bool
-Array_type::is_identical(const Array_type* t, Cmp_tags cmp_tags,
+Array_type::is_identical(const Array_type* t, int flags) const
-			 bool errors_are_identical) const
+{
-{
+if (!Type::are_identical(this->element_type(), t->element_type(),
-if (!Type::are_identical_cmp_tags(this->element_type(), t->element_type(),
+			   flags, NULL))
-				    cmp_tags, errors_are_identical, NULL))
 return false;
 if (this->is_array_incomparable_ != t->is_array_incomparable_)
 return false;
 this->length_->determine_type(&context);
 if (!this->length_->is_constant())
 {
 go_error_at(this->length_->location(), "array bound is not constant");
+return false;
+}
+// For array types, the length expression can be an untyped constant
+// representable as an int, but we don't allow explicitly non-integer
+// values such as "float64(10)". See issues #13485 and #13486.
+if (this->length_->type()->integer_type() == NULL
+&& !this->length_->type()->is_error_type())
+{
+go_error_at(this->length_->location(), "invalid array bound");
 return false;
 }
 Numeric_constant nc;
 if (!this->length_->numeric_constant_value(&nc))
 }
 // Array type hash code.
 unsigned int
-Array_type::do_hash_for_method(Gogo* gogo) const
+Array_type::do_hash_for_method(Gogo* gogo, int flags) const
 {
 unsigned int ret;
 // There is no very convenient way to get a hash code for the
 // length.
-ret = this->element_type_->hash_for_method(gogo) + 1;
+ret = this->element_type_->hash_for_method(gogo, flags) + 1;
 if (this->is_array_incomparable_)
 ret <<= 1;
 return ret;
 }
 gogo->start_block(bloc);
 // Compare element in P1 and P2.
 Expression* e1 = Expression::make_temporary_reference(p1, bloc);
-e1 = Expression::make_unary(OPERATOR_MULT, e1, bloc);
+e1 = Expression::make_dereference(e1, Expression::NIL_CHECK_DEFAULT, bloc);
 ref = Expression::make_temporary_reference(index, bloc);
 e1 = Expression::make_array_index(e1, ref, NULL, NULL, bloc);
 Expression* e2 = Expression::make_temporary_reference(p2, bloc);
-e2 = Expression::make_unary(OPERATOR_MULT, e2, bloc);
+e2 = Expression::make_dereference(e2, Expression::NIL_CHECK_DEFAULT, bloc);
 ref = Expression::make_temporary_reference(index, bloc);
 e2 = Expression::make_array_index(e2, ref, NULL, NULL, bloc);
 Expression* cond = Expression::make_binary(OPERATOR_NOTEQ, e1, e2, bloc);
 array = tref;
 }
 else if (ve != NULL)
 {
 ve = new Var_expression(ve->named_object(), ve->location());
-ve->set_in_lvalue_pos();
 array = ve;
 }
 }
 return Expression::make_slice_info(array,
 std::string zname = Map_type::zero_value->name();
 std::string asm_name(go_selectively_encode_id(zname));
 Bvariable* zvar =
 gogo->backend()->implicit_variable(zname, asm_name,
-barray_type, false, true, true,
+barray_type, false, false, true,
-				       Map_type::zero_value_align);
+					 Map_type::zero_value_align);
 gogo->backend()->implicit_variable_set_init(zvar, zname, barray_type,
-					      false, true, true, NULL);
+					      false, false, true, NULL);
 return zvar;
 }
 // Traversal.
 }
 // Whether two map types are identical.
 bool
-Map_type::is_identical(const Map_type* t, Cmp_tags cmp_tags,
+Map_type::is_identical(const Map_type* t, int flags) const
-		       bool errors_are_identical) const
+{
-{
+return (Type::are_identical(this->key_type(), t->key_type(), flags, NULL)
-return (Type::are_identical_cmp_tags(this->key_type(), t->key_type(),
+	  && Type::are_identical(this->val_type(), t->val_type(), flags,
-				       cmp_tags, errors_are_identical, NULL)
+				 NULL));
-	  && Type::are_identical_cmp_tags(this->val_type(), t->val_type(),
-					  cmp_tags, errors_are_identical,
-					  NULL));
 }
 // Hash code.
 unsigned int
-Map_type::do_hash_for_method(Gogo* gogo) const
+Map_type::do_hash_for_method(Gogo* gogo, int flags) const
 {
-return (this->key_type_->hash_for_method(gogo)
+return (this->key_type_->hash_for_method(gogo, flags)
-	  + this->val_type_->hash_for_method(gogo)
+	  + this->val_type_->hash_for_method(gogo, flags)
 	  + 2);
 }
 // Get the backend representation for a map type.  A map type is
 // represented as a pointer to a struct.  The struct is hmap in
 Type* uintptr_type = Type::lookup_integer_type("uintptr");
 bfields[7].name = "nevacuate";
 bfields[7].btype = uintptr_type->get_backend(gogo);
 bfields[7].location = bloc;
-bfields[8].name = "overflow";
+bfields[8].name = "extra";
 bfields[8].btype = bpvt;
 bfields[8].location = bloc;
 Btype *bt = gogo->backend()->struct_type(bfields);
 bt = gogo->backend()->named_type("runtime.hmap", bt, bloc);
 Type* uint8_type = Type::lookup_integer_type("uint8");
 Type* uint16_type = Type::lookup_integer_type("uint16");
 Type* bool_type = Type::lookup_bool_type();
 Struct_type* sf =
-	Type::make_builtin_struct_type(12,
+	Type::make_builtin_struct_type(11,
 				       "", tdt,
 				       "key", ptdt,
 				       "elem", ptdt,
 				       "bucket", ptdt,
-				       "hmap", ptdt,
 				       "keysize", uint8_type,
 				       "indirectkey", bool_type,
 				       "valuesize", uint8_type,
 				       "indirectvalue", bool_type,
 				       "bucketsize", uint16_type,
 vals->push_back(Expression::make_type_descriptor(this->val_type_, bloc));
 ++p;
 go_assert(p->is_field_name("bucket"));
 vals->push_back(Expression::make_type_descriptor(bucket_type, bloc));
-++p;
-go_assert(p->is_field_name("hmap"));
-Type* hmap_type = this->hmap_type(bucket_type);
-vals->push_back(Expression::make_type_descriptor(hmap_type, bloc));
 ++p;
 go_assert(p->is_field_name("keysize"));
 if (keysize > Map_type::max_key_size)
 vals->push_back(Expression::make_integer_int64(ptrsize, uint8_type, bloc));
 if (this->hmap_type_ != NULL)
 return this->hmap_type_;
 Type* int_type = Type::lookup_integer_type("int");
 Type* uint8_type = Type::lookup_integer_type("uint8");
+Type* uint16_type = Type::lookup_integer_type("uint16");
 Type* uint32_type = Type::lookup_integer_type("uint32");
 Type* uintptr_type = Type::lookup_integer_type("uintptr");
 Type* void_ptr_type = Type::make_pointer_type(Type::make_void_type());
 Type* ptr_bucket_type = Type::make_pointer_type(bucket_type);
-Struct_type* ret = make_builtin_struct_type(8,
+Struct_type* ret = make_builtin_struct_type(9,
 					      "count", int_type,
 					      "flags", uint8_type,
 					      "B", uint8_type,
+					      "noverflow", uint16_type,
 					      "hash0", uint32_type,
 					      "buckets", ptr_bucket_type,
 					      "oldbuckets", ptr_bucket_type,
 					      "nevacuate", uintptr_type,
-					      "overflow", void_ptr_type);
+					      "extra", void_ptr_type);
 ret->set_is_struct_incomparable();
 this->hmap_type_ = ret;
 return ret;
 }
 Type* bucket_type = this->bucket_type(gogo, keysize, valsize);
 Type* bucket_ptr_type = Type::make_pointer_type(bucket_type);
 Type* hmap_type = this->hmap_type(bucket_type);
 Type* hmap_ptr_type = Type::make_pointer_type(hmap_type);
 Type* void_ptr_type = Type::make_pointer_type(Type::make_void_type());
+Type* bool_type = Type::lookup_bool_type();
-Struct_type* ret = make_builtin_struct_type(12,
+Struct_type* ret = make_builtin_struct_type(15,
 					      "key", key_ptr_type,
 					      "val", val_ptr_type,
 					      "t", uint8_ptr_type,
 					      "h", hmap_ptr_type,
 					      "buckets", bucket_ptr_type,
 					      "bptr", bucket_ptr_type,
-					      "overflow0", void_ptr_type,
+					      "overflow", void_ptr_type,
-					      "overflow1", void_ptr_type,
+					      "oldoverflow", void_ptr_type,
 					      "startBucket", uintptr_type,
-					      "stuff", uintptr_type,
+					      "offset", uint8_type,
+					      "wrapped", bool_type,
+					      "B", uint8_type,
+					      "i", uint8_type,
 					      "bucket", uintptr_type,
 					      "checkBucket", uintptr_type);
 ret->set_is_struct_incomparable();
 this->hiter_type_ = ret;
 return ret;
 }
 // Hash code.
 unsigned int
-Channel_type::do_hash_for_method(Gogo* gogo) const
+Channel_type::do_hash_for_method(Gogo* gogo, int flags) 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;
+ret += this->element_type_->hash_for_method(gogo, flags) << 2;
 return ret << 3;
 }
 // Whether this type is the same as T.
 bool
-Channel_type::is_identical(const Channel_type* t, Cmp_tags cmp_tags,
+Channel_type::is_identical(const Channel_type* t, int flags) const
-			   bool errors_are_identical) const
+{
-{
+if (!Type::are_identical(this->element_type(), t->element_type(), flags,
-if (!Type::are_identical_cmp_tags(this->element_type(), t->element_type(),
+			   NULL))
-				    cmp_tags, errors_are_identical, NULL))
 return false;
 return (this->may_send_ == t->may_send_
 	  && this->may_receive_ == t->may_receive_);
 }
 Type* element_type = imp->read_type();
 return Type::make_channel_type(may_send, may_receive, element_type);
 }
-// Return the type to manage a select statement with ncases case
+// Return the type that the runtime package uses for one case of a
-// statements.  A value of this type is allocated on the stack.  This
+// select statement.  An array of values of this type is allocated on
-// must match the type hselect in libgo/go/runtime/select.go.
+// the stack.  This must match scase in libgo/go/runtime/select.go.
 Type*
-Channel_type::select_type(int ncases)
+Channel_type::select_case_type()
 {
-Type* unsafe_pointer_type = Type::make_pointer_type(Type::make_void_type());
-Type* uint16_type = Type::lookup_integer_type("uint16");
 static Struct_type* scase_type;
 if (scase_type == NULL)
 {
-Type* uintptr_type = Type::lookup_integer_type("uintptr");
+Type* unsafe_pointer_type =
-Type* uint64_type = Type::lookup_integer_type("uint64");
+	Type::make_pointer_type(Type::make_void_type());
+Type* uint16_type = Type::lookup_integer_type("uint16");
+Type* int64_type = Type::lookup_integer_type("int64");
 scase_type =
-	Type::make_builtin_struct_type(7,
+	Type::make_builtin_struct_type(4,
+				       "c", unsafe_pointer_type,
 				       "elem", unsafe_pointer_type,
-				       "chan", unsafe_pointer_type,
-				       "pc", uintptr_type,
 				       "kind", uint16_type,
-				       "index", uint16_type,
+				       "releasetime", int64_type);
-				       "receivedp", unsafe_pointer_type,
-				       "releasetime", uint64_type);
 scase_type->set_is_struct_incomparable();
 }
+return scase_type;
-Expression* ncases_expr =
-Expression::make_integer_ul(ncases, NULL, Linemap::predeclared_location());
-Array_type* scases = Type::make_array_type(scase_type, ncases_expr);
-scases->set_is_array_incomparable();
-Array_type* order = Type::make_array_type(uint16_type, ncases_expr);
-order->set_is_array_incomparable();
-Struct_type* ret =
-Type::make_builtin_struct_type(7,
-				   "tcase", uint16_type,
-				   "ncase", uint16_type,
-				   "pollorder", unsafe_pointer_type,
-				   "lockorder", unsafe_pointer_type,
-				   "scase", scases,
-				   "lockorderarr", order,
-				   "pollorderarr", order);
-ret->set_is_struct_incomparable();
-return ret;
 }
 // Make a new channel type.
 Channel_type*
 }
 // Whether this type is identical with T.
 bool
-Interface_type::is_identical(const Interface_type* t, Cmp_tags cmp_tags,
+Interface_type::is_identical(const Interface_type* t, int flags) const
-			     bool errors_are_identical) const
 {
 // If methods have not been finalized, then we are asking whether
 // func redeclarations are the same.  This is an error, so for
 // simplicity we say they are never the same.
 if (!this->methods_are_finalized_ || !t->methods_are_finalized_)
 for (p2 = t->all_methods_->begin(); p2 != t->all_methods_->end(); ++p1, ++p2)
 {
 if (p1 == this->all_methods_->end())
 	break;
 if (p1->name() != p2->name()
-	  || !Type::are_identical_cmp_tags(p1->type(), p2->type(), cmp_tags,
+	  || !Type::are_identical(p1->type(), p2->type(), flags, NULL))
-					   errors_are_identical, NULL))
 	break;
 }
 this->assume_identical_ = hold_ai;
 	    }
 	  return false;
 	}
 std::string subreason;
-if (!Type::are_identical(p->type(), m->type(), true, &subreason))
+if (!Type::are_identical(p->type(), m->type(), Type::COMPARE_TAGS,
+			       &subreason))
 	{
 	  if (reason != NULL)
 	    {
 	      std::string n = Gogo::message_name(p->name());
 	      size_t len = 100 + n.length() + subreason.length();
 }
 // Hash code.
 unsigned int
-Interface_type::do_hash_for_method(Gogo*) const
+Interface_type::do_hash_for_method(Gogo*, int) const
 {
 go_assert(this->methods_are_finalized_);
 unsigned int ret = 0;
 if (this->all_methods_ != NULL)
 {
 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, COMPARE_TAGS, true,
+if (!p_fn_type->is_identical(m_fn_type, true, Type::COMPARE_TAGS,
 				   &subreason))
 	{
 	  if (reason != NULL)
 	    {
 	      std::string n = Gogo::message_name(p->name());
 empty_interface_type = gogo->backend()->struct_type(bfields);
 }
 return empty_interface_type;
 }
+Interface_type::Bmethods_map Interface_type::bmethods_map;
 // Return a pointer to the backend representation of the method table.
 Btype*
 Interface_type::get_backend_methods(Gogo* gogo)
 {
 if (this->bmethods_ != NULL && !this->bmethods_is_placeholder_)
 return this->bmethods_;
+std::pair<Interface_type*, Bmethods_map_entry> val;
+val.first = this;
+val.second.btype = NULL;
+val.second.is_placeholder = false;
+std::pair<Bmethods_map::iterator, bool> ins =
+Interface_type::bmethods_map.insert(val);
+if (!ins.second
+&& ins.first->second.btype != NULL
+&& !ins.first->second.is_placeholder)
+{
+this->bmethods_ = ins.first->second.btype;
+this->bmethods_is_placeholder_ = false;
+return this->bmethods_;
+}
 Location loc = this->location();
 std::vector<Backend::Btyped_identifier>
 mfields(this->all_methods_->size() + 1);
 }
 Btype* st = gogo->backend()->struct_type(mfields);
 Btype* ret = gogo->backend()->pointer_type(st);
-if (this->bmethods_ != NULL && this->bmethods_is_placeholder_)
+if (ins.first->second.btype != NULL
-gogo->backend()->set_placeholder_pointer_type(this->bmethods_, ret);
+&& ins.first->second.is_placeholder)
+gogo->backend()->set_placeholder_pointer_type(ins.first->second.btype,
+ret);
 this->bmethods_ = ret;
+ins.first->second.btype = ret;
 this->bmethods_is_placeholder_ = false;
+ins.first->second.is_placeholder = false;
 return ret;
 }
 // Return a placeholder for the pointer to the backend methods table.
 Btype*
 Interface_type::get_backend_methods_placeholder(Gogo* gogo)
 {
 if (this->bmethods_ == NULL)
 {
+std::pair<Interface_type*, Bmethods_map_entry> val;
+val.first = this;
+val.second.btype = NULL;
+val.second.is_placeholder = false;
+std::pair<Bmethods_map::iterator, bool> ins =
+Interface_type::bmethods_map.insert(val);
+if (!ins.second && ins.first->second.btype != NULL)
+{
+this->bmethods_ = ins.first->second.btype;
+this->bmethods_is_placeholder_ = ins.first->second.is_placeholder;
+return this->bmethods_;
+}
 Location loc = this->location();
-this->bmethods_ = gogo->backend()->placeholder_pointer_type("", loc,
+Btype* bt = gogo->backend()->placeholder_pointer_type("", loc, false);
-								  false);
+this->bmethods_ = bt;
+ins.first->second.btype = bt;
 this->bmethods_is_placeholder_ = true;
+ins.first->second.is_placeholder = true;
 }
 return this->bmethods_;
 }
 // Return the fields of a non-empty interface type.  This is not
 bool
 Named_method::do_nointerface() const
 {
 Named_object* no = this->named_object_;
-return no->is_function() && no->func_value()->nointerface();
+if (no->is_function())
+return no->func_value()->nointerface();
+else if (no->is_function_declaration())
+return no->func_declaration_value()->nointerface();
+else
+go_unreachable();
 }
 // Class Interface_method.
 // Bind a method to an object.
 // 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
+Named_type::do_hash_for_method(Gogo* gogo, int) const
 {
 if (this->is_error_)
 return 0;
 // Aliases are handled in Type::hash_for_method.
 case TYPE_FUNCTION:
 // Don't build a circular data structure.  GENERIC can't handle
 // it.
 if (this->seen_in_get_backend_)
-	{
+return gogo->backend()->circular_pointer_type(bt, true);
-	  this->is_circular_ = true;
-	  return gogo->backend()->circular_pointer_type(bt, true);
-	}
 this->seen_in_get_backend_ = true;
 bt1 = Type::get_named_base_btype(gogo, base);
 this->seen_in_get_backend_ = false;
-if (this->is_circular_)
-	bt1 = gogo->backend()->circular_pointer_type(bt, true);
 if (!gogo->backend()->set_placeholder_pointer_type(bt, bt1))
 	bt = gogo->backend()->error_type();
 return bt;
 case TYPE_POINTER:
 // Don't build a circular data structure. GENERIC can't handle
 // it.
 if (this->seen_in_get_backend_)
-	{
+return gogo->backend()->circular_pointer_type(bt, false);
-	  this->is_circular_ = true;
-	  return gogo->backend()->circular_pointer_type(bt, false);
-	}
 this->seen_in_get_backend_ = true;
 bt1 = Type::get_named_base_btype(gogo, base);
 this->seen_in_get_backend_ = false;
-if (this->is_circular_)
-	bt1 = gogo->backend()->circular_pointer_type(bt, false);
 if (!gogo->backend()->set_placeholder_pointer_type(bt, bt1))
 	bt = gogo->backend()->error_type();
 return bt;
 default:
 ret->push_back('\t');
 }
 ret->append(Gogo::unpack_hidden_name(this->named_object_->name()));
 }
-// Export the type.  This is called to export a global type.
+// Import a named type.  This is only used for export format versions
+// before version 3.
-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");
+imp->require_semicolon_if_old_version();
+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.
+// case Export::export_type will already have issued the name.  The
+// output always ends with a newline, since that is convenient if
+// there are methods.
 void
 Named_type::do_export(Export* exp) const
 {
 exp->write_type(this->type_);
+exp->write_c_string("\n");
 // 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(" ");
 const Package* package;
 if (type->named_type() == NULL)
 	package = NULL;
 else
 	package = type->named_type()->named_object()->package();
-std::string stub_name = gogo->stub_method_name(name);
+std::string stub_name = gogo->stub_method_name(package, name);
 Named_object* stub;
 if (package != NULL)
 	stub = Named_object::make_function_declaration(stub_name, package,
 						       stub_type, location);
 else
 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);
+expr = Expression::make_dereference(expr, Expression::NIL_CHECK_DEFAULT,
+location);
 go_assert(expr->type()->struct_type() == stype);
 }
 return Expression::make_field_reference(expr, field_indexes->field_index,
 					  location);
 }
 && st == NULL
 && it == NULL
 && type->points_to() != NULL
 && type->points_to()->points_to() != NULL)
 {
-expr = Expression::make_unary(OPERATOR_MULT, expr, location);
+expr = Expression::make_dereference(expr, Expression::NIL_CHECK_DEFAULT,
+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();
 go_error_at(location, "pointer type has no field %qs",
 Gogo::message_name(name).c_str());
 return Expression::make_error(location);
 }
 	      go_assert(type->points_to() != NULL);
-	      expr = Expression::make_unary(OPERATOR_MULT, expr,
+expr = Expression::make_dereference(expr,
-					    location);
+Expression::NIL_CHECK_DEFAULT,
+location);
 	      go_assert(expr->type()->struct_type() == st);
 	    }
 	  ret = st->field_reference(expr, name, location);
 if (ret == NULL)
 {
 			   bool* found_pointer_method,
 			   std::string* ambig1,
 			   std::string* ambig2)
 {
 // Named types can have locally defined methods.
-const Named_type* nt = type->named_type();
+const Named_type* nt = type->unalias()->named_type();
 if (nt == NULL && type->points_to() != NULL)
-nt = type->points_to()->named_type();
+nt = type->points_to()->unalias()->named_type();
 if (nt != NULL)
 {
 Named_object* no = nt->find_local_method(name);
 if (no != NULL)
 	{
 }
 // Traverse types.
 int
-Typed_identifier_list::traverse(Traverse* traverse)
+Typed_identifier_list::traverse(Traverse* traverse) const
 {
 for (Typed_identifier_list::const_iterator p = this->begin();
 p != this->end();
 ++p)
 {

Mercurial > hg > CbC > CbC_gcc

comparison gcc/go/gofrontend/types.cc @ 131:84e7813d76e9