Added %NeverOptimize runtime call that can disable optimizations for a method for tests.

src/runtime.cc

 // Copyright 2012 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 8328 matching lines @@
       }
     } else if (type->IsOneByteEqualTo(STATIC_ASCII_VECTOR("parallel"))) {
       function->MarkForParallelRecompilation();
     }
   }
 
   return isolate->heap()->undefined_value();
 }
 
 
+static void MarkNeverOptimize(JSFunction *function) {
+  Code *code = function->code();
+  if (code != NULL && code->kind() == Code::FUNCTION) {
+    code->set_optimizable(false);
+  }
+  Code *shared_code = function->shared()->code();
+  if (shared_code != NULL && shared_code->kind() == Code::FUNCTION) {
+    shared_code->set_optimizable(false);
+  }
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_NeverOptimize) {
+  HandleScope scope(isolate);
+
+  if (args.length() == 0) {
+    // mark the top frame as do not optimize

[Jakob Kummerow, 2013/07/11 15:23:33]

nit: Begin with capitalization, end with punctuation. Again below.

[titzer, 2013/07/11 15:29:02]

Done. (fixed this before submitting).

+    JavaScriptFrameIterator it(isolate);
+    if (!it.done()) MarkNeverOptimize(JSFunction::cast(it.frame()->function()));

[Jakob Kummerow, 2013/07/11 15:23:33]

Instead of rolling your own MarkNeverOptimize, I think you should just call:
JSFunction::cast(it.frame()->function())->shared()->DisableOptimization("%NeverOptimize");
That function does all the right things.

[titzer, 2013/07/11 15:29:02]

I also did something similar prior to submit...as thankfully my
never-optimize.js unit test caught a bug with --always-opt :)

+    return isolate->heap()->undefined_value();
+  }
+
+  // mark the passed functions as do not optimize
+  for (int i = 0; i < args.length(); i++) {
+    CONVERT_ARG_CHECKED(JSFunction, function, i);
+    MarkNeverOptimize(function);
+  }
+  return isolate->heap()->undefined_value();
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_CompleteOptimization) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   if (FLAG_parallel_recompilation && V8::UseCrankshaft()) {
     // While function is in optimization pipeline, it is marked accordingly.
     // Note that if the debugger is activated during parallel recompilation,
     // the function will be marked with the lazy-recompile builtin, which is
     // not related to parallel recompilation.
     while (function->IsMarkedForParallelRecompilation() ||
@@ skipping 5637 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal