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_MACHINE_OPERATOR_REDUCER_H_
      6 #define V8_COMPILER_MACHINE_OPERATOR_REDUCER_H_
      7 
      8 #include "src/base/compiler-specific.h"
      9 #include "src/compiler/graph-reducer.h"
     10 #include "src/compiler/machine-operator.h"
     11 #include "src/globals.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 namespace compiler {
     16 
     17 // Forward declarations.
     18 class CommonOperatorBuilder;
     19 class JSGraph;
     20 
     21 
     22 // Performs constant folding and strength reduction on nodes that have
     23 // machine operators.
     24 class V8_EXPORT_PRIVATE MachineOperatorReducer final
     25     : public NON_EXPORTED_BASE(Reducer) {
     26  public:
     27   explicit MachineOperatorReducer(JSGraph* jsgraph,
     28                                   bool allow_signalling_nan = true);
     29   ~MachineOperatorReducer();
     30 
     31   Reduction Reduce(Node* node) override;
     32 
     33  private:
     34   Node* Float32Constant(volatile float value);
     35   Node* Float64Constant(volatile double value);
     36   Node* Int32Constant(int32_t value);
     37   Node* Int64Constant(int64_t value);
     38   Node* Uint32Constant(uint32_t value) {
     39     return Int32Constant(bit_cast<int32_t>(value));
     40   }
     41   Node* Uint64Constant(uint64_t value) {
     42     return Int64Constant(bit_cast<int64_t>(value));
     43   }
     44   Node* Float64Mul(Node* lhs, Node* rhs);
     45   Node* Float64PowHalf(Node* value);
     46   Node* Word32And(Node* lhs, Node* rhs);
     47   Node* Word32And(Node* lhs, uint32_t rhs) {
     48     return Word32And(lhs, Uint32Constant(rhs));
     49   }
     50   Node* Word32Sar(Node* lhs, uint32_t rhs);
     51   Node* Word32Shr(Node* lhs, uint32_t rhs);
     52   Node* Word32Equal(Node* lhs, Node* rhs);
     53   Node* Int32Add(Node* lhs, Node* rhs);
     54   Node* Int32Sub(Node* lhs, Node* rhs);
     55   Node* Int32Mul(Node* lhs, Node* rhs);
     56   Node* Int32Div(Node* dividend, int32_t divisor);
     57   Node* Uint32Div(Node* dividend, uint32_t divisor);
     58 
     59   Reduction ReplaceBool(bool value) { return ReplaceInt32(value ? 1 : 0); }
     60   Reduction ReplaceFloat32(volatile float value) {
     61     return Replace(Float32Constant(value));
     62   }
     63   Reduction ReplaceFloat64(volatile double value) {
     64     return Replace(Float64Constant(value));
     65   }
     66   Reduction ReplaceInt32(int32_t value) {
     67     return Replace(Int32Constant(value));
     68   }
     69   Reduction ReplaceUint32(uint32_t value) {
     70     return Replace(Uint32Constant(value));
     71   }
     72   Reduction ReplaceInt64(int64_t value) {
     73     return Replace(Int64Constant(value));
     74   }
     75 
     76   Reduction ReduceInt32Add(Node* node);
     77   Reduction ReduceInt64Add(Node* node);
     78   Reduction ReduceInt32Sub(Node* node);
     79   Reduction ReduceInt64Sub(Node* node);
     80   Reduction ReduceInt32Div(Node* node);
     81   Reduction ReduceUint32Div(Node* node);
     82   Reduction ReduceInt32Mod(Node* node);
     83   Reduction ReduceUint32Mod(Node* node);
     84   Reduction ReduceStore(Node* node);
     85   Reduction ReduceProjection(size_t index, Node* node);
     86   Reduction ReduceWord32Shifts(Node* node);
     87   Reduction ReduceWord32Shl(Node* node);
     88   Reduction ReduceWord64Shl(Node* node);
     89   Reduction ReduceWord32Shr(Node* node);
     90   Reduction ReduceWord64Shr(Node* node);
     91   Reduction ReduceWord32Sar(Node* node);
     92   Reduction ReduceWord64Sar(Node* node);
     93   Reduction ReduceWord32And(Node* node);
     94   Reduction TryMatchWord32Ror(Node* node);
     95   Reduction ReduceWord32Or(Node* node);
     96   Reduction ReduceWord32Xor(Node* node);
     97   Reduction ReduceFloat64InsertLowWord32(Node* node);
     98   Reduction ReduceFloat64InsertHighWord32(Node* node);
     99   Reduction ReduceFloat64Compare(Node* node);
    100   Reduction ReduceFloat64RoundDown(Node* node);
    101 
    102   Graph* graph() const;
    103   JSGraph* jsgraph() const { return jsgraph_; }
    104   CommonOperatorBuilder* common() const;
    105   MachineOperatorBuilder* machine() const;
    106 
    107   JSGraph* jsgraph_;
    108   bool allow_signalling_nan_;
    109 };
    110 
    111 }  // namespace compiler
    112 }  // namespace internal
    113 }  // namespace v8
    114 
    115 #endif  // V8_COMPILER_MACHINE_OPERATOR_REDUCER_H_
    116