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_CCTEST_COMPILER_SIMPLIFIED_GRAPH_BUILDER_H_
      6 #define V8_CCTEST_COMPILER_SIMPLIFIED_GRAPH_BUILDER_H_
      7 
      8 #include "src/compiler/common-operator.h"
      9 #include "src/compiler/graph-builder.h"
     10 #include "src/compiler/machine-operator.h"
     11 #include "src/compiler/simplified-operator.h"
     12 #include "test/cctest/cctest.h"
     13 #include "test/cctest/compiler/call-tester.h"
     14 
     15 namespace v8 {
     16 namespace internal {
     17 namespace compiler {
     18 
     19 class SimplifiedGraphBuilder : public GraphBuilder {
     20  public:
     21   SimplifiedGraphBuilder(Graph* graph, CommonOperatorBuilder* common,
     22                          MachineOperatorBuilder* machine,
     23                          SimplifiedOperatorBuilder* simplified);
     24   virtual ~SimplifiedGraphBuilder() {}
     25 
     26   Zone* zone() const { return graph()->zone(); }
     27   Isolate* isolate() const { return zone()->isolate(); }
     28   CommonOperatorBuilder* common() const { return common_; }
     29   MachineOperatorBuilder* machine() const { return machine_; }
     30   SimplifiedOperatorBuilder* simplified() const { return simplified_; }
     31 
     32   // Initialize graph and builder.
     33   void Begin(int num_parameters);
     34 
     35   void Return(Node* value);
     36 
     37   // Close the graph.
     38   void End();
     39 
     40   Node* PointerConstant(void* value) {
     41     intptr_t intptr_value = reinterpret_cast<intptr_t>(value);
     42     return kPointerSize == 8 ? NewNode(common()->Int64Constant(intptr_value))
     43                              : Int32Constant(static_cast<int>(intptr_value));
     44   }
     45   Node* Int32Constant(int32_t value) {
     46     return NewNode(common()->Int32Constant(value));
     47   }
     48   Node* HeapConstant(Handle<Object> object) {
     49     Unique<Object> val = Unique<Object>::CreateUninitialized(object);
     50     return NewNode(common()->HeapConstant(val));
     51   }
     52 
     53   Node* BooleanNot(Node* a) { return NewNode(simplified()->BooleanNot(), a); }
     54 
     55   Node* NumberEqual(Node* a, Node* b) {
     56     return NewNode(simplified()->NumberEqual(), a, b);
     57   }
     58   Node* NumberLessThan(Node* a, Node* b) {
     59     return NewNode(simplified()->NumberLessThan(), a, b);
     60   }
     61   Node* NumberLessThanOrEqual(Node* a, Node* b) {
     62     return NewNode(simplified()->NumberLessThanOrEqual(), a, b);
     63   }
     64   Node* NumberAdd(Node* a, Node* b) {
     65     return NewNode(simplified()->NumberAdd(), a, b);
     66   }
     67   Node* NumberSubtract(Node* a, Node* b) {
     68     return NewNode(simplified()->NumberSubtract(), a, b);
     69   }
     70   Node* NumberMultiply(Node* a, Node* b) {
     71     return NewNode(simplified()->NumberMultiply(), a, b);
     72   }
     73   Node* NumberDivide(Node* a, Node* b) {
     74     return NewNode(simplified()->NumberDivide(), a, b);
     75   }
     76   Node* NumberModulus(Node* a, Node* b) {
     77     return NewNode(simplified()->NumberModulus(), a, b);
     78   }
     79   Node* NumberToInt32(Node* a) {
     80     return NewNode(simplified()->NumberToInt32(), a);
     81   }
     82   Node* NumberToUint32(Node* a) {
     83     return NewNode(simplified()->NumberToUint32(), a);
     84   }
     85 
     86   Node* StringEqual(Node* a, Node* b) {
     87     return NewNode(simplified()->StringEqual(), a, b);
     88   }
     89   Node* StringLessThan(Node* a, Node* b) {
     90     return NewNode(simplified()->StringLessThan(), a, b);
     91   }
     92   Node* StringLessThanOrEqual(Node* a, Node* b) {
     93     return NewNode(simplified()->StringLessThanOrEqual(), a, b);
     94   }
     95   Node* StringAdd(Node* a, Node* b) {
     96     return NewNode(simplified()->StringAdd(), a, b);
     97   }
     98 
     99   Node* ChangeTaggedToInt32(Node* a) {
    100     return NewNode(simplified()->ChangeTaggedToInt32(), a);
    101   }
    102   Node* ChangeTaggedToUint32(Node* a) {
    103     return NewNode(simplified()->ChangeTaggedToUint32(), a);
    104   }
    105   Node* ChangeTaggedToFloat64(Node* a) {
    106     return NewNode(simplified()->ChangeTaggedToFloat64(), a);
    107   }
    108   Node* ChangeInt32ToTagged(Node* a) {
    109     return NewNode(simplified()->ChangeInt32ToTagged(), a);
    110   }
    111   Node* ChangeUint32ToTagged(Node* a) {
    112     return NewNode(simplified()->ChangeUint32ToTagged(), a);
    113   }
    114   Node* ChangeFloat64ToTagged(Node* a) {
    115     return NewNode(simplified()->ChangeFloat64ToTagged(), a);
    116   }
    117   Node* ChangeBoolToBit(Node* a) {
    118     return NewNode(simplified()->ChangeBoolToBit(), a);
    119   }
    120   Node* ChangeBitToBool(Node* a) {
    121     return NewNode(simplified()->ChangeBitToBool(), a);
    122   }
    123 
    124   Node* LoadField(const FieldAccess& access, Node* object) {
    125     return NewNode(simplified()->LoadField(access), object);
    126   }
    127   Node* StoreField(const FieldAccess& access, Node* object, Node* value) {
    128     return NewNode(simplified()->StoreField(access), object, value);
    129   }
    130   Node* LoadElement(const ElementAccess& access, Node* object, Node* index,
    131                     Node* length) {
    132     return NewNode(simplified()->LoadElement(access), object, index, length);
    133   }
    134   Node* StoreElement(const ElementAccess& access, Node* object, Node* index,
    135                      Node* length, Node* value) {
    136     return NewNode(simplified()->StoreElement(access), object, index, length,
    137                    value);
    138   }
    139 
    140  protected:
    141   virtual Node* MakeNode(const Operator* op, int value_input_count,
    142                          Node** value_inputs) FINAL;
    143 
    144  private:
    145   Node* effect_;
    146   Node* return_;
    147   CommonOperatorBuilder* common_;
    148   MachineOperatorBuilder* machine_;
    149   SimplifiedOperatorBuilder* simplified_;
    150 };
    151 
    152 }  // namespace compiler
    153 }  // namespace internal
    154 }  // namespace v8
    155 
    156 #endif  // V8_CCTEST_COMPILER_SIMPLIFIED_GRAPH_BUILDER_H_
    157