OSDN Git Service

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