[debug] use catch prediction flag for promise rejections.

src/full-codegen/full-codegen.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/full-codegen/full-codegen.h"
 
 #include "src/ast/ast-numbering.h"
 #include "src/ast/ast.h"
 #include "src/ast/prettyprinter.h"
 #include "src/ast/scopeinfo.h"
@@ skipping 107 matching lines @@
   code->set_type_feedback_info(*info);
 }
 
 
 void FullCodeGenerator::PopulateHandlerTable(Handle<Code> code) {
   int handler_table_size = static_cast<int>(handler_table_.size());
   Handle<HandlerTable> table =
       Handle<HandlerTable>::cast(isolate()->factory()->NewFixedArray(
           HandlerTable::LengthForRange(handler_table_size), TENURED));
   for (int i = 0; i < handler_table_size; ++i) {
-    HandlerTable::CatchPrediction prediction = handler_table_[i].catch_predicted
-                                                   ? HandlerTable::CAUGHT
-                                                   : HandlerTable::UNCAUGHT;
     table->SetRangeStart(i, handler_table_[i].range_start);
     table->SetRangeEnd(i, handler_table_[i].range_end);
-    table->SetRangeHandler(i, handler_table_[i].handler_offset, prediction);
+    table->SetRangeHandler(i, handler_table_[i].handler_offset,
+                           handler_table_[i].catch_prediction);
     table->SetRangeData(i, handler_table_[i].stack_depth);
   }
   code->set_handler_table(*table);
 }
 
 
 int FullCodeGenerator::NewHandlerTableEntry() {
   int index = static_cast<int>(handler_table_.size());
-  HandlerTableEntry entry = {0, 0, 0, 0, 0};
+  HandlerTableEntry entry = {0, 0, 0, 0, HandlerTable::UNCAUGHT};
   handler_table_.push_back(entry);
   return index;
 }
 
 
 bool FullCodeGenerator::MustCreateObjectLiteralWithRuntime(
     ObjectLiteral* expr) const {
   return masm()->serializer_enabled() ||
          !FastCloneShallowObjectStub::IsSupported(expr);
 }
@@ skipping 1135 matching lines @@
   // Restore the context.
   LoadContextField(context_register(), Context::PREVIOUS_INDEX);
   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
   scope_ = saved_scope;
   __ jmp(&exit);
 
   // Try block code. Sets up the exception handler chain.
   __ bind(&try_entry);
 
   int handler_index = NewHandlerTableEntry();
-  EnterTryBlock(handler_index, &handler_entry, stmt->catch_predicted());
+  EnterTryBlock(handler_index, &handler_entry, stmt->catch_prediction());
   {
     Comment cmnt_try(masm(), "[ Try block");
     Visit(stmt->try_block());
   }
   ExitTryBlock(handler_index);
   __ bind(&exit);
 }
 
 
 void FullCodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* stmt) {
@@ skipping 28 matching lines @@
   // Exception handler code.  This code is only executed when an exception
   // is thrown.  Record the continuation and jump to the finally block.
   {
     Comment cmnt_handler(masm(), "[ Finally handler");
     deferred.RecordThrow();
   }
 
   // Set up try handler.
   __ bind(&try_entry);
   int handler_index = NewHandlerTableEntry();
-  EnterTryBlock(handler_index, &handler_entry, stmt->catch_predicted());
+  EnterTryBlock(handler_index, &handler_entry, stmt->catch_prediction());
   {
     Comment cmnt_try(masm(), "[ Try block");
     TryFinally try_body(this, &deferred);
     Visit(stmt->try_block());
   }
   ExitTryBlock(handler_index);
   // Execute the finally block on the way out.  Clobber the unpredictable
   // value in the result register with one that's safe for GC because the
   // finally block will unconditionally preserve the result register on the
   // stack.
@@ skipping 162 matching lines @@
   VisitForStackValue(expr->exception());
   SetExpressionPosition(expr);
   CallRuntimeWithOperands(Runtime::kThrow);
   // Never returns here.
 
   // Even though this expression doesn't produce a value, we need to simulate
   // plugging of the value context to ensure stack depth tracking is in sync.
   if (context()->IsStackValue()) OperandStackDepthIncrement(1);
 }
 
-void FullCodeGenerator::EnterTryBlock(int handler_index, Label* handler,
-                                      bool catch_predicted) {
+void FullCodeGenerator::EnterTryBlock(
+    int handler_index, Label* handler,
+    HandlerTable::CatchPrediction catch_prediction) {
   HandlerTableEntry* entry = &handler_table_[handler_index];
   entry->range_start = masm()->pc_offset();
   entry->handler_offset = handler->pos();
   entry->stack_depth = operand_stack_depth_;
-  entry->catch_predicted = catch_predicted;
+  entry->catch_prediction = catch_prediction;
 
   // We are using the operand stack depth, check for accuracy.
   EmitOperandStackDepthCheck();
 
   // Push context onto operand stack.
   STATIC_ASSERT(TryBlockConstant::kElementCount == 1);
   PushOperand(context_register());
 }
 
 
@@ skipping 391 matching lines @@
   return var->scope()->is_nonlinear() ||
          var->initializer_position() >= proxy->position();
 }
 
 
 #undef __
 
 
 }  // namespace internal
 }  // namespace v8