diff mbox series

Go patch committed: Do some escape checks earlier

Message ID CAOyqgcVptkVBf45ZAgsFeU19CBbBQP_27ZCKMK+ePZJtfnFokQ@mail.gmail.com
State New
Headers show
Series Go patch committed: Do some escape checks earlier | expand

Commit Message

Ian Lance Taylor Jan. 9, 2018, 11:30 p.m. UTC 
This patch to  the Go frontend by Cherry Zhang moves some checks of
escape state earlier, from get_backend to Mark_address_taken.  This
permits us to reclaim escape analysis Nodes before kicking off the
backend (although that is not done in this patch).  Also it makes it
easier to check variables and closures do not escape when the escape
analysis is run for the runtime package (also not done in this patch).
Bootstrapped on x86_64-pc-linux-gnu.  Committed to mainline.

Ian
diff mbox series

Patch

Index: gcc/go/gofrontend/MERGE
===================================================================
--- gcc/go/gofrontend/MERGE	(revision 256405)
+++ gcc/go/gofrontend/MERGE	(working copy)
@@ -1,4 +1,4 @@ 
-cf5a64066fa21b20beae0b895c05d26af53e13e0
+584fdecefce831c3471dbd4857ba0ce0be2b5212
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.
Index: gcc/go/gofrontend/expressions.cc
===================================================================
--- gcc/go/gofrontend/expressions.cc	(revision 256404)
+++ gcc/go/gofrontend/expressions.cc	(working copy)
@@ -12383,9 +12383,7 @@  Allocation_expression::do_get_backend(Tr
   Gogo* gogo = context->gogo();
   Location loc = this->location();
 
-  Node* n = Node::make_node(this);
-  if (this->allocate_on_stack_
-      || (n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
+  if (this->allocate_on_stack_)
     {
       int64_t size;
       bool ok = this->type_->backend_type_size(gogo, &size);
@@ -13161,13 +13159,8 @@  Slice_construction_expression::do_get_ba
     }
   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.
@@ -14261,8 +14254,7 @@  Heap_expression::do_get_backend(Translat
   Btype* btype = this->type()->get_backend(gogo);
 
   Expression* alloc = Expression::make_allocation(etype, loc);
-  Node* n = Node::make_node(this);
-  if ((n->encoding() & ESCAPE_MASK) == int(Node::ESCAPE_NONE))
+  if (this->allocate_on_stack_)
     alloc->allocation_expression()->set_allocate_on_stack();
   Bexpression* space = alloc->get_backend(context);
 
Index: gcc/go/gofrontend/expressions.h
===================================================================
--- gcc/go/gofrontend/expressions.h	(revision 256366)
+++ gcc/go/gofrontend/expressions.h	(working copy)
@@ -3870,13 +3870,17 @@  class Heap_expression : public Expressio
  public:
   Heap_expression(Expression* expr, Location location)
     : Expression(EXPRESSION_HEAP, location),
-      expr_(expr)
+      expr_(expr), allocate_on_stack_(false)
   { }
 
   Expression*
   expr() const
   { return this->expr_; }
 
+  void
+  set_allocate_on_stack()
+  { this->allocate_on_stack_ = true; }
+
  protected:
   int
   do_traverse(Traverse* traverse)
@@ -3910,6 +3914,8 @@  class Heap_expression : public Expressio
  private:
   // The expression which is being put on the heap.
   Expression* expr_;
+  // Whether or not this is a stack allocation.
+  bool allocate_on_stack_;
 };
 
 // A receive expression.
Index: gcc/go/gofrontend/wb.cc
===================================================================
--- gcc/go/gofrontend/wb.cc	(revision 256404)
+++ gcc/go/gofrontend/wb.cc	(working copy)
@@ -65,6 +65,25 @@  Mark_address_taken::expression(Expressio
       aie->array()->address_taken(escapes);
     }
 
+  if (expr->allocation_expression() != NULL)
+    {
+      Node* n = Node::make_node(expr);
+      if ((n->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
+        expr->allocation_expression()->set_allocate_on_stack();
+    }
+  if (expr->heap_expression() != NULL)
+    {
+      Node* n = Node::make_node(expr);
+      if ((n->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
+        expr->heap_expression()->set_allocate_on_stack();
+    }
+  if (expr->slice_literal() != NULL)
+    {
+      Node* n = Node::make_node(expr);
+      if ((n->encoding() & ESCAPE_MASK) == Node::ESCAPE_NONE)
+        expr->slice_literal()->set_storage_does_not_escape();
+    }
+
   // Rewrite non-escaping makeslice with constant size to stack allocation.
   Unsafe_type_conversion_expression* uce =
     expr->unsafe_conversion_expression();