Minor refactoring: unify lazy function compilation for in loop and no in loop variants.

src/handles.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 816 matching lines @@
 }
 
 
 bool CompileLazyShared(Handle<SharedFunctionInfo> shared,
                        ClearExceptionFlag flag) {
   CompilationInfo info(shared);
   return CompileLazyHelper(&info, flag);
 }
 
 
-bool CompileLazy(Handle<JSFunction> function,
-                 ClearExceptionFlag flag) {
+static bool CompileLazyFunction(Handle<JSFunction> function,
+                                ClearExceptionFlag flag,
+                                bool in_loop) {
   bool result = true;
   if (function->shared()->is_compiled()) {
     function->ReplaceCode(function->shared()->code());
     function->shared()->set_code_age(0);
   } else {
     CompilationInfo info(function);
+    if (in_loop) info.MarkAsInLoop();
     result = CompileLazyHelper(&info, flag);
     ASSERT(!result || function->is_compiled());
   }
   if (result && function->is_compiled()) {
     PROFILE(FunctionCreateEvent(*function));
   }
   return result;
 }
 
 
+bool CompileLazy(Handle<JSFunction> function,
+                 ClearExceptionFlag flag) {
+  return CompileLazyFunction(function, flag, false /* in loop */);

[Kevin Millikin (Chromium), 2011/02/18 16:16:58]

The C style comment is OK, but I don't think we have any examples of the style
in the code already:

You could also consider:

const kInLoop = false;
return CompileLazyFunction(function, flag, kInLoop);

but it's not obviously better.

[antonm, 2011/02/21 18:27:58]

(And responding to Slava too): I didn't want to introduce new enum, but then
recalled we already have this IN_LOOP/NOT_IN_LOOP stuff, switched to it.

On 2011/02/18 16:16:58, Kevin Millikin wrote:

+}
+
+
 bool CompileLazyInLoop(Handle<JSFunction> function,
                        ClearExceptionFlag flag) {
-  bool result = true;
-  if (function->shared()->is_compiled()) {
-    function->ReplaceCode(function->shared()->code());
-    function->shared()->set_code_age(0);
-  } else {
-    CompilationInfo info(function);
-    info.MarkAsInLoop();
-    result = CompileLazyHelper(&info, flag);
-    ASSERT(!result || function->is_compiled());
-  }
-  if (result && function->is_compiled()) {
-    PROFILE(FunctionCreateEvent(*function));
-  }
-  return result;
+  return CompileLazyFunction(function, flag, true /* in loop */);
 }
 
 
 bool CompileOptimized(Handle<JSFunction> function, int osr_ast_id) {
   CompilationInfo info(function);
   info.SetOptimizing(osr_ast_id);
   bool result = CompileLazyHelper(&info, KEEP_EXCEPTION);
   if (result) PROFILE(FunctionCreateEvent(*function));
   return result;
 }
@@ skipping 22 matching lines @@
 
 OptimizedObjectForAddingMultipleProperties::
 ~OptimizedObjectForAddingMultipleProperties() {
   // Reoptimize the object to allow fast property access.
   if (has_been_transformed_) {
     TransformToFastProperties(object_, unused_property_fields_);
   }
 }
 
 } }  // namespace v8::internal