Refactor bailout reasons and disable optimization in more cases.

src/lithium.cc

 // Copyright 2012 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/v8.h"
 
+#include "src/bailout-reason.h"

[Jakob Kummerow, 2014/09/23 16:21:00]

This shouldn't be necessary as lithium.h includes it already.

[Sven Panne, 2014/09/24 06:00:19]

IWYU...

 #include "src/lithium.h"
 #include "src/scopes.h"
 #include "src/serialize.h"
 
 #if V8_TARGET_ARCH_IA32
 #include "src/ia32/lithium-ia32.h"  // NOLINT
 #include "src/ia32/lithium-codegen-ia32.h"  // NOLINT
 #elif V8_TARGET_ARCH_X64
 #include "src/x64/lithium-x64.h"  // NOLINT
 #include "src/x64/lithium-codegen-x64.h"  // NOLINT
@@ skipping 413 matching lines @@
 }
 
 
 LChunk* LChunk::NewChunk(HGraph* graph) {
   DisallowHandleAllocation no_handles;
   DisallowHeapAllocation no_gc;
   graph->DisallowAddingNewValues();
   int values = graph->GetMaximumValueID();
   CompilationInfo* info = graph->info();
   if (values > LUnallocated::kMaxVirtualRegisters) {
-    info->set_bailout_reason(kNotEnoughVirtualRegistersForValues);
+    info->AbortOptimization(kNotEnoughVirtualRegistersForValues);
     return NULL;
   }
   LAllocator allocator(values, graph);
   LChunkBuilder builder(info, graph, &allocator);
   LChunk* chunk = builder.Build();
   if (chunk == NULL) return NULL;
 
   if (!allocator.Allocate(chunk)) {
-    info->set_bailout_reason(kNotEnoughVirtualRegistersRegalloc);
+    info->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
     return NULL;
   }
 
   chunk->set_allocated_double_registers(
       allocator.assigned_double_registers());
 
   return chunk;
 }
 
 
@@ skipping 43 matching lines @@
         spill_slot_count_ += 2;
       } else {
         spill_slot_count_++;
       }
     }
     iterator.Advance();
   }
 }
 
 
+void LChunkBuilderBase::Abort(BailoutReason reason) {
+  info()->AbortOptimization(reason);
+  status_ = ABORTED;
+}
+
+
+void LChunkBuilderBase::Retry(BailoutReason reason) {
+  info()->RetryOptimization(reason);
+  status_ = ABORTED;
+}
+
+
 LEnvironment* LChunkBuilderBase::CreateEnvironment(
     HEnvironment* hydrogen_env, int* argument_index_accumulator,
     ZoneList<HValue*>* objects_to_materialize) {
   if (hydrogen_env == NULL) return NULL;
 
   LEnvironment* outer =
       CreateEnvironment(hydrogen_env->outer(), argument_index_accumulator,
                         objects_to_materialize);
   BailoutId ast_id = hydrogen_env->ast_id();
   DCHECK(!ast_id.IsNone() ||
@@ skipping 126 matching lines @@
 
 
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 } }  // namespace v8::internal