1 // expressions.h -- Go frontend expression handling. -*- C++ -*-
3 // Copyright 2009 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
7 #ifndef GO_EXPRESSIONS_H
8 #define GO_EXPRESSIONS_H
17 class Translate_context
;
19 class Statement_inserter
;
30 class Expression_list
;
31 class Const_expression
;
33 class Enclosed_var_expression
;
34 class Temporary_reference_expression
;
35 class Set_and_use_temporary_expression
;
36 class String_expression
;
37 class Type_conversion_expression
;
38 class Unsafe_type_conversion_expression
;
39 class Unary_expression
;
40 class Binary_expression
;
41 class String_concat_expression
;
42 class Call_expression
;
43 class Builtin_call_expression
;
44 class Call_result_expression
;
45 class Func_expression
;
46 class Func_descriptor_expression
;
47 class Unknown_expression
;
48 class Index_expression
;
49 class Array_index_expression
;
50 class String_index_expression
;
51 class Map_index_expression
;
52 class Bound_method_expression
;
53 class Field_reference_expression
;
54 class Interface_field_reference_expression
;
55 class Allocation_expression
;
56 class Composite_literal_expression
;
57 class Struct_construction_expression
;
58 class Array_construction_expression
;
59 class Fixed_array_construction_expression
;
60 class Slice_construction_expression
;
61 class Map_construction_expression
;
62 class Type_guard_expression
;
63 class Heap_expression
;
64 class Receive_expression
;
65 class Slice_value_expression
;
66 class Slice_info_expression
;
67 class Conditional_expression
;
68 class Compound_expression
;
69 class Numeric_constant
;
71 class Export_function_body
;
72 class Import_expression
;
73 class Temporary_statement
;
75 class Ast_dump_context
;
78 // The precision to use for complex values represented as an mpc_t.
79 const int mpc_precision
= 256;
81 // The base class for all expressions.
86 // The types of expressions.
87 enum Expression_classification
93 EXPRESSION_STRING_CONCAT
,
94 EXPRESSION_CONST_REFERENCE
,
95 EXPRESSION_VAR_REFERENCE
,
96 EXPRESSION_ENCLOSED_VAR_REFERENCE
,
97 EXPRESSION_TEMPORARY_REFERENCE
,
98 EXPRESSION_SET_AND_USE_TEMPORARY
,
100 EXPRESSION_FUNC_REFERENCE
,
101 EXPRESSION_FUNC_DESCRIPTOR
,
102 EXPRESSION_FUNC_CODE_REFERENCE
,
103 EXPRESSION_UNKNOWN_REFERENCE
,
106 EXPRESSION_STRING_INFO
,
107 EXPRESSION_STRING_VALUE
,
114 EXPRESSION_CALL_RESULT
,
115 EXPRESSION_BOUND_METHOD
,
117 EXPRESSION_ARRAY_INDEX
,
118 EXPRESSION_STRING_INDEX
,
119 EXPRESSION_MAP_INDEX
,
121 EXPRESSION_FIELD_REFERENCE
,
122 EXPRESSION_INTERFACE_FIELD_REFERENCE
,
123 EXPRESSION_ALLOCATION
,
124 EXPRESSION_TYPE_GUARD
,
125 EXPRESSION_CONVERSION
,
126 EXPRESSION_UNSAFE_CONVERSION
,
127 EXPRESSION_STRUCT_CONSTRUCTION
,
128 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
,
129 EXPRESSION_SLICE_CONSTRUCTION
,
130 EXPRESSION_MAP_CONSTRUCTION
,
131 EXPRESSION_COMPOSITE_LITERAL
,
132 EXPRESSION_COMPOSITE_LITERAL_KEY
,
135 EXPRESSION_TYPE_DESCRIPTOR
,
136 EXPRESSION_GC_SYMBOL
,
137 EXPRESSION_PTRMASK_SYMBOL
,
138 EXPRESSION_TYPE_INFO
,
139 EXPRESSION_SLICE_INFO
,
140 EXPRESSION_SLICE_VALUE
,
141 EXPRESSION_INTERFACE_INFO
,
142 EXPRESSION_INTERFACE_VALUE
,
143 EXPRESSION_INTERFACE_MTABLE
,
144 EXPRESSION_STRUCT_FIELD_OFFSET
,
145 EXPRESSION_LABEL_ADDR
,
146 EXPRESSION_CONDITIONAL
,
151 Expression(Expression_classification
, Location
);
153 virtual ~Expression();
155 // Make an error expression. This is used when a parse error occurs
156 // to prevent cascading errors.
158 make_error(Location
);
160 // Make an expression which is really a type. This is used during
163 make_type(Type
*, Location
);
165 // Make a unary expression.
167 make_unary(Operator
, Expression
*, Location
);
169 // Make a binary expression.
171 make_binary(Operator
, Expression
*, Expression
*, Location
);
173 // Make a string concatenation expression.
175 make_string_concat(Expression_list
*);
177 // Make a reference to a constant in an expression.
179 make_const_reference(Named_object
*, Location
);
181 // Make a reference to a variable in an expression.
183 make_var_reference(Named_object
*, Location
);
185 // Make a reference to a variable within an enclosing function.
187 make_enclosing_var_reference(Expression
*, Named_object
*, Location
);
189 // Make a reference to a temporary variable. Temporary variables
190 // are always created by a single statement, which is what we use to
192 static Temporary_reference_expression
*
193 make_temporary_reference(Temporary_statement
*, Location
);
195 // Make an expressions which sets a temporary variable and then
196 // evaluates to a reference to that temporary variable. This is
197 // used to set a temporary variable while retaining the order of
199 static Set_and_use_temporary_expression
*
200 make_set_and_use_temporary(Temporary_statement
*, Expression
*, Location
);
202 // Make a sink expression--a reference to the blank identifier _.
206 // Make a reference to a function in an expression. This returns a
207 // pointer to the struct holding the address of the function
208 // followed by any closed-over variables.
210 make_func_reference(Named_object
*, Expression
* closure
, Location
);
212 // Make a function descriptor, an immutable struct with a single
213 // field that points to the function code. This may only be used
214 // with functions that do not have closures. FN is the function for
215 // which we are making the descriptor.
216 static Func_descriptor_expression
*
217 make_func_descriptor(Named_object
* fn
);
219 // Make a reference to the code of a function. This is used to set
220 // descriptor and closure fields.
222 make_func_code_reference(Named_object
*, Location
);
224 // Make a reference to an unknown name. In a correct program this
225 // will always be lowered to a real const/var/func reference.
226 static Unknown_expression
*
227 make_unknown_reference(Named_object
*, Location
);
229 // Make a constant bool expression.
231 make_boolean(bool val
, Location
);
233 // Make a constant string expression.
235 make_string(const std::string
&, Location
);
237 // Make a constant string expression with a specific string subtype.
239 make_string_typed(const std::string
&, Type
*, Location
);
241 // Make an expression that evaluates to some characteristic of an string.
242 // For simplicity, the enum values must match the field indexes in the
243 // underlying struct. This returns an lvalue.
246 // The underlying data in the string.
248 // The length of the string.
253 make_string_info(Expression
* string
, String_info
, Location
);
255 // Make an expression for a string value.
257 make_string_value(Expression
* valptr
, Expression
* len
, Location
);
259 // Make a character constant expression. TYPE should be NULL for an
262 make_character(const mpz_t
*, Type
*, Location
);
264 // Make a constant integer expression from a multi-precision
265 // integer. TYPE should be NULL for an abstract type.
267 make_integer_z(const mpz_t
*, Type
*, Location
);
269 // Make a constant integer expression from an unsigned long. TYPE
270 // should be NULL for an abstract type.
272 make_integer_ul(unsigned long, Type
*, Location
);
274 // Make a constant integer expression from a signed long. TYPE
275 // should be NULL for an abstract type.
277 make_integer_sl(long, Type
*, Location
);
279 // Make a constant integer expression from an int64_t. TYPE should
280 // be NULL for an abstract type.
282 make_integer_int64(int64_t, Type
*, Location
);
284 // Make a constant float expression. TYPE should be NULL for an
287 make_float(const mpfr_t
*, Type
*, Location
);
289 // Make a constant complex expression. TYPE should be NULL for an
292 make_complex(const mpc_t
*, Type
*, Location
);
294 // Make a nil expression.
298 // Make an iota expression. This is used for the predeclared
303 // Make a call expression.
304 static Call_expression
*
305 make_call(Expression
* func
, Expression_list
* args
, bool is_varargs
,
308 // Make a reference to a specific result of a call expression which
311 make_call_result(Call_expression
*, unsigned int index
);
313 // Make an expression which is a method bound to its first
314 // parameter. METHOD is the method being called, FUNCTION is the
316 static Bound_method_expression
*
317 make_bound_method(Expression
* object
, const Method
* method
,
318 Named_object
* function
, Location
);
320 // Make an index or slice expression. This is a parser expression
321 // which represents LEFT[START:END:CAP]. END may be NULL, meaning an
322 // index rather than a slice. CAP may be NULL, meaning we use the default
323 // capacity of LEFT. At parse time we may not know the type of LEFT.
324 // After parsing this is lowered to an array index, a string index,
327 make_index(Expression
* left
, Expression
* start
, Expression
* end
,
328 Expression
* cap
, Location
);
330 // Make an array index expression. END may be NULL, in which case
331 // this is an lvalue. CAP may be NULL, in which case it defaults
334 make_array_index(Expression
* array
, Expression
* start
, Expression
* end
,
335 Expression
* cap
, Location
);
337 // Make a string index expression. END may be NULL. This is never
340 make_string_index(Expression
* string
, Expression
* start
, Expression
* end
,
343 // Make a map index expression. This is an lvalue.
344 static Map_index_expression
*
345 make_map_index(Expression
* map
, Expression
* val
, Location
);
347 // Make a selector. This is a parser expression which represents
348 // LEFT.NAME. At parse time we may not know the type of the left
351 make_selector(Expression
* left
, const std::string
& name
, Location
);
353 // Make a reference to a field in a struct.
354 static Field_reference_expression
*
355 make_field_reference(Expression
*, unsigned int field_index
, Location
);
357 // Make a reference to a field of an interface, with an associated
360 make_interface_field_reference(Expression
*, const std::string
&,
363 // Make an allocation expression.
365 make_allocation(Type
*, Location
);
367 // Make a type guard expression.
369 make_type_guard(Expression
*, Type
*, Location
);
371 // Make a type cast expression.
373 make_cast(Type
*, Expression
*, Location
);
375 // Make an unsafe type cast expression. This is only used when
376 // passing parameter to builtin functions that are part of the Go
379 make_unsafe_cast(Type
*, Expression
*, Location
);
381 // Make a composite literal. The DEPTH parameter is how far down we
382 // are in a list of composite literals with omitted types. HAS_KEYS
383 // is true if the expression list has keys alternating with values.
384 // ALL_ARE_NAMES is true if all the keys could be struct field
387 make_composite_literal(Type
*, int depth
, bool has_keys
, Expression_list
*,
388 bool all_are_names
, Location
);
390 // Make a composite literal key.
392 make_composite_literal_key(const std::string
& name
, Location
);
394 // Make a struct composite literal.
396 make_struct_composite_literal(Type
*, Expression_list
*, Location
);
398 // Make an array composite literal.
400 make_array_composite_literal(Type
*, Expression_list
*, Location
);
402 // Make a slice composite literal.
403 static Slice_construction_expression
*
404 make_slice_composite_literal(Type
*, Expression_list
*, Location
);
406 // Take an expression and allocate it on the heap.
408 make_heap_expression(Expression
*, Location
);
410 // Make a receive expression. VAL is NULL for a unary receive.
411 static Receive_expression
*
412 make_receive(Expression
* channel
, Location
);
414 // Make an expression which evaluates to the address of the type
415 // descriptor for TYPE.
417 make_type_descriptor(Type
* type
, Location
);
419 // Make an expression which evaluates to the address of the gc
422 make_gc_symbol(Type
* type
);
424 // Make an expression that evaluates to the address of a ptrmask
425 // symbol for TYPE. For most types this will be the same as
426 // make_gc_symbol, but for larger types make_gc_symbol will return a
427 // gcprog while this will return a ptrmask.
429 make_ptrmask_symbol(Type
* type
);
431 // Make an expression which evaluates to some characteristic of a
432 // type. These are only used for type descriptors, so there is no
433 // location parameter.
436 // The size of a value of the type.
438 // The required alignment of a value of the type.
440 // The required alignment of a value of the type when used as a
441 // field in a struct.
442 TYPE_INFO_FIELD_ALIGNMENT
,
443 // The size of the prefix of a value of the type that contains
444 // all the pointers. This is 0 for a type that contains no
445 // pointers. It is always <= TYPE_INFO_SIZE.
446 TYPE_INFO_BACKEND_PTRDATA
,
447 // Like TYPE_INFO_BACKEND_PTRDATA, but the ptrdata value that we
448 // want to store in a type descriptor. They are the same for
449 // most types, but can differ for a type that uses a gcprog.
450 TYPE_INFO_DESCRIPTOR_PTRDATA
454 make_type_info(Type
* type
, Type_info
);
456 // Make an expression that evaluates to some characteristic of a
457 // slice. For simplicity, the enum values must match the field indexes
458 // in the underlying struct. This returns an lvalue.
461 // The underlying data of the slice.
462 SLICE_INFO_VALUE_POINTER
,
463 // The length of the slice.
465 // The capacity of the slice.
470 make_slice_info(Expression
* slice
, Slice_info
, Location
);
472 // Make an expression for a slice value.
474 make_slice_value(Type
*, Expression
* valptr
, Expression
* len
, Expression
* cap
,
477 // Make an expression that evaluates to some characteristic of an
478 // interface. For simplicity, the enum values must match the field indexes
479 // in the underlying struct. This returns an lvalue.
482 // The type descriptor of an empty interface.
483 INTERFACE_INFO_TYPE_DESCRIPTOR
= 0,
484 // The methods of an interface.
485 INTERFACE_INFO_METHODS
= 0,
486 // The first argument to pass to an interface method.
487 INTERFACE_INFO_OBJECT
491 make_interface_info(Expression
* iface
, Interface_info
, Location
);
493 // Make an expression for an interface value.
495 make_interface_value(Type
*, Expression
*, Expression
*, Location
);
497 // Make an expression that builds a reference to the interface method table
498 // for TYPE that satisfies interface ITYPE. IS_POINTER is true if this is a
499 // reference to the interface method table for the pointer receiver type.
501 make_interface_mtable_ref(Interface_type
* itype
, Type
* type
,
502 bool is_pointer
, Location
);
504 // Make an expression which evaluates to the offset of a field in a
505 // struct. This is only used for type descriptors, so there is no
506 // location parameter.
508 make_struct_field_offset(Struct_type
*, const Struct_field
*);
510 // Make an expression which evaluates to the address of an unnamed
513 make_label_addr(Label
*, Location
);
515 // Make a conditional expression.
517 make_conditional(Expression
*, Expression
*, Expression
*, Location
);
519 // Make a compound expression.
521 make_compound(Expression
*, Expression
*, Location
);
523 // Make a backend expression.
525 make_backend(Bexpression
*, Type
*, Location
);
527 enum Nil_check_classification
529 // Use the default policy for deciding if this deref needs a check.
531 // An explicit check is required for this dereference operation.
533 // No check needed for this dereference operation.
534 NIL_CHECK_NOT_NEEDED
,
535 // A type error or error construct was encountered when determining
536 // whether this deref needs an explicit check.
537 NIL_CHECK_ERROR_ENCOUNTERED
540 // Make a dereference expression.
542 make_dereference(Expression
*, Nil_check_classification
, Location
);
544 // Return the expression classification.
545 Expression_classification
546 classification() const
547 { return this->classification_
; }
549 // Return the location of the expression.
552 { return this->location_
; }
554 // Set the location of an expression and all its subexpressions.
555 // This is used for const declarations where the expression is
556 // copied from an earlier declaration.
558 set_location(Location loc
);
560 // For set_location. This should really be a local class in
561 // Expression, but it needs types defined in gogo.h.
562 friend class Set_location
;
564 // Return whether this is a constant expression.
567 { return this->do_is_constant(); }
569 // Return whether this is the zero value of its type.
571 is_zero_value() const
572 { return this->do_is_zero_value(); }
574 // Return whether this expression can be used as a static
575 // initializer. This is true for an expression that has only
576 // numbers and pointers to global variables or composite literals
577 // that do not require runtime initialization. It is false if we
578 // must generate code to compute this expression when it is used to
579 // initialize a global variable. This is not a language-level
580 // concept, but an implementation-level one. If this expression is
581 // used to initialize a global variable, this is true if we can pass
582 // an initializer to the backend, false if we must generate code to
583 // initialize the variable. It is always safe for this method to
584 // return false, but the resulting code may be less efficient.
586 is_static_initializer() const
587 { return this->do_is_static_initializer(); }
589 // If this is not a numeric constant, return false. If it is one,
590 // return true, and set VAL to hold the value.
592 numeric_constant_value(Numeric_constant
* val
) const
593 { return this->do_numeric_constant_value(val
); }
595 // If this is not a constant expression with string type, return
596 // false. If it is one, return true, and set VAL to the value.
598 string_constant_value(std::string
* val
) const
599 { return this->do_string_constant_value(val
); }
601 // If this is not a constant expression with boolean type, return
602 // false. If it is one, return true, and set VAL to the value.
604 boolean_constant_value(bool* val
) const
605 { return this->do_boolean_constant_value(val
); }
607 // If this is a const reference expression, return the named
608 // object to which the expression refers, otherwise return NULL.
610 named_constant() const;
612 // This is called if the value of this expression is being
613 // discarded. This issues warnings about computed values being
614 // unused. This returns true if all is well, false if it issued an
618 { return this->do_discarding_value(); }
620 // Return whether this is an error expression.
622 is_error_expression() const
623 { return this->classification_
== EXPRESSION_ERROR
; }
625 // Return whether this expression really represents a type.
627 is_type_expression() const
628 { return this->classification_
== EXPRESSION_TYPE
; }
630 // If this is a const reference, return the Const_expression
631 // structure. Otherwise, return NULL. This is a controlled dynamic
635 { return this->convert
<Const_expression
, EXPRESSION_CONST_REFERENCE
>(); }
637 const Const_expression
*
638 const_expression() const
640 return this->convert
<const Const_expression
,
641 EXPRESSION_CONST_REFERENCE
>();
644 // If this is a variable reference, return the Var_expression
645 // structure. Otherwise, return NULL. This is a controlled dynamic
649 { return this->convert
<Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
651 const Var_expression
*
652 var_expression() const
653 { return this->convert
<const Var_expression
, EXPRESSION_VAR_REFERENCE
>(); }
655 // If this is a enclosed_variable reference, return the
656 // Enclosed_var_expression structure. Otherwise, return NULL.
657 // This is a controlled dynamic cast.
658 Enclosed_var_expression
*
659 enclosed_var_expression()
660 { return this->convert
<Enclosed_var_expression
,
661 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
663 const Enclosed_var_expression
*
664 enclosed_var_expression() const
665 { return this->convert
<const Enclosed_var_expression
,
666 EXPRESSION_ENCLOSED_VAR_REFERENCE
>(); }
669 // If this is a reference to a temporary variable, return the
670 // Temporary_reference_expression. Otherwise, return NULL.
671 Temporary_reference_expression
*
672 temporary_reference_expression()
674 return this->convert
<Temporary_reference_expression
,
675 EXPRESSION_TEMPORARY_REFERENCE
>();
678 // If this is a set-and-use-temporary, return the
679 // Set_and_use_temporary_expression. Otherwise, return NULL.
680 Set_and_use_temporary_expression
*
681 set_and_use_temporary_expression()
683 return this->convert
<Set_and_use_temporary_expression
,
684 EXPRESSION_SET_AND_USE_TEMPORARY
>();
687 // Return whether this is a sink expression.
689 is_sink_expression() const
690 { return this->classification_
== EXPRESSION_SINK
; }
692 // If this is a string expression, return the String_expression
693 // structure. Otherwise, return NULL.
696 { return this->convert
<String_expression
, EXPRESSION_STRING
>(); }
698 // If this is a conversion expression, return the Type_conversion_expression
699 // structure. Otherwise, return NULL.
700 Type_conversion_expression
*
701 conversion_expression()
702 { return this->convert
<Type_conversion_expression
, EXPRESSION_CONVERSION
>(); }
704 // If this is an unsafe conversion expression, return the
705 // Unsafe_type_conversion_expression structure. Otherwise, return NULL.
706 Unsafe_type_conversion_expression
*
707 unsafe_conversion_expression()
709 return this->convert
<Unsafe_type_conversion_expression
,
710 EXPRESSION_UNSAFE_CONVERSION
>();
713 // Return whether this is the expression nil.
715 is_nil_expression() const
716 { return this->classification_
== EXPRESSION_NIL
; }
718 // If this is an indirection through a pointer, return the
719 // expression being pointed through. Otherwise return this.
723 // If this is a unary expression, return the Unary_expression
724 // structure. Otherwise return NULL.
727 { return this->convert
<Unary_expression
, EXPRESSION_UNARY
>(); }
729 // If this is a binary expression, return the Binary_expression
730 // structure. Otherwise return NULL.
733 { return this->convert
<Binary_expression
, EXPRESSION_BINARY
>(); }
735 // If this is a string concatenation expression, return the
736 // String_concat_expression structure. Otherwise, return NULL.
737 String_concat_expression
*
738 string_concat_expression()
740 return this->convert
<String_concat_expression
, EXPRESSION_STRING_CONCAT
>();
743 // If this is a call expression, return the Call_expression
744 // structure. Otherwise, return NULL. This is a controlled dynamic
748 { return this->convert
<Call_expression
, EXPRESSION_CALL
>(); }
750 const Call_expression
*
751 call_expression() const
752 { return this->convert
<const Call_expression
, EXPRESSION_CALL
>(); }
754 // If this is a call_result expression, return the Call_result_expression
755 // structure. Otherwise, return NULL. This is a controlled dynamic
757 Call_result_expression
*
758 call_result_expression()
759 { return this->convert
<Call_result_expression
, EXPRESSION_CALL_RESULT
>(); }
761 // If this is an expression which refers to a function, return the
762 // Func_expression structure. Otherwise, return NULL.
765 { return this->convert
<Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
767 const Func_expression
*
768 func_expression() const
769 { return this->convert
<const Func_expression
, EXPRESSION_FUNC_REFERENCE
>(); }
771 // If this is an expression which refers to an unknown name, return
772 // the Unknown_expression structure. Otherwise, return NULL.
775 { return this->convert
<Unknown_expression
, EXPRESSION_UNKNOWN_REFERENCE
>(); }
777 const Unknown_expression
*
778 unknown_expression() const
780 return this->convert
<const Unknown_expression
,
781 EXPRESSION_UNKNOWN_REFERENCE
>();
784 // If this is an index expression, return the Index_expression
785 // structure. Otherwise, return NULL.
788 { return this->convert
<Index_expression
, EXPRESSION_INDEX
>(); }
790 // If this is an expression which refers to indexing in a array,
791 // return the Array_index_expression structure. Otherwise, return
793 Array_index_expression
*
794 array_index_expression()
795 { return this->convert
<Array_index_expression
, EXPRESSION_ARRAY_INDEX
>(); }
797 // If this is an expression which refers to indexing in a string,
798 // return the String_index_expression structure. Otherwise, return
800 String_index_expression
*
801 string_index_expression()
802 { return this->convert
<String_index_expression
, EXPRESSION_STRING_INDEX
>(); }
804 // If this is an expression which refers to indexing in a map,
805 // return the Map_index_expression structure. Otherwise, return
807 Map_index_expression
*
808 map_index_expression()
809 { return this->convert
<Map_index_expression
, EXPRESSION_MAP_INDEX
>(); }
811 // If this is a bound method expression, return the
812 // Bound_method_expression structure. Otherwise, return NULL.
813 Bound_method_expression
*
814 bound_method_expression()
815 { return this->convert
<Bound_method_expression
, EXPRESSION_BOUND_METHOD
>(); }
817 // If this is a reference to a field in a struct, return the
818 // Field_reference_expression structure. Otherwise, return NULL.
819 Field_reference_expression
*
820 field_reference_expression()
822 return this->convert
<Field_reference_expression
,
823 EXPRESSION_FIELD_REFERENCE
>();
826 // If this is a reference to a field in an interface, return the
827 // Interface_field_reference_expression structure. Otherwise,
829 Interface_field_reference_expression
*
830 interface_field_reference_expression()
832 return this->convert
<Interface_field_reference_expression
,
833 EXPRESSION_INTERFACE_FIELD_REFERENCE
>();
836 // If this is an allocation expression, return the Allocation_expression
837 // structure. Otherwise, return NULL.
838 Allocation_expression
*
839 allocation_expression()
840 { return this->convert
<Allocation_expression
, EXPRESSION_ALLOCATION
>(); }
842 // If this is a general composite literal, return the
843 // Composite_literal_expression structure. Otherwise, return NULL.
844 Composite_literal_expression
*
847 return this->convert
<Composite_literal_expression
,
848 EXPRESSION_COMPOSITE_LITERAL
>();
851 // If this is a struct composite literal, return the
852 // Struct_construction_expression structure. Otherwise, return NULL.
853 Struct_construction_expression
*
856 return this->convert
<Struct_construction_expression
,
857 EXPRESSION_STRUCT_CONSTRUCTION
>();
860 // If this is a array composite literal, return the
861 // Array_construction_expression structure. Otherwise, return NULL.
862 Fixed_array_construction_expression
*
865 return this->convert
<Fixed_array_construction_expression
,
866 EXPRESSION_FIXED_ARRAY_CONSTRUCTION
>();
869 // If this is a slice composite literal, return the
870 // Slice_construction_expression structure. Otherwise, return NULL.
871 Slice_construction_expression
*
874 return this->convert
<Slice_construction_expression
,
875 EXPRESSION_SLICE_CONSTRUCTION
>();
878 // If this is a map composite literal, return the
879 // Map_construction_expression structure. Otherwise, return NULL.
880 Map_construction_expression
*
883 return this->convert
<Map_construction_expression
,
884 EXPRESSION_MAP_CONSTRUCTION
>();
887 // If this is a type guard expression, return the
888 // Type_guard_expression structure. Otherwise, return NULL.
889 Type_guard_expression
*
890 type_guard_expression()
891 { return this->convert
<Type_guard_expression
, EXPRESSION_TYPE_GUARD
>(); }
893 // If this is a heap expression, returhn the Heap_expression structure.
894 // Otherwise, return NULL.
897 { return this->convert
<Heap_expression
, EXPRESSION_HEAP
>(); }
899 // If this is a receive expression, return the Receive_expression
900 // structure. Otherwise, return NULL.
903 { return this->convert
<Receive_expression
, EXPRESSION_RECEIVE
>(); }
905 // If this is a slice value expression, return the Slice_valiue_expression
906 // structure. Otherwise, return NULL.
907 Slice_value_expression
*
908 slice_value_expression()
909 { return this->convert
<Slice_value_expression
, EXPRESSION_SLICE_VALUE
>(); }
911 // If this is a conditional expression, return the Conditional_expression
912 // structure. Otherwise, return NULL.
913 Conditional_expression
*
914 conditional_expression()
915 { return this->convert
<Conditional_expression
, EXPRESSION_CONDITIONAL
>(); }
917 // If this is a compound expression, return the Compound_expression structure.
918 // Otherwise, return NULL.
920 compound_expression()
921 { return this->convert
<Compound_expression
, EXPRESSION_COMPOUND
>(); }
923 // If this is a slice info expression, return the
924 // Slice_info_expression structure. Otherwise, return NULL.
925 Slice_info_expression
*
926 slice_info_expression()
928 return this->convert
<Slice_info_expression
, EXPRESSION_SLICE_INFO
>();
931 // Return true if this is a composite literal.
933 is_composite_literal() const;
935 // Return true if this is a composite literal which is not constant.
937 is_nonconstant_composite_literal() const;
939 // Return true if this is a variable or temporary variable.
943 // Return true if this is a reference to a local variable.
945 is_local_variable() const;
947 // Return true if multiple evaluations of this expression are OK.
948 // This is true for simple variable references and constants.
950 is_multi_eval_safe();
952 // Return true if two expressions refer to the same variable or
955 is_same_variable(Expression
*, Expression
*);
957 // Make the builtin function descriptor type, so that it can be
960 make_func_descriptor_type();
962 // Traverse an expression.
964 traverse(Expression
**, Traverse
*);
966 // Traverse subexpressions of this expression.
968 traverse_subexpressions(Traverse
*);
970 // Lower an expression. This is called immediately after parsing.
971 // FUNCTION is the function we are in; it will be NULL for an
972 // expression initializing a global variable. INSERTER may be used
973 // to insert statements before the statement or initializer
974 // containing this expression; it is normally used to create
975 // temporary variables. IOTA_VALUE is the value that we should give
976 // to any iota expressions. This function must resolve expressions
977 // which could not be fully parsed into their final form. It
978 // returns the same Expression or a new one.
980 lower(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
,
982 { return this->do_lower(gogo
, function
, inserter
, iota_value
); }
984 // Flatten an expression. This is called after order_evaluation.
985 // FUNCTION is the function we are in; it will be NULL for an
986 // expression initializing a global variable. INSERTER may be used
987 // to insert statements before the statement or initializer
988 // containing this expression; it is normally used to create
989 // temporary variables. This function must resolve expressions
990 // which could not be fully parsed into their final form. It
991 // returns the same Expression or a new one.
993 flatten(Gogo
* gogo
, Named_object
* function
, Statement_inserter
* inserter
)
994 { return this->do_flatten(gogo
, function
, inserter
); }
996 // Make implicit type conversions explicit.
999 { this->do_add_conversions(); }
1001 // Determine the real type of an expression with abstract integer,
1002 // floating point, or complex type. TYPE_CONTEXT describes the
1005 determine_type(const Type_context
*);
1007 // Check types in an expression.
1009 check_types(Gogo
* gogo
)
1010 { this->do_check_types(gogo
); }
1012 // Determine the type when there is no context.
1014 determine_type_no_context();
1016 // Return the current type of the expression. This may be changed
1017 // by determine_type. This should not be called before the lowering
1018 // pass, unless the is_type_expression method returns true (i.e.,
1019 // this is an EXPRESSION_TYPE).
1022 { return this->do_type(); }
1024 // Return a copy of an expression.
1027 { return this->do_copy(); }
1029 // Return the cost of this statement for inlining purposes.
1031 inlining_cost() const
1032 { return this->do_inlining_cost(); }
1034 // Return whether the expression is addressable--something which may
1035 // be used as the operand of the unary & operator.
1037 is_addressable() const
1038 { return this->do_is_addressable(); }
1040 // Note that we are taking the address of this expression. ESCAPES
1041 // is true if this address escapes the current function.
1043 address_taken(bool escapes
)
1044 { this->do_address_taken(escapes
); }
1046 // Note that a nil check must be issued for this expression.
1049 { this->do_issue_nil_check(); }
1051 // Return whether this expression must be evaluated in order
1052 // according to the order of evaluation rules. This is basically
1053 // true of all expressions with side-effects.
1055 must_eval_in_order() const
1056 { return this->do_must_eval_in_order(); }
1058 // Return whether subexpressions of this expression must be
1059 // evaluated in order. This is true of index expressions and
1060 // pointer indirections. This sets *SKIP to the number of
1061 // subexpressions to skip during traversing, as index expressions
1062 // only requiring moving the index, not the array.
1064 must_eval_subexpressions_in_order(int* skip
) const
1067 return this->do_must_eval_subexpressions_in_order(skip
);
1070 // Return the backend representation for this expression.
1072 get_backend(Translate_context
*);
1074 // Return an expression handling any conversions which must be done during
1077 convert_for_assignment(Gogo
*, Type
* lhs_type
, Expression
* rhs
,
1080 // Return an expression converting a value of one interface type to another
1081 // interface type. If FOR_TYPE_GUARD is true this is for a type
1084 convert_interface_to_interface(Type
* lhs_type
,
1085 Expression
* rhs
, bool for_type_guard
,
1088 // Return an expression for a conversion from a non-interface type to an
1089 // interface type. If ON_STACK is true, it can allocate the storage on
1092 convert_type_to_interface(Type
* lhs_type
, Expression
* rhs
,
1093 bool on_stack
, Location
);
1095 // Return a backend expression implementing the comparison LEFT OP RIGHT.
1096 // TYPE is the type of both sides.
1098 comparison(Translate_context
*, Type
* result_type
, Operator op
,
1099 Expression
* left
, Expression
* right
, Location
);
1101 // Return the backend expression for the numeric constant VAL.
1103 backend_numeric_constant_expression(Translate_context
*,
1104 Numeric_constant
* val
);
1106 // Export the expression.
1108 export_expression(Export_function_body
* efb
) const
1109 { this->do_export(efb
); }
1111 // Import an expression. The location should be used for the
1112 // returned expression. Errors should be reported using the
1113 // Import's location method.
1115 import_expression(Import_expression
*, Location
);
1117 // Insert bounds checks for an index expression.
1119 check_bounds(Expression
* val
, Operator
, Expression
* bound
, Runtime::Function
,
1120 Runtime::Function
, Runtime::Function
, Runtime::Function
,
1121 Statement_inserter
*, Location
);
1123 // Return an expression for constructing a direct interface type from a
1126 pack_direct_iface(Type
*, Expression
*, Location
);
1128 // Return an expression of the underlying pointer for a direct interface
1129 // type (the opposite of pack_direct_iface).
1131 unpack_direct_iface(Expression
*, Location
);
1133 // Return an expression representing the type descriptor field of an
1136 get_interface_type_descriptor(Expression
*);
1138 // Look through the expression of a Slice_value_expression's valmem to
1139 // find an call to makeslice.
1140 static std::pair
<Call_expression
*, Temporary_statement
*>
1141 find_makeslice_call(Expression
*);
1143 // Dump an expression to a dump constext.
1145 dump_expression(Ast_dump_context
*) const;
1148 // May be implemented by child class: traverse the expressions.
1150 do_traverse(Traverse
*);
1152 // Return a lowered expression.
1154 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
1157 // Return a flattened expression.
1159 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*)
1162 // Make implicit type conversions explicit.
1164 do_add_conversions()
1167 // Return whether this is a constant expression.
1169 do_is_constant() const
1172 // Return whether this is the zero value of its type.
1174 do_is_zero_value() const
1177 // Return whether this expression can be used as a constant
1180 do_is_static_initializer() const
1183 // Return whether this is a constant expression of numeric type, and
1184 // set the Numeric_constant to the value.
1186 do_numeric_constant_value(Numeric_constant
*) const
1189 // Return whether this is a constant expression of string type, and
1190 // set VAL to the value.
1192 do_string_constant_value(std::string
*) const
1195 // Return whether this is a constant expression of boolean type, and
1196 // set VAL to the value.
1198 do_boolean_constant_value(bool*) const
1201 // Called by the parser if the value is being discarded.
1203 do_discarding_value();
1205 // Child class holds type.
1209 // Child class implements determining type information.
1211 do_determine_type(const Type_context
*) = 0;
1213 // Child class implements type checking if needed.
1215 do_check_types(Gogo
*)
1218 // Child class implements copying.
1222 // Child class implements determining the cost of this statement for
1223 // inlining. The default cost is high, so we only need to define
1224 // this method for expressions that can be inlined.
1226 do_inlining_cost() const
1227 { return 0x100000; }
1229 // Child class implements whether the expression is addressable.
1231 do_is_addressable() const
1234 // Child class implements taking the address of an expression.
1236 do_address_taken(bool)
1239 // Child class implements issuing a nil check if the address is taken.
1241 do_issue_nil_check()
1244 // Child class implements whether this expression must be evaluated
1247 do_must_eval_in_order() const
1250 // Child class implements whether this expressions requires that
1251 // subexpressions be evaluated in order. The child implementation
1252 // may set *SKIP if it should be non-zero.
1254 do_must_eval_subexpressions_in_order(int* /* skip */) const
1257 // Child class implements conversion to backend representation.
1258 virtual Bexpression
*
1259 do_get_backend(Translate_context
*) = 0;
1261 // Child class implements export.
1263 do_export(Export_function_body
*) const;
1265 // For children to call to give an error for an unused value.
1267 unused_value_error();
1269 // For children to call when they detect that they are in error.
1273 // For children to call to report an error conveniently.
1275 report_error(const char*);
1277 // Write a name to export data.
1279 export_name(Export_function_body
* efb
, const Named_object
*);
1281 // Child class implements dumping to a dump context.
1283 do_dump_expression(Ast_dump_context
*) const = 0;
1285 // Start exporting a type conversion for a constant, if needed.
1287 export_constant_type(Export_function_body
*, Type
*);
1289 // Finish exporting a type conversion for a constant.
1291 finish_export_constant_type(Export_function_body
*, bool);
1293 // Varargs lowering creates a slice object (unnamed compiler temp)
1294 // to contain the variable length collection of values. The enum
1295 // below tells the lowering routine whether it can mark that temp
1296 // as non-escaping or not. For general varargs calls it is not always
1297 // safe to stack-allocated the storage, but for specific cases (ex:
1298 // call to append()) it is legal.
1299 enum Slice_storage_escape_disp
1301 SLICE_STORAGE_MAY_ESCAPE
,
1302 SLICE_STORAGE_DOES_NOT_ESCAPE
1306 // Convert to the desired statement classification, or return NULL.
1307 // This is a controlled dynamic cast.
1308 template<typename Expression_class
,
1309 Expression_classification expr_classification
>
1313 return (this->classification_
== expr_classification
1314 ? static_cast<Expression_class
*>(this)
1318 template<typename Expression_class
,
1319 Expression_classification expr_classification
>
1320 const Expression_class
*
1323 return (this->classification_
== expr_classification
1324 ? static_cast<const Expression_class
*>(this)
1329 convert_interface_to_type(Gogo
*, Type
*, Expression
*, Location
);
1332 import_identifier(Import_function_body
*, Location
);
1335 import_expression_without_suffix(Import_expression
*, Location
);
1337 // The expression classification.
1338 Expression_classification classification_
;
1339 // The location in the input file.
1343 // A list of Expressions.
1345 class Expression_list
1352 // Return whether the list is empty.
1355 { return this->entries_
.empty(); }
1357 // Return the number of entries in the list.
1360 { return this->entries_
.size(); }
1362 // Add an entry to the end of the list.
1364 push_back(Expression
* expr
)
1365 { this->entries_
.push_back(expr
); }
1368 append(Expression_list
* add
)
1369 { this->entries_
.insert(this->entries_
.end(), add
->begin(), add
->end()); }
1371 // Reserve space in the list.
1373 reserve(size_t size
)
1374 { this->entries_
.reserve(size
); }
1376 // Traverse the expressions in the list.
1378 traverse(Traverse
*);
1384 // Return true if the list contains an error expression.
1386 contains_error() const;
1388 // Retrieve an element by index.
1391 { return this->entries_
.at(i
); }
1393 // Return the first and last elements.
1396 { return this->entries_
.front(); }
1400 { return this->entries_
.front(); }
1404 { return this->entries_
.back(); }
1408 { return this->entries_
.back(); }
1412 typedef std::vector
<Expression
*>::iterator iterator
;
1413 typedef std::vector
<Expression
*>::const_iterator const_iterator
;
1417 { return this->entries_
.begin(); }
1421 { return this->entries_
.begin(); }
1425 { return this->entries_
.end(); }
1429 { return this->entries_
.end(); }
1434 { this->entries_
.erase(p
); }
1437 std::vector
<Expression
*> entries_
;
1440 // An abstract base class for an expression which is only used by the
1441 // parser, and is lowered in the lowering pass.
1443 class Parser_expression
: public Expression
1446 Parser_expression(Expression_classification classification
,
1448 : Expression(classification
, location
)
1453 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int) = 0;
1459 do_determine_type(const Type_context
*)
1460 { go_unreachable(); }
1463 do_check_types(Gogo
*)
1464 { go_unreachable(); }
1467 do_get_backend(Translate_context
*)
1468 { go_unreachable(); }
1471 // A reference to a const in an expression.
1473 class Const_expression
: public Expression
1476 Const_expression(Named_object
* constant
, Location location
)
1477 : Expression(EXPRESSION_CONST_REFERENCE
, location
),
1478 constant_(constant
), type_(NULL
), seen_(false)
1483 { return this->constant_
; }
1486 named_object() const
1487 { return this->constant_
; }
1489 // Check that the initializer does not refer to the constant itself.
1491 check_for_init_loop();
1495 do_traverse(Traverse
*);
1498 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1501 do_is_constant() const
1505 do_is_zero_value() const;
1508 do_is_static_initializer() const
1512 do_numeric_constant_value(Numeric_constant
* nc
) const;
1515 do_string_constant_value(std::string
* val
) const;
1518 do_boolean_constant_value(bool* val
) const;
1523 // The type of a const is set by the declaration, not the use.
1525 do_determine_type(const Type_context
*);
1528 do_check_types(Gogo
*);
1535 do_get_backend(Translate_context
* context
);
1538 do_inlining_cost() const
1541 // When exporting a reference to a const as part of a const
1542 // expression, we export the value. We ignore the fact that it has
1545 do_export(Export_function_body
* efb
) const;
1548 do_dump_expression(Ast_dump_context
*) const;
1552 Named_object
* constant_
;
1553 // The type of this reference. This is used if the constant has an
1556 // Used to prevent infinite recursion when a constant incorrectly
1557 // refers to itself.
1561 // An expression which is simply a variable.
1563 class Var_expression
: public Expression
1566 Var_expression(Named_object
* variable
, Location location
)
1567 : Expression(EXPRESSION_VAR_REFERENCE
, location
),
1571 // Return the variable.
1573 named_object() const
1574 { return this->variable_
; }
1578 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1584 do_determine_type(const Type_context
*);
1591 do_inlining_cost() const
1595 do_export(Export_function_body
*) const;
1598 do_is_addressable() const
1602 do_address_taken(bool);
1605 do_get_backend(Translate_context
*);
1608 do_dump_expression(Ast_dump_context
*) const;
1611 // The variable we are referencing.
1612 Named_object
* variable_
;
1615 // A reference to a variable within an enclosing function.
1617 class Enclosed_var_expression
: public Expression
1620 Enclosed_var_expression(Expression
* reference
, Named_object
* variable
,
1622 : Expression(EXPRESSION_ENCLOSED_VAR_REFERENCE
, location
),
1623 reference_(reference
), variable_(variable
)
1626 // The reference to the enclosed variable. This will be an indirection of the
1627 // the field stored within closure variable.
1630 { return this->reference_
; }
1632 // The variable being enclosed and referenced.
1635 { return this->variable_
; }
1639 do_traverse(Traverse
*);
1642 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1645 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1649 { return this->reference_
->type(); }
1652 do_determine_type(const Type_context
* context
)
1653 { return this->reference_
->determine_type(context
); }
1660 do_is_addressable() const
1661 { return this->reference_
->is_addressable(); }
1664 do_address_taken(bool escapes
);
1667 do_get_backend(Translate_context
* context
)
1668 { return this->reference_
->get_backend(context
); }
1671 do_dump_expression(Ast_dump_context
*) const;
1674 // The reference to the enclosed variable.
1675 Expression
* reference_
;
1676 // The variable being enclosed.
1677 Named_object
* variable_
;
1680 // A reference to a temporary variable.
1682 class Temporary_reference_expression
: public Expression
1685 Temporary_reference_expression(Temporary_statement
* statement
,
1687 : Expression(EXPRESSION_TEMPORARY_REFERENCE
, location
),
1688 statement_(statement
), is_lvalue_(false)
1691 // The temporary that this expression refers to.
1692 Temporary_statement
*
1694 { return this->statement_
; }
1696 // Indicate that this reference appears on the left hand side of an
1697 // assignment statement.
1700 { this->is_lvalue_
= true; }
1703 do_import(Import_function_body
*, Location
);
1710 do_determine_type(const Type_context
*)
1715 { return make_temporary_reference(this->statement_
, this->location()); }
1718 do_inlining_cost() const
1722 do_export(Export_function_body
*) const;
1725 do_is_addressable() const
1729 do_address_taken(bool);
1732 do_get_backend(Translate_context
*);
1735 do_dump_expression(Ast_dump_context
*) const;
1738 // The statement where the temporary variable is defined.
1739 Temporary_statement
* statement_
;
1740 // Whether this reference appears on the left hand side of an
1741 // assignment statement.
1745 // Set and use a temporary variable.
1747 class Set_and_use_temporary_expression
: public Expression
1750 Set_and_use_temporary_expression(Temporary_statement
* statement
,
1751 Expression
* expr
, Location location
)
1752 : Expression(EXPRESSION_SET_AND_USE_TEMPORARY
, location
),
1753 statement_(statement
), expr_(expr
)
1756 // Return the temporary.
1757 Temporary_statement
*
1759 { return this->statement_
; }
1761 // Return the expression.
1764 { return this->expr_
; }
1768 do_traverse(Traverse
* traverse
)
1769 { return Expression::traverse(&this->expr_
, traverse
); }
1775 do_determine_type(const Type_context
*);
1780 return make_set_and_use_temporary(this->statement_
, this->expr_
,
1785 do_must_eval_in_order() const
1789 do_is_addressable() const
1793 do_address_taken(bool);
1796 do_get_backend(Translate_context
*);
1799 do_dump_expression(Ast_dump_context
*) const;
1802 // The statement where the temporary variable is defined.
1803 Temporary_statement
* statement_
;
1804 // The expression to assign to the temporary.
1808 // A string expression.
1810 class String_expression
: public Expression
1813 String_expression(const std::string
& val
, Type
* type
, Location location
)
1814 : Expression(EXPRESSION_STRING
, location
),
1815 val_(val
), type_(type
)
1820 { return this->val_
; }
1823 do_import(Import_expression
*, Location
);
1827 do_traverse(Traverse
*);
1830 do_is_constant() const
1834 do_is_zero_value() const
1835 { return this->val_
== ""; }
1838 do_is_static_initializer() const
1842 do_string_constant_value(std::string
* val
) const
1852 do_determine_type(const Type_context
*);
1859 do_get_backend(Translate_context
*);
1861 // Write string literal to a string dump.
1863 export_string(String_dump
* exp
, const String_expression
* str
);
1865 // Set the inlining cost a bit high since inlining may cause
1866 // duplicated string literals.
1868 do_inlining_cost() const
1872 do_export(Export_function_body
*) const;
1875 do_dump_expression(Ast_dump_context
*) const;
1878 // The string value. This is immutable.
1879 const std::string val_
;
1880 // The type as determined by context.
1884 // A type conversion expression.
1886 class Type_conversion_expression
: public Expression
1889 Type_conversion_expression(Type
* type
, Expression
* expr
,
1891 : Expression(EXPRESSION_CONVERSION
, location
),
1892 type_(type
), expr_(expr
), may_convert_function_types_(false),
1893 no_copy_(false), no_escape_(false)
1896 // Return the type to which we are converting.
1899 { return this->type_
; }
1901 // Return the expression which we are converting.
1904 { return this->expr_
; }
1906 // Permit converting from one function type to another. This is
1907 // used internally for method expressions.
1909 set_may_convert_function_types()
1911 this->may_convert_function_types_
= true;
1914 // Mark string([]byte) conversion to reuse the backing store
1918 { this->no_copy_
= b
; };
1920 // Import a type conversion expression.
1922 do_import(Import_expression
*, Location
);
1926 do_traverse(Traverse
* traverse
);
1929 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
1932 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
1935 do_is_constant() const;
1938 do_is_zero_value() const;
1941 do_is_static_initializer() const;
1944 do_numeric_constant_value(Numeric_constant
*) const;
1947 do_string_constant_value(std::string
*) const;
1950 do_boolean_constant_value(bool*) const;
1954 { return this->type_
; }
1957 do_determine_type(const Type_context
*);
1960 do_check_types(Gogo
*);
1966 do_get_backend(Translate_context
* context
);
1969 do_inlining_cost() const;
1972 do_export(Export_function_body
*) const;
1975 do_dump_expression(Ast_dump_context
*) const;
1978 // The type to convert to.
1980 // The expression to convert.
1982 // True if this is permitted to convert function types. This is
1983 // used internally for method expressions.
1984 bool may_convert_function_types_
;
1985 // True if a string([]byte) conversion can reuse the backing store
1986 // without copying. Only used in string([]byte) conversion.
1988 // True if a conversion does not escape. Used in type-to-interface
1989 // conversions and slice-to/from-string conversions.
1993 // An unsafe type conversion, used to pass values to builtin functions.
1995 class Unsafe_type_conversion_expression
: public Expression
1998 Unsafe_type_conversion_expression(Type
* type
, Expression
* expr
,
2000 : Expression(EXPRESSION_UNSAFE_CONVERSION
, location
),
2001 type_(type
), expr_(expr
)
2006 { return this->expr_
; }
2010 do_traverse(Traverse
* traverse
);
2013 do_is_zero_value() const
2014 { return this->expr_
->is_zero_value(); }
2017 do_is_static_initializer() const;
2021 { return this->type_
; }
2024 do_determine_type(const Type_context
*)
2025 { this->expr_
->determine_type_no_context(); }
2031 do_get_backend(Translate_context
*);
2034 do_dump_expression(Ast_dump_context
*) const;
2037 // The type to convert to.
2039 // The expression to convert.
2043 // A Unary expression.
2045 class Unary_expression
: public Expression
2048 Unary_expression(Operator op
, Expression
* expr
, Location location
)
2049 : Expression(EXPRESSION_UNARY
, location
),
2050 op_(op
), escapes_(true), create_temp_(false), is_gc_root_(false),
2051 is_slice_init_(false), expr_(expr
),
2052 issue_nil_check_(NIL_CHECK_DEFAULT
)
2055 // Return the operator.
2058 { return this->op_
; }
2060 // Return the operand.
2063 { return this->expr_
; }
2065 // Record that an address expression does not escape.
2067 set_does_not_escape()
2069 go_assert(this->op_
== OPERATOR_AND
);
2070 this->escapes_
= false;
2073 // Record that this is an address expression which should create a
2074 // temporary variable if necessary. This is used for method calls.
2078 go_assert(this->op_
== OPERATOR_AND
);
2079 this->create_temp_
= true;
2082 // Record that this is an address expression of a GC root, which is a
2083 // mutable composite literal. This used for registering GC variables.
2087 go_assert(this->op_
== OPERATOR_AND
);
2088 this->is_gc_root_
= true;
2091 // Record that this is an address expression of a slice value initializer,
2092 // which is mutable if the values are not copied to the heap.
2096 go_assert(this->op_
== OPERATOR_AND
);
2097 this->is_slice_init_
= true;
2100 // Call the address_taken method on the operand if necessary.
2102 check_operand_address_taken(Gogo
*);
2104 // Apply unary opcode OP to UNC, setting NC. Return true if this
2105 // could be done, false if not. On overflow, issues an error and
2106 // sets *ISSUED_ERROR.
2108 eval_constant(Operator op
, const Numeric_constant
* unc
,
2109 Location
, Numeric_constant
* nc
, bool *issued_error
);
2112 do_import(Import_expression
*, Location
);
2114 // Declare that this deref does or does not require an explicit nil check.
2116 set_requires_nil_check(bool needed
)
2118 go_assert(this->op_
== OPERATOR_MULT
);
2120 this->issue_nil_check_
= NIL_CHECK_NEEDED
;
2122 this->issue_nil_check_
= NIL_CHECK_NOT_NEEDED
;
2127 do_traverse(Traverse
* traverse
)
2128 { return Expression::traverse(&this->expr_
, traverse
); }
2131 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2134 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2137 do_is_constant() const;
2140 do_is_static_initializer() const;
2143 do_numeric_constant_value(Numeric_constant
*) const;
2146 do_boolean_constant_value(bool*) const;
2152 do_determine_type(const Type_context
*);
2155 do_check_types(Gogo
*);
2160 return Expression::make_unary(this->op_
, this->expr_
->copy(),
2165 do_must_eval_subexpressions_in_order(int*) const
2166 { return this->op_
== OPERATOR_MULT
; }
2169 do_is_addressable() const
2170 { return this->op_
== OPERATOR_MULT
; }
2173 do_get_backend(Translate_context
*);
2176 do_inlining_cost() const
2180 do_export(Export_function_body
*) const;
2183 do_dump_expression(Ast_dump_context
*) const;
2186 do_issue_nil_check()
2188 if (this->op_
== OPERATOR_MULT
)
2189 this->set_requires_nil_check(true);
2194 base_is_static_initializer(Expression
*);
2196 // Return a determination as to whether this dereference expression
2197 // requires a nil check.
2198 Nil_check_classification
2199 requires_nil_check(Gogo
*);
2201 // The unary operator to apply.
2203 // Normally true. False if this is an address expression which does
2204 // not escape the current function.
2206 // True if this is an address expression which should create a
2207 // temporary variable if necessary.
2209 // True if this is an address expression for a GC root. A GC root is a
2210 // special struct composite literal that is mutable when addressed, meaning
2211 // it cannot be represented as an immutable_struct in the backend.
2213 // True if this is an address expression for a slice value with an immutable
2214 // initializer. The initializer for a slice's value pointer has an array
2215 // type, meaning it cannot be represented as an immutable_struct in the
2217 bool is_slice_init_
;
2220 // Whether or not to issue a nil check for this expression if its address
2222 Nil_check_classification issue_nil_check_
;
2225 // A binary expression.
2227 class Binary_expression
: public Expression
2230 Binary_expression(Operator op
, Expression
* left
, Expression
* right
,
2232 : Expression(EXPRESSION_BINARY
, location
),
2233 op_(op
), left_(left
), right_(right
), type_(NULL
)
2236 // Return the operator.
2239 { return this->op_
; }
2241 // Return the left hand expression.
2244 { return this->left_
; }
2246 // Return the right hand expression.
2249 { return this->right_
; }
2251 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC.
2252 // Return true if this could be done, false if not. Issue errors at
2253 // LOCATION as appropriate, and sets *ISSUED_ERROR if it did.
2255 eval_constant(Operator op
, Numeric_constant
* left_nc
,
2256 Numeric_constant
* right_nc
, Location location
,
2257 Numeric_constant
* nc
, bool* issued_error
);
2259 // Compare constants LEFT_NC and RIGHT_NC according to OP, setting
2260 // *RESULT. Return true if this could be done, false if not. Issue
2261 // errors at LOCATION as appropriate.
2263 compare_constant(Operator op
, Numeric_constant
* left_nc
,
2264 Numeric_constant
* right_nc
, Location location
,
2268 do_import(Import_expression
*, Location
);
2270 // Report an error if OP can not be applied to TYPE. Return whether
2271 // it can. OTYPE is the type of the other operand.
2273 check_operator_type(Operator op
, Type
* type
, Type
* otype
, Location
);
2275 // Set *RESULT_TYPE to the resulting type when OP is applied to
2276 // operands of type LEFT_TYPE and RIGHT_TYPE. Return true on
2277 // success, false on failure.
2279 operation_type(Operator op
, Type
* left_type
, Type
* right_type
,
2280 Type
** result_type
);
2284 do_traverse(Traverse
* traverse
);
2287 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2290 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2293 do_is_constant() const
2294 { return this->left_
->is_constant() && this->right_
->is_constant(); }
2297 do_is_static_initializer() const;
2300 do_numeric_constant_value(Numeric_constant
*) const;
2303 do_boolean_constant_value(bool*) const;
2306 do_discarding_value();
2312 do_determine_type(const Type_context
*);
2315 do_check_types(Gogo
*);
2320 return Expression::make_binary(this->op_
, this->left_
->copy(),
2321 this->right_
->copy(), this->location());
2325 do_get_backend(Translate_context
*);
2328 do_inlining_cost() const
2332 do_export(Export_function_body
*) const;
2335 do_dump_expression(Ast_dump_context
*) const;
2339 cmp_to_bool(Operator op
, int cmp
);
2342 eval_integer(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2343 Location
, Numeric_constant
*);
2346 eval_float(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2347 Location
, Numeric_constant
*);
2350 eval_complex(Operator op
, const Numeric_constant
*, const Numeric_constant
*,
2351 Location
, Numeric_constant
*);
2354 compare_integer(const Numeric_constant
*, const Numeric_constant
*, int*);
2357 compare_float(const Numeric_constant
*, const Numeric_constant
*, int*);
2360 compare_complex(const Numeric_constant
*, const Numeric_constant
*, int*);
2363 lower_struct_comparison(Gogo
*, Statement_inserter
*);
2366 lower_array_comparison(Gogo
*, Statement_inserter
*);
2369 lower_interface_value_comparison(Gogo
*, Statement_inserter
*);
2372 lower_compare_to_memcmp(Gogo
*, Statement_inserter
*);
2375 operand_address(Statement_inserter
*, Expression
*);
2377 // The binary operator to apply.
2379 // The left hand side operand.
2381 // The right hand side operand.
2383 // The type of a comparison operation.
2387 // A string concatenation expression. This is a sequence of strings
2388 // added together. It is created when lowering Binary_expression.
2390 class String_concat_expression
: public Expression
2393 String_concat_expression(Expression_list
* exprs
)
2394 : Expression(EXPRESSION_STRING_CONCAT
, exprs
->front()->location()),
2398 // Return the list of string expressions to be concatenated.
2401 { return this->exprs_
; }
2405 do_traverse(Traverse
* traverse
)
2406 { return this->exprs_
->traverse(traverse
); }
2409 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
2413 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2416 do_is_constant() const;
2419 do_is_zero_value() const;
2422 do_is_static_initializer() const;
2428 do_determine_type(const Type_context
*);
2431 do_check_types(Gogo
*);
2435 { return Expression::make_string_concat(this->exprs_
->copy()); }
2438 do_get_backend(Translate_context
*)
2439 { go_unreachable(); }
2442 do_export(Export_function_body
*) const
2443 { go_unreachable(); }
2446 do_dump_expression(Ast_dump_context
*) const;
2449 // The string expressions to concatenate.
2450 Expression_list
* exprs_
;
2453 // A call expression. The go statement needs to dig inside this.
2455 class Call_expression
: public Expression
2458 Call_expression(Expression
* fn
, Expression_list
* args
, bool is_varargs
,
2460 : Expression(EXPRESSION_CALL
, location
),
2461 fn_(fn
), args_(args
), type_(NULL
), call_(NULL
), call_temp_(NULL
)
2462 , expected_result_count_(0), is_varargs_(is_varargs
),
2463 varargs_are_lowered_(false), types_are_determined_(false),
2464 is_deferred_(false), is_concurrent_(false), is_equal_function_(false),
2465 issued_error_(false), is_multi_value_arg_(false), is_flattened_(false)
2468 // The function to call.
2471 { return this->fn_
; }
2476 { return this->args_
; }
2478 const Expression_list
*
2480 { return this->args_
; }
2482 // Get the function type.
2484 get_function_type() const;
2486 // Return the number of values this call will return.
2488 result_count() const;
2490 // Return the temporary variable that holds the results. This is
2491 // only valid after the expression has been lowered, and is only
2492 // valid for calls which return multiple results.
2493 Temporary_statement
*
2496 // Set the number of results expected from this call. This is used
2497 // when the call appears in a context that expects multiple results,
2498 // such as a, b = f().
2500 set_expected_result_count(size_t);
2502 // Return whether this is a call to the predeclared function
2505 is_recover_call() const;
2507 // Set the argument for a call to recover.
2509 set_recover_arg(Expression
*);
2511 // Whether the last argument is a varargs argument (f(a...)).
2514 { return this->is_varargs_
; }
2516 // Return whether varargs have already been lowered.
2518 varargs_are_lowered() const
2519 { return this->varargs_are_lowered_
; }
2521 // Note that varargs have already been lowered.
2523 set_varargs_are_lowered()
2524 { this->varargs_are_lowered_
= true; }
2526 // Whether this call is being deferred.
2529 { return this->is_deferred_
; }
2531 // Note that the call is being deferred.
2534 { this->is_deferred_
= true; }
2536 // Whether this call is concurrently executed.
2538 is_concurrent() const
2539 { return this->is_concurrent_
; }
2541 // Note that the call is concurrently executed.
2544 { this->is_concurrent_
= true; }
2546 // Note that this is a call to a generated equality function.
2548 set_is_equal_function()
2549 { this->is_equal_function_
= true; }
2551 // We have found an error with this call expression; return true if
2552 // we should report it.
2556 // Whether or not this call contains errors, either in the call or the
2557 // arguments to the call.
2559 is_erroneous_call();
2561 // Whether this call returns multiple results that are used as an
2562 // multi-valued argument.
2564 is_multi_value_arg() const
2565 { return this->is_multi_value_arg_
; }
2567 // Note this call is used as a multi-valued argument.
2569 set_is_multi_value_arg()
2570 { this->is_multi_value_arg_
= true; }
2572 // Whether this is a call to builtin function.
2577 // Convert to a Builtin_call_expression, or return NULL.
2578 inline Builtin_call_expression
*
2579 builtin_call_expression();
2581 inline const Builtin_call_expression
*
2582 builtin_call_expression() const;
2586 do_traverse(Traverse
*);
2589 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2592 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2595 do_discarding_value()
2602 do_determine_type(const Type_context
*);
2605 do_check_types(Gogo
*);
2611 do_must_eval_in_order() const;
2613 virtual Bexpression
*
2614 do_get_backend(Translate_context
*);
2617 do_inlining_cost() const;
2620 do_export(Export_function_body
*) const;
2623 do_is_recover_call() const;
2626 do_set_recover_arg(Expression
*);
2628 // Let a builtin expression change the argument list.
2630 set_args(Expression_list
* args
)
2631 { this->args_
= args
; }
2633 // Let a builtin expression lower varargs.
2635 lower_varargs(Gogo
*, Named_object
* function
, Statement_inserter
* inserter
,
2636 Type
* varargs_type
, size_t param_count
,
2637 Slice_storage_escape_disp escape_disp
);
2639 // Let a builtin expression check whether types have been
2642 determining_types();
2645 export_arguments(Export_function_body
*) const;
2648 do_dump_expression(Ast_dump_context
*) const;
2651 do_add_conversions();
2655 check_argument_type(int, const Type
*, const Type
*, Location
, bool);
2658 intrinsify(Gogo
*, Statement_inserter
*);
2661 interface_method_function(Interface_field_reference_expression
*,
2662 Expression
**, Location
);
2665 set_results(Translate_context
*);
2667 // The function to call.
2669 // The arguments to pass. This may be NULL if there are no
2671 Expression_list
* args_
;
2672 // The type of the expression, to avoid recomputing it.
2674 // The backend expression for the call, used for a call which returns a tuple.
2676 // A temporary variable to store this call if the function returns a tuple.
2677 Temporary_statement
* call_temp_
;
2678 // If not 0, the number of results expected from this call, when
2679 // used in a context that expects multiple values.
2680 size_t expected_result_count_
;
2681 // True if the last argument is a varargs argument (f(a...)).
2683 // True if varargs have already been lowered.
2684 bool varargs_are_lowered_
;
2685 // True if types have been determined.
2686 bool types_are_determined_
;
2687 // True if the call is an argument to a defer statement.
2689 // True if the call is an argument to a go statement.
2690 bool is_concurrent_
;
2691 // True if this is a call to a generated equality function.
2692 bool is_equal_function_
;
2693 // True if we reported an error about a mismatch between call
2694 // results and uses. This is to avoid producing multiple errors
2695 // when there are multiple Call_result_expressions.
2697 // True if this call is used as an argument that returns multiple results.
2698 bool is_multi_value_arg_
;
2699 // True if this expression has already been flattened.
2703 // A call expression to a builtin function.
2705 class Builtin_call_expression
: public Call_expression
2708 Builtin_call_expression(Gogo
* gogo
, Expression
* fn
, Expression_list
* args
,
2709 bool is_varargs
, Location location
);
2711 // The builtin functions.
2712 enum Builtin_function_code
2716 // Predeclared builtin functions.
2733 // Builtin functions from the unsafe package.
2741 Builtin_function_code
2743 { return this->code_
; }
2745 // This overrides Call_expression::is_builtin.
2750 // Return whether EXPR, of array type, is a constant if passed to
2753 array_len_is_constant(Expression
* expr
);
2756 flatten_append(Gogo
*, Named_object
*, Statement_inserter
*, Expression
*,
2760 // This overrides Call_expression::do_lower.
2762 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2765 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
2768 do_is_constant() const;
2771 do_numeric_constant_value(Numeric_constant
*) const;
2774 do_discarding_value();
2780 do_determine_type(const Type_context
*);
2783 do_check_types(Gogo
*);
2789 do_get_backend(Translate_context
*);
2792 do_inlining_cost() const
2796 do_export(Export_function_body
*) const;
2799 do_is_recover_call() const;
2802 do_set_recover_arg(Expression
*);
2812 real_imag_type(Type
*);
2815 complex_type(Type
*);
2818 lower_make(Statement_inserter
*);
2821 check_int_value(Expression
*, bool is_length
, bool* small
);
2823 // A pointer back to the general IR structure. This avoids a global
2824 // variable, or passing it around everywhere.
2826 // The builtin function being called.
2827 Builtin_function_code code_
;
2828 // Used to stop endless loops when the length of an array uses len
2829 // or cap of the array itself.
2831 // Whether the argument is set for calls to BUILTIN_RECOVER.
2832 bool recover_arg_is_set_
;
2835 inline Builtin_call_expression
*
2836 Call_expression::builtin_call_expression()
2838 return (this->is_builtin()
2839 ? static_cast<Builtin_call_expression
*>(this)
2843 inline const Builtin_call_expression
*
2844 Call_expression::builtin_call_expression() const
2846 return (this->is_builtin()
2847 ? static_cast<const Builtin_call_expression
*>(this)
2851 // A single result from a call which returns multiple results.
2853 class Call_result_expression
: public Expression
2856 Call_result_expression(Call_expression
* call
, unsigned int index
)
2857 : Expression(EXPRESSION_CALL_RESULT
, call
->location()),
2858 call_(call
), index_(index
)
2863 { return this->call_
; }
2867 { return this->index_
; }
2871 do_traverse(Traverse
*);
2877 do_determine_type(const Type_context
*);
2880 do_check_types(Gogo
*);
2885 return new Call_result_expression(this->call_
->call_expression(),
2890 do_must_eval_in_order() const
2894 do_get_backend(Translate_context
*);
2897 do_dump_expression(Ast_dump_context
*) const;
2900 // The underlying call expression.
2902 // Which result we want.
2903 unsigned int index_
;
2906 // An expression which represents a pointer to a function.
2908 class Func_expression
: public Expression
2911 Func_expression(Named_object
* function
, Expression
* closure
,
2913 : Expression(EXPRESSION_FUNC_REFERENCE
, location
),
2914 function_(function
), closure_(closure
),
2915 runtime_code_(Runtime::NUMBER_OF_FUNCTIONS
)
2918 // Return the object associated with the function.
2920 named_object() const
2921 { return this->function_
; }
2923 // Return the closure for this function. This will return NULL if
2924 // the function has no closure, which is the normal case.
2927 { return this->closure_
; }
2929 // Return whether this is a reference to a runtime function.
2931 is_runtime_function() const
2932 { return this->runtime_code_
!= Runtime::NUMBER_OF_FUNCTIONS
; }
2934 // Return the runtime code for this function expression.
2935 // Returns Runtime::NUMBER_OF_FUNCTIONS if this is not a reference to a
2936 // runtime function.
2938 runtime_code() const
2939 { return this->runtime_code_
; }
2941 // Set the runtime code for this function expression.
2943 set_runtime_code(Runtime::Function code
)
2944 { this->runtime_code_
= code
; }
2946 // Return a backend expression for the code of a function.
2948 get_code_pointer(Gogo
*, Named_object
* function
, Location loc
);
2952 do_traverse(Traverse
*);
2958 do_determine_type(const Type_context
*)
2960 if (this->closure_
!= NULL
)
2961 this->closure_
->determine_type_no_context();
2967 return Expression::make_func_reference(this->function_
,
2968 (this->closure_
== NULL
2970 : this->closure_
->copy()),
2975 do_get_backend(Translate_context
*);
2978 do_inlining_cost() const;
2981 do_export(Export_function_body
*) const;
2984 do_dump_expression(Ast_dump_context
*) const;
2987 // The function itself.
2988 Named_object
* function_
;
2989 // A closure. This is normally NULL. For a nested function, it may
2990 // be a struct holding pointers to all the variables referenced by
2991 // this function and defined in enclosing functions.
2992 Expression
* closure_
;
2993 // The runtime code for the referenced function.
2994 Runtime::Function runtime_code_
;
2997 // A function descriptor. A function descriptor is a struct with a
2998 // single field pointing to the function code. This is used for
2999 // functions without closures.
3001 class Func_descriptor_expression
: public Expression
3004 Func_descriptor_expression(Named_object
* fn
);
3006 // Make the function descriptor type, so that it can be converted.
3008 make_func_descriptor_type();
3012 do_traverse(Traverse
*);
3018 do_determine_type(const Type_context
*)
3023 { return Expression::make_func_descriptor(this->fn_
); }
3026 do_is_addressable() const
3030 do_get_backend(Translate_context
*);
3033 do_dump_expression(Ast_dump_context
* context
) const;
3036 // The type of all function descriptors.
3037 static Type
* descriptor_type
;
3039 // The function for which this is the descriptor.
3041 // The descriptor variable.
3045 // A reference to an unknown name.
3047 class Unknown_expression
: public Parser_expression
3050 Unknown_expression(Named_object
* named_object
, Location location
)
3051 : Parser_expression(EXPRESSION_UNKNOWN_REFERENCE
, location
),
3052 named_object_(named_object
), no_error_message_(false)
3055 // The associated named object.
3057 named_object() const
3058 { return this->named_object_
; }
3060 // The name of the identifier which was unknown.
3064 // Call this to indicate that we should not give an error if this
3065 // name is never defined. This is used to avoid knock-on errors
3066 // during an erroneous parse.
3068 set_no_error_message()
3069 { this->no_error_message_
= true; }
3073 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3077 { return new Unknown_expression(this->named_object_
, this->location()); }
3080 do_dump_expression(Ast_dump_context
*) const;
3083 // The unknown name.
3084 Named_object
* named_object_
;
3085 // True if we should not give errors if this is undefined. This is
3086 // used if there was a parse failure.
3087 bool no_error_message_
;
3090 // An index expression. This is lowered to an array index, a string
3091 // index, or a map index.
3093 class Index_expression
: public Parser_expression
3096 Index_expression(Expression
* left
, Expression
* start
, Expression
* end
,
3097 Expression
* cap
, Location location
)
3098 : Parser_expression(EXPRESSION_INDEX
, location
),
3099 left_(left
), start_(start
), end_(end
), cap_(cap
)
3102 // Dump an index expression, i.e. an expression of the form
3103 // expr[expr], expr[expr:expr], or expr[expr:expr:expr] to a dump context.
3105 dump_index_expression(Ast_dump_context
*, const Expression
* expr
,
3106 const Expression
* start
, const Expression
* end
,
3107 const Expression
* cap
);
3111 do_traverse(Traverse
*);
3114 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3119 return new Index_expression(this->left_
->copy(), this->start_
->copy(),
3122 : this->end_
->copy()),
3125 : this->cap_
->copy()),
3129 // This shouldn't be called--we don't know yet.
3131 do_must_eval_subexpressions_in_order(int*) const
3132 { go_unreachable(); }
3135 do_dump_expression(Ast_dump_context
*) const;
3138 do_issue_nil_check()
3139 { this->left_
->issue_nil_check(); }
3141 // The expression being indexed.
3145 // The second index. This is NULL for an index, non-NULL for a
3148 // The capacity argument. This is NULL for indices and slices that use the
3149 // default capacity, non-NULL for indices and slices that specify the
3154 // An array index. This is used for both indexing and slicing.
3156 class Array_index_expression
: public Expression
3159 Array_index_expression(Expression
* array
, Expression
* start
,
3160 Expression
* end
, Expression
* cap
, Location location
)
3161 : Expression(EXPRESSION_ARRAY_INDEX
, location
),
3162 array_(array
), start_(start
), end_(end
), cap_(cap
), type_(NULL
),
3163 needs_bounds_check_(true), is_flattened_(false)
3166 // Return the array.
3169 { return this->array_
; }
3173 { return this->array_
; }
3175 // Return the index of a simple index expression, or the start index
3176 // of a slice expression.
3179 { return this->start_
; }
3183 { return this->start_
; }
3185 // Return the end index of a slice expression. This is NULL for a
3186 // simple index expression.
3189 { return this->end_
; }
3193 { return this->end_
; }
3196 set_needs_bounds_check(bool b
)
3197 { this->needs_bounds_check_
= b
; }
3201 do_traverse(Traverse
*);
3204 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3210 do_determine_type(const Type_context
*);
3213 do_check_types(Gogo
*);
3218 Expression
* ret
= Expression::make_array_index(this->array_
->copy(),
3219 this->start_
->copy(),
3222 : this->end_
->copy()),
3225 : this->cap_
->copy()),
3227 ret
->array_index_expression()->set_needs_bounds_check(this->needs_bounds_check_
);
3232 do_must_eval_subexpressions_in_order(int* skip
) const;
3235 do_is_addressable() const;
3238 do_address_taken(bool escapes
);
3241 do_issue_nil_check()
3242 { this->array_
->issue_nil_check(); }
3245 do_get_backend(Translate_context
*);
3248 do_inlining_cost() const
3249 { return this->end_
!= NULL
? 2 : 1; }
3252 do_export(Export_function_body
*) const;
3255 do_dump_expression(Ast_dump_context
*) const;
3258 // The array we are getting a value from.
3260 // The start or only index.
3262 // The end index of a slice. This may be NULL for a simple array
3263 // index, or it may be a nil expression for the length of the array.
3265 // The capacity argument of a slice. This may be NULL for an array index or
3268 // The type of the expression.
3270 // Whether bounds check is needed.
3271 bool needs_bounds_check_
;
3272 // Whether this has already been flattened.
3276 // A string index. This is used for both indexing and slicing.
3278 class String_index_expression
: public Expression
3281 String_index_expression(Expression
* string
, Expression
* start
,
3282 Expression
* end
, Location location
)
3283 : Expression(EXPRESSION_STRING_INDEX
, location
),
3284 string_(string
), start_(start
), end_(end
), is_flattened_(false)
3287 // Return the string being indexed.
3290 { return this->string_
; }
3292 // Return the index of a simple index expression, or the start index
3293 // of a slice expression.
3296 { return this->start_
; }
3298 // Return the end index of a slice expression. This is NULL for a
3299 // simple index expression.
3302 { return this->end_
; }
3306 do_traverse(Traverse
*);
3309 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3315 do_determine_type(const Type_context
*);
3318 do_check_types(Gogo
*);
3323 return Expression::make_string_index(this->string_
->copy(),
3324 this->start_
->copy(),
3327 : this->end_
->copy()),
3332 do_must_eval_subexpressions_in_order(int*) const
3336 do_get_backend(Translate_context
*);
3339 do_inlining_cost() const
3340 { return this->end_
!= NULL
? 2 : 1; }
3343 do_export(Export_function_body
*) const;
3346 do_dump_expression(Ast_dump_context
*) const;
3349 // The string we are getting a value from.
3350 Expression
* string_
;
3351 // The start or only index.
3353 // The end index of a slice. This may be NULL for a single index,
3354 // or it may be a nil expression for the length of the string.
3356 // Whether this has already been flattened.
3360 // An index into a map.
3362 class Map_index_expression
: public Expression
3365 Map_index_expression(Expression
* map
, Expression
* index
,
3367 : Expression(EXPRESSION_MAP_INDEX
, location
),
3368 map_(map
), index_(index
), value_pointer_(NULL
)
3374 { return this->map_
; }
3378 { return this->map_
; }
3380 // Return the index.
3383 { return this->index_
; }
3387 { return this->index_
; }
3389 // Get the type of the map being indexed.
3391 get_map_type() const;
3393 // Return an expression for the map index. This returns an
3394 // expression that evaluates to a pointer to a value in the map. If
3395 // the key is not present in the map, this will return a pointer to
3398 get_value_pointer(Gogo
*);
3402 do_traverse(Traverse
*);
3405 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3411 do_determine_type(const Type_context
*);
3414 do_check_types(Gogo
*);
3419 return Expression::make_map_index(this->map_
->copy(),
3420 this->index_
->copy(),
3425 do_must_eval_subexpressions_in_order(int*) const
3428 // A map index expression is an lvalue but it is not addressable.
3431 do_get_backend(Translate_context
*);
3434 do_inlining_cost() const
3438 do_export(Export_function_body
*) const;
3441 do_dump_expression(Ast_dump_context
*) const;
3444 do_add_conversions();
3447 // The map we are looking into.
3451 // A pointer to the value at this index.
3452 Expression
* value_pointer_
;
3455 // An expression which represents a method bound to its first
3458 class Bound_method_expression
: public Expression
3461 Bound_method_expression(Expression
* expr
, const Method
*method
,
3462 Named_object
* function
, Location location
)
3463 : Expression(EXPRESSION_BOUND_METHOD
, location
),
3464 expr_(expr
), expr_type_(NULL
), method_(method
), function_(function
)
3467 // Return the object which is the first argument.
3470 { return this->expr_
; }
3472 // Return the implicit type of the first argument. This will be
3473 // non-NULL when using a method from an anonymous field without
3474 // using an explicit stub.
3476 first_argument_type() const
3477 { return this->expr_type_
; }
3479 // Return the method.
3482 { return this->method_
; }
3484 // Return the function to call.
3487 { return this->function_
; }
3489 // Set the implicit type of the expression.
3491 set_first_argument_type(Type
* type
)
3492 { this->expr_type_
= type
; }
3494 // Create a thunk to call FUNCTION, for METHOD, when it is used as
3495 // part of a method value.
3496 static Named_object
*
3497 create_thunk(Gogo
*, const Method
* method
, Named_object
* function
);
3500 static Named_object
*
3501 lookup_thunk(Named_object
* function
);
3505 do_traverse(Traverse
*);
3508 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3514 do_determine_type(const Type_context
*);
3517 do_check_types(Gogo
*);
3522 return new Bound_method_expression(this->expr_
->copy(), this->method_
,
3523 this->function_
, this->location());
3527 do_get_backend(Translate_context
*)
3528 { go_unreachable(); }
3531 do_dump_expression(Ast_dump_context
*) const;
3534 // A mapping from method functions to the thunks we have created for
3536 typedef Unordered_map(Named_object
*, Named_object
*) Method_value_thunks
;
3537 static Method_value_thunks method_value_thunks
;
3539 // The object used to find the method. This is passed to the method
3540 // as the first argument.
3542 // The implicit type of the object to pass to the method. This is
3543 // NULL in the normal case, non-NULL when using a method from an
3544 // anonymous field which does not require a stub.
3547 const Method
* method_
;
3548 // The function to call. This is not the same as
3549 // method_->named_object() when the method has a stub. This will be
3550 // the real function rather than the stub.
3551 Named_object
* function_
;
3554 // A reference to a field in a struct.
3556 class Field_reference_expression
: public Expression
3559 Field_reference_expression(Expression
* expr
, unsigned int field_index
,
3561 : Expression(EXPRESSION_FIELD_REFERENCE
, location
),
3562 expr_(expr
), field_index_(field_index
), implicit_(false), called_fieldtrack_(false)
3565 // Return the struct expression.
3568 { return this->expr_
; }
3570 // Return the field index.
3573 { return this->field_index_
; }
3575 // Return whether this node was implied by an anonymous field.
3578 { return this->implicit_
; }
3581 set_implicit(bool implicit
)
3582 { this->implicit_
= implicit
; }
3584 // Set the struct expression. This is used when parsing.
3586 set_struct_expression(Expression
* expr
)
3588 go_assert(this->expr_
== NULL
);
3594 do_traverse(Traverse
* traverse
)
3595 { return Expression::traverse(&this->expr_
, traverse
); }
3598 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3604 do_determine_type(const Type_context
*)
3605 { this->expr_
->determine_type_no_context(); }
3608 do_check_types(Gogo
*);
3613 return Expression::make_field_reference(this->expr_
->copy(),
3619 do_is_addressable() const
3620 { return this->expr_
->is_addressable(); }
3623 do_address_taken(bool escapes
)
3624 { this->expr_
->address_taken(escapes
); }
3627 do_issue_nil_check()
3628 { this->expr_
->issue_nil_check(); }
3631 do_get_backend(Translate_context
*);
3634 do_dump_expression(Ast_dump_context
*) const;
3637 // The expression we are looking into. This should have a type of
3640 // The zero-based index of the field we are retrieving.
3641 unsigned int field_index_
;
3642 // Whether this node was emitted implicitly for an embedded field,
3643 // that is, expr_ is not the expr_ of the original user node.
3645 // Whether we have already emitted a fieldtrack call.
3646 bool called_fieldtrack_
;
3649 // A reference to a field of an interface.
3651 class Interface_field_reference_expression
: public Expression
3654 Interface_field_reference_expression(Expression
* expr
,
3655 const std::string
& name
,
3657 : Expression(EXPRESSION_INTERFACE_FIELD_REFERENCE
, location
),
3658 expr_(expr
), name_(name
)
3661 // Return the expression for the interface object.
3664 { return this->expr_
; }
3666 // Return the name of the method to call.
3669 { return this->name_
; }
3671 // Create a thunk to call the method NAME in TYPE when it is used as
3672 // part of a method value.
3673 static Named_object
*
3674 create_thunk(Gogo
*, Interface_type
* type
, const std::string
& name
);
3677 static Named_object
*
3678 lookup_thunk(Interface_type
* type
, const std::string
& name
);
3680 // Return an expression for the pointer to the function to call.
3684 // Return an expression for the first argument to pass to the interface
3685 // function. This is the real object associated with the interface object.
3687 get_underlying_object();
3691 do_traverse(Traverse
* traverse
);
3694 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3700 do_determine_type(const Type_context
*);
3703 do_check_types(Gogo
*);
3708 return Expression::make_interface_field_reference(this->expr_
->copy(),
3714 do_get_backend(Translate_context
*);
3717 do_dump_expression(Ast_dump_context
*) const;
3720 // A mapping from interface types to a list of thunks we have
3721 // created for methods.
3722 typedef std::vector
<std::pair
<std::string
, Named_object
*> > Method_thunks
;
3723 typedef Unordered_map(Interface_type
*, Method_thunks
*)
3724 Interface_method_thunks
;
3725 static Interface_method_thunks interface_method_thunks
;
3727 // The expression for the interface object. This should have a type
3728 // of interface or pointer to interface.
3730 // The field we are retrieving--the name of the method.
3734 // Implement the builtin function new.
3736 class Allocation_expression
: public Expression
3739 Allocation_expression(Type
* type
, Location location
)
3740 : Expression(EXPRESSION_ALLOCATION
, location
),
3741 type_(type
), allocate_on_stack_(false),
3746 set_allocate_on_stack()
3747 { this->allocate_on_stack_
= true; }
3749 // Mark that the allocated memory doesn't need zeroing.
3752 { this->no_zero_
= true; }
3756 do_traverse(Traverse
*);
3762 do_determine_type(const Type_context
*)
3766 do_check_types(Gogo
*);
3772 do_get_backend(Translate_context
*);
3775 do_dump_expression(Ast_dump_context
*) const;
3778 // The type we are allocating.
3780 // Whether or not this is a stack allocation.
3781 bool allocate_on_stack_
;
3782 // Whether we don't need to zero the allocated memory.
3786 // A general composite literal. This is lowered to a type specific
3789 class Composite_literal_expression
: public Parser_expression
3792 Composite_literal_expression(Type
* type
, int depth
, bool has_keys
,
3793 Expression_list
* vals
, bool all_are_names
,
3795 : Parser_expression(EXPRESSION_COMPOSITE_LITERAL
, location
),
3796 type_(type
), depth_(depth
), vals_(vals
), has_keys_(has_keys
),
3797 all_are_names_(all_are_names
), key_path_(std::vector
<bool>(depth
))
3801 // Mark the DEPTH entry of KEY_PATH as containing a key.
3803 update_key_path(size_t depth
)
3805 go_assert(depth
< this->key_path_
.size());
3806 this->key_path_
[depth
] = true;
3811 do_traverse(Traverse
* traverse
);
3814 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3820 do_dump_expression(Ast_dump_context
*) const;
3824 lower_struct(Gogo
*, Type
*);
3830 make_array(Type
*, const std::vector
<unsigned long>*, Expression_list
*);
3833 lower_map(Gogo
*, Named_object
*, Statement_inserter
*, Type
*);
3835 // The type of the composite literal.
3837 // The depth within a list of composite literals within a composite
3838 // literal, when the type is omitted.
3840 // The values to put in the composite literal.
3841 Expression_list
* vals_
;
3842 // If this is true, then VALS_ is a list of pairs: a key and a
3843 // value. In an array initializer, a missing key will be NULL.
3845 // If this is true, then HAS_KEYS_ is true, and every key is a
3846 // simple identifier.
3847 bool all_are_names_
;
3848 // A complement to DEPTH that indicates for each level starting from 0 to
3849 // DEPTH-1 whether or not this composite literal is nested inside of key or
3850 // a value. This is used to decide which type to use when given a map literal
3851 // with omitted key types.
3852 std::vector
<bool> key_path_
;
3855 // Helper/mixin class for struct and array construction expressions;
3856 // encapsulates a list of values plus an optional traversal order
3857 // recording the order in which the values should be visited.
3859 class Ordered_value_list
3862 Ordered_value_list(Expression_list
* vals
)
3863 : vals_(vals
), traverse_order_(NULL
)
3868 { return this->vals_
; }
3871 traverse_vals(Traverse
* traverse
);
3873 // Get the traversal order (may be NULL)
3874 std::vector
<unsigned long>*
3876 { return traverse_order_
; }
3878 // Set the traversal order, used to ensure that we implement the
3879 // order of evaluation rules. Takes ownership of the argument.
3881 set_traverse_order(std::vector
<unsigned long>* traverse_order
)
3882 { this->traverse_order_
= traverse_order
; }
3885 // The list of values, in order of the fields in the struct or in
3886 // order of indices in an array. A NULL value of vals_ means that
3887 // all fields/slots should be zero-initialized; a single NULL entry
3888 // in the list means that the corresponding field or array slot
3889 // should be zero-initialized.
3890 Expression_list
* vals_
;
3891 // If not NULL, the order in which to traverse vals_. This is used
3892 // so that we implement the order of evaluation rules correctly.
3893 std::vector
<unsigned long>* traverse_order_
;
3896 // Construct a struct.
3898 class Struct_construction_expression
: public Expression
,
3899 public Ordered_value_list
3902 Struct_construction_expression(Type
* type
, Expression_list
* vals
,
3904 : Expression(EXPRESSION_STRUCT_CONSTRUCTION
, location
),
3905 Ordered_value_list(vals
),
3909 // Return whether this is a constant initializer.
3911 is_constant_struct() const;
3915 do_traverse(Traverse
* traverse
);
3918 do_is_zero_value() const;
3921 do_is_static_initializer() const;
3925 { return this->type_
; }
3928 do_determine_type(const Type_context
*);
3931 do_check_types(Gogo
*);
3937 do_get_backend(Translate_context
*);
3940 do_export(Export_function_body
*) const;
3943 do_dump_expression(Ast_dump_context
*) const;
3946 do_add_conversions();
3949 // The type of the struct to construct.
3953 // Construct an array. This class is not used directly; instead we
3954 // use the child classes, Fixed_array_construction_expression and
3955 // Slice_construction_expression.
3957 class Array_construction_expression
: public Expression
,
3958 public Ordered_value_list
3961 Array_construction_expression(Expression_classification classification
,
3963 const std::vector
<unsigned long>* indexes
,
3964 Expression_list
* vals
, Location location
)
3965 : Expression(classification
, location
),
3966 Ordered_value_list(vals
),
3967 type_(type
), indexes_(indexes
)
3968 { go_assert(indexes
== NULL
|| indexes
->size() == vals
->size()); }
3971 // Return whether this is a constant initializer.
3973 is_constant_array() const;
3975 // Return the number of elements.
3977 element_count() const
3978 { return this->vals() == NULL
? 0 : this->vals()->size(); }
3982 do_traverse(Traverse
* traverse
);
3985 do_is_zero_value() const;
3988 do_is_static_initializer() const;
3992 { return this->type_
; }
3995 do_determine_type(const Type_context
*);
3998 do_check_types(Gogo
*);
4001 do_export(Export_function_body
*) const;
4004 const std::vector
<unsigned long>*
4006 { return this->indexes_
; }
4008 // Get the backend constructor for the array values.
4010 get_constructor(Translate_context
* context
, Btype
* btype
);
4013 do_dump_expression(Ast_dump_context
*) const;
4016 dump_slice_storage_expression(Ast_dump_context
*) const { }
4019 do_add_conversions();
4022 // The type of the array to construct.
4024 // The list of indexes into the array, one for each value. This may
4025 // be NULL, in which case the indexes start at zero and increment.
4026 const std::vector
<unsigned long>* indexes_
;
4029 // Construct a fixed array.
4031 class Fixed_array_construction_expression
:
4032 public Array_construction_expression
4035 Fixed_array_construction_expression(Type
* type
,
4036 const std::vector
<unsigned long>* indexes
,
4037 Expression_list
* vals
, Location location
);
4044 do_get_backend(Translate_context
*);
4047 // Construct a slice.
4049 class Slice_construction_expression
: public Array_construction_expression
4052 Slice_construction_expression(Type
* type
,
4053 const std::vector
<unsigned long>* indexes
,
4054 Expression_list
* vals
, Location location
);
4057 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4059 // Record that the storage for this slice (e.g. vals) cannot escape,
4060 // hence it can be stack-allocated.
4062 set_storage_does_not_escape()
4064 this->storage_escapes_
= false;
4068 // Note that taking the address of a slice literal is invalid.
4071 do_traverse(Traverse
* traverse
);
4077 do_get_backend(Translate_context
*);
4080 dump_slice_storage_expression(Ast_dump_context
* ast_dump_context
) const;
4082 // Create an array value for the constructed slice. Invoked during
4083 // flattening if slice storage does not escape, otherwise invoked
4084 // later on during do_get_backend().
4089 // The type of the values in this slice.
4091 // Array value expression, optionally filled in during flattening.
4092 Expression
* array_val_
;
4093 // Slice storage expression, optionally filled in during flattening.
4094 Expression
* slice_storage_
;
4095 // Normally true. Can be set to false if we know that the resulting
4096 // storage for the slice cannot escape.
4097 bool storage_escapes_
;
4102 class Map_construction_expression
: public Expression
4105 Map_construction_expression(Type
* type
, Expression_list
* vals
,
4107 : Expression(EXPRESSION_MAP_CONSTRUCTION
, location
),
4108 type_(type
), vals_(vals
), element_type_(NULL
), constructor_temp_(NULL
)
4109 { go_assert(vals
== NULL
|| vals
->size() % 2 == 0); }
4113 { return this->vals_
; }
4117 do_traverse(Traverse
* traverse
);
4120 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4124 { return this->type_
; }
4127 do_determine_type(const Type_context
*);
4130 do_check_types(Gogo
*);
4136 do_get_backend(Translate_context
*);
4139 do_export(Export_function_body
*) const;
4142 do_dump_expression(Ast_dump_context
*) const;
4145 do_add_conversions();
4148 // The type of the map to construct.
4150 // The list of values.
4151 Expression_list
* vals_
;
4152 // The type of the key-value pair struct for each map element.
4153 Struct_type
* element_type_
;
4154 // A temporary reference to the variable storing the constructor initializer.
4155 Temporary_statement
* constructor_temp_
;
4158 // A type guard expression.
4160 class Type_guard_expression
: public Expression
4163 Type_guard_expression(Expression
* expr
, Type
* type
, Location location
)
4164 : Expression(EXPRESSION_TYPE_GUARD
, location
),
4165 expr_(expr
), type_(type
)
4168 // Return the expression to convert.
4171 { return this->expr_
; }
4173 // Return the type to which to convert.
4176 { return this->type_
; }
4180 do_traverse(Traverse
* traverse
);
4183 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4187 { return this->type_
; }
4190 do_determine_type(const Type_context
*)
4191 { this->expr_
->determine_type_no_context(); }
4194 do_check_types(Gogo
*);
4200 do_get_backend(Translate_context
*);
4203 do_dump_expression(Ast_dump_context
*) const;
4206 // The expression to convert.
4208 // The type to which to convert.
4212 // Class Heap_expression.
4214 // When you take the address of an escaping expression, it is allocated
4215 // on the heap. This class implements that.
4217 class Heap_expression
: public Expression
4220 Heap_expression(Expression
* expr
, Location location
)
4221 : Expression(EXPRESSION_HEAP
, location
),
4222 expr_(expr
), allocate_on_stack_(false)
4227 { return this->expr_
; }
4230 set_allocate_on_stack()
4231 { this->allocate_on_stack_
= true; }
4235 do_traverse(Traverse
* traverse
)
4236 { return Expression::traverse(&this->expr_
, traverse
); }
4241 do_determine_type(const Type_context
*)
4242 { this->expr_
->determine_type_no_context(); }
4247 return Expression::make_heap_expression(this->expr_
->copy(),
4252 do_get_backend(Translate_context
*);
4254 // We only export global objects, and the parser does not generate
4255 // this in global scope.
4257 do_export(Export_function_body
*) const
4258 { go_unreachable(); }
4261 do_dump_expression(Ast_dump_context
*) const;
4264 // The expression which is being put on the heap.
4266 // Whether or not this is a stack allocation.
4267 bool allocate_on_stack_
;
4270 // A receive expression.
4272 class Receive_expression
: public Expression
4275 Receive_expression(Expression
* channel
, Location location
)
4276 : Expression(EXPRESSION_RECEIVE
, location
),
4277 channel_(channel
), temp_receiver_(NULL
)
4280 // Return the channel.
4283 { return this->channel_
; }
4286 do_import(Import_expression
*, Location
);
4290 do_traverse(Traverse
* traverse
)
4291 { return Expression::traverse(&this->channel_
, traverse
); }
4294 do_discarding_value()
4301 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
4304 do_determine_type(const Type_context
*)
4305 { this->channel_
->determine_type_no_context(); }
4308 do_check_types(Gogo
*);
4313 return Expression::make_receive(this->channel_
->copy(), this->location());
4317 do_inlining_cost() const
4321 do_must_eval_in_order() const
4325 do_get_backend(Translate_context
*);
4328 do_export(Export_function_body
*) const;
4331 do_dump_expression(Ast_dump_context
*) const;
4334 // The channel from which we are receiving.
4335 Expression
* channel_
;
4336 // A temporary reference to the variable storing the received data.
4337 Temporary_statement
* temp_receiver_
;
4340 // An expression that represents a slice value: a struct with value pointer,
4341 // length, and capacity fields.
4343 class Slice_value_expression
: public Expression
4346 Slice_value_expression(Type
* type
, Expression
* valmem
, Expression
* len
,
4347 Expression
* cap
, Location location
)
4348 : Expression(EXPRESSION_SLICE_VALUE
, location
),
4349 type_(type
), valmem_(valmem
), len_(len
), cap_(cap
)
4352 // The memory holding the values in the slice. The type should be a
4353 // pointer to the element value of the slice.
4356 { return this->valmem_
; }
4360 do_traverse(Traverse
*);
4364 { return this->type_
; }
4367 do_determine_type(const Type_context
*);
4373 do_get_backend(Translate_context
* context
);
4376 do_dump_expression(Ast_dump_context
*) const;
4379 // The type of the slice value.
4381 // The memory holding the values in the slice.
4382 Expression
* valmem_
;
4383 // The length of the slice.
4385 // The capacity of the slice.
4389 // An expression that evaluates to some characteristic of a slice.
4390 // This is used when indexing, bound-checking, or nil checking a slice.
4392 class Slice_info_expression
: public Expression
4395 Slice_info_expression(Expression
* slice
, Slice_info slice_info
,
4397 : Expression(EXPRESSION_SLICE_INFO
, location
),
4398 slice_(slice
), slice_info_(slice_info
)
4401 // The slice operand of this slice info expression.
4404 { return this->slice_
; }
4406 // The info this expression is about.
4409 { return this->slice_info_
; }
4413 do_traverse(Traverse
* traverse
)
4414 { return Expression::traverse(&this->slice_
, traverse
); }
4420 do_determine_type(const Type_context
*)
4421 { this->slice_
->determine_type_no_context(); }
4426 return new Slice_info_expression(this->slice_
->copy(), this->slice_info_
,
4431 do_get_backend(Translate_context
* context
);
4434 do_dump_expression(Ast_dump_context
*) const;
4437 do_issue_nil_check()
4438 { this->slice_
->issue_nil_check(); }
4441 // The slice for which we are getting information.
4443 // What information we want.
4444 Slice_info slice_info_
;
4447 // Conditional expressions.
4449 class Conditional_expression
: public Expression
4452 Conditional_expression(Expression
* cond
, Expression
* then_expr
,
4453 Expression
* else_expr
, Location location
)
4454 : Expression(EXPRESSION_CONDITIONAL
, location
),
4455 cond_(cond
), then_(then_expr
), else_(else_expr
)
4460 { return this->cond_
; }
4464 { return this->then_
; }
4468 { return this->else_
; }
4472 do_traverse(Traverse
*);
4478 do_determine_type(const Type_context
*);
4483 return new Conditional_expression(this->cond_
->copy(), this->then_
->copy(),
4484 this->else_
->copy(), this->location());
4488 do_get_backend(Translate_context
* context
);
4491 do_dump_expression(Ast_dump_context
*) const;
4494 // The condition to be checked.
4496 // The expression to execute if the condition is true.
4498 // The expression to execute if the condition is false.
4502 // Compound expressions.
4504 class Compound_expression
: public Expression
4507 Compound_expression(Expression
* init
, Expression
* expr
, Location location
)
4508 : Expression(EXPRESSION_COMPOUND
, location
), init_(init
), expr_(expr
)
4513 { return this->init_
; }
4517 { return this->expr_
; }
4521 do_traverse(Traverse
*);
4527 do_determine_type(const Type_context
*);
4532 return new Compound_expression(this->init_
->copy(), this->expr_
->copy(),
4537 do_get_backend(Translate_context
* context
);
4540 do_dump_expression(Ast_dump_context
*) const;
4543 // The expression that is evaluated first and discarded.
4545 // The expression that is evaluated and returned.
4549 // A backend expression. This is a backend expression wrapped in an
4550 // Expression, for convenience during backend generation.
4552 class Backend_expression
: public Expression
4555 Backend_expression(Bexpression
* bexpr
, Type
* type
, Location location
)
4556 : Expression(EXPRESSION_BACKEND
, location
), bexpr_(bexpr
), type_(type
)
4561 do_traverse(Traverse
*);
4563 // For now these are always valid static initializers. If that
4564 // changes we can change this.
4566 do_is_static_initializer() const
4571 { return this->type_
; }
4574 do_determine_type(const Type_context
*)
4581 do_get_backend(Translate_context
*)
4582 { return this->bexpr_
; }
4585 do_dump_expression(Ast_dump_context
*) const;
4588 // The backend expression we are wrapping.
4589 Bexpression
* bexpr_
;
4590 // The type of the expression;
4594 // A numeric constant. This is used both for untyped constants and
4595 // for constants that have a type.
4597 class Numeric_constant
4601 : classification_(NC_INVALID
), type_(NULL
)
4604 ~Numeric_constant();
4606 Numeric_constant(const Numeric_constant
&);
4608 Numeric_constant
& operator=(const Numeric_constant
&);
4610 // Check equality with another numeric constant.
4612 equals(const Numeric_constant
&) const;
4614 // Set to an unsigned long value.
4616 set_unsigned_long(Type
*, unsigned long);
4618 // Set to an integer value.
4620 set_int(Type
*, const mpz_t
);
4622 // Set to a rune value.
4624 set_rune(Type
*, const mpz_t
);
4626 // Set to a floating point value.
4628 set_float(Type
*, const mpfr_t
);
4630 // Set to a complex value.
4632 set_complex(Type
*, const mpc_t
);
4634 // Mark numeric constant as invalid.
4637 { this->classification_
= NC_INVALID
; }
4642 { return this->classification_
== Numeric_constant::NC_INT
; }
4646 { return this->classification_
== Numeric_constant::NC_RUNE
; }
4650 { return this->classification_
== Numeric_constant::NC_FLOAT
; }
4654 { return this->classification_
== Numeric_constant::NC_COMPLEX
; }
4658 { return this->classification_
== Numeric_constant::NC_INVALID
; }
4660 // Value retrievers. These will initialize the values as well as
4661 // set them. GET_INT is only valid if IS_INT returns true, and
4662 // likewise respectively.
4664 get_int(mpz_t
*) const;
4667 get_rune(mpz_t
*) const;
4670 get_float(mpfr_t
*) const;
4673 get_complex(mpc_t
*) const;
4675 // Codes returned by to_unsigned_long.
4676 enum To_unsigned_long
4678 // Value is integer and fits in unsigned long.
4680 // Value is not integer.
4682 // Value is integer but is negative.
4684 // Value is non-negative integer but does not fit in unsigned
4689 // If the value can be expressed as an integer that fits in an
4690 // unsigned long, set *VAL and return NC_UL_VALID. Otherwise return
4691 // one of the other To_unsigned_long codes.
4693 to_unsigned_long(unsigned long* val
) const;
4695 // If the value can be expressed as an integer that describes the
4696 // size of an object in memory, set *VAL and return true.
4697 // Otherwise, return false. Currently we use int64_t to represent a
4698 // memory size, as in Type::backend_type_size.
4700 to_memory_size(int64_t* val
) const;
4702 // If the value can be expressed as an int, return true and
4703 // initialize and set VAL. This will return false for a value with
4704 // an explicit float or complex type, even if the value is integral.
4706 to_int(mpz_t
* val
) const;
4708 // If the value can be expressed as a float, return true and
4709 // initialize and set VAL.
4711 to_float(mpfr_t
* val
) const;
4713 // If the value can be expressed as a complex, return true and
4714 // initialize and set VR and VI.
4716 to_complex(mpc_t
* val
) const;
4722 // If the constant can be expressed in TYPE, then set the type of
4723 // the constant to TYPE and return true. Otherwise return false,
4724 // and, if ISSUE_ERROR is true, issue an error message. LOCATION is
4725 // the location to use for the error.
4727 set_type(Type
* type
, bool issue_error
, Location location
);
4729 // Return an Expression for this value.
4731 expression(Location
) const;
4733 // Calculate a hash code with a given seed.
4735 hash(unsigned int seed
) const;
4742 mpz_to_unsigned_long(const mpz_t ival
, unsigned long *val
) const;
4745 mpfr_to_unsigned_long(const mpfr_t fval
, unsigned long *val
) const;
4748 mpz_to_memory_size(const mpz_t ival
, int64_t* val
) const;
4751 mpfr_to_memory_size(const mpfr_t fval
, int64_t* val
) const;
4754 check_int_type(Integer_type
*, bool, Location
);
4757 check_float_type(Float_type
*, bool, Location
);
4760 check_complex_type(Complex_type
*, bool, Location
);
4763 is_float_neg_zero(const mpfr_t
, int bits
);
4765 // The kinds of constants.
4775 // The kind of constant.
4776 Classification classification_
;
4780 // If NC_INT or NC_RUNE.
4787 // The type if there is one. This will be NULL for an untyped
4792 // Temporary buffer size for string conversions.
4793 // Also known to the runtime as tmpStringBufSize in runtime/string.go.
4794 static const int tmp_string_buf_size
= 32;
4796 #endif // !defined(GO_EXPRESSIONS_H)