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.
12 #include "go-linemap.h"
19 class Typed_identifier
;
20 class Typed_identifier_list
;
26 class Backend_function_type
;
28 class Struct_field_list
;
36 class Forward_declaration_type
;
39 class Type_hash_identical
;
42 class Expression_list
;
43 class Call_expression
;
44 class Field_reference_expression
;
45 class Bound_method_expression
;
49 class Translate_context
;
56 // Type codes used in type descriptors. These must match the values
57 // in libgo/runtime/go-type.h. They also match the values in the gc
58 // compiler in src/cmd/gc/reflect.c and src/pkg/runtime/type.go,
59 // although this is not required.
61 static const int RUNTIME_TYPE_KIND_BOOL
= 1;
62 static const int RUNTIME_TYPE_KIND_INT
= 2;
63 static const int RUNTIME_TYPE_KIND_INT8
= 3;
64 static const int RUNTIME_TYPE_KIND_INT16
= 4;
65 static const int RUNTIME_TYPE_KIND_INT32
= 5;
66 static const int RUNTIME_TYPE_KIND_INT64
= 6;
67 static const int RUNTIME_TYPE_KIND_UINT
= 7;
68 static const int RUNTIME_TYPE_KIND_UINT8
= 8;
69 static const int RUNTIME_TYPE_KIND_UINT16
= 9;
70 static const int RUNTIME_TYPE_KIND_UINT32
= 10;
71 static const int RUNTIME_TYPE_KIND_UINT64
= 11;
72 static const int RUNTIME_TYPE_KIND_UINTPTR
= 12;
73 static const int RUNTIME_TYPE_KIND_FLOAT32
= 13;
74 static const int RUNTIME_TYPE_KIND_FLOAT64
= 14;
75 static const int RUNTIME_TYPE_KIND_COMPLEX64
= 15;
76 static const int RUNTIME_TYPE_KIND_COMPLEX128
= 16;
77 static const int RUNTIME_TYPE_KIND_ARRAY
= 17;
78 static const int RUNTIME_TYPE_KIND_CHAN
= 18;
79 static const int RUNTIME_TYPE_KIND_FUNC
= 19;
80 static const int RUNTIME_TYPE_KIND_INTERFACE
= 20;
81 static const int RUNTIME_TYPE_KIND_MAP
= 21;
82 static const int RUNTIME_TYPE_KIND_PTR
= 22;
83 static const int RUNTIME_TYPE_KIND_SLICE
= 23;
84 static const int RUNTIME_TYPE_KIND_STRING
= 24;
85 static const int RUNTIME_TYPE_KIND_STRUCT
= 25;
86 static const int RUNTIME_TYPE_KIND_UNSAFE_POINTER
= 26;
88 static const int RUNTIME_TYPE_KIND_DIRECT_IFACE
= (1 << 5);
89 static const int RUNTIME_TYPE_KIND_GC_PROG
= (1 << 6);
90 static const int RUNTIME_TYPE_KIND_NO_POINTERS
= (1 << 7);
92 // To build the complete list of methods for a named type we need to
93 // gather all methods from anonymous fields. Those methods may
94 // require an arbitrary set of indirections and field offsets. There
95 // is also the possibility of ambiguous methods, which we could ignore
96 // except that we want to give a better error message for that case.
97 // This is a base class. There are two types of methods: named
98 // methods, and methods which are inherited from an anonymous field of
104 // For methods in anonymous types we need to know the sequence of
105 // field references used to extract the pointer to pass to the
106 // method. Since each method for a particular anonymous field will
107 // have the sequence of field indexes, and since the indexes can be
108 // shared going down the chain, we use a manually managed linked
109 // list. The first entry in the list is the field index for the
110 // last field, the one passed to the method.
114 const Field_indexes
* next
;
115 unsigned int field_index
;
121 // Get the list of field indexes.
123 field_indexes() const
124 { return this->field_indexes_
; }
129 { return this->depth_
; }
131 // Return whether this is a value method--a method which does not
132 // require a pointer expression.
134 is_value_method() const
135 { return this->is_value_method_
; }
137 // Return whether we need a stub method--this is true if we can't
138 // just pass the main object to the method.
140 needs_stub_method() const
141 { return this->needs_stub_method_
; }
143 // Return whether this is an ambiguous method name.
146 { return this->is_ambiguous_
; }
148 // Note that this method is ambiguous.
151 { this->is_ambiguous_
= true; }
153 // Return the type of the method.
156 { return this->do_type(); }
158 // Return the location of the method receiver.
160 receiver_location() const
161 { return this->do_receiver_location(); }
163 // Return an expression which binds this method to EXPR. This is
164 // something which can be used with a function call.
166 bind_method(Expression
* expr
, Location location
) const;
168 // Return the named object for this method. This may only be called
169 // after methods are finalized.
171 named_object() const;
173 // Get the stub object.
177 go_assert(this->stub_
!= NULL
);
181 // Set the stub object.
183 set_stub_object(Named_object
* no
)
185 go_assert(this->stub_
== NULL
);
189 // Return true if this method should not participate in any
193 { return this->do_nointerface(); }
196 // These objects are only built by the child classes.
197 Method(const Field_indexes
* field_indexes
, unsigned int depth
,
198 bool is_value_method
, bool needs_stub_method
)
199 : field_indexes_(field_indexes
), depth_(depth
), stub_(NULL
),
200 is_value_method_(is_value_method
), needs_stub_method_(needs_stub_method
),
204 // The named object for this method.
205 virtual Named_object
*
206 do_named_object() const = 0;
208 // The type of the method.
209 virtual Function_type
*
212 // Return the location of the method receiver.
214 do_receiver_location() const = 0;
216 // Bind a method to an object.
218 do_bind_method(Expression
* expr
, Location location
) const = 0;
220 // Return whether this method should not participate in interfaces.
222 do_nointerface() const = 0;
225 // The sequence of field indexes used for this method. If this is
226 // NULL, then the method is defined for the current type.
227 const Field_indexes
* field_indexes_
;
228 // The depth at which this method was found.
230 // If a stub method is required, this is its object. This is only
231 // set after stub methods are built in finalize_methods.
233 // Whether this is a value method--a method that does not require a
235 bool is_value_method_
;
236 // Whether a stub method is required.
237 bool needs_stub_method_
;
238 // Whether this method is ambiguous.
242 // A named method. This is what you get with a method declaration,
243 // either directly on the type, or inherited from some anonymous
246 class Named_method
: public Method
249 Named_method(Named_object
* named_object
, const Field_indexes
* field_indexes
,
250 unsigned int depth
, bool is_value_method
,
251 bool needs_stub_method
)
252 : Method(field_indexes
, depth
, is_value_method
, needs_stub_method
),
253 named_object_(named_object
)
257 // Get the Named_object for the method.
259 do_named_object() const
260 { return this->named_object_
; }
262 // The type of the method.
266 // Return the location of the method receiver.
268 do_receiver_location() const;
270 // Bind a method to an object.
272 do_bind_method(Expression
* expr
, Location location
) const;
274 // Return whether this method should not participate in interfaces.
276 do_nointerface() const;
279 // The method itself. For a method which needs a stub, this starts
280 // out as the underlying method, and is later replaced with the stub
282 Named_object
* named_object_
;
285 // An interface method. This is used when an interface appears as an
286 // anonymous field in a named struct.
288 class Interface_method
: public Method
291 Interface_method(const std::string
& name
, Location location
,
292 Function_type
* fntype
, const Field_indexes
* field_indexes
,
294 : Method(field_indexes
, depth
, true, true),
295 name_(name
), location_(location
), fntype_(fntype
)
299 // Get the Named_object for the method. This should never be
300 // called, as we always create a stub.
302 do_named_object() const
303 { go_unreachable(); }
305 // The type of the method.
308 { return this->fntype_
; }
310 // Return the location of the method receiver.
312 do_receiver_location() const
313 { return this->location_
; }
315 // Bind a method to an object.
317 do_bind_method(Expression
* expr
, Location location
) const;
319 // Return whether this method should not participate in interfaces.
321 do_nointerface() const
325 // The name of the interface method to call.
327 // The location of the definition of the interface method.
329 // The type of the interface method.
330 Function_type
* fntype_
;
333 // A mapping from method name to Method. This is a wrapper around a
339 typedef Unordered_map(std::string
, Method
*) Method_map
;
342 typedef Method_map::const_iterator const_iterator
;
348 // Insert a new method. Returns true if it was inserted, false if
349 // it was overidden or ambiguous.
351 insert(const std::string
& name
, Method
* m
);
353 // The number of (unambiguous) methods.
360 { return this->methods_
.begin(); }
364 { return this->methods_
.end(); }
368 find(const std::string
& name
) const
369 { return this->methods_
.find(name
); }
373 { return this->methods_
.empty(); }
379 // The base class for all types.
384 // The types of types.
385 enum Type_classification
398 TYPE_CALL_MULTIPLE_RESULT
,
418 // Get the unnamed bool type.
422 // Get the named type "bool".
426 // Make the named type "bool".
428 make_named_bool_type();
430 // Make an abstract integer type.
432 make_abstract_integer_type();
434 // Make an abstract type for a character constant.
436 make_abstract_character_type();
438 // Make a named integer type with a specified size.
439 // RUNTIME_TYPE_KIND is the code to use in reflection information,
440 // to distinguish int and int32.
442 make_integer_type(const char* name
, bool is_unsigned
, int bits
,
443 int runtime_type_kind
);
445 // Look up a named integer type.
447 lookup_integer_type(const char* name
);
449 // Make an abstract floating point type.
451 make_abstract_float_type();
453 // Make a named floating point type with a specific size.
454 // RUNTIME_TYPE_KIND is the code to use in reflection information,
455 // to distinguish float and float32.
457 make_float_type(const char* name
, int bits
, int runtime_type_kind
);
459 // Look up a named float type.
461 lookup_float_type(const char* name
);
463 // Make an abstract complex type.
465 make_abstract_complex_type();
467 // Make a named complex type with a specific size.
468 // RUNTIME_TYPE_KIND is the code to use in reflection information,
469 // to distinguish complex and complex64.
471 make_complex_type(const char* name
, int bits
, int runtime_type_kind
);
473 // Look up a named complex type.
475 lookup_complex_type(const char* name
);
477 // Get the unnamed string type.
481 // Get the named type "string".
483 lookup_string_type();
485 // Make the named type "string".
487 make_named_string_type();
492 static Function_type
*
493 make_function_type(Typed_identifier
* receiver
,
494 Typed_identifier_list
* parameters
,
495 Typed_identifier_list
* results
,
498 static Backend_function_type
*
499 make_backend_function_type(Typed_identifier
* receiver
,
500 Typed_identifier_list
* parameters
,
501 Typed_identifier_list
* results
,
505 make_pointer_type(Type
*);
508 finish_pointer_types(Gogo
* gogo
);
514 make_call_multiple_result_type(Call_expression
*);
517 make_struct_type(Struct_field_list
* fields
, Location
);
520 make_array_type(Type
* element_type
, Expression
* length
);
523 make_map_type(Type
* key_type
, Type
* value_type
, Location
);
526 make_channel_type(bool send
, bool receive
, Type
*);
528 static Interface_type
*
529 make_interface_type(Typed_identifier_list
* methods
, Location
);
531 static Interface_type
*
532 make_empty_interface_type(Location
);
535 make_type_descriptor_type();
538 make_type_descriptor_ptr_type();
541 make_named_type(Named_object
*, Type
*, Location
);
544 make_forward_declaration(Named_object
*);
546 // Make a builtin struct type from a list of fields.
548 make_builtin_struct_type(int nfields
, ...);
550 // Make a builtin named type.
552 make_builtin_named_type(const char* name
, Type
* type
);
556 traverse(Type
*, Traverse
*);
558 // Verify the type. This is called after parsing, and verifies that
559 // types are complete and meet the language requirements. This
560 // returns false if the type is invalid and we should not continue
564 { return this->do_verify(); }
566 // Return true if two types are identical. If ERRORS_ARE_IDENTICAL,
567 // returns that an erroneous type is identical to any other type;
568 // this is used to avoid cascading errors. If this returns false,
569 // and REASON is not NULL, it may set *REASON.
571 are_identical(const Type
* lhs
, const Type
* rhs
, bool errors_are_identical
,
572 std::string
* reason
);
574 // An argument to are_identical_cmp_tags, indicating whether or not
575 // to compare struct field tags.
581 // Return true if two types are identical. This is like the
582 // are_identical function, but also takes a CMP_TAGS argument
583 // indicating whether to compare struct tags. Otherwise the
584 // parameters are as for are_identical.
586 are_identical_cmp_tags(const Type
* lhs
, const Type
* rhs
,
587 Cmp_tags
, bool errors_are_identical
,
588 std::string
* reason
);
590 // Return true if two types are compatible for use in a binary
591 // operation, other than a shift, comparison, or channel send. This
592 // is an equivalence relation.
594 are_compatible_for_binop(const Type
* t1
, const Type
* t2
);
596 // Return true if two types are compatible for use with the
597 // comparison operator. IS_EQUALITY_OP is true if this is an
598 // equality comparison, false if it is an ordered comparison. This
599 // is an equivalence relation. If this returns false, and REASON is
600 // not NULL, it sets *REASON.
602 are_compatible_for_comparison(bool is_equality_op
, const Type
*t1
,
603 const Type
*t2
, std::string
* reason
);
605 // Return true if a type is comparable with itself. This is true of
606 // most types, but false for, e.g., function types.
608 is_comparable() const
609 { return Type::are_compatible_for_comparison(true, this, this, NULL
); }
611 // Return true if a value with type RHS is assignable to a variable
612 // with type LHS. This is not an equivalence relation. If this
613 // returns false, and REASON is not NULL, it sets *REASON.
615 are_assignable(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
617 // Return true if a value with type RHS may be converted to type
618 // LHS. If this returns false, and REASON is not NULL, it sets
621 are_convertible(const Type
* lhs
, const Type
* rhs
, std::string
* reason
);
623 // Return true if values of this type can be compared using an
624 // identity function which gets nothing but a pointer to the value
627 compare_is_identity(Gogo
* gogo
)
628 { return this->do_compare_is_identity(gogo
); }
630 // Return whether values of this type are reflexive: if a comparison
631 // of a value with itself always returns true.
634 { return this->do_is_reflexive(); }
636 // Return whether values of this, when used as a key in map,
637 // requires the key to be updated when an assignment is made.
640 { return this->do_needs_key_update(); }
642 // Whether the type is permitted in the heap.
645 { return this->do_in_heap(); }
647 // Return a hash code for this type for the method hash table.
648 // Types which are equivalent according to are_identical will have
649 // the same hash code.
651 hash_for_method(Gogo
*) const;
653 // Return the type classification.
655 classification() const
656 { return this->classification_
; }
658 // Return the base type for this type. This looks through forward
659 // declarations and names. Using this with a forward declaration
660 // which has not been defined will return an error type.
667 // Return the type skipping defined forward declarations. If this
668 // type is a forward declaration which has not been defined, it will
669 // return the Forward_declaration_type. This differs from base() in
670 // that it will return a Named_type, and for a
671 // Forward_declaration_type which is not defined it will return that
672 // type rather than an error type.
679 // Return true if this is a basic type: a type which is not composed
680 // of other types, and is not void.
682 is_basic_type() const;
684 // Return true if this is an abstract type--an integer, floating
685 // point, or complex type whose size has not been determined.
689 // Return a non-abstract version of an abstract type.
691 make_non_abstract_type();
693 // Return true if this type is or contains a pointer. This
694 // determines whether the garbage collector needs to look at a value
698 { return this->do_has_pointer(); }
700 // Return true if this is the error type. This returns false for a
701 // type which is not defined, as it is called by the parser before
702 // all types are defined.
704 is_error_type() const;
706 // Return true if this is the error type or if the type is
707 // undefined. If the type is undefined, this will give an error.
708 // This should only be called after parsing is complete.
711 { return this->base()->is_error_type(); }
713 // Return true if this is a void type.
716 { return this->classification_
== TYPE_VOID
; }
718 // If this is an integer type, return the Integer_type. Otherwise,
719 // return NULL. This is a controlled dynamic_cast.
722 { return this->convert
<Integer_type
, TYPE_INTEGER
>(); }
726 { return this->convert
<const Integer_type
, TYPE_INTEGER
>(); }
728 // If this is a floating point type, return the Float_type.
729 // Otherwise, return NULL. This is a controlled dynamic_cast.
732 { return this->convert
<Float_type
, TYPE_FLOAT
>(); }
736 { return this->convert
<const Float_type
, TYPE_FLOAT
>(); }
738 // If this is a complex type, return the Complex_type. Otherwise,
742 { return this->convert
<Complex_type
, TYPE_COMPLEX
>(); }
746 { return this->convert
<const Complex_type
, TYPE_COMPLEX
>(); }
748 // Return whether this is a numeric type.
750 is_numeric_type() const
752 Type_classification tc
= this->base()->classification_
;
753 return tc
== TYPE_INTEGER
|| tc
== TYPE_FLOAT
|| tc
== TYPE_COMPLEX
;
756 // Return true if this is a boolean type.
758 is_boolean_type() const
759 { return this->base()->classification_
== TYPE_BOOLEAN
; }
761 // Return true if this is an abstract boolean type.
763 is_abstract_boolean_type() const
764 { return this->classification_
== TYPE_BOOLEAN
; }
766 // Return true if this is a string type.
768 is_string_type() const
769 { return this->base()->classification_
== TYPE_STRING
; }
771 // Return true if this is an abstract string type.
773 is_abstract_string_type() const
774 { return this->classification_
== TYPE_STRING
; }
776 // Return true if this is the sink type. This is the type of the
777 // blank identifier _.
780 { return this->base()->classification_
== TYPE_SINK
; }
782 // If this is a function type, return it. Otherwise, return NULL.
785 { return this->convert
<Function_type
, TYPE_FUNCTION
>(); }
788 function_type() const
789 { return this->convert
<const Function_type
, TYPE_FUNCTION
>(); }
791 // If this is a pointer type, return the type to which it points.
792 // Otherwise, return NULL.
796 // If this is a pointer type, return the type to which it points.
797 // Otherwise, return the type itself.
801 Type
* pt
= this->points_to();
802 return pt
!= NULL
? pt
: this;
808 const Type
* pt
= this->points_to();
809 return pt
!= NULL
? pt
: this;
812 // Return true if this is the nil type. We don't use base() here,
813 // because this can be called during parse, and there is no way to
814 // name the nil type anyhow.
817 { return this->classification_
== TYPE_NIL
; }
819 // Return true if this is the predeclared constant nil being used as
820 // a type. This is what the parser produces for type switches which
823 is_nil_constant_as_type() const;
825 // Return true if this is the return type of a function which
826 // returns multiple values.
828 is_call_multiple_result_type() const
829 { return this->base()->classification_
== TYPE_CALL_MULTIPLE_RESULT
; }
831 // If this is a struct type, return it. Otherwise, return NULL.
834 { return this->convert
<Struct_type
, TYPE_STRUCT
>(); }
838 { return this->convert
<const Struct_type
, TYPE_STRUCT
>(); }
840 // If this is an array type, return it. Otherwise, return NULL.
843 { return this->convert
<Array_type
, TYPE_ARRAY
>(); }
847 { return this->convert
<const Array_type
, TYPE_ARRAY
>(); }
849 // Return whether if this is a slice type.
851 is_slice_type() const;
853 // If this is a map type, return it. Otherwise, return NULL.
856 { return this->convert
<Map_type
, TYPE_MAP
>(); }
860 { return this->convert
<const Map_type
, TYPE_MAP
>(); }
862 // If this is a channel type, return it. Otherwise, return NULL.
865 { return this->convert
<Channel_type
, TYPE_CHANNEL
>(); }
869 { return this->convert
<const Channel_type
, TYPE_CHANNEL
>(); }
871 // If this is an interface type, return it. Otherwise, return NULL.
874 { return this->convert
<Interface_type
, TYPE_INTERFACE
>(); }
876 const Interface_type
*
877 interface_type() const
878 { return this->convert
<const Interface_type
, TYPE_INTERFACE
>(); }
880 // If this is a named type, return it. Otherwise, return NULL.
887 // If this is a forward declaration, return it. Otherwise, return
889 Forward_declaration_type
*
890 forward_declaration_type()
891 { return this->convert_no_base
<Forward_declaration_type
, TYPE_FORWARD
>(); }
893 const Forward_declaration_type
*
894 forward_declaration_type() const
896 return this->convert_no_base
<const Forward_declaration_type
,
900 // Return true if this type is not yet defined.
902 is_undefined() const;
904 // Return true if this is the unsafe.pointer type. We currently
905 // represent that as pointer-to-void.
907 is_unsafe_pointer_type() const
908 { return this->points_to() != NULL
&& this->points_to()->is_void_type(); }
910 // Look for field or method NAME for TYPE. Return an expression for
911 // it, bound to EXPR.
913 bind_field_or_method(Gogo
*, const Type
* type
, Expression
* expr
,
914 const std::string
& name
, Location
);
916 // Return true if NAME is an unexported field or method of TYPE.
918 is_unexported_field_or_method(Gogo
*, const Type
*, const std::string
&,
919 std::vector
<const Named_type
*>*);
921 // Convert the builtin named types.
923 convert_builtin_named_types(Gogo
*);
925 // Return the backend representation of this type.
929 // Return a placeholder for the backend representation of the type.
930 // This will return a type of the correct size, but for which some
931 // of the fields may still need to be completed.
933 get_backend_placeholder(Gogo
*);
935 // Finish the backend representation of a placeholder.
937 finish_backend(Gogo
*, Btype
*);
939 // Build a type descriptor entry for this type. Return a pointer to
940 // it. The location is the location which causes us to need the
943 type_descriptor_pointer(Gogo
* gogo
, Location
);
945 // Build the Garbage Collection symbol for this type. Return a pointer to it.
947 gc_symbol_pointer(Gogo
* gogo
);
949 // Return whether this type needs a garbage collection program.
950 // Sets *PTRSIZE and *PTRDATA.
952 needs_gcprog(Gogo
*, int64_t* ptrsize
, int64_t* ptrdata
);
954 // Return a ptrmask variable for this type.
956 gc_ptrmask_var(Gogo
*, int64_t ptrsize
, int64_t ptrdata
);
958 // Return the type reflection string for this type.
960 reflection(Gogo
*) const;
962 // Return a mangled name for the type. This is a name which can be
963 // used in assembler code. Identical types should have the same
966 mangled_name(Gogo
*) const;
968 // If the size of the type can be determined, set *PSIZE to the size
969 // in bytes and return true. Otherwise, return false. This queries
972 backend_type_size(Gogo
*, int64_t* psize
);
974 // If the alignment of the type can be determined, set *PALIGN to
975 // the alignment in bytes and return true. Otherwise, return false.
977 backend_type_align(Gogo
*, int64_t* palign
);
979 // If the alignment of a struct field of this type can be
980 // determined, set *PALIGN to the alignment in bytes and return
981 // true. Otherwise, return false.
983 backend_type_field_align(Gogo
*, int64_t* palign
);
985 // Determine the ptrdata size for the backend version of this type:
986 // the length of the prefix of the type that can contain a pointer
987 // value. If it can be determined, set *PPTRDATA to the value in
988 // bytes and return true. Otherwise, return false.
990 backend_type_ptrdata(Gogo
*, int64_t* pptrdata
);
992 // Determine the ptrdata size that we are going to set in the type
993 // descriptor. This is normally the same as backend_type_ptrdata,
994 // but differs if we use a gcprog for an array. The arguments and
995 // results are as for backend_type_ptrdata.
997 descriptor_ptrdata(Gogo
*, int64_t* pptrdata
);
999 // Whether the backend size is known.
1001 is_backend_type_size_known(Gogo
*);
1003 // Return whether the type needs specially built type functions.
1005 needs_specific_type_functions(Gogo
*);
1007 // Get the hash and equality functions for a type.
1009 type_functions(Gogo
*, Named_type
* name
, Function_type
* hash_fntype
,
1010 Function_type
* equal_fntype
, Named_object
** hash_fn
,
1011 Named_object
** equal_fn
);
1013 // Write the hash and equality type functions.
1015 write_specific_type_functions(Gogo
*, Named_type
*, int64_t size
,
1016 const std::string
& hash_name
,
1017 Function_type
* hash_fntype
,
1018 const std::string
& equal_name
,
1019 Function_type
* equal_fntype
);
1021 // Return the alignment required by the memequalN function.
1022 static int64_t memequal_align(Gogo
*, int size
);
1026 export_type(Export
* exp
) const
1027 { this->do_export(exp
); }
1031 import_type(Import
*);
1034 Type(Type_classification
);
1036 // Functions implemented by the child class.
1038 // Traverse the subtypes.
1040 do_traverse(Traverse
*);
1048 do_has_pointer() const
1052 do_compare_is_identity(Gogo
*) = 0;
1059 do_needs_key_update()
1066 virtual unsigned int
1067 do_hash_for_method(Gogo
*) const;
1070 do_get_backend(Gogo
*) = 0;
1073 do_type_descriptor(Gogo
*, Named_type
* name
) = 0;
1076 do_reflection(Gogo
*, std::string
*) const = 0;
1079 do_mangled_name(Gogo
*, std::string
*) const = 0;
1082 do_export(Export
*) const;
1084 // Return whether a method expects a pointer as the receiver.
1086 method_expects_pointer(const Named_object
*);
1088 // Finalize the methods for a type.
1090 finalize_methods(Gogo
*, const Type
*, Location
, Methods
**);
1092 // Return a method from a set of methods.
1094 method_function(const Methods
*, const std::string
& name
,
1095 bool* is_ambiguous
);
1097 // A mapping from interfaces to the associated interface method
1098 // tables for this type. This maps to a decl.
1099 typedef Unordered_map_hash(Interface_type
*, Expression
*, Type_hash_identical
,
1100 Type_identical
) Interface_method_tables
;
1102 // Return a pointer to the interface method table for TYPE for the
1103 // interface INTERFACE.
1105 interface_method_table(Type
* type
,
1106 Interface_type
*interface
, bool is_pointer
,
1107 Interface_method_tables
** method_tables
,
1108 Interface_method_tables
** pointer_tables
);
1110 // Return a composite literal for the type descriptor entry for a
1113 type_descriptor(Gogo
*, Type
*);
1115 // Return a composite literal for the type descriptor entry for
1116 // TYPE, using NAME as the name of the type.
1118 named_type_descriptor(Gogo
*, Type
* type
, Named_type
* name
);
1120 // Return a composite literal for a plain type descriptor for this
1121 // type with the given kind and name.
1123 plain_type_descriptor(Gogo
*, int runtime_type_kind
, Named_type
* name
);
1125 // Build a composite literal for the basic type descriptor.
1127 type_descriptor_constructor(Gogo
*, int runtime_type_kind
, Named_type
*,
1128 const Methods
*, bool only_value_methods
);
1130 // For the benefit of child class reflection string generation.
1132 append_reflection(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
1133 { type
->do_reflection(gogo
, ret
); }
1135 // For the benefit of child class mangling.
1137 append_mangled_name(const Type
* type
, Gogo
* gogo
, std::string
* ret
) const
1138 { type
->do_mangled_name(gogo
, ret
); }
1140 // Incorporate a string into a hash code.
1142 hash_string(const std::string
&, unsigned int);
1144 // Return the backend representation for the underlying type of a
1147 get_named_base_btype(Gogo
* gogo
, Type
* base_type
)
1148 { return base_type
->get_btype_without_hash(gogo
); }
1151 // Convert to the desired type classification, or return NULL. This
1152 // is a controlled dynamic_cast.
1153 template<typename Type_class
, Type_classification type_classification
>
1157 Type
* base
= this->base();
1158 return (base
->classification_
== type_classification
1159 ? static_cast<Type_class
*>(base
)
1163 template<typename Type_class
, Type_classification type_classification
>
1167 const Type
* base
= this->base();
1168 return (base
->classification_
== type_classification
1169 ? static_cast<Type_class
*>(base
)
1173 template<typename Type_class
, Type_classification type_classification
>
1177 return (this->classification_
== type_classification
1178 ? static_cast<Type_class
*>(this)
1182 template<typename Type_class
, Type_classification type_classification
>
1184 convert_no_base() const
1186 return (this->classification_
== type_classification
1187 ? static_cast<Type_class
*>(this)
1191 // Map unnamed types to type descriptor decls.
1192 typedef Unordered_map_hash(const Type
*, Bvariable
*, Type_hash_identical
,
1193 Type_identical
) Type_descriptor_vars
;
1195 static Type_descriptor_vars type_descriptor_vars
;
1197 // Build the type descriptor variable for this type.
1199 make_type_descriptor_var(Gogo
*);
1201 // Map unnamed types to type descriptor decls.
1202 typedef Unordered_map_hash(const Type
*, Bvariable
*, Type_hash_identical
,
1203 Type_identical
) GC_symbol_vars
;
1205 static GC_symbol_vars gc_symbol_vars
;
1207 // Map ptrmask symbol names to the ptrmask variable.
1208 typedef Unordered_map(std::string
, Bvariable
*) GC_gcbits_vars
;
1210 static GC_gcbits_vars gc_gcbits_vars
;
1212 // Build the GC symbol for this type.
1214 make_gc_symbol_var(Gogo
*);
1216 // Return true if the type descriptor for this type should be
1217 // defined in some other package. If NAME is not NULL, it is the
1218 // name of this type. If this returns true it sets *PACKAGE to the
1219 // package where the type descriptor is defined.
1221 type_descriptor_defined_elsewhere(Named_type
* name
, const Package
** package
);
1223 // Make a composite literal for the garbage collection program for
1226 gcprog_constructor(Gogo
*, int64_t ptrsize
, int64_t ptrdata
);
1228 // Build the hash and equality type functions for a type which needs
1229 // specific functions.
1231 specific_type_functions(Gogo
*, Named_type
*, int64_t size
,
1232 Function_type
* hash_fntype
,
1233 Function_type
* equal_fntype
, Named_object
** hash_fn
,
1234 Named_object
** equal_fn
);
1237 write_identity_hash(Gogo
*, int64_t size
);
1240 write_identity_equal(Gogo
*, int64_t size
);
1243 write_named_hash(Gogo
*, Named_type
*, Function_type
* hash_fntype
,
1244 Function_type
* equal_fntype
);
1247 write_named_equal(Gogo
*, Named_type
*);
1249 // Build a composite literal for the uncommon type information.
1251 uncommon_type_constructor(Gogo
*, Type
* uncommon_type
,
1252 Named_type
*, const Methods
*,
1253 bool only_value_methods
) const;
1255 // Build a composite literal for the methods.
1257 methods_constructor(Gogo
*, Type
* methods_type
, const Methods
*,
1258 bool only_value_methods
) const;
1260 // Build a composite literal for one method.
1262 method_constructor(Gogo
*, Type
* method_type
, const std::string
& name
,
1263 const Method
*, bool only_value_methods
) const;
1265 // Add all methods for TYPE to the list of methods for THIS.
1267 add_methods_for_type(const Type
* type
, const Method::Field_indexes
*,
1268 unsigned int depth
, bool, bool,
1269 std::vector
<const Named_type
*>*,
1273 add_local_methods_for_type(const Named_type
* type
,
1274 const Method::Field_indexes
*,
1275 unsigned int depth
, bool, bool, Methods
*);
1278 add_embedded_methods_for_type(const Type
* type
,
1279 const Method::Field_indexes
*,
1280 unsigned int depth
, bool, bool,
1281 std::vector
<const Named_type
*>*,
1285 add_interface_methods_for_type(const Type
* type
,
1286 const Method::Field_indexes
*,
1287 unsigned int depth
, Methods
*);
1289 // Build stub methods for a type.
1291 build_stub_methods(Gogo
*, const Type
* type
, const Methods
* methods
,
1295 build_one_stub_method(Gogo
*, Method
*, const char* receiver_name
,
1296 const Typed_identifier_list
*, bool is_varargs
,
1300 apply_field_indexes(Expression
*, const Method::Field_indexes
*,
1303 // Look for a field or method named NAME in TYPE.
1305 find_field_or_method(const Type
* type
, const std::string
& name
,
1306 bool receiver_can_be_pointer
,
1307 std::vector
<const Named_type
*>*, int* level
,
1308 bool* is_method
, bool* found_pointer_method
,
1309 std::string
* ambig1
, std::string
* ambig2
);
1311 // Get the backend representation for a type without looking in the
1312 // hash table for identical types.
1314 get_btype_without_hash(Gogo
*);
1316 // A backend type that may be a placeholder.
1317 struct Type_btype_entry
1320 bool is_placeholder
;
1323 // A mapping from Type to Btype*, used to ensure that the backend
1324 // representation of identical types is identical. This is only
1325 // used for unnamed types.
1326 typedef Unordered_map_hash(const Type
*, Type_btype_entry
,
1327 Type_hash_identical
, Type_identical
) Type_btypes
;
1329 static Type_btypes type_btypes
;
1331 // A list of builtin named types.
1332 static std::vector
<Named_type
*> named_builtin_types
;
1334 // A map from types which need specific type functions to the type
1335 // functions themselves.
1336 typedef std::pair
<Named_object
*, Named_object
*> Hash_equal_fn
;
1337 typedef Unordered_map_hash(const Type
*, Hash_equal_fn
, Type_hash_identical
,
1338 Type_identical
) Type_functions
;
1340 static Type_functions type_functions_table
;
1342 // Cache for reusing existing pointer types; maps from pointed-to-type
1344 typedef Unordered_map(Type
*, Pointer_type
*) Pointer_type_table
;
1346 static Pointer_type_table pointer_types
;
1348 // List of placeholder pointer types.
1349 static std::vector
<Pointer_type
*> placeholder_pointers
;
1351 // The type classification.
1352 Type_classification classification_
;
1353 // The backend representation of the type, once it has been
1356 // The type descriptor for this type. This starts out as NULL and
1357 // is filled in as needed.
1358 Bvariable
* type_descriptor_var_
;
1359 // The GC symbol for this type. This starts out as NULL and
1360 // is filled in as needed.
1361 Bvariable
* gc_symbol_var_
;
1362 // Whether this type can appear in the heap.
1366 // Type hash table operations.
1368 class Type_hash_identical
1372 operator()(const Type
* type
) const
1373 { return type
->hash_for_method(NULL
); }
1376 class Type_identical
1380 operator()(const Type
* t1
, const Type
* t2
) const
1381 { return Type::are_identical(t1
, t2
, false, NULL
); }
1384 // An identifier with a type.
1386 class Typed_identifier
1389 Typed_identifier(const std::string
& name
, Type
* type
,
1391 : name_(name
), type_(type
), location_(location
), note_(NULL
)
1397 { return this->name_
; }
1402 { return this->type_
; }
1404 // Return the location where the name was seen. This is not always
1408 { return this->location_
; }
1410 // Set the type--sometimes we see the identifier before the type.
1412 set_type(Type
* type
)
1414 go_assert(this->type_
== NULL
|| type
->is_error_type());
1418 // Get the escape note.
1421 { return this->note_
; }
1423 // Set the escape note.
1425 set_note(const std::string
& note
)
1426 { this->note_
= new std::string(note
); }
1433 // The location where the name was seen.
1435 // Escape note for this typed identifier. Used when importing and exporting
1440 // A list of Typed_identifiers.
1442 class Typed_identifier_list
1445 Typed_identifier_list()
1449 // Whether the list is empty.
1452 { return this->entries_
.empty(); }
1454 // Return the number of entries in the list.
1457 { return this->entries_
.size(); }
1459 // Add an entry to the end of the list.
1461 push_back(const Typed_identifier
& td
)
1462 { this->entries_
.push_back(td
); }
1464 // Remove an entry from the end of the list.
1467 { this->entries_
.pop_back(); }
1469 // Set the type of entry I to TYPE.
1471 set_type(size_t i
, Type
* type
)
1473 go_assert(i
< this->entries_
.size());
1474 this->entries_
[i
].set_type(type
);
1477 // Sort the entries by name.
1483 traverse(Traverse
*);
1485 // Return the first and last elements.
1488 { return this->entries_
.front(); }
1490 const Typed_identifier
&
1492 { return this->entries_
.front(); }
1496 { return this->entries_
.back(); }
1498 const Typed_identifier
&
1500 { return this->entries_
.back(); }
1504 { return this->entries_
.at(i
); }
1506 const Typed_identifier
&
1508 { return this->entries_
.at(i
); }
1511 set(size_t i
, const Typed_identifier
& t
)
1512 { this->entries_
.at(i
) = t
; }
1517 go_assert(c
<= this->entries_
.size());
1518 this->entries_
.resize(c
, Typed_identifier("", NULL
,
1519 Linemap::unknown_location()));
1524 { this->entries_
.reserve(c
); }
1528 typedef std::vector
<Typed_identifier
>::iterator iterator
;
1529 typedef std::vector
<Typed_identifier
>::const_iterator const_iterator
;
1533 { return this->entries_
.begin(); }
1537 { return this->entries_
.begin(); }
1541 { return this->entries_
.end(); }
1545 { return this->entries_
.end(); }
1547 // Return a copy of this list. This returns an independent copy of
1548 // the vector, but does not copy the types.
1549 Typed_identifier_list
*
1553 std::vector
<Typed_identifier
> entries_
;
1556 // A type used to indicate a parsing error. This exists to simplify
1557 // later error detection.
1559 class Error_type
: public Type
1568 do_compare_is_identity(Gogo
*)
1572 do_get_backend(Gogo
* gogo
);
1575 do_type_descriptor(Gogo
*, Named_type
*);
1578 do_reflection(Gogo
*, std::string
*) const;
1581 do_mangled_name(Gogo
*, std::string
* ret
) const;
1586 class Void_type
: public Type
1595 do_compare_is_identity(Gogo
*)
1599 do_get_backend(Gogo
* gogo
);
1602 do_type_descriptor(Gogo
*, Named_type
*)
1603 { go_unreachable(); }
1606 do_reflection(Gogo
*, std::string
*) const
1610 do_mangled_name(Gogo
*, std::string
* ret
) const;
1613 // The boolean type.
1615 class Boolean_type
: public Type
1619 : Type(TYPE_BOOLEAN
)
1624 do_compare_is_identity(Gogo
*)
1628 do_get_backend(Gogo
* gogo
);
1631 do_type_descriptor(Gogo
*, Named_type
* name
);
1633 // We should not be asked for the reflection string of a basic type.
1635 do_reflection(Gogo
*, std::string
* ret
) const
1636 { ret
->append("bool"); }
1639 do_mangled_name(Gogo
*, std::string
* ret
) const;
1642 // The type of an integer.
1644 class Integer_type
: public Type
1647 // Create a new integer type.
1649 create_integer_type(const char* name
, bool is_unsigned
, int bits
,
1650 int runtime_type_kind
);
1652 // Look up an existing integer type.
1654 lookup_integer_type(const char* name
);
1656 // Create an abstract integer type.
1657 static Integer_type
*
1658 create_abstract_integer_type();
1660 // Create an abstract character type.
1661 static Integer_type
*
1662 create_abstract_character_type();
1664 // Whether this is an abstract integer type.
1667 { return this->is_abstract_
; }
1669 // Whether this is an unsigned type.
1672 { return this->is_unsigned_
; }
1674 // The number of bits.
1677 { return this->bits_
; }
1679 // Whether this type is the same as T.
1681 is_identical(const Integer_type
* t
) const;
1683 // Whether this is the type "byte" or another name for "byte".
1686 { return this->is_byte_
; }
1688 // Mark this as the "byte" type.
1691 { this->is_byte_
= true; }
1693 // Whether this is the type "rune" or another name for "rune".
1696 { return this->is_rune_
; }
1698 // Mark this as the "rune" type.
1701 { this->is_rune_
= true; }
1705 do_compare_is_identity(Gogo
*)
1709 do_hash_for_method(Gogo
*) const;
1712 do_get_backend(Gogo
*);
1715 do_type_descriptor(Gogo
*, Named_type
*);
1718 do_reflection(Gogo
*, std::string
*) const;
1721 do_mangled_name(Gogo
*, std::string
*) const;
1724 Integer_type(bool is_abstract
, bool is_unsigned
, int bits
,
1725 int runtime_type_kind
)
1726 : Type(TYPE_INTEGER
),
1727 is_abstract_(is_abstract
), is_unsigned_(is_unsigned
), is_byte_(false),
1728 is_rune_(false), bits_(bits
), runtime_type_kind_(runtime_type_kind
)
1731 // Map names of integer types to the types themselves.
1732 typedef std::map
<std::string
, Named_type
*> Named_integer_types
;
1733 static Named_integer_types named_integer_types
;
1735 // True if this is an abstract type.
1737 // True if this is an unsigned type.
1739 // True if this is the byte type.
1741 // True if this is the rune type.
1743 // The number of bits.
1745 // The runtime type code used in the type descriptor for this type.
1746 int runtime_type_kind_
;
1749 // The type of a floating point number.
1751 class Float_type
: public Type
1754 // Create a new float type.
1756 create_float_type(const char* name
, int bits
, int runtime_type_kind
);
1758 // Look up an existing float type.
1760 lookup_float_type(const char* name
);
1762 // Create an abstract float type.
1764 create_abstract_float_type();
1766 // Whether this is an abstract float type.
1769 { return this->is_abstract_
; }
1771 // The number of bits.
1774 { return this->bits_
; }
1776 // Whether this type is the same as T.
1778 is_identical(const Float_type
* t
) const;
1782 do_compare_is_identity(Gogo
*)
1789 // Distinction between +0 and -0 requires a key update.
1791 do_needs_key_update()
1795 do_hash_for_method(Gogo
*) const;
1798 do_get_backend(Gogo
*);
1801 do_type_descriptor(Gogo
*, Named_type
*);
1804 do_reflection(Gogo
*, std::string
*) const;
1807 do_mangled_name(Gogo
*, std::string
*) const;
1810 Float_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1812 is_abstract_(is_abstract
), bits_(bits
),
1813 runtime_type_kind_(runtime_type_kind
)
1816 // Map names of float types to the types themselves.
1817 typedef std::map
<std::string
, Named_type
*> Named_float_types
;
1818 static Named_float_types named_float_types
;
1820 // True if this is an abstract type.
1822 // The number of bits in the floating point value.
1824 // The runtime type code used in the type descriptor for this type.
1825 int runtime_type_kind_
;
1828 // The type of a complex number.
1830 class Complex_type
: public Type
1833 // Create a new complex type.
1835 create_complex_type(const char* name
, int bits
, int runtime_type_kind
);
1837 // Look up an existing complex type.
1839 lookup_complex_type(const char* name
);
1841 // Create an abstract complex type.
1842 static Complex_type
*
1843 create_abstract_complex_type();
1845 // Whether this is an abstract complex type.
1848 { return this->is_abstract_
; }
1850 // The number of bits: 64 or 128.
1852 { return this->bits_
; }
1854 // Whether this type is the same as T.
1856 is_identical(const Complex_type
* t
) const;
1860 do_compare_is_identity(Gogo
*)
1867 // Distinction between +0 and -0 requires a key update.
1869 do_needs_key_update()
1873 do_hash_for_method(Gogo
*) const;
1876 do_get_backend(Gogo
*);
1879 do_type_descriptor(Gogo
*, Named_type
*);
1882 do_reflection(Gogo
*, std::string
*) const;
1885 do_mangled_name(Gogo
*, std::string
*) const;
1888 Complex_type(bool is_abstract
, int bits
, int runtime_type_kind
)
1889 : Type(TYPE_COMPLEX
),
1890 is_abstract_(is_abstract
), bits_(bits
),
1891 runtime_type_kind_(runtime_type_kind
)
1894 // Map names of complex types to the types themselves.
1895 typedef std::map
<std::string
, Named_type
*> Named_complex_types
;
1896 static Named_complex_types named_complex_types
;
1898 // True if this is an abstract type.
1900 // The number of bits in the complex value--64 or 128.
1902 // The runtime type code used in the type descriptor for this type.
1903 int runtime_type_kind_
;
1906 // The type of a string.
1908 class String_type
: public Type
1917 do_has_pointer() const
1921 do_compare_is_identity(Gogo
*)
1924 // New string might have a smaller backing store.
1926 do_needs_key_update()
1930 do_get_backend(Gogo
*);
1933 do_type_descriptor(Gogo
*, Named_type
*);
1936 do_reflection(Gogo
*, std::string
*) const;
1939 do_mangled_name(Gogo
*, std::string
* ret
) const;
1942 // The named string type.
1943 static Named_type
* string_type_
;
1946 // The type of a function.
1948 class Function_type
: public Type
1951 Function_type(Typed_identifier
* receiver
, Typed_identifier_list
* parameters
,
1952 Typed_identifier_list
* results
, Location location
)
1953 : Type(TYPE_FUNCTION
),
1954 receiver_(receiver
), parameters_(parameters
), results_(results
),
1955 location_(location
), is_varargs_(false), is_builtin_(false),
1956 fnbtype_(NULL
), is_tagged_(false)
1959 // Get the receiver.
1960 const Typed_identifier
*
1962 { return this->receiver_
; }
1964 // Add an escape note for the receiver.
1966 add_receiver_note(int encoding
)
1967 { this->receiver_
->set_note(Escape_note::make_tag(encoding
)); }
1969 // Get the return names and types.
1970 const Typed_identifier_list
*
1972 { return this->results_
; }
1974 // Get the parameter names and types.
1975 const Typed_identifier_list
*
1977 { return this->parameters_
; }
1979 // Add an escape note for the ith parameter.
1981 add_parameter_note(int index
, int encoding
)
1982 { this->parameters_
->at(index
).set_note(Escape_note::make_tag(encoding
)); }
1984 // Whether this function has been tagged during escape analysis.
1987 { return this->is_tagged_
; }
1989 // Mark this function as tagged after analyzing its escape.
1992 { this->is_tagged_
= true; }
1994 // Whether this is a varargs function.
1997 { return this->is_varargs_
; }
1999 // Whether this is a builtin function.
2002 { return this->is_builtin_
; }
2004 // The location where this type was defined.
2007 { return this->location_
; }
2009 // Return whether this is a method type.
2012 { return this->receiver_
!= NULL
; }
2014 // Whether T is a valid redeclaration of this type. This is called
2015 // when a function is declared more than once.
2017 is_valid_redeclaration(const Function_type
* t
, std::string
*) const;
2019 // Whether this type is the same as T.
2021 is_identical(const Function_type
* t
, bool ignore_receiver
,
2022 Cmp_tags
, bool errors_are_identical
, std::string
*) const;
2024 // Record that this is a varargs function.
2027 { this->is_varargs_
= true; }
2029 // Record that this is a builtin function.
2032 { this->is_builtin_
= true; }
2034 // Import a function type.
2035 static Function_type
*
2038 // Return a copy of this type without a receiver. This is only
2039 // valid for a method type.
2041 copy_without_receiver() const;
2043 // Return a copy of this type with a receiver. This is used when an
2044 // interface method is attached to a named or struct type.
2046 copy_with_receiver(Type
*) const;
2048 // Return a copy of this type with the receiver treated as the first
2049 // parameter. If WANT_POINTER_RECEIVER is true, the receiver is
2050 // forced to be a pointer.
2052 copy_with_receiver_as_param(bool want_pointer_receiver
) const;
2054 // Return a copy of this type ignoring any receiver and using dummy
2055 // names for all parameters. This is used for thunks for method
2058 copy_with_names() const;
2061 make_function_type_descriptor_type();
2063 // Return the backend representation of this function type. This is used
2064 // as the real type of a backend function declaration or defintion.
2066 get_backend_fntype(Gogo
*);
2070 do_traverse(Traverse
*);
2072 // A function descriptor may be allocated on the heap.
2074 do_has_pointer() const
2078 do_compare_is_identity(Gogo
*)
2082 do_hash_for_method(Gogo
*) const;
2085 do_get_backend(Gogo
*);
2088 do_type_descriptor(Gogo
*, Named_type
*);
2091 do_reflection(Gogo
*, std::string
*) const;
2094 do_mangled_name(Gogo
*, std::string
*) const;
2097 do_export(Export
*) const;
2101 type_descriptor_params(Type
*, const Typed_identifier
*,
2102 const Typed_identifier_list
*);
2104 // A mapping from a list of result types to a backend struct type.
2109 operator()(const Typed_identifier_list
*) const;
2116 operator()(const Typed_identifier_list
*,
2117 const Typed_identifier_list
*) const;
2120 typedef Unordered_map_hash(Typed_identifier_list
*, Btype
*,
2121 Results_hash
, Results_equal
) Results_structs
;
2123 static Results_structs results_structs
;
2125 // The receiver name and type. This will be NULL for a normal
2126 // function, non-NULL for a method.
2127 Typed_identifier
* receiver_
;
2128 // The parameter names and types.
2129 Typed_identifier_list
* parameters_
;
2130 // The result names and types. This will be NULL if no result was
2132 Typed_identifier_list
* results_
;
2133 // The location where this type was defined. This exists solely to
2134 // give a location for the fields of the struct if this function
2135 // returns multiple values.
2137 // Whether this function takes a variable number of arguments.
2139 // Whether this is a special builtin function which can not simply
2140 // be called. This is used for len, cap, etc.
2142 // The backend representation of this type for backend function
2143 // declarations and definitions.
2145 // Whether this function has been analyzed by escape analysis. If this is
2146 // TRUE, this function type's parameters contain a summary of the analysis.
2150 // The type of a function's backend representation.
2152 class Backend_function_type
: public Function_type
2155 Backend_function_type(Typed_identifier
* receiver
,
2156 Typed_identifier_list
* parameters
,
2157 Typed_identifier_list
* results
, Location location
)
2158 : Function_type(receiver
, parameters
, results
, location
)
2163 do_get_backend(Gogo
* gogo
)
2164 { return this->get_backend_fntype(gogo
); }
2167 // The type of a pointer.
2169 class Pointer_type
: public Type
2172 Pointer_type(Type
* to_type
)
2173 : Type(TYPE_POINTER
),
2179 { return this->to_type_
; }
2181 // Import a pointer type.
2182 static Pointer_type
*
2186 make_pointer_type_descriptor_type();
2190 do_traverse(Traverse
*);
2194 { return this->to_type_
->verify(); }
2197 do_has_pointer() const
2201 do_compare_is_identity(Gogo
*)
2205 do_hash_for_method(Gogo
*) const;
2208 do_get_backend(Gogo
*);
2211 do_type_descriptor(Gogo
*, Named_type
*);
2214 do_reflection(Gogo
*, std::string
*) const;
2217 do_mangled_name(Gogo
*, std::string
*) const;
2220 do_export(Export
*) const;
2223 // The type to which this type points.
2227 // The nil type. We use a special type for nil because it is not the
2228 // same as any other type. In C term nil has type void*, but there is
2229 // no such type in Go.
2231 class Nil_type
: public Type
2240 do_compare_is_identity(Gogo
*)
2244 do_get_backend(Gogo
* gogo
);
2247 do_type_descriptor(Gogo
*, Named_type
*)
2248 { go_unreachable(); }
2251 do_reflection(Gogo
*, std::string
*) const
2252 { go_unreachable(); }
2255 do_mangled_name(Gogo
*, std::string
* ret
) const;
2258 // The type of a field in a struct.
2263 explicit Struct_field(const Typed_identifier
& typed_identifier
)
2264 : typed_identifier_(typed_identifier
), tag_(NULL
), is_imported_(false)
2271 // Return whether this struct field is named NAME.
2273 is_field_name(const std::string
& name
) const;
2275 // Return whether this struct field is an unexported field named NAME.
2277 is_unexported_field_name(Gogo
*, const std::string
& name
) const;
2279 // Return whether this struct field is an embedded built-in type.
2281 is_embedded_builtin(Gogo
*) const;
2286 { return this->typed_identifier_
.type(); }
2288 // The field location.
2291 { return this->typed_identifier_
.location(); }
2293 // Whether the field has a tag.
2296 { return this->tag_
!= NULL
; }
2302 go_assert(this->tag_
!= NULL
);
2306 // Whether this is an anonymous field.
2308 is_anonymous() const
2309 { return this->typed_identifier_
.name().empty(); }
2311 // Set the tag. FIXME: This is never freed.
2313 set_tag(const std::string
& tag
)
2314 { this->tag_
= new std::string(tag
); }
2316 // Record that this field is defined in an imported struct.
2319 { this->is_imported_
= true; }
2321 // Set the type. This is only used in error cases.
2323 set_type(Type
* type
)
2324 { this->typed_identifier_
.set_type(type
); }
2327 // The field name, type, and location.
2328 Typed_identifier typed_identifier_
;
2329 // The field tag. This is NULL if the field has no tag.
2331 // Whether this field is defined in an imported struct.
2335 // A list of struct fields.
2337 class Struct_field_list
2344 // Whether the list is empty.
2347 { return this->entries_
.empty(); }
2349 // Return the number of entries.
2352 { return this->entries_
.size(); }
2354 // Add an entry to the end of the list.
2356 push_back(const Struct_field
& sf
)
2357 { this->entries_
.push_back(sf
); }
2359 // Index into the list.
2362 { return this->entries_
.at(i
); }
2364 // Last entry in list.
2367 { return this->entries_
.back(); }
2371 typedef std::vector
<Struct_field
>::iterator iterator
;
2372 typedef std::vector
<Struct_field
>::const_iterator const_iterator
;
2376 { return this->entries_
.begin(); }
2380 { return this->entries_
.begin(); }
2384 { return this->entries_
.end(); }
2388 { return this->entries_
.end(); }
2391 std::vector
<Struct_field
> entries_
;
2394 // The type of a struct.
2396 class Struct_type
: public Type
2399 Struct_type(Struct_field_list
* fields
, Location location
)
2400 : Type(TYPE_STRUCT
),
2401 fields_(fields
), location_(location
), all_methods_(NULL
),
2402 is_struct_incomparable_(false)
2405 // Return the field NAME. This only looks at local fields, not at
2406 // embedded types. If the field is found, and PINDEX is not NULL,
2407 // this sets *PINDEX to the field index. If the field is not found,
2408 // this returns NULL.
2410 find_local_field(const std::string
& name
, unsigned int *pindex
) const;
2412 // Return the field number INDEX.
2414 field(unsigned int index
) const
2415 { return &this->fields_
->at(index
); }
2417 // Get the struct fields.
2418 const Struct_field_list
*
2420 { return this->fields_
; }
2422 // Return the number of fields.
2425 { return this->fields_
->size(); }
2427 // Push a new field onto the end of the struct. This is used when
2428 // building a closure variable.
2430 push_field(const Struct_field
& sf
)
2431 { this->fields_
->push_back(sf
); }
2433 // Return an expression referring to field NAME in STRUCT_EXPR, or
2434 // NULL if there is no field with that name.
2435 Field_reference_expression
*
2436 field_reference(Expression
* struct_expr
, const std::string
& name
,
2439 // Return the total number of fields, including embedded fields.
2440 // This is the number of values that can appear in a conversion to
2443 total_field_count() const;
2445 // Whether this type is identical with T.
2447 is_identical(const Struct_type
* t
, Cmp_tags
,
2448 bool errors_are_identical
) const;
2450 // Return whether NAME is a local field which is not exported. This
2451 // is only used for better error reporting.
2453 is_unexported_local_field(Gogo
*, const std::string
& name
) const;
2455 // If this is an unnamed struct, build the complete list of methods,
2456 // including those from anonymous fields, and build methods stubs if
2459 finalize_methods(Gogo
*);
2461 // Return whether this type has any methods. This should only be
2462 // called after the finalize_methods pass.
2464 has_any_methods() const
2465 { return this->all_methods_
!= NULL
; }
2467 // Return the methods for tihs type. This should only be called
2468 // after the finalize_methods pass.
2471 { return this->all_methods_
; }
2473 // Return the method to use for NAME. This returns NULL if there is
2474 // no such method or if the method is ambiguous. When it returns
2475 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
2477 method_function(const std::string
& name
, bool* is_ambiguous
) const;
2479 // Return a pointer to the interface method table for this type for
2480 // the interface INTERFACE. If IS_POINTER is true, set the type
2481 // descriptor to a pointer to this type, otherwise set it to this
2484 interface_method_table(Interface_type
* interface
, bool is_pointer
);
2486 // Traverse just the field types of a struct type.
2488 traverse_field_types(Traverse
* traverse
)
2489 { return this->do_traverse(traverse
); }
2491 // If the offset of field INDEX in the backend implementation can be
2492 // determined, set *POFFSET to the offset in bytes and return true.
2493 // Otherwise, return false.
2495 backend_field_offset(Gogo
*, unsigned int index
, int64_t* poffset
);
2497 // Finish the backend representation of all the fields.
2499 finish_backend_fields(Gogo
*);
2501 // Import a struct type.
2506 make_struct_type_descriptor_type();
2508 // Return whether this is a generated struct that is not comparable.
2510 is_struct_incomparable() const
2511 { return this->is_struct_incomparable_
; }
2513 // Record that this is a generated struct that is not comparable.
2515 set_is_struct_incomparable()
2516 { this->is_struct_incomparable_
= true; }
2518 // Write the hash function for this type.
2520 write_hash_function(Gogo
*, Named_type
*, Function_type
*, Function_type
*);
2522 // Write the equality function for this type.
2524 write_equal_function(Gogo
*, Named_type
*);
2526 // Whether we can write this type to a C header file, to implement
2529 can_write_to_c_header(std::vector
<const Named_object
*>*,
2530 std::vector
<const Named_object
*>*) const;
2532 // Write this type to a C header file, to implement -fgo-c-header.
2534 write_to_c_header(std::ostream
&) const;
2538 do_traverse(Traverse
*);
2544 do_has_pointer() const;
2547 do_compare_is_identity(Gogo
*);
2553 do_needs_key_update();
2559 do_hash_for_method(Gogo
*) const;
2562 do_get_backend(Gogo
*);
2565 do_type_descriptor(Gogo
*, Named_type
*);
2568 do_reflection(Gogo
*, std::string
*) const;
2571 do_mangled_name(Gogo
*, std::string
*) const;
2574 do_export(Export
*) const;
2578 can_write_type_to_c_header(const Type
*,
2579 std::vector
<const Named_object
*>*,
2580 std::vector
<const Named_object
*>*) const;
2583 write_field_to_c_header(std::ostream
&, const std::string
&, const Type
*) const;
2585 // Used to merge method sets of identical unnamed structs.
2586 typedef Unordered_map_hash(Struct_type
*, Struct_type
*, Type_hash_identical
,
2587 Type_identical
) Identical_structs
;
2589 static Identical_structs identical_structs
;
2591 // Used to manage method tables for identical unnamed structs.
2592 typedef std::pair
<Interface_method_tables
*, Interface_method_tables
*>
2593 Struct_method_table_pair
;
2595 typedef Unordered_map_hash(Struct_type
*, Struct_method_table_pair
*,
2596 Type_hash_identical
, Type_identical
)
2597 Struct_method_tables
;
2599 static Struct_method_tables struct_method_tables
;
2601 // Used to avoid infinite loops in field_reference_depth.
2602 struct Saw_named_type
2604 Saw_named_type
* next
;
2608 Field_reference_expression
*
2609 field_reference_depth(Expression
* struct_expr
, const std::string
& name
,
2610 Location
, Saw_named_type
*,
2611 unsigned int* depth
) const;
2613 // The fields of the struct.
2614 Struct_field_list
* fields_
;
2615 // The place where the struct was declared.
2617 // If this struct is unnamed, a list of methods.
2618 Methods
* all_methods_
;
2619 // True if this is a generated struct that is not considered to be
2621 bool is_struct_incomparable_
;
2624 // The type of an array.
2626 class Array_type
: public Type
2629 Array_type(Type
* element_type
, Expression
* length
)
2631 element_type_(element_type
), length_(length
), blength_(NULL
),
2632 issued_length_error_(false), is_array_incomparable_(false)
2635 // Return the element type.
2637 element_type() const
2638 { return this->element_type_
; }
2640 // Return the length. This will return NULL for a slice.
2643 { return this->length_
; }
2645 // Store the length as an int64_t into *PLEN. Return false if the
2646 // length can not be determined. This will assert if called for a
2649 int_length(int64_t* plen
);
2651 // Whether this type is identical with T.
2653 is_identical(const Array_type
* t
, Cmp_tags
,
2654 bool errors_are_identical
) const;
2656 // Return an expression for the pointer to the values in an array.
2658 get_value_pointer(Gogo
*, Expression
* array
, bool is_lvalue
) const;
2660 // Return an expression for the length of an array with this type.
2662 get_length(Gogo
*, Expression
* array
) const;
2664 // Return an expression for the capacity of an array with this type.
2666 get_capacity(Gogo
*, Expression
* array
) const;
2668 // Import an array type.
2672 // Return the backend representation of the element type.
2674 get_backend_element(Gogo
*, bool use_placeholder
);
2676 // Return the backend representation of the length.
2678 get_backend_length(Gogo
*);
2680 // Finish the backend representation of the element type.
2682 finish_backend_element(Gogo
*);
2685 make_array_type_descriptor_type();
2688 make_slice_type_descriptor_type();
2690 // Return whether this is a generated array that is not comparable.
2692 is_array_incomparable() const
2693 { return this->is_array_incomparable_
; }
2695 // Record that this is a generated array that is not comparable.
2697 set_is_array_incomparable()
2698 { this->is_array_incomparable_
= true; }
2700 // Write the hash function for this type.
2702 write_hash_function(Gogo
*, Named_type
*, Function_type
*, Function_type
*);
2704 // Write the equality function for this type.
2706 write_equal_function(Gogo
*, Named_type
*);
2710 do_traverse(Traverse
* traverse
);
2716 do_has_pointer() const;
2719 do_compare_is_identity(Gogo
*);
2724 return this->length_
!= NULL
&& this->element_type_
->is_reflexive();
2728 do_needs_key_update()
2729 { return this->element_type_
->needs_key_update(); }
2733 { return this->length_
== NULL
|| this->element_type_
->in_heap(); }
2736 do_hash_for_method(Gogo
*) const;
2739 do_get_backend(Gogo
*);
2742 do_type_descriptor(Gogo
*, Named_type
*);
2745 do_reflection(Gogo
*, std::string
*) const;
2748 do_mangled_name(Gogo
*, std::string
*) const;
2751 do_export(Export
*) const;
2758 array_type_descriptor(Gogo
*, Named_type
*);
2761 slice_type_descriptor(Gogo
*, Named_type
*);
2763 // The type of elements of the array.
2764 Type
* element_type_
;
2765 // The number of elements. This may be NULL.
2766 Expression
* length_
;
2767 // The backend representation of the length.
2768 // We only want to compute this once.
2769 Bexpression
* blength_
;
2770 // Whether or not an invalid length error has been issued for this type,
2771 // to avoid knock-on errors.
2772 mutable bool issued_length_error_
;
2773 // True if this is a generated array that is not considered to be
2775 bool is_array_incomparable_
;
2778 // The type of a map.
2780 class Map_type
: public Type
2783 Map_type(Type
* key_type
, Type
* val_type
, Location location
)
2785 key_type_(key_type
), val_type_(val_type
), hmap_type_(NULL
),
2786 bucket_type_(NULL
), hiter_type_(NULL
), location_(location
)
2789 // Return the key type.
2792 { return this->key_type_
; }
2794 // Return the value type.
2797 { return this->val_type_
; }
2799 // Return the type used for an iteration over this map.
2803 // If this map requires the "fat" functions, returns the pointer to
2804 // pass as the zero value to those functions. Otherwise, in the
2805 // normal case, returns NULL.
2807 fat_zero_value(Gogo
*);
2809 // Return whether VAR is the map zero value.
2811 is_zero_value(Variable
* var
);
2813 // Return the backend representation of the map zero value.
2815 backend_zero_value(Gogo
*);
2817 // Whether this type is identical with T.
2819 is_identical(const Map_type
* t
, Cmp_tags
,
2820 bool errors_are_identical
) const;
2822 // Import a map type.
2827 make_map_type_descriptor_type();
2831 do_traverse(Traverse
*);
2837 do_has_pointer() const
2841 do_compare_is_identity(Gogo
*)
2847 return this->key_type_
->is_reflexive() && this->val_type_
->is_reflexive();
2851 do_hash_for_method(Gogo
*) const;
2854 do_get_backend(Gogo
*);
2857 do_type_descriptor(Gogo
*, Named_type
*);
2860 do_reflection(Gogo
*, std::string
*) const;
2863 do_mangled_name(Gogo
*, std::string
*) const;
2866 do_export(Export
*) const;
2869 // These must be in sync with libgo/go/runtime/hashmap.go.
2870 static const int bucket_size
= 8;
2871 static const int max_key_size
= 128;
2872 static const int max_val_size
= 128;
2873 static const int max_zero_size
= 1024;
2875 // Maps with value types larger than max_zero_size require passing a
2876 // zero value pointer to the map functions.
2878 // The zero value variable.
2879 static Named_object
* zero_value
;
2881 // The current size of the zero value.
2882 static int64_t zero_value_size
;
2884 // The current alignment of the zero value.
2885 static int64_t zero_value_align
;
2888 bucket_type(Gogo
*, int64_t, int64_t);
2897 // The hashmap type. At run time a map is represented as a pointer
2900 // The bucket type, the type used to hold keys and values at run time.
2902 // The iterator type.
2904 // Where the type was defined.
2908 // The type of a channel.
2910 class Channel_type
: public Type
2913 Channel_type(bool may_send
, bool may_receive
, Type
* element_type
)
2914 : Type(TYPE_CHANNEL
),
2915 may_send_(may_send
), may_receive_(may_receive
),
2916 element_type_(element_type
)
2917 { go_assert(may_send
|| may_receive
); }
2919 // Whether this channel can send data.
2922 { return this->may_send_
; }
2924 // Whether this channel can receive data.
2927 { return this->may_receive_
; }
2929 // The type of the values that may be sent on this channel. This is
2930 // NULL if any type may be sent.
2932 element_type() const
2933 { return this->element_type_
; }
2935 // Whether this type is identical with T.
2937 is_identical(const Channel_type
* t
, Cmp_tags
,
2938 bool errors_are_identical
) const;
2940 // Import a channel type.
2941 static Channel_type
*
2945 make_chan_type_descriptor_type();
2948 select_type(int ncases
);
2952 do_traverse(Traverse
* traverse
)
2953 { return Type::traverse(this->element_type_
, traverse
); }
2959 do_has_pointer() const
2963 do_compare_is_identity(Gogo
*)
2967 do_hash_for_method(Gogo
*) const;
2970 do_get_backend(Gogo
*);
2973 do_type_descriptor(Gogo
*, Named_type
*);
2976 do_reflection(Gogo
*, std::string
*) const;
2979 do_mangled_name(Gogo
*, std::string
*) const;
2982 do_export(Export
*) const;
2985 // Whether this channel can send data.
2987 // Whether this channel can receive data.
2989 // The types of elements which may be sent on this channel. If this
2990 // is NULL, it means that any type may be sent.
2991 Type
* element_type_
;
2994 // An interface type.
2996 class Interface_type
: public Type
2999 Interface_type(Typed_identifier_list
* methods
, Location location
)
3000 : Type(TYPE_INTERFACE
),
3001 parse_methods_(methods
), all_methods_(NULL
), location_(location
),
3002 package_(NULL
), interface_btype_(NULL
), bmethods_(NULL
),
3003 assume_identical_(NULL
), methods_are_finalized_(false),
3004 bmethods_is_placeholder_(false), seen_(false)
3005 { go_assert(methods
== NULL
|| !methods
->empty()); }
3007 // The location where the interface type was defined.
3010 { return this->location_
; }
3012 // The package where the interface type was defined. Returns NULL
3013 // for the package currently being compiled.
3016 { return this->package_
; }
3018 // Return whether this is an empty interface.
3022 go_assert(this->methods_are_finalized_
);
3023 return this->all_methods_
== NULL
;
3026 // Return the list of methods. This will return NULL for an empty
3028 const Typed_identifier_list
*
3031 // Return the number of methods.
3033 method_count() const;
3035 // Return the method NAME, or NULL.
3036 const Typed_identifier
*
3037 find_method(const std::string
& name
) const;
3039 // Return the zero-based index of method NAME.
3041 method_index(const std::string
& name
) const;
3043 // Finalize the methods. This sets all_methods_. This handles
3044 // interface inheritance.
3048 // Return true if T implements this interface. If this returns
3049 // false, and REASON is not NULL, it sets *REASON to the reason that
3052 implements_interface(const Type
* t
, std::string
* reason
) const;
3054 // Whether this type is identical with T. REASON is as in
3055 // implements_interface.
3057 is_identical(const Interface_type
* t
, Cmp_tags
,
3058 bool errors_are_identical
) const;
3060 // Whether we can assign T to this type. is_identical is known to
3063 is_compatible_for_assign(const Interface_type
*, std::string
* reason
) const;
3065 // Return whether NAME is a method which is not exported. This is
3066 // only used for better error reporting.
3068 is_unexported_method(Gogo
*, const std::string
& name
) const;
3070 // Import an interface type.
3071 static Interface_type
*
3074 // Make a struct for an empty interface type.
3076 get_backend_empty_interface_type(Gogo
*);
3078 // Get a pointer to the backend representation of the method table.
3080 get_backend_methods(Gogo
*);
3082 // Return a placeholder for the backend representation of the
3083 // pointer to the method table.
3085 get_backend_methods_placeholder(Gogo
*);
3087 // Finish the backend representation of the method types.
3089 finish_backend_methods(Gogo
*);
3092 make_interface_type_descriptor_type();
3096 do_traverse(Traverse
*);
3099 do_has_pointer() const
3103 do_compare_is_identity(Gogo
*)
3106 // Not reflexive if it contains a float.
3111 // Distinction between +0 and -0 requires a key update if it
3112 // contains a float.
3114 do_needs_key_update()
3118 do_hash_for_method(Gogo
*) const;
3121 do_get_backend(Gogo
*);
3124 do_type_descriptor(Gogo
*, Named_type
*);
3127 do_reflection(Gogo
*, std::string
*) const;
3130 do_mangled_name(Gogo
*, std::string
*) const;
3133 do_export(Export
*) const;
3136 // This type guards against infinite recursion when comparing
3137 // interface types. We keep a list of interface types assumed to be
3138 // identical during comparison. We just keep the list on the stack.
3139 // This permits us to compare cases like
3140 // type I1 interface { F() interface{I1} }
3141 // type I2 interface { F() interface{I2} }
3142 struct Assume_identical
3144 Assume_identical
* next
;
3145 const Interface_type
* t1
;
3146 const Interface_type
* t2
;
3150 assume_identical(const Interface_type
*, const Interface_type
*) const;
3152 // The list of methods associated with the interface from the
3153 // parser. This will be NULL for the empty interface. This may
3154 // include unnamed interface types.
3155 Typed_identifier_list
* parse_methods_
;
3156 // The list of all methods associated with the interface. This
3157 // expands any interface types listed in methods_. It is set by
3158 // finalize_methods. This will be NULL for the empty interface.
3159 Typed_identifier_list
* all_methods_
;
3160 // The location where the interface was defined.
3162 // The package where the interface was defined. This is NULL for
3163 // the package being compiled.
3165 // The backend representation of this type during backend conversion.
3166 Btype
* interface_btype_
;
3167 // The backend representation of the pointer to the method table.
3169 // A list of interface types assumed to be identical during
3170 // interface comparison.
3171 mutable Assume_identical
* assume_identical_
;
3172 // Whether the methods have been finalized.
3173 bool methods_are_finalized_
;
3174 // Whether the bmethods_ field is a placeholder.
3175 bool bmethods_is_placeholder_
;
3176 // Used to avoid endless recursion in do_mangled_name.
3180 // The value we keep for a named type. This lets us get the right
3181 // name when we convert to backend. Note that we don't actually keep
3182 // the name here; the name is in the Named_object which points to
3183 // this. This object exists to hold a unique backend representation for
3186 class Named_type
: public Type
3189 Named_type(Named_object
* named_object
, Type
* type
, Location location
)
3191 named_object_(named_object
), in_function_(NULL
), in_function_index_(0),
3192 type_(type
), local_methods_(NULL
), all_methods_(NULL
),
3193 interface_method_tables_(NULL
), pointer_interface_method_tables_(NULL
),
3194 location_(location
), named_btype_(NULL
), dependencies_(),
3195 is_alias_(false), is_visible_(true), is_error_(false), in_heap_(true),
3196 is_placeholder_(false), is_converted_(false), is_circular_(false),
3197 is_verified_(false), seen_(false), seen_in_compare_is_identity_(false),
3198 seen_in_get_backend_(false), seen_alias_(false)
3201 // Return the associated Named_object. This holds the actual name.
3204 { return this->named_object_
; }
3207 named_object() const
3208 { return this->named_object_
; }
3210 // Set the Named_object. This is used when we see a type
3211 // declaration followed by a type.
3213 set_named_object(Named_object
* no
)
3214 { this->named_object_
= no
; }
3216 // Whether this is an alias (type T1 = T2) rather than an ordinary
3217 // named type (type T1 T2).
3220 { return this->is_alias_
; }
3222 // Record that this type is an alias.
3225 { this->is_alias_
= true; }
3227 // Mark this type as not permitted in the heap.
3230 { this->in_heap_
= false; }
3232 // Return the function in which this type is defined. This will
3233 // return NULL for a type defined in global scope.
3235 in_function(unsigned int *pindex
) const
3237 *pindex
= this->in_function_index_
;
3238 return this->in_function_
;
3241 // Set the function in which this type is defined.
3243 set_in_function(Named_object
* f
, unsigned int index
)
3245 this->in_function_
= f
;
3246 this->in_function_index_
= index
;
3249 // Return the name of the type.
3253 // Return the name of the type for an error message. The difference
3254 // is that if the type is defined in a different package, this will
3255 // return PACKAGE.NAME.
3257 message_name() const;
3259 // Return the underlying type.
3262 { return this->type_
; }
3266 { return this->type_
; }
3268 // Return the location.
3271 { return this->location_
; }
3273 // Whether this type is visible. This only matters when parsing.
3276 { return this->is_visible_
; }
3278 // Mark this type as visible.
3281 { this->is_visible_
= true; }
3283 // Mark this type as invisible.
3286 { this->is_visible_
= false; }
3288 // Whether this is a builtin type.
3291 { return Linemap::is_predeclared_location(this->location_
); }
3293 // Whether this named type is valid. A recursive named type is invalid.
3296 { return !this->is_error_
; }
3298 // Whether this is a circular type: a pointer or function type that
3299 // refers to itself, which is not possible in C.
3302 { return this->is_circular_
; }
3304 // Return the base type for this type.
3311 // Return whether this is an error type.
3313 is_named_error_type() const;
3315 // Return whether this type is comparable. If REASON is not NULL,
3316 // set *REASON when returning false.
3318 named_type_is_comparable(std::string
* reason
) const;
3320 // Add a method to this type.
3322 add_method(const std::string
& name
, Function
*);
3324 // Add a method declaration to this type.
3326 add_method_declaration(const std::string
& name
, Package
* package
,
3327 Function_type
* type
, Location location
);
3329 // Add an existing method--one defined before the type itself was
3330 // defined--to a type.
3332 add_existing_method(Named_object
*);
3334 // Look up a local method.
3336 find_local_method(const std::string
& name
) const;
3338 // Return the list of local methods.
3340 local_methods() const;
3342 // Build the complete list of methods, including those from
3343 // anonymous fields, and build method stubs if needed.
3345 finalize_methods(Gogo
*);
3347 // Return whether this type has any methods. This should only be
3348 // called after the finalize_methods pass.
3350 has_any_methods() const;
3352 // Return the methods for this type. This should only be called
3353 // after the finalized_methods pass.
3357 // Return the method to use for NAME. This returns NULL if there is
3358 // no such method or if the method is ambiguous. When it returns
3359 // NULL, this sets *IS_AMBIGUOUS if the method name is ambiguous.
3361 method_function(const std::string
& name
, bool *is_ambiguous
) const;
3363 // Return whether NAME is a known field or method which is not
3364 // exported. This is only used for better error reporting.
3366 is_unexported_local_method(Gogo
*, const std::string
& name
) const;
3368 // Return a pointer to the interface method table for this type for
3369 // the interface INTERFACE. If IS_POINTER is true, set the type
3370 // descriptor to a pointer to this type, otherwise set it to this
3373 interface_method_table(Interface_type
* interface
, bool is_pointer
);
3375 // Note that a type must be converted to the backend representation
3376 // before we convert this type.
3378 add_dependency(Named_type
* nt
)
3379 { this->dependencies_
.push_back(nt
); }
3381 // Return true if the size and alignment of the backend
3382 // representation of this type is known. This is always true after
3383 // types have been converted, but may be false beforehand.
3385 is_named_backend_type_size_known() const
3386 { return this->named_btype_
!= NULL
&& !this->is_placeholder_
; }
3388 // Add to the reflection string as for Type::append_reflection, but
3389 // if USE_ALIAS use the alias name rather than the alias target.
3391 append_reflection_type_name(Gogo
*, bool use_alias
, std::string
*) const;
3393 // Append the mangled type name as for Type::append_mangled_name,
3394 // but if USE_ALIAS use the alias name rather than the alias target.
3396 append_mangled_type_name(Gogo
*, bool use_alias
, std::string
*) const;
3400 export_named_type(Export
*, const std::string
& name
) const;
3402 // Import a named type.
3404 import_named_type(Import
*, Named_type
**);
3406 // Initial conversion to backend representation.
3412 do_traverse(Traverse
* traverse
)
3413 { return Type::traverse(this->type_
, traverse
); }
3419 do_has_pointer() const;
3422 do_compare_is_identity(Gogo
*);
3428 do_needs_key_update();
3432 { return this->in_heap_
&& this->type_
->in_heap(); }
3435 do_hash_for_method(Gogo
*) const;
3438 do_get_backend(Gogo
*);
3441 do_type_descriptor(Gogo
*, Named_type
*);
3444 do_reflection(Gogo
*, std::string
*) const;
3447 do_mangled_name(Gogo
*, std::string
* ret
) const;
3450 do_export(Export
*) const;
3453 // Create the placeholder during conversion.
3455 create_placeholder(Gogo
*);
3457 // A pointer back to the Named_object for this type.
3458 Named_object
* named_object_
;
3459 // If this type is defined in a function, a pointer back to the
3460 // function in which it is defined.
3461 Named_object
* in_function_
;
3462 // The index of this type in IN_FUNCTION_.
3463 unsigned int in_function_index_
;
3466 // The list of methods defined for this type. Any named type can
3468 Bindings
* local_methods_
;
3469 // The full list of methods for this type, including methods
3470 // declared for anonymous fields.
3471 Methods
* all_methods_
;
3472 // A mapping from interfaces to the associated interface method
3473 // tables for this type.
3474 Interface_method_tables
* interface_method_tables_
;
3475 // A mapping from interfaces to the associated interface method
3476 // tables for pointers to this type.
3477 Interface_method_tables
* pointer_interface_method_tables_
;
3478 // The location where this type was defined.
3480 // The backend representation of this type during backend
3481 // conversion. This is used to avoid endless recursion when a named
3482 // type refers to itself.
3483 Btype
* named_btype_
;
3484 // A list of types which must be converted to the backend
3485 // representation before this type can be converted. This is for
3487 // type S1 { p *S2 }
3489 // where we can't convert S2 to the backend representation unless we
3490 // have converted S1.
3491 std::vector
<Named_type
*> dependencies_
;
3492 // Whether this is an alias type.
3494 // Whether this type is visible. This is false if this type was
3495 // created because it was referenced by an imported object, but the
3496 // type itself was not exported. This will always be true for types
3497 // created in the current package.
3499 // Whether this type is erroneous.
3501 // Whether this type is permitted in the heap. This is true by
3502 // default, false if there is a magic //go:notinheap comment.
3504 // Whether the current value of named_btype_ is a placeholder for
3505 // which the final size of the type is not known.
3506 bool is_placeholder_
;
3507 // Whether this type has been converted to the backend
3508 // representation. Implies that is_placeholder_ is false.
3510 // Whether this is a pointer or function type which refers to the
3513 // Whether this type has been verified.
3515 // In a recursive operation such as has_pointer, this flag is used
3516 // to prevent infinite recursion when a type refers to itself. This
3517 // is mutable because it is always reset to false when the function
3520 // Like seen_, but used only by do_compare_is_identity.
3521 bool seen_in_compare_is_identity_
;
3522 // Like seen_, but used only by do_get_backend.
3523 bool seen_in_get_backend_
;
3524 // Like seen_, but used when resolving aliases.
3525 mutable bool seen_alias_
;
3528 // A forward declaration. This handles a type which has been declared
3531 class Forward_declaration_type
: public Type
3534 Forward_declaration_type(Named_object
* named_object
);
3536 // The named object associated with this type declaration. This
3537 // will be resolved.
3542 named_object() const;
3544 // Return the name of the type.
3548 // Return the type to which this points. Give an error if the type
3549 // has not yet been defined.
3556 // Whether the base type has been defined.
3560 // Add a method to this type.
3562 add_method(const std::string
& name
, Function
*);
3564 // Add a method declaration to this type.
3566 add_method_declaration(const std::string
& name
, Package
*, Function_type
*,
3569 // Add an already created object as a method to this type.
3571 add_existing_method(Named_object
*);
3575 do_traverse(Traverse
* traverse
);
3581 do_has_pointer() const
3582 { return this->real_type()->has_pointer(); }
3585 do_compare_is_identity(Gogo
* gogo
)
3586 { return this->real_type()->compare_is_identity(gogo
); }
3590 { return this->real_type()->is_reflexive(); }
3593 do_needs_key_update()
3594 { return this->real_type()->needs_key_update(); }
3598 { return this->real_type()->in_heap(); }
3601 do_hash_for_method(Gogo
* gogo
) const
3602 { return this->real_type()->hash_for_method(gogo
); }
3605 do_get_backend(Gogo
* gogo
);
3608 do_type_descriptor(Gogo
*, Named_type
*);
3611 do_reflection(Gogo
*, std::string
*) const;
3614 do_mangled_name(Gogo
*, std::string
* ret
) const;
3617 do_export(Export
*) const;
3620 // Issue a warning about a use of an undefined type.
3624 // The type declaration.
3625 Named_object
* named_object_
;
3626 // Whether we have issued a warning about this type.
3627 mutable bool warned_
;
3630 // The Type_context struct describes what we expect for the type of an
3635 // The exact type we expect, if known. This may be NULL.
3637 // Whether an abstract type is permitted.
3638 bool may_be_abstract
;
3642 : type(NULL
), may_be_abstract(false)
3645 Type_context(Type
* a_type
, bool a_may_be_abstract
)
3646 : type(a_type
), may_be_abstract(a_may_be_abstract
)
3650 #endif // !defined(GO_TYPES_H)