OSDN Git Service

0bbe3c5b7cabcbdcac127cb34144628b8f37b08e
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / types.cc
1 // types.cc -- Go frontend types.
2
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
6
7 #include "go-system.h"
8
9 #include <gmp.h>
10
11 #ifndef ENABLE_BUILD_WITH_CXX
12 extern "C"
13 {
14 #endif
15
16 #include "toplev.h"
17 #include "intl.h"
18 #include "tree.h"
19 #include "gimple.h"
20 #include "real.h"
21 #include "convert.h"
22
23 #ifndef ENABLE_BUILD_WITH_CXX
24 }
25 #endif
26
27 #include "go-c.h"
28 #include "gogo.h"
29 #include "operator.h"
30 #include "expressions.h"
31 #include "statements.h"
32 #include "export.h"
33 #include "import.h"
34 #include "backend.h"
35 #include "types.h"
36
37 // Class Type.
38
39 Type::Type(Type_classification classification)
40   : classification_(classification), btype_(NULL), type_descriptor_var_(NULL)
41 {
42 }
43
44 Type::~Type()
45 {
46 }
47
48 // Get the base type for a type--skip names and forward declarations.
49
50 Type*
51 Type::base()
52 {
53   switch (this->classification_)
54     {
55     case TYPE_NAMED:
56       return this->named_type()->named_base();
57     case TYPE_FORWARD:
58       return this->forward_declaration_type()->real_type()->base();
59     default:
60       return this;
61     }
62 }
63
64 const Type*
65 Type::base() const
66 {
67   switch (this->classification_)
68     {
69     case TYPE_NAMED:
70       return this->named_type()->named_base();
71     case TYPE_FORWARD:
72       return this->forward_declaration_type()->real_type()->base();
73     default:
74       return this;
75     }
76 }
77
78 // Skip defined forward declarations.
79
80 Type*
81 Type::forwarded()
82 {
83   Type* t = this;
84   Forward_declaration_type* ftype = t->forward_declaration_type();
85   while (ftype != NULL && ftype->is_defined())
86     {
87       t = ftype->real_type();
88       ftype = t->forward_declaration_type();
89     }
90   return t;
91 }
92
93 const Type*
94 Type::forwarded() const
95 {
96   const Type* t = this;
97   const Forward_declaration_type* ftype = t->forward_declaration_type();
98   while (ftype != NULL && ftype->is_defined())
99     {
100       t = ftype->real_type();
101       ftype = t->forward_declaration_type();
102     }
103   return t;
104 }
105
106 // If this is a named type, return it.  Otherwise, return NULL.
107
108 Named_type*
109 Type::named_type()
110 {
111   return this->forwarded()->convert_no_base<Named_type, TYPE_NAMED>();
112 }
113
114 const Named_type*
115 Type::named_type() const
116 {
117   return this->forwarded()->convert_no_base<const Named_type, TYPE_NAMED>();
118 }
119
120 // Return true if this type is not defined.
121
122 bool
123 Type::is_undefined() const
124 {
125   return this->forwarded()->forward_declaration_type() != NULL;
126 }
127
128 // Return true if this is a basic type: a type which is not composed
129 // of other types, and is not void.
130
131 bool
132 Type::is_basic_type() const
133 {
134   switch (this->classification_)
135     {
136     case TYPE_INTEGER:
137     case TYPE_FLOAT:
138     case TYPE_COMPLEX:
139     case TYPE_BOOLEAN:
140     case TYPE_STRING:
141     case TYPE_NIL:
142       return true;
143
144     case TYPE_ERROR:
145     case TYPE_VOID:
146     case TYPE_FUNCTION:
147     case TYPE_POINTER:
148     case TYPE_STRUCT:
149     case TYPE_ARRAY:
150     case TYPE_MAP:
151     case TYPE_CHANNEL:
152     case TYPE_INTERFACE:
153       return false;
154
155     case TYPE_NAMED:
156     case TYPE_FORWARD:
157       return this->base()->is_basic_type();
158
159     default:
160       go_unreachable();
161     }
162 }
163
164 // Return true if this is an abstract type.
165
166 bool
167 Type::is_abstract() const
168 {
169   switch (this->classification())
170     {
171     case TYPE_INTEGER:
172       return this->integer_type()->is_abstract();
173     case TYPE_FLOAT:
174       return this->float_type()->is_abstract();
175     case TYPE_COMPLEX:
176       return this->complex_type()->is_abstract();
177     case TYPE_STRING:
178       return this->is_abstract_string_type();
179     case TYPE_BOOLEAN:
180       return this->is_abstract_boolean_type();
181     default:
182       return false;
183     }
184 }
185
186 // Return a non-abstract version of an abstract type.
187
188 Type*
189 Type::make_non_abstract_type()
190 {
191   go_assert(this->is_abstract());
192   switch (this->classification())
193     {
194     case TYPE_INTEGER:
195       if (this->integer_type()->is_rune())
196         return Type::lookup_integer_type("int32");
197       else
198         return Type::lookup_integer_type("int");
199     case TYPE_FLOAT:
200       return Type::lookup_float_type("float64");
201     case TYPE_COMPLEX:
202       return Type::lookup_complex_type("complex128");
203     case TYPE_STRING:
204       return Type::lookup_string_type();
205     case TYPE_BOOLEAN:
206       return Type::lookup_bool_type();
207     default:
208       go_unreachable();
209     }
210 }
211
212 // Return true if this is an error type.  Don't give an error if we
213 // try to dereference an undefined forwarding type, as this is called
214 // in the parser when the type may legitimately be undefined.
215
216 bool
217 Type::is_error_type() const
218 {
219   const Type* t = this->forwarded();
220   // Note that we return false for an undefined forward type.
221   switch (t->classification_)
222     {
223     case TYPE_ERROR:
224       return true;
225     case TYPE_NAMED:
226       return t->named_type()->is_named_error_type();
227     default:
228       return false;
229     }
230 }
231
232 // If this is a pointer type, return the type to which it points.
233 // Otherwise, return NULL.
234
235 Type*
236 Type::points_to() const
237 {
238   const Pointer_type* ptype = this->convert<const Pointer_type,
239                                             TYPE_POINTER>();
240   return ptype == NULL ? NULL : ptype->points_to();
241 }
242
243 // Return whether this is an open array type.
244
245 bool
246 Type::is_slice_type() const
247 {
248   return this->array_type() != NULL && this->array_type()->length() == NULL;
249 }
250
251 // Return whether this is the predeclared constant nil being used as a
252 // type.
253
254 bool
255 Type::is_nil_constant_as_type() const
256 {
257   const Type* t = this->forwarded();
258   if (t->forward_declaration_type() != NULL)
259     {
260       const Named_object* no = t->forward_declaration_type()->named_object();
261       if (no->is_unknown())
262         no = no->unknown_value()->real_named_object();
263       if (no != NULL
264           && no->is_const()
265           && no->const_value()->expr()->is_nil_expression())
266         return true;
267     }
268   return false;
269 }
270
271 // Traverse a type.
272
273 int
274 Type::traverse(Type* type, Traverse* traverse)
275 {
276   go_assert((traverse->traverse_mask() & Traverse::traverse_types) != 0
277              || (traverse->traverse_mask()
278                  & Traverse::traverse_expressions) != 0);
279   if (traverse->remember_type(type))
280     {
281       // We have already traversed this type.
282       return TRAVERSE_CONTINUE;
283     }
284   if ((traverse->traverse_mask() & Traverse::traverse_types) != 0)
285     {
286       int t = traverse->type(type);
287       if (t == TRAVERSE_EXIT)
288         return TRAVERSE_EXIT;
289       else if (t == TRAVERSE_SKIP_COMPONENTS)
290         return TRAVERSE_CONTINUE;
291     }
292   // An array type has an expression which we need to traverse if
293   // traverse_expressions is set.
294   if (type->do_traverse(traverse) == TRAVERSE_EXIT)
295     return TRAVERSE_EXIT;
296   return TRAVERSE_CONTINUE;
297 }
298
299 // Default implementation for do_traverse for child class.
300
301 int
302 Type::do_traverse(Traverse*)
303 {
304   return TRAVERSE_CONTINUE;
305 }
306
307 // Return whether two types are identical.  If ERRORS_ARE_IDENTICAL,
308 // then return true for all erroneous types; this is used to avoid
309 // cascading errors.  If REASON is not NULL, optionally set *REASON to
310 // the reason the types are not identical.
311
312 bool
313 Type::are_identical(const Type* t1, const Type* t2, bool errors_are_identical,
314                     std::string* reason)
315 {
316   if (t1 == NULL || t2 == NULL)
317     {
318       // Something is wrong.
319       return errors_are_identical ? true : t1 == t2;
320     }
321
322   // Skip defined forward declarations.
323   t1 = t1->forwarded();
324   t2 = t2->forwarded();
325
326   // Ignore aliases for purposes of type identity.
327   if (t1->named_type() != NULL && t1->named_type()->is_alias())
328     t1 = t1->named_type()->real_type();
329   if (t2->named_type() != NULL && t2->named_type()->is_alias())
330     t2 = t2->named_type()->real_type();
331
332   if (t1 == t2)
333     return true;
334
335   // An undefined forward declaration is an error.
336   if (t1->forward_declaration_type() != NULL
337       || t2->forward_declaration_type() != NULL)
338     return errors_are_identical;
339
340   // Avoid cascading errors with error types.
341   if (t1->is_error_type() || t2->is_error_type())
342     {
343       if (errors_are_identical)
344         return true;
345       return t1->is_error_type() && t2->is_error_type();
346     }
347
348   // Get a good reason for the sink type.  Note that the sink type on
349   // the left hand side of an assignment is handled in are_assignable.
350   if (t1->is_sink_type() || t2->is_sink_type())
351     {
352       if (reason != NULL)
353         *reason = "invalid use of _";
354       return false;
355     }
356
357   // A named type is only identical to itself.
358   if (t1->named_type() != NULL || t2->named_type() != NULL)
359     return false;
360
361   // Check type shapes.
362   if (t1->classification() != t2->classification())
363     return false;
364
365   switch (t1->classification())
366     {
367     case TYPE_VOID:
368     case TYPE_BOOLEAN:
369     case TYPE_STRING:
370     case TYPE_NIL:
371       // These types are always identical.
372       return true;
373
374     case TYPE_INTEGER:
375       return t1->integer_type()->is_identical(t2->integer_type());
376
377     case TYPE_FLOAT:
378       return t1->float_type()->is_identical(t2->float_type());
379
380     case TYPE_COMPLEX:
381       return t1->complex_type()->is_identical(t2->complex_type());
382
383     case TYPE_FUNCTION:
384       return t1->function_type()->is_identical(t2->function_type(),
385                                                false,
386                                                errors_are_identical,
387                                                reason);
388
389     case TYPE_POINTER:
390       return Type::are_identical(t1->points_to(), t2->points_to(),
391                                  errors_are_identical, reason);
392
393     case TYPE_STRUCT:
394       return t1->struct_type()->is_identical(t2->struct_type(),
395                                              errors_are_identical);
396
397     case TYPE_ARRAY:
398       return t1->array_type()->is_identical(t2->array_type(),
399                                             errors_are_identical);
400
401     case TYPE_MAP:
402       return t1->map_type()->is_identical(t2->map_type(),
403                                           errors_are_identical);
404
405     case TYPE_CHANNEL:
406       return t1->channel_type()->is_identical(t2->channel_type(),
407                                               errors_are_identical);
408
409     case TYPE_INTERFACE:
410       return t1->interface_type()->is_identical(t2->interface_type(),
411                                                 errors_are_identical);
412
413     case TYPE_CALL_MULTIPLE_RESULT:
414       if (reason != NULL)
415         *reason = "invalid use of multiple value function call";
416       return false;
417
418     default:
419       go_unreachable();
420     }
421 }
422
423 // Return true if it's OK to have a binary operation with types LHS
424 // and RHS.  This is not used for shifts or comparisons.
425
426 bool
427 Type::are_compatible_for_binop(const Type* lhs, const Type* rhs)
428 {
429   if (Type::are_identical(lhs, rhs, true, NULL))
430     return true;
431
432   // A constant of abstract bool type may be mixed with any bool type.
433   if ((rhs->is_abstract_boolean_type() && lhs->is_boolean_type())
434       || (lhs->is_abstract_boolean_type() && rhs->is_boolean_type()))
435     return true;
436
437   // A constant of abstract string type may be mixed with any string
438   // type.
439   if ((rhs->is_abstract_string_type() && lhs->is_string_type())
440       || (lhs->is_abstract_string_type() && rhs->is_string_type()))
441     return true;
442
443   lhs = lhs->base();
444   rhs = rhs->base();
445
446   // A constant of abstract integer, float, or complex type may be
447   // mixed with an integer, float, or complex type.
448   if ((rhs->is_abstract()
449        && (rhs->integer_type() != NULL
450            || rhs->float_type() != NULL
451            || rhs->complex_type() != NULL)
452        && (lhs->integer_type() != NULL
453            || lhs->float_type() != NULL
454            || lhs->complex_type() != NULL))
455       || (lhs->is_abstract()
456           && (lhs->integer_type() != NULL
457               || lhs->float_type() != NULL
458               || lhs->complex_type() != NULL)
459           && (rhs->integer_type() != NULL
460               || rhs->float_type() != NULL
461               || rhs->complex_type() != NULL)))
462     return true;
463
464   // The nil type may be compared to a pointer, an interface type, a
465   // slice type, a channel type, a map type, or a function type.
466   if (lhs->is_nil_type()
467       && (rhs->points_to() != NULL
468           || rhs->interface_type() != NULL
469           || rhs->is_slice_type()
470           || rhs->map_type() != NULL
471           || rhs->channel_type() != NULL
472           || rhs->function_type() != NULL))
473     return true;
474   if (rhs->is_nil_type()
475       && (lhs->points_to() != NULL
476           || lhs->interface_type() != NULL
477           || lhs->is_slice_type()
478           || lhs->map_type() != NULL
479           || lhs->channel_type() != NULL
480           || lhs->function_type() != NULL))
481     return true;
482
483   return false;
484 }
485
486 // Return true if a value with type T1 may be compared with a value of
487 // type T2.  IS_EQUALITY_OP is true for == or !=, false for <, etc.
488
489 bool
490 Type::are_compatible_for_comparison(bool is_equality_op, const Type *t1,
491                                     const Type *t2, std::string *reason)
492 {
493   if (t1 != t2
494       && !Type::are_assignable(t1, t2, NULL)
495       && !Type::are_assignable(t2, t1, NULL))
496     {
497       if (reason != NULL)
498         *reason = "incompatible types in binary expression";
499       return false;
500     }
501
502   if (!is_equality_op)
503     {
504       if (t1->integer_type() == NULL
505           && t1->float_type() == NULL
506           && !t1->is_string_type())
507         {
508           if (reason != NULL)
509             *reason = _("invalid comparison of non-ordered type");
510           return false;
511         }
512     }
513   else if (t1->is_slice_type()
514            || t1->map_type() != NULL
515            || t1->function_type() != NULL
516            || t2->is_slice_type()
517            || t2->map_type() != NULL
518            || t2->function_type() != NULL)
519     {
520       if (!t1->is_nil_type() && !t2->is_nil_type())
521         {
522           if (reason != NULL)
523             {
524               if (t1->is_slice_type() || t2->is_slice_type())
525                 *reason = _("slice can only be compared to nil");
526               else if (t1->map_type() != NULL || t2->map_type() != NULL)
527                 *reason = _("map can only be compared to nil");
528               else
529                 *reason = _("func can only be compared to nil");
530
531               // Match 6g error messages.
532               if (t1->interface_type() != NULL || t2->interface_type() != NULL)
533                 {
534                   char buf[200];
535                   snprintf(buf, sizeof buf, _("invalid operation (%s)"),
536                            reason->c_str());
537                   *reason = buf;
538                 }
539             }
540           return false;
541         }
542     }
543   else
544     {
545       if (!t1->is_boolean_type()
546           && t1->integer_type() == NULL
547           && t1->float_type() == NULL
548           && t1->complex_type() == NULL
549           && !t1->is_string_type()
550           && t1->points_to() == NULL
551           && t1->channel_type() == NULL
552           && t1->interface_type() == NULL
553           && t1->struct_type() == NULL
554           && t1->array_type() == NULL
555           && !t1->is_nil_type())
556         {
557           if (reason != NULL)
558             *reason = _("invalid comparison of non-comparable type");
559           return false;
560         }
561
562       if (t1->named_type() != NULL)
563         return t1->named_type()->named_type_is_comparable(reason);
564       else if (t2->named_type() != NULL)
565         return t2->named_type()->named_type_is_comparable(reason);
566       else if (t1->struct_type() != NULL)
567         {
568           const Struct_field_list* fields = t1->struct_type()->fields();
569           for (Struct_field_list::const_iterator p = fields->begin();
570                p != fields->end();
571                ++p)
572             {
573               if (!p->type()->is_comparable())
574                 {
575                   if (reason != NULL)
576                     *reason = _("invalid comparison of non-comparable struct");
577                   return false;
578                 }
579             }
580         }
581       else if (t1->array_type() != NULL)
582         {
583           if (t1->array_type()->length()->is_nil_expression()
584               || !t1->array_type()->element_type()->is_comparable())
585             {
586               if (reason != NULL)
587                 *reason = _("invalid comparison of non-comparable array");
588               return false;
589             }
590         }
591     }
592
593   return true;
594 }
595
596 // Return true if a value with type RHS may be assigned to a variable
597 // with type LHS.  If CHECK_HIDDEN_FIELDS is true, check whether any
598 // hidden fields are modified.  If REASON is not NULL, set *REASON to
599 // the reason the types are not assignable.
600
601 bool
602 Type::are_assignable_check_hidden(const Type* lhs, const Type* rhs,
603                                   bool check_hidden_fields,
604                                   std::string* reason)
605 {
606   // Do some checks first.  Make sure the types are defined.
607   if (rhs != NULL
608       && rhs->forwarded()->forward_declaration_type() == NULL
609       && rhs->is_void_type())
610     {
611       if (reason != NULL)
612         *reason = "non-value used as value";
613       return false;
614     }
615
616   if (lhs != NULL && lhs->forwarded()->forward_declaration_type() == NULL)
617     {
618       // Any value may be assigned to the blank identifier.
619       if (lhs->is_sink_type())
620         return true;
621
622       // All fields of a struct must be exported, or the assignment
623       // must be in the same package.
624       if (check_hidden_fields
625           && rhs != NULL
626           && rhs->forwarded()->forward_declaration_type() == NULL)
627         {
628           if (lhs->has_hidden_fields(NULL, reason)
629               || rhs->has_hidden_fields(NULL, reason))
630             return false;
631         }
632     }
633
634   // Identical types are assignable.
635   if (Type::are_identical(lhs, rhs, true, reason))
636     return true;
637
638   // The types are assignable if they have identical underlying types
639   // and either LHS or RHS is not a named type.
640   if (((lhs->named_type() != NULL && rhs->named_type() == NULL)
641        || (rhs->named_type() != NULL && lhs->named_type() == NULL))
642       && Type::are_identical(lhs->base(), rhs->base(), true, reason))
643     return true;
644
645   // The types are assignable if LHS is an interface type and RHS
646   // implements the required methods.
647   const Interface_type* lhs_interface_type = lhs->interface_type();
648   if (lhs_interface_type != NULL)
649     {
650       if (lhs_interface_type->implements_interface(rhs, reason))
651         return true;
652       const Interface_type* rhs_interface_type = rhs->interface_type();
653       if (rhs_interface_type != NULL
654           && lhs_interface_type->is_compatible_for_assign(rhs_interface_type,
655                                                           reason))
656         return true;
657     }
658
659   // The type are assignable if RHS is a bidirectional channel type,
660   // LHS is a channel type, they have identical element types, and
661   // either LHS or RHS is not a named type.
662   if (lhs->channel_type() != NULL
663       && rhs->channel_type() != NULL
664       && rhs->channel_type()->may_send()
665       && rhs->channel_type()->may_receive()
666       && (lhs->named_type() == NULL || rhs->named_type() == NULL)
667       && Type::are_identical(lhs->channel_type()->element_type(),
668                              rhs->channel_type()->element_type(),
669                              true,
670                              reason))
671     return true;
672
673   // The nil type may be assigned to a pointer, function, slice, map,
674   // channel, or interface type.
675   if (rhs->is_nil_type()
676       && (lhs->points_to() != NULL
677           || lhs->function_type() != NULL
678           || lhs->is_slice_type()
679           || lhs->map_type() != NULL
680           || lhs->channel_type() != NULL
681           || lhs->interface_type() != NULL))
682     return true;
683
684   // An untyped numeric constant may be assigned to a numeric type if
685   // it is representable in that type.
686   if ((rhs->is_abstract()
687        && (rhs->integer_type() != NULL
688            || rhs->float_type() != NULL
689            || rhs->complex_type() != NULL))
690       && (lhs->integer_type() != NULL
691           || lhs->float_type() != NULL
692           || lhs->complex_type() != NULL))
693     return true;
694
695   // Give some better error messages.
696   if (reason != NULL && reason->empty())
697     {
698       if (rhs->interface_type() != NULL)
699         reason->assign(_("need explicit conversion"));
700       else if (rhs->is_call_multiple_result_type())
701         reason->assign(_("multiple value function call in "
702                          "single value context"));
703       else if (lhs->named_type() != NULL && rhs->named_type() != NULL)
704         {
705           size_t len = (lhs->named_type()->name().length()
706                         + rhs->named_type()->name().length()
707                         + 100);
708           char* buf = new char[len];
709           snprintf(buf, len, _("cannot use type %s as type %s"),
710                    rhs->named_type()->message_name().c_str(),
711                    lhs->named_type()->message_name().c_str());
712           reason->assign(buf);
713           delete[] buf;
714         }
715     }
716
717   return false;
718 }
719
720 // Return true if a value with type RHS may be assigned to a variable
721 // with type LHS.  If REASON is not NULL, set *REASON to the reason
722 // the types are not assignable.
723
724 bool
725 Type::are_assignable(const Type* lhs, const Type* rhs, std::string* reason)
726 {
727   return Type::are_assignable_check_hidden(lhs, rhs, false, reason);
728 }
729
730 // Like are_assignable but don't check for hidden fields.
731
732 bool
733 Type::are_assignable_hidden_ok(const Type* lhs, const Type* rhs,
734                                std::string* reason)
735 {
736   return Type::are_assignable_check_hidden(lhs, rhs, false, reason);
737 }
738
739 // Return true if a value with type RHS may be converted to type LHS.
740 // If REASON is not NULL, set *REASON to the reason the types are not
741 // convertible.
742
743 bool
744 Type::are_convertible(const Type* lhs, const Type* rhs, std::string* reason)
745 {
746   // The types are convertible if they are assignable.
747   if (Type::are_assignable(lhs, rhs, reason))
748     return true;
749
750   // The types are convertible if they have identical underlying
751   // types.
752   if ((lhs->named_type() != NULL || rhs->named_type() != NULL)
753       && Type::are_identical(lhs->base(), rhs->base(), true, reason))
754     return true;
755
756   // The types are convertible if they are both unnamed pointer types
757   // and their pointer base types have identical underlying types.
758   if (lhs->named_type() == NULL
759       && rhs->named_type() == NULL
760       && lhs->points_to() != NULL
761       && rhs->points_to() != NULL
762       && (lhs->points_to()->named_type() != NULL
763           || rhs->points_to()->named_type() != NULL)
764       && Type::are_identical(lhs->points_to()->base(),
765                              rhs->points_to()->base(),
766                              true,
767                              reason))
768     return true;
769
770   // Integer and floating point types are convertible to each other.
771   if ((lhs->integer_type() != NULL || lhs->float_type() != NULL)
772       && (rhs->integer_type() != NULL || rhs->float_type() != NULL))
773     return true;
774
775   // Complex types are convertible to each other.
776   if (lhs->complex_type() != NULL && rhs->complex_type() != NULL)
777     return true;
778
779   // An integer, or []byte, or []rune, may be converted to a string.
780   if (lhs->is_string_type())
781     {
782       if (rhs->integer_type() != NULL)
783         return true;
784       if (rhs->is_slice_type())
785         {
786           const Type* e = rhs->array_type()->element_type()->forwarded();
787           if (e->integer_type() != NULL
788               && (e->integer_type()->is_byte()
789                   || e->integer_type()->is_rune()))
790             return true;
791         }
792     }
793
794   // A string may be converted to []byte or []rune.
795   if (rhs->is_string_type() && lhs->is_slice_type())
796     {
797       const Type* e = lhs->array_type()->element_type()->forwarded();
798       if (e->integer_type() != NULL
799           && (e->integer_type()->is_byte() || e->integer_type()->is_rune()))
800         return true;
801     }
802
803   // An unsafe.Pointer type may be converted to any pointer type or to
804   // uintptr, and vice-versa.
805   if (lhs->is_unsafe_pointer_type()
806       && (rhs->points_to() != NULL
807           || (rhs->integer_type() != NULL
808               && rhs->forwarded() == Type::lookup_integer_type("uintptr"))))
809     return true;
810   if (rhs->is_unsafe_pointer_type()
811       && (lhs->points_to() != NULL
812           || (lhs->integer_type() != NULL
813               && lhs->forwarded() == Type::lookup_integer_type("uintptr"))))
814     return true;
815
816   // Give a better error message.
817   if (reason != NULL)
818     {
819       if (reason->empty())
820         *reason = "invalid type conversion";
821       else
822         {
823           std::string s = "invalid type conversion (";
824           s += *reason;
825           s += ')';
826           *reason = s;
827         }
828     }
829
830   return false;
831 }
832
833 // Return whether this type has any hidden fields.  This is only a
834 // possibility for a few types.
835
836 bool
837 Type::has_hidden_fields(const Named_type* within, std::string* reason) const
838 {
839   switch (this->forwarded()->classification_)
840     {
841     case TYPE_NAMED:
842       return this->named_type()->named_type_has_hidden_fields(reason);
843     case TYPE_STRUCT:
844       return this->struct_type()->struct_has_hidden_fields(within, reason);
845     case TYPE_ARRAY:
846       return this->array_type()->array_has_hidden_fields(within, reason);
847     default:
848       return false;
849     }
850 }
851
852 // Return a hash code for the type to be used for method lookup.
853
854 unsigned int
855 Type::hash_for_method(Gogo* gogo) const
856 {
857   unsigned int ret = 0;
858   if (this->classification_ != TYPE_FORWARD)
859     ret += this->classification_;
860   return ret + this->do_hash_for_method(gogo);
861 }
862
863 // Default implementation of do_hash_for_method.  This is appropriate
864 // for types with no subfields.
865
866 unsigned int
867 Type::do_hash_for_method(Gogo*) const
868 {
869   return 0;
870 }
871
872 // Return a hash code for a string, given a starting hash.
873
874 unsigned int
875 Type::hash_string(const std::string& s, unsigned int h)
876 {
877   const char* p = s.data();
878   size_t len = s.length();
879   for (; len > 0; --len)
880     {
881       h ^= *p++;
882       h*= 16777619;
883     }
884   return h;
885 }
886
887 // A hash table mapping unnamed types to the backend representation of
888 // those types.
889
890 Type::Type_btypes Type::type_btypes;
891
892 // Return a tree representing this type.
893
894 Btype*
895 Type::get_backend(Gogo* gogo)
896 {
897   if (this->btype_ != NULL)
898     return this->btype_;
899
900   if (this->forward_declaration_type() != NULL
901       || this->named_type() != NULL)
902     return this->get_btype_without_hash(gogo);
903
904   if (this->is_error_type())
905     return gogo->backend()->error_type();
906
907   // To avoid confusing the backend, translate all identical Go types
908   // to the same backend representation.  We use a hash table to do
909   // that.  There is no need to use the hash table for named types, as
910   // named types are only identical to themselves.
911
912   std::pair<Type*, Btype*> val(this, NULL);
913   std::pair<Type_btypes::iterator, bool> ins =
914     Type::type_btypes.insert(val);
915   if (!ins.second && ins.first->second != NULL)
916     {
917       if (gogo != NULL && gogo->named_types_are_converted())
918         this->btype_ = ins.first->second;
919       return ins.first->second;
920     }
921
922   Btype* bt = this->get_btype_without_hash(gogo);
923
924   if (ins.first->second == NULL)
925     ins.first->second = bt;
926   else
927     {
928       // We have already created a backend representation for this
929       // type.  This can happen when an unnamed type is defined using
930       // a named type which in turns uses an identical unnamed type.
931       // Use the tree we created earlier and ignore the one we just
932       // built.
933       bt = ins.first->second;
934       if (gogo == NULL || !gogo->named_types_are_converted())
935         return bt;
936       this->btype_ = bt;
937     }
938
939   return bt;
940 }
941
942 // Return the backend representation for a type without looking in the
943 // hash table for identical types.  This is used for named types,
944 // since a named type is never identical to any other type.
945
946 Btype*
947 Type::get_btype_without_hash(Gogo* gogo)
948 {
949   if (this->btype_ == NULL)
950     {
951       Btype* bt = this->do_get_backend(gogo);
952
953       // For a recursive function or pointer type, we will temporarily
954       // return a circular pointer type during the recursion.  We
955       // don't want to record that for a forwarding type, as it may
956       // confuse us later.
957       if (this->forward_declaration_type() != NULL
958           && gogo->backend()->is_circular_pointer_type(bt))
959         return bt;
960
961       if (gogo == NULL || !gogo->named_types_are_converted())
962         return bt;
963
964       this->btype_ = bt;
965     }
966   return this->btype_;
967 }
968
969 // Return a pointer to the type descriptor for this type.
970
971 tree
972 Type::type_descriptor_pointer(Gogo* gogo, Location location)
973 {
974   Type* t = this->forwarded();
975   if (t->named_type() != NULL && t->named_type()->is_alias())
976     t = t->named_type()->real_type();
977   if (t->type_descriptor_var_ == NULL)
978     {
979       t->make_type_descriptor_var(gogo);
980       go_assert(t->type_descriptor_var_ != NULL);
981     }
982   tree var_tree = var_to_tree(t->type_descriptor_var_);
983   if (var_tree == error_mark_node)
984     return error_mark_node;
985   return build_fold_addr_expr_loc(location.gcc_location(), var_tree);
986 }
987
988 // A mapping from unnamed types to type descriptor variables.
989
990 Type::Type_descriptor_vars Type::type_descriptor_vars;
991
992 // Build the type descriptor for this type.
993
994 void
995 Type::make_type_descriptor_var(Gogo* gogo)
996 {
997   go_assert(this->type_descriptor_var_ == NULL);
998
999   Named_type* nt = this->named_type();
1000
1001   // We can have multiple instances of unnamed types, but we only want
1002   // to emit the type descriptor once.  We use a hash table.  This is
1003   // not necessary for named types, as they are unique, and we store
1004   // the type descriptor in the type itself.
1005   Bvariable** phash = NULL;
1006   if (nt == NULL)
1007     {
1008       Bvariable* bvnull = NULL;
1009       std::pair<Type_descriptor_vars::iterator, bool> ins =
1010         Type::type_descriptor_vars.insert(std::make_pair(this, bvnull));
1011       if (!ins.second)
1012         {
1013           // We've already build a type descriptor for this type.
1014           this->type_descriptor_var_ = ins.first->second;
1015           return;
1016         }
1017       phash = &ins.first->second;
1018     }
1019
1020   std::string var_name = this->type_descriptor_var_name(gogo, nt);
1021
1022   // Build the contents of the type descriptor.
1023   Expression* initializer = this->do_type_descriptor(gogo, NULL);
1024
1025   Btype* initializer_btype = initializer->type()->get_backend(gogo);
1026
1027   Location loc = nt == NULL ? Linemap::predeclared_location() : nt->location();
1028
1029   const Package* dummy;
1030   if (this->type_descriptor_defined_elsewhere(nt, &dummy))
1031     {
1032       this->type_descriptor_var_ =
1033         gogo->backend()->immutable_struct_reference(var_name,
1034                                                     initializer_btype,
1035                                                     loc);
1036       if (phash != NULL)
1037         *phash = this->type_descriptor_var_;
1038       return;
1039     }
1040
1041   // See if this type descriptor can appear in multiple packages.
1042   bool is_common = false;
1043   if (nt != NULL)
1044     {
1045       // We create the descriptor for a builtin type whenever we need
1046       // it.
1047       is_common = nt->is_builtin();
1048     }
1049   else
1050     {
1051       // This is an unnamed type.  The descriptor could be defined in
1052       // any package where it is needed, and the linker will pick one
1053       // descriptor to keep.
1054       is_common = true;
1055     }
1056
1057   // We are going to build the type descriptor in this package.  We
1058   // must create the variable before we convert the initializer to the
1059   // backend representation, because the initializer may refer to the
1060   // type descriptor of this type.  By setting type_descriptor_var_ we
1061   // ensure that type_descriptor_pointer will work if called while
1062   // converting INITIALIZER.
1063
1064   this->type_descriptor_var_ =
1065     gogo->backend()->immutable_struct(var_name, is_common, initializer_btype,
1066                                       loc);
1067   if (phash != NULL)
1068     *phash = this->type_descriptor_var_;
1069
1070   Translate_context context(gogo, NULL, NULL, NULL);
1071   context.set_is_const();
1072   Bexpression* binitializer = tree_to_expr(initializer->get_tree(&context));
1073
1074   gogo->backend()->immutable_struct_set_init(this->type_descriptor_var_,
1075                                              var_name, is_common,
1076                                              initializer_btype, loc,
1077                                              binitializer);
1078 }
1079
1080 // Return the name of the type descriptor variable.  If NT is not
1081 // NULL, use it to get the name.  Otherwise this is an unnamed type.
1082
1083 std::string
1084 Type::type_descriptor_var_name(Gogo* gogo, Named_type* nt)
1085 {
1086   if (nt == NULL)
1087     return "__go_td_" + this->mangled_name(gogo);
1088
1089   Named_object* no = nt->named_object();
1090   const Named_object* in_function = nt->in_function();
1091   std::string ret = "__go_tdn_";
1092   if (nt->is_builtin())
1093     go_assert(in_function == NULL);
1094   else
1095     {
1096       const std::string& unique_prefix(no->package() == NULL
1097                                        ? gogo->unique_prefix()
1098                                        : no->package()->unique_prefix());
1099       const std::string& package_name(no->package() == NULL
1100                                       ? gogo->package_name()
1101                                       : no->package()->name());
1102       ret.append(unique_prefix);
1103       ret.append(1, '.');
1104       ret.append(package_name);
1105       ret.append(1, '.');
1106       if (in_function != NULL)
1107         {
1108           ret.append(Gogo::unpack_hidden_name(in_function->name()));
1109           ret.append(1, '.');
1110         }
1111     }
1112   ret.append(no->name());
1113   return ret;
1114 }
1115
1116 // Return true if this type descriptor is defined in a different
1117 // package.  If this returns true it sets *PACKAGE to the package.
1118
1119 bool
1120 Type::type_descriptor_defined_elsewhere(Named_type* nt,
1121                                         const Package** package)
1122 {
1123   if (nt != NULL)
1124     {
1125       if (nt->named_object()->package() != NULL)
1126         {
1127           // This is a named type defined in a different package.  The
1128           // type descriptor should be defined in that package.
1129           *package = nt->named_object()->package();
1130           return true;
1131         }
1132     }
1133   else
1134     {
1135       if (this->points_to() != NULL
1136           && this->points_to()->named_type() != NULL
1137           && this->points_to()->named_type()->named_object()->package() != NULL)
1138         {
1139           // This is an unnamed pointer to a named type defined in a
1140           // different package.  The descriptor should be defined in
1141           // that package.
1142           *package = this->points_to()->named_type()->named_object()->package();
1143           return true;
1144         }
1145     }
1146   return false;
1147 }
1148
1149 // Return a composite literal for a type descriptor.
1150
1151 Expression*
1152 Type::type_descriptor(Gogo* gogo, Type* type)
1153 {
1154   return type->do_type_descriptor(gogo, NULL);
1155 }
1156
1157 // Return a composite literal for a type descriptor with a name.
1158
1159 Expression*
1160 Type::named_type_descriptor(Gogo* gogo, Type* type, Named_type* name)
1161 {
1162   go_assert(name != NULL && type->named_type() != name);
1163   return type->do_type_descriptor(gogo, name);
1164 }
1165
1166 // Make a builtin struct type from a list of fields.  The fields are
1167 // pairs of a name and a type.
1168
1169 Struct_type*
1170 Type::make_builtin_struct_type(int nfields, ...)
1171 {
1172   va_list ap;
1173   va_start(ap, nfields);
1174
1175   Location bloc = Linemap::predeclared_location();
1176   Struct_field_list* sfl = new Struct_field_list();
1177   for (int i = 0; i < nfields; i++)
1178     {
1179       const char* field_name = va_arg(ap, const char *);
1180       Type* type = va_arg(ap, Type*);
1181       sfl->push_back(Struct_field(Typed_identifier(field_name, type, bloc)));
1182     }
1183
1184   va_end(ap);
1185
1186   return Type::make_struct_type(sfl, bloc);
1187 }
1188
1189 // A list of builtin named types.
1190
1191 std::vector<Named_type*> Type::named_builtin_types;
1192
1193 // Make a builtin named type.
1194
1195 Named_type*
1196 Type::make_builtin_named_type(const char* name, Type* type)
1197 {
1198   Location bloc = Linemap::predeclared_location();
1199   Named_object* no = Named_object::make_type(name, NULL, type, bloc);
1200   Named_type* ret = no->type_value();
1201   Type::named_builtin_types.push_back(ret);
1202   return ret;
1203 }
1204
1205 // Convert the named builtin types.
1206
1207 void
1208 Type::convert_builtin_named_types(Gogo* gogo)
1209 {
1210   for (std::vector<Named_type*>::const_iterator p =
1211          Type::named_builtin_types.begin();
1212        p != Type::named_builtin_types.end();
1213        ++p)
1214     {
1215       bool r = (*p)->verify();
1216       go_assert(r);
1217       (*p)->convert(gogo);
1218     }
1219 }
1220
1221 // Return the type of a type descriptor.  We should really tie this to
1222 // runtime.Type rather than copying it.  This must match commonType in
1223 // libgo/go/runtime/type.go.
1224
1225 Type*
1226 Type::make_type_descriptor_type()
1227 {
1228   static Type* ret;
1229   if (ret == NULL)
1230     {
1231       Location bloc = Linemap::predeclared_location();
1232
1233       Type* uint8_type = Type::lookup_integer_type("uint8");
1234       Type* uint32_type = Type::lookup_integer_type("uint32");
1235       Type* uintptr_type = Type::lookup_integer_type("uintptr");
1236       Type* string_type = Type::lookup_string_type();
1237       Type* pointer_string_type = Type::make_pointer_type(string_type);
1238
1239       // This is an unnamed version of unsafe.Pointer.  Perhaps we
1240       // should use the named version instead, although that would
1241       // require us to create the unsafe package if it has not been
1242       // imported.  It probably doesn't matter.
1243       Type* void_type = Type::make_void_type();
1244       Type* unsafe_pointer_type = Type::make_pointer_type(void_type);
1245
1246       // Forward declaration for the type descriptor type.
1247       Named_object* named_type_descriptor_type =
1248         Named_object::make_type_declaration("commonType", NULL, bloc);
1249       Type* ft = Type::make_forward_declaration(named_type_descriptor_type);
1250       Type* pointer_type_descriptor_type = Type::make_pointer_type(ft);
1251
1252       // The type of a method on a concrete type.
1253       Struct_type* method_type =
1254         Type::make_builtin_struct_type(5,
1255                                        "name", pointer_string_type,
1256                                        "pkgPath", pointer_string_type,
1257                                        "mtyp", pointer_type_descriptor_type,
1258                                        "typ", pointer_type_descriptor_type,
1259                                        "tfn", unsafe_pointer_type);
1260       Named_type* named_method_type =
1261         Type::make_builtin_named_type("method", method_type);
1262
1263       // Information for types with a name or methods.
1264       Type* slice_named_method_type =
1265         Type::make_array_type(named_method_type, NULL);
1266       Struct_type* uncommon_type =
1267         Type::make_builtin_struct_type(3,
1268                                        "name", pointer_string_type,
1269                                        "pkgPath", pointer_string_type,
1270                                        "methods", slice_named_method_type);
1271       Named_type* named_uncommon_type =
1272         Type::make_builtin_named_type("uncommonType", uncommon_type);
1273
1274       Type* pointer_uncommon_type =
1275         Type::make_pointer_type(named_uncommon_type);
1276
1277       // The type descriptor type.
1278
1279       Typed_identifier_list* params = new Typed_identifier_list();
1280       params->push_back(Typed_identifier("key", unsafe_pointer_type, bloc));
1281       params->push_back(Typed_identifier("key_size", uintptr_type, bloc));
1282
1283       Typed_identifier_list* results = new Typed_identifier_list();
1284       results->push_back(Typed_identifier("", uintptr_type, bloc));
1285
1286       Type* hashfn_type = Type::make_function_type(NULL, params, results, bloc);
1287
1288       params = new Typed_identifier_list();
1289       params->push_back(Typed_identifier("key1", unsafe_pointer_type, bloc));
1290       params->push_back(Typed_identifier("key2", unsafe_pointer_type, bloc));
1291       params->push_back(Typed_identifier("key_size", uintptr_type, bloc));
1292
1293       results = new Typed_identifier_list();
1294       results->push_back(Typed_identifier("", Type::lookup_bool_type(), bloc));
1295
1296       Type* equalfn_type = Type::make_function_type(NULL, params, results,
1297                                                     bloc);
1298
1299       Struct_type* type_descriptor_type =
1300         Type::make_builtin_struct_type(10,
1301                                        "Kind", uint8_type,
1302                                        "align", uint8_type,
1303                                        "fieldAlign", uint8_type,
1304                                        "size", uintptr_type,
1305                                        "hash", uint32_type,
1306                                        "hashfn", hashfn_type,
1307                                        "equalfn", equalfn_type,
1308                                        "string", pointer_string_type,
1309                                        "", pointer_uncommon_type,
1310                                        "ptrToThis",
1311                                        pointer_type_descriptor_type);
1312
1313       Named_type* named = Type::make_builtin_named_type("commonType",
1314                                                         type_descriptor_type);
1315
1316       named_type_descriptor_type->set_type_value(named);
1317
1318       ret = named;
1319     }
1320
1321   return ret;
1322 }
1323
1324 // Make the type of a pointer to a type descriptor as represented in
1325 // Go.
1326
1327 Type*
1328 Type::make_type_descriptor_ptr_type()
1329 {
1330   static Type* ret;
1331   if (ret == NULL)
1332     ret = Type::make_pointer_type(Type::make_type_descriptor_type());
1333   return ret;
1334 }
1335
1336 // Set *HASH_FN and *EQUAL_FN to the runtime functions which compute a
1337 // hash code for this type and which compare whether two values of
1338 // this type are equal.  If NAME is not NULL it is the name of this
1339 // type.  HASH_FNTYPE and EQUAL_FNTYPE are the types of these
1340 // functions, for convenience; they may be NULL.
1341
1342 void
1343 Type::type_functions(Gogo* gogo, Named_type* name, Function_type* hash_fntype,
1344                      Function_type* equal_fntype, Named_object** hash_fn,
1345                      Named_object** equal_fn)
1346 {
1347   if (hash_fntype == NULL || equal_fntype == NULL)
1348     {
1349       Location bloc = Linemap::predeclared_location();
1350
1351       Type* uintptr_type = Type::lookup_integer_type("uintptr");
1352       Type* void_type = Type::make_void_type();
1353       Type* unsafe_pointer_type = Type::make_pointer_type(void_type);
1354
1355       if (hash_fntype == NULL)
1356         {
1357           Typed_identifier_list* params = new Typed_identifier_list();
1358           params->push_back(Typed_identifier("key", unsafe_pointer_type,
1359                                              bloc));
1360           params->push_back(Typed_identifier("key_size", uintptr_type, bloc));
1361
1362           Typed_identifier_list* results = new Typed_identifier_list();
1363           results->push_back(Typed_identifier("", uintptr_type, bloc));
1364
1365           hash_fntype = Type::make_function_type(NULL, params, results, bloc);
1366         }
1367       if (equal_fntype == NULL)
1368         {
1369           Typed_identifier_list* params = new Typed_identifier_list();
1370           params->push_back(Typed_identifier("key1", unsafe_pointer_type,
1371                                              bloc));
1372           params->push_back(Typed_identifier("key2", unsafe_pointer_type,
1373                                              bloc));
1374           params->push_back(Typed_identifier("key_size", uintptr_type, bloc));
1375
1376           Typed_identifier_list* results = new Typed_identifier_list();
1377           results->push_back(Typed_identifier("", Type::lookup_bool_type(),
1378                                               bloc));
1379
1380           equal_fntype = Type::make_function_type(NULL, params, results, bloc);
1381         }
1382     }
1383
1384   const char* hash_fnname;
1385   const char* equal_fnname;
1386   if (this->compare_is_identity(gogo))
1387     {
1388       hash_fnname = "__go_type_hash_identity";
1389       equal_fnname = "__go_type_equal_identity";
1390     }
1391   else if (!this->is_comparable())
1392     {
1393       hash_fnname = "__go_type_hash_error";
1394       equal_fnname = "__go_type_equal_error";
1395     }
1396   else
1397     {
1398       switch (this->base()->classification())
1399         {
1400         case Type::TYPE_ERROR:
1401         case Type::TYPE_VOID:
1402         case Type::TYPE_NIL:
1403         case Type::TYPE_FUNCTION:
1404         case Type::TYPE_MAP:
1405           // For these types is_comparable should have returned false.
1406           go_unreachable();
1407
1408         case Type::TYPE_BOOLEAN:
1409         case Type::TYPE_INTEGER:
1410         case Type::TYPE_POINTER:
1411         case Type::TYPE_CHANNEL:
1412           // For these types compare_is_identity should have returned true.
1413           go_unreachable();
1414
1415         case Type::TYPE_FLOAT:
1416           hash_fnname = "__go_type_hash_float";
1417           equal_fnname = "__go_type_equal_float";
1418           break;
1419
1420         case Type::TYPE_COMPLEX:
1421           hash_fnname = "__go_type_hash_complex";
1422           equal_fnname = "__go_type_equal_complex";
1423           break;
1424
1425         case Type::TYPE_STRING:
1426           hash_fnname = "__go_type_hash_string";
1427           equal_fnname = "__go_type_equal_string";
1428           break;
1429
1430         case Type::TYPE_STRUCT:
1431           {
1432             // This is a struct which can not be compared using a
1433             // simple identity function.  We need to build a function
1434             // for comparison.
1435             this->specific_type_functions(gogo, name, hash_fntype,
1436                                           equal_fntype, hash_fn, equal_fn);
1437             return;
1438           }
1439
1440         case Type::TYPE_ARRAY:
1441           if (this->is_slice_type())
1442             {
1443               // Type::is_compatible_for_comparison should have
1444               // returned false.
1445               go_unreachable();
1446             }
1447           else
1448             {
1449               // This is an array which can not be compared using a
1450               // simple identity function.  We need to build a
1451               // function for comparison.
1452               this->specific_type_functions(gogo, name, hash_fntype,
1453                                             equal_fntype, hash_fn, equal_fn);
1454               return;
1455             }
1456           break;
1457
1458         case Type::TYPE_INTERFACE:
1459           if (this->interface_type()->is_empty())
1460             {
1461               hash_fnname = "__go_type_hash_empty_interface";
1462               equal_fnname = "__go_type_equal_empty_interface";
1463             }
1464           else
1465             {
1466               hash_fnname = "__go_type_hash_interface";
1467               equal_fnname = "__go_type_equal_interface";
1468             }
1469           break;
1470
1471         case Type::TYPE_NAMED:
1472         case Type::TYPE_FORWARD:
1473           go_unreachable();
1474
1475         default:
1476           go_unreachable();
1477         }
1478     }
1479
1480
1481   Location bloc = Linemap::predeclared_location();
1482   *hash_fn = Named_object::make_function_declaration(hash_fnname, NULL,
1483                                                      hash_fntype, bloc);
1484   (*hash_fn)->func_declaration_value()->set_asm_name(hash_fnname);
1485   *equal_fn = Named_object::make_function_declaration(equal_fnname, NULL,
1486                                                       equal_fntype, bloc);
1487   (*equal_fn)->func_declaration_value()->set_asm_name(equal_fnname);
1488 }
1489
1490 // A hash table mapping types to the specific hash functions.
1491
1492 Type::Type_functions Type::type_functions_table;
1493
1494 // Handle a type function which is specific to a type: a struct or
1495 // array which can not use an identity comparison.
1496
1497 void
1498 Type::specific_type_functions(Gogo* gogo, Named_type* name,
1499                               Function_type* hash_fntype,
1500                               Function_type* equal_fntype,
1501                               Named_object** hash_fn,
1502                               Named_object** equal_fn)
1503 {
1504   Hash_equal_fn fnull(NULL, NULL);
1505   std::pair<Type*, Hash_equal_fn> val(name != NULL ? name : this, fnull);
1506   std::pair<Type_functions::iterator, bool> ins =
1507     Type::type_functions_table.insert(val);
1508   if (!ins.second)
1509     {
1510       // We already have functions for this type
1511       *hash_fn = ins.first->second.first;
1512       *equal_fn = ins.first->second.second;
1513       return;
1514     }
1515
1516   std::string base_name;
1517   if (name == NULL)
1518     {
1519       // Mangled names can have '.' if they happen to refer to named
1520       // types in some way.  That's fine if this is simply a named
1521       // type, but otherwise it will confuse the code that builds
1522       // function identifiers.  Remove '.' when necessary.
1523       base_name = this->mangled_name(gogo);
1524       size_t i;
1525       while ((i = base_name.find('.')) != std::string::npos)
1526         base_name[i] = '$';
1527       base_name = gogo->pack_hidden_name(base_name, false);
1528     }
1529   else
1530     {
1531       // This name is already hidden or not as appropriate.
1532       base_name = name->name();
1533       const Named_object* in_function = name->in_function();
1534       if (in_function != NULL)
1535         base_name += '$' + in_function->name();
1536     }
1537   std::string hash_name = base_name + "$hash";
1538   std::string equal_name = base_name + "$equal";
1539
1540   Location bloc = Linemap::predeclared_location();
1541
1542   const Package* package = NULL;
1543   bool is_defined_elsewhere =
1544     this->type_descriptor_defined_elsewhere(name, &package);
1545   if (is_defined_elsewhere)
1546     {
1547       *hash_fn = Named_object::make_function_declaration(hash_name, package,
1548                                                          hash_fntype, bloc);
1549       *equal_fn = Named_object::make_function_declaration(equal_name, package,
1550                                                           equal_fntype, bloc);
1551     }
1552   else
1553     {
1554       *hash_fn = gogo->declare_package_function(hash_name, hash_fntype, bloc);
1555       *equal_fn = gogo->declare_package_function(equal_name, equal_fntype,
1556                                                  bloc);
1557     }
1558
1559   ins.first->second.first = *hash_fn;
1560   ins.first->second.second = *equal_fn;
1561
1562   if (!is_defined_elsewhere)
1563     {
1564       if (gogo->in_global_scope())
1565         this->write_specific_type_functions(gogo, name, hash_name, hash_fntype,
1566                                             equal_name, equal_fntype);
1567       else
1568         gogo->queue_specific_type_function(this, name, hash_name, hash_fntype,
1569                                            equal_name, equal_fntype);
1570     }
1571 }
1572
1573 // Write the hash and equality functions for a type which needs to be
1574 // written specially.
1575
1576 void
1577 Type::write_specific_type_functions(Gogo* gogo, Named_type* name,
1578                                     const std::string& hash_name,
1579                                     Function_type* hash_fntype,
1580                                     const std::string& equal_name,
1581                                     Function_type* equal_fntype)
1582 {
1583   Location bloc = Linemap::predeclared_location();
1584
1585   Named_object* hash_fn = gogo->start_function(hash_name, hash_fntype, false,
1586                                                bloc);
1587   gogo->start_block(bloc);
1588
1589   if (this->struct_type() != NULL)
1590     this->struct_type()->write_hash_function(gogo, name, hash_fntype,
1591                                              equal_fntype);
1592   else if (this->array_type() != NULL)
1593     this->array_type()->write_hash_function(gogo, name, hash_fntype,
1594                                             equal_fntype);
1595   else
1596     go_unreachable();
1597
1598   Block* b = gogo->finish_block(bloc);
1599   gogo->add_block(b, bloc);
1600   gogo->lower_block(hash_fn, b);
1601   gogo->finish_function(bloc);
1602
1603   Named_object *equal_fn = gogo->start_function(equal_name, equal_fntype,
1604                                                 false, bloc);
1605   gogo->start_block(bloc);
1606
1607   if (this->struct_type() != NULL)
1608     this->struct_type()->write_equal_function(gogo, name);
1609   else if (this->array_type() != NULL)
1610     this->array_type()->write_equal_function(gogo, name);
1611   else
1612     go_unreachable();
1613
1614   b = gogo->finish_block(bloc);
1615   gogo->add_block(b, bloc);
1616   gogo->lower_block(equal_fn, b);
1617   gogo->finish_function(bloc);
1618 }
1619
1620 // Return a composite literal for the type descriptor for a plain type
1621 // of kind RUNTIME_TYPE_KIND named NAME.
1622
1623 Expression*
1624 Type::type_descriptor_constructor(Gogo* gogo, int runtime_type_kind,
1625                                   Named_type* name, const Methods* methods,
1626                                   bool only_value_methods)
1627 {
1628   Location bloc = Linemap::predeclared_location();
1629
1630   Type* td_type = Type::make_type_descriptor_type();
1631   const Struct_field_list* fields = td_type->struct_type()->fields();
1632
1633   Expression_list* vals = new Expression_list();
1634   vals->reserve(9);
1635
1636   if (!this->has_pointer())
1637     runtime_type_kind |= RUNTIME_TYPE_KIND_NO_POINTERS;
1638   Struct_field_list::const_iterator p = fields->begin();
1639   go_assert(p->is_field_name("Kind"));
1640   mpz_t iv;
1641   mpz_init_set_ui(iv, runtime_type_kind);
1642   vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
1643
1644   ++p;
1645   go_assert(p->is_field_name("align"));
1646   Expression::Type_info type_info = Expression::TYPE_INFO_ALIGNMENT;
1647   vals->push_back(Expression::make_type_info(this, type_info));
1648
1649   ++p;
1650   go_assert(p->is_field_name("fieldAlign"));
1651   type_info = Expression::TYPE_INFO_FIELD_ALIGNMENT;
1652   vals->push_back(Expression::make_type_info(this, type_info));
1653
1654   ++p;
1655   go_assert(p->is_field_name("size"));
1656   type_info = Expression::TYPE_INFO_SIZE;
1657   vals->push_back(Expression::make_type_info(this, type_info));
1658
1659   ++p;
1660   go_assert(p->is_field_name("hash"));
1661   mpz_set_ui(iv, this->hash_for_method(gogo));
1662   vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
1663
1664   ++p;
1665   go_assert(p->is_field_name("hashfn"));
1666   Function_type* hash_fntype = p->type()->function_type();
1667
1668   ++p;
1669   go_assert(p->is_field_name("equalfn"));
1670   Function_type* equal_fntype = p->type()->function_type();
1671
1672   Named_object* hash_fn;
1673   Named_object* equal_fn;
1674   this->type_functions(gogo, name, hash_fntype, equal_fntype, &hash_fn,
1675                        &equal_fn);
1676   vals->push_back(Expression::make_func_reference(hash_fn, NULL, bloc));
1677   vals->push_back(Expression::make_func_reference(equal_fn, NULL, bloc));
1678
1679   ++p;
1680   go_assert(p->is_field_name("string"));
1681   Expression* s = Expression::make_string((name != NULL
1682                                            ? name->reflection(gogo)
1683                                            : this->reflection(gogo)),
1684                                           bloc);
1685   vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1686
1687   ++p;
1688   go_assert(p->is_field_name("uncommonType"));
1689   if (name == NULL && methods == NULL)
1690     vals->push_back(Expression::make_nil(bloc));
1691   else
1692     {
1693       if (methods == NULL)
1694         methods = name->methods();
1695       vals->push_back(this->uncommon_type_constructor(gogo,
1696                                                       p->type()->deref(),
1697                                                       name, methods,
1698                                                       only_value_methods));
1699     }
1700
1701   ++p;
1702   go_assert(p->is_field_name("ptrToThis"));
1703   if (name == NULL)
1704     vals->push_back(Expression::make_nil(bloc));
1705   else
1706     {
1707       Type* pt = Type::make_pointer_type(name);
1708       vals->push_back(Expression::make_type_descriptor(pt, bloc));
1709     }
1710
1711   ++p;
1712   go_assert(p == fields->end());
1713
1714   mpz_clear(iv);
1715
1716   return Expression::make_struct_composite_literal(td_type, vals, bloc);
1717 }
1718
1719 // Return a composite literal for the uncommon type information for
1720 // this type.  UNCOMMON_STRUCT_TYPE is the type of the uncommon type
1721 // struct.  If name is not NULL, it is the name of the type.  If
1722 // METHODS is not NULL, it is the list of methods.  ONLY_VALUE_METHODS
1723 // is true if only value methods should be included.  At least one of
1724 // NAME and METHODS must not be NULL.
1725
1726 Expression*
1727 Type::uncommon_type_constructor(Gogo* gogo, Type* uncommon_type,
1728                                 Named_type* name, const Methods* methods,
1729                                 bool only_value_methods) const
1730 {
1731   Location bloc = Linemap::predeclared_location();
1732
1733   const Struct_field_list* fields = uncommon_type->struct_type()->fields();
1734
1735   Expression_list* vals = new Expression_list();
1736   vals->reserve(3);
1737
1738   Struct_field_list::const_iterator p = fields->begin();
1739   go_assert(p->is_field_name("name"));
1740
1741   ++p;
1742   go_assert(p->is_field_name("pkgPath"));
1743
1744   if (name == NULL)
1745     {
1746       vals->push_back(Expression::make_nil(bloc));
1747       vals->push_back(Expression::make_nil(bloc));
1748     }
1749   else
1750     {
1751       Named_object* no = name->named_object();
1752       std::string n = Gogo::unpack_hidden_name(no->name());
1753       Expression* s = Expression::make_string(n, bloc);
1754       vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1755
1756       if (name->is_builtin())
1757         vals->push_back(Expression::make_nil(bloc));
1758       else
1759         {
1760           const Package* package = no->package();
1761           const std::string& unique_prefix(package == NULL
1762                                            ? gogo->unique_prefix()
1763                                            : package->unique_prefix());
1764           const std::string& package_name(package == NULL
1765                                           ? gogo->package_name()
1766                                           : package->name());
1767           n.assign(unique_prefix);
1768           n.append(1, '.');
1769           n.append(package_name);
1770           if (name->in_function() != NULL)
1771             {
1772               n.append(1, '.');
1773               n.append(Gogo::unpack_hidden_name(name->in_function()->name()));
1774             }
1775           s = Expression::make_string(n, bloc);
1776           vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1777         }
1778     }
1779
1780   ++p;
1781   go_assert(p->is_field_name("methods"));
1782   vals->push_back(this->methods_constructor(gogo, p->type(), methods,
1783                                             only_value_methods));
1784
1785   ++p;
1786   go_assert(p == fields->end());
1787
1788   Expression* r = Expression::make_struct_composite_literal(uncommon_type,
1789                                                             vals, bloc);
1790   return Expression::make_unary(OPERATOR_AND, r, bloc);
1791 }
1792
1793 // Sort methods by name.
1794
1795 class Sort_methods
1796 {
1797  public:
1798   bool
1799   operator()(const std::pair<std::string, const Method*>& m1,
1800              const std::pair<std::string, const Method*>& m2) const
1801   { return m1.first < m2.first; }
1802 };
1803
1804 // Return a composite literal for the type method table for this type.
1805 // METHODS_TYPE is the type of the table, and is a slice type.
1806 // METHODS is the list of methods.  If ONLY_VALUE_METHODS is true,
1807 // then only value methods are used.
1808
1809 Expression*
1810 Type::methods_constructor(Gogo* gogo, Type* methods_type,
1811                           const Methods* methods,
1812                           bool only_value_methods) const
1813 {
1814   Location bloc = Linemap::predeclared_location();
1815
1816   std::vector<std::pair<std::string, const Method*> > smethods;
1817   if (methods != NULL)
1818     {
1819       smethods.reserve(methods->count());
1820       for (Methods::const_iterator p = methods->begin();
1821            p != methods->end();
1822            ++p)
1823         {
1824           if (p->second->is_ambiguous())
1825             continue;
1826           if (only_value_methods && !p->second->is_value_method())
1827             continue;
1828           smethods.push_back(std::make_pair(p->first, p->second));
1829         }
1830     }
1831
1832   if (smethods.empty())
1833     return Expression::make_slice_composite_literal(methods_type, NULL, bloc);
1834
1835   std::sort(smethods.begin(), smethods.end(), Sort_methods());
1836
1837   Type* method_type = methods_type->array_type()->element_type();
1838
1839   Expression_list* vals = new Expression_list();
1840   vals->reserve(smethods.size());
1841   for (std::vector<std::pair<std::string, const Method*> >::const_iterator p
1842          = smethods.begin();
1843        p != smethods.end();
1844        ++p)
1845     vals->push_back(this->method_constructor(gogo, method_type, p->first,
1846                                              p->second, only_value_methods));
1847
1848   return Expression::make_slice_composite_literal(methods_type, vals, bloc);
1849 }
1850
1851 // Return a composite literal for a single method.  METHOD_TYPE is the
1852 // type of the entry.  METHOD_NAME is the name of the method and M is
1853 // the method information.
1854
1855 Expression*
1856 Type::method_constructor(Gogo*, Type* method_type,
1857                          const std::string& method_name,
1858                          const Method* m,
1859                          bool only_value_methods) const
1860 {
1861   Location bloc = Linemap::predeclared_location();
1862
1863   const Struct_field_list* fields = method_type->struct_type()->fields();
1864
1865   Expression_list* vals = new Expression_list();
1866   vals->reserve(5);
1867
1868   Struct_field_list::const_iterator p = fields->begin();
1869   go_assert(p->is_field_name("name"));
1870   const std::string n = Gogo::unpack_hidden_name(method_name);
1871   Expression* s = Expression::make_string(n, bloc);
1872   vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1873
1874   ++p;
1875   go_assert(p->is_field_name("pkgPath"));
1876   if (!Gogo::is_hidden_name(method_name))
1877     vals->push_back(Expression::make_nil(bloc));
1878   else
1879     {
1880       s = Expression::make_string(Gogo::hidden_name_prefix(method_name), bloc);
1881       vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1882     }
1883
1884   Named_object* no = (m->needs_stub_method()
1885                       ? m->stub_object()
1886                       : m->named_object());
1887
1888   Function_type* mtype;
1889   if (no->is_function())
1890     mtype = no->func_value()->type();
1891   else
1892     mtype = no->func_declaration_value()->type();
1893   go_assert(mtype->is_method());
1894   Type* nonmethod_type = mtype->copy_without_receiver();
1895
1896   ++p;
1897   go_assert(p->is_field_name("mtyp"));
1898   vals->push_back(Expression::make_type_descriptor(nonmethod_type, bloc));
1899
1900   ++p;
1901   go_assert(p->is_field_name("typ"));
1902   if (!only_value_methods && m->is_value_method())
1903     {
1904       // This is a value method on a pointer type.  Change the type of
1905       // the method to use a pointer receiver.  The implementation
1906       // always uses a pointer receiver anyhow.
1907       Type* rtype = mtype->receiver()->type();
1908       Type* prtype = Type::make_pointer_type(rtype);
1909       Typed_identifier* receiver =
1910         new Typed_identifier(mtype->receiver()->name(), prtype,
1911                              mtype->receiver()->location());
1912       mtype = Type::make_function_type(receiver,
1913                                        (mtype->parameters() == NULL
1914                                         ? NULL
1915                                         : mtype->parameters()->copy()),
1916                                        (mtype->results() == NULL
1917                                         ? NULL
1918                                         : mtype->results()->copy()),
1919                                        mtype->location());
1920     }
1921   vals->push_back(Expression::make_type_descriptor(mtype, bloc));
1922
1923   ++p;
1924   go_assert(p->is_field_name("tfn"));
1925   vals->push_back(Expression::make_func_reference(no, NULL, bloc));
1926
1927   ++p;
1928   go_assert(p == fields->end());
1929
1930   return Expression::make_struct_composite_literal(method_type, vals, bloc);
1931 }
1932
1933 // Return a composite literal for the type descriptor of a plain type.
1934 // RUNTIME_TYPE_KIND is the value of the kind field.  If NAME is not
1935 // NULL, it is the name to use as well as the list of methods.
1936
1937 Expression*
1938 Type::plain_type_descriptor(Gogo* gogo, int runtime_type_kind,
1939                             Named_type* name)
1940 {
1941   return this->type_descriptor_constructor(gogo, runtime_type_kind,
1942                                            name, NULL, true);
1943 }
1944
1945 // Return the type reflection string for this type.
1946
1947 std::string
1948 Type::reflection(Gogo* gogo) const
1949 {
1950   std::string ret;
1951
1952   // The do_reflection virtual function should set RET to the
1953   // reflection string.
1954   this->do_reflection(gogo, &ret);
1955
1956   return ret;
1957 }
1958
1959 // Return a mangled name for the type.
1960
1961 std::string
1962 Type::mangled_name(Gogo* gogo) const
1963 {
1964   std::string ret;
1965
1966   // The do_mangled_name virtual function should set RET to the
1967   // mangled name.  For a composite type it should append a code for
1968   // the composition and then call do_mangled_name on the components.
1969   this->do_mangled_name(gogo, &ret);
1970
1971   return ret;
1972 }
1973
1974 // Return whether the backend size of the type is known.
1975
1976 bool
1977 Type::is_backend_type_size_known(Gogo* gogo)
1978 {
1979   switch (this->classification_)
1980     {
1981     case TYPE_ERROR:
1982     case TYPE_VOID:
1983     case TYPE_BOOLEAN:
1984     case TYPE_INTEGER:
1985     case TYPE_FLOAT:
1986     case TYPE_COMPLEX:
1987     case TYPE_STRING:
1988     case TYPE_FUNCTION:
1989     case TYPE_POINTER:
1990     case TYPE_NIL:
1991     case TYPE_MAP:
1992     case TYPE_CHANNEL:
1993     case TYPE_INTERFACE:
1994       return true;
1995
1996     case TYPE_STRUCT:
1997       {
1998         const Struct_field_list* fields = this->struct_type()->fields();
1999         for (Struct_field_list::const_iterator pf = fields->begin();
2000              pf != fields->end();
2001              ++pf)
2002           if (!pf->type()->is_backend_type_size_known(gogo))
2003             return false;
2004         return true;
2005       }
2006
2007     case TYPE_ARRAY:
2008       {
2009         const Array_type* at = this->array_type();
2010         if (at->length() == NULL)
2011           return true;
2012         else
2013           {
2014             mpz_t ival;
2015             mpz_init(ival);
2016             Type* dummy;
2017             bool length_known = at->length()->integer_constant_value(true,
2018                                                                      ival,
2019                                                                      &dummy);
2020             mpz_clear(ival);
2021             if (!length_known)
2022               return false;
2023             return at->element_type()->is_backend_type_size_known(gogo);
2024           }
2025       }
2026
2027     case TYPE_NAMED:
2028       // Begin converting this type to the backend representation.
2029       // This will create a placeholder if necessary.
2030       this->get_backend(gogo);
2031       return this->named_type()->is_named_backend_type_size_known();
2032
2033     case TYPE_FORWARD:
2034       {
2035         Forward_declaration_type* fdt = this->forward_declaration_type();
2036         return fdt->real_type()->is_backend_type_size_known(gogo);
2037       }
2038
2039     case TYPE_SINK:
2040     case TYPE_CALL_MULTIPLE_RESULT:
2041       go_unreachable();
2042
2043     default:
2044       go_unreachable();
2045     }
2046 }
2047
2048 // If the size of the type can be determined, set *PSIZE to the size
2049 // in bytes and return true.  Otherwise, return false.  This queries
2050 // the backend.
2051
2052 bool
2053 Type::backend_type_size(Gogo* gogo, unsigned int *psize)
2054 {
2055   if (!this->is_backend_type_size_known(gogo))
2056     return false;
2057   size_t size = gogo->backend()->type_size(this->get_backend(gogo));
2058   *psize = static_cast<unsigned int>(size);
2059   if (*psize != size)
2060     return false;
2061   return true;
2062 }
2063
2064 // If the alignment of the type can be determined, set *PALIGN to
2065 // the alignment in bytes and return true.  Otherwise, return false.
2066
2067 bool
2068 Type::backend_type_align(Gogo* gogo, unsigned int *palign)
2069 {
2070   if (!this->is_backend_type_size_known(gogo))
2071     return false;
2072   size_t align = gogo->backend()->type_alignment(this->get_backend(gogo));
2073   *palign = static_cast<unsigned int>(align);
2074   if (*palign != align)
2075     return false;
2076   return true;
2077 }
2078
2079 // Like backend_type_align, but return the alignment when used as a
2080 // field.
2081
2082 bool
2083 Type::backend_type_field_align(Gogo* gogo, unsigned int *palign)
2084 {
2085   if (!this->is_backend_type_size_known(gogo))
2086     return false;
2087   size_t a = gogo->backend()->type_field_alignment(this->get_backend(gogo));
2088   *palign = static_cast<unsigned int>(a);
2089   if (*palign != a)
2090     return false;
2091   return true;
2092 }
2093
2094 // Default function to export a type.
2095
2096 void
2097 Type::do_export(Export*) const
2098 {
2099   go_unreachable();
2100 }
2101
2102 // Import a type.
2103
2104 Type*
2105 Type::import_type(Import* imp)
2106 {
2107   if (imp->match_c_string("("))
2108     return Function_type::do_import(imp);
2109   else if (imp->match_c_string("*"))
2110     return Pointer_type::do_import(imp);
2111   else if (imp->match_c_string("struct "))
2112     return Struct_type::do_import(imp);
2113   else if (imp->match_c_string("["))
2114     return Array_type::do_import(imp);
2115   else if (imp->match_c_string("map "))
2116     return Map_type::do_import(imp);
2117   else if (imp->match_c_string("chan "))
2118     return Channel_type::do_import(imp);
2119   else if (imp->match_c_string("interface"))
2120     return Interface_type::do_import(imp);
2121   else
2122     {
2123       error_at(imp->location(), "import error: expected type");
2124       return Type::make_error_type();
2125     }
2126 }
2127
2128 // A type used to indicate a parsing error.  This exists to simplify
2129 // later error detection.
2130
2131 class Error_type : public Type
2132 {
2133  public:
2134   Error_type()
2135     : Type(TYPE_ERROR)
2136   { }
2137
2138  protected:
2139   bool
2140   do_compare_is_identity(Gogo*) const
2141   { return false; }
2142
2143   Btype*
2144   do_get_backend(Gogo* gogo)
2145   { return gogo->backend()->error_type(); }
2146
2147   Expression*
2148   do_type_descriptor(Gogo*, Named_type*)
2149   { return Expression::make_error(Linemap::predeclared_location()); }
2150
2151   void
2152   do_reflection(Gogo*, std::string*) const
2153   { go_assert(saw_errors()); }
2154
2155   void
2156   do_mangled_name(Gogo*, std::string* ret) const
2157   { ret->push_back('E'); }
2158 };
2159
2160 Type*
2161 Type::make_error_type()
2162 {
2163   static Error_type singleton_error_type;
2164   return &singleton_error_type;
2165 }
2166
2167 // The void type.
2168
2169 class Void_type : public Type
2170 {
2171  public:
2172   Void_type()
2173     : Type(TYPE_VOID)
2174   { }
2175
2176  protected:
2177   bool
2178   do_compare_is_identity(Gogo*) const
2179   { return false; }
2180
2181   Btype*
2182   do_get_backend(Gogo* gogo)
2183   { return gogo->backend()->void_type(); }
2184
2185   Expression*
2186   do_type_descriptor(Gogo*, Named_type*)
2187   { go_unreachable(); }
2188
2189   void
2190   do_reflection(Gogo*, std::string*) const
2191   { }
2192
2193   void
2194   do_mangled_name(Gogo*, std::string* ret) const
2195   { ret->push_back('v'); }
2196 };
2197
2198 Type*
2199 Type::make_void_type()
2200 {
2201   static Void_type singleton_void_type;
2202   return &singleton_void_type;
2203 }
2204
2205 // The boolean type.
2206
2207 class Boolean_type : public Type
2208 {
2209  public:
2210   Boolean_type()
2211     : Type(TYPE_BOOLEAN)
2212   { }
2213
2214  protected:
2215   bool
2216   do_compare_is_identity(Gogo*) const
2217   { return true; }
2218
2219   Btype*
2220   do_get_backend(Gogo* gogo)
2221   { return gogo->backend()->bool_type(); }
2222
2223   Expression*
2224   do_type_descriptor(Gogo*, Named_type* name);
2225
2226   // We should not be asked for the reflection string of a basic type.
2227   void
2228   do_reflection(Gogo*, std::string* ret) const
2229   { ret->append("bool"); }
2230
2231   void
2232   do_mangled_name(Gogo*, std::string* ret) const
2233   { ret->push_back('b'); }
2234 };
2235
2236 // Make the type descriptor.
2237
2238 Expression*
2239 Boolean_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2240 {
2241   if (name != NULL)
2242     return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_BOOL, name);
2243   else
2244     {
2245       Named_object* no = gogo->lookup_global("bool");
2246       go_assert(no != NULL);
2247       return Type::type_descriptor(gogo, no->type_value());
2248     }
2249 }
2250
2251 Type*
2252 Type::make_boolean_type()
2253 {
2254   static Boolean_type boolean_type;
2255   return &boolean_type;
2256 }
2257
2258 // The named type "bool".
2259
2260 static Named_type* named_bool_type;
2261
2262 // Get the named type "bool".
2263
2264 Named_type*
2265 Type::lookup_bool_type()
2266 {
2267   return named_bool_type;
2268 }
2269
2270 // Make the named type "bool".
2271
2272 Named_type*
2273 Type::make_named_bool_type()
2274 {
2275   Type* bool_type = Type::make_boolean_type();
2276   Named_object* named_object =
2277     Named_object::make_type("bool", NULL, bool_type,
2278                             Linemap::predeclared_location());
2279   Named_type* named_type = named_object->type_value();
2280   named_bool_type = named_type;
2281   return named_type;
2282 }
2283
2284 // Class Integer_type.
2285
2286 Integer_type::Named_integer_types Integer_type::named_integer_types;
2287
2288 // Create a new integer type.  Non-abstract integer types always have
2289 // names.
2290
2291 Named_type*
2292 Integer_type::create_integer_type(const char* name, bool is_unsigned,
2293                                   int bits, int runtime_type_kind)
2294 {
2295   Integer_type* integer_type = new Integer_type(false, is_unsigned, bits,
2296                                                 runtime_type_kind);
2297   std::string sname(name);
2298   Named_object* named_object =
2299     Named_object::make_type(sname, NULL, integer_type,
2300                             Linemap::predeclared_location());
2301   Named_type* named_type = named_object->type_value();
2302   std::pair<Named_integer_types::iterator, bool> ins =
2303     Integer_type::named_integer_types.insert(std::make_pair(sname, named_type));
2304   go_assert(ins.second);
2305   return named_type;
2306 }
2307
2308 // Look up an existing integer type.
2309
2310 Named_type*
2311 Integer_type::lookup_integer_type(const char* name)
2312 {
2313   Named_integer_types::const_iterator p =
2314     Integer_type::named_integer_types.find(name);
2315   go_assert(p != Integer_type::named_integer_types.end());
2316   return p->second;
2317 }
2318
2319 // Create a new abstract integer type.
2320
2321 Integer_type*
2322 Integer_type::create_abstract_integer_type()
2323 {
2324   static Integer_type* abstract_type;
2325   if (abstract_type == NULL)
2326     abstract_type = new Integer_type(true, false, INT_TYPE_SIZE,
2327                                      RUNTIME_TYPE_KIND_INT);
2328   return abstract_type;
2329 }
2330
2331 // Create a new abstract character type.
2332
2333 Integer_type*
2334 Integer_type::create_abstract_character_type()
2335 {
2336   static Integer_type* abstract_type;
2337   if (abstract_type == NULL)
2338     {
2339       abstract_type = new Integer_type(true, false, 32,
2340                                        RUNTIME_TYPE_KIND_INT32);
2341       abstract_type->set_is_rune();
2342     }
2343   return abstract_type;
2344 }
2345
2346 // Integer type compatibility.
2347
2348 bool
2349 Integer_type::is_identical(const Integer_type* t) const
2350 {
2351   if (this->is_unsigned_ != t->is_unsigned_ || this->bits_ != t->bits_)
2352     return false;
2353   return this->is_abstract_ == t->is_abstract_;
2354 }
2355
2356 // Hash code.
2357
2358 unsigned int
2359 Integer_type::do_hash_for_method(Gogo*) const
2360 {
2361   return ((this->bits_ << 4)
2362           + ((this->is_unsigned_ ? 1 : 0) << 8)
2363           + ((this->is_abstract_ ? 1 : 0) << 9));
2364 }
2365
2366 // Convert an Integer_type to the backend representation.
2367
2368 Btype*
2369 Integer_type::do_get_backend(Gogo* gogo)
2370 {
2371   if (this->is_abstract_)
2372     {
2373       go_assert(saw_errors());
2374       return gogo->backend()->error_type();
2375     }
2376   return gogo->backend()->integer_type(this->is_unsigned_, this->bits_);
2377 }
2378
2379 // The type descriptor for an integer type.  Integer types are always
2380 // named.
2381
2382 Expression*
2383 Integer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2384 {
2385   go_assert(name != NULL);
2386   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2387 }
2388
2389 // We should not be asked for the reflection string of a basic type.
2390
2391 void
2392 Integer_type::do_reflection(Gogo*, std::string*) const
2393 {
2394   go_assert(saw_errors());
2395 }
2396
2397 // Mangled name.
2398
2399 void
2400 Integer_type::do_mangled_name(Gogo*, std::string* ret) const
2401 {
2402   char buf[100];
2403   snprintf(buf, sizeof buf, "i%s%s%de",
2404            this->is_abstract_ ? "a" : "",
2405            this->is_unsigned_ ? "u" : "",
2406            this->bits_);
2407   ret->append(buf);
2408 }
2409
2410 // Make an integer type.
2411
2412 Named_type*
2413 Type::make_integer_type(const char* name, bool is_unsigned, int bits,
2414                         int runtime_type_kind)
2415 {
2416   return Integer_type::create_integer_type(name, is_unsigned, bits,
2417                                            runtime_type_kind);
2418 }
2419
2420 // Make an abstract integer type.
2421
2422 Integer_type*
2423 Type::make_abstract_integer_type()
2424 {
2425   return Integer_type::create_abstract_integer_type();
2426 }
2427
2428 // Make an abstract character type.
2429
2430 Integer_type*
2431 Type::make_abstract_character_type()
2432 {
2433   return Integer_type::create_abstract_character_type();
2434 }
2435
2436 // Look up an integer type.
2437
2438 Named_type*
2439 Type::lookup_integer_type(const char* name)
2440 {
2441   return Integer_type::lookup_integer_type(name);
2442 }
2443
2444 // Class Float_type.
2445
2446 Float_type::Named_float_types Float_type::named_float_types;
2447
2448 // Create a new float type.  Non-abstract float types always have
2449 // names.
2450
2451 Named_type*
2452 Float_type::create_float_type(const char* name, int bits,
2453                               int runtime_type_kind)
2454 {
2455   Float_type* float_type = new Float_type(false, bits, runtime_type_kind);
2456   std::string sname(name);
2457   Named_object* named_object =
2458     Named_object::make_type(sname, NULL, float_type,
2459                             Linemap::predeclared_location());
2460   Named_type* named_type = named_object->type_value();
2461   std::pair<Named_float_types::iterator, bool> ins =
2462     Float_type::named_float_types.insert(std::make_pair(sname, named_type));
2463   go_assert(ins.second);
2464   return named_type;
2465 }
2466
2467 // Look up an existing float type.
2468
2469 Named_type*
2470 Float_type::lookup_float_type(const char* name)
2471 {
2472   Named_float_types::const_iterator p =
2473     Float_type::named_float_types.find(name);
2474   go_assert(p != Float_type::named_float_types.end());
2475   return p->second;
2476 }
2477
2478 // Create a new abstract float type.
2479
2480 Float_type*
2481 Float_type::create_abstract_float_type()
2482 {
2483   static Float_type* abstract_type;
2484   if (abstract_type == NULL)
2485     abstract_type = new Float_type(true, 64, RUNTIME_TYPE_KIND_FLOAT64);
2486   return abstract_type;
2487 }
2488
2489 // Whether this type is identical with T.
2490
2491 bool
2492 Float_type::is_identical(const Float_type* t) const
2493 {
2494   if (this->bits_ != t->bits_)
2495     return false;
2496   return this->is_abstract_ == t->is_abstract_;
2497 }
2498
2499 // Hash code.
2500
2501 unsigned int
2502 Float_type::do_hash_for_method(Gogo*) const
2503 {
2504   return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
2505 }
2506
2507 // Convert to the backend representation.
2508
2509 Btype*
2510 Float_type::do_get_backend(Gogo* gogo)
2511 {
2512   return gogo->backend()->float_type(this->bits_);
2513 }
2514
2515 // The type descriptor for a float type.  Float types are always named.
2516
2517 Expression*
2518 Float_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2519 {
2520   go_assert(name != NULL);
2521   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2522 }
2523
2524 // We should not be asked for the reflection string of a basic type.
2525
2526 void
2527 Float_type::do_reflection(Gogo*, std::string*) const
2528 {
2529   go_assert(saw_errors());
2530 }
2531
2532 // Mangled name.
2533
2534 void
2535 Float_type::do_mangled_name(Gogo*, std::string* ret) const
2536 {
2537   char buf[100];
2538   snprintf(buf, sizeof buf, "f%s%de",
2539            this->is_abstract_ ? "a" : "",
2540            this->bits_);
2541   ret->append(buf);
2542 }
2543
2544 // Make a floating point type.
2545
2546 Named_type*
2547 Type::make_float_type(const char* name, int bits, int runtime_type_kind)
2548 {
2549   return Float_type::create_float_type(name, bits, runtime_type_kind);
2550 }
2551
2552 // Make an abstract float type.
2553
2554 Float_type*
2555 Type::make_abstract_float_type()
2556 {
2557   return Float_type::create_abstract_float_type();
2558 }
2559
2560 // Look up a float type.
2561
2562 Named_type*
2563 Type::lookup_float_type(const char* name)
2564 {
2565   return Float_type::lookup_float_type(name);
2566 }
2567
2568 // Class Complex_type.
2569
2570 Complex_type::Named_complex_types Complex_type::named_complex_types;
2571
2572 // Create a new complex type.  Non-abstract complex types always have
2573 // names.
2574
2575 Named_type*
2576 Complex_type::create_complex_type(const char* name, int bits,
2577                                   int runtime_type_kind)
2578 {
2579   Complex_type* complex_type = new Complex_type(false, bits,
2580                                                 runtime_type_kind);
2581   std::string sname(name);
2582   Named_object* named_object =
2583     Named_object::make_type(sname, NULL, complex_type,
2584                             Linemap::predeclared_location());
2585   Named_type* named_type = named_object->type_value();
2586   std::pair<Named_complex_types::iterator, bool> ins =
2587     Complex_type::named_complex_types.insert(std::make_pair(sname,
2588                                                             named_type));
2589   go_assert(ins.second);
2590   return named_type;
2591 }
2592
2593 // Look up an existing complex type.
2594
2595 Named_type*
2596 Complex_type::lookup_complex_type(const char* name)
2597 {
2598   Named_complex_types::const_iterator p =
2599     Complex_type::named_complex_types.find(name);
2600   go_assert(p != Complex_type::named_complex_types.end());
2601   return p->second;
2602 }
2603
2604 // Create a new abstract complex type.
2605
2606 Complex_type*
2607 Complex_type::create_abstract_complex_type()
2608 {
2609   static Complex_type* abstract_type;
2610   if (abstract_type == NULL)
2611     abstract_type = new Complex_type(true, 128, RUNTIME_TYPE_KIND_COMPLEX128);
2612   return abstract_type;
2613 }
2614
2615 // Whether this type is identical with T.
2616
2617 bool
2618 Complex_type::is_identical(const Complex_type *t) const
2619 {
2620   if (this->bits_ != t->bits_)
2621     return false;
2622   return this->is_abstract_ == t->is_abstract_;
2623 }
2624
2625 // Hash code.
2626
2627 unsigned int
2628 Complex_type::do_hash_for_method(Gogo*) const
2629 {
2630   return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
2631 }
2632
2633 // Convert to the backend representation.
2634
2635 Btype*
2636 Complex_type::do_get_backend(Gogo* gogo)
2637 {
2638   return gogo->backend()->complex_type(this->bits_);
2639 }
2640
2641 // The type descriptor for a complex type.  Complex types are always
2642 // named.
2643
2644 Expression*
2645 Complex_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2646 {
2647   go_assert(name != NULL);
2648   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2649 }
2650
2651 // We should not be asked for the reflection string of a basic type.
2652
2653 void
2654 Complex_type::do_reflection(Gogo*, std::string*) const
2655 {
2656   go_assert(saw_errors());
2657 }
2658
2659 // Mangled name.
2660
2661 void
2662 Complex_type::do_mangled_name(Gogo*, std::string* ret) const
2663 {
2664   char buf[100];
2665   snprintf(buf, sizeof buf, "c%s%de",
2666            this->is_abstract_ ? "a" : "",
2667            this->bits_);
2668   ret->append(buf);
2669 }
2670
2671 // Make a complex type.
2672
2673 Named_type*
2674 Type::make_complex_type(const char* name, int bits, int runtime_type_kind)
2675 {
2676   return Complex_type::create_complex_type(name, bits, runtime_type_kind);
2677 }
2678
2679 // Make an abstract complex type.
2680
2681 Complex_type*
2682 Type::make_abstract_complex_type()
2683 {
2684   return Complex_type::create_abstract_complex_type();
2685 }
2686
2687 // Look up a complex type.
2688
2689 Named_type*
2690 Type::lookup_complex_type(const char* name)
2691 {
2692   return Complex_type::lookup_complex_type(name);
2693 }
2694
2695 // Class String_type.
2696
2697 // Convert String_type to the backend representation.  A string is a
2698 // struct with two fields: a pointer to the characters and a length.
2699
2700 Btype*
2701 String_type::do_get_backend(Gogo* gogo)
2702 {
2703   static Btype* backend_string_type;
2704   if (backend_string_type == NULL)
2705     {
2706       std::vector<Backend::Btyped_identifier> fields(2);
2707
2708       Type* b = gogo->lookup_global("byte")->type_value();
2709       Type* pb = Type::make_pointer_type(b);
2710       fields[0].name = "__data";
2711       fields[0].btype = pb->get_backend(gogo);
2712       fields[0].location = Linemap::predeclared_location();
2713
2714       Type* int_type = Type::lookup_integer_type("int");
2715       fields[1].name = "__length";
2716       fields[1].btype = int_type->get_backend(gogo);
2717       fields[1].location = fields[0].location;
2718
2719       backend_string_type = gogo->backend()->struct_type(fields);
2720     }
2721   return backend_string_type;
2722 }
2723
2724 // Return a tree for the length of STRING.
2725
2726 tree
2727 String_type::length_tree(Gogo*, tree string)
2728 {
2729   tree string_type = TREE_TYPE(string);
2730   go_assert(TREE_CODE(string_type) == RECORD_TYPE);
2731   tree length_field = DECL_CHAIN(TYPE_FIELDS(string_type));
2732   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(length_field)),
2733                     "__length") == 0);
2734   return fold_build3(COMPONENT_REF, integer_type_node, string,
2735                      length_field, NULL_TREE);
2736 }
2737
2738 // Return a tree for a pointer to the bytes of STRING.
2739
2740 tree
2741 String_type::bytes_tree(Gogo*, tree string)
2742 {
2743   tree string_type = TREE_TYPE(string);
2744   go_assert(TREE_CODE(string_type) == RECORD_TYPE);
2745   tree bytes_field = TYPE_FIELDS(string_type);
2746   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(bytes_field)),
2747                     "__data") == 0);
2748   return fold_build3(COMPONENT_REF, TREE_TYPE(bytes_field), string,
2749                      bytes_field, NULL_TREE);
2750 }
2751
2752 // The type descriptor for the string type.
2753
2754 Expression*
2755 String_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2756 {
2757   if (name != NULL)
2758     return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_STRING, name);
2759   else
2760     {
2761       Named_object* no = gogo->lookup_global("string");
2762       go_assert(no != NULL);
2763       return Type::type_descriptor(gogo, no->type_value());
2764     }
2765 }
2766
2767 // We should not be asked for the reflection string of a basic type.
2768
2769 void
2770 String_type::do_reflection(Gogo*, std::string* ret) const
2771 {
2772   ret->append("string");
2773 }
2774
2775 // Mangled name of a string type.
2776
2777 void
2778 String_type::do_mangled_name(Gogo*, std::string* ret) const
2779 {
2780   ret->push_back('z');
2781 }
2782
2783 // Make a string type.
2784
2785 Type*
2786 Type::make_string_type()
2787 {
2788   static String_type string_type;
2789   return &string_type;
2790 }
2791
2792 // The named type "string".
2793
2794 static Named_type* named_string_type;
2795
2796 // Get the named type "string".
2797
2798 Named_type*
2799 Type::lookup_string_type()
2800 {
2801   return named_string_type;
2802 }
2803
2804 // Make the named type string.
2805
2806 Named_type*
2807 Type::make_named_string_type()
2808 {
2809   Type* string_type = Type::make_string_type();
2810   Named_object* named_object =
2811     Named_object::make_type("string", NULL, string_type,
2812                             Linemap::predeclared_location());
2813   Named_type* named_type = named_object->type_value();
2814   named_string_type = named_type;
2815   return named_type;
2816 }
2817
2818 // The sink type.  This is the type of the blank identifier _.  Any
2819 // type may be assigned to it.
2820
2821 class Sink_type : public Type
2822 {
2823  public:
2824   Sink_type()
2825     : Type(TYPE_SINK)
2826   { }
2827
2828  protected:
2829   bool
2830   do_compare_is_identity(Gogo*) const
2831   { return false; }
2832
2833   Btype*
2834   do_get_backend(Gogo*)
2835   { go_unreachable(); }
2836
2837   Expression*
2838   do_type_descriptor(Gogo*, Named_type*)
2839   { go_unreachable(); }
2840
2841   void
2842   do_reflection(Gogo*, std::string*) const
2843   { go_unreachable(); }
2844
2845   void
2846   do_mangled_name(Gogo*, std::string*) const
2847   { go_unreachable(); }
2848 };
2849
2850 // Make the sink type.
2851
2852 Type*
2853 Type::make_sink_type()
2854 {
2855   static Sink_type sink_type;
2856   return &sink_type;
2857 }
2858
2859 // Class Function_type.
2860
2861 // Traversal.
2862
2863 int
2864 Function_type::do_traverse(Traverse* traverse)
2865 {
2866   if (this->receiver_ != NULL
2867       && Type::traverse(this->receiver_->type(), traverse) == TRAVERSE_EXIT)
2868     return TRAVERSE_EXIT;
2869   if (this->parameters_ != NULL
2870       && this->parameters_->traverse(traverse) == TRAVERSE_EXIT)
2871     return TRAVERSE_EXIT;
2872   if (this->results_ != NULL
2873       && this->results_->traverse(traverse) == TRAVERSE_EXIT)
2874     return TRAVERSE_EXIT;
2875   return TRAVERSE_CONTINUE;
2876 }
2877
2878 // Returns whether T is a valid redeclaration of this type.  If this
2879 // returns false, and REASON is not NULL, *REASON may be set to a
2880 // brief explanation of why it returned false.
2881
2882 bool
2883 Function_type::is_valid_redeclaration(const Function_type* t,
2884                                       std::string* reason) const
2885 {
2886   if (!this->is_identical(t, false, true, reason))
2887     return false;
2888
2889   // A redeclaration of a function is required to use the same names
2890   // for the receiver and parameters.
2891   if (this->receiver() != NULL
2892       && this->receiver()->name() != t->receiver()->name()
2893       && this->receiver()->name() != Import::import_marker
2894       && t->receiver()->name() != Import::import_marker)
2895     {
2896       if (reason != NULL)
2897         *reason = "receiver name changed";
2898       return false;
2899     }
2900
2901   const Typed_identifier_list* parms1 = this->parameters();
2902   const Typed_identifier_list* parms2 = t->parameters();
2903   if (parms1 != NULL)
2904     {
2905       Typed_identifier_list::const_iterator p1 = parms1->begin();
2906       for (Typed_identifier_list::const_iterator p2 = parms2->begin();
2907            p2 != parms2->end();
2908            ++p2, ++p1)
2909         {
2910           if (p1->name() != p2->name()
2911               && p1->name() != Import::import_marker
2912               && p2->name() != Import::import_marker)
2913             {
2914               if (reason != NULL)
2915                 *reason = "parameter name changed";
2916               return false;
2917             }
2918
2919           // This is called at parse time, so we may have unknown
2920           // types.
2921           Type* t1 = p1->type()->forwarded();
2922           Type* t2 = p2->type()->forwarded();
2923           if (t1 != t2
2924               && t1->forward_declaration_type() != NULL
2925               && (t2->forward_declaration_type() == NULL
2926                   || (t1->forward_declaration_type()->named_object()
2927                       != t2->forward_declaration_type()->named_object())))
2928             return false;
2929         }
2930     }
2931
2932   const Typed_identifier_list* results1 = this->results();
2933   const Typed_identifier_list* results2 = t->results();
2934   if (results1 != NULL)
2935     {
2936       Typed_identifier_list::const_iterator res1 = results1->begin();
2937       for (Typed_identifier_list::const_iterator res2 = results2->begin();
2938            res2 != results2->end();
2939            ++res2, ++res1)
2940         {
2941           if (res1->name() != res2->name()
2942               && res1->name() != Import::import_marker
2943               && res2->name() != Import::import_marker)
2944             {
2945               if (reason != NULL)
2946                 *reason = "result name changed";
2947               return false;
2948             }
2949
2950           // This is called at parse time, so we may have unknown
2951           // types.
2952           Type* t1 = res1->type()->forwarded();
2953           Type* t2 = res2->type()->forwarded();
2954           if (t1 != t2
2955               && t1->forward_declaration_type() != NULL
2956               && (t2->forward_declaration_type() == NULL
2957                   || (t1->forward_declaration_type()->named_object()
2958                       != t2->forward_declaration_type()->named_object())))
2959             return false;
2960         }
2961     }
2962
2963   return true;
2964 }
2965
2966 // Check whether T is the same as this type.
2967
2968 bool
2969 Function_type::is_identical(const Function_type* t, bool ignore_receiver,
2970                             bool errors_are_identical,
2971                             std::string* reason) const
2972 {
2973   if (!ignore_receiver)
2974     {
2975       const Typed_identifier* r1 = this->receiver();
2976       const Typed_identifier* r2 = t->receiver();
2977       if ((r1 != NULL) != (r2 != NULL))
2978         {
2979           if (reason != NULL)
2980             *reason = _("different receiver types");
2981           return false;
2982         }
2983       if (r1 != NULL)
2984         {
2985           if (!Type::are_identical(r1->type(), r2->type(), errors_are_identical,
2986                                    reason))
2987             {
2988               if (reason != NULL && !reason->empty())
2989                 *reason = "receiver: " + *reason;
2990               return false;
2991             }
2992         }
2993     }
2994
2995   const Typed_identifier_list* parms1 = this->parameters();
2996   const Typed_identifier_list* parms2 = t->parameters();
2997   if ((parms1 != NULL) != (parms2 != NULL))
2998     {
2999       if (reason != NULL)
3000         *reason = _("different number of parameters");
3001       return false;
3002     }
3003   if (parms1 != NULL)
3004     {
3005       Typed_identifier_list::const_iterator p1 = parms1->begin();
3006       for (Typed_identifier_list::const_iterator p2 = parms2->begin();
3007            p2 != parms2->end();
3008            ++p2, ++p1)
3009         {
3010           if (p1 == parms1->end())
3011             {
3012               if (reason != NULL)
3013                 *reason = _("different number of parameters");
3014               return false;
3015             }
3016
3017           if (!Type::are_identical(p1->type(), p2->type(),
3018                                    errors_are_identical, NULL))
3019             {
3020               if (reason != NULL)
3021                 *reason = _("different parameter types");
3022               return false;
3023             }
3024         }
3025       if (p1 != parms1->end())
3026         {
3027           if (reason != NULL)
3028             *reason = _("different number of parameters");
3029         return false;
3030         }
3031     }
3032
3033   if (this->is_varargs() != t->is_varargs())
3034     {
3035       if (reason != NULL)
3036         *reason = _("different varargs");
3037       return false;
3038     }
3039
3040   const Typed_identifier_list* results1 = this->results();
3041   const Typed_identifier_list* results2 = t->results();
3042   if ((results1 != NULL) != (results2 != NULL))
3043     {
3044       if (reason != NULL)
3045         *reason = _("different number of results");
3046       return false;
3047     }
3048   if (results1 != NULL)
3049     {
3050       Typed_identifier_list::const_iterator res1 = results1->begin();
3051       for (Typed_identifier_list::const_iterator res2 = results2->begin();
3052            res2 != results2->end();
3053            ++res2, ++res1)
3054         {
3055           if (res1 == results1->end())
3056             {
3057               if (reason != NULL)
3058                 *reason = _("different number of results");
3059               return false;
3060             }
3061
3062           if (!Type::are_identical(res1->type(), res2->type(),
3063                                    errors_are_identical, NULL))
3064             {
3065               if (reason != NULL)
3066                 *reason = _("different result types");
3067               return false;
3068             }
3069         }
3070       if (res1 != results1->end())
3071         {
3072           if (reason != NULL)
3073             *reason = _("different number of results");
3074           return false;
3075         }
3076     }
3077
3078   return true;
3079 }
3080
3081 // Hash code.
3082
3083 unsigned int
3084 Function_type::do_hash_for_method(Gogo* gogo) const
3085 {
3086   unsigned int ret = 0;
3087   // We ignore the receiver type for hash codes, because we need to
3088   // get the same hash code for a method in an interface and a method
3089   // declared for a type.  The former will not have a receiver.
3090   if (this->parameters_ != NULL)
3091     {
3092       int shift = 1;
3093       for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
3094            p != this->parameters_->end();
3095            ++p, ++shift)
3096         ret += p->type()->hash_for_method(gogo) << shift;
3097     }
3098   if (this->results_ != NULL)
3099     {
3100       int shift = 2;
3101       for (Typed_identifier_list::const_iterator p = this->results_->begin();
3102            p != this->results_->end();
3103            ++p, ++shift)
3104         ret += p->type()->hash_for_method(gogo) << shift;
3105     }
3106   if (this->is_varargs_)
3107     ret += 1;
3108   ret <<= 4;
3109   return ret;
3110 }
3111
3112 // Get the backend representation for a function type.
3113
3114 Btype*
3115 Function_type::get_function_backend(Gogo* gogo)
3116 {
3117   Backend::Btyped_identifier breceiver;
3118   if (this->receiver_ != NULL)
3119     {
3120       breceiver.name = Gogo::unpack_hidden_name(this->receiver_->name());
3121
3122       // We always pass the address of the receiver parameter, in
3123       // order to make interface calls work with unknown types.
3124       Type* rtype = this->receiver_->type();
3125       if (rtype->points_to() == NULL)
3126         rtype = Type::make_pointer_type(rtype);
3127       breceiver.btype = rtype->get_backend(gogo);
3128       breceiver.location = this->receiver_->location();
3129     }
3130
3131   std::vector<Backend::Btyped_identifier> bparameters;
3132   if (this->parameters_ != NULL)
3133     {
3134       bparameters.resize(this->parameters_->size());
3135       size_t i = 0;
3136       for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
3137            p != this->parameters_->end();
3138            ++p, ++i)
3139         {
3140           bparameters[i].name = Gogo::unpack_hidden_name(p->name());
3141           bparameters[i].btype = p->type()->get_backend(gogo);
3142           bparameters[i].location = p->location();
3143         }
3144       go_assert(i == bparameters.size());
3145     }
3146
3147   std::vector<Backend::Btyped_identifier> bresults;
3148   if (this->results_ != NULL)
3149     {
3150       bresults.resize(this->results_->size());
3151       size_t i = 0;
3152       for (Typed_identifier_list::const_iterator p = this->results_->begin();
3153            p != this->results_->end();
3154            ++p, ++i)
3155         {
3156           bresults[i].name = Gogo::unpack_hidden_name(p->name());
3157           bresults[i].btype = p->type()->get_backend(gogo);
3158           bresults[i].location = p->location();
3159         }
3160       go_assert(i == bresults.size());
3161     }
3162
3163   return gogo->backend()->function_type(breceiver, bparameters, bresults,
3164                                         this->location());
3165 }
3166
3167 // A hash table mapping function types to their backend placeholders.
3168
3169 Function_type::Placeholders Function_type::placeholders;
3170
3171 // Get the backend representation for a function type.  If we are
3172 // still converting types, and this types has multiple results, return
3173 // a placeholder instead.  We do this because for multiple results we
3174 // build a struct, and we need to make sure that all the types in the
3175 // struct are valid before we create the struct.
3176
3177 Btype*
3178 Function_type::do_get_backend(Gogo* gogo)
3179 {
3180   if (!gogo->named_types_are_converted()
3181       && this->results_ != NULL
3182       && this->results_->size() > 1)
3183     {
3184       Btype* placeholder =
3185         gogo->backend()->placeholder_pointer_type("", this->location(), true);
3186       Function_type::placeholders.push_back(std::make_pair(this, placeholder));
3187       return placeholder;
3188     }
3189   return this->get_function_backend(gogo);
3190 }
3191
3192 // Convert function types after all named types are converted.
3193
3194 void
3195 Function_type::convert_types(Gogo* gogo)
3196 {
3197   for (Placeholders::const_iterator p = Function_type::placeholders.begin();
3198        p != Function_type::placeholders.end();
3199        ++p)
3200     {
3201       Btype* bt = p->first->get_function_backend(gogo);
3202       if (!gogo->backend()->set_placeholder_function_type(p->second, bt))
3203         go_assert(saw_errors());
3204     }
3205 }
3206
3207 // The type of a function type descriptor.
3208
3209 Type*
3210 Function_type::make_function_type_descriptor_type()
3211 {
3212   static Type* ret;
3213   if (ret == NULL)
3214     {
3215       Type* tdt = Type::make_type_descriptor_type();
3216       Type* ptdt = Type::make_type_descriptor_ptr_type();
3217
3218       Type* bool_type = Type::lookup_bool_type();
3219
3220       Type* slice_type = Type::make_array_type(ptdt, NULL);
3221
3222       Struct_type* s = Type::make_builtin_struct_type(4,
3223                                                       "", tdt,
3224                                                       "dotdotdot", bool_type,
3225                                                       "in", slice_type,
3226                                                       "out", slice_type);
3227
3228       ret = Type::make_builtin_named_type("FuncType", s);
3229     }
3230
3231   return ret;
3232 }
3233
3234 // The type descriptor for a function type.
3235
3236 Expression*
3237 Function_type::do_type_descriptor(Gogo* gogo, Named_type* name)
3238 {
3239   Location bloc = Linemap::predeclared_location();
3240
3241   Type* ftdt = Function_type::make_function_type_descriptor_type();
3242
3243   const Struct_field_list* fields = ftdt->struct_type()->fields();
3244
3245   Expression_list* vals = new Expression_list();
3246   vals->reserve(4);
3247
3248   Struct_field_list::const_iterator p = fields->begin();
3249   go_assert(p->is_field_name("commonType"));
3250   vals->push_back(this->type_descriptor_constructor(gogo,
3251                                                     RUNTIME_TYPE_KIND_FUNC,
3252                                                     name, NULL, true));
3253
3254   ++p;
3255   go_assert(p->is_field_name("dotdotdot"));
3256   vals->push_back(Expression::make_boolean(this->is_varargs(), bloc));
3257
3258   ++p;
3259   go_assert(p->is_field_name("in"));
3260   vals->push_back(this->type_descriptor_params(p->type(), this->receiver(),
3261                                                this->parameters()));
3262
3263   ++p;
3264   go_assert(p->is_field_name("out"));
3265   vals->push_back(this->type_descriptor_params(p->type(), NULL,
3266                                                this->results()));
3267
3268   ++p;
3269   go_assert(p == fields->end());
3270
3271   return Expression::make_struct_composite_literal(ftdt, vals, bloc);
3272 }
3273
3274 // Return a composite literal for the parameters or results of a type
3275 // descriptor.
3276
3277 Expression*
3278 Function_type::type_descriptor_params(Type* params_type,
3279                                       const Typed_identifier* receiver,
3280                                       const Typed_identifier_list* params)
3281 {
3282   Location bloc = Linemap::predeclared_location();
3283
3284   if (receiver == NULL && params == NULL)
3285     return Expression::make_slice_composite_literal(params_type, NULL, bloc);
3286
3287   Expression_list* vals = new Expression_list();
3288   vals->reserve((params == NULL ? 0 : params->size())
3289                 + (receiver != NULL ? 1 : 0));
3290
3291   if (receiver != NULL)
3292     vals->push_back(Expression::make_type_descriptor(receiver->type(), bloc));
3293
3294   if (params != NULL)
3295     {
3296       for (Typed_identifier_list::const_iterator p = params->begin();
3297            p != params->end();
3298            ++p)
3299         vals->push_back(Expression::make_type_descriptor(p->type(), bloc));
3300     }
3301
3302   return Expression::make_slice_composite_literal(params_type, vals, bloc);
3303 }
3304
3305 // The reflection string.
3306
3307 void
3308 Function_type::do_reflection(Gogo* gogo, std::string* ret) const
3309 {
3310   // FIXME: Turn this off until we straighten out the type of the
3311   // struct field used in a go statement which calls a method.
3312   // go_assert(this->receiver_ == NULL);
3313
3314   ret->append("func");
3315
3316   if (this->receiver_ != NULL)
3317     {
3318       ret->push_back('(');
3319       this->append_reflection(this->receiver_->type(), gogo, ret);
3320       ret->push_back(')');
3321     }
3322
3323   ret->push_back('(');
3324   const Typed_identifier_list* params = this->parameters();
3325   if (params != NULL)
3326     {
3327       bool is_varargs = this->is_varargs_;
3328       for (Typed_identifier_list::const_iterator p = params->begin();
3329            p != params->end();
3330            ++p)
3331         {
3332           if (p != params->begin())
3333             ret->append(", ");
3334           if (!is_varargs || p + 1 != params->end())
3335             this->append_reflection(p->type(), gogo, ret);
3336           else
3337             {
3338               ret->append("...");
3339               this->append_reflection(p->type()->array_type()->element_type(),
3340                                       gogo, ret);
3341             }
3342         }
3343     }
3344   ret->push_back(')');
3345
3346   const Typed_identifier_list* results = this->results();
3347   if (results != NULL && !results->empty())
3348     {
3349       if (results->size() == 1)
3350         ret->push_back(' ');
3351       else
3352         ret->append(" (");
3353       for (Typed_identifier_list::const_iterator p = results->begin();
3354            p != results->end();
3355            ++p)
3356         {
3357           if (p != results->begin())
3358             ret->append(", ");
3359           this->append_reflection(p->type(), gogo, ret);
3360         }
3361       if (results->size() > 1)
3362         ret->push_back(')');
3363     }
3364 }
3365
3366 // Mangled name.
3367
3368 void
3369 Function_type::do_mangled_name(Gogo* gogo, std::string* ret) const
3370 {
3371   ret->push_back('F');
3372
3373   if (this->receiver_ != NULL)
3374     {
3375       ret->push_back('m');
3376       this->append_mangled_name(this->receiver_->type(), gogo, ret);
3377     }
3378
3379   const Typed_identifier_list* params = this->parameters();
3380   if (params != NULL)
3381     {
3382       ret->push_back('p');
3383       for (Typed_identifier_list::const_iterator p = params->begin();
3384            p != params->end();
3385            ++p)
3386         this->append_mangled_name(p->type(), gogo, ret);
3387       if (this->is_varargs_)
3388         ret->push_back('V');
3389       ret->push_back('e');
3390     }
3391
3392   const Typed_identifier_list* results = this->results();
3393   if (results != NULL)
3394     {
3395       ret->push_back('r');
3396       for (Typed_identifier_list::const_iterator p = results->begin();
3397            p != results->end();
3398            ++p)
3399         this->append_mangled_name(p->type(), gogo, ret);
3400       ret->push_back('e');
3401     }
3402
3403   ret->push_back('e');
3404 }
3405
3406 // Export a function type.
3407
3408 void
3409 Function_type::do_export(Export* exp) const
3410 {
3411   // We don't write out the receiver.  The only function types which
3412   // should have a receiver are the ones associated with explicitly
3413   // defined methods.  For those the receiver type is written out by
3414   // Function::export_func.
3415
3416   exp->write_c_string("(");
3417   bool first = true;
3418   if (this->parameters_ != NULL)
3419     {
3420       bool is_varargs = this->is_varargs_;
3421       for (Typed_identifier_list::const_iterator p =
3422              this->parameters_->begin();
3423            p != this->parameters_->end();
3424            ++p)
3425         {
3426           if (first)
3427             first = false;
3428           else
3429             exp->write_c_string(", ");
3430           if (!is_varargs || p + 1 != this->parameters_->end())
3431             exp->write_type(p->type());
3432           else
3433             {
3434               exp->write_c_string("...");
3435               exp->write_type(p->type()->array_type()->element_type());
3436             }
3437         }
3438     }
3439   exp->write_c_string(")");
3440
3441   const Typed_identifier_list* results = this->results_;
3442   if (results != NULL)
3443     {
3444       exp->write_c_string(" ");
3445       if (results->size() == 1)
3446         exp->write_type(results->begin()->type());
3447       else
3448         {
3449           first = true;
3450           exp->write_c_string("(");
3451           for (Typed_identifier_list::const_iterator p = results->begin();
3452                p != results->end();
3453                ++p)
3454             {
3455               if (first)
3456                 first = false;
3457               else
3458                 exp->write_c_string(", ");
3459               exp->write_type(p->type());
3460             }
3461           exp->write_c_string(")");
3462         }
3463     }
3464 }
3465
3466 // Import a function type.
3467
3468 Function_type*
3469 Function_type::do_import(Import* imp)
3470 {
3471   imp->require_c_string("(");
3472   Typed_identifier_list* parameters;
3473   bool is_varargs = false;
3474   if (imp->peek_char() == ')')
3475     parameters = NULL;
3476   else
3477     {
3478       parameters = new Typed_identifier_list();
3479       while (true)
3480         {
3481           if (imp->match_c_string("..."))
3482             {
3483               imp->advance(3);
3484               is_varargs = true;
3485             }
3486
3487           Type* ptype = imp->read_type();
3488           if (is_varargs)
3489             ptype = Type::make_array_type(ptype, NULL);
3490           parameters->push_back(Typed_identifier(Import::import_marker,
3491                                                  ptype, imp->location()));
3492           if (imp->peek_char() != ',')
3493             break;
3494           go_assert(!is_varargs);
3495           imp->require_c_string(", ");
3496         }
3497     }
3498   imp->require_c_string(")");
3499
3500   Typed_identifier_list* results;
3501   if (imp->peek_char() != ' ')
3502     results = NULL;
3503   else
3504     {
3505       imp->advance(1);
3506       results = new Typed_identifier_list;
3507       if (imp->peek_char() != '(')
3508         {
3509           Type* rtype = imp->read_type();
3510           results->push_back(Typed_identifier(Import::import_marker, rtype,
3511                                               imp->location()));
3512         }
3513       else
3514         {
3515           imp->advance(1);
3516           while (true)
3517             {
3518               Type* rtype = imp->read_type();
3519               results->push_back(Typed_identifier(Import::import_marker,
3520                                                   rtype, imp->location()));
3521               if (imp->peek_char() != ',')
3522                 break;
3523               imp->require_c_string(", ");
3524             }
3525           imp->require_c_string(")");
3526         }
3527     }
3528
3529   Function_type* ret = Type::make_function_type(NULL, parameters, results,
3530                                                 imp->location());
3531   if (is_varargs)
3532     ret->set_is_varargs();
3533   return ret;
3534 }
3535
3536 // Make a copy of a function type without a receiver.
3537
3538 Function_type*
3539 Function_type::copy_without_receiver() const
3540 {
3541   go_assert(this->is_method());
3542   Function_type *ret = Type::make_function_type(NULL, this->parameters_,
3543                                                 this->results_,
3544                                                 this->location_);
3545   if (this->is_varargs())
3546     ret->set_is_varargs();
3547   if (this->is_builtin())
3548     ret->set_is_builtin();
3549   return ret;
3550 }
3551
3552 // Make a copy of a function type with a receiver.
3553
3554 Function_type*
3555 Function_type::copy_with_receiver(Type* receiver_type) const
3556 {
3557   go_assert(!this->is_method());
3558   Typed_identifier* receiver = new Typed_identifier("", receiver_type,
3559                                                     this->location_);
3560   return Type::make_function_type(receiver, this->parameters_,
3561                                   this->results_, this->location_);
3562 }
3563
3564 // Make a function type.
3565
3566 Function_type*
3567 Type::make_function_type(Typed_identifier* receiver,
3568                          Typed_identifier_list* parameters,
3569                          Typed_identifier_list* results,
3570                          Location location)
3571 {
3572   return new Function_type(receiver, parameters, results, location);
3573 }
3574
3575 // Class Pointer_type.
3576
3577 // Traversal.
3578
3579 int
3580 Pointer_type::do_traverse(Traverse* traverse)
3581 {
3582   return Type::traverse(this->to_type_, traverse);
3583 }
3584
3585 // Hash code.
3586
3587 unsigned int
3588 Pointer_type::do_hash_for_method(Gogo* gogo) const
3589 {
3590   return this->to_type_->hash_for_method(gogo) << 4;
3591 }
3592
3593 // The tree for a pointer type.
3594
3595 Btype*
3596 Pointer_type::do_get_backend(Gogo* gogo)
3597 {
3598   Btype* to_btype = this->to_type_->get_backend(gogo);
3599   return gogo->backend()->pointer_type(to_btype);
3600 }
3601
3602 // The type of a pointer type descriptor.
3603
3604 Type*
3605 Pointer_type::make_pointer_type_descriptor_type()
3606 {
3607   static Type* ret;
3608   if (ret == NULL)
3609     {
3610       Type* tdt = Type::make_type_descriptor_type();
3611       Type* ptdt = Type::make_type_descriptor_ptr_type();
3612
3613       Struct_type* s = Type::make_builtin_struct_type(2,
3614                                                       "", tdt,
3615                                                       "elem", ptdt);
3616
3617       ret = Type::make_builtin_named_type("PtrType", s);
3618     }
3619
3620   return ret;
3621 }
3622
3623 // The type descriptor for a pointer type.
3624
3625 Expression*
3626 Pointer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
3627 {
3628   if (this->is_unsafe_pointer_type())
3629     {
3630       go_assert(name != NULL);
3631       return this->plain_type_descriptor(gogo,
3632                                          RUNTIME_TYPE_KIND_UNSAFE_POINTER,
3633                                          name);
3634     }
3635   else
3636     {
3637       Location bloc = Linemap::predeclared_location();
3638
3639       const Methods* methods;
3640       Type* deref = this->points_to();
3641       if (deref->named_type() != NULL)
3642         methods = deref->named_type()->methods();
3643       else if (deref->struct_type() != NULL)
3644         methods = deref->struct_type()->methods();
3645       else
3646         methods = NULL;
3647
3648       Type* ptr_tdt = Pointer_type::make_pointer_type_descriptor_type();
3649
3650       const Struct_field_list* fields = ptr_tdt->struct_type()->fields();
3651
3652       Expression_list* vals = new Expression_list();
3653       vals->reserve(2);
3654
3655       Struct_field_list::const_iterator p = fields->begin();
3656       go_assert(p->is_field_name("commonType"));
3657       vals->push_back(this->type_descriptor_constructor(gogo,
3658                                                         RUNTIME_TYPE_KIND_PTR,
3659                                                         name, methods, false));
3660
3661       ++p;
3662       go_assert(p->is_field_name("elem"));
3663       vals->push_back(Expression::make_type_descriptor(deref, bloc));
3664
3665       return Expression::make_struct_composite_literal(ptr_tdt, vals, bloc);
3666     }
3667 }
3668
3669 // Reflection string.
3670
3671 void
3672 Pointer_type::do_reflection(Gogo* gogo, std::string* ret) const
3673 {
3674   ret->push_back('*');
3675   this->append_reflection(this->to_type_, gogo, ret);
3676 }
3677
3678 // Mangled name.
3679
3680 void
3681 Pointer_type::do_mangled_name(Gogo* gogo, std::string* ret) const
3682 {
3683   ret->push_back('p');
3684   this->append_mangled_name(this->to_type_, gogo, ret);
3685 }
3686
3687 // Export.
3688
3689 void
3690 Pointer_type::do_export(Export* exp) const
3691 {
3692   exp->write_c_string("*");
3693   if (this->is_unsafe_pointer_type())
3694     exp->write_c_string("any");
3695   else
3696     exp->write_type(this->to_type_);
3697 }
3698
3699 // Import.
3700
3701 Pointer_type*
3702 Pointer_type::do_import(Import* imp)
3703 {
3704   imp->require_c_string("*");
3705   if (imp->match_c_string("any"))
3706     {
3707       imp->advance(3);
3708       return Type::make_pointer_type(Type::make_void_type());
3709     }
3710   Type* to = imp->read_type();
3711   return Type::make_pointer_type(to);
3712 }
3713
3714 // Make a pointer type.
3715
3716 Pointer_type*
3717 Type::make_pointer_type(Type* to_type)
3718 {
3719   typedef Unordered_map(Type*, Pointer_type*) Hashtable;
3720   static Hashtable pointer_types;
3721   Hashtable::const_iterator p = pointer_types.find(to_type);
3722   if (p != pointer_types.end())
3723     return p->second;
3724   Pointer_type* ret = new Pointer_type(to_type);
3725   pointer_types[to_type] = ret;
3726   return ret;
3727 }
3728
3729 // The nil type.  We use a special type for nil because it is not the
3730 // same as any other type.  In C term nil has type void*, but there is
3731 // no such type in Go.
3732
3733 class Nil_type : public Type
3734 {
3735  public:
3736   Nil_type()
3737     : Type(TYPE_NIL)
3738   { }
3739
3740  protected:
3741   bool
3742   do_compare_is_identity(Gogo*) const
3743   { return false; }
3744
3745   Btype*
3746   do_get_backend(Gogo* gogo)
3747   { return gogo->backend()->pointer_type(gogo->backend()->void_type()); }
3748
3749   Expression*
3750   do_type_descriptor(Gogo*, Named_type*)
3751   { go_unreachable(); }
3752
3753   void
3754   do_reflection(Gogo*, std::string*) const
3755   { go_unreachable(); }
3756
3757   void
3758   do_mangled_name(Gogo*, std::string* ret) const
3759   { ret->push_back('n'); }
3760 };
3761
3762 // Make the nil type.
3763
3764 Type*
3765 Type::make_nil_type()
3766 {
3767   static Nil_type singleton_nil_type;
3768   return &singleton_nil_type;
3769 }
3770
3771 // The type of a function call which returns multiple values.  This is
3772 // really a struct, but we don't want to confuse a function call which
3773 // returns a struct with a function call which returns multiple
3774 // values.
3775
3776 class Call_multiple_result_type : public Type
3777 {
3778  public:
3779   Call_multiple_result_type(Call_expression* call)
3780     : Type(TYPE_CALL_MULTIPLE_RESULT),
3781       call_(call)
3782   { }
3783
3784  protected:
3785   bool
3786   do_has_pointer() const
3787   {
3788     go_assert(saw_errors());
3789     return false;
3790   }
3791
3792   bool
3793   do_compare_is_identity(Gogo*) const
3794   { return false; }
3795
3796   Btype*
3797   do_get_backend(Gogo* gogo)
3798   {
3799     go_assert(saw_errors());
3800     return gogo->backend()->error_type();
3801   }
3802
3803   Expression*
3804   do_type_descriptor(Gogo*, Named_type*)
3805   {
3806     go_assert(saw_errors());
3807     return Expression::make_error(Linemap::unknown_location());
3808   }
3809
3810   void
3811   do_reflection(Gogo*, std::string*) const
3812   { go_assert(saw_errors()); }
3813
3814   void
3815   do_mangled_name(Gogo*, std::string*) const
3816   { go_assert(saw_errors()); }
3817
3818  private:
3819   // The expression being called.
3820   Call_expression* call_;
3821 };
3822
3823 // Make a call result type.
3824
3825 Type*
3826 Type::make_call_multiple_result_type(Call_expression* call)
3827 {
3828   return new Call_multiple_result_type(call);
3829 }
3830
3831 // Class Struct_field.
3832
3833 // Get the name of a field.
3834
3835 const std::string&
3836 Struct_field::field_name() const
3837 {
3838   const std::string& name(this->typed_identifier_.name());
3839   if (!name.empty())
3840     return name;
3841   else
3842     {
3843       // This is called during parsing, before anything is lowered, so
3844       // we have to be pretty careful to avoid dereferencing an
3845       // unknown type name.
3846       Type* t = this->typed_identifier_.type();
3847       Type* dt = t;
3848       if (t->classification() == Type::TYPE_POINTER)
3849         {
3850           // Very ugly.
3851           Pointer_type* ptype = static_cast<Pointer_type*>(t);
3852           dt = ptype->points_to();
3853         }
3854       if (dt->forward_declaration_type() != NULL)
3855         return dt->forward_declaration_type()->name();
3856       else if (dt->named_type() != NULL)
3857         return dt->named_type()->name();
3858       else if (t->is_error_type() || dt->is_error_type())
3859         {
3860           static const std::string error_string = "*error*";
3861           return error_string;
3862         }
3863       else
3864         {
3865           // Avoid crashing in the erroneous case where T is named but
3866           // DT is not.
3867           go_assert(t != dt);
3868           if (t->forward_declaration_type() != NULL)
3869             return t->forward_declaration_type()->name();
3870           else if (t->named_type() != NULL)
3871             return t->named_type()->name();
3872           else
3873             go_unreachable();
3874         }
3875     }
3876 }
3877
3878 // Return whether this field is named NAME.
3879
3880 bool
3881 Struct_field::is_field_name(const std::string& name) const
3882 {
3883   const std::string& me(this->typed_identifier_.name());
3884   if (!me.empty())
3885     return me == name;
3886   else
3887     {
3888       Type* t = this->typed_identifier_.type();
3889       if (t->points_to() != NULL)
3890         t = t->points_to();
3891       Named_type* nt = t->named_type();
3892       if (nt != NULL && nt->name() == name)
3893         return true;
3894
3895       // This is a horrible hack caused by the fact that we don't pack
3896       // the names of builtin types.  FIXME.
3897       if (nt != NULL
3898           && nt->is_builtin()
3899           && nt->name() == Gogo::unpack_hidden_name(name))
3900         return true;
3901
3902       return false;
3903     }
3904 }
3905
3906 // Class Struct_type.
3907
3908 // Traversal.
3909
3910 int
3911 Struct_type::do_traverse(Traverse* traverse)
3912 {
3913   Struct_field_list* fields = this->fields_;
3914   if (fields != NULL)
3915     {
3916       for (Struct_field_list::iterator p = fields->begin();
3917            p != fields->end();
3918            ++p)
3919         {
3920           if (Type::traverse(p->type(), traverse) == TRAVERSE_EXIT)
3921             return TRAVERSE_EXIT;
3922         }
3923     }
3924   return TRAVERSE_CONTINUE;
3925 }
3926
3927 // Verify that the struct type is complete and valid.
3928
3929 bool
3930 Struct_type::do_verify()
3931 {
3932   Struct_field_list* fields = this->fields_;
3933   if (fields == NULL)
3934     return true;
3935   bool ret = true;
3936   for (Struct_field_list::iterator p = fields->begin();
3937        p != fields->end();
3938        ++p)
3939     {
3940       Type* t = p->type();
3941       if (t->is_undefined())
3942         {
3943           error_at(p->location(), "struct field type is incomplete");
3944           p->set_type(Type::make_error_type());
3945           ret = false;
3946         }
3947       else if (p->is_anonymous())
3948         {
3949           if (t->named_type() != NULL && t->points_to() != NULL)
3950             {
3951               error_at(p->location(), "embedded type may not be a pointer");
3952               p->set_type(Type::make_error_type());
3953               return false;
3954             }
3955           if (t->points_to() != NULL
3956               && t->points_to()->interface_type() != NULL)
3957             {
3958               error_at(p->location(),
3959                        "embedded type may not be pointer to interface");
3960               p->set_type(Type::make_error_type());
3961               return false;
3962             }
3963         }
3964     }
3965   return ret;
3966 }
3967
3968 // Whether this contains a pointer.
3969
3970 bool
3971 Struct_type::do_has_pointer() const
3972 {
3973   const Struct_field_list* fields = this->fields();
3974   if (fields == NULL)
3975     return false;
3976   for (Struct_field_list::const_iterator p = fields->begin();
3977        p != fields->end();
3978        ++p)
3979     {
3980       if (p->type()->has_pointer())
3981         return true;
3982     }
3983   return false;
3984 }
3985
3986 // Whether this type is identical to T.
3987
3988 bool
3989 Struct_type::is_identical(const Struct_type* t,
3990                           bool errors_are_identical) const
3991 {
3992   const Struct_field_list* fields1 = this->fields();
3993   const Struct_field_list* fields2 = t->fields();
3994   if (fields1 == NULL || fields2 == NULL)
3995     return fields1 == fields2;
3996   Struct_field_list::const_iterator pf2 = fields2->begin();
3997   for (Struct_field_list::const_iterator pf1 = fields1->begin();
3998        pf1 != fields1->end();
3999        ++pf1, ++pf2)
4000     {
4001       if (pf2 == fields2->end())
4002         return false;
4003       if (pf1->field_name() != pf2->field_name())
4004         return false;
4005       if (pf1->is_anonymous() != pf2->is_anonymous()
4006           || !Type::are_identical(pf1->type(), pf2->type(),
4007                                   errors_are_identical, NULL))
4008         return false;
4009       if (!pf1->has_tag())
4010         {
4011           if (pf2->has_tag())
4012             return false;
4013         }
4014       else
4015         {
4016           if (!pf2->has_tag())
4017             return false;
4018           if (pf1->tag() != pf2->tag())
4019             return false;
4020         }
4021     }
4022   if (pf2 != fields2->end())
4023     return false;
4024   return true;
4025 }
4026
4027 // Whether this struct type has any hidden fields.
4028
4029 bool
4030 Struct_type::struct_has_hidden_fields(const Named_type* within,
4031                                       std::string* reason) const
4032 {
4033   const Struct_field_list* fields = this->fields();
4034   if (fields == NULL)
4035     return false;
4036   const Package* within_package = (within == NULL
4037                                    ? NULL
4038                                    : within->named_object()->package());
4039   for (Struct_field_list::const_iterator pf = fields->begin();
4040        pf != fields->end();
4041        ++pf)
4042     {
4043       if (within_package != NULL
4044           && !pf->is_anonymous()
4045           && Gogo::is_hidden_name(pf->field_name()))
4046         {
4047           if (reason != NULL)
4048             {
4049               std::string within_name = within->named_object()->message_name();
4050               std::string name = Gogo::message_name(pf->field_name());
4051               size_t bufsize = 200 + within_name.length() + name.length();
4052               char* buf = new char[bufsize];
4053               snprintf(buf, bufsize,
4054                        _("implicit assignment of %s%s%s hidden field %s%s%s"),
4055                        open_quote, within_name.c_str(), close_quote,
4056                        open_quote, name.c_str(), close_quote);
4057               reason->assign(buf);
4058               delete[] buf;
4059             }
4060           return true;
4061         }
4062
4063       if (pf->type()->has_hidden_fields(within, reason))
4064         return true;
4065     }
4066
4067   return false;
4068 }
4069
4070 // Whether comparisons of this struct type are simple identity
4071 // comparisons.
4072
4073 bool
4074 Struct_type::do_compare_is_identity(Gogo* gogo) const
4075 {
4076   const Struct_field_list* fields = this->fields_;
4077   if (fields == NULL)
4078     return true;
4079   unsigned int offset = 0;
4080   for (Struct_field_list::const_iterator pf = fields->begin();
4081        pf != fields->end();
4082        ++pf)
4083     {
4084       if (!pf->type()->compare_is_identity(gogo))
4085         return false;
4086
4087       unsigned int field_align;
4088       if (!pf->type()->backend_type_align(gogo, &field_align))
4089         return false;
4090       if ((offset & (field_align - 1)) != 0)
4091         {
4092           // This struct has padding.  We don't guarantee that that
4093           // padding is zero-initialized for a stack variable, so we
4094           // can't use memcmp to compare struct values.
4095           return false;
4096         }
4097
4098       unsigned int field_size;
4099       if (!pf->type()->backend_type_size(gogo, &field_size))
4100         return false;
4101       offset += field_size;
4102     }
4103   return true;
4104 }
4105
4106 // Build identity and hash functions for this struct.
4107
4108 // Hash code.
4109
4110 unsigned int
4111 Struct_type::do_hash_for_method(Gogo* gogo) const
4112 {
4113   unsigned int ret = 0;
4114   if (this->fields() != NULL)
4115     {
4116       for (Struct_field_list::const_iterator pf = this->fields()->begin();
4117            pf != this->fields()->end();
4118            ++pf)
4119         ret = (ret << 1) + pf->type()->hash_for_method(gogo);
4120     }
4121   return ret <<= 2;
4122 }
4123
4124 // Find the local field NAME.
4125
4126 const Struct_field*
4127 Struct_type::find_local_field(const std::string& name,
4128                               unsigned int *pindex) const
4129 {
4130   const Struct_field_list* fields = this->fields_;
4131   if (fields == NULL)
4132     return NULL;
4133   unsigned int i = 0;
4134   for (Struct_field_list::const_iterator pf = fields->begin();
4135        pf != fields->end();
4136        ++pf, ++i)
4137     {
4138       if (pf->is_field_name(name))
4139         {
4140           if (pindex != NULL)
4141             *pindex = i;
4142           return &*pf;
4143         }
4144     }
4145   return NULL;
4146 }
4147
4148 // Return an expression for field NAME in STRUCT_EXPR, or NULL.
4149
4150 Field_reference_expression*
4151 Struct_type::field_reference(Expression* struct_expr, const std::string& name,
4152                              Location location) const
4153 {
4154   unsigned int depth;
4155   return this->field_reference_depth(struct_expr, name, location, NULL,
4156                                      &depth);
4157