1 // expressions.cc -- Go frontend expression handling.
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.
16 #include "statements.h"
20 #include "expressions.h"
25 Expression::Expression(Expression_classification classification
,
27 : classification_(classification
), location_(location
)
31 Expression::~Expression()
35 // Traverse the expressions.
38 Expression::traverse(Expression
** pexpr
, Traverse
* traverse
)
40 Expression
* expr
= *pexpr
;
41 if ((traverse
->traverse_mask() & Traverse::traverse_expressions
) != 0)
43 int t
= traverse
->expression(pexpr
);
44 if (t
== TRAVERSE_EXIT
)
46 else if (t
== TRAVERSE_SKIP_COMPONENTS
)
47 return TRAVERSE_CONTINUE
;
49 return expr
->do_traverse(traverse
);
52 // Traverse subexpressions of this expression.
55 Expression::traverse_subexpressions(Traverse
* traverse
)
57 return this->do_traverse(traverse
);
60 // Default implementation for do_traverse for child classes.
63 Expression::do_traverse(Traverse
*)
65 return TRAVERSE_CONTINUE
;
68 // This virtual function is called by the parser if the value of this
69 // expression is being discarded. By default, we give an error.
70 // Expressions with side effects override.
73 Expression::do_discarding_value()
75 this->unused_value_error();
79 // This virtual function is called to export expressions. This will
80 // only be used by expressions which may be constant.
83 Expression::do_export(Export
*) const
88 // Give an error saying that the value of the expression is not used.
91 Expression::unused_value_error()
93 this->report_error(_("value computed is not used"));
96 // Note that this expression is an error. This is called by children
97 // when they discover an error.
100 Expression::set_is_error()
102 this->classification_
= EXPRESSION_ERROR
;
105 // For children to call to report an error conveniently.
108 Expression::report_error(const char* msg
)
110 error_at(this->location_
, "%s", msg
);
111 this->set_is_error();
114 // Set types of variables and constants. This is implemented by the
118 Expression::determine_type(const Type_context
* context
)
120 this->do_determine_type(context
);
123 // Set types when there is no context.
126 Expression::determine_type_no_context()
128 Type_context context
;
129 this->do_determine_type(&context
);
132 // Return an expression handling any conversions which must be done during
136 Expression::convert_for_assignment(Gogo
* gogo
, Type
* lhs_type
,
137 Expression
* rhs
, Location location
)
139 Type
* rhs_type
= rhs
->type();
140 if (lhs_type
->is_error()
141 || rhs_type
->is_error()
142 || rhs
->is_error_expression())
143 return Expression::make_error(location
);
145 if (lhs_type
->forwarded() != rhs_type
->forwarded()
146 && lhs_type
->interface_type() != NULL
)
148 if (rhs_type
->interface_type() == NULL
)
149 return Expression::convert_type_to_interface(lhs_type
, rhs
, location
);
151 return Expression::convert_interface_to_interface(lhs_type
, rhs
, false,
154 else if (lhs_type
->forwarded() != rhs_type
->forwarded()
155 && rhs_type
->interface_type() != NULL
)
156 return Expression::convert_interface_to_type(lhs_type
, rhs
, location
);
157 else if (lhs_type
->is_slice_type() && rhs_type
->is_nil_type())
159 // Assigning nil to a slice.
160 Expression
* nil
= Expression::make_nil(location
);
161 Expression
* zero
= Expression::make_integer_ul(0, NULL
, location
);
162 return Expression::make_slice_value(lhs_type
, nil
, zero
, zero
, location
);
164 else if (rhs_type
->is_nil_type())
165 return Expression::make_nil(location
);
166 else if (Type::are_identical(lhs_type
, rhs_type
, false, NULL
))
168 // No conversion is needed.
171 else if (lhs_type
->points_to() != NULL
)
172 return Expression::make_unsafe_cast(lhs_type
, rhs
, location
);
173 else if (lhs_type
->is_numeric_type())
174 return Expression::make_cast(lhs_type
, rhs
, location
);
175 else if ((lhs_type
->struct_type() != NULL
176 && rhs_type
->struct_type() != NULL
)
177 || (lhs_type
->array_type() != NULL
178 && rhs_type
->array_type() != NULL
))
180 // Avoid confusion from zero sized variables which may be
181 // represented as non-zero-sized.
182 // TODO(cmang): This check is for a GCC-specific issue, and should be
183 // removed from the frontend. FIXME.
184 size_t lhs_size
= gogo
->backend()->type_size(lhs_type
->get_backend(gogo
));
185 size_t rhs_size
= gogo
->backend()->type_size(rhs_type
->get_backend(gogo
));
186 if (rhs_size
== 0 || lhs_size
== 0)
189 // This conversion must be permitted by Go, or we wouldn't have
191 return Expression::make_unsafe_cast(lhs_type
, rhs
, location
);
197 // Return an expression for a conversion from a non-interface type to an
201 Expression::convert_type_to_interface(Type
* lhs_type
, Expression
* rhs
,
204 Interface_type
* lhs_interface_type
= lhs_type
->interface_type();
205 bool lhs_is_empty
= lhs_interface_type
->is_empty();
207 // Since RHS_TYPE is a static type, we can create the interface
208 // method table at compile time.
210 // When setting an interface to nil, we just set both fields to
212 Type
* rhs_type
= rhs
->type();
213 if (rhs_type
->is_nil_type())
215 Expression
* nil
= Expression::make_nil(location
);
216 return Expression::make_interface_value(lhs_type
, nil
, nil
, location
);
219 // This should have been checked already.
220 go_assert(lhs_interface_type
->implements_interface(rhs_type
, NULL
));
222 // An interface is a tuple. If LHS_TYPE is an empty interface type,
223 // then the first field is the type descriptor for RHS_TYPE.
224 // Otherwise it is the interface method table for RHS_TYPE.
225 Expression
* first_field
;
227 first_field
= Expression::make_type_descriptor(rhs_type
, location
);
230 // Build the interface method table for this interface and this
231 // object type: a list of function pointers for each interface
233 Named_type
* rhs_named_type
= rhs_type
->named_type();
234 Struct_type
* rhs_struct_type
= rhs_type
->struct_type();
235 bool is_pointer
= false;
236 if (rhs_named_type
== NULL
&& rhs_struct_type
== NULL
)
238 rhs_named_type
= rhs_type
->deref()->named_type();
239 rhs_struct_type
= rhs_type
->deref()->struct_type();
242 if (rhs_named_type
!= NULL
)
244 rhs_named_type
->interface_method_table(lhs_interface_type
,
246 else if (rhs_struct_type
!= NULL
)
248 rhs_struct_type
->interface_method_table(lhs_interface_type
,
251 first_field
= Expression::make_nil(location
);
255 if (rhs_type
->points_to() != NULL
)
257 // We are assigning a pointer to the interface; the interface
258 // holds the pointer itself.
263 // We are assigning a non-pointer value to the interface; the
264 // interface gets a copy of the value in the heap.
265 obj
= Expression::make_heap_expression(rhs
, location
);
268 return Expression::make_interface_value(lhs_type
, first_field
, obj
, location
);
271 // Return an expression for the type descriptor of RHS.
274 Expression::get_interface_type_descriptor(Expression
* rhs
)
276 go_assert(rhs
->type()->interface_type() != NULL
);
277 Location location
= rhs
->location();
279 // The type descriptor is the first field of an empty interface.
280 if (rhs
->type()->interface_type()->is_empty())
281 return Expression::make_interface_info(rhs
, INTERFACE_INFO_TYPE_DESCRIPTOR
,
285 Expression::make_interface_info(rhs
, INTERFACE_INFO_METHODS
, location
);
287 Expression
* descriptor
=
288 Expression::make_unary(OPERATOR_MULT
, mtable
, location
);
289 descriptor
= Expression::make_field_reference(descriptor
, 0, location
);
290 Expression
* nil
= Expression::make_nil(location
);
293 Expression::make_binary(OPERATOR_EQEQ
, mtable
, nil
, location
);
294 return Expression::make_conditional(eq
, nil
, descriptor
, location
);
297 // Return an expression for the conversion of an interface type to an
301 Expression::convert_interface_to_interface(Type
*lhs_type
, Expression
* rhs
,
305 Interface_type
* lhs_interface_type
= lhs_type
->interface_type();
306 bool lhs_is_empty
= lhs_interface_type
->is_empty();
308 // In the general case this requires runtime examination of the type
309 // method table to match it up with the interface methods.
311 // FIXME: If all of the methods in the right hand side interface
312 // also appear in the left hand side interface, then we don't need
313 // to do a runtime check, although we still need to build a new
316 // Get the type descriptor for the right hand side. This will be
317 // NULL for a nil interface.
318 Expression
* rhs_type_expr
= Expression::get_interface_type_descriptor(rhs
);
319 Expression
* lhs_type_expr
=
320 Expression::make_type_descriptor(lhs_type
, location
);
322 Expression
* first_field
;
325 // A type assertion fails when converting a nil interface.
327 Runtime::make_call(Runtime::ASSERT_INTERFACE
, location
, 2,
328 lhs_type_expr
, rhs_type_expr
);
330 else if (lhs_is_empty
)
332 // A conversion to an empty interface always succeeds, and the
333 // first field is just the type descriptor of the object.
334 first_field
= rhs_type_expr
;
338 // A conversion to a non-empty interface may fail, but unlike a
339 // type assertion converting nil will always succeed.
341 Runtime::make_call(Runtime::CONVERT_INTERFACE
, location
, 2,
342 lhs_type_expr
, rhs_type_expr
);
345 // The second field is simply the object pointer.
347 Expression::make_interface_info(rhs
, INTERFACE_INFO_OBJECT
, location
);
348 return Expression::make_interface_value(lhs_type
, first_field
, obj
, location
);
351 // Return an expression for the conversion of an interface type to a
352 // non-interface type.
355 Expression::convert_interface_to_type(Type
*lhs_type
, Expression
* rhs
,
358 // Call a function to check that the type is valid. The function
359 // will panic with an appropriate runtime type error if the type is
361 Expression
* lhs_type_expr
= Expression::make_type_descriptor(lhs_type
,
363 Expression
* rhs_descriptor
=
364 Expression::get_interface_type_descriptor(rhs
);
366 Type
* rhs_type
= rhs
->type();
367 Expression
* rhs_inter_expr
= Expression::make_type_descriptor(rhs_type
,
370 Expression
* check_iface
= Runtime::make_call(Runtime::CHECK_INTERFACE_TYPE
,
371 location
, 3, lhs_type_expr
,
372 rhs_descriptor
, rhs_inter_expr
);
374 // If the call succeeds, pull out the value.
375 Expression
* obj
= Expression::make_interface_info(rhs
, INTERFACE_INFO_OBJECT
,
378 // If the value is a pointer, then it is the value we want.
379 // Otherwise it points to the value.
380 if (lhs_type
->points_to() == NULL
)
382 obj
= Expression::make_unsafe_cast(Type::make_pointer_type(lhs_type
), obj
,
384 obj
= Expression::make_unary(OPERATOR_MULT
, obj
, location
);
386 return Expression::make_compound(check_iface
, obj
, location
);
389 // Convert an expression to its backend representation. This is implemented by
390 // the child class. Not that it is not in general safe to call this multiple
391 // times for a single expression, but that we don't catch such errors.
394 Expression::get_backend(Translate_context
* context
)
396 // The child may have marked this expression as having an error.
397 if (this->classification_
== EXPRESSION_ERROR
)
398 return context
->backend()->error_expression();
400 return this->do_get_backend(context
);
403 // Return a backend expression for VAL.
405 Expression::backend_numeric_constant_expression(Translate_context
* context
,
406 Numeric_constant
* val
)
408 Gogo
* gogo
= context
->gogo();
409 Type
* type
= val
->type();
411 return gogo
->backend()->error_expression();
413 Btype
* btype
= type
->get_backend(gogo
);
415 if (type
->integer_type() != NULL
)
418 if (!val
->to_int(&ival
))
420 go_assert(saw_errors());
421 return gogo
->backend()->error_expression();
423 ret
= gogo
->backend()->integer_constant_expression(btype
, ival
);
426 else if (type
->float_type() != NULL
)
429 if (!val
->to_float(&fval
))
431 go_assert(saw_errors());
432 return gogo
->backend()->error_expression();
434 ret
= gogo
->backend()->float_constant_expression(btype
, fval
);
437 else if (type
->complex_type() != NULL
)
440 if (!val
->to_complex(&cval
))
442 go_assert(saw_errors());
443 return gogo
->backend()->error_expression();
445 ret
= gogo
->backend()->complex_constant_expression(btype
, cval
);
454 // Return an expression which evaluates to true if VAL, of arbitrary integer
455 // type, is negative or is more than the maximum value of the Go type "int".
458 Expression::check_bounds(Expression
* val
, Location loc
)
460 Type
* val_type
= val
->type();
461 Type
* bound_type
= Type::lookup_integer_type("int");
464 bool val_is_unsigned
= false;
465 if (val_type
->integer_type() != NULL
)
467 val_type_size
= val_type
->integer_type()->bits();
468 val_is_unsigned
= val_type
->integer_type()->is_unsigned();
472 if (!val_type
->is_numeric_type()
473 || !Type::are_convertible(bound_type
, val_type
, NULL
))
475 go_assert(saw_errors());
476 return Expression::make_boolean(true, loc
);
479 if (val_type
->complex_type() != NULL
)
480 val_type_size
= val_type
->complex_type()->bits();
482 val_type_size
= val_type
->float_type()->bits();
485 Expression
* negative_index
= Expression::make_boolean(false, loc
);
486 Expression
* index_overflows
= Expression::make_boolean(false, loc
);
487 if (!val_is_unsigned
)
489 Expression
* zero
= Expression::make_integer_ul(0, val_type
, loc
);
490 negative_index
= Expression::make_binary(OPERATOR_LT
, val
, zero
, loc
);
493 int bound_type_size
= bound_type
->integer_type()->bits();
494 if (val_type_size
> bound_type_size
495 || (val_type_size
== bound_type_size
499 mpz_init_set_ui(one
, 1UL);
501 // maxval = 2^(bound_type_size - 1) - 1
504 mpz_mul_2exp(maxval
, one
, bound_type_size
- 1);
505 mpz_sub_ui(maxval
, maxval
, 1);
506 Expression
* max
= Expression::make_integer_z(&maxval
, val_type
, loc
);
510 index_overflows
= Expression::make_binary(OPERATOR_GT
, val
, max
, loc
);
513 return Expression::make_binary(OPERATOR_OROR
, negative_index
, index_overflows
,
518 Expression::dump_expression(Ast_dump_context
* ast_dump_context
) const
520 this->do_dump_expression(ast_dump_context
);
523 // Error expressions. This are used to avoid cascading errors.
525 class Error_expression
: public Expression
528 Error_expression(Location location
)
529 : Expression(EXPRESSION_ERROR
, location
)
534 do_is_constant() const
538 do_is_immutable() const
542 do_numeric_constant_value(Numeric_constant
* nc
) const
544 nc
->set_unsigned_long(NULL
, 0);
549 do_discarding_value()
554 { return Type::make_error_type(); }
557 do_determine_type(const Type_context
*)
565 do_is_addressable() const
569 do_get_backend(Translate_context
* context
)
570 { return context
->backend()->error_expression(); }
573 do_dump_expression(Ast_dump_context
*) const;
576 // Dump the ast representation for an error expression to a dump context.
579 Error_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
581 ast_dump_context
->ostream() << "_Error_" ;
585 Expression::make_error(Location location
)
587 return new Error_expression(location
);
590 // An expression which is really a type. This is used during parsing.
591 // It is an error if these survive after lowering.
594 Type_expression
: public Expression
597 Type_expression(Type
* type
, Location location
)
598 : Expression(EXPRESSION_TYPE
, location
),
604 do_traverse(Traverse
* traverse
)
605 { return Type::traverse(this->type_
, traverse
); }
609 { return this->type_
; }
612 do_determine_type(const Type_context
*)
616 do_check_types(Gogo
*)
617 { this->report_error(_("invalid use of type")); }
624 do_get_backend(Translate_context
*)
625 { go_unreachable(); }
627 void do_dump_expression(Ast_dump_context
*) const;
630 // The type which we are representing as an expression.
635 Type_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
637 ast_dump_context
->dump_type(this->type_
);
641 Expression::make_type(Type
* type
, Location location
)
643 return new Type_expression(type
, location
);
646 // Class Parser_expression.
649 Parser_expression::do_type()
651 // We should never really ask for the type of a Parser_expression.
652 // However, it can happen, at least when we have an invalid const
653 // whose initializer refers to the const itself. In that case we
654 // may ask for the type when lowering the const itself.
655 go_assert(saw_errors());
656 return Type::make_error_type();
659 // Class Var_expression.
661 // Lower a variable expression. Here we just make sure that the
662 // initialization expression of the variable has been lowered. This
663 // ensures that we will be able to determine the type of the variable
667 Var_expression::do_lower(Gogo
* gogo
, Named_object
* function
,
668 Statement_inserter
* inserter
, int)
670 if (this->variable_
->is_variable())
672 Variable
* var
= this->variable_
->var_value();
673 // This is either a local variable or a global variable. A
674 // reference to a variable which is local to an enclosing
675 // function will be a reference to a field in a closure.
676 if (var
->is_global())
681 var
->lower_init_expression(gogo
, function
, inserter
);
686 // Return the type of a reference to a variable.
689 Var_expression::do_type()
691 if (this->variable_
->is_variable())
692 return this->variable_
->var_value()->type();
693 else if (this->variable_
->is_result_variable())
694 return this->variable_
->result_var_value()->type();
699 // Determine the type of a reference to a variable.
702 Var_expression::do_determine_type(const Type_context
*)
704 if (this->variable_
->is_variable())
705 this->variable_
->var_value()->determine_type();
708 // Something takes the address of this variable. This means that we
709 // may want to move the variable onto the heap.
712 Var_expression::do_address_taken(bool escapes
)
716 if (this->variable_
->is_variable())
717 this->variable_
->var_value()->set_non_escaping_address_taken();
718 else if (this->variable_
->is_result_variable())
719 this->variable_
->result_var_value()->set_non_escaping_address_taken();
725 if (this->variable_
->is_variable())
726 this->variable_
->var_value()->set_address_taken();
727 else if (this->variable_
->is_result_variable())
728 this->variable_
->result_var_value()->set_address_taken();
734 // Get the backend representation for a reference to a variable.
737 Var_expression::do_get_backend(Translate_context
* context
)
739 Bvariable
* bvar
= this->variable_
->get_backend_variable(context
->gogo(),
740 context
->function());
742 Location loc
= this->location();
744 Gogo
* gogo
= context
->gogo();
745 if (this->variable_
->is_variable())
747 is_in_heap
= this->variable_
->var_value()->is_in_heap();
748 btype
= this->variable_
->var_value()->type()->get_backend(gogo
);
750 else if (this->variable_
->is_result_variable())
752 is_in_heap
= this->variable_
->result_var_value()->is_in_heap();
753 btype
= this->variable_
->result_var_value()->type()->get_backend(gogo
);
758 Bexpression
* ret
= context
->backend()->var_expression(bvar
, loc
);
760 ret
= context
->backend()->indirect_expression(btype
, ret
, true, loc
);
764 // Ast dump for variable expression.
767 Var_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
769 ast_dump_context
->ostream() << this->variable_
->name() ;
772 // Make a reference to a variable in an expression.
775 Expression::make_var_reference(Named_object
* var
, Location location
)
778 return Expression::make_sink(location
);
780 // FIXME: Creating a new object for each reference to a variable is
782 return new Var_expression(var
, location
);
785 // Class Temporary_reference_expression.
790 Temporary_reference_expression::do_type()
792 return this->statement_
->type();
795 // Called if something takes the address of this temporary variable.
796 // We never have to move temporary variables to the heap, but we do
797 // need to know that they must live in the stack rather than in a
801 Temporary_reference_expression::do_address_taken(bool)
803 this->statement_
->set_is_address_taken();
806 // Get a backend expression referring to the variable.
809 Temporary_reference_expression::do_get_backend(Translate_context
* context
)
811 Gogo
* gogo
= context
->gogo();
812 Bvariable
* bvar
= this->statement_
->get_backend_variable(context
);
813 Bexpression
* ret
= gogo
->backend()->var_expression(bvar
, this->location());
815 // The backend can't always represent the same set of recursive types
816 // that the Go frontend can. In some cases this means that a
817 // temporary variable won't have the right backend type. Correct
818 // that here by adding a type cast. We need to use base() to push
819 // the circularity down one level.
820 Type
* stype
= this->statement_
->type();
821 if (!this->is_lvalue_
822 && stype
->has_pointer()
823 && stype
->deref()->is_void_type())
825 Btype
* btype
= this->type()->base()->get_backend(gogo
);
826 ret
= gogo
->backend()->convert_expression(btype
, ret
, this->location());
831 // Ast dump for temporary reference.
834 Temporary_reference_expression::do_dump_expression(
835 Ast_dump_context
* ast_dump_context
) const
837 ast_dump_context
->dump_temp_variable_name(this->statement_
);
840 // Make a reference to a temporary variable.
842 Temporary_reference_expression
*
843 Expression::make_temporary_reference(Temporary_statement
* statement
,
846 return new Temporary_reference_expression(statement
, location
);
849 // Class Set_and_use_temporary_expression.
854 Set_and_use_temporary_expression::do_type()
856 return this->statement_
->type();
859 // Determine the type of the expression.
862 Set_and_use_temporary_expression::do_determine_type(
863 const Type_context
* context
)
865 this->expr_
->determine_type(context
);
871 Set_and_use_temporary_expression::do_address_taken(bool)
873 this->statement_
->set_is_address_taken();
876 // Return the backend representation.
879 Set_and_use_temporary_expression::do_get_backend(Translate_context
* context
)
881 Location loc
= this->location();
882 Gogo
* gogo
= context
->gogo();
883 Bvariable
* bvar
= this->statement_
->get_backend_variable(context
);
884 Bexpression
* var_ref
= gogo
->backend()->var_expression(bvar
, loc
);
886 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
887 Bstatement
* set
= gogo
->backend()->assignment_statement(var_ref
, bexpr
, loc
);
888 var_ref
= gogo
->backend()->var_expression(bvar
, loc
);
889 Bexpression
* ret
= gogo
->backend()->compound_expression(set
, var_ref
, loc
);
896 Set_and_use_temporary_expression::do_dump_expression(
897 Ast_dump_context
* ast_dump_context
) const
899 ast_dump_context
->ostream() << '(';
900 ast_dump_context
->dump_temp_variable_name(this->statement_
);
901 ast_dump_context
->ostream() << " = ";
902 this->expr_
->dump_expression(ast_dump_context
);
903 ast_dump_context
->ostream() << ')';
906 // Make a set-and-use temporary.
908 Set_and_use_temporary_expression
*
909 Expression::make_set_and_use_temporary(Temporary_statement
* statement
,
910 Expression
* expr
, Location location
)
912 return new Set_and_use_temporary_expression(statement
, expr
, location
);
915 // A sink expression--a use of the blank identifier _.
917 class Sink_expression
: public Expression
920 Sink_expression(Location location
)
921 : Expression(EXPRESSION_SINK
, location
),
922 type_(NULL
), bvar_(NULL
)
927 do_discarding_value()
934 do_determine_type(const Type_context
*);
938 { return new Sink_expression(this->location()); }
941 do_get_backend(Translate_context
*);
944 do_dump_expression(Ast_dump_context
*) const;
947 // The type of this sink variable.
949 // The temporary variable we generate.
953 // Return the type of a sink expression.
956 Sink_expression::do_type()
958 if (this->type_
== NULL
)
959 return Type::make_sink_type();
963 // Determine the type of a sink expression.
966 Sink_expression::do_determine_type(const Type_context
* context
)
968 if (context
->type
!= NULL
)
969 this->type_
= context
->type
;
972 // Return a temporary variable for a sink expression. This will
973 // presumably be a write-only variable which the middle-end will drop.
976 Sink_expression::do_get_backend(Translate_context
* context
)
978 Location loc
= this->location();
979 Gogo
* gogo
= context
->gogo();
980 if (this->bvar_
== NULL
)
982 go_assert(this->type_
!= NULL
&& !this->type_
->is_sink_type());
983 Named_object
* fn
= context
->function();
984 go_assert(fn
!= NULL
);
985 Bfunction
* fn_ctx
= fn
->func_value()->get_or_make_decl(gogo
, fn
);
986 Btype
* bt
= this->type_
->get_backend(context
->gogo());
989 gogo
->backend()->temporary_variable(fn_ctx
, context
->bblock(), bt
, NULL
,
991 Bexpression
* var_ref
= gogo
->backend()->var_expression(this->bvar_
, loc
);
992 var_ref
= gogo
->backend()->compound_expression(decl
, var_ref
, loc
);
995 return gogo
->backend()->var_expression(this->bvar_
, loc
);
998 // Ast dump for sink expression.
1001 Sink_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
1003 ast_dump_context
->ostream() << "_" ;
1006 // Make a sink expression.
1009 Expression::make_sink(Location location
)
1011 return new Sink_expression(location
);
1014 // Class Func_expression.
1016 // FIXME: Can a function expression appear in a constant expression?
1017 // The value is unchanging. Initializing a constant to the address of
1018 // a function seems like it could work, though there might be little
1024 Func_expression::do_traverse(Traverse
* traverse
)
1026 return (this->closure_
== NULL
1028 : Expression::traverse(&this->closure_
, traverse
));
1031 // Return the type of a function expression.
1034 Func_expression::do_type()
1036 if (this->function_
->is_function())
1037 return this->function_
->func_value()->type();
1038 else if (this->function_
->is_function_declaration())
1039 return this->function_
->func_declaration_value()->type();
1044 // Get the backend representation for the code of a function expression.
1047 Func_expression::get_code_pointer(Gogo
* gogo
, Named_object
* no
, Location loc
)
1049 Function_type
* fntype
;
1050 if (no
->is_function())
1051 fntype
= no
->func_value()->type();
1052 else if (no
->is_function_declaration())
1053 fntype
= no
->func_declaration_value()->type();
1057 // Builtin functions are handled specially by Call_expression. We
1058 // can't take their address.
1059 if (fntype
->is_builtin())
1062 "invalid use of special builtin function %qs; must be called",
1063 no
->message_name().c_str());
1064 return gogo
->backend()->error_expression();
1068 if (no
->is_function())
1069 fndecl
= no
->func_value()->get_or_make_decl(gogo
, no
);
1070 else if (no
->is_function_declaration())
1071 fndecl
= no
->func_declaration_value()->get_or_make_decl(gogo
, no
);
1075 return gogo
->backend()->function_code_expression(fndecl
, loc
);
1078 // Get the backend representation for a function expression. This is used when
1079 // we take the address of a function rather than simply calling it. A func
1080 // value is represented as a pointer to a block of memory. The first
1081 // word of that memory is a pointer to the function code. The
1082 // remaining parts of that memory are the addresses of variables that
1083 // the function closes over.
1086 Func_expression::do_get_backend(Translate_context
* context
)
1088 // If there is no closure, just use the function descriptor.
1089 if (this->closure_
== NULL
)
1091 Gogo
* gogo
= context
->gogo();
1092 Named_object
* no
= this->function_
;
1093 Expression
* descriptor
;
1094 if (no
->is_function())
1095 descriptor
= no
->func_value()->descriptor(gogo
, no
);
1096 else if (no
->is_function_declaration())
1098 if (no
->func_declaration_value()->type()->is_builtin())
1100 error_at(this->location(),
1101 ("invalid use of special builtin function %qs; "
1103 no
->message_name().c_str());
1104 return gogo
->backend()->error_expression();
1106 descriptor
= no
->func_declaration_value()->descriptor(gogo
, no
);
1111 Bexpression
* bdesc
= descriptor
->get_backend(context
);
1112 return gogo
->backend()->address_expression(bdesc
, this->location());
1115 go_assert(this->function_
->func_value()->enclosing() != NULL
);
1117 // If there is a closure, then the closure is itself the function
1118 // expression. It is a pointer to a struct whose first field points
1119 // to the function code and whose remaining fields are the addresses
1120 // of the closed-over variables.
1121 return this->closure_
->get_backend(context
);
1124 // Ast dump for function.
1127 Func_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
1129 ast_dump_context
->ostream() << this->function_
->name();
1130 if (this->closure_
!= NULL
)
1132 ast_dump_context
->ostream() << " {closure = ";
1133 this->closure_
->dump_expression(ast_dump_context
);
1134 ast_dump_context
->ostream() << "}";
1138 // Make a reference to a function in an expression.
1141 Expression::make_func_reference(Named_object
* function
, Expression
* closure
,
1144 return new Func_expression(function
, closure
, location
);
1147 // Class Func_descriptor_expression.
1151 Func_descriptor_expression::Func_descriptor_expression(Named_object
* fn
)
1152 : Expression(EXPRESSION_FUNC_DESCRIPTOR
, fn
->location()),
1153 fn_(fn
), dvar_(NULL
)
1155 go_assert(!fn
->is_function() || !fn
->func_value()->needs_closure());
1161 Func_descriptor_expression::do_traverse(Traverse
*)
1163 return TRAVERSE_CONTINUE
;
1166 // All function descriptors have the same type.
1168 Type
* Func_descriptor_expression::descriptor_type
;
1171 Func_descriptor_expression::make_func_descriptor_type()
1173 if (Func_descriptor_expression::descriptor_type
!= NULL
)
1175 Type
* uintptr_type
= Type::lookup_integer_type("uintptr");
1176 Type
* struct_type
= Type::make_builtin_struct_type(1, "code", uintptr_type
);
1177 Func_descriptor_expression::descriptor_type
=
1178 Type::make_builtin_named_type("functionDescriptor", struct_type
);
1182 Func_descriptor_expression::do_type()
1184 Func_descriptor_expression::make_func_descriptor_type();
1185 return Func_descriptor_expression::descriptor_type
;
1188 // The backend representation for a function descriptor.
1191 Func_descriptor_expression::do_get_backend(Translate_context
* context
)
1193 Named_object
* no
= this->fn_
;
1194 Location loc
= no
->location();
1195 if (this->dvar_
!= NULL
)
1196 return context
->backend()->var_expression(this->dvar_
, loc
);
1198 Gogo
* gogo
= context
->gogo();
1199 std::string var_name
;
1200 if (no
->package() == NULL
)
1201 var_name
= gogo
->pkgpath_symbol();
1203 var_name
= no
->package()->pkgpath_symbol();
1204 var_name
.push_back('.');
1205 var_name
.append(Gogo::unpack_hidden_name(no
->name()));
1206 var_name
.append("$descriptor");
1208 Btype
* btype
= this->type()->get_backend(gogo
);
1211 if (no
->package() != NULL
1212 || Linemap::is_predeclared_location(no
->location()))
1213 bvar
= context
->backend()->immutable_struct_reference(var_name
, btype
,
1217 Location bloc
= Linemap::predeclared_location();
1218 bool is_hidden
= ((no
->is_function()
1219 && no
->func_value()->enclosing() != NULL
)
1220 || Gogo::is_thunk(no
));
1221 bvar
= context
->backend()->immutable_struct(var_name
, is_hidden
, false,
1223 Expression_list
* vals
= new Expression_list();
1224 vals
->push_back(Expression::make_func_code_reference(this->fn_
, bloc
));
1226 Expression::make_struct_composite_literal(this->type(), vals
, bloc
);
1227 Translate_context
bcontext(gogo
, NULL
, NULL
, NULL
);
1228 bcontext
.set_is_const();
1229 Bexpression
* binit
= init
->get_backend(&bcontext
);
1230 context
->backend()->immutable_struct_set_init(bvar
, var_name
, is_hidden
,
1231 false, btype
, bloc
, binit
);
1235 return gogo
->backend()->var_expression(bvar
, loc
);
1238 // Print a function descriptor expression.
1241 Func_descriptor_expression::do_dump_expression(Ast_dump_context
* context
) const
1243 context
->ostream() << "[descriptor " << this->fn_
->name() << "]";
1246 // Make a function descriptor expression.
1248 Func_descriptor_expression
*
1249 Expression::make_func_descriptor(Named_object
* fn
)
1251 return new Func_descriptor_expression(fn
);
1254 // Make the function descriptor type, so that it can be converted.
1257 Expression::make_func_descriptor_type()
1259 Func_descriptor_expression::make_func_descriptor_type();
1262 // A reference to just the code of a function.
1264 class Func_code_reference_expression
: public Expression
1267 Func_code_reference_expression(Named_object
* function
, Location location
)
1268 : Expression(EXPRESSION_FUNC_CODE_REFERENCE
, location
),
1274 do_traverse(Traverse
*)
1275 { return TRAVERSE_CONTINUE
; }
1278 do_is_immutable() const
1283 { return Type::make_pointer_type(Type::make_void_type()); }
1286 do_determine_type(const Type_context
*)
1292 return Expression::make_func_code_reference(this->function_
,
1297 do_get_backend(Translate_context
*);
1300 do_dump_expression(Ast_dump_context
* context
) const
1301 { context
->ostream() << "[raw " << this->function_
->name() << "]" ; }
1305 Named_object
* function_
;
1308 // Get the backend representation for a reference to function code.
1311 Func_code_reference_expression::do_get_backend(Translate_context
* context
)
1313 return Func_expression::get_code_pointer(context
->gogo(), this->function_
,
1317 // Make a reference to the code of a function.
1320 Expression::make_func_code_reference(Named_object
* function
, Location location
)
1322 return new Func_code_reference_expression(function
, location
);
1325 // Class Unknown_expression.
1327 // Return the name of an unknown expression.
1330 Unknown_expression::name() const
1332 return this->named_object_
->name();
1335 // Lower a reference to an unknown name.
1338 Unknown_expression::do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
1340 Location location
= this->location();
1341 Named_object
* no
= this->named_object_
;
1343 if (!no
->is_unknown())
1347 real
= no
->unknown_value()->real_named_object();
1350 if (this->is_composite_literal_key_
)
1352 if (!this->no_error_message_
)
1353 error_at(location
, "reference to undefined name %qs",
1354 this->named_object_
->message_name().c_str());
1355 return Expression::make_error(location
);
1358 switch (real
->classification())
1360 case Named_object::NAMED_OBJECT_CONST
:
1361 return Expression::make_const_reference(real
, location
);
1362 case Named_object::NAMED_OBJECT_TYPE
:
1363 return Expression::make_type(real
->type_value(), location
);
1364 case Named_object::NAMED_OBJECT_TYPE_DECLARATION
:
1365 if (this->is_composite_literal_key_
)
1367 if (!this->no_error_message_
)
1368 error_at(location
, "reference to undefined type %qs",
1369 real
->message_name().c_str());
1370 return Expression::make_error(location
);
1371 case Named_object::NAMED_OBJECT_VAR
:
1372 real
->var_value()->set_is_used();
1373 return Expression::make_var_reference(real
, location
);
1374 case Named_object::NAMED_OBJECT_FUNC
:
1375 case Named_object::NAMED_OBJECT_FUNC_DECLARATION
:
1376 return Expression::make_func_reference(real
, NULL
, location
);
1377 case Named_object::NAMED_OBJECT_PACKAGE
:
1378 if (this->is_composite_literal_key_
)
1380 if (!this->no_error_message_
)
1381 error_at(location
, "unexpected reference to package");
1382 return Expression::make_error(location
);
1388 // Dump the ast representation for an unknown expression to a dump context.
1391 Unknown_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
1393 ast_dump_context
->ostream() << "_Unknown_(" << this->named_object_
->name()
1397 // Make a reference to an unknown name.
1400 Expression::make_unknown_reference(Named_object
* no
, Location location
)
1402 return new Unknown_expression(no
, location
);
1405 // A boolean expression.
1407 class Boolean_expression
: public Expression
1410 Boolean_expression(bool val
, Location location
)
1411 : Expression(EXPRESSION_BOOLEAN
, location
),
1412 val_(val
), type_(NULL
)
1420 do_is_constant() const
1424 do_is_immutable() const
1431 do_determine_type(const Type_context
*);
1438 do_get_backend(Translate_context
* context
)
1439 { return context
->backend()->boolean_constant_expression(this->val_
); }
1442 do_export(Export
* exp
) const
1443 { exp
->write_c_string(this->val_
? "true" : "false"); }
1446 do_dump_expression(Ast_dump_context
* ast_dump_context
) const
1447 { ast_dump_context
->ostream() << (this->val_
? "true" : "false"); }
1452 // The type as determined by context.
1459 Boolean_expression::do_type()
1461 if (this->type_
== NULL
)
1462 this->type_
= Type::make_boolean_type();
1466 // Set the type from the context.
1469 Boolean_expression::do_determine_type(const Type_context
* context
)
1471 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
1473 else if (context
->type
!= NULL
&& context
->type
->is_boolean_type())
1474 this->type_
= context
->type
;
1475 else if (!context
->may_be_abstract
)
1476 this->type_
= Type::lookup_bool_type();
1479 // Import a boolean constant.
1482 Boolean_expression::do_import(Import
* imp
)
1484 if (imp
->peek_char() == 't')
1486 imp
->require_c_string("true");
1487 return Expression::make_boolean(true, imp
->location());
1491 imp
->require_c_string("false");
1492 return Expression::make_boolean(false, imp
->location());
1496 // Make a boolean expression.
1499 Expression::make_boolean(bool val
, Location location
)
1501 return new Boolean_expression(val
, location
);
1504 // Class String_expression.
1509 String_expression::do_type()
1511 if (this->type_
== NULL
)
1512 this->type_
= Type::make_string_type();
1516 // Set the type from the context.
1519 String_expression::do_determine_type(const Type_context
* context
)
1521 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
1523 else if (context
->type
!= NULL
&& context
->type
->is_string_type())
1524 this->type_
= context
->type
;
1525 else if (!context
->may_be_abstract
)
1526 this->type_
= Type::lookup_string_type();
1529 // Build a string constant.
1532 String_expression::do_get_backend(Translate_context
* context
)
1534 Gogo
* gogo
= context
->gogo();
1535 Btype
* btype
= Type::make_string_type()->get_backend(gogo
);
1537 Location loc
= this->location();
1538 std::vector
<Bexpression
*> init(2);
1539 Bexpression
* str_cst
=
1540 gogo
->backend()->string_constant_expression(this->val_
);
1541 init
[0] = gogo
->backend()->address_expression(str_cst
, loc
);
1543 Btype
* int_btype
= Type::lookup_integer_type("int")->get_backend(gogo
);
1545 mpz_init_set_ui(lenval
, this->val_
.length());
1546 init
[1] = gogo
->backend()->integer_constant_expression(int_btype
, lenval
);
1549 return gogo
->backend()->constructor_expression(btype
, init
, loc
);
1552 // Write string literal to string dump.
1555 String_expression::export_string(String_dump
* exp
,
1556 const String_expression
* str
)
1559 s
.reserve(str
->val_
.length() * 4 + 2);
1561 for (std::string::const_iterator p
= str
->val_
.begin();
1562 p
!= str
->val_
.end();
1565 if (*p
== '\\' || *p
== '"')
1570 else if (*p
>= 0x20 && *p
< 0x7f)
1572 else if (*p
== '\n')
1574 else if (*p
== '\t')
1579 unsigned char c
= *p
;
1580 unsigned int dig
= c
>> 4;
1581 s
+= dig
< 10 ? '0' + dig
: 'A' + dig
- 10;
1583 s
+= dig
< 10 ? '0' + dig
: 'A' + dig
- 10;
1587 exp
->write_string(s
);
1590 // Export a string expression.
1593 String_expression::do_export(Export
* exp
) const
1595 String_expression::export_string(exp
, this);
1598 // Import a string expression.
1601 String_expression::do_import(Import
* imp
)
1603 imp
->require_c_string("\"");
1607 int c
= imp
->get_char();
1608 if (c
== '"' || c
== -1)
1611 val
+= static_cast<char>(c
);
1614 c
= imp
->get_char();
1615 if (c
== '\\' || c
== '"')
1616 val
+= static_cast<char>(c
);
1623 c
= imp
->get_char();
1624 unsigned int vh
= c
>= '0' && c
<= '9' ? c
- '0' : c
- 'A' + 10;
1625 c
= imp
->get_char();
1626 unsigned int vl
= c
>= '0' && c
<= '9' ? c
- '0' : c
- 'A' + 10;
1627 char v
= (vh
<< 4) | vl
;
1632 error_at(imp
->location(), "bad string constant");
1633 return Expression::make_error(imp
->location());
1637 return Expression::make_string(val
, imp
->location());
1640 // Ast dump for string expression.
1643 String_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
1645 String_expression::export_string(ast_dump_context
, this);
1648 // Make a string expression.
1651 Expression::make_string(const std::string
& val
, Location location
)
1653 return new String_expression(val
, location
);
1656 // An expression that evaluates to some characteristic of a string.
1657 // This is used when indexing, bound-checking, or nil checking a string.
1659 class String_info_expression
: public Expression
1662 String_info_expression(Expression
* string
, String_info string_info
,
1664 : Expression(EXPRESSION_STRING_INFO
, location
),
1665 string_(string
), string_info_(string_info
)
1673 do_determine_type(const Type_context
*)
1674 { go_unreachable(); }
1679 return new String_info_expression(this->string_
->copy(), this->string_info_
,
1684 do_get_backend(Translate_context
* context
);
1687 do_dump_expression(Ast_dump_context
*) const;
1690 do_issue_nil_check()
1691 { this->string_
->issue_nil_check(); }
1694 // The string for which we are getting information.
1695 Expression
* string_
;
1696 // What information we want.
1697 String_info string_info_
;
1700 // Return the type of the string info.
1703 String_info_expression::do_type()
1705 switch (this->string_info_
)
1707 case STRING_INFO_DATA
:
1709 Type
* byte_type
= Type::lookup_integer_type("uint8");
1710 return Type::make_pointer_type(byte_type
);
1712 case STRING_INFO_LENGTH
:
1713 return Type::lookup_integer_type("int");
1719 // Return string information in GENERIC.
1722 String_info_expression::do_get_backend(Translate_context
* context
)
1724 Gogo
* gogo
= context
->gogo();
1726 Bexpression
* bstring
= this->string_
->get_backend(context
);
1727 switch (this->string_info_
)
1729 case STRING_INFO_DATA
:
1730 case STRING_INFO_LENGTH
:
1731 return gogo
->backend()->struct_field_expression(bstring
,
1740 // Dump ast representation for a type info expression.
1743 String_info_expression::do_dump_expression(
1744 Ast_dump_context
* ast_dump_context
) const
1746 ast_dump_context
->ostream() << "stringinfo(";
1747 this->string_
->dump_expression(ast_dump_context
);
1748 ast_dump_context
->ostream() << ",";
1749 ast_dump_context
->ostream() <<
1750 (this->string_info_
== STRING_INFO_DATA
? "data"
1751 : this->string_info_
== STRING_INFO_LENGTH
? "length"
1753 ast_dump_context
->ostream() << ")";
1756 // Make a string info expression.
1759 Expression::make_string_info(Expression
* string
, String_info string_info
,
1762 return new String_info_expression(string
, string_info
, location
);
1765 // Make an integer expression.
1767 class Integer_expression
: public Expression
1770 Integer_expression(const mpz_t
* val
, Type
* type
, bool is_character_constant
,
1772 : Expression(EXPRESSION_INTEGER
, location
),
1773 type_(type
), is_character_constant_(is_character_constant
)
1774 { mpz_init_set(this->val_
, *val
); }
1779 // Write VAL to string dump.
1781 export_integer(String_dump
* exp
, const mpz_t val
);
1783 // Write VAL to dump context.
1785 dump_integer(Ast_dump_context
* ast_dump_context
, const mpz_t val
);
1789 do_is_constant() const
1793 do_is_immutable() const
1797 do_numeric_constant_value(Numeric_constant
* nc
) const;
1803 do_determine_type(const Type_context
* context
);
1806 do_check_types(Gogo
*);
1809 do_get_backend(Translate_context
*);
1814 if (this->is_character_constant_
)
1815 return Expression::make_character(&this->val_
, this->type_
,
1818 return Expression::make_integer_z(&this->val_
, this->type_
,
1823 do_export(Export
*) const;
1826 do_dump_expression(Ast_dump_context
*) const;
1829 // The integer value.
1833 // Whether this is a character constant.
1834 bool is_character_constant_
;
1837 // Return a numeric constant for this expression. We have to mark
1838 // this as a character when appropriate.
1841 Integer_expression::do_numeric_constant_value(Numeric_constant
* nc
) const
1843 if (this->is_character_constant_
)
1844 nc
->set_rune(this->type_
, this->val_
);
1846 nc
->set_int(this->type_
, this->val_
);
1850 // Return the current type. If we haven't set the type yet, we return
1851 // an abstract integer type.
1854 Integer_expression::do_type()
1856 if (this->type_
== NULL
)
1858 if (this->is_character_constant_
)
1859 this->type_
= Type::make_abstract_character_type();
1861 this->type_
= Type::make_abstract_integer_type();
1866 // Set the type of the integer value. Here we may switch from an
1867 // abstract type to a real type.
1870 Integer_expression::do_determine_type(const Type_context
* context
)
1872 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
1874 else if (context
->type
!= NULL
&& context
->type
->is_numeric_type())
1875 this->type_
= context
->type
;
1876 else if (!context
->may_be_abstract
)
1878 if (this->is_character_constant_
)
1879 this->type_
= Type::lookup_integer_type("int32");
1881 this->type_
= Type::lookup_integer_type("int");
1885 // Check the type of an integer constant.
1888 Integer_expression::do_check_types(Gogo
*)
1890 Type
* type
= this->type_
;
1893 Numeric_constant nc
;
1894 if (this->is_character_constant_
)
1895 nc
.set_rune(NULL
, this->val_
);
1897 nc
.set_int(NULL
, this->val_
);
1898 if (!nc
.set_type(type
, true, this->location()))
1899 this->set_is_error();
1902 // Get the backend representation for an integer constant.
1905 Integer_expression::do_get_backend(Translate_context
* context
)
1907 Type
* resolved_type
= NULL
;
1908 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
1909 resolved_type
= this->type_
;
1910 else if (this->type_
!= NULL
&& this->type_
->float_type() != NULL
)
1912 // We are converting to an abstract floating point type.
1913 resolved_type
= Type::lookup_float_type("float64");
1915 else if (this->type_
!= NULL
&& this->type_
->complex_type() != NULL
)
1917 // We are converting to an abstract complex type.
1918 resolved_type
= Type::lookup_complex_type("complex128");
1922 // If we still have an abstract type here, then this is being
1923 // used in a constant expression which didn't get reduced for
1924 // some reason. Use a type which will fit the value. We use <,
1925 // not <=, because we need an extra bit for the sign bit.
1926 int bits
= mpz_sizeinbase(this->val_
, 2);
1927 Type
* int_type
= Type::lookup_integer_type("int");
1928 if (bits
< int_type
->integer_type()->bits())
1929 resolved_type
= int_type
;
1931 resolved_type
= Type::lookup_integer_type("int64");
1935 error_at(this->location(),
1936 "unknown type for large integer constant");
1937 return context
->gogo()->backend()->error_expression();
1940 Numeric_constant nc
;
1941 nc
.set_int(resolved_type
, this->val_
);
1942 return Expression::backend_numeric_constant_expression(context
, &nc
);
1945 // Write VAL to export data.
1948 Integer_expression::export_integer(String_dump
* exp
, const mpz_t val
)
1950 char* s
= mpz_get_str(NULL
, 10, val
);
1951 exp
->write_c_string(s
);
1955 // Export an integer in a constant expression.
1958 Integer_expression::do_export(Export
* exp
) const
1960 Integer_expression::export_integer(exp
, this->val_
);
1961 if (this->is_character_constant_
)
1962 exp
->write_c_string("'");
1963 // A trailing space lets us reliably identify the end of the number.
1964 exp
->write_c_string(" ");
1967 // Import an integer, floating point, or complex value. This handles
1968 // all these types because they all start with digits.
1971 Integer_expression::do_import(Import
* imp
)
1973 std::string num
= imp
->read_identifier();
1974 imp
->require_c_string(" ");
1975 if (!num
.empty() && num
[num
.length() - 1] == 'i')
1978 size_t plus_pos
= num
.find('+', 1);
1979 size_t minus_pos
= num
.find('-', 1);
1981 if (plus_pos
== std::string::npos
)
1983 else if (minus_pos
== std::string::npos
)
1987 error_at(imp
->location(), "bad number in import data: %qs",
1989 return Expression::make_error(imp
->location());
1991 if (pos
== std::string::npos
)
1992 mpfr_set_ui(real
, 0, GMP_RNDN
);
1995 std::string real_str
= num
.substr(0, pos
);
1996 if (mpfr_init_set_str(real
, real_str
.c_str(), 10, GMP_RNDN
) != 0)
1998 error_at(imp
->location(), "bad number in import data: %qs",
2000 return Expression::make_error(imp
->location());
2004 std::string imag_str
;
2005 if (pos
== std::string::npos
)
2008 imag_str
= num
.substr(pos
);
2009 imag_str
= imag_str
.substr(0, imag_str
.size() - 1);
2011 if (mpfr_init_set_str(imag
, imag_str
.c_str(), 10, GMP_RNDN
) != 0)
2013 error_at(imp
->location(), "bad number in import data: %qs",
2015 return Expression::make_error(imp
->location());
2018 mpc_init2(cval
, mpc_precision
);
2019 mpc_set_fr_fr(cval
, real
, imag
, MPC_RNDNN
);
2022 Expression
* ret
= Expression::make_complex(&cval
, NULL
, imp
->location());
2026 else if (num
.find('.') == std::string::npos
2027 && num
.find('E') == std::string::npos
)
2029 bool is_character_constant
= (!num
.empty()
2030 && num
[num
.length() - 1] == '\'');
2031 if (is_character_constant
)
2032 num
= num
.substr(0, num
.length() - 1);
2034 if (mpz_init_set_str(val
, num
.c_str(), 10) != 0)
2036 error_at(imp
->location(), "bad number in import data: %qs",
2038 return Expression::make_error(imp
->location());
2041 if (is_character_constant
)
2042 ret
= Expression::make_character(&val
, NULL
, imp
->location());
2044 ret
= Expression::make_integer_z(&val
, NULL
, imp
->location());
2051 if (mpfr_init_set_str(val
, num
.c_str(), 10, GMP_RNDN
) != 0)
2053 error_at(imp
->location(), "bad number in import data: %qs",
2055 return Expression::make_error(imp
->location());
2057 Expression
* ret
= Expression::make_float(&val
, NULL
, imp
->location());
2062 // Ast dump for integer expression.
2065 Integer_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2067 if (this->is_character_constant_
)
2068 ast_dump_context
->ostream() << '\'';
2069 Integer_expression::export_integer(ast_dump_context
, this->val_
);
2070 if (this->is_character_constant_
)
2071 ast_dump_context
->ostream() << '\'';
2074 // Build a new integer value from a multi-precision integer.
2077 Expression::make_integer_z(const mpz_t
* val
, Type
* type
, Location location
)
2079 return new Integer_expression(val
, type
, false, location
);
2082 // Build a new integer value from an unsigned long.
2085 Expression::make_integer_ul(unsigned long val
, Type
*type
, Location location
)
2088 mpz_init_set_ui(zval
, val
);
2089 Expression
* ret
= Expression::make_integer_z(&zval
, type
, location
);
2094 // Build a new integer value from a signed long.
2097 Expression::make_integer_sl(long val
, Type
*type
, Location location
)
2100 mpz_init_set_si(zval
, val
);
2101 Expression
* ret
= Expression::make_integer_z(&zval
, type
, location
);
2106 // Build a new character constant value.
2109 Expression::make_character(const mpz_t
* val
, Type
* type
, Location location
)
2111 return new Integer_expression(val
, type
, true, location
);
2116 class Float_expression
: public Expression
2119 Float_expression(const mpfr_t
* val
, Type
* type
, Location location
)
2120 : Expression(EXPRESSION_FLOAT
, location
),
2123 mpfr_init_set(this->val_
, *val
, GMP_RNDN
);
2126 // Write VAL to export data.
2128 export_float(String_dump
* exp
, const mpfr_t val
);
2130 // Write VAL to dump file.
2132 dump_float(Ast_dump_context
* ast_dump_context
, const mpfr_t val
);
2136 do_is_constant() const
2140 do_is_immutable() const
2144 do_numeric_constant_value(Numeric_constant
* nc
) const
2146 nc
->set_float(this->type_
, this->val_
);
2154 do_determine_type(const Type_context
*);
2157 do_check_types(Gogo
*);
2161 { return Expression::make_float(&this->val_
, this->type_
,
2162 this->location()); }
2165 do_get_backend(Translate_context
*);
2168 do_export(Export
*) const;
2171 do_dump_expression(Ast_dump_context
*) const;
2174 // The floating point value.
2180 // Return the current type. If we haven't set the type yet, we return
2181 // an abstract float type.
2184 Float_expression::do_type()
2186 if (this->type_
== NULL
)
2187 this->type_
= Type::make_abstract_float_type();
2191 // Set the type of the float value. Here we may switch from an
2192 // abstract type to a real type.
2195 Float_expression::do_determine_type(const Type_context
* context
)
2197 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
2199 else if (context
->type
!= NULL
2200 && (context
->type
->integer_type() != NULL
2201 || context
->type
->float_type() != NULL
2202 || context
->type
->complex_type() != NULL
))
2203 this->type_
= context
->type
;
2204 else if (!context
->may_be_abstract
)
2205 this->type_
= Type::lookup_float_type("float64");
2208 // Check the type of a float value.
2211 Float_expression::do_check_types(Gogo
*)
2213 Type
* type
= this->type_
;
2216 Numeric_constant nc
;
2217 nc
.set_float(NULL
, this->val_
);
2218 if (!nc
.set_type(this->type_
, true, this->location()))
2219 this->set_is_error();
2222 // Get the backend representation for a float constant.
2225 Float_expression::do_get_backend(Translate_context
* context
)
2227 Type
* resolved_type
;
2228 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
2229 resolved_type
= this->type_
;
2230 else if (this->type_
!= NULL
&& this->type_
->integer_type() != NULL
)
2232 // We have an abstract integer type. We just hope for the best.
2233 resolved_type
= Type::lookup_integer_type("int");
2235 else if (this->type_
!= NULL
&& this->type_
->complex_type() != NULL
)
2237 // We are converting to an abstract complex type.
2238 resolved_type
= Type::lookup_complex_type("complex128");
2242 // If we still have an abstract type here, then this is being
2243 // used in a constant expression which didn't get reduced. We
2244 // just use float64 and hope for the best.
2245 resolved_type
= Type::lookup_float_type("float64");
2248 Numeric_constant nc
;
2249 nc
.set_float(resolved_type
, this->val_
);
2250 return Expression::backend_numeric_constant_expression(context
, &nc
);
2253 // Write a floating point number to a string dump.
2256 Float_expression::export_float(String_dump
*exp
, const mpfr_t val
)
2259 char* s
= mpfr_get_str(NULL
, &exponent
, 10, 0, val
, GMP_RNDN
);
2261 exp
->write_c_string("-");
2262 exp
->write_c_string("0.");
2263 exp
->write_c_string(*s
== '-' ? s
+ 1 : s
);
2266 snprintf(buf
, sizeof buf
, "E%ld", exponent
);
2267 exp
->write_c_string(buf
);
2270 // Export a floating point number in a constant expression.
2273 Float_expression::do_export(Export
* exp
) const
2275 Float_expression::export_float(exp
, this->val_
);
2276 // A trailing space lets us reliably identify the end of the number.
2277 exp
->write_c_string(" ");
2280 // Dump a floating point number to the dump file.
2283 Float_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2285 Float_expression::export_float(ast_dump_context
, this->val_
);
2288 // Make a float expression.
2291 Expression::make_float(const mpfr_t
* val
, Type
* type
, Location location
)
2293 return new Float_expression(val
, type
, location
);
2298 class Complex_expression
: public Expression
2301 Complex_expression(const mpc_t
* val
, Type
* type
, Location location
)
2302 : Expression(EXPRESSION_COMPLEX
, location
),
2305 mpc_init2(this->val_
, mpc_precision
);
2306 mpc_set(this->val_
, *val
, MPC_RNDNN
);
2309 // Write VAL to string dump.
2311 export_complex(String_dump
* exp
, const mpc_t val
);
2313 // Write REAL/IMAG to dump context.
2315 dump_complex(Ast_dump_context
* ast_dump_context
, const mpc_t val
);
2319 do_is_constant() const
2323 do_is_immutable() const
2327 do_numeric_constant_value(Numeric_constant
* nc
) const
2329 nc
->set_complex(this->type_
, this->val_
);
2337 do_determine_type(const Type_context
*);
2340 do_check_types(Gogo
*);
2345 return Expression::make_complex(&this->val_
, this->type_
,
2350 do_get_backend(Translate_context
*);
2353 do_export(Export
*) const;
2356 do_dump_expression(Ast_dump_context
*) const;
2359 // The complex value.
2361 // The type if known.
2365 // Return the current type. If we haven't set the type yet, we return
2366 // an abstract complex type.
2369 Complex_expression::do_type()
2371 if (this->type_
== NULL
)
2372 this->type_
= Type::make_abstract_complex_type();
2376 // Set the type of the complex value. Here we may switch from an
2377 // abstract type to a real type.
2380 Complex_expression::do_determine_type(const Type_context
* context
)
2382 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
2384 else if (context
->type
!= NULL
2385 && context
->type
->complex_type() != NULL
)
2386 this->type_
= context
->type
;
2387 else if (!context
->may_be_abstract
)
2388 this->type_
= Type::lookup_complex_type("complex128");
2391 // Check the type of a complex value.
2394 Complex_expression::do_check_types(Gogo
*)
2396 Type
* type
= this->type_
;
2399 Numeric_constant nc
;
2400 nc
.set_complex(NULL
, this->val_
);
2401 if (!nc
.set_type(this->type_
, true, this->location()))
2402 this->set_is_error();
2405 // Get the backend representation for a complex constant.
2408 Complex_expression::do_get_backend(Translate_context
* context
)
2410 Type
* resolved_type
;
2411 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
2412 resolved_type
= this->type_
;
2413 else if (this->type_
!= NULL
&& this->type_
->integer_type() != NULL
)
2415 // We are converting to an abstract integer type.
2416 resolved_type
= Type::lookup_integer_type("int");
2418 else if (this->type_
!= NULL
&& this->type_
->float_type() != NULL
)
2420 // We are converting to an abstract float type.
2421 resolved_type
= Type::lookup_float_type("float64");
2425 // If we still have an abstract type here, this this is being
2426 // used in a constant expression which didn't get reduced. We
2427 // just use complex128 and hope for the best.
2428 resolved_type
= Type::lookup_complex_type("complex128");
2431 Numeric_constant nc
;
2432 nc
.set_complex(resolved_type
, this->val_
);
2433 return Expression::backend_numeric_constant_expression(context
, &nc
);
2436 // Write REAL/IMAG to export data.
2439 Complex_expression::export_complex(String_dump
* exp
, const mpc_t val
)
2441 if (!mpfr_zero_p(mpc_realref(val
)))
2443 Float_expression::export_float(exp
, mpc_realref(val
));
2444 if (mpfr_sgn(mpc_imagref(val
)) > 0)
2445 exp
->write_c_string("+");
2447 Float_expression::export_float(exp
, mpc_imagref(val
));
2448 exp
->write_c_string("i");
2451 // Export a complex number in a constant expression.
2454 Complex_expression::do_export(Export
* exp
) const
2456 Complex_expression::export_complex(exp
, this->val_
);
2457 // A trailing space lets us reliably identify the end of the number.
2458 exp
->write_c_string(" ");
2461 // Dump a complex expression to the dump file.
2464 Complex_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2466 Complex_expression::export_complex(ast_dump_context
, this->val_
);
2469 // Make a complex expression.
2472 Expression::make_complex(const mpc_t
* val
, Type
* type
, Location location
)
2474 return new Complex_expression(val
, type
, location
);
2477 // Find a named object in an expression.
2479 class Find_named_object
: public Traverse
2482 Find_named_object(Named_object
* no
)
2483 : Traverse(traverse_expressions
),
2484 no_(no
), found_(false)
2487 // Whether we found the object.
2490 { return this->found_
; }
2494 expression(Expression
**);
2497 // The object we are looking for.
2499 // Whether we found it.
2503 // A reference to a const in an expression.
2505 class Const_expression
: public Expression
2508 Const_expression(Named_object
* constant
, Location location
)
2509 : Expression(EXPRESSION_CONST_REFERENCE
, location
),
2510 constant_(constant
), type_(NULL
), seen_(false)
2515 { return this->constant_
; }
2517 // Check that the initializer does not refer to the constant itself.
2519 check_for_init_loop();
2523 do_traverse(Traverse
*);
2526 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
2529 do_is_constant() const
2533 do_is_immutable() const
2537 do_numeric_constant_value(Numeric_constant
* nc
) const;
2540 do_string_constant_value(std::string
* val
) const;
2545 // The type of a const is set by the declaration, not the use.
2547 do_determine_type(const Type_context
*);
2550 do_check_types(Gogo
*);
2557 do_get_backend(Translate_context
* context
);
2559 // When exporting a reference to a const as part of a const
2560 // expression, we export the value. We ignore the fact that it has
2563 do_export(Export
* exp
) const
2564 { this->constant_
->const_value()->expr()->export_expression(exp
); }
2567 do_dump_expression(Ast_dump_context
*) const;
2571 Named_object
* constant_
;
2572 // The type of this reference. This is used if the constant has an
2575 // Used to prevent infinite recursion when a constant incorrectly
2576 // refers to itself.
2583 Const_expression::do_traverse(Traverse
* traverse
)
2585 if (this->type_
!= NULL
)
2586 return Type::traverse(this->type_
, traverse
);
2587 return TRAVERSE_CONTINUE
;
2590 // Lower a constant expression. This is where we convert the
2591 // predeclared constant iota into an integer value.
2594 Const_expression::do_lower(Gogo
* gogo
, Named_object
*,
2595 Statement_inserter
*, int iota_value
)
2597 if (this->constant_
->const_value()->expr()->classification()
2600 if (iota_value
== -1)
2602 error_at(this->location(),
2603 "iota is only defined in const declarations");
2606 return Expression::make_integer_ul(iota_value
, NULL
, this->location());
2609 // Make sure that the constant itself has been lowered.
2610 gogo
->lower_constant(this->constant_
);
2615 // Return a numeric constant value.
2618 Const_expression::do_numeric_constant_value(Numeric_constant
* nc
) const
2623 Expression
* e
= this->constant_
->const_value()->expr();
2627 bool r
= e
->numeric_constant_value(nc
);
2629 this->seen_
= false;
2632 if (this->type_
!= NULL
)
2633 ctype
= this->type_
;
2635 ctype
= this->constant_
->const_value()->type();
2636 if (r
&& ctype
!= NULL
)
2638 if (!nc
->set_type(ctype
, false, this->location()))
2646 Const_expression::do_string_constant_value(std::string
* val
) const
2651 Expression
* e
= this->constant_
->const_value()->expr();
2654 bool ok
= e
->string_constant_value(val
);
2655 this->seen_
= false;
2660 // Return the type of the const reference.
2663 Const_expression::do_type()
2665 if (this->type_
!= NULL
)
2668 Named_constant
* nc
= this->constant_
->const_value();
2670 if (this->seen_
|| nc
->lowering())
2672 this->report_error(_("constant refers to itself"));
2673 this->type_
= Type::make_error_type();
2679 Type
* ret
= nc
->type();
2683 this->seen_
= false;
2687 // During parsing, a named constant may have a NULL type, but we
2688 // must not return a NULL type here.
2689 ret
= nc
->expr()->type();
2691 this->seen_
= false;
2696 // Set the type of the const reference.
2699 Const_expression::do_determine_type(const Type_context
* context
)
2701 Type
* ctype
= this->constant_
->const_value()->type();
2702 Type
* cetype
= (ctype
!= NULL
2704 : this->constant_
->const_value()->expr()->type());
2705 if (ctype
!= NULL
&& !ctype
->is_abstract())
2707 else if (context
->type
!= NULL
2708 && context
->type
->is_numeric_type()
2709 && cetype
->is_numeric_type())
2710 this->type_
= context
->type
;
2711 else if (context
->type
!= NULL
2712 && context
->type
->is_string_type()
2713 && cetype
->is_string_type())
2714 this->type_
= context
->type
;
2715 else if (context
->type
!= NULL
2716 && context
->type
->is_boolean_type()
2717 && cetype
->is_boolean_type())
2718 this->type_
= context
->type
;
2719 else if (!context
->may_be_abstract
)
2721 if (cetype
->is_abstract())
2722 cetype
= cetype
->make_non_abstract_type();
2723 this->type_
= cetype
;
2727 // Check for a loop in which the initializer of a constant refers to
2728 // the constant itself.
2731 Const_expression::check_for_init_loop()
2733 if (this->type_
!= NULL
&& this->type_
->is_error())
2738 this->report_error(_("constant refers to itself"));
2739 this->type_
= Type::make_error_type();
2743 Expression
* init
= this->constant_
->const_value()->expr();
2744 Find_named_object
find_named_object(this->constant_
);
2747 Expression::traverse(&init
, &find_named_object
);
2748 this->seen_
= false;
2750 if (find_named_object
.found())
2752 if (this->type_
== NULL
|| !this->type_
->is_error())
2754 this->report_error(_("constant refers to itself"));
2755 this->type_
= Type::make_error_type();
2761 // Check types of a const reference.
2764 Const_expression::do_check_types(Gogo
*)
2766 if (this->type_
!= NULL
&& this->type_
->is_error())
2769 this->check_for_init_loop();
2771 // Check that numeric constant fits in type.
2772 if (this->type_
!= NULL
&& this->type_
->is_numeric_type())
2774 Numeric_constant nc
;
2775 if (this->constant_
->const_value()->expr()->numeric_constant_value(&nc
))
2777 if (!nc
.set_type(this->type_
, true, this->location()))
2778 this->set_is_error();
2783 // Return the backend representation for a const reference.
2786 Const_expression::do_get_backend(Translate_context
* context
)
2788 if (this->type_
!= NULL
&& this->type_
->is_error())
2789 return context
->backend()->error_expression();
2791 // If the type has been set for this expression, but the underlying
2792 // object is an abstract int or float, we try to get the abstract
2793 // value. Otherwise we may lose something in the conversion.
2794 Expression
* expr
= this->constant_
->const_value()->expr();
2795 if (this->type_
!= NULL
2796 && this->type_
->is_numeric_type()
2797 && (this->constant_
->const_value()->type() == NULL
2798 || this->constant_
->const_value()->type()->is_abstract()))
2800 Numeric_constant nc
;
2801 if (expr
->numeric_constant_value(&nc
)
2802 && nc
.set_type(this->type_
, false, this->location()))
2804 Expression
* e
= nc
.expression(this->location());
2805 return e
->get_backend(context
);
2809 if (this->type_
!= NULL
)
2810 expr
= Expression::make_cast(this->type_
, expr
, this->location());
2811 return expr
->get_backend(context
);
2814 // Dump ast representation for constant expression.
2817 Const_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2819 ast_dump_context
->ostream() << this->constant_
->name();
2822 // Make a reference to a constant in an expression.
2825 Expression::make_const_reference(Named_object
* constant
,
2828 return new Const_expression(constant
, location
);
2831 // Find a named object in an expression.
2834 Find_named_object::expression(Expression
** pexpr
)
2836 switch ((*pexpr
)->classification())
2838 case Expression::EXPRESSION_CONST_REFERENCE
:
2840 Const_expression
* ce
= static_cast<Const_expression
*>(*pexpr
);
2841 if (ce
->named_object() == this->no_
)
2844 // We need to check a constant initializer explicitly, as
2845 // loops here will not be caught by the loop checking for
2846 // variable initializers.
2847 ce
->check_for_init_loop();
2849 return TRAVERSE_CONTINUE
;
2852 case Expression::EXPRESSION_VAR_REFERENCE
:
2853 if ((*pexpr
)->var_expression()->named_object() == this->no_
)
2855 return TRAVERSE_CONTINUE
;
2856 case Expression::EXPRESSION_FUNC_REFERENCE
:
2857 if ((*pexpr
)->func_expression()->named_object() == this->no_
)
2859 return TRAVERSE_CONTINUE
;
2861 return TRAVERSE_CONTINUE
;
2863 this->found_
= true;
2864 return TRAVERSE_EXIT
;
2869 class Nil_expression
: public Expression
2872 Nil_expression(Location location
)
2873 : Expression(EXPRESSION_NIL
, location
)
2881 do_is_constant() const
2885 do_is_immutable() const
2890 { return Type::make_nil_type(); }
2893 do_determine_type(const Type_context
*)
2901 do_get_backend(Translate_context
* context
)
2902 { return context
->backend()->nil_pointer_expression(); }
2905 do_export(Export
* exp
) const
2906 { exp
->write_c_string("nil"); }
2909 do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2910 { ast_dump_context
->ostream() << "nil"; }
2913 // Import a nil expression.
2916 Nil_expression::do_import(Import
* imp
)
2918 imp
->require_c_string("nil");
2919 return Expression::make_nil(imp
->location());
2922 // Make a nil expression.
2925 Expression::make_nil(Location location
)
2927 return new Nil_expression(location
);
2930 // The value of the predeclared constant iota. This is little more
2931 // than a marker. This will be lowered to an integer in
2932 // Const_expression::do_lower, which is where we know the value that
2935 class Iota_expression
: public Parser_expression
2938 Iota_expression(Location location
)
2939 : Parser_expression(EXPRESSION_IOTA
, location
)
2944 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
2945 { go_unreachable(); }
2947 // There should only ever be one of these.
2950 { go_unreachable(); }
2953 do_dump_expression(Ast_dump_context
* ast_dump_context
) const
2954 { ast_dump_context
->ostream() << "iota"; }
2957 // Make an iota expression. This is only called for one case: the
2958 // value of the predeclared constant iota.
2961 Expression::make_iota()
2963 static Iota_expression
iota_expression(Linemap::unknown_location());
2964 return &iota_expression
;
2967 // A type conversion expression.
2969 class Type_conversion_expression
: public Expression
2972 Type_conversion_expression(Type
* type
, Expression
* expr
,
2974 : Expression(EXPRESSION_CONVERSION
, location
),
2975 type_(type
), expr_(expr
), may_convert_function_types_(false)
2978 // Return the type to which we are converting.
2981 { return this->type_
; }
2983 // Return the expression which we are converting.
2986 { return this->expr_
; }
2988 // Permit converting from one function type to another. This is
2989 // used internally for method expressions.
2991 set_may_convert_function_types()
2993 this->may_convert_function_types_
= true;
2996 // Import a type conversion expression.
3002 do_traverse(Traverse
* traverse
);
3005 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
3008 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
3011 do_is_constant() const;
3014 do_is_immutable() const;
3017 do_numeric_constant_value(Numeric_constant
*) const;
3020 do_string_constant_value(std::string
*) const;
3024 { return this->type_
; }
3027 do_determine_type(const Type_context
*)
3029 Type_context
subcontext(this->type_
, false);
3030 this->expr_
->determine_type(&subcontext
);
3034 do_check_types(Gogo
*);
3039 return new Type_conversion_expression(this->type_
, this->expr_
->copy(),
3044 do_get_backend(Translate_context
* context
);
3047 do_export(Export
*) const;
3050 do_dump_expression(Ast_dump_context
*) const;
3053 // The type to convert to.
3055 // The expression to convert.
3057 // True if this is permitted to convert function types. This is
3058 // used internally for method expressions.
3059 bool may_convert_function_types_
;
3065 Type_conversion_expression::do_traverse(Traverse
* traverse
)
3067 if (Expression::traverse(&this->expr_
, traverse
) == TRAVERSE_EXIT
3068 || Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
3069 return TRAVERSE_EXIT
;
3070 return TRAVERSE_CONTINUE
;
3073 // Convert to a constant at lowering time.
3076 Type_conversion_expression::do_lower(Gogo
*, Named_object
*,
3077 Statement_inserter
*, int)
3079 Type
* type
= this->type_
;
3080 Expression
* val
= this->expr_
;
3081 Location location
= this->location();
3083 if (type
->is_numeric_type())
3085 Numeric_constant nc
;
3086 if (val
->numeric_constant_value(&nc
))
3088 if (!nc
.set_type(type
, true, location
))
3089 return Expression::make_error(location
);
3090 return nc
.expression(location
);
3094 if (type
->is_slice_type())
3096 Type
* element_type
= type
->array_type()->element_type()->forwarded();
3097 bool is_byte
= (element_type
->integer_type() != NULL
3098 && element_type
->integer_type()->is_byte());
3099 bool is_rune
= (element_type
->integer_type() != NULL
3100 && element_type
->integer_type()->is_rune());
3101 if (is_byte
|| is_rune
)
3104 if (val
->string_constant_value(&s
))
3106 Expression_list
* vals
= new Expression_list();
3109 for (std::string::const_iterator p
= s
.begin();
3113 unsigned char c
= static_cast<unsigned char>(*p
);
3114 vals
->push_back(Expression::make_integer_ul(c
,
3121 const char *p
= s
.data();
3122 const char *pend
= s
.data() + s
.length();
3126 int adv
= Lex::fetch_char(p
, &c
);
3129 warning_at(this->location(), 0,
3130 "invalid UTF-8 encoding");
3134 vals
->push_back(Expression::make_integer_ul(c
,
3140 return Expression::make_slice_composite_literal(type
, vals
,
3149 // Flatten a type conversion by using a temporary variable for the slice
3150 // in slice to string conversions.
3153 Type_conversion_expression::do_flatten(Gogo
*, Named_object
*,
3154 Statement_inserter
* inserter
)
3156 if (((this->type()->is_string_type()
3157 && this->expr_
->type()->is_slice_type())
3158 || (this->type()->interface_type() != NULL
3159 && this->expr_
->type()->interface_type() != NULL
))
3160 && !this->expr_
->is_variable())
3162 Temporary_statement
* temp
=
3163 Statement::make_temporary(NULL
, this->expr_
, this->location());
3164 inserter
->insert(temp
);
3165 this->expr_
= Expression::make_temporary_reference(temp
, this->location());
3170 // Return whether a type conversion is a constant.
3173 Type_conversion_expression::do_is_constant() const
3175 if (!this->expr_
->is_constant())
3178 // A conversion to a type that may not be used as a constant is not
3179 // a constant. For example, []byte(nil).
3180 Type
* type
= this->type_
;
3181 if (type
->integer_type() == NULL
3182 && type
->float_type() == NULL
3183 && type
->complex_type() == NULL
3184 && !type
->is_boolean_type()
3185 && !type
->is_string_type())
3191 // Return whether a type conversion is immutable.
3194 Type_conversion_expression::do_is_immutable() const
3196 Type
* type
= this->type_
;
3197 Type
* expr_type
= this->expr_
->type();
3199 if (type
->interface_type() != NULL
3200 || expr_type
->interface_type() != NULL
)
3203 if (!this->expr_
->is_immutable())
3206 if (Type::are_identical(type
, expr_type
, false, NULL
))
3209 return type
->is_basic_type() && expr_type
->is_basic_type();
3212 // Return the constant numeric value if there is one.
3215 Type_conversion_expression::do_numeric_constant_value(
3216 Numeric_constant
* nc
) const
3218 if (!this->type_
->is_numeric_type())
3220 if (!this->expr_
->numeric_constant_value(nc
))
3222 return nc
->set_type(this->type_
, false, this->location());
3225 // Return the constant string value if there is one.
3228 Type_conversion_expression::do_string_constant_value(std::string
* val
) const
3230 if (this->type_
->is_string_type()
3231 && this->expr_
->type()->integer_type() != NULL
)
3233 Numeric_constant nc
;
3234 if (this->expr_
->numeric_constant_value(&nc
))
3237 if (nc
.to_unsigned_long(&ival
) == Numeric_constant::NC_UL_VALID
)
3240 Lex::append_char(ival
, true, val
, this->location());
3246 // FIXME: Could handle conversion from const []int here.
3251 // Check that types are convertible.
3254 Type_conversion_expression::do_check_types(Gogo
*)
3256 Type
* type
= this->type_
;
3257 Type
* expr_type
= this->expr_
->type();
3260 if (type
->is_error() || expr_type
->is_error())
3262 this->set_is_error();
3266 if (this->may_convert_function_types_
3267 && type
->function_type() != NULL
3268 && expr_type
->function_type() != NULL
)
3271 if (Type::are_convertible(type
, expr_type
, &reason
))
3274 error_at(this->location(), "%s", reason
.c_str());
3275 this->set_is_error();
3278 // Get the backend representation for a type conversion.
3281 Type_conversion_expression::do_get_backend(Translate_context
* context
)
3283 Type
* type
= this->type_
;
3284 Type
* expr_type
= this->expr_
->type();
3286 Gogo
* gogo
= context
->gogo();
3287 Btype
* btype
= type
->get_backend(gogo
);
3288 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
3289 Location loc
= this->location();
3291 if (Type::are_identical(type
, expr_type
, false, NULL
))
3292 return gogo
->backend()->convert_expression(btype
, bexpr
, loc
);
3293 else if (type
->interface_type() != NULL
3294 || expr_type
->interface_type() != NULL
)
3296 Expression
* conversion
=
3297 Expression::convert_for_assignment(gogo
, type
, this->expr_
,
3299 return conversion
->get_backend(context
);
3301 else if (type
->is_string_type()
3302 && expr_type
->integer_type() != NULL
)
3305 Numeric_constant nc
;
3306 if (this->expr_
->numeric_constant_value(&nc
)
3307 && nc
.to_int(&intval
)
3308 && mpz_fits_ushort_p(intval
))
3311 Lex::append_char(mpz_get_ui(intval
), true, &s
, loc
);
3313 Expression
* se
= Expression::make_string(s
, loc
);
3314 return se
->get_backend(context
);
3317 Expression
* i2s_expr
=
3318 Runtime::make_call(Runtime::INT_TO_STRING
, loc
, 1, this->expr_
);
3319 return Expression::make_cast(type
, i2s_expr
, loc
)->get_backend(context
);
3321 else if (type
->is_string_type() && expr_type
->is_slice_type())
3323 Array_type
* a
= expr_type
->array_type();
3324 Type
* e
= a
->element_type()->forwarded();
3325 go_assert(e
->integer_type() != NULL
);
3326 go_assert(this->expr_
->is_variable());
3328 Runtime::Function code
;
3329 if (e
->integer_type()->is_byte())
3330 code
= Runtime::BYTE_ARRAY_TO_STRING
;
3333 go_assert(e
->integer_type()->is_rune());
3334 code
= Runtime::INT_ARRAY_TO_STRING
;
3336 Expression
* valptr
= a
->get_value_pointer(gogo
, this->expr_
);
3337 Expression
* len
= a
->get_length(gogo
, this->expr_
);
3338 return Runtime::make_call(code
, loc
, 2, valptr
,
3339 len
)->get_backend(context
);
3341 else if (type
->is_slice_type() && expr_type
->is_string_type())
3343 Type
* e
= type
->array_type()->element_type()->forwarded();
3344 go_assert(e
->integer_type() != NULL
);
3346 Runtime::Function code
;
3347 if (e
->integer_type()->is_byte())
3348 code
= Runtime::STRING_TO_BYTE_ARRAY
;
3351 go_assert(e
->integer_type()->is_rune());
3352 code
= Runtime::STRING_TO_INT_ARRAY
;
3354 Expression
* s2a
= Runtime::make_call(code
, loc
, 1, this->expr_
);
3355 return Expression::make_unsafe_cast(type
, s2a
, loc
)->get_backend(context
);
3357 else if (type
->is_numeric_type())
3359 go_assert(Type::are_convertible(type
, expr_type
, NULL
));
3360 return gogo
->backend()->convert_expression(btype
, bexpr
, loc
);
3362 else if ((type
->is_unsafe_pointer_type()
3363 && (expr_type
->points_to() != NULL
3364 || expr_type
->integer_type()))
3365 || (expr_type
->is_unsafe_pointer_type()
3366 && type
->points_to() != NULL
)
3367 || (this->may_convert_function_types_
3368 && type
->function_type() != NULL
3369 && expr_type
->function_type() != NULL
))
3370 return gogo
->backend()->convert_expression(btype
, bexpr
, loc
);
3373 Expression
* conversion
=
3374 Expression::convert_for_assignment(gogo
, type
, this->expr_
, loc
);
3375 return conversion
->get_backend(context
);
3379 // Output a type conversion in a constant expression.
3382 Type_conversion_expression::do_export(Export
* exp
) const
3384 exp
->write_c_string("convert(");
3385 exp
->write_type(this->type_
);
3386 exp
->write_c_string(", ");
3387 this->expr_
->export_expression(exp
);
3388 exp
->write_c_string(")");
3391 // Import a type conversion or a struct construction.
3394 Type_conversion_expression::do_import(Import
* imp
)
3396 imp
->require_c_string("convert(");
3397 Type
* type
= imp
->read_type();
3398 imp
->require_c_string(", ");
3399 Expression
* val
= Expression::import_expression(imp
);
3400 imp
->require_c_string(")");
3401 return Expression::make_cast(type
, val
, imp
->location());
3404 // Dump ast representation for a type conversion expression.
3407 Type_conversion_expression::do_dump_expression(
3408 Ast_dump_context
* ast_dump_context
) const
3410 ast_dump_context
->dump_type(this->type_
);
3411 ast_dump_context
->ostream() << "(";
3412 ast_dump_context
->dump_expression(this->expr_
);
3413 ast_dump_context
->ostream() << ") ";
3416 // Make a type cast expression.
3419 Expression::make_cast(Type
* type
, Expression
* val
, Location location
)
3421 if (type
->is_error_type() || val
->is_error_expression())
3422 return Expression::make_error(location
);
3423 return new Type_conversion_expression(type
, val
, location
);
3426 // An unsafe type conversion, used to pass values to builtin functions.
3428 class Unsafe_type_conversion_expression
: public Expression
3431 Unsafe_type_conversion_expression(Type
* type
, Expression
* expr
,
3433 : Expression(EXPRESSION_UNSAFE_CONVERSION
, location
),
3434 type_(type
), expr_(expr
)
3439 do_traverse(Traverse
* traverse
);
3442 do_is_immutable() const;
3446 { return this->type_
; }
3449 do_determine_type(const Type_context
*)
3450 { this->expr_
->determine_type_no_context(); }
3455 return new Unsafe_type_conversion_expression(this->type_
,
3456 this->expr_
->copy(),
3461 do_get_backend(Translate_context
*);
3464 do_dump_expression(Ast_dump_context
*) const;
3467 // The type to convert to.
3469 // The expression to convert.
3476 Unsafe_type_conversion_expression::do_traverse(Traverse
* traverse
)
3478 if (Expression::traverse(&this->expr_
, traverse
) == TRAVERSE_EXIT
3479 || Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
3480 return TRAVERSE_EXIT
;
3481 return TRAVERSE_CONTINUE
;
3484 // Return whether an unsafe type conversion is immutable.
3487 Unsafe_type_conversion_expression::do_is_immutable() const
3489 Type
* type
= this->type_
;
3490 Type
* expr_type
= this->expr_
->type();
3492 if (type
->interface_type() != NULL
3493 || expr_type
->interface_type() != NULL
)
3496 if (!this->expr_
->is_immutable())
3499 if (Type::are_convertible(type
, expr_type
, NULL
))
3502 return type
->is_basic_type() && expr_type
->is_basic_type();
3505 // Convert to backend representation.
3508 Unsafe_type_conversion_expression::do_get_backend(Translate_context
* context
)
3510 // We are only called for a limited number of cases.
3512 Type
* t
= this->type_
;
3513 Type
* et
= this->expr_
->type();
3514 if (t
->array_type() != NULL
)
3515 go_assert(et
->array_type() != NULL
3516 && t
->is_slice_type() == et
->is_slice_type());
3517 else if (t
->struct_type() != NULL
)
3519 if (t
->named_type() != NULL
3520 && et
->named_type() != NULL
3521 && !Type::are_convertible(t
, et
, NULL
))
3523 go_assert(saw_errors());
3524 return context
->backend()->error_expression();
3527 go_assert(et
->struct_type() != NULL
3528 && Type::are_convertible(t
, et
, NULL
));
3530 else if (t
->map_type() != NULL
)
3531 go_assert(et
->map_type() != NULL
);
3532 else if (t
->channel_type() != NULL
)
3533 go_assert(et
->channel_type() != NULL
);
3534 else if (t
->points_to() != NULL
)
3535 go_assert(et
->points_to() != NULL
3536 || et
->channel_type() != NULL
3537 || et
->map_type() != NULL
3538 || et
->function_type() != NULL
3539 || et
->is_nil_type());
3540 else if (et
->is_unsafe_pointer_type())
3541 go_assert(t
->points_to() != NULL
);
3542 else if (t
->interface_type() != NULL
)
3544 bool empty_iface
= t
->interface_type()->is_empty();
3545 go_assert(et
->interface_type() != NULL
3546 && et
->interface_type()->is_empty() == empty_iface
);
3548 else if (t
->integer_type() != NULL
)
3549 go_assert(et
->is_boolean_type()
3550 || et
->integer_type() != NULL
3551 || et
->function_type() != NULL
3552 || et
->points_to() != NULL
3553 || et
->map_type() != NULL
3554 || et
->channel_type() != NULL
);
3558 Gogo
* gogo
= context
->gogo();
3559 Btype
* btype
= t
->get_backend(gogo
);
3560 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
3561 Location loc
= this->location();
3562 return gogo
->backend()->convert_expression(btype
, bexpr
, loc
);
3565 // Dump ast representation for an unsafe type conversion expression.
3568 Unsafe_type_conversion_expression::do_dump_expression(
3569 Ast_dump_context
* ast_dump_context
) const
3571 ast_dump_context
->dump_type(this->type_
);
3572 ast_dump_context
->ostream() << "(";
3573 ast_dump_context
->dump_expression(this->expr_
);
3574 ast_dump_context
->ostream() << ") ";
3577 // Make an unsafe type conversion expression.
3580 Expression::make_unsafe_cast(Type
* type
, Expression
* expr
,
3583 return new Unsafe_type_conversion_expression(type
, expr
, location
);
3586 // Class Unary_expression.
3588 // If we are taking the address of a composite literal, and the
3589 // contents are not constant, then we want to make a heap expression
3593 Unary_expression::do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
3595 Location loc
= this->location();
3596 Operator op
= this->op_
;
3597 Expression
* expr
= this->expr_
;
3599 if (op
== OPERATOR_MULT
&& expr
->is_type_expression())
3600 return Expression::make_type(Type::make_pointer_type(expr
->type()), loc
);
3602 // *&x simplifies to x. *(*T)(unsafe.Pointer)(&x) does not require
3603 // moving x to the heap. FIXME: Is it worth doing a real escape
3604 // analysis here? This case is found in math/unsafe.go and is
3605 // therefore worth special casing.
3606 if (op
== OPERATOR_MULT
)
3608 Expression
* e
= expr
;
3609 while (e
->classification() == EXPRESSION_CONVERSION
)
3611 Type_conversion_expression
* te
3612 = static_cast<Type_conversion_expression
*>(e
);
3616 if (e
->classification() == EXPRESSION_UNARY
)
3618 Unary_expression
* ue
= static_cast<Unary_expression
*>(e
);
3619 if (ue
->op_
== OPERATOR_AND
)
3624 if (!ue
->expr_
->is_addressable() && !ue
->create_temp_
)
3626 error_at(ue
->location(),
3627 "invalid operand for unary %<&%>");
3628 this->set_is_error();
3632 ue
->set_does_not_escape();
3637 // Catching an invalid indirection of unsafe.Pointer here avoid
3638 // having to deal with TYPE_VOID in other places.
3639 if (op
== OPERATOR_MULT
&& expr
->type()->is_unsafe_pointer_type())
3641 error_at(this->location(), "invalid indirect of %<unsafe.Pointer%>");
3642 return Expression::make_error(this->location());
3645 // Check for an invalid pointer dereference. We need to do this
3646 // here because Unary_expression::do_type will return an error type
3647 // in this case. That can cause code to appear erroneous, and
3648 // therefore disappear at lowering time, without any error message.
3649 if (op
== OPERATOR_MULT
&& expr
->type()->points_to() == NULL
)
3651 this->report_error(_("expected pointer"));
3652 return Expression::make_error(this->location());
3655 if (op
== OPERATOR_PLUS
|| op
== OPERATOR_MINUS
|| op
== OPERATOR_XOR
)
3657 Numeric_constant nc
;
3658 if (expr
->numeric_constant_value(&nc
))
3660 Numeric_constant result
;
3661 if (Unary_expression::eval_constant(op
, &nc
, loc
, &result
))
3662 return result
.expression(loc
);
3669 // Flatten expression if a nil check must be performed and create temporary
3670 // variables if necessary.
3673 Unary_expression::do_flatten(Gogo
* gogo
, Named_object
*,
3674 Statement_inserter
* inserter
)
3676 if (this->is_error_expression() || this->expr_
->is_error_expression())
3677 return Expression::make_error(this->location());
3679 Location location
= this->location();
3680 if (this->op_
== OPERATOR_MULT
3681 && !this->expr_
->is_variable())
3683 go_assert(this->expr_
->type()->points_to() != NULL
);
3684 Type
* ptype
= this->expr_
->type()->points_to();
3685 if (!ptype
->is_void_type())
3687 Btype
* pbtype
= ptype
->get_backend(gogo
);
3688 size_t s
= gogo
->backend()->type_size(pbtype
);
3689 if (s
>= 4096 || this->issue_nil_check_
)
3691 Temporary_statement
* temp
=
3692 Statement::make_temporary(NULL
, this->expr_
, location
);
3693 inserter
->insert(temp
);
3695 Expression::make_temporary_reference(temp
, location
);
3700 if (this->create_temp_
&& !this->expr_
->is_variable())
3702 Temporary_statement
* temp
=
3703 Statement::make_temporary(NULL
, this->expr_
, location
);
3704 inserter
->insert(temp
);
3705 this->expr_
= Expression::make_temporary_reference(temp
, location
);
3711 // Return whether a unary expression is a constant.
3714 Unary_expression::do_is_constant() const
3716 if (this->op_
== OPERATOR_MULT
)
3718 // Indirecting through a pointer is only constant if the object
3719 // to which the expression points is constant, but we currently
3720 // have no way to determine that.
3723 else if (this->op_
== OPERATOR_AND
)
3725 // Taking the address of a variable is constant if it is a
3726 // global variable, not constant otherwise. In other cases taking the
3727 // address is probably not a constant.
3728 Var_expression
* ve
= this->expr_
->var_expression();
3731 Named_object
* no
= ve
->named_object();
3732 return no
->is_variable() && no
->var_value()->is_global();
3737 return this->expr_
->is_constant();
3740 // Apply unary opcode OP to UNC, setting NC. Return true if this
3741 // could be done, false if not. Issue errors for overflow.
3744 Unary_expression::eval_constant(Operator op
, const Numeric_constant
* unc
,
3745 Location location
, Numeric_constant
* nc
)
3753 case OPERATOR_MINUS
:
3754 if (unc
->is_int() || unc
->is_rune())
3756 else if (unc
->is_float())
3759 unc
->get_float(&uval
);
3762 mpfr_neg(val
, uval
, GMP_RNDN
);
3763 nc
->set_float(unc
->type(), val
);
3768 else if (unc
->is_complex())
3771 unc
->get_complex(&uval
);
3773 mpc_init2(val
, mpc_precision
);
3774 mpc_neg(val
, uval
, MPC_RNDNN
);
3775 nc
->set_complex(unc
->type(), val
);
3795 if (!unc
->is_int() && !unc
->is_rune())
3800 unc
->get_rune(&uval
);
3802 unc
->get_int(&uval
);
3808 case OPERATOR_MINUS
:
3813 mpz_set_ui(val
, mpz_cmp_si(uval
, 0) == 0 ? 1 : 0);
3818 Type
* utype
= unc
->type();
3819 if (utype
->integer_type() == NULL
3820 || utype
->integer_type()->is_abstract())
3824 // The number of HOST_WIDE_INTs that it takes to represent
3826 size_t count
= ((mpz_sizeinbase(uval
, 2)
3827 + HOST_BITS_PER_WIDE_INT
3829 / HOST_BITS_PER_WIDE_INT
);
3831 unsigned HOST_WIDE_INT
* phwi
= new unsigned HOST_WIDE_INT
[count
];
3832 memset(phwi
, 0, count
* sizeof(HOST_WIDE_INT
));
3834 size_t obits
= utype
->integer_type()->bits();
3836 if (!utype
->integer_type()->is_unsigned() && mpz_sgn(uval
) < 0)
3839 mpz_init_set_ui(adj
, 1);
3840 mpz_mul_2exp(adj
, adj
, obits
);
3841 mpz_add(uval
, uval
, adj
);
3846 mpz_export(phwi
, &ecount
, -1, sizeof(HOST_WIDE_INT
), 0, 0, uval
);
3847 go_assert(ecount
<= count
);
3849 // Trim down to the number of words required by the type.
3850 size_t ocount
= ((obits
+ HOST_BITS_PER_WIDE_INT
- 1)
3851 / HOST_BITS_PER_WIDE_INT
);
3852 go_assert(ocount
<= count
);
3854 for (size_t i
= 0; i
< ocount
; ++i
)
3857 size_t clearbits
= ocount
* HOST_BITS_PER_WIDE_INT
- obits
;
3859 phwi
[ocount
- 1] &= (((unsigned HOST_WIDE_INT
) (HOST_WIDE_INT
) -1)
3862 mpz_import(val
, ocount
, -1, sizeof(HOST_WIDE_INT
), 0, 0, phwi
);
3864 if (!utype
->integer_type()->is_unsigned()
3865 && mpz_tstbit(val
, obits
- 1))
3868 mpz_init_set_ui(adj
, 1);
3869 mpz_mul_2exp(adj
, adj
, obits
);
3870 mpz_sub(val
, val
, adj
);
3884 nc
->set_rune(NULL
, val
);
3886 nc
->set_int(NULL
, val
);
3891 return nc
->set_type(unc
->type(), true, location
);
3894 // Return the integral constant value of a unary expression, if it has one.
3897 Unary_expression::do_numeric_constant_value(Numeric_constant
* nc
) const
3899 Numeric_constant unc
;
3900 if (!this->expr_
->numeric_constant_value(&unc
))
3902 return Unary_expression::eval_constant(this->op_
, &unc
, this->location(),
3906 // Return the type of a unary expression.
3909 Unary_expression::do_type()
3914 case OPERATOR_MINUS
:
3917 return this->expr_
->type();
3920 return Type::make_pointer_type(this->expr_
->type());
3924 Type
* subtype
= this->expr_
->type();
3925 Type
* points_to
= subtype
->points_to();
3926 if (points_to
== NULL
)
3927 return Type::make_error_type();
3936 // Determine abstract types for a unary expression.
3939 Unary_expression::do_determine_type(const Type_context
* context
)
3944 case OPERATOR_MINUS
:
3947 this->expr_
->determine_type(context
);
3951 // Taking the address of something.
3953 Type
* subtype
= (context
->type
== NULL
3955 : context
->type
->points_to());
3956 Type_context
subcontext(subtype
, false);
3957 this->expr_
->determine_type(&subcontext
);
3962 // Indirecting through a pointer.
3964 Type
* subtype
= (context
->type
== NULL
3966 : Type::make_pointer_type(context
->type
));
3967 Type_context
subcontext(subtype
, false);
3968 this->expr_
->determine_type(&subcontext
);
3977 // Check types for a unary expression.
3980 Unary_expression::do_check_types(Gogo
*)
3982 Type
* type
= this->expr_
->type();
3983 if (type
->is_error())
3985 this->set_is_error();
3992 case OPERATOR_MINUS
:
3993 if (type
->integer_type() == NULL
3994 && type
->float_type() == NULL
3995 && type
->complex_type() == NULL
)
3996 this->report_error(_("expected numeric type"));
4000 if (!type
->is_boolean_type())
4001 this->report_error(_("expected boolean type"));
4005 if (type
->integer_type() == NULL
4006 && !type
->is_boolean_type())
4007 this->report_error(_("expected integer or boolean type"));
4011 if (!this->expr_
->is_addressable())
4013 if (!this->create_temp_
)
4015 error_at(this->location(), "invalid operand for unary %<&%>");
4016 this->set_is_error();
4021 this->expr_
->address_taken(this->escapes_
);
4022 this->expr_
->issue_nil_check();
4027 // Indirecting through a pointer.
4028 if (type
->points_to() == NULL
)
4029 this->report_error(_("expected pointer"));
4037 // Get the backend representation for a unary expression.
4040 Unary_expression::do_get_backend(Translate_context
* context
)
4042 Gogo
* gogo
= context
->gogo();
4043 Location loc
= this->location();
4045 // Taking the address of a set-and-use-temporary expression requires
4046 // setting the temporary and then taking the address.
4047 if (this->op_
== OPERATOR_AND
)
4049 Set_and_use_temporary_expression
* sut
=
4050 this->expr_
->set_and_use_temporary_expression();
4053 Temporary_statement
* temp
= sut
->temporary();
4054 Bvariable
* bvar
= temp
->get_backend_variable(context
);
4055 Bexpression
* bvar_expr
= gogo
->backend()->var_expression(bvar
, loc
);
4056 Bexpression
* bval
= sut
->expression()->get_backend(context
);
4058 Bstatement
* bassign
=
4059 gogo
->backend()->assignment_statement(bvar_expr
, bval
, loc
);
4060 Bexpression
* bvar_addr
=
4061 gogo
->backend()->address_expression(bvar_expr
, loc
);
4062 return gogo
->backend()->compound_expression(bassign
, bvar_addr
, loc
);
4067 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
4068 Btype
* btype
= this->expr_
->type()->get_backend(gogo
);
4075 case OPERATOR_MINUS
:
4076 ret
= gogo
->backend()->unary_expression(this->op_
, bexpr
, loc
);
4077 ret
= gogo
->backend()->convert_expression(btype
, ret
, loc
);
4082 ret
= gogo
->backend()->unary_expression(this->op_
, bexpr
, loc
);
4086 if (!this->create_temp_
)
4088 // We should not see a non-constant constructor here; cases
4089 // where we would see one should have been moved onto the
4090 // heap at parse time. Taking the address of a nonconstant
4091 // constructor will not do what the programmer expects.
4093 go_assert(!this->expr_
->is_composite_literal()
4094 || this->expr_
->is_immutable());
4095 if (this->expr_
->classification() == EXPRESSION_UNARY
)
4097 Unary_expression
* ue
=
4098 static_cast<Unary_expression
*>(this->expr_
);
4099 go_assert(ue
->op() != OPERATOR_AND
);
4103 static unsigned int counter
;
4105 if (this->is_gc_root_
|| this->is_slice_init_
)
4107 bool copy_to_heap
= false;
4108 if (this->is_gc_root_
)
4110 // Build a decl for a GC root variable. GC roots are mutable, so
4111 // they cannot be represented as an immutable_struct in the
4113 static unsigned int root_counter
;
4114 snprintf(buf
, sizeof buf
, "gc%u", root_counter
);
4119 // Build a decl for a slice value initializer. An immutable slice
4120 // value initializer may have to be copied to the heap if it
4121 // contains pointers in a non-constant context.
4122 snprintf(buf
, sizeof buf
, "C%u", counter
);
4125 Array_type
* at
= this->expr_
->type()->array_type();
4126 go_assert(at
!= NULL
);
4128 // If we are not copying the value to the heap, we will only
4129 // initialize the value once, so we can use this directly
4130 // rather than copying it. In that case we can't make it
4131 // read-only, because the program is permitted to change it.
4132 copy_to_heap
= (at
->element_type()->has_pointer()
4133 && !context
->is_const());
4135 Bvariable
* implicit
=
4136 gogo
->backend()->implicit_variable(buf
, btype
, true, copy_to_heap
,
4138 gogo
->backend()->implicit_variable_set_init(implicit
, buf
, btype
,
4139 true, copy_to_heap
, false,
4141 bexpr
= gogo
->backend()->var_expression(implicit
, loc
);
4143 else if ((this->expr_
->is_composite_literal()
4144 || this->expr_
->string_expression() != NULL
)
4145 && this->expr_
->is_immutable())
4147 // Build a decl for a constant constructor.
4148 snprintf(buf
, sizeof buf
, "C%u", counter
);
4152 gogo
->backend()->immutable_struct(buf
, true, false, btype
, loc
);
4153 gogo
->backend()->immutable_struct_set_init(decl
, buf
, true, false,
4155 bexpr
= gogo
->backend()->var_expression(decl
, loc
);
4158 go_assert(!this->create_temp_
|| this->expr_
->is_variable());
4159 ret
= gogo
->backend()->address_expression(bexpr
, loc
);
4164 go_assert(this->expr_
->type()->points_to() != NULL
);
4166 // If we are dereferencing the pointer to a large struct, we
4167 // need to check for nil. We don't bother to check for small
4168 // structs because we expect the system to crash on a nil
4169 // pointer dereference. However, if we know the address of this
4170 // expression is being taken, we must always check for nil.
4172 Type
* ptype
= this->expr_
->type()->points_to();
4173 Btype
* pbtype
= ptype
->get_backend(gogo
);
4174 if (!ptype
->is_void_type())
4176 size_t s
= gogo
->backend()->type_size(pbtype
);
4177 if (s
>= 4096 || this->issue_nil_check_
)
4179 go_assert(this->expr_
->is_variable());
4181 Expression::make_nil(loc
)->get_backend(context
);
4182 Bexpression
* compare
=
4183 gogo
->backend()->binary_expression(OPERATOR_EQEQ
, bexpr
,
4185 Bexpression
* crash
=
4186 gogo
->runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE
,
4187 loc
)->get_backend(context
);
4188 bexpr
= gogo
->backend()->conditional_expression(btype
, compare
,
4194 ret
= gogo
->backend()->indirect_expression(pbtype
, bexpr
, false, loc
);
4205 // Export a unary expression.
4208 Unary_expression::do_export(Export
* exp
) const
4213 exp
->write_c_string("+ ");
4215 case OPERATOR_MINUS
:
4216 exp
->write_c_string("- ");
4219 exp
->write_c_string("! ");
4222 exp
->write_c_string("^ ");
4229 this->expr_
->export_expression(exp
);
4232 // Import a unary expression.
4235 Unary_expression::do_import(Import
* imp
)
4238 switch (imp
->get_char())
4244 op
= OPERATOR_MINUS
;
4255 imp
->require_c_string(" ");
4256 Expression
* expr
= Expression::import_expression(imp
);
4257 return Expression::make_unary(op
, expr
, imp
->location());
4260 // Dump ast representation of an unary expression.
4263 Unary_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
4265 ast_dump_context
->dump_operator(this->op_
);
4266 ast_dump_context
->ostream() << "(";
4267 ast_dump_context
->dump_expression(this->expr_
);
4268 ast_dump_context
->ostream() << ") ";
4271 // Make a unary expression.
4274 Expression::make_unary(Operator op
, Expression
* expr
, Location location
)
4276 return new Unary_expression(op
, expr
, location
);
4279 // If this is an indirection through a pointer, return the expression
4280 // being pointed through. Otherwise return this.
4285 if (this->classification_
== EXPRESSION_UNARY
)
4287 Unary_expression
* ue
= static_cast<Unary_expression
*>(this);
4288 if (ue
->op() == OPERATOR_MULT
)
4289 return ue
->operand();
4294 // Class Binary_expression.
4299 Binary_expression::do_traverse(Traverse
* traverse
)
4301 int t
= Expression::traverse(&this->left_
, traverse
);
4302 if (t
== TRAVERSE_EXIT
)
4303 return TRAVERSE_EXIT
;
4304 return Expression::traverse(&this->right_
, traverse
);
4307 // Return the type to use for a binary operation on operands of
4308 // LEFT_TYPE and RIGHT_TYPE. These are the types of constants and as
4309 // such may be NULL or abstract.
4312 Binary_expression::operation_type(Operator op
, Type
* left_type
,
4313 Type
* right_type
, Type
** result_type
)
4315 if (left_type
!= right_type
4316 && !left_type
->is_abstract()
4317 && !right_type
->is_abstract()
4318 && left_type
->base() != right_type
->base()
4319 && op
!= OPERATOR_LSHIFT
4320 && op
!= OPERATOR_RSHIFT
)
4322 // May be a type error--let it be diagnosed elsewhere.
4326 if (op
== OPERATOR_LSHIFT
|| op
== OPERATOR_RSHIFT
)
4328 if (left_type
->integer_type() != NULL
)
4329 *result_type
= left_type
;
4331 *result_type
= Type::make_abstract_integer_type();
4333 else if (!left_type
->is_abstract() && left_type
->named_type() != NULL
)
4334 *result_type
= left_type
;
4335 else if (!right_type
->is_abstract() && right_type
->named_type() != NULL
)
4336 *result_type
= right_type
;
4337 else if (!left_type
->is_abstract())
4338 *result_type
= left_type
;
4339 else if (!right_type
->is_abstract())
4340 *result_type
= right_type
;
4341 else if (left_type
->complex_type() != NULL
)
4342 *result_type
= left_type
;
4343 else if (right_type
->complex_type() != NULL
)
4344 *result_type
= right_type
;
4345 else if (left_type
->float_type() != NULL
)
4346 *result_type
= left_type
;
4347 else if (right_type
->float_type() != NULL
)
4348 *result_type
= right_type
;
4349 else if (left_type
->integer_type() != NULL
4350 && left_type
->integer_type()->is_rune())
4351 *result_type
= left_type
;
4352 else if (right_type
->integer_type() != NULL
4353 && right_type
->integer_type()->is_rune())
4354 *result_type
= right_type
;
4356 *result_type
= left_type
;
4361 // Convert an integer comparison code and an operator to a boolean
4365 Binary_expression::cmp_to_bool(Operator op
, int cmp
)
4372 case OPERATOR_NOTEQ
:
4389 // Compare constants according to OP.
4392 Binary_expression::compare_constant(Operator op
, Numeric_constant
* left_nc
,
4393 Numeric_constant
* right_nc
,
4394 Location location
, bool* result
)
4396 Type
* left_type
= left_nc
->type();
4397 Type
* right_type
= right_nc
->type();
4400 if (!Binary_expression::operation_type(op
, left_type
, right_type
, &type
))
4403 // When comparing an untyped operand to a typed operand, we are
4404 // effectively coercing the untyped operand to the other operand's
4405 // type, so make sure that is valid.
4406 if (!left_nc
->set_type(type
, true, location
)
4407 || !right_nc
->set_type(type
, true, location
))
4412 if (type
->complex_type() != NULL
)
4414 if (op
!= OPERATOR_EQEQ
&& op
!= OPERATOR_NOTEQ
)
4416 ret
= Binary_expression::compare_complex(left_nc
, right_nc
, &cmp
);
4418 else if (type
->float_type() != NULL
)
4419 ret
= Binary_expression::compare_float(left_nc
, right_nc
, &cmp
);
4421 ret
= Binary_expression::compare_integer(left_nc
, right_nc
, &cmp
);
4424 *result
= Binary_expression::cmp_to_bool(op
, cmp
);
4429 // Compare integer constants.
4432 Binary_expression::compare_integer(const Numeric_constant
* left_nc
,
4433 const Numeric_constant
* right_nc
,
4437 if (!left_nc
->to_int(&left_val
))
4440 if (!right_nc
->to_int(&right_val
))
4442 mpz_clear(left_val
);
4446 *cmp
= mpz_cmp(left_val
, right_val
);
4448 mpz_clear(left_val
);
4449 mpz_clear(right_val
);
4454 // Compare floating point constants.
4457 Binary_expression::compare_float(const Numeric_constant
* left_nc
,
4458 const Numeric_constant
* right_nc
,
4462 if (!left_nc
->to_float(&left_val
))
4465 if (!right_nc
->to_float(&right_val
))
4467 mpfr_clear(left_val
);
4471 // We already coerced both operands to the same type. If that type
4472 // is not an abstract type, we need to round the values accordingly.
4473 Type
* type
= left_nc
->type();
4474 if (!type
->is_abstract() && type
->float_type() != NULL
)
4476 int bits
= type
->float_type()->bits();
4477 mpfr_prec_round(left_val
, bits
, GMP_RNDN
);
4478 mpfr_prec_round(right_val
, bits
, GMP_RNDN
);
4481 *cmp
= mpfr_cmp(left_val
, right_val
);
4483 mpfr_clear(left_val
);
4484 mpfr_clear(right_val
);
4489 // Compare complex constants. Complex numbers may only be compared
4493 Binary_expression::compare_complex(const Numeric_constant
* left_nc
,
4494 const Numeric_constant
* right_nc
,
4498 if (!left_nc
->to_complex(&left_val
))
4501 if (!right_nc
->to_complex(&right_val
))
4503 mpc_clear(left_val
);
4507 // We already coerced both operands to the same type. If that type
4508 // is not an abstract type, we need to round the values accordingly.
4509 Type
* type
= left_nc
->type();
4510 if (!type
->is_abstract() && type
->complex_type() != NULL
)
4512 int bits
= type
->complex_type()->bits();
4513 mpfr_prec_round(mpc_realref(left_val
), bits
/ 2, GMP_RNDN
);
4514 mpfr_prec_round(mpc_imagref(left_val
), bits
/ 2, GMP_RNDN
);
4515 mpfr_prec_round(mpc_realref(right_val
), bits
/ 2, GMP_RNDN
);
4516 mpfr_prec_round(mpc_imagref(right_val
), bits
/ 2, GMP_RNDN
);
4519 *cmp
= mpc_cmp(left_val
, right_val
) != 0;
4521 mpc_clear(left_val
);
4522 mpc_clear(right_val
);
4527 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC. Return
4528 // true if this could be done, false if not. Issue errors at LOCATION
4532 Binary_expression::eval_constant(Operator op
, Numeric_constant
* left_nc
,
4533 Numeric_constant
* right_nc
,
4534 Location location
, Numeric_constant
* nc
)
4539 case OPERATOR_ANDAND
:
4541 case OPERATOR_NOTEQ
:
4546 // These return boolean values, not numeric.
4552 Type
* left_type
= left_nc
->type();
4553 Type
* right_type
= right_nc
->type();
4556 if (!Binary_expression::operation_type(op
, left_type
, right_type
, &type
))
4559 bool is_shift
= op
== OPERATOR_LSHIFT
|| op
== OPERATOR_RSHIFT
;
4561 // When combining an untyped operand with a typed operand, we are
4562 // effectively coercing the untyped operand to the other operand's
4563 // type, so make sure that is valid.
4564 if (!left_nc
->set_type(type
, true, location
))
4566 if (!is_shift
&& !right_nc
->set_type(type
, true, location
))
4570 if (type
->complex_type() != NULL
)
4571 r
= Binary_expression::eval_complex(op
, left_nc
, right_nc
, location
, nc
);
4572 else if (type
->float_type() != NULL
)
4573 r
= Binary_expression::eval_float(op
, left_nc
, right_nc
, location
, nc
);
4575 r
= Binary_expression::eval_integer(op
, left_nc
, right_nc
, location
, nc
);
4578 r
= nc
->set_type(type
, true, location
);
4583 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC, using
4584 // integer operations. Return true if this could be done, false if
4588 Binary_expression::eval_integer(Operator op
, const Numeric_constant
* left_nc
,
4589 const Numeric_constant
* right_nc
,
4590 Location location
, Numeric_constant
* nc
)
4593 if (!left_nc
->to_int(&left_val
))
4596 if (!right_nc
->to_int(&right_val
))
4598 mpz_clear(left_val
);
4608 mpz_add(val
, left_val
, right_val
);
4609 if (mpz_sizeinbase(val
, 2) > 0x100000)
4611 error_at(location
, "constant addition overflow");
4615 case OPERATOR_MINUS
:
4616 mpz_sub(val
, left_val
, right_val
);
4617 if (mpz_sizeinbase(val
, 2) > 0x100000)
4619 error_at(location
, "constant subtraction overflow");
4624 mpz_ior(val
, left_val
, right_val
);
4627 mpz_xor(val
, left_val
, right_val
);
4630 mpz_mul(val
, left_val
, right_val
);
4631 if (mpz_sizeinbase(val
, 2) > 0x100000)
4633 error_at(location
, "constant multiplication overflow");
4638 if (mpz_sgn(right_val
) != 0)
4639 mpz_tdiv_q(val
, left_val
, right_val
);
4642 error_at(location
, "division by zero");
4647 if (mpz_sgn(right_val
) != 0)
4648 mpz_tdiv_r(val
, left_val
, right_val
);
4651 error_at(location
, "division by zero");
4655 case OPERATOR_LSHIFT
:
4657 unsigned long shift
= mpz_get_ui(right_val
);
4658 if (mpz_cmp_ui(right_val
, shift
) == 0 && shift
<= 0x100000)
4659 mpz_mul_2exp(val
, left_val
, shift
);
4662 error_at(location
, "shift count overflow");
4668 case OPERATOR_RSHIFT
:
4670 unsigned long shift
= mpz_get_ui(right_val
);
4671 if (mpz_cmp_ui(right_val
, shift
) != 0)
4673 error_at(location
, "shift count overflow");
4678 if (mpz_cmp_ui(left_val
, 0) >= 0)
4679 mpz_tdiv_q_2exp(val
, left_val
, shift
);
4681 mpz_fdiv_q_2exp(val
, left_val
, shift
);
4687 mpz_and(val
, left_val
, right_val
);
4689 case OPERATOR_BITCLEAR
:
4693 mpz_com(tval
, right_val
);
4694 mpz_and(val
, left_val
, tval
);
4702 mpz_clear(left_val
);
4703 mpz_clear(right_val
);
4705 if (left_nc
->is_rune()
4706 || (op
!= OPERATOR_LSHIFT
4707 && op
!= OPERATOR_RSHIFT
4708 && right_nc
->is_rune()))
4709 nc
->set_rune(NULL
, val
);
4711 nc
->set_int(NULL
, val
);
4718 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC, using
4719 // floating point operations. Return true if this could be done,
4723 Binary_expression::eval_float(Operator op
, const Numeric_constant
* left_nc
,
4724 const Numeric_constant
* right_nc
,
4725 Location location
, Numeric_constant
* nc
)
4728 if (!left_nc
->to_float(&left_val
))
4731 if (!right_nc
->to_float(&right_val
))
4733 mpfr_clear(left_val
);
4744 mpfr_add(val
, left_val
, right_val
, GMP_RNDN
);
4746 case OPERATOR_MINUS
:
4747 mpfr_sub(val
, left_val
, right_val
, GMP_RNDN
);
4752 case OPERATOR_BITCLEAR
:
4754 case OPERATOR_LSHIFT
:
4755 case OPERATOR_RSHIFT
:
4756 mpfr_set_ui(val
, 0, GMP_RNDN
);
4760 mpfr_mul(val
, left_val
, right_val
, GMP_RNDN
);
4763 if (!mpfr_zero_p(right_val
))
4764 mpfr_div(val
, left_val
, right_val
, GMP_RNDN
);
4767 error_at(location
, "division by zero");
4768 mpfr_set_ui(val
, 0, GMP_RNDN
);
4775 mpfr_clear(left_val
);
4776 mpfr_clear(right_val
);
4778 nc
->set_float(NULL
, val
);
4784 // Apply binary opcode OP to LEFT_NC and RIGHT_NC, setting NC, using
4785 // complex operations. Return true if this could be done, false if
4789 Binary_expression::eval_complex(Operator op
, const Numeric_constant
* left_nc
,
4790 const Numeric_constant
* right_nc
,
4791 Location location
, Numeric_constant
* nc
)
4794 if (!left_nc
->to_complex(&left_val
))
4797 if (!right_nc
->to_complex(&right_val
))
4799 mpc_clear(left_val
);
4804 mpc_init2(val
, mpc_precision
);
4810 mpc_add(val
, left_val
, right_val
, MPC_RNDNN
);
4812 case OPERATOR_MINUS
:
4813 mpc_sub(val
, left_val
, right_val
, MPC_RNDNN
);
4818 case OPERATOR_BITCLEAR
:
4820 case OPERATOR_LSHIFT
:
4821 case OPERATOR_RSHIFT
:
4822 mpc_set_ui(val
, 0, MPC_RNDNN
);
4826 mpc_mul(val
, left_val
, right_val
, MPC_RNDNN
);
4829 if (mpc_cmp_si(right_val
, 0) == 0)
4831 error_at(location
, "division by zero");
4832 mpc_set_ui(val
, 0, MPC_RNDNN
);
4835 mpc_div(val
, left_val
, right_val
, MPC_RNDNN
);
4841 mpc_clear(left_val
);
4842 mpc_clear(right_val
);
4844 nc
->set_complex(NULL
, val
);
4850 // Lower a binary expression. We have to evaluate constant
4851 // expressions now, in order to implement Go's unlimited precision
4855 Binary_expression::do_lower(Gogo
* gogo
, Named_object
*,
4856 Statement_inserter
* inserter
, int)
4858 Location location
= this->location();
4859 Operator op
= this->op_
;
4860 Expression
* left
= this->left_
;
4861 Expression
* right
= this->right_
;
4863 const bool is_comparison
= (op
== OPERATOR_EQEQ
4864 || op
== OPERATOR_NOTEQ
4865 || op
== OPERATOR_LT
4866 || op
== OPERATOR_LE
4867 || op
== OPERATOR_GT
4868 || op
== OPERATOR_GE
);
4870 // Numeric constant expressions.
4872 Numeric_constant left_nc
;
4873 Numeric_constant right_nc
;
4874 if (left
->numeric_constant_value(&left_nc
)
4875 && right
->numeric_constant_value(&right_nc
))
4880 if (!Binary_expression::compare_constant(op
, &left_nc
,
4881 &right_nc
, location
,
4884 return Expression::make_cast(Type::make_boolean_type(),
4885 Expression::make_boolean(result
,
4891 Numeric_constant nc
;
4892 if (!Binary_expression::eval_constant(op
, &left_nc
, &right_nc
,
4895 return nc
.expression(location
);
4900 // String constant expressions.
4901 if (left
->type()->is_string_type() && right
->type()->is_string_type())
4903 std::string left_string
;
4904 std::string right_string
;
4905 if (left
->string_constant_value(&left_string
)
4906 && right
->string_constant_value(&right_string
))
4908 if (op
== OPERATOR_PLUS
)
4909 return Expression::make_string(left_string
+ right_string
,
4911 else if (is_comparison
)
4913 int cmp
= left_string
.compare(right_string
);
4914 bool r
= Binary_expression::cmp_to_bool(op
, cmp
);
4915 return Expression::make_boolean(r
, location
);
4920 // Lower struct, array, and some interface comparisons.
4921 if (op
== OPERATOR_EQEQ
|| op
== OPERATOR_NOTEQ
)
4923 if (left
->type()->struct_type() != NULL
4924 && right
->type()->struct_type() != NULL
)
4925 return this->lower_struct_comparison(gogo
, inserter
);
4926 else if (left
->type()->array_type() != NULL
4927 && !left
->type()->is_slice_type()
4928 && right
->type()->array_type() != NULL
4929 && !right
->type()->is_slice_type())
4930 return this->lower_array_comparison(gogo
, inserter
);
4931 else if ((left
->type()->interface_type() != NULL
4932 && right
->type()->interface_type() == NULL
)
4933 || (left
->type()->interface_type() == NULL
4934 && right
->type()->interface_type() != NULL
))
4935 return this->lower_interface_value_comparison(gogo
, inserter
);
4941 // Lower a struct comparison.
4944 Binary_expression::lower_struct_comparison(Gogo
* gogo
,
4945 Statement_inserter
* inserter
)
4947 Struct_type
* st
= this->left_
->type()->struct_type();
4948 Struct_type
* st2
= this->right_
->type()->struct_type();
4951 if (st
!= st2
&& !Type::are_identical(st
, st2
, false, NULL
))
4953 if (!Type::are_compatible_for_comparison(true, this->left_
->type(),
4954 this->right_
->type(), NULL
))
4957 // See if we can compare using memcmp. As a heuristic, we use
4958 // memcmp rather than field references and comparisons if there are
4959 // more than two fields.
4960 if (st
->compare_is_identity(gogo
) && st
->total_field_count() > 2)
4961 return this->lower_compare_to_memcmp(gogo
, inserter
);
4963 Location loc
= this->location();
4965 Expression
* left
= this->left_
;
4966 Temporary_statement
* left_temp
= NULL
;
4967 if (left
->var_expression() == NULL
4968 && left
->temporary_reference_expression() == NULL
)
4970 left_temp
= Statement::make_temporary(left
->type(), NULL
, loc
);
4971 inserter
->insert(left_temp
);
4972 left
= Expression::make_set_and_use_temporary(left_temp
, left
, loc
);
4975 Expression
* right
= this->right_
;
4976 Temporary_statement
* right_temp
= NULL
;
4977 if (right
->var_expression() == NULL
4978 && right
->temporary_reference_expression() == NULL
)
4980 right_temp
= Statement::make_temporary(right
->type(), NULL
, loc
);
4981 inserter
->insert(right_temp
);
4982 right
= Expression::make_set_and_use_temporary(right_temp
, right
, loc
);
4985 Expression
* ret
= Expression::make_boolean(true, loc
);
4986 const Struct_field_list
* fields
= st
->fields();
4987 unsigned int field_index
= 0;
4988 for (Struct_field_list::const_iterator pf
= fields
->begin();
4989 pf
!= fields
->end();
4990 ++pf
, ++field_index
)
4992 if (Gogo::is_sink_name(pf
->field_name()))
4995 if (field_index
> 0)
4997 if (left_temp
== NULL
)
4998 left
= left
->copy();
5000 left
= Expression::make_temporary_reference(left_temp
, loc
);
5001 if (right_temp
== NULL
)
5002 right
= right
->copy();
5004 right
= Expression::make_temporary_reference(right_temp
, loc
);
5006 Expression
* f1
= Expression::make_field_reference(left
, field_index
,
5008 Expression
* f2
= Expression::make_field_reference(right
, field_index
,
5010 Expression
* cond
= Expression::make_binary(OPERATOR_EQEQ
, f1
, f2
, loc
);
5011 ret
= Expression::make_binary(OPERATOR_ANDAND
, ret
, cond
, loc
);
5014 if (this->op_
== OPERATOR_NOTEQ
)
5015 ret
= Expression::make_unary(OPERATOR_NOT
, ret
, loc
);
5020 // Lower an array comparison.
5023 Binary_expression::lower_array_comparison(Gogo
* gogo
,
5024 Statement_inserter
* inserter
)
5026 Array_type
* at
= this->left_
->type()->array_type();
5027 Array_type
* at2
= this->right_
->type()->array_type();
5030 if (at
!= at2
&& !Type::are_identical(at
, at2
, false, NULL
))
5032 if (!Type::are_compatible_for_comparison(true, this->left_
->type(),
5033 this->right_
->type(), NULL
))
5036 // Call memcmp directly if possible. This may let the middle-end
5037 // optimize the call.
5038 if (at
->compare_is_identity(gogo
))
5039 return this->lower_compare_to_memcmp(gogo
, inserter
);
5041 // Call the array comparison function.
5042 Named_object
* hash_fn
;
5043 Named_object
* equal_fn
;
5044 at
->type_functions(gogo
, this->left_
->type()->named_type(), NULL
, NULL
,
5045 &hash_fn
, &equal_fn
);
5047 Location loc
= this->location();
5049 Expression
* func
= Expression::make_func_reference(equal_fn
, NULL
, loc
);
5051 Expression_list
* args
= new Expression_list();
5052 args
->push_back(this->operand_address(inserter
, this->left_
));
5053 args
->push_back(this->operand_address(inserter
, this->right_
));
5054 args
->push_back(Expression::make_type_info(at
, TYPE_INFO_SIZE
));
5056 Expression
* ret
= Expression::make_call(func
, args
, false, loc
);
5058 if (this->op_
== OPERATOR_NOTEQ
)
5059 ret
= Expression::make_unary(OPERATOR_NOT
, ret
, loc
);
5064 // Lower an interface to value comparison.
5067 Binary_expression::lower_interface_value_comparison(Gogo
*,
5068 Statement_inserter
* inserter
)
5070 Type
* left_type
= this->left_
->type();
5071 Type
* right_type
= this->right_
->type();
5072 Interface_type
* ift
;
5073 if (left_type
->interface_type() != NULL
)
5075 ift
= left_type
->interface_type();
5076 if (!ift
->implements_interface(right_type
, NULL
))
5081 ift
= right_type
->interface_type();
5082 if (!ift
->implements_interface(left_type
, NULL
))
5085 if (!Type::are_compatible_for_comparison(true, left_type
, right_type
, NULL
))
5088 Location loc
= this->location();
5090 if (left_type
->interface_type() == NULL
5091 && left_type
->points_to() == NULL
5092 && !this->left_
->is_addressable())
5094 Temporary_statement
* temp
=
5095 Statement::make_temporary(left_type
, NULL
, loc
);
5096 inserter
->insert(temp
);
5098 Expression::make_set_and_use_temporary(temp
, this->left_
, loc
);
5101 if (right_type
->interface_type() == NULL
5102 && right_type
->points_to() == NULL
5103 && !this->right_
->is_addressable())
5105 Temporary_statement
* temp
=
5106 Statement::make_temporary(right_type
, NULL
, loc
);
5107 inserter
->insert(temp
);
5109 Expression::make_set_and_use_temporary(temp
, this->right_
, loc
);
5115 // Lower a struct or array comparison to a call to memcmp.
5118 Binary_expression::lower_compare_to_memcmp(Gogo
*, Statement_inserter
* inserter
)
5120 Location loc
= this->location();
5122 Expression
* a1
= this->operand_address(inserter
, this->left_
);
5123 Expression
* a2
= this->operand_address(inserter
, this->right_
);
5124 Expression
* len
= Expression::make_type_info(this->left_
->type(),
5127 Expression
* call
= Runtime::make_call(Runtime::MEMCMP
, loc
, 3, a1
, a2
, len
);
5128 Expression
* zero
= Expression::make_integer_ul(0, NULL
, loc
);
5129 return Expression::make_binary(this->op_
, call
, zero
, loc
);
5133 Binary_expression::do_flatten(Gogo
* gogo
, Named_object
*,
5134 Statement_inserter
* inserter
)
5136 Location loc
= this->location();
5137 Temporary_statement
* temp
;
5138 if (this->left_
->type()->is_string_type()
5139 && this->op_
== OPERATOR_PLUS
)
5141 if (!this->left_
->is_variable())
5143 temp
= Statement::make_temporary(NULL
, this->left_
, loc
);
5144 inserter
->insert(temp
);
5145 this->left_
= Expression::make_temporary_reference(temp
, loc
);
5147 if (!this->right_
->is_variable())
5150 Statement::make_temporary(this->left_
->type(), this->right_
, loc
);
5151 this->right_
= Expression::make_temporary_reference(temp
, loc
);
5152 inserter
->insert(temp
);
5156 Type
* left_type
= this->left_
->type();
5157 bool is_shift_op
= (this->op_
== OPERATOR_LSHIFT
5158 || this->op_
== OPERATOR_RSHIFT
);
5159 bool is_idiv_op
= ((this->op_
== OPERATOR_DIV
&&
5160 left_type
->integer_type() != NULL
)
5161 || this->op_
== OPERATOR_MOD
);
5165 && (gogo
->check_divide_by_zero() || gogo
->check_divide_overflow())))
5167 if (!this->left_
->is_variable())
5169 temp
= Statement::make_temporary(NULL
, this->left_
, loc
);
5170 inserter
->insert(temp
);
5171 this->left_
= Expression::make_temporary_reference(temp
, loc
);
5173 if (!this->right_
->is_variable())
5176 Statement::make_temporary(NULL
, this->right_
, loc
);
5177 this->right_
= Expression::make_temporary_reference(temp
, loc
);
5178 inserter
->insert(temp
);
5185 // Return the address of EXPR, cast to unsafe.Pointer.
5188 Binary_expression::operand_address(Statement_inserter
* inserter
,
5191 Location loc
= this->location();
5193 if (!expr
->is_addressable())
5195 Temporary_statement
* temp
= Statement::make_temporary(expr
->type(), NULL
,
5197 inserter
->insert(temp
);
5198 expr
= Expression::make_set_and_use_temporary(temp
, expr
, loc
);
5200 expr
= Expression::make_unary(OPERATOR_AND
, expr
, loc
);
5201 static_cast<Unary_expression
*>(expr
)->set_does_not_escape();
5202 Type
* void_type
= Type::make_void_type();
5203 Type
* unsafe_pointer_type
= Type::make_pointer_type(void_type
);
5204 return Expression::make_cast(unsafe_pointer_type
, expr
, loc
);
5207 // Return the numeric constant value, if it has one.
5210 Binary_expression::do_numeric_constant_value(Numeric_constant
* nc
) const
5212 Numeric_constant left_nc
;
5213 if (!this->left_
->numeric_constant_value(&left_nc
))
5215 Numeric_constant right_nc
;
5216 if (!this->right_
->numeric_constant_value(&right_nc
))
5218 return Binary_expression::eval_constant(this->op_
, &left_nc
, &right_nc
,
5219 this->location(), nc
);
5222 // Note that the value is being discarded.
5225 Binary_expression::do_discarding_value()
5227 if (this->op_
== OPERATOR_OROR
|| this->op_
== OPERATOR_ANDAND
)
5228 return this->right_
->discarding_value();
5231 this->unused_value_error();
5239 Binary_expression::do_type()
5241 if (this->classification() == EXPRESSION_ERROR
)
5242 return Type::make_error_type();
5247 case OPERATOR_NOTEQ
:
5252 if (this->type_
== NULL
)
5253 this->type_
= Type::make_boolean_type();
5257 case OPERATOR_MINUS
:
5264 case OPERATOR_BITCLEAR
:
5266 case OPERATOR_ANDAND
:
5269 if (!Binary_expression::operation_type(this->op_
,
5270 this->left_
->type(),
5271 this->right_
->type(),
5273 return Type::make_error_type();
5277 case OPERATOR_LSHIFT
:
5278 case OPERATOR_RSHIFT
:
5279 return this->left_
->type();
5286 // Set type for a binary expression.
5289 Binary_expression::do_determine_type(const Type_context
* context
)
5291 Type
* tleft
= this->left_
->type();
5292 Type
* tright
= this->right_
->type();
5294 // Both sides should have the same type, except for the shift
5295 // operations. For a comparison, we should ignore the incoming
5298 bool is_shift_op
= (this->op_
== OPERATOR_LSHIFT
5299 || this->op_
== OPERATOR_RSHIFT
);
5301 bool is_comparison
= (this->op_
== OPERATOR_EQEQ
5302 || this->op_
== OPERATOR_NOTEQ
5303 || this->op_
== OPERATOR_LT
5304 || this->op_
== OPERATOR_LE
5305 || this->op_
== OPERATOR_GT
5306 || this->op_
== OPERATOR_GE
);
5308 Type_context
subcontext(*context
);
5312 // In a comparison, the context does not determine the types of
5314 subcontext
.type
= NULL
;
5317 // Set the context for the left hand operand.
5320 // The right hand operand of a shift plays no role in
5321 // determining the type of the left hand operand.
5323 else if (!tleft
->is_abstract())
5324 subcontext
.type
= tleft
;
5325 else if (!tright
->is_abstract())
5326 subcontext
.type
= tright
;
5327 else if (subcontext
.type
== NULL
)
5329 if ((tleft
->integer_type() != NULL
&& tright
->integer_type() != NULL
)
5330 || (tleft
->float_type() != NULL
&& tright
->float_type() != NULL
)
5331 || (tleft
->complex_type() != NULL
&& tright
->complex_type() != NULL
))
5333 // Both sides have an abstract integer, abstract float, or
5334 // abstract complex type. Just let CONTEXT determine
5335 // whether they may remain abstract or not.
5337 else if (tleft
->complex_type() != NULL
)
5338 subcontext
.type
= tleft
;
5339 else if (tright
->complex_type() != NULL
)
5340 subcontext
.type
= tright
;
5341 else if (tleft
->float_type() != NULL
)
5342 subcontext
.type
= tleft
;
5343 else if (tright
->float_type() != NULL
)
5344 subcontext
.type
= tright
;
5346 subcontext
.type
= tleft
;
5348 if (subcontext
.type
!= NULL
&& !context
->may_be_abstract
)
5349 subcontext
.type
= subcontext
.type
->make_non_abstract_type();
5352 this->left_
->determine_type(&subcontext
);
5356 // We may have inherited an unusable type for the shift operand.
5357 // Give a useful error if that happened.
5358 if (tleft
->is_abstract()
5359 && subcontext
.type
!= NULL
5360 && !subcontext
.may_be_abstract
5361 && subcontext
.type
->interface_type() == NULL
5362 && subcontext
.type
->integer_type() == NULL
)
5363 this->report_error(("invalid context-determined non-integer type "
5364 "for left operand of shift"));
5366 // The context for the right hand operand is the same as for the
5367 // left hand operand, except for a shift operator.
5368 subcontext
.type
= Type::lookup_integer_type("uint");
5369 subcontext
.may_be_abstract
= false;
5372 this->right_
->determine_type(&subcontext
);
5376 if (this->type_
!= NULL
&& !this->type_
->is_abstract())
5378 else if (context
->type
!= NULL
&& context
->type
->is_boolean_type())
5379 this->type_
= context
->type
;
5380 else if (!context
->may_be_abstract
)
5381 this->type_
= Type::lookup_bool_type();
5385 // Report an error if the binary operator OP does not support TYPE.
5386 // OTYPE is the type of the other operand. Return whether the
5387 // operation is OK. This should not be used for shift.
5390 Binary_expression::check_operator_type(Operator op
, Type
* type
, Type
* otype
,
5396 case OPERATOR_ANDAND
:
5397 if (!type
->is_boolean_type())
5399 error_at(location
, "expected boolean type");
5405 case OPERATOR_NOTEQ
:
5408 if (!Type::are_compatible_for_comparison(true, type
, otype
, &reason
))
5410 error_at(location
, "%s", reason
.c_str());
5422 if (!Type::are_compatible_for_comparison(false, type
, otype
, &reason
))
5424 error_at(location
, "%s", reason
.c_str());
5431 case OPERATOR_PLUSEQ
:
5432 if (type
->integer_type() == NULL
5433 && type
->float_type() == NULL
5434 && type
->complex_type() == NULL
5435 && !type
->is_string_type())
5438 "expected integer, floating, complex, or string type");
5443 case OPERATOR_MINUS
:
5444 case OPERATOR_MINUSEQ
:
5446 case OPERATOR_MULTEQ
:
5448 case OPERATOR_DIVEQ
:
5449 if (type
->integer_type() == NULL
5450 && type
->float_type() == NULL
5451 && type
->complex_type() == NULL
)
5453 error_at(location
, "expected integer, floating, or complex type");
5459 case OPERATOR_MODEQ
:
5463 case OPERATOR_ANDEQ
:
5465 case OPERATOR_XOREQ
:
5466 case OPERATOR_BITCLEAR
:
5467 case OPERATOR_BITCLEAREQ
:
5468 if (type
->integer_type() == NULL
)
5470 error_at(location
, "expected integer type");
5485 Binary_expression::do_check_types(Gogo
*)
5487 if (this->classification() == EXPRESSION_ERROR
)
5490 Type
* left_type
= this->left_
->type();
5491 Type
* right_type
= this->right_
->type();
5492 if (left_type
->is_error() || right_type
->is_error())
5494 this->set_is_error();
5498 if (this->op_
== OPERATOR_EQEQ
5499 || this->op_
== OPERATOR_NOTEQ
5500 || this->op_
== OPERATOR_LT
5501 || this->op_
== OPERATOR_LE
5502 || this->op_
== OPERATOR_GT
5503 || this->op_
== OPERATOR_GE
)
5505 if (left_type
->is_nil_type() && right_type
->is_nil_type())
5507 this->report_error(_("invalid comparison of nil with nil"));
5510 if (!Type::are_assignable(left_type
, right_type
, NULL
)
5511 && !Type::are_assignable(right_type
, left_type
, NULL
))
5513 this->report_error(_("incompatible types in binary expression"));
5516 if (!Binary_expression::check_operator_type(this->op_
, left_type
,
5519 || !Binary_expression::check_operator_type(this->op_
, right_type
,
5523 this->set_is_error();
5527 else if (this->op_
!= OPERATOR_LSHIFT
&& this->op_
!= OPERATOR_RSHIFT
)
5529 if (!Type::are_compatible_for_binop(left_type
, right_type
))
5531 this->report_error(_("incompatible types in binary expression"));
5534 if (!Binary_expression::check_operator_type(this->op_
, left_type
,
5538 this->set_is_error();
5541 if (this->op_
== OPERATOR_DIV
|| this->op_
== OPERATOR_MOD
)
5543 // Division by a zero integer constant is an error.
5544 Numeric_constant rconst
;
5546 if (left_type
->integer_type() != NULL
5547 && this->right_
->numeric_constant_value(&rconst
)
5548 && rconst
.to_unsigned_long(&rval
) == Numeric_constant::NC_UL_VALID
5551 this->report_error(_("integer division by zero"));
5558 if (left_type
->integer_type() == NULL
)
5559 this->report_error(_("shift of non-integer operand"));
5561 if (!right_type
->is_abstract()
5562 && (right_type
->integer_type() == NULL
5563 || !right_type
->integer_type()->is_unsigned()))
5564 this->report_error(_("shift count not unsigned integer"));
5567 Numeric_constant nc
;
5568 if (this->right_
->numeric_constant_value(&nc
))
5571 if (!nc
.to_int(&val
))
5572 this->report_error(_("shift count not unsigned integer"));
5575 if (mpz_sgn(val
) < 0)
5577 this->report_error(_("negative shift count"));
5578 Location rloc
= this->right_
->location();
5579 this->right_
= Expression::make_integer_ul(0, right_type
,
5589 // Get the backend representation for a binary expression.
5592 Binary_expression::do_get_backend(Translate_context
* context
)
5594 Gogo
* gogo
= context
->gogo();
5595 Location loc
= this->location();
5596 Type
* left_type
= this->left_
->type();
5597 Type
* right_type
= this->right_
->type();
5599 bool use_left_type
= true;
5600 bool is_shift_op
= false;
5601 bool is_idiv_op
= false;
5605 case OPERATOR_NOTEQ
:
5610 return Expression::comparison(context
, this->type_
, this->op_
,
5611 this->left_
, this->right_
, loc
);
5614 case OPERATOR_ANDAND
:
5615 use_left_type
= false;
5618 case OPERATOR_MINUS
:
5624 if (left_type
->float_type() != NULL
|| left_type
->complex_type() != NULL
)
5629 case OPERATOR_LSHIFT
:
5630 case OPERATOR_RSHIFT
:
5633 case OPERATOR_BITCLEAR
:
5634 this->right_
= Expression::make_unary(OPERATOR_XOR
, this->right_
, loc
);
5641 if (left_type
->is_string_type())
5643 go_assert(this->op_
== OPERATOR_PLUS
);
5644 Expression
* string_plus
=
5645 Runtime::make_call(Runtime::STRING_PLUS
, loc
, 2,
5646 this->left_
, this->right_
);
5647 return string_plus
->get_backend(context
);
5650 // For complex division Go might want slightly different results than the
5651 // backend implementation provides, so we have our own runtime routine.
5652 if (this->op_
== OPERATOR_DIV
&& this->left_
->type()->complex_type() != NULL
)
5654 Runtime::Function complex_code
;
5655 switch (this->left_
->type()->complex_type()->bits())
5658 complex_code
= Runtime::COMPLEX64_DIV
;
5661 complex_code
= Runtime::COMPLEX128_DIV
;
5666 Expression
* complex_div
=
5667 Runtime::make_call(complex_code
, loc
, 2, this->left_
, this->right_
);
5668 return complex_div
->get_backend(context
);
5671 Bexpression
* left
= this->left_
->get_backend(context
);
5672 Bexpression
* right
= this->right_
->get_backend(context
);
5674 Type
* type
= use_left_type
? left_type
: right_type
;
5675 Btype
* btype
= type
->get_backend(gogo
);
5678 gogo
->backend()->binary_expression(this->op_
, left
, right
, loc
);
5679 ret
= gogo
->backend()->convert_expression(btype
, ret
, loc
);
5681 // Initialize overflow constants.
5682 Bexpression
* overflow
;
5684 mpz_init_set_ui(zero
, 0UL);
5686 mpz_init_set_ui(one
, 1UL);
5688 mpz_init_set_si(neg_one
, -1);
5690 Btype
* left_btype
= left_type
->get_backend(gogo
);
5691 Btype
* right_btype
= right_type
->get_backend(gogo
);
5693 // In Go, a shift larger than the size of the type is well-defined.
5694 // This is not true in C, so we need to insert a conditional.
5697 go_assert(left_type
->integer_type() != NULL
);
5700 int bits
= left_type
->integer_type()->bits();
5701 mpz_init_set_ui(bitsval
, bits
);
5702 Bexpression
* bits_expr
=
5703 gogo
->backend()->integer_constant_expression(right_btype
, bitsval
);
5704 Bexpression
* compare
=
5705 gogo
->backend()->binary_expression(OPERATOR_LT
,
5706 right
, bits_expr
, loc
);
5708 Bexpression
* zero_expr
=
5709 gogo
->backend()->integer_constant_expression(left_btype
, zero
);
5710 overflow
= zero_expr
;
5711 if (this->op_
== OPERATOR_RSHIFT
5712 && !left_type
->integer_type()->is_unsigned())
5714 Bexpression
* neg_expr
=
5715 gogo
->backend()->binary_expression(OPERATOR_LT
, left
,
5717 Bexpression
* neg_one_expr
=
5718 gogo
->backend()->integer_constant_expression(left_btype
, neg_one
);
5719 overflow
= gogo
->backend()->conditional_expression(btype
, neg_expr
,
5723 ret
= gogo
->backend()->conditional_expression(btype
, compare
, ret
,
5728 // Add checks for division by zero and division overflow as needed.
5731 if (gogo
->check_divide_by_zero())
5734 Bexpression
* zero_expr
=
5735 gogo
->backend()->integer_constant_expression(right_btype
, zero
);
5736 Bexpression
* check
=
5737 gogo
->backend()->binary_expression(OPERATOR_EQEQ
,
5738 right
, zero_expr
, loc
);
5740 // __go_runtime_error(RUNTIME_ERROR_DIVISION_BY_ZERO)
5741 int errcode
= RUNTIME_ERROR_DIVISION_BY_ZERO
;
5742 Bexpression
* crash
= gogo
->runtime_error(errcode
,
5743 loc
)->get_backend(context
);
5745 // right == 0 ? (__go_runtime_error(...), 0) : ret
5746 ret
= gogo
->backend()->conditional_expression(btype
, check
, crash
,
5750 if (gogo
->check_divide_overflow())
5753 // FIXME: It would be nice to say that this test is expected
5756 Bexpression
* neg_one_expr
=
5757 gogo
->backend()->integer_constant_expression(right_btype
, neg_one
);
5758 Bexpression
* check
=
5759 gogo
->backend()->binary_expression(OPERATOR_EQEQ
,
5760 right
, neg_one_expr
, loc
);
5762 Bexpression
* zero_expr
=
5763 gogo
->backend()->integer_constant_expression(btype
, zero
);
5764 Bexpression
* one_expr
=
5765 gogo
->backend()->integer_constant_expression(btype
, one
);
5767 if (type
->integer_type()->is_unsigned())
5769 // An unsigned -1 is the largest possible number, so
5770 // dividing is always 1 or 0.
5773 gogo
->backend()->binary_expression(OPERATOR_EQEQ
,
5775 if (this->op_
== OPERATOR_DIV
)
5777 gogo
->backend()->conditional_expression(btype
, cmp
,
5778 one_expr
, zero_expr
,
5782 gogo
->backend()->conditional_expression(btype
, cmp
,
5788 // Computing left / -1 is the same as computing - left,
5789 // which does not overflow since Go sets -fwrapv.
5790 if (this->op_
== OPERATOR_DIV
)
5792 Expression
* negate_expr
=
5793 Expression::make_unary(OPERATOR_MINUS
, this->left_
, loc
);
5794 overflow
= negate_expr
->get_backend(context
);
5797 overflow
= zero_expr
;
5799 overflow
= gogo
->backend()->convert_expression(btype
, overflow
, loc
);
5801 // right == -1 ? - left : ret
5802 ret
= gogo
->backend()->conditional_expression(btype
, check
, overflow
,
5813 // Export a binary expression.
5816 Binary_expression::do_export(Export
* exp
) const
5818 exp
->write_c_string("(");
5819 this->left_
->export_expression(exp
);
5823 exp
->write_c_string(" || ");
5825 case OPERATOR_ANDAND
:
5826 exp
->write_c_string(" && ");
5829 exp
->write_c_string(" == ");
5831 case OPERATOR_NOTEQ
:
5832 exp
->write_c_string(" != ");
5835 exp
->write_c_string(" < ");
5838 exp
->write_c_string(" <= ");
5841 exp
->write_c_string(" > ");
5844 exp
->write_c_string(" >= ");
5847 exp
->write_c_string(" + ");
5849 case OPERATOR_MINUS
:
5850 exp
->write_c_string(" - ");
5853 exp
->write_c_string(" | ");
5856 exp
->write_c_string(" ^ ");
5859 exp
->write_c_string(" * ");
5862 exp
->write_c_string(" / ");
5865 exp
->write_c_string(" % ");
5867 case OPERATOR_LSHIFT
:
5868 exp
->write_c_string(" << ");
5870 case OPERATOR_RSHIFT
:
5871 exp
->write_c_string(" >> ");
5874 exp
->write_c_string(" & ");
5876 case OPERATOR_BITCLEAR
:
5877 exp
->write_c_string(" &^ ");
5882 this->right_
->export_expression(exp
);
5883 exp
->write_c_string(")");
5886 // Import a binary expression.
5889 Binary_expression::do_import(Import
* imp
)
5891 imp
->require_c_string("(");
5893 Expression
* left
= Expression::import_expression(imp
);
5896 if (imp
->match_c_string(" || "))
5901 else if (imp
->match_c_string(" && "))
5903 op
= OPERATOR_ANDAND
;
5906 else if (imp
->match_c_string(" == "))
5911 else if (imp
->match_c_string(" != "))
5913 op
= OPERATOR_NOTEQ
;
5916 else if (imp
->match_c_string(" < "))
5921 else if (imp
->match_c_string(" <= "))
5926 else if (imp
->match_c_string(" > "))
5931 else if (imp
->match_c_string(" >= "))
5936 else if (imp
->match_c_string(" + "))
5941 else if (imp
->match_c_string(" - "))
5943 op
= OPERATOR_MINUS
;
5946 else if (imp
->match_c_string(" | "))
5951 else if (imp
->match_c_string(" ^ "))
5956 else if (imp
->match_c_string(" * "))
5961 else if (imp
->match_c_string(" / "))
5966 else if (imp
->match_c_string(" % "))
5971 else if (imp
->match_c_string(" << "))
5973 op
= OPERATOR_LSHIFT
;
5976 else if (imp
->match_c_string(" >> "))
5978 op
= OPERATOR_RSHIFT
;
5981 else if (imp
->match_c_string(" & "))
5986 else if (imp
->match_c_string(" &^ "))
5988 op
= OPERATOR_BITCLEAR
;
5993 error_at(imp
->location(), "unrecognized binary operator");
5994 return Expression::make_error(imp
->location());
5997 Expression
* right
= Expression::import_expression(imp
);
5999 imp
->require_c_string(")");
6001 return Expression::make_binary(op
, left
, right
, imp
->location());
6004 // Dump ast representation of a binary expression.
6007 Binary_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
6009 ast_dump_context
->ostream() << "(";
6010 ast_dump_context
->dump_expression(this->left_
);
6011 ast_dump_context
->ostream() << " ";
6012 ast_dump_context
->dump_operator(this->op_
);
6013 ast_dump_context
->ostream() << " ";
6014 ast_dump_context
->dump_expression(this->right_
);
6015 ast_dump_context
->ostream() << ") ";
6018 // Make a binary expression.
6021 Expression::make_binary(Operator op
, Expression
* left
, Expression
* right
,
6024 return new Binary_expression(op
, left
, right
, location
);
6027 // Implement a comparison.
6030 Expression::comparison(Translate_context
* context
, Type
* result_type
,
6031 Operator op
, Expression
* left
, Expression
* right
,
6034 Type
* left_type
= left
->type();
6035 Type
* right_type
= right
->type();
6037 Expression
* zexpr
= Expression::make_integer_ul(0, NULL
, location
);
6039 if (left_type
->is_string_type() && right_type
->is_string_type())
6041 left
= Runtime::make_call(Runtime::STRCMP
, location
, 2,
6045 else if ((left_type
->interface_type() != NULL
6046 && right_type
->interface_type() == NULL
6047 && !right_type
->is_nil_type())
6048 || (left_type
->interface_type() == NULL
6049 && !left_type
->is_nil_type()
6050 && right_type
->interface_type() != NULL
))
6052 // Comparing an interface value to a non-interface value.
6053 if (left_type
->interface_type() == NULL
)
6055 std::swap(left_type
, right_type
);
6056 std::swap(left
, right
);
6059 // The right operand is not an interface. We need to take its
6060 // address if it is not a pointer.
6061 Expression
* pointer_arg
= NULL
;
6062 if (right_type
->points_to() != NULL
)
6063 pointer_arg
= right
;
6066 go_assert(right
->is_addressable());
6067 pointer_arg
= Expression::make_unary(OPERATOR_AND
, right
,
6071 Expression
* descriptor
=
6072 Expression::make_type_descriptor(right_type
, location
);
6074 Runtime::make_call((left_type
->interface_type()->is_empty()
6075 ? Runtime::EMPTY_INTERFACE_VALUE_COMPARE
6076 : Runtime::INTERFACE_VALUE_COMPARE
),
6077 location
, 3, left
, descriptor
,
6081 else if (left_type
->interface_type() != NULL
6082 && right_type
->interface_type() != NULL
)
6084 Runtime::Function compare_function
;
6085 if (left_type
->interface_type()->is_empty()
6086 && right_type
->interface_type()->is_empty())
6087 compare_function
= Runtime::EMPTY_INTERFACE_COMPARE
;
6088 else if (!left_type
->interface_type()->is_empty()
6089 && !right_type
->interface_type()->is_empty())
6090 compare_function
= Runtime::INTERFACE_COMPARE
;
6093 if (left_type
->interface_type()->is_empty())
6095 go_assert(op
== OPERATOR_EQEQ
|| op
== OPERATOR_NOTEQ
);
6096 std::swap(left_type
, right_type
);
6097 std::swap(left
, right
);
6099 go_assert(!left_type
->interface_type()->is_empty());
6100 go_assert(right_type
->interface_type()->is_empty());
6101 compare_function
= Runtime::INTERFACE_EMPTY_COMPARE
;
6104 left
= Runtime::make_call(compare_function
, location
, 2, left
, right
);
6108 if (left_type
->is_nil_type()
6109 && (op
== OPERATOR_EQEQ
|| op
== OPERATOR_NOTEQ
))
6111 std::swap(left_type
, right_type
);
6112 std::swap(left
, right
);
6115 if (right_type
->is_nil_type())
6117 right
= Expression::make_nil(location
);
6118 if (left_type
->array_type() != NULL
6119 && left_type
->array_type()->length() == NULL
)
6121 Array_type
* at
= left_type
->array_type();
6122 left
= at
->get_value_pointer(context
->gogo(), left
);
6124 else if (left_type
->interface_type() != NULL
)
6126 // An interface is nil if the first field is nil.
6127 left
= Expression::make_field_reference(left
, 0, location
);
6131 Bexpression
* left_bexpr
= left
->get_backend(context
);
6132 Bexpression
* right_bexpr
= right
->get_backend(context
);
6134 Gogo
* gogo
= context
->gogo();
6135 Bexpression
* ret
= gogo
->backend()->binary_expression(op
, left_bexpr
,
6136 right_bexpr
, location
);
6137 if (result_type
!= NULL
)
6138 ret
= gogo
->backend()->convert_expression(result_type
->get_backend(gogo
),
6143 // Class Bound_method_expression.
6148 Bound_method_expression::do_traverse(Traverse
* traverse
)
6150 return Expression::traverse(&this->expr_
, traverse
);
6153 // Lower the expression. If this is a method value rather than being
6154 // called, and the method is accessed via a pointer, we may need to
6155 // add nil checks. Introduce a temporary variable so that those nil
6156 // checks do not cause multiple evaluation.
6159 Bound_method_expression::do_lower(Gogo
*, Named_object
*,
6160 Statement_inserter
* inserter
, int)
6162 // For simplicity we use a temporary for every call to an embedded
6163 // method, even though some of them might be pure value methods and
6164 // not require a temporary.
6165 if (this->expr_
->var_expression() == NULL
6166 && this->expr_
->temporary_reference_expression() == NULL
6167 && this->expr_
->set_and_use_temporary_expression() == NULL
6168 && (this->method_
->field_indexes() != NULL
6169 || (this->method_
->is_value_method()
6170 && this->expr_
->type()->points_to() != NULL
)))
6172 Temporary_statement
* temp
=
6173 Statement::make_temporary(this->expr_
->type(), NULL
, this->location());
6174 inserter
->insert(temp
);
6175 this->expr_
= Expression::make_set_and_use_temporary(temp
, this->expr_
,
6181 // Return the type of a bound method expression. The type of this
6182 // object is simply the type of the method with no receiver.
6185 Bound_method_expression::do_type()
6187 Named_object
* fn
= this->method_
->named_object();
6188 Function_type
* fntype
;
6189 if (fn
->is_function())
6190 fntype
= fn
->func_value()->type();
6191 else if (fn
->is_function_declaration())
6192 fntype
= fn
->func_declaration_value()->type();
6194 return Type::make_error_type();
6195 return fntype
->copy_without_receiver();
6198 // Determine the types of a method expression.
6201 Bound_method_expression::do_determine_type(const Type_context
*)
6203 Named_object
* fn
= this->method_
->named_object();
6204 Function_type
* fntype
;
6205 if (fn
->is_function())
6206 fntype
= fn
->func_value()->type();
6207 else if (fn
->is_function_declaration())
6208 fntype
= fn
->func_declaration_value()->type();
6211 if (fntype
== NULL
|| !fntype
->is_method())
6212 this->expr_
->determine_type_no_context();
6215 Type_context
subcontext(fntype
->receiver()->type(), false);
6216 this->expr_
->determine_type(&subcontext
);
6220 // Check the types of a method expression.
6223 Bound_method_expression::do_check_types(Gogo
*)
6225 Named_object
* fn
= this->method_
->named_object();
6226 if (!fn
->is_function() && !fn
->is_function_declaration())
6228 this->report_error(_("object is not a method"));
6232 Function_type
* fntype
;
6233 if (fn
->is_function())
6234 fntype
= fn
->func_value()->type();
6235 else if (fn
->is_function_declaration())
6236 fntype
= fn
->func_declaration_value()->type();
6239 Type
* rtype
= fntype
->receiver()->type()->deref();
6240 Type
* etype
= (this->expr_type_
!= NULL
6242 : this->expr_
->type());
6243 etype
= etype
->deref();
6244 if (!Type::are_identical(rtype
, etype
, true, NULL
))
6245 this->report_error(_("method type does not match object type"));
6248 // If a bound method expression is not simply called, then it is
6249 // represented as a closure. The closure will hold a single variable,
6250 // the receiver to pass to the method. The function will be a simple
6251 // thunk that pulls that value from the closure and calls the method
6252 // with the remaining arguments.
6254 // Because method values are not common, we don't build all thunks for
6255 // every methods, but instead only build them as we need them. In
6256 // particular, we even build them on demand for methods defined in
6259 Bound_method_expression::Method_value_thunks
6260 Bound_method_expression::method_value_thunks
;
6262 // Find or create the thunk for METHOD.
6265 Bound_method_expression::create_thunk(Gogo
* gogo
, const Method
* method
,
6268 std::pair
<Named_object
*, Named_object
*> val(fn
, NULL
);
6269 std::pair
<Method_value_thunks::iterator
, bool> ins
=
6270 Bound_method_expression::method_value_thunks
.insert(val
);
6273 // We have seen this method before.
6274 go_assert(ins
.first
->second
!= NULL
);
6275 return ins
.first
->second
;
6278 Location loc
= fn
->location();
6280 Function_type
* orig_fntype
;
6281 if (fn
->is_function())
6282 orig_fntype
= fn
->func_value()->type();
6283 else if (fn
->is_function_declaration())
6284 orig_fntype
= fn
->func_declaration_value()->type();
6288 if (orig_fntype
== NULL
|| !orig_fntype
->is_method())
6290 ins
.first
->second
= Named_object::make_erroneous_name(Gogo::thunk_name());
6291 return ins
.first
->second
;
6294 Struct_field_list
* sfl
= new Struct_field_list();
6295 // The type here is wrong--it should be the C function type. But it
6296 // doesn't really matter.
6297 Type
* vt
= Type::make_pointer_type(Type::make_void_type());
6298 sfl
->push_back(Struct_field(Typed_identifier("fn.0", vt
, loc
)));
6299 sfl
->push_back(Struct_field(Typed_identifier("val.1",
6300 orig_fntype
->receiver()->type(),
6302 Type
* closure_type
= Type::make_struct_type(sfl
, loc
);
6303 closure_type
= Type::make_pointer_type(closure_type
);
6305 Function_type
* new_fntype
= orig_fntype
->copy_with_names();
6307 Named_object
* new_no
= gogo
->start_function(Gogo::thunk_name(), new_fntype
,
6310 Variable
* cvar
= new Variable(closure_type
, NULL
, false, false, false, loc
);
6311 cvar
->set_is_used();
6312 Named_object
* cp
= Named_object::make_variable("$closure", NULL
, cvar
);
6313 new_no
->func_value()->set_closure_var(cp
);
6315 gogo
->start_block(loc
);
6317 // Field 0 of the closure is the function code pointer, field 1 is
6318 // the value on which to invoke the method.
6319 Expression
* arg
= Expression::make_var_reference(cp
, loc
);
6320 arg
= Expression::make_unary(OPERATOR_MULT
, arg
, loc
);
6321 arg
= Expression::make_field_reference(arg
, 1, loc
);
6323 Expression
* bme
= Expression::make_bound_method(arg
, method
, fn
, loc
);
6325 const Typed_identifier_list
* orig_params
= orig_fntype
->parameters();
6326 Expression_list
* args
;
6327 if (orig_params
== NULL
|| orig_params
->empty())
6331 const Typed_identifier_list
* new_params
= new_fntype
->parameters();
6332 args
= new Expression_list();
6333 for (Typed_identifier_list::const_iterator p
= new_params
->begin();
6334 p
!= new_params
->end();
6337 Named_object
* p_no
= gogo
->lookup(p
->name(), NULL
);
6338 go_assert(p_no
!= NULL
6339 && p_no
->is_variable()
6340 && p_no
->var_value()->is_parameter());
6341 args
->push_back(Expression::make_var_reference(p_no
, loc
));
6345 Call_expression
* call
= Expression::make_call(bme
, args
,
6346 orig_fntype
->is_varargs(),
6348 call
->set_varargs_are_lowered();
6350 Statement
* s
= Statement::make_return_from_call(call
, loc
);
6351 gogo
->add_statement(s
);
6352 Block
* b
= gogo
->finish_block(loc
);
6353 gogo
->add_block(b
, loc
);
6354 gogo
->lower_block(new_no
, b
);
6355 gogo
->flatten_block(new_no
, b
);
6356 gogo
->finish_function(loc
);
6358 ins
.first
->second
= new_no
;
6362 // Return an expression to check *REF for nil while dereferencing
6363 // according to FIELD_INDEXES. Update *REF to build up the field
6364 // reference. This is a static function so that we don't have to
6365 // worry about declaring Field_indexes in expressions.h.
6368 bme_check_nil(const Method::Field_indexes
* field_indexes
, Location loc
,
6371 if (field_indexes
== NULL
)
6372 return Expression::make_boolean(false, loc
);
6373 Expression
* cond
= bme_check_nil(field_indexes
->next
, loc
, ref
);
6374 Struct_type
* stype
= (*ref
)->type()->deref()->struct_type();
6375 go_assert(stype
!= NULL
6376 && field_indexes
->field_index
< stype
->field_count());
6377 if ((*ref
)->type()->struct_type() == NULL
)
6379 go_assert((*ref
)->type()->points_to() != NULL
);
6380 Expression
* n
= Expression::make_binary(OPERATOR_EQEQ
, *ref
,
6381 Expression::make_nil(loc
),
6383 cond
= Expression::make_binary(OPERATOR_OROR
, cond
, n
, loc
);
6384 *ref
= Expression::make_unary(OPERATOR_MULT
, *ref
, loc
);
6385 go_assert((*ref
)->type()->struct_type() == stype
);
6387 *ref
= Expression::make_field_reference(*ref
, field_indexes
->field_index
,
6392 // Get the backend representation for a method value.
6395 Bound_method_expression::do_get_backend(Translate_context
* context
)
6397 Named_object
* thunk
= Bound_method_expression::create_thunk(context
->gogo(),
6400 if (thunk
->is_erroneous())
6402 go_assert(saw_errors());
6403 return context
->backend()->error_expression();
6406 // FIXME: We should lower this earlier, but we can't lower it in the
6407 // lowering pass because at that point we don't know whether we need
6408 // to create the thunk or not. If the expression is called, we
6409 // don't need the thunk.
6411 Location loc
= this->location();
6413 // If the method expects a value, and we have a pointer, we need to
6414 // dereference the pointer.
6416 Named_object
* fn
= this->method_
->named_object();
6417 Function_type
* fntype
;
6418 if (fn
->is_function())
6419 fntype
= fn
->func_value()->type();
6420 else if (fn
->is_function_declaration())
6421 fntype
= fn
->func_declaration_value()->type();
6425 Expression
* val
= this->expr_
;
6426 if (fntype
->receiver()->type()->points_to() == NULL
6427 && val
->type()->points_to() != NULL
)
6428 val
= Expression::make_unary(OPERATOR_MULT
, val
, loc
);
6430 // Note that we are ignoring this->expr_type_ here. The thunk will
6431 // expect a closure whose second field has type this->expr_type_ (if
6432 // that is not NULL). We are going to pass it a closure whose
6433 // second field has type this->expr_->type(). Since
6434 // this->expr_type_ is only not-NULL for pointer types, we can get
6437 Struct_field_list
* fields
= new Struct_field_list();
6438 fields
->push_back(Struct_field(Typed_identifier("fn.0",
6439 thunk
->func_value()->type(),
6441 fields
->push_back(Struct_field(Typed_identifier("val.1", val
->type(), loc
)));
6442 Struct_type
* st
= Type::make_struct_type(fields
, loc
);
6444 Expression_list
* vals
= new Expression_list();
6445 vals
->push_back(Expression::make_func_code_reference(thunk
, loc
));
6446 vals
->push_back(val
);
6448 Expression
* ret
= Expression::make_struct_composite_literal(st
, vals
, loc
);
6449 ret
= Expression::make_heap_expression(ret
, loc
);
6451 // See whether the expression or any embedded pointers are nil.
6453 Expression
* nil_check
= NULL
;
6454 Expression
* expr
= this->expr_
;
6455 if (this->method_
->field_indexes() != NULL
)
6457 // Note that we are evaluating this->expr_ twice, but that is OK
6458 // because in the lowering pass we forced it into a temporary
6460 Expression
* ref
= expr
;
6461 nil_check
= bme_check_nil(this->method_
->field_indexes(), loc
, &ref
);
6465 if (this->method_
->is_value_method() && expr
->type()->points_to() != NULL
)
6467 Expression
* n
= Expression::make_binary(OPERATOR_EQEQ
, expr
,
6468 Expression::make_nil(loc
),
6470 if (nil_check
== NULL
)
6473 nil_check
= Expression::make_binary(OPERATOR_OROR
, nil_check
, n
, loc
);
6476 Bexpression
* bme
= ret
->get_backend(context
);
6477 if (nil_check
!= NULL
)
6479 Gogo
* gogo
= context
->gogo();
6480 Bexpression
* crash
=
6481 gogo
->runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE
,
6482 loc
)->get_backend(context
);
6483 Btype
* btype
= ret
->type()->get_backend(gogo
);
6484 Bexpression
* bcheck
= nil_check
->get_backend(context
);
6485 bme
= gogo
->backend()->conditional_expression(btype
, bcheck
, crash
,
6491 // Dump ast representation of a bound method expression.
6494 Bound_method_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
6497 if (this->expr_type_
!= NULL
)
6498 ast_dump_context
->ostream() << "(";
6499 ast_dump_context
->dump_expression(this->expr_
);
6500 if (this->expr_type_
!= NULL
)
6502 ast_dump_context
->ostream() << ":";
6503 ast_dump_context
->dump_type(this->expr_type_
);
6504 ast_dump_context
->ostream() << ")";
6507 ast_dump_context
->ostream() << "." << this->function_
->name();
6510 // Make a method expression.
6512 Bound_method_expression
*
6513 Expression::make_bound_method(Expression
* expr
, const Method
* method
,
6514 Named_object
* function
, Location location
)
6516 return new Bound_method_expression(expr
, method
, function
, location
);
6519 // Class Builtin_call_expression. This is used for a call to a
6520 // builtin function.
6522 class Builtin_call_expression
: public Call_expression
6525 Builtin_call_expression(Gogo
* gogo
, Expression
* fn
, Expression_list
* args
,
6526 bool is_varargs
, Location location
);
6529 // This overrides Call_expression::do_lower.
6531 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
6534 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
6537 do_is_constant() const;
6540 do_numeric_constant_value(Numeric_constant
*) const;
6543 do_discarding_value();
6549 do_determine_type(const Type_context
*);
6552 do_check_types(Gogo
*);
6557 return new Builtin_call_expression(this->gogo_
, this->fn()->copy(),
6558 this->args()->copy(),
6564 do_get_backend(Translate_context
*);
6567 do_export(Export
*) const;
6570 do_is_recover_call() const;
6573 do_set_recover_arg(Expression
*);
6576 // The builtin functions.
6577 enum Builtin_function_code
6581 // Predeclared builtin functions.
6598 // Builtin functions from the unsafe package.
6611 real_imag_type(Type
*);
6614 complex_type(Type
*);
6620 check_int_value(Expression
*, bool is_length
);
6622 // A pointer back to the general IR structure. This avoids a global
6623 // variable, or passing it around everywhere.
6625 // The builtin function being called.
6626 Builtin_function_code code_
;
6627 // Used to stop endless loops when the length of an array uses len
6628 // or cap of the array itself.
6632 Builtin_call_expression::Builtin_call_expression(Gogo
* gogo
,
6634 Expression_list
* args
,
6637 : Call_expression(fn
, args
, is_varargs
, location
),
6638 gogo_(gogo
), code_(BUILTIN_INVALID
), seen_(false)
6640 Func_expression
* fnexp
= this->fn()->func_expression();
6641 go_assert(fnexp
!= NULL
);
6642 const std::string
& name(fnexp
->named_object()->name());
6643 if (name
== "append")
6644 this->code_
= BUILTIN_APPEND
;
6645 else if (name
== "cap")
6646 this->code_
= BUILTIN_CAP
;
6647 else if (name
== "close")
6648 this->code_
= BUILTIN_CLOSE
;
6649 else if (name
== "complex")
6650 this->code_
= BUILTIN_COMPLEX
;
6651 else if (name
== "copy")
6652 this->code_
= BUILTIN_COPY
;
6653 else if (name
== "delete")
6654 this->code_
= BUILTIN_DELETE
;
6655 else if (name
== "imag")
6656 this->code_
= BUILTIN_IMAG
;
6657 else if (name
== "len")
6658 this->code_
= BUILTIN_LEN
;
6659 else if (name
== "make")
6660 this->code_
= BUILTIN_MAKE
;
6661 else if (name
== "new")
6662 this->code_
= BUILTIN_NEW
;
6663 else if (name
== "panic")
6664 this->code_
= BUILTIN_PANIC
;
6665 else if (name
== "print")
6666 this->code_
= BUILTIN_PRINT
;
6667 else if (name
== "println")
6668 this->code_
= BUILTIN_PRINTLN
;
6669 else if (name
== "real")
6670 this->code_
= BUILTIN_REAL
;
6671 else if (name
== "recover")
6672 this->code_
= BUILTIN_RECOVER
;
6673 else if (name
== "Alignof")
6674 this->code_
= BUILTIN_ALIGNOF
;
6675 else if (name
== "Offsetof")
6676 this->code_
= BUILTIN_OFFSETOF
;
6677 else if (name
== "Sizeof")
6678 this->code_
= BUILTIN_SIZEOF
;
6683 // Return whether this is a call to recover. This is a virtual
6684 // function called from the parent class.
6687 Builtin_call_expression::do_is_recover_call() const
6689 if (this->classification() == EXPRESSION_ERROR
)
6691 return this->code_
== BUILTIN_RECOVER
;
6694 // Set the argument for a call to recover.
6697 Builtin_call_expression::do_set_recover_arg(Expression
* arg
)
6699 const Expression_list
* args
= this->args();
6700 go_assert(args
== NULL
|| args
->empty());
6701 Expression_list
* new_args
= new Expression_list();
6702 new_args
->push_back(arg
);
6703 this->set_args(new_args
);
6706 // Lower a builtin call expression. This turns new and make into
6707 // specific expressions. We also convert to a constant if we can.
6710 Builtin_call_expression::do_lower(Gogo
* gogo
, Named_object
* function
,
6711 Statement_inserter
* inserter
, int)
6713 if (this->classification() == EXPRESSION_ERROR
)
6716 Location loc
= this->location();
6718 if (this->is_varargs() && this->code_
!= BUILTIN_APPEND
)
6720 this->report_error(_("invalid use of %<...%> with builtin function"));
6721 return Expression::make_error(loc
);
6724 if (this->code_
== BUILTIN_OFFSETOF
)
6726 Expression
* arg
= this->one_arg();
6728 if (arg
->bound_method_expression() != NULL
6729 || arg
->interface_field_reference_expression() != NULL
)
6731 this->report_error(_("invalid use of method value as argument "
6736 Field_reference_expression
* farg
= arg
->field_reference_expression();
6737 while (farg
!= NULL
)
6739 if (!farg
->implicit())
6741 // When the selector refers to an embedded field,
6742 // it must not be reached through pointer indirections.
6743 if (farg
->expr()->deref() != farg
->expr())
6745 this->report_error(_("argument of Offsetof implies "
6746 "indirection of an embedded field"));
6749 // Go up until we reach the original base.
6750 farg
= farg
->expr()->field_reference_expression();
6754 if (this->is_constant())
6756 Numeric_constant nc
;
6757 if (this->numeric_constant_value(&nc
))
6758 return nc
.expression(loc
);
6761 switch (this->code_
)
6768 const Expression_list
* args
= this->args();
6769 if (args
== NULL
|| args
->size() < 1)
6770 this->report_error(_("not enough arguments"));
6771 else if (args
->size() > 1)
6772 this->report_error(_("too many arguments"));
6775 Expression
* arg
= args
->front();
6776 if (!arg
->is_type_expression())
6778 error_at(arg
->location(), "expected type");
6779 this->set_is_error();
6782 return Expression::make_allocation(arg
->type(), loc
);
6788 return this->lower_make();
6790 case BUILTIN_RECOVER
:
6791 if (function
!= NULL
)
6792 function
->func_value()->set_calls_recover();
6795 // Calling recover outside of a function always returns the
6796 // nil empty interface.
6797 Type
* eface
= Type::make_empty_interface_type(loc
);
6798 return Expression::make_cast(eface
, Expression::make_nil(loc
), loc
);
6802 case BUILTIN_APPEND
:
6804 // Lower the varargs.
6805 const Expression_list
* args
= this->args();
6806 if (args
== NULL
|| args
->empty())
6808 Type
* slice_type
= args
->front()->type();
6809 if (!slice_type
->is_slice_type())
6811 if (slice_type
->is_nil_type())
6812 error_at(args
->front()->location(), "use of untyped nil");
6814 error_at(args
->front()->location(),
6815 "argument 1 must be a slice");
6816 this->set_is_error();
6819 Type
* element_type
= slice_type
->array_type()->element_type();
6820 this->lower_varargs(gogo
, function
, inserter
,
6821 Type::make_array_type(element_type
, NULL
),
6826 case BUILTIN_DELETE
:
6828 // Lower to a runtime function call.
6829 const Expression_list
* args
= this->args();
6830 if (args
== NULL
|| args
->size() < 2)
6831 this->report_error(_("not enough arguments"));
6832 else if (args
->size() > 2)
6833 this->report_error(_("too many arguments"));
6834 else if (args
->front()->type()->map_type() == NULL
)
6835 this->report_error(_("argument 1 must be a map"));
6838 // Since this function returns no value it must appear in
6839 // a statement by itself, so we don't have to worry about
6840 // order of evaluation of values around it. Evaluate the
6841 // map first to get order of evaluation right.
6842 Map_type
* mt
= args
->front()->type()->map_type();
6843 Temporary_statement
* map_temp
=
6844 Statement::make_temporary(mt
, args
->front(), loc
);
6845 inserter
->insert(map_temp
);
6847 Temporary_statement
* key_temp
=
6848 Statement::make_temporary(mt
->key_type(), args
->back(), loc
);
6849 inserter
->insert(key_temp
);
6851 Expression
* e1
= Expression::make_temporary_reference(map_temp
,
6853 Expression
* e2
= Expression::make_temporary_reference(key_temp
,
6855 e2
= Expression::make_unary(OPERATOR_AND
, e2
, loc
);
6856 return Runtime::make_call(Runtime::MAPDELETE
, this->location(),
6866 // Flatten a builtin call expression. This turns the arguments of copy and
6867 // append into temporary expressions.
6870 Builtin_call_expression::do_flatten(Gogo
*, Named_object
*,
6871 Statement_inserter
* inserter
)
6873 if (this->code_
== BUILTIN_APPEND
6874 || this->code_
== BUILTIN_COPY
)
6876 Location loc
= this->location();
6877 Type
* at
= this->args()->front()->type();
6878 for (Expression_list::iterator pa
= this->args()->begin();
6879 pa
!= this->args()->end();
6882 if ((*pa
)->is_nil_expression())
6883 *pa
= Expression::make_slice_composite_literal(at
, NULL
, loc
);
6884 if (!(*pa
)->is_variable())
6886 Temporary_statement
* temp
=
6887 Statement::make_temporary(NULL
, *pa
, loc
);
6888 inserter
->insert(temp
);
6889 *pa
= Expression::make_temporary_reference(temp
, loc
);
6896 // Lower a make expression.
6899 Builtin_call_expression::lower_make()
6901 Location loc
= this->location();
6903 const Expression_list
* args
= this->args();
6904 if (args
== NULL
|| args
->size() < 1)
6906 this->report_error(_("not enough arguments"));
6907 return Expression::make_error(this->location());
6910 Expression_list::const_iterator parg
= args
->begin();
6912 Expression
* first_arg
= *parg
;
6913 if (!first_arg
->is_type_expression())
6915 error_at(first_arg
->location(), "expected type");
6916 this->set_is_error();
6917 return Expression::make_error(this->location());
6919 Type
* type
= first_arg
->type();
6921 bool is_slice
= false;
6922 bool is_map
= false;
6923 bool is_chan
= false;
6924 if (type
->is_slice_type())
6926 else if (type
->map_type() != NULL
)
6928 else if (type
->channel_type() != NULL
)
6932 this->report_error(_("invalid type for make function"));
6933 return Expression::make_error(this->location());
6936 bool have_big_args
= false;
6937 Type
* uintptr_type
= Type::lookup_integer_type("uintptr");
6938 int uintptr_bits
= uintptr_type
->integer_type()->bits();
6940 Type_context
int_context(Type::lookup_integer_type("int"), false);
6943 Expression
* len_arg
;
6944 if (parg
== args
->end())
6948 this->report_error(_("length required when allocating a slice"));
6949 return Expression::make_error(this->location());
6951 len_arg
= Expression::make_integer_ul(0, NULL
, loc
);
6956 len_arg
->determine_type(&int_context
);
6957 if (!this->check_int_value(len_arg
, true))
6958 return Expression::make_error(this->location());
6959 if (len_arg
->type()->integer_type() != NULL
6960 && len_arg
->type()->integer_type()->bits() > uintptr_bits
)
6961 have_big_args
= true;
6965 Expression
* cap_arg
= NULL
;
6966 if (is_slice
&& parg
!= args
->end())
6969 cap_arg
->determine_type(&int_context
);
6970 if (!this->check_int_value(cap_arg
, false))
6971 return Expression::make_error(this->location());
6973 Numeric_constant nclen
;
6974 Numeric_constant nccap
;
6977 if (len_arg
->numeric_constant_value(&nclen
)
6978 && cap_arg
->numeric_constant_value(&nccap
)
6979 && nclen
.to_unsigned_long(&vlen
) == Numeric_constant::NC_UL_VALID
6980 && nccap
.to_unsigned_long(&vcap
) == Numeric_constant::NC_UL_VALID
6983 this->report_error(_("len larger than cap"));
6984 return Expression::make_error(this->location());
6987 if (cap_arg
->type()->integer_type() != NULL
6988 && cap_arg
->type()->integer_type()->bits() > uintptr_bits
)
6989 have_big_args
= true;
6993 if (parg
!= args
->end())
6995 this->report_error(_("too many arguments to make"));
6996 return Expression::make_error(this->location());
6999 Location type_loc
= first_arg
->location();
7000 Expression
* type_arg
;
7001 if (is_slice
|| is_chan
)
7002 type_arg
= Expression::make_type_descriptor(type
, type_loc
);
7004 type_arg
= Expression::make_map_descriptor(type
->map_type(), type_loc
);
7011 if (cap_arg
== NULL
)
7012 call
= Runtime::make_call((have_big_args
7013 ? Runtime::MAKESLICE1BIG
7014 : Runtime::MAKESLICE1
),
7015 loc
, 2, type_arg
, len_arg
);
7017 call
= Runtime::make_call((have_big_args
7018 ? Runtime::MAKESLICE2BIG
7019 : Runtime::MAKESLICE2
),
7020 loc
, 3, type_arg
, len_arg
, cap_arg
);
7023 call
= Runtime::make_call((have_big_args
7024 ? Runtime::MAKEMAPBIG
7025 : Runtime::MAKEMAP
),
7026 loc
, 2, type_arg
, len_arg
);
7028 call
= Runtime::make_call((have_big_args
7029 ? Runtime::MAKECHANBIG
7030 : Runtime::MAKECHAN
),
7031 loc
, 2, type_arg
, len_arg
);
7035 return Expression::make_unsafe_cast(type
, call
, loc
);
7038 // Return whether an expression has an integer value. Report an error
7039 // if not. This is used when handling calls to the predeclared make
7043 Builtin_call_expression::check_int_value(Expression
* e
, bool is_length
)
7045 Numeric_constant nc
;
7046 if (e
->numeric_constant_value(&nc
))
7049 switch (nc
.to_unsigned_long(&v
))
7051 case Numeric_constant::NC_UL_VALID
:
7053 case Numeric_constant::NC_UL_NOTINT
:
7054 error_at(e
->location(), "non-integer %s argument to make",
7055 is_length
? "len" : "cap");
7057 case Numeric_constant::NC_UL_NEGATIVE
:
7058 error_at(e
->location(), "negative %s argument to make",
7059 is_length
? "len" : "cap");
7061 case Numeric_constant::NC_UL_BIG
:
7062 // We don't want to give a compile-time error for a 64-bit
7063 // value on a 32-bit target.
7068 if (!nc
.to_int(&val
))
7070 int bits
= mpz_sizeinbase(val
, 2);
7072 Type
* int_type
= Type::lookup_integer_type("int");
7073 if (bits
>= int_type
->integer_type()->bits())
7075 error_at(e
->location(), "%s argument too large for make",
7076 is_length
? "len" : "cap");
7083 if (e
->type()->integer_type() != NULL
)
7086 error_at(e
->location(), "non-integer %s argument to make",
7087 is_length
? "len" : "cap");
7091 // Return the type of the real or imag functions, given the type of
7092 // the argument. We need to map complex64 to float32 and complex128
7093 // to float64, so it has to be done by name. This returns NULL if it
7094 // can't figure out the type.
7097 Builtin_call_expression::real_imag_type(Type
* arg_type
)
7099 if (arg_type
== NULL
|| arg_type
->is_abstract())
7101 Named_type
* nt
= arg_type
->named_type();
7104 while (nt
->real_type()->named_type() != NULL
)
7105 nt
= nt
->real_type()->named_type();
7106 if (nt
->name() == "complex64")
7107 return Type::lookup_float_type("float32");
7108 else if (nt
->name() == "complex128")
7109 return Type::lookup_float_type("float64");
7114 // Return the type of the complex function, given the type of one of the
7115 // argments. Like real_imag_type, we have to map by name.
7118 Builtin_call_expression::complex_type(Type
* arg_type
)
7120 if (arg_type
== NULL
|| arg_type
->is_abstract())
7122 Named_type
* nt
= arg_type
->named_type();
7125 while (nt
->real_type()->named_type() != NULL
)
7126 nt
= nt
->real_type()->named_type();
7127 if (nt
->name() == "float32")
7128 return Type::lookup_complex_type("complex64");
7129 else if (nt
->name() == "float64")
7130 return Type::lookup_complex_type("complex128");
7135 // Return a single argument, or NULL if there isn't one.
7138 Builtin_call_expression::one_arg() const
7140 const Expression_list
* args
= this->args();
7141 if (args
== NULL
|| args
->size() != 1)
7143 return args
->front();
7146 // A traversal class which looks for a call or receive expression.
7148 class Find_call_expression
: public Traverse
7151 Find_call_expression()
7152 : Traverse(traverse_expressions
),
7157 expression(Expression
**);
7161 { return this->found_
; }
7168 Find_call_expression::expression(Expression
** pexpr
)
7170 if ((*pexpr
)->call_expression() != NULL
7171 || (*pexpr
)->receive_expression() != NULL
)
7173 this->found_
= true;
7174 return TRAVERSE_EXIT
;
7176 return TRAVERSE_CONTINUE
;
7179 // Return whether this is constant: len of a string constant, or len
7180 // or cap of an array, or unsafe.Sizeof, unsafe.Offsetof,
7184 Builtin_call_expression::do_is_constant() const
7186 if (this->is_error_expression())
7188 switch (this->code_
)
7196 Expression
* arg
= this->one_arg();
7199 Type
* arg_type
= arg
->type();
7201 if (arg_type
->points_to() != NULL
7202 && arg_type
->points_to()->array_type() != NULL
7203 && !arg_type
->points_to()->is_slice_type())
7204 arg_type
= arg_type
->points_to();
7206 // The len and cap functions are only constant if there are no
7207 // function calls or channel operations in the arguments.
7208 // Otherwise we have to make the call.
7209 if (!arg
->is_constant())
7211 Find_call_expression find_call
;
7212 Expression::traverse(&arg
, &find_call
);
7213 if (find_call
.found())
7217 if (arg_type
->array_type() != NULL
7218 && arg_type
->array_type()->length() != NULL
)
7221 if (this->code_
== BUILTIN_LEN
&& arg_type
->is_string_type())
7224 bool ret
= arg
->is_constant();
7225 this->seen_
= false;
7231 case BUILTIN_SIZEOF
:
7232 case BUILTIN_ALIGNOF
:
7233 return this->one_arg() != NULL
;
7235 case BUILTIN_OFFSETOF
:
7237 Expression
* arg
= this->one_arg();
7240 return arg
->field_reference_expression() != NULL
;
7243 case BUILTIN_COMPLEX
:
7245 const Expression_list
* args
= this->args();
7246 if (args
!= NULL
&& args
->size() == 2)
7247 return args
->front()->is_constant() && args
->back()->is_constant();
7254 Expression
* arg
= this->one_arg();
7255 return arg
!= NULL
&& arg
->is_constant();
7265 // Return a numeric constant if possible.
7268 Builtin_call_expression::do_numeric_constant_value(Numeric_constant
* nc
) const
7270 if (this->code_
== BUILTIN_LEN
7271 || this->code_
== BUILTIN_CAP
)
7273 Expression
* arg
= this->one_arg();
7276 Type
* arg_type
= arg
->type();
7278 if (this->code_
== BUILTIN_LEN
&& arg_type
->is_string_type())
7281 if (arg
->string_constant_value(&sval
))
7283 nc
->set_unsigned_long(Type::lookup_integer_type("int"),
7289 if (arg_type
->points_to() != NULL
7290 && arg_type
->points_to()->array_type() != NULL
7291 && !arg_type
->points_to()->is_slice_type())
7292 arg_type
= arg_type
->points_to();
7294 if (arg_type
->array_type() != NULL
7295 && arg_type
->array_type()->length() != NULL
)
7299 Expression
* e
= arg_type
->array_type()->length();
7301 bool r
= e
->numeric_constant_value(nc
);
7302 this->seen_
= false;
7305 if (!nc
->set_type(Type::lookup_integer_type("int"), false,
7312 else if (this->code_
== BUILTIN_SIZEOF
7313 || this->code_
== BUILTIN_ALIGNOF
)
7315 Expression
* arg
= this->one_arg();
7318 Type
* arg_type
= arg
->type();
7319 if (arg_type
->is_error())
7321 if (arg_type
->is_abstract())
7327 if (this->code_
== BUILTIN_SIZEOF
)
7330 bool ok
= arg_type
->backend_type_size(this->gogo_
, &ret
);
7331 this->seen_
= false;
7335 else if (this->code_
== BUILTIN_ALIGNOF
)
7339 if (arg
->field_reference_expression() == NULL
)
7340 ok
= arg_type
->backend_type_align(this->gogo_
, &ret
);
7343 // Calling unsafe.Alignof(s.f) returns the alignment of
7344 // the type of f when it is used as a field in a struct.
7345 ok
= arg_type
->backend_type_field_align(this->gogo_
, &ret
);
7347 this->seen_
= false;
7354 nc
->set_unsigned_long(Type::lookup_integer_type("uintptr"), ret
);
7357 else if (this->code_
== BUILTIN_OFFSETOF
)
7359 Expression
* arg
= this->one_arg();
7362 Field_reference_expression
* farg
= arg
->field_reference_expression();
7368 unsigned int total_offset
= 0;
7371 Expression
* struct_expr
= farg
->expr();
7372 Type
* st
= struct_expr
->type();
7373 if (st
->struct_type() == NULL
)
7375 if (st
->named_type() != NULL
)
7376 st
->named_type()->convert(this->gogo_
);
7377 unsigned int offset
;
7379 bool ok
= st
->struct_type()->backend_field_offset(this->gogo_
,
7380 farg
->field_index(),
7382 this->seen_
= false;
7385 total_offset
+= offset
;
7386 if (farg
->implicit() && struct_expr
->field_reference_expression() != NULL
)
7388 // Go up until we reach the original base.
7389 farg
= struct_expr
->field_reference_expression();
7394 nc
->set_unsigned_long(Type::lookup_integer_type("uintptr"),
7395 static_cast<unsigned long>(total_offset
));
7398 else if (this->code_
== BUILTIN_REAL
|| this->code_
== BUILTIN_IMAG
)
7400 Expression
* arg
= this->one_arg();
7404 Numeric_constant argnc
;
7405 if (!arg
->numeric_constant_value(&argnc
))
7409 if (!argnc
.to_complex(&val
))
7412 Type
* type
= Builtin_call_expression::real_imag_type(argnc
.type());
7413 if (this->code_
== BUILTIN_REAL
)
7414 nc
->set_float(type
, mpc_realref(val
));
7416 nc
->set_float(type
, mpc_imagref(val
));
7420 else if (this->code_
== BUILTIN_COMPLEX
)
7422 const Expression_list
* args
= this->args();
7423 if (args
== NULL
|| args
->size() != 2)
7426 Numeric_constant rnc
;
7427 if (!args
->front()->numeric_constant_value(&rnc
))
7429 Numeric_constant inc
;
7430 if (!args
->back()->numeric_constant_value(&inc
))
7433 if (rnc
.type() != NULL
7434 && !rnc
.type()->is_abstract()
7435 && inc
.type() != NULL
7436 && !inc
.type()->is_abstract()
7437 && !Type::are_identical(rnc
.type(), inc
.type(), false, NULL
))
7441 if (!rnc
.to_float(&r
))
7444 if (!inc
.to_float(&i
))
7450 Type
* arg_type
= rnc
.type();
7451 if (arg_type
== NULL
|| arg_type
->is_abstract())
7452 arg_type
= inc
.type();
7455 mpc_init2(val
, mpc_precision
);
7456 mpc_set_fr_fr(val
, r
, i
, MPC_RNDNN
);
7460 Type
* type
= Builtin_call_expression::complex_type(arg_type
);
7461 nc
->set_complex(type
, val
);
7471 // Give an error if we are discarding the value of an expression which
7472 // should not normally be discarded. We don't give an error for
7473 // discarding the value of an ordinary function call, but we do for
7474 // builtin functions, purely for consistency with the gc compiler.
7477 Builtin_call_expression::do_discarding_value()
7479 switch (this->code_
)
7481 case BUILTIN_INVALID
:
7485 case BUILTIN_APPEND
:
7487 case BUILTIN_COMPLEX
:
7493 case BUILTIN_ALIGNOF
:
7494 case BUILTIN_OFFSETOF
:
7495 case BUILTIN_SIZEOF
:
7496 this->unused_value_error();
7501 case BUILTIN_DELETE
:
7504 case BUILTIN_PRINTLN
:
7505 case BUILTIN_RECOVER
:
7513 Builtin_call_expression::do_type()
7515 switch (this->code_
)
7517 case BUILTIN_INVALID
:
7524 const Expression_list
* args
= this->args();
7525 if (args
== NULL
|| args
->empty())
7526 return Type::make_error_type();
7527 return Type::make_pointer_type(args
->front()->type());
7533 return Type::lookup_integer_type("int");
7535 case BUILTIN_ALIGNOF
:
7536 case BUILTIN_OFFSETOF
:
7537 case BUILTIN_SIZEOF
:
7538 return Type::lookup_integer_type("uintptr");
7541 case BUILTIN_DELETE
:
7544 case BUILTIN_PRINTLN
:
7545 return Type::make_void_type();
7547 case BUILTIN_RECOVER
:
7548 return Type::make_empty_interface_type(Linemap::predeclared_location());
7550 case BUILTIN_APPEND
:
7552 const Expression_list
* args
= this->args();
7553 if (args
== NULL
|| args
->empty())
7554 return Type::make_error_type();
7555 Type
*ret
= args
->front()->type();
7556 if (!ret
->is_slice_type())
7557 return Type::make_error_type();
7564 Expression
* arg
= this->one_arg();
7566 return Type::make_error_type();
7567 Type
* t
= arg
->type();
7568 if (t
->is_abstract())
7569 t
= t
->make_non_abstract_type();
7570 t
= Builtin_call_expression::real_imag_type(t
);
7572 t
= Type::make_error_type();
7576 case BUILTIN_COMPLEX
:
7578 const Expression_list
* args
= this->args();
7579 if (args
== NULL
|| args
->size() != 2)
7580 return Type::make_error_type();
7581 Type
* t
= args
->front()->type();
7582 if (t
->is_abstract())
7584 t
= args
->back()->type();
7585 if (t
->is_abstract())
7586 t
= t
->make_non_abstract_type();
7588 t
= Builtin_call_expression::complex_type(t
);
7590 t
= Type::make_error_type();
7596 // Determine the type.
7599 Builtin_call_expression::do_determine_type(const Type_context
* context
)
7601 if (!this->determining_types())
7604 this->fn()->determine_type_no_context();
7606 const Expression_list
* args
= this->args();
7609 Type
* arg_type
= NULL
;
7610 switch (this->code_
)
7613 case BUILTIN_PRINTLN
:
7614 // Do not force a large integer constant to "int".
7620 arg_type
= Builtin_call_expression::complex_type(context
->type
);
7621 if (arg_type
== NULL
)
7622 arg_type
= Type::lookup_complex_type("complex128");
7626 case BUILTIN_COMPLEX
:
7628 // For the complex function the type of one operand can
7629 // determine the type of the other, as in a binary expression.
7630 arg_type
= Builtin_call_expression::real_imag_type(context
->type
);
7631 if (arg_type
== NULL
)
7632 arg_type
= Type::lookup_float_type("float64");
7633 if (args
!= NULL
&& args
->size() == 2)
7635 Type
* t1
= args
->front()->type();
7636 Type
* t2
= args
->back()->type();
7637 if (!t1
->is_abstract())
7639 else if (!t2
->is_abstract())
7653 for (Expression_list::const_iterator pa
= args
->begin();
7657 Type_context subcontext
;
7658 subcontext
.type
= arg_type
;
7662 // We want to print large constants, we so can't just
7663 // use the appropriate nonabstract type. Use uint64 for
7664 // an integer if we know it is nonnegative, otherwise
7665 // use int64 for a integer, otherwise use float64 for a
7666 // float or complex128 for a complex.
7667 Type
* want_type
= NULL
;
7668 Type
* atype
= (*pa
)->type();
7669 if (atype
->is_abstract())
7671 if (atype
->integer_type() != NULL
)
7673 Numeric_constant nc
;
7674 if (this->numeric_constant_value(&nc
))
7677 if (nc
.to_int(&val
))
7679 if (mpz_sgn(val
) >= 0)
7680 want_type
= Type::lookup_integer_type("uint64");
7684 if (want_type
== NULL
)
7685 want_type
= Type::lookup_integer_type("int64");
7687 else if (atype
->float_type() != NULL
)
7688 want_type
= Type::lookup_float_type("float64");
7689 else if (atype
->complex_type() != NULL
)
7690 want_type
= Type::lookup_complex_type("complex128");
7691 else if (atype
->is_abstract_string_type())
7692 want_type
= Type::lookup_string_type();
7693 else if (atype
->is_abstract_boolean_type())
7694 want_type
= Type::lookup_bool_type();
7697 subcontext
.type
= want_type
;
7701 (*pa
)->determine_type(&subcontext
);
7706 // If there is exactly one argument, return true. Otherwise give an
7707 // error message and return false.
7710 Builtin_call_expression::check_one_arg()
7712 const Expression_list
* args
= this->args();
7713 if (args
== NULL
|| args
->size() < 1)
7715 this->report_error(_("not enough arguments"));
7718 else if (args
->size() > 1)
7720 this->report_error(_("too many arguments"));
7723 if (args
->front()->is_error_expression()
7724 || args
->front()->type()->is_error())
7726 this->set_is_error();
7732 // Check argument types for a builtin function.
7735 Builtin_call_expression::do_check_types(Gogo
*)
7737 if (this->is_error_expression())
7739 switch (this->code_
)
7741 case BUILTIN_INVALID
:
7744 case BUILTIN_DELETE
:
7750 // The single argument may be either a string or an array or a
7751 // map or a channel, or a pointer to a closed array.
7752 if (this->check_one_arg())
7754 Type
* arg_type
= this->one_arg()->type();
7755 if (arg_type
->points_to() != NULL
7756 && arg_type
->points_to()->array_type() != NULL
7757 && !arg_type
->points_to()->is_slice_type())
7758 arg_type
= arg_type
->points_to();
7759 if (this->code_
== BUILTIN_CAP
)
7761 if (!arg_type
->is_error()
7762 && arg_type
->array_type() == NULL
7763 && arg_type
->channel_type() == NULL
)
7764 this->report_error(_("argument must be array or slice "
7769 if (!arg_type
->is_error()
7770 && !arg_type
->is_string_type()
7771 && arg_type
->array_type() == NULL
7772 && arg_type
->map_type() == NULL
7773 && arg_type
->channel_type() == NULL
)
7774 this->report_error(_("argument must be string or "
7775 "array or slice or map or channel"));
7782 case BUILTIN_PRINTLN
:
7784 const Expression_list
* args
= this->args();
7787 if (this->code_
== BUILTIN_PRINT
)
7788 warning_at(this->location(), 0,
7789 "no arguments for builtin function %<%s%>",
7790 (this->code_
== BUILTIN_PRINT
7796 for (Expression_list::const_iterator p
= args
->begin();
7800 Type
* type
= (*p
)->type();
7801 if (type
->is_error()
7802 || type
->is_string_type()
7803 || type
->integer_type() != NULL
7804 || type
->float_type() != NULL
7805 || type
->complex_type() != NULL
7806 || type
->is_boolean_type()
7807 || type
->points_to() != NULL
7808 || type
->interface_type() != NULL
7809 || type
->channel_type() != NULL
7810 || type
->map_type() != NULL
7811 || type
->function_type() != NULL
7812 || type
->is_slice_type())
7814 else if ((*p
)->is_type_expression())
7816 // If this is a type expression it's going to give
7817 // an error anyhow, so we don't need one here.
7820 this->report_error(_("unsupported argument type to "
7821 "builtin function"));
7828 if (this->check_one_arg())
7830 if (this->one_arg()->type()->channel_type() == NULL
)
7831 this->report_error(_("argument must be channel"));
7832 else if (!this->one_arg()->type()->channel_type()->may_send())
7833 this->report_error(_("cannot close receive-only channel"));
7838 case BUILTIN_SIZEOF
:
7839 case BUILTIN_ALIGNOF
:
7840 this->check_one_arg();
7843 case BUILTIN_RECOVER
:
7844 if (this->args() != NULL
&& !this->args()->empty())
7845 this->report_error(_("too many arguments"));
7848 case BUILTIN_OFFSETOF
:
7849 if (this->check_one_arg())
7851 Expression
* arg
= this->one_arg();
7852 if (arg
->field_reference_expression() == NULL
)
7853 this->report_error(_("argument must be a field reference"));
7859 const Expression_list
* args
= this->args();
7860 if (args
== NULL
|| args
->size() < 2)
7862 this->report_error(_("not enough arguments"));
7865 else if (args
->size() > 2)
7867 this->report_error(_("too many arguments"));
7870 Type
* arg1_type
= args
->front()->type();
7871 Type
* arg2_type
= args
->back()->type();
7872 if (arg1_type
->is_error() || arg2_type
->is_error())
7876 if (arg1_type
->is_slice_type())
7877 e1
= arg1_type
->array_type()->element_type();
7880 this->report_error(_("left argument must be a slice"));
7884 if (arg2_type
->is_slice_type())
7886 Type
* e2
= arg2_type
->array_type()->element_type();
7887 if (!Type::are_identical(e1
, e2
, true, NULL
))
7888 this->report_error(_("element types must be the same"));
7890 else if (arg2_type
->is_string_type())
7892 if (e1
->integer_type() == NULL
|| !e1
->integer_type()->is_byte())
7893 this->report_error(_("first argument must be []byte"));
7896 this->report_error(_("second argument must be slice or string"));
7900 case BUILTIN_APPEND
:
7902 const Expression_list
* args
= this->args();
7903 if (args
== NULL
|| args
->size() < 2)
7905 this->report_error(_("not enough arguments"));
7908 if (args
->size() > 2)
7910 this->report_error(_("too many arguments"));
7913 if (args
->front()->type()->is_error()
7914 || args
->back()->type()->is_error())
7917 Array_type
* at
= args
->front()->type()->array_type();
7918 Type
* e
= at
->element_type();
7920 // The language permits appending a string to a []byte, as a
7922 if (args
->back()->type()->is_string_type())
7924 if (e
->integer_type() != NULL
&& e
->integer_type()->is_byte())
7928 // The language says that the second argument must be
7929 // assignable to a slice of the element type of the first
7930 // argument. We already know the first argument is a slice
7932 Type
* arg2_type
= Type::make_array_type(e
, NULL
);
7934 if (!Type::are_assignable(arg2_type
, args
->back()->type(), &reason
))
7937 this->report_error(_("argument 2 has invalid type"));
7940 error_at(this->location(), "argument 2 has invalid type (%s)",
7942 this->set_is_error();
7950 if (this->check_one_arg())
7952 if (this->one_arg()->type()->complex_type() == NULL
)
7953 this->report_error(_("argument must have complex type"));
7957 case BUILTIN_COMPLEX
:
7959 const Expression_list
* args
= this->args();
7960 if (args
== NULL
|| args
->size() < 2)
7961 this->report_error(_("not enough arguments"));
7962 else if (args
->size() > 2)
7963 this->report_error(_("too many arguments"));
7964 else if (args
->front()->is_error_expression()
7965 || args
->front()->type()->is_error()
7966 || args
->back()->is_error_expression()
7967 || args
->back()->type()->is_error())
7968 this->set_is_error();
7969 else if (!Type::are_identical(args
->front()->type(),
7970 args
->back()->type(), true, NULL
))
7971 this->report_error(_("complex arguments must have identical types"));
7972 else if (args
->front()->type()->float_type() == NULL
)
7973 this->report_error(_("complex arguments must have "
7974 "floating-point type"));
7983 // Return the backend representation for a builtin function.
7986 Builtin_call_expression::do_get_backend(Translate_context
* context
)
7988 Gogo
* gogo
= context
->gogo();
7989 Location location
= this->location();
7990 switch (this->code_
)
7992 case BUILTIN_INVALID
:
8000 const Expression_list
* args
= this->args();
8001 go_assert(args
!= NULL
&& args
->size() == 1);
8002 Expression
* arg
= args
->front();
8003 Type
* arg_type
= arg
->type();
8007 go_assert(saw_errors());
8008 return context
->backend()->error_expression();
8011 this->seen_
= false;
8012 if (arg_type
->points_to() != NULL
)
8014 arg_type
= arg_type
->points_to();
8015 go_assert(arg_type
->array_type() != NULL
8016 && !arg_type
->is_slice_type());
8017 arg
= Expression::make_unary(OPERATOR_MULT
, arg
, location
);
8020 Type
* int_type
= Type::lookup_integer_type("int");
8022 if (this->code_
== BUILTIN_LEN
)
8024 if (arg_type
->is_string_type())
8025 val
= Expression::make_string_info(arg
, STRING_INFO_LENGTH
,
8027 else if (arg_type
->array_type() != NULL
)
8031 go_assert(saw_errors());
8032 return context
->backend()->error_expression();
8035 val
= arg_type
->array_type()->get_length(gogo
, arg
);
8036 this->seen_
= false;
8038 else if (arg_type
->map_type() != NULL
)
8039 val
= Runtime::make_call(Runtime::MAP_LEN
, location
, 1, arg
);
8040 else if (arg_type
->channel_type() != NULL
)
8041 val
= Runtime::make_call(Runtime::CHAN_LEN
, location
, 1, arg
);
8047 if (arg_type
->array_type() != NULL
)
8051 go_assert(saw_errors());
8052 return context
->backend()->error_expression();
8055 val
= arg_type
->array_type()->get_capacity(gogo
, arg
);
8056 this->seen_
= false;
8058 else if (arg_type
->channel_type() != NULL
)
8059 val
= Runtime::make_call(Runtime::CHAN_CAP
, location
, 1, arg
);
8064 return Expression::make_cast(int_type
, val
,
8065 location
)->get_backend(context
);
8069 case BUILTIN_PRINTLN
:
8071 const bool is_ln
= this->code_
== BUILTIN_PRINTLN
;
8072 Expression
* print_stmts
= NULL
;
8074 const Expression_list
* call_args
= this->args();
8075 if (call_args
!= NULL
)
8077 for (Expression_list::const_iterator p
= call_args
->begin();
8078 p
!= call_args
->end();
8081 if (is_ln
&& p
!= call_args
->begin())
8083 Expression
* print_space
=
8084 Runtime::make_call(Runtime::PRINT_SPACE
,
8085 this->location(), 0);
8088 Expression::make_compound(print_stmts
, print_space
,
8092 Expression
* arg
= *p
;
8093 Type
* type
= arg
->type();
8094 Runtime::Function code
;
8095 if (type
->is_string_type())
8096 code
= Runtime::PRINT_STRING
;
8097 else if (type
->integer_type() != NULL
8098 && type
->integer_type()->is_unsigned())
8100 Type
* itype
= Type::lookup_integer_type("uint64");
8101 arg
= Expression::make_cast(itype
, arg
, location
);
8102 code
= Runtime::PRINT_UINT64
;
8104 else if (type
->integer_type() != NULL
)
8106 Type
* itype
= Type::lookup_integer_type("int64");
8107 arg
= Expression::make_cast(itype
, arg
, location
);
8108 code
= Runtime::PRINT_INT64
;
8110 else if (type
->float_type() != NULL
)
8112 Type
* dtype
= Type::lookup_float_type("float64");
8113 arg
= Expression::make_cast(dtype
, arg
, location
);
8114 code
= Runtime::PRINT_DOUBLE
;
8116 else if (type
->complex_type() != NULL
)
8118 Type
* ctype
= Type::lookup_complex_type("complex128");
8119 arg
= Expression::make_cast(ctype
, arg
, location
);
8120 code
= Runtime::PRINT_COMPLEX
;
8122 else if (type
->is_boolean_type())
8123 code
= Runtime::PRINT_BOOL
;
8124 else if (type
->points_to() != NULL
8125 || type
->channel_type() != NULL
8126 || type
->map_type() != NULL
8127 || type
->function_type() != NULL
)
8129 arg
= Expression::make_cast(type
, arg
, location
);
8130 code
= Runtime::PRINT_POINTER
;
8132 else if (type
->interface_type() != NULL
)
8134 if (type
->interface_type()->is_empty())
8135 code
= Runtime::PRINT_EMPTY_INTERFACE
;
8137 code
= Runtime::PRINT_INTERFACE
;
8139 else if (type
->is_slice_type())
8140 code
= Runtime::PRINT_SLICE
;
8143 go_assert(saw_errors());
8144 return context
->backend()->error_expression();
8147 Expression
* call
= Runtime::make_call(code
, location
, 1, arg
);
8148 if (print_stmts
== NULL
)
8151 print_stmts
= Expression::make_compound(print_stmts
, call
,
8158 Expression
* print_nl
=
8159 Runtime::make_call(Runtime::PRINT_NL
, location
, 0);
8160 if (print_stmts
== NULL
)
8161 print_stmts
= print_nl
;
8163 print_stmts
= Expression::make_compound(print_stmts
, print_nl
,
8167 return print_stmts
->get_backend(context
);
8172 const Expression_list
* args
= this->args();
8173 go_assert(args
!= NULL
&& args
->size() == 1);
8174 Expression
* arg
= args
->front();
8176 Type::make_empty_interface_type(Linemap::predeclared_location());
8177 arg
= Expression::convert_for_assignment(gogo
, empty
, arg
, location
);
8180 Runtime::make_call(Runtime::PANIC
, location
, 1, arg
);
8181 return panic
->get_backend(context
);
8184 case BUILTIN_RECOVER
:
8186 // The argument is set when building recover thunks. It's a
8187 // boolean value which is true if we can recover a value now.
8188 const Expression_list
* args
= this->args();
8189 go_assert(args
!= NULL
&& args
->size() == 1);
8190 Expression
* arg
= args
->front();
8192 Type::make_empty_interface_type(Linemap::predeclared_location());
8194 Expression
* nil
= Expression::make_nil(location
);
8195 nil
= Expression::convert_for_assignment(gogo
, empty
, nil
, location
);
8197 // We need to handle a deferred call to recover specially,
8198 // because it changes whether it can recover a panic or not.
8199 // See test7 in test/recover1.go.
8200 Expression
* recover
= Runtime::make_call((this->is_deferred()
8201 ? Runtime::DEFERRED_RECOVER
8202 : Runtime::RECOVER
),
8205 Expression::make_conditional(arg
, recover
, nil
, location
);
8206 return cond
->get_backend(context
);
8211 const Expression_list
* args
= this->args();
8212 go_assert(args
!= NULL
&& args
->size() == 1);
8213 Expression
* arg
= args
->front();
8214 Expression
* close
= Runtime::make_call(Runtime::CLOSE
, location
,
8216 return close
->get_backend(context
);
8219 case BUILTIN_SIZEOF
:
8220 case BUILTIN_OFFSETOF
:
8221 case BUILTIN_ALIGNOF
:
8223 Numeric_constant nc
;
8225 if (!this->numeric_constant_value(&nc
)
8226 || nc
.to_unsigned_long(&val
) != Numeric_constant::NC_UL_VALID
)
8228 go_assert(saw_errors());
8229 return context
->backend()->error_expression();
8231 Type
* uintptr_type
= Type::lookup_integer_type("uintptr");
8234 Expression
* int_cst
=
8235 Expression::make_integer_z(&ival
, uintptr_type
, location
);
8237 return int_cst
->get_backend(context
);
8242 const Expression_list
* args
= this->args();
8243 go_assert(args
!= NULL
&& args
->size() == 2);
8244 Expression
* arg1
= args
->front();
8245 Expression
* arg2
= args
->back();
8247 Type
* arg1_type
= arg1
->type();
8248 Array_type
* at
= arg1_type
->array_type();
8249 go_assert(arg1
->is_variable());
8250 Expression
* arg1_val
= at
->get_value_pointer(gogo
, arg1
);
8251 Expression
* arg1_len
= at
->get_length(gogo
, arg1
);
8253 Type
* arg2_type
= arg2
->type();
8254 go_assert(arg2
->is_variable());
8255 Expression
* arg2_val
;
8256 Expression
* arg2_len
;
8257 if (arg2_type
->is_slice_type())
8259 at
= arg2_type
->array_type();
8260 arg2_val
= at
->get_value_pointer(gogo
, arg2
);
8261 arg2_len
= at
->get_length(gogo
, arg2
);
8265 go_assert(arg2
->is_variable());
8266 arg2_val
= Expression::make_string_info(arg2
, STRING_INFO_DATA
,
8268 arg2_len
= Expression::make_string_info(arg2
, STRING_INFO_LENGTH
,
8272 Expression::make_binary(OPERATOR_LT
, arg1_len
, arg2_len
, location
);
8273 Expression
* length
=
8274 Expression::make_conditional(cond
, arg1_len
, arg2_len
, location
);
8276 Type
* element_type
= at
->element_type();
8277 Btype
* element_btype
= element_type
->get_backend(gogo
);
8278 size_t element_size
= gogo
->backend()->type_size(element_btype
);
8279 Expression
* size_expr
= Expression::make_integer_ul(element_size
,
8282 Expression
* bytecount
=
8283 Expression::make_binary(OPERATOR_MULT
, size_expr
, length
, location
);
8284 Expression
* copy
= Runtime::make_call(Runtime::COPY
, location
, 3,
8285 arg1_val
, arg2_val
, bytecount
);
8287 Expression
* compound
= Expression::make_compound(copy
, length
, location
);
8288 return compound
->get_backend(context
);
8291 case BUILTIN_APPEND
:
8293 const Expression_list
* args
= this->args();
8294 go_assert(args
!= NULL
&& args
->size() == 2);
8295 Expression
* arg1
= args
->front();
8296 Expression
* arg2
= args
->back();
8298 Array_type
* at
= arg1
->type()->array_type();
8299 Type
* element_type
= at
->element_type()->forwarded();
8301 go_assert(arg2
->is_variable());
8302 Expression
* arg2_val
;
8303 Expression
* arg2_len
;
8305 if (arg2
->type()->is_string_type()
8306 && element_type
->integer_type() != NULL
8307 && element_type
->integer_type()->is_byte())
8309 arg2_val
= Expression::make_string_info(arg2
, STRING_INFO_DATA
,
8311 arg2_len
= Expression::make_string_info(arg2
, STRING_INFO_LENGTH
,
8317 arg2_val
= at
->get_value_pointer(gogo
, arg2
);
8318 arg2_len
= at
->get_length(gogo
, arg2
);
8319 Btype
* element_btype
= element_type
->get_backend(gogo
);
8320 size
= gogo
->backend()->type_size(element_btype
);
8322 Expression
* element_size
=
8323 Expression::make_integer_ul(size
, NULL
, location
);
8325 Expression
* append
= Runtime::make_call(Runtime::APPEND
, location
, 4,
8326 arg1
, arg2_val
, arg2_len
,
8328 append
= Expression::make_unsafe_cast(arg1
->type(), append
, location
);
8329 return append
->get_backend(context
);
8335 const Expression_list
* args
= this->args();
8336 go_assert(args
!= NULL
&& args
->size() == 1);
8339 Bexpression
* bcomplex
= args
->front()->get_backend(context
);
8340 if (this->code_
== BUILTIN_REAL
)
8341 ret
= gogo
->backend()->real_part_expression(bcomplex
, location
);
8343 ret
= gogo
->backend()->imag_part_expression(bcomplex
, location
);
8347 case BUILTIN_COMPLEX
:
8349 const Expression_list
* args
= this->args();
8350 go_assert(args
!= NULL
&& args
->size() == 2);
8351 Bexpression
* breal
= args
->front()->get_backend(context
);
8352 Bexpression
* bimag
= args
->back()->get_backend(context
);
8353 return gogo
->backend()->complex_expression(breal
, bimag
, location
);
8361 // We have to support exporting a builtin call expression, because
8362 // code can set a constant to the result of a builtin expression.
8365 Builtin_call_expression::do_export(Export
* exp
) const
8367 Numeric_constant nc
;
8368 if (!this->numeric_constant_value(&nc
))
8370 error_at(this->location(), "value is not constant");
8378 Integer_expression::export_integer(exp
, val
);
8381 else if (nc
.is_float())
8384 nc
.get_float(&fval
);
8385 Float_expression::export_float(exp
, fval
);
8388 else if (nc
.is_complex())
8391 nc
.get_complex(&cval
);
8392 Complex_expression::export_complex(exp
, cval
);
8398 // A trailing space lets us reliably identify the end of the number.
8399 exp
->write_c_string(" ");
8402 // Class Call_expression.
8404 // A Go function can be viewed in a couple of different ways. The
8405 // code of a Go function becomes a backend function with parameters
8406 // whose types are simply the backend representation of the Go types.
8407 // If there are multiple results, they are returned as a backend
8410 // However, when Go code refers to a function other than simply
8411 // calling it, the backend type of that function is actually a struct.
8412 // The first field of the struct points to the Go function code
8413 // (sometimes a wrapper as described below). The remaining fields
8414 // hold addresses of closed-over variables. This struct is called a
8417 // There are a few cases to consider.
8419 // A direct function call of a known function in package scope. In
8420 // this case there are no closed-over variables, and we know the name
8421 // of the function code. We can simply produce a backend call to the
8422 // function directly, and not worry about the closure.
8424 // A direct function call of a known function literal. In this case
8425 // we know the function code and we know the closure. We generate the
8426 // function code such that it expects an additional final argument of
8427 // the closure type. We pass the closure as the last argument, after
8428 // the other arguments.
8430 // An indirect function call. In this case we have a closure. We
8431 // load the pointer to the function code from the first field of the
8432 // closure. We pass the address of the closure as the last argument.
8434 // A call to a method of an interface. Type methods are always at
8435 // package scope, so we call the function directly, and don't worry
8436 // about the closure.
8438 // This means that for a function at package scope we have two cases.
8439 // One is the direct call, which has no closure. The other is the
8440 // indirect call, which does have a closure. We can't simply ignore
8441 // the closure, even though it is the last argument, because that will
8442 // fail on targets where the function pops its arguments. So when
8443 // generating a closure for a package-scope function we set the
8444 // function code pointer in the closure to point to a wrapper
8445 // function. This wrapper function accepts a final argument that
8446 // points to the closure, ignores it, and calls the real function as a
8447 // direct function call. This wrapper will normally be efficient, and
8448 // can often simply be a tail call to the real function.
8450 // We don't use GCC's static chain pointer because 1) we don't need
8451 // it; 2) GCC only permits using a static chain to call a known
8452 // function, so we can't use it for an indirect call anyhow. Since we
8453 // can't use it for an indirect call, we may as well not worry about
8454 // using it for a direct call either.
8456 // We pass the closure last rather than first because it means that
8457 // the function wrapper we put into a closure for a package-scope
8458 // function can normally just be a tail call to the real function.
8460 // For method expressions we generate a wrapper that loads the
8461 // receiver from the closure and then calls the method. This
8462 // unfortunately forces reshuffling the arguments, since there is a
8463 // new first argument, but we can't avoid reshuffling either for
8464 // method expressions or for indirect calls of package-scope
8465 // functions, and since the latter are more common we reshuffle for
8466 // method expressions.
8468 // Note that the Go code retains the Go types. The extra final
8469 // argument only appears when we convert to the backend
8475 Call_expression::do_traverse(Traverse
* traverse
)
8477 if (Expression::traverse(&this->fn_
, traverse
) == TRAVERSE_EXIT
)
8478 return TRAVERSE_EXIT
;
8479 if (this->args_
!= NULL
)
8481 if (this->args_
->traverse(traverse
) == TRAVERSE_EXIT
)
8482 return TRAVERSE_EXIT
;
8484 return TRAVERSE_CONTINUE
;
8487 // Lower a call statement.
8490 Call_expression::do_lower(Gogo
* gogo
, Named_object
* function
,
8491 Statement_inserter
* inserter
, int)
8493 Location loc
= this->location();
8495 // A type cast can look like a function call.
8496 if (this->fn_
->is_type_expression()
8497 && this->args_
!= NULL
8498 && this->args_
->size() == 1)
8499 return Expression::make_cast(this->fn_
->type(), this->args_
->front(),
8502 // Because do_type will return an error type and thus prevent future
8503 // errors, check for that case now to ensure that the error gets
8505 Function_type
* fntype
= this->get_function_type();
8508 if (!this->fn_
->type()->is_error())
8509 this->report_error(_("expected function"));
8510 return Expression::make_error(loc
);
8513 // Handle an argument which is a call to a function which returns
8514 // multiple results.
8515 if (this->args_
!= NULL
8516 && this->args_
->size() == 1
8517 && this->args_
->front()->call_expression() != NULL
)
8519 size_t rc
= this->args_
->front()->call_expression()->result_count();
8521 && ((fntype
->parameters() != NULL
8522 && (fntype
->parameters()->size() == rc
8523 || (fntype
->is_varargs()
8524 && fntype
->parameters()->size() - 1 <= rc
)))
8525 || fntype
->is_builtin()))
8527 Call_expression
* call
= this->args_
->front()->call_expression();
8528 Expression_list
* args
= new Expression_list
;
8529 for (size_t i
= 0; i
< rc
; ++i
)
8530 args
->push_back(Expression::make_call_result(call
, i
));
8531 // We can't return a new call expression here, because this
8532 // one may be referenced by Call_result expressions. We
8533 // also can't delete the old arguments, because we may still
8534 // traverse them somewhere up the call stack. FIXME.
8539 // Recognize a call to a builtin function.
8540 if (fntype
->is_builtin())
8541 return new Builtin_call_expression(gogo
, this->fn_
, this->args_
,
8542 this->is_varargs_
, loc
);
8544 // If this call returns multiple results, create a temporary
8545 // variable for each result.
8546 size_t rc
= this->result_count();
8547 if (rc
> 1 && this->results_
== NULL
)
8549 std::vector
<Temporary_statement
*>* temps
=
8550 new std::vector
<Temporary_statement
*>;
8552 const Typed_identifier_list
* results
= fntype
->results();
8553 for (Typed_identifier_list::const_iterator p
= results
->begin();
8554 p
!= results
->end();
8557 Temporary_statement
* temp
= Statement::make_temporary(p
->type(),
8559 inserter
->insert(temp
);
8560 temps
->push_back(temp
);
8562 this->results_
= temps
;
8565 // Handle a call to a varargs function by packaging up the extra
8567 if (fntype
->is_varargs())
8569 const Typed_identifier_list
* parameters
= fntype
->parameters();
8570 go_assert(parameters
!= NULL
&& !parameters
->empty());
8571 Type
* varargs_type
= parameters
->back().type();
8572 this->lower_varargs(gogo
, function
, inserter
, varargs_type
,
8573 parameters
->size());
8576 // If this is call to a method, call the method directly passing the
8577 // object as the first parameter.
8578 Bound_method_expression
* bme
= this->fn_
->bound_method_expression();
8581 Named_object
* methodfn
= bme
->function();
8582 Expression
* first_arg
= bme
->first_argument();
8584 // We always pass a pointer when calling a method.
8585 if (first_arg
->type()->points_to() == NULL
8586 && !first_arg
->type()->is_error())
8588 first_arg
= Expression::make_unary(OPERATOR_AND
, first_arg
, loc
);
8589 // We may need to create a temporary variable so that we can
8590 // take the address. We can't do that here because it will
8591 // mess up the order of evaluation.
8592 Unary_expression
* ue
= static_cast<Unary_expression
*>(first_arg
);
8593 ue
->set_create_temp();
8596 // If we are calling a method which was inherited from an
8597 // embedded struct, and the method did not get a stub, then the
8598 // first type may be wrong.
8599 Type
* fatype
= bme
->first_argument_type();
8602 if (fatype
->points_to() == NULL
)
8603 fatype
= Type::make_pointer_type(fatype
);
8604 first_arg
= Expression::make_unsafe_cast(fatype
, first_arg
, loc
);
8607 Expression_list
* new_args
= new Expression_list();
8608 new_args
->push_back(first_arg
);
8609 if (this->args_
!= NULL
)
8611 for (Expression_list::const_iterator p
= this->args_
->begin();
8612 p
!= this->args_
->end();
8614 new_args
->push_back(*p
);
8617 // We have to change in place because this structure may be
8618 // referenced by Call_result_expressions. We can't delete the
8619 // old arguments, because we may be traversing them up in some
8621 this->args_
= new_args
;
8622 this->fn_
= Expression::make_func_reference(methodfn
, NULL
,
8629 // Lower a call to a varargs function. FUNCTION is the function in
8630 // which the call occurs--it's not the function we are calling.
8631 // VARARGS_TYPE is the type of the varargs parameter, a slice type.
8632 // PARAM_COUNT is the number of parameters of the function we are
8633 // calling; the last of these parameters will be the varargs
8637 Call_expression::lower_varargs(Gogo
* gogo
, Named_object
* function
,
8638 Statement_inserter
* inserter
,
8639 Type
* varargs_type
, size_t param_count
)
8641 if (this->varargs_are_lowered_
)
8644 Location loc
= this->location();
8646 go_assert(param_count
> 0);
8647 go_assert(varargs_type
->is_slice_type());
8649 size_t arg_count
= this->args_
== NULL
? 0 : this->args_
->size();
8650 if (arg_count
< param_count
- 1)
8652 // Not enough arguments; will be caught in check_types.
8656 Expression_list
* old_args
= this->args_
;
8657 Expression_list
* new_args
= new Expression_list();
8658 bool push_empty_arg
= false;
8659 if (old_args
== NULL
|| old_args
->empty())
8661 go_assert(param_count
== 1);
8662 push_empty_arg
= true;
8666 Expression_list::const_iterator pa
;
8668 for (pa
= old_args
->begin(); pa
!= old_args
->end(); ++pa
, ++i
)
8670 if (static_cast<size_t>(i
) == param_count
)
8672 new_args
->push_back(*pa
);
8675 // We have reached the varargs parameter.
8677 bool issued_error
= false;
8678 if (pa
== old_args
->end())
8679 push_empty_arg
= true;
8680 else if (pa
+ 1 == old_args
->end() && this->is_varargs_
)
8681 new_args
->push_back(*pa
);
8682 else if (this->is_varargs_
)
8684 if ((*pa
)->type()->is_slice_type())
8685 this->report_error(_("too many arguments"));
8688 error_at(this->location(),
8689 _("invalid use of %<...%> with non-slice"));
8690 this->set_is_error();
8696 Type
* element_type
= varargs_type
->array_type()->element_type();
8697 Expression_list
* vals
= new Expression_list
;
8698 for (; pa
!= old_args
->end(); ++pa
, ++i
)
8700 // Check types here so that we get a better message.
8701 Type
* patype
= (*pa
)->type();
8702 Location paloc
= (*pa
)->location();
8703 if (!this->check_argument_type(i
, element_type
, patype
,
8704 paloc
, issued_error
))
8706 vals
->push_back(*pa
);
8709 Expression::make_slice_composite_literal(varargs_type
, vals
, loc
);
8710 gogo
->lower_expression(function
, inserter
, &val
);
8711 new_args
->push_back(val
);
8716 new_args
->push_back(Expression::make_nil(loc
));
8718 // We can't return a new call expression here, because this one may
8719 // be referenced by Call_result expressions. FIXME. We can't
8720 // delete OLD_ARGS because we may have both a Call_expression and a
8721 // Builtin_call_expression which refer to them. FIXME.
8722 this->args_
= new_args
;
8723 this->varargs_are_lowered_
= true;
8726 // Flatten a call with multiple results into a temporary.
8729 Call_expression::do_flatten(Gogo
* gogo
, Named_object
*,
8730 Statement_inserter
* inserter
)
8732 if (this->classification() == EXPRESSION_ERROR
)
8735 // Add temporary variables for all arguments that require type
8737 Function_type
* fntype
= this->get_function_type();
8740 go_assert(saw_errors());
8743 if (this->args_
!= NULL
&& !this->args_
->empty()
8744 && fntype
->parameters() != NULL
&& !fntype
->parameters()->empty())
8746 bool is_interface_method
=
8747 this->fn_
->interface_field_reference_expression() != NULL
;
8749 Expression_list
*args
= new Expression_list();
8750 Typed_identifier_list::const_iterator pp
= fntype
->parameters()->begin();
8751 Expression_list::const_iterator pa
= this->args_
->begin();
8752 if (!is_interface_method
&& fntype
->is_method())
8754 // The receiver argument.
8755 args
->push_back(*pa
);
8758 for (; pa
!= this->args_
->end(); ++pa
, ++pp
)
8760 go_assert(pp
!= fntype
->parameters()->end());
8761 if (Type::are_identical(pp
->type(), (*pa
)->type(), true, NULL
))
8762 args
->push_back(*pa
);
8765 Location loc
= (*pa
)->location();
8767 Expression::convert_for_assignment(gogo
, pp
->type(), *pa
, loc
);
8768 Temporary_statement
* temp
=
8769 Statement::make_temporary(pp
->type(), arg
, loc
);
8770 inserter
->insert(temp
);
8771 args
->push_back(Expression::make_temporary_reference(temp
, loc
));
8778 size_t rc
= this->result_count();
8779 if (rc
> 1 && this->call_temp_
== NULL
)
8781 Struct_field_list
* sfl
= new Struct_field_list();
8782 Function_type
* fntype
= this->get_function_type();
8783 const Typed_identifier_list
* results
= fntype
->results();
8784 Location loc
= this->location();
8788 for (Typed_identifier_list::const_iterator p
= results
->begin();
8789 p
!= results
->end();
8792 snprintf(buf
, sizeof buf
, "res%d", i
);
8793 sfl
->push_back(Struct_field(Typed_identifier(buf
, p
->type(), loc
)));
8796 Struct_type
* st
= Type::make_struct_type(sfl
, loc
);
8797 this->call_temp_
= Statement::make_temporary(st
, NULL
, loc
);
8798 inserter
->insert(this->call_temp_
);
8804 // Get the function type. This can return NULL in error cases.
8807 Call_expression::get_function_type() const
8809 return this->fn_
->type()->function_type();
8812 // Return the number of values which this call will return.
8815 Call_expression::result_count() const
8817 const Function_type
* fntype
= this->get_function_type();
8820 if (fntype
->results() == NULL
)
8822 return fntype
->results()->size();
8825 // Return the temporary which holds a result.
8827 Temporary_statement
*
8828 Call_expression::result(size_t i
) const
8830 if (this->results_
== NULL
|| this->results_
->size() <= i
)
8832 go_assert(saw_errors());
8835 return (*this->results_
)[i
];
8838 // Set the number of results expected from a call expression.
8841 Call_expression::set_expected_result_count(size_t count
)
8843 go_assert(this->expected_result_count_
== 0);
8844 this->expected_result_count_
= count
;
8847 // Return whether this is a call to the predeclared function recover.
8850 Call_expression::is_recover_call() const
8852 return this->do_is_recover_call();
8855 // Set the argument to the recover function.
8858 Call_expression::set_recover_arg(Expression
* arg
)
8860 this->do_set_recover_arg(arg
);
8863 // Virtual functions also implemented by Builtin_call_expression.
8866 Call_expression::do_is_recover_call() const
8872 Call_expression::do_set_recover_arg(Expression
*)
8877 // We have found an error with this call expression; return true if
8878 // we should report it.
8881 Call_expression::issue_error()
8883 if (this->issued_error_
)
8887 this->issued_error_
= true;
8895 Call_expression::do_type()
8897 if (this->type_
!= NULL
)
8901 Function_type
* fntype
= this->get_function_type();
8903 return Type::make_error_type();
8905 const Typed_identifier_list
* results
= fntype
->results();
8906 if (results
== NULL
)
8907 ret
= Type::make_void_type();
8908 else if (results
->size() == 1)
8909 ret
= results
->begin()->type();
8911 ret
= Type::make_call_multiple_result_type(this);
8918 // Determine types for a call expression. We can use the function
8919 // parameter types to set the types of the arguments.
8922 Call_expression::do_determine_type(const Type_context
*)
8924 if (!this->determining_types())
8927 this->fn_
->determine_type_no_context();
8928 Function_type
* fntype
= this->get_function_type();
8929 const Typed_identifier_list
* parameters
= NULL
;
8931 parameters
= fntype
->parameters();
8932 if (this->args_
!= NULL
)
8934 Typed_identifier_list::const_iterator pt
;
8935 if (parameters
!= NULL
)
8936 pt
= parameters
->begin();
8938 for (Expression_list::const_iterator pa
= this->args_
->begin();
8939 pa
!= this->args_
->end();
8945 // If this is a method, the first argument is the
8947 if (fntype
!= NULL
&& fntype
->is_method())
8949 Type
* rtype
= fntype
->receiver()->type();
8950 // The receiver is always passed as a pointer.
8951 if (rtype
->points_to() == NULL
)
8952 rtype
= Type::make_pointer_type(rtype
);
8953 Type_context
subcontext(rtype
, false);
8954 (*pa
)->determine_type(&subcontext
);
8959 if (parameters
!= NULL
&& pt
!= parameters
->end())
8961 Type_context
subcontext(pt
->type(), false);
8962 (*pa
)->determine_type(&subcontext
);
8966 (*pa
)->determine_type_no_context();
8971 // Called when determining types for a Call_expression. Return true
8972 // if we should go ahead, false if they have already been determined.
8975 Call_expression::determining_types()
8977 if (this->types_are_determined_
)
8981 this->types_are_determined_
= true;
8986 // Check types for parameter I.
8989 Call_expression::check_argument_type(int i
, const Type
* parameter_type
,
8990 const Type
* argument_type
,
8991 Location argument_location
,
8995 if (!Type::are_assignable(parameter_type
, argument_type
, &reason
))
9000 error_at(argument_location
, "argument %d has incompatible type", i
);
9002 error_at(argument_location
,
9003 "argument %d has incompatible type (%s)",
9006 this->set_is_error();
9015 Call_expression::do_check_types(Gogo
*)
9017 if (this->classification() == EXPRESSION_ERROR
)
9020 Function_type
* fntype
= this->get_function_type();
9023 if (!this->fn_
->type()->is_error())
9024 this->report_error(_("expected function"));
9028 if (this->expected_result_count_
!= 0
9029 && this->expected_result_count_
!= this->result_count())
9031 if (this->issue_error())
9032 this->report_error(_("function result count mismatch"));
9033 this->set_is_error();
9037 bool is_method
= fntype
->is_method();
9040 go_assert(this->args_
!= NULL
&& !this->args_
->empty());
9041 Type
* rtype
= fntype
->receiver()->type();
9042 Expression
* first_arg
= this->args_
->front();
9043 // We dereference the values since receivers are always passed
9046 if (!Type::are_assignable(rtype
->deref(), first_arg
->type()->deref(),
9050 this->report_error(_("incompatible type for receiver"));
9053 error_at(this->location(),
9054 "incompatible type for receiver (%s)",
9056 this->set_is_error();
9061 // Note that varargs was handled by the lower_varargs() method, so
9062 // we don't have to worry about it here unless something is wrong.
9063 if (this->is_varargs_
&& !this->varargs_are_lowered_
)
9065 if (!fntype
->is_varargs())
9067 error_at(this->location(),
9068 _("invalid use of %<...%> calling non-variadic function"));
9069 this->set_is_error();
9074 const Typed_identifier_list
* parameters
= fntype
->parameters();
9075 if (this->args_
== NULL
)
9077 if (parameters
!= NULL
&& !parameters
->empty())
9078 this->report_error(_("not enough arguments"));
9080 else if (parameters
== NULL
)
9082 if (!is_method
|| this->args_
->size() > 1)
9083 this->report_error(_("too many arguments"));
9085 else if (this->args_
->size() == 1
9086 && this->args_
->front()->call_expression() != NULL
9087 && this->args_
->front()->call_expression()->result_count() > 1)
9089 // This is F(G()) when G returns more than one result. If the
9090 // results can be matched to parameters, it would have been
9091 // lowered in do_lower. If we get here we know there is a
9093 if (this->args_
->front()->call_expression()->result_count()
9094 < parameters
->size())
9095 this->report_error(_("not enough arguments"));
9097 this->report_error(_("too many arguments"));
9102 Expression_list::const_iterator pa
= this->args_
->begin();
9105 for (Typed_identifier_list::const_iterator pt
= parameters
->begin();
9106 pt
!= parameters
->end();
9109 if (pa
== this->args_
->end())
9111 this->report_error(_("not enough arguments"));
9114 this->check_argument_type(i
+ 1, pt
->type(), (*pa
)->type(),
9115 (*pa
)->location(), false);
9117 if (pa
!= this->args_
->end())
9118 this->report_error(_("too many arguments"));
9122 // Return whether we have to use a temporary variable to ensure that
9123 // we evaluate this call expression in order. If the call returns no
9124 // results then it will inevitably be executed last.
9127 Call_expression::do_must_eval_in_order() const
9129 return this->result_count() > 0;
9132 // Get the function and the first argument to use when calling an
9133 // interface method.
9136 Call_expression::interface_method_function(
9137 Interface_field_reference_expression
* interface_method
,
9138 Expression
** first_arg_ptr
)
9140 *first_arg_ptr
= interface_method
->get_underlying_object();
9141 return interface_method
->get_function();
9144 // Build the call expression.
9147 Call_expression::do_get_backend(Translate_context
* context
)
9149 if (this->call_
!= NULL
)
9152 Function_type
* fntype
= this->get_function_type();
9154 return context
->backend()->error_expression();
9156 if (this->fn_
->is_error_expression())
9157 return context
->backend()->error_expression();
9159 Gogo
* gogo
= context
->gogo();
9160 Location location
= this->location();
9162 Func_expression
* func
= this->fn_
->func_expression();
9163 Interface_field_reference_expression
* interface_method
=
9164 this->fn_
->interface_field_reference_expression();
9165 const bool has_closure
= func
!= NULL
&& func
->closure() != NULL
;
9166 const bool is_interface_method
= interface_method
!= NULL
;
9168 bool has_closure_arg
;
9170 has_closure_arg
= true;
9171 else if (func
!= NULL
)
9172 has_closure_arg
= false;
9173 else if (is_interface_method
)
9174 has_closure_arg
= false;
9176 has_closure_arg
= true;
9179 std::vector
<Bexpression
*> fn_args
;
9180 if (this->args_
== NULL
|| this->args_
->empty())
9182 nargs
= is_interface_method
? 1 : 0;
9186 else if (fntype
->parameters() == NULL
|| fntype
->parameters()->empty())
9188 // Passing a receiver parameter.
9189 go_assert(!is_interface_method
9190 && fntype
->is_method()
9191 && this->args_
->size() == 1);
9194 fn_args
[0] = this->args_
->front()->get_backend(context
);
9198 const Typed_identifier_list
* params
= fntype
->parameters();
9200 nargs
= this->args_
->size();
9201 int i
= is_interface_method
? 1 : 0;
9203 fn_args
.resize(nargs
);
9205 Typed_identifier_list::const_iterator pp
= params
->begin();
9206 Expression_list::const_iterator pe
= this->args_
->begin();
9207 if (!is_interface_method
&& fntype
->is_method())
9209 fn_args
[i
] = (*pe
)->get_backend(context
);
9213 for (; pe
!= this->args_
->end(); ++pe
, ++pp
, ++i
)
9215 go_assert(pp
!= params
->end());
9217 Expression::convert_for_assignment(gogo
, pp
->type(), *pe
,
9219 fn_args
[i
] = arg
->get_backend(context
);
9221 go_assert(pp
== params
->end());
9222 go_assert(i
== nargs
);
9226 Expression
* closure
= NULL
;
9229 Named_object
* no
= func
->named_object();
9230 fn
= Expression::make_func_code_reference(no
, location
);
9232 closure
= func
->closure();
9234 else if (!is_interface_method
)
9236 closure
= this->fn_
;
9238 // The backend representation of this function type is a pointer
9239 // to a struct whose first field is the actual function to call.
9241 Type::make_pointer_type(
9242 Type::make_pointer_type(Type::make_void_type()));
9243 fn
= Expression::make_unsafe_cast(pfntype
, this->fn_
, location
);
9244 fn
= Expression::make_unary(OPERATOR_MULT
, fn
, location
);
9248 Expression
* first_arg
;
9249 fn
= this->interface_method_function(interface_method
, &first_arg
);
9250 fn_args
[0] = first_arg
->get_backend(context
);
9253 if (!has_closure_arg
)
9254 go_assert(closure
== NULL
);
9257 // Pass the closure argument by calling the function function
9258 // __go_set_closure. In the order_evaluations pass we have
9259 // ensured that if any parameters contain call expressions, they
9260 // will have been moved out to temporary variables.
9261 go_assert(closure
!= NULL
);
9262 Expression
* set_closure
=
9263 Runtime::make_call(Runtime::SET_CLOSURE
, location
, 1, closure
);
9264 fn
= Expression::make_compound(set_closure
, fn
, location
);
9267 Bexpression
* bfn
= fn
->get_backend(context
);
9269 // When not calling a named function directly, use a type conversion
9270 // in case the type of the function is a recursive type which refers
9271 // to itself. We don't do this for an interface method because 1)
9272 // an interface method never refers to itself, so we always have a
9273 // function type here; 2) we pass an extra first argument to an
9274 // interface method, so fntype is not correct.
9275 if (func
== NULL
&& !is_interface_method
)
9277 Btype
* bft
= fntype
->get_backend_fntype(gogo
);
9278 bfn
= gogo
->backend()->convert_expression(bft
, bfn
, location
);
9281 Bexpression
* call
= gogo
->backend()->call_expression(bfn
, fn_args
, location
);
9283 if (this->results_
!= NULL
)
9285 go_assert(this->call_temp_
!= NULL
);
9286 Expression
* call_ref
=
9287 Expression::make_temporary_reference(this->call_temp_
, location
);
9288 Bexpression
* bcall_ref
= call_ref
->get_backend(context
);
9289 Bstatement
* assn_stmt
=
9290 gogo
->backend()->assignment_statement(bcall_ref
, call
, location
);
9292 this->call_
= this->set_results(context
, bcall_ref
);
9294 Bexpression
* set_and_call
=
9295 gogo
->backend()->compound_expression(assn_stmt
, this->call_
,
9297 return set_and_call
;
9304 // Set the result variables if this call returns multiple results.
9307 Call_expression::set_results(Translate_context
* context
, Bexpression
* call
)
9309 Gogo
* gogo
= context
->gogo();
9311 Bexpression
* results
= NULL
;
9312 Location loc
= this->location();
9314 size_t rc
= this->result_count();
9315 for (size_t i
= 0; i
< rc
; ++i
)
9317 Temporary_statement
* temp
= this->result(i
);
9320 go_assert(saw_errors());
9321 return gogo
->backend()->error_expression();
9323 Temporary_reference_expression
* ref
=
9324 Expression::make_temporary_reference(temp
, loc
);
9325 ref
->set_is_lvalue();
9327 Bexpression
* result_ref
= ref
->get_backend(context
);
9328 Bexpression
* call_result
=
9329 gogo
->backend()->struct_field_expression(call
, i
, loc
);
9330 Bstatement
* assn_stmt
=
9331 gogo
->backend()->assignment_statement(result_ref
, call_result
, loc
);
9333 Bexpression
* result
=
9334 gogo
->backend()->compound_expression(assn_stmt
, call_result
, loc
);
9336 if (results
== NULL
)
9340 Bstatement
* expr_stmt
= gogo
->backend()->expression_statement(result
);
9342 gogo
->backend()->compound_expression(expr_stmt
, results
, loc
);
9348 // Dump ast representation for a call expressin.
9351 Call_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
9353 this->fn_
->dump_expression(ast_dump_context
);
9354 ast_dump_context
->ostream() << "(";
9356 ast_dump_context
->dump_expression_list(this->args_
);
9358 ast_dump_context
->ostream() << ") ";
9361 // Make a call expression.
9364 Expression::make_call(Expression
* fn
, Expression_list
* args
, bool is_varargs
,
9367 return new Call_expression(fn
, args
, is_varargs
, location
);
9370 // A single result from a call which returns multiple results.
9372 class Call_result_expression
: public Expression
9375 Call_result_expression(Call_expression
* call
, unsigned int index
)
9376 : Expression(EXPRESSION_CALL_RESULT
, call
->location()),
9377 call_(call
), index_(index
)
9382 do_traverse(Traverse
*);
9388 do_determine_type(const Type_context
*);
9391 do_check_types(Gogo
*);
9396 return new Call_result_expression(this->call_
->call_expression(),
9401 do_must_eval_in_order() const
9405 do_get_backend(Translate_context
*);
9408 do_dump_expression(Ast_dump_context
*) const;
9411 // The underlying call expression.
9413 // Which result we want.
9414 unsigned int index_
;
9417 // Traverse a call result.
9420 Call_result_expression::do_traverse(Traverse
* traverse
)
9422 if (traverse
->remember_expression(this->call_
))
9424 // We have already traversed the call expression.
9425 return TRAVERSE_CONTINUE
;
9427 return Expression::traverse(&this->call_
, traverse
);
9433 Call_result_expression::do_type()
9435 if (this->classification() == EXPRESSION_ERROR
)
9436 return Type::make_error_type();
9438 // THIS->CALL_ can be replaced with a temporary reference due to
9439 // Call_expression::do_must_eval_in_order when there is an error.
9440 Call_expression
* ce
= this->call_
->call_expression();
9443 this->set_is_error();
9444 return Type::make_error_type();
9446 Function_type
* fntype
= ce
->get_function_type();
9449 if (ce
->issue_error())
9451 if (!ce
->fn()->type()->is_error())
9452 this->report_error(_("expected function"));
9454 this->set_is_error();
9455 return Type::make_error_type();
9457 const Typed_identifier_list
* results
= fntype
->results();
9458 if (results
== NULL
|| results
->size() < 2)
9460 if (ce
->issue_error())
9461 this->report_error(_("number of results does not match "
9462 "number of values"));
9463 return Type::make_error_type();
9465 Typed_identifier_list::const_iterator pr
= results
->begin();
9466 for (unsigned int i
= 0; i
< this->index_
; ++i
)
9468 if (pr
== results
->end())
9472 if (pr
== results
->end())
9474 if (ce
->issue_error())
9475 this->report_error(_("number of results does not match "
9476 "number of values"));
9477 return Type::make_error_type();
9482 // Check the type. Just make sure that we trigger the warning in
9486 Call_result_expression::do_check_types(Gogo
*)
9491 // Determine the type. We have nothing to do here, but the 0 result
9492 // needs to pass down to the caller.
9495 Call_result_expression::do_determine_type(const Type_context
*)
9497 this->call_
->determine_type_no_context();
9500 // Return the backend representation. We just refer to the temporary set by the
9501 // call expression. We don't do this at lowering time because it makes it
9502 // hard to evaluate the call at the right time.
9505 Call_result_expression::do_get_backend(Translate_context
* context
)
9507 Call_expression
* ce
= this->call_
->call_expression();
9510 go_assert(this->call_
->is_error_expression());
9511 return context
->backend()->error_expression();
9513 Temporary_statement
* ts
= ce
->result(this->index_
);
9516 go_assert(saw_errors());
9517 return context
->backend()->error_expression();
9519 Expression
* ref
= Expression::make_temporary_reference(ts
, this->location());
9520 return ref
->get_backend(context
);
9523 // Dump ast representation for a call result expression.
9526 Call_result_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
9529 // FIXME: Wouldn't it be better if the call is assigned to a temporary
9530 // (struct) and the fields are referenced instead.
9531 ast_dump_context
->ostream() << this->index_
<< "@(";
9532 ast_dump_context
->dump_expression(this->call_
);
9533 ast_dump_context
->ostream() << ")";
9536 // Make a reference to a single result of a call which returns
9537 // multiple results.
9540 Expression::make_call_result(Call_expression
* call
, unsigned int index
)
9542 return new Call_result_expression(call
, index
);
9545 // Class Index_expression.
9550 Index_expression::do_traverse(Traverse
* traverse
)
9552 if (Expression::traverse(&this->left_
, traverse
) == TRAVERSE_EXIT
9553 || Expression::traverse(&this->start_
, traverse
) == TRAVERSE_EXIT
9554 || (this->end_
!= NULL
9555 && Expression::traverse(&this->end_
, traverse
) == TRAVERSE_EXIT
)
9556 || (this->cap_
!= NULL
9557 && Expression::traverse(&this->cap_
, traverse
) == TRAVERSE_EXIT
))
9558 return TRAVERSE_EXIT
;
9559 return TRAVERSE_CONTINUE
;
9562 // Lower an index expression. This converts the generic index
9563 // expression into an array index, a string index, or a map index.
9566 Index_expression::do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int)
9568 Location location
= this->location();
9569 Expression
* left
= this->left_
;
9570 Expression
* start
= this->start_
;
9571 Expression
* end
= this->end_
;
9572 Expression
* cap
= this->cap_
;
9574 Type
* type
= left
->type();
9575 if (type
->is_error())
9577 go_assert(saw_errors());
9578 return Expression::make_error(location
);
9580 else if (left
->is_type_expression())
9582 error_at(location
, "attempt to index type expression");
9583 return Expression::make_error(location
);
9585 else if (type
->array_type() != NULL
)
9586 return Expression::make_array_index(left
, start
, end
, cap
, location
);
9587 else if (type
->points_to() != NULL
9588 && type
->points_to()->array_type() != NULL
9589 && !type
->points_to()->is_slice_type())
9591 Expression
* deref
= Expression::make_unary(OPERATOR_MULT
, left
,
9594 // For an ordinary index into the array, the pointer will be
9595 // dereferenced. For a slice it will not--the resulting slice
9596 // will simply reuse the pointer, which is incorrect if that
9598 if (end
!= NULL
|| cap
!= NULL
)
9599 deref
->issue_nil_check();
9601 return Expression::make_array_index(deref
, start
, end
, cap
, location
);
9603 else if (type
->is_string_type())
9607 error_at(location
, "invalid 3-index slice of string");
9608 return Expression::make_error(location
);
9610 return Expression::make_string_index(left
, start
, end
, location
);
9612 else if (type
->map_type() != NULL
)
9614 if (end
!= NULL
|| cap
!= NULL
)
9616 error_at(location
, "invalid slice of map");
9617 return Expression::make_error(location
);
9619 Map_index_expression
* ret
= Expression::make_map_index(left
, start
,
9621 if (this->is_lvalue_
)
9622 ret
->set_is_lvalue();
9628 "attempt to index object which is not array, string, or map");
9629 return Expression::make_error(location
);
9633 // Write an indexed expression
9634 // (expr[expr:expr:expr], expr[expr:expr] or expr[expr]) to a dump context.
9637 Index_expression::dump_index_expression(Ast_dump_context
* ast_dump_context
,
9638 const Expression
* expr
,
9639 const Expression
* start
,
9640 const Expression
* end
,
9641 const Expression
* cap
)
9643 expr
->dump_expression(ast_dump_context
);
9644 ast_dump_context
->ostream() << "[";
9645 start
->dump_expression(ast_dump_context
);
9648 ast_dump_context
->ostream() << ":";
9649 end
->dump_expression(ast_dump_context
);
9653 ast_dump_context
->ostream() << ":";
9654 cap
->dump_expression(ast_dump_context
);
9656 ast_dump_context
->ostream() << "]";
9659 // Dump ast representation for an index expression.
9662 Index_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
9665 Index_expression::dump_index_expression(ast_dump_context
, this->left_
,
9666 this->start_
, this->end_
, this->cap_
);
9669 // Make an index expression.
9672 Expression::make_index(Expression
* left
, Expression
* start
, Expression
* end
,
9673 Expression
* cap
, Location location
)
9675 return new Index_expression(left
, start
, end
, cap
, location
);
9678 // An array index. This is used for both indexing and slicing.
9680 class Array_index_expression
: public Expression
9683 Array_index_expression(Expression
* array
, Expression
* start
,
9684 Expression
* end
, Expression
* cap
, Location location
)
9685 : Expression(EXPRESSION_ARRAY_INDEX
, location
),
9686 array_(array
), start_(start
), end_(end
), cap_(cap
), type_(NULL
)
9691 do_traverse(Traverse
*);
9694 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
9700 do_determine_type(const Type_context
*);
9703 do_check_types(Gogo
*);
9708 return Expression::make_array_index(this->array_
->copy(),
9709 this->start_
->copy(),
9712 : this->end_
->copy()),
9715 : this->cap_
->copy()),
9720 do_must_eval_subexpressions_in_order(int* skip
) const
9727 do_is_addressable() const;
9730 do_address_taken(bool escapes
)
9731 { this->array_
->address_taken(escapes
); }
9734 do_issue_nil_check()
9735 { this->array_
->issue_nil_check(); }
9738 do_get_backend(Translate_context
*);
9741 do_dump_expression(Ast_dump_context
*) const;
9744 // The array we are getting a value from.
9746 // The start or only index.
9748 // The end index of a slice. This may be NULL for a simple array
9749 // index, or it may be a nil expression for the length of the array.
9751 // The capacity argument of a slice. This may be NULL for an array index or
9754 // The type of the expression.
9758 // Array index traversal.
9761 Array_index_expression::do_traverse(Traverse
* traverse
)
9763 if (Expression::traverse(&this->array_
, traverse
) == TRAVERSE_EXIT
)
9764 return TRAVERSE_EXIT
;
9765 if (Expression::traverse(&this->start_
, traverse
) == TRAVERSE_EXIT
)
9766 return TRAVERSE_EXIT
;
9767 if (this->end_
!= NULL
)
9769 if (Expression::traverse(&this->end_
, traverse
) == TRAVERSE_EXIT
)
9770 return TRAVERSE_EXIT
;
9772 if (this->cap_
!= NULL
)
9774 if (Expression::traverse(&this->cap_
, traverse
) == TRAVERSE_EXIT
)
9775 return TRAVERSE_EXIT
;
9777 return TRAVERSE_CONTINUE
;
9780 // Return the type of an array index.
9783 Array_index_expression::do_type()
9785 if (this->type_
== NULL
)
9787 Array_type
* type
= this->array_
->type()->array_type();
9789 this->type_
= Type::make_error_type();
9790 else if (this->end_
== NULL
)
9791 this->type_
= type
->element_type();
9792 else if (type
->is_slice_type())
9794 // A slice of a slice has the same type as the original
9796 this->type_
= this->array_
->type()->deref();
9800 // A slice of an array is a slice.
9801 this->type_
= Type::make_array_type(type
->element_type(), NULL
);
9807 // Set the type of an array index.
9810 Array_index_expression::do_determine_type(const Type_context
*)
9812 this->array_
->determine_type_no_context();
9813 this->start_
->determine_type_no_context();
9814 if (this->end_
!= NULL
)
9815 this->end_
->determine_type_no_context();
9816 if (this->cap_
!= NULL
)
9817 this->cap_
->determine_type_no_context();
9820 // Check types of an array index.
9823 Array_index_expression::do_check_types(Gogo
*)
9825 Numeric_constant nc
;
9827 if (this->start_
->type()->integer_type() == NULL
9828 && !this->start_
->type()->is_error()
9829 && (!this->start_
->numeric_constant_value(&nc
)
9830 || nc
.to_unsigned_long(&v
) == Numeric_constant::NC_UL_NOTINT
))
9831 this->report_error(_("index must be integer"));
9832 if (this->end_
!= NULL
9833 && this->end_
->type()->integer_type() == NULL
9834 && !this->end_
->type()->is_error()
9835 && !this->end_
->is_nil_expression()
9836 && !this->end_
->is_error_expression()
9837 && (!this->end_
->numeric_constant_value(&nc
)
9838 || nc
.to_unsigned_long(&v
) == Numeric_constant::NC_UL_NOTINT
))
9839 this->report_error(_("slice end must be integer"));
9840 if (this->cap_
!= NULL
9841 && this->cap_
->type()->integer_type() == NULL
9842 && !this->cap_
->type()->is_error()
9843 && !this->cap_
->is_nil_expression()
9844 && !this->cap_
->is_error_expression()
9845 && (!this->cap_
->numeric_constant_value(&nc
)
9846 || nc
.to_unsigned_long(&v
) == Numeric_constant::NC_UL_NOTINT
))
9847 this->report_error(_("slice capacity must be integer"));
9849 Array_type
* array_type
= this->array_
->type()->array_type();
9850 if (array_type
== NULL
)
9852 go_assert(this->array_
->type()->is_error());
9856 unsigned int int_bits
=
9857 Type::lookup_integer_type("int")->integer_type()->bits();
9859 Numeric_constant lvalnc
;
9861 bool lval_valid
= (array_type
->length() != NULL
9862 && array_type
->length()->numeric_constant_value(&lvalnc
)
9863 && lvalnc
.to_int(&lval
));
9864 Numeric_constant inc
;
9866 bool ival_valid
= false;
9867 if (this->start_
->numeric_constant_value(&inc
) && inc
.to_int(&ival
))
9870 if (mpz_sgn(ival
) < 0
9871 || mpz_sizeinbase(ival
, 2) >= int_bits
9873 && (this->end_
== NULL
9874 ? mpz_cmp(ival
, lval
) >= 0
9875 : mpz_cmp(ival
, lval
) > 0)))
9877 error_at(this->start_
->location(), "array index out of bounds");
9878 this->set_is_error();
9881 if (this->end_
!= NULL
&& !this->end_
->is_nil_expression())
9883 Numeric_constant enc
;
9885 bool eval_valid
= false;
9886 if (this->end_
->numeric_constant_value(&enc
) && enc
.to_int(&eval
))
9889 if (mpz_sgn(eval
) < 0
9890 || mpz_sizeinbase(eval
, 2) >= int_bits
9891 || (lval_valid
&& mpz_cmp(eval
, lval
) > 0))
9893 error_at(this->end_
->location(), "array index out of bounds");
9894 this->set_is_error();
9896 else if (ival_valid
&& mpz_cmp(ival
, eval
) > 0)
9897 this->report_error(_("inverted slice range"));
9900 Numeric_constant cnc
;
9902 if (this->cap_
!= NULL
9903 && this->cap_
->numeric_constant_value(&cnc
) && cnc
.to_int(&cval
))
9905 if (mpz_sgn(cval
) < 0
9906 || mpz_sizeinbase(cval
, 2) >= int_bits
9907 || (lval_valid
&& mpz_cmp(cval
, lval
) > 0))
9909 error_at(this->cap_
->location(), "array index out of bounds");
9910 this->set_is_error();
9912 else if (ival_valid
&& mpz_cmp(ival
, cval
) > 0)
9914 error_at(this->cap_
->location(),
9915 "invalid slice index: capacity less than start");
9916 this->set_is_error();
9918 else if (eval_valid
&& mpz_cmp(eval
, cval
) > 0)
9920 error_at(this->cap_
->location(),
9921 "invalid slice index: capacity less than length");
9922 this->set_is_error();
9935 // A slice of an array requires an addressable array. A slice of a
9936 // slice is always possible.
9937 if (this->end_
!= NULL
&& !array_type
->is_slice_type())
9939 if (!this->array_
->is_addressable())
9940 this->report_error(_("slice of unaddressable value"));
9942 this->array_
->address_taken(true);
9946 // Flatten array indexing by using temporary variables for slices and indexes.
9949 Array_index_expression::do_flatten(Gogo
*, Named_object
*,
9950 Statement_inserter
* inserter
)
9952 Location loc
= this->location();
9953 Temporary_statement
* temp
;
9954 if (this->array_
->type()->is_slice_type() && !this->array_
->is_variable())
9956 temp
= Statement::make_temporary(NULL
, this->array_
, loc
);
9957 inserter
->insert(temp
);
9958 this->array_
= Expression::make_temporary_reference(temp
, loc
);
9960 if (!this->start_
->is_variable())
9962 temp
= Statement::make_temporary(NULL
, this->start_
, loc
);
9963 inserter
->insert(temp
);
9964 this->start_
= Expression::make_temporary_reference(temp
, loc
);
9966 if (this->end_
!= NULL
9967 && !this->end_
->is_nil_expression()
9968 && !this->end_
->is_variable())
9970 temp
= Statement::make_temporary(NULL
, this->end_
, loc
);
9971 inserter
->insert(temp
);
9972 this->end_
= Expression::make_temporary_reference(temp
, loc
);
9974 if (this->cap_
!= NULL
&& !this->cap_
->is_variable())
9976 temp
= Statement::make_temporary(NULL
, this->cap_
, loc
);
9977 inserter
->insert(temp
);
9978 this->cap_
= Expression::make_temporary_reference(temp
, loc
);
9984 // Return whether this expression is addressable.
9987 Array_index_expression::do_is_addressable() const
9989 // A slice expression is not addressable.
9990 if (this->end_
!= NULL
)
9993 // An index into a slice is addressable.
9994 if (this->array_
->type()->is_slice_type())
9997 // An index into an array is addressable if the array is
9999 return this->array_
->is_addressable();
10002 // Get the backend representation for an array index.
10005 Array_index_expression::do_get_backend(Translate_context
* context
)
10007 Array_type
* array_type
= this->array_
->type()->array_type();
10008 if (array_type
== NULL
)
10010 go_assert(this->array_
->type()->is_error());
10011 return context
->backend()->error_expression();
10013 go_assert(!array_type
->is_slice_type() || this->array_
->is_variable());
10015 Location loc
= this->location();
10016 Gogo
* gogo
= context
->gogo();
10018 Type
* int_type
= Type::lookup_integer_type("int");
10019 Btype
* int_btype
= int_type
->get_backend(gogo
);
10021 // We need to convert the length and capacity to the Go "int" type here
10022 // because the length of a fixed-length array could be of type "uintptr"
10023 // and gimple disallows binary operations between "uintptr" and other
10024 // integer types. FIXME.
10025 Bexpression
* length
= NULL
;
10026 if (this->end_
== NULL
|| this->end_
->is_nil_expression())
10028 Expression
* len
= array_type
->get_length(gogo
, this->array_
);
10029 length
= len
->get_backend(context
);
10030 length
= gogo
->backend()->convert_expression(int_btype
, length
, loc
);
10033 Bexpression
* capacity
= NULL
;
10034 if (this->end_
!= NULL
)
10036 Expression
* cap
= array_type
->get_capacity(gogo
, this->array_
);
10037 capacity
= cap
->get_backend(context
);
10038 capacity
= gogo
->backend()->convert_expression(int_btype
, capacity
, loc
);
10041 Bexpression
* cap_arg
= capacity
;
10042 if (this->cap_
!= NULL
)
10044 cap_arg
= this->cap_
->get_backend(context
);
10045 cap_arg
= gogo
->backend()->convert_expression(int_btype
, cap_arg
, loc
);
10048 if (length
== NULL
)
10051 int code
= (array_type
->length() != NULL
10052 ? (this->end_
== NULL
10053 ? RUNTIME_ERROR_ARRAY_INDEX_OUT_OF_BOUNDS
10054 : RUNTIME_ERROR_ARRAY_SLICE_OUT_OF_BOUNDS
)
10055 : (this->end_
== NULL
10056 ? RUNTIME_ERROR_SLICE_INDEX_OUT_OF_BOUNDS
10057 : RUNTIME_ERROR_SLICE_SLICE_OUT_OF_BOUNDS
));
10058 Bexpression
* crash
= gogo
->runtime_error(code
, loc
)->get_backend(context
);
10060 if (this->start_
->type()->integer_type() == NULL
10061 && !Type::are_convertible(int_type
, this->start_
->type(), NULL
))
10063 go_assert(saw_errors());
10064 return context
->backend()->error_expression();
10067 Bexpression
* bad_index
=
10068 Expression::check_bounds(this->start_
, loc
)->get_backend(context
);
10070 Bexpression
* start
= this->start_
->get_backend(context
);
10071 start
= gogo
->backend()->convert_expression(int_btype
, start
, loc
);
10072 Bexpression
* start_too_large
=
10073 gogo
->backend()->binary_expression((this->end_
== NULL
10077 (this->end_
== NULL
10081 bad_index
= gogo
->backend()->binary_expression(OPERATOR_OROR
, start_too_large
,
10084 if (this->end_
== NULL
)
10086 // Simple array indexing. This has to return an l-value, so
10087 // wrap the index check into START.
10089 gogo
->backend()->conditional_expression(int_btype
, bad_index
,
10090 crash
, start
, loc
);
10093 if (array_type
->length() != NULL
)
10095 Bexpression
* array
= this->array_
->get_backend(context
);
10096 ret
= gogo
->backend()->array_index_expression(array
, start
, loc
);
10101 Expression
* valptr
=
10102 array_type
->get_value_pointer(gogo
, this->array_
);
10103 Bexpression
* ptr
= valptr
->get_backend(context
);
10104 ptr
= gogo
->backend()->pointer_offset_expression(ptr
, start
, loc
);
10106 Type
* ele_type
= this->array_
->type()->array_type()->element_type();
10107 Btype
* ele_btype
= ele_type
->get_backend(gogo
);
10108 ret
= gogo
->backend()->indirect_expression(ele_btype
, ptr
, true, loc
);
10115 if (this->cap_
!= NULL
)
10117 Bexpression
* bounds_bcheck
=
10118 Expression::check_bounds(this->cap_
, loc
)->get_backend(context
);
10120 gogo
->backend()->binary_expression(OPERATOR_OROR
, bounds_bcheck
,
10122 cap_arg
= gogo
->backend()->convert_expression(int_btype
, cap_arg
, loc
);
10124 Bexpression
* cap_too_small
=
10125 gogo
->backend()->binary_expression(OPERATOR_LT
, cap_arg
, start
, loc
);
10126 Bexpression
* cap_too_large
=
10127 gogo
->backend()->binary_expression(OPERATOR_GT
, cap_arg
, capacity
, loc
);
10128 Bexpression
* bad_cap
=
10129 gogo
->backend()->binary_expression(OPERATOR_OROR
, cap_too_small
,
10130 cap_too_large
, loc
);
10131 bad_index
= gogo
->backend()->binary_expression(OPERATOR_OROR
, bad_cap
,
10136 if (this->end_
->is_nil_expression())
10140 Bexpression
* bounds_bcheck
=
10141 Expression::check_bounds(this->end_
, loc
)->get_backend(context
);
10144 gogo
->backend()->binary_expression(OPERATOR_OROR
, bounds_bcheck
,
10147 end
= this->end_
->get_backend(context
);
10148 end
= gogo
->backend()->convert_expression(int_btype
, end
, loc
);
10149 Bexpression
* end_too_small
=
10150 gogo
->backend()->binary_expression(OPERATOR_LT
, end
, start
, loc
);
10151 Bexpression
* end_too_large
=
10152 gogo
->backend()->binary_expression(OPERATOR_GT
, end
, cap_arg
, loc
);
10153 Bexpression
* bad_end
=
10154 gogo
->backend()->binary_expression(OPERATOR_OROR
, end_too_small
,
10155 end_too_large
, loc
);
10156 bad_index
= gogo
->backend()->binary_expression(OPERATOR_OROR
, bad_end
,
10160 Expression
* valptr
= array_type
->get_value_pointer(gogo
, this->array_
);
10161 Bexpression
* val
= valptr
->get_backend(context
);
10162 val
= gogo
->backend()->pointer_offset_expression(val
, start
, loc
);
10164 Bexpression
* result_length
=
10165 gogo
->backend()->binary_expression(OPERATOR_MINUS
, end
, start
, loc
);
10167 Bexpression
* result_capacity
=
10168 gogo
->backend()->binary_expression(OPERATOR_MINUS
, cap_arg
, start
, loc
);
10170 Btype
* struct_btype
= this->type()->get_backend(gogo
);
10171 std::vector
<Bexpression
*> init
;
10172 init
.push_back(val
);
10173 init
.push_back(result_length
);
10174 init
.push_back(result_capacity
);
10176 Bexpression
* ctor
=
10177 gogo
->backend()->constructor_expression(struct_btype
, init
, loc
);
10178 return gogo
->backend()->conditional_expression(struct_btype
, bad_index
,
10182 // Dump ast representation for an array index expression.
10185 Array_index_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
10188 Index_expression::dump_index_expression(ast_dump_context
, this->array_
,
10189 this->start_
, this->end_
, this->cap_
);
10192 // Make an array index expression. END and CAP may be NULL.
10195 Expression::make_array_index(Expression
* array
, Expression
* start
,
10196 Expression
* end
, Expression
* cap
,
10199 return new Array_index_expression(array
, start
, end
, cap
, location
);
10202 // A string index. This is used for both indexing and slicing.
10204 class String_index_expression
: public Expression
10207 String_index_expression(Expression
* string
, Expression
* start
,
10208 Expression
* end
, Location location
)
10209 : Expression(EXPRESSION_STRING_INDEX
, location
),
10210 string_(string
), start_(start
), end_(end
)
10215 do_traverse(Traverse
*);
10218 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
10224 do_determine_type(const Type_context
*);
10227 do_check_types(Gogo
*);
10232 return Expression::make_string_index(this->string_
->copy(),
10233 this->start_
->copy(),
10234 (this->end_
== NULL
10236 : this->end_
->copy()),
10241 do_must_eval_subexpressions_in_order(int* skip
) const
10248 do_get_backend(Translate_context
*);
10251 do_dump_expression(Ast_dump_context
*) const;
10254 // The string we are getting a value from.
10255 Expression
* string_
;
10256 // The start or only index.
10257 Expression
* start_
;
10258 // The end index of a slice. This may be NULL for a single index,
10259 // or it may be a nil expression for the length of the string.
10263 // String index traversal.
10266 String_index_expression::do_traverse(Traverse
* traverse
)
10268 if (Expression::traverse(&this->string_
, traverse
) == TRAVERSE_EXIT
)
10269 return TRAVERSE_EXIT
;
10270 if (Expression::traverse(&this->start_
, traverse
) == TRAVERSE_EXIT
)
10271 return TRAVERSE_EXIT
;
10272 if (this->end_
!= NULL
)
10274 if (Expression::traverse(&this->end_
, traverse
) == TRAVERSE_EXIT
)
10275 return TRAVERSE_EXIT
;
10277 return TRAVERSE_CONTINUE
;
10281 String_index_expression::do_flatten(Gogo
*, Named_object
*,
10282 Statement_inserter
* inserter
)
10284 Temporary_statement
* temp
;
10285 Location loc
= this->location();
10286 if (!this->string_
->is_variable())
10288 temp
= Statement::make_temporary(NULL
, this->string_
, loc
);
10289 inserter
->insert(temp
);
10290 this->string_
= Expression::make_temporary_reference(temp
, loc
);
10292 if (!this->start_
->is_variable())
10294 temp
= Statement::make_temporary(NULL
, this->start_
, loc
);
10295 inserter
->insert(temp
);
10296 this->start_
= Expression::make_temporary_reference(temp
, loc
);
10298 if (this->end_
!= NULL
10299 && !this->end_
->is_nil_expression()
10300 && !this->end_
->is_variable())
10302 temp
= Statement::make_temporary(NULL
, this->end_
, loc
);
10303 inserter
->insert(temp
);
10304 this->end_
= Expression::make_temporary_reference(temp
, loc
);
10310 // Return the type of a string index.
10313 String_index_expression::do_type()
10315 if (this->end_
== NULL
)
10316 return Type::lookup_integer_type("uint8");
10318 return this->string_
->type();
10321 // Determine the type of a string index.
10324 String_index_expression::do_determine_type(const Type_context
*)
10326 this->string_
->determine_type_no_context();
10327 this->start_
->determine_type_no_context();
10328 if (this->end_
!= NULL
)
10329 this->end_
->determine_type_no_context();
10332 // Check types of a string index.
10335 String_index_expression::do_check_types(Gogo
*)
10337 Numeric_constant nc
;
10339 if (this->start_
->type()->integer_type() == NULL
10340 && !this->start_
->type()->is_error()
10341 && (!this->start_
->numeric_constant_value(&nc
)
10342 || nc
.to_unsigned_long(&v
) == Numeric_constant::NC_UL_NOTINT
))
10343 this->report_error(_("index must be integer"));
10344 if (this->end_
!= NULL
10345 && this->end_
->type()->integer_type() == NULL
10346 && !this->end_
->type()->is_error()
10347 && !this->end_
->is_nil_expression()
10348 && !this->end_
->is_error_expression()
10349 && (!this->end_
->numeric_constant_value(&nc
)
10350 || nc
.to_unsigned_long(&v
) == Numeric_constant::NC_UL_NOTINT
))
10351 this->report_error(_("slice end must be integer"));
10354 bool sval_valid
= this->string_
->string_constant_value(&sval
);
10356 Numeric_constant inc
;
10358 bool ival_valid
= false;
10359 if (this->start_
->numeric_constant_value(&inc
) && inc
.to_int(&ival
))
10362 if (mpz_sgn(ival
) < 0
10363 || (sval_valid
&& mpz_cmp_ui(ival
, sval
.length()) >= 0))
10365 error_at(this->start_
->location(), "string index out of bounds");
10366 this->set_is_error();
10369 if (this->end_
!= NULL
&& !this->end_
->is_nil_expression())
10371 Numeric_constant enc
;
10373 if (this->end_
->numeric_constant_value(&enc
) && enc
.to_int(&eval
))
10375 if (mpz_sgn(eval
) < 0
10376 || (sval_valid
&& mpz_cmp_ui(eval
, sval
.length()) > 0))
10378 error_at(this->end_
->location(), "string index out of bounds");
10379 this->set_is_error();
10381 else if (ival_valid
&& mpz_cmp(ival
, eval
) > 0)
10382 this->report_error(_("inverted slice range"));
10390 // Get the backend representation for a string index.
10393 String_index_expression::do_get_backend(Translate_context
* context
)
10395 Location loc
= this->location();
10396 Expression
* string_arg
= this->string_
;
10397 if (this->string_
->type()->points_to() != NULL
)
10398 string_arg
= Expression::make_unary(OPERATOR_MULT
, this->string_
, loc
);
10400 Expression
* bad_index
= Expression::check_bounds(this->start_
, loc
);
10402 int code
= (this->end_
== NULL
10403 ? RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
10404 : RUNTIME_ERROR_STRING_SLICE_OUT_OF_BOUNDS
);
10406 Gogo
* gogo
= context
->gogo();
10407 Bexpression
* crash
= gogo
->runtime_error(code
, loc
)->get_backend(context
);
10409 Type
* int_type
= Type::lookup_integer_type("int");
10411 // It is possible that an error occurred earlier because the start index
10412 // cannot be represented as an integer type. In this case, we shouldn't
10413 // try casting the starting index into an integer since
10414 // Type_conversion_expression will fail to get the backend representation.
10416 if (this->start_
->type()->integer_type() == NULL
10417 && !Type::are_convertible(int_type
, this->start_
->type(), NULL
))
10419 go_assert(saw_errors());
10420 return context
->backend()->error_expression();
10423 Expression
* start
= Expression::make_cast(int_type
, this->start_
, loc
);
10425 if (this->end_
== NULL
)
10427 Expression
* length
=
10428 Expression::make_string_info(this->string_
, STRING_INFO_LENGTH
, loc
);
10430 Expression
* start_too_large
=
10431 Expression::make_binary(OPERATOR_GE
, start
, length
, loc
);
10432 bad_index
= Expression::make_binary(OPERATOR_OROR
, start_too_large
,
10434 Expression
* bytes
=
10435 Expression::make_string_info(this->string_
, STRING_INFO_DATA
, loc
);
10437 Bexpression
* bstart
= start
->get_backend(context
);
10438 Bexpression
* ptr
= bytes
->get_backend(context
);
10439 ptr
= gogo
->backend()->pointer_offset_expression(ptr
, bstart
, loc
);
10440 Btype
* ubtype
= Type::lookup_integer_type("uint8")->get_backend(gogo
);
10441 Bexpression
* index
=
10442 gogo
->backend()->indirect_expression(ubtype
, ptr
, true, loc
);
10444 Btype
* byte_btype
= bytes
->type()->points_to()->get_backend(gogo
);
10445 Bexpression
* index_error
= bad_index
->get_backend(context
);
10446 return gogo
->backend()->conditional_expression(byte_btype
, index_error
,
10447 crash
, index
, loc
);
10450 Expression
* end
= NULL
;
10451 if (this->end_
->is_nil_expression())
10452 end
= Expression::make_integer_sl(-1, int_type
, loc
);
10455 Expression
* bounds_check
= Expression::check_bounds(this->end_
, loc
);
10457 Expression::make_binary(OPERATOR_OROR
, bounds_check
, bad_index
, loc
);
10458 end
= Expression::make_cast(int_type
, this->end_
, loc
);
10461 Expression
* strslice
= Runtime::make_call(Runtime::STRING_SLICE
, loc
, 3,
10462 string_arg
, start
, end
);
10463 Bexpression
* bstrslice
= strslice
->get_backend(context
);
10465 Btype
* str_btype
= strslice
->type()->get_backend(gogo
);
10466 Bexpression
* index_error
= bad_index
->get_backend(context
);
10467 return gogo
->backend()->conditional_expression(str_btype
, index_error
,
10468 crash
, bstrslice
, loc
);
10471 // Dump ast representation for a string index expression.
10474 String_index_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
10477 Index_expression::dump_index_expression(ast_dump_context
, this->string_
,
10478 this->start_
, this->end_
, NULL
);
10481 // Make a string index expression. END may be NULL.
10484 Expression::make_string_index(Expression
* string
, Expression
* start
,
10485 Expression
* end
, Location location
)
10487 return new String_index_expression(string
, start
, end
, location
);
10490 // Class Map_index.
10492 // Get the type of the map.
10495 Map_index_expression::get_map_type() const
10497 Map_type
* mt
= this->map_
->type()->deref()->map_type();
10499 go_assert(saw_errors());
10503 // Map index traversal.
10506 Map_index_expression::do_traverse(Traverse
* traverse
)
10508 if (Expression::traverse(&this->map_
, traverse
) == TRAVERSE_EXIT
)
10509 return TRAVERSE_EXIT
;
10510 return Expression::traverse(&this->index_
, traverse
);
10513 // We need to pass in a pointer to the key, so flatten the index into a
10514 // temporary variable if it isn't already. The value pointer will be
10515 // dereferenced and checked for nil, so flatten into a temporary to avoid
10519 Map_index_expression::do_flatten(Gogo
*, Named_object
*,
10520 Statement_inserter
* inserter
)
10522 Map_type
* mt
= this->get_map_type();
10523 if (this->index_
->type() != mt
->key_type())
10524 this->index_
= Expression::make_cast(mt
->key_type(), this->index_
,
10527 if (!this->index_
->is_variable())
10529 Temporary_statement
* temp
= Statement::make_temporary(NULL
, this->index_
,
10531 inserter
->insert(temp
);
10532 this->index_
= Expression::make_temporary_reference(temp
,
10536 if (this->value_pointer_
== NULL
)
10537 this->get_value_pointer(this->is_lvalue_
);
10538 if (!this->value_pointer_
->is_variable())
10540 Temporary_statement
* temp
=
10541 Statement::make_temporary(NULL
, this->value_pointer_
,
10543 inserter
->insert(temp
);
10544 this->value_pointer_
=
10545 Expression::make_temporary_reference(temp
, this->location());
10551 // Return the type of a map index.
10554 Map_index_expression::do_type()
10556 Map_type
* mt
= this->get_map_type();
10558 return Type::make_error_type();
10559 Type
* type
= mt
->val_type();
10560 // If this map index is in a tuple assignment, we actually return a
10561 // pointer to the value type. Tuple_map_assignment_statement is
10562 // responsible for handling this correctly. We need to get the type
10563 // right in case this gets assigned to a temporary variable.
10564 if (this->is_in_tuple_assignment_
)
10565 type
= Type::make_pointer_type(type
);
10569 // Fix the type of a map index.
10572 Map_index_expression::do_determine_type(const Type_context
*)
10574 this->map_
->determine_type_no_context();
10575 Map_type
* mt
= this->get_map_type();
10576 Type
* key_type
= mt
== NULL
? NULL
: mt
->key_type();
10577 Type_context
subcontext(key_type
, false);
10578 this->index_
->determine_type(&subcontext
);
10581 // Check types of a map index.
10584 Map_index_expression::do_check_types(Gogo
*)
10586 std::string reason
;
10587 Map_type
* mt
= this->get_map_type();
10590 if (!Type::are_assignable(mt
->key_type(), this->index_
->type(), &reason
))
10592 if (reason
.empty())
10593 this->report_error(_("incompatible type for map index"));
10596 error_at(this->location(), "incompatible type for map index (%s)",
10598 this->set_is_error();
10603 // Get the backend representation for a map index.
10606 Map_index_expression::do_get_backend(Translate_context
* context
)
10608 Map_type
* type
= this->get_map_type();
10611 go_assert(saw_errors());
10612 return context
->backend()->error_expression();
10615 go_assert(this->value_pointer_
!= NULL
10616 && this->value_pointer_
->is_variable());
10619 if (this->is_lvalue_
)
10622 Expression::make_unary(OPERATOR_MULT
, this->value_pointer_
,
10624 ret
= val
->get_backend(context
);
10626 else if (this->is_in_tuple_assignment_
)
10628 // Tuple_map_assignment_statement is responsible for using this
10630 ret
= this->value_pointer_
->get_backend(context
);
10634 Location loc
= this->location();
10636 Expression
* nil_check
=
10637 Expression::make_binary(OPERATOR_EQEQ
, this->value_pointer_
,
10638 Expression::make_nil(loc
), loc
);
10639 Bexpression
* bnil_check
= nil_check
->get_backend(context
);
10641 Expression::make_unary(OPERATOR_MULT
, this->value_pointer_
, loc
);
10642 Bexpression
* bval
= val
->get_backend(context
);
10644 Gogo
* gogo
= context
->gogo();
10645 Btype
* val_btype
= type
->val_type()->get_backend(gogo
);
10646 Bexpression
* val_zero
= gogo
->backend()->zero_expression(val_btype
);
10647 ret
= gogo
->backend()->conditional_expression(val_btype
, bnil_check
,
10648 val_zero
, bval
, loc
);
10653 // Get an expression for the map index. This returns an expression which
10654 // evaluates to a pointer to a value. The pointer will be NULL if the key is
10658 Map_index_expression::get_value_pointer(bool insert
)
10660 if (this->value_pointer_
== NULL
)
10662 Map_type
* type
= this->get_map_type();
10665 go_assert(saw_errors());
10666 return Expression::make_error(this->location());
10669 Location loc
= this->location();
10670 Expression
* map_ref
= this->map_
;
10671 if (this->map_
->type()->points_to() != NULL
)
10672 map_ref
= Expression::make_unary(OPERATOR_MULT
, map_ref
, loc
);
10674 Expression
* index_ptr
= Expression::make_unary(OPERATOR_AND
, this->index_
,
10676 Expression
* map_index
=
10677 Runtime::make_call(Runtime::MAP_INDEX
, loc
, 3,
10678 map_ref
, index_ptr
,
10679 Expression::make_boolean(insert
, loc
));
10681 Type
* val_type
= type
->val_type();
10682 this->value_pointer_
=
10683 Expression::make_unsafe_cast(Type::make_pointer_type(val_type
),
10684 map_index
, this->location());
10686 return this->value_pointer_
;
10689 // Dump ast representation for a map index expression
10692 Map_index_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
10695 Index_expression::dump_index_expression(ast_dump_context
, this->map_
,
10696 this->index_
, NULL
, NULL
);
10699 // Make a map index expression.
10701 Map_index_expression
*
10702 Expression::make_map_index(Expression
* map
, Expression
* index
,
10705 return new Map_index_expression(map
, index
, location
);
10708 // Class Field_reference_expression.
10710 // Lower a field reference expression. There is nothing to lower, but
10711 // this is where we generate the tracking information for fields with
10712 // the magic go:"track" tag.
10715 Field_reference_expression::do_lower(Gogo
* gogo
, Named_object
* function
,
10716 Statement_inserter
* inserter
, int)
10718 Struct_type
* struct_type
= this->expr_
->type()->struct_type();
10719 if (struct_type
== NULL
)
10721 // Error will be reported elsewhere.
10724 const Struct_field
* field
= struct_type
->field(this->field_index_
);
10727 if (!field
->has_tag())
10729 if (field
->tag().find("go:\"track\"") == std::string::npos
)
10732 // References from functions generated by the compiler don't count.
10733 if (function
->func_value()->is_type_specific_function())
10736 // We have found a reference to a tracked field. Build a call to
10737 // the runtime function __go_fieldtrack with a string that describes
10738 // the field. FIXME: We should only call this once per referenced
10739 // field per function, not once for each reference to the field.
10741 if (this->called_fieldtrack_
)
10743 this->called_fieldtrack_
= true;
10745 Location loc
= this->location();
10747 std::string s
= "fieldtrack \"";
10748 Named_type
* nt
= this->expr_
->type()->named_type();
10749 if (nt
== NULL
|| nt
->named_object()->package() == NULL
)
10750 s
.append(gogo
->pkgpath());
10752 s
.append(nt
->named_object()->package()->pkgpath());
10755 s
.append(Gogo::unpack_hidden_name(nt
->name()));
10757 s
.append(field
->field_name());
10760 // We can't use a string here, because internally a string holds a
10761 // pointer to the actual bytes; when the linker garbage collects the
10762 // string, it won't garbage collect the bytes. So we use a
10765 Expression
* length_expr
= Expression::make_integer_ul(s
.length(), NULL
, loc
);
10767 Type
* byte_type
= gogo
->lookup_global("byte")->type_value();
10768 Type
* array_type
= Type::make_array_type(byte_type
, length_expr
);
10770 Expression_list
* bytes
= new Expression_list();
10771 for (std::string::const_iterator p
= s
.begin(); p
!= s
.end(); p
++)
10773 unsigned char c
= static_cast<unsigned char>(*p
);
10774 bytes
->push_back(Expression::make_integer_ul(c
, NULL
, loc
));
10777 Expression
* e
= Expression::make_composite_literal(array_type
, 0, false,
10778 bytes
, false, loc
);
10780 Variable
* var
= new Variable(array_type
, e
, true, false, false, loc
);
10784 snprintf(buf
, sizeof buf
, "fieldtrack.%d", count
);
10787 Named_object
* no
= gogo
->add_variable(buf
, var
);
10788 e
= Expression::make_var_reference(no
, loc
);
10789 e
= Expression::make_unary(OPERATOR_AND
, e
, loc
);
10791 Expression
* call
= Runtime::make_call(Runtime::FIELDTRACK
, loc
, 1, e
);
10792 gogo
->lower_expression(function
, inserter
, &call
);
10793 inserter
->insert(Statement::make_statement(call
, false));
10795 // Put this function, and the global variable we just created, into
10796 // unique sections. This will permit the linker to garbage collect
10797 // them if they are not referenced. The effect is that the only
10798 // strings, indicating field references, that will wind up in the
10799 // executable will be those for functions that are actually needed.
10800 if (function
!= NULL
)
10801 function
->func_value()->set_in_unique_section();
10802 var
->set_in_unique_section();
10807 // Return the type of a field reference.
10810 Field_reference_expression::do_type()
10812 Type
* type
= this->expr_
->type();
10813 if (type
->is_error())
10815 Struct_type
* struct_type
= type
->struct_type();
10816 go_assert(struct_type
!= NULL
);
10817 return struct_type
->field(this->field_index_
)->type();
10820 // Check the types for a field reference.
10823 Field_reference_expression::do_check_types(Gogo
*)
10825 Type
* type
= this->expr_
->type();
10826 if (type
->is_error())
10828 Struct_type
* struct_type
= type
->struct_type();
10829 go_assert(struct_type
!= NULL
);
10830 go_assert(struct_type
->field(this->field_index_
) != NULL
);
10833 // Get the backend representation for a field reference.
10836 Field_reference_expression::do_get_backend(Translate_context
* context
)
10838 Bexpression
* bstruct
= this->expr_
->get_backend(context
);
10839 return context
->gogo()->backend()->struct_field_expression(bstruct
,
10840 this->field_index_
,
10844 // Dump ast representation for a field reference expression.
10847 Field_reference_expression::do_dump_expression(
10848 Ast_dump_context
* ast_dump_context
) const
10850 this->expr_
->dump_expression(ast_dump_context
);
10851 ast_dump_context
->ostream() << "." << this->field_index_
;
10854 // Make a reference to a qualified identifier in an expression.
10856 Field_reference_expression
*
10857 Expression::make_field_reference(Expression
* expr
, unsigned int field_index
,
10860 return new Field_reference_expression(expr
, field_index
, location
);
10863 // Class Interface_field_reference_expression.
10865 // Return an expression for the pointer to the function to call.
10868 Interface_field_reference_expression::get_function()
10870 Expression
* ref
= this->expr_
;
10871 Location loc
= this->location();
10872 if (ref
->type()->points_to() != NULL
)
10873 ref
= Expression::make_unary(OPERATOR_MULT
, ref
, loc
);
10875 Expression
* mtable
=
10876 Expression::make_interface_info(ref
, INTERFACE_INFO_METHODS
, loc
);
10877 Struct_type
* mtable_type
= mtable
->type()->points_to()->struct_type();
10879 std::string name
= Gogo::unpack_hidden_name(this->name_
);
10880 unsigned int index
;
10881 const Struct_field
* field
= mtable_type
->find_local_field(name
, &index
);
10882 go_assert(field
!= NULL
);
10883 mtable
= Expression::make_unary(OPERATOR_MULT
, mtable
, loc
);
10884 return Expression::make_field_reference(mtable
, index
, loc
);
10887 // Return an expression for the first argument to pass to the interface
10891 Interface_field_reference_expression::get_underlying_object()
10893 Expression
* expr
= this->expr_
;
10894 if (expr
->type()->points_to() != NULL
)
10895 expr
= Expression::make_unary(OPERATOR_MULT
, expr
, this->location());
10896 return Expression::make_interface_info(expr
, INTERFACE_INFO_OBJECT
,
10903 Interface_field_reference_expression::do_traverse(Traverse
* traverse
)
10905 return Expression::traverse(&this->expr_
, traverse
);
10908 // Lower the expression. If this expression is not called, we need to
10909 // evaluate the expression twice when converting to the backend
10910 // interface. So introduce a temporary variable if necessary.
10913 Interface_field_reference_expression::do_flatten(Gogo
*, Named_object
*,
10914 Statement_inserter
* inserter
)
10916 if (!this->expr_
->is_variable())
10918 Temporary_statement
* temp
=
10919 Statement::make_temporary(this->expr_
->type(), NULL
, this->location());
10920 inserter
->insert(temp
);
10921 this->expr_
= Expression::make_set_and_use_temporary(temp
, this->expr_
,
10927 // Return the type of an interface field reference.
10930 Interface_field_reference_expression::do_type()
10932 Type
* expr_type
= this->expr_
->type();
10934 Type
* points_to
= expr_type
->points_to();
10935 if (points_to
!= NULL
)
10936 expr_type
= points_to
;
10938 Interface_type
* interface_type
= expr_type
->interface_type();
10939 if (interface_type
== NULL
)
10940 return Type::make_error_type();
10942 const Typed_identifier
* method
= interface_type
->find_method(this->name_
);
10943 if (method
== NULL
)
10944 return Type::make_error_type();
10946 return method
->type();
10949 // Determine types.
10952 Interface_field_reference_expression::do_determine_type(const Type_context
*)
10954 this->expr_
->determine_type_no_context();
10957 // Check the types for an interface field reference.
10960 Interface_field_reference_expression::do_check_types(Gogo
*)
10962 Type
* type
= this->expr_
->type();
10964 Type
* points_to
= type
->points_to();
10965 if (points_to
!= NULL
)
10968 Interface_type
* interface_type
= type
->interface_type();
10969 if (interface_type
== NULL
)
10971 if (!type
->is_error_type())
10972 this->report_error(_("expected interface or pointer to interface"));
10976 const Typed_identifier
* method
=
10977 interface_type
->find_method(this->name_
);
10978 if (method
== NULL
)
10980 error_at(this->location(), "method %qs not in interface",
10981 Gogo::message_name(this->name_
).c_str());
10982 this->set_is_error();
10987 // If an interface field reference is not simply called, then it is
10988 // represented as a closure. The closure will hold a single variable,
10989 // the value of the interface on which the method should be called.
10990 // The function will be a simple thunk that pulls the value from the
10991 // closure and calls the method with the remaining arguments.
10993 // Because method values are not common, we don't build all thunks for
10994 // all possible interface methods, but instead only build them as we
10995 // need them. In particular, we even build them on demand for
10996 // interface methods defined in other packages.
10998 Interface_field_reference_expression::Interface_method_thunks
10999 Interface_field_reference_expression::interface_method_thunks
;
11001 // Find or create the thunk to call method NAME on TYPE.
11004 Interface_field_reference_expression::create_thunk(Gogo
* gogo
,
11005 Interface_type
* type
,
11006 const std::string
& name
)
11008 std::pair
<Interface_type
*, Method_thunks
*> val(type
, NULL
);
11009 std::pair
<Interface_method_thunks::iterator
, bool> ins
=
11010 Interface_field_reference_expression::interface_method_thunks
.insert(val
);
11013 // This is the first time we have seen this interface.
11014 ins
.first
->second
= new Method_thunks();
11017 for (Method_thunks::const_iterator p
= ins
.first
->second
->begin();
11018 p
!= ins
.first
->second
->end();
11020 if (p
->first
== name
)
11023 Location loc
= type
->location();
11025 const Typed_identifier
* method_id
= type
->find_method(name
);
11026 if (method_id
== NULL
)
11027 return Named_object::make_erroneous_name(Gogo::thunk_name());
11029 Function_type
* orig_fntype
= method_id
->type()->function_type();
11030 if (orig_fntype
== NULL
)
11031 return Named_object::make_erroneous_name(Gogo::thunk_name());
11033 Struct_field_list
* sfl
= new Struct_field_list();
11034 // The type here is wrong--it should be the C function type. But it
11035 // doesn't really matter.
11036 Type
* vt
= Type::make_pointer_type(Type::make_void_type());
11037 sfl
->push_back(Struct_field(Typed_identifier("fn.0", vt
, loc
)));
11038 sfl
->push_back(Struct_field(Typed_identifier("val.1", type
, loc
)));
11039 Type
* closure_type
= Type::make_struct_type(sfl
, loc
);
11040 closure_type
= Type::make_pointer_type(closure_type
);
11042 Function_type
* new_fntype
= orig_fntype
->copy_with_names();
11044 Named_object
* new_no
= gogo
->start_function(Gogo::thunk_name(), new_fntype
,
11047 Variable
* cvar
= new Variable(closure_type
, NULL
, false, false, false, loc
);
11048 cvar
->set_is_used();
11049 Named_object
* cp
= Named_object::make_variable("$closure", NULL
, cvar
);
11050 new_no
->func_value()->set_closure_var(cp
);
11052 gogo
->start_block(loc
);
11054 // Field 0 of the closure is the function code pointer, field 1 is
11055 // the value on which to invoke the method.
11056 Expression
* arg
= Expression::make_var_reference(cp
, loc
);
11057 arg
= Expression::make_unary(OPERATOR_MULT
, arg
, loc
);
11058 arg
= Expression::make_field_reference(arg
, 1, loc
);
11060 Expression
*ifre
= Expression::make_interface_field_reference(arg
, name
,
11063 const Typed_identifier_list
* orig_params
= orig_fntype
->parameters();
11064 Expression_list
* args
;
11065 if (orig_params
== NULL
|| orig_params
->empty())
11069 const Typed_identifier_list
* new_params
= new_fntype
->parameters();
11070 args
= new Expression_list();
11071 for (Typed_identifier_list::const_iterator p
= new_params
->begin();
11072 p
!= new_params
->end();
11075 Named_object
* p_no
= gogo
->lookup(p
->name(), NULL
);
11076 go_assert(p_no
!= NULL
11077 && p_no
->is_variable()
11078 && p_no
->var_value()->is_parameter());
11079 args
->push_back(Expression::make_var_reference(p_no
, loc
));
11083 Call_expression
* call
= Expression::make_call(ifre
, args
,
11084 orig_fntype
->is_varargs(),
11086 call
->set_varargs_are_lowered();
11088 Statement
* s
= Statement::make_return_from_call(call
, loc
);
11089 gogo
->add_statement(s
);
11090 Block
* b
= gogo
->finish_block(loc
);
11091 gogo
->add_block(b
, loc
);
11092 gogo
->lower_block(new_no
, b
);
11093 gogo
->flatten_block(new_no
, b
);
11094 gogo
->finish_function(loc
);
11096 ins
.first
->second
->push_back(std::make_pair(name
, new_no
));
11100 // Get the backend representation for a method value.
11103 Interface_field_reference_expression::do_get_backend(Translate_context
* context
)
11105 Interface_type
* type
= this->expr_
->type()->interface_type();
11108 go_assert(saw_errors());
11109 return context
->backend()->error_expression();
11112 Named_object
* thunk
=
11113 Interface_field_reference_expression::create_thunk(context
->gogo(),
11114 type
, this->name_
);
11115 if (thunk
->is_erroneous())
11117 go_assert(saw_errors());
11118 return context
->backend()->error_expression();
11121 // FIXME: We should lower this earlier, but we can't it lower it in
11122 // the lowering pass because at that point we don't know whether we
11123 // need to create the thunk or not. If the expression is called, we
11124 // don't need the thunk.
11126 Location loc
= this->location();
11128 Struct_field_list
* fields
= new Struct_field_list();
11129 fields
->push_back(Struct_field(Typed_identifier("fn.0",
11130 thunk
->func_value()->type(),
11132 fields
->push_back(Struct_field(Typed_identifier("val.1",
11133 this->expr_
->type(),
11135 Struct_type
* st
= Type::make_struct_type(fields
, loc
);
11137 Expression_list
* vals
= new Expression_list();
11138 vals
->push_back(Expression::make_func_code_reference(thunk
, loc
));
11139 vals
->push_back(this->expr_
);
11141 Expression
* expr
= Expression::make_struct_composite_literal(st
, vals
, loc
);
11142 Bexpression
* bclosure
=
11143 Expression::make_heap_expression(expr
, loc
)->get_backend(context
);
11145 Expression
* nil_check
=
11146 Expression::make_binary(OPERATOR_EQEQ
, this->expr_
,
11147 Expression::make_nil(loc
), loc
);
11148 Bexpression
* bnil_check
= nil_check
->get_backend(context
);
11150 Gogo
* gogo
= context
->gogo();
11151 Bexpression
* bcrash
= gogo
->runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE
,
11152 loc
)->get_backend(context
);
11154 Bexpression
* bcond
=
11155 gogo
->backend()->conditional_expression(NULL
, bnil_check
, bcrash
, NULL
, loc
);
11156 Bstatement
* cond_statement
= gogo
->backend()->expression_statement(bcond
);
11157 return gogo
->backend()->compound_expression(cond_statement
, bclosure
, loc
);
11160 // Dump ast representation for an interface field reference.
11163 Interface_field_reference_expression::do_dump_expression(
11164 Ast_dump_context
* ast_dump_context
) const
11166 this->expr_
->dump_expression(ast_dump_context
);
11167 ast_dump_context
->ostream() << "." << this->name_
;
11170 // Make a reference to a field in an interface.
11173 Expression::make_interface_field_reference(Expression
* expr
,
11174 const std::string
& field
,
11177 return new Interface_field_reference_expression(expr
, field
, location
);
11180 // A general selector. This is a Parser_expression for LEFT.NAME. It
11181 // is lowered after we know the type of the left hand side.
11183 class Selector_expression
: public Parser_expression
11186 Selector_expression(Expression
* left
, const std::string
& name
,
11188 : Parser_expression(EXPRESSION_SELECTOR
, location
),
11189 left_(left
), name_(name
)
11194 do_traverse(Traverse
* traverse
)
11195 { return Expression::traverse(&this->left_
, traverse
); }
11198 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
11203 return new Selector_expression(this->left_
->copy(), this->name_
,
11208 do_dump_expression(Ast_dump_context
* ast_dump_context
) const;
11212 lower_method_expression(Gogo
*);
11214 // The expression on the left hand side.
11216 // The name on the right hand side.
11220 // Lower a selector expression once we know the real type of the left
11224 Selector_expression::do_lower(Gogo
* gogo
, Named_object
*, Statement_inserter
*,
11227 Expression
* left
= this->left_
;
11228 if (left
->is_type_expression())
11229 return this->lower_method_expression(gogo
);
11230 return Type::bind_field_or_method(gogo
, left
->type(), left
, this->name_
,
11234 // Lower a method expression T.M or (*T).M. We turn this into a
11235 // function literal.
11238 Selector_expression::lower_method_expression(Gogo
* gogo
)
11240 Location location
= this->location();
11241 Type
* type
= this->left_
->type();
11242 const std::string
& name(this->name_
);
11245 if (type
->points_to() == NULL
)
11246 is_pointer
= false;
11250 type
= type
->points_to();
11252 Named_type
* nt
= type
->named_type();
11256 ("method expression requires named type or "
11257 "pointer to named type"));
11258 return Expression::make_error(location
);
11262 Method
* method
= nt
->method_function(name
, &is_ambiguous
);
11263 const Typed_identifier
* imethod
= NULL
;
11264 if (method
== NULL
&& !is_pointer
)
11266 Interface_type
* it
= nt
->interface_type();
11268 imethod
= it
->find_method(name
);
11271 if (method
== NULL
&& imethod
== NULL
)
11274 error_at(location
, "type %<%s%s%> has no method %<%s%>",
11275 is_pointer
? "*" : "",
11276 nt
->message_name().c_str(),
11277 Gogo::message_name(name
).c_str());
11279 error_at(location
, "method %<%s%s%> is ambiguous in type %<%s%>",
11280 Gogo::message_name(name
).c_str(),
11281 is_pointer
? "*" : "",
11282 nt
->message_name().c_str());
11283 return Expression::make_error(location
);
11286 if (method
!= NULL
&& !is_pointer
&& !method
->is_value_method())
11288 error_at(location
, "method requires pointer (use %<(*%s).%s)%>",
11289 nt
->message_name().c_str(),
11290 Gogo::message_name(name
).c_str());
11291 return Expression::make_error(location
);
11294 // Build a new function type in which the receiver becomes the first
11296 Function_type
* method_type
;
11297 if (method
!= NULL
)
11299 method_type
= method
->type();
11300 go_assert(method_type
->is_method());
11304 method_type
= imethod
->type()->function_type();
11305 go_assert(method_type
!= NULL
&& !method_type
->is_method());
11308 const char* const receiver_name
= "$this";
11309 Typed_identifier_list
* parameters
= new Typed_identifier_list();
11310 parameters
->push_back(Typed_identifier(receiver_name
, this->left_
->type(),
11313 const Typed_identifier_list
* method_parameters
= method_type
->parameters();
11314 if (method_parameters
!= NULL
)
11317 for (Typed_identifier_list::const_iterator p
= method_parameters
->begin();
11318 p
!= method_parameters
->end();
11321 if (!p
->name().empty())
11322 parameters
->push_back(*p
);
11326 snprintf(buf
, sizeof buf
, "$param%d", i
);
11327 parameters
->push_back(Typed_identifier(buf
, p
->type(),
11333 const Typed_identifier_list
* method_results
= method_type
->results();
11334 Typed_identifier_list
* results
;
11335 if (method_results
== NULL
)
11339 results
= new Typed_identifier_list();
11340 for (Typed_identifier_list::const_iterator p
= method_results
->begin();
11341 p
!= method_results
->end();
11343 results
->push_back(*p
);
11346 Function_type
* fntype
= Type::make_function_type(NULL
, parameters
, results
,
11348 if (method_type
->is_varargs())
11349 fntype
->set_is_varargs();
11351 // We generate methods which always takes a pointer to the receiver
11352 // as their first argument. If this is for a pointer type, we can
11353 // simply reuse the existing function. We use an internal hack to
11354 // get the right type.
11355 // FIXME: This optimization is disabled because it doesn't yet work
11356 // with function descriptors when the method expression is not
11357 // directly called.
11358 if (method
!= NULL
&& is_pointer
&& false)
11360 Named_object
* mno
= (method
->needs_stub_method()
11361 ? method
->stub_object()
11362 : method
->named_object());
11363 Expression
* f
= Expression::make_func_reference(mno
, NULL
, location
);
11364 f
= Expression::make_cast(fntype
, f
, location
);
11365 Type_conversion_expression
* tce
=
11366 static_cast<Type_conversion_expression
*>(f
);
11367 tce
->set_may_convert_function_types();
11371 Named_object
* no
= gogo
->start_function(Gogo::thunk_name(), fntype
, false,
11374 Named_object
* vno
= gogo
->lookup(receiver_name
, NULL
);
11375 go_assert(vno
!= NULL
);
11376 Expression
* ve
= Expression::make_var_reference(vno
, location
);
11378 if (method
!= NULL
)
11379 bm
= Type::bind_field_or_method(gogo
, nt
, ve
, name
, location
);
11381 bm
= Expression::make_interface_field_reference(ve
, name
, location
);
11383 // Even though we found the method above, if it has an error type we
11384 // may see an error here.
11385 if (bm
->is_error_expression())
11387 gogo
->finish_function(location
);
11391 Expression_list
* args
;
11392 if (parameters
->size() <= 1)
11396 args
= new Expression_list();
11397 Typed_identifier_list::const_iterator p
= parameters
->begin();
11399 for (; p
!= parameters
->end(); ++p
)
11401 vno
= gogo
->lookup(p
->name(), NULL
);
11402 go_assert(vno
!= NULL
);
11403 args
->push_back(Expression::make_var_reference(vno
, location
));
11407 gogo
->start_block(location
);
11409 Call_expression
* call
= Expression::make_call(bm
, args
,
11410 method_type
->is_varargs(),
11413 Statement
* s
= Statement::make_return_from_call(call
, location
);
11414 gogo
->add_statement(s
);
11416 Block
* b
= gogo
->finish_block(location
);
11418 gogo
->add_block(b
, location
);
11420 // Lower the call in case there are multiple results.
11421 gogo
->lower_block(no
, b
);
11422 gogo
->flatten_block(no
, b
);
11424 gogo
->finish_function(location
);
11426 return Expression::make_func_reference(no
, NULL
, location
);
11429 // Dump the ast for a selector expression.
11432 Selector_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
11435 ast_dump_context
->dump_expression(this->left_
);
11436 ast_dump_context
->ostream() << ".";
11437 ast_dump_context
->ostream() << this->name_
;
11440 // Make a selector expression.
11443 Expression::make_selector(Expression
* left
, const std::string
& name
,
11446 return new Selector_expression(left
, name
, location
);
11449 // Implement the builtin function new.
11451 class Allocation_expression
: public Expression
11454 Allocation_expression(Type
* type
, Location location
)
11455 : Expression(EXPRESSION_ALLOCATION
, location
),
11461 do_traverse(Traverse
* traverse
)
11462 { return Type::traverse(this->type_
, traverse
); }
11466 { return Type::make_pointer_type(this->type_
); }
11469 do_determine_type(const Type_context
*)
11474 { return new Allocation_expression(this->type_
, this->location()); }
11477 do_get_backend(Translate_context
*);
11480 do_dump_expression(Ast_dump_context
*) const;
11483 // The type we are allocating.
11487 // Return the backend representation for an allocation expression.
11490 Allocation_expression::do_get_backend(Translate_context
* context
)
11492 Gogo
* gogo
= context
->gogo();
11493 Location loc
= this->location();
11494 Bexpression
* space
=
11495 gogo
->allocate_memory(this->type_
, loc
)->get_backend(context
);
11496 Btype
* pbtype
= gogo
->backend()->pointer_type(this->type_
->get_backend(gogo
));
11497 return gogo
->backend()->convert_expression(pbtype
, space
, loc
);
11500 // Dump ast representation for an allocation expression.
11503 Allocation_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
11506 ast_dump_context
->ostream() << "new(";
11507 ast_dump_context
->dump_type(this->type_
);
11508 ast_dump_context
->ostream() << ")";
11511 // Make an allocation expression.
11514 Expression::make_allocation(Type
* type
, Location location
)
11516 return new Allocation_expression(type
, location
);
11519 // Construct a struct.
11521 class Struct_construction_expression
: public Expression
11524 Struct_construction_expression(Type
* type
, Expression_list
* vals
,
11526 : Expression(EXPRESSION_STRUCT_CONSTRUCTION
, location
),
11527 type_(type
), vals_(vals
), traverse_order_(NULL
)
11530 // Set the traversal order, used to ensure that we implement the
11531 // order of evaluation rules. Takes ownership of the argument.
11533 set_traverse_order(std::vector
<int>* traverse_order
)
11534 { this->traverse_order_
= traverse_order
; }
11536 // Return whether this is a constant initializer.
11538 is_constant_struct() const;
11542 do_traverse(Traverse
* traverse
);
11545 do_is_immutable() const;
11549 { return this->type_
; }
11552 do_determine_type(const Type_context
*);
11555 do_check_types(Gogo
*);
11560 Struct_construction_expression
* ret
=
11561 new Struct_construction_expression(this->type_
, this->vals_
->copy(),
11563 if (this->traverse_order_
!= NULL
)
11564 ret
->set_traverse_order(this->traverse_order_
);
11569 do_get_backend(Translate_context
*);
11572 do_export(Export
*) const;
11575 do_dump_expression(Ast_dump_context
*) const;
11578 // The type of the struct to construct.
11580 // The list of values, in order of the fields in the struct. A NULL
11581 // entry means that the field should be zero-initialized.
11582 Expression_list
* vals_
;
11583 // If not NULL, the order in which to traverse vals_. This is used
11584 // so that we implement the order of evaluation rules correctly.
11585 std::vector
<int>* traverse_order_
;
11591 Struct_construction_expression::do_traverse(Traverse
* traverse
)
11593 if (this->vals_
!= NULL
)
11595 if (this->traverse_order_
== NULL
)
11597 if (this->vals_
->traverse(traverse
) == TRAVERSE_EXIT
)
11598 return TRAVERSE_EXIT
;
11602 for (std::vector
<int>::const_iterator p
=
11603 this->traverse_order_
->begin();
11604 p
!= this->traverse_order_
->end();
11607 if (Expression::traverse(&this->vals_
->at(*p
), traverse
)
11609 return TRAVERSE_EXIT
;
11613 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
11614 return TRAVERSE_EXIT
;
11615 return TRAVERSE_CONTINUE
;
11618 // Return whether this is a constant initializer.
11621 Struct_construction_expression::is_constant_struct() const
11623 if (this->vals_
== NULL
)
11625 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11626 pv
!= this->vals_
->end();
11630 && !(*pv
)->is_constant()
11631 && (!(*pv
)->is_composite_literal()
11632 || (*pv
)->is_nonconstant_composite_literal()))
11636 const Struct_field_list
* fields
= this->type_
->struct_type()->fields();
11637 for (Struct_field_list::const_iterator pf
= fields
->begin();
11638 pf
!= fields
->end();
11641 // There are no constant constructors for interfaces.
11642 if (pf
->type()->interface_type() != NULL
)
11649 // Return whether this struct is immutable.
11652 Struct_construction_expression::do_is_immutable() const
11654 if (this->vals_
== NULL
)
11656 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11657 pv
!= this->vals_
->end();
11660 if (*pv
!= NULL
&& !(*pv
)->is_immutable())
11666 // Final type determination.
11669 Struct_construction_expression::do_determine_type(const Type_context
*)
11671 if (this->vals_
== NULL
)
11673 const Struct_field_list
* fields
= this->type_
->struct_type()->fields();
11674 Expression_list::const_iterator pv
= this->vals_
->begin();
11675 for (Struct_field_list::const_iterator pf
= fields
->begin();
11676 pf
!= fields
->end();
11679 if (pv
== this->vals_
->end())
11683 Type_context
subcontext(pf
->type(), false);
11684 (*pv
)->determine_type(&subcontext
);
11687 // Extra values are an error we will report elsewhere; we still want
11688 // to determine the type to avoid knockon errors.
11689 for (; pv
!= this->vals_
->end(); ++pv
)
11690 (*pv
)->determine_type_no_context();
11696 Struct_construction_expression::do_check_types(Gogo
*)
11698 if (this->vals_
== NULL
)
11701 Struct_type
* st
= this->type_
->struct_type();
11702 if (this->vals_
->size() > st
->field_count())
11704 this->report_error(_("too many expressions for struct"));
11708 const Struct_field_list
* fields
= st
->fields();
11709 Expression_list::const_iterator pv
= this->vals_
->begin();
11711 for (Struct_field_list::const_iterator pf
= fields
->begin();
11712 pf
!= fields
->end();
11715 if (pv
== this->vals_
->end())
11717 this->report_error(_("too few expressions for struct"));
11724 std::string reason
;
11725 if (!Type::are_assignable(pf
->type(), (*pv
)->type(), &reason
))
11727 if (reason
.empty())
11728 error_at((*pv
)->location(),
11729 "incompatible type for field %d in struct construction",
11732 error_at((*pv
)->location(),
11733 ("incompatible type for field %d in "
11734 "struct construction (%s)"),
11735 i
+ 1, reason
.c_str());
11736 this->set_is_error();
11739 go_assert(pv
== this->vals_
->end());
11742 // Return the backend representation for constructing a struct.
11745 Struct_construction_expression::do_get_backend(Translate_context
* context
)
11747 Gogo
* gogo
= context
->gogo();
11749 Btype
* btype
= this->type_
->get_backend(gogo
);
11750 if (this->vals_
== NULL
)
11751 return gogo
->backend()->zero_expression(btype
);
11753 const Struct_field_list
* fields
= this->type_
->struct_type()->fields();
11754 Expression_list::const_iterator pv
= this->vals_
->begin();
11755 std::vector
<Bexpression
*> init
;
11756 for (Struct_field_list::const_iterator pf
= fields
->begin();
11757 pf
!= fields
->end();
11760 Btype
* fbtype
= pf
->type()->get_backend(gogo
);
11761 if (pv
== this->vals_
->end())
11762 init
.push_back(gogo
->backend()->zero_expression(fbtype
));
11763 else if (*pv
== NULL
)
11765 init
.push_back(gogo
->backend()->zero_expression(fbtype
));
11771 Expression::convert_for_assignment(gogo
, pf
->type(),
11772 *pv
, this->location());
11773 init
.push_back(val
->get_backend(context
));
11777 return gogo
->backend()->constructor_expression(btype
, init
, this->location());
11780 // Export a struct construction.
11783 Struct_construction_expression::do_export(Export
* exp
) const
11785 exp
->write_c_string("convert(");
11786 exp
->write_type(this->type_
);
11787 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11788 pv
!= this->vals_
->end();
11791 exp
->write_c_string(", ");
11793 (*pv
)->export_expression(exp
);
11795 exp
->write_c_string(")");
11798 // Dump ast representation of a struct construction expression.
11801 Struct_construction_expression::do_dump_expression(
11802 Ast_dump_context
* ast_dump_context
) const
11804 ast_dump_context
->dump_type(this->type_
);
11805 ast_dump_context
->ostream() << "{";
11806 ast_dump_context
->dump_expression_list(this->vals_
);
11807 ast_dump_context
->ostream() << "}";
11810 // Make a struct composite literal. This used by the thunk code.
11813 Expression::make_struct_composite_literal(Type
* type
, Expression_list
* vals
,
11816 go_assert(type
->struct_type() != NULL
);
11817 return new Struct_construction_expression(type
, vals
, location
);
11820 // Construct an array. This class is not used directly; instead we
11821 // use the child classes, Fixed_array_construction_expression and
11822 // Slice_construction_expression.
11824 class Array_construction_expression
: public Expression
11827 Array_construction_expression(Expression_classification classification
,
11829 const std::vector
<unsigned long>* indexes
,
11830 Expression_list
* vals
, Location location
)
11831 : Expression(classification
, location
),
11832 type_(type
), indexes_(indexes
), vals_(vals
)
11833 { go_assert(indexes
== NULL
|| indexes
->size() == vals
->size()); }
11836 // Return whether this is a constant initializer.
11838 is_constant_array() const;
11840 // Return the number of elements.
11842 element_count() const
11843 { return this->vals_
== NULL
? 0 : this->vals_
->size(); }
11847 do_traverse(Traverse
* traverse
);
11850 do_is_immutable() const;
11854 { return this->type_
; }
11857 do_determine_type(const Type_context
*);
11860 do_check_types(Gogo
*);
11863 do_export(Export
*) const;
11866 const std::vector
<unsigned long>*
11868 { return this->indexes_
; }
11870 // The list of values.
11873 { return this->vals_
; }
11875 // Get the backend constructor for the array values.
11877 get_constructor(Translate_context
* context
, Btype
* btype
);
11880 do_dump_expression(Ast_dump_context
*) const;
11883 // The type of the array to construct.
11885 // The list of indexes into the array, one for each value. This may
11886 // be NULL, in which case the indexes start at zero and increment.
11887 const std::vector
<unsigned long>* indexes_
;
11888 // The list of values. This may be NULL if there are no values.
11889 Expression_list
* vals_
;
11895 Array_construction_expression::do_traverse(Traverse
* traverse
)
11897 if (this->vals_
!= NULL
11898 && this->vals_
->traverse(traverse
) == TRAVERSE_EXIT
)
11899 return TRAVERSE_EXIT
;
11900 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
11901 return TRAVERSE_EXIT
;
11902 return TRAVERSE_CONTINUE
;
11905 // Return whether this is a constant initializer.
11908 Array_construction_expression::is_constant_array() const
11910 if (this->vals_
== NULL
)
11913 // There are no constant constructors for interfaces.
11914 if (this->type_
->array_type()->element_type()->interface_type() != NULL
)
11917 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11918 pv
!= this->vals_
->end();
11922 && !(*pv
)->is_constant()
11923 && (!(*pv
)->is_composite_literal()
11924 || (*pv
)->is_nonconstant_composite_literal()))
11930 // Return whether this is an immutable array initializer.
11933 Array_construction_expression::do_is_immutable() const
11935 if (this->vals_
== NULL
)
11937 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11938 pv
!= this->vals_
->end();
11941 if (*pv
!= NULL
&& !(*pv
)->is_immutable())
11947 // Final type determination.
11950 Array_construction_expression::do_determine_type(const Type_context
*)
11952 if (this->vals_
== NULL
)
11954 Type_context
subcontext(this->type_
->array_type()->element_type(), false);
11955 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11956 pv
!= this->vals_
->end();
11960 (*pv
)->determine_type(&subcontext
);
11967 Array_construction_expression::do_check_types(Gogo
*)
11969 if (this->vals_
== NULL
)
11972 Array_type
* at
= this->type_
->array_type();
11974 Type
* element_type
= at
->element_type();
11975 for (Expression_list::const_iterator pv
= this->vals_
->begin();
11976 pv
!= this->vals_
->end();
11980 && !Type::are_assignable(element_type
, (*pv
)->type(), NULL
))
11982 error_at((*pv
)->location(),
11983 "incompatible type for element %d in composite literal",
11985 this->set_is_error();
11990 // Get a constructor expression for the array values.
11993 Array_construction_expression::get_constructor(Translate_context
* context
,
11994 Btype
* array_btype
)
11996 Type
* element_type
= this->type_
->array_type()->element_type();
11998 std::vector
<unsigned long> indexes
;
11999 std::vector
<Bexpression
*> vals
;
12000 Gogo
* gogo
= context
->gogo();
12001 if (this->vals_
!= NULL
)
12004 std::vector
<unsigned long>::const_iterator pi
;
12005 if (this->indexes_
!= NULL
)
12006 pi
= this->indexes_
->begin();
12007 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12008 pv
!= this->vals_
->end();
12011 if (this->indexes_
!= NULL
)
12012 go_assert(pi
!= this->indexes_
->end());
12014 if (this->indexes_
== NULL
)
12015 indexes
.push_back(i
);
12017 indexes
.push_back(*pi
);
12020 Btype
* ebtype
= element_type
->get_backend(gogo
);
12021 Bexpression
*zv
= gogo
->backend()->zero_expression(ebtype
);
12022 vals
.push_back(zv
);
12026 Expression
* val_expr
=
12027 Expression::convert_for_assignment(gogo
, element_type
, *pv
,
12029 vals
.push_back(val_expr
->get_backend(context
));
12031 if (this->indexes_
!= NULL
)
12034 if (this->indexes_
!= NULL
)
12035 go_assert(pi
== this->indexes_
->end());
12037 return gogo
->backend()->array_constructor_expression(array_btype
, indexes
,
12038 vals
, this->location());
12041 // Export an array construction.
12044 Array_construction_expression::do_export(Export
* exp
) const
12046 exp
->write_c_string("convert(");
12047 exp
->write_type(this->type_
);
12048 if (this->vals_
!= NULL
)
12050 std::vector
<unsigned long>::const_iterator pi
;
12051 if (this->indexes_
!= NULL
)
12052 pi
= this->indexes_
->begin();
12053 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12054 pv
!= this->vals_
->end();
12057 exp
->write_c_string(", ");
12059 if (this->indexes_
!= NULL
)
12062 snprintf(buf
, sizeof buf
, "%lu", *pi
);
12063 exp
->write_c_string(buf
);
12064 exp
->write_c_string(":");
12068 (*pv
)->export_expression(exp
);
12070 if (this->indexes_
!= NULL
)
12074 exp
->write_c_string(")");
12077 // Dump ast representation of an array construction expressin.
12080 Array_construction_expression::do_dump_expression(
12081 Ast_dump_context
* ast_dump_context
) const
12083 Expression
* length
= this->type_
->array_type()->length();
12085 ast_dump_context
->ostream() << "[" ;
12086 if (length
!= NULL
)
12088 ast_dump_context
->dump_expression(length
);
12090 ast_dump_context
->ostream() << "]" ;
12091 ast_dump_context
->dump_type(this->type_
);
12092 ast_dump_context
->ostream() << "{" ;
12093 if (this->indexes_
== NULL
)
12094 ast_dump_context
->dump_expression_list(this->vals_
);
12097 Expression_list::const_iterator pv
= this->vals_
->begin();
12098 for (std::vector
<unsigned long>::const_iterator pi
=
12099 this->indexes_
->begin();
12100 pi
!= this->indexes_
->end();
12103 if (pi
!= this->indexes_
->begin())
12104 ast_dump_context
->ostream() << ", ";
12105 ast_dump_context
->ostream() << *pi
<< ':';
12106 ast_dump_context
->dump_expression(*pv
);
12109 ast_dump_context
->ostream() << "}" ;
12113 // Construct a fixed array.
12115 class Fixed_array_construction_expression
:
12116 public Array_construction_expression
12119 Fixed_array_construction_expression(Type
* type
,
12120 const std::vector
<unsigned long>* indexes
,
12121 Expression_list
* vals
, Location location
)
12122 : Array_construction_expression(EXPRESSION_FIXED_ARRAY_CONSTRUCTION
,
12123 type
, indexes
, vals
, location
)
12124 { go_assert(type
->array_type() != NULL
&& !type
->is_slice_type()); }
12130 return new Fixed_array_construction_expression(this->type(),
12132 (this->vals() == NULL
12134 : this->vals()->copy()),
12139 do_get_backend(Translate_context
*);
12142 // Return the backend representation for constructing a fixed array.
12145 Fixed_array_construction_expression::do_get_backend(Translate_context
* context
)
12147 Type
* type
= this->type();
12148 Btype
* btype
= type
->get_backend(context
->gogo());
12149 return this->get_constructor(context
, btype
);
12153 Expression::make_array_composite_literal(Type
* type
, Expression_list
* vals
,
12156 go_assert(type
->array_type() != NULL
&& !type
->is_slice_type());
12157 return new Fixed_array_construction_expression(type
, NULL
, vals
, location
);
12160 // Construct a slice.
12162 class Slice_construction_expression
: public Array_construction_expression
12165 Slice_construction_expression(Type
* type
,
12166 const std::vector
<unsigned long>* indexes
,
12167 Expression_list
* vals
, Location location
)
12168 : Array_construction_expression(EXPRESSION_SLICE_CONSTRUCTION
,
12169 type
, indexes
, vals
, location
),
12172 go_assert(type
->is_slice_type());
12174 unsigned long lenval
;
12175 Expression
* length
;
12176 if (vals
== NULL
|| vals
->empty())
12180 if (this->indexes() == NULL
)
12181 lenval
= vals
->size();
12183 lenval
= indexes
->back() + 1;
12185 Type
* int_type
= Type::lookup_integer_type("int");
12186 length
= Expression::make_integer_ul(lenval
, int_type
, location
);
12187 Type
* element_type
= type
->array_type()->element_type();
12188 this->valtype_
= Type::make_array_type(element_type
, length
);
12192 // Note that taking the address of a slice literal is invalid.
12195 do_traverse(Traverse
* traverse
);
12200 return new Slice_construction_expression(this->type(), this->indexes(),
12201 (this->vals() == NULL
12203 : this->vals()->copy()),
12208 do_get_backend(Translate_context
*);
12211 // The type of the values in this slice.
12218 Slice_construction_expression::do_traverse(Traverse
* traverse
)
12220 if (this->Array_construction_expression::do_traverse(traverse
)
12222 return TRAVERSE_EXIT
;
12223 if (Type::traverse(this->valtype_
, traverse
) == TRAVERSE_EXIT
)
12224 return TRAVERSE_EXIT
;
12225 return TRAVERSE_CONTINUE
;
12228 // Return the backend representation for constructing a slice.
12231 Slice_construction_expression::do_get_backend(Translate_context
* context
)
12233 Array_type
* array_type
= this->type()->array_type();
12234 if (array_type
== NULL
)
12236 go_assert(this->type()->is_error());
12237 return context
->backend()->error_expression();
12240 Location loc
= this->location();
12241 Type
* element_type
= array_type
->element_type();
12242 go_assert(this->valtype_
!= NULL
);
12244 Expression_list
* vals
= this->vals();
12245 if (this->vals() == NULL
|| this->vals()->empty())
12247 // We need to create a unique value for the empty array literal.
12248 vals
= new Expression_list
;
12249 vals
->push_back(NULL
);
12251 Expression
* array_val
=
12252 new Fixed_array_construction_expression(this->valtype_
, this->indexes(),
12255 bool is_constant_initializer
= array_val
->is_immutable();
12257 // We have to copy the initial values into heap memory if we are in
12258 // a function or if the values are not constants. We also have to
12259 // copy them if they may contain pointers in a non-constant context,
12260 // as otherwise the garbage collector won't see them.
12261 bool copy_to_heap
= (context
->function() != NULL
12262 || !is_constant_initializer
12263 || (element_type
->has_pointer()
12264 && !context
->is_const()));
12269 // The initializer will only run once.
12270 space
= Expression::make_unary(OPERATOR_AND
, array_val
, loc
);
12271 space
->unary_expression()->set_is_slice_init();
12274 space
= Expression::make_heap_expression(array_val
, loc
);
12276 // Build a constructor for the slice.
12278 Expression
* len
= this->valtype_
->array_type()->length();
12279 Expression
* slice_val
=
12280 Expression::make_slice_value(this->type(), space
, len
, len
, loc
);
12281 return slice_val
->get_backend(context
);
12284 // Make a slice composite literal. This is used by the type
12285 // descriptor code.
12288 Expression::make_slice_composite_literal(Type
* type
, Expression_list
* vals
,
12291 go_assert(type
->is_slice_type());
12292 return new Slice_construction_expression(type
, NULL
, vals
, location
);
12295 // Construct a map.
12297 class Map_construction_expression
: public Expression
12300 Map_construction_expression(Type
* type
, Expression_list
* vals
,
12302 : Expression(EXPRESSION_MAP_CONSTRUCTION
, location
),
12303 type_(type
), vals_(vals
), element_type_(NULL
), constructor_temp_(NULL
)
12304 { go_assert(vals
== NULL
|| vals
->size() % 2 == 0); }
12308 do_traverse(Traverse
* traverse
);
12311 do_flatten(Gogo
*, Named_object
*, Statement_inserter
*);
12315 { return this->type_
; }
12318 do_determine_type(const Type_context
*);
12321 do_check_types(Gogo
*);
12326 return new Map_construction_expression(this->type_
, this->vals_
->copy(),
12331 do_get_backend(Translate_context
*);
12334 do_export(Export
*) const;
12337 do_dump_expression(Ast_dump_context
*) const;
12340 // The type of the map to construct.
12342 // The list of values.
12343 Expression_list
* vals_
;
12344 // The type of the key-value pair struct for each map element.
12345 Struct_type
* element_type_
;
12346 // A temporary reference to the variable storing the constructor initializer.
12347 Temporary_statement
* constructor_temp_
;
12353 Map_construction_expression::do_traverse(Traverse
* traverse
)
12355 if (this->vals_
!= NULL
12356 && this->vals_
->traverse(traverse
) == TRAVERSE_EXIT
)
12357 return TRAVERSE_EXIT
;
12358 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
12359 return TRAVERSE_EXIT
;
12360 return TRAVERSE_CONTINUE
;
12363 // Flatten constructor initializer into a temporary variable since
12364 // we need to take its address for __go_construct_map.
12367 Map_construction_expression::do_flatten(Gogo
* gogo
, Named_object
*,
12368 Statement_inserter
* inserter
)
12370 if (!this->is_error_expression()
12371 && this->vals_
!= NULL
12372 && !this->vals_
->empty()
12373 && this->constructor_temp_
== NULL
)
12375 Map_type
* mt
= this->type_
->map_type();
12376 Type
* key_type
= mt
->key_type();
12377 Type
* val_type
= mt
->val_type();
12378 this->element_type_
= Type::make_builtin_struct_type(2,
12380 "__val", val_type
);
12382 Expression_list
* value_pairs
= new Expression_list();
12383 Location loc
= this->location();
12386 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12387 pv
!= this->vals_
->end();
12390 Expression_list
* key_value_pair
= new Expression_list();
12392 Expression::convert_for_assignment(gogo
, key_type
, *pv
, loc
);
12396 Expression::convert_for_assignment(gogo
, val_type
, *pv
, loc
);
12398 key_value_pair
->push_back(key
);
12399 key_value_pair
->push_back(val
);
12400 value_pairs
->push_back(
12401 Expression::make_struct_composite_literal(this->element_type_
,
12402 key_value_pair
, loc
));
12405 Expression
* element_count
= Expression::make_integer_ul(i
, NULL
, loc
);
12407 Type::make_array_type(this->element_type_
, element_count
);
12408 Expression
* constructor
=
12409 new Fixed_array_construction_expression(ctor_type
, NULL
,
12412 this->constructor_temp_
=
12413 Statement::make_temporary(NULL
, constructor
, loc
);
12414 constructor
->issue_nil_check();
12415 this->constructor_temp_
->set_is_address_taken();
12416 inserter
->insert(this->constructor_temp_
);
12422 // Final type determination.
12425 Map_construction_expression::do_determine_type(const Type_context
*)
12427 if (this->vals_
== NULL
)
12430 Map_type
* mt
= this->type_
->map_type();
12431 Type_context
key_context(mt
->key_type(), false);
12432 Type_context
val_context(mt
->val_type(), false);
12433 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12434 pv
!= this->vals_
->end();
12437 (*pv
)->determine_type(&key_context
);
12439 (*pv
)->determine_type(&val_context
);
12446 Map_construction_expression::do_check_types(Gogo
*)
12448 if (this->vals_
== NULL
)
12451 Map_type
* mt
= this->type_
->map_type();
12453 Type
* key_type
= mt
->key_type();
12454 Type
* val_type
= mt
->val_type();
12455 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12456 pv
!= this->vals_
->end();
12459 if (!Type::are_assignable(key_type
, (*pv
)->type(), NULL
))
12461 error_at((*pv
)->location(),
12462 "incompatible type for element %d key in map construction",
12464 this->set_is_error();
12467 if (!Type::are_assignable(val_type
, (*pv
)->type(), NULL
))
12469 error_at((*pv
)->location(),
12470 ("incompatible type for element %d value "
12471 "in map construction"),
12473 this->set_is_error();
12478 // Return the backend representation for constructing a map.
12481 Map_construction_expression::do_get_backend(Translate_context
* context
)
12483 if (this->is_error_expression())
12484 return context
->backend()->error_expression();
12485 Location loc
= this->location();
12488 Expression
* ventries
;
12489 if (this->vals_
== NULL
|| this->vals_
->empty())
12490 ventries
= Expression::make_nil(loc
);
12493 go_assert(this->constructor_temp_
!= NULL
);
12494 i
= this->vals_
->size() / 2;
12496 Expression
* ctor_ref
=
12497 Expression::make_temporary_reference(this->constructor_temp_
, loc
);
12498 ventries
= Expression::make_unary(OPERATOR_AND
, ctor_ref
, loc
);
12501 Map_type
* mt
= this->type_
->map_type();
12502 if (this->element_type_
== NULL
)
12503 this->element_type_
=
12504 Type::make_builtin_struct_type(2,
12505 "__key", mt
->key_type(),
12506 "__val", mt
->val_type());
12507 Expression
* descriptor
= Expression::make_map_descriptor(mt
, loc
);
12509 Type
* uintptr_t = Type::lookup_integer_type("uintptr");
12510 Expression
* count
= Expression::make_integer_ul(i
, uintptr_t, loc
);
12512 Expression
* entry_size
=
12513 Expression::make_type_info(this->element_type_
, TYPE_INFO_SIZE
);
12515 unsigned int field_index
;
12516 const Struct_field
* valfield
=
12517 this->element_type_
->find_local_field("__val", &field_index
);
12518 Expression
* val_offset
=
12519 Expression::make_struct_field_offset(this->element_type_
, valfield
);
12520 Expression
* val_size
=
12521 Expression::make_type_info(mt
->val_type(), TYPE_INFO_SIZE
);
12523 Expression
* map_ctor
=
12524 Runtime::make_call(Runtime::CONSTRUCT_MAP
, loc
, 6, descriptor
, count
,
12525 entry_size
, val_offset
, val_size
, ventries
);
12526 return map_ctor
->get_backend(context
);
12529 // Export an array construction.
12532 Map_construction_expression::do_export(Export
* exp
) const
12534 exp
->write_c_string("convert(");
12535 exp
->write_type(this->type_
);
12536 for (Expression_list::const_iterator pv
= this->vals_
->begin();
12537 pv
!= this->vals_
->end();
12540 exp
->write_c_string(", ");
12541 (*pv
)->export_expression(exp
);
12543 exp
->write_c_string(")");
12546 // Dump ast representation for a map construction expression.
12549 Map_construction_expression::do_dump_expression(
12550 Ast_dump_context
* ast_dump_context
) const
12552 ast_dump_context
->ostream() << "{" ;
12553 ast_dump_context
->dump_expression_list(this->vals_
, true);
12554 ast_dump_context
->ostream() << "}";
12557 // A general composite literal. This is lowered to a type specific
12560 class Composite_literal_expression
: public Parser_expression
12563 Composite_literal_expression(Type
* type
, int depth
, bool has_keys
,
12564 Expression_list
* vals
, bool all_are_names
,
12566 : Parser_expression(EXPRESSION_COMPOSITE_LITERAL
, location
),
12567 type_(type
), depth_(depth
), vals_(vals
), has_keys_(has_keys
),
12568 all_are_names_(all_are_names
)
12573 do_traverse(Traverse
* traverse
);
12576 do_lower(Gogo
*, Named_object
*, Statement_inserter
*, int);
12581 return new Composite_literal_expression(this->type_
, this->depth_
,
12583 (this->vals_
== NULL
12585 : this->vals_
->copy()),
12586 this->all_are_names_
,
12591 do_dump_expression(Ast_dump_context
*) const;
12595 lower_struct(Gogo
*, Type
*);
12598 lower_array(Type
*);
12601 make_array(Type
*, const std::vector
<unsigned long>*, Expression_list
*);
12604 lower_map(Gogo
*, Named_object
*, Statement_inserter
*, Type
*);
12606 // The type of the composite literal.
12608 // The depth within a list of composite literals within a composite
12609 // literal, when the type is omitted.
12611 // The values to put in the composite literal.
12612 Expression_list
* vals_
;
12613 // If this is true, then VALS_ is a list of pairs: a key and a
12614 // value. In an array initializer, a missing key will be NULL.
12616 // If this is true, then HAS_KEYS_ is true, and every key is a
12617 // simple identifier.
12618 bool all_are_names_
;
12624 Composite_literal_expression::do_traverse(Traverse
* traverse
)
12626 if (Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
12627 return TRAVERSE_EXIT
;
12629 // If this is a struct composite literal with keys, then the keys
12630 // are field names, not expressions. We don't want to traverse them
12631 // in that case. If we do, we can give an erroneous error "variable
12632 // initializer refers to itself." See bug482.go in the testsuite.
12633 if (this->has_keys_
&& this->vals_
!= NULL
)
12635 // The type may not be resolvable at this point.
12636 Type
* type
= this->type_
;
12638 for (int depth
= this->depth_
; depth
> 0; --depth
)
12640 if (type
->array_type() != NULL
)
12641 type
= type
->array_type()->element_type();
12642 else if (type
->map_type() != NULL
)
12643 type
= type
->map_type()->val_type();
12646 // This error will be reported during lowering.
12647 return TRAVERSE_CONTINUE
;
12653 if (type
->classification() == Type::TYPE_NAMED
)
12654 type
= type
->named_type()->real_type();
12655 else if (type
->classification() == Type::TYPE_FORWARD
)
12657 Type
* t
= type
->forwarded();
12666 if (type
->classification() == Type::TYPE_STRUCT
)
12668 Expression_list::iterator p
= this->vals_
->begin();
12669 while (p
!= this->vals_
->end())
12673 go_assert(p
!= this->vals_
->end());
12674 if (Expression::traverse(&*p
, traverse
) == TRAVERSE_EXIT
)
12675 return TRAVERSE_EXIT
;
12678 return TRAVERSE_CONTINUE
;
12682 if (this->vals_
!= NULL
)
12683 return this->vals_
->traverse(traverse
);
12685 return TRAVERSE_CONTINUE
;
12688 // Lower a generic composite literal into a specific version based on
12692 Composite_literal_expression::do_lower(Gogo
* gogo
, Named_object
* function
,
12693 Statement_inserter
* inserter
, int)
12695 Type
* type
= this->type_
;
12697 for (int depth
= this->depth_
; depth
> 0; --depth
)
12699 if (type
->array_type() != NULL
)
12700 type
= type
->array_type()->element_type();
12701 else if (type
->map_type() != NULL
)
12702 type
= type
->map_type()->val_type();
12705 if (!type
->is_error())
12706 error_at(this->location(),
12707 ("may only omit types within composite literals "
12708 "of slice, array, or map type"));
12709 return Expression::make_error(this->location());
12713 Type
*pt
= type
->points_to();
12714 bool is_pointer
= false;
12722 if (type
->is_error())
12723 return Expression::make_error(this->location());
12724 else if (type
->struct_type() != NULL
)
12725 ret
= this->lower_struct(gogo
, type
);
12726 else if (type
->array_type() != NULL
)
12727 ret
= this->lower_array(type
);
12728 else if (type
->map_type() != NULL
)
12729 ret
= this->lower_map(gogo
, function
, inserter
, type
);
12732 error_at(this->location(),
12733 ("expected struct, slice, array, or map type "
12734 "for composite literal"));
12735 return Expression::make_error(this->location());
12739 ret
= Expression::make_heap_expression(ret
, this->location());
12744 // Lower a struct composite literal.
12747 Composite_literal_expression::lower_struct(Gogo
* gogo
, Type
* type
)
12749 Location location
= this->location();
12750 Struct_type
* st
= type
->struct_type();
12751 if (this->vals_
== NULL
|| !this->has_keys_
)
12753 if (this->vals_
!= NULL
12754 && !this->vals_
->empty()
12755 && type
->named_type() != NULL
12756 && type
->named_type()->named_object()->package() != NULL
)
12758 for (Struct_field_list::const_iterator pf
= st
->fields()->begin();
12759 pf
!= st
->fields()->end();
12762 if (Gogo::is_hidden_name(pf
->field_name()))
12763 error_at(this->location(),
12764 "assignment of unexported field %qs in %qs literal",
12765 Gogo::message_name(pf
->field_name()).c_str(),
12766 type
->named_type()->message_name().c_str());
12770 return new Struct_construction_expression(type
, this->vals_
, location
);
12773 size_t field_count
= st
->field_count();
12774 std::vector
<Expression
*> vals(field_count
);
12775 std::vector
<int>* traverse_order
= new(std::vector
<int>);
12776 Expression_list::const_iterator p
= this->vals_
->begin();
12777 Expression
* external_expr
= NULL
;
12778 const Named_object
* external_no
= NULL
;
12779 while (p
!= this->vals_
->end())
12781 Expression
* name_expr
= *p
;
12784 go_assert(p
!= this->vals_
->end());
12785 Expression
* val
= *p
;
12789 if (name_expr
== NULL
)
12791 error_at(val
->location(), "mixture of field and value initializers");
12792 return Expression::make_error(location
);
12795 bool bad_key
= false;
12797 const Named_object
* no
= NULL
;
12798 switch (name_expr
->classification())
12800 case EXPRESSION_UNKNOWN_REFERENCE
:
12801 name
= name_expr
->unknown_expression()->name();
12802 if (type
->named_type() != NULL
)
12804 // If the named object found for this field name comes from a
12805 // different package than the struct it is a part of, do not count
12806 // this incorrect lookup as a usage of the object's package.
12807 no
= name_expr
->unknown_expression()->named_object();
12808 if (no
->package() != NULL
12809 && no
->package() != type
->named_type()->named_object()->package())
12810 no
->package()->forget_usage(name_expr
);
12814 case EXPRESSION_CONST_REFERENCE
:
12815 no
= static_cast<Const_expression
*>(name_expr
)->named_object();
12818 case EXPRESSION_TYPE
:
12820 Type
* t
= name_expr
->type();
12821 Named_type
* nt
= t
->named_type();
12825 no
= nt
->named_object();
12829 case EXPRESSION_VAR_REFERENCE
:
12830 no
= name_expr
->var_expression()->named_object();
12833 case EXPRESSION_FUNC_REFERENCE
:
12834 no
= name_expr
->func_expression()->named_object();
12837 case EXPRESSION_UNARY
:
12838 // If there is a local variable around with the same name as
12839 // the field, and this occurs in the closure, then the
12840 // parser may turn the field reference into an indirection
12841 // through the closure. FIXME: This is a mess.
12844 Unary_expression
* ue
= static_cast<Unary_expression
*>(name_expr
);
12845 if (ue
->op() == OPERATOR_MULT
)
12847 Field_reference_expression
* fre
=
12848 ue
->operand()->field_reference_expression();
12852 fre
->expr()->type()->deref()->struct_type();
12855 const Struct_field
* sf
= st
->field(fre
->field_index());
12856 name
= sf
->field_name();
12858 // See below. FIXME.
12859 if (!Gogo::is_hidden_name(name
)
12863 if (gogo
->lookup_global(name
.c_str()) != NULL
)
12864 name
= gogo
->pack_hidden_name(name
, false);
12868 snprintf(buf
, sizeof buf
, "%u", fre
->field_index());
12869 size_t buflen
= strlen(buf
);
12870 if (name
.compare(name
.length() - buflen
, buflen
, buf
)
12873 name
= name
.substr(0, name
.length() - buflen
);
12888 error_at(name_expr
->location(), "expected struct field name");
12889 return Expression::make_error(location
);
12894 if (no
->package() != NULL
&& external_expr
== NULL
)
12896 external_expr
= name_expr
;
12902 // A predefined name won't be packed. If it starts with a
12903 // lower case letter we need to check for that case, because
12904 // the field name will be packed. FIXME.
12905 if (!Gogo::is_hidden_name(name
)
12909 Named_object
* gno
= gogo
->lookup_global(name
.c_str());
12911 name
= gogo
->pack_hidden_name(name
, false);
12915 unsigned int index
;
12916 const Struct_field
* sf
= st
->find_local_field(name
, &index
);
12919 error_at(name_expr
->location(), "unknown field %qs in %qs",
12920 Gogo::message_name(name
).c_str(),
12921 (type
->named_type() != NULL
12922 ? type
->named_type()->message_name().c_str()
12923 : "unnamed struct"));
12924 return Expression::make_error(location
);
12926 if (vals
[index
] != NULL
)
12928 error_at(name_expr
->location(),
12929 "duplicate value for field %qs in %qs",
12930 Gogo::message_name(name
).c_str(),
12931 (type
->named_type() != NULL
12932 ? type
->named_type()->message_name().c_str()
12933 : "unnamed struct"));
12934 return Expression::make_error(location
);
12937 if (type
->named_type() != NULL
12938 && type
->named_type()->named_object()->package() != NULL
12939 && Gogo::is_hidden_name(sf
->field_name()))
12940 error_at(name_expr
->location(),
12941 "assignment of unexported field %qs in %qs literal",
12942 Gogo::message_name(sf
->field_name()).c_str(),
12943 type
->named_type()->message_name().c_str());
12946 traverse_order
->push_back(index
);
12949 if (!this->all_are_names_
)
12951 // This is a weird case like bug462 in the testsuite.
12952 if (external_expr
== NULL
)
12953 error_at(this->location(), "unknown field in %qs literal",
12954 (type
->named_type() != NULL
12955 ? type
->named_type()->message_name().c_str()
12956 : "unnamed struct"));
12958 error_at(external_expr
->location(), "unknown field %qs in %qs",
12959 external_no
->message_name().c_str(),
12960 (type
->named_type() != NULL
12961 ? type
->named_type()->message_name().c_str()
12962 : "unnamed struct"));
12963 return Expression::make_error(location
);
12966 Expression_list
* list
= new Expression_list
;
12967 list
->reserve(field_count
);
12968 for (size_t i
= 0; i
< field_count
; ++i
)
12969 list
->push_back(vals
[i
]);
12971 Struct_construction_expression
* ret
=
12972 new Struct_construction_expression(type
, list
, location
);
12973 ret
->set_traverse_order(traverse_order
);
12977 // Used to sort an index/value array.
12979 class Index_value_compare
12983 operator()(const std::pair
<unsigned long, Expression
*>& a
,
12984 const std::pair
<unsigned long, Expression
*>& b
)
12985 { return a
.first
< b
.first
; }
12988 // Lower an array composite literal.
12991 Composite_literal_expression::lower_array(Type
* type
)
12993 Location location
= this->location();
12994 if (this->vals_
== NULL
|| !this->has_keys_
)
12995 return this->make_array(type
, NULL
, this->vals_
);
12997 std::vector
<unsigned long>* indexes
= new std::vector
<unsigned long>;
12998 indexes
->reserve(this->vals_
->size());
12999 bool indexes_out_of_order
= false;
13000 Expression_list
* vals
= new Expression_list();
13001 vals
->reserve(this->vals_
->size());
13002 unsigned long index
= 0;
13003 Expression_list::const_iterator p
= this->vals_
->begin();
13004 while (p
!= this->vals_
->end())
13006 Expression
* index_expr
= *p
;
13009 go_assert(p
!= this->vals_
->end());
13010 Expression
* val
= *p
;
13014 if (index_expr
== NULL
)
13016 if (!indexes
->empty())
13017 indexes
->push_back(index
);
13021 if (indexes
->empty() && !vals
->empty())
13023 for (size_t i
= 0; i
< vals
->size(); ++i
)
13024 indexes
->push_back(i
);
13027 Numeric_constant nc
;
13028 if (!index_expr
->numeric_constant_value(&nc
))
13030 error_at(index_expr
->location(),
13031 "index expression is not integer constant");
13032 return Expression::make_error(location
);
13035 switch (nc
.to_unsigned_long(&index
))
13037 case Numeric_constant::NC_UL_VALID
:
13039 case Numeric_constant::NC_UL_NOTINT
:
13040 error_at(index_expr
->location(),
13041 "index expression is not integer constant");
13042 return Expression::make_error(location
);
13043 case Numeric_constant::NC_UL_NEGATIVE
:
13044 error_at(index_expr
->location(), "index expression is negative");
13045 return Expression::make_error(location
);
13046 case Numeric_constant::NC_UL_BIG
:
13047 error_at(index_expr
->location(), "index value overflow");
13048 return Expression::make_error(location
);
13053 Named_type
* ntype
= Type::lookup_integer_type("int");
13054 Integer_type
* inttype
= ntype
->integer_type();
13055 if (sizeof(index
) <= static_cast<size_t>(inttype
->bits() * 8)
13056 && index
>> (inttype
->bits() - 1) != 0)
13058 error_at(index_expr
->location(), "index value overflow");
13059 return Expression::make_error(location
);
13062 if (std::find(indexes
->begin(), indexes
->end(), index
)
13065 error_at(index_expr
->location(), "duplicate value for index %lu",
13067 return Expression::make_error(location
);
13070 if (!indexes
->empty() && index
< indexes
->back())
13071 indexes_out_of_order
= true;
13073 indexes
->push_back(index
);
13076 vals
->push_back(val
);
13081 if (indexes
->empty())
13087 if (indexes_out_of_order
)
13089 typedef std::vector
<std::pair
<unsigned long, Expression
*> > V
;
13092 v
.reserve(indexes
->size());
13093 std::vector
<unsigned long>::const_iterator pi
= indexes
->begin();
13094 for (Expression_list::const_iterator pe
= vals
->begin();
13097 v
.push_back(std::make_pair(*pi
, *pe
));
13099 std::sort(v
.begin(), v
.end(), Index_value_compare());
13103 indexes
= new std::vector
<unsigned long>();
13104 indexes
->reserve(v
.size());
13105 vals
= new Expression_list();
13106 vals
->reserve(v
.size());
13108 for (V::const_iterator p
= v
.begin(); p
!= v
.end(); ++p
)
13110 indexes
->push_back(p
->first
);
13111 vals
->push_back(p
->second
);
13115 return this->make_array(type
, indexes
, vals
);
13118 // Actually build the array composite literal. This handles
13122 Composite_literal_expression::make_array(
13124 const std::vector
<unsigned long>* indexes
,
13125 Expression_list
* vals
)
13127 Location location
= this->location();
13128 Array_type
* at
= type
->array_type();
13130 if (at
->length() != NULL
&& at
->length()->is_nil_expression())
13135 else if (indexes
!= NULL
)
13136 size
= indexes
->back() + 1;
13139 size
= vals
->size();
13140 Integer_type
* it
= Type::lookup_integer_type("int")->integer_type();
13141 if (sizeof(size
) <= static_cast<size_t>(it
->bits() * 8)
13142 && size
>> (it
->bits() - 1) != 0)
13144 error_at(location
, "too many elements in composite literal");
13145 return Expression::make_error(location
);
13149 Expression
* elen
= Expression::make_integer_ul(size
, NULL
, location
);
13150 at
= Type::make_array_type(at
->element_type(), elen
);
13153 else if (at
->length() != NULL
13154 && !at
->length()->is_error_expression()
13155 && this->vals_
!= NULL
)
13157 Numeric_constant nc
;
13159 if (at
->length()->numeric_constant_value(&nc
)
13160 && nc
.to_unsigned_long(&val
) == Numeric_constant::NC_UL_VALID
)
13162 if (indexes
== NULL
)
13164 if (this->vals_
->size() > val
)
13166 error_at(location
, "too many elements in composite literal");
13167 return Expression::make_error(location
);
13172 unsigned long max
= indexes
->back();
13176 ("some element keys in composite literal "
13177 "are out of range"));
13178 return Expression::make_error(location
);
13184 if (at
->length() != NULL
)
13185 return new Fixed_array_construction_expression(type
, indexes
, vals
,
13188 return new Slice_construction_expression(type
, indexes
, vals
, location
);
13191 // Lower a map composite literal.
13194 Composite_literal_expression::lower_map(Gogo
* gogo
, Named_object
* function
,
13195 Statement_inserter
* inserter
,
13198 Location location
= this->location();
13199 if (this->vals_
!= NULL
)
13201 if (!this->has_keys_
)
13203 error_at(location
, "map composite literal must have keys");
13204 return Expression::make_error(location
);
13207 for (Expression_list::iterator p
= this->vals_
->begin();
13208 p
!= this->vals_
->end();
13214 error_at((*p
)->location(),
13215 "map composite literal must have keys for every value");
13216 return Expression::make_error(location
);
13218 // Make sure we have lowered the key; it may not have been
13219 // lowered in order to handle keys for struct composite
13220 // literals. Lower it now to get the right error message.
13221 if ((*p
)->unknown_expression() != NULL
)
13223 (*p
)->unknown_expression()->clear_is_composite_literal_key();
13224 gogo
->lower_expression(function
, inserter
, &*p
);
13225 go_assert((*p
)->is_error_expression());
13226 return Expression::make_error(location
);
13231 return new Map_construction_expression(type
, this->vals_
, location
);
13234 // Dump ast representation for a composite literal expression.
13237 Composite_literal_expression::do_dump_expression(
13238 Ast_dump_context
* ast_dump_context
) const
13240 ast_dump_context
->ostream() << "composite(";
13241 ast_dump_context
->dump_type(this->type_
);
13242 ast_dump_context
->ostream() << ", {";
13243 ast_dump_context
->dump_expression_list(this->vals_
, this->has_keys_
);
13244 ast_dump_context
->ostream() << "})";
13247 // Make a composite literal expression.
13250 Expression::make_composite_literal(Type
* type
, int depth
, bool has_keys
,
13251 Expression_list
* vals
, bool all_are_names
,
13254 return new Composite_literal_expression(type
, depth
, has_keys
, vals
,
13255 all_are_names
, location
);
13258 // Return whether this expression is a composite literal.
13261 Expression::is_composite_literal() const
13263 switch (this->classification_
)
13265 case EXPRESSION_COMPOSITE_LITERAL
:
13266 case EXPRESSION_STRUCT_CONSTRUCTION
:
13267 case EXPRESSION_FIXED_ARRAY_CONSTRUCTION
:
13268 case EXPRESSION_SLICE_CONSTRUCTION
:
13269 case EXPRESSION_MAP_CONSTRUCTION
:
13276 // Return whether this expression is a composite literal which is not
13280 Expression::is_nonconstant_composite_literal() const
13282 switch (this->classification_
)
13284 case EXPRESSION_STRUCT_CONSTRUCTION
:
13286 const Struct_construction_expression
*psce
=
13287 static_cast<const Struct_construction_expression
*>(this);
13288 return !psce
->is_constant_struct();
13290 case EXPRESSION_FIXED_ARRAY_CONSTRUCTION
:
13292 const Fixed_array_construction_expression
*pace
=
13293 static_cast<const Fixed_array_construction_expression
*>(this);
13294 return !pace
->is_constant_array();
13296 case EXPRESSION_SLICE_CONSTRUCTION
:
13298 const Slice_construction_expression
*pace
=
13299 static_cast<const Slice_construction_expression
*>(this);
13300 return !pace
->is_constant_array();
13302 case EXPRESSION_MAP_CONSTRUCTION
:
13309 // Return true if this is a variable or temporary_variable.
13312 Expression::is_variable() const
13314 switch (this->classification_
)
13316 case EXPRESSION_VAR_REFERENCE
:
13317 case EXPRESSION_TEMPORARY_REFERENCE
:
13318 case EXPRESSION_SET_AND_USE_TEMPORARY
:
13325 // Return true if this is a reference to a local variable.
13328 Expression::is_local_variable() const
13330 const Var_expression
* ve
= this->var_expression();
13333 const Named_object
* no
= ve
->named_object();
13334 return (no
->is_result_variable()
13335 || (no
->is_variable() && !no
->var_value()->is_global()));
13338 // Class Type_guard_expression.
13343 Type_guard_expression::do_traverse(Traverse
* traverse
)
13345 if (Expression::traverse(&this->expr_
, traverse
) == TRAVERSE_EXIT
13346 || Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
13347 return TRAVERSE_EXIT
;
13348 return TRAVERSE_CONTINUE
;
13352 Type_guard_expression::do_flatten(Gogo
*, Named_object
*,
13353 Statement_inserter
* inserter
)
13355 if (!this->expr_
->is_variable())
13357 Temporary_statement
* temp
= Statement::make_temporary(NULL
, this->expr_
,
13359 inserter
->insert(temp
);
13361 Expression::make_temporary_reference(temp
, this->location());
13366 // Check types of a type guard expression. The expression must have
13367 // an interface type, but the actual type conversion is checked at run
13371 Type_guard_expression::do_check_types(Gogo
*)
13373 Type
* expr_type
= this->expr_
->type();
13374 if (expr_type
->interface_type() == NULL
)
13376 if (!expr_type
->is_error() && !this->type_
->is_error())
13377 this->report_error(_("type assertion only valid for interface types"));
13378 this->set_is_error();
13380 else if (this->type_
->interface_type() == NULL
)
13382 std::string reason
;
13383 if (!expr_type
->interface_type()->implements_interface(this->type_
,
13386 if (!this->type_
->is_error())
13388 if (reason
.empty())
13389 this->report_error(_("impossible type assertion: "
13390 "type does not implement interface"));
13392 error_at(this->location(),
13393 ("impossible type assertion: "
13394 "type does not implement interface (%s)"),
13397 this->set_is_error();
13402 // Return the backend representation for a type guard expression.
13405 Type_guard_expression::do_get_backend(Translate_context
* context
)
13407 Expression
* conversion
;
13408 if (this->type_
->interface_type() != NULL
)
13410 Expression::convert_interface_to_interface(this->type_
, this->expr_
,
13411 true, this->location());
13414 Expression::convert_for_assignment(context
->gogo(), this->type_
,
13415 this->expr_
, this->location());
13417 return conversion
->get_backend(context
);
13420 // Dump ast representation for a type guard expression.
13423 Type_guard_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
)
13426 this->expr_
->dump_expression(ast_dump_context
);
13427 ast_dump_context
->ostream() << ".";
13428 ast_dump_context
->dump_type(this->type_
);
13431 // Make a type guard expression.
13434 Expression::make_type_guard(Expression
* expr
, Type
* type
,
13437 return new Type_guard_expression(expr
, type
, location
);
13440 // Class Heap_expression.
13442 // When you take the address of an escaping expression, it is allocated
13443 // on the heap. This class implements that.
13445 class Heap_expression
: public Expression
13448 Heap_expression(Expression
* expr
, Location location
)
13449 : Expression(EXPRESSION_HEAP
, location
),
13455 do_traverse(Traverse
* traverse
)
13456 { return Expression::traverse(&this->expr_
, traverse
); }
13460 { return Type::make_pointer_type(this->expr_
->type()); }
13463 do_determine_type(const Type_context
*)
13464 { this->expr_
->determine_type_no_context(); }
13469 return Expression::make_heap_expression(this->expr_
->copy(),
13474 do_get_backend(Translate_context
*);
13476 // We only export global objects, and the parser does not generate
13477 // this in global scope.
13479 do_export(Export
*) const
13480 { go_unreachable(); }
13483 do_dump_expression(Ast_dump_context
*) const;
13486 // The expression which is being put on the heap.
13490 // Return the backend representation for allocating an expression on the heap.
13493 Heap_expression::do_get_backend(Translate_context
* context
)
13495 if (this->expr_
->is_error_expression() || this->expr_
->type()->is_error())
13496 return context
->backend()->error_expression();
13498 Location loc
= this->location();
13499 Gogo
* gogo
= context
->gogo();
13500 Btype
* btype
= this->type()->get_backend(gogo
);
13501 Bexpression
* space
= Expression::make_allocation(this->expr_
->type(),
13502 loc
)->get_backend(context
);
13505 Named_object
* fn
= context
->function();
13506 go_assert(fn
!= NULL
);
13507 Bfunction
* fndecl
= fn
->func_value()->get_or_make_decl(gogo
, fn
);
13508 Bvariable
* space_temp
=
13509 gogo
->backend()->temporary_variable(fndecl
, context
->bblock(), btype
,
13510 space
, true, loc
, &decl
);
13511 space
= gogo
->backend()->var_expression(space_temp
, loc
);
13512 Btype
* expr_btype
= this->expr_
->type()->get_backend(gogo
);
13514 gogo
->backend()->indirect_expression(expr_btype
, space
, true, loc
);
13516 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
13517 Bstatement
* assn
= gogo
->backend()->assignment_statement(ref
, bexpr
, loc
);
13518 decl
= gogo
->backend()->compound_statement(decl
, assn
);
13519 space
= gogo
->backend()->var_expression(space_temp
, loc
);
13520 return gogo
->backend()->compound_expression(decl
, space
, loc
);
13523 // Dump ast representation for a heap expression.
13526 Heap_expression::do_dump_expression(
13527 Ast_dump_context
* ast_dump_context
) const
13529 ast_dump_context
->ostream() << "&(";
13530 ast_dump_context
->dump_expression(this->expr_
);
13531 ast_dump_context
->ostream() << ")";
13534 // Allocate an expression on the heap.
13537 Expression::make_heap_expression(Expression
* expr
, Location location
)
13539 return new Heap_expression(expr
, location
);
13542 // Class Receive_expression.
13544 // Return the type of a receive expression.
13547 Receive_expression::do_type()
13549 Channel_type
* channel_type
= this->channel_
->type()->channel_type();
13550 if (channel_type
== NULL
)
13551 return Type::make_error_type();
13552 return channel_type
->element_type();
13555 // Check types for a receive expression.
13558 Receive_expression::do_check_types(Gogo
*)
13560 Type
* type
= this->channel_
->type();
13561 if (type
->is_error())
13563 this->set_is_error();
13566 if (type
->channel_type() == NULL
)
13568 this->report_error(_("expected channel"));
13571 if (!type
->channel_type()->may_receive())
13573 this->report_error(_("invalid receive on send-only channel"));
13578 // Flattening for receive expressions creates a temporary variable to store
13579 // received data in for receives.
13582 Receive_expression::do_flatten(Gogo
*, Named_object
*,
13583 Statement_inserter
* inserter
)
13585 Channel_type
* channel_type
= this->channel_
->type()->channel_type();
13586 if (channel_type
== NULL
)
13588 go_assert(saw_errors());
13592 Type
* element_type
= channel_type
->element_type();
13593 if (this->temp_receiver_
== NULL
)
13595 this->temp_receiver_
= Statement::make_temporary(element_type
, NULL
,
13597 this->temp_receiver_
->set_is_address_taken();
13598 inserter
->insert(this->temp_receiver_
);
13604 // Get the backend representation for a receive expression.
13607 Receive_expression::do_get_backend(Translate_context
* context
)
13609 Location loc
= this->location();
13611 Channel_type
* channel_type
= this->channel_
->type()->channel_type();
13612 if (channel_type
== NULL
)
13614 go_assert(this->channel_
->type()->is_error());
13615 return context
->backend()->error_expression();
13617 Expression
* td
= Expression::make_type_descriptor(channel_type
, loc
);
13619 Expression
* recv_ref
=
13620 Expression::make_temporary_reference(this->temp_receiver_
, loc
);
13621 Expression
* recv_addr
=
13622 Expression::make_temporary_reference(this->temp_receiver_
, loc
);
13623 recv_addr
= Expression::make_unary(OPERATOR_AND
, recv_addr
, loc
);
13625 Runtime::make_call(Runtime::RECEIVE
, loc
, 3,
13626 td
, this->channel_
, recv_addr
);
13627 return Expression::make_compound(recv
, recv_ref
, loc
)->get_backend(context
);
13630 // Dump ast representation for a receive expression.
13633 Receive_expression::do_dump_expression(Ast_dump_context
* ast_dump_context
) const
13635 ast_dump_context
->ostream() << " <- " ;
13636 ast_dump_context
->dump_expression(channel_
);
13639 // Make a receive expression.
13641 Receive_expression
*
13642 Expression::make_receive(Expression
* channel
, Location location
)
13644 return new Receive_expression(channel
, location
);
13647 // An expression which evaluates to a pointer to the type descriptor
13650 class Type_descriptor_expression
: public Expression
13653 Type_descriptor_expression(Type
* type
, Location location
)
13654 : Expression(EXPRESSION_TYPE_DESCRIPTOR
, location
),
13661 { return Type::make_type_descriptor_ptr_type(); }
13664 do_is_immutable() const
13668 do_determine_type(const Type_context
*)
13676 do_get_backend(Translate_context
* context
)
13678 return this->type_
->type_descriptor_pointer(context
->gogo(),
13683 do_dump_expression(Ast_dump_context
*) const;
13686 // The type for which this is the descriptor.
13690 // Dump ast representation for a type descriptor expression.
13693 Type_descriptor_expression::do_dump_expression(
13694 Ast_dump_context
* ast_dump_context
) const
13696 ast_dump_context
->dump_type(this->type_
);
13699 // Make a type descriptor expression.
13702 Expression::make_type_descriptor(Type
* type
, Location location
)
13704 return new Type_descriptor_expression(type
, location
);
13707 // An expression which evaluates to a pointer to the Garbage Collection symbol
13710 class GC_symbol_expression
: public Expression
13713 GC_symbol_expression(Type
* type
)
13714 : Expression(EXPRESSION_GC_SYMBOL
, Linemap::predeclared_location()),
13721 { return Type::lookup_integer_type("uintptr"); }
13724 do_is_immutable() const
13728 do_determine_type(const Type_context
*)
13736 do_get_backend(Translate_context
* context
)
13737 { return this->type_
->gc_symbol_pointer(context
->gogo()); }
13740 do_dump_expression(Ast_dump_context
*) const;
13743 // The type which this gc symbol describes.
13747 // Dump ast representation for a gc symbol expression.
13750 GC_symbol_expression::do_dump_expression(
13751 Ast_dump_context
* ast_dump_context
) const
13753 ast_dump_context
->ostream() << "gcdata(";
13754 ast_dump_context
->dump_type(this->type_
);
13755 ast_dump_context
->ostream() << ")";
13758 // Make a gc symbol expression.
13761 Expression::make_gc_symbol(Type
* type
)
13763 return new GC_symbol_expression(type
);
13766 // An expression which evaluates to some characteristic of a type.
13767 // This is only used to initialize fields of a type descriptor. Using
13768 // a new expression class is slightly inefficient but gives us a good
13769 // separation between the frontend and the middle-end with regard to
13770 // how types are laid out.
13772 class Type_info_expression
: public Expression
13775 Type_info_expression(Type
* type
, Type_info type_info
)
13776 : Expression(EXPRESSION_TYPE_INFO
, Linemap::predeclared_location()),
13777 type_(type
), type_info_(type_info
)
13782 do_is_immutable() const
13789 do_determine_type(const Type_context
*)
13797 do_get_backend(Translate_context
* context
);
13800 do_dump_expression(Ast_dump_context
*) const;
13803 // The type for which we are getting information.
13805 // What information we want.
13806 Type_info type_info_
;
13809 // The type is chosen to match what the type descriptor struct
13813 Type_info_expression::do_type()
13815 switch (this->type_info_
)
13817 case TYPE_INFO_SIZE
:
13818 return Type::lookup_integer_type("uintptr");
13819 case TYPE_INFO_ALIGNMENT
:
13820 case TYPE_INFO_FIELD_ALIGNMENT
:
13821 return Type::lookup_integer_type("uint8");
13827 // Return the backend representation for type information.
13830 Type_info_expression::do_get_backend(Translate_context
* context
)
13832 Btype
* btype
= this->type_
->get_backend(context
->gogo());
13833 Gogo
* gogo
= context
->gogo();
13835 switch (this->type_info_
)
13837 case TYPE_INFO_SIZE
:
13838 val
= gogo
->backend()->type_size(btype
);
13840 case TYPE_INFO_ALIGNMENT
:
13841 val
= gogo
->backend()->type_alignment(btype
);
13843 case TYPE_INFO_FIELD_ALIGNMENT
:
13844 val
= gogo
->backend()->type_field_alignment(btype
);
13850 mpz_init_set_ui(cst
, val
);
13851 Btype
* int_btype
= this->type()->get_backend(gogo
);
13853 gogo
->backend()->integer_constant_expression(int_btype
, cst
);
13858 // Dump ast representation for a type info expression.
13861 Type_info_expression::do_dump_expression(
13862 Ast_dump_context
* ast_dump_context
) const
13864 ast_dump_context
->ostream() << "typeinfo(";
13865 ast_dump_context
->dump_type(this->type_
);
13866 ast_dump_context
->ostream() << ",";
13867 ast_dump_context
->ostream() <<
13868 (this->type_info_
== TYPE_INFO_ALIGNMENT
? "alignment"
13869 : this->type_info_
== TYPE_INFO_FIELD_ALIGNMENT
? "field alignment"
13870 : this->type_info_
== TYPE_INFO_SIZE
? "size "
13872 ast_dump_context
->ostream() << ")";
13875 // Make a type info expression.
13878 Expression::make_type_info(Type
* type
, Type_info type_info
)
13880 return new Type_info_expression(type
, type_info
);
13883 // An expression that evaluates to some characteristic of a slice.
13884 // This is used when indexing, bound-checking, or nil checking a slice.
13886 class Slice_info_expression
: public Expression
13889 Slice_info_expression(Expression
* slice
, Slice_info slice_info
,
13891 : Expression(EXPRESSION_SLICE_INFO
, location
),
13892 slice_(slice
), slice_info_(slice_info
)
13900 do_determine_type(const Type_context
*)
13906 return new Slice_info_expression(this->slice_
->copy(), this->slice_info_
,
13911 do_get_backend(Translate_context
* context
);
13914 do_dump_expression(Ast_dump_context
*) const;
13917 do_issue_nil_check()
13918 { this->slice_
->issue_nil_check(); }
13921 // The slice for which we are getting information.
13922 Expression
* slice_
;
13923 // What information we want.
13924 Slice_info slice_info_
;
13927 // Return the type of the slice info.
13930 Slice_info_expression::do_type()
13932 switch (this->slice_info_
)
13934 case SLICE_INFO_VALUE_POINTER
:
13935 return Type::make_pointer_type(
13936 this->slice_
->type()->array_type()->element_type());
13937 case SLICE_INFO_LENGTH
:
13938 case SLICE_INFO_CAPACITY
:
13939 return Type::lookup_integer_type("int");
13945 // Return the backend information for slice information.
13948 Slice_info_expression::do_get_backend(Translate_context
* context
)
13950 Gogo
* gogo
= context
->gogo();
13951 Bexpression
* bslice
= this->slice_
->get_backend(context
);
13952 switch (this->slice_info_
)
13954 case SLICE_INFO_VALUE_POINTER
:
13955 case SLICE_INFO_LENGTH
:
13956 case SLICE_INFO_CAPACITY
:
13957 return gogo
->backend()->struct_field_expression(bslice
, this->slice_info_
,
13965 // Dump ast representation for a type info expression.
13968 Slice_info_expression::do_dump_expression(
13969 Ast_dump_context
* ast_dump_context
) const
13971 ast_dump_context
->ostream() << "sliceinfo(";
13972 this->slice_
->dump_expression(ast_dump_context
);
13973 ast_dump_context
->ostream() << ",";
13974 ast_dump_context
->ostream() <<
13975 (this->slice_info_
== SLICE_INFO_VALUE_POINTER
? "values"
13976 : this->slice_info_
== SLICE_INFO_LENGTH
? "length"
13977 : this->slice_info_
== SLICE_INFO_CAPACITY
? "capacity "
13979 ast_dump_context
->ostream() << ")";
13982 // Make a slice info expression.
13985 Expression::make_slice_info(Expression
* slice
, Slice_info slice_info
,
13988 return new Slice_info_expression(slice
, slice_info
, location
);
13991 // An expression that represents a slice value: a struct with value pointer,
13992 // length, and capacity fields.
13994 class Slice_value_expression
: public Expression
13997 Slice_value_expression(Type
* type
, Expression
* valptr
, Expression
* len
,
13998 Expression
* cap
, Location location
)
13999 : Expression(EXPRESSION_SLICE_VALUE
, location
),
14000 type_(type
), valptr_(valptr
), len_(len
), cap_(cap
)
14005 do_traverse(Traverse
*);
14009 { return this->type_
; }
14012 do_determine_type(const Type_context
*)
14013 { go_unreachable(); }
14018 return new Slice_value_expression(this->type_
, this->valptr_
->copy(),
14019 this->len_
->copy(), this->cap_
->copy(),
14024 do_get_backend(Translate_context
* context
);
14027 do_dump_expression(Ast_dump_context
*) const;
14030 // The type of the slice value.
14032 // The pointer to the values in the slice.
14033 Expression
* valptr_
;
14034 // The length of the slice.
14036 // The capacity of the slice.
14041 Slice_value_expression::do_traverse(Traverse
* traverse
)
14043 if (Expression::traverse(&this->valptr_
, traverse
) == TRAVERSE_EXIT
14044 || Expression::traverse(&this->len_
, traverse
) == TRAVERSE_EXIT
14045 || Expression::traverse(&this->cap_
, traverse
) == TRAVERSE_EXIT
)
14046 return TRAVERSE_EXIT
;
14047 return TRAVERSE_CONTINUE
;
14051 Slice_value_expression::do_get_backend(Translate_context
* context
)
14053 std::vector
<Bexpression
*> vals(3);
14054 vals
[0] = this->valptr_
->get_backend(context
);
14055 vals
[1] = this->len_
->get_backend(context
);
14056 vals
[2] = this->cap_
->get_backend(context
);
14058 Gogo
* gogo
= context
->gogo();
14059 Btype
* btype
= this->type_
->get_backend(gogo
);
14060 return gogo
->backend()->constructor_expression(btype
, vals
, this->location());
14064 Slice_value_expression::do_dump_expression(
14065 Ast_dump_context
* ast_dump_context
) const
14067 ast_dump_context
->ostream() << "slicevalue(";
14068 ast_dump_context
->ostream() << "values: ";
14069 this->valptr_
->dump_expression(ast_dump_context
);
14070 ast_dump_context
->ostream() << ", length: ";
14071 this->len_
->dump_expression(ast_dump_context
);
14072 ast_dump_context
->ostream() << ", capacity: ";
14073 this->cap_
->dump_expression(ast_dump_context
);
14074 ast_dump_context
->ostream() << ")";
14078 Expression::make_slice_value(Type
* at
, Expression
* valptr
, Expression
* len
,
14079 Expression
* cap
, Location location
)
14081 go_assert(at
->is_slice_type());
14082 return new Slice_value_expression(at
, valptr
, len
, cap
, location
);
14085 // An expression that evaluates to some characteristic of a non-empty interface.
14086 // This is used to access the method table or underlying object of an interface.
14088 class Interface_info_expression
: public Expression
14091 Interface_info_expression(Expression
* iface
, Interface_info iface_info
,
14093 : Expression(EXPRESSION_INTERFACE_INFO
, location
),
14094 iface_(iface
), iface_info_(iface_info
)
14102 do_determine_type(const Type_context
*)
14108 return new Interface_info_expression(this->iface_
->copy(),
14109 this->iface_info_
, this->location());
14113 do_get_backend(Translate_context
* context
);
14116 do_dump_expression(Ast_dump_context
*) const;
14119 do_issue_nil_check()
14120 { this->iface_
->issue_nil_check(); }
14123 // The interface for which we are getting information.
14124 Expression
* iface_
;
14125 // What information we want.
14126 Interface_info iface_info_
;
14129 // Return the type of the interface info.
14132 Interface_info_expression::do_type()
14134 switch (this->iface_info_
)
14136 case INTERFACE_INFO_METHODS
:
14138 Type
* pdt
= Type::make_type_descriptor_ptr_type();
14139 if (this->iface_
->type()->interface_type()->is_empty())
14142 Location loc
= this->location();
14143 Struct_field_list
* sfl
= new Struct_field_list();
14145 Struct_field(Typed_identifier("__type_descriptor", pdt
, loc
)));
14147 Interface_type
* itype
= this->iface_
->type()->interface_type();
14148 for (Typed_identifier_list::const_iterator p
= itype
->methods()->begin();
14149 p
!= itype
->methods()->end();
14152 Function_type
* ft
= p
->type()->function_type();
14153 go_assert(ft
->receiver() == NULL
);
14155 const Typed_identifier_list
* params
= ft
->parameters();
14156 Typed_identifier_list
* mparams
= new Typed_identifier_list();
14157 if (params
!= NULL
)
14158 mparams
->reserve(params
->size() + 1);
14159 Type
* vt
= Type::make_pointer_type(Type::make_void_type());
14160 mparams
->push_back(Typed_identifier("", vt
, ft
->location()));
14161 if (params
!= NULL
)
14163 for (Typed_identifier_list::const_iterator pp
= params
->begin();
14164 pp
!= params
->end();
14166 mparams
->push_back(*pp
);
14169 Typed_identifier_list
* mresults
= (ft
->results() == NULL
14171 : ft
->results()->copy());
14172 Backend_function_type
* mft
=
14173 Type::make_backend_function_type(NULL
, mparams
, mresults
,
14176 std::string fname
= Gogo::unpack_hidden_name(p
->name());
14177 sfl
->push_back(Struct_field(Typed_identifier(fname
, mft
, loc
)));
14180 return Type::make_pointer_type(Type::make_struct_type(sfl
, loc
));
14182 case INTERFACE_INFO_OBJECT
:
14183 return Type::make_pointer_type(Type::make_void_type());
14189 // Return the backend representation for interface information.
14192 Interface_info_expression::do_get_backend(Translate_context
* context
)
14194 Gogo
* gogo
= context
->gogo();
14195 Bexpression
* biface
= this->iface_
->get_backend(context
);
14196 switch (this->iface_info_
)
14198 case INTERFACE_INFO_METHODS
:
14199 case INTERFACE_INFO_OBJECT
:
14200 return gogo
->backend()->struct_field_expression(biface
, this->iface_info_
,
14208 // Dump ast representation for an interface info expression.
14211 Interface_info_expression::do_dump_expression(
14212 Ast_dump_context
* ast_dump_context
) const
14214 bool is_empty
= this->iface_
->type()->interface_type()->is_empty();
14215 ast_dump_context
->ostream() << "interfaceinfo(";
14216 this->iface_
->dump_expression(ast_dump_context
);
14217 ast_dump_context
->ostream() << ",";
14218 ast_dump_context
->ostream() <<
14219 (this->iface_info_
== INTERFACE_INFO_METHODS
&& !is_empty
? "methods"
14220 : this->iface_info_
== INTERFACE_INFO_TYPE_DESCRIPTOR
? "type_descriptor"
14221 : this->iface_info_
== INTERFACE_INFO_OBJECT
? "object"
14223 ast_dump_context
->ostream() << ")";
14226 // Make an interface info expression.
14229 Expression::make_interface_info(Expression
* iface
, Interface_info iface_info
,
14232 return new Interface_info_expression(iface
, iface_info
, location
);
14235 // An expression that represents an interface value. The first field is either
14236 // a type descriptor for an empty interface or a pointer to the interface method
14237 // table for a non-empty interface. The second field is always the object.
14239 class Interface_value_expression
: public Expression
14242 Interface_value_expression(Type
* type
, Expression
* first_field
,
14243 Expression
* obj
, Location location
)
14244 : Expression(EXPRESSION_INTERFACE_VALUE
, location
),
14245 type_(type
), first_field_(first_field
), obj_(obj
)
14250 do_traverse(Traverse
*);
14254 { return this->type_
; }
14257 do_determine_type(const Type_context
*)
14258 { go_unreachable(); }
14263 return new Interface_value_expression(this->type_
,
14264 this->first_field_
->copy(),
14265 this->obj_
->copy(), this->location());
14269 do_get_backend(Translate_context
* context
);
14272 do_dump_expression(Ast_dump_context
*) const;
14275 // The type of the interface value.
14277 // The first field of the interface (either a type descriptor or a pointer
14278 // to the method table.
14279 Expression
* first_field_
;
14280 // The underlying object of the interface.
14285 Interface_value_expression::do_traverse(Traverse
* traverse
)
14287 if (Expression::traverse(&this->first_field_
, traverse
) == TRAVERSE_EXIT
14288 || Expression::traverse(&this->obj_
, traverse
) == TRAVERSE_EXIT
)
14289 return TRAVERSE_EXIT
;
14290 return TRAVERSE_CONTINUE
;
14294 Interface_value_expression::do_get_backend(Translate_context
* context
)
14296 std::vector
<Bexpression
*> vals(2);
14297 vals
[0] = this->first_field_
->get_backend(context
);
14298 vals
[1] = this->obj_
->get_backend(context
);
14300 Gogo
* gogo
= context
->gogo();
14301 Btype
* btype
= this->type_
->get_backend(gogo
);
14302 return gogo
->backend()->constructor_expression(btype
, vals
, this->location());
14306 Interface_value_expression::do_dump_expression(
14307 Ast_dump_context
* ast_dump_context
) const
14309 ast_dump_context
->ostream() << "interfacevalue(";
14310 ast_dump_context
->ostream() <<
14311 (this->type_
->interface_type()->is_empty()
14312 ? "type_descriptor: "
14314 this->first_field_
->dump_expression(ast_dump_context
);
14315 ast_dump_context
->ostream() << ", object: ";
14316 this->obj_
->dump_expression(ast_dump_context
);
14317 ast_dump_context
->ostream() << ")";
14321 Expression::make_interface_value(Type
* type
, Expression
* first_value
,
14322 Expression
* object
, Location location
)
14324 return new Interface_value_expression(type
, first_value
, object
, location
);
14327 // An interface method table for a pair of types: an interface type and a type
14328 // that implements that interface.
14330 class Interface_mtable_expression
: public Expression
14333 Interface_mtable_expression(Interface_type
* itype
, Type
* type
,
14334 bool is_pointer
, Location location
)
14335 : Expression(EXPRESSION_INTERFACE_MTABLE
, location
),
14336 itype_(itype
), type_(type
), is_pointer_(is_pointer
),
14337 method_table_type_(NULL
), bvar_(NULL
)
14342 do_traverse(Traverse
*);
14348 is_immutable() const
14352 do_determine_type(const Type_context
*)
14353 { go_unreachable(); }
14358 return new Interface_mtable_expression(this->itype_
, this->type_
,
14359 this->is_pointer_
, this->location());
14363 do_is_addressable() const
14367 do_get_backend(Translate_context
* context
);
14370 do_dump_expression(Ast_dump_context
*) const;
14373 // The interface type for which the methods are defined.
14374 Interface_type
* itype_
;
14375 // The type to construct the interface method table for.
14377 // Whether this table contains the method set for the receiver type or the
14378 // pointer receiver type.
14380 // The type of the method table.
14381 Type
* method_table_type_
;
14382 // The backend variable that refers to the interface method table.
14387 Interface_mtable_expression::do_traverse(Traverse
* traverse
)
14389 if (Type::traverse(this->itype_
, traverse
) == TRAVERSE_EXIT
14390 || Type::traverse(this->type_
, traverse
) == TRAVERSE_EXIT
)
14391 return TRAVERSE_EXIT
;
14392 return TRAVERSE_CONTINUE
;
14396 Interface_mtable_expression::do_type()
14398 if (this->method_table_type_
!= NULL
)
14399 return this->method_table_type_
;
14401 const Typed_identifier_list
* interface_methods
= this->itype_
->methods();
14402 go_assert(!interface_methods
->empty());
14404 Struct_field_list
* sfl
= new Struct_field_list
;
14405 Typed_identifier
tid("__type_descriptor", Type::make_type_descriptor_ptr_type(),
14407 sfl
->push_back(Struct_field(tid
));
14408 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
14409 p
!= interface_methods
->end();
14411 sfl
->push_back(Struct_field(*p
));
14412 this->method_table_type_
= Type::make_struct_type(sfl
, this->location());
14413 return this->method_table_type_
;
14417 Interface_mtable_expression::do_get_backend(Translate_context
* context
)
14419 Gogo
* gogo
= context
->gogo();
14420 Location loc
= Linemap::predeclared_location();
14421 if (this->bvar_
!= NULL
)
14422 return gogo
->backend()->var_expression(this->bvar_
, this->location());
14424 const Typed_identifier_list
* interface_methods
= this->itype_
->methods();
14425 go_assert(!interface_methods
->empty());
14427 std::string mangled_name
= ((this->is_pointer_
? "__go_pimt__" : "__go_imt_")
14428 + this->itype_
->mangled_name(gogo
)
14430 + this->type_
->mangled_name(gogo
));
14432 // See whether this interface has any hidden methods.
14433 bool has_hidden_methods
= false;
14434 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
14435 p
!= interface_methods
->end();
14438 if (Gogo::is_hidden_name(p
->name()))
14440 has_hidden_methods
= true;
14445 // We already know that the named type is convertible to the
14446 // interface. If the interface has hidden methods, and the named
14447 // type is defined in a different package, then the interface
14448 // conversion table will be defined by that other package.
14449 if (has_hidden_methods
14450 && this->type_
->named_type() != NULL
14451 && this->type_
->named_type()->named_object()->package() != NULL
)
14453 Btype
* btype
= this->type()->get_backend(gogo
);
14455 gogo
->backend()->immutable_struct_reference(mangled_name
, btype
, loc
);
14456 return gogo
->backend()->var_expression(this->bvar_
, this->location());
14459 // The first element is the type descriptor.
14461 if (!this->is_pointer_
)
14462 td_type
= this->type_
;
14464 td_type
= Type::make_pointer_type(this->type_
);
14466 // Build an interface method table for a type: a type descriptor followed by a
14467 // list of function pointers, one for each interface method. This is used for
14469 Expression_list
* svals
= new Expression_list();
14470 svals
->push_back(Expression::make_type_descriptor(td_type
, loc
));
14472 Named_type
* nt
= this->type_
->named_type();
14473 Struct_type
* st
= this->type_
->struct_type();
14474 go_assert(nt
!= NULL
|| st
!= NULL
);
14476 for (Typed_identifier_list::const_iterator p
= interface_methods
->begin();
14477 p
!= interface_methods
->end();
14483 m
= nt
->method_function(p
->name(), &is_ambiguous
);
14485 m
= st
->method_function(p
->name(), &is_ambiguous
);
14486 go_assert(m
!= NULL
);
14487 Named_object
* no
= m
->named_object();
14489 go_assert(no
->is_function() || no
->is_function_declaration());
14490 svals
->push_back(Expression::make_func_code_reference(no
, loc
));
14493 Btype
* btype
= this->type()->get_backend(gogo
);
14494 Expression
* mtable
= Expression::make_struct_composite_literal(this->type(),
14496 Bexpression
* ctor
= mtable
->get_backend(context
);
14498 bool is_public
= has_hidden_methods
&& this->type_
->named_type() != NULL
;
14499 this->bvar_
= gogo
->backend()->immutable_struct(mangled_name
, false,
14500 !is_public
, btype
, loc
);
14501 gogo
->backend()->immutable_struct_set_init(this->bvar_
, mangled_name
, false,
14502 !is_public
, btype
, loc
, ctor
);
14503 return gogo
->backend()->var_expression(this->bvar_
, loc
);
14507 Interface_mtable_expression::do_dump_expression(
14508 Ast_dump_context
* ast_dump_context
) const
14510 ast_dump_context
->ostream() << "__go_"
14511 << (this->is_pointer_
? "pimt__" : "imt_");
14512 ast_dump_context
->dump_type(this->itype_
);
14513 ast_dump_context
->ostream() << "__";
14514 ast_dump_context
->dump_type(this->type_
);
14518 Expression::make_interface_mtable_ref(Interface_type
* itype
, Type
* type
,
14519 bool is_pointer
, Location location
)
14521 return new Interface_mtable_expression(itype
, type
, is_pointer
, location
);
14524 // An expression which evaluates to the offset of a field within a
14525 // struct. This, like Type_info_expression, q.v., is only used to
14526 // initialize fields of a type descriptor.
14528 class Struct_field_offset_expression
: public Expression
14531 Struct_field_offset_expression(Struct_type
* type
, const Struct_field
* field
)
14532 : Expression(EXPRESSION_STRUCT_FIELD_OFFSET
,
14533 Linemap::predeclared_location()),
14534 type_(type
), field_(field
)
14539 do_is_immutable() const
14544 { return Type::lookup_integer_type("uintptr"); }
14547 do_determine_type(const Type_context
*)
14555 do_get_backend(Translate_context
* context
);
14558 do_dump_expression(Ast_dump_context
*) const;
14561 // The type of the struct.
14562 Struct_type
* type_
;
14564 const Struct_field
* field_
;
14567 // Return the backend representation for a struct field offset.
14570 Struct_field_offset_expression::do_get_backend(Translate_context
* context
)
14572 const Struct_field_list
* fields
= this->type_
->fields();
14573 Struct_field_list::const_iterator p
;
14575 for (p
= fields
->begin();
14576 p
!= fields
->end();
14578 if (&*p
== this->field_
)
14580 go_assert(&*p
== this->field_
);
14582 Gogo
* gogo
= context
->gogo();
14583 Btype
* btype
= this->type_
->get_backend(gogo
);
14585 size_t offset
= gogo
->backend()->type_field_offset(btype
, i
);
14586 Type
* uptr_type
= Type::lookup_integer_type("uintptr");
14588 Expression::make_integer_ul(offset
, uptr_type
,
14589 Linemap::predeclared_location());
14590 return ret
->get_backend(context
);
14593 // Dump ast representation for a struct field offset expression.
14596 Struct_field_offset_expression::do_dump_expression(
14597 Ast_dump_context
* ast_dump_context
) const
14599 ast_dump_context
->ostream() << "unsafe.Offsetof(";
14600 ast_dump_context
->dump_type(this->type_
);
14601 ast_dump_context
->ostream() << '.';
14602 ast_dump_context
->ostream() <<
14603 Gogo::message_name(this->field_
->field_name());
14604 ast_dump_context
->ostream() << ")";
14607 // Make an expression for a struct field offset.
14610 Expression::make_struct_field_offset(Struct_type
* type
,
14611 const Struct_field
* field
)
14613 return new Struct_field_offset_expression(type
, field
);
14616 // An expression which evaluates to a pointer to the map descriptor of
14619 class Map_descriptor_expression
: public Expression
14622 Map_descriptor_expression(Map_type
* type
, Location location
)
14623 : Expression(EXPRESSION_MAP_DESCRIPTOR
, location
),
14630 { return Type::make_pointer_type(Map_type::make_map_descriptor_type()); }
14633 do_determine_type(const Type_context
*)
14641 do_get_backend(Translate_context
* context
)
14643 return this->type_
->map_descriptor_pointer(context
->gogo(),
14648 do_dump_expression(Ast_dump_context
*) const;
14651 // The type for which this is the descriptor.
14655 // Dump ast representation for a map descriptor expression.
14658 Map_descriptor_expression::do_dump_expression(
14659 Ast_dump_context
* ast_dump_context
) const
14661 ast_dump_context
->ostream() << "map_descriptor(";
14662 ast_dump_context
->dump_type(this->type_
);
14663 ast_dump_context
->ostream() << ")";
14666 // Make a map descriptor expression.
14669 Expression::make_map_descriptor(Map_type
* type
, Location location
)
14671 return new Map_descriptor_expression(type
, location
);
14674 // An expression which evaluates to the address of an unnamed label.
14676 class Label_addr_expression
: public Expression
14679 Label_addr_expression(Label
* label
, Location location
)
14680 : Expression(EXPRESSION_LABEL_ADDR
, location
),
14687 { return Type::make_pointer_type(Type::make_void_type()); }
14690 do_determine_type(const Type_context
*)
14695 { return new Label_addr_expression(this->label_
, this->location()); }
14698 do_get_backend(Translate_context
* context
)
14699 { return this->label_
->get_addr(context
, this->location()); }
14702 do_dump_expression(Ast_dump_context
* ast_dump_context
) const
14703 { ast_dump_context
->ostream() << this->label_
->name(); }
14706 // The label whose address we are taking.
14710 // Make an expression for the address of an unnamed label.
14713 Expression::make_label_addr(Label
* label
, Location location
)
14715 return new Label_addr_expression(label
, location
);
14718 // Conditional expressions.
14720 class Conditional_expression
: public Expression
14723 Conditional_expression(Expression
* cond
, Expression
* then_expr
,
14724 Expression
* else_expr
, Location location
)
14725 : Expression(EXPRESSION_CONDITIONAL
, location
),
14726 cond_(cond
), then_(then_expr
), else_(else_expr
)
14731 do_traverse(Traverse
*);
14737 do_determine_type(const Type_context
*);
14742 return new Conditional_expression(this->cond_
->copy(), this->then_
->copy(),
14743 this->else_
->copy(), this->location());
14747 do_get_backend(Translate_context
* context
);
14750 do_dump_expression(Ast_dump_context
*) const;
14753 // The condition to be checked.
14755 // The expression to execute if the condition is true.
14757 // The expression to execute if the condition is false.
14764 Conditional_expression::do_traverse(Traverse
* traverse
)
14766 if (Expression::traverse(&this->cond_
, traverse
) == TRAVERSE_EXIT
14767 || Expression::traverse(&this->then_
, traverse
) == TRAVERSE_EXIT
14768 || Expression::traverse(&this->else_
, traverse
) == TRAVERSE_EXIT
)
14769 return TRAVERSE_EXIT
;
14770 return TRAVERSE_CONTINUE
;
14773 // Return the type of the conditional expression.
14776 Conditional_expression::do_type()
14778 Type
* result_type
= Type::make_void_type();
14779 if (Type::are_identical(this->then_
->type(), this->else_
->type(), false,
14781 result_type
= this->then_
->type();
14782 else if (this->then_
->is_nil_expression()
14783 || this->else_
->is_nil_expression())
14784 result_type
= (!this->then_
->is_nil_expression()
14785 ? this->then_
->type()
14786 : this->else_
->type());
14787 return result_type
;
14790 // Determine type for a conditional expression.
14793 Conditional_expression::do_determine_type(const Type_context
* context
)
14795 this->cond_
->determine_type_no_context();
14796 this->then_
->determine_type(context
);
14797 this->else_
->determine_type(context
);
14800 // Get the backend representation of a conditional expression.
14803 Conditional_expression::do_get_backend(Translate_context
* context
)
14805 Gogo
* gogo
= context
->gogo();
14806 Btype
* result_btype
= this->type()->get_backend(gogo
);
14807 Bexpression
* cond
= this->cond_
->get_backend(context
);
14808 Bexpression
* then
= this->then_
->get_backend(context
);
14809 Bexpression
* belse
= this->else_
->get_backend(context
);
14810 return gogo
->backend()->conditional_expression(result_btype
, cond
, then
,
14811 belse
, this->location());
14814 // Dump ast representation of a conditional expression.
14817 Conditional_expression::do_dump_expression(
14818 Ast_dump_context
* ast_dump_context
) const
14820 ast_dump_context
->ostream() << "(";
14821 ast_dump_context
->dump_expression(this->cond_
);
14822 ast_dump_context
->ostream() << " ? ";
14823 ast_dump_context
->dump_expression(this->then_
);
14824 ast_dump_context
->ostream() << " : ";
14825 ast_dump_context
->dump_expression(this->else_
);
14826 ast_dump_context
->ostream() << ") ";
14829 // Make a conditional expression.
14832 Expression::make_conditional(Expression
* cond
, Expression
* then
,
14833 Expression
* else_expr
, Location location
)
14835 return new Conditional_expression(cond
, then
, else_expr
, location
);
14838 // Compound expressions.
14840 class Compound_expression
: public Expression
14843 Compound_expression(Expression
* init
, Expression
* expr
, Location location
)
14844 : Expression(EXPRESSION_COMPOUND
, location
), init_(init
), expr_(expr
)
14849 do_traverse(Traverse
*);
14855 do_determine_type(const Type_context
*);
14860 return new Compound_expression(this->init_
->copy(), this->expr_
->copy(),
14865 do_get_backend(Translate_context
* context
);
14868 do_dump_expression(Ast_dump_context
*) const;
14871 // The expression that is evaluated first and discarded.
14873 // The expression that is evaluated and returned.
14880 Compound_expression::do_traverse(Traverse
* traverse
)
14882 if (Expression::traverse(&this->init_
, traverse
) == TRAVERSE_EXIT
14883 || Expression::traverse(&this->expr_
, traverse
) == TRAVERSE_EXIT
)
14884 return TRAVERSE_EXIT
;
14885 return TRAVERSE_CONTINUE
;
14888 // Return the type of the compound expression.
14891 Compound_expression::do_type()
14893 return this->expr_
->type();
14896 // Determine type for a compound expression.
14899 Compound_expression::do_determine_type(const Type_context
* context
)
14901 this->init_
->determine_type_no_context();
14902 this->expr_
->determine_type(context
);
14905 // Get the backend representation of a compound expression.
14908 Compound_expression::do_get_backend(Translate_context
* context
)
14910 Gogo
* gogo
= context
->gogo();
14911 Bexpression
* binit
= this->init_
->get_backend(context
);
14912 Bstatement
* init_stmt
= gogo
->backend()->expression_statement(binit
);
14913 Bexpression
* bexpr
= this->expr_
->get_backend(context
);
14914 return gogo
->backend()->compound_expression(init_stmt
, bexpr
,
14918 // Dump ast representation of a conditional expression.
14921 Compound_expression::do_dump_expression(
14922 Ast_dump_context
* ast_dump_context
) const
14924 ast_dump_context
->ostream() << "(";
14925 ast_dump_context
->dump_expression(this->init_
);
14926 ast_dump_context
->ostream() << ",";
14927 ast_dump_context
->dump_expression(this->expr_
);
14928 ast_dump_context
->ostream() << ") ";
14931 // Make a compound expression.
14934 Expression::make_compound(Expression
* init
, Expression
* expr
, Location location
)
14936 return new Compound_expression(init
, expr
, location
);
14939 // Import an expression. This comes at the end in order to see the
14940 // various class definitions.
14943 Expression::import_expression(Import
* imp
)
14945 int c
= imp
->peek_char();
14946 if (imp
->match_c_string("- ")
14947 || imp
->match_c_string("! ")
14948 || imp
->match_c_string("^ "))
14949 return Unary_expression::do_import(imp
);
14951 return Binary_expression::do_import(imp
);
14952 else if (imp
->match_c_string("true")
14953 || imp
->match_c_string("false"))
14954 return Boolean_expression::do_import(imp
);
14956 return String_expression::do_import(imp
);
14957 else if (c
== '-' || (c
>= '0' && c
<= '9'))
14959 // This handles integers, floats and complex constants.
14960 return Integer_expression::do_import(imp
);
14962 else if (imp
->match_c_string("nil"))
14963 return Nil_expression::do_import(imp
);
14964 else if (imp
->match_c_string("convert"))
14965 return Type_conversion_expression::do_import(imp
);
14968 error_at(imp
->location(), "import error: expected expression");
14969 return Expression::make_error(imp
->location());
14973 // Class Expression_list.
14975 // Traverse the list.
14978 Expression_list::traverse(Traverse
* traverse
)
14980 for (Expression_list::iterator p
= this->begin();
14986 if (Expression::traverse(&*p
, traverse
) == TRAVERSE_EXIT
)
14987 return TRAVERSE_EXIT
;
14990 return TRAVERSE_CONTINUE
;
14996 Expression_list::copy()
14998 Expression_list
* ret
= new Expression_list();
14999 for (Expression_list::iterator p
= this->begin();
15004 ret
->push_back(NULL
);
15006 ret
->push_back((*p
)->copy());
15011 // Return whether an expression list has an error expression.
15014 Expression_list::contains_error() const
15016 for (Expression_list::const_iterator p
= this->begin();
15019 if (*p
!= NULL
&& (*p
)->is_error_expression())
15024 // Class Numeric_constant.
15028 Numeric_constant::~Numeric_constant()
15033 // Copy constructor.
15035 Numeric_constant::Numeric_constant(const Numeric_constant
& a
)
15036 : classification_(a
.classification_
), type_(a
.type_
)
15038 switch (a
.classification_
)
15044 mpz_init_set(this->u_
.int_val
, a
.u_
.int_val
);
15047 mpfr_init_set(this->u_
.float_val
, a
.u_
.float_val
, GMP_RNDN
);
15050 mpc_init2(this->u_
.complex_val
, mpc_precision
);
15051 mpc_set(this->u_
.complex_val
, a
.u_
.complex_val
, MPC_RNDNN
);
15058 // Assignment operator.
15061 Numeric_constant::operator=(const Numeric_constant
& a
)
15064 this->classification_
= a
.classification_
;
15065 this->type_
= a
.type_
;
15066 switch (a
.classification_
)
15072 mpz_init_set(this->u_
.int_val
, a
.u_
.int_val
);
15075 mpfr_init_set(this->u_
.float_val
, a
.u_
.float_val
, GMP_RNDN
);
15078 mpc_init2(this->u_
.complex_val
, mpc_precision
);
15079 mpc_set(this->u_
.complex_val
, a
.u_
.complex_val
, MPC_RNDNN
);
15087 // Clear the contents.
15090 Numeric_constant::clear()
15092 switch (this->classification_
)
15098 mpz_clear(this->u_
.int_val
);
15101 mpfr_clear(this->u_
.float_val
);
15104 mpc_clear(this->u_
.complex_val
);
15109 this->classification_
= NC_INVALID
;
15112 // Set to an unsigned long value.
15115 Numeric_constant::set_unsigned_long(Type
* type
, unsigned long val
)
15118 this->classification_
= NC_INT
;
15119 this->type_
= type
;
15120 mpz_init_set_ui(this->u_
.int_val
, val
);
15123 // Set to an integer value.
15126 Numeric_constant::set_int(Type
* type
, const mpz_t val
)
15129 this->classification_
= NC_INT
;
15130 this->type_
= type
;
15131 mpz_init_set(this->u_
.int_val
, val
);
15134 // Set to a rune value.
15137 Numeric_constant::set_rune(Type
* type
, const mpz_t val
)
15140 this->classification_
= NC_RUNE
;
15141 this->type_
= type
;
15142 mpz_init_set(this->u_
.int_val
, val
);
15145 // Set to a floating point value.
15148 Numeric_constant::set_float(Type
* type
, const mpfr_t val
)
15151 this->classification_
= NC_FLOAT
;
15152 this->type_
= type
;
15153 // Numeric constants do not have negative zero values, so remove
15154 // them here. They also don't have infinity or NaN values, but we
15155 // should never see them here.
15156 if (mpfr_zero_p(val
))
15157 mpfr_init_set_ui(this->u_
.float_val
, 0, GMP_RNDN
);
15159 mpfr_init_set(this->u_
.float_val
, val
, GMP_RNDN
);
15162 // Set to a complex value.
15165 Numeric_constant::set_complex(Type
* type
, const mpc_t val
)
15168 this->classification_
= NC_COMPLEX
;
15169 this->type_
= type
;
15170 mpc_init2(this->u_
.complex_val
, mpc_precision
);
15171 mpc_set(this->u_
.complex_val
, val
, MPC_RNDNN
);
15174 // Get an int value.
15177 Numeric_constant::get_int(mpz_t
* val
) const
15179 go_assert(this->is_int());
15180 mpz_init_set(*val
, this->u_
.int_val
);
15183 // Get a rune value.
15186 Numeric_constant::get_rune(mpz_t
* val
) const
15188 go_assert(this->is_rune());
15189 mpz_init_set(*val
, this->u_
.int_val
);
15192 // Get a floating point value.
15195 Numeric_constant::get_float(mpfr_t
* val
) const
15197 go_assert(this->is_float());
15198 mpfr_init_set(*val
, this->u_
.float_val
, GMP_RNDN
);
15201 // Get a complex value.
15204 Numeric_constant::get_complex(mpc_t
* val
) const
15206 go_assert(this->is_complex());
15207 mpc_init2(*val
, mpc_precision
);
15208 mpc_set(*val
, this->u_
.complex_val
, MPC_RNDNN
);
15211 // Express value as unsigned long if possible.
15213 Numeric_constant::To_unsigned_long
15214 Numeric_constant::to_unsigned_long(unsigned long* val
) const
15216 switch (this->classification_
)
15220 return this->mpz_to_unsigned_long(this->u_
.int_val
, val
);
15222 return this->mpfr_to_unsigned_long(this->u_
.float_val
, val
);
15224 if (!mpfr_zero_p(mpc_imagref(this->u_
.complex_val
)))
15225 return NC_UL_NOTINT
;
15226 return this->mpfr_to_unsigned_long(mpc_realref(this->u_
.complex_val
),
15233 // Express integer value as unsigned long if possible.
15235 Numeric_constant::To_unsigned_long
15236 Numeric_constant::mpz_to_unsigned_long(const mpz_t ival
,
15237 unsigned long *val
) const
15239 if (mpz_sgn(ival
) < 0)
15240 return NC_UL_NEGATIVE
;
15241 unsigned long ui
= mpz_get_ui(ival
);
15242 if (mpz_cmp_ui(ival
, ui
) != 0)
15245 return NC_UL_VALID
;
15248 // Express floating point value as unsigned long if possible.
15250 Numeric_constant::To_unsigned_long
15251 Numeric_constant::mpfr_to_unsigned_long(const mpfr_t fval
,
15252 unsigned long *val
) const
15254 if (!mpfr_integer_p(fval
))
15255 return NC_UL_NOTINT
;
15258 mpfr_get_z(ival
, fval
, GMP_RNDN
);
15259 To_unsigned_long ret
= this->mpz_to_unsigned_long(ival
, val
);
15264 // Convert value to integer if possible.
15267 Numeric_constant::to_int(mpz_t
* val
) const
15269 switch (this->classification_
)
15273 mpz_init_set(*val
, this->u_
.int_val
);
15276 if (!mpfr_integer_p(this->u_
.float_val
))
15279 mpfr_get_z(*val
, this->u_
.float_val
, GMP_RNDN
);
15282 if (!mpfr_zero_p(mpc_imagref(this->u_
.complex_val
))
15283 || !mpfr_integer_p(mpc_realref(this->u_
.complex_val
)))
15286 mpfr_get_z(*val
, mpc_realref(this->u_
.complex_val
), GMP_RNDN
);
15293 // Convert value to floating point if possible.
15296 Numeric_constant::to_float(mpfr_t
* val
) const
15298 switch (this->classification_
)
15302 mpfr_init_set_z(*val
, this->u_
.int_val
, GMP_RNDN
);
15305 mpfr_init_set(*val
, this->u_
.float_val
, GMP_RNDN
);
15308 if (!mpfr_zero_p(mpc_imagref(this->u_
.complex_val
)))
15310 mpfr_init_set(*val
, mpc_realref(this->u_
.complex_val
), GMP_RNDN
);
15317 // Convert value to complex.
15320 Numeric_constant::to_complex(mpc_t
* val
) const
15322 mpc_init2(*val
, mpc_precision
);
15323 switch (this->classification_
)
15327 mpc_set_z(*val
, this->u_
.int_val
, MPC_RNDNN
);
15330 mpc_set_fr(*val
, this->u_
.float_val
, MPC_RNDNN
);
15333 mpc_set(*val
, this->u_
.complex_val
, MPC_RNDNN
);
15343 Numeric_constant::type() const
15345 if (this->type_
!= NULL
)
15346 return this->type_
;
15347 switch (this->classification_
)
15350 return Type::make_abstract_integer_type();
15352 return Type::make_abstract_character_type();
15354 return Type::make_abstract_float_type();
15356 return Type::make_abstract_complex_type();
15362 // If the constant can be expressed in TYPE, then set the type of the
15363 // constant to TYPE and return true. Otherwise return false, and, if
15364 // ISSUE_ERROR is true, report an appropriate error message.
15367 Numeric_constant::set_type(Type
* type
, bool issue_error
, Location loc
)
15372 else if (type
->integer_type() != NULL
)
15373 ret
= this->check_int_type(type
->integer_type(), issue_error
, loc
);
15374 else if (type
->float_type() != NULL
)
15375 ret
= this->check_float_type(type
->float_type(), issue_error
, loc
);
15376 else if (type
->complex_type() != NULL
)
15377 ret
= this->check_complex_type(type
->complex_type(), issue_error
, loc
);
15381 this->type_
= type
;
15385 // Check whether the constant can be expressed in an integer type.
15388 Numeric_constant::check_int_type(Integer_type
* type
, bool issue_error
,
15389 Location location
) const
15392 switch (this->classification_
)
15396 mpz_init_set(val
, this->u_
.int_val
);
15400 if (!mpfr_integer_p(this->u_
.float_val
))
15403 error_at(location
, "floating point constant truncated to integer");
15407 mpfr_get_z(val
, this->u_
.float_val
, GMP_RNDN
);
15411 if (!mpfr_integer_p(mpc_realref(this->u_
.complex_val
))
15412 || !mpfr_zero_p(mpc_imagref(this->u_
.complex_val
)))
15415 error_at(location
, "complex constant truncated to integer");
15419 mpfr_get_z(val
, mpc_realref(this->u_
.complex_val
), GMP_RNDN
);
15427 if (type
->is_abstract())
15431 int bits
= mpz_sizeinbase(val
, 2);
15432 if (type
->is_unsigned())
15434 // For an unsigned type we can only accept a nonnegative
15435 // number, and we must be able to represents at least BITS.
15436 ret
= mpz_sgn(val
) >= 0 && bits
<= type
->bits();
15440 // For a signed type we need an extra bit to indicate the
15441 // sign. We have to handle the most negative integer
15443 ret
= (bits
+ 1 <= type
->bits()
15444 || (bits
<= type
->bits()
15445 && mpz_sgn(val
) < 0
15446 && (mpz_scan1(val
, 0)
15447 == static_cast<unsigned long>(type
->bits() - 1))
15448 && mpz_scan0(val
, type
->bits()) == ULONG_MAX
));
15452 if (!ret
&& issue_error
)
15453 error_at(location
, "integer constant overflow");
15458 // Check whether the constant can be expressed in a floating point
15462 Numeric_constant::check_float_type(Float_type
* type
, bool issue_error
,
15466 switch (this->classification_
)
15470 mpfr_init_set_z(val
, this->u_
.int_val
, GMP_RNDN
);
15474 mpfr_init_set(val
, this->u_
.float_val
, GMP_RNDN
);
15478 if (!mpfr_zero_p(mpc_imagref(this->u_
.complex_val
)))
15481 error_at(location
, "complex constant truncated to float");
15484 mpfr_init_set(val
, mpc_realref(this->u_
.complex_val
), GMP_RNDN
);
15492 if (type
->is_abstract())
15494 else if (mpfr_nan_p(val
) || mpfr_inf_p(val
) || mpfr_zero_p(val
))
15496 // A NaN or Infinity always fits in the range of the type.
15501 mp_exp_t exp
= mpfr_get_exp(val
);
15503 switch (type
->bits())
15515 ret
= exp
<= max_exp
;
15519 // Round the constant to the desired type.
15522 switch (type
->bits())
15525 mpfr_set_prec(t
, 24);
15528 mpfr_set_prec(t
, 53);
15533 mpfr_set(t
, val
, GMP_RNDN
);
15534 mpfr_set(val
, t
, GMP_RNDN
);
15537 this->set_float(type
, val
);
15543 if (!ret
&& issue_error
)
15544 error_at(location
, "floating point constant overflow");
15549 // Check whether the constant can be expressed in a complex type.
15552 Numeric_constant::check_complex_type(Complex_type
* type
, bool issue_error
,
15555 if (type
->is_abstract())
15559 switch (type
->bits())
15572 mpc_init2(val
, mpc_precision
);
15573 switch (this->classification_
)
15577 mpc_set_z(val
, this->u_
.int_val
, MPC_RNDNN
);
15581 mpc_set_fr(val
, this->u_
.float_val
, MPC_RNDNN
);
15585 mpc_set(val
, this->u_
.complex_val
, MPC_RNDNN
);
15593 if (!mpfr_nan_p(mpc_realref(val
))
15594 && !mpfr_inf_p(mpc_realref(val
))
15595 && !mpfr_zero_p(mpc_realref(val
))
15596 && mpfr_get_exp(mpc_realref(val
)) > max_exp
)
15599 error_at(location
, "complex real part overflow");
15603 if (!mpfr_nan_p(mpc_imagref(val
))
15604 && !mpfr_inf_p(mpc_imagref(val
))
15605 && !mpfr_zero_p(mpc_imagref(val
))
15606 && mpfr_get_exp(mpc_imagref(val
)) > max_exp
)
15609 error_at(location
, "complex imaginary part overflow");
15615 // Round the constant to the desired type.
15617 switch (type
->bits())
15628 mpc_set(t
, val
, MPC_RNDNN
);
15629 mpc_set(val
, t
, MPC_RNDNN
);
15632 this->set_complex(type
, val
);
15640 // Return an Expression for this value.
15643 Numeric_constant::expression(Location loc
) const
15645 switch (this->classification_
)
15648 return Expression::make_integer_z(&this->u_
.int_val
, this->type_
, loc
);
15650 return Expression::make_character(&this->u_
.int_val
, this->type_
, loc
);
15652 return Expression::make_float(&this->u_
.float_val
, this->type_
, loc
);
15654 return Expression::make_complex(&this->u_
.complex_val
, this->type_
, loc
);