OSDN Git Service

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