1 // types.h -- Go frontend types. -*- C++ -*-
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.
10 #include "go-linemap.h"
15 class Typed_identifier
;
16 class Typed_identifier_list
;
23 class Struct_field_list
;
31 class Forward_declaration_type
;
34 class Type_hash_identical
;
37 class Expression_list
;
38 class Call_expression
;
39 class Field_reference_expression
;
40 class Bound_method_expression
;
44 class Translate_context
;
51 // Type codes used in type descriptors. These must match the values
52 // in libgo/runtime/go-type.h. They also match the values in the gc
53 // compiler in src/cmd/gc/reflect.c and src/pkg/runtime/type.go,
54 // although this is not required.
56 static const int RUNTIME_TYPE_KIND_BOOL
= 1;
57 static const int RUNTIME_TYPE_KIND_INT
= 2;
58 static const int RUNTIME_TYPE_KIND_INT8
= 3;
59 static const int RUNTIME_TYPE_KIND_INT16
= 4;
60 static const int RUNTIME_TYPE_KIND_INT32
= 5;
61 static const int RUNTIME_TYPE_KIND_INT64
= 6;
62 static const int RUNTIME_TYPE_KIND_UINT
= 7;
63 static const int RUNTIME_TYPE_KIND_UINT8
= 8;
64 static const int RUNTIME_TYPE_KIND_UINT16
= 9;
65 static const int RUNTIME_TYPE_KIND_UINT32
= 10;
66 static const int RUNTIME_TYPE_KIND_UINT64
= 11;
67 static const int RUNTIME_TYPE_KIND_UINTPTR
= 12;
68 static const int RUNTIME_TYPE_KIND_FLOAT32
= 13;
69 static const int RUNTIME_TYPE_KIND_FLOAT64
= 14;
70 static const int RUNTIME_TYPE_KIND_COMPLEX64
= 15;
71 static const int RUNTIME_TYPE_KIND_COMPLEX128
= 16;
72 static const int RUNTIME_TYPE_KIND_ARRAY
= 17;
73 static const int RUNTIME_TYPE_KIND_CHAN
= 18;
74 static const int RUNTIME_TYPE_KIND_FUNC
= 19;
75 static const int RUNTIME_TYPE_KIND_INTERFACE
= 20;
76 static const int RUNTIME_TYPE_KIND_MAP
= 21;
77 static const int RUNTIME_TYPE_KIND_PTR
= 22;
78 static const int RUNTIME_TYPE_KIND_SLICE
= 23;
79 static const int RUNTIME_TYPE_KIND_STRING
= 24;
80 static const int RUNTIME_TYPE_KIND_STRUCT
= 25;
81 static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER
= 26;
83 static const int RUNTIME_TYPE_KIND_NO_POINTERS
= (1 << 7);
85 // To build the complete list of methods for a named type we need to
86 // gather all methods from anonymous fields. Those methods may
87 // require an arbitrary set of indirections and field offsets. There
88 // is also the possibility of ambiguous methods, which we could ignore
89 // except that we want to give a better error message for that case.
90 // This is a base class. There are two types of methods: named
91 // methods, and methods which are inherited from an anonymous field of
97 // For methods in anonymous types we need to know the sequence of
98 // field references used to extract the pointer to pass to the
99 // method. Since each method for a particular anonymous field will
100 // have the sequence of field indexes, and since the indexes can be
101 // shared going down the chain, we use a manually managed linked
102 // list. The first entry in the list is the field index for the
103 // last field, the one passed to the method.
107 const Field_indexes
* next
;
108 unsigned int field_index
;
114 // Get the list of field indexes.
116 field_indexes() const
117 { return this->field_indexes_
; }
122 { return this->depth_
; }
124 // Return whether this is a value method--a method which does not
125 // require a pointer expression.
127 is_value_method() const
128 { return this->is_value_method_
; }
130 // Return whether we need a stub method--this is true if we can't
131 // just pass the main object to the method.
133 needs_stub_method() const
134 { return this->needs_stub_method_
; }
136 // Return whether this is an ambiguous method name.
139 { return this->is_ambiguous_
; }
141 // Note that this method is ambiguous.
144 { this->is_ambiguous_
= true; }
146 // Return the type of the method.
149 { return this->do_type(); }
151 // Return the location of the method receiver.
153 receiver_location() const
154 { return this->do_receiver_location(); }
156 // Return an expression which binds this method to EXPR. This is
157 // something which can be used with a function call.
159 bind_method(Expression
* expr
, Location location
) const;
161 // Return the named object for this method. This may only be called
162 // after methods are finalized.
164 named_object() const;
166 // Get the stub object.
170 go_assert(this->stub_
!= NULL
);
174 // Set the stub object.
176 set_stub_object(Named_object
* no
)
178 go_assert(this->stub_
== NULL
);
182 // Return true if this method should not participate in any
186 { return this->do_nointerface(); }
189 // These objects are only built by the child classes.
190 Method(const Field_indexes
* field_indexes
, unsigned int depth
,
191 bool is_value_method
, bool needs_stub_method
)
192 : field_indexes_(field_indexes
), depth_(depth
), stub_(NULL
),
193 is_value_method_(is_value_method
), needs_stub_method_(needs_stub_method
),
197 // The named object for this method.
198 virtual Named_object
*
199 do_named_object() const = 0;
201 // The type of the method.
202 virtual Function_type
*
205 // Return the location of the method receiver.
207 do_receiver_location() const = 0;
209 // Bind a method to an object.
211 do_bind_method(Expression
* expr
, Location location
) const = 0;
213 // Return whether this method should not participate in interfaces.
215 do_nointerface() const = 0;
218 // The sequence of field indexes used for this method. If this is
219 // NULL, then the method is defined for the current type.
220 const Field_indexes
* field_indexes_
;
221 // The depth at which this method was found.
223 // If a stub method is required, this is its object. This is only
224 // set after stub methods are built in finalize_methods.
226 // Whether this is a value method--a method that does not require a
228 bool is_value_method_
;
229 // Whether a stub method is required.
230 bool needs_stub_method_
;
231 // Whether this method is ambiguous.
235 // A named method. This is what you get with a method declaration,
236 // either directly on the type, or inherited from some anonymous
239 class Named_method
: public Method
242 Named_method(Named_object
* named_object
, const Field_indexes
* field_indexes
,
243 unsigned int depth
, bool is_value_method
,
244 bool needs_stub_method
)
245 : Method(field_indexes
, depth
, is_value_method
, needs_stub_method
),
246 named_object_(named_object
)
250 // Get the Named_object for the method.
252 do_named_object() const
253 { return this->named_object_
; }
255 // The type of the method.
259 // Return the location of the method receiver.
261 do_receiver_location() const;
263 // Bind a method to an object.
265 do_bind_method(Expression
* expr
, Location location
) const;
267 // Return whether this method should not participate in interfaces.
269 do_nointerface() const;
272 // The method itself. For a method which needs a stub, this starts
273 // out as the underlying method, and is later replaced with the stub
275 Named_object
* named_object_
;
278 // An interface method. This is used when an interface appears as an
279 // anonymous field in a named struct.
281 class Interface_method
: public Method
284 Interface_method(const std::string
& name
, Location location
,
285 Function_type
* fntype
, const Field_indexes
* field_indexes
,
287 : Method(field_indexes
, depth
, true, true),
288 name_(name
), location_(location
), fntype_(fntype
)
292 // Get the Named_object for the method. This should never be
293 // called, as we always create a stub.
295 do_named_object() const
296 { go_unreachable(); }
298 // The type of the method.
301 { return this->fntype_
; }
303 // Return the location of the method receiver.
305 do_receiver_location() const
306 { return this->location_
; }
308 // Bind a method to an object.
310 do_bind_method(Expression
* expr
, Location location
) const;
312 // Return whether this method should not participate in interfaces.
314 do_nointerface() const
318 // The name of the interface method to call.
320 // The location of the definition of the interface method.
322 // The type of the interface method.
323 Function_type
* fntype_
;
326 // A mapping from method name to Method. This is a wrapper around a
332 typedef Unordered_map(std::string
, Method
*) Method_map
;
335 typedef Method_map::const_iterator const_iterator
;
341 // Insert a new method. Returns true if it was inserted, false if
342 // it was overidden or ambiguous.
344 insert(const std::string
& name
, Method
* m
);
346 // The number of (unambiguous) methods.
353 { return this->methods_
.begin(); }
357 { return this->methods_
.end(); }
361 find(const std::string
& name
) const
362 { return this->methods_
.find(name
); }
368 // The base class for all types.
373 // The types of types.
374 enum Type_classification
387 TYPE_CALL_MULTIPLE_RESULT
,
407 // Get the unnamed bool type.
411 // Get the named type "bool".
415 // Make the named type "bool".
417 make_named_bool_type();
419 // Make an abstract integer type.
421 make_abstract_integer_type();
423 // Make an abstract type for a character constant.
425 make_abstract_character_type();
427 // Make a named integer type with a specified size.
428 // RUNTIME_TYPE_KIND is the code to use in reflection information,
429 // to distinguish int and int32.
431 make_integer_type(const char* name
, bool is_unsigned
, int bits
,
432 int runtime_type_kind
);
434 // Look up a named integer type.
436 lookup_integer_type(const char* name
);
438 // Make an abstract floating point type.
440 make_abstract_float_type();
442 // Make a named floating point type with a specific size.
443 // RUNTIME_TYPE_KIND is the code to use in reflection information,
444 // to distinguish float and float32.
446 make_float_type(const char* name
, int bits
, int runtime_type_kind
);
448 // Look up a named float type.
450 lookup_float_type(const char* name
);
452 // Make an abstract complex type.
454 make_abstract_complex_type();
456 // Make a named complex type with a specific size.
457 // RUNTIME_TYPE_KIND is the code to use in reflection information,
458 // to distinguish complex and complex64.
460 make_complex_type(const char* name
, int bits
, int runtime_type_kind
);
462 // Look up a named complex type.
464 lookup_complex_type(const char* name
);
466 // Get the unnamed string type.
470 // Get the named type "string".
472 lookup_string_type();
474 // Make the named type "string".
476 make_named_string_type();
481 static Function_type
*
482 make_function_type(Typed_identifier
* receiver
,
483 Typed_identifier_list
* parameters
,
484 Typed_identifier_list
* results
,
488 make_pointer_type(Type
*);
494 make_call_multiple_result_type(Call_expression
*);
497 make_struct_type(Struct_field_list
* fields
, Location
);
500 make_array_type(Type
* element_type
, Expression
* length
);
503 make_map_type(Type
* key_type
, Type
* value_type
, Location
);
506 make_channel_type(bool send
, bool receive
, Type
*);
508 static Interface_type
*
509 make_interface_type(Typed_identifier_list
* methods
, Location
);
511 static Interface_type
*
512 make_empty_interface_type(Location
);
515 make_type_descriptor_type();
518 make_type_descriptor_ptr_type();
521 make_named_type(Named_object
*, Type
*, Location
);
524 make_forward_declaration(Named_object
*);
526 // Make a builtin struct type from a list of fields.
528 make_builtin_struct_type(int nfields
, ...);
530 // Make a builtin named type.
532 make_builtin_named_type(const char* name
, Type
* type
);
536 traverse(Type
*, Traverse
*);
538 // Verify the type. This is called after parsing, and verifies that
539 // types are complete and meet the language requirements. This
540 // returns false if the type is invalid and we should not continue
544 { return this->do_verify(); }
546 // Return true if two types are identical. If ERRORS_ARE_IDENTICAL,
547 // returns that an erroneous type is identical to any other type;
548 // this is used to avoid cascading errors. If this returns false,
549 // and REASON is not NULL, it may set *REASON.
551 are_identical(const Type
* lhs
, const Type
* rhs
, bool errors_are_identical
,
552 std::string
* reason
);
554 // Return true if two types are compatible for use in a binary
555 // operation, other than a shift, comparison, or channel send. This
556 // is an equivalence relation.
558 are_compatible_for_binop(const Type
* t1
, const Type
* t2
);
560 // Return true if two types are compatible for use with the
561 // comparison operator. IS_EQUALITY_OP is true if this is an
562 // equality comparison, false if it is an ordered comparison. This
563 // is an equivalence relation. If this returns false, and REASON is
564 // not NULL, it sets *REASON.
566 are_compatible_for_comparison(bool is_equality_op
, const Type
*t1
,
567 const Type
*t2
, std::string
* reason
);
569 // Return true if a type is comparable with itself. This is true of
570 // most types, but false for, e.g., function types.
572 is_comparable() const
573 { return Type::are_compatible_for_comparison(true, this, this, NULL
); }
575 // Return true if a value with type RHS is assignable to a variable
576 // with type LHS. This is not an equivalence relation. If this
577 // returns false, and REASON is not NULL, it sets *REASON.
579 are_assignable(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
581 // Return true if a value with type RHS is assignable to a variable
582 // with type LHS, ignoring any assignment of hidden fields
583 // (unexported fields of a type imported from another package).
584 // This is like the are_assignable method.
586 are_assignable_hidden_ok(const Type
* lhs
, const Type
* rhs
,
587 std::string
* reason
);
589 // Return true if a value with type RHS may be converted to type
590 // LHS. If this returns false, and REASON is not NULL, it sets
593 are_convertible(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
595 // Whether this type has any hidden fields which are not visible in
596 // the current compilation, such as a field whose name begins with a
597 // lower case letter in a struct imported from a different package.
598 // WITHIN is not NULL if we are looking at fields in a named type.
600 has_hidden_fields(const Named_type
* within
, std::string
* reason
) const;
602 // Return true if values of this type can be compared using an
603 // identity function which gets nothing but a pointer to the value
606 compare_is_identity(Gogo
* gogo
)
607 { return this->do_compare_is_identity(gogo
); }
609 // Return a hash code for this type for the method hash table.
610 // Types which are equivalent according to are_identical will have
611 // the same hash code.
613 hash_for_method(Gogo
*) const;
615 // Return the type classification.
617 classification() const
618 { return this->classification_
; }
620 // Return the base type for this type. This looks through forward
621 // declarations and names. Using this with a forward declaration
622 // which has not been defined will return an error type.
629 // Return the type skipping defined forward declarations. If this
630 // type is a forward declaration which has not been defined, it will
631 // return the Forward_declaration_type. This differs from base() in
632 // that it will return a Named_type, and for a
633 // Forward_declaration_type which is not defined it will return that
634 // type rather than an error type.
641 // Return true if this is a basic type: a type which is not composed
642 // of other types, and is not void.
644 is_basic_type() const;
646 // Return true if this is an abstract type--an integer, floating
647 // point, or complex type whose size has not been determined.
651 // Return a non-abstract version of an abstract type.
653 make_non_abstract_type();
655 // Return true if this type is or contains a pointer. This
656 // determines whether the garbage collector needs to look at a value
660 { return this->do_has_pointer(); }
662 // Return true if this is the error type. This returns false for a
663 // type which is not defined, as it is called by the parser before
664 // all types are defined.
666 is_error_type() const;
668 // Return true if this is the error type or if the type is
669 // undefined. If the type is undefined, this will give an error.
670 // This should only be called after parsing is complete.
673 { return this->base()->is_error_type(); }
675 // Return true if this is a void type.
678 { return this->classification_
== TYPE_VOID
; }
680 // If this is an integer type, return the Integer_type. Otherwise,
681 // return NULL. This is a controlled dynamic_cast.
684 { return this->convert
<Integer_type
, TYPE_INTEGER
>(); }
688 { return this->convert
<const Integer_type
, TYPE_INTEGER
>(); }
690 // If this is a floating point type, return the Float_type.
691 // Otherwise, return NULL. This is a controlled dynamic_cast.
694 { return this->convert
<Float_type
, TYPE_FLOAT
>(); }
698 { return this->convert
<const Float_type
, TYPE_FLOAT
>(); }
700 // If this is a complex type, return the Complex_type. Otherwise,
704 { return this->convert
<Complex_type
, TYPE_COMPLEX
>(); }
708 { return this->convert
<const Complex_type
, TYPE_COMPLEX
>(); }
710 // Return whether this is a numeric type.
712 is_numeric_type() const
714 Type_classification tc
= this->base()->classification_
;
715 return tc
== TYPE_INTEGER
|| tc
== TYPE_FLOAT
|| tc
== TYPE_COMPLEX
;
718 // Return true if this is a boolean type.
720 is_boolean_type() const
721 { return this->base()->classification_
== TYPE_BOOLEAN
; }
723 // Return true if this is an abstract boolean type.
725 is_abstract_boolean_type() const
726 { return this->classification_
== TYPE_BOOLEAN
; }
728 // Return true if this is a string type.
730 is_string_type() const
731 { return this->base()->classification_
== TYPE_STRING
; }
733 // Return true if this is an abstract string type.
735 is_abstract_string_type() const
736 { return this->classification_
== TYPE_STRING
; }
738 // Return true if this is the sink type. This is the type of the
739 // blank identifier _.
742 { return this->base()->classification_
== TYPE_SINK
; }
744 // If this is a function type, return it. Otherwise, return NULL.
747 { return this->convert
<Function_type
, TYPE_FUNCTION
>(); }
750 function_type() const
751 { return this->convert
<const Function_type
, TYPE_FUNCTION
>(); }
753 // If this is a pointer type, return the type to which it points.
754 // Otherwise, return NULL.
758 // If this is a pointer type, return the type to which it points.
759 // Otherwise, return the type itself.
763 Type
* pt
= this->points_to();
764 return pt
!= NULL
? pt
: this;
770 const Type
* pt
= this->points_to();
771 return pt
!= NULL
? pt
: this;
774 // Return true if this is the nil type. We don't use base() here,
775 // because this can be called during parse, and there is no way to
776 // name the nil type anyhow.
779 { return this->classification_
== TYPE_NIL
; }
781 // Return true if this is the predeclared constant nil being used as
782 // a type. This is what the parser produces for type switches which
785 is_nil_constant_as_type() const;
787 // Return true if this is the return type of a function which
788 // returns multiple values.
790 is_call_multiple_result_type() const
791 { return this->base()->classification_
== TYPE_CALL_MULTIPLE_RESULT
; }
793 // If this is a struct type, return it. Otherwise, return NULL.
796 { return this->convert
<Struct_type
, TYPE_STRUCT
>(); }
800 { return this->convert
<const Struct_type
, TYPE_STRUCT
>(); }
802 // If this is an array type, return it. Otherwise, return NULL.
805 { return this->convert
<Array_type
, TYPE_ARRAY
>(); }
809 { return this->convert
<const Array_type
, TYPE_ARRAY
>(); }
811 // Return whether if this is a slice type.
813 is_slice_type() const;
815 // If this is a map type, return it. Otherwise, return NULL.
818 { return this->convert
<Map_type
, TYPE_MAP
>(); }
822 { return this->convert
<const Map_type
, TYPE_MAP
>(); }
824 // If this is a channel type, return it. Otherwise, return NULL.
827 { return this->convert
<Channel_type
, TYPE_CHANNEL
>(); }
831 { return this->convert
<const Channel_type
, TYPE_CHANNEL
>(); }
833 // If this is an interface type, return it. Otherwise, return NULL.
836 { return this->convert
<Interface_type
, TYPE_INTERFACE
>(); }
838 const Interface_type
*
839 interface_type() const
840 { return this->convert
<const Interface_type
, TYPE_INTERFACE
>(); }
842 // If this is a named type, return it. Otherwise, return NULL.
849 // If this is a forward declaration, return it. Otherwise, return
851 Forward_declaration_type
*
852 forward_declaration_type()
853 { return this->convert_no_base
<Forward_declaration_type
, TYPE_FORWARD
>(); }
855 const Forward_declaration_type
*
856 forward_declaration_type() const
858 return this->convert_no_base
<const Forward_declaration_type
,
862 // Return true if this type is not yet defined.
864 is_undefined() const;
866 // Return true if this is the unsafe.pointer type. We currently
867 // represent that as pointer-to-void.
869 is_unsafe_pointer_type() const
870 { return this->points_to() != NULL
&& this->points_to()->is_void_type(); }
872 // Look for field or method NAME for TYPE. Return an expression for
873 // it, bound to EXPR.
875 bind_field_or_method(Gogo
*, const Type
* type
, Expression
* expr
,
876 const std::string
& name
, Location
);
878 // Return true if NAME is an unexported field or method of TYPE.
880 is_unexported_field_or_method(Gogo
*, const Type
*, const std::string
&,
881 std::vector
<const Named_type
*>*);
883 // Convert the builtin named types.
885 convert_builtin_named_types(Gogo
*);
887 // Return the backend representation of this type.
891 // Return a placeholder for the backend representation of the type.
892 // This will return a type of the correct size, but for which some
893 // of the fields may still need to be completed.
895 get_backend_placeholder(Gogo
*);
897 // Finish the backend representation of a placeholder.
899 finish_backend(Gogo
*, Btype
*);
901 // Build a type descriptor entry for this type. Return a pointer to
902 // it. The location is the location which causes us to need the
905 type_descriptor_pointer(Gogo
* gogo
, Location
);
907 // Return the type reflection string for this type.
909 reflection(Gogo
*) const;
911 // Return a mangled name for the type. This is a name which can be
912 // used in assembler code. Identical types should have the same
915 mangled_name(Gogo
*) const;
917 // If the size of the type can be determined, set *PSIZE to the size
918 // in bytes and return true. Otherwise, return false. This queries
921 backend_type_size(Gogo
*, unsigned int* psize
);
923 // If the alignment of the type can be determined, set *PALIGN to
924 // the alignment in bytes and return true. Otherwise, return false.
926 backend_type_align(Gogo
*, unsigned int* palign
);
928 // If the alignment of a struct field of this type can be
929 // determined, set *PALIGN to the alignment in bytes and return
930 // true. Otherwise, return false.
932 backend_type_field_align(Gogo
*, unsigned int* palign
);
934 // Whether the backend size is known.
936 is_backend_type_size_known(Gogo
*);
938 // Get the hash and equality functions for a type.
940 type_functions(Gogo
*, Named_type
* name
, Function_type
* hash_fntype
,
941 Function_type
* equal_fntype
, Named_object
** hash_fn
,
942 Named_object
** equal_fn
);
944 // Write the hash and equality type functions.
946 write_specific_type_functions(Gogo
*, Named_type
*,
947 const std::string
& hash_name
,
948 Function_type
* hash_fntype
,
949 const std::string
& equal_name
,
950 Function_type
* equal_fntype
);
954 export_type(Export
* exp
) const
955 { this->do_export(exp
); }
959 import_type(Import
*);
962 Type(Type_classification
);
964 // Functions implemented by the child class.
966 // Traverse the subtypes.
968 do_traverse(Traverse
*);
976 do_has_pointer() const
980 do_compare_is_identity(Gogo
*) = 0;
983 do_hash_for_method(Gogo
*) const;
986 do_get_backend(Gogo
*) = 0;
989 do_type_descriptor(Gogo
*, Named_type
* name
) = 0;
992 do_reflection(Gogo
*, std::string
*) const = 0;
995 do_mangled_name(Gogo
*, std::string
*) const = 0;
998 do_export(Export
*) const;
1000 // Return whether a method expects a pointer as the receiver.
1002 method_expects_pointer(const Named_object
*);
1004 // Finalize the methods for a type.
1006 finalize_methods(Gogo
*, const Type
*, Location
, Methods
**);
1008 // Return a method from a set of methods.
1010 method_function(const Methods
*, const std::string
& name
,
1011 bool* is_ambiguous
);
1013 // A mapping from interfaces to the associated interface method
1014 // tables for this type. This maps to a decl.
1015 typedef Unordered_map_hash(const Interface_type
*, tree
, Type_hash_identical
,
1016 Type_identical
) Interface_method_tables
;
1018 // Return a pointer to the interface method table for TYPE for the
1019 // interface INTERFACE.
1021 interface_method_table(Gogo
* gogo
, Type
* type
,
1022 const Interface_type
*interface
, bool is_pointer
,
1023 Interface_method_tables
** method_tables
,
1024 Interface_method_tables
** pointer_tables
);
1026 // Return a composite literal for the type descriptor entry for a
1029 type_descriptor(Gogo
*, Type
*);
1031 // Return a composite literal for the type descriptor entry for
1032 // TYPE, using NAME as the name of the type.
1034 named_type_descriptor(Gogo
*, Type
* type
, Named_type
* name
);
1036 // Return a composite literal for a plain type descriptor for this
1037 // type with the given kind and name.
1039 plain_type_descriptor(Gogo
*, int runtime_type_kind
, Named_type
* name
);
1041 // Build a composite literal for the basic type descriptor.
1043 type_descriptor_constructor(Gogo
*, int runtime_type_kind
, Named_type
*,
1044 const Methods
*, bool only_value_methods
);
1046 // For the benefit of child class reflection string generation.
1048 append_reflection(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
1049 { type
->do_reflection(gogo
, ret
); }
1051 // For the benefit of child class mangling.
1053 append_mangled_name(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
1054 { type
->do_mangled_name(gogo
, ret
); }
1056 // Incorporate a string into a hash code.
1058 hash_string(const std::string
&, unsigned int);
1060 // Return the backend representation for the underlying type of a
1063 get_named_base_btype(Gogo
* gogo
, Type
* base_type
)
1064 { return base_type
->get_btype_without_hash(gogo
); }
1067 // Convert to the desired type classification, or return NULL. This
1068 // is a controlled dynamic_cast.
1069 template<typename Type_class
, Type_classification type_classification
>
1073 Type
* base
= this->base();
1074 return (base
->classification_
== type_classification
1075 ? static_cast<Type_class
*>(base
)
1079 template<typename Type_class
, Type_classification type_classification
>
1083 const Type
* base
= this->base();
1084 return (base
->classification_
== type_classification
1085 ? static_cast<Type_class
*>(base
)
1089 template<typename Type_class
, Type_classification type_classification
>
1093 return (this->classification_
== type_classification
1094 ? static_cast<Type_class
*>(this)
1098 template<typename Type_class
, Type_classification type_classification
>
1100 convert_no_base() const
1102 return (this->classification_
== type_classification
1103 ? static_cast<Type_class
*>(this)
1107 // Support for are_assignable and are_assignable_hidden_ok.
1109 are_assignable_check_hidden(const Type
* lhs
, const Type
* rhs
,
1110 bool check_hidden_fields
, std::string
* reason
);
1112 // Map unnamed types to type descriptor decls.
1113 typedef Unordered_map_hash(const Type
*, Bvariable
*, Type_hash_identical
,
1114 Type_identical
) Type_descriptor_vars
;
1116 static Type_descriptor_vars type_descriptor_vars
;
1118 // Build the type descriptor variable for this type.
1120 make_type_descriptor_var(Gogo
*);
1122 // Return the name of the type descriptor variable. If NAME is not
1123 // NULL, it is the name to use.
1125 type_descriptor_var_name(Gogo
*, Named_type
* name
);
1127 // Return true if the type descriptor for this type should be
1128 // defined in some other package. If NAME is not NULL, it is the
1129 // name of this type. If this returns true it sets *PACKAGE to the
1130 // package where the type descriptor is defined.
1132 type_descriptor_defined_elsewhere(Named_type
* name
, const Package
** package
);
1134 // Build the hash and equality type functions for a type which needs
1135 // specific functions.
1137 specific_type_functions(Gogo
*, Named_type
*, Function_type
* hash_fntype
,
1138 Function_type
* equal_fntype
, Named_object
** hash_fn
,
1139 Named_object
** equal_fn
);
1141 // Build a composite literal for the uncommon type information.
1143 uncommon_type_constructor(Gogo
*, Type
* uncommon_type
,
1144 Named_type
*, const Methods
*,
1145 bool only_value_methods
) const;
1147 // Build a composite literal for the methods.
1149 methods_constructor(Gogo
*, Type
* methods_type
, const Methods
*,
1150 bool only_value_methods
) const;
1152 // Build a composite literal for one method.
1154 method_constructor(Gogo
*, Type
* method_type
, const std::string
& name
,
1155 const Method
*, bool only_value_methods
) const;
1158 build_receive_return_type(tree type
);
1160 // A hash table we use to avoid infinite recursion.
1161 typedef Unordered_set_hash(const Named_type
*, Type_hash_identical
,
1162 Type_identical
) Types_seen
;
1164 // Add all methods for TYPE to the list of methods for THIS.
1166 add_methods_for_type(const Type
* type
, const Method::Field_indexes
*,
1167 unsigned int depth
, bool, bool, Types_seen
*,
1171 add_local_methods_for_type(const Named_type
* type
,
1172 const Method::Field_indexes
*,
1173 unsigned int depth
, bool, bool, Methods
**);
1176 add_embedded_methods_for_type(const Type
* type
,
1177 const Method::Field_indexes
*,
1178 unsigned int depth
, bool, bool, Types_seen
*,
1182 add_interface_methods_for_type(const Type
* type
,
1183 const Method::Field_indexes
*,
1184 unsigned int depth
, Methods
**);
1186 // Build stub methods for a type.
1188 build_stub_methods(Gogo
*, const Type
* type
, const Methods
* methods
,
1192 build_one_stub_method(Gogo
*, Method
*, const char* receiver_name
,
1193 const Typed_identifier_list
*, bool is_varargs
,
1197 apply_field_indexes(Expression
*, const Method::Field_indexes
*,
1200 // Look for a field or method named NAME in TYPE.
1202 find_field_or_method(const Type
* type
, const std::string
& name
,
1203 bool receiver_can_be_pointer
,
1204 std::vector
<const Named_type
*>*, int* level
,
1205 bool* is_method
, bool* found_pointer_method
,
1206 std::string
* ambig1
, std::string
* ambig2
);
1208 // Get the backend representation for a type without looking in the
1209 // hash table for identical types.
1211 get_btype_without_hash(Gogo
*);
1213 // A backend type that may be a placeholder.
1214 struct Type_btype_entry
1217 bool is_placeholder
;
1220 // A mapping from Type to Btype*, used to ensure that the backend
1221 // representation of identical types is identical. This is only
1222 // used for unnamed types.
1223 typedef Unordered_map_hash(const Type
*, Type_btype_entry
,
1224 Type_hash_identical
, Type_identical
) Type_btypes
;
1226 static Type_btypes type_btypes
;
1228 // A list of builtin named types.
1229 static std::vector
<Named_type
*> named_builtin_types
;
1231 // A map from types which need specific type functions to the type
1232 // functions themselves.
1233 typedef std::pair
<Named_object
*, Named_object
*> Hash_equal_fn
;
1234 typedef Unordered_map_hash(const Type
*, Hash_equal_fn
, Type_hash_identical
,
1235 Type_identical
) Type_functions
;
1237 static Type_functions type_functions_table
;
1239 // The type classification.
1240 Type_classification classification_
;
1241 // The backend representation of the type, once it has been
1244 // The type descriptor for this type. This starts out as NULL and
1245 // is filled in as needed.
1246 Bvariable
* type_descriptor_var_
;
1249 // Type hash table operations.
1251 class Type_hash_identical
1255 operator()(const Type
* type
) const
1256 { return type
->hash_for_method(NULL
); }
1259 class Type_identical
1263 operator()(const Type
* t1
, const Type
* t2
) const
1264 { return Type::are_identical(t1
, t2
, false, NULL
); }
1267 // An identifier with a type.
1269 class Typed_identifier
1272 Typed_identifier(const std::string
& name
, Type
* type
,
1274 : name_(name
), type_(type
), location_(location
)
1280 { return this->name_
; }
1285 { return this->type_
; }
1287 // Return the location where the name was seen. This is not always
1291 { return this->location_
; }
1293 // Set the type--sometimes we see the identifier before the type.
1295 set_type(Type
* type
)
1297 go_assert(this->type_
== NULL
|| type
->is_error_type());
1306 // The location where the name was seen.
1310 // A list of Typed_identifiers.
1312 class Typed_identifier_list
1315 Typed_identifier_list()
1319 // Whether the list is empty.
1322 { return this->entries_
.empty(); }
1324 // Return the number of entries in the list.
1327 { return this->entries_
.size(); }
1329 // Add an entry to the end of the list.
1331 push_back(const Typed_identifier
& td
)
1332 { this->entries_
.push_back(td
); }
1334 // Remove an entry from the end of the list.
1337 { this->entries_
.pop_back(); }
1339 // Set the type of entry I to TYPE.
1341 set_type(size_t i
, Type
* type
)
1343 go_assert(i
< this->entries_
.size());
1344 this->entries_
[i
].set_type(type
);
1347 // Sort the entries by name.
1353 traverse(Traverse
*);
1355 // Return the first and last elements.
1358 { return this->entries_
.front(); }
1360 const Typed_identifier
&
1362 { return this->entries_
.front(); }
1366 { return this->entries_
.back(); }
1368 const Typed_identifier
&
1370 { return this->entries_
.back(); }
1372 const Typed_identifier
&
1374 { return this->entries_
.at(i
); }
1377 set(size_t i
, const Typed_identifier
& t
)
1378 { this->entries_
.at(i
) = t
; }
1383 go_assert(c
<= this->entries_
.size());
1384 this->entries_
.resize(c
, Typed_identifier("", NULL
,
1385 Linemap::unknown_location()));
1390 { this->entries_
.reserve(c
); }
1394 typedef std::vector
<Typed_identifier
>::iterator iterator
;
1395 typedef std::vector
<Typed_identifier
>::const_iterator const_iterator
;
1399 { return this->entries_
.begin(); }
1403 { return this->entries_
.begin(); }
1407 { return this->entries_
.end(); }
1411 { return this->entries_
.end(); }
1413 // Return a copy of this list. This returns an independent copy of
1414 // the vector, but does not copy the types.
1415 Typed_identifier_list
*
1419 std::vector
<Typed_identifier
> entries_
;
1422 // The type of an integer.
1424 class Integer_type
: public Type
1427 // Create a new integer type.
1429 create_integer_type(const char* name
, bool is_unsigned
, int bits
,
1430 int runtime_type_kind
);
1432 // Look up an existing integer type.
1434 lookup_integer_type(const char* name
);
1436 // Create an abstract integer type.
1437 static Integer_type
*
1438 create_abstract_integer_type();
1440 // Create an abstract character type.
1441 static Integer_type
*
1442 create_abstract_character_type();
1444 // Whether this is an abstract integer type.
1447 { return this->is_abstract_
; }
1449 // Whether this is an unsigned type.
1452 { return this->is_unsigned_
; }
1454 // The number of bits.
1457 { return this->bits_
; }
1459 // Whether this type is the same as T.
1461 is_identical(const Integer_type
* t
) const;
1463 // Whether this is the type "byte" or another name for "byte".
1466 { return this->is_byte_
; }
1468 // Mark this as the "byte" type.
1471 { this->is_byte_
= true; }
1473 // Whether this is the type "rune" or another name for "rune".
1476 { return this->is_rune_
; }
1478 // Mark this as the "rune" type.
1481 { this->is_rune_
= true; }
1485 do_compare_is_identity(Gogo
*)
1489 do_hash_for_method(Gogo
*) const;
1492 do_get_backend(Gogo
*);
1495 do_type_descriptor(Gogo
*, Named_type
*);
1498 do_reflection(Gogo
*, std::string
*) const;
1501 do_mangled_name(Gogo
*, std::string
*) const;
1504 Integer_type(bool is_abstract
, bool is_unsigned
, int bits
,
1505 int runtime_type_kind
)
1506 : Type(TYPE_INTEGER
),
1507 is_abstract_(is_abstract
), is_unsigned_(is_unsigned
), is_byte_(false),
1508 is_rune_(false), bits_(bits
), runtime_type_kind_(runtime_type_kind
)
1511 // Map names of integer types to the types themselves.
1512 typedef std::map
<std::string
, Named_type
*> Named_integer_types
;
1513 static Named_integer_types named_integer_types
;
1515 // True if this is an abstract type.
1517 // True if this is an unsigned type.
1519 // True if this is the byte type.
1521 // True if this is the rune type.
1523 // The number of bits.
1525 // The runtime type code used in the type descriptor for this type.
1526 int runtime_type_kind_
;
1529 // The type of a floating point number.
1531 class Float_type
: public Type
1534 // Create a new float type.
1536 create_float_type(const char* name
, int bits
, int runtime_type_kind
);
1538 // Look up an existing float type.
1540 lookup_float_type(const char* name
);
1542 // Create an abstract float type.
1544 create_abstract_float_type();
1546 // Whether this is an abstract float type.
1549 { return this->is_abstract_
; }
1551 // The number of bits.
1554 { return this->bits_
; }
1556 // Whether this type is the same as T.
1558 is_identical(const Float_type
* t
) const;
1562 do_compare_is_identity(Gogo
*)
1566 do_hash_for_method(Gogo
*) const;
1569 do_get_backend(Gogo
*);
1572 do_type_descriptor(Gogo
*, Named_type
*);
1575 do_reflection(Gogo
*, std::string
*) const;
1578 do_mangled_name(Gogo
*, std::string
*) const;
1581 Float_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1583 is_abstract_(is_abstract
), bits_(bits
),
1584 runtime_type_kind_(runtime_type_kind
)
1587 // Map names of float types to the types themselves.
1588 typedef std::map
<std::string
, Named_type
*> Named_float_types
;
1589 static Named_float_types named_float_types
;
1591 // True if this is an abstract type.
1593 // The number of bits in the floating point value.
1595 // The runtime type code used in the type descriptor for this type.
1596 int runtime_type_kind_
;
1599 // The type of a complex number.
1601 class Complex_type
: public Type
1604 // Create a new complex type.
1606 create_complex_type(const char* name
, int bits
, int runtime_type_kind
);
1608 // Look up an existing complex type.
1610 lookup_complex_type(const char* name
);
1612 // Create an abstract complex type.
1613 static Complex_type
*
1614 create_abstract_complex_type();
1616 // Whether this is an abstract complex type.
1619 { return this->is_abstract_
; }
1621 // The number of bits: 64 or 128.
1623 { return this->bits_
; }
1625 // Whether this type is the same as T.
1627 is_identical(const Complex_type
* t
) const;
1631 do_compare_is_identity(Gogo
*)
1635 do_hash_for_method(Gogo
*) const;
1638 do_get_backend(Gogo
*);
1641 do_type_descriptor(Gogo
*, Named_type
*);
1644 do_reflection(Gogo
*, std::string
*) const;
1647 do_mangled_name(Gogo
*, std::string
*) const;
1650 Complex_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1651 : Type(TYPE_COMPLEX
),
1652 is_abstract_(is_abstract
), bits_(bits
),
1653 runtime_type_kind_(runtime_type_kind
)
1656 // Map names of complex types to the types themselves.
1657 typedef std::map
<std::string
, Named_type
*> Named_complex_types
;
1658 static Named_complex_types named_complex_types
;
1660 // True if this is an abstract type.
1662 // The number of bits in the complex value--64 or 128.
1664 // The runtime type code used in the type descriptor for this type.
1665 int runtime_type_kind_
;
1668 // The type of a string.
1670 class String_type
: public Type
1677 // Return a tree for the length of STRING.
1679 length_tree(Gogo
*, tree string
);
1681 // Return a tree which points to the bytes of STRING.
1683 bytes_tree(Gogo
*, tree string
);
1687 do_has_pointer() const
1691 do_compare_is_identity(Gogo
*)
1695 do_get_backend(Gogo
*);
1698 do_type_descriptor(Gogo
*, Named_type
*);
1701 do_reflection(Gogo
*, std::string
*) const;
1704 do_mangled_name(Gogo
*, std::string
* ret
) const;
1707 // The named string type.
1708 static Named_type
* string_type_
;
1711 // The type of a function.
1713 class Function_type
: public Type
1716 Function_type(Typed_identifier
* receiver
, Typed_identifier_list
* parameters
,
1717 Typed_identifier_list
* results
, Location location
)
1718 : Type(TYPE_FUNCTION
),
1719 receiver_(receiver
), parameters_(parameters
), results_(results
),
1720 location_(location
), is_varargs_(false), is_builtin_(false),
1724 // Get the receiver.
1725 const Typed_identifier
*
1727 { return this->receiver_
; }
1729 // Get the return names and types.
1730 const Typed_identifier_list
*
1732 { return this->results_
; }
1734 // Get the parameter names and types.
1735 const Typed_identifier_list
*
1737 { return this->parameters_
; }
1739 // Whether this is a varargs function.
1742 { return this->is_varargs_
; }
1744 // Whether this is a builtin function.
1747 { return this->is_builtin_
; }
1749 // The location where this type was defined.
1752 { return this->location_
; }
1754 // Return whether this is a method type.
1757 { return this->receiver_
!= NULL
; }
1759 // Whether T is a valid redeclaration of this type. This is called
1760 // when a function is declared more than once.
1762 is_valid_redeclaration(const Function_type
* t
, std::string
*) const;
1764 // Whether this type is the same as T.
1766 is_identical(const Function_type
* t
, bool ignore_receiver
,
1767 bool errors_are_identical
, std::string
*) const;
1769 // Record that this is a varargs function.
1772 { this->is_varargs_
= true; }
1774 // Record that this is a builtin function.
1777 { this->is_builtin_
= true; }
1779 // Import a function type.
1780 static Function_type
*
1783 // Return a copy of this type without a receiver. This is only
1784 // valid for a method type.
1786 copy_without_receiver() const;
1788 // Return a copy of this type with a receiver. This is used when an
1789 // interface method is attached to a named or struct type.
1791 copy_with_receiver(Type
*) const;
1793 // Return a copy of this type ignoring any receiver and using dummy
1794 // names for all parameters. This is used for thunks for method
1797 copy_with_names() const;
1800 make_function_type_descriptor_type();
1802 // Return the backend representation of this function type. This is used
1803 // as the real type of a backend function declaration or defintion.
1805 get_backend_fntype(Gogo
*);
1809 do_traverse(Traverse
*);
1811 // A function descriptor may be allocated on the heap.
1813 do_has_pointer() const
1817 do_compare_is_identity(Gogo
*)
1821 do_hash_for_method(Gogo
*) const;
1824 do_get_backend(Gogo
*);
1827 do_type_descriptor(Gogo
*, Named_type
*);
1830 do_reflection(Gogo
*, std::string
*) const;
1833 do_mangled_name(Gogo
*, std::string
*) const;
1836 do_export(Export
*) const;
1840 type_descriptor_params(Type
*, const Typed_identifier
*,
1841 const Typed_identifier_list
*);
1843 // The receiver name and type. This will be NULL for a normal
1844 // function, non-NULL for a method.
1845 Typed_identifier
* receiver_
;
1846 // The parameter names and types.
1847 Typed_identifier_list
* parameters_
;
1848 // The result names and types. This will be NULL if no result was
1850 Typed_identifier_list
* results_
;
1851 // The location where this type was defined. This exists solely to
1852 // give a location for the fields of the struct if this function
1853 // returns multiple values.
1855 // Whether this function takes a variable number of arguments.
1857 // Whether this is a special builtin function which can not simply
1858 // be called. This is used for len, cap, etc.
1860 // The backend representation of this type for backend function
1861 // declarations and definitions.
1865 // The type of a pointer.
1867 class Pointer_type
: public Type
1870 Pointer_type(Type
* to_type
)
1871 : Type(TYPE_POINTER
),
1877 { return this->to_type_
; }
1879 // Import a pointer type.
1880 static Pointer_type
*
1884 make_pointer_type_descriptor_type();
1888 do_traverse(Traverse
*);
1891 do_has_pointer() const
1895 do_compare_is_identity(Gogo
*)
1899 do_hash_for_method(Gogo
*) const;
1902 do_get_backend(Gogo
*);
1905 do_type_descriptor(Gogo
*, Named_type
*);
1908 do_reflection(Gogo
*, std::string
*) const;
1911 do_mangled_name(Gogo
*, std::string
*) const;
1914 do_export(Export
*) const;
1917 // The type to which this type points.
1921 // The type of a field in a struct.
1926 explicit Struct_field(const Typed_identifier
& typed_identifier
)
1927 : typed_identifier_(typed_identifier
), tag_(NULL
), is_imported_(false)
1934 // Return whether this struct field is named NAME.
1936 is_field_name(const std::string
& name
) const;
1938 // Return whether this struct field is an unexported field named NAME.
1940 is_unexported_field_name(Gogo
*, const std::string
& name
) const;
1942 // Return whether this struct field is an embedded built-in type.
1944 is_embedded_builtin(Gogo
*) const;
1949 { return this->typed_identifier_
.type(); }
1951 // The field location.
1954 { return this->typed_identifier_
.location(); }
1956 // Whether the field has a tag.
1959 { return this->tag_
!= NULL
; }
1965 go_assert(this->tag_
!= NULL
);
1969 // Whether this is an anonymous field.
1971 is_anonymous() const
1972 { return this->typed_identifier_
.name().empty(); }
1974 // Set the tag. FIXME: This is never freed.
1976 set_tag(const std::string
& tag
)
1977 { this->tag_
= new std::string(tag
); }
1979 // Record that this field is defined in an imported struct.
1982 { this->is_imported_
= true; }
1984 // Set the type. This is only used in error cases.
1986 set_type(Type
* type
)
1987 { this->typed_identifier_
.set_type(type
); }
1990 // The field name, type, and location.
1991 Typed_identifier typed_identifier_
;
1992 // The field tag. This is NULL if the field has no tag.
1994 // Whether this field is defined in an imported struct.
1998 // A list of struct fields.
2000 class Struct_field_list
2007 // Whether the list is empty.
2010 { return this->entries_
.empty(); }
2012 // Return the number of entries.
2015 { return this->entries_
.size(); }
2017 // Add an entry to the end of the list.
2019 push_back(const Struct_field
& sf
)
2020 { this->entries_
.push_back(sf
); }
2022 // Index into the list.
2025 { return this->entries_
.at(i
); }
2027 // Last entry in list.
2030 { return this->entries_
.back(); }
2034 typedef std::vector
<Struct_field
>::iterator iterator
;
2035 typedef std::vector
<Struct_field
>::const_iterator const_iterator
;
2039 { return this->entries_
.begin(); }
2043 { return this->entries_
.begin(); }
2047 { return this->entries_
.end(); }
2051 { return this->entries_
.end(); }
2054 std::vector
<Struct_field
> entries_
;
2057 // The type of a struct.
2059 class Struct_type
: public Type
2062 Struct_type(Struct_field_list
* fields
, Location location
)
2063 : Type(TYPE_STRUCT
),
2064 fields_(fields
), location_(location
), all_methods_(NULL
)
2067 // Return the field NAME. This only looks at local fields, not at
2068 // embedded types. If the field is found, and PINDEX is not NULL,
2069 // this sets *PINDEX to the field index. If the field is not found,
2070 // this returns NULL.
2072 find_local_field(const std::string
& name
, unsigned int *pindex
) const;
2074 // Return the field number INDEX.
2076 field(unsigned int index
) const
2077 { return &this->fields_
->at(index
); }
2079 // Get the struct fields.
2080 const Struct_field_list
*
2082 { return this->fields_
; }
2084 // Return the number of fields.
2087 { return this->fields_
->size(); }
2089 // Push a new field onto the end of the struct. This is used when
2090 // building a closure variable.
2092 push_field(const Struct_field
& sf
)
2093 { this->fields_
->push_back(sf
); }
2095 // Return an expression referring to field NAME in STRUCT_EXPR, or
2096 // NULL if there is no field with that name.
2097 Field_reference_expression
*
2098 field_reference(Expression
* struct_expr
, const std::string
& name
,
2101 // Return the total number of fields, including embedded fields.
2102 // This is the number of values that can appear in a conversion to
2105 total_field_count() const;
2107 // Whether this type is identical with T.
2109 is_identical(const Struct_type
* t
, bool errors_are_identical
) const;
2111 // Whether this struct type has any hidden fields. This returns
2112 // true if any fields have hidden names, or if any non-pointer
2113 // anonymous fields have types with hidden fields.
2115 struct_has_hidden_fields(const Named_type
* within
, std::string
*) const;
2117 // Return whether NAME is a local field which is not exported. This
2118 // is only used for better error reporting.
2120 is_unexported_local_field(Gogo
*, const std::string
& name
) const;
2122 // If this is an unnamed struct, build the complete list of methods,
2123 // including those from anonymous fields, and build methods stubs if
2126 finalize_methods(Gogo
*);
2128 // Return whether this type has any methods. This should only be
2129 // called after the finalize_methods pass.
2131 has_any_methods() const
2132 { return this->all_methods_
!= NULL
; }
2134 // Return the methods for tihs type. This should only be called
2135 // after the finalize_methods pass.
2138 { return this->all_methods_
; }
2140 // Return the method to use for NAME. This returns NULL if there is
2141 // no such method or if the method is ambiguous. When it returns
2142 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2144 method_function(const std::string
& name
, bool* is_ambiguous
) const;
2146 // Return a pointer to the interface method table for this type for
2147 // the interface INTERFACE. If IS_POINTER is true, set the type
2148 // descriptor to a pointer to this type, otherwise set it to this
2151 interface_method_table(Gogo
*, const Interface_type
* interface
,
2154 // Traverse just the field types of a struct type.
2156 traverse_field_types(Traverse
* traverse
)
2157 { return this->do_traverse(traverse
); }
2159 // If the offset of field INDEX in the backend implementation can be
2160 // determined, set *POFFSET to the offset in bytes and return true.
2161 // Otherwise, return false.
2163 backend_field_offset(Gogo
*, unsigned int index
, unsigned int* poffset
);
2165 // Finish the backend representation of all the fields.
2167 finish_backend_fields(Gogo
*);
2169 // Import a struct type.
2174 make_struct_type_descriptor_type();
2176 // Write the hash function for this type.
2178 write_hash_function(Gogo
*, Named_type
*, Function_type
*, Function_type
*);
2180 // Write the equality function for this type.
2182 write_equal_function(Gogo
*, Named_type
*);
2186 do_traverse(Traverse
*);
2192 do_has_pointer() const;
2195 do_compare_is_identity(Gogo
*);
2198 do_hash_for_method(Gogo
*) const;
2201 do_get_backend(Gogo
*);
2204 do_type_descriptor(Gogo
*, Named_type
*);
2207 do_reflection(Gogo
*, std::string
*) const;
2210 do_mangled_name(Gogo
*, std::string
*) const;
2213 do_export(Export
*) const;
2216 // Used to merge method sets of identical unnamed structs.
2217 typedef Unordered_map_hash(Struct_type
*, Struct_type
*, Type_hash_identical
,
2218 Type_identical
) Identical_structs
;
2220 static Identical_structs identical_structs
;
2222 // Used to manage method tables for identical unnamed structs.
2223 typedef std::pair
<Interface_method_tables
*, Interface_method_tables
*>
2224 Struct_method_table_pair
;
2226 typedef Unordered_map_hash(Struct_type
*, Struct_method_table_pair
*,
2227 Type_hash_identical
, Type_identical
)
2228 Struct_method_tables
;
2230 static Struct_method_tables struct_method_tables
;
2232 // Used to avoid infinite loops in field_reference_depth.
2233 struct Saw_named_type
2235 Saw_named_type
* next
;
2239 Field_reference_expression
*
2240 field_reference_depth(Expression
* struct_expr
, const std::string
& name
,
2241 Location
, Saw_named_type
*,
2242 unsigned int* depth
) const;
2244 // The fields of the struct.
2245 Struct_field_list
* fields_
;
2246 // The place where the struct was declared.
2248 // If this struct is unnamed, a list of methods.
2249 Methods
* all_methods_
;
2252 // The type of an array.
2254 class Array_type
: public Type
2257 Array_type(Type
* element_type
, Expression
* length
)
2259 element_type_(element_type
), length_(length
), length_tree_(NULL
)
2262 // Return the element type.
2264 element_type() const
2265 { return this->element_type_
; }
2267 // Return the length. This will return NULL for an open array.
2270 { return this->length_
; }
2272 // Whether this type is identical with T.
2274 is_identical(const Array_type
* t
, bool errors_are_identical
) const;
2276 // Whether this type has any hidden fields.
2278 array_has_hidden_fields(const Named_type
* within
, std::string
* reason
) const
2279 { return this->element_type_
->has_hidden_fields(within
, reason
); }
2281 // Return a tree for the pointer to the values in an array.
2283 value_pointer_tree(Gogo
*, tree array
) const;
2285 // Return a tree for the length of an array with this type.
2287 length_tree(Gogo
*, tree array
);
2289 // Return a tree for the capacity of an array with this type.
2291 capacity_tree(Gogo
*, tree array
);
2293 // Import an array type.
2297 // Return the backend representation of the element type.
2299 get_backend_element(Gogo
*, bool use_placeholder
);
2301 // Return the backend representation of the length.
2303 get_backend_length(Gogo
*);
2305 // Finish the backend representation of the element type.
2307 finish_backend_element(Gogo
*);
2310 make_array_type_descriptor_type();
2313 make_slice_type_descriptor_type();
2315 // Write the hash function for this type.
2317 write_hash_function(Gogo
*, Named_type
*, Function_type
*, Function_type
*);
2319 // Write the equality function for this type.
2321 write_equal_function(Gogo
*, Named_type
*);
2325 do_traverse(Traverse
* traverse
);
2331 do_has_pointer() const
2333 return this->length_
== NULL
|| this->element_type_
->has_pointer();
2337 do_compare_is_identity(Gogo
*);
2340 do_hash_for_method(Gogo
*) const;
2343 do_get_backend(Gogo
*);
2346 do_type_descriptor(Gogo
*, Named_type
*);
2349 do_reflection(Gogo
*, std::string
*) const;
2352 do_mangled_name(Gogo
*, std::string
*) const;
2355 do_export(Export
*) const;
2362 get_length_tree(Gogo
*);
2365 array_type_descriptor(Gogo
*, Named_type
*);
2368 slice_type_descriptor(Gogo
*, Named_type
*);
2370 // The type of elements of the array.
2371 Type
* element_type_
;
2372 // The number of elements. This may be NULL.
2373 Expression
* length_
;
2374 // The length as a tree. We only want to compute this once.
2378 // The type of a map.
2380 class Map_type
: public Type
2383 Map_type(Type
* key_type
, Type
* val_type
, Location location
)
2385 key_type_(key_type
), val_type_(val_type
), location_(location
)
2388 // Return the key type.
2391 { return this->key_type_
; }
2393 // Return the value type.
2396 { return this->val_type_
; }
2398 // Whether this type is identical with T.
2400 is_identical(const Map_type
* t
, bool errors_are_identical
) const;
2402 // Import a map type.
2407 make_map_type_descriptor_type();
2410 make_map_descriptor_type();
2412 // Build a map descriptor for this type. Return a pointer to it.
2413 // The location is the location which causes us to need the
2416 map_descriptor_pointer(Gogo
* gogo
, Location
);
2420 do_traverse(Traverse
*);
2426 do_has_pointer() const
2430 do_compare_is_identity(Gogo
*)
2434 do_hash_for_method(Gogo
*) const;
2437 do_get_backend(Gogo
*);
2440 do_type_descriptor(Gogo
*, Named_type
*);
2443 do_reflection(Gogo
*, std::string
*) const;
2446 do_mangled_name(Gogo
*, std::string
*) const;
2449 do_export(Export
*) const;
2452 // Mapping from map types to map descriptors.
2453 typedef Unordered_map_hash(const Map_type
*, Bvariable
*, Type_hash_identical
,
2454 Type_identical
) Map_descriptors
;
2455 static Map_descriptors map_descriptors
;
2458 map_descriptor(Gogo
*);
2464 // Where the type was defined.
2468 // The type of a channel.
2470 class Channel_type
: public Type
2473 Channel_type(bool may_send
, bool may_receive
, Type
* element_type
)
2474 : Type(TYPE_CHANNEL
),
2475 may_send_(may_send
), may_receive_(may_receive
),
2476 element_type_(element_type
)
2477 { go_assert(may_send
|| may_receive
); }
2479 // Whether this channel can send data.
2482 { return this->may_send_
; }
2484 // Whether this channel can receive data.
2487 { return this->may_receive_
; }
2489 // The type of the values that may be sent on this channel. This is
2490 // NULL if any type may be sent.
2492 element_type() const
2493 { return this->element_type_
; }
2495 // Whether this type is identical with T.
2497 is_identical(const Channel_type
* t
, bool errors_are_identical
) const;
2499 // Import a channel type.
2500 static Channel_type
*
2504 make_chan_type_descriptor_type();
2508 do_traverse(Traverse
* traverse
)
2509 { return Type::traverse(this->element_type_
, traverse
); }
2512 do_has_pointer() const
2516 do_compare_is_identity(Gogo
*)
2520 do_hash_for_method(Gogo
*) const;
2523 do_get_backend(Gogo
*);
2526 do_type_descriptor(Gogo
*, Named_type
*);
2529 do_reflection(Gogo
*, std::string
*) const;
2532 do_mangled_name(Gogo
*, std::string
*) const;
2535 do_export(Export
*) const;
2538 // Whether this channel can send data.
2540 // Whether this channel can receive data.
2542 // The types of elements which may be sent on this channel. If this
2543 // is NULL, it means that any type may be sent.
2544 Type
* element_type_
;
2547 // An interface type.
2549 class Interface_type
: public Type
2552 Interface_type(Typed_identifier_list
* methods
, Location location
)
2553 : Type(TYPE_INTERFACE
),
2554 parse_methods_(methods
), all_methods_(NULL
), location_(location
),
2555 interface_btype_(NULL
), assume_identical_(NULL
),
2556 methods_are_finalized_(false), seen_(false)
2557 { go_assert(methods
== NULL
|| !methods
->empty()); }
2559 // The location where the interface type was defined.
2562 { return this->location_
; }
2564 // Return whether this is an empty interface.
2568 go_assert(this->methods_are_finalized_
);
2569 return this->all_methods_
== NULL
;
2572 // Return the list of methods. This will return NULL for an empty
2574 const Typed_identifier_list
*
2577 // Return the number of methods.
2579 method_count() const;
2581 // Return the method NAME, or NULL.
2582 const Typed_identifier
*
2583 find_method(const std::string
& name
) const;
2585 // Return the zero-based index of method NAME.
2587 method_index(const std::string
& name
) const;
2589 // Finalize the methods. This sets all_methods_. This handles
2590 // interface inheritance.
2594 // Return true if T implements this interface. If this returns
2595 // false, and REASON is not NULL, it sets *REASON to the reason that
2598 implements_interface(const Type
* t
, std::string
* reason
) const;
2600 // Whether this type is identical with T. REASON is as in
2601 // implements_interface.
2603 is_identical(const Interface_type
* t
, bool errors_are_identical
) const;
2605 // Whether we can assign T to this type. is_identical is known to
2608 is_compatible_for_assign(const Interface_type
*, std::string
* reason
) const;
2610 // Return whether NAME is a method which is not exported. This is
2611 // only used for better error reporting.
2613 is_unexported_method(Gogo
*, const std::string
& name
) const;
2615 // Import an interface type.
2616 static Interface_type
*
2619 // Make a struct for an empty interface type.
2621 get_backend_empty_interface_type(Gogo
*);
2623 // Finish the backend representation of the method types.
2625 finish_backend_methods(Gogo
*);
2628 make_interface_type_descriptor_type();
2632 do_traverse(Traverse
*);
2635 do_has_pointer() const
2639 do_compare_is_identity(Gogo
*)
2643 do_hash_for_method(Gogo
*) const;
2646 do_get_backend(Gogo
*);
2649 do_type_descriptor(Gogo
*, Named_type
*);
2652 do_reflection(Gogo
*, std::string
*) const;
2655 do_mangled_name(Gogo
*, std::string
*) const;
2658 do_export(Export
*) const;
2661 // This type guards against infinite recursion when comparing
2662 // interface types. We keep a list of interface types assumed to be
2663 // identical during comparison. We just keep the list on the stack.
2664 // This permits us to compare cases like
2665 // type I1 interface { F() interface{I1} }
2666 // type I2 interface { F() interface{I2} }
2667 struct Assume_identical
2669 Assume_identical
* next
;
2670 const Interface_type
* t1
;
2671 const Interface_type
* t2
;
2675 assume_identical(const Interface_type
*, const Interface_type
*) const;
2677 // The list of methods associated with the interface from the
2678 // parser. This will be NULL for the empty interface. This may
2679 // include unnamed interface types.
2680 Typed_identifier_list
* parse_methods_
;
2681 // The list of all methods associated with the interface. This
2682 // expands any interface types listed in methods_. It is set by
2683 // finalize_methods. This will be NULL for the empty interface.
2684 Typed_identifier_list
* all_methods_
;
2685 // The location where the interface was defined.
2687 // The backend representation of this type during backend conversion.
2688 Btype
* interface_btype_
;
2689 // A list of interface types assumed to be identical during
2690 // interface comparison.
2691 mutable Assume_identical
* assume_identical_
;
2692 // Whether the methods have been finalized.
2693 bool methods_are_finalized_
;
2694 // Used to avoid endless recursion in do_mangled_name.
2698 // The value we keep for a named type. This lets us get the right
2699 // name when we convert to trees. Note that we don't actually keep
2700 // the name here; the name is in the Named_object which points to
2701 // this. This object exists to hold a unique tree which represents
2704 class Named_type
: public Type
2707 Named_type(Named_object
* named_object
, Type
* type
, Location location
)
2709 named_object_(named_object
), in_function_(NULL
), in_function_index_(0),
2710 type_(type
), local_methods_(NULL
), all_methods_(NULL
),
2711 interface_method_tables_(NULL
), pointer_interface_method_tables_(NULL
),
2712 location_(location
), named_btype_(NULL
), dependencies_(),
2713 is_visible_(true), is_error_(false), is_placeholder_(false),
2714 is_converted_(false), is_circular_(false), is_verified_(false),
2715 seen_(false), seen_in_compare_is_identity_(false),
2716 seen_in_get_backend_(false)
2719 // Return the associated Named_object. This holds the actual name.
2722 { return this->named_object_
; }
2725 named_object() const
2726 { return this->named_object_
; }
2728 // Set the Named_object. This is used when we see a type
2729 // declaration followed by a type.
2731 set_named_object(Named_object
* no
)
2732 { this->named_object_
= no
; }
2734 // Return the function in which this type is defined. This will
2735 // return NULL for a type defined in global scope.
2737 in_function(unsigned int *pindex
) const
2739 *pindex
= this->in_function_index_
;
2740 return this->in_function_
;
2743 // Set the function in which this type is defined.
2745 set_in_function(Named_object
* f
, unsigned int index
)
2747 this->in_function_
= f
;
2748 this->in_function_index_
= index
;
2751 // Return the name of the type.
2755 // Return the name of the type for an error message. The difference
2756 // is that if the type is defined in a different package, this will
2757 // return PACKAGE.NAME.
2759 message_name() const;
2761 // Return the underlying type.
2764 { return this->type_
; }
2768 { return this->type_
; }
2770 // Return the location.
2773 { return this->location_
; }
2775 // Whether this type is visible. This only matters when parsing.
2778 { return this->is_visible_
; }
2780 // Mark this type as visible.
2783 { this->is_visible_
= true; }
2785 // Mark this type as invisible.
2788 { this->is_visible_
= false; }
2790 // Whether this is a builtin type.
2793 { return Linemap::is_predeclared_location(this->location_
); }
2795 // Whether this is an alias. There are currently two aliases: byte
2800 // Whether this is a circular type: a pointer or function type that
2801 // refers to itself, which is not possible in C.
2804 { return this->is_circular_
; }
2806 // Return the base type for this type.
2813 // Return whether this is an error type.
2815 is_named_error_type() const;
2817 // Return whether this type is comparable. If REASON is not NULL,
2818 // set *REASON when returning false.
2820 named_type_is_comparable(std::string
* reason
) const;
2822 // Add a method to this type.
2824 add_method(const std::string
& name
, Function
*);
2826 // Add a method declaration to this type.
2828 add_method_declaration(const std::string
& name
, Package
* package
,
2829 Function_type
* type
, Location location
);
2831 // Add an existing method--one defined before the type itself was
2832 // defined--to a type.
2834 add_existing_method(Named_object
*);
2836 // Look up a local method.
2838 find_local_method(const std::string
& name
) const;
2840 // Return the list of local methods.
2842 local_methods() const
2843 { return this->local_methods_
; }
2845 // Build the complete list of methods, including those from
2846 // anonymous fields, and build method stubs if needed.
2848 finalize_methods(Gogo
*);
2850 // Return whether this type has any methods. This should only be
2851 // called after the finalize_methods pass.
2853 has_any_methods() const
2854 { return this->all_methods_
!= NULL
; }
2856 // Return the methods for this type. This should only be called
2857 // after the finalized_methods pass.
2860 { return this->all_methods_
; }
2862 // Return the method to use for NAME. This returns NULL if there is
2863 // no such method or if the method is ambiguous. When it returns
2864 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2866 method_function(const std::string
& name
, bool *is_ambiguous
) const;
2868 // Return whether NAME is a known field or method which is not
2869 // exported. This is only used for better error reporting.
2871 is_unexported_local_method(Gogo
*, const std::string
& name
) const;
2873 // Return a pointer to the interface method table for this type for
2874 // the interface INTERFACE. If IS_POINTER is true, set the type
2875 // descriptor to a pointer to this type, otherwise set it to this
2878 interface_method_table(Gogo
*, const Interface_type
* interface
,
2881 // Whether this type has any hidden fields.
2883 named_type_has_hidden_fields(std::string
* reason
) const;
2885 // Note that a type must be converted to the backend representation
2886 // before we convert this type.
2888 add_dependency(Named_type
* nt
)
2889 { this->dependencies_
.push_back(nt
); }
2891 // Return true if the size and alignment of the backend
2892 // representation of this type is known. This is always true after
2893 // types have been converted, but may be false beforehand.
2895 is_named_backend_type_size_known() const
2896 { return this->named_btype_
!= NULL
&& !this->is_placeholder_
; }
2900 export_named_type(Export
*, const std::string
& name
) const;
2902 // Import a named type.
2904 import_named_type(Import
*, Named_type
**);
2906 // Initial conversion to backend representation.
2912 do_traverse(Traverse
* traverse
)
2913 { return Type::traverse(this->type_
, traverse
); }
2919 do_has_pointer() const;
2922 do_compare_is_identity(Gogo
*);
2925 do_hash_for_method(Gogo
*) const;
2928 do_get_backend(Gogo
*);
2931 do_type_descriptor(Gogo
*, Named_type
*);
2934 do_reflection(Gogo
*, std::string
*) const;
2937 do_mangled_name(Gogo
*, std::string
* ret
) const;
2940 do_export(Export
*) const;
2943 // Create the placeholder during conversion.
2945 create_placeholder(Gogo
*);
2947 // A pointer back to the Named_object for this type.
2948 Named_object
* named_object_
;
2949 // If this type is defined in a function, a pointer back to the
2950 // function in which it is defined.
2951 Named_object
* in_function_
;
2952 // The index of this type in IN_FUNCTION_.
2953 unsigned int in_function_index_
;
2956 // The list of methods defined for this type. Any named type can
2958 Bindings
* local_methods_
;
2959 // The full list of methods for this type, including methods
2960 // declared for anonymous fields.
2961 Methods
* all_methods_
;
2962 // A mapping from interfaces to the associated interface method
2963 // tables for this type.
2964 Interface_method_tables
* interface_method_tables_
;
2965 // A mapping from interfaces to the associated interface method
2966 // tables for pointers to this type.
2967 Interface_method_tables
* pointer_interface_method_tables_
;
2968 // The location where this type was defined.
2970 // The backend representation of this type during backend
2971 // conversion. This is used to avoid endless recursion when a named
2972 // type refers to itself.
2973 Btype
* named_btype_
;
2974 // A list of types which must be converted to the backend
2975 // representation before this type can be converted. This is for
2977 // type S1 { p *S2 }
2979 // where we can't convert S2 to the backend representation unless we
2980 // have converted S1.
2981 std::vector
<Named_type
*> dependencies_
;
2982 // Whether this type is visible. This is false if this type was
2983 // created because it was referenced by an imported object, but the
2984 // type itself was not exported. This will always be true for types
2985 // created in the current package.
2987 // Whether this type is erroneous.
2989 // Whether the current value of named_btype_ is a placeholder for
2990 // which the final size of the type is not known.
2991 bool is_placeholder_
;
2992 // Whether this type has been converted to the backend
2993 // representation. Implies that is_placeholder_ is false.
2995 // Whether this is a pointer or function type which refers to the
2998 // Whether this type has been verified.
3000 // In a recursive operation such as has_hidden_fields, this flag is
3001 // used to prevent infinite recursion when a type refers to itself.
3002 // This is mutable because it is always reset to false when the
3005 // Like seen_, but used only by do_compare_is_identity.
3006 bool seen_in_compare_is_identity_
;
3007 // Like seen_, but used only by do_get_backend.
3008 bool seen_in_get_backend_
;
3011 // A forward declaration. This handles a type which has been declared
3014 class Forward_declaration_type
: public Type
3017 Forward_declaration_type(Named_object
* named_object
);
3019 // The named object associated with this type declaration. This
3020 // will be resolved.
3025 named_object() const;
3027 // Return the name of the type.
3031 // Return the type to which this points. Give an error if the type
3032 // has not yet been defined.
3039 // Whether the base type has been defined.
3043 // Add a method to this type.
3045 add_method(const std::string
& name
, Function
*);
3047 // Add a method declaration to this type.
3049 add_method_declaration(const std::string
& name
, Package
*, Function_type
*,
3054 do_traverse(Traverse
* traverse
);
3060 do_has_pointer() const
3061 { return this->real_type()->has_pointer(); }
3064 do_compare_is_identity(Gogo
* gogo
)
3065 { return this->real_type()->compare_is_identity(gogo
); }
3068 do_hash_for_method(Gogo
* gogo
) const
3069 { return this->real_type()->hash_for_method(gogo
); }
3072 do_get_backend(Gogo
* gogo
);
3075 do_type_descriptor(Gogo
*, Named_type
*);
3078 do_reflection(Gogo
*, std::string
*) const;
3081 do_mangled_name(Gogo
*, std::string
* ret
) const;
3084 do_export(Export
*) const;
3087 // Issue a warning about a use of an undefined type.
3091 // The type declaration.
3092 Named_object
* named_object_
;
3093 // Whether we have issued a warning about this type.
3094 mutable bool warned_
;
3097 // The Type_context struct describes what we expect for the type of an
3102 // The exact type we expect, if known. This may be NULL.
3104 // Whether an abstract type is permitted.
3105 bool may_be_abstract
;
3109 : type(NULL
), may_be_abstract(false)
3112 Type_context(Type
* a_type
, bool a_may_be_abstract
)
3113 : type(a_type
), may_be_abstract(a_may_be_abstract
)
3117 #endif // !defined(GO_TYPES_H)