diff --git a/build.js b/build.js
index 2206b0f57dd0fe..40c0bf80a67113 100644
--- a/build.js
+++ b/build.js
@@ -6,8 +6,8 @@ const node = __dirname;
 // Download the record/replay driver archive, using the latest version unless
 //it was overridden via the environment.
 let driverArchive = `${currentPlatform()}-recordreplay.tgz`;
-let driverRevision = process.env.DRIVER_REVISION ? process.env.DRIVER_REVISION : fs.readFileSync("REPLAY_BACKEND_REV", "utf8");
-let downloadArchive = `${currentPlatform()}-recordreplay-${driverRevision.trim().substring(0,12)}.tgz`;
+let downloadDriverRevision = process.env.DRIVER_REVISION ? process.env.DRIVER_REVISION : fs.readFileSync("REPLAY_BACKEND_REV", "utf8");
+let downloadArchive = `${currentPlatform()}-recordreplay-${downloadDriverRevision.trim().substring(0,12)}.tgz`;
 const driverFile = `${currentPlatform()}-recordreplay.${driverExtension()}`;
 const driverJSON = `${currentPlatform()}-recordreplay.json`;
 spawnChecked("curl", [`https://static.replay.io/downloads/${downloadArchive}`, "-o", driverArchive], { stdio: "inherit" });
diff --git a/deps/v8/src/ast/ast.h b/deps/v8/src/ast/ast.h
index 0b2320860e56a5..e56e7dfdec182c 100644
--- a/deps/v8/src/ast/ast.h
+++ b/deps/v8/src/ast/ast.h
@@ -34,7 +34,6 @@ namespace internal {
 // allocation and constant-time deallocation of the entire syntax
 // tree.
 
-
 // ----------------------------------------------------------------------------
 // Nodes of the abstract syntax tree. Only concrete classes are
 // enumerated here.
@@ -111,9 +110,9 @@ namespace internal {
 
 #define FAILURE_NODE_LIST(V) V(FailureExpression)
 
-#define AST_NODE_LIST(V)                        \
-  DECLARATION_NODE_LIST(V)                      \
-  STATEMENT_NODE_LIST(V)                        \
+#define AST_NODE_LIST(V)   \
+  DECLARATION_NODE_LIST(V) \
+  STATEMENT_NODE_LIST(V)   \
   EXPRESSION_NODE_LIST(V)
 
 // Forward declarations
@@ -135,7 +134,7 @@ AST_NODE_LIST(DEF_FORWARD_DECLARATION)
 FAILURE_NODE_LIST(DEF_FORWARD_DECLARATION)
 #undef DEF_FORWARD_DECLARATION
 
-class AstNode: public ZoneObject {
+class AstNode : public ZoneObject {
  public:
 #define DECLARE_TYPE_ENUM(type) k##type,
   enum NodeType : uint8_t {
@@ -177,13 +176,11 @@ class AstNode: public ZoneObject {
       : position_(position), bit_field_(NodeTypeField::encode(type)) {}
 };
 
-
 class Statement : public AstNode {
  protected:
   Statement(int position, NodeType type) : AstNode(position, type) {}
 };
 
-
 class Expression : public AstNode {
  public:
   enum Context {
@@ -424,7 +421,6 @@ class FunctionDeclaration final : public Declaration {
   FunctionLiteral* fun_;
 };
 
-
 class IterationStatement : public BreakableStatement {
  public:
   Statement* body() const { return body_; }
@@ -439,7 +435,6 @@ class IterationStatement : public BreakableStatement {
   Statement* body_;
 };
 
-
 class DoWhileStatement final : public IterationStatement {
  public:
   void Initialize(Expression* cond, Statement* body) {
@@ -459,7 +454,6 @@ class DoWhileStatement final : public IterationStatement {
   Expression* cond_;
 };
 
-
 class WhileStatement final : public IterationStatement {
  public:
   void Initialize(Expression* cond, Statement* body) {
@@ -479,7 +473,6 @@ class WhileStatement final : public IterationStatement {
   Expression* cond_;
 };
 
-
 class ForStatement final : public IterationStatement {
  public:
   void Initialize(Statement* init, Expression* cond, Statement* next,
@@ -513,8 +506,8 @@ class ForStatement final : public IterationStatement {
 class ForEachStatement : public IterationStatement {
  public:
   enum VisitMode {
-    ENUMERATE,   // for (each in subject) body;
-    ITERATE      // for (each of subject) body;
+    ENUMERATE,  // for (each in subject) body;
+    ITERATE     // for (each of subject) body;
   };
 
   using IterationStatement::Initialize;
@@ -581,13 +574,11 @@ class ExpressionStatement final : public Statement {
   Expression* expression_;
 };
 
-
 class JumpStatement : public Statement {
  protected:
   JumpStatement(int pos, NodeType type) : Statement(pos, type) {}
 };
 
-
 class ContinueStatement final : public JumpStatement {
  public:
   IterationStatement* target() const { return target_; }
@@ -602,7 +593,6 @@ class ContinueStatement final : public JumpStatement {
   IterationStatement* target_;
 };
 
-
 class BreakStatement final : public JumpStatement {
  public:
   BreakableStatement* target() const { return target_; }
@@ -617,7 +607,6 @@ class BreakStatement final : public JumpStatement {
   BreakableStatement* target_;
 };
 
-
 class ReturnStatement final : public JumpStatement {
  public:
   enum Type { kNormal, kAsyncReturn, kSyntheticAsyncReturn };
@@ -653,7 +642,6 @@ class ReturnStatement final : public JumpStatement {
   using TypeField = JumpStatement::NextBitField<Type, 2>;
 };
 
-
 class WithStatement final : public Statement {
  public:
   Scope* scope() { return scope_; }
@@ -697,7 +685,6 @@ class CaseClause final : public ZoneObject {
   ZonePtrList<Statement> statements_;
 };
 
-
 class SwitchStatement final : public BreakableStatement {
  public:
   Expression* tag() const { return tag_; }
@@ -716,7 +703,6 @@ class SwitchStatement final : public BreakableStatement {
   ZonePtrList<CaseClause> cases_;
 };
 
-
 // If-statements always have non-null references to their then- and
 // else-parts. When parsing if-statements with no explicit else-part,
 // the parser implicitly creates an empty statement. Use the
@@ -750,7 +736,6 @@ class IfStatement final : public Statement {
   Statement* else_statement_;
 };
 
-
 class TryStatement : public Statement {
  public:
   Block* try_block() const { return try_block_; }
@@ -764,7 +749,6 @@ class TryStatement : public Statement {
   Block* try_block_;
 };
 
-
 class TryCatchStatement final : public TryStatement {
  public:
   Scope* scope() { return scope_; }
@@ -848,7 +832,6 @@ class TryCatchStatement final : public TryStatement {
   HandlerTable::CatchPrediction catch_prediction_;
 };
 
-
 class TryFinallyStatement final : public TryStatement {
  public:
   Block* finally_block() const { return finally_block_; }
@@ -865,7 +848,6 @@ class TryFinallyStatement final : public TryStatement {
   Block* finally_block_;
 };
 
-
 class DebuggerStatement final : public Statement {
  private:
   friend class AstNodeFactory;
@@ -874,7 +856,6 @@ class DebuggerStatement final : public Statement {
   explicit DebuggerStatement(int pos) : Statement(pos, kDebuggerStatement) {}
 };
 
-
 class EmptyStatement final : public Statement {
  private:
   friend class AstNodeFactory;
@@ -882,7 +863,6 @@ class EmptyStatement final : public Statement {
   EmptyStatement() : Statement(kNoSourcePosition, kEmptyStatement) {}
 };
 
-
 // Delegates to another statement, which may be overwritten.
 // This was introduced to implement ES2015 Annex B3.3 for conditionally making
 // sloppy-mode block-scoped functions have a var binding, which is changed
@@ -917,7 +897,6 @@ class SloppyBlockFunctionStatement final : public Statement {
   SloppyBlockFunctionStatement* next_;
 };
 
-
 class Literal final : public Expression {
  public:
   enum Type {
@@ -1631,13 +1610,16 @@ class CallBase : public Expression {
   SpreadPosition spread_position() const {
     return SpreadPositionField::decode(bit_field_);
   }
+  int call_head_token_position() const { return call_head_token_position_; }
 
  protected:
   CallBase(Zone* zone, NodeType type, Expression* expression,
-           const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
+           const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
+           int call_head_token_position)
       : Expression(pos, type),
         expression_(expression),
-        arguments_(arguments.ToConstVector(), zone) {
+        arguments_(arguments.ToConstVector(), zone),
+        call_head_token_position_(call_head_token_position) {
     DCHECK(type == kCall || type == kCallNew);
     if (has_spread) {
       ComputeSpreadPosition();
@@ -1656,6 +1638,7 @@ class CallBase : public Expression {
 
   Expression* expression_;
   ZonePtrList<Expression> arguments_;
+  int call_head_token_position_;
 };
 
 class Call final : public CallBase {
@@ -1703,8 +1686,10 @@ class Call final : public CallBase {
 
   Call(Zone* zone, Expression* expression,
        const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
-       PossiblyEval possibly_eval, bool optional_chain)
-      : CallBase(zone, kCall, expression, arguments, pos, has_spread) {
+       int call_head_token_position, PossiblyEval possibly_eval,
+       bool optional_chain)
+      : CallBase(zone, kCall, expression, arguments, pos, has_spread,
+                 call_head_token_position) {
     bit_field_ |=
         IsPossiblyEvalField::encode(possibly_eval == IS_POSSIBLY_EVAL) |
         IsTaggedTemplateField::encode(false) |
@@ -1713,8 +1698,9 @@ class Call final : public CallBase {
 
   Call(Zone* zone, Expression* expression,
        const ScopedPtrList<Expression>& arguments, int pos,
-       TaggedTemplateTag tag)
-      : CallBase(zone, kCall, expression, arguments, pos, false) {
+       TaggedTemplateTag tag, int call_head_token_position)
+      : CallBase(zone, kCall, expression, arguments, pos, false,
+                 call_head_token_position) {
     bit_field_ |= IsPossiblyEvalField::encode(false) |
                   IsTaggedTemplateField::encode(true) |
                   IsOptionalChainLinkField::encode(false);
@@ -1731,8 +1717,10 @@ class CallNew final : public CallBase {
   friend Zone;
 
   CallNew(Zone* zone, Expression* expression,
-          const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
-      : CallBase(zone, kCallNew, expression, arguments, pos, has_spread) {}
+          const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
+          int call_head_token_position)
+      : CallBase(zone, kCallNew, expression, arguments, pos, has_spread,
+                 call_head_token_position) {}
 };
 
 // The CallRuntime class does not represent any official JavaScript
@@ -1776,7 +1764,6 @@ class CallRuntime final : public Expression {
   ZonePtrList<Expression> arguments_;
 };
 
-
 class UnaryOperation final : public Expression {
  public:
   Token::Value op() const { return OperatorField::decode(bit_field_); }
@@ -1797,7 +1784,6 @@ class UnaryOperation final : public Expression {
   using OperatorField = Expression::NextBitField<Token::Value, 7>;
 };
 
-
 class BinaryOperation final : public Expression {
  public:
   Token::Value op() const { return OperatorField::decode(bit_field_); }
@@ -1908,7 +1894,6 @@ class CountOperation final : public Expression {
   Expression* expression_;
 };
 
-
 class CompareOperation final : public Expression {
  public:
   Token::Value op() const { return OperatorField::decode(bit_field_); }
@@ -1937,7 +1922,6 @@ class CompareOperation final : public Expression {
   using OperatorField = Expression::NextBitField<Token::Value, 7>;
 };
 
-
 class Spread final : public Expression {
  public:
   Expression* expression() const { return expression_; }
@@ -2109,7 +2093,6 @@ class Throw final : public Expression {
   Expression* exception_;
 };
 
-
 class FunctionLiteral final : public Expression {
  public:
   enum ParameterFlag : uint8_t {
@@ -2523,7 +2506,6 @@ class ClassLiteral final : public Expression {
   Variable* static_home_object_;
 };
 
-
 class NativeFunctionLiteral final : public Expression {
  public:
   Handle<String> name() const { return name_->string(); }
@@ -2544,7 +2526,6 @@ class NativeFunctionLiteral final : public Expression {
   v8::Extension* extension_;
 };
 
-
 class SuperPropertyReference final : public Expression {
  public:
   VariableProxy* home_object() const { return home_object_; }
@@ -2559,7 +2540,6 @@ class SuperPropertyReference final : public Expression {
   VariableProxy* home_object_;
 };
 
-
 class SuperCallReference final : public Expression {
  public:
   VariableProxy* new_target_var() const { return new_target_var_; }
@@ -2707,8 +2687,8 @@ class AstVisitor {
   Subclass* impl() { return static_cast<Subclass*>(this); }
 };
 
-#define GENERATE_VISIT_CASE(NodeType)                                   \
-  case AstNode::k##NodeType:                                            \
+#define GENERATE_VISIT_CASE(NodeType) \
+  case AstNode::k##NodeType:          \
     return this->impl()->Visit##NodeType(static_cast<NodeType*>(node));
 
 #define GENERATE_FAILURE_CASE(NodeType) \
@@ -2871,10 +2851,8 @@ class AstNodeFactory final {
         expression, ReturnStatement::kSyntheticAsyncReturn, pos, end_position);
   }
 
-  WithStatement* NewWithStatement(Scope* scope,
-                                  Expression* expression,
-                                  Statement* statement,
-                                  int pos) {
+  WithStatement* NewWithStatement(Scope* scope, Expression* expression,
+                                  Statement* statement, int pos) {
     return zone_->New<WithStatement>(scope, expression, statement, pos);
   }
 
@@ -2923,9 +2901,7 @@ class AstNodeFactory final {
     return zone_->New<DebuggerStatement>(pos);
   }
 
-  class EmptyStatement* EmptyStatement() {
-    return empty_statement_;
-  }
+  class EmptyStatement* EmptyStatement() { return empty_statement_; }
 
   class ThisExpression* ThisExpression() {
     // Clear any previously set "parenthesized" flag on this_expression_ so this
@@ -2943,9 +2919,7 @@ class AstNodeFactory final {
     return zone_->New<class ThisExpression>(pos);
   }
 
-  class FailureExpression* FailureExpression() {
-    return failure_expression_;
-  }
+  class FailureExpression* FailureExpression() { return failure_expression_; }
 
   SloppyBlockFunctionStatement* NewSloppyBlockFunctionStatement(
       int pos, Variable* var, Token::Value init) {
@@ -3058,24 +3032,28 @@ class AstNodeFactory final {
 
   Call* NewCall(Expression* expression,
                 const ScopedPtrList<Expression>& arguments, int pos,
-                bool has_spread,
+                bool has_spread, int call_head_token_position = 0,
                 Call::PossiblyEval possibly_eval = Call::NOT_EVAL,
                 bool optional_chain = false) {
     DCHECK_IMPLIES(possibly_eval == Call::IS_POSSIBLY_EVAL, !optional_chain);
     return zone_->New<Call>(zone_, expression, arguments, pos, has_spread,
-                            possibly_eval, optional_chain);
+                            call_head_token_position, possibly_eval,
+                            optional_chain);
   }
 
   Call* NewTaggedTemplate(Expression* expression,
-                          const ScopedPtrList<Expression>& arguments, int pos) {
+                          const ScopedPtrList<Expression>& arguments, int pos,
+                          int call_head_token_position) {
     return zone_->New<Call>(zone_, expression, arguments, pos,
-                            Call::TaggedTemplateTag::kTrue);
+                            Call::TaggedTemplateTag::kTrue,
+                            call_head_token_position);
   }
 
   CallNew* NewCallNew(Expression* expression,
                       const ScopedPtrList<Expression>& arguments, int pos,
-                      bool has_spread) {
-    return zone_->New<CallNew>(zone_, expression, arguments, pos, has_spread);
+                      bool has_spread, int call_head_token_position = 0) {
+    return zone_->New<CallNew>(zone_, expression, arguments, pos, has_spread,
+                               call_head_token_position);
   }
 
   CallRuntime* NewCallRuntime(Runtime::FunctionId id,
@@ -3097,16 +3075,13 @@ class AstNodeFactory final {
     return zone_->New<CallRuntime>(zone_, context_index, arguments, pos);
   }
 
-  UnaryOperation* NewUnaryOperation(Token::Value op,
-                                    Expression* expression,
+  UnaryOperation* NewUnaryOperation(Token::Value op, Expression* expression,
                                     int pos) {
     return zone_->New<UnaryOperation>(op, expression, pos);
   }
 
-  BinaryOperation* NewBinaryOperation(Token::Value op,
-                                      Expression* left,
-                                      Expression* right,
-                                      int pos) {
+  BinaryOperation* NewBinaryOperation(Token::Value op, Expression* left,
+                                      Expression* right, int pos) {
     return zone_->New<BinaryOperation>(op, left, right, pos);
   }
 
@@ -3115,17 +3090,13 @@ class AstNodeFactory final {
     return zone_->New<NaryOperation>(zone_, op, first, initial_subsequent_size);
   }
 
-  CountOperation* NewCountOperation(Token::Value op,
-                                    bool is_prefix,
-                                    Expression* expr,
-                                    int pos) {
+  CountOperation* NewCountOperation(Token::Value op, bool is_prefix,
+                                    Expression* expr, int pos) {
     return zone_->New<CountOperation>(op, is_prefix, expr, pos);
   }
 
-  CompareOperation* NewCompareOperation(Token::Value op,
-                                        Expression* left,
-                                        Expression* right,
-                                        int pos) {
+  CompareOperation* NewCompareOperation(Token::Value op, Expression* left,
+                                        Expression* right, int pos) {
     return zone_->New<CompareOperation>(op, left, right, pos);
   }
 
@@ -3135,16 +3106,13 @@ class AstNodeFactory final {
 
   Conditional* NewConditional(Expression* condition,
                               Expression* then_expression,
-                              Expression* else_expression,
-                              int position) {
+                              Expression* else_expression, int position) {
     return zone_->New<Conditional>(condition, then_expression, else_expression,
                                    position);
   }
 
-  Assignment* NewAssignment(Token::Value op,
-                            Expression* target,
-                            Expression* value,
-                            int pos) {
+  Assignment* NewAssignment(Token::Value op, Expression* target,
+                            Expression* value, int pos) {
     DCHECK(Token::IsAssignmentOp(op));
     DCHECK_NOT_NULL(target);
     DCHECK_NOT_NULL(value);
@@ -3318,7 +3286,6 @@ class AstNodeFactory final {
   class FailureExpression* failure_expression_;
 };
 
-
 // Type testing & conversion functions overridden by concrete subclasses.
 // Inline functions for AstNode.
 
diff --git a/deps/v8/src/interpreter/bytecode-array-builder.cc b/deps/v8/src/interpreter/bytecode-array-builder.cc
index 33e2b01225b3ed..939805421b74c4 100644
--- a/deps/v8/src/interpreter/bytecode-array-builder.cc
+++ b/deps/v8/src/interpreter/bytecode-array-builder.cc
@@ -19,7 +19,8 @@
 namespace v8 {
 namespace internal {
 
-extern int RegisterAssertValueSite(const std::string& desc, int source_position);
+extern int RegisterAssertValueSite(const std::string& desc,
+                                   int source_position);
 extern int RegisterInstrumentationSite(const char* kind, int source_position,
                                        int bytecode_offset);
 extern bool gRecordReplayAssertValues;
@@ -48,8 +49,7 @@ class RegisterTransferWriter final
 
 BytecodeArrayBuilder::BytecodeArrayBuilder(
     Zone* zone, int parameter_count, int locals_count,
-    bool record_replay_ignore,
-    FeedbackVectorSpec* feedback_vector_spec,
+    bool record_replay_ignore, FeedbackVectorSpec* feedback_vector_spec,
     SourcePositionTableBuilder::RecordingMode source_position_mode)
     : zone_(zone),
       feedback_vector_spec_(feedback_vector_spec),
@@ -71,7 +71,8 @@ BytecodeArrayBuilder::BytecodeArrayBuilder(
         zone->New<RegisterTransferWriter>(this));
   }
 
-  if (recordreplay::IsRecordingOrReplaying() && IsMainThread() && !record_replay_ignore) {
+  if (recordreplay::IsRecordingOrReplaying() && IsMainThread() &&
+      !record_replay_ignore) {
     emit_record_replay_opcodes_ = true;
   }
 }
@@ -846,7 +847,8 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::LoadNamedProperty(
     Register object, const AstRawString* name, int feedback_slot) {
   size_t name_index = GetConstantPoolEntry(name);
   OutputLdaNamedProperty(object, name_index, feedback_slot);
-  RecordReplayAssertValue(std::string("LoadNamedProperty ") + name->to_string());
+  RecordReplayAssertValue(std::string("LoadNamedProperty ") +
+                          name->to_string());
   return *this;
 }
 
@@ -917,7 +919,8 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedProperty(
 
 BytecodeArrayBuilder& BytecodeArrayBuilder::StoreNamedOwnProperty(
     Register object, const AstRawString* name, int feedback_slot) {
-  RecordReplayAssertValue(std::string("StoreNamedOwnProperty " + name->to_string()));
+  RecordReplayAssertValue(
+      std::string("StoreNamedOwnProperty " + name->to_string()));
   size_t name_index = GetConstantPoolEntry(name);
   // Ensure that the store operation is in sync with the IC slot kind.
   DCHECK_EQ(
@@ -1351,14 +1354,16 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::IncBlockCounter(
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayIncExecutionProgressCounter() {
+BytecodeArrayBuilder&
+BytecodeArrayBuilder::RecordReplayIncExecutionProgressCounter() {
   if (emit_record_replay_opcodes_) {
     OutputRecordReplayIncExecutionProgressCounter();
   }
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayAssertValue(const std::string& desc) {
+BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayAssertValue(
+    const std::string& desc) {
   if (emit_record_replay_opcodes_ && gRecordReplayAssertValues) {
     int index = RegisterAssertValueSite(desc, most_recent_source_position_);
     OutputRecordReplayAssertValue(index);
@@ -1366,25 +1371,48 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayAssertValue(const std::s
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayInstrumentation(const char* kind,
-                                                                        int source_position) {
+int BytecodeArrayBuilder::RecordReplayRegisterInstrumentationSite(
+    const char* kind, int source_position) {
+  if (!strcmp(kind, "breakpoint") && source_position != kNoSourcePosition &&
+      record_replay_instrumentation_site_locations_.find(source_position) !=
+          record_replay_instrumentation_site_locations_.end()) {
+    // Don't insert a breakpoint at the same location more than once.
+    return -1;
+  }
+  record_replay_instrumentation_site_locations_.insert(source_position);
+
+  // Chromium's v8 uses function_index since:
+  // https://github.com/replayio/chromium-v8/pull/222
+  int bytecode_offset = bytecode_array_writer_.size();
+  return RegisterInstrumentationSite(kind, source_position, bytecode_offset);
+}
+
+bool BytecodeArrayBuilder::EmitRecordReplayInstrumentationOpcodes() const {
   // Instrumentation opcodes aren't needed when recording.
-  if (emit_record_replay_opcodes_ && recordreplay::IsReplaying()) {
-    int bytecode_offset = bytecode_array_writer_.size();
-    int index = RegisterInstrumentationSite(kind, source_position, bytecode_offset);
-    OutputRecordReplayInstrumentation(index);
+  return emit_record_replay_opcodes_ && recordreplay::IsReplaying();
+}
+
+BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayInstrumentation(
+    const char* kind, int source_position) {
+  if (EmitRecordReplayInstrumentationOpcodes()) {
+    int index = RecordReplayRegisterInstrumentationSite(kind, source_position);
+    if (index >= 0) {
+      OutputRecordReplayInstrumentation(index);
+    }
   }
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::RecordReplayInstrumentationGenerator(
+BytecodeArrayBuilder&
+BytecodeArrayBuilder::RecordReplayInstrumentationGenerator(
     const char* kind, Register generator_object) {
   // Even though instrumentation opcodes aren't needed when recording, we still
   // need to emit InstrumentationGenerator opcodes so that generator objects
   // will be associated with IDs at consistent points.
   if (emit_record_replay_opcodes_) {
     int bytecode_offset = bytecode_array_writer_.size();
-    int index = RegisterInstrumentationSite(kind, kNoSourcePosition, bytecode_offset);
+    int index =
+        RegisterInstrumentationSite(kind, kNoSourcePosition, bytecode_offset);
     OutputRecordReplayInstrumentationGenerator(index, generator_object);
   }
   return *this;
diff --git a/deps/v8/src/interpreter/bytecode-array-builder.h b/deps/v8/src/interpreter/bytecode-array-builder.h
index b090a046e3c333..cf4f2ff583923a 100644
--- a/deps/v8/src/interpreter/bytecode-array-builder.h
+++ b/deps/v8/src/interpreter/bytecode-array-builder.h
@@ -454,10 +454,12 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final {
 
   BytecodeArrayBuilder& RecordReplayIncExecutionProgressCounter();
   BytecodeArrayBuilder& RecordReplayAssertValue(const std::string& desc);
-  BytecodeArrayBuilder& RecordReplayInstrumentation(const char* kind,
-                                                    int source_position = kNoSourcePosition);
-  BytecodeArrayBuilder& RecordReplayInstrumentationGenerator(const char* kind,
-                                                             Register generator_object);
+  int RecordReplayRegisterInstrumentationSite(const char* kind,
+                                              int source_position);
+  BytecodeArrayBuilder& RecordReplayInstrumentation(
+      const char* kind, int source_position = kNoSourcePosition);
+  BytecodeArrayBuilder& RecordReplayInstrumentationGenerator(
+      const char* kind, Register generator_object);
 
   // Complex flow control.
   BytecodeArrayBuilder& ForInEnumerate(Register receiver);
@@ -502,11 +504,13 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final {
 
   void InitializeReturnPosition(FunctionLiteral* literal);
 
-  void SetStatementPosition(Statement* stmt) {
-    SetStatementPosition(stmt->position());
+  void SetStatementPosition(Statement* stmt,
+                            bool record_replay_breakpoint = true) {
+    SetStatementPosition(stmt->position(), record_replay_breakpoint);
   }
 
-  void SetStatementPosition(int position, bool record_replay_breakpoint = true) {
+  void SetStatementPosition(int position,
+                            bool record_replay_breakpoint = true) {
     if (position == kNoSourcePosition) return;
     latest_source_info_.MakeStatementPosition(position);
     most_recent_source_position_ = position;
@@ -529,8 +533,9 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final {
     }
   }
 
-  void SetExpressionAsStatementPosition(Expression* expr) {
-    SetStatementPosition(expr->position());
+  void SetExpressionAsStatementPosition(Expression* expr,
+                                        bool record_replay_breakpoint = true) {
+    SetStatementPosition(expr->position(), record_replay_breakpoint);
   }
 
   bool RemainderOfBlockIsDead() const {
@@ -638,6 +643,9 @@ class V8_EXPORT_PRIVATE BytecodeArrayBuilder final {
   BytecodeSourceInfo deferred_source_info_;
   int most_recent_source_position_ = -1;
   bool emit_record_replay_opcodes_ = false;
+
+ public:
+  std::unordered_set<int> record_replay_instrumentation_site_locations_;
 };
 
 V8_EXPORT_PRIVATE std::ostream& operator<<(
diff --git a/deps/v8/src/interpreter/bytecode-generator.cc b/deps/v8/src/interpreter/bytecode-generator.cc
index fdecaa4751aeb1..de74e43d0d2871 100644
--- a/deps/v8/src/interpreter/bytecode-generator.cc
+++ b/deps/v8/src/interpreter/bytecode-generator.cc
@@ -1201,7 +1201,8 @@ template <typename IsolateT>
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(
     IsolateT* isolate, Handle<Script> script) {
   if (recordreplay::IsRecordingOrReplaying() && IsMainThread()) {
-    CHECK(info()->flags().record_replay_ignore() == RecordReplayIgnoreScript(*script));
+    CHECK(info()->flags().record_replay_ignore() ==
+          RecordReplayIgnoreScript(*script));
   }
 
   DCHECK_EQ(ThreadId::Current(), isolate->thread_id());
@@ -1446,11 +1447,13 @@ void BytecodeGenerator::GenerateBytecodeBody() {
     int num_parameters = closure_scope()->num_parameters();
     for (int i = 0; i < num_parameters; i++) {
       Register parameter(builder()->Parameter(i));
-      builder()->LoadAccumulatorWithRegister(parameter).RecordReplayAssertValue("Parameter");
+      builder()->LoadAccumulatorWithRegister(parameter).RecordReplayAssertValue(
+          "Parameter");
     }
 
     if (IsResumableFunction(literal->kind())) {
-      builder()->RecordReplayInstrumentationGenerator("generator", generator_object());
+      builder()->RecordReplayInstrumentationGenerator("generator",
+                                                      generator_object());
     } else {
       builder()->RecordReplayInstrumentation("main");
     }
@@ -1743,6 +1746,32 @@ void BytecodeGenerator::VisitStatements(
   }
 }
 
+void BytecodeGenerator::ReplayExpressionShiftedSetStatementPosition(
+    Statement* stmt, Expression* expr) {
+  builder()->SetStatementPosition(stmt, /* record_replay_breakpoint */ false);
+  if (expr->position() < 0) {
+    // expression is empty, so the breakpoint gets added at the statement itself
+    builder()->RecordReplayInstrumentation("breakpoint", stmt->position());
+  } else if (expr->IsBinaryOperation()) {
+    // given the breakpoint gets shifted to the expression (if that's available)
+    // by default we first check if it's not a binary operation, in which case
+    // we need to make sure the breakpoint is added at the position of the left
+    // operand this targets the case in which the binary operation's position is
+    // set to its right operand, see:
+    // https://github.com/v8/v8/commit/5bf9e470f8290dde983797e695e5156374d81962
+    // without this the pre-call-post-args breakpoint added by `VisitCall` would
+    // not be added as it would be treated as duplicate. without this
+    // specialcase the breakpoints would be added like this (3 would be
+    // skipped):
+    //
+    // return /*2*/foo(), /*1*//*3*/bar();
+    builder()->RecordReplayInstrumentation(
+        "breakpoint", expr->AsBinaryOperation()->left()->position());
+  } else {
+    builder()->RecordReplayInstrumentation("breakpoint", expr->position());
+  }
+}
+
 void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   builder()->SetStatementPosition(stmt);
   VisitForEffect(stmt->expression());
@@ -1802,7 +1831,7 @@ void BytecodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
 
 void BytecodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   AllocateBlockCoverageSlotIfEnabled(stmt, SourceRangeKind::kContinuation);
-  builder()->SetStatementPosition(stmt);
+  ReplayExpressionShiftedSetStatementPosition(stmt, stmt->expression());
   VisitForAccumulatorValue(stmt->expression());
   int return_position = stmt->end_position();
   if (return_position == ReturnStatement::kFunctionLiteralReturnPosition) {
@@ -5316,6 +5345,9 @@ void BytecodeGenerator::VisitCall(Call* expr) {
     return VisitCallSuper(expr);
   }
 
+  size_t start_locations_size =
+      builder()->record_replay_instrumentation_site_locations_.size();
+
   // We compile the call differently depending on the presence of spreads and
   // their positions.
   //
@@ -5504,6 +5536,39 @@ void BytecodeGenerator::VisitCall(Call* expr) {
 
   builder()->SetExpressionPosition(expr);
 
+  // Emit a breakpoint for all call expressions
+  // after arguments have already been evaluated.
+  // This might duplicate the call's parent's position,
+  // so we should try to have it get deduplicated
+  // by inserting it before the call, *if* there are no arguments.
+  //
+  // Example1 (potentially deduped breakpoint):
+  // `/*BREAK1*/func();
+  //
+  // Example2 (extra breakpoint after arguments evaluation):
+  // `/*BREAK1*/func/*BREAK3*/(/*BREAK2*/g());`
+
+  // TODO: Deduplicate property call locations
+  //       NOTE: In this case, `expr->position()` is different from the
+  //             `ExpressionStatement`'s position.
+  //       Example: `/*BREAK1*/o.func/*BREAK2*/();`
+
+  if (expr->call_head_token_position() &&
+      start_locations_size !=
+          builder()->record_replay_instrumentation_site_locations_.size()) {
+    // Has arguments and visiting them added breakpoints.
+    // Move this to a position that is assured not to conflict with any other
+    // AST node.
+    builder()->RecordReplayInstrumentation("breakpoint",
+                                           expr->call_head_token_position());
+  } else {
+    // Might have arguments but visiting them didn't add breakpoints.
+    // Add this to a potentially conflicting position, letting it to be
+    // deduplicated in such case. If there is no conflict, a breakpoint will be
+    // added.
+    builder()->RecordReplayInstrumentation("breakpoint", expr->position());
+  }
+
   if (spread_position == Call::kHasFinalSpread) {
     DCHECK(!implicit_undefined_receiver);
     builder()->CallWithSpread(callee, args,
diff --git a/deps/v8/src/interpreter/bytecode-generator.h b/deps/v8/src/interpreter/bytecode-generator.h
index 01f4b2a5b6b901..b03056439b3342 100644
--- a/deps/v8/src/interpreter/bytecode-generator.h
+++ b/deps/v8/src/interpreter/bytecode-generator.h
@@ -57,6 +57,10 @@ class BytecodeGenerator final : public AstVisitor<BytecodeGenerator> {
   void VisitDeclarations(Declaration::List* declarations);
   void VisitStatements(const ZonePtrList<Statement>* statments);
 
+  // [RUN-3317] Shift breakpoint from |stmt| to |expr|, if |expr| exists.
+  void ReplayExpressionShiftedSetStatementPosition(Statement* stmt,
+                                                   Expression* expr);
+
  private:
   class AccumulatorPreservingScope;
   class ContextScope;
diff --git a/deps/v8/src/parsing/parser-base.h b/deps/v8/src/parsing/parser-base.h
index 108b11edc83d0d..d1b32988718db5 100644
--- a/deps/v8/src/parsing/parser-base.h
+++ b/deps/v8/src/parsing/parser-base.h
@@ -1533,7 +1533,7 @@ class ParserBase {
 
   // Parser base's protected field members.
 
-  Scope* scope_;                   // Scope stack.
+  Scope* scope_;  // Scope stack.
   // Stack of scopes for object literals we're currently parsing.
   Scope* object_literal_scope_ = nullptr;
   Scope* original_scope_;  // The top scope for the current parsing item.
@@ -3140,9 +3140,14 @@ ParserBase<Impl>::ParseBinaryContinuation(ExpressionT x, int prec, int prec1) {
         // We have a comparison.
         Token::Value cmp = op;
         switch (op) {
-          case Token::NE: cmp = Token::EQ; break;
-          case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;
-          default: break;
+          case Token::NE:
+            cmp = Token::EQ;
+            break;
+          case Token::NE_STRICT:
+            cmp = Token::EQ_STRICT;
+            break;
+          default:
+            break;
         }
         x = factory()->NewCompareOperation(cmp, x, y, pos);
         if (cmp != op) {
@@ -3367,6 +3372,7 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
 
     ExpressionListT args(pointer_buffer());
     bool has_spread;
+    int call_head_token_position = peek_position();
     ParseArguments(&args, &has_spread, kMaybeArrowHead);
     if (V8_LIKELY(peek() == Token::ARROW)) {
       fni_.RemoveAsyncKeywordFromEnd();
@@ -3380,7 +3386,8 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
       return result;
     }
 
-    result = factory()->NewCall(result, args, pos, has_spread);
+    result = factory()->NewCall(result, args, pos, has_spread,
+                                call_head_token_position);
 
     maybe_arrow.ValidateExpression();
 
@@ -3457,6 +3464,7 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
         }
         bool has_spread;
         ExpressionListT args(pointer_buffer());
+        int call_head_token_position = peek_position();
         ParseArguments(&args, &has_spread);
 
         // Keep track of eval() calls since they disable all local variable
@@ -3470,7 +3478,8 @@ ParserBase<Impl>::ParseLeftHandSideContinuation(ExpressionT result) {
             CheckPossibleEvalCall(result, is_optional, scope());
 
         result = factory()->NewCall(result, args, pos, has_spread,
-                                    is_possibly_eval, is_optional);
+                                    call_head_token_position, is_possibly_eval,
+                                    is_optional);
 
         fni_.RemoveLastFunction();
         break;
@@ -3548,9 +3557,11 @@ ParserBase<Impl>::ParseMemberWithPresentNewPrefixesExpression() {
     {
       ExpressionListT args(pointer_buffer());
       bool has_spread;
+      int call_head_token_position = peek_position();
       ParseArguments(&args, &has_spread);
 
-      result = factory()->NewCallNew(result, args, new_pos, has_spread);
+      result = factory()->NewCallNew(result, args, new_pos, has_spread,
+                                     call_head_token_position);
     }
     // The expression can still continue with . or [ after the arguments.
     return ParseMemberExpressionContinuation(result);
@@ -4834,6 +4845,7 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseTemplateLiteral(
 
   Consume(Token::TEMPLATE_SPAN);
   int pos = position();
+  int call_head_token_position = pos;
   typename Impl::TemplateLiteralState ts = impl()->OpenTemplateLiteral(pos);
   bool is_valid = CheckTemplateEscapes(forbid_illegal_escapes);
   impl()->AddTemplateSpan(&ts, is_valid, false);
@@ -4869,7 +4881,8 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseTemplateLiteral(
 
   DCHECK_IMPLIES(!has_error(), next == Token::TEMPLATE_TAIL);
   // Once we've reached a TEMPLATE_TAIL, we can close the TemplateLiteral.
-  return impl()->CloseTemplateLiteral(&ts, start, tag);
+  return impl()->CloseTemplateLiteral(&ts, start, tag,
+                                      call_head_token_position);
 }
 
 template <typename Impl>
@@ -6408,9 +6421,9 @@ void ParserBase<Impl>::CheckClassMethodName(IdentifierT name,
     if (flags != ParseFunctionFlag::kIsNormal || IsAccessor(type)) {
       MessageTemplate msg = (flags & ParseFunctionFlag::kIsGenerator) != 0
                                 ? MessageTemplate::kConstructorIsGenerator
-                                : (flags & ParseFunctionFlag::kIsAsync) != 0
-                                      ? MessageTemplate::kConstructorIsAsync
-                                      : MessageTemplate::kConstructorIsAccessor;
+                            : (flags & ParseFunctionFlag::kIsAsync) != 0
+                                ? MessageTemplate::kConstructorIsAsync
+                                : MessageTemplate::kConstructorIsAccessor;
       ReportMessage(msg);
       return;
     }
diff --git a/deps/v8/src/parsing/parser.cc b/deps/v8/src/parsing/parser.cc
index a541734bdd060f..022bcbd512724d 100644
--- a/deps/v8/src/parsing/parser.cc
+++ b/deps/v8/src/parsing/parser.cc
@@ -3320,7 +3320,8 @@ void Parser::AddTemplateExpression(TemplateLiteralState* state,
 }
 
 Expression* Parser::CloseTemplateLiteral(TemplateLiteralState* state, int start,
-                                         Expression* tag) {
+                                         Expression* tag,
+                                         int call_head_token_position) {
   TemplateLiteral* lit = *state;
   int pos = lit->position();
   const ZonePtrList<const AstRawString>* cooked_strings = lit->cooked();
@@ -3343,7 +3344,8 @@ Expression* Parser::CloseTemplateLiteral(TemplateLiteralState* state, int start,
     ScopedPtrList<Expression> call_args(pointer_buffer());
     call_args.Add(template_object);
     call_args.AddAll(expressions->ToConstVector());
-    return factory()->NewTaggedTemplate(tag, call_args, pos);
+    return factory()->NewTaggedTemplate(tag, call_args, pos,
+                                        call_head_token_position);
   }
 }
 
diff --git a/deps/v8/src/parsing/parser.h b/deps/v8/src/parsing/parser.h
index 6b50ed134c364d..1391b269df147f 100644
--- a/deps/v8/src/parsing/parser.h
+++ b/deps/v8/src/parsing/parser.h
@@ -40,7 +40,6 @@ class PreparseData;
 
 class Parser;
 
-
 struct ParserFormalParameters : FormalParametersBase {
   struct Parameter : public ZoneObject {
     Parameter(Expression* pattern, Expression* initializer, int position,
@@ -489,7 +488,8 @@ class V8_EXPORT_PRIVATE Parser : public NON_EXPORTED_BASE(ParserBase<Parser>) {
   void AddTemplateExpression(TemplateLiteralState* state,
                              Expression* expression);
   Expression* CloseTemplateLiteral(TemplateLiteralState* state, int start,
-                                   Expression* tag);
+                                   Expression* tag,
+                                   int call_head_token_position = 0);
 
   ArrayLiteral* ArrayLiteralFromListWithSpread(
       const ScopedPtrList<Expression>& list);
@@ -592,9 +592,8 @@ class V8_EXPORT_PRIVATE Parser : public NON_EXPORTED_BASE(ParserBase<Parser>) {
 
   V8_INLINE bool IsNative(Expression* expr) const {
     DCHECK_NOT_NULL(expr);
-    return expr->IsVariableProxy() &&
-           expr->AsVariableProxy()->raw_name() ==
-               ast_value_factory()->native_string();
+    return expr->IsVariableProxy() && expr->AsVariableProxy()->raw_name() ==
+                                          ast_value_factory()->native_string();
   }
 
   V8_INLINE static bool IsArrayIndex(const AstRawString* string,
@@ -1059,7 +1058,7 @@ class V8_EXPORT_PRIVATE Parser : public NON_EXPORTED_BASE(ParserBase<Parser>) {
   }
 
   // Parser's private field members.
-  friend class PreParserZoneScope;  // Uses reusable_preparser().
+  friend class PreParserZoneScope;   // Uses reusable_preparser().
   friend class PreparseDataBuilder;  // Uses preparse_data_buffer()
 
   ParseInfo* info_;
diff --git a/deps/v8/src/parsing/preparser.h b/deps/v8/src/parsing/preparser.h
index 1949e7f8a7ed9d..88882a3e9064af 100644
--- a/deps/v8/src/parsing/preparser.h
+++ b/deps/v8/src/parsing/preparser.h
@@ -399,9 +399,7 @@ class PreParserExpressionList {
 
   int length() const { return length_; }
 
-  void Add(const PreParserExpression& expression) {
-    ++length_;
-  }
+  void Add(const PreParserExpression& expression) { ++length_; }
 
  private:
   int length_;
@@ -448,9 +446,7 @@ class PreParserStatement {
 
   bool IsStringLiteral() { return code_ == kStringLiteralExpressionStatement; }
 
-  bool IsJumpStatement() {
-    return code_ == kJumpStatement;
-  }
+  bool IsJumpStatement() { return code_ == kJumpStatement; }
 
   bool IsNull() { return code_ == kNullStatement; }
 
@@ -527,8 +523,7 @@ class PreParserFactory {
                                        int pos) {
     return PreParserExpression::Default();
   }
-  PreParserExpression NewNumberLiteral(double number,
-                                       int pos) {
+  PreParserExpression NewNumberLiteral(double number, int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewUndefinedLiteral(int pos) {
@@ -644,7 +639,7 @@ class PreParserFactory {
   }
   PreParserExpression NewCall(PreParserExpression expression,
                               const PreParserExpressionList& arguments, int pos,
-                              bool has_spread,
+                              bool has_spread, int call_head_token_position = 0,
                               Call::PossiblyEval possibly_eval = Call::NOT_EVAL,
                               bool optional_chain = false) {
     if (possibly_eval == Call::IS_POSSIBLY_EVAL) {
@@ -656,12 +651,13 @@ class PreParserFactory {
   }
   PreParserExpression NewTaggedTemplate(
       PreParserExpression expression, const PreParserExpressionList& arguments,
-      int pos) {
+      int pos, int call_head_token_position) {
     return PreParserExpression::CallTaggedTemplate();
   }
   PreParserExpression NewCallNew(const PreParserExpression& expression,
                                  const PreParserExpressionList& arguments,
-                                 int pos, bool has_spread) {
+                                 int pos, bool has_spread,
+                                 int call_head_token_position = 0) {
     return PreParserExpression::Default();
   }
   PreParserStatement NewReturnStatement(
@@ -903,7 +899,6 @@ struct ParserTypes<PreParser> {
   using SourceRangeScope = PreParserSourceRangeScope;
 };
 
-
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
@@ -1037,7 +1032,8 @@ class PreParser : public ParserBase<PreParser> {
   V8_INLINE void AddTemplateSpan(TemplateLiteralState* state, bool should_cook,
                                  bool tail) {}
   V8_INLINE PreParserExpression CloseTemplateLiteral(
-      TemplateLiteralState* state, int start, const PreParserExpression& tag) {
+      TemplateLiteralState* state, int start, const PreParserExpression& tag,
+      int call_head_token_position = 0) {
     return PreParserExpression::Default();
   }
   V8_INLINE bool IsPrivateReference(const PreParserExpression& expression) {
@@ -1397,8 +1393,7 @@ class PreParser : public ParserBase<PreParser> {
 
   V8_INLINE void DesugarBindingInForEachStatement(
       ForInfo* for_info, PreParserStatement* body_block,
-      PreParserExpression* each_variable) {
-  }
+      PreParserExpression* each_variable) {}
 
   V8_INLINE PreParserBlock CreateForEachStatementTDZ(PreParserBlock init_block,
                                                      const ForInfo& for_info) {
@@ -1642,8 +1637,7 @@ class PreParser : public ParserBase<PreParser> {
 
   V8_INLINE void DeclareArrowFunctionFormalParameters(
       PreParserFormalParameters* parameters, const PreParserExpression& params,
-      const Scanner::Location& params_loc) {
-  }
+      const Scanner::Location& params_loc) {}
 
   V8_INLINE PreParserExpression
   ExpressionListToExpression(const PreParserExpressionList& args) {