Home | History | Annotate | Download | only in src 
      1 // Copyright 2011 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_SCOPEINFO_H_
     29 #define V8_SCOPEINFO_H_
     30 
     31 #include "allocation.h"
     32 #include "variables.h"
     33 #include "zone-inl.h"
     34 
     35 namespace v8 {
     36 namespace internal {
     37 
     38 // Cache for mapping (data, property name) into context slot index.
     39 // The cache contains both positive and negative results.
     40 // Slot index equals -1 means the property is absent.
     41 // Cleared at startup and prior to mark sweep collection.
     42 class ContextSlotCache {
     43  public:
     44   // Lookup context slot index for (data, name).
     45   // If absent, kNotFound is returned.
     46   int Lookup(Object* data,
     47              String* name,
     48              VariableMode* mode,
     49              InitializationFlag* init_flag);
     50 
     51   // Update an element in the cache.
     52   void Update(Object* data,
     53               String* name,
     54               VariableMode mode,
     55               InitializationFlag init_flag,
     56               int slot_index);
     57 
     58   // Clear the cache.
     59   void Clear();
     60 
     61   static const int kNotFound = -2;
     62 
     63  private:
     64   ContextSlotCache() {
     65     for (int i = 0; i < kLength; ++i) {
     66       keys_[i].data = NULL;
     67       keys_[i].name = NULL;
     68       values_[i] = kNotFound;
     69     }
     70   }
     71 
     72   inline static int Hash(Object* data, String* name);
     73 
     74 #ifdef DEBUG
     75   void ValidateEntry(Object* data,
     76                      String* name,
     77                      VariableMode mode,
     78                      InitializationFlag init_flag,
     79                      int slot_index);
     80 #endif
     81 
     82   static const int kLength = 256;
     83   struct Key {
     84     Object* data;
     85     String* name;
     86   };
     87 
     88   struct Value {
     89     Value(VariableMode mode,
     90           InitializationFlag init_flag,
     91           int index) {
     92       ASSERT(ModeField::is_valid(mode));
     93       ASSERT(InitField::is_valid(init_flag));
     94       ASSERT(IndexField::is_valid(index));
     95       value_ = ModeField::encode(mode) |
     96           IndexField::encode(index) |
     97           InitField::encode(init_flag);
     98       ASSERT(mode == this->mode());
     99       ASSERT(init_flag == this->initialization_flag());
    100       ASSERT(index == this->index());
    101     }
    102 
    103     explicit inline Value(uint32_t value) : value_(value) {}
    104 
    105     uint32_t raw() { return value_; }
    106 
    107     VariableMode mode() { return ModeField::decode(value_); }
    108 
    109     InitializationFlag initialization_flag() {
    110       return InitField::decode(value_);
    111     }
    112 
    113     int index() { return IndexField::decode(value_); }
    114 
    115     // Bit fields in value_ (type, shift, size). Must be public so the
    116     // constants can be embedded in generated code.
    117     class ModeField:  public BitField<VariableMode,       0, 3> {};
    118     class InitField:  public BitField<InitializationFlag, 3, 1> {};
    119     class IndexField: public BitField<int,                4, 32-4> {};
    120 
    121    private:
    122     uint32_t value_;
    123   };
    124 
    125   Key keys_[kLength];
    126   uint32_t values_[kLength];
    127 
    128   friend class Isolate;
    129   DISALLOW_COPY_AND_ASSIGN(ContextSlotCache);
    130 };
    131 
    132 
    133 } }  // namespace v8::internal
    134 
    135 #endif  // V8_SCOPEINFO_H_
    136