Home | History | Annotate | Download | only in compiler 
      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_JS_GRAPH_H_
      6 #define V8_COMPILER_JS_GRAPH_H_
      7 
      8 #include "src/compiler/common-node-cache.h"
      9 #include "src/compiler/common-operator.h"
     10 #include "src/compiler/graph.h"
     11 #include "src/compiler/js-operator.h"
     12 #include "src/compiler/machine-operator.h"
     13 #include "src/compiler/node-properties.h"
     14 #include "src/isolate.h"
     15 
     16 namespace v8 {
     17 namespace internal {
     18 namespace compiler {
     19 
     20 class SimplifiedOperatorBuilder;
     21 class Typer;
     22 
     23 // Implements a facade on a Graph, enhancing the graph with JS-specific
     24 // notions, including various builders for operators, canonicalized global
     25 // constants, and various helper methods.
     26 class JSGraph : public ZoneObject {
     27  public:
     28   JSGraph(Isolate* isolate, Graph* graph, CommonOperatorBuilder* common,
     29           JSOperatorBuilder* javascript, SimplifiedOperatorBuilder* simplified,
     30           MachineOperatorBuilder* machine)
     31       : isolate_(isolate),
     32         graph_(graph),
     33         common_(common),
     34         javascript_(javascript),
     35         simplified_(simplified),
     36         machine_(machine),
     37         cache_(zone()) {
     38     for (int i = 0; i < kNumCachedNodes; i++) cached_nodes_[i] = nullptr;
     39   }
     40 
     41   // Canonicalized global constants.
     42   Node* AllocateInNewSpaceStubConstant();
     43   Node* AllocateInOldSpaceStubConstant();
     44   Node* ToNumberBuiltinConstant();
     45   Node* CEntryStubConstant(int result_size);
     46   Node* EmptyFixedArrayConstant();
     47   Node* EmptyLiteralsArrayConstant();
     48   Node* HeapNumberMapConstant();
     49   Node* OptimizedOutConstant();
     50   Node* StaleRegisterConstant();
     51   Node* UndefinedConstant();
     52   Node* TheHoleConstant();
     53   Node* TrueConstant();
     54   Node* FalseConstant();
     55   Node* NullConstant();
     56   Node* ZeroConstant();
     57   Node* OneConstant();
     58   Node* NaNConstant();
     59 
     60   // Creates a HeapConstant node, possibly canonicalized, and may access the
     61   // heap to inspect the object.
     62   Node* HeapConstant(Handle<HeapObject> value);
     63 
     64   // Creates a Constant node of the appropriate type for the given object.
     65   // Accesses the heap to inspect the object and determine whether one of the
     66   // canonicalized globals or a number constant should be returned.
     67   Node* Constant(Handle<Object> value);
     68 
     69   // Creates a NumberConstant node, usually canonicalized.
     70   Node* Constant(double value);
     71 
     72   // Creates a NumberConstant node, usually canonicalized.
     73   Node* Constant(int32_t value);
     74 
     75   // Creates a Int32Constant node, usually canonicalized.
     76   Node* Int32Constant(int32_t value);
     77   Node* Uint32Constant(uint32_t value) {
     78     return Int32Constant(bit_cast<int32_t>(value));
     79   }
     80 
     81   // Creates a HeapConstant node for either true or false.
     82   Node* BooleanConstant(bool is_true) {
     83     return is_true ? TrueConstant() : FalseConstant();
     84   }
     85 
     86   // Creates a Int64Constant node, usually canonicalized.
     87   Node* Int64Constant(int64_t value);
     88   Node* Uint64Constant(uint64_t value) {
     89     return Int64Constant(bit_cast<int64_t>(value));
     90   }
     91 
     92   // Creates a Int32Constant/Int64Constant node, depending on the word size of
     93   // the target machine.
     94   // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer
     95   // constants is probably not serializable.
     96   Node* IntPtrConstant(intptr_t value) {
     97     return machine()->Is32() ? Int32Constant(static_cast<int32_t>(value))
     98                              : Int64Constant(static_cast<int64_t>(value));
     99   }
    100   template <typename T>
    101   Node* PointerConstant(T* value) {
    102     return IntPtrConstant(bit_cast<intptr_t>(value));
    103   }
    104 
    105   Node* RelocatableInt32Constant(int32_t value, RelocInfo::Mode rmode);
    106   Node* RelocatableInt64Constant(int64_t value, RelocInfo::Mode rmode);
    107   Node* RelocatableIntPtrConstant(intptr_t value, RelocInfo::Mode rmode);
    108 
    109   // Creates a Float32Constant node, usually canonicalized.
    110   Node* Float32Constant(float value);
    111 
    112   // Creates a Float64Constant node, usually canonicalized.
    113   Node* Float64Constant(double value);
    114 
    115   // Creates an ExternalConstant node, usually canonicalized.
    116   Node* ExternalConstant(ExternalReference ref);
    117   Node* ExternalConstant(Runtime::FunctionId function_id);
    118 
    119   Node* SmiConstant(int32_t immediate) {
    120     DCHECK(Smi::IsValid(immediate));
    121     return Constant(immediate);
    122   }
    123 
    124   // Creates a dummy Constant node, used to satisfy calling conventions of
    125   // stubs and runtime functions that do not require a context.
    126   Node* NoContextConstant() { return ZeroConstant(); }
    127 
    128   // Creates an empty StateValues node, used when we don't have any concrete
    129   // values for a certain part of the frame state.
    130   Node* EmptyStateValues();
    131 
    132   // Create a control node that serves as dependency for dead nodes.
    133   Node* Dead();
    134 
    135   CommonOperatorBuilder* common() const { return common_; }
    136   JSOperatorBuilder* javascript() const { return javascript_; }
    137   SimplifiedOperatorBuilder* simplified() const { return simplified_; }
    138   MachineOperatorBuilder* machine() const { return machine_; }
    139   Graph* graph() const { return graph_; }
    140   Zone* zone() const { return graph()->zone(); }
    141   Isolate* isolate() const { return isolate_; }
    142   Factory* factory() const { return isolate()->factory(); }
    143 
    144   void GetCachedNodes(NodeVector* nodes);
    145 
    146  private:
    147   enum CachedNode {
    148     kAllocateInNewSpaceStubConstant,
    149     kAllocateInOldSpaceStubConstant,
    150     kToNumberBuiltinConstant,
    151     kCEntryStubConstant,
    152     kEmptyFixedArrayConstant,
    153     kEmptyLiteralsArrayConstant,
    154     kHeapNumberMapConstant,
    155     kOptimizedOutConstant,
    156     kStaleRegisterConstant,
    157     kUndefinedConstant,
    158     kTheHoleConstant,
    159     kTrueConstant,
    160     kFalseConstant,
    161     kNullConstant,
    162     kZeroConstant,
    163     kOneConstant,
    164     kNaNConstant,
    165     kEmptyStateValues,
    166     kDead,
    167     kNumCachedNodes  // Must remain last.
    168   };
    169 
    170   Isolate* isolate_;
    171   Graph* graph_;
    172   CommonOperatorBuilder* common_;
    173   JSOperatorBuilder* javascript_;
    174   SimplifiedOperatorBuilder* simplified_;
    175   MachineOperatorBuilder* machine_;
    176   CommonNodeCache cache_;
    177   Node* cached_nodes_[kNumCachedNodes];
    178 
    179   Node* NumberConstant(double value);
    180 
    181   DISALLOW_COPY_AND_ASSIGN(JSGraph);
    182 };
    183 
    184 }  // namespace compiler
    185 }  // namespace internal
    186 }  // namespace v8
    187 
    188 #endif
    189