Line data    Source code

       1             : // Copyright 2014 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_COMPILER_COMMON_NODE_CACHE_H_
       6             : #define V8_COMPILER_COMMON_NODE_CACHE_H_
       7             : 
       8             : #include "src/compiler/node-cache.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : 
      13             : // Forward declarations.
      14             : class ExternalReference;
      15             : class HeapObject;
      16             : template <typename>
      17             : class Handle;
      18             : 
      19             : 
      20             : namespace compiler {
      21             : 
      22             : // Bundles various caches for common nodes.
      23             : class CommonNodeCache final {
      24             :  public:
      25     4289183 :   explicit CommonNodeCache(Zone* zone) : zone_(zone) {}
      26             :   ~CommonNodeCache() = default;
      27             : 
      28             :   Node** FindInt32Constant(int32_t value) {
      29    14405430 :     return int32_constants_.Find(zone(), value);
      30             :   }
      31             : 
      32             :   Node** FindInt64Constant(int64_t value) {
      33     9830254 :     return int64_constants_.Find(zone(), value);
      34             :   }
      35             : 
      36             :   Node** FindFloat32Constant(float value) {
      37             :     // We canonicalize float constants at the bit representation level.
      38      125497 :     return float32_constants_.Find(zone(), bit_cast<int32_t>(value));
      39             :   }
      40             : 
      41             :   Node** FindFloat64Constant(double value) {
      42             :     // We canonicalize double constants at the bit representation level.
      43      496328 :     return float64_constants_.Find(zone(), bit_cast<int64_t>(value));
      44             :   }
      45             : 
      46             :   Node** FindExternalConstant(ExternalReference value);
      47             : 
      48             :   Node** FindPointerConstant(intptr_t value) {
      49        1348 :     return pointer_constants_.Find(zone(), value);
      50             :   }
      51             : 
      52             :   Node** FindNumberConstant(double value) {
      53             :     // We canonicalize double constants at the bit representation level.
      54     3359605 :     return number_constants_.Find(zone(), bit_cast<int64_t>(value));
      55             :   }
      56             : 
      57             :   Node** FindHeapConstant(Handle<HeapObject> value);
      58             : 
      59             :   Node** FindRelocatableInt32Constant(int32_t value, RelocInfoMode rmode) {
      60           0 :     return relocatable_int32_constants_.Find(zone(),
      61           0 :                                              std::make_pair(value, rmode));
      62             :   }
      63             : 
      64             :   Node** FindRelocatableInt64Constant(int64_t value, RelocInfoMode rmode) {
      65      185524 :     return relocatable_int64_constants_.Find(zone(),
      66      185524 :                                              std::make_pair(value, rmode));
      67             :   }
      68             : 
      69             :   // Return all nodes from the cache.
      70             :   void GetCachedNodes(ZoneVector<Node*>* nodes);
      71             : 
      72             :   Zone* zone() const { return zone_; }
      73             : 
      74             :  private:
      75             :   Int32NodeCache int32_constants_;
      76             :   Int64NodeCache int64_constants_;
      77             :   Int32NodeCache float32_constants_;
      78             :   Int64NodeCache float64_constants_;
      79             :   IntPtrNodeCache external_constants_;
      80             :   IntPtrNodeCache pointer_constants_;
      81             :   Int64NodeCache number_constants_;
      82             :   IntPtrNodeCache heap_constants_;
      83             :   RelocInt32NodeCache relocatable_int32_constants_;
      84             :   RelocInt64NodeCache relocatable_int64_constants_;
      85             :   Zone* const zone_;
      86             : 
      87             :   DISALLOW_COPY_AND_ASSIGN(CommonNodeCache);
      88             : };
      89             : 
      90             : }  // namespace compiler
      91             : }  // namespace internal
      92             : }  // namespace v8
      93             : 
      94             : #endif  // V8_COMPILER_COMMON_NODE_CACHE_H_