src/3rdparty/v8/src/scopeinfo.h

   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_