Fix the debugger in multipass mode by introducing phantome...

src/cfg.h

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 288 matching lines @@
 #endif
 };
 
 
 // Instructions are computations.  The represent non-trivial source
 // expressions: typically ones that have side effects and require code to
 // be generated.
 class Instruction : public ZoneObject {
  public:
   // Every instruction has a location where its result is stored (which may
-  // be Effect).
+  // be Effect, the default).
+  Instruction() : loc_(CfgGlobals::current()->effect_location()) {}
+
   explicit Instruction(Location* loc) : loc_(loc) {}
 
   virtual ~Instruction() {}
 
   // Accessors.
   Location* location() { return loc_; }
   void set_location(Location* loc) { loc_ = loc; }
 
   // Support for fast-compilation mode:
 
   // Emit code to perform the instruction.
   virtual void Compile(MacroAssembler* masm) = 0;
 
   // Allocate a temporary which is the result of the immediate predecessor
   // instruction.  It is allocated to the accumulator register if it is used
   // as an operand to this instruction, otherwise to the stack.
   virtual void FastAllocate(TempLocation* temp) = 0;
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 
  protected:
   Location* loc_;
 };
 
 
+// A phantom instruction that indicates the start of a statement.  It
+// causes the statement position to be recorded in the relocation
+// information but generates no code.
+class PositionInstr : public Instruction {
+ public:
+  explicit PositionInstr(int pos) : pos_(pos) {}
+
+  // Support for fast-compilation mode.
+  void Compile(MacroAssembler* masm);
+
+  // This should not be called.  The last instruction of the previous
+  // statement should not have a temporary as its location.
+  void FastAllocate(TempLocation* temp) { UNREACHABLE(); }
+
+#ifdef DEBUG
+  // Printing support.  Print nothing.
+  void Print() {}
+#endif
+
+ private:
+  int pos_;
+};
+
+
 // Perform a (non-short-circuited) binary operation on a pair of values,
 // leaving the result in a location.
 class BinaryOpInstr : public Instruction {
  public:
   BinaryOpInstr(Location* loc, Token::Value op, Value* val0, Value* val1)
       : Instruction(loc), op_(op), val0_(val0), val1_(val1) {
   }
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
@@ skipping 11 matching lines @@
 
 
 // Return a value.  Has the side effect of moving its value into the return
 // value register.  Can only occur as the last instruction in an instruction
 // block, and implies that the block is closed (cannot have instructions
 // appended or graph fragments concatenated to the end) and that the block's
 // successor is the global exit node for the current function.
 class ReturnInstr : public Instruction {
  public:
   // Location is always Effect.
-  explicit ReturnInstr(Value* value)
-      : Instruction(CfgGlobals::current()->effect_location()),
-        value_(value) {
-  }
+  explicit ReturnInstr(Value* value) : value_(value) {}
 
   virtual ~ReturnInstr() {}
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
   void FastAllocate(TempLocation* temp);
 
 #ifdef DEBUG
   void Print();
 #endif
@@ skipping 247 matching lines @@
 #undef DECLARE_VISIT
 
  private:
   Cfg* cfg_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CFG_H_