Remove some remaining references to boilerplate functions.

Review URL: http://codereview.chromium.org/1605037

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@4440 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/arm/full-codegen-arm.cc b/src/arm/full-codegen-arm.cc
index 72f4128..62365ff 100644 (file)
--- a/src/arm/full-codegen-arm.cc
+++ b/src/arm/full-codegen-arm.cc
@@ -666,7 +666,8 @@ void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
 void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
-  // Build the function boilerplate and instantiate it.
+  // Build the shared function info and instantiate the function based
+  // on it.
   Handle<SharedFunctionInfo> function_info =
       Compiler::BuildFunctionInfo(expr, script(), this);
   if (HasStackOverflow()) return;

diff --git a/src/compilation-cache.cc b/src/compilation-cache.cc
index f1ab87b..cec10fd 100644 (file)
--- a/src/compilation-cache.cc
+++ b/src/compilation-cache.cc
@@ -270,7 +270,7 @@ Handle<SharedFunctionInfo> CompilationCacheScript::Lookup(Handle<String> source,
       if (probe->IsSharedFunctionInfo()) {
         Handle<SharedFunctionInfo> function_info =
             Handle<SharedFunctionInfo>::cast(probe);
-        // Break when we've found a suitable boilerplate function that
+        // Break when we've found a suitable shared function info that
         // matches the origin.
         if (HasOrigin(function_info, name, line_offset, column_offset)) {
           result = *function_info;

diff --git a/src/compilation-cache.h b/src/compilation-cache.h
index d231822..6358a26 100644 (file)
--- a/src/compilation-cache.h
+++ b/src/compilation-cache.h
@@ -32,12 +32,13 @@ namespace v8 {
 namespace internal {
 
 
-// The compilation cache keeps function boilerplates for compiled
-// scripts and evals. The boilerplates are looked up using the source
-// string as the key. For regular expressions the compilation data is cached.
+// The compilation cache keeps shared function infos for compiled
+// scripts and evals. The shared function infos are looked up using
+// the source string as the key. For regular expressions the
+// compilation data is cached.
 class CompilationCache {
  public:
-  // Finds the script function boilerplate for a source
+  // Finds the script shared function info for a source
   // string. Returns an empty handle if the cache doesn't contain a
   // script for the given source string with the right origin.
   static Handle<SharedFunctionInfo> LookupScript(Handle<String> source,
@@ -45,7 +46,7 @@ class CompilationCache {
                                                  int line_offset,
                                                  int column_offset);
 
-  // Finds the function boilerplate for a source string for eval in a
+  // Finds the shared function info for a source string for eval in a
   // given context.  Returns an empty handle if the cache doesn't
   // contain a script for the given source string.
   static Handle<SharedFunctionInfo> LookupEval(Handle<String> source,
@@ -57,13 +58,13 @@ class CompilationCache {
   static Handle<FixedArray> LookupRegExp(Handle<String> source,
                                          JSRegExp::Flags flags);
 
-  // Associate the (source, kind) pair to the boilerplate. This may
-  // overwrite an existing mapping.
+  // Associate the (source, kind) pair to the shared function
+  // info. This may overwrite an existing mapping.
   static void PutScript(Handle<String> source,
                         Handle<SharedFunctionInfo> function_info);
 
   // Associate the (source, context->closure()->shared(), kind) triple
-  // with the boilerplate. This may overwrite an existing mapping.
+  // with the shared function info. This may overwrite an existing mapping.
   static void PutEval(Handle<String> source,
                       Handle<Context> context,
                       bool is_global,

diff --git a/src/compiler.cc b/src/compiler.cc
index aa80a02..c342dc2 100755 (executable)
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -541,7 +541,7 @@ Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal,
                               code);
   }
 
-  // Create a boilerplate function.
+  // Create a shared function info object.
   Handle<SharedFunctionInfo> result =
       Factory::NewSharedFunctionInfo(literal->name(),
                                      literal->materialized_literal_count(),

diff --git a/src/execution.cc b/src/execution.cc
index e8b0d94..006d358 100644 (file)
--- a/src/execution.cc
+++ b/src/execution.cc
@@ -46,9 +46,6 @@ static Handle<Object> Invoke(bool construct,
                              int argc,
                              Object*** args,
                              bool* has_pending_exception) {
-  // Make sure we have a real function, not a boilerplate function.
-  ASSERT(!func->IsBoilerplate());
-
   // Entering JavaScript.
   VMState state(JS);
 

diff --git a/src/factory.cc b/src/factory.cc
index 18cd218..20f8261 100644 (file)
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -314,7 +314,6 @@ Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
                   context->global_context());
   }
   result->set_literals(*literals);
-  ASSERT(!result->IsBoilerplate());
   return result;
 }
 

diff --git a/src/heap.cc b/src/heap.cc
index 2a65a68..48c73bf 100644 (file)
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -1444,10 +1444,6 @@ bool Heap::CreateInitialMaps() {
   if (obj->IsFailure()) return false;
   set_global_context_map(Map::cast(obj));
 
-  obj = AllocateMap(JS_FUNCTION_TYPE, JSFunction::kSize);
-  if (obj->IsFailure()) return false;
-  set_boilerplate_function_map(Map::cast(obj));
-
   obj = AllocateMap(SHARED_FUNCTION_INFO_TYPE,
                     SharedFunctionInfo::kAlignedSize);
   if (obj->IsFailure()) return false;

diff --git a/src/heap.h b/src/heap.h
index 5c01e74..4812bd9 100644 (file)
--- a/src/heap.h
+++ b/src/heap.h
@@ -89,7 +89,6 @@ class ZoneScopeInfo;
   V(Map, code_map, CodeMap)                                                    \
   V(Map, oddball_map, OddballMap)                                              \
   V(Map, global_property_cell_map, GlobalPropertyCellMap)                      \
-  V(Map, boilerplate_function_map, BoilerplateFunctionMap)                     \
   V(Map, shared_function_info_map, SharedFunctionInfoMap)                      \
   V(Map, proxy_map, ProxyMap)                                                  \
   V(Object, nan_value, NanValue)                                               \

diff --git a/src/ia32/codegen-ia32.cc b/src/ia32/codegen-ia32.cc
index a586b0d..7682d57 100644 (file)
--- a/src/ia32/codegen-ia32.cc
+++ b/src/ia32/codegen-ia32.cc
@@ -4661,8 +4661,8 @@ Result CodeGenerator::InstantiateFunction(
     frame()->EmitPush(Immediate(function_info));
     return frame()->CallStub(&stub, 1);
   } else {
-    // Call the runtime to instantiate the function boilerplate
-    // object.
+    // Call the runtime to instantiate the function based on the
+    // shared function info.
     frame()->EmitPush(esi);
     frame()->EmitPush(Immediate(function_info));
     return frame()->CallRuntime(Runtime::kNewClosure, 2);

diff --git a/src/ia32/full-codegen-ia32.cc b/src/ia32/full-codegen-ia32.cc
index e59dc51..e9838ad 100644 (file)
--- a/src/ia32/full-codegen-ia32.cc
+++ b/src/ia32/full-codegen-ia32.cc
@@ -776,7 +776,8 @@ void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
 void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
-  // Build the function boilerplate and instantiate it.
+  // Build the shared function info and instantiate the function based
+  // on it.
   Handle<SharedFunctionInfo> function_info =
       Compiler::BuildFunctionInfo(expr, script(), this);
   if (HasStackOverflow()) return;

diff --git a/src/objects-debug.cc b/src/objects-debug.cc
index a6ad958..c82d194 100644 (file)
--- a/src/objects-debug.cc
+++ b/src/objects-debug.cc
@@ -725,7 +725,6 @@ void String::StringVerify() {
 void JSFunction::JSFunctionPrint() {
   HeapObject::PrintHeader("Function");
   PrintF(" - map = 0x%p\n", map());
-  PrintF(" - is boilerplate: %s\n", IsBoilerplate() ? "yes" : "no");
   PrintF(" - initial_map = ");
   if (has_initial_map()) {
     initial_map()->ShortPrint();

diff --git a/src/objects-inl.h b/src/objects-inl.h
index a21a735..621a3f8 100644 (file)
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -2491,11 +2491,6 @@ bool SharedFunctionInfo::HasCustomCallGenerator() {
 }
 
 
-bool JSFunction::IsBoilerplate() {
-  return map() == Heap::boilerplate_function_map();
-}
-
-
 bool JSFunction::IsBuiltin() {
   return context()->global()->IsJSBuiltinsObject();
 }
@@ -2580,7 +2575,6 @@ bool JSFunction::is_compiled() {
 
 
 int JSFunction::NumberOfLiterals() {
-  ASSERT(!IsBoilerplate());
   return literals()->length();
 }
 

diff --git a/src/objects.cc b/src/objects.cc
index 02ea5b0..252d847 100644 (file)
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -1189,8 +1189,7 @@ String* JSObject::class_name() {
 
 String* JSObject::constructor_name() {
   if (IsJSFunction()) {
-    return JSFunction::cast(this)->IsBoilerplate() ?
-      Heap::function_class_symbol() : Heap::closure_symbol();
+    return Heap::closure_symbol();
   }
   if (map()->constructor()->IsJSFunction()) {
     JSFunction* constructor = JSFunction::cast(map()->constructor());
@@ -2519,9 +2518,8 @@ bool JSObject::ReferencesObject(Object* obj) {
       break;
   }
 
-  // For functions check the context. Boilerplate functions do
-  // not have to be traversed since they have no real context.
-  if (IsJSFunction() && !JSFunction::cast(this)->IsBoilerplate()) {
+  // For functions check the context.
+  if (IsJSFunction()) {
     // Get the constructor function for arguments array.
     JSObject* arguments_boilerplate =
         Top::context()->global_context()->arguments_boilerplate();

diff --git a/src/objects.h b/src/objects.h
index aa60e63..1639457 100644 (file)
--- a/src/objects.h
+++ b/src/objects.h
@@ -3364,10 +3364,6 @@ class JSFunction: public JSObject {
   inline Code* code();
   inline void set_code(Code* value);
 
-  // Tells whether this function is a context-independent boilerplate
-  // function.
-  inline bool IsBoilerplate();
-
   // Tells whether this function is builtin.
   inline bool IsBuiltin();
 

diff --git a/src/parser.cc b/src/parser.cc
index b923a7f..089eeee 100644 (file)
--- a/src/parser.cc
+++ b/src/parser.cc
@@ -1959,7 +1959,7 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) {
       extension_->GetNativeFunction(v8::Utils::ToLocal(name));
   ASSERT(!fun_template.IsEmpty());
 
-  // Instantiate the function and create a boilerplate function from it.
+  // Instantiate the function and create a shared function info from it.
   Handle<JSFunction> fun = Utils::OpenHandle(*fun_template->GetFunction());
   const int literals = fun->NumberOfLiterals();
   Handle<Code> code = Handle<Code>(fun->shared()->code());
@@ -1968,7 +1968,7 @@ Statement* Parser::ParseNativeDeclaration(bool* ok) {
       Factory::NewSharedFunctionInfo(name, literals, code);
   shared->set_construct_stub(*construct_stub);
 
-  // Copy the function data to the boilerplate.
+  // Copy the function data to the shared function info.
   shared->set_function_data(fun->shared()->function_data());
   int parameters = fun->shared()->formal_parameter_count();
   shared->set_formal_parameter_count(parameters);

diff --git a/src/x64/codegen-x64.cc b/src/x64/codegen-x64.cc
index 9c84e23..44d7cee 100644 (file)
--- a/src/x64/codegen-x64.cc
+++ b/src/x64/codegen-x64.cc
@@ -2283,8 +2283,8 @@ void CodeGenerator::InstantiateFunction(
     Result answer = frame_->CallStub(&stub, 1);
     frame_->Push(&answer);
   } else {
-    // Call the runtime to instantiate the function boilerplate
-    // object.
+    // Call the runtime to instantiate the function based on the
+    // shared function info.
     frame_->EmitPush(rsi);
     frame_->EmitPush(function_info);
     Result result = frame_->CallRuntime(Runtime::kNewClosure, 2);

diff --git a/src/x64/full-codegen-x64.cc b/src/x64/full-codegen-x64.cc
index ab73706..a34a94e 100644 (file)
--- a/src/x64/full-codegen-x64.cc
+++ b/src/x64/full-codegen-x64.cc
@@ -780,7 +780,8 @@ void FullCodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
 void FullCodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
   Comment cmnt(masm_, "[ FunctionLiteral");
 
-  // Build the function boilerplate and instantiate it.
+  // Build the shared function info and instantiate the function based
+  // on it.
   Handle<SharedFunctionInfo> function_info =
       Compiler::BuildFunctionInfo(expr, script(), this);
   if (HasStackOverflow()) return;