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

comparison gcc/go/gofrontend/gogo.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
 c_header_(),
 check_divide_by_zero_(true),
 check_divide_overflow_(true),
 compiling_runtime_(false),
 debug_escape_level_(0),
+nil_check_size_threshold_(4096),
 verify_types_(),
 interface_types_(),
 specific_type_functions_(),
 specific_type_functions_are_written_(false),
 named_types_are_converted_(false),
 std::string user_name = ii->package_name() + ".init";
 const std::string& init_name(ii->init_name());
 Bfunction* pfunc = this->backend()->function(fntype, user_name, init_name,
 true, true, true, false,
-false, unknown_loc);
+false, false, unknown_loc);
 Bexpression* pfunc_code =
 this->backend()->function_code_expression(pfunc, unknown_loc);
 Bexpression* pfunc_call =
 this->backend()->call_expression(bfunction, pfunc_code, empty_args,
 NULL, unknown_loc);
 return NULL;
 }
 return initfn;
 }
-// Search for references to VAR in any statements or called functions.
+// Given an expression, collect all the global variables defined in
+// this package that it references.
-class Find_var : public Traverse
-{
+class Find_vars : public Traverse
+{
+private:
+// The list of variables we accumulate.
+typedef Unordered_set(Named_object*) Vars;
+// A hash table we use to avoid looping.  The index is a
+// Named_object* or a Temporary_statement*.  We only look through
+// objects defined in this package.
+typedef Unordered_set(const void*) Seen_objects;
 public:
-// A hash table we use to avoid looping.  The index is the name of a
+Find_vars()
-// named object.  We only look through objects defined in this
-// package.
-typedef Unordered_set(const void*) Seen_objects;
-Find_var(Named_object* var, Seen_objects* seen_objects)
 : Traverse(traverse_expressions),
-var_(var), seen_objects_(seen_objects), found_(false)
+vars_(), seen_objects_()
 { }
-// Whether the variable was found.
+// An iterator through the variables found, after the traversal.
-bool
+typedef Vars::const_iterator const_iterator;
-found() const
-{ return this->found_; }
+const_iterator
+begin() const
+{ return this->vars_.begin(); }
+const_iterator
+end() const
+{ return this->vars_.end(); }
 int
 expression(Expression**);
 private:
-// The variable we are looking for.
+// Accumulated variables.
-Named_object* var_;
+Vars vars_;
-// Names of objects we have already seen.
+// Objects we have already seen.
-Seen_objects* seen_objects_;
+Seen_objects seen_objects_;
-// True if the variable was found.
-bool found_;
 };
-// See if EXPR refers to VAR, looking through function calls and
+// Collect global variables referenced by EXPR.  Look through function
-// variable initializations.
+// calls and variable initializations.
 int
-Find_var::expression(Expression** pexpr)
+Find_vars::expression(Expression** pexpr)
 {
 Expression* e = *pexpr;
 Var_expression* ve = e->var_expression();
 if (ve != NULL)
 {
 Named_object* v = ve->named_object();
-if (v == this->var_)
+if (!v->is_variable() || v->package() != NULL)
 	{
-	  this->found_ = true;
+	  // This is a result parameter or a variable defined in a
-	  return TRAVERSE_EXIT;
+	  // different package.  Either way we don't care about it.
-	}
+	  return TRAVERSE_CONTINUE;
+	}
-if (v->is_variable() && v->package() == NULL)
-	{
+std::pair<Seen_objects::iterator, bool> ins =
-	  Expression* init = v->var_value()->init();
+	this->seen_objects_.insert(v);
-	  if (init != NULL)
+if (!ins.second)
-	    {
+	{
-	      std::pair<Seen_objects::iterator, bool> ins =
+	  // We've seen this variable before.
-		this->seen_objects_->insert(v);
+	  return TRAVERSE_CONTINUE;
-	      if (ins.second)
+	}
-		{
-		  // This is the first time we have seen this name.
+if (v->var_value()->is_global())
-		  if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
+	this->vars_.insert(v);
-		    return TRAVERSE_EXIT;
-		}
+Expression* init = v->var_value()->init();
-	    }
+if (init != NULL)
+	{
+	  if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
+	    return TRAVERSE_EXIT;
 	}
 }
 // We traverse the code of any function or bound method we see.  Note that
 // this means that we will traverse the code of a function or bound method
 {
 const Named_object* f = fe != NULL ? fe->named_object() : bme->function();
 if (f->is_function() && f->package() == NULL)
 	{
 	  std::pair<Seen_objects::iterator, bool> ins =
-	    this->seen_objects_->insert(f);
+	    this->seen_objects_.insert(f);
 	  if (ins.second)
 	    {
 	      // This is the first time we have seen this name.
 	      if (f->func_value()->block()->traverse(this) == TRAVERSE_EXIT)
 		return TRAVERSE_EXIT;
 Temporary_statement* ts = tre->statement();
 Expression* init = ts->init();
 if (init != NULL)
 	{
 	  std::pair<Seen_objects::iterator, bool> ins =
-	    this->seen_objects_->insert(ts);
+	    this->seen_objects_.insert(ts);
 	  if (ins.second)
 	    {
 	      // This is the first time we have seen this temporary
 	      // statement.
 	      if (Expression::traverse(&init, this) == TRAVERSE_EXIT)
 static bool
 expression_requires(Expression* expr, Block* preinit, Named_object* dep,
 		    Named_object* var)
 {
-Find_var::Seen_objects seen_objects;
+Find_vars find_vars;
-Find_var find_var(var, &seen_objects);
 if (expr != NULL)
-Expression::traverse(&expr, &find_var);
+Expression::traverse(&expr, &find_vars);
 if (preinit != NULL)
-preinit->traverse(&find_var);
+preinit->traverse(&find_vars);
 if (dep != NULL)
 {
 Expression* init = dep->var_value()->init();
 if (init != NULL)
-	Expression::traverse(&init, &find_var);
+	Expression::traverse(&init, &find_vars);
 if (dep->var_value()->has_pre_init())
-	dep->var_value()->preinit()->traverse(&find_var);
+	dep->var_value()->preinit()->traverse(&find_vars);
 }
-return find_var.found();
+for (Find_vars::const_iterator p = find_vars.begin();
+p != find_vars.end();
+++p)
+{
+if (*p == var)
+	return true;
+}
+return false;
 }
 // Sort variable initializations.  If the initialization expression
 // for variable A refers directly or indirectly to the initialization
 // expression for variable B, then we must initialize B before A.
 class Var_init
 {
 public:
 Var_init()
-: var_(NULL), init_(NULL), dep_count_(0)
+: var_(NULL), init_(NULL), refs_(NULL), dep_count_(0)
 { }
 Var_init(Named_object* var, Bstatement* init)
-: var_(var), init_(init), dep_count_(0)
+: var_(var), init_(init), refs_(NULL), dep_count_(0)
 { }
 // Return the variable.
 Named_object*
 var() const
 // Return the initialization expression.
 Bstatement*
 init() const
 { return this->init_; }
+// Add a reference.
+void
+add_ref(Named_object* var);
+// The variables which this variable's initializers refer to.
+const std::vector<Named_object*>*
+refs()
+{ return this->refs_; }
+// Clear the references, if any.
+void
+clear_refs();
 // Return the number of remaining dependencies.
 size_t
 dep_count() const
 { return this->dep_count_; }
 { --this->dep_count_; }
 private:
 // The variable being initialized.
 Named_object* var_;
-// The initialization statement.
+// The backend initialization statement.
 Bstatement* init_;
+// Variables this refers to.
+std::vector<Named_object*>* refs_;
 // The number of initializations this is dependent on.  A variable
 // initialization should not be emitted if any of its dependencies
 // have not yet been resolved.
 size_t dep_count_;
 };
+// Add a reference.
+void
+Var_init::add_ref(Named_object* var)
+{
+if (this->refs_ == NULL)
+this->refs_ = new std::vector<Named_object*>;
+this->refs_->push_back(var);
+}
+// Clear the references, if any.
+void
+Var_init::clear_refs()
+{
+if (this->refs_ != NULL)
+{
+delete this->refs_;
+this->refs_ = NULL;
+}
+}
 // For comparing Var_init keys in a map.
 inline bool
 operator<(const Var_init& v1, const Var_init& v2)
 { return v1.var()->name() < v2.var()->name(); }
 sort_var_inits(Gogo* gogo, Var_inits* var_inits)
 {
 if (var_inits->empty())
 return;
-typedef std::pair<Named_object*, Named_object*> No_no;
+std::map<Named_object*, Var_init*> var_to_init;
-typedef std::map<No_no, bool> Cache;
-Cache cache;
 // A mapping from a variable initialization to a set of
 // variable initializations that depend on it.
 typedef std::map<Var_init, std::set<Var_init*> > Init_deps;
 Init_deps init_deps;
 bool init_loop = false;
-for (Var_inits::iterator p1 = var_inits->begin();
-p1 != var_inits->end();
+// Compute all variable references.
-++p1)
+for (Var_inits::iterator pvar = var_inits->begin();
-{
+pvar != var_inits->end();
-Named_object* var = p1->var();
+++pvar)
+{
+Named_object* var = pvar->var();
+var_to_init[var] = &*pvar;
+Find_vars find_vars;
 Expression* init = var->var_value()->init();
-Block* preinit = var->var_value()->preinit();
+if (init != NULL)
+	Expression::traverse(&init, &find_vars);
+if (var->var_value()->has_pre_init())
+	var->var_value()->preinit()->traverse(&find_vars);
 Named_object* dep = gogo->var_depends_on(var->var_value());
+if (dep != NULL)
-// Start walking through the list to see which variables VAR
+	{
-// needs to wait for.
+	  Expression* dinit = dep->var_value()->init();
-for (Var_inits::iterator p2 = var_inits->begin();
+	  if (dinit != NULL)
-	   p2 != var_inits->end();
+	    Expression::traverse(&dinit, &find_vars);
-	   ++p2)
+	  if (dep->var_value()->has_pre_init())
-	{
+	    dep->var_value()->preinit()->traverse(&find_vars);
-	  if (var == p2->var())
+	}
+for (Find_vars::const_iterator p = find_vars.begin();
+	   p != find_vars.end();
+	   ++p)
+	pvar->add_ref(*p);
+}
+// Add dependencies to init_deps, and check for cycles.
+for (Var_inits::iterator pvar = var_inits->begin();
+pvar != var_inits->end();
+++pvar)
+{
+Named_object* var = pvar->var();
+const std::vector<Named_object*>* refs = pvar->refs();
+if (refs == NULL)
+	continue;
+for (std::vector<Named_object*>::const_iterator pdep = refs->begin();
+	   pdep != refs->end();
+	   ++pdep)
+	{
+	  Named_object* dep = *pdep;
+	  if (var == dep)
+	    {
+	      // This is a reference from a variable to itself, which
+	      // may indicate a loop.  We only report an error if
+	      // there is an initializer and there is no dependency.
+	      // When there is no initializer, it means that the
+	      // preinitializer sets the variable, which will appear
+	      // to be a loop here.
+	      if (var->var_value()->init() != NULL
+		  && gogo->var_depends_on(var->var_value()) == NULL)
+		go_error_at(var->location(),
+			    ("initialization expression for %qs "
+			     "depends upon itself"),
+			    var->message_name().c_str());
+	      continue;
+	    }
+	  Var_init* dep_init = var_to_init[dep];
+	  if (dep_init == NULL)
+	    {
+	      // This is a dependency on some variable that doesn't
+	      // have an initializer, so for purposes of
+	      // initialization ordering this is irrelevant.
+	      continue;
+	    }
+	  init_deps[*dep_init].insert(&(*pvar));
+	  pvar->add_dependency();
+	  // Check for cycles.
+	  const std::vector<Named_object*>* deprefs = dep_init->refs();
+	  if (deprefs == NULL)
 	    continue;
+	  for (std::vector<Named_object*>::const_iterator pdepdep =
-	  Named_object* p2var = p2->var();
+		 deprefs->begin();
-	  No_no key(var, p2var);
+	       pdepdep != deprefs->end();
-	  std::pair<Cache::iterator, bool> ins =
+	       ++pdepdep)
-	    cache.insert(std::make_pair(key, false));
-	  if (ins.second)
-	    ins.first->second = expression_requires(init, preinit, dep, p2var);
-	  if (ins.first->second)
 	    {
-	      // VAR depends on P2VAR.
+	      if (*pdepdep == var)
-	      init_deps[*p2].insert(&(*p1));
-	      p1->add_dependency();
-	      // Check for cycles.
-	      key = std::make_pair(p2var, var);
-	      ins = cache.insert(std::make_pair(key, false));
-	      if (ins.second)
-		ins.first->second =
-		  expression_requires(p2var->var_value()->init(),
-				      p2var->var_value()->preinit(),
-				      gogo->var_depends_on(p2var->var_value()),
-				      var);
-	      if (ins.first->second)
 		{
 		  go_error_at(var->location(),
 			      ("initialization expressions for %qs and "
 			       "%qs depend upon each other"),
 			      var->message_name().c_str(),
-			      p2var->message_name().c_str());
+			      dep->message_name().c_str());
-		  go_inform(p2->var()->location(), "%qs defined here",
+		  go_inform(dep->location(), "%qs defined here",
-			    p2var->message_name().c_str());
+			    dep->message_name().c_str());
 		  init_loop = true;
 		  break;
 		}
 	    }
 	}
 }
+var_to_init.clear();
+for (Var_inits::iterator pvar = var_inits->begin();
+pvar != var_inits->end();
+++pvar)
+pvar->clear_refs();
 // If there are no dependencies then the declaration order is sorted.
 if (!init_deps.empty() && !init_loop)
 {
 // Otherwise, sort variable initializations by emitting all variables with
 	    }
 	}
 var_inits->swap(ready);
 go_assert(init_deps.empty());
 }
-// VAR_INITS is in the correct order.  For each VAR in VAR_INITS,
-// check for a loop of VAR on itself.
-// interpret as a loop.
-for (Var_inits::const_iterator p = var_inits->begin();
-p != var_inits->end();
-++p)
-gogo->check_self_dep(p->var());
 }
 // Give an error if the initialization expression for VAR depends on
 // itself.  We only check if INIT is not NULL and there is no
 // dependency; when INIT is NULL, it means that PREINIT sets VAR,
 this->backend()->expression_statement(init_bfn, var_binit);
 	      else
 {
 Location loc = var->location();
 Bexpression* var_expr =
-this->backend()->var_expression(bvar, VE_lvalue, loc);
+this->backend()->var_expression(bvar, loc);
 var_init_stmt =
 this->backend()->assignment_statement(init_bfn, var_expr,
 var_binit, loc);
 }
 	    }
 	  if (!is_sink && var->type()->has_pointer())
 	    {
 	      // Avoid putting runtime.gcRoots itself on the list.
 	      if (this->compiling_runtime()
 		  && this->package_name() == "runtime"
-		  && Gogo::unpack_hidden_name(no->name()) == "gcRoots")
+		  && (Gogo::unpack_hidden_name(no->name()) == "gcRoots"
+|| Gogo::unpack_hidden_name(no->name()) == "gcRootsIndex"))
 		;
 	      else
 		var_gc.push_back(no);
 	    }
 	}
 else if (!name.empty())
 pname = &name;
 else
 {
 // Invent a name for a nested function.
-nested_name = this->nested_function_name();
+nested_name = this->nested_function_name(enclosing);
 pname = &nested_name;
 }
 Named_object* ret;
 if (Gogo::is_sink_name(*pname))
 	break;
 if (enew->traverse_subexpressions(this) == TRAVERSE_EXIT)
 	return TRAVERSE_EXIT;
 *pexpr = enew;
 }
+// Lower the type of this expression before the parent looks at it,
+// in case the type contains an array that has expressions in its
+// length.  Skip an Unknown_expression, as at this point that means
+// a composite literal key that does not have a type.
+if ((*pexpr)->unknown_expression() == NULL)
+Type::traverse((*pexpr)->type(), this);
 return TRAVERSE_SKIP_COMPONENTS;
 }
 // Lower the parse tree.  This is called after the parse is complete,
 // when all names should be resolved.
 {
 Check_types_traverse traverse(this);
 block->traverse(&traverse);
 }
-// A traversal class used to find a single shortcut operator within an
-// expression.
-class Find_shortcut : public Traverse
-{
-public:
-Find_shortcut()
-: Traverse(traverse_blocks
-	       | traverse_statements
-	       | traverse_expressions),
-found_(NULL)
-{ }
-// A pointer to the expression which was found, or NULL if none was
-// found.
-Expression**
-found() const
-{ return this->found_; }
-protected:
-int
-block(Block*)
-{ return TRAVERSE_SKIP_COMPONENTS; }
-int
-statement(Block*, size_t*, Statement*)
-{ return TRAVERSE_SKIP_COMPONENTS; }
-int
-expression(Expression**);
-private:
-Expression** found_;
-};
-// Find a shortcut expression.
-int
-Find_shortcut::expression(Expression** pexpr)
-{
-Expression* expr = *pexpr;
-Binary_expression* be = expr->binary_expression();
-if (be == NULL)
-return TRAVERSE_CONTINUE;
-Operator op = be->op();
-if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
-return TRAVERSE_CONTINUE;
-go_assert(this->found_ == NULL);
-this->found_ = pexpr;
-return TRAVERSE_EXIT;
-}
-// A traversal class used to turn shortcut operators into explicit if
-// statements.
-class Shortcuts : public Traverse
-{
-public:
-Shortcuts(Gogo* gogo)
-: Traverse(traverse_variables
-	       | traverse_statements),
-gogo_(gogo)
-{ }
-protected:
-int
-variable(Named_object*);
-int
-statement(Block*, size_t*, Statement*);
-private:
-// Convert a shortcut operator.
-Statement*
-convert_shortcut(Block* enclosing, Expression** pshortcut);
-// The IR.
-Gogo* gogo_;
-};
-// Remove shortcut operators in a single statement.
-int
-Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
-{
-// FIXME: This approach doesn't work for switch statements, because
-// we add the new statements before the whole switch when we need to
-// instead add them just before the switch expression.  The right
-// fix is probably to lower switch statements with nonconstant cases
-// to a series of conditionals.
-if (s->switch_statement() != NULL)
-return TRAVERSE_CONTINUE;
-while (true)
-{
-Find_shortcut find_shortcut;
-// If S is a variable declaration, then ordinary traversal won't
-// do anything.  We want to explicitly traverse the
-// initialization expression if there is one.
-Variable_declaration_statement* vds = s->variable_declaration_statement();
-Expression* init = NULL;
-if (vds == NULL)
-	s->traverse_contents(&find_shortcut);
-else
-	{
-	  init = vds->var()->var_value()->init();
-	  if (init == NULL)
-	    return TRAVERSE_CONTINUE;
-	  init->traverse(&init, &find_shortcut);
-	}
-Expression** pshortcut = find_shortcut.found();
-if (pshortcut == NULL)
-	return TRAVERSE_CONTINUE;
-Statement* snew = this->convert_shortcut(block, pshortcut);
-block->insert_statement_before(*pindex, snew);
-++*pindex;
-if (pshortcut == &init)
-	vds->var()->var_value()->set_init(init);
-}
-}
-// Remove shortcut operators in the initializer of a global variable.
-int
-Shortcuts::variable(Named_object* no)
-{
-if (no->is_result_variable())
-return TRAVERSE_CONTINUE;
-Variable* var = no->var_value();
-Expression* init = var->init();
-if (!var->is_global() || init == NULL)
-return TRAVERSE_CONTINUE;
-while (true)
-{
-Find_shortcut find_shortcut;
-init->traverse(&init, &find_shortcut);
-Expression** pshortcut = find_shortcut.found();
-if (pshortcut == NULL)
-	return TRAVERSE_CONTINUE;
-Statement* snew = this->convert_shortcut(NULL, pshortcut);
-var->add_preinit_statement(this->gogo_, snew);
-if (pshortcut == &init)
-	var->set_init(init);
-}
-}
-// Given an expression which uses a shortcut operator, return a
-// statement which implements it, and update *PSHORTCUT accordingly.
-Statement*
-Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
-{
-Binary_expression* shortcut = (*pshortcut)->binary_expression();
-Expression* left = shortcut->left();
-Expression* right = shortcut->right();
-Location loc = shortcut->location();
-Block* retblock = new Block(enclosing, loc);
-retblock->set_end_location(loc);
-Temporary_statement* ts = Statement::make_temporary(shortcut->type(),
-						      left, loc);
-retblock->add_statement(ts);
-Block* block = new Block(retblock, loc);
-block->set_end_location(loc);
-Expression* tmpref = Expression::make_temporary_reference(ts, loc);
-Statement* assign = Statement::make_assignment(tmpref, right, loc);
-block->add_statement(assign);
-Expression* cond = Expression::make_temporary_reference(ts, loc);
-if (shortcut->binary_expression()->op() == OPERATOR_OROR)
-cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
-Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
-							 loc);
-retblock->add_statement(if_statement);
-*pshortcut = Expression::make_temporary_reference(ts, loc);
-delete shortcut;
-// Now convert any shortcut operators in LEFT and RIGHT.
-Shortcuts shortcuts(this->gogo_);
-retblock->traverse(&shortcuts);
-return Statement::make_block_statement(retblock, loc);
-}
-// Turn shortcut operators into explicit if statements.  Doing this
-// considerably simplifies the order of evaluation rules.
-void
-Gogo::remove_shortcuts()
-{
-Shortcuts shortcuts(this);
-this->traverse(&shortcuts);
-}
 // A traversal class which finds all the expressions which must be
 // evaluated in order within a statement or larger expression.  This
 // is used to implement the rules about order of evaluation.
 class Find_eval_ordering : public Traverse
 // If an expression must be evaluated in order, put it on the list.
 int
 Find_eval_ordering::expression(Expression** expression_pointer)
 {
+Binary_expression* binexp = (*expression_pointer)->binary_expression();
+if (binexp != NULL
+&& (binexp->op() == OPERATOR_ANDAND || binexp->op() == OPERATOR_OROR))
+{
+// Shortcut expressions may potentially have side effects which need
+// to be ordered, so add them to the list.
+// We don't order its subexpressions here since they may be evaluated
+// conditionally. This is handled in remove_shortcuts.
+this->exprs_.push_back(expression_pointer);
+return TRAVERSE_SKIP_COMPONENTS;
+}
 // We have to look at subexpressions before this one.
 if ((*expression_pointer)->traverse_subexpressions(this) == TRAVERSE_EXIT)
 return TRAVERSE_EXIT;
 if ((*expression_pointer)->must_eval_in_order())
 this->exprs_.push_back(expression_pointer);
 {
 Order_eval order_eval(this);
 this->traverse(&order_eval);
 }
+// A traversal class used to find a single shortcut operator within an
+// expression.
+class Find_shortcut : public Traverse
+{
+public:
+Find_shortcut()
+: Traverse(traverse_blocks
+	       | traverse_statements
+	       | traverse_expressions),
+found_(NULL)
+{ }
+// A pointer to the expression which was found, or NULL if none was
+// found.
+Expression**
+found() const
+{ return this->found_; }
+protected:
+int
+block(Block*)
+{ return TRAVERSE_SKIP_COMPONENTS; }
+int
+statement(Block*, size_t*, Statement*)
+{ return TRAVERSE_SKIP_COMPONENTS; }
+int
+expression(Expression**);
+private:
+Expression** found_;
+};
+// Find a shortcut expression.
+int
+Find_shortcut::expression(Expression** pexpr)
+{
+Expression* expr = *pexpr;
+Binary_expression* be = expr->binary_expression();
+if (be == NULL)
+return TRAVERSE_CONTINUE;
+Operator op = be->op();
+if (op != OPERATOR_OROR && op != OPERATOR_ANDAND)
+return TRAVERSE_CONTINUE;
+go_assert(this->found_ == NULL);
+this->found_ = pexpr;
+return TRAVERSE_EXIT;
+}
+// A traversal class used to turn shortcut operators into explicit if
+// statements.
+class Shortcuts : public Traverse
+{
+public:
+Shortcuts(Gogo* gogo)
+: Traverse(traverse_variables
+	       | traverse_statements),
+gogo_(gogo)
+{ }
+protected:
+int
+variable(Named_object*);
+int
+statement(Block*, size_t*, Statement*);
+private:
+// Convert a shortcut operator.
+Statement*
+convert_shortcut(Block* enclosing, Expression** pshortcut);
+// The IR.
+Gogo* gogo_;
+};
+// Remove shortcut operators in a single statement.
+int
+Shortcuts::statement(Block* block, size_t* pindex, Statement* s)
+{
+// FIXME: This approach doesn't work for switch statements, because
+// we add the new statements before the whole switch when we need to
+// instead add them just before the switch expression.  The right
+// fix is probably to lower switch statements with nonconstant cases
+// to a series of conditionals.
+if (s->switch_statement() != NULL)
+return TRAVERSE_CONTINUE;
+while (true)
+{
+Find_shortcut find_shortcut;
+// If S is a variable declaration, then ordinary traversal won't
+// do anything.  We want to explicitly traverse the
+// initialization expression if there is one.
+Variable_declaration_statement* vds = s->variable_declaration_statement();
+Expression* init = NULL;
+if (vds == NULL)
+	s->traverse_contents(&find_shortcut);
+else
+	{
+	  init = vds->var()->var_value()->init();
+	  if (init == NULL)
+	    return TRAVERSE_CONTINUE;
+	  init->traverse(&init, &find_shortcut);
+	}
+Expression** pshortcut = find_shortcut.found();
+if (pshortcut == NULL)
+	return TRAVERSE_CONTINUE;
+Statement* snew = this->convert_shortcut(block, pshortcut);
+block->insert_statement_before(*pindex, snew);
+++*pindex;
+if (pshortcut == &init)
+	vds->var()->var_value()->set_init(init);
+}
+}
+// Remove shortcut operators in the initializer of a global variable.
+int
+Shortcuts::variable(Named_object* no)
+{
+if (no->is_result_variable())
+return TRAVERSE_CONTINUE;
+Variable* var = no->var_value();
+Expression* init = var->init();
+if (!var->is_global() || init == NULL)
+return TRAVERSE_CONTINUE;
+while (true)
+{
+Find_shortcut find_shortcut;
+init->traverse(&init, &find_shortcut);
+Expression** pshortcut = find_shortcut.found();
+if (pshortcut == NULL)
+	return TRAVERSE_CONTINUE;
+Statement* snew = this->convert_shortcut(NULL, pshortcut);
+var->add_preinit_statement(this->gogo_, snew);
+if (pshortcut == &init)
+	var->set_init(init);
+}
+}
+// Given an expression which uses a shortcut operator, return a
+// statement which implements it, and update *PSHORTCUT accordingly.
+Statement*
+Shortcuts::convert_shortcut(Block* enclosing, Expression** pshortcut)
+{
+Binary_expression* shortcut = (*pshortcut)->binary_expression();
+Expression* left = shortcut->left();
+Expression* right = shortcut->right();
+Location loc = shortcut->location();
+Block* retblock = new Block(enclosing, loc);
+retblock->set_end_location(loc);
+Temporary_statement* ts = Statement::make_temporary(shortcut->type(),
+						      left, loc);
+retblock->add_statement(ts);
+Block* block = new Block(retblock, loc);
+block->set_end_location(loc);
+Expression* tmpref = Expression::make_temporary_reference(ts, loc);
+Statement* assign = Statement::make_assignment(tmpref, right, loc);
+block->add_statement(assign);
+Expression* cond = Expression::make_temporary_reference(ts, loc);
+if (shortcut->binary_expression()->op() == OPERATOR_OROR)
+cond = Expression::make_unary(OPERATOR_NOT, cond, loc);
+Statement* if_statement = Statement::make_if_statement(cond, block, NULL,
+							 loc);
+retblock->add_statement(if_statement);
+*pshortcut = Expression::make_temporary_reference(ts, loc);
+delete shortcut;
+// Now convert any shortcut operators in LEFT and RIGHT.
+// LEFT and RIGHT were skipped in the top level
+// Gogo::order_evaluations. We need to order their
+// components first.
+Order_eval order_eval(this->gogo_);
+retblock->traverse(&order_eval);
+Shortcuts shortcuts(this->gogo_);
+retblock->traverse(&shortcuts);
+return Statement::make_block_statement(retblock, loc);
+}
+// Turn shortcut operators into explicit if statements.  Doing this
+// considerably simplifies the order of evaluation rules.
+void
+Gogo::remove_shortcuts()
+{
+Shortcuts shortcuts(this);
+this->traverse(&shortcuts);
+}
 // Traversal to flatten parse tree after order of evaluation rules are applied.
 class Flatten : public Traverse
 {
 public:
 // Global variables can have loops in their initialization
 // expressions.  This is handled in flatten_init_expression.
 no->var_value()->flatten_init_expression(this->gogo_, this->function_,
 &this->inserter_);
 return TRAVERSE_CONTINUE;
+}
+if (!no->var_value()->is_parameter()
+&& !no->var_value()->is_receiver()
+&& !no->var_value()->is_closure()
+&& no->var_value()->is_non_escaping_address_taken()
+&& !no->var_value()->is_in_heap()
+&& no->var_value()->toplevel_decl() == NULL)
+{
+// Local variable that has address taken but not escape.
+// It needs to be live beyond its lexical scope. So we
+// create a top-level declaration for it.
+// No need to do it if it is already in the top level.
+Block* top_block = function_->func_value()->block();
+if (top_block->bindings()->lookup_local(no->name()) != no)
+{
+Variable* var = no->var_value();
+Temporary_statement* ts =
+Statement::make_temporary(var->type(), NULL, var->location());
+ts->set_is_address_taken();
+top_block->add_statement_at_front(ts);
+var->set_toplevel_decl(ts);
+}
 }
 go_assert(!no->var_value()->has_pre_init());
 return TRAVERSE_SKIP_COMPONENTS;
 	  && (name != "_defer" && name != "_panic"))
 	continue;
 if (no->is_type() && no->type_value()->struct_type() != NULL)
 	types.push_back(no);
-if (no->is_const() && no->const_value()->type()->integer_type() != NULL)
+if (no->is_const()
+	  && no->const_value()->type()->integer_type() != NULL
+	  && !no->const_value()->is_sink())
 	{
 	  Numeric_constant nc;
 	  unsigned long val;
 	  if (no->const_value()->expr()->numeric_constant_value(&nc)
 	      && nc.to_unsigned_long(&val) == Numeric_constant::NC_UL_VALID)
 Function::Function(Function_type* type, Named_object* enclosing, Block* block,
 		   Location location)
 : type_(type), enclosing_(enclosing), results_(NULL),
 closure_var_(NULL), block_(block), location_(location), labels_(),
 local_type_count_(0), descriptor_(NULL), fndecl_(NULL), defer_stack_(NULL),
-pragmas_(0), is_sink_(false), results_are_named_(false),
+pragmas_(0), nested_functions_(0), is_sink_(false),
-is_unnamed_type_stub_method_(false), calls_recover_(false),
+results_are_named_(false), is_unnamed_type_stub_method_(false),
-is_recover_thunk_(false), has_recover_thunk_(false),
+calls_recover_(false), is_recover_thunk_(false), has_recover_thunk_(false),
 calls_defer_retaddr_(false), is_type_specific_function_(false),
 in_unique_section_(false)
 {
 }
 Struct_type* st = closure->var_value()->type()->deref()->struct_type();
 // The first field of a closure is always a pointer to the function
 // code.
 Type* voidptr_type = Type::make_pointer_type(Type::make_void_type());
-st->push_field(Struct_field(Typed_identifier(".$f", voidptr_type,
+st->push_field(Struct_field(Typed_identifier(".f", voidptr_type,
 					       this->location_)));
 unsigned int index = 1;
 for (Closure_fields::const_iterator p = this->closure_fields_.begin();
 p != this->closure_fields_.end();
 // Export the function.
 void
 Function::export_func(Export* exp, const std::string& name) const
 {
-Function::export_func_with_type(exp, name, this->type_);
+Function::export_func_with_type(exp, name, this->type_,
+				  this->is_method() && this->nointerface());
 }
 // Export a function with a type.
 void
 Function::export_func_with_type(Export* exp, const std::string& name,
-				const Function_type* fntype)
+				const Function_type* fntype, bool nointerface)
 {
 exp->write_c_string("func ");
+if (nointerface)
+{
+go_assert(fntype->is_method());
+exp->write_c_string("/*nointerface*/ ");
+}
 if (fntype->is_method())
 {
 exp->write_c_string("(");
 const Typed_identifier* receiver = fntype->receiver();
 	      exp->write_type(p->type());
 	    }
 	  exp->write_c_string(")");
 	}
 }
-exp->write_c_string(";\n");
+exp->write_c_string("\n");
 }
 // Import a function.
 void
 Function::import_func(Import* imp, std::string* pname,
 		      Typed_identifier** preceiver,
 		      Typed_identifier_list** pparameters,
 		      Typed_identifier_list** presults,
-		      bool* is_varargs)
+		      bool* is_varargs,
+		      bool* nointerface)
 {
 imp->require_c_string("func ");
+*nointerface = false;
+if (imp->match_c_string("/*"))
+{
+imp->require_c_string("/*nointerface*/ ");
+*nointerface = true;
+// Only a method can be nointerface.
+go_assert(imp->peek_char() == '(');
+}
 *preceiver = NULL;
 if (imp->peek_char() == '(')
 {
 imp->require_c_string("(");
 	      imp->require_c_string(", ");
 	    }
 	  imp->require_c_string(")");
 	}
 }
-imp->require_c_string(";\n");
+imp->require_semicolon_if_old_version();
+imp->require_c_string("\n");
 *presults = results;
 }
 // Get the backend representation.
 Btype* functype = this->type_->get_backend_fntype(gogo);
 this->fndecl_ =
 gogo->backend()->function(functype, no->get_id(gogo), asm_name,
 is_visible, false, is_inlinable,
-disable_split_stack, in_unique_section,
+disable_split_stack, false,
-				    this->location());
+				    in_unique_section, this->location());
 }
 return this->fndecl_;
 }
 // Get the backend representation.
 Bfunction*
 Function_declaration::get_or_make_decl(Gogo* gogo, Named_object* no)
 {
 if (this->fndecl_ == NULL)
 {
+bool does_not_return = false;
 // Let Go code use an asm declaration to pick up a builtin
 // function.
 if (!this->asm_name_.empty())
 	{
 	  Bfunction* builtin_decl =
 	  if (builtin_decl != NULL)
 	    {
 	      this->fndecl_ = builtin_decl;
 	      return this->fndecl_;
 	    }
+	  if (this->asm_name_ == "runtime.gopanic"
+	      || this->asm_name_ == "__go_runtime_error")
+	    does_not_return = true;
 	}
 std::string asm_name;
 if (this->asm_name_.empty())
 	{
 asm_name = go_encode_id(no->get_id(gogo));
 Btype* functype = this->fntype_->get_backend_fntype(gogo);
 this->fndecl_ =
 gogo->backend()->function(functype, no->get_id(gogo), asm_name,
-true, true, true, false, false,
+true, true, true, false, does_not_return,
-this->location());
+				    false, this->location());
 }
 return this->fndecl_;
 }
 // Variables that need to be declared for this function and their
 // initial values.
 std::vector<Bvariable*> vars;
 std::vector<Bexpression*> var_inits;
+std::vector<Statement*> var_decls_stmts;
 for (Bindings::const_definitions_iterator p =
 	 this->block_->bindings()->begin_definitions();
 p != this->block_->bindings()->end_definitions();
 ++p)
 {
 parm_bvar = parm_no->get_backend_variable(gogo, named_function);
 vars.push_back(bvar);
 	      Expression* parm_ref =
 Expression::make_var_reference(parm_no, loc);
-	      parm_ref = Expression::make_unary(OPERATOR_MULT, parm_ref, loc);
+parm_ref =
+Expression::make_dereference(parm_ref,
+Expression::NIL_CHECK_NEEDED,
+loc);
 	      if ((*p)->var_value()->is_in_heap())
 		parm_ref = Expression::make_heap_expression(parm_ref, loc);
 var_inits.push_back(parm_ref->get_backend(&context));
 	    }
 	  else if ((*p)->var_value()->is_in_heap())
 					       loc)->get_backend(&context);
 vars.push_back(bvar);
 var_inits.push_back(init);
 	}
+else if (this->defer_stack_ != NULL
+&& (*p)->is_variable()
+&& (*p)->var_value()->is_non_escaping_address_taken()
+&& !(*p)->var_value()->is_in_heap())
+{
+// Local variable captured by deferred closure needs to be live
+// until the end of the function. We create a top-level
+// declaration for it.
+// TODO: we don't need to do this if the variable is not captured
+// by the defer closure. There is no easy way to check it here,
+// so we do this for all address-taken variables for now.
+Variable* var = (*p)->var_value();
+Temporary_statement* ts =
+Statement::make_temporary(var->type(), NULL, var->location());
+ts->set_is_address_taken();
+var->set_toplevel_decl(ts);
+var_decls_stmts.push_back(ts);
+}
 }
 if (!gogo->backend()->function_set_parameters(this->fndecl_, param_vars))
 {
 go_assert(saw_errors());
 return;
 if (this->block_ != NULL)
 {
 // Declare variables if necessary.
 Bblock* var_decls = NULL;
+std::vector<Bstatement*> var_decls_bstmt_list;
 Bstatement* defer_init = NULL;
 if (!vars.empty() || this->defer_stack_ != NULL)
 	{
 var_decls =
 gogo->backend()->block(this->fndecl_, NULL, vars,
 	  if (this->defer_stack_ != NULL)
 	    {
 	      Translate_context dcontext(gogo, named_function, this->block_,
 var_decls);
 defer_init = this->defer_stack_->get_backend(&dcontext);
+var_decls_bstmt_list.push_back(defer_init);
+for (std::vector<Statement*>::iterator p = var_decls_stmts.begin();
+p != var_decls_stmts.end();
+++p)
+{
+Bstatement* bstmt = (*p)->get_backend(&dcontext);
+var_decls_bstmt_list.push_back(bstmt);
+}
 	    }
 	}
 // Build the backend representation for all the statements in the
 // function.
 Bstatement* init_stmt =
 gogo->backend()->init_statement(this->fndecl_, vars[i],
 var_inits[i]);
 init.push_back(init_stmt);
 	}
-if (defer_init != NULL)
-	init.push_back(defer_init);
 Bstatement* var_init = gogo->backend()->statement_list(init);
 // Initialize all variables before executing this code block.
 Bstatement* code_stmt = gogo->backend()->block_statement(code_block);
 code_stmt = gogo->backend()->compound_statement(var_init, code_stmt);
 // Stick the code into the block we built for the receiver, if
 // we built one.
 if (var_decls != NULL)
 {
-std::vector<Bstatement*> code_stmt_list(1, code_stmt);
+var_decls_bstmt_list.push_back(code_stmt);
-gogo->backend()->block_add_statements(var_decls, code_stmt_list);
+gogo->backend()->block_add_statements(var_decls, var_decls_bstmt_list);
 code_stmt = gogo->backend()->block_statement(var_decls);
 }
 if (!gogo->backend()->function_set_body(this->fndecl_, code_stmt))
 {
 std::vector<Bexpression*> vals(results->size());
 for (size_t i = 0; i < vals.size(); ++i)
 {
 Named_object* no = (*this->results_)[i];
 Bvariable* bvar = no->get_backend_variable(gogo, named_function);
-Bexpression* val = gogo->backend()->var_expression(bvar, VE_rvalue,
+Bexpression* val = gogo->backend()->var_expression(bvar, location);
-location);
 if (no->result_var_value()->is_in_heap())
 	{
 	  Btype* bt = no->result_var_value()->type()->get_backend(gogo);
 	  val = gogo->backend()->indirect_expression(bt, val, true, location);
 	}
 	  go_assert(p != block->bindings()->end_definitions());
 	  ++p;
 	}
 go_assert(p != block->bindings()->end_definitions());
-std::string n = (*p)->message_name();
+for (; p != block->bindings()->end_definitions(); ++p)
-go_error_at(loc, "goto jumps over declaration of %qs", n.c_str());
+	{
-go_inform((*p)->location(), "%qs defined here", n.c_str());
+	  if ((*p)->is_variable())
+	    {
+	      std::string n = (*p)->message_name();
+	      go_error_at(loc, "goto jumps over declaration of %qs", n.c_str());
+	      go_inform((*p)->location(), "%qs defined here", n.c_str());
+	    }
+	}
 }
 }
 // Class Function_declaration.
+// Whether this declares a method.
+bool
+Function_declaration::is_method() const
+{
+return this->fntype_->is_method();
+}
+// Whether this method should not be included in the type descriptor.
+bool
+Function_declaration::nointerface() const
+{
+go_assert(this->is_method());
+return (this->pragmas_ & GOPRAGMA_NOINTERFACE) != 0;
+}
+// Record that this method should not be included in the type
+// descriptor.
+void
+Function_declaration::set_nointerface()
+{
+this->pragmas_ |= GOPRAGMA_NOINTERFACE;
+}
 // Return the function descriptor.
 Expression*
 Function_declaration::descriptor(Gogo*, Named_object* no)
 is_address_taken_(false), is_non_escaping_address_taken_(false),
 seen_(false), init_is_lowered_(false), init_is_flattened_(false),
 type_from_init_tuple_(false), type_from_range_index_(false),
 type_from_range_value_(false), type_from_chan_element_(false),
 is_type_switch_var_(false), determined_type_(false),
-in_unique_section_(false), escapes_(true)
+in_unique_section_(false), escapes_(true),
+toplevel_decl_(NULL)
 {
 go_assert(type != NULL || init != NULL);
 go_assert(!is_parameter || init == NULL);
 }
 gogo->flatten_expression(function, inserter, &this->init_);
 // If an interface conversion is needed, we need a temporary
 // variable.
 if (this->type_ != NULL
-	  && !Type::are_identical(this->type_, this->init_->type(), false,
+	  && !Type::are_identical(this->type_, this->init_->type(),
+				  Type::COMPARE_ERRORS | Type::COMPARE_TAGS,
 				  NULL)
 	  && this->init_->type()->interface_type() != NULL
 	  && !this->init_->is_variable())
 	{
 	  Temporary_statement* temp =
 Location loc = this->location();
 Expression* val_expr =
 Expression::make_cast(this->type(), this->init_, loc);
 Bexpression* val = val_expr->get_backend(&context);
 Bexpression* var_ref =
-gogo->backend()->var_expression(var_decl, VE_lvalue, loc);
+gogo->backend()->var_expression(var_decl, loc);
 decl_init = gogo->backend()->assignment_statement(bfunction, var_ref,
 val, loc);
 	}
 }
 Bstatement* block_stmt = gogo->backend()->block_statement(bblock);
 go_assert(this->is_global_);
 exp->write_c_string("var ");
 exp->write_string(name);
 exp->write_c_string(" ");
 exp->write_type(this->type());
-exp->write_c_string(";\n");
+exp->write_c_string("\n");
 }
 // Import a variable.
 void
 {
 imp->require_c_string("var ");
 *pname = imp->read_identifier();
 imp->require_c_string(" ");
 *ptype = imp->read_type();
-imp->require_c_string(";\n");
+imp->require_semicolon_if_old_version();
+imp->require_c_string("\n");
 }
 // Convert a variable to the backend representation.
 Bvariable*
 	      else if (is_parameter)
 		bvar = backend->parameter_variable(bfunction, n, btype,
 						   is_address_taken,
 						   this->location_);
 	      else
-		bvar = backend->local_variable(bfunction, n, btype,
+{
-					       is_address_taken,
+Bvariable* bvar_decl = NULL;
-					       this->location_);
+if (this->toplevel_decl_ != NULL)
+{
+Translate_context context(gogo, NULL, NULL, NULL);
+bvar_decl = this->toplevel_decl_->temporary_statement()
+->get_backend_variable(&context);
+}
+bvar = backend->local_variable(bfunction, n, btype,
+bvar_decl,
+is_address_taken,
+this->location_);
+}
 	    }
 	  this->backend_ = bvar;
 	}
 }
 return this->backend_;
 	  Bfunction* bfunction = function->func_value()->get_decl();
 	  std::string n = Gogo::unpack_hidden_name(name);
 	  bool is_address_taken = (this->is_non_escaping_address_taken_
 				   && !this->is_in_heap());
 	  this->backend_ = backend->local_variable(bfunction, n, btype,
-						   is_address_taken,
+						   NULL, is_address_taken,
 						   this->location_);
 	}
 }
 return this->backend_;
 }
 // Class Named_constant.
+// Set the type of a named constant.  This is only used to set the
+// type to an error type.
+void
+Named_constant::set_type(Type* t)
+{
+go_assert(this->type_ == NULL || t->is_error_type());
+this->type_ = t;
+}
 // Traverse the initializer expression.
 int
 Named_constant::traverse_expression(Traverse* traverse)
 exp->write_type(this->type_);
 exp->write_c_string(" ");
 }
 exp->write_c_string("= ");
 this->expr()->export_expression(exp);
-exp->write_c_string(";\n");
+exp->write_c_string("\n");
 }
 // Import a constant.
 void
 *ptype = imp->read_type();
 imp->require_c_string(" ");
 }
 imp->require_c_string("= ");
 *pexpr = Expression::import_expression(imp);
-imp->require_c_string(";\n");
+imp->require_semicolon_if_old_version();
+imp->require_c_string("\n");
 }
 // Get the backend representation.
 Bexpression*
 case NAMED_OBJECT_CONST:
 this->const_value()->export_const(exp, this->name_);
 break;
 case NAMED_OBJECT_TYPE:
-this->type_value()->export_named_type(exp, this->name_);
+// Types are handled by export::write_types.
-break;
+go_unreachable();
 case NAMED_OBJECT_TYPE_DECLARATION:
 go_error_at(this->type_declaration_value()->location(),
 		  "attempt to export %<%s%> which was declared but not defined",
 		  this->message_name().c_str());
 break;
 case NAMED_OBJECT_TYPE:
 {
 Named_type* named_type = this->u_.type_value;
-	if (!Gogo::is_erroneous_name(this->name_))
+	if (!Gogo::is_erroneous_name(this->name_) && !named_type->is_alias())
 	  type_decls.push_back(named_type->get_backend(gogo));
 // We need to produce a type descriptor for every named
 // type, and for a pointer to every named type, since
 // other files or packages might refer to them.  We need
 case Named_object::NAMED_OBJECT_SINK:
 go_unreachable();
 case Named_object::NAMED_OBJECT_FUNC:
-if (new_object->is_function_declaration())
-	{
-	  if (!new_object->func_declaration_value()->asm_name().empty())
-	    go_error_at(Linemap::unknown_location(),
-			("sorry, not implemented: "
-			 "__asm__ for function definitions"));
-	  Function_type* old_type = old_object->func_value()->type();
-	  Function_type* new_type =
-	    new_object->func_declaration_value()->type();
-	  if (old_type->is_valid_redeclaration(new_type, &reason))
-	    return old_object;
-	}
 break;
 case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
 {
-	if (new_object->is_function())
+	// We declare the hash and equality functions before defining
+	// them, because we sometimes see that we need the declaration
+	// while we are in the middle of a different function.  We
+	// declare the main function before the user defines it, to
+	// give better error messages.
+	if (new_object->is_function()
+	    && ((Linemap::is_predeclared_location(old_object->location())
+		 && Linemap::is_predeclared_location(new_object->location()))
+		|| (Gogo::unpack_hidden_name(old_object->name()) == "main"
+		    && Linemap::is_unknown_location(old_object->location()))))
 	  {
 Function_type* old_type =
 old_object->func_declaration_value()->type();
 	    Function_type* new_type = new_object->func_value()->type();
 	    if (old_type->is_valid_redeclaration(new_type, &reason))
 	      {
-		if (!old_object->func_declaration_value()->asm_name().empty())
+		Function_declaration* fd =
-		  go_error_at(Linemap::unknown_location(),
+		  old_object->func_declaration_value();
-			      ("sorry, not implemented: "
+		go_assert(fd->asm_name().empty());
-			       "__asm__ for function definitions"));
 		old_object->set_function_value(new_object->func_value());
 		this->named_objects_.push_back(old_object);
 		return old_object;
 	      }
 	  }
 go_error_at(new_object->location(), "redefinition of %qs: %s", n.c_str(),
 		reason.c_str());
 old_object->set_is_redefinition();
 new_object->set_is_redefinition();
-go_inform(old_object->location(), "previous definition of %qs was here",
+if (!Linemap::is_unknown_location(old_object->location())
-n.c_str());
+&& !Linemap::is_predeclared_location(old_object->location()))
+go_inform(old_object->location(), "previous definition of %qs was here",
+	      n.c_str());
 return old_object;
 }
 // Add a named type.
 		}
 	    }
 	}
 }
+// Traverse function declarations when needed.
+if ((traverse_mask & Traverse::traverse_func_declarations) != 0)
+{
+for (Bindings::const_declarations_iterator p = this->begin_declarations();
+p != this->end_declarations();
+++p)
+{
+if (p->second->is_function_declaration())
+{
+if (traverse->function_declaration(p->second) == TRAVERSE_EXIT)
+return TRAVERSE_EXIT;
+}
+}
+}
 return TRAVERSE_CONTINUE;
 }
 // Class Label.
 go_assert((this->traverse_mask() & traverse_types) != 0
 	     || (this->traverse_mask() & traverse_expressions) != 0);
 // We mostly only have to remember named types.  But it turns out
 // that an interface type can refer to itself without using a name
 // by relying on interface inheritance, as in
-// type I interface { F() interface{I} }
+//
+//         type I interface { F() interface{I} }
+//
+// Similarly it is possible for array types to refer to themselves
+// without a name, e.g.
+//
+//         var x [uintptr(unsafe.Sizeof(&x))]byte
+//
 if (type->classification() != Type::TYPE_NAMED
+&& type->classification() != Type::TYPE_ARRAY
 && type->classification() != Type::TYPE_INTERFACE)
 return false;
 if (this->types_seen_ == NULL)
 this->types_seen_ = new Types_seen();
 std::pair<Types_seen::iterator, bool> ins = this->types_seen_->insert(type);
 Traverse::type(Type*)
 {
 go_unreachable();
 }
+int
+Traverse::function_declaration(Named_object*)
+{
+go_unreachable();
+}
 // Class Statement_inserter.
 void
 Statement_inserter::insert(Statement* s)
 {
+if (this->statements_added_ != NULL)
+this->statements_added_->insert(s);
 if (this->block_ != NULL)
 {
 go_assert(this->pindex_ != NULL);
 this->block_->insert_statement_before(*this->pindex_, s);
 ++*this->pindex_;

Mercurial > hg > CbC > CbC_gcc

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