gcc/go/gofrontend/expressions.cc

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