OSDN Git Service

compiler, reflect: Fix hash codes of named types, fix PtrTo hash.
[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   unsigned int h;
1662   if (name != NULL)
1663     h = name->hash_for_method(gogo);
1664   else
1665     h = this->hash_for_method(gogo);
1666   mpz_set_ui(iv, h);
1667   vals->push_back(Expression::make_integer(&iv, p->type(), bloc));
1668
1669   ++p;
1670   go_assert(p->is_field_name("hashfn"));
1671   Function_type* hash_fntype = p->type()->function_type();
1672
1673   ++p;
1674   go_assert(p->is_field_name("equalfn"));
1675   Function_type* equal_fntype = p->type()->function_type();
1676
1677   Named_object* hash_fn;
1678   Named_object* equal_fn;
1679   this->type_functions(gogo, name, hash_fntype, equal_fntype, &hash_fn,
1680                        &equal_fn);
1681   vals->push_back(Expression::make_func_reference(hash_fn, NULL, bloc));
1682   vals->push_back(Expression::make_func_reference(equal_fn, NULL, bloc));
1683
1684   ++p;
1685   go_assert(p->is_field_name("string"));
1686   Expression* s = Expression::make_string((name != NULL
1687                                            ? name->reflection(gogo)
1688                                            : this->reflection(gogo)),
1689                                           bloc);
1690   vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1691
1692   ++p;
1693   go_assert(p->is_field_name("uncommonType"));
1694   if (name == NULL && methods == NULL)
1695     vals->push_back(Expression::make_nil(bloc));
1696   else
1697     {
1698       if (methods == NULL)
1699         methods = name->methods();
1700       vals->push_back(this->uncommon_type_constructor(gogo,
1701                                                       p->type()->deref(),
1702                                                       name, methods,
1703                                                       only_value_methods));
1704     }
1705
1706   ++p;
1707   go_assert(p->is_field_name("ptrToThis"));
1708   if (name == NULL)
1709     vals->push_back(Expression::make_nil(bloc));
1710   else
1711     {
1712       Type* pt = Type::make_pointer_type(name);
1713       vals->push_back(Expression::make_type_descriptor(pt, bloc));
1714     }
1715
1716   ++p;
1717   go_assert(p == fields->end());
1718
1719   mpz_clear(iv);
1720
1721   return Expression::make_struct_composite_literal(td_type, vals, bloc);
1722 }
1723
1724 // Return a composite literal for the uncommon type information for
1725 // this type.  UNCOMMON_STRUCT_TYPE is the type of the uncommon type
1726 // struct.  If name is not NULL, it is the name of the type.  If
1727 // METHODS is not NULL, it is the list of methods.  ONLY_VALUE_METHODS
1728 // is true if only value methods should be included.  At least one of
1729 // NAME and METHODS must not be NULL.
1730
1731 Expression*
1732 Type::uncommon_type_constructor(Gogo* gogo, Type* uncommon_type,
1733                                 Named_type* name, const Methods* methods,
1734                                 bool only_value_methods) const
1735 {
1736   Location bloc = Linemap::predeclared_location();
1737
1738   const Struct_field_list* fields = uncommon_type->struct_type()->fields();
1739
1740   Expression_list* vals = new Expression_list();
1741   vals->reserve(3);
1742
1743   Struct_field_list::const_iterator p = fields->begin();
1744   go_assert(p->is_field_name("name"));
1745
1746   ++p;
1747   go_assert(p->is_field_name("pkgPath"));
1748
1749   if (name == NULL)
1750     {
1751       vals->push_back(Expression::make_nil(bloc));
1752       vals->push_back(Expression::make_nil(bloc));
1753     }
1754   else
1755     {
1756       Named_object* no = name->named_object();
1757       std::string n = Gogo::unpack_hidden_name(no->name());
1758       Expression* s = Expression::make_string(n, bloc);
1759       vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1760
1761       if (name->is_builtin())
1762         vals->push_back(Expression::make_nil(bloc));
1763       else
1764         {
1765           const Package* package = no->package();
1766           const std::string& unique_prefix(package == NULL
1767                                            ? gogo->unique_prefix()
1768                                            : package->unique_prefix());
1769           const std::string& package_name(package == NULL
1770                                           ? gogo->package_name()
1771                                           : package->name());
1772           n.assign(unique_prefix);
1773           n.append(1, '.');
1774           n.append(package_name);
1775           if (name->in_function() != NULL)
1776             {
1777               n.append(1, '.');
1778               n.append(Gogo::unpack_hidden_name(name->in_function()->name()));
1779             }
1780           s = Expression::make_string(n, bloc);
1781           vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1782         }
1783     }
1784
1785   ++p;
1786   go_assert(p->is_field_name("methods"));
1787   vals->push_back(this->methods_constructor(gogo, p->type(), methods,
1788                                             only_value_methods));
1789
1790   ++p;
1791   go_assert(p == fields->end());
1792
1793   Expression* r = Expression::make_struct_composite_literal(uncommon_type,
1794                                                             vals, bloc);
1795   return Expression::make_unary(OPERATOR_AND, r, bloc);
1796 }
1797
1798 // Sort methods by name.
1799
1800 class Sort_methods
1801 {
1802  public:
1803   bool
1804   operator()(const std::pair<std::string, const Method*>& m1,
1805              const std::pair<std::string, const Method*>& m2) const
1806   { return m1.first < m2.first; }
1807 };
1808
1809 // Return a composite literal for the type method table for this type.
1810 // METHODS_TYPE is the type of the table, and is a slice type.
1811 // METHODS is the list of methods.  If ONLY_VALUE_METHODS is true,
1812 // then only value methods are used.
1813
1814 Expression*
1815 Type::methods_constructor(Gogo* gogo, Type* methods_type,
1816                           const Methods* methods,
1817                           bool only_value_methods) const
1818 {
1819   Location bloc = Linemap::predeclared_location();
1820
1821   std::vector<std::pair<std::string, const Method*> > smethods;
1822   if (methods != NULL)
1823     {
1824       smethods.reserve(methods->count());
1825       for (Methods::const_iterator p = methods->begin();
1826            p != methods->end();
1827            ++p)
1828         {
1829           if (p->second->is_ambiguous())
1830             continue;
1831           if (only_value_methods && !p->second->is_value_method())
1832             continue;
1833           smethods.push_back(std::make_pair(p->first, p->second));
1834         }
1835     }
1836
1837   if (smethods.empty())
1838     return Expression::make_slice_composite_literal(methods_type, NULL, bloc);
1839
1840   std::sort(smethods.begin(), smethods.end(), Sort_methods());
1841
1842   Type* method_type = methods_type->array_type()->element_type();
1843
1844   Expression_list* vals = new Expression_list();
1845   vals->reserve(smethods.size());
1846   for (std::vector<std::pair<std::string, const Method*> >::const_iterator p
1847          = smethods.begin();
1848        p != smethods.end();
1849        ++p)
1850     vals->push_back(this->method_constructor(gogo, method_type, p->first,
1851                                              p->second, only_value_methods));
1852
1853   return Expression::make_slice_composite_literal(methods_type, vals, bloc);
1854 }
1855
1856 // Return a composite literal for a single method.  METHOD_TYPE is the
1857 // type of the entry.  METHOD_NAME is the name of the method and M is
1858 // the method information.
1859
1860 Expression*
1861 Type::method_constructor(Gogo*, Type* method_type,
1862                          const std::string& method_name,
1863                          const Method* m,
1864                          bool only_value_methods) const
1865 {
1866   Location bloc = Linemap::predeclared_location();
1867
1868   const Struct_field_list* fields = method_type->struct_type()->fields();
1869
1870   Expression_list* vals = new Expression_list();
1871   vals->reserve(5);
1872
1873   Struct_field_list::const_iterator p = fields->begin();
1874   go_assert(p->is_field_name("name"));
1875   const std::string n = Gogo::unpack_hidden_name(method_name);
1876   Expression* s = Expression::make_string(n, bloc);
1877   vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1878
1879   ++p;
1880   go_assert(p->is_field_name("pkgPath"));
1881   if (!Gogo::is_hidden_name(method_name))
1882     vals->push_back(Expression::make_nil(bloc));
1883   else
1884     {
1885       s = Expression::make_string(Gogo::hidden_name_prefix(method_name), bloc);
1886       vals->push_back(Expression::make_unary(OPERATOR_AND, s, bloc));
1887     }
1888
1889   Named_object* no = (m->needs_stub_method()
1890                       ? m->stub_object()
1891                       : m->named_object());
1892
1893   Function_type* mtype;
1894   if (no->is_function())
1895     mtype = no->func_value()->type();
1896   else
1897     mtype = no->func_declaration_value()->type();
1898   go_assert(mtype->is_method());
1899   Type* nonmethod_type = mtype->copy_without_receiver();
1900
1901   ++p;
1902   go_assert(p->is_field_name("mtyp"));
1903   vals->push_back(Expression::make_type_descriptor(nonmethod_type, bloc));
1904
1905   ++p;
1906   go_assert(p->is_field_name("typ"));
1907   if (!only_value_methods && m->is_value_method())
1908     {
1909       // This is a value method on a pointer type.  Change the type of
1910       // the method to use a pointer receiver.  The implementation
1911       // always uses a pointer receiver anyhow.
1912       Type* rtype = mtype->receiver()->type();
1913       Type* prtype = Type::make_pointer_type(rtype);
1914       Typed_identifier* receiver =
1915         new Typed_identifier(mtype->receiver()->name(), prtype,
1916                              mtype->receiver()->location());
1917       mtype = Type::make_function_type(receiver,
1918                                        (mtype->parameters() == NULL
1919                                         ? NULL
1920                                         : mtype->parameters()->copy()),
1921                                        (mtype->results() == NULL
1922                                         ? NULL
1923                                         : mtype->results()->copy()),
1924                                        mtype->location());
1925     }
1926   vals->push_back(Expression::make_type_descriptor(mtype, bloc));
1927
1928   ++p;
1929   go_assert(p->is_field_name("tfn"));
1930   vals->push_back(Expression::make_func_reference(no, NULL, bloc));
1931
1932   ++p;
1933   go_assert(p == fields->end());
1934
1935   return Expression::make_struct_composite_literal(method_type, vals, bloc);
1936 }
1937
1938 // Return a composite literal for the type descriptor of a plain type.
1939 // RUNTIME_TYPE_KIND is the value of the kind field.  If NAME is not
1940 // NULL, it is the name to use as well as the list of methods.
1941
1942 Expression*
1943 Type::plain_type_descriptor(Gogo* gogo, int runtime_type_kind,
1944                             Named_type* name)
1945 {
1946   return this->type_descriptor_constructor(gogo, runtime_type_kind,
1947                                            name, NULL, true);
1948 }
1949
1950 // Return the type reflection string for this type.
1951
1952 std::string
1953 Type::reflection(Gogo* gogo) const
1954 {
1955   std::string ret;
1956
1957   // The do_reflection virtual function should set RET to the
1958   // reflection string.
1959   this->do_reflection(gogo, &ret);
1960
1961   return ret;
1962 }
1963
1964 // Return a mangled name for the type.
1965
1966 std::string
1967 Type::mangled_name(Gogo* gogo) const
1968 {
1969   std::string ret;
1970
1971   // The do_mangled_name virtual function should set RET to the
1972   // mangled name.  For a composite type it should append a code for
1973   // the composition and then call do_mangled_name on the components.
1974   this->do_mangled_name(gogo, &ret);
1975
1976   return ret;
1977 }
1978
1979 // Return whether the backend size of the type is known.
1980
1981 bool
1982 Type::is_backend_type_size_known(Gogo* gogo)
1983 {
1984   switch (this->classification_)
1985     {
1986     case TYPE_ERROR:
1987     case TYPE_VOID:
1988     case TYPE_BOOLEAN:
1989     case TYPE_INTEGER:
1990     case TYPE_FLOAT:
1991     case TYPE_COMPLEX:
1992     case TYPE_STRING:
1993     case TYPE_FUNCTION:
1994     case TYPE_POINTER:
1995     case TYPE_NIL:
1996     case TYPE_MAP:
1997     case TYPE_CHANNEL:
1998     case TYPE_INTERFACE:
1999       return true;
2000
2001     case TYPE_STRUCT:
2002       {
2003         const Struct_field_list* fields = this->struct_type()->fields();
2004         for (Struct_field_list::const_iterator pf = fields->begin();
2005              pf != fields->end();
2006              ++pf)
2007           if (!pf->type()->is_backend_type_size_known(gogo))
2008             return false;
2009         return true;
2010       }
2011
2012     case TYPE_ARRAY:
2013       {
2014         const Array_type* at = this->array_type();
2015         if (at->length() == NULL)
2016           return true;
2017         else
2018           {
2019             mpz_t ival;
2020             mpz_init(ival);
2021             Type* dummy;
2022             bool length_known = at->length()->integer_constant_value(true,
2023                                                                      ival,
2024                                                                      &dummy);
2025             mpz_clear(ival);
2026             if (!length_known)
2027               return false;
2028             return at->element_type()->is_backend_type_size_known(gogo);
2029           }
2030       }
2031
2032     case TYPE_NAMED:
2033       // Begin converting this type to the backend representation.
2034       // This will create a placeholder if necessary.
2035       this->get_backend(gogo);
2036       return this->named_type()->is_named_backend_type_size_known();
2037
2038     case TYPE_FORWARD:
2039       {
2040         Forward_declaration_type* fdt = this->forward_declaration_type();
2041         return fdt->real_type()->is_backend_type_size_known(gogo);
2042       }
2043
2044     case TYPE_SINK:
2045     case TYPE_CALL_MULTIPLE_RESULT:
2046       go_unreachable();
2047
2048     default:
2049       go_unreachable();
2050     }
2051 }
2052
2053 // If the size of the type can be determined, set *PSIZE to the size
2054 // in bytes and return true.  Otherwise, return false.  This queries
2055 // the backend.
2056
2057 bool
2058 Type::backend_type_size(Gogo* gogo, unsigned int *psize)
2059 {
2060   if (!this->is_backend_type_size_known(gogo))
2061     return false;
2062   size_t size = gogo->backend()->type_size(this->get_backend(gogo));
2063   *psize = static_cast<unsigned int>(size);
2064   if (*psize != size)
2065     return false;
2066   return true;
2067 }
2068
2069 // If the alignment of the type can be determined, set *PALIGN to
2070 // the alignment in bytes and return true.  Otherwise, return false.
2071
2072 bool
2073 Type::backend_type_align(Gogo* gogo, unsigned int *palign)
2074 {
2075   if (!this->is_backend_type_size_known(gogo))
2076     return false;
2077   size_t align = gogo->backend()->type_alignment(this->get_backend(gogo));
2078   *palign = static_cast<unsigned int>(align);
2079   if (*palign != align)
2080     return false;
2081   return true;
2082 }
2083
2084 // Like backend_type_align, but return the alignment when used as a
2085 // field.
2086
2087 bool
2088 Type::backend_type_field_align(Gogo* gogo, unsigned int *palign)
2089 {
2090   if (!this->is_backend_type_size_known(gogo))
2091     return false;
2092   size_t a = gogo->backend()->type_field_alignment(this->get_backend(gogo));
2093   *palign = static_cast<unsigned int>(a);
2094   if (*palign != a)
2095     return false;
2096   return true;
2097 }
2098
2099 // Default function to export a type.
2100
2101 void
2102 Type::do_export(Export*) const
2103 {
2104   go_unreachable();
2105 }
2106
2107 // Import a type.
2108
2109 Type*
2110 Type::import_type(Import* imp)
2111 {
2112   if (imp->match_c_string("("))
2113     return Function_type::do_import(imp);
2114   else if (imp->match_c_string("*"))
2115     return Pointer_type::do_import(imp);
2116   else if (imp->match_c_string("struct "))
2117     return Struct_type::do_import(imp);
2118   else if (imp->match_c_string("["))
2119     return Array_type::do_import(imp);
2120   else if (imp->match_c_string("map "))
2121     return Map_type::do_import(imp);
2122   else if (imp->match_c_string("chan "))
2123     return Channel_type::do_import(imp);
2124   else if (imp->match_c_string("interface"))
2125     return Interface_type::do_import(imp);
2126   else
2127     {
2128       error_at(imp->location(), "import error: expected type");
2129       return Type::make_error_type();
2130     }
2131 }
2132
2133 // A type used to indicate a parsing error.  This exists to simplify
2134 // later error detection.
2135
2136 class Error_type : public Type
2137 {
2138  public:
2139   Error_type()
2140     : Type(TYPE_ERROR)
2141   { }
2142
2143  protected:
2144   bool
2145   do_compare_is_identity(Gogo*) const
2146   { return false; }
2147
2148   Btype*
2149   do_get_backend(Gogo* gogo)
2150   { return gogo->backend()->error_type(); }
2151
2152   Expression*
2153   do_type_descriptor(Gogo*, Named_type*)
2154   { return Expression::make_error(Linemap::predeclared_location()); }
2155
2156   void
2157   do_reflection(Gogo*, std::string*) const
2158   { go_assert(saw_errors()); }
2159
2160   void
2161   do_mangled_name(Gogo*, std::string* ret) const
2162   { ret->push_back('E'); }
2163 };
2164
2165 Type*
2166 Type::make_error_type()
2167 {
2168   static Error_type singleton_error_type;
2169   return &singleton_error_type;
2170 }
2171
2172 // The void type.
2173
2174 class Void_type : public Type
2175 {
2176  public:
2177   Void_type()
2178     : Type(TYPE_VOID)
2179   { }
2180
2181  protected:
2182   bool
2183   do_compare_is_identity(Gogo*) const
2184   { return false; }
2185
2186   Btype*
2187   do_get_backend(Gogo* gogo)
2188   { return gogo->backend()->void_type(); }
2189
2190   Expression*
2191   do_type_descriptor(Gogo*, Named_type*)
2192   { go_unreachable(); }
2193
2194   void
2195   do_reflection(Gogo*, std::string*) const
2196   { }
2197
2198   void
2199   do_mangled_name(Gogo*, std::string* ret) const
2200   { ret->push_back('v'); }
2201 };
2202
2203 Type*
2204 Type::make_void_type()
2205 {
2206   static Void_type singleton_void_type;
2207   return &singleton_void_type;
2208 }
2209
2210 // The boolean type.
2211
2212 class Boolean_type : public Type
2213 {
2214  public:
2215   Boolean_type()
2216     : Type(TYPE_BOOLEAN)
2217   { }
2218
2219  protected:
2220   bool
2221   do_compare_is_identity(Gogo*) const
2222   { return true; }
2223
2224   Btype*
2225   do_get_backend(Gogo* gogo)
2226   { return gogo->backend()->bool_type(); }
2227
2228   Expression*
2229   do_type_descriptor(Gogo*, Named_type* name);
2230
2231   // We should not be asked for the reflection string of a basic type.
2232   void
2233   do_reflection(Gogo*, std::string* ret) const
2234   { ret->append("bool"); }
2235
2236   void
2237   do_mangled_name(Gogo*, std::string* ret) const
2238   { ret->push_back('b'); }
2239 };
2240
2241 // Make the type descriptor.
2242
2243 Expression*
2244 Boolean_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2245 {
2246   if (name != NULL)
2247     return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_BOOL, name);
2248   else
2249     {
2250       Named_object* no = gogo->lookup_global("bool");
2251       go_assert(no != NULL);
2252       return Type::type_descriptor(gogo, no->type_value());
2253     }
2254 }
2255
2256 Type*
2257 Type::make_boolean_type()
2258 {
2259   static Boolean_type boolean_type;
2260   return &boolean_type;
2261 }
2262
2263 // The named type "bool".
2264
2265 static Named_type* named_bool_type;
2266
2267 // Get the named type "bool".
2268
2269 Named_type*
2270 Type::lookup_bool_type()
2271 {
2272   return named_bool_type;
2273 }
2274
2275 // Make the named type "bool".
2276
2277 Named_type*
2278 Type::make_named_bool_type()
2279 {
2280   Type* bool_type = Type::make_boolean_type();
2281   Named_object* named_object =
2282     Named_object::make_type("bool", NULL, bool_type,
2283                             Linemap::predeclared_location());
2284   Named_type* named_type = named_object->type_value();
2285   named_bool_type = named_type;
2286   return named_type;
2287 }
2288
2289 // Class Integer_type.
2290
2291 Integer_type::Named_integer_types Integer_type::named_integer_types;
2292
2293 // Create a new integer type.  Non-abstract integer types always have
2294 // names.
2295
2296 Named_type*
2297 Integer_type::create_integer_type(const char* name, bool is_unsigned,
2298                                   int bits, int runtime_type_kind)
2299 {
2300   Integer_type* integer_type = new Integer_type(false, is_unsigned, bits,
2301                                                 runtime_type_kind);
2302   std::string sname(name);
2303   Named_object* named_object =
2304     Named_object::make_type(sname, NULL, integer_type,
2305                             Linemap::predeclared_location());
2306   Named_type* named_type = named_object->type_value();
2307   std::pair<Named_integer_types::iterator, bool> ins =
2308     Integer_type::named_integer_types.insert(std::make_pair(sname, named_type));
2309   go_assert(ins.second);
2310   return named_type;
2311 }
2312
2313 // Look up an existing integer type.
2314
2315 Named_type*
2316 Integer_type::lookup_integer_type(const char* name)
2317 {
2318   Named_integer_types::const_iterator p =
2319     Integer_type::named_integer_types.find(name);
2320   go_assert(p != Integer_type::named_integer_types.end());
2321   return p->second;
2322 }
2323
2324 // Create a new abstract integer type.
2325
2326 Integer_type*
2327 Integer_type::create_abstract_integer_type()
2328 {
2329   static Integer_type* abstract_type;
2330   if (abstract_type == NULL)
2331     abstract_type = new Integer_type(true, false, INT_TYPE_SIZE,
2332                                      RUNTIME_TYPE_KIND_INT);
2333   return abstract_type;
2334 }
2335
2336 // Create a new abstract character type.
2337
2338 Integer_type*
2339 Integer_type::create_abstract_character_type()
2340 {
2341   static Integer_type* abstract_type;
2342   if (abstract_type == NULL)
2343     {
2344       abstract_type = new Integer_type(true, false, 32,
2345                                        RUNTIME_TYPE_KIND_INT32);
2346       abstract_type->set_is_rune();
2347     }
2348   return abstract_type;
2349 }
2350
2351 // Integer type compatibility.
2352
2353 bool
2354 Integer_type::is_identical(const Integer_type* t) const
2355 {
2356   if (this->is_unsigned_ != t->is_unsigned_ || this->bits_ != t->bits_)
2357     return false;
2358   return this->is_abstract_ == t->is_abstract_;
2359 }
2360
2361 // Hash code.
2362
2363 unsigned int
2364 Integer_type::do_hash_for_method(Gogo*) const
2365 {
2366   return ((this->bits_ << 4)
2367           + ((this->is_unsigned_ ? 1 : 0) << 8)
2368           + ((this->is_abstract_ ? 1 : 0) << 9));
2369 }
2370
2371 // Convert an Integer_type to the backend representation.
2372
2373 Btype*
2374 Integer_type::do_get_backend(Gogo* gogo)
2375 {
2376   if (this->is_abstract_)
2377     {
2378       go_assert(saw_errors());
2379       return gogo->backend()->error_type();
2380     }
2381   return gogo->backend()->integer_type(this->is_unsigned_, this->bits_);
2382 }
2383
2384 // The type descriptor for an integer type.  Integer types are always
2385 // named.
2386
2387 Expression*
2388 Integer_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2389 {
2390   go_assert(name != NULL);
2391   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2392 }
2393
2394 // We should not be asked for the reflection string of a basic type.
2395
2396 void
2397 Integer_type::do_reflection(Gogo*, std::string*) const
2398 {
2399   go_assert(saw_errors());
2400 }
2401
2402 // Mangled name.
2403
2404 void
2405 Integer_type::do_mangled_name(Gogo*, std::string* ret) const
2406 {
2407   char buf[100];
2408   snprintf(buf, sizeof buf, "i%s%s%de",
2409            this->is_abstract_ ? "a" : "",
2410            this->is_unsigned_ ? "u" : "",
2411            this->bits_);
2412   ret->append(buf);
2413 }
2414
2415 // Make an integer type.
2416
2417 Named_type*
2418 Type::make_integer_type(const char* name, bool is_unsigned, int bits,
2419                         int runtime_type_kind)
2420 {
2421   return Integer_type::create_integer_type(name, is_unsigned, bits,
2422                                            runtime_type_kind);
2423 }
2424
2425 // Make an abstract integer type.
2426
2427 Integer_type*
2428 Type::make_abstract_integer_type()
2429 {
2430   return Integer_type::create_abstract_integer_type();
2431 }
2432
2433 // Make an abstract character type.
2434
2435 Integer_type*
2436 Type::make_abstract_character_type()
2437 {
2438   return Integer_type::create_abstract_character_type();
2439 }
2440
2441 // Look up an integer type.
2442
2443 Named_type*
2444 Type::lookup_integer_type(const char* name)
2445 {
2446   return Integer_type::lookup_integer_type(name);
2447 }
2448
2449 // Class Float_type.
2450
2451 Float_type::Named_float_types Float_type::named_float_types;
2452
2453 // Create a new float type.  Non-abstract float types always have
2454 // names.
2455
2456 Named_type*
2457 Float_type::create_float_type(const char* name, int bits,
2458                               int runtime_type_kind)
2459 {
2460   Float_type* float_type = new Float_type(false, bits, runtime_type_kind);
2461   std::string sname(name);
2462   Named_object* named_object =
2463     Named_object::make_type(sname, NULL, float_type,
2464                             Linemap::predeclared_location());
2465   Named_type* named_type = named_object->type_value();
2466   std::pair<Named_float_types::iterator, bool> ins =
2467     Float_type::named_float_types.insert(std::make_pair(sname, named_type));
2468   go_assert(ins.second);
2469   return named_type;
2470 }
2471
2472 // Look up an existing float type.
2473
2474 Named_type*
2475 Float_type::lookup_float_type(const char* name)
2476 {
2477   Named_float_types::const_iterator p =
2478     Float_type::named_float_types.find(name);
2479   go_assert(p != Float_type::named_float_types.end());
2480   return p->second;
2481 }
2482
2483 // Create a new abstract float type.
2484
2485 Float_type*
2486 Float_type::create_abstract_float_type()
2487 {
2488   static Float_type* abstract_type;
2489   if (abstract_type == NULL)
2490     abstract_type = new Float_type(true, 64, RUNTIME_TYPE_KIND_FLOAT64);
2491   return abstract_type;
2492 }
2493
2494 // Whether this type is identical with T.
2495
2496 bool
2497 Float_type::is_identical(const Float_type* t) const
2498 {
2499   if (this->bits_ != t->bits_)
2500     return false;
2501   return this->is_abstract_ == t->is_abstract_;
2502 }
2503
2504 // Hash code.
2505
2506 unsigned int
2507 Float_type::do_hash_for_method(Gogo*) const
2508 {
2509   return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
2510 }
2511
2512 // Convert to the backend representation.
2513
2514 Btype*
2515 Float_type::do_get_backend(Gogo* gogo)
2516 {
2517   return gogo->backend()->float_type(this->bits_);
2518 }
2519
2520 // The type descriptor for a float type.  Float types are always named.
2521
2522 Expression*
2523 Float_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2524 {
2525   go_assert(name != NULL);
2526   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2527 }
2528
2529 // We should not be asked for the reflection string of a basic type.
2530
2531 void
2532 Float_type::do_reflection(Gogo*, std::string*) const
2533 {
2534   go_assert(saw_errors());
2535 }
2536
2537 // Mangled name.
2538
2539 void
2540 Float_type::do_mangled_name(Gogo*, std::string* ret) const
2541 {
2542   char buf[100];
2543   snprintf(buf, sizeof buf, "f%s%de",
2544            this->is_abstract_ ? "a" : "",
2545            this->bits_);
2546   ret->append(buf);
2547 }
2548
2549 // Make a floating point type.
2550
2551 Named_type*
2552 Type::make_float_type(const char* name, int bits, int runtime_type_kind)
2553 {
2554   return Float_type::create_float_type(name, bits, runtime_type_kind);
2555 }
2556
2557 // Make an abstract float type.
2558
2559 Float_type*
2560 Type::make_abstract_float_type()
2561 {
2562   return Float_type::create_abstract_float_type();
2563 }
2564
2565 // Look up a float type.
2566
2567 Named_type*
2568 Type::lookup_float_type(const char* name)
2569 {
2570   return Float_type::lookup_float_type(name);
2571 }
2572
2573 // Class Complex_type.
2574
2575 Complex_type::Named_complex_types Complex_type::named_complex_types;
2576
2577 // Create a new complex type.  Non-abstract complex types always have
2578 // names.
2579
2580 Named_type*
2581 Complex_type::create_complex_type(const char* name, int bits,
2582                                   int runtime_type_kind)
2583 {
2584   Complex_type* complex_type = new Complex_type(false, bits,
2585                                                 runtime_type_kind);
2586   std::string sname(name);
2587   Named_object* named_object =
2588     Named_object::make_type(sname, NULL, complex_type,
2589                             Linemap::predeclared_location());
2590   Named_type* named_type = named_object->type_value();
2591   std::pair<Named_complex_types::iterator, bool> ins =
2592     Complex_type::named_complex_types.insert(std::make_pair(sname,
2593                                                             named_type));
2594   go_assert(ins.second);
2595   return named_type;
2596 }
2597
2598 // Look up an existing complex type.
2599
2600 Named_type*
2601 Complex_type::lookup_complex_type(const char* name)
2602 {
2603   Named_complex_types::const_iterator p =
2604     Complex_type::named_complex_types.find(name);
2605   go_assert(p != Complex_type::named_complex_types.end());
2606   return p->second;
2607 }
2608
2609 // Create a new abstract complex type.
2610
2611 Complex_type*
2612 Complex_type::create_abstract_complex_type()
2613 {
2614   static Complex_type* abstract_type;
2615   if (abstract_type == NULL)
2616     abstract_type = new Complex_type(true, 128, RUNTIME_TYPE_KIND_COMPLEX128);
2617   return abstract_type;
2618 }
2619
2620 // Whether this type is identical with T.
2621
2622 bool
2623 Complex_type::is_identical(const Complex_type *t) const
2624 {
2625   if (this->bits_ != t->bits_)
2626     return false;
2627   return this->is_abstract_ == t->is_abstract_;
2628 }
2629
2630 // Hash code.
2631
2632 unsigned int
2633 Complex_type::do_hash_for_method(Gogo*) const
2634 {
2635   return (this->bits_ << 4) + ((this->is_abstract_ ? 1 : 0) << 8);
2636 }
2637
2638 // Convert to the backend representation.
2639
2640 Btype*
2641 Complex_type::do_get_backend(Gogo* gogo)
2642 {
2643   return gogo->backend()->complex_type(this->bits_);
2644 }
2645
2646 // The type descriptor for a complex type.  Complex types are always
2647 // named.
2648
2649 Expression*
2650 Complex_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2651 {
2652   go_assert(name != NULL);
2653   return this->plain_type_descriptor(gogo, this->runtime_type_kind_, name);
2654 }
2655
2656 // We should not be asked for the reflection string of a basic type.
2657
2658 void
2659 Complex_type::do_reflection(Gogo*, std::string*) const
2660 {
2661   go_assert(saw_errors());
2662 }
2663
2664 // Mangled name.
2665
2666 void
2667 Complex_type::do_mangled_name(Gogo*, std::string* ret) const
2668 {
2669   char buf[100];
2670   snprintf(buf, sizeof buf, "c%s%de",
2671            this->is_abstract_ ? "a" : "",
2672            this->bits_);
2673   ret->append(buf);
2674 }
2675
2676 // Make a complex type.
2677
2678 Named_type*
2679 Type::make_complex_type(const char* name, int bits, int runtime_type_kind)
2680 {
2681   return Complex_type::create_complex_type(name, bits, runtime_type_kind);
2682 }
2683
2684 // Make an abstract complex type.
2685
2686 Complex_type*
2687 Type::make_abstract_complex_type()
2688 {
2689   return Complex_type::create_abstract_complex_type();
2690 }
2691
2692 // Look up a complex type.
2693
2694 Named_type*
2695 Type::lookup_complex_type(const char* name)
2696 {
2697   return Complex_type::lookup_complex_type(name);
2698 }
2699
2700 // Class String_type.
2701
2702 // Convert String_type to the backend representation.  A string is a
2703 // struct with two fields: a pointer to the characters and a length.
2704
2705 Btype*
2706 String_type::do_get_backend(Gogo* gogo)
2707 {
2708   static Btype* backend_string_type;
2709   if (backend_string_type == NULL)
2710     {
2711       std::vector<Backend::Btyped_identifier> fields(2);
2712
2713       Type* b = gogo->lookup_global("byte")->type_value();
2714       Type* pb = Type::make_pointer_type(b);
2715       fields[0].name = "__data";
2716       fields[0].btype = pb->get_backend(gogo);
2717       fields[0].location = Linemap::predeclared_location();
2718
2719       Type* int_type = Type::lookup_integer_type("int");
2720       fields[1].name = "__length";
2721       fields[1].btype = int_type->get_backend(gogo);
2722       fields[1].location = fields[0].location;
2723
2724       backend_string_type = gogo->backend()->struct_type(fields);
2725     }
2726   return backend_string_type;
2727 }
2728
2729 // Return a tree for the length of STRING.
2730
2731 tree
2732 String_type::length_tree(Gogo*, tree string)
2733 {
2734   tree string_type = TREE_TYPE(string);
2735   go_assert(TREE_CODE(string_type) == RECORD_TYPE);
2736   tree length_field = DECL_CHAIN(TYPE_FIELDS(string_type));
2737   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(length_field)),
2738                     "__length") == 0);
2739   return fold_build3(COMPONENT_REF, integer_type_node, string,
2740                      length_field, NULL_TREE);
2741 }
2742
2743 // Return a tree for a pointer to the bytes of STRING.
2744
2745 tree
2746 String_type::bytes_tree(Gogo*, tree string)
2747 {
2748   tree string_type = TREE_TYPE(string);
2749   go_assert(TREE_CODE(string_type) == RECORD_TYPE);
2750   tree bytes_field = TYPE_FIELDS(string_type);
2751   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(bytes_field)),
2752                     "__data") == 0);
2753   return fold_build3(COMPONENT_REF, TREE_TYPE(bytes_field), string,
2754                      bytes_field, NULL_TREE);
2755 }
2756
2757 // The type descriptor for the string type.
2758
2759 Expression*
2760 String_type::do_type_descriptor(Gogo* gogo, Named_type* name)
2761 {
2762   if (name != NULL)
2763     return this->plain_type_descriptor(gogo, RUNTIME_TYPE_KIND_STRING, name);
2764   else
2765     {
2766       Named_object* no = gogo->lookup_global("string");
2767       go_assert(no != NULL);
2768       return Type::type_descriptor(gogo, no->type_value());
2769     }
2770 }
2771
2772 // We should not be asked for the reflection string of a basic type.
2773
2774 void
2775 String_type::do_reflection(Gogo*, std::string* ret) const
2776 {
2777   ret->append("string");
2778 }
2779
2780 // Mangled name of a string type.
2781
2782 void
2783 String_type::do_mangled_name(Gogo*, std::string* ret) const
2784 {
2785   ret->push_back('z');
2786 }
2787
2788 // Make a string type.
2789
2790 Type*
2791 Type::make_string_type()
2792 {
2793   static String_type string_type;
2794   return &string_type;
2795 }
2796
2797 // The named type "string".
2798
2799 static Named_type* named_string_type;
2800
2801 // Get the named type "string".
2802
2803 Named_type*
2804 Type::lookup_string_type()
2805 {
2806   return named_string_type;
2807 }
2808
2809 // Make the named type string.
2810
2811 Named_type*
2812 Type::make_named_string_type()
2813 {
2814   Type* string_type = Type::make_string_type();
2815   Named_object* named_object =
2816     Named_object::make_type("string", NULL, string_type,
2817                             Linemap::predeclared_location());
2818   Named_type* named_type = named_object->type_value();
2819   named_string_type = named_type;
2820   return named_type;
2821 }
2822
2823 // The sink type.  This is the type of the blank identifier _.  Any
2824 // type may be assigned to it.
2825
2826 class Sink_type : public Type
2827 {
2828  public:
2829   Sink_type()
2830     : Type(TYPE_SINK)
2831   { }
2832
2833  protected:
2834   bool
2835   do_compare_is_identity(Gogo*) const
2836   { return false; }
2837
2838   Btype*
2839   do_get_backend(Gogo*)
2840   { go_unreachable(); }
2841
2842   Expression*
2843   do_type_descriptor(Gogo*, Named_type*)
2844   { go_unreachable(); }
2845
2846   void
2847   do_reflection(Gogo*, std::string*) const
2848   { go_unreachable(); }
2849
2850   void
2851   do_mangled_name(Gogo*, std::string*) const
2852   { go_unreachable(); }
2853 };
2854
2855 // Make the sink type.
2856
2857 Type*
2858 Type::make_sink_type()
2859 {
2860   static Sink_type sink_type;
2861   return &sink_type;
2862 }
2863
2864 // Class Function_type.
2865
2866 // Traversal.
2867
2868 int
2869 Function_type::do_traverse(Traverse* traverse)
2870 {
2871   if (this->receiver_ != NULL
2872       && Type::traverse(this->receiver_->type(), traverse) == TRAVERSE_EXIT)
2873     return TRAVERSE_EXIT;
2874   if (this->parameters_ != NULL
2875       && this->parameters_->traverse(traverse) == TRAVERSE_EXIT)
2876     return TRAVERSE_EXIT;
2877   if (this->results_ != NULL
2878       && this->results_->traverse(traverse) == TRAVERSE_EXIT)
2879     return TRAVERSE_EXIT;
2880   return TRAVERSE_CONTINUE;
2881 }
2882
2883 // Returns whether T is a valid redeclaration of this type.  If this
2884 // returns false, and REASON is not NULL, *REASON may be set to a
2885 // brief explanation of why it returned false.
2886
2887 bool
2888 Function_type::is_valid_redeclaration(const Function_type* t,
2889                                       std::string* reason) const
2890 {
2891   if (!this->is_identical(t, false, true, reason))
2892     return false;
2893
2894   // A redeclaration of a function is required to use the same names
2895   // for the receiver and parameters.
2896   if (this->receiver() != NULL
2897       && this->receiver()->name() != t->receiver()->name()
2898       && this->receiver()->name() != Import::import_marker
2899       && t->receiver()->name() != Import::import_marker)
2900     {
2901       if (reason != NULL)
2902         *reason = "receiver name changed";
2903       return false;
2904     }
2905
2906   const Typed_identifier_list* parms1 = this->parameters();
2907   const Typed_identifier_list* parms2 = t->parameters();
2908   if (parms1 != NULL)
2909     {
2910       Typed_identifier_list::const_iterator p1 = parms1->begin();
2911       for (Typed_identifier_list::const_iterator p2 = parms2->begin();
2912            p2 != parms2->end();
2913            ++p2, ++p1)
2914         {
2915           if (p1->name() != p2->name()
2916               && p1->name() != Import::import_marker
2917               && p2->name() != Import::import_marker)
2918             {
2919               if (reason != NULL)
2920                 *reason = "parameter name changed";
2921               return false;
2922             }
2923
2924           // This is called at parse time, so we may have unknown
2925           // types.
2926           Type* t1 = p1->type()->forwarded();
2927           Type* t2 = p2->type()->forwarded();
2928           if (t1 != t2
2929               && t1->forward_declaration_type() != NULL
2930               && (t2->forward_declaration_type() == NULL
2931                   || (t1->forward_declaration_type()->named_object()
2932                       != t2->forward_declaration_type()->named_object())))
2933             return false;
2934         }
2935     }
2936
2937   const Typed_identifier_list* results1 = this->results();
2938   const Typed_identifier_list* results2 = t->results();
2939   if (results1 != NULL)
2940     {
2941       Typed_identifier_list::const_iterator res1 = results1->begin();
2942       for (Typed_identifier_list::const_iterator res2 = results2->begin();
2943            res2 != results2->end();
2944            ++res2, ++res1)
2945         {
2946           if (res1->name() != res2->name()
2947               && res1->name() != Import::import_marker
2948               && res2->name() != Import::import_marker)
2949             {
2950               if (reason != NULL)
2951                 *reason = "result name changed";
2952               return false;
2953             }
2954
2955           // This is called at parse time, so we may have unknown
2956           // types.
2957           Type* t1 = res1->type()->forwarded();
2958           Type* t2 = res2->type()->forwarded();
2959           if (t1 != t2
2960               && t1->forward_declaration_type() != NULL
2961               && (t2->forward_declaration_type() == NULL
2962                   || (t1->forward_declaration_type()->named_object()
2963                       != t2->forward_declaration_type()->named_object())))
2964             return false;
2965         }
2966     }
2967
2968   return true;
2969 }
2970
2971 // Check whether T is the same as this type.
2972
2973 bool
2974 Function_type::is_identical(const Function_type* t, bool ignore_receiver,
2975                             bool errors_are_identical,
2976                             std::string* reason) const
2977 {
2978   if (!ignore_receiver)
2979     {
2980       const Typed_identifier* r1 = this->receiver();
2981       const Typed_identifier* r2 = t->receiver();
2982       if ((r1 != NULL) != (r2 != NULL))
2983         {
2984           if (reason != NULL)
2985             *reason = _("different receiver types");
2986           return false;
2987         }
2988       if (r1 != NULL)
2989         {
2990           if (!Type::are_identical(r1->type(), r2->type(), errors_are_identical,
2991                                    reason))
2992             {
2993               if (reason != NULL && !reason->empty())
2994                 *reason = "receiver: " + *reason;
2995               return false;
2996             }
2997         }
2998     }
2999
3000   const Typed_identifier_list* parms1 = this->parameters();
3001   const Typed_identifier_list* parms2 = t->parameters();
3002   if ((parms1 != NULL) != (parms2 != NULL))
3003     {
3004       if (reason != NULL)
3005         *reason = _("different number of parameters");
3006       return false;
3007     }
3008   if (parms1 != NULL)
3009     {
3010       Typed_identifier_list::const_iterator p1 = parms1->begin();
3011       for (Typed_identifier_list::const_iterator p2 = parms2->begin();
3012            p2 != parms2->end();
3013            ++p2, ++p1)
3014         {
3015           if (p1 == parms1->end())
3016             {
3017               if (reason != NULL)
3018                 *reason = _("different number of parameters");
3019               return false;
3020             }
3021
3022           if (!Type::are_identical(p1->type(), p2->type(),
3023                                    errors_are_identical, NULL))
3024             {
3025               if (reason != NULL)
3026                 *reason = _("different parameter types");
3027               return false;
3028             }
3029         }
3030       if (p1 != parms1->end())
3031         {
3032           if (reason != NULL)
3033             *reason = _("different number of parameters");
3034         return false;
3035         }
3036     }
3037
3038   if (this->is_varargs() != t->is_varargs())
3039     {
3040       if (reason != NULL)
3041         *reason = _("different varargs");
3042       return false;
3043     }
3044
3045   const Typed_identifier_list* results1 = this->results();
3046   const Typed_identifier_list* results2 = t->results();
3047   if ((results1 != NULL) != (results2 != NULL))
3048     {
3049       if (reason != NULL)
3050         *reason = _("different number of results");
3051       return false;
3052     }
3053   if (results1 != NULL)
3054     {
3055       Typed_identifier_list::const_iterator res1 = results1->begin();
3056       for (Typed_identifier_list::const_iterator res2 = results2->begin();
3057            res2 != results2->end();
3058            ++res2, ++res1)
3059         {
3060           if (res1 == results1->end())
3061             {
3062               if (reason != NULL)
3063                 *reason = _("different number of results");
3064               return false;
3065             }
3066
3067           if (!Type::are_identical(res1->type(), res2->type(),
3068                                    errors_are_identical, NULL))
3069             {
3070               if (reason != NULL)
3071                 *reason = _("different result types");
3072               return false;
3073             }
3074         }
3075       if (res1 != results1->end())
3076         {
3077           if (reason != NULL)
3078             *reason = _("different number of results");
3079           return false;
3080         }
3081     }
3082
3083   return true;
3084 }
3085
3086 // Hash code.
3087
3088 unsigned int
3089 Function_type::do_hash_for_method(Gogo* gogo) const
3090 {
3091   unsigned int ret = 0;
3092   // We ignore the receiver type for hash codes, because we need to
3093   // get the same hash code for a method in an interface and a method
3094   // declared for a type.  The former will not have a receiver.
3095   if (this->parameters_ != NULL)
3096     {
3097       int shift = 1;
3098       for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
3099            p != this->parameters_->end();
3100            ++p, ++shift)
3101         ret += p->type()->hash_for_method(gogo) << shift;
3102     }
3103   if (this->results_ != NULL)
3104     {
3105       int shift = 2;
3106       for (Typed_identifier_list::const_iterator p = this->results_->begin();
3107            p != this->results_->end();
3108            ++p, ++shift)
3109         ret += p->type()->hash_for_method(gogo) << shift;
3110     }
3111   if (this->is_varargs_)
3112     ret += 1;
3113   ret <<= 4;
3114   return ret;
3115 }
3116
3117 // Get the backend representation for a function type.
3118
3119 Btype*
3120 Function_type::get_function_backend(Gogo* gogo)
3121 {
3122   Backend::Btyped_identifier breceiver;
3123   if (this->receiver_ != NULL)
3124     {
3125       breceiver.name = Gogo::unpack_hidden_name(this->receiver_->name());
3126
3127       // We always pass the address of the receiver parameter, in
3128       // order to make interface calls work with unknown types.
3129       Type* rtype = this->receiver_->type();
3130       if (rtype->points_to() == NULL)
3131         rtype = Type::make_pointer_type(rtype);
3132       breceiver.btype = rtype->get_backend(gogo);
3133       breceiver.location = this->receiver_->location();
3134     }
3135
3136   std::vector<Backend::Btyped_identifier> bparameters;
3137   if (this->parameters_ != NULL)
3138     {
3139       bparameters.resize(this->parameters_->size());
3140       size_t i = 0;
3141       for (Typed_identifier_list::const_iterator p = this->parameters_->begin();
3142            p != this->parameters_->end();
3143            ++p, ++i)
3144         {
3145           bparameters[i].name = Gogo::unpack_hidden_name(p->name());
3146           bparameters[i].btype = p->type()->get_backend(gogo);
3147           bparameters[i].location = p->location();
3148         }
3149       go_assert(i == bparameters.size());
3150     }
3151
3152   std::vector<Backend::Btyped_identifier> bresults;
3153   if (this->results_ != NULL)
3154     {
3155       bresults.resize(this->results_->size());
3156       size_t i = 0;
3157       for (Typed_identifier_list::const_iterator p = this->results_->begin();
3158            p != this->results_->end();
3159            ++p, ++i)
3160         {
3161           bresults[i].name = Gogo::unpack_hidden_name(p->name());
3162           bresults[i].btype = p->type()->get_backend(gogo);
3163           bresults[i].location = p->location();
3164         }
3165       go_assert(i == bresults.size());
3166     }
3167
3168   return gogo->backend()->function_type(breceiver, bparameters, bresults,
3169                                         this->location());
3170 }
3171
3172 // A hash table mapping function types to their backend placeholders.
3173
3174 Function_type::Placeholders Function_type::placeholders;
3175
3176 // Get the backend representation for a function type.  If we are
3177 // still converting types, and this types has multiple results, return
3178 // a placeholder instead.  We do this because for multiple results we
3179 // build a struct, and we need to make sure that all the types in the
3180 // struct are valid before we create the struct.
3181
3182 Btype*
3183 Function_type::do_get_backend(Gogo* gogo)
3184 {
3185   if (!gogo->named_types_are_converted()
3186       && this->results_ != NULL
3187       && this->results_->size() > 1)
3188     {
3189       Btype* placeholder =
3190         gogo->backend()->placeholder_pointer_type("", this->location(), true);
3191       Function_type::placeholders.push_back(std::make_pair(this, placeholder));
3192       return placeholder;
3193     }
3194   return this->get_function_backend(gogo);
3195 }
3196
3197 // Convert function types after all named types are converted.
3198
3199 void
3200 Function_type::convert_types(Gogo* gogo)
3201 {
3202   for (Placeholders::const_iterator p = Function_type::placeholders.begin();
3203        p != Function_type::placeholders.end();
3204        ++p)
3205     {
3206       Btype* bt = p->first->get_function_backend(gogo);
3207       if (!gogo->backend()->set_placeholder_function_type(p->second, bt))
3208         go_assert(saw_errors());
3209     }
3210 }
3211
3212 // The type of a function type descriptor.
3213
3214 Type*
3215 Function_type::make_function_type_descriptor_type()
3216 {
3217   static Type* ret;
3218   if (ret == NULL)
3219     {
3220       Type* tdt = Type::make_type_descriptor_type();
3221       Type* ptdt = Type::make_type_descriptor_ptr_type();
3222
3223       Type* bool_type = Type::lookup_bool_type();
3224
3225       Type* slice_type = Type::make_array_type(ptdt, NULL);
3226
3227       Struct_type* s = Type::make_builtin_struct_type(4,
3228                                                       "", tdt,
3229                                                       "dotdotdot", bool_type,
3230                                                       "in", slice_type,
3231                                                       "out", slice_type);
3232
3233       ret = Type::make_builtin_named_type("FuncType", s);
3234     }
3235
3236   return ret;
3237 }
3238
3239 // The type descriptor for a function type.
3240
3241 Expression*
3242 Function_type::do_type_descriptor(Gogo* gogo, Named_type* name)
3243 {
3244   Location bloc = Linemap::predeclared_location();
3245
3246   Type* ftdt = Function_type::make_function_type_descriptor_type();
3247
3248   const Struct_field_list* fields = ftdt->struct_type()->fields();
3249
3250   Expression_list* vals = new Expression_list();
3251   vals->reserve(4);
3252
3253   Struct_field_list::const_iterator p = fields->begin();
3254   go_assert(p->is_field_name("commonType"));
3255   vals->push_back(this->type_descriptor_constructor(gogo,
3256                                                     RUNTIME_TYPE_KIND_FUNC,
3257                                                     name, NULL, true));
3258
3259   ++p;
3260   go_assert(p->is_field_name("dotdotdot"));
3261   vals->push_back(Expression::make_boolean(this->is_varargs(), bloc));
3262
3263   ++p;
3264   go_assert(p->is_field_name("in"));
3265   vals->push_back(this->type_descriptor_params(p->type(), this->receiver(),
3266                                                this->parameters()));
3267
3268   ++p;
3269   go_assert(p->is_field_name("out"));
3270   vals->push_back(this->type_descriptor_params(p->type(), NULL,
3271                                                this->results()));
3272
3273   ++p;
3274   go_assert(p == fields->end());
3275
3276   return Expression::make_struct_composite_literal(ftdt, vals, bloc);
3277 }
3278
3279 // Return a composite literal for the parameters or results of a type
3280 // descriptor.
3281
3282 Expression*
3283 Function_type::type_descriptor_params(Type* params_type,
3284                                       const Typed_identifier* receiver,
3285                                       const Typed_identifier_list* params)
3286 {
3287   Location bloc = Linemap::predeclared_location();
3288
3289   if (receiver == NULL && params == NULL)
3290     return Expression::make_slice_composite_literal(params_type, NULL, bloc);
3291
3292   Expression_list* vals = new Expression_list();
3293   vals->reserve((params == NULL ? 0 : params->size())
3294                 + (receiver != NULL ? 1 : 0));
3295
3296   if (receiver != NULL)
3297     vals->push_back(Expression::make_type_descriptor(receiver->type(), bloc));
3298
3299   if (params != NULL)
3300     {
3301       for (Typed_identifier_list::const_iterator p = params->begin();
3302            p != params->end();
3303            ++p)
3304         vals->push_back(Expression::make_type_descriptor(p->type(), bloc));
3305     }
3306
3307   return Expression::make_slice_composite_literal(params_type, vals, bloc);
3308 }
3309
3310 // The reflection string.
3311
3312 void
3313 Function_type::do_reflection(Gogo* gogo, std::string* ret) const
3314 {
3315   // FIXME: Turn this off until we straighten out the type of the
3316   // struct field used in a go statement which calls a method.
3317   // go_assert(this->receiver_ == NULL);
3318
3319   ret->append("func");
3320
3321   if (this->receiver_ != NULL)
3322     {
3323       ret->push_back('(');
3324       this->append_reflection(this->receiver_->type(), gogo, ret);
3325       ret->push_back(')');
3326     }
3327
3328   ret->push_back('(');
3329   const Typed_identifier_list* params = this->parameters();
3330   if (params != NULL)
3331     {
3332       bool is_varargs = this->is_varargs_;
3333       for (Typed_identifier_list::const_iterator p = params->begin();
3334            p != params->end();
3335            ++p)
3336         {
3337           if (p != params->begin())
3338             ret->append(", ");
3339           if (!is_varargs || p + 1 != params->end())
3340             this->append_reflection(p->type(), gogo, ret);
3341           else
3342             {
3343               ret->append("...");
3344               this->append_reflection(p->type()->array_type()->element_type(),
3345                                       gogo, ret);
3346             }
3347         }
3348     }
3349   ret->push_back(')');
3350
3351   const Typed_identifier_list* results = this->results();
3352   if (results != NULL && !results->empty())
3353     {
3354       if (results->size() == 1)
3355         ret->push_back(' ');
3356       else
3357         ret->append(" (");
3358       for (Typed_identifier_list::const_iterator p = results->begin();
3359            p != results->end();
3360            ++p)
3361         {
3362           if (p != results->begin())
3363             ret->append(", ");
3364           this->append_reflection(p->type(), gogo, ret);
3365         }
3366       if (results->size() > 1)
3367         ret->push_back(')');
3368     }
3369 }
3370
3371 // Mangled name.
3372
3373 void
3374 Function_type::do_mangled_name(Gogo* gogo, std::string* ret) const
3375 {
3376   ret->push_back('F');
3377
3378   if (this->receiver_ != NULL)
3379     {
3380       ret->push_back('m');
3381       this->append_mangled_name(this->receiver_->type(), gogo, ret);
3382     }
3383
3384   const Typed_identifier_list* params = this->parameters();
3385   if (params != NULL)
3386     {
3387       ret->push_back('p');
3388       for (Typed_identifier_list::const_iterator p = params->begin();
3389            p != params->end();
3390            ++p)
3391         this->append_mangled_name(p->type(), gogo, ret);
3392       if (this->is_varargs_)
3393         ret->push_back('V');
3394       ret->push_back('e');
3395     }
3396
3397   const Typed_identifier_list* results = this->results();
3398   if (results != NULL)
3399     {
3400       ret->push_back('r');
3401       for (Typed_identifier_list::const_iterator p = results->begin();
3402            p != results->end();
3403            ++p)
3404         this->append_mangled_name(p->type(), gogo, ret);
3405       ret->push_back('e');
3406     }
3407
3408   ret->push_back('e');
3409 }
3410
3411 // Export a function type.
3412
3413 void
3414 Function_type::do_export(Export* exp) const
3415 {
3416   // We don't write out the receiver.  The only function types which
3417   // should have a receiver are the ones associated with explicitly
3418   // defined methods.  For those the receiver type is written out by
3419   // Function::export_func.
3420
3421   exp->write_c_string("(");
3422   bool first = true;
3423   if (this->parameters_ != NULL)
3424     {
3425       bool is_varargs = this->is_varargs_;
3426       for (Typed_identifier_list::const_iterator p =
3427              this->parameters_->begin();
3428            p != this->parameters_->end();
3429            ++p)
3430         {
3431           if (first)
3432             first = false;
3433           else
3434             exp->write_c_string(", ");
3435           if (!is_varargs || p + 1 != this->parameters_->end())
3436             exp->write_type(p->type());
3437           else
3438             {
3439               exp->write_c_string("...");
3440               exp->write_type(p->type()->array_type()->element_type());
3441             }
3442         }
3443     }
3444   exp->write_c_string(")");
3445
3446   const Typed_identifier_list* results = this->results_;
3447   if (results != NULL)
3448     {
3449       exp->write_c_string(" ");
3450       if (results->size() == 1)
3451         exp->write_type(results->begin()->type());
3452       else
3453         {
3454           first = true;
3455           exp->write_c_string("(");
3456           for (Typed_identifier_list::const_iterator p = results->begin();
3457                p != results->end();
3458                ++p)
3459             {
3460               if (first)
3461                 first = false;
3462               else
3463                 exp->write_c_string(", ");
3464               exp->write_type(p->type());
3465             }
3466           exp->write_c_string(")");
3467         }
3468     }
3469 }
3470
3471 // Import a function type.
3472
3473 Function_type*
3474 Function_type::do_import(Import* imp)
3475 {
3476   imp->require_c_string("(");
3477   Typed_identifier_list* parameters;
3478   bool is_varargs = false;
3479   if (imp->peek_char() == ')')
3480     parameters = NULL;
3481   else
3482     {
3483       parameters = new Typed_identifier_list();
3484       while (true)
3485         {
3486           if (imp->match_c_string("..."))
3487             {
3488               imp->advance(3);
3489               is_varargs = true;
3490             }
3491
3492           Type* ptype = imp->read_type();
3493           if (is_varargs)
3494             ptype = Type::make_array_type(ptype, NULL);
3495           parameters->push_back(Typed_identifier(Import::import_marker,
3496                                                  ptype, imp->location()));
3497           if (imp->peek_char() != ',')
3498             break;
3499           go_assert(!is_varargs);
3500           imp->require_c_string(", ");
3501         }
3502     }
3503   imp->require_c_string(")");
3504
3505   Typed_identifier_list* results;
3506   if (imp->peek_char() != ' ')
3507     results = NULL;
3508   else
3509     {
3510       imp->advance(1);
3511       results = new Typed_identifier_list;
3512       if (imp->peek_char() != '(')
3513         {
3514           Type* rtype = imp->read_type();
3515           results->push_back(Typed_identifier(Import::import_marker, rtype,
3516                                               imp->location()));
3517         }
3518       else
3519         {
3520           imp->advance(1);
3521           while (true)
3522             {