[debugger] omit exception events for rethrown exceptions in async.

src/interpreter/bytecode-array-builder.cc

 // Copyright 2015 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/interpreter/bytecode-array-builder.h"
 
 #include "src/compiler.h"
 #include "src/globals.h"
 #include "src/interpreter/bytecode-array-writer.h"
 #include "src/interpreter/bytecode-dead-code-optimizer.h"
@@ skipping 12 matching lines @@
                                            FunctionLiteral* literal)
     : isolate_(isolate),
       zone_(zone),
       bytecode_generated_(false),
       constant_array_builder_(isolate, zone),
       handler_table_builder_(isolate, zone),
       return_seen_in_block_(false),
       parameter_count_(parameter_count),
       local_register_count_(locals_count),
       context_register_count_(context_count),
+      literal_(literal),
       temporary_allocator_(zone, fixed_register_count()),
       bytecode_array_writer_(isolate, zone, &constant_array_builder_),
       pipeline_(&bytecode_array_writer_) {
   DCHECK_GE(parameter_count_, 0);
   DCHECK_GE(context_register_count_, 0);
   DCHECK_GE(local_register_count_, 0);
 
   if (FLAG_ignition_deadcode) {
     pipeline_ = new (zone) BytecodeDeadCodeOptimizer(pipeline_);
   }
 
   if (FLAG_ignition_peephole) {
     pipeline_ = new (zone)
         BytecodePeepholeOptimizer(&constant_array_builder_, pipeline_);
   }
 
   if (FLAG_ignition_reo) {
     pipeline_ = new (zone) BytecodeRegisterOptimizer(
         zone, &temporary_allocator_, parameter_count, pipeline_);
   }
-
-  return_position_ =
-      literal ? std::max(literal->start_position(), literal->end_position() - 1)
-              : kNoSourcePosition;
 }
 
 Register BytecodeArrayBuilder::first_context_register() const {
   DCHECK_GT(context_register_count_, 0);
   return Register(local_register_count_);
 }
 
 Register BytecodeArrayBuilder::last_context_register() const {
   DCHECK_GT(context_register_count_, 0);
   return Register(local_register_count_ + context_register_count_ - 1);
@@ skipping 558 matching lines @@
                                                    LanguageMode language_mode) {
   Output(BytecodeForDelete(language_mode), RegisterOperand(object));
   return *this;
 }
 
 size_t BytecodeArrayBuilder::GetConstantPoolEntry(Handle<Object> object) {
   return constant_array_builder()->Insert(object);
 }
 
 void BytecodeArrayBuilder::SetReturnPosition() {
-  if (return_position_ == kNoSourcePosition) return;
-  latest_source_info_.MakeStatementPosition(return_position_);
+  if (literal_ == nullptr) return;
+  int position =
+      std::max(literal_->start_position(), literal_->end_position() - 1);
+  latest_source_info_.MakeStatementPosition(position);

[Dan Ehrenberg, 2016/07/07 00:25:41]

What does this change have to do with the other part?

[Yang, 2016/07/07 04:00:47]

Since we now store the function literal anyways, we don't need to compute the
return position upfront anymore.

 }
 
 void BytecodeArrayBuilder::SetStatementPosition(Statement* stmt) {
   if (stmt->position() == kNoSourcePosition) return;
   latest_source_info_.MakeStatementPosition(stmt->position());
 }
 
 void BytecodeArrayBuilder::SetExpressionPosition(Expression* expr) {
   if (expr->position() == kNoSourcePosition) return;
   if (!latest_source_info_.is_statement()) {
@@ skipping 284 matching lines @@
       return Bytecode::kTailCall;
     default:
       UNREACHABLE();
   }
   return Bytecode::kIllegal;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8