Revert of [tests] Make assertOptimized()/assertUnoptimized() great again.

src/runtime/runtime-test.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/runtime/runtime-utils.h"
 
 #include <memory>
 
 #include "src/arguments.h"
 #include "src/compiler-dispatcher/optimizing-compile-dispatcher.h"
@@ skipping 218 matching lines @@
 RUNTIME_FUNCTION(Runtime_NeverOptimizeFunction) {
   HandleScope scope(isolate);
   DCHECK_EQ(1, args.length());
   CONVERT_ARG_CHECKED(JSFunction, function, 0);
   function->shared()->set_disable_optimization_reason(
       kOptimizationDisabledForTest);
   function->shared()->set_optimization_disabled(true);
   return isolate->heap()->undefined_value();
 }
 
+
 RUNTIME_FUNCTION(Runtime_GetOptimizationStatus) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1 || args.length() == 2);
-  int status = 0;
   if (!isolate->use_crankshaft()) {
-    status |= static_cast<int>(OptimizationStatus::kNeverOptimize);
-  }
-  if (FLAG_always_opt || FLAG_prepare_always_opt) {
-    status |= static_cast<int>(OptimizationStatus::kAlwaysOptimize);
-  }
-  if (FLAG_deopt_every_n_times) {
-    status |= static_cast<int>(OptimizationStatus::kMaybeDeopted);
+    return Smi::FromInt(4);  // 4 == "never".
   }
 
   // This function is used by fuzzers to get coverage for optimizations
   // in compiler. Ignore calls on non-function objects to avoid runtime errors.
   CONVERT_ARG_HANDLE_CHECKED(Object, function_object, 0);
   if (!function_object->IsJSFunction()) {
-    return Smi::FromInt(status);
+    return isolate->heap()->undefined_value();
   }
   Handle<JSFunction> function = Handle<JSFunction>::cast(function_object);
-  status |= static_cast<int>(OptimizationStatus::kIsFunction);
 
   bool sync_with_compiler_thread = true;
   if (args.length() == 2) {
     CONVERT_ARG_HANDLE_CHECKED(Object, sync_object, 1);
     if (!sync_object->IsString()) return isolate->heap()->undefined_value();
     Handle<String> sync = Handle<String>::cast(sync_object);
     if (sync->IsOneByteEqualTo(STATIC_CHAR_VECTOR("no sync"))) {
       sync_with_compiler_thread = false;
     }
   }
 
   if (isolate->concurrent_recompilation_enabled() &&
       sync_with_compiler_thread) {
     while (function->IsInOptimizationQueue()) {
       isolate->optimizing_compile_dispatcher()->InstallOptimizedFunctions();
       base::OS::Sleep(base::TimeDelta::FromMilliseconds(50));
     }
   }
-  if (function->IsOptimized()) {
-    status |= static_cast<int>(OptimizationStatus::kOptimized);
-    if (function->code()->is_turbofanned()) {
-      status |= static_cast<int>(OptimizationStatus::kTurboFanned);
-    }
+  if (FLAG_always_opt || FLAG_prepare_always_opt) {
+    // With --always-opt, optimization status expectations might not
+    // match up, so just return a sentinel.
+    return Smi::FromInt(3);  // 3 == "always".
+  }
+  if (FLAG_deopt_every_n_times) {
+    return Smi::FromInt(6);  // 6 == "maybe deopted".
+  }
+  if (function->IsOptimized() && function->code()->is_turbofanned()) {
+    return Smi::FromInt(7);  // 7 == "TurboFan compiler".
   }
   if (function->IsInterpreted()) {
-    status |= static_cast<int>(OptimizationStatus::kInterpreted);
+    return Smi::FromInt(8);  // 8 == "Interpreted".
   }
-  return Smi::FromInt(status);
+  return function->IsOptimized() ? Smi::FromInt(1)   // 1 == "yes".
+                                 : Smi::FromInt(2);  // 2 == "no".
 }
 
 
 RUNTIME_FUNCTION(Runtime_UnblockConcurrentRecompilation) {
   DCHECK_EQ(0, args.length());
   if (FLAG_block_concurrent_recompilation &&
       isolate->concurrent_recompilation_enabled()) {
     isolate->optimizing_compile_dispatcher()->Unblock();
   }
   return isolate->heap()->undefined_value();
@@ skipping 557 matching lines @@
     CHECK(HeapObject::cast(*object)->map()->IsMap());
   } else {
     CHECK(object->IsSmi());
   }
 #endif
   return isolate->heap()->ToBoolean(true);
 }
 
 }  // namespace internal
 }  // namespace v8