Revert of More simplification and unification of frame handling

src/compiler/frame.h

 // Copyright 2014 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.
 
 #ifndef V8_COMPILER_FRAME_H_
 #define V8_COMPILER_FRAME_H_
 
 #include "src/bit-vector.h"
 #include "src/frames.h"
 
@@ skipping 16 matching lines @@
 //   predicted before code generation begins depending on the type of code being
 //   generated.
 // - The second is the region for spill slots, which is immediately below the
 //   fixed header and grows as the register allocator needs to spill to the
 //   stack and asks the frame for more space.
 // - The third region, which contains the callee-saved registers must be
 //   reserved after register allocation, since its size can only be precisely
 //   determined after register allocation once the number of used callee-saved
 //   register is certain.
 //
-// The frame region immediately below the fixed header contains spill slots
-// starting at slot 4 for JSFunctions.  The callee-saved frame region below that
-// starts at 4+spill_slot_count_.  Callee stack slots corresponding to
-// parameters are accessible through negative slot ids.
+// Every pointer in a frame has a slot id. On 32-bit platforms, doubles consume
+// two slots.
+//
+// Stack slot indices >= 0 access the callee stack with slot 0 corresponding to
+// the callee's saved return address and 1 corresponding to the saved frame
+// pointer. Some frames have additional information stored in the fixed header,
+// for example JSFunctions store the function context and marker in the fixed
+// header, with slot index 2 corresponding to the current function context and 3
+// corresponding to the frame marker/JSFunction. The frame region immediately
+// below the fixed header contains spill slots starting at 4 for JsFunctions.
+// The callee-saved frame region below that starts at 4+spill_slot_count_.
+// Callee stack slots corresponding to parameters are accessible through
+// negative slot ids.
 //
 // Every slot of a caller or callee frame is accessible by the register
 // allocator and gap resolver with a SpillSlotOperand containing its
 // corresponding slot id.
 //
 // Below an example JSFunction Frame with slot ids, frame regions and contents:
 //
 //  slot      JS frame
 //       +-----------------+--------------------------------
 //  -n-1 |   parameter 0   |                            ^
 //       |- - - - - - - - -|                            |
 //  -n   |                 |                          Caller
 //  ...  |       ...       |                       frame slots
 //  -2   |  parameter n-1  |                       (slot < 0)
 //       |- - - - - - - - -|                            |
 //  -1   |   parameter n   |                            v
 //  -----+-----------------+--------------------------------
 //   0   |   return addr   |   ^                        ^
 //       |- - - - - - - - -|   |                        |
 //   1   | saved frame ptr | Fixed                      |
 //       |- - - - - - - - -| Header <-- frame ptr       |
 //   2   |     Context     |   |                        |
 //       |- - - - - - - - -|   |                        |
 //   3   |JSFunction/Marker|   v                        |
 //       +-----------------+----                        |
 //   4   |    spill 1      |   ^                      Callee
 //       |- - - - - - - - -|   |                   frame slots
 //  ...  |      ...        | Spill slots           (slot >= 0)
 //       |- - - - - - - - -|   |                        |
-//  m+3  |    spill m      |   v                        |
+//  m+4  |    spill m      |   v                        |
 //       +-----------------+----                        |
-//  m+4  |  callee-saved 1 |   ^                        |
+//  m+5  |  callee-saved 1 |   ^                        |
 //       |- - - - - - - - -|   |                        |
 //       |      ...        | Callee-saved               |
 //       |- - - - - - - - -|   |                        |
-// m+r+3 |  callee-saved r |   v                        v
+// m+r+4 |  callee-saved r |   v                        v
 //  -----+-----------------+----- <-- stack ptr -------------
 //
 class Frame : public ZoneObject {
  public:
   explicit Frame(int fixed_frame_size_in_slots,
                  const CallDescriptor* descriptor);
 
+  static int FPOffsetToSlot(int frame_offset) {
+    return StandardFrameConstants::kFixedSlotCountAboveFp - 1 -
+           frame_offset / kPointerSize;
+  }
+
+  static int SlotToFPOffset(int slot) {
+    return (StandardFrameConstants::kFixedSlotCountAboveFp - 1 - slot) *
+           kPointerSize;
+  }
+
   inline bool needs_frame() const { return needs_frame_; }
   inline void MarkNeedsFrame() { needs_frame_ = true; }
 
   inline int GetTotalFrameSlotCount() const { return frame_slot_count_; }
 
   inline int GetSpToFpSlotCount() const {
     return GetTotalFrameSlotCount() -
            StandardFrameConstants::kFixedSlotCountAboveFp;
   }
   inline int GetSavedCalleeRegisterSlotCount() const {
@@ skipping 135 matching lines @@
  private:
   Frame* const frame_;
   bool access_frame_with_fp_;
   int sp_delta_;
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_FRAME_H_