LCOV - code coverage report
Current view: top level - src/interpreter - constant-array-builder.h (source / functions) Hit Total Coverage
Test: app.info Lines: 9 9 100.0 %
Date: 2017-04-26 Functions: 0 0 -

          Line data    Source code
       1             : // Copyright 2015 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
       6             : #define V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_
       7             : 
       8             : #include "src/globals.h"
       9             : #include "src/identity-map.h"
      10             : #include "src/interpreter/bytecodes.h"
      11             : #include "src/zone/zone-containers.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16             : class Isolate;
      17             : class AstRawString;
      18             : class AstValue;
      19             : 
      20             : namespace interpreter {
      21             : 
      22             : // Constant array entries that represent singletons.
      23             : #define SINGLETON_CONSTANT_ENTRY_TYPES(V)       \
      24             :   V(IteratorSymbol, iterator_symbol)            \
      25             :   V(AsyncIteratorSymbol, async_iterator_symbol) \
      26             :   V(HomeObjectSymbol, home_object_symbol)       \
      27             :   V(EmptyFixedArray, empty_fixed_array)
      28             : 
      29             : // A helper class for constructing constant arrays for the
      30             : // interpreter. Each instance of this class is intended to be used to
      31             : // generate exactly one FixedArray of constants via the ToFixedArray
      32             : // method.
      33             : class V8_EXPORT_PRIVATE ConstantArrayBuilder final BASE_EMBEDDED {
      34             :  public:
      35             :   // Capacity of the 8-bit operand slice.
      36             :   static const size_t k8BitCapacity = 1u << kBitsPerByte;
      37             : 
      38             :   // Capacity of the 16-bit operand slice.
      39             :   static const size_t k16BitCapacity = (1u << 2 * kBitsPerByte) - k8BitCapacity;
      40             : 
      41             :   // Capacity of the 32-bit operand slice.
      42             :   static const size_t k32BitCapacity =
      43             :       kMaxUInt32 - k16BitCapacity - k8BitCapacity + 1;
      44             : 
      45             :   ConstantArrayBuilder(Zone* zone);
      46             : 
      47             :   // Generate a fixed array of constant handles based on inserted objects.
      48             :   Handle<FixedArray> ToFixedArray(Isolate* isolate);
      49             : 
      50             :   // Returns the object, as a handle in |isolate|, that is in the constant pool
      51             :   // array at index |index|. Returns null if there is no handle at this index.
      52             :   // Only expected to be used in tests.
      53             :   MaybeHandle<Object> At(size_t index, Isolate* isolate) const;
      54             : 
      55             :   // Returns the number of elements in the array.
      56             :   size_t size() const;
      57             : 
      58             :   // Insert an object into the constants array if it is not already present.
      59             :   // Returns the array index associated with the object.
      60             :   size_t Insert(Smi* smi);
      61             :   size_t Insert(const AstRawString* raw_string);
      62             :   size_t Insert(const AstValue* heap_number);
      63             :   size_t Insert(const Scope* scope);
      64             : #define INSERT_ENTRY(NAME, ...) size_t Insert##NAME();
      65             :   SINGLETON_CONSTANT_ENTRY_TYPES(INSERT_ENTRY)
      66             : #undef INSERT_ENTRY
      67             : 
      68             :   // Inserts an empty entry and returns the array index associated with the
      69             :   // reservation. The entry's handle value can be inserted by calling
      70             :   // SetDeferredAt().
      71             :   size_t InsertDeferred();
      72             : 
      73             :   // Sets the deferred value at |index| to |object|.
      74             :   void SetDeferredAt(size_t index, Handle<Object> object);
      75             : 
      76             :   // Creates a reserved entry in the constant pool and returns
      77             :   // the size of the operand that'll be required to hold the entry
      78             :   // when committed.
      79             :   OperandSize CreateReservedEntry();
      80             : 
      81             :   // Commit reserved entry and returns the constant pool index for the
      82             :   // SMI value.
      83             :   size_t CommitReservedEntry(OperandSize operand_size, Smi* value);
      84             : 
      85             :   // Discards constant pool reservation.
      86             :   void DiscardReservedEntry(OperandSize operand_size);
      87             : 
      88             :  private:
      89             :   typedef uint32_t index_t;
      90             : 
      91             :   class Entry {
      92             :    private:
      93             :     enum class Tag : uint8_t;
      94             : 
      95             :    public:
      96      157444 :     explicit Entry(Smi* smi) : smi_(smi), tag_(Tag::kSmi) {}
      97             :     explicit Entry(const AstRawString* raw_string)
      98     7113061 :         : raw_string_(raw_string), tag_(Tag::kRawString) {}
      99             :     explicit Entry(const AstValue* heap_number)
     100      861557 :         : heap_number_(heap_number), tag_(Tag::kHeapNumber) {}
     101      184271 :     explicit Entry(const Scope* scope) : scope_(scope), tag_(Tag::kScope) {}
     102             : 
     103             : #define CONSTRUCT_ENTRY(NAME, LOWER_NAME) \
     104             :   static Entry NAME() { return Entry(Tag::k##NAME); }
     105             :     SINGLETON_CONSTANT_ENTRY_TYPES(CONSTRUCT_ENTRY)
     106             : #undef CONSTRUCT_ENTRY
     107             : 
     108             :     static Entry Deferred() { return Entry(Tag::kDeferred); }
     109             : 
     110             :     bool IsDeferred() const { return tag_ == Tag::kDeferred; }
     111             : 
     112             :     void SetDeferred(Handle<Object> handle) {
     113             :       DCHECK(tag_ == Tag::kDeferred);
     114     3994782 :       tag_ = Tag::kHandle;
     115     3994782 :       handle_ = handle;
     116             :     }
     117             : 
     118             :     Handle<Object> ToHandle(Isolate* isolate) const;
     119             : 
     120             :    private:
     121             :     explicit Entry(Tag tag) : tag_(tag) {}
     122             : 
     123             :     union {
     124             :       Handle<Object> handle_;
     125             :       Smi* smi_;
     126             :       const AstRawString* raw_string_;
     127             :       const AstValue* heap_number_;
     128             :       const Scope* scope_;
     129             :     };
     130             : 
     131             :     enum class Tag : uint8_t {
     132             :       kDeferred,
     133             :       kHandle,
     134             :       kSmi,
     135             :       kRawString,
     136             :       kHeapNumber,
     137             :       kScope,
     138             : #define ENTRY_TAG(NAME, ...) k##NAME,
     139             :       SINGLETON_CONSTANT_ENTRY_TYPES(ENTRY_TAG)
     140             : #undef ENTRY_TAG
     141             :     } tag_;
     142             :   };
     143             : 
     144             :   index_t AllocateIndex(Entry constant_entry);
     145             :   index_t AllocateReservedEntry(Smi* value);
     146             : 
     147             :   struct ConstantArraySlice final : public ZoneObject {
     148             :     ConstantArraySlice(Zone* zone, size_t start_index, size_t capacity,
     149             :                        OperandSize operand_size);
     150             :     void Reserve();
     151             :     void Unreserve();
     152             :     size_t Allocate(Entry entry);
     153             :     Entry& At(size_t index);
     154             :     const Entry& At(size_t index) const;
     155             : 
     156             : #if DEBUG
     157             :     void CheckAllElementsAreUnique(Isolate* isolate) const;
     158             : #endif
     159             : 
     160    17321405 :     inline size_t available() const { return capacity() - reserved() - size(); }
     161             :     inline size_t reserved() const { return reserved_; }
     162             :     inline size_t capacity() const { return capacity_; }
     163    38661814 :     inline size_t size() const { return constants_.size(); }
     164             :     inline size_t start_index() const { return start_index_; }
     165     5008598 :     inline size_t max_index() const { return start_index_ + capacity() - 1; }
     166             :     inline OperandSize operand_size() const { return operand_size_; }
     167             : 
     168             :    private:
     169             :     const size_t start_index_;
     170             :     const size_t capacity_;
     171             :     size_t reserved_;
     172             :     OperandSize operand_size_;
     173             :     ZoneVector<Entry> constants_;
     174             : 
     175             :     DISALLOW_COPY_AND_ASSIGN(ConstantArraySlice);
     176             :   };
     177             : 
     178             :   ConstantArraySlice* IndexToSlice(size_t index) const;
     179             :   ConstantArraySlice* OperandSizeToSlice(OperandSize operand_size) const;
     180             : 
     181             :   ConstantArraySlice* idx_slice_[3];
     182             :   base::TemplateHashMapImpl<intptr_t, index_t,
     183             :                             base::KeyEqualityMatcher<intptr_t>,
     184             :                             ZoneAllocationPolicy>
     185             :       constants_map_;
     186             :   ZoneMap<Smi*, index_t> smi_map_;
     187             :   ZoneVector<std::pair<Smi*, index_t>> smi_pairs_;
     188             : 
     189             : #define SINGLETON_ENTRY_FIELD(NAME, LOWER_NAME) int LOWER_NAME##_;
     190             :   SINGLETON_CONSTANT_ENTRY_TYPES(SINGLETON_ENTRY_FIELD)
     191             : #undef SINGLETON_ENTRY_FIELD
     192             : 
     193             :   Zone* zone_;
     194             : };
     195             : 
     196             : }  // namespace interpreter
     197             : }  // namespace internal
     198             : }  // namespace v8
     199             : 
     200             : #endif  // V8_INTERPRETER_CONSTANT_ARRAY_BUILDER_H_

Generated by: LCOV version 1.10