gcc/go/gofrontend/expressions.cc

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