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
;
32 class Enclosed_var_expression
;
33 class Temporary_reference_expression
;
34 class Set_and_use_temporary_expression
;
35 class String_expression
;
36 class Type_conversion_expression
;
37 class Unsafe_type_conversion_expression
;
38 class Unary_expression
;
39 class Binary_expression
;
40 class String_concat_expression
;
41 class Call_expression
;
42 class Builtin_call_expression
;
43 class Call_result_expression
;
44 class Func_expression
;
45 class Func_descriptor_expression
;
46 class Unknown_expression
;
47 class Index_expression
;
48 class Array_index_expression
;
49 class String_index_expression
;
50 class Map_index_expression
;
51 class Bound_method_expression
;
52 class Field_reference_expression
;
53 class Interface_field_reference_expression
;
54 class Allocation_expression
;
55 class Composite_literal_expression
;
56 class Struct_construction_expression
;
57 class Array_construction_expression
;
58 class Fixed_array_construction_expression
;
59 class Slice_construction_expression
;
60 class Map_construction_expression
;
61 class Type_guard_expression
;
62 class Heap_expression
;
63 class Receive_expression
;
64 class Conditional_expression
;
65 class Compound_expression
;
66 class Numeric_constant
;
70 class Temporary_statement
;
72 class Ast_dump_context
;
75 // The precision to use for complex values represented as an mpc_t.
76 const int mpc_precision
= 256;
78 // The base class for all expressions.
83 // The types of expressions.
84 enum Expression_classification
90 EXPRESSION_STRING_CONCAT
,
91 EXPRESSION_CONST_REFERENCE
,
92 EXPRESSION_VAR_REFERENCE
,
93 EXPRESSION_ENCLOSED_VAR_REFERENCE
,
94 EXPRESSION_TEMPORARY_REFERENCE
,
95 EXPRESSION_SET_AND_USE_TEMPORARY
,
97 EXPRESSION_FUNC_REFERENCE
,
98 EXPRESSION_FUNC_DESCRIPTOR
,
99 EXPRESSION_FUNC_CODE_REFERENCE
,
100 EXPRESSION_UNKNOWN_REFERENCE
,
103 EXPRESSION_STRING_INFO
,
110 EXPRESSION_CALL_RESULT
,
111 EXPRESSION_BOUND_METHOD
,
113 EXPRESSION_ARRAY_INDEX
,
114 EXPRESSION_STRING_INDEX
,
115 EXPRESSION_MAP_INDEX
,
117 EXPRESSION_FIELD_REFERENCE
,
118 EXPRESSION_INTERFACE_FIELD_REFERENCE
,
119 EXPRESSION_ALLOCATION
,
120 EXPRESSION_TYPE_GUARD
,
121 EXPRESSION_CONVERSION
,
122 EXPRESSION_UNSAFE_CONVERSION
,
123 EXPRESSION_STRUCT_CONSTRUCTION
,
124 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
,
125 EXPRESSION_SLICE_CONSTRUCTION
,
126 EXPRESSION_MAP_CONSTRUCTION
,
127 EXPRESSION_COMPOSITE_LITERAL
,
130 EXPRESSION_TYPE_DESCRIPTOR
,
131 EXPRESSION_GC_SYMBOL
,
132 EXPRESSION_PTRMASK_SYMBOL
,
133 EXPRESSION_TYPE_INFO
,
134 EXPRESSION_SLICE_INFO
,
135 EXPRESSION_SLICE_VALUE
,
136 EXPRESSION_INTERFACE_INFO
,
137 EXPRESSION_INTERFACE_VALUE
,
138 EXPRESSION_INTERFACE_MTABLE
,
139 EXPRESSION_STRUCT_FIELD_OFFSET
,
140 EXPRESSION_LABEL_ADDR
,
141 EXPRESSION_CONDITIONAL
,
146 Expression(Expression_classification
, Location
);
148 virtual ~Expression();
150 // Make an error expression. This is used when a parse error occurs
151 // to prevent cascading errors.
153 make_error(Location
);
155 // Make an expression which is really a type. This is used during
158 make_type(Type
*, Location
);
160 // Make a unary expression.
162 make_unary(Operator
, Expression
*, Location
);
164 // Make a binary expression.
166 make_binary(Operator
, Expression
*, Expression
*, Location
);
168 // Make a string concatenation expression.
170 make_string_concat(Expression_list
*);
172 // Make a reference to a constant in an expression.
174 make_const_reference(Named_object
*, Location
);
176 // Make a reference to a variable in an expression.
178 make_var_reference(Named_object
*, Location
);
180 // Make a reference to a variable within an enclosing function.
182 make_enclosing_var_reference(Expression
*, Named_object
*, Location
);
184 // Make a reference to a temporary variable. Temporary variables
185 // are always created by a single statement, which is what we use to
187 static Temporary_reference_expression
*
188 make_temporary_reference(Temporary_statement
*, Location
);
190 // Make an expressions which sets a temporary variable and then
191 // evaluates to a reference to that temporary variable. This is
192 // used to set a temporary variable while retaining the order of
194 static Set_and_use_temporary_expression
*
195 make_set_and_use_temporary(Temporary_statement
*, Expression
*, Location
);
197 // Make a sink expression--a reference to the blank identifier _.
201 // Make a reference to a function in an expression. This returns a
202 // pointer to the struct holding the address of the function
203 // followed by any closed-over variables.
205 make_func_reference(Named_object
*, Expression
* closure
, Location
);
207 // Make a function descriptor, an immutable struct with a single
208 // field that points to the function code. This may only be used
209 // with functions that do not have closures. FN is the function for
210 // which we are making the descriptor.
211 static Func_descriptor_expression
*
212 make_func_descriptor(Named_object
* fn
);
214 // Make a reference to the code of a function. This is used to set
215 // descriptor and closure fields.
217 make_func_code_reference(Named_object
*, Location
);
219 // Make a reference to an unknown name. In a correct program this
220 // will always be lowered to a real const/var/func reference.
221 static Unknown_expression
*
222 make_unknown_reference(Named_object
*, Location
);
224 // Make a constant bool expression.
226 make_boolean(bool val
, Location
);
228 // Make a constant string expression.
230 make_string(const std::string
&, Location
);
232 // Make an expression that evaluates to some characteristic of an string.
233 // For simplicity, the enum values must match the field indexes in the
234 // underlying struct.
237 // The underlying data in the string.
239 // The length of the string.
244 make_string_info(Expression
* string
, String_info
, Location
);
246 // Make a character constant expression. TYPE should be NULL for an
249 make_character(const mpz_t
*, Type
*, Location
);
251 // Make a constant integer expression from a multi-precision
252 // integer. TYPE should be NULL for an abstract type.
254 make_integer_z(const mpz_t
*, Type
*, Location
);
256 // Make a constant integer expression from an unsigned long. TYPE
257 // should be NULL for an abstract type.
259 make_integer_ul(unsigned long, Type
*, Location
);
261 // Make a constant integer expression from a signed long. TYPE
262 // should be NULL for an abstract type.
264 make_integer_sl(long, Type
*, Location
);
266 // Make a constant integer expression from an int64_t. TYPE should
267 // be NULL for an abstract type.
269 make_integer_int64(int64_t, Type
*, Location
);
271 // Make a constant float expression. TYPE should be NULL for an
274 make_float(const mpfr_t
*, Type
*, Location
);
276 // Make a constant complex expression. TYPE should be NULL for an
279 make_complex(const mpc_t
*, Type
*, Location
);
281 // Make a nil expression.
285 // Make an iota expression. This is used for the predeclared
290 // Make a call expression.
291 static Call_expression
*
292 make_call(Expression
* func
, Expression_list
* args
, bool is_varargs
,
295 // Make a reference to a specific result of a call expression which
298 make_call_result(Call_expression
*, unsigned int index
);
300 // Make an expression which is a method bound to its first
301 // parameter. METHOD is the method being called, FUNCTION is the
303 static Bound_method_expression
*
304 make_bound_method(Expression
* object
, const Method
* method
,
305 Named_object
* function
, Location
);
307 // Make an index or slice expression. This is a parser expression
308 // which represents LEFT[START:END:CAP]. END may be NULL, meaning an
309 // index rather than a slice. CAP may be NULL, meaning we use the default
310 // capacity of LEFT. At parse time we may not know the type of LEFT.
311 // After parsing this is lowered to an array index, a string index,
314 make_index(Expression
* left
, Expression
* start
, Expression
* end
,
315 Expression
* cap
, Location
);
317 // Make an array index expression. END may be NULL, in which case
318 // this is an lvalue. CAP may be NULL, in which case it defaults
321 make_array_index(Expression
* array
, Expression
* start
, Expression
* end
,
322 Expression
* cap
, Location
);
324 // Make a string index expression. END may be NULL. This is never
327 make_string_index(Expression
* string
, Expression
* start
, Expression
* end
,
330 // Make a map index expression. This is an lvalue.
331 static Map_index_expression
*
332 make_map_index(Expression
* map
, Expression
* val
, Location
);
334 // Make a selector. This is a parser expression which represents
335 // LEFT.NAME. At parse time we may not know the type of the left
338 make_selector(Expression
* left
, const std::string
& name
, Location
);
340 // Make a reference to a field in a struct.
341 static Field_reference_expression
*
342 make_field_reference(Expression
*, unsigned int field_index
, Location
);
344 // Make a reference to a field of an interface, with an associated
347 make_interface_field_reference(Expression
*, const std::string
&,
350 // Make an allocation expression.
352 make_allocation(Type
*, Location
);
354 // Make a type guard expression.
356 make_type_guard(Expression
*, Type
*, Location
);
358 // Make a type cast expression.
360 make_cast(Type
*, Expression
*, Location
);
362 // Make an unsafe type cast expression. This is only used when
363 // passing parameter to builtin functions that are part of the Go
366 make_unsafe_cast(Type
*, Expression
*, Location
);
368 // Make a composite literal. The DEPTH parameter is how far down we
369 // are in a list of composite literals with omitted types. HAS_KEYS
370 // is true if the expression list has keys alternating with values.
371 // ALL_ARE_NAMES is true if all the keys could be struct field
374 make_composite_literal(Type
*, int depth
, bool has_keys
, Expression_list
*,
375 bool all_are_names
, Location
);
377 // Make a struct composite literal.
379 make_struct_composite_literal(Type
*, Expression_list
*, Location
);
381 // Make an array composite literal.
383 make_array_composite_literal(Type
*, Expression_list
*, Location
);
385 // Make a slice composite literal.
386 static Slice_construction_expression
*
387 make_slice_composite_literal(Type
*, Expression_list
*, Location
);
389 // Take an expression and allocate it on the heap.
391 make_heap_expression(Expression
*, Location
);
393 // Make a receive expression. VAL is NULL for a unary receive.
394 static Receive_expression
*
395 make_receive(Expression
* channel
, Location
);
397 // Make an expression which evaluates to the address of the type
398 // descriptor for TYPE.
400 make_type_descriptor(Type
* type
, Location
);
402 // Make an expression which evaluates to the address of the gc
405 make_gc_symbol(Type
* type
);
407 // Make an expression that evaluates to the address of a ptrmask
408 // symbol for TYPE. For most types this will be the same as
409 // make_gc_symbol, but for larger types make_gc_symbol will return a
410 // gcprog while this will return a ptrmask.
412 make_ptrmask_symbol(Type
* type
);
414 // Make an expression which evaluates to some characteristic of a
415 // type. These are only used for type descriptors, so there is no
416 // location parameter.
419 // The size of a value of the type.
421 // The required alignment of a value of the type.
423 // The required alignment of a value of the type when used as a
424 // field in a struct.
425 TYPE_INFO_FIELD_ALIGNMENT
,
426 // The size of the prefix of a value of the type that contains
427 // all the pointers. This is 0 for a type that contains no
428 // pointers. It is always <= TYPE_INFO_SIZE.
429 TYPE_INFO_BACKEND_PTRDATA
,
430 // Like TYPE_INFO_BACKEND_PTRDATA, but the ptrdata value that we
431 // want to store in a type descriptor. They are the same for
432 // most types, but can differ for a type that uses a gcprog.
433 TYPE_INFO_DESCRIPTOR_PTRDATA
437 make_type_info(Type
* type
, Type_info
);
439 // Make an expression that evaluates to some characteristic of a
440 // slice. For simplicity, the enum values must match the field indexes
441 // in the underlying struct.
444 // The underlying data of the slice.
445 SLICE_INFO_VALUE_POINTER
,
446 // The length of the slice.
448 // The capacity of the slice.
453 make_slice_info(Expression
* slice
, Slice_info
, Location
);
455 // Make an expression for a slice value.
457 make_slice_value(Type
*, Expression
* valptr
, Expression
* len
, Expression
* cap
,
460 // Make an expression that evaluates to some characteristic of an
461 // interface. For simplicity, the enum values must match the field indexes
462 // in the underlying struct.
465 // The type descriptor of an empty interface.
466 INTERFACE_INFO_TYPE_DESCRIPTOR
= 0,
467 // The methods of an interface.
468 INTERFACE_INFO_METHODS
= 0,
469 // The first argument to pass to an interface method.
470 INTERFACE_INFO_OBJECT
474 make_interface_info(Expression
* iface
, Interface_info
, Location
);
476 // Make an expression for an interface value.
478 make_interface_value(Type
*, Expression
*, Expression
*, Location
);
480 // Make an expression that builds a reference to the interface method table
481 // for TYPE that satisfies interface ITYPE. IS_POINTER is true if this is a
482 // reference to the interface method table for the pointer receiver type.
484 make_interface_mtable_ref(Interface_type
* itype
, Type
* type
,
485 bool is_pointer
, Location
);
487 // Make an expression which evaluates to the offset of a field in a
488 // struct. This is only used for type descriptors, so there is no
489 // location parameter.
491 make_struct_field_offset(Struct_type
*, const Struct_field
*);
493 // Make an expression which evaluates to the address of an unnamed
496 make_label_addr(Label
*, Location
);
498 // Make a conditional expression.
500 make_conditional(Expression
*, Expression
*, Expression
*, Location
);
502 // Make a compound expression.
504 make_compound(Expression
*, Expression
*, Location
);
506 // Make a backend expression.
508 make_backend(Bexpression
*, Type
*, Location
);
510 enum Nil_check_classification
512 // Use the default policy for deciding if this deref needs a check.
514 // An explicit check is required for this dereference operation.
516 // No check needed for this dereference operation.
517 NIL_CHECK_NOT_NEEDED
,
518 // A type error or error construct was encountered when determining
519 // whether this deref needs an explicit check.
520 NIL_CHECK_ERROR_ENCOUNTERED
523 // Make a dereference expression.
525 make_dereference(Expression
*, Nil_check_classification
, Location
);
527 // Return the expression classification.
528 Expression_classification
529 classification() const
530 { return this->classification_
; }
532 // Return the location of the expression.
535 { return this->location_
; }
537 // Return whether this is a constant expression.
540 { return this->do_is_constant(); }
542 // Return whether this expression can be used as a static
543 // initializer. This is true for an expression that has only
544 // numbers and pointers to global variables or composite literals
545 // that do not require runtime initialization. It is false if we
546 // must generate code to compute this expression when it is used to
547 // initialize a global variable. This is not a language-level
548 // concept, but an implementation-level one. If this expression is
549 // used to initialize a global variable, this is true if we can pass
550 // an initializer to the backend, false if we must generate code to
551 // initialize the variable. It is always safe for this method to
552 // return false, but the resulting code may be less efficient.
554 is_static_initializer() const
555 { return this->do_is_static_initializer(); }
557 // If this is not a numeric constant, return false. If it is one,
558 // return true, and set VAL to hold the value.
560 numeric_constant_value(Numeric_constant
* val
) const
561 { return this->do_numeric_constant_value(val
); }
563 // If this is not a constant expression with string type, return
564 // false. If it is one, return true, and set VAL to the value.
566 string_constant_value(std::string
* val
) const
567 { return this->do_string_constant_value(val
); }
569 // This is called if the value of this expression is being
570 // discarded. This issues warnings about computed values being
571 // unused. This returns true if all is well, false if it issued an
575 { return this->do_discarding_value(); }
577 // Return whether this is an error expression.
579 is_error_expression() const
580 { return this->classification_
== EXPRESSION_ERROR
; }
582 // Return whether this expression really represents a type.
584 is_type_expression() const
585 { return this->classification_
== EXPRESSION_TYPE
; }
587 // If this is a variable reference, return the Var_expression
588 // structure. Otherwise, return NULL. This is a controlled dynamic
592 { return this->convert
<Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
594 const Var_expression
*
595 var_expression() const
596 { return this->convert
<const Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
598 // If this is a enclosed_variable reference, return the
599 // Enclosed_var_expression structure. Otherwise, return NULL.
600 // This is a controlled dynamic cast.
601 Enclosed_var_expression
*
602 enclosed_var_expression()
603 { return this->convert
<Enclosed_var_expression
,
604 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
606 const Enclosed_var_expression
*
607 enclosed_var_expression() const
608 { return this->convert
<const Enclosed_var_expression
,
609 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
612 // If this is a reference to a temporary variable, return the
613 // Temporary_reference_expression. Otherwise, return NULL.
614 Temporary_reference_expression
*
615 temporary_reference_expression()
617 return this->convert
<Temporary_reference_expression
,
618 EXPRESSION_TEMPORARY_REFERENCE
>();
621 // If this is a set-and-use-temporary, return the
622 // Set_and_use_temporary_expression. Otherwise, return NULL.
623 Set_and_use_temporary_expression
*
624 set_and_use_temporary_expression()
626 return this->convert
<Set_and_use_temporary_expression
,
627 EXPRESSION_SET_AND_USE_TEMPORARY
>();
630 // Return whether this is a sink expression.
632 is_sink_expression() const
633 { return this->classification_
== EXPRESSION_SINK
; }
635 // If this is a string expression, return the String_expression
636 // structure. Otherwise, return NULL.
639 { return this->convert
<String_expression
, EXPRESSION_STRING
>(); }
641 // If this is a conversion expression, return the Type_conversion_expression
642 // structure. Otherwise, return NULL.
643 Type_conversion_expression
*
644 conversion_expression()
645 { return this->convert
<Type_conversion_expression
, EXPRESSION_CONVERSION
>(); }
647 // If this is an unsafe conversion expression, return the
648 // Unsafe_type_conversion_expression structure. Otherwise, return NULL.
649 Unsafe_type_conversion_expression
*
650 unsafe_conversion_expression()
652 return this->convert
<Unsafe_type_conversion_expression
,
653 EXPRESSION_UNSAFE_CONVERSION
>();
656 // Return whether this is the expression nil.
658 is_nil_expression() const
659 { return this->classification_
== EXPRESSION_NIL
; }
661 // If this is an indirection through a pointer, return the
662 // expression being pointed through. Otherwise return this.
666 // If this is a unary expression, return the Unary_expression
667 // structure. Otherwise return NULL.
670 { return this->convert
<Unary_expression
, EXPRESSION_UNARY
>(); }
672 // If this is a binary expression, return the Binary_expression
673 // structure. Otherwise return NULL.
676 { return this->convert
<Binary_expression
, EXPRESSION_BINARY
>(); }
678 // If this is a string concatenation expression, return the
679 // String_concat_expression structure. Otherwise, return NULL.
680 String_concat_expression
*
681 string_concat_expression()
683 return this->convert
<String_concat_expression
, EXPRESSION_STRING_CONCAT
>();
686 // If this is a call expression, return the Call_expression
687 // structure. Otherwise, return NULL. This is a controlled dynamic
691 { return this->convert
<Call_expression
, EXPRESSION_CALL
>(); }
693 // If this is a call_result expression, return the Call_result_expression
694 // structure. Otherwise, return NULL. This is a controlled dynamic
696 Call_result_expression
*
697 call_result_expression()
698 { return this->convert
<Call_result_expression
, EXPRESSION_CALL_RESULT
>(); }
700 // If this is an expression which refers to a function, return the
701 // Func_expression structure. Otherwise, return NULL.
704 { return this->convert
<Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
706 const Func_expression
*
707 func_expression() const
708 { return this->convert
<const Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
710 // If this is an expression which refers to an unknown name, return
711 // the Unknown_expression structure. Otherwise, return NULL.
714 { return this->convert
<Unknown_expression
, EXPRESSION_UNKNOWN_REFERENCE
>(); }
716 const Unknown_expression
*
717 unknown_expression() const
719 return this->convert
<const Unknown_expression
,
720 EXPRESSION_UNKNOWN_REFERENCE
>();
723 // If this is an index expression, return the Index_expression
724 // structure. Otherwise, return NULL.
727 { return this->convert
<Index_expression
, EXPRESSION_INDEX
>(); }
729 // If this is an expression which refers to indexing in a array,
730 // return the Array_index_expression structure. Otherwise, return
732 Array_index_expression
*
733 array_index_expression()
734 { return this->convert
<Array_index_expression
, EXPRESSION_ARRAY_INDEX
>(); }
736 // If this is an expression which refers to indexing in a string,
737 // return the String_index_expression structure. Otherwise, return
739 String_index_expression
*
740 string_index_expression()
741 { return this->convert
<String_index_expression
, EXPRESSION_STRING_INDEX
>(); }
743 // If this is an expression which refers to indexing in a map,
744 // return the Map_index_expression structure. Otherwise, return
746 Map_index_expression
*
747 map_index_expression()
748 { return this->convert
<Map_index_expression
, EXPRESSION_MAP_INDEX
>(); }
750 // If this is a bound method expression, return the
751 // Bound_method_expression structure. Otherwise, return NULL.
752 Bound_method_expression
*
753 bound_method_expression()
754 { return this->convert
<Bound_method_expression
, EXPRESSION_BOUND_METHOD
>(); }
756 // If this is a reference to a field in a struct, return the
757 // Field_reference_expression structure. Otherwise, return NULL.
758 Field_reference_expression
*
759 field_reference_expression()
761 return this->convert
<Field_reference_expression
,
762 EXPRESSION_FIELD_REFERENCE
>();
765 // If this is a reference to a field in an interface, return the
766 // Interface_field_reference_expression structure. Otherwise,
768 Interface_field_reference_expression
*
769 interface_field_reference_expression()
771 return this->convert
<Interface_field_reference_expression
,
772 EXPRESSION_INTERFACE_FIELD_REFERENCE
>();
775 // If this is an allocation expression, return the Allocation_expression
776 // structure. Otherwise, return NULL.
777 Allocation_expression
*
778 allocation_expression()
779 { return this->convert
<Allocation_expression
, EXPRESSION_ALLOCATION
>(); }
781 // If this is a general composite literal, return the
782 // Composite_literal_expression structure. Otherwise, return NULL.
783 Composite_literal_expression
*
786 return this->convert
<Composite_literal_expression
,
787 EXPRESSION_COMPOSITE_LITERAL
>();
790 // If this is a struct composite literal, return the
791 // Struct_construction_expression structure. Otherwise, return NULL.
792 Struct_construction_expression
*
795 return this->convert
<Struct_construction_expression
,
796 EXPRESSION_STRUCT_CONSTRUCTION
>();
799 // If this is a array composite literal, return the
800 // Array_construction_expression structure. Otherwise, return NULL.
801 Fixed_array_construction_expression
*
804 return this->convert
<Fixed_array_construction_expression
,
805 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
>();
808 // If this is a slice composite literal, return the
809 // Slice_construction_expression structure. Otherwise, return NULL.
810 Slice_construction_expression
*
813 return this->convert
<Slice_construction_expression
,
814 EXPRESSION_SLICE_CONSTRUCTION
>();
817 // If this is a map composite literal, return the
818 // Map_construction_expression structure. Otherwise, return NULL.
819 Map_construction_expression
*
822 return this->convert
<Map_construction_expression
,
823 EXPRESSION_MAP_CONSTRUCTION
>();
826 // If this is a type guard expression, return the
827 // Type_guard_expression structure. Otherwise, return NULL.
828 Type_guard_expression
*
829 type_guard_expression()
830 { return this->convert
<Type_guard_expression
, EXPRESSION_TYPE_GUARD
>(); }
832 // If this is a heap expression, returhn the Heap_expression structure.
833 // Otherwise, return NULL.
836 { return this->convert
<Heap_expression
, EXPRESSION_HEAP
>(); }
838 // If this is a receive expression, return the Receive_expression
839 // structure. Otherwise, return NULL.
842 { return this->convert
<Receive_expression
, EXPRESSION_RECEIVE
>(); }
844 // If this is a conditional expression, return the Conditional_expression
845 // structure. Otherwise, return NULL.
846 Conditional_expression
*
847 conditional_expression()
848 { return this->convert
<Conditional_expression
, EXPRESSION_CONDITIONAL
>(); }
850 // If this is a compound expression, return the Compound_expression structure.
851 // Otherwise, return NULL.
853 compound_expression()
854 { return this->convert
<Compound_expression
, EXPRESSION_COMPOUND
>(); }
856 // Return true if this is a composite literal.
858 is_composite_literal() const;
860 // Return true if this is a composite literal which is not constant.
862 is_nonconstant_composite_literal() const;
864 // Return true if this is a variable or temporary variable.
868 // Return true if this is a reference to a local variable.
870 is_local_variable() const;
872 // Make the builtin function descriptor type, so that it can be
875 make_func_descriptor_type();
877 // Traverse an expression.
879 traverse(Expression
**, Traverse
*);
881 // Traverse subexpressions of this expression.
883 traverse_subexpressions(Traverse
*);
885 // Lower an expression. This is called immediately after parsing.
886 // FUNCTION is the function we are in; it will be NULL for an
887 // expression initializing a global variable. INSERTER may be used
888 // to insert statements before the statement or initializer
889 // containing this expression; it is normally used to create
890 // temporary variables. IOTA_VALUE is the value that we should give
891 // to any iota expressions. This function must resolve expressions
892 // which could not be fully parsed into their final form. It
893 // returns the same Expression or a new one.
895 lower(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
,
897 { return this->do_lower(gogo
, function
, inserter
, iota_value
); }
899 // Flatten an expression. This is called after order_evaluation.
900 // FUNCTION is the function we are in; it will be NULL for an
901 // expression initializing a global variable. INSERTER may be used
902 // to insert statements before the statement or initializer
903 // containing this expression; it is normally used to create
904 // temporary variables. This function must resolve expressions
905 // which could not be fully parsed into their final form. It
906 // returns the same Expression or a new one.
908 flatten(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
)
909 { return this->do_flatten(gogo
, function
, inserter
); }
911 // Determine the real type of an expression with abstract integer,
912 // floating point, or complex type. TYPE_CONTEXT describes the
915 determine_type(const Type_context
*);
917 // Check types in an expression.
919 check_types(Gogo
* gogo
)
920 { this->do_check_types(gogo
); }
922 // Determine the type when there is no context.
924 determine_type_no_context();
926 // Return the current type of the expression. This may be changed
927 // by determine_type.
930 { return this->do_type(); }
932 // Return a copy of an expression.
935 { return this->do_copy(); }
937 // Return whether the expression is addressable--something which may
938 // be used as the operand of the unary & operator.
940 is_addressable() const
941 { return this->do_is_addressable(); }
943 // Note that we are taking the address of this expression. ESCAPES
944 // is true if this address escapes the current function.
946 address_taken(bool escapes
)
947 { this->do_address_taken(escapes
); }
949 // Note that a nil check must be issued for this expression.
952 { this->do_issue_nil_check(); }
954 // Return whether this expression must be evaluated in order
955 // according to the order of evaluation rules. This is basically
956 // true of all expressions with side-effects.
958 must_eval_in_order() const
959 { return this->do_must_eval_in_order(); }
961 // Return whether subexpressions of this expression must be
962 // evaluated in order. This is true of index expressions and
963 // pointer indirections. This sets *SKIP to the number of
964 // subexpressions to skip during traversing, as index expressions
965 // only requiring moving the index, not the array.
967 must_eval_subexpressions_in_order(int* skip
) const
970 return this->do_must_eval_subexpressions_in_order(skip
);
973 // Return the backend representation for this expression.
975 get_backend(Translate_context
*);
977 // Return an expression handling any conversions which must be done during
980 convert_for_assignment(Gogo
*, Type
* lhs_type
, Expression
* rhs
,
983 // Return an expression converting a value of one interface type to another
984 // interface type. If FOR_TYPE_GUARD is true this is for a type
987 convert_interface_to_interface(Type
* lhs_type
,
988 Expression
* rhs
, bool for_type_guard
,
991 // Return a backend expression implementing the comparison LEFT OP RIGHT.
992 // TYPE is the type of both sides.
994 comparison(Translate_context
*, Type
* result_type
, Operator op
,
995 Expression
* left
, Expression
* right
, Location
);
997 // Return the backend expression for the numeric constant VAL.
999 backend_numeric_constant_expression(Translate_context
*,
1000 Numeric_constant
* val
);
1002 // Export the expression. This is only used for constants. It will
1003 // be used for things like values of named constants and sizes of
1006 export_expression(Export
* exp
) const
1007 { this->do_export(exp
); }
1009 // Import an expression.
1011 import_expression(Import
*);
1013 // Return an expression which checks that VAL, of arbitrary integer type,
1014 // is non-negative and is not more than the maximum integer value.
1016 check_bounds(Expression
* val
, Location
);
1018 // Dump an expression to a dump constext.
1020 dump_expression(Ast_dump_context
*) const;
1023 // May be implemented by child class: traverse the expressions.
1025 do_traverse(Traverse
*);
1027 // Return a lowered expression.
1029 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
1032 // Return a flattened expression.
1034 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*)
1038 // Return whether this is a constant expression.
1040 do_is_constant() const
1043 // Return whether this expression can be used as a constant
1046 do_is_static_initializer() const
1049 // Return whether this is a constant expression of numeric type, and
1050 // set the Numeric_constant to the value.
1052 do_numeric_constant_value(Numeric_constant
*) const
1055 // Return whether this is a constant expression of string type, and
1056 // set VAL to the value.
1058 do_string_constant_value(std::string
*) const
1061 // Called by the parser if the value is being discarded.
1063 do_discarding_value();
1065 // Child class holds type.
1069 // Child class implements determining type information.
1071 do_determine_type(const Type_context
*) = 0;
1073 // Child class implements type checking if needed.
1075 do_check_types(Gogo
*)
1078 // Child class implements copying.
1082 // Child class implements whether the expression is addressable.
1084 do_is_addressable() const
1087 // Child class implements taking the address of an expression.
1089 do_address_taken(bool)
1092 // Child class implements issuing a nil check if the address is taken.
1094 do_issue_nil_check()
1097 // Child class implements whether this expression must be evaluated
1100 do_must_eval_in_order() const
1103 // Child class implements whether this expressions requires that
1104 // subexpressions be evaluated in order. The child implementation
1105 // may set *SKIP if it should be non-zero.
1107 do_must_eval_subexpressions_in_order(int* /* skip */) const
1110 // Child class implements conversion to backend representation.
1111 virtual Bexpression
*
1112 do_get_backend(Translate_context
*) = 0;
1114 // Child class implements export.
1116 do_export(Export
*) const;
1118 // For children to call to give an error for an unused value.
1120 unused_value_error();
1122 // For children to call when they detect that they are in error.
1126 // For children to call to report an error conveniently.
1128 report_error(const char*);
1130 // Child class implements dumping to a dump context.
1132 do_dump_expression(Ast_dump_context
*) const = 0;
1134 // Varargs lowering creates a slice object (unnamed compiler temp)
1135 // to contain the variable length collection of values. The enum
1136 // below tells the lowering routine whether it can mark that temp
1137 // as non-escaping or not. For general varargs calls it is not always
1138 // safe to stack-allocated the storage, but for specific cases (ex:
1139 // call to append()) it is legal.
1140 enum Slice_storage_escape_disp
1142 SLICE_STORAGE_MAY_ESCAPE
,
1143 SLICE_STORAGE_DOES_NOT_ESCAPE
1147 // Convert to the desired statement classification, or return NULL.
1148 // This is a controlled dynamic cast.
1149 template<typename Expression_class
,
1150 Expression_classification expr_classification
>
1154 return (this->classification_
== expr_classification
1155 ? static_cast<Expression_class
*>(this)
1159 template<typename Expression_class
,
1160 Expression_classification expr_classification
>
1161 const Expression_class
*
1164 return (this->classification_
== expr_classification
1165 ? static_cast<const Expression_class
*>(this)
1170 convert_type_to_interface(Type
*, Expression
*, Location
);
1173 get_interface_type_descriptor(Expression
*);
1176 convert_interface_to_type(Type
*, Expression
*, Location
);
1178 // The expression classification.
1179 Expression_classification classification_
;
1180 // The location in the input file.
1184 // A list of Expressions.
1186 class Expression_list
1193 // Return whether the list is empty.
1196 { return this->entries_
.empty(); }
1198 // Return the number of entries in the list.
1201 { return this->entries_
.size(); }
1203 // Add an entry to the end of the list.
1205 push_back(Expression
* expr
)
1206 { this->entries_
.push_back(expr
); }
1209 append(Expression_list
* add
)
1210 { this->entries_
.insert(this->entries_
.end(), add
->begin(), add
->end()); }
1212 // Reserve space in the list.
1214 reserve(size_t size
)
1215 { this->entries_
.reserve(size
); }
1217 // Traverse the expressions in the list.
1219 traverse(Traverse
*);
1225 // Return true if the list contains an error expression.
1227 contains_error() const;
1229 // Retrieve an element by index.
1232 { return this->entries_
.at(i
); }
1234 // Return the first and last elements.
1237 { return this->entries_
.front(); }
1241 { return this->entries_
.front(); }
1245 { return this->entries_
.back(); }
1249 { return this->entries_
.back(); }
1253 typedef std::vector
<Expression
*>::iterator iterator
;
1254 typedef std::vector
<Expression
*>::const_iterator const_iterator
;
1258 { return this->entries_
.begin(); }
1262 { return this->entries_
.begin(); }
1266 { return this->entries_
.end(); }
1270 { return this->entries_
.end(); }
1275 { this->entries_
.erase(p
); }
1278 std::vector
<Expression
*> entries_
;
1281 // An abstract base class for an expression which is only used by the
1282 // parser, and is lowered in the lowering pass.
1284 class Parser_expression
: public Expression
1287 Parser_expression(Expression_classification classification
,
1289 : Expression(classification
, location
)
1294 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int) = 0;
1300 do_determine_type(const Type_context
*)
1301 { go_unreachable(); }
1304 do_check_types(Gogo
*)
1305 { go_unreachable(); }
1308 do_get_backend(Translate_context
*)
1309 { go_unreachable(); }
1312 // An expression which is simply a variable.
1314 class Var_expression
: public Expression
1317 Var_expression(Named_object
* variable
, Location location
)
1318 : Expression(EXPRESSION_VAR_REFERENCE
, location
),
1322 // Return the variable.
1324 named_object() const
1325 { return this->variable_
; }
1329 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1335 do_determine_type(const Type_context
*);
1342 do_is_addressable() const
1346 do_address_taken(bool);
1349 do_get_backend(Translate_context
*);
1352 do_dump_expression(Ast_dump_context
*) const;
1355 // The variable we are referencing.
1356 Named_object
* variable_
;
1359 // A reference to a variable within an enclosing function.
1361 class Enclosed_var_expression
: public Expression
1364 Enclosed_var_expression(Expression
* reference
, Named_object
* variable
,
1366 : Expression(EXPRESSION_ENCLOSED_VAR_REFERENCE
, location
),
1367 reference_(reference
), variable_(variable
)
1370 // The reference to the enclosed variable. This will be an indirection of the
1371 // the field stored within closure variable.
1374 { return this->reference_
; }
1376 // The variable being enclosed and referenced.
1379 { return this->variable_
; }
1383 do_traverse(Traverse
*);
1386 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1389 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1393 { return this->reference_
->type(); }
1396 do_determine_type(const Type_context
* context
)
1397 { return this->reference_
->determine_type(context
); }
1404 do_is_addressable() const
1405 { return this->reference_
->is_addressable(); }
1408 do_address_taken(bool escapes
);
1411 do_get_backend(Translate_context
* context
)
1412 { return this->reference_
->get_backend(context
); }
1415 do_dump_expression(Ast_dump_context
*) const;
1418 // The reference to the enclosed variable.
1419 Expression
* reference_
;
1420 // The variable being enclosed.
1421 Named_object
* variable_
;
1424 // A reference to a temporary variable.
1426 class Temporary_reference_expression
: public Expression
1429 Temporary_reference_expression(Temporary_statement
* statement
,
1431 : Expression(EXPRESSION_TEMPORARY_REFERENCE
, location
),
1432 statement_(statement
), is_lvalue_(false)
1435 // The temporary that this expression refers to.
1436 Temporary_statement
*
1438 { return this->statement_
; }
1440 // Indicate that this reference appears on the left hand side of an
1441 // assignment statement.
1444 { this->is_lvalue_
= true; }
1451 do_determine_type(const Type_context
*)
1456 { return make_temporary_reference(this->statement_
, this->location()); }
1459 do_is_addressable() const
1463 do_address_taken(bool);
1466 do_get_backend(Translate_context
*);
1469 do_dump_expression(Ast_dump_context
*) const;
1472 // The statement where the temporary variable is defined.
1473 Temporary_statement
* statement_
;
1474 // Whether this reference appears on the left hand side of an
1475 // assignment statement.
1479 // Set and use a temporary variable.
1481 class Set_and_use_temporary_expression
: public Expression
1484 Set_and_use_temporary_expression(Temporary_statement
* statement
,
1485 Expression
* expr
, Location location
)
1486 : Expression(EXPRESSION_SET_AND_USE_TEMPORARY
, location
),
1487 statement_(statement
), expr_(expr
)
1490 // Return the temporary.
1491 Temporary_statement
*
1493 { return this->statement_
; }
1495 // Return the expression.
1498 { return this->expr_
; }
1502 do_traverse(Traverse
* traverse
)
1503 { return Expression::traverse(&this->expr_
, traverse
); }
1509 do_determine_type(const Type_context
*);
1514 return make_set_and_use_temporary(this->statement_
, this->expr_
,
1519 do_is_addressable() const
1523 do_address_taken(bool);
1526 do_get_backend(Translate_context
*);
1529 do_dump_expression(Ast_dump_context
*) const;
1532 // The statement where the temporary variable is defined.
1533 Temporary_statement
* statement_
;
1534 // The expression to assign to the temporary.
1538 // A string expression.
1540 class String_expression
: public Expression
1543 String_expression(const std::string
& val
, Location location
)
1544 : Expression(EXPRESSION_STRING
, location
),
1545 val_(val
), type_(NULL
)
1550 { return this->val_
; }
1557 do_is_constant() const
1561 do_is_static_initializer() const
1565 do_string_constant_value(std::string
* val
) const
1575 do_determine_type(const Type_context
*);
1582 do_get_backend(Translate_context
*);
1584 // Write string literal to a string dump.
1586 export_string(String_dump
* exp
, const String_expression
* str
);
1589 do_export(Export
*) const;
1592 do_dump_expression(Ast_dump_context
*) const;
1595 // The string value. This is immutable.
1596 const std::string val_
;
1597 // The type as determined by context.
1601 // A type conversion expression.
1603 class Type_conversion_expression
: public Expression
1606 Type_conversion_expression(Type
* type
, Expression
* expr
,
1608 : Expression(EXPRESSION_CONVERSION
, location
),
1609 type_(type
), expr_(expr
), may_convert_function_types_(false)
1612 // Return the type to which we are converting.
1615 { return this->type_
; }
1617 // Return the expression which we are converting.
1620 { return this->expr_
; }
1622 // Permit converting from one function type to another. This is
1623 // used internally for method expressions.
1625 set_may_convert_function_types()
1627 this->may_convert_function_types_
= true;
1630 // Import a type conversion expression.
1636 do_traverse(Traverse
* traverse
);
1639 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1642 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1645 do_is_constant() const;
1648 do_is_static_initializer() const;
1651 do_numeric_constant_value(Numeric_constant
*) const;
1654 do_string_constant_value(std::string
*) const;
1658 { return this->type_
; }
1661 do_determine_type(const Type_context
*);
1664 do_check_types(Gogo
*);
1669 return new Type_conversion_expression(this->type_
, this->expr_
->copy(),
1674 do_get_backend(Translate_context
* context
);
1677 do_export(Export
*) const;
1680 do_dump_expression(Ast_dump_context
*) const;
1683 // The type to convert to.
1685 // The expression to convert.
1687 // True if this is permitted to convert function types. This is
1688 // used internally for method expressions.
1689 bool may_convert_function_types_
;
1692 // An unsafe type conversion, used to pass values to builtin functions.
1694 class Unsafe_type_conversion_expression
: public Expression
1697 Unsafe_type_conversion_expression(Type
* type
, Expression
* expr
,
1699 : Expression(EXPRESSION_UNSAFE_CONVERSION
, location
),
1700 type_(type
), expr_(expr
)
1705 { return this->expr_
; }
1709 do_traverse(Traverse
* traverse
);
1712 do_is_static_initializer() const;
1716 { return this->type_
; }
1719 do_determine_type(const Type_context
*)
1720 { this->expr_
->determine_type_no_context(); }
1725 return new Unsafe_type_conversion_expression(this->type_
,
1726 this->expr_
->copy(),
1731 do_get_backend(Translate_context
*);
1734 do_dump_expression(Ast_dump_context
*) const;
1737 // The type to convert to.
1739 // The expression to convert.
1743 // A Unary expression.
1745 class Unary_expression
: public Expression
1748 Unary_expression(Operator op
, Expression
* expr
, Location location
)
1749 : Expression(EXPRESSION_UNARY
, location
),
1750 op_(op
), escapes_(true), create_temp_(false), is_gc_root_(false),
1751 is_slice_init_(false), expr_(expr
),
1752 issue_nil_check_(NIL_CHECK_DEFAULT
)
1755 // Return the operator.
1758 { return this->op_
; }
1760 // Return the operand.
1763 { return this->expr_
; }
1765 // Record that an address expression does not escape.
1767 set_does_not_escape()
1769 go_assert(this->op_
== OPERATOR_AND
);
1770 this->escapes_
= false;
1773 // Record that this is an address expression which should create a
1774 // temporary variable if necessary. This is used for method calls.
1778 go_assert(this->op_
== OPERATOR_AND
);
1779 this->create_temp_
= true;
1782 // Record that this is an address expression of a GC root, which is a
1783 // mutable composite literal. This used for registering GC variables.
1787 go_assert(this->op_
== OPERATOR_AND
);
1788 this->is_gc_root_
= true;
1791 // Record that this is an address expression of a slice value initializer,
1792 // which is mutable if the values are not copied to the heap.
1796 go_assert(this->op_
== OPERATOR_AND
);
1797 this->is_slice_init_
= true;
1800 // Call the address_taken method on the operand if necessary.
1802 check_operand_address_taken(Gogo
*);
1804 // Apply unary opcode OP to UNC, setting NC. Return true if this
1805 // could be done, false if not. On overflow, issues an error and
1806 // sets *ISSUED_ERROR.
1808 eval_constant(Operator op
, const Numeric_constant
* unc
,
1809 Location
, Numeric_constant
* nc
, bool *issued_error
);
1814 // Declare that this deref does or does not require an explicit nil check.
1816 set_requires_nil_check(bool needed
)
1818 go_assert(this->op_
== OPERATOR_MULT
);
1820 this->issue_nil_check_
= NIL_CHECK_NEEDED
;
1822 this->issue_nil_check_
= NIL_CHECK_NOT_NEEDED
;
1827 do_traverse(Traverse
* traverse
)
1828 { return Expression::traverse(&this->expr_
, traverse
); }
1831 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1834 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1837 do_is_constant() const;
1840 do_is_static_initializer() const;
1843 do_numeric_constant_value(Numeric_constant
*) const;
1849 do_determine_type(const Type_context
*);
1852 do_check_types(Gogo
*);
1857 return Expression::make_unary(this->op_
, this->expr_
->copy(),
1862 do_must_eval_subexpressions_in_order(int*) const
1863 { return this->op_
== OPERATOR_MULT
; }
1866 do_is_addressable() const
1867 { return this->op_
== OPERATOR_MULT
; }
1870 do_get_backend(Translate_context
*);
1873 do_export(Export
*) const;
1876 do_dump_expression(Ast_dump_context
*) const;
1879 do_issue_nil_check()
1881 if (this->op_
== OPERATOR_MULT
)
1882 this->set_requires_nil_check(true);
1887 base_is_static_initializer(Expression
*);
1889 // Return a determination as to whether this dereference expression
1890 // requires a nil check.
1891 Nil_check_classification
1892 requires_nil_check(Gogo
*);
1894 // The unary operator to apply.
1896 // Normally true. False if this is an address expression which does
1897 // not escape the current function.
1899 // True if this is an address expression which should create a
1900 // temporary variable if necessary.
1902 // True if this is an address expression for a GC root. A GC root is a
1903 // special struct composite literal that is mutable when addressed, meaning
1904 // it cannot be represented as an immutable_struct in the backend.
1906 // True if this is an address expression for a slice value with an immutable
1907 // initializer. The initializer for a slice's value pointer has an array
1908 // type, meaning it cannot be represented as an immutable_struct in the
1910 bool is_slice_init_
;
1913 // Whether or not to issue a nil check for this expression if its address
1915 Nil_check_classification issue_nil_check_
;
1918 // A binary expression.
1920 class Binary_expression
: public Expression
1923 Binary_expression(Operator op
, Expression
* left
, Expression
* right
,
1925 : Expression(EXPRESSION_BINARY
, location
),
1926 op_(op
), left_(left
), right_(right
), type_(NULL
)
1929 // Return the operator.
1932 { return this->op_
; }
1934 // Return the left hand expression.
1937 { return this->left_
; }
1939 // Return the right hand expression.
1942 { return this->right_
; }
1944 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
1945 // Return true if this could be done, false if not. Issue errors at
1946 // LOCATION as appropriate, and sets *ISSUED_ERROR if it did.
1948 eval_constant(Operator op
, Numeric_constant
* left_nc
,
1949 Numeric_constant
* right_nc
, Location location
,
1950 Numeric_constant
* nc
, bool* issued_error
);
1952 // Compare constants LEFT_NC and RIGHT_NC according to OP, setting
1953 // *RESULT. Return true if this could be done, false if not. Issue
1954 // errors at LOCATION as appropriate.
1956 compare_constant(Operator op
, Numeric_constant
* left_nc
,
1957 Numeric_constant
* right_nc
, Location location
,
1963 // Report an error if OP can not be applied to TYPE. Return whether
1964 // it can. OTYPE is the type of the other operand.
1966 check_operator_type(Operator op
, Type
* type
, Type
* otype
, Location
);
1968 // Set *RESULT_TYPE to the resulting type when OP is applied to
1969 // operands of type LEFT_TYPE and RIGHT_TYPE. Return true on
1970 // success, false on failure.
1972 operation_type(Operator op
, Type
* left_type
, Type
* right_type
,
1973 Type
** result_type
);
1977 do_traverse(Traverse
* traverse
);
1980 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1983 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1986 do_is_constant() const
1987 { return this->left_
->is_constant() && this->right_
->is_constant(); }
1990 do_is_static_initializer() const;
1993 do_numeric_constant_value(Numeric_constant
*) const;
1996 do_discarding_value();
2002 do_determine_type(const Type_context
*);
2005 do_check_types(Gogo
*);
2010 return Expression::make_binary(this->op_
, this->left_
->copy(),
2011 this->right_
->copy(), this->location());
2015 do_get_backend(Translate_context
*);
2018 do_export(Export
*) const;
2021 do_dump_expression(Ast_dump_context
*) const;
2025 cmp_to_bool(Operator op
, int cmp
);
2028 eval_integer(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2029 Location
, Numeric_constant
*);
2032 eval_float(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2033 Location
, Numeric_constant
*);
2036 eval_complex(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2037 Location
, Numeric_constant
*);
2040 compare_integer(const Numeric_constant
*, const Numeric_constant
*, int*);
2043 compare_float(const Numeric_constant
*, const Numeric_constant
*, int*);
2046 compare_complex(const Numeric_constant
*, const Numeric_constant
*, int*);
2049 lower_struct_comparison(Gogo
*, Statement_inserter
*);
2052 lower_array_comparison(Gogo
*, Statement_inserter
*);
2055 lower_interface_value_comparison(Gogo
*, Statement_inserter
*);
2058 lower_compare_to_memcmp(Gogo
*, Statement_inserter
*);
2061 operand_address(Statement_inserter
*, Expression
*);
2063 // The binary operator to apply.
2065 // The left hand side operand.
2067 // The right hand side operand.
2069 // The type of a comparison operation.
2073 // A string concatenation expression. This is a sequence of strings
2074 // added together. It is created when lowering Binary_expression.
2076 class String_concat_expression
: public Expression
2079 String_concat_expression(Expression_list
* exprs
)
2080 : Expression(EXPRESSION_STRING_CONCAT
, exprs
->front()->location()),
2084 // Return the list of string expressions to be concatenated.
2087 { return this->exprs_
; }
2091 do_traverse(Traverse
* traverse
)
2092 { return this->exprs_
->traverse(traverse
); }
2095 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
2099 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2102 do_is_constant() const;
2105 do_is_static_initializer() const;
2111 do_determine_type(const Type_context
*);
2114 do_check_types(Gogo
*);
2118 { return Expression::make_string_concat(this->exprs_
->copy()); }
2121 do_get_backend(Translate_context
*)
2122 { go_unreachable(); }
2125 do_export(Export
*) const
2126 { go_unreachable(); }
2129 do_dump_expression(Ast_dump_context
*) const;
2132 // The string expressions to concatenate.
2133 Expression_list
* exprs_
;
2136 // A call expression. The go statement needs to dig inside this.
2138 class Call_expression
: public Expression
2141 Call_expression(Expression
* fn
, Expression_list
* args
, bool is_varargs
,
2143 : Expression(EXPRESSION_CALL
, location
),
2144 fn_(fn
), args_(args
), type_(NULL
), call_(NULL
), call_temp_(NULL
)
2145 , expected_result_count_(0), is_varargs_(is_varargs
),
2146 varargs_are_lowered_(false), types_are_determined_(false),
2147 is_deferred_(false), is_concurrent_(false), issued_error_(false),
2148 is_multi_value_arg_(false), is_flattened_(false)
2151 // The function to call.
2154 { return this->fn_
; }
2159 { return this->args_
; }
2161 const Expression_list
*
2163 { return this->args_
; }
2165 // Get the function type.
2167 get_function_type() const;
2169 // Return the number of values this call will return.
2171 result_count() const;
2173 // Return the temporary variable that holds the results. This is
2174 // only valid after the expression has been lowered, and is only
2175 // valid for calls which return multiple results.
2176 Temporary_statement
*
2179 // Set the number of results expected from this call. This is used
2180 // when the call appears in a context that expects multiple results,
2181 // such as a, b = f().
2183 set_expected_result_count(size_t);
2185 // Return whether this is a call to the predeclared function
2188 is_recover_call() const;
2190 // Set the argument for a call to recover.
2192 set_recover_arg(Expression
*);
2194 // Whether the last argument is a varargs argument (f(a...)).
2197 { return this->is_varargs_
; }
2199 // Return whether varargs have already been lowered.
2201 varargs_are_lowered() const
2202 { return this->varargs_are_lowered_
; }
2204 // Note that varargs have already been lowered.
2206 set_varargs_are_lowered()
2207 { this->varargs_are_lowered_
= true; }
2209 // Whether this call is being deferred.
2212 { return this->is_deferred_
; }
2214 // Note that the call is being deferred.
2217 { this->is_deferred_
= true; }
2219 // Whether this call is concurrently executed.
2221 is_concurrent() const
2222 { return this->is_concurrent_
; }
2224 // Note that the call is concurrently executed.
2227 { this->is_concurrent_
= true; }
2229 // We have found an error with this call expression; return true if
2230 // we should report it.
2234 // Whether or not this call contains errors, either in the call or the
2235 // arguments to the call.
2237 is_erroneous_call();
2239 // Whether this call returns multiple results that are used as an
2240 // multi-valued argument.
2242 is_multi_value_arg() const
2243 { return this->is_multi_value_arg_
; }
2245 // Note this call is used as a multi-valued argument.
2247 set_is_multi_value_arg()
2248 { this->is_multi_value_arg_
= true; }
2250 // Whether this is a call to builtin function.
2255 // Convert to a Builtin_call_expression, or return NULL.
2256 inline Builtin_call_expression
*
2257 builtin_call_expression();
2261 do_traverse(Traverse
*);
2264 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2267 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2270 do_discarding_value()
2277 do_determine_type(const Type_context
*);
2280 do_check_types(Gogo
*);
2286 do_must_eval_in_order() const;
2288 virtual Bexpression
*
2289 do_get_backend(Translate_context
*);
2292 do_is_recover_call() const;
2295 do_set_recover_arg(Expression
*);
2297 // Let a builtin expression change the argument list.
2299 set_args(Expression_list
* args
)
2300 { this->args_
= args
; }
2302 // Let a builtin expression lower varargs.
2304 lower_varargs(Gogo
*, Named_object
* function
, Statement_inserter
* inserter
,
2305 Type
* varargs_type
, size_t param_count
,
2306 Slice_storage_escape_disp escape_disp
);
2308 // Let a builtin expression check whether types have been
2311 determining_types();
2314 do_dump_expression(Ast_dump_context
*) const;
2318 check_argument_type(int, const Type
*, const Type
*, Location
, bool);
2321 lower_to_builtin(Named_object
**, const char*, int);
2324 interface_method_function(Interface_field_reference_expression
*,
2325 Expression
**, Location
);
2328 set_results(Translate_context
*);
2330 // The function to call.
2332 // The arguments to pass. This may be NULL if there are no
2334 Expression_list
* args_
;
2335 // The type of the expression, to avoid recomputing it.
2337 // The backend expression for the call, used for a call which returns a tuple.
2339 // A temporary variable to store this call if the function returns a tuple.
2340 Temporary_statement
* call_temp_
;
2341 // If not 0, the number of results expected from this call, when
2342 // used in a context that expects multiple values.
2343 size_t expected_result_count_
;
2344 // True if the last argument is a varargs argument (f(a...)).
2346 // True if varargs have already been lowered.
2347 bool varargs_are_lowered_
;
2348 // True if types have been determined.
2349 bool types_are_determined_
;
2350 // True if the call is an argument to a defer statement.
2352 // True if the call is an argument to a go statement.
2353 bool is_concurrent_
;
2354 // True if we reported an error about a mismatch between call
2355 // results and uses. This is to avoid producing multiple errors
2356 // when there are multiple Call_result_expressions.
2358 // True if this call is used as an argument that returns multiple results.
2359 bool is_multi_value_arg_
;
2360 // True if this expression has already been flattened.
2364 // A call expression to a builtin function.
2366 class Builtin_call_expression
: public Call_expression
2369 Builtin_call_expression(Gogo
* gogo
, Expression
* fn
, Expression_list
* args
,
2370 bool is_varargs
, Location location
);
2372 // The builtin functions.
2373 enum Builtin_function_code
2377 // Predeclared builtin functions.
2394 // Builtin functions from the unsafe package.
2400 Builtin_function_code
2402 { return this->code_
; }
2404 // This overrides Call_expression::is_builtin.
2410 // This overrides Call_expression::do_lower.
2412 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2415 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2418 do_is_constant() const;
2421 do_numeric_constant_value(Numeric_constant
*) const;
2424 do_discarding_value();
2430 do_determine_type(const Type_context
*);
2433 do_check_types(Gogo
*);
2439 do_get_backend(Translate_context
*);
2442 do_export(Export
*) const;
2445 do_is_recover_call() const;
2448 do_set_recover_arg(Expression
*);
2458 real_imag_type(Type
*);
2461 complex_type(Type
*);
2464 lower_make(Statement_inserter
*);
2466 Expression
* flatten_append(Gogo
*, Named_object
*, Statement_inserter
*);
2469 check_int_value(Expression
*, bool is_length
, bool* small
);
2471 // A pointer back to the general IR structure. This avoids a global
2472 // variable, or passing it around everywhere.
2474 // The builtin function being called.
2475 Builtin_function_code code_
;
2476 // Used to stop endless loops when the length of an array uses len
2477 // or cap of the array itself.
2479 // Whether the argument is set for calls to BUILTIN_RECOVER.
2480 bool recover_arg_is_set_
;
2483 inline Builtin_call_expression
*
2484 Call_expression::builtin_call_expression()
2486 return (this->is_builtin()
2487 ? static_cast<Builtin_call_expression
*>(this)
2491 // A single result from a call which returns multiple results.
2493 class Call_result_expression
: public Expression
2496 Call_result_expression(Call_expression
* call
, unsigned int index
)
2497 : Expression(EXPRESSION_CALL_RESULT
, call
->location()),
2498 call_(call
), index_(index
)
2503 { return this->call_
; }
2507 { return this->index_
; }
2511 do_traverse(Traverse
*);
2517 do_determine_type(const Type_context
*);
2520 do_check_types(Gogo
*);
2525 return new Call_result_expression(this->call_
->call_expression(),
2530 do_must_eval_in_order() const
2534 do_get_backend(Translate_context
*);
2537 do_dump_expression(Ast_dump_context
*) const;
2540 // The underlying call expression.
2542 // Which result we want.
2543 unsigned int index_
;
2546 // An expression which represents a pointer to a function.
2548 class Func_expression
: public Expression
2551 Func_expression(Named_object
* function
, Expression
* closure
,
2553 : Expression(EXPRESSION_FUNC_REFERENCE
, location
),
2554 function_(function
), closure_(closure
),
2555 runtime_code_(Runtime::NUMBER_OF_FUNCTIONS
)
2558 // Return the object associated with the function.
2560 named_object() const
2561 { return this->function_
; }
2563 // Return the closure for this function. This will return NULL if
2564 // the function has no closure, which is the normal case.
2567 { return this->closure_
; }
2569 // Return whether this is a reference to a runtime function.
2571 is_runtime_function() const
2572 { return this->runtime_code_
!= Runtime::NUMBER_OF_FUNCTIONS
; }
2574 // Return the runtime code for this function expression.
2575 // Returns Runtime::NUMBER_OF_FUNCTIONS if this is not a reference to a
2576 // runtime function.
2578 runtime_code() const
2579 { return this->runtime_code_
; }
2581 // Set the runtime code for this function expression.
2583 set_runtime_code(Runtime::Function code
)
2584 { this->runtime_code_
= code
; }
2586 // Return a backend expression for the code of a function.
2588 get_code_pointer(Gogo
*, Named_object
* function
, Location loc
);
2592 do_traverse(Traverse
*);
2598 do_determine_type(const Type_context
*)
2600 if (this->closure_
!= NULL
)
2601 this->closure_
->determine_type_no_context();
2607 return Expression::make_func_reference(this->function_
,
2608 (this->closure_
== NULL
2610 : this->closure_
->copy()),
2615 do_get_backend(Translate_context
*);
2618 do_dump_expression(Ast_dump_context
*) const;
2621 // The function itself.
2622 Named_object
* function_
;
2623 // A closure. This is normally NULL. For a nested function, it may
2624 // be a struct holding pointers to all the variables referenced by
2625 // this function and defined in enclosing functions.
2626 Expression
* closure_
;
2627 // The runtime code for the referenced function.
2628 Runtime::Function runtime_code_
;
2631 // A function descriptor. A function descriptor is a struct with a
2632 // single field pointing to the function code. This is used for
2633 // functions without closures.
2635 class Func_descriptor_expression
: public Expression
2638 Func_descriptor_expression(Named_object
* fn
);
2640 // Make the function descriptor type, so that it can be converted.
2642 make_func_descriptor_type();
2646 do_traverse(Traverse
*);
2652 do_determine_type(const Type_context
*)
2657 { return Expression::make_func_descriptor(this->fn_
); }
2660 do_is_addressable() const
2664 do_get_backend(Translate_context
*);
2667 do_dump_expression(Ast_dump_context
* context
) const;
2670 // The type of all function descriptors.
2671 static Type
* descriptor_type
;
2673 // The function for which this is the descriptor.
2675 // The descriptor variable.
2679 // A reference to an unknown name.
2681 class Unknown_expression
: public Parser_expression
2684 Unknown_expression(Named_object
* named_object
, Location location
)
2685 : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE
, location
),
2686 named_object_(named_object
), no_error_message_(false),
2687 is_composite_literal_key_(false)
2690 // The associated named object.
2692 named_object() const
2693 { return this->named_object_
; }
2695 // The name of the identifier which was unknown.
2699 // Call this to indicate that we should not give an error if this
2700 // name is never defined. This is used to avoid knock-on errors
2701 // during an erroneous parse.
2703 set_no_error_message()
2704 { this->no_error_message_
= true; }
2706 // Note that this expression is being used as the key in a composite
2707 // literal, so it may be OK if it is not resolved.
2709 set_is_composite_literal_key()
2710 { this->is_composite_literal_key_
= true; }
2712 // Note that this expression should no longer be treated as a
2713 // composite literal key.
2715 clear_is_composite_literal_key()
2716 { this->is_composite_literal_key_
= false; }
2720 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2724 { return new Unknown_expression(this->named_object_
, this->location()); }
2727 do_dump_expression(Ast_dump_context
*) const;
2730 // The unknown name.
2731 Named_object
* named_object_
;
2732 // True if we should not give errors if this is undefined. This is
2733 // used if there was a parse failure.
2734 bool no_error_message_
;
2735 // True if this is the key in a composite literal.
2736 bool is_composite_literal_key_
;
2739 // An index expression. This is lowered to an array index, a string
2740 // index, or a map index.
2742 class Index_expression
: public Parser_expression
2745 Index_expression(Expression
* left
, Expression
* start
, Expression
* end
,
2746 Expression
* cap
, Location location
)
2747 : Parser_expression(EXPRESSION_INDEX
, location
),
2748 left_(left
), start_(start
), end_(end
), cap_(cap
)
2751 // Dump an index expression, i.e. an expression of the form
2752 // expr[expr], expr[expr:expr], or expr[expr:expr:expr] to a dump context.
2754 dump_index_expression(Ast_dump_context
*, const Expression
* expr
,
2755 const Expression
* start
, const Expression
* end
,
2756 const Expression
* cap
);
2760 do_traverse(Traverse
*);
2763 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2768 return new Index_expression(this->left_
->copy(), this->start_
->copy(),
2771 : this->end_
->copy()),
2774 : this->cap_
->copy()),
2779 do_must_eval_subexpressions_in_order(int* skip
) const
2786 do_dump_expression(Ast_dump_context
*) const;
2789 do_issue_nil_check()
2790 { this->left_
->issue_nil_check(); }
2792 // The expression being indexed.
2796 // The second index. This is NULL for an index, non-NULL for a
2799 // The capacity argument. This is NULL for indices and slices that use the
2800 // default capacity, non-NULL for indices and slices that specify the
2805 // An array index. This is used for both indexing and slicing.
2807 class Array_index_expression
: public Expression
2810 Array_index_expression(Expression
* array
, Expression
* start
,
2811 Expression
* end
, Expression
* cap
, Location location
)
2812 : Expression(EXPRESSION_ARRAY_INDEX
, location
),
2813 array_(array
), start_(start
), end_(end
), cap_(cap
), type_(NULL
),
2817 // Return the array.
2820 { return this->array_
; }
2824 { return this->array_
; }
2826 // Return the index of a simple index expression, or the start index
2827 // of a slice expression.
2830 { return this->start_
; }
2834 { return this->start_
; }
2836 // Return the end index of a slice expression. This is NULL for a
2837 // simple index expression.
2840 { return this->end_
; }
2844 { return this->end_
; }
2846 // Return whether this array index expression appears in an lvalue
2847 // (left hand side of assignment) context.
2850 { return this->is_lvalue_
; }
2852 // Update this array index expression to indicate that it appears
2853 // in a left-hand-side or lvalue context.
2856 { this->is_lvalue_
= true; }
2860 do_traverse(Traverse
*);
2863 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2869 do_determine_type(const Type_context
*);
2872 do_check_types(Gogo
*);
2877 return Expression::make_array_index(this->array_
->copy(),
2878 this->start_
->copy(),
2881 : this->end_
->copy()),
2884 : this->cap_
->copy()),
2889 do_must_eval_subexpressions_in_order(int* skip
) const
2896 do_is_addressable() const;
2899 do_address_taken(bool escapes
);
2902 do_issue_nil_check()
2903 { this->array_
->issue_nil_check(); }
2906 do_get_backend(Translate_context
*);
2909 do_dump_expression(Ast_dump_context
*) const;
2912 // The array we are getting a value from.
2914 // The start or only index.
2916 // The end index of a slice. This may be NULL for a simple array
2917 // index, or it may be a nil expression for the length of the array.
2919 // The capacity argument of a slice. This may be NULL for an array index or
2922 // The type of the expression.
2924 // Whether expr appears in an lvalue context.
2928 // A string index. This is used for both indexing and slicing.
2930 class String_index_expression
: public Expression
2933 String_index_expression(Expression
* string
, Expression
* start
,
2934 Expression
* end
, Location location
)
2935 : Expression(EXPRESSION_STRING_INDEX
, location
),
2936 string_(string
), start_(start
), end_(end
)
2939 // Return the string being indexed.
2942 { return this->string_
; }
2946 do_traverse(Traverse
*);
2949 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2955 do_determine_type(const Type_context
*);
2958 do_check_types(Gogo
*);
2963 return Expression::make_string_index(this->string_
->copy(),
2964 this->start_
->copy(),
2967 : this->end_
->copy()),
2972 do_must_eval_subexpressions_in_order(int* skip
) const
2979 do_get_backend(Translate_context
*);
2982 do_dump_expression(Ast_dump_context
*) const;
2985 // The string we are getting a value from.
2986 Expression
* string_
;
2987 // The start or only index.
2989 // The end index of a slice. This may be NULL for a single index,
2990 // or it may be a nil expression for the length of the string.
2994 // An index into a map.
2996 class Map_index_expression
: public Expression
2999 Map_index_expression(Expression
* map
, Expression
* index
,
3001 : Expression(EXPRESSION_MAP_INDEX
, location
),
3002 map_(map
), index_(index
), value_pointer_(NULL
)
3008 { return this->map_
; }
3012 { return this->map_
; }
3014 // Return the index.
3017 { return this->index_
; }
3021 { return this->index_
; }
3023 // Get the type of the map being indexed.
3025 get_map_type() const;
3027 // Return an expression for the map index. This returns an
3028 // expression that evaluates to a pointer to a value in the map. If
3029 // the key is not present in the map, this will return a pointer to
3032 get_value_pointer(Gogo
*);
3036 do_traverse(Traverse
*);
3039 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3045 do_determine_type(const Type_context
*);
3048 do_check_types(Gogo
*);
3053 return Expression::make_map_index(this->map_
->copy(),
3054 this->index_
->copy(),
3059 do_must_eval_subexpressions_in_order(int* skip
) const
3065 // A map index expression is an lvalue but it is not addressable.
3068 do_get_backend(Translate_context
*);
3071 do_dump_expression(Ast_dump_context
*) const;
3074 // The map we are looking into.
3078 // A pointer to the value at this index.
3079 Expression
* value_pointer_
;
3082 // An expression which represents a method bound to its first
3085 class Bound_method_expression
: public Expression
3088 Bound_method_expression(Expression
* expr
, const Method
*method
,
3089 Named_object
* function
, Location location
)
3090 : Expression(EXPRESSION_BOUND_METHOD
, location
),
3091 expr_(expr
), expr_type_(NULL
), method_(method
), function_(function
)
3094 // Return the object which is the first argument.
3097 { return this->expr_
; }
3099 // Return the implicit type of the first argument. This will be
3100 // non-NULL when using a method from an anonymous field without
3101 // using an explicit stub.
3103 first_argument_type() const
3104 { return this->expr_type_
; }
3106 // Return the method.
3109 { return this->method_
; }
3111 // Return the function to call.
3114 { return this->function_
; }
3116 // Set the implicit type of the expression.
3118 set_first_argument_type(Type
* type
)
3119 { this->expr_type_
= type
; }
3121 // Create a thunk to call FUNCTION, for METHOD, when it is used as
3122 // part of a method value.
3123 static Named_object
*
3124 create_thunk(Gogo
*, const Method
* method
, Named_object
* function
);
3128 do_traverse(Traverse
*);
3131 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3137 do_determine_type(const Type_context
*);
3140 do_check_types(Gogo
*);
3145 return new Bound_method_expression(this->expr_
->copy(), this->method_
,
3146 this->function_
, this->location());
3150 do_get_backend(Translate_context
*)
3151 { go_unreachable(); }
3154 do_dump_expression(Ast_dump_context
*) const;
3157 // A mapping from method functions to the thunks we have created for
3159 typedef Unordered_map(Named_object
*, Named_object
*) Method_value_thunks
;
3160 static Method_value_thunks method_value_thunks
;
3162 // The object used to find the method. This is passed to the method
3163 // as the first argument.
3165 // The implicit type of the object to pass to the method. This is
3166 // NULL in the normal case, non-NULL when using a method from an
3167 // anonymous field which does not require a stub.
3170 const Method
* method_
;
3171 // The function to call. This is not the same as
3172 // method_->named_object() when the method has a stub. This will be
3173 // the real function rather than the stub.
3174 Named_object
* function_
;
3177 // A reference to a field in a struct.
3179 class Field_reference_expression
: public Expression
3182 Field_reference_expression(Expression
* expr
, unsigned int field_index
,
3184 : Expression(EXPRESSION_FIELD_REFERENCE
, location
),
3185 expr_(expr
), field_index_(field_index
), implicit_(false), called_fieldtrack_(false)
3188 // Return the struct expression.
3191 { return this->expr_
; }
3193 // Return the field index.
3196 { return this->field_index_
; }
3198 // Return whether this node was implied by an anonymous field.
3201 { return this->implicit_
; }
3204 set_implicit(bool implicit
)
3205 { this->implicit_
= implicit
; }
3207 // Set the struct expression. This is used when parsing.
3209 set_struct_expression(Expression
* expr
)
3211 go_assert(this->expr_
== NULL
);
3217 do_traverse(Traverse
* traverse
)
3218 { return Expression::traverse(&this->expr_
, traverse
); }
3221 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3227 do_determine_type(const Type_context
*)
3228 { this->expr_
->determine_type_no_context(); }
3231 do_check_types(Gogo
*);
3236 return Expression::make_field_reference(this->expr_
->copy(),
3242 do_is_addressable() const
3243 { return this->expr_
->is_addressable(); }
3246 do_address_taken(bool escapes
)
3247 { this->expr_
->address_taken(escapes
); }
3250 do_issue_nil_check()
3251 { this->expr_
->issue_nil_check(); }
3254 do_get_backend(Translate_context
*);
3257 do_dump_expression(Ast_dump_context
*) const;
3260 // The expression we are looking into. This should have a type of
3263 // The zero-based index of the field we are retrieving.
3264 unsigned int field_index_
;
3265 // Whether this node was emitted implicitly for an embedded field,
3266 // that is, expr_ is not the expr_ of the original user node.
3268 // Whether we have already emitted a fieldtrack call.
3269 bool called_fieldtrack_
;
3272 // A reference to a field of an interface.
3274 class Interface_field_reference_expression
: public Expression
3277 Interface_field_reference_expression(Expression
* expr
,
3278 const std::string
& name
,
3280 : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE
, location
),
3281 expr_(expr
), name_(name
)
3284 // Return the expression for the interface object.
3287 { return this->expr_
; }
3289 // Return the name of the method to call.
3292 { return this->name_
; }
3294 // Create a thunk to call the method NAME in TYPE when it is used as
3295 // part of a method value.
3296 static Named_object
*
3297 create_thunk(Gogo
*, Interface_type
* type
, const std::string
& name
);
3299 // Return an expression for the pointer to the function to call.
3303 // Return an expression for the first argument to pass to the interface
3304 // function. This is the real object associated with the interface object.
3306 get_underlying_object();
3310 do_traverse(Traverse
* traverse
);
3313 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3319 do_determine_type(const Type_context
*);
3322 do_check_types(Gogo
*);
3327 return Expression::make_interface_field_reference(this->expr_
->copy(),
3333 do_get_backend(Translate_context
*);
3336 do_dump_expression(Ast_dump_context
*) const;
3339 // A mapping from interface types to a list of thunks we have
3340 // created for methods.
3341 typedef std::vector
<std::pair
<std::string
, Named_object
*> > Method_thunks
;
3342 typedef Unordered_map(Interface_type
*, Method_thunks
*)
3343 Interface_method_thunks
;
3344 static Interface_method_thunks interface_method_thunks
;
3346 // The expression for the interface object. This should have a type
3347 // of interface or pointer to interface.
3349 // The field we are retrieving--the name of the method.
3353 // Implement the builtin function new.
3355 class Allocation_expression
: public Expression
3358 Allocation_expression(Type
* type
, Location location
)
3359 : Expression(EXPRESSION_ALLOCATION
, location
),
3360 type_(type
), allocate_on_stack_(false)
3364 set_allocate_on_stack()
3365 { this->allocate_on_stack_
= true; }
3369 do_traverse(Traverse
*);
3375 do_determine_type(const Type_context
*)
3379 do_check_types(Gogo
*);
3385 do_get_backend(Translate_context
*);
3388 do_dump_expression(Ast_dump_context
*) const;
3391 // The type we are allocating.
3393 // Whether or not this is a stack allocation.
3394 bool allocate_on_stack_
;
3397 // A general composite literal. This is lowered to a type specific
3400 class Composite_literal_expression
: public Parser_expression
3403 Composite_literal_expression(Type
* type
, int depth
, bool has_keys
,
3404 Expression_list
* vals
, bool all_are_names
,
3406 : Parser_expression(EXPRESSION_COMPOSITE_LITERAL
, location
),
3407 type_(type
), depth_(depth
), vals_(vals
), has_keys_(has_keys
),
3408 all_are_names_(all_are_names
), key_path_(std::vector
<bool>(depth
))
3412 // Mark the DEPTH entry of KEY_PATH as containing a key.
3414 update_key_path(size_t depth
)
3416 go_assert(depth
< this->key_path_
.size());
3417 this->key_path_
[depth
] = true;
3422 do_traverse(Traverse
* traverse
);
3425 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3430 Composite_literal_expression
*ret
=
3431 new Composite_literal_expression(this->type_
, this->depth_
,
3433 (this->vals_
== NULL
3435 : this->vals_
->copy()),
3436 this->all_are_names_
,
3438 ret
->key_path_
= this->key_path_
;
3443 do_dump_expression(Ast_dump_context
*) const;
3447 lower_struct(Gogo
*, Type
*);
3453 make_array(Type
*, const std::vector
<unsigned long>*, Expression_list
*);
3456 lower_map(Gogo
*, Named_object
*, Statement_inserter
*, Type
*);
3458 // The type of the composite literal.
3460 // The depth within a list of composite literals within a composite
3461 // literal, when the type is omitted.
3463 // The values to put in the composite literal.
3464 Expression_list
* vals_
;
3465 // If this is true, then VALS_ is a list of pairs: a key and a
3466 // value. In an array initializer, a missing key will be NULL.
3468 // If this is true, then HAS_KEYS_ is true, and every key is a
3469 // simple identifier.
3470 bool all_are_names_
;
3471 // A complement to DEPTH that indicates for each level starting from 0 to
3472 // DEPTH-1 whether or not this composite literal is nested inside of key or
3473 // a value. This is used to decide which type to use when given a map literal
3474 // with omitted key types.
3475 std::vector
<bool> key_path_
;
3478 // Helper/mixin class for struct and array construction expressions;
3479 // encapsulates a list of values plus an optional traversal order
3480 // recording the order in which the values should be visited.
3482 class Ordered_value_list
3485 Ordered_value_list(Expression_list
* vals
)
3486 : vals_(vals
), traverse_order_(NULL
)
3491 { return this->vals_
; }
3494 traverse_vals(Traverse
* traverse
);
3496 // Get the traversal order (may be NULL)
3497 std::vector
<unsigned long>*
3499 { return traverse_order_
; }
3501 // Set the traversal order, used to ensure that we implement the
3502 // order of evaluation rules. Takes ownership of the argument.
3504 set_traverse_order(std::vector
<unsigned long>* traverse_order
)
3505 { this->traverse_order_
= traverse_order
; }
3508 // The list of values, in order of the fields in the struct or in
3509 // order of indices in an array. A NULL value of vals_ means that
3510 // all fields/slots should be zero-initialized; a single NULL entry
3511 // in the list means that the corresponding field or array slot
3512 // should be zero-initialized.
3513 Expression_list
* vals_
;
3514 // If not NULL, the order in which to traverse vals_. This is used
3515 // so that we implement the order of evaluation rules correctly.
3516 std::vector
<unsigned long>* traverse_order_
;
3519 // Construct a struct.
3521 class Struct_construction_expression
: public Expression
,
3522 public Ordered_value_list
3525 Struct_construction_expression(Type
* type
, Expression_list
* vals
,
3527 : Expression(EXPRESSION_STRUCT_CONSTRUCTION
, location
),
3528 Ordered_value_list(vals
),
3532 // Return whether this is a constant initializer.
3534 is_constant_struct() const;
3538 do_traverse(Traverse
* traverse
);
3541 do_is_static_initializer() const;
3545 { return this->type_
; }
3548 do_determine_type(const Type_context
*);
3551 do_check_types(Gogo
*);
3556 Struct_construction_expression
* ret
=
3557 new Struct_construction_expression(this->type_
,
3558 (this->vals() == NULL
3560 : this->vals()->copy()),
3562 if (this->traverse_order() != NULL
)
3563 ret
->set_traverse_order(this->traverse_order());
3568 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3571 do_get_backend(Translate_context
*);
3574 do_export(Export
*) const;
3577 do_dump_expression(Ast_dump_context
*) const;
3580 // The type of the struct to construct.
3584 // Construct an array. This class is not used directly; instead we
3585 // use the child classes, Fixed_array_construction_expression and
3586 // Slice_construction_expression.
3588 class Array_construction_expression
: public Expression
,
3589 public Ordered_value_list
3592 Array_construction_expression(Expression_classification classification
,
3594 const std::vector
<unsigned long>* indexes
,
3595 Expression_list
* vals
, Location location
)
3596 : Expression(classification
, location
),
3597 Ordered_value_list(vals
),
3598 type_(type
), indexes_(indexes
)
3599 { go_assert(indexes
== NULL
|| indexes
->size() == vals
->size()); }
3602 // Return whether this is a constant initializer.
3604 is_constant_array() const;
3606 // Return the number of elements.
3608 element_count() const
3609 { return this->vals() == NULL
? 0 : this->vals()->size(); }
3613 do_traverse(Traverse
* traverse
);
3616 do_is_static_initializer() const;
3620 { return this->type_
; }
3623 do_determine_type(const Type_context
*);
3626 do_check_types(Gogo
*);
3629 do_export(Export
*) const;
3632 const std::vector
<unsigned long>*
3634 { return this->indexes_
; }
3637 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3639 // Get the backend constructor for the array values.
3641 get_constructor(Translate_context
* context
, Btype
* btype
);
3644 do_dump_expression(Ast_dump_context
*) const;
3647 dump_slice_storage_expression(Ast_dump_context
*) const { }
3650 // The type of the array to construct.
3652 // The list of indexes into the array, one for each value. This may
3653 // be NULL, in which case the indexes start at zero and increment.
3654 const std::vector
<unsigned long>* indexes_
;
3657 // Construct a fixed array.
3659 class Fixed_array_construction_expression
:
3660 public Array_construction_expression
3663 Fixed_array_construction_expression(Type
* type
,
3664 const std::vector
<unsigned long>* indexes
,
3665 Expression_list
* vals
, Location location
);
3671 return new Fixed_array_construction_expression(this->type(),
3673 (this->vals() == NULL
3675 : this->vals()->copy()),
3680 do_get_backend(Translate_context
*);
3683 // Construct a slice.
3685 class Slice_construction_expression
: public Array_construction_expression
3688 Slice_construction_expression(Type
* type
,
3689 const std::vector
<unsigned long>* indexes
,
3690 Expression_list
* vals
, Location location
);
3693 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3695 // Record that the storage for this slice (e.g. vals) cannot escape,
3696 // hence it can be stack-allocated.
3698 set_storage_does_not_escape()
3700 this->storage_escapes_
= false;
3704 // Note that taking the address of a slice literal is invalid.
3707 do_traverse(Traverse
* traverse
);
3712 return new Slice_construction_expression(this->type(), this->indexes(),
3713 (this->vals() == NULL
3715 : this->vals()->copy()),
3720 do_get_backend(Translate_context
*);
3723 dump_slice_storage_expression(Ast_dump_context
* ast_dump_context
) const;
3725 // Create an array value for the constructed slice. Invoked during
3726 // flattening if slice storage does not escape, otherwise invoked
3727 // later on during do_get_backend().
3732 // The type of the values in this slice.
3734 // Array value expression, optionally filled in during flattening.
3735 Expression
* array_val_
;
3736 // Slice storage expression, optionally filled in during flattening.
3737 Expression
* slice_storage_
;
3738 // Normally true. Can be set to false if we know that the resulting
3739 // storage for the slice cannot escape.
3740 bool storage_escapes_
;
3745 class Map_construction_expression
: public Expression
3748 Map_construction_expression(Type
* type
, Expression_list
* vals
,
3750 : Expression(EXPRESSION_MAP_CONSTRUCTION
, location
),
3751 type_(type
), vals_(vals
), element_type_(NULL
), constructor_temp_(NULL
)
3752 { go_assert(vals
== NULL
|| vals
->size() % 2 == 0); }
3756 { return this->vals_
; }
3760 do_traverse(Traverse
* traverse
);
3763 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3767 { return this->type_
; }
3770 do_determine_type(const Type_context
*);
3773 do_check_types(Gogo
*);
3778 return new Map_construction_expression(this->type_
,
3779 (this->vals_
== NULL
3781 : this->vals_
->copy()),
3786 do_get_backend(Translate_context
*);
3789 do_export(Export
*) const;
3792 do_dump_expression(Ast_dump_context
*) const;
3795 // The type of the map to construct.
3797 // The list of values.
3798 Expression_list
* vals_
;
3799 // The type of the key-value pair struct for each map element.
3800 Struct_type
* element_type_
;
3801 // A temporary reference to the variable storing the constructor initializer.
3802 Temporary_statement
* constructor_temp_
;
3805 // A type guard expression.
3807 class Type_guard_expression
: public Expression
3810 Type_guard_expression(Expression
* expr
, Type
* type
, Location location
)
3811 : Expression(EXPRESSION_TYPE_GUARD
, location
),
3812 expr_(expr
), type_(type
)
3815 // Return the expression to convert.
3818 { return this->expr_
; }
3820 // Return the type to which to convert.
3823 { return this->type_
; }
3827 do_traverse(Traverse
* traverse
);
3830 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3834 { return this->type_
; }
3837 do_determine_type(const Type_context
*)
3838 { this->expr_
->determine_type_no_context(); }
3841 do_check_types(Gogo
*);
3846 return new Type_guard_expression(this->expr_
->copy(), this->type_
,
3851 do_get_backend(Translate_context
*);
3854 do_dump_expression(Ast_dump_context
*) const;
3857 // The expression to convert.
3859 // The type to which to convert.
3863 // Class Heap_expression.
3865 // When you take the address of an escaping expression, it is allocated
3866 // on the heap. This class implements that.
3868 class Heap_expression
: public Expression
3871 Heap_expression(Expression
* expr
, Location location
)
3872 : Expression(EXPRESSION_HEAP
, location
),
3873 expr_(expr
), allocate_on_stack_(false)
3878 { return this->expr_
; }
3881 set_allocate_on_stack()
3882 { this->allocate_on_stack_
= true; }
3886 do_traverse(Traverse
* traverse
)
3887 { return Expression::traverse(&this->expr_
, traverse
); }
3892 do_determine_type(const Type_context
*)
3893 { this->expr_
->determine_type_no_context(); }
3898 return Expression::make_heap_expression(this->expr_
->copy(),
3903 do_get_backend(Translate_context
*);
3905 // We only export global objects, and the parser does not generate
3906 // this in global scope.
3908 do_export(Export
*) const
3909 { go_unreachable(); }
3912 do_dump_expression(Ast_dump_context
*) const;
3915 // The expression which is being put on the heap.
3917 // Whether or not this is a stack allocation.
3918 bool allocate_on_stack_
;
3921 // A receive expression.
3923 class Receive_expression
: public Expression
3926 Receive_expression(Expression
* channel
, Location location
)
3927 : Expression(EXPRESSION_RECEIVE
, location
),
3928 channel_(channel
), temp_receiver_(NULL
)
3931 // Return the channel.
3934 { return this->channel_
; }
3938 do_traverse(Traverse
* traverse
)
3939 { return Expression::traverse(&this->channel_
, traverse
); }
3942 do_discarding_value()
3949 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3952 do_determine_type(const Type_context
*)
3953 { this->channel_
->determine_type_no_context(); }
3956 do_check_types(Gogo
*);
3961 return Expression::make_receive(this->channel_
->copy(), this->location());
3965 do_must_eval_in_order() const
3969 do_get_backend(Translate_context
*);
3972 do_dump_expression(Ast_dump_context
*) const;
3975 // The channel from which we are receiving.
3976 Expression
* channel_
;
3977 // A temporary reference to the variable storing the received data.
3978 Temporary_statement
* temp_receiver_
;
3981 // Conditional expressions.
3983 class Conditional_expression
: public Expression
3986 Conditional_expression(Expression
* cond
, Expression
* then_expr
,
3987 Expression
* else_expr
, Location location
)
3988 : Expression(EXPRESSION_CONDITIONAL
, location
),
3989 cond_(cond
), then_(then_expr
), else_(else_expr
)
3994 { return this->cond_
; }
3998 do_traverse(Traverse
*);
4004 do_determine_type(const Type_context
*);
4009 return new Conditional_expression(this->cond_
->copy(), this->then_
->copy(),
4010 this->else_
->copy(), this->location());
4014 do_get_backend(Translate_context
* context
);
4017 do_dump_expression(Ast_dump_context
*) const;
4020 // The condition to be checked.
4022 // The expression to execute if the condition is true.
4024 // The expression to execute if the condition is false.
4028 // Compound expressions.
4030 class Compound_expression
: public Expression
4033 Compound_expression(Expression
* init
, Expression
* expr
, Location location
)
4034 : Expression(EXPRESSION_COMPOUND
, location
), init_(init
), expr_(expr
)
4039 { return this->init_
; }
4043 do_traverse(Traverse
*);
4049 do_determine_type(const Type_context
*);
4054 return new Compound_expression(this->init_
->copy(), this->expr_
->copy(),
4059 do_get_backend(Translate_context
* context
);
4062 do_dump_expression(Ast_dump_context
*) const;
4065 // The expression that is evaluated first and discarded.
4067 // The expression that is evaluated and returned.
4071 // A backend expression. This is a backend expression wrapped in an
4072 // Expression, for convenience during backend generation.
4074 class Backend_expression
: public Expression
4077 Backend_expression(Bexpression
* bexpr
, Type
* type
, Location location
)
4078 : Expression(EXPRESSION_BACKEND
, location
), bexpr_(bexpr
), type_(type
)
4083 do_traverse(Traverse
*);
4085 // For now these are always valid static initializers. If that
4086 // changes we can change this.
4088 do_is_static_initializer() const
4093 { return this->type_
; }
4096 do_determine_type(const Type_context
*)
4102 return new Backend_expression(this->bexpr_
, this->type_
, this->location());
4106 do_get_backend(Translate_context
*)
4107 { return this->bexpr_
; }
4110 do_dump_expression(Ast_dump_context
*) const;
4113 // The backend expression we are wrapping.
4114 Bexpression
* bexpr_
;
4115 // The type of the expression;
4119 // A numeric constant. This is used both for untyped constants and
4120 // for constants that have a type.
4122 class Numeric_constant
4126 : classification_(NC_INVALID
), type_(NULL
)
4129 ~Numeric_constant();
4131 Numeric_constant(const Numeric_constant
&);
4133 Numeric_constant
& operator=(const Numeric_constant
&);
4135 // Set to an unsigned long value.
4137 set_unsigned_long(Type
*, unsigned long);
4139 // Set to an integer value.
4141 set_int(Type
*, const mpz_t
);
4143 // Set to a rune value.
4145 set_rune(Type
*, const mpz_t
);
4147 // Set to a floating point value.
4149 set_float(Type
*, const mpfr_t
);
4151 // Set to a complex value.
4153 set_complex(Type
*, const mpc_t
);
4155 // Mark numeric constant as invalid.
4158 { this->classification_
= NC_INVALID
; }
4163 { return this->classification_
== Numeric_constant::NC_INT
; }
4167 { return this->classification_
== Numeric_constant::NC_RUNE
; }
4171 { return this->classification_
== Numeric_constant::NC_FLOAT
; }
4175 { return this->classification_
== Numeric_constant::NC_COMPLEX
; }
4179 { return this->classification_
== Numeric_constant::NC_INVALID
; }
4181 // Value retrievers. These will initialize the values as well as
4182 // set them. GET_INT is only valid if IS_INT returns true, and
4183 // likewise respectively.
4185 get_int(mpz_t
*) const;
4188 get_rune(mpz_t
*) const;
4191 get_float(mpfr_t
*) const;
4194 get_complex(mpc_t
*) const;
4196 // Codes returned by to_unsigned_long.
4197 enum To_unsigned_long
4199 // Value is integer and fits in unsigned long.
4201 // Value is not integer.
4203 // Value is integer but is negative.
4205 // Value is non-negative integer but does not fit in unsigned
4210 // If the value can be expressed as an integer that fits in an
4211 // unsigned long, set *VAL and return NC_UL_VALID. Otherwise return
4212 // one of the other To_unsigned_long codes.
4214 to_unsigned_long(unsigned long* val
) const;
4216 // If the value can be expressed as an integer that describes the
4217 // size of an object in memory, set *VAL and return true.
4218 // Otherwise, return false. Currently we use int64_t to represent a
4219 // memory size, as in Type::backend_type_size.
4221 to_memory_size(int64_t* val
) const;
4223 // If the value can be expressed as an int, return true and
4224 // initialize and set VAL. This will return false for a value with
4225 // an explicit float or complex type, even if the value is integral.
4227 to_int(mpz_t
* val
) const;
4229 // If the value can be expressed as a float, return true and
4230 // initialize and set VAL.
4232 to_float(mpfr_t
* val
) const;
4234 // If the value can be expressed as a complex, return true and
4235 // initialize and set VR and VI.
4237 to_complex(mpc_t
* val
) const;
4243 // If the constant can be expressed in TYPE, then set the type of
4244 // the constant to TYPE and return true. Otherwise return false,
4245 // and, if ISSUE_ERROR is true, issue an error message. LOCATION is
4246 // the location to use for the error.
4248 set_type(Type
* type
, bool issue_error
, Location location
);
4250 // Return an Expression for this value.
4252 expression(Location
) const;
4259 mpz_to_unsigned_long(const mpz_t ival
, unsigned long *val
) const;
4262 mpfr_to_unsigned_long(const mpfr_t fval
, unsigned long *val
) const;
4265 mpz_to_memory_size(const mpz_t ival
, int64_t* val
) const;
4268 mpfr_to_memory_size(const mpfr_t fval
, int64_t* val
) const;
4271 check_int_type(Integer_type
*, bool, Location
);
4274 check_float_type(Float_type
*, bool, Location
);
4277 check_complex_type(Complex_type
*, bool, Location
);
4279 // The kinds of constants.
4289 // The kind of constant.
4290 Classification classification_
;
4294 // If NC_INT or NC_RUNE.
4301 // The type if there is one. This will be NULL for an untyped
4306 #endif // !defined(GO_EXPRESSIONS_H)