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_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      246317 :     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        2480 :   Node* Word32And(Node* lhs, uint32_t rhs) {
      48        2480 :     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      129631 :   Reduction ReplaceBool(bool value) { return ReplaceInt32(value ? 1 : 0); }
      60             :   Reduction ReplaceFloat32(volatile float value) {
      61       92698 :     return Replace(Float32Constant(value));
      62             :   }
      63             :   Reduction ReplaceFloat64(volatile double value) {
      64       99647 :     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      560777 :     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_