[crankshaft] Fragmentation-free allocation folding.

src/crankshaft/hydrogen-instructions.h

 // Copyright 2012 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_CRANKSHAFT_HYDROGEN_INSTRUCTIONS_H_
 #define V8_CRANKSHAFT_HYDROGEN_INSTRUCTIONS_H_
 
 #include <cstring>
 #include <iosfwd>
 
@@ skipping 4987 matching lines @@
   }
 
   bool MustPrefillWithFiller() const {
     return (flags_ & PREFILL_WITH_FILLER) != 0;
   }
 
   void MakePrefillWithFiller() {
     flags_ = static_cast<HAllocate::Flags>(flags_ | PREFILL_WITH_FILLER);
   }
 
-  bool MustClearNextMapWord() const {
-    return (flags_ & CLEAR_NEXT_MAP_WORD) != 0;
-  }
-
   void MakeDoubleAligned() {
     flags_ = static_cast<HAllocate::Flags>(flags_ | ALLOCATE_DOUBLE_ALIGNED);
   }
 
+  void MakeAllocationFoldingDominator() {
+    flags_ =
+        static_cast<HAllocate::Flags>(flags_ | ALLOCATION_FOLDING_DOMINATOR);
+  }
+
+  bool IsAllocationFoldingDominator() {
+    return (flags_ & ALLOCATION_FOLDING_DOMINATOR) != 0;
+  }
+
+  void MakeAllocationFoldingDominated() {
+    flags_ =
+        static_cast<HAllocate::Flags>(flags_ | ALLOCATION_FOLDING_DOMINATED);
+    ClearFlag(kTrackSideEffectDominators);
+    ClearChangesFlag(kNewSpacePromotion);
+  }
+
+  bool IsAllocationFoldingDominated() {
+    return (flags_ & ALLOCATION_FOLDING_DOMINATED) != 0;
+  }
+
   bool HandleSideEffectDominator(GVNFlag side_effect,
                                  HValue* dominator) override;
 
   std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(Allocate)
 
  private:
   enum Flags {
     ALLOCATE_IN_NEW_SPACE = 1 << 0,
     ALLOCATE_IN_OLD_SPACE = 1 << 2,
     ALLOCATE_DOUBLE_ALIGNED = 1 << 3,
     PREFILL_WITH_FILLER = 1 << 4,
-    CLEAR_NEXT_MAP_WORD = 1 << 5
+    ALLOCATION_FOLDING_DOMINATOR = 1 << 5,
+    ALLOCATION_FOLDING_DOMINATED = 1 << 6

[Benedikt Meurer, 2016/04/19 07:25:38]

Is there a better name than "dominated"?

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Changed to ALLOCATION_FOLDED. Done.

   };
 
   HAllocate(HValue* context,
             HValue* size,
             HType type,
             PretenureFlag pretenure_flag,
             InstanceType instance_type,
             Handle<AllocationSite> allocation_site =
                 Handle<AllocationSite>::null())
       : HTemplateInstruction<2>(type),
@@ skipping 25 matching lines @@
       flags = static_cast<Flags>(flags | ALLOCATE_DOUBLE_ALIGNED);
     }
     // We have to fill the allocated object with one word fillers if we do
     // not use allocation folding since some allocations may depend on each
     // other, i.e., have a pointer to each other. A GC in between these
     // allocations may leave such objects behind in a not completely initialized
     // state.
     if (!FLAG_use_gvn || !FLAG_use_allocation_folding) {
       flags = static_cast<Flags>(flags | PREFILL_WITH_FILLER);
     }
-    if (pretenure_flag == NOT_TENURED &&
-        AllocationSite::CanTrack(instance_type)) {
-      flags = static_cast<Flags>(flags | CLEAR_NEXT_MAP_WORD);
-    }
     return flags;
   }
 
-  void UpdateClearNextMapWord(bool clear_next_map_word) {
-    flags_ = static_cast<Flags>(clear_next_map_word
-                                ? flags_ | CLEAR_NEXT_MAP_WORD
-                                : flags_ & ~CLEAR_NEXT_MAP_WORD);
-  }
-
   void UpdateSize(HValue* size) {
     SetOperandAt(1, size);
     if (size->IsInteger32Constant()) {
       size_upper_bound_ = HConstant::cast(size);
     } else {
       size_upper_bound_ = NULL;
     }
   }
 
   HAllocate* GetFoldableDominator(HAllocate* dominator);
 
-  void UpdateFreeSpaceFiller(int32_t filler_size);
-
-  void CreateFreeSpaceFiller(int32_t filler_size);
-
   bool IsFoldable(HAllocate* allocate) {
     return (IsNewSpaceAllocation() && allocate->IsNewSpaceAllocation()) ||
            (IsOldSpaceAllocation() && allocate->IsOldSpaceAllocation());
   }
 
-  void ClearNextMapWord(int offset);
-
   Flags flags_;
   Handle<Map> known_initial_map_;
   HAllocate* dominating_allocate_;
   HStoreNamedField* filler_free_space_size_;
   HConstant* size_upper_bound_;
 };
 
 
 class HStoreCodeEntry final : public HTemplateInstruction<2> {
  public:
@@ skipping 2122 matching lines @@
   bool IsDeletable() const override { return true; }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CRANKSHAFT_HYDROGEN_INSTRUCTIONS_H_