OSDN Git Service

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