compiler: Expose runtime code through Func_expression.

    Enables us to easily check if a Call_expression is a call to a runtime
    function and, if so, which runtime function is corresponds to.
    This will be used during escape analysis.

    Reviewed-on: https://go-review.googlesource.com/18544

From-SVN: r235383

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 5c8cd7d6f18d670c4f83c424192a489c636a89c2..6b2e105a2d31bf437c65ef3e79251bd6f63762b7 100644 (file)
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-97b358f525584e45fa2e3d83fc7d3a091900927a
+944c3ca6ac7c204585fd73936894fe05de535b94
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 09ab5bf8f7e19fc9625de2992f9b4252cc09a8a4..170d95703c6abfb0c4145334d010988d8e79a8fc 100644 (file)
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -1141,7 +1141,13 @@ Expression*
 Expression::make_func_reference(Named_object* function, Expression* closure,
                                Location location)
 {
-  return new Func_expression(function, closure, location);
+  Func_expression* fe = new Func_expression(function, closure, location);
+
+  // Detect references to builtin functions and set the runtime code if
+  // appropriate.
+  if (function->is_function_declaration())
+    fe->set_runtime_code(Runtime::name_to_code(function->name()));
+  return fe;
 }
 
 // Class Func_descriptor_expression.

diff --git a/gcc/go/gofrontend/expressions.h b/gcc/go/gofrontend/expressions.h
index c33e63653e62072ae564a02db0a25257b6124fbb..6c780607f2ddb937ac8622e9c0d0faac8e5f61a4 100644 (file)
--- a/gcc/go/gofrontend/expressions.h
+++ b/gcc/go/gofrontend/expressions.h
@@ -11,6 +11,7 @@
 #include <mpc.h>
 
 #include "operator.h"
+#include "runtime.h"
 
 class Gogo;
 class Translate_context;
@@ -2149,7 +2150,8 @@ class Func_expression : public Expression
   Func_expression(Named_object* function, Expression* closure,
                  Location location)
     : Expression(EXPRESSION_FUNC_REFERENCE, location),
-      function_(function), closure_(closure)
+      function_(function), closure_(closure),
+      runtime_code_(Runtime::NUMBER_OF_FUNCTIONS)
   { }
 
   // Return the object associated with the function.
@@ -2163,6 +2165,23 @@ class Func_expression : public Expression
   closure()
   { return this->closure_; }
 
+  // Return whether this is a reference to a runtime function.
+  bool
+  is_runtime_function() const
+  { return this->runtime_code_ != Runtime::NUMBER_OF_FUNCTIONS; }
+
+  // Return the runtime code for this function expression.
+  // Returns Runtime::NUMBER_OF_FUNCTIONS if this is not a reference to a
+  // runtime function.
+  Runtime::Function
+  runtime_code() const
+  { return this->runtime_code_; }
+
+  // Set the runtime code for this function expression.
+  void
+  set_runtime_code(Runtime::Function code)
+  { this->runtime_code_ = code; }
+
   // Return a backend expression for the code of a function.
   static Bexpression*
   get_code_pointer(Gogo*, Named_object* function, Location loc);
@@ -2204,6 +2223,8 @@ class Func_expression : public Expression
   // be a struct holding pointers to all the variables referenced by
   // this function and defined in enclosing functions.
   Expression* closure_;
+  // The runtime code for the referenced function.
+  Runtime::Function runtime_code_;
 };
 
 // A function descriptor.  A function descriptor is a struct with a

diff --git a/gcc/go/gofrontend/runtime.cc b/gcc/go/gofrontend/runtime.cc
index de68f64b59357f2e38f3900f6a94505082c7e9a7..64920250e4347f968e7be22fd240ccf1957aa60b 100644 (file)
--- a/gcc/go/gofrontend/runtime.cc
+++ b/gcc/go/gofrontend/runtime.cc
@@ -402,3 +402,39 @@ Runtime::map_iteration_type()
                                Linemap::predeclared_location());
   return Type::make_array_type(runtime_function_type(RFT_POINTER), iexpr);
 }
+
+
+// Get the runtime code for a named builtin function.  This is used as a helper
+// when creating function references for call expressions.  Every reference to
+// a builtin runtime function should have the associated runtime code.  If the
+// name is ambiguous and can refer to many runtime codes, return
+// NUMBER_OF_FUNCTIONS.
+
+Runtime::Function
+Runtime::name_to_code(const std::string& name)
+{
+  Function code = Runtime::NUMBER_OF_FUNCTIONS;
+
+  // Aliases seen in function declaration code.
+  // TODO(cmang): Add other aliases.
+  if (name == "new")
+    code = Runtime::NEW;
+  else if (name == "close")
+    code = Runtime::CLOSE;
+  else if (name == "copy")
+    code = Runtime::COPY;
+  else if (name == "append")
+    code = Runtime::APPEND;
+  else if (name == "delete")
+    code = Runtime::MAPDELETE;
+  else
+    {
+      // Look through the known names for a match.
+      for (size_t i = 0; i < Runtime::NUMBER_OF_FUNCTIONS; i++)
+       {
+         if (strcmp(runtime_functions[i].name, name.c_str()) == 0)
+           code = static_cast<Runtime::Function>(i);
+       }
+    }
+  return code;
+}

diff --git a/gcc/go/gofrontend/runtime.h b/gcc/go/gofrontend/runtime.h
index be5dcbe25d07166deef57d1e995e2f229ae28801..636e1965006fe466c1d9fd6aa18f66018902a4a0 100644 (file)
--- a/gcc/go/gofrontend/runtime.h
+++ b/gcc/go/gofrontend/runtime.h
@@ -43,6 +43,10 @@ class Runtime
   static Type*
   map_iteration_type();
 
+  // Return the runtime code for a named builtin function.
+  static Function
+  name_to_code(const std::string&);
+
  private:
   static Named_object*
   runtime_declaration(Function);