CbC/CbC_gcc: gcc/go/gofrontend/expressions.cc comparison

comparison gcc/go/gofrontend/expressions.cc @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 {
 Type_context context;
 this->do_determine_type(&context);
 }
+// Return true if two expressions refer to the same variable or struct
+// field.  This can only be true when there are no side effects.
+bool
+Expression::is_same_variable(Expression* a, Expression* b)
+{
+if (a->classification() != b->classification())
+return false;
+Var_expression* av = a->var_expression();
+if (av != NULL)
+return av->named_object() == b->var_expression()->named_object();
+Field_reference_expression* af = a->field_reference_expression();
+if (af != NULL)
+{
+Field_reference_expression* bf = b->field_reference_expression();
+return (af->field_index() == bf->field_index()
+	      && Expression::is_same_variable(af->expr(), bf->expr()));
+}
+Unary_expression* au = a->unary_expression();
+if (au != NULL)
+{
+Unary_expression* bu = b->unary_expression();
+return (au->op() == OPERATOR_MULT
+	      && bu->op() == OPERATOR_MULT
+	      && Expression::is_same_variable(au->operand(),
+					      bu->operand()));
+}
+return false;
+}
 // Return an expression handling any conversions which must be done during
 // assignment.
 Expression*
 Expression::convert_for_assignment(Gogo*, Type* lhs_type,
 if (lhs_type->is_error()
 || rhs_type->is_error()
 || rhs->is_error_expression())
 return Expression::make_error(location);
-bool are_identical = Type::are_identical(lhs_type, rhs_type, false, NULL);
+bool are_identical = Type::are_identical(lhs_type, rhs_type,
+					   (Type::COMPARE_ERRORS
+					    | Type::COMPARE_TAGS),
+					   NULL);
 if (!are_identical && lhs_type->interface_type() != NULL)
 {
 if (rhs_type->interface_type() == NULL)
 return Expression::convert_type_to_interface(lhs_type, rhs, location);
 else
 Expression* mtable =
 Expression::make_interface_info(rhs, INTERFACE_INFO_METHODS, location);
 Expression* descriptor =
-Expression::make_unary(OPERATOR_MULT, mtable, location);
+Expression::make_dereference(mtable, NIL_CHECK_NOT_NEEDED, location);
 descriptor = Expression::make_field_reference(descriptor, 0, location);
 Expression* nil = Expression::make_nil(location);
 Expression* eq =
 Expression::make_binary(OPERATOR_EQEQ, mtable, nil, location);
 Expression*
 Expression::convert_interface_to_interface(Type *lhs_type, Expression* rhs,
 bool for_type_guard,
 Location location)
 {
-if (Type::are_identical(lhs_type, rhs->type(), false, NULL))
+if (Type::are_identical(lhs_type, rhs->type(),
+			  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			  NULL))
 return rhs;
 Interface_type* lhs_interface_type = lhs_type->interface_type();
 bool lhs_is_empty = lhs_interface_type->is_empty();
 // Otherwise it points to the value.
 if (lhs_type->points_to() == NULL)
 {
 obj = Expression::make_unsafe_cast(Type::make_pointer_type(lhs_type), obj,
 location);
-obj = Expression::make_unary(OPERATOR_MULT, obj, location);
+obj = Expression::make_dereference(obj, NIL_CHECK_NOT_NEEDED,
+location);
 }
 return Expression::make_compound(check_iface, obj, location);
 }
 // Convert an expression to its backend representation.  This is implemented by
 }
 else
 go_unreachable();
 Bexpression* ret =
-context->backend()->var_expression(bvar, this->in_lvalue_pos_, loc);
+context->backend()->var_expression(bvar, loc);
 if (is_in_heap)
 ret = context->backend()->indirect_expression(btype, ret, true, loc);
 return ret;
 }
 // Ast dump for variable expression.
 void
 Var_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
 {
-ast_dump_context->ostream() << this->variable_->name() ;
+ast_dump_context->ostream() << this->variable_->message_name() ;
 }
 // Make a reference to a variable in an expression.
 Expression*
 // Ast dump for enclosed variable expression.
 void
 Enclosed_var_expression::do_dump_expression(Ast_dump_context* adc) const
 {
-adc->ostream() << this->variable_->name();
+adc->ostream() << this->variable_->message_name();
 }
 // Make a reference to a variable within an enclosing function.
 Expression*
 Bexpression*
 Temporary_reference_expression::do_get_backend(Translate_context* context)
 {
 Gogo* gogo = context->gogo();
 Bvariable* bvar = this->statement_->get_backend_variable(context);
-Varexpr_context ve_ctxt = (this->is_lvalue_ ? VE_lvalue : VE_rvalue);
+Bexpression* ret = gogo->backend()->var_expression(bvar, this->location());
-Bexpression* ret = gogo->backend()->var_expression(bvar, ve_ctxt,
-this->location());
 // The backend can't always represent the same set of recursive types
 // that the Go frontend can.  In some cases this means that a
 // temporary variable won't have the right backend type.  Correct
 // that here by adding a type cast.  We need to use base() to push
 Set_and_use_temporary_expression::do_get_backend(Translate_context* context)
 {
 Location loc = this->location();
 Gogo* gogo = context->gogo();
 Bvariable* bvar = this->statement_->get_backend_variable(context);
-Bexpression* lvar_ref = gogo->backend()->var_expression(bvar, VE_lvalue, loc);
+Bexpression* lvar_ref = gogo->backend()->var_expression(bvar, loc);
 Named_object* fn = context->function();
 go_assert(fn != NULL);
 Bfunction* bfn = fn->func_value()->get_or_make_decl(gogo, fn);
 Bexpression* bexpr = this->expr_->get_backend(context);
 Bstatement* set = gogo->backend()->assignment_statement(bfn, lvar_ref,
 bexpr, loc);
-Bexpression* var_ref = gogo->backend()->var_expression(bvar, VE_rvalue, loc);
+Bexpression* var_ref = gogo->backend()->var_expression(bvar, loc);
 Bexpression* ret = gogo->backend()->compound_expression(set, var_ref, loc);
 return ret;
 }
 // Dump.
 Bstatement* decl;
 this->bvar_ =
 	gogo->backend()->temporary_variable(fn_ctx, context->bblock(), bt, NULL,
 					    false, loc, &decl);
 Bexpression* var_ref =
-gogo->backend()->var_expression(this->bvar_, VE_lvalue, loc);
+gogo->backend()->var_expression(this->bvar_, loc);
 var_ref = gogo->backend()->compound_expression(decl, var_ref, loc);
 return var_ref;
 }
-return gogo->backend()->var_expression(this->bvar_, VE_lvalue, loc);
+return gogo->backend()->var_expression(this->bvar_, loc);
 }
 // Ast dump for sink expression.
 void
 Func_descriptor_expression::do_get_backend(Translate_context* context)
 {
 Named_object* no = this->fn_;
 Location loc = no->location();
 if (this->dvar_ != NULL)
-return context->backend()->var_expression(this->dvar_, VE_rvalue, loc);
+return context->backend()->var_expression(this->dvar_, loc);
 Gogo* gogo = context->gogo();
 std::string var_name(gogo->function_descriptor_name(no));
 bool is_descriptor = false;
 if (no->is_function_declaration()
 && !no->func_declaration_value()->asm_name().empty()
 && Linemap::is_predeclared_location(no->location()))
 is_descriptor = true;
+// The runtime package implements some functions defined in the
+// syscall package.  Let the syscall package define the descriptor
+// in this case.
+if (gogo->compiling_runtime()
+&& gogo->package_name() == "runtime"
+&& no->is_function()
+&& !no->func_value()->asm_name().empty()
+&& no->func_value()->asm_name().compare(0, 8, "syscall.") == 0)
+is_descriptor = true;
 Btype* btype = this->type()->get_backend(gogo);
 Bvariable* bvar;
 std::string asm_name(go_selectively_encode_id(var_name));
 if (no->package() != NULL || is_descriptor)
 bvar = context->backend()->immutable_struct_reference(var_name, asm_name,
 btype, loc);
 else
 {
 Location bloc = Linemap::predeclared_location();
+// The runtime package has hash/equality functions that are
+// referenced by type descriptors outside of the runtime, so the
+// function descriptors must be visible even though they are not
+// exported.
+bool is_exported_runtime = false;
+if (gogo->compiling_runtime()
+	  && gogo->package_name() == "runtime"
+	  && (no->name().find("hash") != std::string::npos
+	      || no->name().find("equal") != std::string::npos))
+	is_exported_runtime = true;
 bool is_hidden = ((no->is_function()
 			 && no->func_value()->enclosing() != NULL)
+			|| (Gogo::is_hidden_name(no->name())
+			    && !is_exported_runtime)
 			|| Gogo::is_thunk(no));
 bvar = context->backend()->immutable_struct(var_name, asm_name,
 is_hidden, false,
 						  btype, bloc);
 Expression_list* vals = new Expression_list();
 vals->push_back(Expression::make_func_code_reference(this->fn_, bloc));
 context->backend()->immutable_struct_set_init(bvar, var_name, is_hidden,
 						    false, btype, bloc, binit);
 }
 this->dvar_ = bvar;
-return gogo->backend()->var_expression(bvar, VE_rvalue, loc);
+return gogo->backend()->var_expression(bvar, loc);
 }
 // Print a function descriptor expression.
 void
 Expression*
 do_copy()
 {
 if (this->is_character_constant_)
-return Expression::make_character(&this->val_, this->type_,
+return Expression::make_character(&this->val_,
+					(this->type_ == NULL
+					 ? NULL
+					 : this->type_->copy_expressions()),
 					this->location());
 else
-return Expression::make_integer_z(&this->val_, this->type_,
+return Expression::make_integer_z(&this->val_,
+					(this->type_ == NULL
+					 ? NULL
+					 : this->type_->copy_expressions()),
 					this->location());
 }
 void
 do_export(Export*) const;
 void
 do_check_types(Gogo*);
 Expression*
 do_copy()
-{ return Expression::make_float(&this->val_, this->type_,
+{ return Expression::make_float(&this->val_,
+				  (this->type_ == NULL
+				   ? NULL
+				   : this->type_->copy_expressions()),
 				  this->location()); }
 Bexpression*
 do_get_backend(Translate_context*);
 do_check_types(Gogo*);
 Expression*
 do_copy()
 {
-return Expression::make_complex(&this->val_, this->type_,
+return Expression::make_complex(&this->val_,
+				    (this->type_ == NULL
+				     ? NULL
+				     : this->type_->copy_expressions()),
 				    this->location());
 }
 Bexpression*
 do_get_backend(Translate_context*);
 Named_constant* nc = this->constant_->const_value();
 if (this->seen_ || nc->lowering())
 {
-this->report_error(_("constant refers to itself"));
+if (nc->type() == NULL || !nc->type()->is_error_type())
+	{
+	  Location loc = this->location();
+	  if (!this->seen_)
+	    loc = nc->location();
+	  go_error_at(loc, "constant refers to itself");
+	}
+this->set_is_error();
 this->type_ = Type::make_error_type();
+nc->set_type(this->type_);
 return this->type_;
 }
 this->seen_ = true;
 // During parsing, a named constant may have a NULL type, but we
 // must not return a NULL type here.
 ret = nc->expr()->type();
 this->seen_ = false;
+if (ret->is_error_type())
+nc->set_type(ret);
 return ret;
 }
 // Set the type of the const reference.
 return false;
 if (!this->expr_->is_static_initializer())
 return false;
-if (Type::are_identical(type, expr_type, false, NULL))
+if (Type::are_identical(type, expr_type,
+			  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			  NULL))
 return true;
 if (type->is_string_type() && expr_type->is_string_type())
 return true;
 go_error_at(this->location(), "%s", reason.c_str());
 this->set_is_error();
 }
+// Copy.
+Expression*
+Type_conversion_expression::do_copy()
+{
+return new Type_conversion_expression(this->type_->copy_expressions(),
+					this->expr_->copy(),
+					this->location());
+}
 // Get the backend representation for a type conversion.
 Bexpression*
 Type_conversion_expression::do_get_backend(Translate_context* context)
 {
 Gogo* gogo = context->gogo();
 Btype* btype = type->get_backend(gogo);
 Location loc = this->location();
-if (Type::are_identical(type, expr_type, false, NULL))
+if (Type::are_identical(type, expr_type,
+			  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			  NULL))
 {
 Bexpression* bexpr = this->expr_->get_backend(context);
 return gogo->backend()->convert_expression(btype, bexpr, loc);
 }
 else if (type->interface_type() != NULL
 	  || expr_type->is_boolean_type()
 	  || expr_type->points_to() != NULL))
 return true;
 return false;
+}
+// Copy.
+Expression*
+Unsafe_type_conversion_expression::do_copy()
+{
+return new Unsafe_type_conversion_expression(this->type_->copy_expressions(),
+					       this->expr_->copy(),
+					       this->location());
 }
 // Convert to backend representation.
 Bexpression*
 // Call the address_taken method of the operand if needed.  This is
 // called after escape analysis but before inserting write barriers.
 void
-Unary_expression::check_operand_address_taken(Gogo* gogo)
+Unary_expression::check_operand_address_taken(Gogo*)
 {
 if (this->op_ != OPERATOR_AND)
 return;
 // If this->escapes_ is false at this point, then it was set to
 // does not escape.  If this->escapes_ is true, we may be able to
 // set it to false if taking the address of a variable that does not
 // escape.
 Node* n = Node::make_node(this);
 if ((n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
-this->escapes_ = false;
-// When compiling the runtime, the address operator does not cause
-// local variables to escape.  When escape analysis becomes the
-// default, this should be changed to make it an error if we have an
-// address operator that escapes.
-if (gogo->compiling_runtime() && gogo->package_name() == "runtime")
 this->escapes_ = false;
 Named_object* var = NULL;
 if (this->expr_->var_expression() != NULL)
 var = this->expr_->var_expression()->named_object();
 Location location = this->location();
 if (this->op_ == OPERATOR_MULT
 && !this->expr_->is_variable())
 {
 go_assert(this->expr_->type()->points_to() != NULL);
-Type* ptype = this->expr_->type()->points_to();
+switch (this->requires_nil_check(gogo))
-if (!ptype->is_void_type())
 {
-int64_t s;
+case NIL_CHECK_ERROR_ENCOUNTERED:
-bool ok = ptype->backend_type_size(gogo, &s);
-if (!ok)
 {
 go_assert(saw_errors());
 return Expression::make_error(this->location());
 }
-if (s >= 4096 || this->issue_nil_check_)
+case NIL_CHECK_NOT_NEEDED:
-{
+break;
-Temporary_statement* temp =
+case NIL_CHECK_NEEDED:
-Statement::make_temporary(NULL, this->expr_, location);
+this->create_temp_ = true;
-inserter->insert(temp);
+break;
-this->expr_ =
+case NIL_CHECK_DEFAULT:
-Expression::make_temporary_reference(temp, location);
+go_unreachable();
-}
 }
 }
 if (this->create_temp_ && !this->expr_->is_variable())
 {
 // used when building a type descriptor.
 if (expr->string_expression() != NULL)
 return true;
 return false;
+}
+// Return whether this dereference expression requires an explicit nil
+// check. If we are dereferencing the pointer to a large struct
+// (greater than the specified size threshold), we need to check for
+// nil. We don't bother to check for small structs because we expect
+// the system to crash on a nil pointer dereference. However, if we
+// know the address of this expression is being taken, we must always
+// check for nil.
+Unary_expression::Nil_check_classification
+Unary_expression::requires_nil_check(Gogo* gogo)
+{
+go_assert(this->op_ == OPERATOR_MULT);
+go_assert(this->expr_->type()->points_to() != NULL);
+if (this->issue_nil_check_ == NIL_CHECK_NEEDED)
+return NIL_CHECK_NEEDED;
+else if (this->issue_nil_check_ == NIL_CHECK_NOT_NEEDED)
+return NIL_CHECK_NOT_NEEDED;
+Type* ptype = this->expr_->type()->points_to();
+int64_t type_size = -1;
+if (!ptype->is_void_type())
+{
+bool ok = ptype->backend_type_size(gogo, &type_size);
+if (!ok)
+return NIL_CHECK_ERROR_ENCOUNTERED;
+}
+int64_t size_cutoff = gogo->nil_check_size_threshold();
+if (size_cutoff == -1 || (type_size != -1 && type_size >= size_cutoff))
+this->issue_nil_check_ = NIL_CHECK_NEEDED;
+else
+this->issue_nil_check_ = NIL_CHECK_NOT_NEEDED;
+return this->issue_nil_check_;
 }
 // Apply unary opcode OP to UNC, setting NC.  Return true if this
 // could be done, false if not.  On overflow, issues an error and sets
 // *ISSUED_ERROR.
 if (sut != NULL)
 	{
 	  Temporary_statement* temp = sut->temporary();
 	  Bvariable* bvar = temp->get_backend_variable(context);
 Bexpression* bvar_expr =
-gogo->backend()->var_expression(bvar, VE_lvalue, loc);
+gogo->backend()->var_expression(bvar, loc);
 Bexpression* bval = sut->expression()->get_backend(context);
 Named_object* fn = context->function();
 go_assert(fn != NULL);
 Bfunction* bfn =
 	      // If we are not copying the value to the heap, we will only
 	      // initialize the value once, so we can use this directly
 	      // rather than copying it.  In that case we can't make it
 	      // read-only, because the program is permitted to change it.
-	      copy_to_heap = context->function() != NULL;
+	      copy_to_heap = (context->function() != NULL
+|| context->is_const());
 	    }
 	  std::string asm_name(go_selectively_encode_id(var_name));
 	  Bvariable* implicit =
 gogo->backend()->implicit_variable(var_name, asm_name,
 btype, true, copy_to_heap,
 false, 0);
 	  gogo->backend()->implicit_variable_set_init(implicit, var_name, btype,
 						      true, copy_to_heap, false,
 						      bexpr);
-	  bexpr = gogo->backend()->var_expression(implicit, VE_rvalue, loc);
+	  bexpr = gogo->backend()->var_expression(implicit, loc);
 	  // If we are not copying a slice initializer to the heap,
 	  // then it can be changed by the program, so if it can
 	  // contain pointers we must register it as a GC root.
 	  if (this->is_slice_init_
 	      && !copy_to_heap
 	      && this->expr_->type()->has_pointer())
 	    {
 	      Bexpression* root =
-gogo->backend()->var_expression(implicit, VE_rvalue, loc);
+gogo->backend()->var_expression(implicit, loc);
 	      root = gogo->backend()->address_expression(root, loc);
 	      Type* type = Type::make_pointer_type(this->expr_->type());
 	      gogo->add_gc_root(Expression::make_backend(root, type, loc));
 	    }
 	}
 Bvariable* decl =
 gogo->backend()->immutable_struct(var_name, asm_name,
 true, false, btype, loc);
 gogo->backend()->immutable_struct_set_init(decl, var_name, true,
 						     false, btype, loc, bexpr);
-bexpr = gogo->backend()->var_expression(decl, VE_rvalue, loc);
+bexpr = gogo->backend()->var_expression(decl, loc);
 }
 go_assert(!this->create_temp_ || this->expr_->is_variable());
 ret = gogo->backend()->address_expression(bexpr, loc);
 break;
 case OPERATOR_MULT:
 {
 go_assert(this->expr_->type()->points_to() != NULL);
-	// If we are dereferencing the pointer to a large struct, we
+bool known_valid = false;
-	// need to check for nil.  We don't bother to check for small
-	// structs because we expect the system to crash on a nil
-	// pointer dereference.	 However, if we know the address of this
-	// expression is being taken, we must always check for nil.
 Type* ptype = this->expr_->type()->points_to();
 Btype* pbtype = ptype->get_backend(gogo);
-if (!ptype->is_void_type())
+switch (this->requires_nil_check(gogo))
-	  {
+{
-int64_t s;
+case NIL_CHECK_NOT_NEEDED:
-bool ok = ptype->backend_type_size(gogo, &s);
+break;
-if (!ok)
+case NIL_CHECK_ERROR_ENCOUNTERED:
 {
 go_assert(saw_errors());
 return gogo->backend()->error_expression();
 }
-	    if (s >= 4096 || this->issue_nil_check_)
+case NIL_CHECK_NEEDED:
-	      {
+{
 go_assert(this->expr_->is_variable());
+// If we're nil-checking the result of a set-and-use-temporary
+// expression, then pick out the target temp and use that
+// for the final result of the conditional.
+Bexpression* tbexpr = bexpr;
+Bexpression* ubexpr = bexpr;
+Set_and_use_temporary_expression* sut =
+this->expr_->set_and_use_temporary_expression();
+if (sut != NULL) {
+Temporary_statement* temp = sut->temporary();
+Bvariable* bvar = temp->get_backend_variable(context);
+ubexpr = gogo->backend()->var_expression(bvar, loc);
+}
 Bexpression* nil =
-		  Expression::make_nil(loc)->get_backend(context);
+Expression::make_nil(loc)->get_backend(context);
 Bexpression* compare =
-gogo->backend()->binary_expression(OPERATOR_EQEQ, bexpr,
+gogo->backend()->binary_expression(OPERATOR_EQEQ, tbexpr,
 nil, loc);
 Bexpression* crash =
-		  gogo->runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE,
+gogo->runtime_error(RUNTIME_ERROR_NIL_DEREFERENCE,
-				      loc)->get_backend(context);
+loc)->get_backend(context);
 Bfunction* bfn = context->function()->func_value()->get_decl();
 bexpr = gogo->backend()->conditional_expression(bfn, btype,
 compare,
-crash, bexpr,
+crash, ubexpr,
 loc);
+known_valid = true;
-	      }
+break;
-	  }
+}
-ret = gogo->backend()->indirect_expression(pbtype, bexpr, false, loc);
+case NIL_CHECK_DEFAULT:
+go_unreachable();
+}
+ret = gogo->backend()->indirect_expression(pbtype, bexpr,
+known_valid, loc);
 }
 break;
 default:
 go_unreachable();
 Expression*
 Expression::make_unary(Operator op, Expression* expr, Location location)
 {
 return new Unary_expression(op, expr, location);
+}
+Expression*
+Expression::make_dereference(Expression* ptr,
+Nil_check_classification docheck,
+Location location)
+{
+Expression* deref = Expression::make_unary(OPERATOR_MULT, ptr, location);
+if (docheck == NIL_CHECK_NEEDED)
+deref->unary_expression()->set_requires_nil_check(true);
+else if (docheck == NIL_CHECK_NOT_NEEDED)
+deref->unary_expression()->set_requires_nil_check(false);
+return deref;
 }
 // If this is an indirection through a pointer, return the expression
 // being pointed through.  Otherwise return this.
 {
 Struct_type* st = this->left_->type()->struct_type();
 Struct_type* st2 = this->right_->type()->struct_type();
 if (st2 == NULL)
 return this;
-if (st != st2 && !Type::are_identical(st, st2, false, NULL))
+if (st != st2
+&& !Type::are_identical(st, st2,
+			      Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			      NULL))
 return this;
 if (!Type::are_compatible_for_comparison(true, this->left_->type(),
 					   this->right_->type(), NULL))
 return this;
 {
 Array_type* at = this->left_->type()->array_type();
 Array_type* at2 = this->right_->type()->array_type();
 if (at2 == NULL)
 return this;
-if (at != at2 && !Type::are_identical(at, at2, false, NULL))
+if (at != at2
+&& !Type::are_identical(at, at2,
+			      Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			      NULL))
 return this;
 if (!Type::are_compatible_for_comparison(true, this->left_->type(),
 					   this->right_->type(), NULL))
 return this;
 Type* rtype = fntype->receiver()->type()->deref();
 Type* etype = (this->expr_type_ != NULL
 		 ? this->expr_type_
 		 : this->expr_->type());
 etype = etype->deref();
-if (!Type::are_identical(rtype, etype, true, NULL))
+if (!Type::are_identical(rtype, etype, Type::COMPARE_TAGS, NULL))
 this->report_error(_("method type does not match object type"));
 }
 // If a bound method expression is not simply called, then it is
 // represented as a closure.  The closure will hold a single variable,
 else
 orig_fntype = NULL;
 if (orig_fntype == NULL || !orig_fntype->is_method())
 {
-ins.first->second = Named_object::make_erroneous_name(Gogo::thunk_name());
+ins.first->second =
+	Named_object::make_erroneous_name(gogo->thunk_name());
 return ins.first->second;
 }
 Struct_field_list* sfl = new Struct_field_list();
 // The type here is wrong--it should be the C function type.  But it
 // doesn't really matter.
 Type* vt = Type::make_pointer_type(Type::make_void_type());
-sfl->push_back(Struct_field(Typed_identifier("fn.0", vt, loc)));
+sfl->push_back(Struct_field(Typed_identifier("fn", vt, loc)));
-sfl->push_back(Struct_field(Typed_identifier("val.1",
+sfl->push_back(Struct_field(Typed_identifier("val",
 					       orig_fntype->receiver()->type(),
 					       loc)));
 Struct_type* st = Type::make_struct_type(sfl, loc);
 st->set_is_struct_incomparable();
 Type* closure_type = Type::make_pointer_type(st);
 Function_type* new_fntype = orig_fntype->copy_with_names();
-std::string thunk_name = Gogo::thunk_name();
+std::string thunk_name = gogo->thunk_name();
 Named_object* new_no = gogo->start_function(thunk_name, new_fntype,
 					      false, loc);
 Variable* cvar = new Variable(closure_type, NULL, false, false, false, loc);
 cvar->set_is_used();
 gogo->start_block(loc);
 // Field 0 of the closure is the function code pointer, field 1 is
 // the value on which to invoke the method.
 Expression* arg = Expression::make_var_reference(cp, loc);
-arg = Expression::make_unary(OPERATOR_MULT, arg, loc);
+arg = Expression::make_dereference(arg, NIL_CHECK_NOT_NEEDED, loc);
 arg = Expression::make_field_reference(arg, 1, loc);
 Expression* bme = Expression::make_bound_method(arg, method, fn, loc);
 const Typed_identifier_list* orig_params = orig_fntype->parameters();
 go_assert((*ref)->type()->points_to() != NULL);
 Expression* n = Expression::make_binary(OPERATOR_EQEQ, *ref,
 					      Expression::make_nil(loc),
 					      loc);
 cond = Expression::make_binary(OPERATOR_OROR, cond, n, loc);
-*ref = Expression::make_unary(OPERATOR_MULT, *ref, loc);
+*ref = Expression::make_dereference(*ref, Expression::NIL_CHECK_DEFAULT,
+loc);
 go_assert((*ref)->type()->struct_type() == stype);
 }
 *ref = Expression::make_field_reference(*ref, field_indexes->field_index,
 					  loc);
 return cond;
 go_unreachable();
 Expression* val = expr;
 if (fntype->receiver()->type()->points_to() == NULL
 && val->type()->points_to() != NULL)
-val = Expression::make_unary(OPERATOR_MULT, val, loc);
+val = Expression::make_dereference(val, NIL_CHECK_DEFAULT, loc);
 // Note that we are ignoring this->expr_type_ here.  The thunk will
 // expect a closure whose second field has type this->expr_type_ (if
 // that is not NULL).  We are going to pass it a closure whose
 // second field has type this->expr_->type().  Since
 // this->expr_type_ is only not-NULL for pointer types, we can get
 // away with this.
 Struct_field_list* fields = new Struct_field_list();
-fields->push_back(Struct_field(Typed_identifier("fn.0",
+fields->push_back(Struct_field(Typed_identifier("fn",
 						  thunk->func_value()->type(),
 						  loc)));
-fields->push_back(Struct_field(Typed_identifier("val.1", val->type(), loc)));
+fields->push_back(Struct_field(Typed_identifier("val", val->type(), loc)));
 Struct_type* st = Type::make_struct_type(fields, loc);
 st->set_is_struct_incomparable();
 Expression_list* vals = new Expression_list();
 vals->push_back(Expression::make_func_code_reference(thunk, loc));
 vals->push_back(val);
 Expression* ret = Expression::make_struct_composite_literal(st, vals, loc);
+ret = Expression::make_heap_expression(ret, loc);
-if (!gogo->compiling_runtime() || gogo->package_name() != "runtime")
-ret = Expression::make_heap_expression(ret, loc);
+Node* n = Node::make_node(this);
-else
+if ((n->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
-{
+ret->heap_expression()->set_allocate_on_stack();
-// When compiling the runtime, method closures do not escape.
+else if (gogo->compiling_runtime() && gogo->package_name() == "runtime")
-// When escape analysis becomes the default, and applies to
+go_error_at(loc, "%s escapes to heap, not allowed in runtime",
-// method closures, this should be changed to make it an error
+n->ast_format(gogo).c_str());
-// if a method closure escapes.
-Temporary_statement* ctemp = Statement::make_temporary(st, ret, loc);
-inserter->insert(ctemp);
-ret = Expression::make_temporary_reference(ctemp, loc);
-ret = Expression::make_unary(OPERATOR_AND, ret, loc);
-ret->unary_expression()->set_does_not_escape();
-}
 // If necessary, check whether the expression or any embedded
 // pointers are nil.
 Expression* nil_check = NULL;
 return new Bound_method_expression(expr, method, function, location);
 }
 // Class Builtin_call_expression.  This is used for a call to a
 // builtin function.
-class Builtin_call_expression : public Call_expression
-{
-public:
-Builtin_call_expression(Gogo* gogo, Expression* fn, Expression_list* args,
-			  bool is_varargs, Location location);
-protected:
-// This overrides Call_expression::do_lower.
-Expression*
-do_lower(Gogo*, Named_object*, Statement_inserter*, int);
-Expression*
-do_flatten(Gogo*, Named_object*, Statement_inserter*);
-bool
-do_is_constant() const;
-bool
-do_numeric_constant_value(Numeric_constant*) const;
-bool
-do_discarding_value();
-Type*
-do_type();
-void
-do_determine_type(const Type_context*);
-void
-do_check_types(Gogo*);
-Expression*
-do_copy();
-Bexpression*
-do_get_backend(Translate_context*);
-void
-do_export(Export*) const;
-virtual bool
-do_is_recover_call() const;
-virtual void
-do_set_recover_arg(Expression*);
-private:
-// The builtin functions.
-enum Builtin_function_code
-{
-BUILTIN_INVALID,
-// Predeclared builtin functions.
-BUILTIN_APPEND,
-BUILTIN_CAP,
-BUILTIN_CLOSE,
-BUILTIN_COMPLEX,
-BUILTIN_COPY,
-BUILTIN_DELETE,
-BUILTIN_IMAG,
-BUILTIN_LEN,
-BUILTIN_MAKE,
-BUILTIN_NEW,
-BUILTIN_PANIC,
-BUILTIN_PRINT,
-BUILTIN_PRINTLN,
-BUILTIN_REAL,
-BUILTIN_RECOVER,
-// Builtin functions from the unsafe package.
-BUILTIN_ALIGNOF,
-BUILTIN_OFFSETOF,
-BUILTIN_SIZEOF
-};
-Expression*
-one_arg() const;
-bool
-check_one_arg();
-static Type*
-real_imag_type(Type*);
-static Type*
-complex_type(Type*);
-Expression*
-lower_make(Statement_inserter*);
-Expression* flatten_append(Gogo*, Named_object*, Statement_inserter*);
-bool
-check_int_value(Expression*, bool is_length, bool* small);
-// A pointer back to the general IR structure.  This avoids a global
-// variable, or passing it around everywhere.
-Gogo* gogo_;
-// The builtin function being called.
-Builtin_function_code code_;
-// Used to stop endless loops when the length of an array uses len
-// or cap of the array itself.
-mutable bool seen_;
-// Whether the argument is set for calls to BUILTIN_RECOVER.
-bool recover_arg_is_set_;
-};
 Builtin_call_expression::Builtin_call_expression(Gogo* gogo,
 						 Expression* fn,
 						 Expression_list* args,
 						 bool is_varargs,
 	    Expression* e1 = Expression::make_type_descriptor(mt, loc);
 	    Expression* e2 = Expression::make_temporary_reference(map_temp,
 								  loc);
 	    Expression* e3 = Expression::make_temporary_reference(key_temp,
 								  loc);
-	    e3 = Expression::make_unary(OPERATOR_AND, e3, loc);
+	    // If the call to delete is deferred, and is in a loop,
+	    // then the loop will only have a single instance of the
+	    // temporary variable.  Passing the address of the
+	    // temporary variable here means that the deferred call
+	    // will see the last value in the loop, not the current
+	    // value.  So for this unusual case copy the value into
+	    // the heap.
+	    if (!this->is_deferred())
+	      e3 = Expression::make_unary(OPERATOR_AND, e3, loc);
+	    else
+	      {
+		Expression* a = Expression::make_allocation(mt->key_type(),
+							    loc);
+		Temporary_statement* atemp =
+		  Statement::make_temporary(NULL, a, loc);
+		inserter->insert(atemp);
+		a = Expression::make_temporary_reference(atemp, loc);
+		a = Expression::make_dereference(a, NIL_CHECK_NOT_NEEDED, loc);
+		Statement* s = Statement::make_assignment(a, e3, loc);
+		inserter->insert(s);
+		e3 = Expression::make_temporary_reference(atemp, loc);
+	      }
 	    return Runtime::make_call(Runtime::MAPDELETE, this->location(),
 				      3, e1, e2, e3);
 	  }
 }
 break;
 {
 default:
 break;
 case BUILTIN_APPEND:
-return this->flatten_append(gogo, function, inserter);
+return this->flatten_append(gogo, function, inserter, NULL, NULL);
 case BUILTIN_COPY:
 {
 	Type* at = this->args()->front()->type();
 	for (Expression_list::iterator pa = this->args()->begin();
 	{
 	  this->report_error(_("length required when allocating a slice"));
 	  return Expression::make_error(this->location());
 	}
 len_arg = Expression::make_integer_ul(0, NULL, loc);
+len_small = true;
 }
 else
 {
 len_arg = *parg;
 len_arg->determine_type(&int_context);
+if (len_arg->type()->integer_type() == NULL)
+	{
+	  go_error_at(len_arg->location(), "non-integer len argument in make");
+	  return Expression::make_error(this->location());
+	}
 if (!this->check_int_value(len_arg, true, &len_small))
 	return Expression::make_error(this->location());
 ++parg;
 }
 Expression* cap_arg = NULL;
 bool cap_small = false;
+Numeric_constant nclen;
+Numeric_constant nccap;
+unsigned long vlen;
+unsigned long vcap;
 if (is_slice && parg != args->end())
 {
 cap_arg = *parg;
 cap_arg->determine_type(&int_context);
+if (cap_arg->type()->integer_type() == NULL)
+	{
+	  go_error_at(cap_arg->location(), "non-integer cap argument in make");
+	  return Expression::make_error(this->location());
+	}
 if (!this->check_int_value(cap_arg, false, &cap_small))
 	return Expression::make_error(this->location());
-Numeric_constant nclen;
-Numeric_constant nccap;
-unsigned long vlen;
-unsigned long vcap;
 if (len_arg->numeric_constant_value(&nclen)
 	  && cap_arg->numeric_constant_value(&nccap)
 	  && nclen.to_unsigned_long(&vlen) == Numeric_constant::NC_UL_VALID
 	  && nccap.to_unsigned_long(&vcap) == Numeric_constant::NC_UL_VALID
 	  && vlen > vcap)
 Location type_loc = first_arg->location();
 Expression* call;
 if (is_slice)
 {
+if (cap_arg == NULL)
+	{
+cap_small = len_small;
+if (len_arg->numeric_constant_value(&nclen)
+&& nclen.to_unsigned_long(&vlen) == Numeric_constant::NC_UL_VALID)
+cap_arg = Expression::make_integer_ul(vlen, len_arg->type(), loc);
+else
+{
+Temporary_statement* temp = Statement::make_temporary(NULL,
+len_arg,
+loc);
+inserter->insert(temp);
+len_arg = Expression::make_temporary_reference(temp, loc);
+cap_arg = Expression::make_temporary_reference(temp, loc);
+}
+	}
 Type* et = type->array_type()->element_type();
 Expression* type_arg = Expression::make_type_descriptor(et, type_loc);
-if (cap_arg == NULL)
-	{
-	  Temporary_statement* temp = Statement::make_temporary(NULL,
-								len_arg,
-								loc);
-	  inserter->insert(temp);
-	  len_arg = Expression::make_temporary_reference(temp, loc);
-	  cap_arg = Expression::make_temporary_reference(temp, loc);
-	  cap_small = len_small;
-	}
 Runtime::Function code = Runtime::MAKESLICE;
 if (!len_small || !cap_small)
 	code = Runtime::MAKESLICE64;
 call = Runtime::make_call(code, loc, 3, type_arg, len_arg, cap_arg);
 }
 else if (is_map)
 {
 Expression* type_arg = Expression::make_type_descriptor(type, type_loc);
-call = Runtime::make_call(Runtime::MAKEMAP, loc, 4, type_arg, len_arg,
+if (!len_small)
-				Expression::make_nil(loc),
+	call = Runtime::make_call(Runtime::MAKEMAP64, loc, 3, type_arg,
-				Expression::make_nil(loc));
+				  len_arg,
+				  Expression::make_nil(loc));
+else
+	{
+	  Numeric_constant nclen;
+	  unsigned long vlen;
+	  if (len_arg->numeric_constant_value(&nclen)
+	      && nclen.to_unsigned_long(&vlen) == Numeric_constant::NC_UL_VALID
+	      && vlen <= Map_type::bucket_size)
+	    call = Runtime::make_call(Runtime::MAKEMAP_SMALL, loc, 0);
+	  else
+	    call = Runtime::make_call(Runtime::MAKEMAP, loc, 3, type_arg,
+				      len_arg,
+				      Expression::make_nil(loc));
+	}
 }
 else if (is_chan)
 {
 Expression* type_arg = Expression::make_type_descriptor(type, type_loc);
-call = Runtime::make_call(Runtime::MAKECHAN, loc, 2, type_arg, len_arg);
+Runtime::Function code = Runtime::MAKECHAN;
+if (!len_small)
+	code = Runtime::MAKECHAN64;
+call = Runtime::make_call(code, loc, 2, type_arg, len_arg);
 }
 else
 go_unreachable();
 return Expression::make_unsafe_cast(type, call, loc);
 }
 // Flatten a call to the predeclared append function.  We do this in
 // the flatten phase, not the lowering phase, so that we run after
-// type checking and after order_evaluations.
+// type checking and after order_evaluations.  If ASSIGN_LHS is not
+// NULL, this append is the right-hand-side of an assignment and
+// ASSIGN_LHS is the left-hand-side; in that case, set LHS directly
+// rather than returning a slice.  This lets us omit a write barrier
+// in common cases like a = append(a, ...) when the slice does not
+// need to grow.  ENCLOSING is not NULL iff ASSIGN_LHS is not NULL.
 Expression*
 Builtin_call_expression::flatten_append(Gogo* gogo, Named_object* function,
-					Statement_inserter* inserter)
+					Statement_inserter* inserter,
+					Expression* assign_lhs,
+					Block* enclosing)
 {
 if (this->is_error_expression())
 return this;
 Location loc = this->location();
 Type* element_type = slice_type->array_type()->element_type();
 if (args->size() == 1)
 {
 // append(s) evaluates to s.
+if (assign_lhs != NULL)
+	return NULL;
 return args->front();
 }
 Type* int_type = Type::lookup_integer_type("int");
 Type* uint_type = Type::lookup_integer_type("uint");
 Expression* zero = Expression::make_integer_ul(0, int_type, loc);
 Expression* ref2 = Expression::make_temporary_reference(ntmp, loc);
 // FIXME: Mark this index as not requiring bounds checks.
 ref = Expression::make_index(ref, zero, ref2, NULL, loc);
-Expression* rhs = Expression::make_conditional(cond, call, ref, loc);
+if (assign_lhs == NULL)
+{
-gogo->lower_expression(function, inserter, &rhs);
+Expression* rhs = Expression::make_conditional(cond, call, ref, loc);
-gogo->flatten_expression(function, inserter, &rhs);
+gogo->lower_expression(function, inserter, &rhs);
-Expression* lhs = Expression::make_temporary_reference(s1tmp, loc);
+gogo->flatten_expression(function, inserter, &rhs);
-Statement* assign = Statement::make_assignment(lhs, rhs, loc);
-inserter->insert(assign);
+ref = Expression::make_temporary_reference(s1tmp, loc);
+Statement* assign = Statement::make_assignment(ref, rhs, loc);
+inserter->insert(assign);
+}
+else
+{
+gogo->lower_expression(function, inserter, &cond);
+gogo->flatten_expression(function, inserter, &cond);
+gogo->lower_expression(function, inserter, &call);
+gogo->flatten_expression(function, inserter, &call);
+gogo->lower_expression(function, inserter, &ref);
+gogo->flatten_expression(function, inserter, &ref);
+Block* then_block = new Block(enclosing, loc);
+Assignment_statement* assign =
+	Statement::make_assignment(assign_lhs, call, loc);
+then_block->add_statement(assign);
+Block* else_block = new Block(enclosing, loc);
+assign = Statement::make_assignment(assign_lhs->copy(), ref, loc);
+// This assignment will not change the pointer value, so it does
+// not need a write barrier.
+assign->set_omit_write_barrier();
+else_block->add_statement(assign);
+Statement* s = Statement::make_if_statement(cond, then_block,
+						  else_block, loc);
+inserter->insert(s);
+ref = Expression::make_temporary_reference(s1tmp, loc);
+assign = Statement::make_assignment(ref, assign_lhs->copy(), loc);
+inserter->insert(assign);
+}
 if (this->is_varargs())
 {
 // copy(s1tmp[l1tmp:], s2tmp)
 a1 = Expression::make_temporary_reference(s1tmp, loc);
 	  ref = Expression::make_temporary_reference(s1tmp, loc);
 	  ref2 = Expression::make_temporary_reference(l1tmp, loc);
 	  Expression* off = Expression::make_integer_ul(i, int_type, loc);
 	  ref2 = Expression::make_binary(OPERATOR_PLUS, ref2, off, loc);
 	  // FIXME: Mark this index as not requiring bounds checks.
-	  lhs = Expression::make_index(ref, ref2, NULL, NULL, loc);
+	  Expression* lhs = Expression::make_index(ref, ref2, NULL, NULL,
+						   loc);
 	  gogo->lower_expression(function, inserter, &lhs);
 	  gogo->flatten_expression(function, inserter, &lhs);
 	  // The flatten pass runs after the write barrier pass, so we
 	  // need to insert a write barrier here if necessary.
-	  if (!gogo->assign_needs_write_barrier(lhs))
+	  // However, if ASSIGN_LHS is not NULL, we have been called
+	  // directly before the write barrier pass.
+	  Statement* assign;
+	  if (assign_lhs != NULL
+	      || !gogo->assign_needs_write_barrier(lhs))
 	    assign = Statement::make_assignment(lhs, *pa, loc);
 	  else
 	    {
 	      Function* f = function == NULL ? NULL : function->func_value();
 	      assign = gogo->assign_with_write_barrier(f, NULL, inserter,
 						       lhs, *pa, loc);
 	    }
 	  inserter->insert(assign);
 	}
 }
+if (assign_lhs != NULL)
+return NULL;
 return Expression::make_temporary_reference(s1tmp, loc);
 }
 // Return whether an expression has an integer value.  Report an error
 };
 int
 Find_call_expression::expression(Expression** pexpr)
 {
-if ((*pexpr)->call_expression() != NULL
+Expression* expr = *pexpr;
-|| (*pexpr)->receive_expression() != NULL)
+if (!expr->is_constant()
+&& (expr->call_expression() != NULL
+	  || expr->receive_expression() != NULL))
 {
 this->found_ = true;
 return TRAVERSE_EXIT;
 }
 return TRAVERSE_CONTINUE;
+}
+// Return whether calling len or cap on EXPR, of array type, is a
+// constant.  The language spec says "the expressions len(s) and
+// cap(s) are constants if the type of s is an array or pointer to an
+// array and the expression s does not contain channel receives or
+// (non-constant) function calls."
+bool
+Builtin_call_expression::array_len_is_constant(Expression* expr)
+{
+go_assert(expr->type()->deref()->array_type() != NULL
+	    && !expr->type()->deref()->is_slice_type());
+if (expr->is_constant())
+return true;
+Find_call_expression find_call;
+Expression::traverse(&expr, &find_call);
+return !find_call.found();
 }
 // Return whether this is constant: len of a string constant, or len
 // or cap of an array, or unsafe.Sizeof, unsafe.Offsetof,
 // unsafe.Alignof.
 	if (arg_type->points_to() != NULL
 	    && arg_type->points_to()->array_type() != NULL
 	    && !arg_type->points_to()->is_slice_type())
 	  arg_type = arg_type->points_to();
-	// The len and cap functions are only constant if there are no
-	// function calls or channel operations in the arguments.
-	// Otherwise we have to make the call.
-	if (!arg->is_constant())
-	  {
-	    Find_call_expression find_call;
-	    Expression::traverse(&arg, &find_call);
-	    if (find_call.found())
-	      return false;
-	  }
 	if (arg_type->array_type() != NULL
 	    && arg_type->array_type()->length() != NULL)
-	  return true;
+{
+	    this->seen_ = true;
+	    bool ret = Builtin_call_expression::array_len_is_constant(arg);
+	    this->seen_ = false;
+	    return ret;
+}
 	if (this->code_ == BUILTIN_LEN && arg_type->is_string_type())
 	  {
 	    this->seen_ = true;
 	    bool ret = arg->is_constant();
 Type* st = struct_expr->type();
 if (st->struct_type() == NULL)
 return false;
 if (st->named_type() != NULL)
 st->named_type()->convert(this->gogo_);
+if (st->is_error_type())
+{
+go_assert(saw_errors());
+return false;
+}
 int64_t offset;
 this->seen_ = true;
 bool ok = st->struct_type()->backend_field_offset(this->gogo_,
 							    farg->field_index(),
 							    &offset);
 if (rnc.type() != NULL
 	  && !rnc.type()->is_abstract()
 	  && inc.type() != NULL
 	  && !inc.type()->is_abstract()
-	  && !Type::are_identical(rnc.type(), inc.type(), false, NULL))
+	  && !Type::are_identical(rnc.type(), inc.type(),
+				  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+				  NULL))
 	return false;
 mpfr_t r;
 if (!rnc.to_float(&r))
 	return false;
 case BUILTIN_INVALID:
 default:
 return Type::make_error_type();
 case BUILTIN_NEW:
+{
+	const Expression_list* args = this->args();
+	if (args == NULL || args->empty())
+	  return Type::make_error_type();
+	return Type::make_pointer_type(args->front()->type());
+}
 case BUILTIN_MAKE:
 {
 	const Expression_list* args = this->args();
 	if (args == NULL || args->empty())
 	  return Type::make_error_type();
-	return Type::make_pointer_type(args->front()->type());
+	return args->front()->type();
 }
 case BUILTIN_CAP:
 case BUILTIN_COPY:
 case BUILTIN_LEN:
 	  }
 	if (arg2_type->is_slice_type())
 	  {
 	    Type* e2 = arg2_type->array_type()->element_type();
-	    if (!Type::are_identical(e1, e2, true, NULL))
+	    if (!Type::are_identical(e1, e2, Type::COMPARE_TAGS, NULL))
 	      this->report_error(_("element types must be the same"));
 	  }
 	else if (arg2_type->is_string_type())
 	  {
 	    if (e1->integer_type() == NULL || !e1->integer_type()->is_byte())
 		 || args->front()->type()->is_error()
 		 || args->back()->is_error_expression()
 		 || args->back()->type()->is_error())
 	  this->set_is_error();
 	else if (!Type::are_identical(args->front()->type(),
-				      args->back()->type(), true, NULL))
+				      args->back()->type(),
+				      Type::COMPARE_TAGS, NULL))
 	  this->report_error(_("complex arguments must have identical types"));
 	else if (args->front()->type()->float_type() == NULL)
 	  this->report_error(_("complex arguments must have "
 			       "floating-point type"));
 }
 				this->is_varargs(),
 				this->location());
 if (this->varargs_are_lowered())
 bce->set_varargs_are_lowered();
+if (this->is_deferred())
+bce->set_is_deferred();
+if (this->is_concurrent())
+bce->set_is_concurrent();
 return bce;
 }
 // Return the backend representation for a builtin function.
 	if (arg_type->points_to() != NULL)
 	  {
 	    arg_type = arg_type->points_to();
 	    go_assert(arg_type->array_type() != NULL
 		       && !arg_type->is_slice_type());
-arg = Expression::make_unary(OPERATOR_MULT, arg, location);
+arg = Expression::make_dereference(arg, NIL_CHECK_DEFAULT,
+location);
 	  }
 	Type* int_type = Type::lookup_integer_type("int");
 Expression* val;
 	if (this->code_ == BUILTIN_LEN)
 		nil = Expression::make_cast(pint_type, nil, location);
 		Expression* cmp = Expression::make_binary(OPERATOR_EQEQ,
 							  arg, nil, location);
 		Expression* zero = Expression::make_integer_ul(0, int_type,
 							       location);
-		Expression* indir = Expression::make_unary(OPERATOR_MULT,
+Expression* indir =
-							   arg, location);
+Expression::make_dereference(arg, NIL_CHECK_NOT_NEEDED,
+location);
 		val = Expression::make_conditional(cmp, zero, indir, location);
 	      }
 	    else
 	      go_unreachable();
 	  }
 		nil = Expression::make_cast(pint_type, nil, location);
 		Expression* cmp = Expression::make_binary(OPERATOR_EQEQ,
 							  arg, nil, location);
 		Expression* zero = Expression::make_integer_ul(0, int_type,
 							       location);
-		Expression* indir = Expression::make_unary(OPERATOR_MULT,
+Expression* indir =
-							   parg, location);
+Expression::make_dereference(parg, NIL_CHECK_NOT_NEEDED,
+location);
 		val = Expression::make_conditional(cmp, zero, indir, location);
 	      }
 	    else
 	      go_unreachable();
 	  }
 	}
 }
 // Recognize a call to a builtin function.
 if (fntype->is_builtin())
-return new Builtin_call_expression(gogo, this->fn_, this->args_,
+{
-				       this->is_varargs_, loc);
+Builtin_call_expression* bce =
+	new Builtin_call_expression(gogo, this->fn_, this->args_,
+				    this->is_varargs_, loc);
+if (this->is_deferred_)
+	bce->set_is_deferred();
+if (this->is_concurrent_)
+	bce->set_is_concurrent();
+return bce;
+}
 // If this call returns multiple results, create a temporary
 // variable to hold them.
 if (this->result_count() > 1 && this->call_temp_ == NULL)
 {
 // getcallersp returns the frame pointer of the caller.  Implement
 // these by turning them into calls to GCC builtin functions.  We
 // could implement them in normal code, but then we would have to
 // explicitly unwind the stack.  These functions are intended to be
 // efficient.  Note that this technique obviously only works for
-// direct calls, but that is the only way they are used.  The actual
+// direct calls, but that is the only way they are used.
-// argument to these functions is always the address of a parameter;
+if (gogo->compiling_runtime() && gogo->package_name() == "runtime")
-// we don't need that for the GCC builtin functions, so we just
-// ignore it.
-if (gogo->compiling_runtime()
-&& this->args_ != NULL
-&& this->args_->size() == 1
-&& gogo->package_name() == "runtime")
 {
 Func_expression* fe = this->fn_->func_expression();
 if (fe != NULL
 	  && fe->named_object()->is_function_declaration()
 	  && fe->named_object()->package() == NULL)
 	{
 	  std::string n = Gogo::unpack_hidden_name(fe->named_object()->name());
-	  if (n == "getcallerpc")
+	  if ((this->args_ == NULL || this->args_->size() == 0)
+	      && n == "getcallerpc")
 	    {
 	      static Named_object* builtin_return_address;
 	      return this->lower_to_builtin(&builtin_return_address,
 					    "__builtin_return_address",
 					    0);
 	    }
-	  else if (n == "getcallersp")
+	  else if ((this->args_ == NULL || this->args_->size() == 0)
+		   && n == "getcallersp")
 	    {
 	      static Named_object* builtin_frame_address;
 	      return this->lower_to_builtin(&builtin_frame_address,
 					    "__builtin_frame_address",
 					    1);
 Call_expression::lower_varargs(Gogo* gogo, Named_object* function,
 			       Statement_inserter* inserter,
 			       Type* varargs_type, size_t param_count,
 Slice_storage_escape_disp escape_disp)
 {
-// When compiling the runtime, varargs slices do not escape.  When
-// escape analysis becomes the default, this should be changed to
-// make it an error if we have a varargs slice that escapes.
-if (gogo->compiling_runtime() && gogo->package_name() == "runtime")
-escape_disp = SLICE_STORAGE_DOES_NOT_ESCAPE;
 if (this->varargs_are_lowered_)
 return;
 Location loc = this->location();
 	  ++pa;
 	}
 for (; pa != this->args_->end(); ++pa, ++pp)
 	{
 	  go_assert(pp != fntype->parameters()->end());
-	  if (Type::are_identical(pp->type(), (*pa)->type(), true, NULL))
+	  if (Type::are_identical(pp->type(), (*pa)->type(),
+				  Type::COMPARE_TAGS, NULL))
 	    args->push_back(*pa);
 	  else
 	    {
 	      Location loc = (*pa)->location();
 	      Expression* arg = *pa;
 	  return;
 	}
 }
 const Typed_identifier_list* parameters = fntype->parameters();
-if (this->args_ == NULL)
+if (this->args_ == NULL || this->args_->size() == 0)
 {
 if (parameters != NULL && !parameters->empty())
 	this->report_error(_("not enough arguments"));
 }
 else if (parameters == NULL)
 			   : this->args_->copy()),
 			  this->is_varargs_, this->location());
 if (this->varargs_are_lowered_)
 call->set_varargs_are_lowered();
+if (this->is_deferred_)
+call->set_is_deferred();
+if (this->is_concurrent_)
+call->set_is_concurrent();
 return call;
 }
 // Return whether we have to use a temporary variable to ensure that
 // we evaluate this call expression in order.  If the call returns no
 // to a struct whose first field is the actual function to call.
 Type* pfntype =
 Type::make_pointer_type(
 Type::make_pointer_type(Type::make_void_type()));
 fn = Expression::make_unsafe_cast(pfntype, this->fn_, location);
-fn = Expression::make_unary(OPERATOR_MULT, fn, location);
+fn = Expression::make_dereference(fn, NIL_CHECK_NOT_NEEDED, location);
 }
 else
 {
 Expression* first_arg;
 fn = this->interface_method_function(interface_method, &first_arg,
 return Expression::make_array_index(left, start, end, cap, location);
 else if (type->points_to() != NULL
 	   && type->points_to()->array_type() != NULL
 	   && !type->points_to()->is_slice_type())
 {
-Expression* deref = Expression::make_unary(OPERATOR_MULT, left,
+Expression* deref =
-						 location);
+Expression::make_dereference(left, NIL_CHECK_DEFAULT, location);
 // For an ordinary index into the array, the pointer will be
 // dereferenced.  For a slice it will not--the resulting slice
 // will simply reuse the pointer, which is incorrect if that
 // pointer is nil.
 }
 // Check types of an array index.
 void
-Array_index_expression::do_check_types(Gogo* gogo)
+Array_index_expression::do_check_types(Gogo*)
 {
 Numeric_constant nc;
 unsigned long v;
 if (this->start_->type()->integer_type() == NULL
 && !this->start_->type()->is_error()
 if (this->end_ != NULL && !array_type->is_slice_type())
 {
 if (!this->array_->is_addressable())
 	this->report_error(_("slice of unaddressable value"));
 else
-	{
+// Set the array address taken but not escape. The escape
-	  bool escapes = true;
+// analysis will make it escape to heap when needed.
+this->array_->address_taken(false);
-	  // When compiling the runtime, a slice operation does not
+}
-	  // cause local variables to escape.  When escape analysis
+}
-	  // becomes the default, this should be changed to make it an
-	  // error if we have a slice operation that escapes.
+// The subexpressions of an array index must be evaluated in order.
-	  if (gogo->compiling_runtime() && gogo->package_name() == "runtime")
+// If this is indexing into an array, rather than a slice, then only
-	    escapes = false;
+// the index should be evaluated.  Since this is called for values on
+// the left hand side of an assigment, evaluating the array, meaning
-	  this->array_->address_taken(escapes);
+// copying the array, will cause a different array to be modified.
-	}
-}
+bool
+Array_index_expression::do_must_eval_subexpressions_in_order(
+int* skip) const
+{
+*skip = this->array_->type()->is_slice_type() ? 0 : 1;
+return true;
 }
 // Flatten array indexing by using temporary variables for slices and indexes.
 Expression*
 return true;
 // An index into an array is addressable if the array is
 // addressable.
 return this->array_->is_addressable();
+}
+void
+Array_index_expression::do_address_taken(bool escapes)
+{
+// In &x[0], if x is a slice, then x's address is not taken.
+if (!this->array_->type()->is_slice_type())
+this->array_->address_taken(escapes);
 }
 // Get the backend representation for an array index.
 Bexpression*
 String_index_expression::do_get_backend(Translate_context* context)
 {
 Location loc = this->location();
 Expression* string_arg = this->string_;
 if (this->string_->type()->points_to() != NULL)
-string_arg = Expression::make_unary(OPERATOR_MULT, this->string_, loc);
+string_arg = Expression::make_dereference(this->string_,
+NIL_CHECK_NOT_NEEDED, loc);
 Expression* bad_index = Expression::check_bounds(this->start_, loc);
 int code = (this->end_ == NULL
 	      ? RUNTIME_ERROR_STRING_INDEX_OUT_OF_BOUNDS
 {
 go_assert(saw_errors());
 return Expression::make_error(loc);
 }
-if (!Type::are_identical(mt->key_type(), this->index_->type(), false, NULL))
+if (!Type::are_identical(mt->key_type(), this->index_->type(),
+			   Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
+			   NULL))
 {
 if (this->index_->type()->interface_type() != NULL
 	  && !this->index_->is_variable())
 	{
 	  Temporary_statement* temp =
 }
 go_assert(this->value_pointer_ != NULL
 && this->value_pointer_->is_variable());
-Expression* val = Expression::make_unary(OPERATOR_MULT, this->value_pointer_,
+Expression* val = Expression::make_dereference(this->value_pointer_,
-					   this->location());
+NIL_CHECK_NOT_NEEDED,
+this->location());
 return val->get_backend(context);
 }
 // Get an expression for the map index.  This returns an expression
 // that evaluates to a pointer to a value.  If the key is not in the
 this->called_fieldtrack_ = true;
 Location loc = this->location();
 std::string s = "fieldtrack \"";
-Named_type* nt = this->expr_->type()->named_type();
+Named_type* nt = this->expr_->type()->unalias()->named_type();
 if (nt == NULL || nt->named_object()->package() == NULL)
 s.append(gogo->pkgpath());
 else
 s.append(nt->named_object()->package()->pkgpath());
 s.push_back('.');
 Interface_field_reference_expression::get_function()
 {
 Expression* ref = this->expr_;
 Location loc = this->location();
 if (ref->type()->points_to() != NULL)
-ref = Expression::make_unary(OPERATOR_MULT, ref, loc);
+ref = Expression::make_dereference(ref, NIL_CHECK_DEFAULT, loc);
 Expression* mtable =
 Expression::make_interface_info(ref, INTERFACE_INFO_METHODS, loc);
 Struct_type* mtable_type = mtable->type()->points_to()->struct_type();
 std::string name = Gogo::unpack_hidden_name(this->name_);
 unsigned int index;
 const Struct_field* field = mtable_type->find_local_field(name, &index);
 go_assert(field != NULL);
-mtable = Expression::make_unary(OPERATOR_MULT, mtable, loc);
+mtable = Expression::make_dereference(mtable, NIL_CHECK_NOT_NEEDED, loc);
 return Expression::make_field_reference(mtable, index, loc);
 }
 // Return an expression for the first argument to pass to the interface
 // function.
 Expression*
 Interface_field_reference_expression::get_underlying_object()
 {
 Expression* expr = this->expr_;
 if (expr->type()->points_to() != NULL)
-expr = Expression::make_unary(OPERATOR_MULT, expr, this->location());
+expr = Expression::make_dereference(expr, NIL_CHECK_DEFAULT,
+this->location());
 return Expression::make_interface_info(expr, INTERFACE_INFO_OBJECT,
 this->location());
 }
 // Traversal.
 }
 if (!this->expr_->is_variable())
 {
 Temporary_statement* temp =
-	Statement::make_temporary(this->expr_->type(), NULL, this->location());
+	Statement::make_temporary(NULL, this->expr_, this->location());
 inserter->insert(temp);
-this->expr_ = Expression::make_set_and_use_temporary(temp, this->expr_,
+this->expr_ = Expression::make_temporary_reference(temp, this->location());
-							   this->location());
 }
 return this;
 }
 // Return the type of an interface field reference.
 Location loc = type->location();
 const Typed_identifier* method_id = type->find_method(name);
 if (method_id == NULL)
-return Named_object::make_erroneous_name(Gogo::thunk_name());
+return Named_object::make_erroneous_name(gogo->thunk_name());
 Function_type* orig_fntype = method_id->type()->function_type();
 if (orig_fntype == NULL)
-return Named_object::make_erroneous_name(Gogo::thunk_name());
+return Named_object::make_erroneous_name(gogo->thunk_name());
 Struct_field_list* sfl = new Struct_field_list();
 // The type here is wrong--it should be the C function type.  But it
 // doesn't really matter.
 Type* vt = Type::make_pointer_type(Type::make_void_type());
-sfl->push_back(Struct_field(Typed_identifier("fn.0", vt, loc)));
+sfl->push_back(Struct_field(Typed_identifier("fn", vt, loc)));
-sfl->push_back(Struct_field(Typed_identifier("val.1", type, loc)));
+sfl->push_back(Struct_field(Typed_identifier("val", type, loc)));
 Struct_type* st = Type::make_struct_type(sfl, loc);
 st->set_is_struct_incomparable();
 Type* closure_type = Type::make_pointer_type(st);
 Function_type* new_fntype = orig_fntype->copy_with_names();
-std::string thunk_name = Gogo::thunk_name();
+std::string thunk_name = gogo->thunk_name();
 Named_object* new_no = gogo->start_function(thunk_name, new_fntype,
 					      false, loc);
 Variable* cvar = new Variable(closure_type, NULL, false, false, false, loc);
 cvar->set_is_used();
 gogo->start_block(loc);
 // Field 0 of the closure is the function code pointer, field 1 is
 // the value on which to invoke the method.
 Expression* arg = Expression::make_var_reference(cp, loc);
-arg = Expression::make_unary(OPERATOR_MULT, arg, loc);
+arg = Expression::make_dereference(arg, NIL_CHECK_NOT_NEEDED, loc);
 arg = Expression::make_field_reference(arg, 1, loc);
 Expression *ifre = Expression::make_interface_field_reference(arg, name,
 								loc);
 // don't need the thunk.
 Location loc = this->location();
 Struct_field_list* fields = new Struct_field_list();
-fields->push_back(Struct_field(Typed_identifier("fn.0",
+fields->push_back(Struct_field(Typed_identifier("fn",
 						  thunk->func_value()->type(),
 						  loc)));
-fields->push_back(Struct_field(Typed_identifier("val.1",
+fields->push_back(Struct_field(Typed_identifier("val",
 						  this->expr_->type(),
 						  loc)));
 Struct_type* st = Type::make_struct_type(fields, loc);
 st->set_is_struct_incomparable();
 	static_cast<Type_conversion_expression*>(f);
 tce->set_may_convert_function_types();
 return f;
 }
-Named_object* no = gogo->start_function(Gogo::thunk_name(), fntype, false,
+Named_object* no = gogo->start_function(gogo->thunk_name(), fntype, false,
 					  location);
 Named_object* vno = gogo->lookup(receiver_name, NULL);
 go_assert(vno != NULL);
 Expression* ve = Expression::make_var_reference(vno, location);
 Expression*
 Allocation_expression::do_copy()
 {
 Allocation_expression* alloc =
-new Allocation_expression(this->type_, this->location());
+new Allocation_expression(this->type_->copy_expressions(),
+			      this->location());
 if (this->allocate_on_stack_)
 alloc->set_allocate_on_stack();
 return alloc;
 }
 Bexpression*
 Allocation_expression::do_get_backend(Translate_context* context)
 {
 Gogo* gogo = context->gogo();
 Location loc = this->location();
+Btype* btype = this->type_->get_backend(gogo);
-Node* n = Node::make_node(this);
-if (this->allocate_on_stack_
+if (this->allocate_on_stack_)
-|| (n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
 {
 int64_t size;
 bool ok = this->type_->backend_type_size(gogo, &size);
 if (!ok)
 {
 go_assert(saw_errors());
 return gogo->backend()->error_expression();
 }
-return gogo->backend()->stack_allocation_expression(size, loc);
+Bstatement* decl;
-}
+Named_object* fn = context->function();
+go_assert(fn != NULL);
-Btype* btype = this->type_->get_backend(gogo);
+Bfunction* fndecl = fn->func_value()->get_or_make_decl(gogo, fn);
+Bexpression* zero = gogo->backend()->zero_expression(btype);
+Bvariable* temp =
+gogo->backend()->temporary_variable(fndecl, context->bblock(), btype,
+zero, true, loc, &decl);
+Bexpression* ret = gogo->backend()->var_expression(temp, loc);
+ret = gogo->backend()->address_expression(ret, loc);
+ret = gogo->backend()->compound_expression(decl, ret, loc);
+return ret;
+}
 Bexpression* space =
 gogo->allocate_memory(this->type_, loc)->get_backend(context);
 Btype* pbtype = gogo->backend()->pointer_type(btype);
 return gogo->backend()->convert_expression(pbtype, space, loc);
 }
 i + 1, reason.c_str());
 	  this->set_is_error();
 	}
 }
 go_assert(pv == this->vals()->end());
+}
+// Copy.
+Expression*
+Struct_construction_expression::do_copy()
+{
+Struct_construction_expression* ret =
+new Struct_construction_expression(this->type_->copy_expressions(),
+				       (this->vals() == NULL
+					? NULL
+					: this->vals()->copy()),
+				       this->location());
+if (this->traverse_order() != NULL)
+ret->set_traverse_order(this->traverse_order());
+return ret;
 }
 // Flatten a struct construction expression.  Store the values into
 // temporaries in case they need interface conversion.
 Expression_list* vals, Location location)
 : Array_construction_expression(EXPRESSION_FIXED_ARRAY_CONSTRUCTION,
 				  type, indexes, vals, location)
 { go_assert(type->array_type() != NULL && !type->is_slice_type()); }
+// Copy.
+Expression*
+Fixed_array_construction_expression::do_copy()
+{
+Type* t = this->type()->copy_expressions();
+return new Fixed_array_construction_expression(t, this->indexes(),
+						 (this->vals() == NULL
+						  ? NULL
+						  : this->vals()->copy()),
+						 this->location());
+}
 // Return the backend representation for constructing a fixed array.
 Bexpression*
 Fixed_array_construction_expression::do_get_backend(Translate_context* context)
 {
 return;
 ast_dump_context->ostream() << "storage=" ;
 ast_dump_context->dump_expression(this->slice_storage_);
 }
+// Copy.
+Expression*
+Slice_construction_expression::do_copy()
+{
+return new Slice_construction_expression(this->type()->copy_expressions(),
+					   this->indexes(),
+					   (this->vals() == NULL
+					    ? NULL
+					    : this->vals()->copy()),
+					   this->location());
+}
 // Return the backend representation for constructing a slice.
 Bexpression*
 Slice_construction_expression::do_get_backend(Translate_context* context)
 {
 space = Expression::make_unary(OPERATOR_AND, this->array_val_, loc);
 space->unary_expression()->set_is_slice_init();
 }
 else
 {
+go_assert(this->storage_escapes_ || this->element_count() == 0);
 space = Expression::make_heap_expression(this->array_val_, loc);
-Node* n = Node::make_node(this);
-if ((n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
-	{
-	  n = Node::make_node(space);
-	  n->set_encoding(Node::ESCAPE_NONE);
-	}
 }
 // Build a constructor for the slice.
 Expression* len = this->valtype_->array_type()->length();
 Expression* slice_val =
 	  this->set_is_error();
 	}
 }
 }
+// Copy.
+Expression*
+Map_construction_expression::do_copy()
+{
+return new Map_construction_expression(this->type_->copy_expressions(),
+					 (this->vals_ == NULL
+					  ? NULL
+					  : this->vals_->copy()),
+					 this->location());
+}
 // Return the backend representation for constructing a map.
 Bexpression*
 Map_construction_expression::do_get_backend(Translate_context* context)
 {
 {
 Type* type = this->type_;
 for (int depth = 0; depth < this->depth_; ++depth)
 {
+type = type->deref();
 if (type->array_type() != NULL)
 	type = type->array_type()->element_type();
 else if (type->map_type() != NULL)
 {
 if (this->key_path_[depth])
 	    }
 	}
 }
 return new Map_construction_expression(type, this->vals_, location);
+}
+// Copy.
+Expression*
+Composite_literal_expression::do_copy()
+{
+Composite_literal_expression* ret =
+new Composite_literal_expression(this->type_->copy_expressions(),
+				     this->depth_, this->has_keys_,
+				     (this->vals_ == NULL
+				      ? NULL
+				      : this->vals_->copy()),
+				     this->all_are_names_,
+				     this->location());
+ret->key_path_ = this->key_path_;
+return ret;
 }
 // Dump ast representation for a composite literal expression.
 void
 	  this->set_is_error();
 	}
 }
 }
+// Copy.
+Expression*
+Type_guard_expression::do_copy()
+{
+return new Type_guard_expression(this->expr_->copy(),
+				   this->type_->copy_expressions(),
+				   this->location());
+}
 // Return the backend representation for a type guard expression.
 Bexpression*
 Type_guard_expression::do_get_backend(Translate_context* context)
 {
 Location loc = this->location();
 Gogo* gogo = context->gogo();
 Btype* btype = this->type()->get_backend(gogo);
 Expression* alloc = Expression::make_allocation(etype, loc);
-Node* n = Node::make_node(this);
+if (this->allocate_on_stack_)
-if ((n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
 alloc->allocation_expression()->set_allocate_on_stack();
 Bexpression* space = alloc->get_backend(context);
 Bstatement* decl;
 Named_object* fn = context->function();
 // If this assignment needs a write barrier, call typedmemmove.  We
 // don't do this in the write barrier pass because in some cases
 // backend conversion can introduce new Heap_expression values.
 Bstatement* assn;
-if (!etype->has_pointer())
+if (!etype->has_pointer() || this->allocate_on_stack_)
 {
-space = gogo->backend()->var_expression(space_temp, VE_lvalue, loc);
+space = gogo->backend()->var_expression(space_temp, loc);
 Bexpression* ref =
 	gogo->backend()->indirect_expression(expr_btype, space, true, loc);
 assn = gogo->backend()->assignment_statement(fndecl, ref, bexpr, loc);
 }
 else
 Bvariable* btemp =
 	gogo->backend()->temporary_variable(fndecl, context->bblock(),
 					    expr_btype, bexpr, true, loc,
 					    &edecl);
 Bexpression* btempref = gogo->backend()->var_expression(btemp,
-							      VE_lvalue, loc);
+							      loc);
 Bexpression* addr = gogo->backend()->address_expression(btempref, loc);
 Expression* td = Expression::make_type_descriptor(etype, loc);
 Type* etype_ptr = Type::make_pointer_type(etype);
-space = gogo->backend()->var_expression(space_temp, VE_rvalue, loc);
+space = gogo->backend()->var_expression(space_temp, loc);
 Expression* elhs = Expression::make_backend(space, etype_ptr, loc);
 Expression* erhs = Expression::make_backend(addr, etype_ptr, loc);
 Expression* call = Runtime::make_call(Runtime::TYPEDMEMMOVE, loc, 3,
 					    td, elhs, erhs);
 Bexpression* bcall = call->get_backend(context);
 Bstatement* s = gogo->backend()->expression_statement(fndecl, bcall);
 assn = gogo->backend()->compound_statement(edecl, s);
 }
 decl = gogo->backend()->compound_statement(decl, assn);
-space = gogo->backend()->var_expression(space_temp, VE_rvalue, loc);
+space = gogo->backend()->var_expression(space_temp, loc);
 return gogo->backend()->compound_expression(decl, space, loc);
 }
 // Dump ast representation for a heap expression.
 // Otherwise we have to build a ptrmask variable, and return a
 // pointer to it.
 Bvariable* bvar = this->type_->gc_ptrmask_var(gogo, ptrsize, ptrdata);
 Location bloc = Linemap::predeclared_location();
-Bexpression* bref = gogo->backend()->var_expression(bvar, VE_rvalue, bloc);
+Bexpression* bref = gogo->backend()->var_expression(bvar, bloc);
 Bexpression* baddr = gogo->backend()->address_expression(bref, bloc);
 Type* uint8_type = Type::lookup_integer_type("uint8");
 Type* pointer_uint8_type = Type::make_pointer_type(uint8_type);
 Btype* ubtype = pointer_uint8_type->get_backend(gogo);
 { go_unreachable(); }
 Expression*
 do_copy()
 {
-return new Slice_value_expression(this->type_, this->valptr_->copy(),
+return new Slice_value_expression(this->type_->copy_expressions(),
+				      this->valptr_->copy(),
 this->len_->copy(), this->cap_->copy(),
 this->location());
 }
 Bexpression*
 { go_unreachable(); }
 Expression*
 do_copy()
 {
-return new Interface_value_expression(this->type_,
+return new Interface_value_expression(this->type_->copy_expressions(),
 this->first_field_->copy(),
 this->obj_->copy(), this->location());
 }
 Bexpression*
 { go_unreachable(); }
 Expression*
 do_copy()
 {
-return new Interface_mtable_expression(this->itype_, this->type_,
+Interface_type* itype = this->itype_->copy_expressions()->interface_type();
+return new Interface_mtable_expression(itype,
+					   this->type_->copy_expressions(),
 this->is_pointer_, this->location());
 }
 bool
 do_is_addressable() const
 Interface_mtable_expression::do_get_backend(Translate_context* context)
 {
 Gogo* gogo = context->gogo();
 Location loc = Linemap::predeclared_location();
 if (this->bvar_ != NULL)
-return gogo->backend()->var_expression(this->bvar_, VE_rvalue,
+return gogo->backend()->var_expression(this->bvar_, this->location());
-this->location());
 const Typed_identifier_list* interface_methods = this->itype_->methods();
 go_assert(!interface_methods->empty());
 std::string mangled_name =
 Btype* btype = this->type()->get_backend(gogo);
 std::string asm_name(go_selectively_encode_id(mangled_name));
 this->bvar_ =
 gogo->backend()->immutable_struct_reference(mangled_name, asm_name,
 btype, loc);
-return gogo->backend()->var_expression(this->bvar_, VE_rvalue,
+return gogo->backend()->var_expression(this->bvar_, this->location());
-this->location());
 }
 // The first element is the type descriptor.
 Type* td_type;
 if (!this->is_pointer_)
 std::string asm_name(go_selectively_encode_id(mangled_name));
 this->bvar_ = gogo->backend()->immutable_struct(mangled_name, asm_name, false,
 						  !is_public, btype, loc);
 gogo->backend()->immutable_struct_set_init(this->bvar_, mangled_name, false,
 !is_public, btype, loc, ctor);
-return gogo->backend()->var_expression(this->bvar_, VE_lvalue, loc);
+return gogo->backend()->var_expression(this->bvar_, loc);
 }
 void
 Interface_mtable_expression::do_dump_expression(
 Ast_dump_context* ast_dump_context) const
 Type*
 Conditional_expression::do_type()
 {
 Type* result_type = Type::make_void_type();
-if (Type::are_identical(this->then_->type(), this->else_->type(), false,
+if (Type::are_identical(this->then_->type(), this->else_->type(),
+			  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
 NULL))
 result_type = this->then_->type();
 else if (this->then_->is_nil_expression()
 || this->else_->is_nil_expression())
 result_type = (!this->then_->is_nil_expression()
 int
 Backend_expression::do_traverse(Traverse*)
 {
 return TRAVERSE_CONTINUE;
+}
+Expression*
+Backend_expression::do_copy()
+{
+return new Backend_expression(this->bexpr_, this->type_->copy_expressions(),
+				this->location());
 }
 void
 Backend_expression::do_dump_expression(Ast_dump_context* ast_dump_context) const
 {
 Numeric_constant::set_float(Type* type, const mpfr_t val)
 {
 this->clear();
 this->classification_ = NC_FLOAT;
 this->type_ = type;
 // Numeric constants do not have negative zero values, so remove
 // them here.  They also don't have infinity or NaN values, but we
 // should never see them here.
-if (mpfr_zero_p(val))
+int bits = 0;
+if (type != NULL
+&& type->float_type() != NULL
+&& !type->float_type()->is_abstract())
+bits = type->float_type()->bits();
+if (Numeric_constant::is_float_neg_zero(val, bits))
 mpfr_init_set_ui(this->u_.float_val, 0, GMP_RNDN);
 else
 mpfr_init_set(this->u_.float_val, val, GMP_RNDN);
 }
 Numeric_constant::set_complex(Type* type, const mpc_t val)
 {
 this->clear();
 this->classification_ = NC_COMPLEX;
 this->type_ = type;
+// Avoid negative zero as in set_float.
+int bits = 0;
+if (type != NULL
+&& type->complex_type() != NULL
+&& !type->complex_type()->is_abstract())
+bits = type->complex_type()->bits() / 2;
+mpfr_t real;
+mpfr_init_set(real, mpc_realref(val), GMP_RNDN);
+if (Numeric_constant::is_float_neg_zero(real, bits))
+mpfr_set_ui(real, 0, GMP_RNDN);
+mpfr_t imag;
+mpfr_init_set(imag, mpc_imagref(val), GMP_RNDN);
+if (Numeric_constant::is_float_neg_zero(imag, bits))
+mpfr_set_ui(imag, 0, GMP_RNDN);
 mpc_init2(this->u_.complex_val, mpc_precision);
-mpc_set(this->u_.complex_val, val, MPC_RNDNN);
+mpc_set_fr_fr(this->u_.complex_val, real, imag, MPC_RNDNN);
+mpfr_clear(real);
+mpfr_clear(imag);
+}
+// Return whether VAL, at a precision of BITS, is a negative zero.
+// BITS may be zero in which case it is ignored.
+bool
+Numeric_constant::is_float_neg_zero(const mpfr_t val, int bits)
+{
+if (!mpfr_signbit(val))
+return false;
+if (mpfr_zero_p(val))
+return true;
+mp_exp_t min_exp;
+switch (bits)
+{
+case 0:
+return false;
+case 32:
+// In a denormalized float32 the exponent is -126, and there are
+// 24 bits of which at least the last must be 1, so the smallest
+// representable non-zero exponent is -126 - (24 - 1) == -149.
+min_exp = -149;
+break;
+case 64:
+// Minimum exponent is -1022, there are 53 bits.
+min_exp = -1074;
+break;
+default:
+go_unreachable();
+}
+return mpfr_get_exp(val) < min_exp;
 }
 // Get an int value.
 void

Mercurial > hg > CbC > CbC_gcc

comparison gcc/go/gofrontend/expressions.cc @ 131:84e7813d76e9