1 // expressions.h -- Go frontend expression handling. -*- 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.
7 #ifndef GO_EXPRESSIONS_H
8 #define GO_EXPRESSIONS_H
17 class Translate_context
;
19 class Statement_inserter
;
30 class Expression_list
;
31 class Const_expression
;
33 class Enclosed_var_expression
;
34 class Temporary_reference_expression
;
35 class Set_and_use_temporary_expression
;
36 class String_expression
;
37 class Type_conversion_expression
;
38 class Unsafe_type_conversion_expression
;
39 class Unary_expression
;
40 class Binary_expression
;
41 class String_concat_expression
;
42 class Call_expression
;
43 class Builtin_call_expression
;
44 class Call_result_expression
;
45 class Func_expression
;
46 class Func_descriptor_expression
;
47 class Unknown_expression
;
48 class Index_expression
;
49 class Array_index_expression
;
50 class String_index_expression
;
51 class Map_index_expression
;
52 class Bound_method_expression
;
53 class Field_reference_expression
;
54 class Interface_field_reference_expression
;
55 class Allocation_expression
;
56 class Composite_literal_expression
;
57 class Struct_construction_expression
;
58 class Array_construction_expression
;
59 class Fixed_array_construction_expression
;
60 class Slice_construction_expression
;
61 class Map_construction_expression
;
62 class Type_guard_expression
;
63 class Heap_expression
;
64 class Receive_expression
;
65 class Slice_value_expression
;
66 class Slice_info_expression
;
67 class Conditional_expression
;
68 class Compound_expression
;
69 class Numeric_constant
;
71 class Export_function_body
;
72 class Import_expression
;
73 class Temporary_statement
;
75 class Ast_dump_context
;
78 // The precision to use for complex values represented as an mpc_t.
79 const int mpc_precision
= 256;
81 // The base class for all expressions.
86 // The types of expressions.
87 enum Expression_classification
93 EXPRESSION_STRING_CONCAT
,
94 EXPRESSION_CONST_REFERENCE
,
95 EXPRESSION_VAR_REFERENCE
,
96 EXPRESSION_ENCLOSED_VAR_REFERENCE
,
97 EXPRESSION_TEMPORARY_REFERENCE
,
98 EXPRESSION_SET_AND_USE_TEMPORARY
,
100 EXPRESSION_FUNC_REFERENCE
,
101 EXPRESSION_FUNC_DESCRIPTOR
,
102 EXPRESSION_FUNC_CODE_REFERENCE
,
103 EXPRESSION_UNKNOWN_REFERENCE
,
106 EXPRESSION_STRING_INFO
,
107 EXPRESSION_STRING_VALUE
,
114 EXPRESSION_CALL_RESULT
,
115 EXPRESSION_BOUND_METHOD
,
117 EXPRESSION_ARRAY_INDEX
,
118 EXPRESSION_STRING_INDEX
,
119 EXPRESSION_MAP_INDEX
,
121 EXPRESSION_FIELD_REFERENCE
,
122 EXPRESSION_INTERFACE_FIELD_REFERENCE
,
123 EXPRESSION_ALLOCATION
,
124 EXPRESSION_TYPE_GUARD
,
125 EXPRESSION_CONVERSION
,
126 EXPRESSION_UNSAFE_CONVERSION
,
127 EXPRESSION_STRUCT_CONSTRUCTION
,
128 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
,
129 EXPRESSION_SLICE_CONSTRUCTION
,
130 EXPRESSION_MAP_CONSTRUCTION
,
131 EXPRESSION_COMPOSITE_LITERAL
,
132 EXPRESSION_COMPOSITE_LITERAL_KEY
,
135 EXPRESSION_TYPE_DESCRIPTOR
,
136 EXPRESSION_GC_SYMBOL
,
137 EXPRESSION_PTRMASK_SYMBOL
,
138 EXPRESSION_TYPE_INFO
,
139 EXPRESSION_SLICE_INFO
,
140 EXPRESSION_SLICE_VALUE
,
141 EXPRESSION_INTERFACE_INFO
,
142 EXPRESSION_INTERFACE_VALUE
,
143 EXPRESSION_INTERFACE_MTABLE
,
144 EXPRESSION_STRUCT_FIELD_OFFSET
,
145 EXPRESSION_LABEL_ADDR
,
146 EXPRESSION_CONDITIONAL
,
151 Expression(Expression_classification
, Location
);
153 virtual ~Expression();
155 // Make an error expression. This is used when a parse error occurs
156 // to prevent cascading errors.
158 make_error(Location
);
160 // Make an expression which is really a type. This is used during
163 make_type(Type
*, Location
);
165 // Make a unary expression.
167 make_unary(Operator
, Expression
*, Location
);
169 // Make a binary expression.
171 make_binary(Operator
, Expression
*, Expression
*, Location
);
173 // Make a string concatenation expression.
175 make_string_concat(Expression_list
*);
177 // Make a reference to a constant in an expression.
179 make_const_reference(Named_object
*, Location
);
181 // Make a reference to a variable in an expression.
183 make_var_reference(Named_object
*, Location
);
185 // Make a reference to a variable within an enclosing function.
187 make_enclosing_var_reference(Expression
*, Named_object
*, Location
);
189 // Make a reference to a temporary variable. Temporary variables
190 // are always created by a single statement, which is what we use to
192 static Temporary_reference_expression
*
193 make_temporary_reference(Temporary_statement
*, Location
);
195 // Make an expressions which sets a temporary variable and then
196 // evaluates to a reference to that temporary variable. This is
197 // used to set a temporary variable while retaining the order of
199 static Set_and_use_temporary_expression
*
200 make_set_and_use_temporary(Temporary_statement
*, Expression
*, Location
);
202 // Make a sink expression--a reference to the blank identifier _.
206 // Make a reference to a function in an expression. This returns a
207 // pointer to the struct holding the address of the function
208 // followed by any closed-over variables.
210 make_func_reference(Named_object
*, Expression
* closure
, Location
);
212 // Make a function descriptor, an immutable struct with a single
213 // field that points to the function code. This may only be used
214 // with functions that do not have closures. FN is the function for
215 // which we are making the descriptor.
216 static Func_descriptor_expression
*
217 make_func_descriptor(Named_object
* fn
);
219 // Make a reference to the code of a function. This is used to set
220 // descriptor and closure fields.
222 make_func_code_reference(Named_object
*, Location
);
224 // Make a reference to an unknown name. In a correct program this
225 // will always be lowered to a real const/var/func reference.
226 static Unknown_expression
*
227 make_unknown_reference(Named_object
*, Location
);
229 // Make a constant bool expression.
231 make_boolean(bool val
, Location
);
233 // Make a constant string expression.
235 make_string(const std::string
&, Location
);
237 // Make a constant string expression with a specific string subtype.
239 make_string_typed(const std::string
&, Type
*, Location
);
241 // Make an expression that evaluates to some characteristic of an string.
242 // For simplicity, the enum values must match the field indexes in the
243 // underlying struct. This returns an lvalue.
246 // The underlying data in the string.
248 // The length of the string.
253 make_string_info(Expression
* string
, String_info
, Location
);
255 // Make an expression for a string value.
257 make_string_value(Expression
* valptr
, Expression
* len
, Location
);
259 // Make a character constant expression. TYPE should be NULL for an
262 make_character(const mpz_t
*, Type
*, Location
);
264 // Make a constant integer expression from a multi-precision
265 // integer. TYPE should be NULL for an abstract type.
267 make_integer_z(const mpz_t
*, Type
*, Location
);
269 // Make a constant integer expression from an unsigned long. TYPE
270 // should be NULL for an abstract type.
272 make_integer_ul(unsigned long, Type
*, Location
);
274 // Make a constant integer expression from a signed long. TYPE
275 // should be NULL for an abstract type.
277 make_integer_sl(long, Type
*, Location
);
279 // Make a constant integer expression from an int64_t. TYPE should
280 // be NULL for an abstract type.
282 make_integer_int64(int64_t, Type
*, Location
);
284 // Make a constant float expression. TYPE should be NULL for an
287 make_float(const mpfr_t
*, Type
*, Location
);
289 // Make a constant complex expression. TYPE should be NULL for an
292 make_complex(const mpc_t
*, Type
*, Location
);
294 // Make a nil expression.
298 // Make an iota expression. This is used for the predeclared
303 // Make a call expression.
304 static Call_expression
*
305 make_call(Expression
* func
, Expression_list
* args
, bool is_varargs
,
308 // Make a reference to a specific result of a call expression which
311 make_call_result(Call_expression
*, unsigned int index
);
313 // Make an expression which is a method bound to its first
314 // parameter. METHOD is the method being called, FUNCTION is the
316 static Bound_method_expression
*
317 make_bound_method(Expression
* object
, const Method
* method
,
318 Named_object
* function
, Location
);
320 // Make an index or slice expression. This is a parser expression
321 // which represents LEFT[START:END:CAP]. END may be NULL, meaning an
322 // index rather than a slice. CAP may be NULL, meaning we use the default
323 // capacity of LEFT. At parse time we may not know the type of LEFT.
324 // After parsing this is lowered to an array index, a string index,
327 make_index(Expression
* left
, Expression
* start
, Expression
* end
,
328 Expression
* cap
, Location
);
330 // Make an array index expression. END may be NULL, in which case
331 // this is an lvalue. CAP may be NULL, in which case it defaults
334 make_array_index(Expression
* array
, Expression
* start
, Expression
* end
,
335 Expression
* cap
, Location
);
337 // Make a string index expression. END may be NULL. This is never
340 make_string_index(Expression
* string
, Expression
* start
, Expression
* end
,
343 // Make a map index expression. This is an lvalue.
344 static Map_index_expression
*
345 make_map_index(Expression
* map
, Expression
* val
, Location
);
347 // Make a selector. This is a parser expression which represents
348 // LEFT.NAME. At parse time we may not know the type of the left
351 make_selector(Expression
* left
, const std::string
& name
, Location
);
353 // Make a reference to a field in a struct.
354 static Field_reference_expression
*
355 make_field_reference(Expression
*, unsigned int field_index
, Location
);
357 // Make a reference to a field of an interface, with an associated
360 make_interface_field_reference(Expression
*, const std::string
&,
363 // Make an allocation expression.
365 make_allocation(Type
*, Location
);
367 // Make a type guard expression.
369 make_type_guard(Expression
*, Type
*, Location
);
371 // Make a type cast expression.
373 make_cast(Type
*, Expression
*, Location
);
375 // Make an unsafe type cast expression. This is only used when
376 // passing parameter to builtin functions that are part of the Go
379 make_unsafe_cast(Type
*, Expression
*, Location
);
381 // Make a composite literal. The DEPTH parameter is how far down we
382 // are in a list of composite literals with omitted types. HAS_KEYS
383 // is true if the expression list has keys alternating with values.
384 // ALL_ARE_NAMES is true if all the keys could be struct field
387 make_composite_literal(Type
*, int depth
, bool has_keys
, Expression_list
*,
388 bool all_are_names
, Location
);
390 // Make a composite literal key.
392 make_composite_literal_key(const std::string
& name
, Location
);
394 // Make a struct composite literal.
396 make_struct_composite_literal(Type
*, Expression_list
*, Location
);
398 // Make an array composite literal.
400 make_array_composite_literal(Type
*, Expression_list
*, Location
);
402 // Make a slice composite literal.
403 static Slice_construction_expression
*
404 make_slice_composite_literal(Type
*, Expression_list
*, Location
);
406 // Take an expression and allocate it on the heap.
408 make_heap_expression(Expression
*, Location
);
410 // Make a receive expression. VAL is NULL for a unary receive.
411 static Receive_expression
*
412 make_receive(Expression
* channel
, Location
);
414 // Make an expression which evaluates to the address of the type
415 // descriptor for TYPE.
417 make_type_descriptor(Type
* type
, Location
);
419 // Make an expression which evaluates to the address of the gc
422 make_gc_symbol(Type
* type
);
424 // Make an expression that evaluates to the address of a ptrmask
425 // symbol for TYPE. For most types this will be the same as
426 // make_gc_symbol, but for larger types make_gc_symbol will return a
427 // gcprog while this will return a ptrmask.
429 make_ptrmask_symbol(Type
* type
);
431 // Make an expression which evaluates to some characteristic of a
432 // type. These are only used for type descriptors, so there is no
433 // location parameter.
436 // The size of a value of the type.
438 // The required alignment of a value of the type.
440 // The required alignment of a value of the type when used as a
441 // field in a struct.
442 TYPE_INFO_FIELD_ALIGNMENT
,
443 // The size of the prefix of a value of the type that contains
444 // all the pointers. This is 0 for a type that contains no
445 // pointers. It is always <= TYPE_INFO_SIZE.
446 TYPE_INFO_BACKEND_PTRDATA
,
447 // Like TYPE_INFO_BACKEND_PTRDATA, but the ptrdata value that we
448 // want to store in a type descriptor. They are the same for
449 // most types, but can differ for a type that uses a gcprog.
450 TYPE_INFO_DESCRIPTOR_PTRDATA
454 make_type_info(Type
* type
, Type_info
);
456 // Make an expression that evaluates to some characteristic of a
457 // slice. For simplicity, the enum values must match the field indexes
458 // in the underlying struct. This returns an lvalue.
461 // The underlying data of the slice.
462 SLICE_INFO_VALUE_POINTER
,
463 // The length of the slice.
465 // The capacity of the slice.
470 make_slice_info(Expression
* slice
, Slice_info
, Location
);
472 // Make an expression for a slice value.
474 make_slice_value(Type
*, Expression
* valptr
, Expression
* len
, Expression
* cap
,
477 // Make an expression that evaluates to some characteristic of an
478 // interface. For simplicity, the enum values must match the field indexes
479 // in the underlying struct. This returns an lvalue.
482 // The type descriptor of an empty interface.
483 INTERFACE_INFO_TYPE_DESCRIPTOR
= 0,
484 // The methods of an interface.
485 INTERFACE_INFO_METHODS
= 0,
486 // The first argument to pass to an interface method.
487 INTERFACE_INFO_OBJECT
491 make_interface_info(Expression
* iface
, Interface_info
, Location
);
493 // Make an expression for an interface value.
495 make_interface_value(Type
*, Expression
*, Expression
*, Location
);
497 // Make an expression that builds a reference to the interface method table
498 // for TYPE that satisfies interface ITYPE. IS_POINTER is true if this is a
499 // reference to the interface method table for the pointer receiver type.
501 make_interface_mtable_ref(Interface_type
* itype
, Type
* type
,
502 bool is_pointer
, Location
);
504 // Make an expression which evaluates to the offset of a field in a
505 // struct. This is only used for type descriptors, so there is no
506 // location parameter.
508 make_struct_field_offset(Struct_type
*, const Struct_field
*);
510 // Make an expression which evaluates to the address of an unnamed
513 make_label_addr(Label
*, Location
);
515 // Make a conditional expression.
517 make_conditional(Expression
*, Expression
*, Expression
*, Location
);
519 // Make a compound expression.
521 make_compound(Expression
*, Expression
*, Location
);
523 // Make a backend expression.
525 make_backend(Bexpression
*, Type
*, Location
);
527 enum Nil_check_classification
529 // Use the default policy for deciding if this deref needs a check.
531 // An explicit check is required for this dereference operation.
533 // No check needed for this dereference operation.
534 NIL_CHECK_NOT_NEEDED
,
535 // A type error or error construct was encountered when determining
536 // whether this deref needs an explicit check.
537 NIL_CHECK_ERROR_ENCOUNTERED
540 // Make a dereference expression.
542 make_dereference(Expression
*, Nil_check_classification
, Location
);
544 // Return the expression classification.
545 Expression_classification
546 classification() const
547 { return this->classification_
; }
549 // Return the location of the expression.
552 { return this->location_
; }
554 // Set the location of an expression and all its subexpressions.
555 // This is used for const declarations where the expression is
556 // copied from an earlier declaration.
558 set_location(Location loc
);
560 // For set_location. This should really be a local class in
561 // Expression, but it needs types defined in gogo.h.
562 friend class Set_location
;
564 // Return whether this is a constant expression.
567 { return this->do_is_constant(); }
569 // Return whether this expression is untyped. This isn't quite the
570 // same as is_constant with an abstract type, as 1<<val is untyped
571 // even if val is a variable. If this returns true, it sets *PTYPE
572 // to an abstract type, which is the type the expression will have
573 // if there is no context.
575 is_untyped(Type
** ptype
) const
576 { return this->do_is_untyped(ptype
); }
578 // Return whether this is the zero value of its type.
580 is_zero_value() const
581 { return this->do_is_zero_value(); }
583 // Return whether this expression can be used as a static
584 // initializer. This is true for an expression that has only
585 // numbers and pointers to global variables or composite literals
586 // that do not require runtime initialization. It is false if we
587 // must generate code to compute this expression when it is used to
588 // initialize a global variable. This is not a language-level
589 // concept, but an implementation-level one. If this expression is
590 // used to initialize a global variable, this is true if we can pass
591 // an initializer to the backend, false if we must generate code to
592 // initialize the variable. It is always safe for this method to
593 // return false, but the resulting code may be less efficient.
595 is_static_initializer() const
596 { return this->do_is_static_initializer(); }
598 // If this is not a numeric constant, return false. If it is one,
599 // return true, and set VAL to hold the value. This method can be
600 // called before the determine_types pass.
602 numeric_constant_value(Numeric_constant
* val
)
603 { return this->do_numeric_constant_value(val
); }
605 // If this is not a constant expression with string type, return
606 // false. If it is one, return true, and set VAL to the value.
608 string_constant_value(std::string
* val
)
609 { return this->do_string_constant_value(val
); }
611 // If this is not a constant expression with boolean type, return
612 // false. If it is one, return true, and set VAL to the value.
614 boolean_constant_value(bool* val
)
615 { return this->do_boolean_constant_value(val
); }
617 // If this is a const reference expression, return the named
618 // object to which the expression refers, otherwise return NULL.
620 named_constant() const;
622 // This is called if the value of this expression is being
623 // discarded. This issues warnings about computed values being
624 // unused. This returns true if all is well, false if it issued an
628 { return this->do_discarding_value(); }
630 // Return whether this is an error expression.
632 is_error_expression() const
633 { return this->classification_
== EXPRESSION_ERROR
; }
635 // Return whether this expression really represents a type.
637 is_type_expression() const;
639 // If this is a const reference, return the Const_expression
640 // structure. Otherwise, return NULL. This is a controlled dynamic
644 { return this->convert
<Const_expression
, EXPRESSION_CONST_REFERENCE
>(); }
646 const Const_expression
*
647 const_expression() const
649 return this->convert
<const Const_expression
,
650 EXPRESSION_CONST_REFERENCE
>();
653 // If this is a variable reference, return the Var_expression
654 // structure. Otherwise, return NULL. This is a controlled dynamic
658 { return this->convert
<Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
660 const Var_expression
*
661 var_expression() const
662 { return this->convert
<const Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
664 // If this is a enclosed_variable reference, return the
665 // Enclosed_var_expression structure. Otherwise, return NULL.
666 // This is a controlled dynamic cast.
667 Enclosed_var_expression
*
668 enclosed_var_expression()
669 { return this->convert
<Enclosed_var_expression
,
670 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
672 const Enclosed_var_expression
*
673 enclosed_var_expression() const
674 { return this->convert
<const Enclosed_var_expression
,
675 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
678 // If this is a reference to a temporary variable, return the
679 // Temporary_reference_expression. Otherwise, return NULL.
680 Temporary_reference_expression
*
681 temporary_reference_expression()
683 return this->convert
<Temporary_reference_expression
,
684 EXPRESSION_TEMPORARY_REFERENCE
>();
687 // If this is a set-and-use-temporary, return the
688 // Set_and_use_temporary_expression. Otherwise, return NULL.
689 Set_and_use_temporary_expression
*
690 set_and_use_temporary_expression()
692 return this->convert
<Set_and_use_temporary_expression
,
693 EXPRESSION_SET_AND_USE_TEMPORARY
>();
696 // Return whether this is a sink expression.
698 is_sink_expression() const
699 { return this->classification_
== EXPRESSION_SINK
; }
701 // If this is a string expression, return the String_expression
702 // structure. Otherwise, return NULL.
705 { return this->convert
<String_expression
, EXPRESSION_STRING
>(); }
707 // If this is a conversion expression, return the Type_conversion_expression
708 // structure. Otherwise, return NULL.
709 Type_conversion_expression
*
710 conversion_expression()
711 { return this->convert
<Type_conversion_expression
, EXPRESSION_CONVERSION
>(); }
713 // If this is an unsafe conversion expression, return the
714 // Unsafe_type_conversion_expression structure. Otherwise, return NULL.
715 Unsafe_type_conversion_expression
*
716 unsafe_conversion_expression()
718 return this->convert
<Unsafe_type_conversion_expression
,
719 EXPRESSION_UNSAFE_CONVERSION
>();
722 // Return whether this is the expression nil.
724 is_nil_expression() const
725 { return this->classification_
== EXPRESSION_NIL
; }
727 // If this is an indirection through a pointer, return the
728 // expression being pointed through. Otherwise return this.
732 // If this is a unary expression, return the Unary_expression
733 // structure. Otherwise return NULL.
736 { return this->convert
<Unary_expression
, EXPRESSION_UNARY
>(); }
738 const Unary_expression
*
739 unary_expression() const
740 { return this->convert
<const Unary_expression
, EXPRESSION_UNARY
>(); }
742 // If this is a binary expression, return the Binary_expression
743 // structure. Otherwise return NULL.
746 { return this->convert
<Binary_expression
, EXPRESSION_BINARY
>(); }
748 // If this is a string concatenation expression, return the
749 // String_concat_expression structure. Otherwise, return NULL.
750 String_concat_expression
*
751 string_concat_expression()
753 return this->convert
<String_concat_expression
, EXPRESSION_STRING_CONCAT
>();
756 // If this is a call expression, return the Call_expression
757 // structure. Otherwise, return NULL. This is a controlled dynamic
761 { return this->convert
<Call_expression
, EXPRESSION_CALL
>(); }
763 const Call_expression
*
764 call_expression() const
765 { return this->convert
<const Call_expression
, EXPRESSION_CALL
>(); }
767 // If this is a call_result expression, return the Call_result_expression
768 // structure. Otherwise, return NULL. This is a controlled dynamic
770 Call_result_expression
*
771 call_result_expression()
772 { return this->convert
<Call_result_expression
, EXPRESSION_CALL_RESULT
>(); }
774 // If this is an expression which refers to a function, return the
775 // Func_expression structure. Otherwise, return NULL.
778 { return this->convert
<Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
780 const Func_expression
*
781 func_expression() const
782 { return this->convert
<const Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
784 // If this is an expression which refers to an unknown name, return
785 // the Unknown_expression structure. Otherwise, return NULL.
788 { return this->convert
<Unknown_expression
, EXPRESSION_UNKNOWN_REFERENCE
>(); }
790 const Unknown_expression
*
791 unknown_expression() const
793 return this->convert
<const Unknown_expression
,
794 EXPRESSION_UNKNOWN_REFERENCE
>();
797 // If this is an index expression, return the Index_expression
798 // structure. Otherwise, return NULL.
801 { return this->convert
<Index_expression
, EXPRESSION_INDEX
>(); }
803 // If this is an expression which refers to indexing in a array,
804 // return the Array_index_expression structure. Otherwise, return
806 Array_index_expression
*
807 array_index_expression()
808 { return this->convert
<Array_index_expression
, EXPRESSION_ARRAY_INDEX
>(); }
810 // If this is an expression which refers to indexing in a string,
811 // return the String_index_expression structure. Otherwise, return
813 String_index_expression
*
814 string_index_expression()
815 { return this->convert
<String_index_expression
, EXPRESSION_STRING_INDEX
>(); }
817 // If this is an expression which refers to indexing in a map,
818 // return the Map_index_expression structure. Otherwise, return
820 Map_index_expression
*
821 map_index_expression()
822 { return this->convert
<Map_index_expression
, EXPRESSION_MAP_INDEX
>(); }
824 // If this is a bound method expression, return the
825 // Bound_method_expression structure. Otherwise, return NULL.
826 Bound_method_expression
*
827 bound_method_expression()
828 { return this->convert
<Bound_method_expression
, EXPRESSION_BOUND_METHOD
>(); }
830 // If this is a reference to a field in a struct, return the
831 // Field_reference_expression structure. Otherwise, return NULL.
832 Field_reference_expression
*
833 field_reference_expression()
835 return this->convert
<Field_reference_expression
,
836 EXPRESSION_FIELD_REFERENCE
>();
839 // If this is a reference to a field in an interface, return the
840 // Interface_field_reference_expression structure. Otherwise,
842 Interface_field_reference_expression
*
843 interface_field_reference_expression()
845 return this->convert
<Interface_field_reference_expression
,
846 EXPRESSION_INTERFACE_FIELD_REFERENCE
>();
849 // If this is an allocation expression, return the Allocation_expression
850 // structure. Otherwise, return NULL.
851 Allocation_expression
*
852 allocation_expression()
853 { return this->convert
<Allocation_expression
, EXPRESSION_ALLOCATION
>(); }
855 // If this is a general composite literal, return the
856 // Composite_literal_expression structure. Otherwise, return NULL.
857 Composite_literal_expression
*
860 return this->convert
<Composite_literal_expression
,
861 EXPRESSION_COMPOSITE_LITERAL
>();
864 // If this is a struct composite literal, return the
865 // Struct_construction_expression structure. Otherwise, return NULL.
866 Struct_construction_expression
*
869 return this->convert
<Struct_construction_expression
,
870 EXPRESSION_STRUCT_CONSTRUCTION
>();
873 // If this is a array composite literal, return the
874 // Array_construction_expression structure. Otherwise, return NULL.
875 Fixed_array_construction_expression
*
878 return this->convert
<Fixed_array_construction_expression
,
879 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
>();
882 // If this is a slice composite literal, return the
883 // Slice_construction_expression structure. Otherwise, return NULL.
884 Slice_construction_expression
*
887 return this->convert
<Slice_construction_expression
,
888 EXPRESSION_SLICE_CONSTRUCTION
>();
891 // If this is a map composite literal, return the
892 // Map_construction_expression structure. Otherwise, return NULL.
893 Map_construction_expression
*
896 return this->convert
<Map_construction_expression
,
897 EXPRESSION_MAP_CONSTRUCTION
>();
900 // If this is a type guard expression, return the
901 // Type_guard_expression structure. Otherwise, return NULL.
902 Type_guard_expression
*
903 type_guard_expression()
904 { return this->convert
<Type_guard_expression
, EXPRESSION_TYPE_GUARD
>(); }
906 // If this is a heap expression, returhn the Heap_expression structure.
907 // Otherwise, return NULL.
910 { return this->convert
<Heap_expression
, EXPRESSION_HEAP
>(); }
912 // If this is a receive expression, return the Receive_expression
913 // structure. Otherwise, return NULL.
916 { return this->convert
<Receive_expression
, EXPRESSION_RECEIVE
>(); }
918 // If this is a slice value expression, return the Slice_valiue_expression
919 // structure. Otherwise, return NULL.
920 Slice_value_expression
*
921 slice_value_expression()
922 { return this->convert
<Slice_value_expression
, EXPRESSION_SLICE_VALUE
>(); }
924 // If this is a conditional expression, return the Conditional_expression
925 // structure. Otherwise, return NULL.
926 Conditional_expression
*
927 conditional_expression()
928 { return this->convert
<Conditional_expression
, EXPRESSION_CONDITIONAL
>(); }
930 // If this is a compound expression, return the Compound_expression structure.
931 // Otherwise, return NULL.
933 compound_expression()
934 { return this->convert
<Compound_expression
, EXPRESSION_COMPOUND
>(); }
936 // If this is a slice info expression, return the
937 // Slice_info_expression structure. Otherwise, return NULL.
938 Slice_info_expression
*
939 slice_info_expression()
941 return this->convert
<Slice_info_expression
, EXPRESSION_SLICE_INFO
>();
944 // Return true if this is a composite literal.
946 is_composite_literal() const;
948 // Return true if this is a composite literal which is not constant.
950 is_nonconstant_composite_literal() const;
952 // Return true if this is a variable or temporary variable.
956 // Return true if this is a reference to a local variable.
958 is_local_variable() const;
960 // Return true if multiple evaluations of this expression are OK.
961 // This is true for simple variable references and constants.
963 is_multi_eval_safe();
965 // Return true if two expressions refer to the same variable or
968 is_same_variable(Expression
*, Expression
*);
970 // Make the builtin function descriptor type, so that it can be
973 make_func_descriptor_type();
975 // Traverse an expression.
977 traverse(Expression
**, Traverse
*);
979 // Traverse subexpressions of this expression.
981 traverse_subexpressions(Traverse
*);
983 // Lower an expression. This is called immediately after parsing.
984 // FUNCTION is the function we are in; it will be NULL for an
985 // expression initializing a global variable. INSERTER may be used
986 // to insert statements before the statement or initializer
987 // containing this expression; it is normally used to create
988 // temporary variables. IOTA_VALUE is the value that we should give
989 // to any iota expressions. This function must resolve expressions
990 // which could not be fully parsed into their final form. It
991 // returns the same Expression or a new one.
993 lower(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
)
994 { return this->do_lower(gogo
, function
, inserter
); }
996 // Flatten an expression. This is called after order_evaluation.
997 // FUNCTION is the function we are in; it will be NULL for an
998 // expression initializing a global variable. INSERTER may be used
999 // to insert statements before the statement or initializer
1000 // containing this expression; it is normally used to create
1001 // temporary variables. This function must resolve expressions
1002 // which could not be fully parsed into their final form. It
1003 // returns the same Expression or a new one.
1005 flatten(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
)
1006 { return this->do_flatten(gogo
, function
, inserter
); }
1008 // Make implicit type conversions explicit.
1011 { this->do_add_conversions(); }
1013 // Determine the real type of an expression with abstract integer,
1014 // floating point, or complex type. TYPE_CONTEXT describes the
1017 determine_type(Gogo
*, const Type_context
*);
1019 // Check types in an expression.
1021 check_types(Gogo
* gogo
)
1022 { this->do_check_types(gogo
); }
1024 // Determine the type when there is no context.
1026 determine_type_no_context(Gogo
*);
1028 // Return the type of the expression. This should not be called
1029 // before the determine_types pass.
1032 { return this->do_type(); }
1034 // Return a copy of an expression.
1037 { return this->do_copy(); }
1039 // Return the cost of this statement for inlining purposes.
1041 inlining_cost() const
1042 { return this->do_inlining_cost(); }
1044 // Return whether the expression is addressable--something which may
1045 // be used as the operand of the unary & operator.
1047 is_addressable() const
1048 { return this->do_is_addressable(); }
1050 // Note that we are taking the address of this expression. ESCAPES
1051 // is true if this address escapes the current function.
1053 address_taken(bool escapes
)
1054 { this->do_address_taken(escapes
); }
1056 // Note that a nil check must be issued for this expression.
1059 { this->do_issue_nil_check(); }
1061 // Return whether this expression must be evaluated in order
1062 // according to the order of evaluation rules. This is basically
1063 // true of all expressions with side-effects.
1065 must_eval_in_order() const
1066 { return this->do_must_eval_in_order(); }
1068 // Return whether subexpressions of this expression must be
1069 // evaluated in order. This is true of index expressions and
1070 // pointer indirections. This sets *SKIP to the number of
1071 // subexpressions to skip during traversing, as index expressions
1072 // only requiring moving the index, not the array.
1074 must_eval_subexpressions_in_order(int* skip
) const
1077 return this->do_must_eval_subexpressions_in_order(skip
);
1080 // Return the backend representation for this expression.
1082 get_backend(Translate_context
*);
1084 // Return an expression handling any conversions which must be done during
1087 convert_for_assignment(Gogo
*, Type
* lhs_type
, Expression
* rhs
,
1090 // Return an expression converting a value of one interface type to another
1091 // interface type. If FOR_TYPE_GUARD is true this is for a type
1094 convert_interface_to_interface(Gogo
*, Type
* lhs_type
,
1095 Expression
* rhs
, bool for_type_guard
,
1098 // Return an expression for a conversion from a non-interface type to an
1099 // interface type. If ON_STACK is true, it can allocate the storage on
1102 convert_type_to_interface(Type
* lhs_type
, Expression
* rhs
,
1103 bool on_stack
, Location
);
1105 // Return a backend expression implementing the comparison LEFT OP RIGHT.
1106 // TYPE is the type of both sides.
1108 comparison(Translate_context
*, Type
* result_type
, Operator op
,
1109 Expression
* left
, Expression
* right
, Location
);
1111 // Return the backend expression for the numeric constant VAL.
1113 backend_numeric_constant_expression(Translate_context
*,
1114 Numeric_constant
* val
);
1116 // Export the expression.
1118 export_expression(Export_function_body
* efb
) const
1119 { this->do_export(efb
); }
1121 // Import an expression. The location should be used for the
1122 // returned expression. Errors should be reported using the
1123 // Import's location method.
1125 import_expression(Import_expression
*, Location
);
1127 // Insert bounds checks for an index expression.
1129 check_bounds(Gogo
*, Expression
* val
, Operator
, Expression
* bound
,
1130 Runtime::Function
, Runtime::Function
, Runtime::Function
,
1131 Runtime::Function
, Statement_inserter
*, Location
);
1133 // Return an expression for constructing a direct interface type from a
1136 pack_direct_iface(Type
*, Expression
*, Location
);
1138 // Return an expression of the underlying pointer for a direct interface
1139 // type (the opposite of pack_direct_iface).
1141 unpack_direct_iface(Expression
*, Location
);
1143 // Return an expression representing the type descriptor field of an
1146 get_interface_type_descriptor(Expression
*);
1148 // Look through the expression of a Slice_value_expression's valmem to
1149 // find an call to makeslice.
1150 static std::pair
<Call_expression
*, Temporary_statement
*>
1151 find_makeslice_call(Expression
*);
1153 // Dump an expression to a dump constext.
1155 dump_expression(Ast_dump_context
*) const;
1158 // May be implemented by child class: traverse the expressions.
1160 do_traverse(Traverse
*);
1162 // Return a lowered expression.
1164 do_lower(Gogo
*, Named_object
*, Statement_inserter
*)
1167 // Return a flattened expression.
1169 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*)
1172 // Make implicit type conversions explicit.
1174 do_add_conversions()
1177 // Return whether this is a constant expression.
1179 do_is_constant() const
1182 // Return whether this expression is untyped.
1184 do_is_untyped(Type
**) const
1187 // Return whether this is the zero value of its type.
1189 do_is_zero_value() const
1192 // Return whether this expression can be used as a constant
1195 do_is_static_initializer() const
1198 // Return whether this is a constant expression of numeric type, and
1199 // set the Numeric_constant to the value.
1201 do_numeric_constant_value(Numeric_constant
*)
1204 // Return whether this is a constant expression of string type, and
1205 // set VAL to the value.
1207 do_string_constant_value(std::string
*)
1210 // Return whether this is a constant expression of boolean type, and
1211 // set VAL to the value.
1213 do_boolean_constant_value(bool*)
1216 // Called by the parser if the value is being discarded.
1218 do_discarding_value();
1220 // Child class holds type.
1224 // Child class implements determining type information.
1226 do_determine_type(Gogo
*, const Type_context
*) = 0;
1228 // Child class implements type checking if needed.
1230 do_check_types(Gogo
*)
1233 // Child class implements copying.
1237 // Child class implements determining the cost of this statement for
1238 // inlining. The default cost is high, so we only need to define
1239 // this method for expressions that can be inlined.
1241 do_inlining_cost() const
1242 { return 0x100000; }
1244 // Child class implements whether the expression is addressable.
1246 do_is_addressable() const
1249 // Child class implements taking the address of an expression.
1251 do_address_taken(bool)
1254 // Child class implements issuing a nil check if the address is taken.
1256 do_issue_nil_check()
1259 // Child class implements whether this expression must be evaluated
1262 do_must_eval_in_order() const
1265 // Child class implements whether this expressions requires that
1266 // subexpressions be evaluated in order. The child implementation
1267 // may set *SKIP if it should be non-zero.
1269 do_must_eval_subexpressions_in_order(int* /* skip */) const
1272 // Child class implements conversion to backend representation.
1273 virtual Bexpression
*
1274 do_get_backend(Translate_context
*) = 0;
1276 // Child class implements export.
1278 do_export(Export_function_body
*) const;
1280 // For children to call to give an error for an unused value.
1282 unused_value_error();
1284 // For children to call when they detect that they are in error.
1288 // For children to call to report an error conveniently.
1290 report_error(const char*);
1292 // A convenience function for handling a type in do_is_untyped. If
1293 // TYPE is not abstract, return false. Otherwise set *PTYPE to TYPE
1296 is_untyped_type(Type
* type
, Type
** ptype
);
1298 // Write a name to export data.
1300 export_name(Export_function_body
* efb
, const Named_object
*);
1302 // Child class implements dumping to a dump context.
1304 do_dump_expression(Ast_dump_context
*) const = 0;
1306 // Start exporting a type conversion for a constant, if needed.
1308 export_constant_type(Export_function_body
*, Type
*);
1310 // Finish exporting a type conversion for a constant.
1312 finish_export_constant_type(Export_function_body
*, bool);
1314 // Varargs lowering creates a slice object (unnamed compiler temp)
1315 // to contain the variable length collection of values. The enum
1316 // below tells the lowering routine whether it can mark that temp
1317 // as non-escaping or not. For general varargs calls it is not always
1318 // safe to stack-allocated the storage, but for specific cases (ex:
1319 // call to append()) it is legal.
1320 enum Slice_storage_escape_disp
1322 SLICE_STORAGE_MAY_ESCAPE
,
1323 SLICE_STORAGE_DOES_NOT_ESCAPE
1327 // Convert to the desired statement classification, or return NULL.
1328 // This is a controlled dynamic cast.
1329 template<typename Expression_class
,
1330 Expression_classification expr_classification
>
1334 return (this->classification_
== expr_classification
1335 ? static_cast<Expression_class
*>(this)
1339 template<typename Expression_class
,
1340 Expression_classification expr_classification
>
1341 const Expression_class
*
1344 return (this->classification_
== expr_classification
1345 ? static_cast<const Expression_class
*>(this)
1350 convert_interface_to_type(Gogo
*, Type
*, Expression
*, Location
);
1353 import_identifier(Import_function_body
*, Location
);
1356 import_expression_without_suffix(Import_expression
*, Location
);
1358 // The expression classification.
1359 Expression_classification classification_
;
1360 // The location in the input file.
1364 // A list of Expressions.
1366 class Expression_list
1373 // Return whether the list is empty.
1376 { return this->entries_
.empty(); }
1378 // Return the number of entries in the list.
1381 { return this->entries_
.size(); }
1383 // Add an entry to the end of the list.
1385 push_back(Expression
* expr
)
1386 { this->entries_
.push_back(expr
); }
1389 append(Expression_list
* add
)
1390 { this->entries_
.insert(this->entries_
.end(), add
->begin(), add
->end()); }
1392 // Reserve space in the list.
1394 reserve(size_t size
)
1395 { this->entries_
.reserve(size
); }
1397 // Traverse the expressions in the list.
1399 traverse(Traverse
*);
1405 // Return true if the list contains an error expression.
1407 contains_error() const;
1409 // Retrieve an element by index.
1412 { return this->entries_
.at(i
); }
1414 // Return the first and last elements.
1417 { return this->entries_
.front(); }
1421 { return this->entries_
.front(); }
1425 { return this->entries_
.back(); }
1429 { return this->entries_
.back(); }
1433 typedef std::vector
<Expression
*>::iterator iterator
;
1434 typedef std::vector
<Expression
*>::const_iterator const_iterator
;
1438 { return this->entries_
.begin(); }
1442 { return this->entries_
.begin(); }
1446 { return this->entries_
.end(); }
1450 { return this->entries_
.end(); }
1455 { this->entries_
.erase(p
); }
1458 std::vector
<Expression
*> entries_
;
1461 // An abstract base class for an expression which is only used by the
1462 // parser, and is lowered in the lowering pass.
1464 class Parser_expression
: public Expression
1467 Parser_expression(Expression_classification classification
,
1469 : Expression(classification
, location
)
1474 do_lower(Gogo
*, Named_object
*, Statement_inserter
*) = 0;
1477 do_get_backend(Translate_context
*)
1478 { go_unreachable(); }
1481 // A reference to a const in an expression.
1483 class Const_expression
: public Expression
1486 Const_expression(Named_object
* constant
, Location location
)
1487 : Expression(EXPRESSION_CONST_REFERENCE
, location
),
1488 constant_(constant
), type_(NULL
), iota_value_(0), seen_(false),
1494 { return this->constant_
; }
1497 named_object() const
1498 { return this->constant_
; }
1500 // Check that the initializer does not refer to the constant itself.
1502 check_for_init_loop();
1504 // Set the iota value if this is a reference to iota.
1506 set_iota_value(int);
1510 do_traverse(Traverse
*);
1513 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
1516 do_is_constant() const
1520 do_is_untyped(Type
**) const;
1523 do_is_zero_value() const;
1526 do_is_static_initializer() const
1530 do_numeric_constant_value(Numeric_constant
* nc
);
1533 do_string_constant_value(std::string
* val
);
1536 do_boolean_constant_value(bool* val
);
1541 // The type of a const is set by the declaration, not the use.
1543 do_determine_type(Gogo
*, const Type_context
*);
1546 do_check_types(Gogo
*);
1553 do_get_backend(Translate_context
* context
);
1556 do_inlining_cost() const
1559 // When exporting a reference to a const as part of a const
1560 // expression, we export the value. We ignore the fact that it has
1563 do_export(Export_function_body
* efb
) const;
1566 do_dump_expression(Ast_dump_context
*) const;
1570 Named_object
* constant_
;
1571 // The type of this reference. This is used if the constant has an
1574 // If this const is a reference to the predeclared iota value, the
1577 // Used to prevent infinite recursion when a constant incorrectly
1578 // refers to itself.
1580 // Whether this const is a reference to the predeclared iota value.
1584 // An expression which is simply a variable.
1586 class Var_expression
: public Expression
1589 Var_expression(Named_object
* variable
, Location location
)
1590 : Expression(EXPRESSION_VAR_REFERENCE
, location
),
1594 // Return the variable.
1596 named_object() const
1597 { return this->variable_
; }
1601 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
1607 do_determine_type(Gogo
*, const Type_context
*);
1614 do_inlining_cost() const
1618 do_export(Export_function_body
*) const;
1621 do_is_addressable() const
1625 do_address_taken(bool);
1628 do_get_backend(Translate_context
*);
1631 do_dump_expression(Ast_dump_context
*) const;
1634 // The variable we are referencing.
1635 Named_object
* variable_
;
1638 // A reference to a variable within an enclosing function.
1640 class Enclosed_var_expression
: public Expression
1643 Enclosed_var_expression(Expression
* reference
, Named_object
* variable
,
1645 : Expression(EXPRESSION_ENCLOSED_VAR_REFERENCE
, location
),
1646 reference_(reference
), variable_(variable
)
1649 // The reference to the enclosed variable. This will be an indirection of the
1650 // the field stored within closure variable.
1653 { return this->reference_
; }
1655 // The variable being enclosed and referenced.
1658 { return this->variable_
; }
1662 do_traverse(Traverse
*);
1665 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
1668 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1672 { return this->reference_
->type(); }
1675 do_determine_type(Gogo
* gogo
, const Type_context
* context
)
1676 { return this->reference_
->determine_type(gogo
, context
); }
1683 do_is_addressable() const
1684 { return this->reference_
->is_addressable(); }
1687 do_address_taken(bool escapes
);
1690 do_get_backend(Translate_context
* context
)
1691 { return this->reference_
->get_backend(context
); }
1694 do_dump_expression(Ast_dump_context
*) const;
1697 // The reference to the enclosed variable.
1698 Expression
* reference_
;
1699 // The variable being enclosed.
1700 Named_object
* variable_
;
1703 // A reference to a temporary variable.
1705 class Temporary_reference_expression
: public Expression
1708 Temporary_reference_expression(Temporary_statement
* statement
,
1710 : Expression(EXPRESSION_TEMPORARY_REFERENCE
, location
),
1711 statement_(statement
), is_lvalue_(false)
1714 // The temporary that this expression refers to.
1715 Temporary_statement
*
1717 { return this->statement_
; }
1719 // Indicate that this reference appears on the left hand side of an
1720 // assignment statement.
1723 { this->is_lvalue_
= true; }
1726 do_import(Import_function_body
*, Location
);
1733 do_determine_type(Gogo
*, const Type_context
*)
1738 { return make_temporary_reference(this->statement_
, this->location()); }
1741 do_inlining_cost() const
1745 do_export(Export_function_body
*) const;
1748 do_is_addressable() const
1752 do_address_taken(bool);
1755 do_get_backend(Translate_context
*);
1758 do_dump_expression(Ast_dump_context
*) const;
1761 // The statement where the temporary variable is defined.
1762 Temporary_statement
* statement_
;
1763 // Whether this reference appears on the left hand side of an
1764 // assignment statement.
1768 // Set and use a temporary variable.
1770 class Set_and_use_temporary_expression
: public Expression
1773 Set_and_use_temporary_expression(Temporary_statement
* statement
,
1774 Expression
* expr
, Location location
)
1775 : Expression(EXPRESSION_SET_AND_USE_TEMPORARY
, location
),
1776 statement_(statement
), expr_(expr
)
1779 // Return the temporary.
1780 Temporary_statement
*
1782 { return this->statement_
; }
1784 // Return the expression.
1787 { return this->expr_
; }
1791 do_traverse(Traverse
* traverse
)
1792 { return Expression::traverse(&this->expr_
, traverse
); }
1798 do_determine_type(Gogo
*, const Type_context
*);
1803 return make_set_and_use_temporary(this->statement_
, this->expr_
,
1808 do_must_eval_in_order() const
1812 do_is_addressable() const
1816 do_address_taken(bool);
1819 do_get_backend(Translate_context
*);
1822 do_dump_expression(Ast_dump_context
*) const;
1825 // The statement where the temporary variable is defined.
1826 Temporary_statement
* statement_
;
1827 // The expression to assign to the temporary.
1831 // A string expression.
1833 class String_expression
: public Expression
1836 String_expression(const std::string
& val
, Type
* type
, Location location
)
1837 : Expression(EXPRESSION_STRING
, location
),
1838 val_(val
), type_(type
)
1843 { return this->val_
; }
1846 do_import(Import_expression
*, Location
);
1850 do_traverse(Traverse
*);
1853 do_is_constant() const
1857 do_is_untyped(Type
**) const;
1860 do_is_zero_value() const
1861 { return this->val_
== ""; }
1864 do_is_static_initializer() const
1868 do_string_constant_value(std::string
* val
)
1878 do_determine_type(Gogo
*, const Type_context
*);
1885 do_get_backend(Translate_context
*);
1887 // Write string literal to a string dump.
1889 export_string(String_dump
* exp
, const String_expression
* str
);
1891 // Set the inlining cost a bit high since inlining may cause
1892 // duplicated string literals.
1894 do_inlining_cost() const
1898 do_export(Export_function_body
*) const;
1901 do_dump_expression(Ast_dump_context
*) const;
1904 // The string value. This is immutable.
1905 const std::string val_
;
1906 // The type as determined by context.
1910 // A type conversion expression.
1912 class Type_conversion_expression
: public Expression
1915 Type_conversion_expression(Type
* type
, Expression
* expr
,
1917 : Expression(EXPRESSION_CONVERSION
, location
),
1918 type_(type
), expr_(expr
), may_convert_function_types_(false),
1919 no_copy_(false), no_escape_(false)
1922 // Return the type to which we are converting.
1925 { return this->type_
; }
1927 // Return the expression which we are converting.
1930 { return this->expr_
; }
1932 // Permit converting from one function type to another. This is
1933 // used internally for method expressions.
1935 set_may_convert_function_types()
1937 this->may_convert_function_types_
= true;
1940 // Mark string([]byte) conversion to reuse the backing store
1944 { this->no_copy_
= b
; };
1946 // Import a type conversion expression.
1948 do_import(Import_expression
*, Location
);
1952 do_traverse(Traverse
* traverse
);
1955 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
1958 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1961 do_is_constant() const;
1964 do_is_zero_value() const;
1967 do_is_static_initializer() const;
1970 do_numeric_constant_value(Numeric_constant
*);
1973 do_string_constant_value(std::string
*);
1976 do_boolean_constant_value(bool*);
1982 do_determine_type(Gogo
*, const Type_context
*);
1985 do_check_types(Gogo
*);
1991 do_get_backend(Translate_context
* context
);
1994 do_inlining_cost() const;
1997 do_export(Export_function_body
*) const;
2000 do_dump_expression(Ast_dump_context
*) const;
2003 // The type to convert to.
2005 // The expression to convert.
2007 // True if this is permitted to convert function types. This is
2008 // used internally for method expressions.
2009 bool may_convert_function_types_
;
2010 // True if a string([]byte) conversion can reuse the backing store
2011 // without copying. Only used in string([]byte) conversion.
2013 // True if a conversion does not escape. Used in type-to-interface
2014 // conversions and slice-to/from-string conversions.
2018 // An unsafe type conversion, used to pass values to builtin functions.
2020 class Unsafe_type_conversion_expression
: public Expression
2023 Unsafe_type_conversion_expression(Type
* type
, Expression
* expr
,
2025 : Expression(EXPRESSION_UNSAFE_CONVERSION
, location
),
2026 type_(type
), expr_(expr
)
2031 { return this->expr_
; }
2035 do_traverse(Traverse
* traverse
);
2038 do_is_zero_value() const
2039 { return this->expr_
->is_zero_value(); }
2042 do_is_static_initializer() const;
2046 { return this->type_
; }
2049 do_determine_type(Gogo
* gogo
, const Type_context
*)
2050 { this->expr_
->determine_type_no_context(gogo
); }
2056 do_get_backend(Translate_context
*);
2059 do_dump_expression(Ast_dump_context
*) const;
2062 // The type to convert to.
2064 // The expression to convert.
2068 // A Unary expression.
2070 class Unary_expression
: public Expression
2073 Unary_expression(Operator op
, Expression
* expr
, Location location
)
2074 : Expression(EXPRESSION_UNARY
, location
),
2075 op_(op
), escapes_(true), create_temp_(false), is_gc_root_(false),
2076 is_slice_init_(false), expr_(expr
), type_(NULL
),
2077 issue_nil_check_(NIL_CHECK_DEFAULT
)
2080 // Return the operator.
2083 { return this->op_
; }
2085 // Return the operand.
2088 { return this->expr_
; }
2090 // Record that an address expression does not escape.
2092 set_does_not_escape()
2094 go_assert(this->op_
== OPERATOR_AND
);
2095 this->escapes_
= false;
2098 // Record that this is an address expression which should create a
2099 // temporary variable if necessary. This is used for method calls.
2103 go_assert(this->op_
== OPERATOR_AND
);
2104 this->create_temp_
= true;
2107 // Record that this is an address expression of a GC root, which is a
2108 // mutable composite literal. This used for registering GC variables.
2112 go_assert(this->op_
== OPERATOR_AND
);
2113 this->is_gc_root_
= true;
2116 // Record that this is an address expression of a slice value initializer,
2117 // which is mutable if the values are not copied to the heap.
2121 go_assert(this->op_
== OPERATOR_AND
);
2122 this->is_slice_init_
= true;
2125 // Call the address_taken method on the operand if necessary.
2127 check_operand_address_taken(Gogo
*);
2129 // Apply unary opcode OP to UNC, setting NC. Return true if this
2130 // could be done, false if not. On overflow, issues an error and
2131 // sets *ISSUED_ERROR.
2133 eval_constant(Type
*, Operator op
, const Numeric_constant
* unc
,
2134 Location
, Numeric_constant
* nc
, bool *issued_error
);
2137 do_import(Import_expression
*, Location
);
2139 // Declare that this deref does or does not require an explicit nil check.
2141 set_requires_nil_check(bool needed
)
2143 go_assert(this->op_
== OPERATOR_MULT
);
2145 this->issue_nil_check_
= NIL_CHECK_NEEDED
;
2147 this->issue_nil_check_
= NIL_CHECK_NOT_NEEDED
;
2152 do_traverse(Traverse
* traverse
)
2153 { return Expression::traverse(&this->expr_
, traverse
); }
2156 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
2159 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2162 do_is_constant() const;
2165 do_is_untyped(Type
**) const;
2168 do_is_static_initializer() const;
2171 do_numeric_constant_value(Numeric_constant
*);
2174 do_boolean_constant_value(bool*);
2180 do_determine_type(Gogo
*, const Type_context
*);
2183 do_check_types(Gogo
*);
2188 return Expression::make_unary(this->op_
, this->expr_
->copy(),
2193 do_must_eval_subexpressions_in_order(int*) const
2194 { return this->op_
== OPERATOR_MULT
; }
2197 do_is_addressable() const
2198 { return this->op_
== OPERATOR_MULT
; }
2201 do_get_backend(Translate_context
*);
2204 do_inlining_cost() const
2208 do_export(Export_function_body
*) const;
2211 do_dump_expression(Ast_dump_context
*) const;
2214 do_issue_nil_check()
2216 if (this->op_
== OPERATOR_MULT
)
2217 this->set_requires_nil_check(true);
2222 base_is_static_initializer(Expression
*);
2224 // Return a determination as to whether this dereference expression
2225 // requires a nil check.
2226 Nil_check_classification
2227 requires_nil_check(Gogo
*);
2229 // The unary operator to apply.
2231 // Normally true. False if this is an address expression which does
2232 // not escape the current function.
2234 // True if this is an address expression which should create a
2235 // temporary variable if necessary.
2237 // True if this is an address expression for a GC root. A GC root is a
2238 // special struct composite literal that is mutable when addressed, meaning
2239 // it cannot be represented as an immutable_struct in the backend.
2241 // True if this is an address expression for a slice value with an immutable
2242 // initializer. The initializer for a slice's value pointer has an array
2243 // type, meaning it cannot be represented as an immutable_struct in the
2245 bool is_slice_init_
;
2248 // The type of the expression. Not used for AND and MULT.
2250 // Whether or not to issue a nil check for this expression if its address
2252 Nil_check_classification issue_nil_check_
;
2255 // A binary expression.
2257 class Binary_expression
: public Expression
2260 Binary_expression(Operator op
, Expression
* left
, Expression
* right
,
2262 : Expression(EXPRESSION_BINARY
, location
),
2263 op_(op
), left_(left
), right_(right
), type_(NULL
)
2266 // Return the operator.
2269 { return this->op_
; }
2271 // Return the left hand expression.
2274 { return this->left_
; }
2276 // Return the right hand expression.
2279 { return this->right_
; }
2281 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
2282 // Return true if this could be done, false if not. Issue errors at
2283 // LOCATION as appropriate, and sets *ISSUED_ERROR if it did.
2285 eval_constant(Operator op
, Numeric_constant
* left_nc
,
2286 Numeric_constant
* right_nc
, Location location
,
2287 Numeric_constant
* nc
, bool* issued_error
);
2289 // Compare constants LEFT_NC and RIGHT_NC according to OP, setting
2290 // *RESULT. Return true if this could be done, false if not. Issue
2291 // errors at LOCATION as appropriate.
2293 compare_constant(Operator op
, Numeric_constant
* left_nc
,
2294 Numeric_constant
* right_nc
, Location location
,
2298 do_import(Import_expression
*, Location
);
2300 // Report an error if OP can not be applied to TYPE. Return whether
2301 // it can. OTYPE is the type of the other operand.
2303 check_operator_type(Operator op
, Type
* type
, Type
* otype
, Location
);
2305 // Set *RESULT_TYPE to the resulting type when OP is applied to
2306 // operands of type LEFT_TYPE and RIGHT_TYPE. Return true on
2307 // success, false on failure.
2309 operation_type(Operator op
, Type
* left_type
, Type
* right_type
,
2310 Type
** result_type
);
2314 do_traverse(Traverse
* traverse
);
2317 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
2320 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2323 do_is_constant() const
2324 { return this->left_
->is_constant() && this->right_
->is_constant(); }
2327 do_is_untyped(Type
**) const;
2330 do_is_static_initializer() const;
2333 do_numeric_constant_value(Numeric_constant
*);
2336 do_boolean_constant_value(bool*);
2339 do_discarding_value();
2345 do_determine_type(Gogo
*, const Type_context
*);
2348 do_check_types(Gogo
*);
2353 return Expression::make_binary(this->op_
, this->left_
->copy(),
2354 this->right_
->copy(), this->location());
2358 do_get_backend(Translate_context
*);
2361 do_inlining_cost() const
2365 do_export(Export_function_body
*) const;
2368 do_dump_expression(Ast_dump_context
*) const;
2372 cmp_to_bool(Operator op
, int cmp
);
2375 eval_integer(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2376 Location
, Numeric_constant
*, bool* issued_error
);
2379 eval_float(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2380 Location
, Numeric_constant
*, bool* issued_error
);
2383 eval_complex(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2384 Location
, Numeric_constant
*, bool* issued_error
);
2387 compare_integer(const Numeric_constant
*, const Numeric_constant
*, int*);
2390 compare_float(const Numeric_constant
*, const Numeric_constant
*, int*);
2393 compare_complex(const Numeric_constant
*, const Numeric_constant
*, int*);
2396 lower_struct_comparison(Gogo
*, Statement_inserter
*);
2399 lower_array_comparison(Gogo
*, Statement_inserter
*);
2402 lower_interface_value_comparison(Gogo
*, Statement_inserter
*);
2405 lower_compare_to_memcmp(Gogo
*, Statement_inserter
*);
2408 operand_address(Statement_inserter
*, Expression
*);
2410 // The binary operator to apply.
2412 // The left hand side operand.
2414 // The right hand side operand.
2416 // The type of the expression.
2420 // A string concatenation expression. This is a sequence of strings
2421 // added together. It is created when lowering Binary_expression.
2423 class String_concat_expression
: public Expression
2426 String_concat_expression(Expression_list
* exprs
)
2427 : Expression(EXPRESSION_STRING_CONCAT
, exprs
->front()->location()),
2431 // Return the list of string expressions to be concatenated.
2434 { return this->exprs_
; }
2438 do_traverse(Traverse
* traverse
)
2439 { return this->exprs_
->traverse(traverse
); }
2442 do_lower(Gogo
*, Named_object
*, Statement_inserter
*)
2446 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2449 do_is_constant() const;
2452 do_is_untyped(Type
**) const;
2455 do_is_zero_value() const;
2458 do_is_static_initializer() const;
2464 do_determine_type(Gogo
*, const Type_context
*);
2467 do_check_types(Gogo
*);
2471 { return Expression::make_string_concat(this->exprs_
->copy()); }
2474 do_get_backend(Translate_context
*)
2475 { go_unreachable(); }
2478 do_export(Export_function_body
*) const
2479 { go_unreachable(); }
2482 do_dump_expression(Ast_dump_context
*) const;
2485 // The string expressions to concatenate.
2486 Expression_list
* exprs_
;
2489 // A call expression. The go statement needs to dig inside this.
2491 class Call_expression
: public Expression
2494 Call_expression(Expression
* fn
, Expression_list
* args
, bool is_varargs
,
2496 : Expression(EXPRESSION_CALL
, location
),
2497 fn_(fn
), args_(args
), type_(NULL
), lowered_(NULL
), call_(NULL
),
2498 call_temp_(NULL
), expected_result_count_(0), is_varargs_(is_varargs
),
2499 varargs_are_lowered_(false), types_are_determined_(false),
2500 is_deferred_(false), is_concurrent_(false), is_equal_function_(false),
2501 issued_error_(false), is_multi_value_arg_(false), is_flattened_(false)
2504 // The function to call.
2507 { return this->fn_
; }
2512 { return this->args_
; }
2514 const Expression_list
*
2516 { return this->args_
; }
2518 // Get the function type.
2520 get_function_type() const;
2522 // Return the number of values this call will return.
2524 result_count() const;
2526 // Return the temporary variable that holds the results. This is
2527 // only valid after the expression has been lowered, and is only
2528 // valid for calls which return multiple results.
2529 Temporary_statement
*
2532 // Set the number of results expected from this call. This is used
2533 // when the call appears in a context that expects multiple results,
2534 // such as a, b = f(). This must be called before the
2535 // determine_types pass.
2537 set_expected_result_count(size_t);
2539 // Return whether this is a call to the predeclared function
2542 is_recover_call() const;
2544 // Set the argument for a call to recover.
2546 set_recover_arg(Expression
*);
2548 // Whether the last argument is a varargs argument (f(a...)).
2551 { return this->is_varargs_
; }
2553 // Return whether varargs have already been lowered.
2555 varargs_are_lowered() const
2556 { return this->varargs_are_lowered_
; }
2558 // Note that varargs have already been lowered.
2560 set_varargs_are_lowered()
2561 { this->varargs_are_lowered_
= true; }
2563 // Whether this call is being deferred.
2566 { return this->is_deferred_
; }
2568 // Note that the call is being deferred.
2571 { this->is_deferred_
= true; }
2573 // Whether this call is concurrently executed.
2575 is_concurrent() const
2576 { return this->is_concurrent_
; }
2578 // Note that the call is concurrently executed.
2581 { this->is_concurrent_
= true; }
2583 // Note that this is a call to a generated equality function.
2585 set_is_equal_function()
2586 { this->is_equal_function_
= true; }
2588 // We have found an error with this call expression; return true if
2589 // we should report it.
2593 // Whether or not this call contains errors, either in the call or the
2594 // arguments to the call.
2596 is_erroneous_call();
2598 // Whether this call returns multiple results that are used as an
2599 // multi-valued argument.
2601 is_multi_value_arg() const
2602 { return this->is_multi_value_arg_
; }
2604 // Note this call is used as a multi-valued argument.
2606 set_is_multi_value_arg()
2607 { this->is_multi_value_arg_
= true; }
2609 // Whether this is a call to builtin function.
2614 // Convert to a Builtin_call_expression, or return NULL.
2615 inline Builtin_call_expression
*
2616 builtin_call_expression();
2618 inline const Builtin_call_expression
*
2619 builtin_call_expression() const;
2621 // Lower to a Builtin_call_expression if appropriate.
2623 lower_builtin(Gogo
*);
2627 do_traverse(Traverse
*);
2630 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
2633 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2636 do_discarding_value();
2642 do_is_constant() const;
2645 do_is_untyped(Type
**) const;
2648 do_numeric_constant_value(Numeric_constant
*);
2651 do_determine_type(Gogo
*, const Type_context
*);
2654 do_check_types(Gogo
*);
2660 do_must_eval_in_order() const;
2662 virtual Bexpression
*
2663 do_get_backend(Translate_context
*);
2666 do_inlining_cost() const;
2669 do_export(Export_function_body
*) const;
2672 do_is_recover_call() const;
2675 do_set_recover_arg(Expression
*);
2677 // Let a builtin expression change the argument list.
2679 set_args(Expression_list
* args
)
2680 { this->args_
= args
; }
2682 // Let a builtin expression check whether types have been
2685 determining_types();
2687 // Let a builtin expression retrieve the expected type.
2690 { return this->type_
; }
2692 // Let a builtin expression set the expected type.
2694 set_type(Type
* type
)
2695 { this->type_
= type
; }
2697 // Let a builtin expression simply f(g()) where g returns multiple
2700 simplify_multiple_results(Gogo
*);
2703 export_arguments(Export_function_body
*) const;
2706 do_dump_expression(Ast_dump_context
*) const;
2709 do_add_conversions();
2716 check_argument_type(int, const Type
*, const Type
*, Location
);
2719 intrinsify(Gogo
*, Statement_inserter
*);
2722 interface_method_function(Interface_field_reference_expression
*,
2723 Expression
**, Location
);
2726 set_results(Translate_context
*);
2728 // The function to call.
2730 // The arguments to pass. This may be NULL if there are no
2732 Expression_list
* args_
;
2733 // The type of the expression, to avoid recomputing it.
2735 // If not NULL, this is a lowered version of this Call_expression.
2736 Expression
* lowered_
;
2737 // The backend expression for the call, used for a call which returns a tuple.
2739 // A temporary variable to store this call if the function returns a tuple.
2740 Temporary_statement
* call_temp_
;
2741 // If not 0, the number of results expected from this call, when
2742 // used in a context that expects multiple values.
2743 size_t expected_result_count_
;
2744 // True if the last argument is a varargs argument (f(a...)).
2746 // True if varargs have already been lowered.
2747 bool varargs_are_lowered_
;
2748 // True if types have been determined.
2749 bool types_are_determined_
;
2750 // True if the call is an argument to a defer statement.
2752 // True if the call is an argument to a go statement.
2753 bool is_concurrent_
;
2754 // True if this is a call to a generated equality function.
2755 bool is_equal_function_
;
2756 // True if we reported an error about a mismatch between call
2757 // results and uses. This is to avoid producing multiple errors
2758 // when there are multiple Call_result_expressions.
2760 // True if this call is used as an argument that returns multiple results.
2761 bool is_multi_value_arg_
;
2762 // True if this expression has already been flattened.
2766 // A call expression to a builtin function.
2768 class Builtin_call_expression
: public Call_expression
2771 Builtin_call_expression(Gogo
* gogo
, Expression
* fn
, Expression_list
* args
,
2772 bool is_varargs
, Location location
);
2774 // The builtin functions.
2775 enum Builtin_function_code
2779 // Predeclared builtin functions.
2796 // Builtin functions from the unsafe package.
2804 Builtin_function_code
2806 { return this->code_
; }
2808 // This overrides Call_expression::is_builtin.
2813 // Return whether EXPR, of array type, is a constant if passed to
2816 array_len_is_constant(Expression
* expr
);
2819 flatten_append(Gogo
*, Named_object
*, Statement_inserter
*, Expression
*,
2823 // This overrides Call_expression::do_lower.
2825 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
2828 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2831 do_is_constant() const;
2834 do_is_untyped(Type
**) const;
2837 do_numeric_constant_value(Numeric_constant
*);
2840 do_discarding_value();
2846 do_determine_type(Gogo
*, const Type_context
*);
2849 do_check_types(Gogo
*);
2855 do_get_backend(Translate_context
*);
2858 do_inlining_cost() const
2862 do_export(Export_function_body
*) const;
2865 do_is_recover_call() const;
2868 do_set_recover_arg(Expression
*);
2878 real_imag_type(Type
*);
2881 complex_type(Type
*);
2884 lower_make(Gogo
*, Statement_inserter
*);
2887 check_int_value(Expression
*, bool is_length
, bool* small
);
2889 // A pointer back to the general IR structure. This avoids a global
2890 // variable, or passing it around everywhere.
2892 // The builtin function being called.
2893 Builtin_function_code code_
;
2894 // Used to stop endless loops when the length of an array uses len
2895 // or cap of the array itself.
2897 // Whether the argument is set for calls to BUILTIN_RECOVER.
2898 bool recover_arg_is_set_
;
2901 inline Builtin_call_expression
*
2902 Call_expression::builtin_call_expression()
2904 return (this->is_builtin()
2905 ? static_cast<Builtin_call_expression
*>(this)
2909 inline const Builtin_call_expression
*
2910 Call_expression::builtin_call_expression() const
2912 return (this->is_builtin()
2913 ? static_cast<const Builtin_call_expression
*>(this)
2917 // A single result from a call which returns multiple results.
2919 class Call_result_expression
: public Expression
2922 Call_result_expression(Call_expression
* call
, unsigned int index
)
2923 : Expression(EXPRESSION_CALL_RESULT
, call
->location()),
2924 call_(call
), index_(index
)
2929 { return this->call_
; }
2933 { return this->index_
; }
2937 do_traverse(Traverse
*);
2943 do_determine_type(Gogo
*, const Type_context
*);
2946 do_check_types(Gogo
*);
2951 return new Call_result_expression(this->call_
->call_expression(),
2956 do_must_eval_in_order() const
2960 do_get_backend(Translate_context
*);
2963 do_dump_expression(Ast_dump_context
*) const;
2966 // The underlying call expression.
2968 // Which result we want.
2969 unsigned int index_
;
2972 // An expression which represents a pointer to a function.
2974 class Func_expression
: public Expression
2977 Func_expression(Named_object
* function
, Expression
* closure
,
2979 : Expression(EXPRESSION_FUNC_REFERENCE
, location
),
2980 function_(function
), closure_(closure
),
2981 runtime_code_(Runtime::NUMBER_OF_FUNCTIONS
)
2984 // Return the object associated with the function.
2986 named_object() const
2987 { return this->function_
; }
2989 // Return the closure for this function. This will return NULL if
2990 // the function has no closure, which is the normal case.
2993 { return this->closure_
; }
2995 // Return whether this is a reference to a runtime function.
2997 is_runtime_function() const
2998 { return this->runtime_code_
!= Runtime::NUMBER_OF_FUNCTIONS
; }
3000 // Return the runtime code for this function expression.
3001 // Returns Runtime::NUMBER_OF_FUNCTIONS if this is not a reference to a
3002 // runtime function.
3004 runtime_code() const
3005 { return this->runtime_code_
; }
3007 // Set the runtime code for this function expression.
3009 set_runtime_code(Runtime::Function code
)
3010 { this->runtime_code_
= code
; }
3012 // Return a backend expression for the code of a function.
3014 get_code_pointer(Gogo
*, Named_object
* function
, Location loc
);
3018 do_traverse(Traverse
*);
3024 do_determine_type(Gogo
* gogo
, const Type_context
*)
3026 if (this->closure_
!= NULL
)
3027 this->closure_
->determine_type_no_context(gogo
);
3033 return Expression::make_func_reference(this->function_
,
3034 (this->closure_
== NULL
3036 : this->closure_
->copy()),
3041 do_get_backend(Translate_context
*);
3044 do_inlining_cost() const;
3047 do_export(Export_function_body
*) const;
3050 do_dump_expression(Ast_dump_context
*) const;
3053 // The function itself.
3054 Named_object
* function_
;
3055 // A closure. This is normally NULL. For a nested function, it may
3056 // be a struct holding pointers to all the variables referenced by
3057 // this function and defined in enclosing functions.
3058 Expression
* closure_
;
3059 // The runtime code for the referenced function.
3060 Runtime::Function runtime_code_
;
3063 // A function descriptor. A function descriptor is a struct with a
3064 // single field pointing to the function code. This is used for
3065 // functions without closures.
3067 class Func_descriptor_expression
: public Expression
3070 Func_descriptor_expression(Named_object
* fn
);
3072 // Make the function descriptor type, so that it can be converted.
3074 make_func_descriptor_type();
3078 do_traverse(Traverse
*);
3084 do_determine_type(Gogo
*, const Type_context
*)
3089 { return Expression::make_func_descriptor(this->fn_
); }
3092 do_is_addressable() const
3096 do_get_backend(Translate_context
*);
3099 do_dump_expression(Ast_dump_context
* context
) const;
3102 // The type of all function descriptors.
3103 static Type
* descriptor_type
;
3105 // The function for which this is the descriptor.
3107 // The descriptor variable.
3111 // A reference to an unknown name.
3113 class Unknown_expression
: public Parser_expression
3116 Unknown_expression(Named_object
* named_object
, Location location
)
3117 : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE
, location
),
3118 named_object_(named_object
), lowered_(NULL
), iota_value_(0),
3119 no_error_message_(false), is_iota_(false)
3122 // The associated named object.
3124 named_object() const
3125 { return this->named_object_
; }
3127 // The name of the identifier which was unknown.
3131 // Call this to indicate that we should not give an error if this
3132 // name is never defined. This is used to avoid knock-on errors
3133 // during an erroneous parse.
3135 set_no_error_message()
3136 { this->no_error_message_
= true; }
3138 // Set the iota value if this is a reference to iota.
3140 set_iota_value(int);
3144 do_traverse(Traverse
*);
3150 do_determine_type(Gogo
*, const Type_context
*);
3153 do_is_constant() const;
3156 do_is_untyped(Type
**) const;
3159 do_numeric_constant_value(Numeric_constant
*);
3162 do_string_constant_value(std::string
*);
3165 do_boolean_constant_value(bool*);
3168 do_is_addressable() const;
3171 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
3175 { return new Unknown_expression(this->named_object_
, this->location()); }
3178 do_dump_expression(Ast_dump_context
*) const;
3181 // The unknown name.
3182 Named_object
* named_object_
;
3183 // The fully resolved expression.
3184 Expression
* lowered_
;
3185 // The iota value if this turns out to be a reference to iota.
3187 // True if we should not give errors if this is undefined. This is
3188 // used if there was a parse failure.
3189 bool no_error_message_
;
3190 // True if this could be a reference to iota.
3194 // An index expression. This is lowered to an array index, a string
3195 // index, or a map index.
3197 class Index_expression
: public Parser_expression
3200 Index_expression(Expression
* left
, Expression
* start
, Expression
* end
,
3201 Expression
* cap
, Location location
)
3202 : Parser_expression(EXPRESSION_INDEX
, location
),
3203 left_(left
), start_(start
), end_(end
), cap_(cap
),
3204 needs_nil_check_(false)
3207 // Return the expression being indexed.
3210 { return this->left_
; }
3212 // Dump an index expression, i.e. an expression of the form
3213 // expr[expr], expr[expr:expr], or expr[expr:expr:expr] to a dump context.
3215 dump_index_expression(Ast_dump_context
*, const Expression
* expr
,
3216 const Expression
* start
, const Expression
* end
,
3217 const Expression
* cap
);
3219 // Report whether EXPR is a map index expression.
3221 is_map_index(Expression
* expr
);
3225 do_traverse(Traverse
*);
3231 do_determine_type(Gogo
*, const Type_context
*);
3234 do_check_types(Gogo
*);
3237 do_is_addressable() const;
3240 do_lower(Gogo
*, Named_object
*, Statement_inserter
*s
);
3245 Index_expression
* ret
=
3246 new Index_expression(this->left_
->copy(), this->start_
->copy(),
3249 : this->end_
->copy()),
3252 : this->cap_
->copy()),
3254 if (this->needs_nil_check_
)
3255 ret
->needs_nil_check_
= true;
3259 // This shouldn't be called--we don't know yet.
3261 do_must_eval_subexpressions_in_order(int*) const
3262 { go_unreachable(); }
3265 do_dump_expression(Ast_dump_context
*) const;
3268 do_issue_nil_check();
3271 // The expression being indexed.
3275 // The second index. This is NULL for an index, non-NULL for a
3278 // The capacity argument. This is NULL for indices and slices that use the
3279 // default capacity, non-NULL for indices and slices that specify the
3282 // True if this needs a nil check. This changes how we handle
3283 // dereferencing a pointer to an array.
3284 bool needs_nil_check_
;
3287 // An array index. This is used for both indexing and slicing.
3289 class Array_index_expression
: public Expression
3292 Array_index_expression(Expression
* array
, Expression
* start
,
3293 Expression
* end
, Expression
* cap
, Location location
)
3294 : Expression(EXPRESSION_ARRAY_INDEX
, location
),
3295 array_(array
), start_(start
), end_(end
), cap_(cap
), type_(NULL
),
3296 needs_bounds_check_(true), is_flattened_(false)
3299 // Return the array.
3302 { return this->array_
; }
3306 { return this->array_
; }
3308 // Return the index of a simple index expression, or the start index
3309 // of a slice expression.
3312 { return this->start_
; }
3316 { return this->start_
; }
3318 // Return the end index of a slice expression. This is NULL for a
3319 // simple index expression.
3322 { return this->end_
; }
3326 { return this->end_
; }
3329 set_needs_bounds_check(bool b
)
3330 { this->needs_bounds_check_
= b
; }
3334 check_indexes(Expression
* array
, Expression
* start
, Expression
* len
,
3335 Expression
* cap
, Location
);
3339 do_traverse(Traverse
*);
3342 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3348 do_determine_type(Gogo
*, const Type_context
*);
3351 do_check_types(Gogo
*);
3356 Expression
* ret
= Expression::make_array_index(this->array_
->copy(),
3357 this->start_
->copy(),
3360 : this->end_
->copy()),
3363 : this->cap_
->copy()),
3365 ret
->array_index_expression()->set_needs_bounds_check(this->needs_bounds_check_
);
3370 do_must_eval_subexpressions_in_order(int* skip
) const;
3373 do_is_addressable() const;
3376 do_address_taken(bool escapes
);
3379 do_issue_nil_check()
3380 { this->array_
->issue_nil_check(); }
3383 do_get_backend(Translate_context
*);
3386 do_inlining_cost() const
3387 { return this->end_
!= NULL
? 2 : 1; }
3390 do_export(Export_function_body
*) const;
3393 do_dump_expression(Ast_dump_context
*) const;
3396 // The array we are getting a value from.
3398 // The start or only index.
3400 // The end index of a slice. This may be NULL for a simple array
3401 // index, or it may be a nil expression for the length of the array.
3403 // The capacity argument of a slice. This may be NULL for an array index or
3406 // The type of the expression.
3408 // Whether bounds check is needed.
3409 bool needs_bounds_check_
;
3410 // Whether this has already been flattened.
3414 // A string index. This is used for both indexing and slicing.
3416 class String_index_expression
: public Expression
3419 String_index_expression(Expression
* string
, Expression
* start
,
3420 Expression
* end
, Location location
)
3421 : Expression(EXPRESSION_STRING_INDEX
, location
),
3422 string_(string
), start_(start
), end_(end
), is_flattened_(false)
3425 // Return the string being indexed.
3428 { return this->string_
; }
3430 // Return the index of a simple index expression, or the start index
3431 // of a slice expression.
3434 { return this->start_
; }
3436 // Return the end index of a slice expression. This is NULL for a
3437 // simple index expression.
3440 { return this->end_
; }
3444 check_indexes(Expression
* string
, Expression
* start
, Expression
* len
,
3449 do_traverse(Traverse
*);
3452 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3458 do_determine_type(Gogo
*, const Type_context
*);
3461 do_check_types(Gogo
*);
3466 return Expression::make_string_index(this->string_
->copy(),
3467 this->start_
->copy(),
3470 : this->end_
->copy()),
3475 do_must_eval_subexpressions_in_order(int*) const
3479 do_get_backend(Translate_context
*);
3482 do_inlining_cost() const
3483 { return this->end_
!= NULL
? 2 : 1; }
3486 do_export(Export_function_body
*) const;
3489 do_dump_expression(Ast_dump_context
*) const;
3492 // The string we are getting a value from.
3493 Expression
* string_
;
3494 // The start or only index.
3496 // The end index of a slice. This may be NULL for a single index,
3497 // or it may be a nil expression for the length of the string.
3499 // Whether this has already been flattened.
3503 // An index into a map.
3505 class Map_index_expression
: public Expression
3508 Map_index_expression(Expression
* map
, Expression
* index
,
3510 : Expression(EXPRESSION_MAP_INDEX
, location
),
3511 map_(map
), index_(index
), value_pointer_(NULL
)
3517 { return this->map_
; }
3521 { return this->map_
; }
3523 // Return the index.
3526 { return this->index_
; }
3530 { return this->index_
; }
3532 // Get the type of the map being indexed.
3534 get_map_type() const;
3536 // Return an expression for the map index. This returns an
3537 // expression that evaluates to a pointer to a value in the map. If
3538 // the key is not present in the map, this will return a pointer to
3541 get_value_pointer(Gogo
*);
3545 do_traverse(Traverse
*);
3548 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3554 do_determine_type(Gogo
*, const Type_context
*);
3557 do_check_types(Gogo
*);
3562 return Expression::make_map_index(this->map_
->copy(),
3563 this->index_
->copy(),
3568 do_must_eval_subexpressions_in_order(int*) const
3571 // A map index expression is an lvalue but it is not addressable.
3574 do_get_backend(Translate_context
*);
3577 do_inlining_cost() const
3581 do_export(Export_function_body
*) const;
3584 do_dump_expression(Ast_dump_context
*) const;
3587 do_add_conversions();
3590 // The map we are looking into.
3594 // A pointer to the value at this index.
3595 Expression
* value_pointer_
;
3598 // An expression which represents a method bound to its first
3601 class Bound_method_expression
: public Expression
3604 Bound_method_expression(Expression
* expr
, const Method
*method
,
3605 Named_object
* function
, Location location
)
3606 : Expression(EXPRESSION_BOUND_METHOD
, location
),
3607 expr_(expr
), expr_type_(NULL
), method_(method
), function_(function
)
3610 // Return the object which is the first argument.
3613 { return this->expr_
; }
3615 // Return the implicit type of the first argument. This will be
3616 // non-NULL when using a method from an anonymous field without
3617 // using an explicit stub.
3619 first_argument_type() const
3620 { return this->expr_type_
; }
3622 // Return the method.
3625 { return this->method_
; }
3627 // Return the function to call.
3630 { return this->function_
; }
3632 // Set the implicit type of the expression.
3634 set_first_argument_type(Type
* type
)
3635 { this->expr_type_
= type
; }
3637 // Create a thunk to call FUNCTION, for METHOD, when it is used as
3638 // part of a method value.
3639 static Named_object
*
3640 create_thunk(Gogo
*, const Method
* method
, Named_object
* function
);
3643 static Named_object
*
3644 lookup_thunk(Named_object
* function
);
3648 do_traverse(Traverse
*);
3651 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3657 do_determine_type(Gogo
*, const Type_context
*);
3660 do_check_types(Gogo
*);
3665 return new Bound_method_expression(this->expr_
->copy(), this->method_
,
3666 this->function_
, this->location());
3670 do_get_backend(Translate_context
*)
3671 { go_unreachable(); }
3674 do_dump_expression(Ast_dump_context
*) const;
3677 // A mapping from method functions to the thunks we have created for
3679 typedef Unordered_map(Named_object
*, Named_object
*) Method_value_thunks
;
3680 static Method_value_thunks method_value_thunks
;
3682 // The object used to find the method. This is passed to the method
3683 // as the first argument.
3685 // The implicit type of the object to pass to the method. This is
3686 // NULL in the normal case, non-NULL when using a method from an
3687 // anonymous field which does not require a stub.
3690 const Method
* method_
;
3691 // The function to call. This is not the same as
3692 // method_->named_object() when the method has a stub. This will be
3693 // the real function rather than the stub.
3694 Named_object
* function_
;
3697 // A reference to a field in a struct.
3699 class Field_reference_expression
: public Expression
3702 Field_reference_expression(Expression
* expr
, unsigned int field_index
,
3704 : Expression(EXPRESSION_FIELD_REFERENCE
, location
),
3705 expr_(expr
), field_index_(field_index
), implicit_(false), called_fieldtrack_(false)
3708 // Return the struct expression.
3711 { return this->expr_
; }
3713 // Return the field index.
3716 { return this->field_index_
; }
3718 // Return whether this node was implied by an anonymous field.
3721 { return this->implicit_
; }
3724 set_implicit(bool implicit
)
3725 { this->implicit_
= implicit
; }
3727 // Set the struct expression. This is used when parsing.
3729 set_struct_expression(Expression
* expr
)
3731 go_assert(this->expr_
== NULL
);
3737 do_traverse(Traverse
* traverse
)
3738 { return Expression::traverse(&this->expr_
, traverse
); }
3741 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
3747 do_determine_type(Gogo
* gogo
, const Type_context
*)
3748 { this->expr_
->determine_type_no_context(gogo
); }
3751 do_check_types(Gogo
*);
3756 return Expression::make_field_reference(this->expr_
->copy(),
3762 do_is_addressable() const
3763 { return this->expr_
->is_addressable(); }
3766 do_address_taken(bool escapes
)
3767 { this->expr_
->address_taken(escapes
); }
3770 do_issue_nil_check()
3771 { this->expr_
->issue_nil_check(); }
3774 do_get_backend(Translate_context
*);
3777 do_dump_expression(Ast_dump_context
*) const;
3780 // The expression we are looking into. This should have a type of
3783 // The zero-based index of the field we are retrieving.
3784 unsigned int field_index_
;
3785 // Whether this node was emitted implicitly for an embedded field,
3786 // that is, expr_ is not the expr_ of the original user node.
3788 // Whether we have already emitted a fieldtrack call.
3789 bool called_fieldtrack_
;
3792 // A reference to a field of an interface.
3794 class Interface_field_reference_expression
: public Expression
3797 Interface_field_reference_expression(Expression
* expr
,
3798 const std::string
& name
,
3800 : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE
, location
),
3801 expr_(expr
), name_(name
)
3804 // Return the expression for the interface object.
3807 { return this->expr_
; }
3809 // Return the name of the method to call.
3812 { return this->name_
; }
3814 // Create a thunk to call the method NAME in TYPE when it is used as
3815 // part of a method value.
3816 static Named_object
*
3817 create_thunk(Gogo
*, Interface_type
* type
, const std::string
& name
);
3820 static Named_object
*
3821 lookup_thunk(Interface_type
* type
, const std::string
& name
);
3823 // Return an expression for the pointer to the function to call.
3827 // Return an expression for the first argument to pass to the interface
3828 // function. This is the real object associated with the interface object.
3830 get_underlying_object();
3834 do_traverse(Traverse
* traverse
);
3837 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3843 do_determine_type(Gogo
*, const Type_context
*);
3846 do_check_types(Gogo
*);
3851 return Expression::make_interface_field_reference(this->expr_
->copy(),
3857 do_get_backend(Translate_context
*);
3860 do_dump_expression(Ast_dump_context
*) const;
3863 // A mapping from interface types to a list of thunks we have
3864 // created for methods.
3865 typedef std::vector
<std::pair
<std::string
, Named_object
*> > Method_thunks
;
3866 typedef Unordered_map(Interface_type
*, Method_thunks
*)
3867 Interface_method_thunks
;
3868 static Interface_method_thunks interface_method_thunks
;
3870 // The expression for the interface object. This should have a type
3871 // of interface or pointer to interface.
3873 // The field we are retrieving--the name of the method.
3877 // Implement the builtin function new.
3879 class Allocation_expression
: public Expression
3882 Allocation_expression(Type
* type
, Location location
)
3883 : Expression(EXPRESSION_ALLOCATION
, location
),
3884 type_(type
), allocate_on_stack_(false),
3889 set_allocate_on_stack()
3890 { this->allocate_on_stack_
= true; }
3892 // Mark that the allocated memory doesn't need zeroing.
3895 { this->no_zero_
= true; }
3899 do_traverse(Traverse
*);
3905 do_determine_type(Gogo
*, const Type_context
*)
3909 do_check_types(Gogo
*);
3915 do_get_backend(Translate_context
*);
3918 do_dump_expression(Ast_dump_context
*) const;
3921 // The type we are allocating.
3923 // Whether or not this is a stack allocation.
3924 bool allocate_on_stack_
;
3925 // Whether we don't need to zero the allocated memory.
3929 // A general composite literal. This is lowered to a type specific
3932 class Composite_literal_expression
: public Parser_expression
3935 Composite_literal_expression(Type
* type
, int depth
, bool has_keys
,
3936 Expression_list
* vals
, bool all_are_names
,
3938 : Parser_expression(EXPRESSION_COMPOSITE_LITERAL
, location
),
3939 type_(type
), depth_(depth
), vals_(vals
), has_keys_(has_keys
),
3940 all_are_names_(all_are_names
), key_path_(std::vector
<bool>(depth
)),
3941 traverse_order_(NULL
)
3945 // Mark the DEPTH entry of KEY_PATH as containing a key.
3947 update_key_path(size_t depth
)
3949 go_assert(depth
< this->key_path_
.size());
3950 this->key_path_
[depth
] = true;
3955 do_traverse(Traverse
* traverse
);
3961 do_determine_type(Gogo
*, const Type_context
*);
3964 do_check_types(Gogo
*);
3967 do_lower(Gogo
*, Named_object
*, Statement_inserter
*);
3973 do_dump_expression(Ast_dump_context
*) const;
3977 resolve_struct_keys(Gogo
*, Type
* type
);
3980 resolve_array_length(Type
*);
3983 lower_struct(Type
*);
3989 make_array(Type
*, const std::vector
<unsigned long>*, Expression_list
*);
3992 lower_map(Gogo
*, Named_object
*, Statement_inserter
*, Type
*);
3994 // The type of the composite literal.
3996 // The depth within a list of composite literals within a composite
3997 // literal, when the type is omitted.
3999 // The values to put in the composite literal.
4000 Expression_list
* vals_
;
4001 // If this is true, then VALS_ is a list of pairs: a key and a
4002 // value. In an array initializer, a missing key will be NULL.
4004 // If this is true, then HAS_KEYS_ is true, and every key is a
4005 // simple identifier.
4006 bool all_are_names_
;
4007 // A complement to DEPTH that indicates for each level starting from 0 to
4008 // DEPTH-1 whether or not this composite literal is nested inside of key or
4009 // a value. This is used to decide which type to use when given a map literal
4010 // with omitted key types.
4011 std::vector
<bool> key_path_
;
4012 // If not NULL, the order in which to traverse vals_ for a struct
4013 // composite literal. This is used so that we implement the order
4014 // of evaluation rules correctly.
4015 std::vector
<unsigned long>* traverse_order_
;
4018 // Helper/mixin class for struct and array construction expressions;
4019 // encapsulates a list of values plus an optional traversal order
4020 // recording the order in which the values should be visited.
4022 class Ordered_value_list
4025 Ordered_value_list(Expression_list
* vals
)
4026 : vals_(vals
), traverse_order_(NULL
)
4031 { return this->vals_
; }
4034 traverse_vals(Traverse
* traverse
);
4036 // Get the traversal order (may be NULL)
4037 std::vector
<unsigned long>*
4039 { return traverse_order_
; }
4041 // Set the traversal order, used to ensure that we implement the
4042 // order of evaluation rules. Takes ownership of the argument.
4044 set_traverse_order(std::vector
<unsigned long>* traverse_order
)
4045 { this->traverse_order_
= traverse_order
; }
4048 // The list of values, in order of the fields in the struct or in
4049 // order of indices in an array. A NULL value of vals_ means that
4050 // all fields/slots should be zero-initialized; a single NULL entry
4051 // in the list means that the corresponding field or array slot
4052 // should be zero-initialized.
4053 Expression_list
* vals_
;
4054 // If not NULL, the order in which to traverse vals_. This is used
4055 // so that we implement the order of evaluation rules correctly.
4056 std::vector
<unsigned long>* traverse_order_
;
4059 // Construct a struct.
4061 class Struct_construction_expression
: public Expression
,
4062 public Ordered_value_list
4065 Struct_construction_expression(Type
* type
, Expression_list
* vals
,
4067 : Expression(EXPRESSION_STRUCT_CONSTRUCTION
, location
),
4068 Ordered_value_list(vals
),
4072 // Return whether this is a constant initializer.
4074 is_constant_struct() const;
4076 // Check types of a struct composite literal.
4078 check_value_types(Gogo
*, Type
*, Expression_list
*, Location
);
4082 do_traverse(Traverse
* traverse
);
4085 do_is_zero_value() const;
4088 do_is_static_initializer() const;
4092 { return this->type_
; }
4095 do_determine_type(Gogo
*, const Type_context
*);
4098 do_check_types(Gogo
*);
4104 do_get_backend(Translate_context
*);
4107 do_export(Export_function_body
*) const;
4110 do_dump_expression(Ast_dump_context
*) const;
4113 do_add_conversions();
4116 // The type of the struct to construct.
4120 // Construct an array. This class is not used directly; instead we
4121 // use the child classes, Fixed_array_construction_expression and
4122 // Slice_construction_expression.
4124 class Array_construction_expression
: public Expression
,
4125 public Ordered_value_list
4128 Array_construction_expression(Expression_classification classification
,
4130 const std::vector
<unsigned long>* indexes
,
4131 Expression_list
* vals
, Location location
)
4132 : Expression(classification
, location
),
4133 Ordered_value_list(vals
),
4134 type_(type
), indexes_(indexes
)
4135 { go_assert(indexes
== NULL
|| indexes
->size() == vals
->size()); }
4138 // Return whether this is a constant initializer.
4140 is_constant_array() const;
4142 // Return the number of elements.
4144 element_count() const
4145 { return this->vals() == NULL
? 0 : this->vals()->size(); }
4149 do_traverse(Traverse
* traverse
);
4152 do_is_zero_value() const;
4155 do_is_static_initializer() const;
4159 { return this->type_
; }
4162 do_determine_type(Gogo
*, const Type_context
*);
4165 do_check_types(Gogo
*);
4168 do_export(Export_function_body
*) const;
4171 const std::vector
<unsigned long>*
4173 { return this->indexes_
; }
4175 // Get the backend constructor for the array values.
4177 get_constructor(Translate_context
* context
, Btype
* btype
);
4180 do_dump_expression(Ast_dump_context
*) const;
4183 dump_slice_storage_expression(Ast_dump_context
*) const { }
4186 do_add_conversions();
4189 // The type of the array to construct.
4191 // The list of indexes into the array, one for each value. This may
4192 // be NULL, in which case the indexes start at zero and increment.
4193 const std::vector
<unsigned long>* indexes_
;
4196 // Construct a fixed array.
4198 class Fixed_array_construction_expression
:
4199 public Array_construction_expression
4202 Fixed_array_construction_expression(Type
* type
,
4203 const std::vector
<unsigned long>* indexes
,
4204 Expression_list
* vals
, Location location
);
4211 do_get_backend(Translate_context
*);
4214 // Construct a slice.
4216 class Slice_construction_expression
: public Array_construction_expression
4219 Slice_construction_expression(Type
* type
,
4220 const std::vector
<unsigned long>* indexes
,
4221 Expression_list
* vals
, Location location
);
4224 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4226 // Record that the storage for this slice (e.g. vals) cannot escape,
4227 // hence it can be stack-allocated.
4229 set_storage_does_not_escape()
4231 this->storage_escapes_
= false;
4235 // Note that taking the address of a slice literal is invalid.
4238 do_traverse(Traverse
* traverse
);
4244 do_get_backend(Translate_context
*);
4247 dump_slice_storage_expression(Ast_dump_context
* ast_dump_context
) const;
4249 // Create an array value for the constructed slice. Invoked during
4250 // flattening if slice storage does not escape, otherwise invoked
4251 // later on during do_get_backend().
4256 // The type of the values in this slice.
4258 // Array value expression, optionally filled in during flattening.
4259 Expression
* array_val_
;
4260 // Slice storage expression, optionally filled in during flattening.
4261 Expression
* slice_storage_
;
4262 // Normally true. Can be set to false if we know that the resulting
4263 // storage for the slice cannot escape.
4264 bool storage_escapes_
;
4269 class Map_construction_expression
: public Expression
4272 Map_construction_expression(Type
* type
, Expression_list
* vals
,
4274 : Expression(EXPRESSION_MAP_CONSTRUCTION
, location
),
4275 type_(type
), vals_(vals
), element_type_(NULL
), constructor_temp_(NULL
)
4276 { go_assert(vals
== NULL
|| vals
->size() % 2 == 0); }
4280 { return this->vals_
; }
4284 do_traverse(Traverse
* traverse
);
4287 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4291 { return this->type_
; }
4294 do_determine_type(Gogo
*, const Type_context
*);
4297 do_check_types(Gogo
*);
4303 do_get_backend(Translate_context
*);
4306 do_export(Export_function_body
*) const;
4309 do_dump_expression(Ast_dump_context
*) const;
4312 do_add_conversions();
4315 // The type of the map to construct.
4317 // The list of values.
4318 Expression_list
* vals_
;
4319 // The type of the key-value pair struct for each map element.
4320 Struct_type
* element_type_
;
4321 // A temporary reference to the variable storing the constructor initializer.
4322 Temporary_statement
* constructor_temp_
;
4325 // A type guard expression.
4327 class Type_guard_expression
: public Expression
4330 Type_guard_expression(Expression
* expr
, Type
* type
, Location location
)
4331 : Expression(EXPRESSION_TYPE_GUARD
, location
),
4332 expr_(expr
), type_(type
)
4335 // Return the expression to convert.
4338 { return this->expr_
; }
4340 // Return the type to which to convert.
4343 { return this->type_
; }
4347 do_traverse(Traverse
* traverse
);
4350 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4354 { return this->type_
; }
4357 do_determine_type(Gogo
* gogo
, const Type_context
*)
4358 { this->expr_
->determine_type_no_context(gogo
); }
4361 do_check_types(Gogo
*);
4367 do_get_backend(Translate_context
*);
4370 do_dump_expression(Ast_dump_context
*) const;
4373 // The expression to convert.
4375 // The type to which to convert.
4379 // Class Heap_expression.
4381 // When you take the address of an escaping expression, it is allocated
4382 // on the heap. This class implements that.
4384 class Heap_expression
: public Expression
4387 Heap_expression(Expression
* expr
, Location location
)
4388 : Expression(EXPRESSION_HEAP
, location
),
4389 expr_(expr
), allocate_on_stack_(false)
4394 { return this->expr_
; }
4397 set_allocate_on_stack()
4398 { this->allocate_on_stack_
= true; }
4402 do_traverse(Traverse
* traverse
)
4403 { return Expression::traverse(&this->expr_
, traverse
); }
4408 do_determine_type(Gogo
* gogo
, const Type_context
*)
4409 { this->expr_
->determine_type_no_context(gogo
); }
4414 return Expression::make_heap_expression(this->expr_
->copy(),
4419 do_get_backend(Translate_context
*);
4421 // We only export global objects, and the parser does not generate
4422 // this in global scope.
4424 do_export(Export_function_body
*) const
4425 { go_unreachable(); }
4428 do_dump_expression(Ast_dump_context
*) const;
4431 // The expression which is being put on the heap.
4433 // Whether or not this is a stack allocation.
4434 bool allocate_on_stack_
;
4437 // A receive expression.
4439 class Receive_expression
: public Expression
4442 Receive_expression(Expression
* channel
, Location location
)
4443 : Expression(EXPRESSION_RECEIVE
, location
),
4444 channel_(channel
), temp_receiver_(NULL
)
4447 // Return the channel.
4450 { return this->channel_
; }
4453 do_import(Import_expression
*, Location
);
4457 do_traverse(Traverse
* traverse
)
4458 { return Expression::traverse(&this->channel_
, traverse
); }
4461 do_discarding_value()
4468 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4471 do_determine_type(Gogo
* gogo
, const Type_context
*)
4472 { this->channel_
->determine_type_no_context(gogo
); }
4475 do_check_types(Gogo
*);
4480 return Expression::make_receive(this->channel_
->copy(), this->location());
4484 do_inlining_cost() const
4488 do_must_eval_in_order() const
4492 do_get_backend(Translate_context
*);
4495 do_export(Export_function_body
*) const;
4498 do_dump_expression(Ast_dump_context
*) const;
4501 // The channel from which we are receiving.
4502 Expression
* channel_
;
4503 // A temporary reference to the variable storing the received data.
4504 Temporary_statement
* temp_receiver_
;
4507 // An expression that represents a slice value: a struct with value pointer,
4508 // length, and capacity fields.
4510 class Slice_value_expression
: public Expression
4513 Slice_value_expression(Type
* type
, Expression
* valmem
, Expression
* len
,
4514 Expression
* cap
, Location location
)
4515 : Expression(EXPRESSION_SLICE_VALUE
, location
),
4516 type_(type
), valmem_(valmem
), len_(len
), cap_(cap
)
4519 // The memory holding the values in the slice. The type should be a
4520 // pointer to the element value of the slice.
4523 { return this->valmem_
; }
4527 do_traverse(Traverse
*);
4531 { return this->type_
; }
4534 do_determine_type(Gogo
*, const Type_context
*);
4540 do_get_backend(Translate_context
* context
);
4543 do_dump_expression(Ast_dump_context
*) const;
4546 // The type of the slice value.
4548 // The memory holding the values in the slice.
4549 Expression
* valmem_
;
4550 // The length of the slice.
4552 // The capacity of the slice.
4556 // An expression that evaluates to some characteristic of a slice.
4557 // This is used when indexing, bound-checking, or nil checking a slice.
4559 class Slice_info_expression
: public Expression
4562 Slice_info_expression(Expression
* slice
, Slice_info slice_info
,
4564 : Expression(EXPRESSION_SLICE_INFO
, location
),
4565 slice_(slice
), slice_info_(slice_info
)
4568 // The slice operand of this slice info expression.
4571 { return this->slice_
; }
4573 // The info this expression is about.
4576 { return this->slice_info_
; }
4580 do_traverse(Traverse
* traverse
)
4581 { return Expression::traverse(&this->slice_
, traverse
); }
4587 do_determine_type(Gogo
* gogo
, const Type_context
*)
4588 { this->slice_
->determine_type_no_context(gogo
); }
4593 return new Slice_info_expression(this->slice_
->copy(), this->slice_info_
,
4598 do_get_backend(Translate_context
* context
);
4601 do_dump_expression(Ast_dump_context
*) const;
4604 do_issue_nil_check()
4605 { this->slice_
->issue_nil_check(); }
4608 // The slice for which we are getting information.
4610 // What information we want.
4611 Slice_info slice_info_
;
4614 // Conditional expressions.
4616 class Conditional_expression
: public Expression
4619 Conditional_expression(Expression
* cond
, Expression
* then_expr
,
4620 Expression
* else_expr
, Location location
)
4621 : Expression(EXPRESSION_CONDITIONAL
, location
),
4622 cond_(cond
), then_(then_expr
), else_(else_expr
)
4627 { return this->cond_
; }
4631 { return this->then_
; }
4635 { return this->else_
; }
4639 do_traverse(Traverse
*);
4645 do_determine_type(Gogo
*, const Type_context
*);
4650 return new Conditional_expression(this->cond_
->copy(), this->then_
->copy(),
4651 this->else_
->copy(), this->location());
4655 do_get_backend(Translate_context
* context
);
4658 do_dump_expression(Ast_dump_context
*) const;
4661 // The condition to be checked.
4663 // The expression to execute if the condition is true.
4665 // The expression to execute if the condition is false.
4669 // Compound expressions.
4671 class Compound_expression
: public Expression
4674 Compound_expression(Expression
* init
, Expression
* expr
, Location location
)
4675 : Expression(EXPRESSION_COMPOUND
, location
), init_(init
), expr_(expr
)
4680 { return this->init_
; }
4684 { return this->expr_
; }
4688 do_traverse(Traverse
*);
4694 do_determine_type(Gogo
*, const Type_context
*);
4699 return new Compound_expression(this->init_
->copy(), this->expr_
->copy(),
4704 do_get_backend(Translate_context
* context
);
4707 do_dump_expression(Ast_dump_context
*) const;
4710 // The expression that is evaluated first and discarded.
4712 // The expression that is evaluated and returned.
4716 // A backend expression. This is a backend expression wrapped in an
4717 // Expression, for convenience during backend generation.
4719 class Backend_expression
: public Expression
4722 Backend_expression(Bexpression
* bexpr
, Type
* type
, Location location
)
4723 : Expression(EXPRESSION_BACKEND
, location
), bexpr_(bexpr
), type_(type
)
4728 do_traverse(Traverse
*);
4730 // For now these are always valid static initializers. If that
4731 // changes we can change this.
4733 do_is_static_initializer() const
4738 { return this->type_
; }
4741 do_determine_type(Gogo
*, const Type_context
*)
4748 do_get_backend(Translate_context
*)
4749 { return this->bexpr_
; }
4752 do_dump_expression(Ast_dump_context
*) const;
4755 // The backend expression we are wrapping.
4756 Bexpression
* bexpr_
;
4757 // The type of the expression;
4761 // A numeric constant. This is used both for untyped constants and
4762 // for constants that have a type.
4764 class Numeric_constant
4768 : classification_(NC_INVALID
), type_(NULL
)
4771 ~Numeric_constant();
4773 Numeric_constant(const Numeric_constant
&);
4775 Numeric_constant
& operator=(const Numeric_constant
&);
4777 // Check equality with another numeric constant.
4779 equals(const Numeric_constant
&) const;
4781 // Set to an unsigned long value.
4783 set_unsigned_long(Type
*, unsigned long);
4785 // Set to an integer value.
4787 set_int(Type
*, const mpz_t
);
4789 // Set to a rune value.
4791 set_rune(Type
*, const mpz_t
);
4793 // Set to a floating point value.
4795 set_float(Type
*, const mpfr_t
);
4797 // Set to a complex value.
4799 set_complex(Type
*, const mpc_t
);
4801 // Mark numeric constant as invalid.
4804 { this->classification_
= NC_INVALID
; }
4809 { return this->classification_
== Numeric_constant::NC_INT
; }
4813 { return this->classification_
== Numeric_constant::NC_RUNE
; }
4817 { return this->classification_
== Numeric_constant::NC_FLOAT
; }
4821 { return this->classification_
== Numeric_constant::NC_COMPLEX
; }
4825 { return this->classification_
== Numeric_constant::NC_INVALID
; }
4827 // Value retrievers. These will initialize the values as well as
4828 // set them. GET_INT is only valid if IS_INT returns true, and
4829 // likewise respectively.
4831 get_int(mpz_t
*) const;
4834 get_rune(mpz_t
*) const;
4837 get_float(mpfr_t
*) const;
4840 get_complex(mpc_t
*) const;
4842 // Codes returned by to_unsigned_long.
4843 enum To_unsigned_long
4845 // Value is integer and fits in unsigned long.
4847 // Value is not integer.
4849 // Value is integer but is negative.
4851 // Value is non-negative integer but does not fit in unsigned
4856 // If the value can be expressed as an integer that fits in an
4857 // unsigned long, set *VAL and return NC_UL_VALID. Otherwise return
4858 // one of the other To_unsigned_long codes.
4860 to_unsigned_long(unsigned long* val
) const;
4862 // If the value can be expressed as an integer that describes the
4863 // size of an object in memory, set *VAL and return true.
4864 // Otherwise, return false. Currently we use int64_t to represent a
4865 // memory size, as in Type::backend_type_size.
4867 to_memory_size(int64_t* val
) const;
4869 // If the value can be expressed as an int, return true and
4870 // initialize and set VAL. This will return false for a value with
4871 // an explicit float or complex type, even if the value is integral.
4873 to_int(mpz_t
* val
) const;
4875 // If the value can be expressed as a float, return true and
4876 // initialize and set VAL.
4878 to_float(mpfr_t
* val
) const;
4880 // If the value can be expressed as a complex, return true and
4881 // initialize and set VR and VI.
4883 to_complex(mpc_t
* val
) const;
4889 // If the constant can be expressed in TYPE, then set the type of
4890 // the constant to TYPE and return true. Otherwise return false,
4891 // and, if ISSUE_ERROR is true, issue an error message. LOCATION is
4892 // the location to use for the error.
4894 set_type(Type
* type
, bool issue_error
, Location location
);
4896 // Return an Expression for this value.
4898 expression(Location
) const;
4900 // Calculate a hash code with a given seed.
4902 hash(unsigned int seed
) const;
4909 mpz_to_unsigned_long(const mpz_t ival
, unsigned long *val
) const;
4912 mpfr_to_unsigned_long(const mpfr_t fval
, unsigned long *val
) const;
4915 mpz_to_memory_size(const mpz_t ival
, int64_t* val
) const;
4918 mpfr_to_memory_size(const mpfr_t fval
, int64_t* val
) const;
4921 check_int_type(Integer_type
*, bool, Location
);
4924 check_float_type(Float_type
*, bool, Location
);
4927 check_complex_type(Complex_type
*, bool, Location
);
4930 is_float_neg_zero(const mpfr_t
, int bits
);
4932 // The kinds of constants.
4942 // The kind of constant.
4943 Classification classification_
;
4947 // If NC_INT or NC_RUNE.
4954 // The type if there is one. This will be NULL for an untyped
4959 // Temporary buffer size for string conversions.
4960 // Also known to the runtime as tmpStringBufSize in runtime/string.go.
4961 static const int tmp_string_buf_size
= 32;
4963 #endif // !defined(GO_EXPRESSIONS_H)