OSDN Git Service

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