[compiler] Allow for StackSlots of arbitrary size

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 94 matching lines @@
       frame_slot_count_ += delta;
     }
     spill_slot_count_ += delta;
   }
 
   void AllocateSavedCalleeRegisterSlots(int count) {
     frame_slot_count_ += count;
   }
 
   int AllocateSpillSlot(int width) {
-    int frame_slot_count_before = frame_slot_count_;
-    int slot = AllocateAlignedFrameSlot(width);
-    spill_slot_count_ += (frame_slot_count_ - frame_slot_count_before);
-    return slot;
+    int new_frame_slots = NumAlignedFrameSlots(width);
+    spill_slot_count_ += new_frame_slots;
+    frame_slot_count_ += new_frame_slots;
+    return frame_slot_count_ - 1;
   }
 
   int AlignFrame(int alignment = kDoubleSize);
 
   int ReserveSpillSlots(size_t slot_count) {
     DCHECK_EQ(0, spill_slot_count_);
     spill_slot_count_ += static_cast<int>(slot_count);
     frame_slot_count_ += static_cast<int>(slot_count);
     return frame_slot_count_ - 1;
   }
 
   static const int kContextSlot = 2 + StandardFrameConstants::kCPSlotCount;
   static const int kJSFunctionSlot = 3 + StandardFrameConstants::kCPSlotCount;
 
  private:
-  int AllocateAlignedFrameSlot(int width) {
-    DCHECK(width == 4 || width == 8 || width == 16);
-    if (kPointerSize == 4) {
-      // Skip one slot if necessary.
-      if (width > kPointerSize) {
-        frame_slot_count_++;
-        frame_slot_count_ |= 1;
-        // 2 extra slots if width == 16.
-        frame_slot_count_ += (width & 16) / 8;
-      }
-    } else {
-      // No alignment when slots are 8 bytes.
-      DCHECK_EQ(8, kPointerSize);
-      // 1 extra slot if width == 16.
-      frame_slot_count_ += (width & 16) / 16;
+  int NumAlignedFrameSlots(int width) {
+    int new_frame_slots = (width + kPointerSize - 1) / kPointerSize;
+    // Align to 8 bytes if width is a multiple of 8 bytes.
+    if (kPointerSize == 4 && width >= 8 && (width & 7) == 0 &&

[titzer, 2017/01/11 15:13:40]

Why not just alignSize = (width & 7) == 0 ? 8 : kPointerSize?

And actually, you probably want to align to 16 bytes 16-byte aligned sizes too
(SIMD).

[Clemens Hammacher, 2017/01/11 15:41:34]

It wasn't there before, but sounds like a good idea. Done.
PTAL.

+        ((frame_slot_count_ + new_frame_slots) & 1) != 0) {
+      ++new_frame_slots;
     }
-    return frame_slot_count_++;
+    DCHECK_GT(kMaxInt - frame_slot_count_, new_frame_slots);
+    return new_frame_slots;
   }
 
  private:
   int frame_slot_count_;
   int spill_slot_count_;
   BitVector* allocated_registers_;
   BitVector* allocated_double_registers_;
 
   DISALLOW_COPY_AND_ASSIGN(Frame);
 };
@@ skipping 70 matching lines @@
   const Frame* const frame_;
   bool access_frame_with_fp_;
   int sp_delta_;
   bool has_frame_;
 };
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_FRAME_H_