OSDN Git Service

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