src/v8/src/feedback-slots.h

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #ifndef V8_FEEDBACK_SLOTS_H_
  29 #define V8_FEEDBACK_SLOTS_H_
  30
  31 #include "v8.h"
  32
  33 #include "isolate.h"
  34
  35 namespace v8 {
  36 namespace internal {
  37
  38 enum ComputablePhase {
  39   DURING_PARSE,
  40   AFTER_SCOPING
  41 };
  42
  43
  44 class FeedbackSlotInterface {
  45  public:
  46   static const int kInvalidFeedbackSlot = -1;
  47
  48   virtual ~FeedbackSlotInterface() {}
  49
  50   // When can we ask how many feedback slots are necessary?
  51   virtual ComputablePhase GetComputablePhase() = 0;
  52   virtual int ComputeFeedbackSlotCount(Isolate* isolate) = 0;
  53   virtual void SetFirstFeedbackSlot(int slot) = 0;
  54 };
  55
  56
  57 class DeferredFeedbackSlotProcessor {
  58  public:
  59   DeferredFeedbackSlotProcessor()
  60     : slot_nodes_(NULL),
  61       slot_count_(0) { }
  62
  63   void add_slot_node(Zone* zone, FeedbackSlotInterface* slot) {
  64     if (slot->GetComputablePhase() == DURING_PARSE) {
  65       // No need to add to the list
  66       int count = slot->ComputeFeedbackSlotCount(zone->isolate());
  67       slot->SetFirstFeedbackSlot(slot_count_);
  68       slot_count_ += count;
  69     } else {
  70       if (slot_nodes_ == NULL) {
  71         slot_nodes_ = new(zone) ZoneList<FeedbackSlotInterface*>(10, zone);
  72       }
  73       slot_nodes_->Add(slot, zone);
  74     }
  75   }
  76
  77   void ProcessFeedbackSlots(Isolate* isolate) {
  78     // Scope analysis must have been done.
  79     if (slot_nodes_ == NULL) {
  80       return;
  81     }
  82
  83     int current_slot = slot_count_;
  84     for (int i = 0; i < slot_nodes_->length(); i++) {
  85       FeedbackSlotInterface* slot_interface = slot_nodes_->at(i);
  86       int count = slot_interface->ComputeFeedbackSlotCount(isolate);
  87       if (count > 0) {
  88         slot_interface->SetFirstFeedbackSlot(current_slot);
  89         current_slot += count;
  90       }
  91     }
  92
  93     slot_count_ = current_slot;
  94     slot_nodes_->Clear();
  95   }
  96
  97   int slot_count() {
  98     ASSERT(slot_count_ >= 0);
  99     return slot_count_;
 100   }
 101
 102  private:
 103   ZoneList<FeedbackSlotInterface*>* slot_nodes_;
 104   int slot_count_;
 105 };
 106
 107
 108 } }  // namespace v8::internal
 109
 110 #endif  // V8_FEEDBACK_SLOTS_H_