OSDN Git Service

compiler: Fix crash in go/defer of some builtin functions.
[pf3gnuchains/gcc-fork.git] / gcc / go / gofrontend / expressions.cc
1 // expressions.cc -- Go frontend expression handling.
2
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.
6
7 #include "go-system.h"
8
9 #include <algorithm>
10
11 #include <gmp.h>
12
13 #ifndef ENABLE_BUILD_WITH_CXX
14 extern "C"
15 {
16 #endif
17
18 #include "toplev.h"
19 #include "intl.h"
20 #include "tree.h"
21 #include "gimple.h"
22 #include "tree-iterator.h"
23 #include "convert.h"
24 #include "real.h"
25 #include "realmpfr.h"
26
27 #ifndef ENABLE_BUILD_WITH_CXX
28 }
29 #endif
30
31 #include "go-c.h"
32 #include "gogo.h"
33 #include "types.h"
34 #include "export.h"
35 #include "import.h"
36 #include "statements.h"
37 #include "lex.h"
38 #include "runtime.h"
39 #include "backend.h"
40 #include "expressions.h"
41 #include "ast-dump.h"
42
43 // Class Expression.
44
45 Expression::Expression(Expression_classification classification,
46                        Location location)
47   : classification_(classification), location_(location)
48 {
49 }
50
51 Expression::~Expression()
52 {
53 }
54
55 // Traverse the expressions.
56
57 int
58 Expression::traverse(Expression** pexpr, Traverse* traverse)
59 {
60   Expression* expr = *pexpr;
61   if ((traverse->traverse_mask() & Traverse::traverse_expressions) != 0)
62     {
63       int t = traverse->expression(pexpr);
64       if (t == TRAVERSE_EXIT)
65         return TRAVERSE_EXIT;
66       else if (t == TRAVERSE_SKIP_COMPONENTS)
67         return TRAVERSE_CONTINUE;
68     }
69   return expr->do_traverse(traverse);
70 }
71
72 // Traverse subexpressions of this expression.
73
74 int
75 Expression::traverse_subexpressions(Traverse* traverse)
76 {
77   return this->do_traverse(traverse);
78 }
79
80 // Default implementation for do_traverse for child classes.
81
82 int
83 Expression::do_traverse(Traverse*)
84 {
85   return TRAVERSE_CONTINUE;
86 }
87
88 // This virtual function is called by the parser if the value of this
89 // expression is being discarded.  By default, we give an error.
90 // Expressions with side effects override.
91
92 bool
93 Expression::do_discarding_value()
94 {
95   this->unused_value_error();
96   return false;
97 }
98
99 // This virtual function is called to export expressions.  This will
100 // only be used by expressions which may be constant.
101
102 void
103 Expression::do_export(Export*) const
104 {
105   go_unreachable();
106 }
107
108 // Give an error saying that the value of the expression is not used.
109
110 void
111 Expression::unused_value_error()
112 {
113   this->report_error(_("value computed is not used"));
114 }
115
116 // Note that this expression is an error.  This is called by children
117 // when they discover an error.
118
119 void
120 Expression::set_is_error()
121 {
122   this->classification_ = EXPRESSION_ERROR;
123 }
124
125 // For children to call to report an error conveniently.
126
127 void
128 Expression::report_error(const char* msg)
129 {
130   error_at(this->location_, "%s", msg);
131   this->set_is_error();
132 }
133
134 // Set types of variables and constants.  This is implemented by the
135 // child class.
136
137 void
138 Expression::determine_type(const Type_context* context)
139 {
140   this->do_determine_type(context);
141 }
142
143 // Set types when there is no context.
144
145 void
146 Expression::determine_type_no_context()
147 {
148   Type_context context;
149   this->do_determine_type(&context);
150 }
151
152 // Return a tree handling any conversions which must be done during
153 // assignment.
154
155 tree
156 Expression::convert_for_assignment(Translate_context* context, Type* lhs_type,
157                                    Type* rhs_type, tree rhs_tree,
158                                    Location location)
159 {
160   if (lhs_type->is_error() || rhs_type->is_error())
161     return error_mark_node;
162
163   if (rhs_tree == error_mark_node || TREE_TYPE(rhs_tree) == error_mark_node)
164     return error_mark_node;
165
166   Gogo* gogo = context->gogo();
167
168   tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
169   if (lhs_type_tree == error_mark_node)
170     return error_mark_node;
171
172   if (lhs_type->forwarded() != rhs_type->forwarded()
173       && lhs_type->interface_type() != NULL)
174     {
175       if (rhs_type->interface_type() == NULL)
176         return Expression::convert_type_to_interface(context, lhs_type,
177                                                      rhs_type, rhs_tree,
178                                                      location);
179       else
180         return Expression::convert_interface_to_interface(context, lhs_type,
181                                                           rhs_type, rhs_tree,
182                                                           false, location);
183     }
184   else if (lhs_type->forwarded() != rhs_type->forwarded()
185            && rhs_type->interface_type() != NULL)
186     return Expression::convert_interface_to_type(context, lhs_type, rhs_type,
187                                                  rhs_tree, location);
188   else if (lhs_type->is_slice_type() && rhs_type->is_nil_type())
189     {
190       // Assigning nil to an open array.
191       go_assert(TREE_CODE(lhs_type_tree) == RECORD_TYPE);
192
193       VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 3);
194
195       constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
196       tree field = TYPE_FIELDS(lhs_type_tree);
197       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
198                         "__values") == 0);
199       elt->index = field;
200       elt->value = fold_convert(TREE_TYPE(field), null_pointer_node);
201
202       elt = VEC_quick_push(constructor_elt, init, NULL);
203       field = DECL_CHAIN(field);
204       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
205                         "__count") == 0);
206       elt->index = field;
207       elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
208
209       elt = VEC_quick_push(constructor_elt, init, NULL);
210       field = DECL_CHAIN(field);
211       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
212                         "__capacity") == 0);
213       elt->index = field;
214       elt->value = fold_convert(TREE_TYPE(field), integer_zero_node);
215
216       tree val = build_constructor(lhs_type_tree, init);
217       TREE_CONSTANT(val) = 1;
218
219       return val;
220     }
221   else if (rhs_type->is_nil_type())
222     {
223       // The left hand side should be a pointer type at the tree
224       // level.
225       go_assert(POINTER_TYPE_P(lhs_type_tree));
226       return fold_convert(lhs_type_tree, null_pointer_node);
227     }
228   else if (lhs_type_tree == TREE_TYPE(rhs_tree))
229     {
230       // No conversion is needed.
231       return rhs_tree;
232     }
233   else if (POINTER_TYPE_P(lhs_type_tree)
234            || INTEGRAL_TYPE_P(lhs_type_tree)
235            || SCALAR_FLOAT_TYPE_P(lhs_type_tree)
236            || COMPLEX_FLOAT_TYPE_P(lhs_type_tree))
237     return fold_convert_loc(location.gcc_location(), lhs_type_tree, rhs_tree);
238   else if ((TREE_CODE(lhs_type_tree) == RECORD_TYPE
239             && TREE_CODE(TREE_TYPE(rhs_tree)) == RECORD_TYPE)
240            || (TREE_CODE(lhs_type_tree) == ARRAY_TYPE
241                && TREE_CODE(TREE_TYPE(rhs_tree)) == ARRAY_TYPE))
242     {
243       // Avoid confusion from zero sized variables which may be
244       // represented as non-zero-sized.
245       if (int_size_in_bytes(lhs_type_tree) == 0
246           || int_size_in_bytes(TREE_TYPE(rhs_tree)) == 0)
247         return rhs_tree;
248
249       // This conversion must be permitted by Go, or we wouldn't have
250       // gotten here.
251       go_assert(int_size_in_bytes(lhs_type_tree)
252                 == int_size_in_bytes(TREE_TYPE(rhs_tree)));
253       return fold_build1_loc(location.gcc_location(), VIEW_CONVERT_EXPR,
254                              lhs_type_tree, rhs_tree);
255     }
256   else
257     {
258       go_assert(useless_type_conversion_p(lhs_type_tree, TREE_TYPE(rhs_tree)));
259       return rhs_tree;
260     }
261 }
262
263 // Return a tree for a conversion from a non-interface type to an
264 // interface type.
265
266 tree
267 Expression::convert_type_to_interface(Translate_context* context,
268                                       Type* lhs_type, Type* rhs_type,
269                                       tree rhs_tree, Location location)
270 {
271   Gogo* gogo = context->gogo();
272   Interface_type* lhs_interface_type = lhs_type->interface_type();
273   bool lhs_is_empty = lhs_interface_type->is_empty();
274
275   // Since RHS_TYPE is a static type, we can create the interface
276   // method table at compile time.
277
278   // When setting an interface to nil, we just set both fields to
279   // NULL.
280   if (rhs_type->is_nil_type())
281     {
282       Btype* lhs_btype = lhs_type->get_backend(gogo);
283       return expr_to_tree(gogo->backend()->zero_expression(lhs_btype));
284     }
285
286   // This should have been checked already.
287   go_assert(lhs_interface_type->implements_interface(rhs_type, NULL));
288
289   tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
290   if (lhs_type_tree == error_mark_node)
291     return error_mark_node;
292
293   // An interface is a tuple.  If LHS_TYPE is an empty interface type,
294   // then the first field is the type descriptor for RHS_TYPE.
295   // Otherwise it is the interface method table for RHS_TYPE.
296   tree first_field_value;
297   if (lhs_is_empty)
298     first_field_value = rhs_type->type_descriptor_pointer(gogo, location);
299   else
300     {
301       // Build the interface method table for this interface and this
302       // object type: a list of function pointers for each interface
303       // method.
304       Named_type* rhs_named_type = rhs_type->named_type();
305       Struct_type* rhs_struct_type = rhs_type->struct_type();
306       bool is_pointer = false;
307       if (rhs_named_type == NULL && rhs_struct_type == NULL)
308         {
309           rhs_named_type = rhs_type->deref()->named_type();
310           rhs_struct_type = rhs_type->deref()->struct_type();
311           is_pointer = true;
312         }
313       tree method_table;
314       if (rhs_named_type != NULL)
315         method_table =
316           rhs_named_type->interface_method_table(gogo, lhs_interface_type,
317                                                  is_pointer);
318       else if (rhs_struct_type != NULL)
319         method_table =
320           rhs_struct_type->interface_method_table(gogo, lhs_interface_type,
321                                                   is_pointer);
322       else
323         method_table = null_pointer_node;
324       first_field_value = fold_convert_loc(location.gcc_location(),
325                                            const_ptr_type_node, method_table);
326     }
327   if (first_field_value == error_mark_node)
328     return error_mark_node;
329
330   // Start building a constructor for the value we will return.
331
332   VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
333
334   constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
335   tree field = TYPE_FIELDS(lhs_type_tree);
336   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
337                     (lhs_is_empty ? "__type_descriptor" : "__methods")) == 0);
338   elt->index = field;
339   elt->value = fold_convert_loc(location.gcc_location(), TREE_TYPE(field),
340                                 first_field_value);
341
342   elt = VEC_quick_push(constructor_elt, init, NULL);
343   field = DECL_CHAIN(field);
344   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
345   elt->index = field;
346
347   if (rhs_type->points_to() != NULL)
348     {
349       //  We are assigning a pointer to the interface; the interface
350       // holds the pointer itself.
351       elt->value = rhs_tree;
352       return build_constructor(lhs_type_tree, init);
353     }
354
355   // We are assigning a non-pointer value to the interface; the
356   // interface gets a copy of the value in the heap.
357
358   tree object_size = TYPE_SIZE_UNIT(TREE_TYPE(rhs_tree));
359
360   tree space = gogo->allocate_memory(rhs_type, object_size, location);
361   space = fold_convert_loc(location.gcc_location(),
362                            build_pointer_type(TREE_TYPE(rhs_tree)), space);
363   space = save_expr(space);
364
365   tree ref = build_fold_indirect_ref_loc(location.gcc_location(), space);
366   TREE_THIS_NOTRAP(ref) = 1;
367   tree set = fold_build2_loc(location.gcc_location(), MODIFY_EXPR,
368                              void_type_node, ref, rhs_tree);
369
370   elt->value = fold_convert_loc(location.gcc_location(), TREE_TYPE(field),
371                                 space);
372
373   return build2(COMPOUND_EXPR, lhs_type_tree, set,
374                 build_constructor(lhs_type_tree, init));
375 }
376
377 // Return a tree for the type descriptor of RHS_TREE, which has
378 // interface type RHS_TYPE.  If RHS_TREE is nil the result will be
379 // NULL.
380
381 tree
382 Expression::get_interface_type_descriptor(Translate_context*,
383                                           Type* rhs_type, tree rhs_tree,
384                                           Location location)
385 {
386   tree rhs_type_tree = TREE_TYPE(rhs_tree);
387   go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
388   tree rhs_field = TYPE_FIELDS(rhs_type_tree);
389   tree v = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
390                   NULL_TREE);
391   if (rhs_type->interface_type()->is_empty())
392     {
393       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)),
394                         "__type_descriptor") == 0);
395       return v;
396     }
397
398   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__methods")
399              == 0);
400   go_assert(POINTER_TYPE_P(TREE_TYPE(v)));
401   v = save_expr(v);
402   tree v1 = build_fold_indirect_ref_loc(location.gcc_location(), v);
403   go_assert(TREE_CODE(TREE_TYPE(v1)) == RECORD_TYPE);
404   tree f = TYPE_FIELDS(TREE_TYPE(v1));
405   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(f)), "__type_descriptor")
406              == 0);
407   v1 = build3(COMPONENT_REF, TREE_TYPE(f), v1, f, NULL_TREE);
408
409   tree eq = fold_build2_loc(location.gcc_location(), EQ_EXPR, boolean_type_node,
410                             v, fold_convert_loc(location.gcc_location(),
411                                                 TREE_TYPE(v),
412                                                 null_pointer_node));
413   tree n = fold_convert_loc(location.gcc_location(), TREE_TYPE(v1),
414                             null_pointer_node);
415   return fold_build3_loc(location.gcc_location(), COND_EXPR, TREE_TYPE(v1),
416                          eq, n, v1);
417 }
418
419 // Return a tree for the conversion of an interface type to an
420 // interface type.
421
422 tree
423 Expression::convert_interface_to_interface(Translate_context* context,
424                                            Type *lhs_type, Type *rhs_type,
425                                            tree rhs_tree, bool for_type_guard,
426                                            Location location)
427 {
428   Gogo* gogo = context->gogo();
429   Interface_type* lhs_interface_type = lhs_type->interface_type();
430   bool lhs_is_empty = lhs_interface_type->is_empty();
431
432   tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
433   if (lhs_type_tree == error_mark_node)
434     return error_mark_node;
435
436   // In the general case this requires runtime examination of the type
437   // method table to match it up with the interface methods.
438
439   // FIXME: If all of the methods in the right hand side interface
440   // also appear in the left hand side interface, then we don't need
441   // to do a runtime check, although we still need to build a new
442   // method table.
443
444   // Get the type descriptor for the right hand side.  This will be
445   // NULL for a nil interface.
446
447   if (!DECL_P(rhs_tree))
448     rhs_tree = save_expr(rhs_tree);
449
450   tree rhs_type_descriptor =
451     Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
452                                               location);
453
454   // The result is going to be a two element constructor.
455
456   VEC(constructor_elt,gc)* init = VEC_alloc(constructor_elt, gc, 2);
457
458   constructor_elt* elt = VEC_quick_push(constructor_elt, init, NULL);
459   tree field = TYPE_FIELDS(lhs_type_tree);
460   elt->index = field;
461
462   if (for_type_guard)
463     {
464       // A type assertion fails when converting a nil interface.
465       tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo,
466                                                                    location);
467       static tree assert_interface_decl;
468       tree call = Gogo::call_builtin(&assert_interface_decl,
469                                      location,
470                                      "__go_assert_interface",
471                                      2,
472                                      ptr_type_node,
473                                      TREE_TYPE(lhs_type_descriptor),
474                                      lhs_type_descriptor,
475                                      TREE_TYPE(rhs_type_descriptor),
476                                      rhs_type_descriptor);
477       if (call == error_mark_node)
478         return error_mark_node;
479       // This will panic if the interface conversion fails.
480       TREE_NOTHROW(assert_interface_decl) = 0;
481       elt->value = fold_convert_loc(location.gcc_location(), TREE_TYPE(field),
482                                     call);
483     }
484   else if (lhs_is_empty)
485     {
486       // A convertion to an empty interface always succeeds, and the
487       // first field is just the type descriptor of the object.
488       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)),
489                         "__type_descriptor") == 0);
490       elt->value = fold_convert_loc(location.gcc_location(),
491                                     TREE_TYPE(field), rhs_type_descriptor);
492     }
493   else
494     {
495       // A conversion to a non-empty interface may fail, but unlike a
496       // type assertion converting nil will always succeed.
497       go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__methods")
498                  == 0);
499       tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo,
500                                                                    location);
501       static tree convert_interface_decl;
502       tree call = Gogo::call_builtin(&convert_interface_decl,
503                                      location,
504                                      "__go_convert_interface",
505                                      2,
506                                      ptr_type_node,
507                                      TREE_TYPE(lhs_type_descriptor),
508                                      lhs_type_descriptor,
509                                      TREE_TYPE(rhs_type_descriptor),
510                                      rhs_type_descriptor);
511       if (call == error_mark_node)
512         return error_mark_node;
513       // This will panic if the interface conversion fails.
514       TREE_NOTHROW(convert_interface_decl) = 0;
515       elt->value = fold_convert_loc(location.gcc_location(), TREE_TYPE(field),
516                                     call);
517     }
518
519   // The second field is simply the object pointer.
520
521   elt = VEC_quick_push(constructor_elt, init, NULL);
522   field = DECL_CHAIN(field);
523   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(field)), "__object") == 0);
524   elt->index = field;
525
526   tree rhs_type_tree = TREE_TYPE(rhs_tree);
527   go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
528   tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
529   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
530   elt->value = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
531                       NULL_TREE);
532
533   return build_constructor(lhs_type_tree, init);
534 }
535
536 // Return a tree for the conversion of an interface type to a
537 // non-interface type.
538
539 tree
540 Expression::convert_interface_to_type(Translate_context* context,
541                                       Type *lhs_type, Type* rhs_type,
542                                       tree rhs_tree, Location location)
543 {
544   Gogo* gogo = context->gogo();
545   tree rhs_type_tree = TREE_TYPE(rhs_tree);
546
547   tree lhs_type_tree = type_to_tree(lhs_type->get_backend(gogo));
548   if (lhs_type_tree == error_mark_node)
549     return error_mark_node;
550
551   // Call a function to check that the type is valid.  The function
552   // will panic with an appropriate runtime type error if the type is
553   // not valid.
554
555   tree lhs_type_descriptor = lhs_type->type_descriptor_pointer(gogo, location);
556
557   if (!DECL_P(rhs_tree))
558     rhs_tree = save_expr(rhs_tree);
559
560   tree rhs_type_descriptor =
561     Expression::get_interface_type_descriptor(context, rhs_type, rhs_tree,
562                                               location);
563
564   tree rhs_inter_descriptor = rhs_type->type_descriptor_pointer(gogo,
565                                                                 location);
566
567   static tree check_interface_type_decl;
568   tree call = Gogo::call_builtin(&check_interface_type_decl,
569                                  location,
570                                  "__go_check_interface_type",
571                                  3,
572                                  void_type_node,
573                                  TREE_TYPE(lhs_type_descriptor),
574                                  lhs_type_descriptor,
575                                  TREE_TYPE(rhs_type_descriptor),
576                                  rhs_type_descriptor,
577                                  TREE_TYPE(rhs_inter_descriptor),
578                                  rhs_inter_descriptor);
579   if (call == error_mark_node)
580     return error_mark_node;
581   // This call will panic if the conversion is invalid.
582   TREE_NOTHROW(check_interface_type_decl) = 0;
583
584   // If the call succeeds, pull out the value.
585   go_assert(TREE_CODE(rhs_type_tree) == RECORD_TYPE);
586   tree rhs_field = DECL_CHAIN(TYPE_FIELDS(rhs_type_tree));
587   go_assert(strcmp(IDENTIFIER_POINTER(DECL_NAME(rhs_field)), "__object") == 0);
588   tree val = build3(COMPONENT_REF, TREE_TYPE(rhs_field), rhs_tree, rhs_field,
589                     NULL_TREE);
590
591   // If the value is a pointer, then it is the value we want.
592   // Otherwise it points to the value.
593   if (lhs_type->points_to() == NULL)
594     {
595       val = fold_convert_loc(location.gcc_location(),
596                              build_pointer_type(lhs_type_tree), val);
597       val = build_fold_indirect_ref_loc(location.gcc_location(), val);
598     }
599
600   return build2(COMPOUND_EXPR, lhs_type_tree, call,
601                 fold_convert_loc(location.gcc_location(), lhs_type_tree, val));
602 }
603
604 // Convert an expression to a tree.  This is implemented by the child
605 // class.  Not that it is not in general safe to call this multiple
606 // times for a single expression, but that we don't catch such errors.
607
608 tree
609 Expression::get_tree(Translate_context* context)
610 {
611   // The child may have marked this expression as having an error.
612   if (this->classification_ == EXPRESSION_ERROR)
613     return error_mark_node;
614
615   return this->do_get_tree(context);
616 }
617
618 // Return a tree for VAL in TYPE.
619
620 tree
621 Expression::integer_constant_tree(mpz_t val, tree type)
622 {
623   if (type == error_mark_node)
624     return error_mark_node;
625   else if (TREE_CODE(type) == INTEGER_TYPE)
626     return double_int_to_tree(type,
627                               mpz_get_double_int(type, val, true));
628   else if (TREE_CODE(type) == REAL_TYPE)
629     {
630       mpfr_t fval;
631       mpfr_init_set_z(fval, val, GMP_RNDN);
632       tree ret = Expression::float_constant_tree(fval, type);
633       mpfr_clear(fval);
634       return ret;
635     }
636   else if (TREE_CODE(type) == COMPLEX_TYPE)
637     {
638       mpfr_t fval;
639       mpfr_init_set_z(fval, val, GMP_RNDN);
640       tree real = Expression::float_constant_tree(fval, TREE_TYPE(type));
641       mpfr_clear(fval);
642       tree imag = build_real_from_int_cst(TREE_TYPE(type),
643                                           integer_zero_node);
644       return build_complex(type, real, imag);
645     }
646   else
647     go_unreachable();
648 }
649
650 // Return a tree for VAL in TYPE.
651
652 tree
653 Expression::float_constant_tree(mpfr_t val, tree type)
654 {
655   if (type == error_mark_node)
656     return error_mark_node;
657   else if (TREE_CODE(type) == INTEGER_TYPE)
658     {
659       mpz_t ival;
660       mpz_init(ival);
661       mpfr_get_z(ival, val, GMP_RNDN);
662       tree ret = Expression::integer_constant_tree(ival, type);
663       mpz_clear(ival);
664       return ret;
665     }
666   else if (TREE_CODE(type) == REAL_TYPE)
667     {
668       REAL_VALUE_TYPE r1;
669       real_from_mpfr(&r1, val, type, GMP_RNDN);
670       REAL_VALUE_TYPE r2;
671       real_convert(&r2, TYPE_MODE(type), &r1);
672       return build_real(type, r2);
673     }
674   else if (TREE_CODE(type) == COMPLEX_TYPE)
675     {
676       REAL_VALUE_TYPE r1;
677       real_from_mpfr(&r1, val, TREE_TYPE(type), GMP_RNDN);
678       REAL_VALUE_TYPE r2;
679       real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
680       tree imag = build_real_from_int_cst(TREE_TYPE(type),
681                                           integer_zero_node);
682       return build_complex(type, build_real(TREE_TYPE(type), r2), imag);
683     }
684   else
685     go_unreachable();
686 }
687
688 // Return a tree for REAL/IMAG in TYPE.
689
690 tree
691 Expression::complex_constant_tree(mpfr_t real, mpfr_t imag, tree type)
692 {
693   if (type == error_mark_node)
694     return error_mark_node;
695   else if (TREE_CODE(type) == INTEGER_TYPE || TREE_CODE(type) == REAL_TYPE)
696     return Expression::float_constant_tree(real, type);
697   else if (TREE_CODE(type) == COMPLEX_TYPE)
698     {
699       REAL_VALUE_TYPE r1;
700       real_from_mpfr(&r1, real, TREE_TYPE(type), GMP_RNDN);
701       REAL_VALUE_TYPE r2;
702       real_convert(&r2, TYPE_MODE(TREE_TYPE(type)), &r1);
703
704       REAL_VALUE_TYPE r3;
705       real_from_mpfr(&r3, imag, TREE_TYPE(type), GMP_RNDN);
706       REAL_VALUE_TYPE r4;
707       real_convert(&r4, TYPE_MODE(TREE_TYPE(type)), &r3);
708
709       return build_complex(type, build_real(TREE_TYPE(type), r2),
710                            build_real(TREE_TYPE(type), r4));
711     }
712   else
713     go_unreachable();
714 }
715
716 // Return a tree which evaluates to true if VAL, of arbitrary integer
717 // type, is negative or is more than the maximum value of BOUND_TYPE.
718 // If SOFAR is not NULL, it is or'red into the result.  The return
719 // value may be NULL if SOFAR is NULL.
720
721 tree
722 Expression::check_bounds(tree val, tree bound_type, tree sofar,
723                          Location loc)
724 {
725   tree val_type = TREE_TYPE(val);
726   tree ret = NULL_TREE;
727
728   if (!TYPE_UNSIGNED(val_type))
729     {
730       ret = fold_build2_loc(loc.gcc_location(), LT_EXPR, boolean_type_node, val,
731                             build_int_cst(val_type, 0));
732       if (ret == boolean_false_node)
733         ret = NULL_TREE;
734     }
735
736   HOST_WIDE_INT val_type_size = int_size_in_bytes(val_type);
737   HOST_WIDE_INT bound_type_size = int_size_in_bytes(bound_type);
738   go_assert(val_type_size != -1 && bound_type_size != -1);
739   if (val_type_size > bound_type_size
740       || (val_type_size == bound_type_size
741           && TYPE_UNSIGNED(val_type)
742           && !TYPE_UNSIGNED(bound_type)))
743     {
744       tree max = TYPE_MAX_VALUE(bound_type);
745       tree big = fold_build2_loc(loc.gcc_location(), GT_EXPR, boolean_type_node,
746                                  val, fold_convert_loc(loc.gcc_location(),
747                                                        val_type, max));
748       if (big == boolean_false_node)
749         ;
750       else if (ret == NULL_TREE)
751         ret = big;
752       else
753         ret = fold_build2_loc(loc.gcc_location(), TRUTH_OR_EXPR,
754                               boolean_type_node, ret, big);
755     }
756
757   if (ret == NULL_TREE)
758     return sofar;
759   else if (sofar == NULL_TREE)
760     return ret;
761   else
762     return fold_build2_loc(loc.gcc_location(), TRUTH_OR_EXPR, boolean_type_node,
763                            sofar, ret);
764 }
765
766 void
767 Expression::dump_expression(Ast_dump_context* ast_dump_context) const
768 {
769   this->do_dump_expression(ast_dump_context);
770 }
771
772 // Error expressions.  This are used to avoid cascading errors.
773
774 class Error_expression : public Expression
775 {
776  public:
777   Error_expression(Location location)
778     : Expression(EXPRESSION_ERROR, location)
779   { }
780
781  protected:
782   bool
783   do_is_constant() const
784   { return true; }
785
786   bool
787   do_numeric_constant_value(Numeric_constant* nc) const
788   {
789     nc->set_unsigned_long(NULL, 0);
790     return true;
791   }
792
793   bool
794   do_discarding_value()
795   { return true; }
796
797   Type*
798   do_type()
799   { return Type::make_error_type(); }
800
801   void
802   do_determine_type(const Type_context*)
803   { }
804
805   Expression*
806   do_copy()
807   { return this; }
808
809   bool
810   do_is_addressable() const
811   { return true; }
812
813   tree
814   do_get_tree(Translate_context*)
815   { return error_mark_node; }
816
817   void
818   do_dump_expression(Ast_dump_context*) const;
819 };
820
821 // Dump the ast representation for an error expression to a dump context.
822
823 void
824 Error_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
825 {
826   ast_dump_context->ostream() << "_Error_" ;
827 }
828
829 Expression*
830 Expression::make_error(Location location)
831 {
832   return new Error_expression(location);
833 }
834
835 // An expression which is really a type.  This is used during parsing.
836 // It is an error if these survive after lowering.
837
838 class
839 Type_expression : public Expression
840 {
841  public:
842   Type_expression(Type* type, Location location)
843     : Expression(EXPRESSION_TYPE, location),
844       type_(type)
845   { }
846
847  protected:
848   int
849   do_traverse(Traverse* traverse)
850   { return Type::traverse(this->type_, traverse); }
851
852   Type*
853   do_type()
854   { return this->type_; }
855
856   void
857   do_determine_type(const Type_context*)
858   { }
859
860   void
861   do_check_types(Gogo*)
862   { this->report_error(_("invalid use of type")); }
863
864   Expression*
865   do_copy()
866   { return this; }
867
868   tree
869   do_get_tree(Translate_context*)
870   { go_unreachable(); }
871
872   void do_dump_expression(Ast_dump_context*) const;
873  
874  private:
875   // The type which we are representing as an expression.
876   Type* type_;
877 };
878
879 void
880 Type_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
881 {
882   ast_dump_context->dump_type(this->type_);
883 }
884
885 Expression*
886 Expression::make_type(Type* type, Location location)
887 {
888   return new Type_expression(type, location);
889 }
890
891 // Class Parser_expression.
892
893 Type*
894 Parser_expression::do_type()
895 {
896   // We should never really ask for the type of a Parser_expression.
897   // However, it can happen, at least when we have an invalid const
898   // whose initializer refers to the const itself.  In that case we
899   // may ask for the type when lowering the const itself.
900   go_assert(saw_errors());
901   return Type::make_error_type();
902 }
903
904 // Class Var_expression.
905
906 // Lower a variable expression.  Here we just make sure that the
907 // initialization expression of the variable has been lowered.  This
908 // ensures that we will be able to determine the type of the variable
909 // if necessary.
910
911 Expression*
912 Var_expression::do_lower(Gogo* gogo, Named_object* function,
913                          Statement_inserter* inserter, int)
914 {
915   if (this->variable_->is_variable())
916     {
917       Variable* var = this->variable_->var_value();
918       // This is either a local variable or a global variable.  A
919       // reference to a variable which is local to an enclosing
920       // function will be a reference to a field in a closure.
921       if (var->is_global())
922         {
923           function = NULL;
924           inserter = NULL;
925         }
926       var->lower_init_expression(gogo, function, inserter);
927     }
928   return this;
929 }
930
931 // Return the type of a reference to a variable.
932
933 Type*
934 Var_expression::do_type()
935 {
936   if (this->variable_->is_variable())
937     return this->variable_->var_value()->type();
938   else if (this->variable_->is_result_variable())
939     return this->variable_->result_var_value()->type();
940   else
941     go_unreachable();
942 }
943
944 // Determine the type of a reference to a variable.
945
946 void
947 Var_expression::do_determine_type(const Type_context*)
948 {
949   if (this->variable_->is_variable())
950     this->variable_->var_value()->determine_type();
951 }
952
953 // Something takes the address of this variable.  This means that we
954 // may want to move the variable onto the heap.
955
956 void
957 Var_expression::do_address_taken(bool escapes)
958 {
959   if (!escapes)
960     {
961       if (this->variable_->is_variable())
962         this->variable_->var_value()->set_non_escaping_address_taken();
963       else if (this->variable_->is_result_variable())
964         this->variable_->result_var_value()->set_non_escaping_address_taken();
965       else
966         go_unreachable();
967     }
968   else
969     {
970       if (this->variable_->is_variable())
971         this->variable_->var_value()->set_address_taken();
972       else if (this->variable_->is_result_variable())
973         this->variable_->result_var_value()->set_address_taken();
974       else
975         go_unreachable();
976     }
977 }
978
979 // Get the tree for a reference to a variable.
980
981 tree
982 Var_expression::do_get_tree(Translate_context* context)
983 {
984   Bvariable* bvar = this->variable_->get_backend_variable(context->gogo(),
985                                                           context->function());
986   tree ret = var_to_tree(bvar);
987   if (ret == error_mark_node)
988     return error_mark_node;
989   bool is_in_heap;
990   if (this->variable_->is_variable())
991     is_in_heap = this->variable_->var_value()->is_in_heap();
992   else if (this->variable_->is_result_variable())
993     is_in_heap = this->variable_->result_var_value()->is_in_heap();
994   else
995     go_unreachable();
996   if (is_in_heap)
997     {
998       ret = build_fold_indirect_ref_loc(this->location().gcc_location(), ret);
999       TREE_THIS_NOTRAP(ret) = 1;
1000     }
1001   return ret;
1002 }
1003
1004 // Ast dump for variable expression.
1005
1006 void
1007 Var_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1008 {
1009   ast_dump_context->ostream() << this->variable_->name() ;
1010 }
1011
1012 // Make a reference to a variable in an expression.
1013
1014 Expression*
1015 Expression::make_var_reference(Named_object* var, Location location)
1016 {
1017   if (var->is_sink())
1018     return Expression::make_sink(location);
1019
1020   // FIXME: Creating a new object for each reference to a variable is
1021   // wasteful.
1022   return new Var_expression(var, location);
1023 }
1024
1025 // Class Temporary_reference_expression.
1026
1027 // The type.
1028
1029 Type*
1030 Temporary_reference_expression::do_type()
1031 {
1032   return this->statement_->type();
1033 }
1034
1035 // Called if something takes the address of this temporary variable.
1036 // We never have to move temporary variables to the heap, but we do
1037 // need to know that they must live in the stack rather than in a
1038 // register.
1039
1040 void
1041 Temporary_reference_expression::do_address_taken(bool)
1042 {
1043   this->statement_->set_is_address_taken();
1044 }
1045
1046 // Get a tree referring to the variable.
1047
1048 tree
1049 Temporary_reference_expression::do_get_tree(Translate_context* context)
1050 {
1051   Bvariable* bvar = this->statement_->get_backend_variable(context);
1052
1053   // The gcc backend can't represent the same set of recursive types
1054   // that the Go frontend can.  In some cases this means that a
1055   // temporary variable won't have the right backend type.  Correct
1056   // that here by adding a type cast.  We need to use base() to push
1057   // the circularity down one level.
1058   tree ret = var_to_tree(bvar);
1059   if (!this->is_lvalue_
1060       && POINTER_TYPE_P(TREE_TYPE(ret))
1061       && VOID_TYPE_P(TREE_TYPE(TREE_TYPE(ret))))
1062     {
1063       Btype* type_btype = this->type()->base()->get_backend(context->gogo());
1064       tree type_tree = type_to_tree(type_btype);
1065       ret = fold_convert_loc(this->location().gcc_location(), type_tree, ret);
1066     }
1067   return ret;
1068 }
1069
1070 // Ast dump for temporary reference.
1071
1072 void
1073 Temporary_reference_expression::do_dump_expression(
1074                                 Ast_dump_context* ast_dump_context) const
1075 {
1076   ast_dump_context->dump_temp_variable_name(this->statement_);
1077 }
1078
1079 // Make a reference to a temporary variable.
1080
1081 Temporary_reference_expression*
1082 Expression::make_temporary_reference(Temporary_statement* statement,
1083                                      Location location)
1084 {
1085   return new Temporary_reference_expression(statement, location);
1086 }
1087
1088 // Class Set_and_use_temporary_expression.
1089
1090 // Return the type.
1091
1092 Type*
1093 Set_and_use_temporary_expression::do_type()
1094 {
1095   return this->statement_->type();
1096 }
1097
1098 // Take the address.
1099
1100 void
1101 Set_and_use_temporary_expression::do_address_taken(bool)
1102 {
1103   this->statement_->set_is_address_taken();
1104 }
1105
1106 // Return the backend representation.
1107
1108 tree
1109 Set_and_use_temporary_expression::do_get_tree(Translate_context* context)
1110 {
1111   Bvariable* bvar = this->statement_->get_backend_variable(context);
1112   tree var_tree = var_to_tree(bvar);
1113   tree expr_tree = this->expr_->get_tree(context);
1114   if (var_tree == error_mark_node || expr_tree == error_mark_node)
1115     return error_mark_node;
1116   Location loc = this->location();
1117   return build2_loc(loc.gcc_location(), COMPOUND_EXPR, TREE_TYPE(var_tree),
1118                     build2_loc(loc.gcc_location(), MODIFY_EXPR, void_type_node,
1119                                var_tree, expr_tree),
1120                     var_tree);
1121 }
1122
1123 // Dump.
1124
1125 void
1126 Set_and_use_temporary_expression::do_dump_expression(
1127     Ast_dump_context* ast_dump_context) const
1128 {
1129   ast_dump_context->ostream() << '(';
1130   ast_dump_context->dump_temp_variable_name(this->statement_);
1131   ast_dump_context->ostream() << " = ";
1132   this->expr_->dump_expression(ast_dump_context);
1133   ast_dump_context->ostream() << ')';
1134 }
1135
1136 // Make a set-and-use temporary.
1137
1138 Set_and_use_temporary_expression*
1139 Expression::make_set_and_use_temporary(Temporary_statement* statement,
1140                                        Expression* expr, Location location)
1141 {
1142   return new Set_and_use_temporary_expression(statement, expr, location);
1143 }
1144
1145 // A sink expression--a use of the blank identifier _.
1146
1147 class Sink_expression : public Expression
1148 {
1149  public:
1150   Sink_expression(Location location)
1151     : Expression(EXPRESSION_SINK, location),
1152       type_(NULL), var_(NULL_TREE)
1153   { }
1154
1155  protected:
1156   bool
1157   do_discarding_value()
1158   { return true; }
1159
1160   Type*
1161   do_type();
1162
1163   void
1164   do_determine_type(const Type_context*);
1165
1166   Expression*
1167   do_copy()
1168   { return new Sink_expression(this->location()); }
1169
1170   tree
1171   do_get_tree(Translate_context*);
1172
1173   void
1174   do_dump_expression(Ast_dump_context*) const;
1175
1176  private:
1177   // The type of this sink variable.
1178   Type* type_;
1179   // The temporary variable we generate.
1180   tree var_;
1181 };
1182
1183 // Return the type of a sink expression.
1184
1185 Type*
1186 Sink_expression::do_type()
1187 {
1188   if (this->type_ == NULL)
1189     return Type::make_sink_type();
1190   return this->type_;
1191 }
1192
1193 // Determine the type of a sink expression.
1194
1195 void
1196 Sink_expression::do_determine_type(const Type_context* context)
1197 {
1198   if (context->type != NULL)
1199     this->type_ = context->type;
1200 }
1201
1202 // Return a temporary variable for a sink expression.  This will
1203 // presumably be a write-only variable which the middle-end will drop.
1204
1205 tree
1206 Sink_expression::do_get_tree(Translate_context* context)
1207 {
1208   if (this->var_ == NULL_TREE)
1209     {
1210       go_assert(this->type_ != NULL && !this->type_->is_sink_type());
1211       Btype* bt = this->type_->get_backend(context->gogo());
1212       this->var_ = create_tmp_var(type_to_tree(bt), "blank");
1213     }
1214   return this->var_;
1215 }
1216
1217 // Ast dump for sink expression.
1218
1219 void
1220 Sink_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1221 {
1222   ast_dump_context->ostream() << "_" ;
1223 }
1224
1225 // Make a sink expression.
1226
1227 Expression*
1228 Expression::make_sink(Location location)
1229 {
1230   return new Sink_expression(location);
1231 }
1232
1233 // Class Func_expression.
1234
1235 // FIXME: Can a function expression appear in a constant expression?
1236 // The value is unchanging.  Initializing a constant to the address of
1237 // a function seems like it could work, though there might be little
1238 // point to it.
1239
1240 // Traversal.
1241
1242 int
1243 Func_expression::do_traverse(Traverse* traverse)
1244 {
1245   return (this->closure_ == NULL
1246           ? TRAVERSE_CONTINUE
1247           : Expression::traverse(&this->closure_, traverse));
1248 }
1249
1250 // Return the type of a function expression.
1251
1252 Type*
1253 Func_expression::do_type()
1254 {
1255   if (this->function_->is_function())
1256     return this->function_->func_value()->type();
1257   else if (this->function_->is_function_declaration())
1258     return this->function_->func_declaration_value()->type();
1259   else
1260     go_unreachable();
1261 }
1262
1263 // Get the tree for a function expression without evaluating the
1264 // closure.
1265
1266 tree
1267 Func_expression::get_tree_without_closure(Gogo* gogo)
1268 {
1269   Function_type* fntype;
1270   if (this->function_->is_function())
1271     fntype = this->function_->func_value()->type();
1272   else if (this->function_->is_function_declaration())
1273     fntype = this->function_->func_declaration_value()->type();
1274   else
1275     go_unreachable();
1276
1277   // Builtin functions are handled specially by Call_expression.  We
1278   // can't take their address.
1279   if (fntype->is_builtin())
1280     {
1281       error_at(this->location(),
1282                "invalid use of special builtin function %qs; must be called",
1283                this->function_->name().c_str());
1284       return error_mark_node;
1285     }
1286
1287   Named_object* no = this->function_;
1288
1289   tree id = no->get_id(gogo);
1290   if (id == error_mark_node)
1291     return error_mark_node;
1292
1293   tree fndecl;
1294   if (no->is_function())
1295     fndecl = no->func_value()->get_or_make_decl(gogo, no, id);
1296   else if (no->is_function_declaration())
1297     fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
1298   else
1299     go_unreachable();
1300
1301   if (fndecl == error_mark_node)
1302     return error_mark_node;
1303
1304   return build_fold_addr_expr_loc(this->location().gcc_location(), fndecl);
1305 }
1306
1307 // Get the tree for a function expression.  This is used when we take
1308 // the address of a function rather than simply calling it.  If the
1309 // function has a closure, we must use a trampoline.
1310
1311 tree
1312 Func_expression::do_get_tree(Translate_context* context)
1313 {
1314   Gogo* gogo = context->gogo();
1315
1316   tree fnaddr = this->get_tree_without_closure(gogo);
1317   if (fnaddr == error_mark_node)
1318     return error_mark_node;
1319
1320   go_assert(TREE_CODE(fnaddr) == ADDR_EXPR
1321              && TREE_CODE(TREE_OPERAND(fnaddr, 0)) == FUNCTION_DECL);
1322   TREE_ADDRESSABLE(TREE_OPERAND(fnaddr, 0)) = 1;
1323
1324   // If there is no closure, that is all have to do.
1325   if (this->closure_ == NULL)
1326     return fnaddr;
1327
1328   go_assert(this->function_->func_value()->enclosing() != NULL);
1329
1330   // Get the value of the closure.  This will be a pointer to space
1331   // allocated on the heap.
1332   tree closure_tree = this->closure_->get_tree(context);
1333   if (closure_tree == error_mark_node)
1334     return error_mark_node;
1335   go_assert(POINTER_TYPE_P(TREE_TYPE(closure_tree)));
1336
1337   // Now we need to build some code on the heap.  This code will load
1338   // the static chain pointer with the closure and then jump to the
1339   // body of the function.  The normal gcc approach is to build the
1340   // code on the stack.  Unfortunately we can not do that, as Go
1341   // permits us to return the function pointer.
1342
1343   return gogo->make_trampoline(fnaddr, closure_tree, this->location());
1344 }
1345
1346 // Ast dump for function.
1347
1348 void
1349 Func_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1350 {
1351   ast_dump_context->ostream() << this->function_->name();
1352   if (this->closure_ != NULL)
1353     {
1354       ast_dump_context->ostream() << " {closure =  ";
1355       this->closure_->dump_expression(ast_dump_context);
1356       ast_dump_context->ostream() << "}";
1357     }
1358 }
1359
1360 // Make a reference to a function in an expression.
1361
1362 Expression*
1363 Expression::make_func_reference(Named_object* function, Expression* closure,
1364                                 Location location)
1365 {
1366   return new Func_expression(function, closure, location);
1367 }
1368
1369 // Class Unknown_expression.
1370
1371 // Return the name of an unknown expression.
1372
1373 const std::string&
1374 Unknown_expression::name() const
1375 {
1376   return this->named_object_->name();
1377 }
1378
1379 // Lower a reference to an unknown name.
1380
1381 Expression*
1382 Unknown_expression::do_lower(Gogo*, Named_object*, Statement_inserter*, int)
1383 {
1384   Location location = this->location();
1385   Named_object* no = this->named_object_;
1386   Named_object* real;
1387   if (!no->is_unknown())
1388     real = no;
1389   else
1390     {
1391       real = no->unknown_value()->real_named_object();
1392       if (real == NULL)
1393         {
1394           if (this->is_composite_literal_key_)
1395             return this;
1396           if (!this->no_error_message_)
1397             error_at(location, "reference to undefined name %qs",
1398                      this->named_object_->message_name().c_str());
1399           return Expression::make_error(location);
1400         }
1401     }
1402   switch (real->classification())
1403     {
1404     case Named_object::NAMED_OBJECT_CONST:
1405       return Expression::make_const_reference(real, location);
1406     case Named_object::NAMED_OBJECT_TYPE:
1407       return Expression::make_type(real->type_value(), location);
1408     case Named_object::NAMED_OBJECT_TYPE_DECLARATION:
1409       if (this->is_composite_literal_key_)
1410         return this;
1411       if (!this->no_error_message_)
1412         error_at(location, "reference to undefined type %qs",
1413                  real->message_name().c_str());
1414       return Expression::make_error(location);
1415     case Named_object::NAMED_OBJECT_VAR:
1416       real->var_value()->set_is_used();
1417       return Expression::make_var_reference(real, location);
1418     case Named_object::NAMED_OBJECT_FUNC:
1419     case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
1420       return Expression::make_func_reference(real, NULL, location);
1421     case Named_object::NAMED_OBJECT_PACKAGE:
1422       if (this->is_composite_literal_key_)
1423         return this;
1424       if (!this->no_error_message_)
1425         error_at(location, "unexpected reference to package");
1426       return Expression::make_error(location);
1427     default:
1428       go_unreachable();
1429     }
1430 }
1431
1432 // Dump the ast representation for an unknown expression to a dump context.
1433
1434 void
1435 Unknown_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1436 {
1437   ast_dump_context->ostream() << "_Unknown_(" << this->named_object_->name()
1438                               << ")";
1439 }
1440
1441 // Make a reference to an unknown name.
1442
1443 Unknown_expression*
1444 Expression::make_unknown_reference(Named_object* no, Location location)
1445 {
1446   return new Unknown_expression(no, location);
1447 }
1448
1449 // A boolean expression.
1450
1451 class Boolean_expression : public Expression
1452 {
1453  public:
1454   Boolean_expression(bool val, Location location)
1455     : Expression(EXPRESSION_BOOLEAN, location),
1456       val_(val), type_(NULL)
1457   { }
1458
1459   static Expression*
1460   do_import(Import*);
1461
1462  protected:
1463   bool
1464   do_is_constant() const
1465   { return true; }
1466
1467   Type*
1468   do_type();
1469
1470   void
1471   do_determine_type(const Type_context*);
1472
1473   Expression*
1474   do_copy()
1475   { return this; }
1476
1477   tree
1478   do_get_tree(Translate_context*)
1479   { return this->val_ ? boolean_true_node : boolean_false_node; }
1480
1481   void
1482   do_export(Export* exp) const
1483   { exp->write_c_string(this->val_ ? "true" : "false"); }
1484
1485   void
1486   do_dump_expression(Ast_dump_context* ast_dump_context) const
1487   { ast_dump_context->ostream() << (this->val_ ? "true" : "false"); }
1488   
1489  private:
1490   // The constant.
1491   bool val_;
1492   // The type as determined by context.
1493   Type* type_;
1494 };
1495
1496 // Get the type.
1497
1498 Type*
1499 Boolean_expression::do_type()
1500 {
1501   if (this->type_ == NULL)
1502     this->type_ = Type::make_boolean_type();
1503   return this->type_;
1504 }
1505
1506 // Set the type from the context.
1507
1508 void
1509 Boolean_expression::do_determine_type(const Type_context* context)
1510 {
1511   if (this->type_ != NULL && !this->type_->is_abstract())
1512     ;
1513   else if (context->type != NULL && context->type->is_boolean_type())
1514     this->type_ = context->type;
1515   else if (!context->may_be_abstract)
1516     this->type_ = Type::lookup_bool_type();
1517 }
1518
1519 // Import a boolean constant.
1520
1521 Expression*
1522 Boolean_expression::do_import(Import* imp)
1523 {
1524   if (imp->peek_char() == 't')
1525     {
1526       imp->require_c_string("true");
1527       return Expression::make_boolean(true, imp->location());
1528     }
1529   else
1530     {
1531       imp->require_c_string("false");
1532       return Expression::make_boolean(false, imp->location());
1533     }
1534 }
1535
1536 // Make a boolean expression.
1537
1538 Expression*
1539 Expression::make_boolean(bool val, Location location)
1540 {
1541   return new Boolean_expression(val, location);
1542 }
1543
1544 // Class String_expression.
1545
1546 // Get the type.
1547
1548 Type*
1549 String_expression::do_type()
1550 {
1551   if (this->type_ == NULL)
1552     this->type_ = Type::make_string_type();
1553   return this->type_;
1554 }
1555
1556 // Set the type from the context.
1557
1558 void
1559 String_expression::do_determine_type(const Type_context* context)
1560 {
1561   if (this->type_ != NULL && !this->type_->is_abstract())
1562     ;
1563   else if (context->type != NULL && context->type->is_string_type())
1564     this->type_ = context->type;
1565   else if (!context->may_be_abstract)
1566     this->type_ = Type::lookup_string_type();
1567 }
1568
1569 // Build a string constant.
1570
1571 tree
1572 String_expression::do_get_tree(Translate_context* context)
1573 {
1574   return context->gogo()->go_string_constant_tree(this->val_);
1575 }
1576
1577  // Write string literal to string dump.
1578
1579 void
1580 String_expression::export_string(String_dump* exp,
1581                                  const String_expression* str)
1582 {
1583   std::string s;
1584   s.reserve(str->val_.length() * 4 + 2);
1585   s += '"';
1586   for (std::string::const_iterator p = str->val_.begin();
1587        p != str->val_.end();
1588        ++p)
1589     {
1590       if (*p == '\\' || *p == '"')
1591         {
1592           s += '\\';
1593           s += *p;
1594         }
1595       else if (*p >= 0x20 && *p < 0x7f)
1596         s += *p;
1597       else if (*p == '\n')
1598         s += "\\n";
1599       else if (*p == '\t')
1600         s += "\\t";
1601       else
1602         {
1603           s += "\\x";
1604           unsigned char c = *p;
1605           unsigned int dig = c >> 4;
1606           s += dig < 10 ? '0' + dig : 'A' + dig - 10;
1607           dig = c & 0xf;
1608           s += dig < 10 ? '0' + dig : 'A' + dig - 10;
1609         }
1610     }
1611   s += '"';
1612   exp->write_string(s);
1613 }
1614
1615 // Export a string expression.
1616
1617 void
1618 String_expression::do_export(Export* exp) const
1619 {
1620   String_expression::export_string(exp, this);
1621 }
1622
1623 // Import a string expression.
1624
1625 Expression*
1626 String_expression::do_import(Import* imp)
1627 {
1628   imp->require_c_string("\"");
1629   std::string val;
1630   while (true)
1631     {
1632       int c = imp->get_char();
1633       if (c == '"' || c == -1)
1634         break;
1635       if (c != '\\')
1636         val += static_cast<char>(c);
1637       else
1638         {
1639           c = imp->get_char();
1640           if (c == '\\' || c == '"')
1641             val += static_cast<char>(c);
1642           else if (c == 'n')
1643             val += '\n';
1644           else if (c == 't')
1645             val += '\t';
1646           else if (c == 'x')
1647             {
1648               c = imp->get_char();
1649               unsigned int vh = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
1650               c = imp->get_char();
1651               unsigned int vl = c >= '0' && c <= '9' ? c - '0' : c - 'A' + 10;
1652               char v = (vh << 4) | vl;
1653               val += v;
1654             }
1655           else
1656             {
1657               error_at(imp->location(), "bad string constant");
1658               return Expression::make_error(imp->location());
1659             }
1660         }
1661     }
1662   return Expression::make_string(val, imp->location());
1663 }
1664
1665 // Ast dump for string expression.
1666
1667 void
1668 String_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1669 {
1670   String_expression::export_string(ast_dump_context, this);
1671 }
1672
1673 // Make a string expression.
1674
1675 Expression*
1676 Expression::make_string(const std::string& val, Location location)
1677 {
1678   return new String_expression(val, location);
1679 }
1680
1681 // Make an integer expression.
1682
1683 class Integer_expression : public Expression
1684 {
1685  public:
1686   Integer_expression(const mpz_t* val, Type* type, bool is_character_constant,
1687                      Location location)
1688     : Expression(EXPRESSION_INTEGER, location),
1689       type_(type), is_character_constant_(is_character_constant)
1690   { mpz_init_set(this->val_, *val); }
1691
1692   static Expression*
1693   do_import(Import*);
1694
1695   // Write VAL to string dump.
1696   static void
1697   export_integer(String_dump* exp, const mpz_t val);
1698
1699   // Write VAL to dump context.
1700   static void
1701   dump_integer(Ast_dump_context* ast_dump_context, const mpz_t val);
1702
1703  protected:
1704   bool
1705   do_is_constant() const
1706   { return true; }
1707
1708   bool
1709   do_numeric_constant_value(Numeric_constant* nc) const;
1710
1711   Type*
1712   do_type();
1713
1714   void
1715   do_determine_type(const Type_context* context);
1716
1717   void
1718   do_check_types(Gogo*);
1719
1720   tree
1721   do_get_tree(Translate_context*);
1722
1723   Expression*
1724   do_copy()
1725   {
1726     if (this->is_character_constant_)
1727       return Expression::make_character(&this->val_, this->type_,
1728                                         this->location());
1729     else
1730       return Expression::make_integer(&this->val_, this->type_,
1731                                       this->location());
1732   }
1733
1734   void
1735   do_export(Export*) const;
1736
1737   void
1738   do_dump_expression(Ast_dump_context*) const;
1739
1740  private:
1741   // The integer value.
1742   mpz_t val_;
1743   // The type so far.
1744   Type* type_;
1745   // Whether this is a character constant.
1746   bool is_character_constant_;
1747 };
1748
1749 // Return a numeric constant for this expression.  We have to mark
1750 // this as a character when appropriate.
1751
1752 bool
1753 Integer_expression::do_numeric_constant_value(Numeric_constant* nc) const
1754 {
1755   if (this->is_character_constant_)
1756     nc->set_rune(this->type_, this->val_);
1757   else
1758     nc->set_int(this->type_, this->val_);
1759   return true;
1760 }
1761
1762 // Return the current type.  If we haven't set the type yet, we return
1763 // an abstract integer type.
1764
1765 Type*
1766 Integer_expression::do_type()
1767 {
1768   if (this->type_ == NULL)
1769     {
1770       if (this->is_character_constant_)
1771         this->type_ = Type::make_abstract_character_type();
1772       else
1773         this->type_ = Type::make_abstract_integer_type();
1774     }
1775   return this->type_;
1776 }
1777
1778 // Set the type of the integer value.  Here we may switch from an
1779 // abstract type to a real type.
1780
1781 void
1782 Integer_expression::do_determine_type(const Type_context* context)
1783 {
1784   if (this->type_ != NULL && !this->type_->is_abstract())
1785     ;
1786   else if (context->type != NULL && context->type->is_numeric_type())
1787     this->type_ = context->type;
1788   else if (!context->may_be_abstract)
1789     {
1790       if (this->is_character_constant_)
1791         this->type_ = Type::lookup_integer_type("int32");
1792       else
1793         this->type_ = Type::lookup_integer_type("int");
1794     }
1795 }
1796
1797 // Check the type of an integer constant.
1798
1799 void
1800 Integer_expression::do_check_types(Gogo*)
1801 {
1802   Type* type = this->type_;
1803   if (type == NULL)
1804     return;
1805   Numeric_constant nc;
1806   if (this->is_character_constant_)
1807     nc.set_rune(NULL, this->val_);
1808   else
1809     nc.set_int(NULL, this->val_);
1810   if (!nc.set_type(type, true, this->location()))
1811     this->set_is_error();
1812 }
1813
1814 // Get a tree for an integer constant.
1815
1816 tree
1817 Integer_expression::do_get_tree(Translate_context* context)
1818 {
1819   Gogo* gogo = context->gogo();
1820   tree type;
1821   if (this->type_ != NULL && !this->type_->is_abstract())
1822     type = type_to_tree(this->type_->get_backend(gogo));
1823   else if (this->type_ != NULL && this->type_->float_type() != NULL)
1824     {
1825       // We are converting to an abstract floating point type.
1826       Type* ftype = Type::lookup_float_type("float64");
1827       type = type_to_tree(ftype->get_backend(gogo));
1828     }
1829   else if (this->type_ != NULL && this->type_->complex_type() != NULL)
1830     {
1831       // We are converting to an abstract complex type.
1832       Type* ctype = Type::lookup_complex_type("complex128");
1833       type = type_to_tree(ctype->get_backend(gogo));
1834     }
1835   else
1836     {
1837       // If we still have an abstract type here, then this is being
1838       // used in a constant expression which didn't get reduced for
1839       // some reason.  Use a type which will fit the value.  We use <,
1840       // not <=, because we need an extra bit for the sign bit.
1841       int bits = mpz_sizeinbase(this->val_, 2);
1842       if (bits < INT_TYPE_SIZE)
1843         {
1844           Type* t = Type::lookup_integer_type("int");
1845           type = type_to_tree(t->get_backend(gogo));
1846         }
1847       else if (bits < 64)
1848         {
1849           Type* t = Type::lookup_integer_type("int64");
1850           type = type_to_tree(t->get_backend(gogo));
1851         }
1852       else
1853         type = long_long_integer_type_node;
1854     }
1855   return Expression::integer_constant_tree(this->val_, type);
1856 }
1857
1858 // Write VAL to export data.
1859
1860 void
1861 Integer_expression::export_integer(String_dump* exp, const mpz_t val)
1862 {
1863   char* s = mpz_get_str(NULL, 10, val);
1864   exp->write_c_string(s);
1865   free(s);
1866 }
1867
1868 // Export an integer in a constant expression.
1869
1870 void
1871 Integer_expression::do_export(Export* exp) const
1872 {
1873   Integer_expression::export_integer(exp, this->val_);
1874   if (this->is_character_constant_)
1875     exp->write_c_string("'");
1876   // A trailing space lets us reliably identify the end of the number.
1877   exp->write_c_string(" ");
1878 }
1879
1880 // Import an integer, floating point, or complex value.  This handles
1881 // all these types because they all start with digits.
1882
1883 Expression*
1884 Integer_expression::do_import(Import* imp)
1885 {
1886   std::string num = imp->read_identifier();
1887   imp->require_c_string(" ");
1888   if (!num.empty() && num[num.length() - 1] == 'i')
1889     {
1890       mpfr_t real;
1891       size_t plus_pos = num.find('+', 1);
1892       size_t minus_pos = num.find('-', 1);
1893       size_t pos;
1894       if (plus_pos == std::string::npos)
1895         pos = minus_pos;
1896       else if (minus_pos == std::string::npos)
1897         pos = plus_pos;
1898       else
1899         {
1900           error_at(imp->location(), "bad number in import data: %qs",
1901                    num.c_str());
1902           return Expression::make_error(imp->location());
1903         }
1904       if (pos == std::string::npos)
1905         mpfr_set_ui(real, 0, GMP_RNDN);
1906       else
1907         {
1908           std::string real_str = num.substr(0, pos);
1909           if (mpfr_init_set_str(real, real_str.c_str(), 10, GMP_RNDN) != 0)
1910             {
1911               error_at(imp->location(), "bad number in import data: %qs",
1912                        real_str.c_str());
1913               return Expression::make_error(imp->location());
1914             }
1915         }
1916
1917       std::string imag_str;
1918       if (pos == std::string::npos)
1919         imag_str = num;
1920       else
1921         imag_str = num.substr(pos);
1922       imag_str = imag_str.substr(0, imag_str.size() - 1);
1923       mpfr_t imag;
1924       if (mpfr_init_set_str(imag, imag_str.c_str(), 10, GMP_RNDN) != 0)
1925         {
1926           error_at(imp->location(), "bad number in import data: %qs",
1927                    imag_str.c_str());
1928           return Expression::make_error(imp->location());
1929         }
1930       Expression* ret = Expression::make_complex(&real, &imag, NULL,
1931                                                  imp->location());
1932       mpfr_clear(real);
1933       mpfr_clear(imag);
1934       return ret;
1935     }
1936   else if (num.find('.') == std::string::npos
1937            && num.find('E') == std::string::npos)
1938     {
1939       bool is_character_constant = (!num.empty()
1940                                     && num[num.length() - 1] == '\'');
1941       if (is_character_constant)
1942         num = num.substr(0, num.length() - 1);
1943       mpz_t val;
1944       if (mpz_init_set_str(val, num.c_str(), 10) != 0)
1945         {
1946           error_at(imp->location(), "bad number in import data: %qs",
1947                    num.c_str());
1948           return Expression::make_error(imp->location());
1949         }
1950       Expression* ret;
1951       if (is_character_constant)
1952         ret = Expression::make_character(&val, NULL, imp->location());
1953       else
1954         ret = Expression::make_integer(&val, NULL, imp->location());
1955       mpz_clear(val);
1956       return ret;
1957     }
1958   else
1959     {
1960       mpfr_t val;
1961       if (mpfr_init_set_str(val, num.c_str(), 10, GMP_RNDN) != 0)
1962         {
1963           error_at(imp->location(), "bad number in import data: %qs",
1964                    num.c_str());
1965           return Expression::make_error(imp->location());
1966         }
1967       Expression* ret = Expression::make_float(&val, NULL, imp->location());
1968       mpfr_clear(val);
1969       return ret;
1970     }
1971 }
1972 // Ast dump for integer expression.
1973
1974 void
1975 Integer_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
1976 {
1977   if (this->is_character_constant_)
1978     ast_dump_context->ostream() << '\'';
1979   Integer_expression::export_integer(ast_dump_context, this->val_);
1980   if (this->is_character_constant_)
1981     ast_dump_context->ostream() << '\'';
1982 }
1983
1984 // Build a new integer value.
1985
1986 Expression*
1987 Expression::make_integer(const mpz_t* val, Type* type, Location location)
1988 {
1989   return new Integer_expression(val, type, false, location);
1990 }
1991
1992 // Build a new character constant value.
1993
1994 Expression*
1995 Expression::make_character(const mpz_t* val, Type* type, Location location)
1996 {
1997   return new Integer_expression(val, type, true, location);
1998 }
1999
2000 // Floats.
2001
2002 class Float_expression : public Expression
2003 {
2004  public:
2005   Float_expression(const mpfr_t* val, Type* type, Location location)
2006     : Expression(EXPRESSION_FLOAT, location),
2007       type_(type)
2008   {
2009     mpfr_init_set(this->val_, *val, GMP_RNDN);
2010   }
2011
2012   // Write VAL to export data.
2013   static void
2014   export_float(String_dump* exp, const mpfr_t val);
2015
2016   // Write VAL to dump file.
2017   static void
2018   dump_float(Ast_dump_context* ast_dump_context, const mpfr_t val);
2019
2020  protected:
2021   bool
2022   do_is_constant() const
2023   { return true; }
2024
2025   bool
2026   do_numeric_constant_value(Numeric_constant* nc) const
2027   {
2028     nc->set_float(this->type_, this->val_);
2029     return true;
2030   }
2031
2032   Type*
2033   do_type();
2034
2035   void
2036   do_determine_type(const Type_context*);
2037
2038   void
2039   do_check_types(Gogo*);
2040
2041   Expression*
2042   do_copy()
2043   { return Expression::make_float(&this->val_, this->type_,
2044                                   this->location()); }
2045
2046   tree
2047   do_get_tree(Translate_context*);
2048
2049   void
2050   do_export(Export*) const;
2051
2052   void
2053   do_dump_expression(Ast_dump_context*) const;
2054
2055  private:
2056   // The floating point value.
2057   mpfr_t val_;
2058   // The type so far.
2059   Type* type_;
2060 };
2061
2062 // Return the current type.  If we haven't set the type yet, we return
2063 // an abstract float type.
2064
2065 Type*
2066 Float_expression::do_type()
2067 {
2068   if (this->type_ == NULL)
2069     this->type_ = Type::make_abstract_float_type();
2070   return this->type_;
2071 }
2072
2073 // Set the type of the float value.  Here we may switch from an
2074 // abstract type to a real type.
2075
2076 void
2077 Float_expression::do_determine_type(const Type_context* context)
2078 {
2079   if (this->type_ != NULL && !this->type_->is_abstract())
2080     ;
2081   else if (context->type != NULL
2082            && (context->type->integer_type() != NULL
2083                || context->type->float_type() != NULL
2084                || context->type->complex_type() != NULL))
2085     this->type_ = context->type;
2086   else if (!context->may_be_abstract)
2087     this->type_ = Type::lookup_float_type("float64");
2088 }
2089
2090 // Check the type of a float value.
2091
2092 void
2093 Float_expression::do_check_types(Gogo*)
2094 {
2095   Type* type = this->type_;
2096   if (type == NULL)
2097     return;
2098   Numeric_constant nc;
2099   nc.set_float(NULL, this->val_);
2100   if (!nc.set_type(this->type_, true, this->location()))
2101     this->set_is_error();
2102 }
2103
2104 // Get a tree for a float constant.
2105
2106 tree
2107 Float_expression::do_get_tree(Translate_context* context)
2108 {
2109   Gogo* gogo = context->gogo();
2110   tree type;
2111   if (this->type_ != NULL && !this->type_->is_abstract())
2112     type = type_to_tree(this->type_->get_backend(gogo));
2113   else if (this->type_ != NULL && this->type_->integer_type() != NULL)
2114     {
2115       // We have an abstract integer type.  We just hope for the best.
2116       type = type_to_tree(Type::lookup_integer_type("int")->get_backend(gogo));
2117     }
2118   else
2119     {
2120       // If we still have an abstract type here, then this is being
2121       // used in a constant expression which didn't get reduced.  We
2122       // just use float64 and hope for the best.
2123       Type* ft = Type::lookup_float_type("float64");
2124       type = type_to_tree(ft->get_backend(gogo));
2125     }
2126   return Expression::float_constant_tree(this->val_, type);
2127 }
2128
2129 // Write a floating point number to a string dump.
2130
2131 void
2132 Float_expression::export_float(String_dump *exp, const mpfr_t val)
2133 {
2134   mp_exp_t exponent;
2135   char* s = mpfr_get_str(NULL, &exponent, 10, 0, val, GMP_RNDN);
2136   if (*s == '-')
2137     exp->write_c_string("-");
2138   exp->write_c_string("0.");
2139   exp->write_c_string(*s == '-' ? s + 1 : s);
2140   mpfr_free_str(s);
2141   char buf[30];
2142   snprintf(buf, sizeof buf, "E%ld", exponent);
2143   exp->write_c_string(buf);
2144 }
2145
2146 // Export a floating point number in a constant expression.
2147
2148 void
2149 Float_expression::do_export(Export* exp) const
2150 {
2151   Float_expression::export_float(exp, this->val_);
2152   // A trailing space lets us reliably identify the end of the number.
2153   exp->write_c_string(" ");
2154 }
2155
2156 // Dump a floating point number to the dump file.
2157
2158 void
2159 Float_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
2160 {
2161   Float_expression::export_float(ast_dump_context, this->val_);
2162 }
2163
2164 // Make a float expression.
2165
2166 Expression*
2167 Expression::make_float(const mpfr_t* val, Type* type, Location location)
2168 {
2169   return new Float_expression(val, type, location);
2170 }
2171
2172 // Complex numbers.
2173
2174 class Complex_expression : public Expression
2175 {
2176  public:
2177   Complex_expression(const mpfr_t* real, const mpfr_t* imag, Type* type,
2178                      Location location)
2179     : Expression(EXPRESSION_COMPLEX, location),
2180       type_(type)
2181   {
2182     mpfr_init_set(this->real_, *real, GMP_RNDN);
2183     mpfr_init_set(this->imag_, *imag, GMP_RNDN);
2184   }
2185
2186   // Write REAL/IMAG to string dump.
2187   static void
2188   export_complex(String_dump* exp, const mpfr_t real, const mpfr_t val);
2189
2190   // Write REAL/IMAG to dump context.
2191   static void
2192   dump_complex(Ast_dump_context* ast_dump_context, 
2193                const mpfr_t real, const mpfr_t val);
2194   
2195  protected:
2196   bool
2197   do_is_constant() const
2198   { return true; }
2199
2200   bool
2201   do_numeric_constant_value(Numeric_constant* nc) const
2202   {
2203     nc->set_complex(this->type_, this->real_, this->imag_);
2204     return true;
2205   }
2206
2207   Type*
2208   do_type();
2209
2210   void
2211   do_determine_type(const Type_context*);
2212
2213   void
2214   do_check_types(Gogo*);
2215
2216   Expression*
2217   do_copy()
2218   {
2219     return Expression::make_complex(&this->real_, &this->imag_, this->type_,
2220                                     this->location());
2221   }
2222
2223   tree
2224   do_get_tree(Translate_context*);
2225
2226   void
2227   do_export(Export*) const;
2228
2229   void
2230   do_dump_expression(Ast_dump_context*) const;
2231   
2232  private:
2233   // The real part.
2234   mpfr_t real_;
2235   // The imaginary part;
2236   mpfr_t imag_;
2237   // The type if known.
2238   Type* type_;
2239 };
2240
2241 // Return the current type.  If we haven't set the type yet, we return
2242 // an abstract complex type.
2243
2244 Type*
2245 Complex_expression::do_type()
2246 {
2247   if (this->type_ == NULL)
2248     this->type_ = Type::make_abstract_complex_type();
2249   return this->type_;
2250 }
2251
2252 // Set the type of the complex value.  Here we may switch from an
2253 // abstract type to a real type.
2254
2255 void
2256 Complex_expression::do_determine_type(const Type_context* context)
2257 {
2258   if (this->type_ != NULL && !this->type_->is_abstract())
2259     ;
2260   else if (context->type != NULL
2261            && context->type->complex_type() != NULL)
2262     this->type_ = context->type;
2263   else if (!context->may_be_abstract)
2264     this->type_ = Type::lookup_complex_type("complex128");
2265 }
2266
2267 // Check the type of a complex value.
2268
2269 void
2270 Complex_expression::do_check_types(Gogo*)
2271 {
2272   Type* type = this->type_;
2273   if (type == NULL)
2274     return;
2275   Numeric_constant nc;
2276   nc.set_complex(NULL, this->real_, this->imag_);
2277   if (!nc.set_type(this->type_, true, this->location()))
2278     this->set_is_error();
2279 }
2280
2281 // Get a tree for a complex constant.
2282
2283 tree
2284 Complex_expression::do_get_tree(Translate_context* context)
2285 {
2286   Gogo* gogo = context->gogo();
2287   tree type;
2288   if (this->type_ != NULL && !this->type_->is_abstract())
2289     type = type_to_tree(this->type_->get_backend(gogo));
2290   else
2291     {
2292       // If we still have an abstract type here, this this is being
2293       // used in a constant expression which didn't get reduced.  We
2294       // just use complex128 and hope for the best.
2295       Type* ct = Type::lookup_complex_type("complex128");
2296       type = type_to_tree(ct->get_backend(gogo));
2297     }
2298   return Expression::complex_constant_tree(this->real_, this->imag_, type);
2299 }
2300
2301 // Write REAL/IMAG to export data.
2302
2303 void
2304 Complex_expression::export_complex(String_dump* exp, const mpfr_t real,
2305                                    const mpfr_t imag)
2306 {
2307   if (!mpfr_zero_p(real))
2308     {
2309       Float_expression::export_float(exp, real);
2310       if (mpfr_sgn(imag) > 0)
2311         exp->write_c_string("+");
2312     }
2313   Float_expression::export_float(exp, imag);
2314   exp->write_c_string("i");
2315 }
2316
2317 // Export a complex number in a constant expression.
2318
2319 void
2320 Complex_expression::do_export(Export* exp) const
2321 {
2322   Complex_expression::export_complex(exp, this->real_, this->imag_);
2323   // A trailing space lets us reliably identify the end of the number.
2324   exp->write_c_string(" ");
2325 }
2326
2327 // Dump a complex expression to the dump file.
2328
2329 void
2330 Complex_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
2331 {
2332   Complex_expression::export_complex(ast_dump_context,
2333                                       this->real_,
2334                                       this->imag_);
2335 }
2336
2337 // Make a complex expression.
2338
2339 Expression*
2340 Expression::make_complex(const mpfr_t* real, const mpfr_t* imag, Type* type,
2341                          Location location)
2342 {
2343   return new Complex_expression(real, imag, type, location);
2344 }
2345
2346 // Find a named object in an expression.
2347
2348 class Find_named_object : public Traverse
2349 {
2350  public:
2351   Find_named_object(Named_object* no)
2352     : Traverse(traverse_expressions),
2353       no_(no), found_(false)
2354   { }
2355
2356   // Whether we found the object.
2357   bool
2358   found() const
2359   { return this->found_; }
2360
2361  protected:
2362   int
2363   expression(Expression**);
2364
2365  private:
2366   // The object we are looking for.
2367   Named_object* no_;
2368   // Whether we found it.
2369   bool found_;
2370 };
2371
2372 // A reference to a const in an expression.
2373
2374 class Const_expression : public Expression
2375 {
2376  public:
2377   Const_expression(Named_object* constant, Location location)
2378     : Expression(EXPRESSION_CONST_REFERENCE, location),
2379       constant_(constant), type_(NULL), seen_(false)
2380   { }
2381
2382   Named_object*
2383   named_object()
2384   { return this->constant_; }
2385
2386   // Check that the initializer does not refer to the constant itself.
2387   void
2388   check_for_init_loop();
2389
2390  protected:
2391   int
2392   do_traverse(Traverse*);
2393
2394   Expression*
2395   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
2396
2397   bool
2398   do_is_constant() const
2399   { return true; }
2400
2401   bool
2402   do_numeric_constant_value(Numeric_constant* nc) const;
2403
2404   bool
2405   do_string_constant_value(std::string* val) const;
2406
2407   Type*
2408   do_type();
2409
2410   // The type of a const is set by the declaration, not the use.
2411   void
2412   do_determine_type(const Type_context*);
2413
2414   void
2415   do_check_types(Gogo*);
2416
2417   Expression*
2418   do_copy()
2419   { return this; }
2420
2421   tree
2422   do_get_tree(Translate_context* context);
2423
2424   // When exporting a reference to a const as part of a const
2425   // expression, we export the value.  We ignore the fact that it has
2426   // a name.
2427   void
2428   do_export(Export* exp) const
2429   { this->constant_->const_value()->expr()->export_expression(exp); }
2430
2431   void
2432   do_dump_expression(Ast_dump_context*) const;
2433
2434  private:
2435   // The constant.
2436   Named_object* constant_;
2437   // The type of this reference.  This is used if the constant has an
2438   // abstract type.
2439   Type* type_;
2440   // Used to prevent infinite recursion when a constant incorrectly
2441   // refers to itself.
2442   mutable bool seen_;
2443 };
2444
2445 // Traversal.
2446
2447 int
2448 Const_expression::do_traverse(Traverse* traverse)
2449 {
2450   if (this->type_ != NULL)
2451     return Type::traverse(this->type_, traverse);
2452   return TRAVERSE_CONTINUE;
2453 }
2454
2455 // Lower a constant expression.  This is where we convert the
2456 // predeclared constant iota into an integer value.
2457
2458 Expression*
2459 Const_expression::do_lower(Gogo* gogo, Named_object*,
2460                            Statement_inserter*, int iota_value)
2461 {
2462   if (this->constant_->const_value()->expr()->classification()
2463       == EXPRESSION_IOTA)
2464     {
2465       if (iota_value == -1)
2466         {
2467           error_at(this->location(),
2468                    "iota is only defined in const declarations");
2469           iota_value = 0;
2470         }
2471       mpz_t val;
2472       mpz_init_set_ui(val, static_cast<unsigned long>(iota_value));
2473       Expression* ret = Expression::make_integer(&val, NULL,
2474                                                  this->location());
2475       mpz_clear(val);
2476       return ret;
2477     }
2478
2479   // Make sure that the constant itself has been lowered.
2480   gogo->lower_constant(this->constant_);
2481
2482   return this;
2483 }
2484
2485 // Return a numeric constant value.
2486
2487 bool
2488 Const_expression::do_numeric_constant_value(Numeric_constant* nc) const
2489 {
2490   if (this->seen_)
2491     return false;
2492
2493   Expression* e = this->constant_->const_value()->expr();
2494   
2495   this->seen_ = true;
2496
2497   bool r = e->numeric_constant_value(nc);
2498
2499   this->seen_ = false;
2500
2501   Type* ctype;
2502   if (this->type_ != NULL)
2503     ctype = this->type_;
2504   else
2505     ctype = this->constant_->const_value()->type();
2506   if (r && ctype != NULL)
2507     {
2508       if (!nc->set_type(ctype, false, this->location()))
2509         return false;
2510     }
2511
2512   return r;
2513 }
2514
2515 bool
2516 Const_expression::do_string_constant_value(std::string* val) const
2517 {
2518   if (this->seen_)
2519     return false;
2520
2521   Expression* e = this->constant_->const_value()->expr();
2522
2523   this->seen_ = true;
2524   bool ok = e->string_constant_value(val);
2525   this->seen_ = false;
2526
2527   return ok;
2528 }
2529
2530 // Return the type of the const reference.
2531
2532 Type*
2533 Const_expression::do_type()
2534 {
2535   if (this->type_ != NULL)
2536     return this->type_;
2537
2538   Named_constant* nc = this->constant_->const_value();
2539
2540   if (this->seen_ || nc->lowering())
2541     {
2542       this->report_error(_("constant refers to itself"));
2543       this->type_ = Type::make_error_type();
2544       return this->type_;
2545     }
2546
2547   this->seen_ = true;
2548
2549   Type* ret = nc->type();
2550
2551   if (ret != NULL)
2552     {
2553       this->seen_ = false;
2554       return ret;
2555     }
2556
2557   // During parsing, a named constant may have a NULL type, but we
2558   // must not return a NULL type here.
2559   ret = nc->expr()->type();
2560
2561   this->seen_ = false;
2562
2563   return ret;
2564 }
2565
2566 // Set the type of the const reference.
2567
2568 void
2569 Const_expression::do_determine_type(const Type_context* context)
2570 {
2571   Type* ctype = this->constant_->const_value()->type();
2572   Type* cetype = (ctype != NULL
2573                   ? ctype
2574                   : this->constant_->const_value()->expr()->type());
2575   if (ctype != NULL && !ctype->is_abstract())
2576     ;
2577   else if (context->type != NULL
2578            && context->type->is_numeric_type()
2579            && cetype->is_numeric_type())
2580     this->type_ = context->type;
2581   else if (context->type != NULL
2582            && context->type->is_string_type()
2583            && cetype->is_string_type())
2584     this->type_ = context->type;
2585   else if (context->type != NULL
2586            && context->type->is_boolean_type()
2587            && cetype->is_boolean_type())
2588     this->type_ = context->type;
2589   else if (!context->may_be_abstract)
2590     {
2591       if (cetype->is_abstract())
2592         cetype = cetype->make_non_abstract_type();
2593       this->type_ = cetype;
2594     }
2595 }
2596
2597 // Check for a loop in which the initializer of a constant refers to
2598 // the constant itself.
2599
2600 void
2601 Const_expression::check_for_init_loop()
2602 {
2603   if (this->type_ != NULL && this->type_->is_error())
2604     return;
2605
2606   if (this->seen_)
2607     {
2608       this->report_error(_("constant refers to itself"));
2609       this->type_ = Type::make_error_type();
2610       return;
2611     }
2612
2613   Expression* init = this->constant_->const_value()->expr();
2614   Find_named_object find_named_object(this->constant_);
2615
2616   this->seen_ = true;
2617   Expression::traverse(&init, &find_named_object);
2618   this->seen_ = false;
2619
2620   if (find_named_object.found())
2621     {
2622       if (this->type_ == NULL || !this->type_->is_error())
2623         {
2624           this->report_error(_("constant refers to itself"));
2625           this->type_ = Type::make_error_type();
2626         }
2627       return;
2628     }
2629 }
2630
2631 // Check types of a const reference.
2632
2633 void
2634 Const_expression::do_check_types(Gogo*)
2635 {
2636   if (this->type_ != NULL && this->type_->is_error())
2637     return;
2638
2639   this->check_for_init_loop();
2640
2641   // Check that numeric constant fits in type.
2642   if (this->type_ != NULL && this->type_->is_numeric_type())
2643     {
2644       Numeric_constant nc;
2645       if (this->constant_->const_value()->expr()->numeric_constant_value(&nc))
2646         {
2647           if (!nc.set_type(this->type_, true, this->location()))
2648             this->set_is_error();
2649         }
2650     }
2651 }
2652
2653 // Return a tree for the const reference.
2654
2655 tree
2656 Const_expression::do_get_tree(Translate_context* context)
2657 {
2658   Gogo* gogo = context->gogo();
2659   tree type_tree;
2660   if (this->type_ == NULL)
2661     type_tree = NULL_TREE;
2662   else
2663     {
2664       type_tree = type_to_tree(this->type_->get_backend(gogo));
2665       if (type_tree == error_mark_node)
2666         return error_mark_node;
2667     }
2668
2669   // If the type has been set for this expression, but the underlying
2670   // object is an abstract int or float, we try to get the abstract
2671   // value.  Otherwise we may lose something in the conversion.
2672   if (this->type_ != NULL
2673       && this->type_->is_numeric_type()
2674       && (this->constant_->const_value()->type() == NULL
2675           || this->constant_->const_value()->type()->is_abstract()))
2676     {
2677       Expression* expr = this->constant_->const_value()->expr();
2678       Numeric_constant nc;
2679       if (expr->numeric_constant_value(&nc)
2680           && nc.set_type(this->type_, false, this->location()))
2681         {
2682           Expression* e = nc.expression(this->location());
2683           return e->get_tree(context);
2684         }
2685     }
2686
2687   tree const_tree = this->constant_->get_tree(gogo, context->function());
2688   if (this->type_ == NULL
2689       || const_tree == error_mark_node
2690       || TREE_TYPE(const_tree) == error_mark_node)
2691     return const_tree;
2692
2693   tree ret;
2694   if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(const_tree)))
2695     ret = fold_convert(type_tree, const_tree);
2696   else if (TREE_CODE(type_tree) == INTEGER_TYPE)
2697     ret = fold(convert_to_integer(type_tree, const_tree));
2698   else if (TREE_CODE(type_tree) == REAL_TYPE)
2699     ret = fold(convert_to_real(type_tree, const_tree));
2700   else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
2701     ret = fold(convert_to_complex(type_tree, const_tree));
2702   else
2703     go_unreachable();
2704   return ret;
2705 }
2706
2707 // Dump ast representation for constant expression.
2708
2709 void
2710 Const_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
2711 {
2712   ast_dump_context->ostream() << this->constant_->name();
2713 }
2714
2715 // Make a reference to a constant in an expression.
2716
2717 Expression*
2718 Expression::make_const_reference(Named_object* constant,
2719                                  Location location)
2720 {
2721   return new Const_expression(constant, location);
2722 }
2723
2724 // Find a named object in an expression.
2725
2726 int
2727 Find_named_object::expression(Expression** pexpr)
2728 {
2729   switch ((*pexpr)->classification())
2730     {
2731     case Expression::EXPRESSION_CONST_REFERENCE:
2732       {
2733         Const_expression* ce = static_cast<Const_expression*>(*pexpr);
2734         if (ce->named_object() == this->no_)
2735           break;
2736
2737         // We need to check a constant initializer explicitly, as
2738         // loops here will not be caught by the loop checking for
2739         // variable initializers.
2740         ce->check_for_init_loop();
2741
2742         return TRAVERSE_CONTINUE;
2743       }
2744
2745     case Expression::EXPRESSION_VAR_REFERENCE:
2746       if ((*pexpr)->var_expression()->named_object() == this->no_)
2747         break;
2748       return TRAVERSE_CONTINUE;
2749     case Expression::EXPRESSION_FUNC_REFERENCE:
2750       if ((*pexpr)->func_expression()->named_object() == this->no_)
2751         break;
2752       return TRAVERSE_CONTINUE;
2753     default:
2754       return TRAVERSE_CONTINUE;
2755     }
2756   this->found_ = true;
2757   return TRAVERSE_EXIT;
2758 }
2759
2760 // The nil value.
2761
2762 class Nil_expression : public Expression
2763 {
2764  public:
2765   Nil_expression(Location location)
2766     : Expression(EXPRESSION_NIL, location)
2767   { }
2768
2769   static Expression*
2770   do_import(Import*);
2771
2772  protected:
2773   bool
2774   do_is_constant() const
2775   { return true; }
2776
2777   Type*
2778   do_type()
2779   { return Type::make_nil_type(); }
2780
2781   void
2782   do_determine_type(const Type_context*)
2783   { }
2784
2785   Expression*
2786   do_copy()
2787   { return this; }
2788
2789   tree
2790   do_get_tree(Translate_context*)
2791   { return null_pointer_node; }
2792
2793   void
2794   do_export(Export* exp) const
2795   { exp->write_c_string("nil"); }
2796
2797   void
2798   do_dump_expression(Ast_dump_context* ast_dump_context) const
2799   { ast_dump_context->ostream() << "nil"; }
2800 };
2801
2802 // Import a nil expression.
2803
2804 Expression*
2805 Nil_expression::do_import(Import* imp)
2806 {
2807   imp->require_c_string("nil");
2808   return Expression::make_nil(imp->location());
2809 }
2810
2811 // Make a nil expression.
2812
2813 Expression*
2814 Expression::make_nil(Location location)
2815 {
2816   return new Nil_expression(location);
2817 }
2818
2819 // The value of the predeclared constant iota.  This is little more
2820 // than a marker.  This will be lowered to an integer in
2821 // Const_expression::do_lower, which is where we know the value that
2822 // it should have.
2823
2824 class Iota_expression : public Parser_expression
2825 {
2826  public:
2827   Iota_expression(Location location)
2828     : Parser_expression(EXPRESSION_IOTA, location)
2829   { }
2830
2831  protected:
2832   Expression*
2833   do_lower(Gogo*, Named_object*, Statement_inserter*, int)
2834   { go_unreachable(); }
2835
2836   // There should only ever be one of these.
2837   Expression*
2838   do_copy()
2839   { go_unreachable(); }
2840   
2841   void
2842   do_dump_expression(Ast_dump_context* ast_dump_context) const
2843   { ast_dump_context->ostream() << "iota"; } 
2844 };
2845
2846 // Make an iota expression.  This is only called for one case: the
2847 // value of the predeclared constant iota.
2848
2849 Expression*
2850 Expression::make_iota()
2851 {
2852   static Iota_expression iota_expression(Linemap::unknown_location());
2853   return &iota_expression;
2854 }
2855
2856 // A type conversion expression.
2857
2858 class Type_conversion_expression : public Expression
2859 {
2860  public:
2861   Type_conversion_expression(Type* type, Expression* expr,
2862                              Location location)
2863     : Expression(EXPRESSION_CONVERSION, location),
2864       type_(type), expr_(expr), may_convert_function_types_(false)
2865   { }
2866
2867   // Return the type to which we are converting.
2868   Type*
2869   type() const
2870   { return this->type_; }
2871
2872   // Return the expression which we are converting.
2873   Expression*
2874   expr() const
2875   { return this->expr_; }
2876
2877   // Permit converting from one function type to another.  This is
2878   // used internally for method expressions.
2879   void
2880   set_may_convert_function_types()
2881   {
2882     this->may_convert_function_types_ = true;
2883   }
2884
2885   // Import a type conversion expression.
2886   static Expression*
2887   do_import(Import*);
2888
2889  protected:
2890   int
2891   do_traverse(Traverse* traverse);
2892
2893   Expression*
2894   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
2895
2896   bool
2897   do_is_constant() const
2898   { return this->expr_->is_constant(); }
2899
2900   bool
2901   do_numeric_constant_value(Numeric_constant*) const;
2902
2903   bool
2904   do_string_constant_value(std::string*) const;
2905
2906   Type*
2907   do_type()
2908   { return this->type_; }
2909
2910   void
2911   do_determine_type(const Type_context*)
2912   {
2913     Type_context subcontext(this->type_, false);
2914     this->expr_->determine_type(&subcontext);
2915   }
2916
2917   void
2918   do_check_types(Gogo*);
2919
2920   Expression*
2921   do_copy()
2922   {
2923     return new Type_conversion_expression(this->type_, this->expr_->copy(),
2924                                           this->location());
2925   }
2926
2927   tree
2928   do_get_tree(Translate_context* context);
2929
2930   void
2931   do_export(Export*) const;
2932
2933   void
2934   do_dump_expression(Ast_dump_context*) const;
2935
2936  private:
2937   // The type to convert to.
2938   Type* type_;
2939   // The expression to convert.
2940   Expression* expr_;
2941   // True if this is permitted to convert function types.  This is
2942   // used internally for method expressions.
2943   bool may_convert_function_types_;
2944 };
2945
2946 // Traversal.
2947
2948 int
2949 Type_conversion_expression::do_traverse(Traverse* traverse)
2950 {
2951   if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
2952       || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
2953     return TRAVERSE_EXIT;
2954   return TRAVERSE_CONTINUE;
2955 }
2956
2957 // Convert to a constant at lowering time.
2958
2959 Expression*
2960 Type_conversion_expression::do_lower(Gogo*, Named_object*,
2961                                      Statement_inserter*, int)
2962 {
2963   Type* type = this->type_;
2964   Expression* val = this->expr_;
2965   Location location = this->location();
2966
2967   if (type->is_numeric_type())
2968     {
2969       Numeric_constant nc;
2970       if (val->numeric_constant_value(&nc))
2971         {
2972           if (!nc.set_type(type, true, location))
2973             return Expression::make_error(location);
2974           return nc.expression(location);
2975         }
2976     }
2977
2978   if (type->is_slice_type())
2979     {
2980       Type* element_type = type->array_type()->element_type()->forwarded();
2981       bool is_byte = (element_type->integer_type() != NULL
2982                       && element_type->integer_type()->is_byte());
2983       bool is_rune = (element_type->integer_type() != NULL
2984                       && element_type->integer_type()->is_rune());
2985       if (is_byte || is_rune)
2986         {
2987           std::string s;
2988           if (val->string_constant_value(&s))
2989             {
2990               Expression_list* vals = new Expression_list();
2991               if (is_byte)
2992                 {
2993                   for (std::string::const_iterator p = s.begin();
2994                        p != s.end();
2995                        p++)
2996                     {
2997                       mpz_t val;
2998                       mpz_init_set_ui(val, static_cast<unsigned char>(*p));
2999                       Expression* v = Expression::make_integer(&val,
3000                                                                element_type,
3001                                                                location);
3002                       vals->push_back(v);
3003                       mpz_clear(val);
3004                     }
3005                 }
3006               else
3007                 {
3008                   const char *p = s.data();
3009                   const char *pend = s.data() + s.length();
3010                   while (p < pend)
3011                     {
3012                       unsigned int c;
3013                       int adv = Lex::fetch_char(p, &c);
3014                       if (adv == 0)
3015                         {
3016                           warning_at(this->location(), 0,
3017                                      "invalid UTF-8 encoding");
3018                           adv = 1;
3019                         }
3020                       p += adv;
3021                       mpz_t val;
3022                       mpz_init_set_ui(val, c);
3023                       Expression* v = Expression::make_integer(&val,
3024                                                                element_type,
3025                                                                location);
3026                       vals->push_back(v);
3027                       mpz_clear(val);
3028                     }
3029                 }
3030
3031               return Expression::make_slice_composite_literal(type, vals,
3032                                                               location);
3033             }
3034         }
3035     }
3036
3037   return this;
3038 }
3039
3040 // Return the constant numeric value if there is one.
3041
3042 bool
3043 Type_conversion_expression::do_numeric_constant_value(
3044     Numeric_constant* nc) const
3045 {
3046   if (!this->type_->is_numeric_type())
3047     return false;
3048   if (!this->expr_->numeric_constant_value(nc))
3049     return false;
3050   return nc->set_type(this->type_, false, this->location());
3051 }
3052
3053 // Return the constant string value if there is one.
3054
3055 bool
3056 Type_conversion_expression::do_string_constant_value(std::string* val) const
3057 {
3058   if (this->type_->is_string_type()
3059       && this->expr_->type()->integer_type() != NULL)
3060     {
3061       Numeric_constant nc;
3062       if (this->expr_->numeric_constant_value(&nc))
3063         {
3064           unsigned long ival;
3065           if (nc.to_unsigned_long(&ival) == Numeric_constant::NC_UL_VALID)
3066             {
3067               val->clear();
3068               Lex::append_char(ival, true, val, this->location());
3069               return true;
3070             }
3071         }
3072     }
3073
3074   // FIXME: Could handle conversion from const []int here.
3075
3076   return false;
3077 }
3078
3079 // Check that types are convertible.
3080
3081 void
3082 Type_conversion_expression::do_check_types(Gogo*)
3083 {
3084   Type* type = this->type_;
3085   Type* expr_type = this->expr_->type();
3086   std::string reason;
3087
3088   if (type->is_error() || expr_type->is_error())
3089     {
3090       this->set_is_error();
3091       return;
3092     }
3093
3094   if (this->may_convert_function_types_
3095       && type->function_type() != NULL
3096       && expr_type->function_type() != NULL)
3097     return;
3098
3099   if (Type::are_convertible(type, expr_type, &reason))
3100     return;
3101
3102   error_at(this->location(), "%s", reason.c_str());
3103   this->set_is_error();
3104 }
3105
3106 // Get a tree for a type conversion.
3107
3108 tree
3109 Type_conversion_expression::do_get_tree(Translate_context* context)
3110 {
3111   Gogo* gogo = context->gogo();
3112   tree type_tree = type_to_tree(this->type_->get_backend(gogo));
3113   tree expr_tree = this->expr_->get_tree(context);
3114
3115   if (type_tree == error_mark_node
3116       || expr_tree == error_mark_node
3117       || TREE_TYPE(expr_tree) == error_mark_node)
3118     return error_mark_node;
3119
3120   if (TYPE_MAIN_VARIANT(type_tree) == TYPE_MAIN_VARIANT(TREE_TYPE(expr_tree)))
3121     return fold_convert(type_tree, expr_tree);
3122
3123   Type* type = this->type_;
3124   Type* expr_type = this->expr_->type();
3125   tree ret;
3126   if (type->interface_type() != NULL || expr_type->interface_type() != NULL)
3127     ret = Expression::convert_for_assignment(context, type, expr_type,
3128                                              expr_tree, this->location());
3129   else if (type->integer_type() != NULL)
3130     {
3131       if (expr_type->integer_type() != NULL
3132           || expr_type->float_type() != NULL
3133           || expr_type->is_unsafe_pointer_type())
3134         ret = fold(convert_to_integer(type_tree, expr_tree));
3135       else
3136         go_unreachable();
3137     }
3138   else if (type->float_type() != NULL)
3139     {
3140       if (expr_type->integer_type() != NULL
3141           || expr_type->float_type() != NULL)
3142         ret = fold(convert_to_real(type_tree, expr_tree));
3143       else
3144         go_unreachable();
3145     }
3146   else if (type->complex_type() != NULL)
3147     {
3148       if (expr_type->complex_type() != NULL)
3149         ret = fold(convert_to_complex(type_tree, expr_tree));
3150       else
3151         go_unreachable();
3152     }
3153   else if (type->is_string_type()
3154            && expr_type->integer_type() != NULL)
3155     {
3156       expr_tree = fold_convert(integer_type_node, expr_tree);
3157       if (host_integerp(expr_tree, 0))
3158         {
3159           HOST_WIDE_INT intval = tree_low_cst(expr_tree, 0);
3160           std::string s;
3161           Lex::append_char(intval, true, &s, this->location());
3162           Expression* se = Expression::make_string(s, this->location());
3163           return se->get_tree(context);
3164         }
3165
3166       static tree int_to_string_fndecl;
3167       ret = Gogo::call_builtin(&int_to_string_fndecl,
3168                                this->location(),
3169                                "__go_int_to_string",
3170                                1,
3171                                type_tree,
3172                                integer_type_node,
3173                                fold_convert(integer_type_node, expr_tree));
3174     }
3175   else if (type->is_string_type() && expr_type->is_slice_type())
3176     {
3177       if (!DECL_P(expr_tree))
3178         expr_tree = save_expr(expr_tree);
3179       Array_type* a = expr_type->array_type();
3180       Type* e = a->element_type()->forwarded();
3181       go_assert(e->integer_type() != NULL);
3182       tree valptr = fold_convert(const_ptr_type_node,
3183                                  a->value_pointer_tree(gogo, expr_tree));
3184       tree len = a->length_tree(gogo, expr_tree);
3185       len = fold_convert_loc(this->location().gcc_location(), integer_type_node,
3186                              len);
3187       if (e->integer_type()->is_byte())
3188         {
3189           static tree byte_array_to_string_fndecl;
3190           ret = Gogo::call_builtin(&byte_array_to_string_fndecl,
3191                                    this->location(),
3192                                    "__go_byte_array_to_string",
3193                                    2,
3194                                    type_tree,
3195                                    const_ptr_type_node,
3196                                    valptr,
3197                                    integer_type_node,
3198                                    len);
3199         }
3200       else
3201         {
3202           go_assert(e->integer_type()->is_rune());
3203           static tree int_array_to_string_fndecl;
3204           ret = Gogo::call_builtin(&int_array_to_string_fndecl,
3205                                    this->location(),
3206                                    "__go_int_array_to_string",
3207                                    2,
3208                                    type_tree,
3209                                    const_ptr_type_node,
3210                                    valptr,
3211                                    integer_type_node,
3212                                    len);
3213         }
3214     }
3215   else if (type->is_slice_type() && expr_type->is_string_type())
3216     {
3217       Type* e = type->array_type()->element_type()->forwarded();
3218       go_assert(e->integer_type() != NULL);
3219       if (e->integer_type()->is_byte())
3220         {
3221           tree string_to_byte_array_fndecl = NULL_TREE;
3222           ret = Gogo::call_builtin(&string_to_byte_array_fndecl,
3223                                    this->location(),
3224                                    "__go_string_to_byte_array",
3225                                    1,
3226                                    type_tree,
3227                                    TREE_TYPE(expr_tree),
3228                                    expr_tree);
3229         }
3230       else
3231         {
3232           go_assert(e->integer_type()->is_rune());
3233           tree string_to_int_array_fndecl = NULL_TREE;
3234           ret = Gogo::call_builtin(&string_to_int_array_fndecl,
3235                                    this->location(),
3236                                    "__go_string_to_int_array",
3237                                    1,
3238                                    type_tree,
3239                                    TREE_TYPE(expr_tree),
3240                                    expr_tree);
3241         }
3242     }
3243   else if ((type->is_unsafe_pointer_type()
3244             && expr_type->points_to() != NULL)
3245            || (expr_type->is_unsafe_pointer_type()
3246                && type->points_to() != NULL))
3247     ret = fold_convert(type_tree, expr_tree);
3248   else if (type->is_unsafe_pointer_type()
3249            && expr_type->integer_type() != NULL)
3250     ret = convert_to_pointer(type_tree, expr_tree);
3251   else if (this->may_convert_function_types_
3252            && type->function_type() != NULL
3253            && expr_type->function_type() != NULL)
3254     ret = fold_convert_loc(this->location().gcc_location(), type_tree,
3255                            expr_tree);
3256   else
3257     ret = Expression::convert_for_assignment(context, type, expr_type,
3258                                              expr_tree, this->location());
3259
3260   return ret;
3261 }
3262
3263 // Output a type conversion in a constant expression.
3264
3265 void
3266 Type_conversion_expression::do_export(Export* exp) const
3267 {
3268   exp->write_c_string("convert(");
3269   exp->write_type(this->type_);
3270   exp->write_c_string(", ");
3271   this->expr_->export_expression(exp);
3272   exp->write_c_string(")");
3273 }
3274
3275 // Import a type conversion or a struct construction.
3276
3277 Expression*
3278 Type_conversion_expression::do_import(Import* imp)
3279 {
3280   imp->require_c_string("convert(");
3281   Type* type = imp->read_type();
3282   imp->require_c_string(", ");
3283   Expression* val = Expression::import_expression(imp);
3284   imp->require_c_string(")");
3285   return Expression::make_cast(type, val, imp->location());
3286 }
3287
3288 // Dump ast representation for a type conversion expression.
3289
3290 void
3291 Type_conversion_expression::do_dump_expression(
3292     Ast_dump_context* ast_dump_context) const
3293 {
3294   ast_dump_context->dump_type(this->type_);
3295   ast_dump_context->ostream() << "(";
3296   ast_dump_context->dump_expression(this->expr_);
3297   ast_dump_context->ostream() << ") ";
3298 }
3299
3300 // Make a type cast expression.
3301
3302 Expression*
3303 Expression::make_cast(Type* type, Expression* val, Location location)
3304 {
3305   if (type->is_error_type() || val->is_error_expression())
3306     return Expression::make_error(location);
3307   return new Type_conversion_expression(type, val, location);
3308 }
3309
3310 // An unsafe type conversion, used to pass values to builtin functions.
3311
3312 class Unsafe_type_conversion_expression : public Expression
3313 {
3314  public:
3315   Unsafe_type_conversion_expression(Type* type, Expression* expr,
3316                                     Location location)
3317     : Expression(EXPRESSION_UNSAFE_CONVERSION, location),
3318       type_(type), expr_(expr)
3319   { }
3320
3321  protected:
3322   int
3323   do_traverse(Traverse* traverse);
3324
3325   Type*
3326   do_type()
3327   { return this->type_; }
3328
3329   void
3330   do_determine_type(const Type_context*)
3331   { this->expr_->determine_type_no_context(); }
3332
3333   Expression*
3334   do_copy()
3335   {
3336     return new Unsafe_type_conversion_expression(this->type_,
3337                                                  this->expr_->copy(),
3338                                                  this->location());
3339   }
3340
3341   tree
3342   do_get_tree(Translate_context*);
3343
3344   void
3345   do_dump_expression(Ast_dump_context*) const;
3346
3347  private:
3348   // The type to convert to.
3349   Type* type_;
3350   // The expression to convert.
3351   Expression* expr_;
3352 };
3353
3354 // Traversal.
3355
3356 int
3357 Unsafe_type_conversion_expression::do_traverse(Traverse* traverse)
3358 {
3359   if (Expression::traverse(&this->expr_, traverse) == TRAVERSE_EXIT
3360       || Type::traverse(this->type_, traverse) == TRAVERSE_EXIT)
3361     return TRAVERSE_EXIT;
3362   return TRAVERSE_CONTINUE;
3363 }
3364
3365 // Convert to backend representation.
3366
3367 tree
3368 Unsafe_type_conversion_expression::do_get_tree(Translate_context* context)
3369 {
3370   // We are only called for a limited number of cases.
3371
3372   Type* t = this->type_;
3373   Type* et = this->expr_->type();
3374
3375   tree type_tree = type_to_tree(this->type_->get_backend(context->gogo()));
3376   tree expr_tree = this->expr_->get_tree(context);
3377   if (type_tree == error_mark_node || expr_tree == error_mark_node)
3378     return error_mark_node;
3379
3380   Location loc = this->location();
3381
3382   bool use_view_convert = false;
3383   if (t->is_slice_type())
3384     {
3385       go_assert(et->is_slice_type());
3386       use_view_convert = true;
3387     }
3388   else if (t->map_type() != NULL)
3389     go_assert(et->map_type() != NULL);
3390   else if (t->channel_type() != NULL)
3391     go_assert(et->channel_type() != NULL);
3392   else if (t->points_to() != NULL)
3393     go_assert(et->points_to() != NULL || et->is_nil_type());
3394   else if (et->is_unsafe_pointer_type())
3395     go_assert(t->points_to() != NULL);
3396   else if (t->interface_type() != NULL && !t->interface_type()->is_empty())
3397     {
3398       go_assert(et->interface_type() != NULL
3399                  && !et->interface_type()->is_empty());
3400       use_view_convert = true;
3401     }
3402   else if (t->interface_type() != NULL && t->interface_type()->is_empty())
3403     {
3404       go_assert(et->interface_type() != NULL
3405                  && et->interface_type()->is_empty());
3406       use_view_convert = true;
3407     }
3408   else if (t->integer_type() != NULL)
3409     {
3410       go_assert(et->is_boolean_type()
3411                  || et->integer_type() != NULL
3412                  || et->function_type() != NULL
3413                  || et->points_to() != NULL
3414                  || et->map_type() != NULL
3415                  || et->channel_type() != NULL);
3416       return convert_to_integer(type_tree, expr_tree);
3417     }
3418   else
3419     go_unreachable();
3420
3421   if (use_view_convert)
3422     return fold_build1_loc(loc.gcc_location(), VIEW_CONVERT_EXPR, type_tree,
3423                            expr_tree);
3424   else
3425     return fold_convert_loc(loc.gcc_location(), type_tree, expr_tree);
3426 }
3427
3428 // Dump ast representation for an unsafe type conversion expression.
3429
3430 void
3431 Unsafe_type_conversion_expression::do_dump_expression(
3432     Ast_dump_context* ast_dump_context) const
3433 {
3434   ast_dump_context->dump_type(this->type_);
3435   ast_dump_context->ostream() << "(";
3436   ast_dump_context->dump_expression(this->expr_);
3437   ast_dump_context->ostream() << ") ";
3438 }
3439
3440 // Make an unsafe type conversion expression.
3441
3442 Expression*
3443 Expression::make_unsafe_cast(Type* type, Expression* expr,
3444                              Location location)
3445 {
3446   return new Unsafe_type_conversion_expression(type, expr, location);
3447 }
3448
3449 // Unary expressions.
3450
3451 class Unary_expression : public Expression
3452 {
3453  public:
3454   Unary_expression(Operator op, Expression* expr, Location location)
3455     : Expression(EXPRESSION_UNARY, location),
3456       op_(op), escapes_(true), create_temp_(false), expr_(expr)
3457   { }
3458
3459   // Return the operator.
3460   Operator
3461   op() const
3462   { return this->op_; }
3463
3464   // Return the operand.
3465   Expression*
3466   operand() const
3467   { return this->expr_; }
3468
3469   // Record that an address expression does not escape.
3470   void
3471   set_does_not_escape()
3472   {
3473     go_assert(this->op_ == OPERATOR_AND);
3474     this->escapes_ = false;
3475   }
3476
3477   // Record that this is an address expression which should create a
3478   // temporary variable if necessary.  This is used for method calls.
3479   void
3480   set_create_temp()
3481   {
3482     go_assert(this->op_ == OPERATOR_AND);
3483     this->create_temp_ = true;
3484   }
3485
3486   // Apply unary opcode OP to UNC, setting NC.  Return true if this
3487   // could be done, false if not.  Issue errors for overflow.
3488   static bool
3489   eval_constant(Operator op, const Numeric_constant* unc,
3490                 Location, Numeric_constant* nc);
3491
3492   static Expression*
3493   do_import(Import*);
3494
3495  protected:
3496   int
3497   do_traverse(Traverse* traverse)
3498   { return Expression::traverse(&this->expr_, traverse); }
3499
3500   Expression*
3501   do_lower(Gogo*, Named_object*, Statement_inserter*, int);
3502
3503   bool
3504   do_is_constant() const;
3505
3506   bool
3507   do_numeric_constant_value(Numeric_constant*) const;
3508
3509   Type*
3510   do_type();
3511
3512   void
3513   do_determine_type(const Type_context*);
3514
3515   void
3516   do_check_types(Gogo*);
3517
3518   Expression*
3519   do_copy()
3520   {
3521     return Expression::make_unary(this->op_, this->expr_->copy(),
3522                                   this->location());
3523   }
3524
3525   bool
3526   do_must_eval_subexpressions_in_order(int*) const