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_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
      6 #define V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
      7 
      8 #include "src/compiler/machine-operator.h"
      9 #include "src/compiler/type-hints.h"
     10 #include "src/machine-type.h"
     11 #include "testing/gmock/include/gmock/gmock.h"
     12 
     13 namespace v8 {
     14 namespace internal {
     15 
     16 // Forward declarations.
     17 class ExternalReference;
     18 template <typename T>
     19 class Handle;
     20 class HeapObject;
     21 class Type;
     22 enum TypeofMode : int;
     23 
     24 namespace compiler {
     25 
     26 // Forward declarations.
     27 class BufferAccess;
     28 class CallDescriptor;
     29 class ContextAccess;
     30 struct ElementAccess;
     31 struct FieldAccess;
     32 class Node;
     33 
     34 
     35 using ::testing::Matcher;
     36 
     37 
     38 Matcher<Node*> IsDead();
     39 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher);
     40 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher,
     41                      const Matcher<Node*>& control1_matcher);
     42 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher,
     43                      const Matcher<Node*>& control1_matcher,
     44                      const Matcher<Node*>& control2_matcher);
     45 Matcher<Node*> IsBranch(const Matcher<Node*>& value_matcher,
     46                         const Matcher<Node*>& control_matcher);
     47 Matcher<Node*> IsMerge(const Matcher<Node*>& control0_matcher,
     48                        const Matcher<Node*>& control1_matcher);
     49 Matcher<Node*> IsMerge(const Matcher<Node*>& control0_matcher,
     50                        const Matcher<Node*>& control1_matcher,
     51                        const Matcher<Node*>& control2_matcher);
     52 Matcher<Node*> IsLoop(const Matcher<Node*>& control0_matcher,
     53                       const Matcher<Node*>& control1_matcher);
     54 Matcher<Node*> IsLoop(const Matcher<Node*>& control0_matcher,
     55                       const Matcher<Node*>& control1_matcher,
     56                       const Matcher<Node*>& control2_matcher);
     57 Matcher<Node*> IsIfTrue(const Matcher<Node*>& control_matcher);
     58 Matcher<Node*> IsIfFalse(const Matcher<Node*>& control_matcher);
     59 Matcher<Node*> IsIfSuccess(const Matcher<Node*>& control_matcher);
     60 Matcher<Node*> IsSwitch(const Matcher<Node*>& value_matcher,
     61                         const Matcher<Node*>& control_matcher);
     62 Matcher<Node*> IsIfValue(const Matcher<int32_t>& value_matcher,
     63                          const Matcher<Node*>& control_matcher);
     64 Matcher<Node*> IsIfDefault(const Matcher<Node*>& control_matcher);
     65 Matcher<Node*> IsBeginRegion(const Matcher<Node*>& effect_matcher);
     66 Matcher<Node*> IsFinishRegion(const Matcher<Node*>& value_matcher,
     67                               const Matcher<Node*>& effect_matcher);
     68 Matcher<Node*> IsReturn(const Matcher<Node*>& value_matcher,
     69                         const Matcher<Node*>& effect_matcher,
     70                         const Matcher<Node*>& control_matcher);
     71 Matcher<Node*> IsReturn2(const Matcher<Node*>& value_matcher,
     72                          const Matcher<Node*>& value2_matcher,
     73                          const Matcher<Node*>& effect_matcher,
     74                          const Matcher<Node*>& control_matcher);
     75 Matcher<Node*> IsTerminate(const Matcher<Node*>& effect_matcher,
     76                            const Matcher<Node*>& control_matcher);
     77 Matcher<Node*> IsExternalConstant(
     78     const Matcher<ExternalReference>& value_matcher);
     79 Matcher<Node*> IsHeapConstant(Handle<HeapObject> value);
     80 Matcher<Node*> IsFloat32Constant(const Matcher<float>& value_matcher);
     81 Matcher<Node*> IsFloat64Constant(const Matcher<double>& value_matcher);
     82 Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher);
     83 Matcher<Node*> IsInt64Constant(const Matcher<int64_t>& value_matcher);
     84 Matcher<Node*> IsNumberConstant(const Matcher<double>& value_matcher);
     85 Matcher<Node*> IsSelect(const Matcher<MachineRepresentation>& type_matcher,
     86                         const Matcher<Node*>& value0_matcher,
     87                         const Matcher<Node*>& value1_matcher,
     88                         const Matcher<Node*>& value2_matcher);
     89 Matcher<Node*> IsPhi(const Matcher<MachineRepresentation>& type_matcher,
     90                      const Matcher<Node*>& value0_matcher,
     91                      const Matcher<Node*>& value1_matcher,
     92                      const Matcher<Node*>& merge_matcher);
     93 Matcher<Node*> IsPhi(const Matcher<MachineRepresentation>& type_matcher,
     94                      const Matcher<Node*>& value0_matcher,
     95                      const Matcher<Node*>& value1_matcher,
     96                      const Matcher<Node*>& value2_matcher,
     97                      const Matcher<Node*>& merge_matcher);
     98 Matcher<Node*> IsEffectPhi(const Matcher<Node*>& effect0_matcher,
     99                            const Matcher<Node*>& effect1_matcher,
    100                            const Matcher<Node*>& merge_matcher);
    101 Matcher<Node*> IsProjection(const Matcher<size_t>& index_matcher,
    102                             const Matcher<Node*>& base_matcher);
    103 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    104                       const Matcher<Node*>& value0_matcher,
    105                       const Matcher<Node*>& effect_matcher,
    106                       const Matcher<Node*>& control_matcher);
    107 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    108                       const Matcher<Node*>& value0_matcher,
    109                       const Matcher<Node*>& value1_matcher,
    110                       const Matcher<Node*>& effect_matcher,
    111                       const Matcher<Node*>& control_matcher);
    112 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    113                       const Matcher<Node*>& value0_matcher,
    114                       const Matcher<Node*>& value1_matcher,
    115                       const Matcher<Node*>& value2_matcher,
    116                       const Matcher<Node*>& effect_matcher,
    117                       const Matcher<Node*>& control_matcher);
    118 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    119                       const Matcher<Node*>& value0_matcher,
    120                       const Matcher<Node*>& value1_matcher,
    121                       const Matcher<Node*>& value2_matcher,
    122                       const Matcher<Node*>& value3_matcher,
    123                       const Matcher<Node*>& effect_matcher,
    124                       const Matcher<Node*>& control_matcher);
    125 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    126                       const Matcher<Node*>& value0_matcher,
    127                       const Matcher<Node*>& value1_matcher,
    128                       const Matcher<Node*>& value2_matcher,
    129                       const Matcher<Node*>& value3_matcher,
    130                       const Matcher<Node*>& value4_matcher,
    131                       const Matcher<Node*>& effect_matcher,
    132                       const Matcher<Node*>& control_matcher);
    133 Matcher<Node*> IsCall(const Matcher<const CallDescriptor*>& descriptor_matcher,
    134                       const Matcher<Node*>& value0_matcher,
    135                       const Matcher<Node*>& value1_matcher,
    136                       const Matcher<Node*>& value2_matcher,
    137                       const Matcher<Node*>& value3_matcher,
    138                       const Matcher<Node*>& value4_matcher,
    139                       const Matcher<Node*>& value5_matcher,
    140                       const Matcher<Node*>& effect_matcher,
    141                       const Matcher<Node*>& control_matcher);
    142 Matcher<Node*> IsCall(
    143     const Matcher<const CallDescriptor*>& descriptor_matcher,
    144     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    145     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    146     const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
    147     const Matcher<Node*>& value6_matcher, const Matcher<Node*>& effect_matcher,
    148     const Matcher<Node*>& control_matcher);
    149 Matcher<Node*> IsTailCall(
    150     const Matcher<CallDescriptor const*>& descriptor_matcher,
    151     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    152     const Matcher<Node*>& effect_matcher,
    153     const Matcher<Node*>& control_matcher);
    154 Matcher<Node*> IsTailCall(
    155     const Matcher<CallDescriptor const*>& descriptor_matcher,
    156     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    157     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& effect_matcher,
    158     const Matcher<Node*>& control_matcher);
    159 Matcher<Node*> IsTailCall(
    160     const Matcher<CallDescriptor const*>& descriptor_matcher,
    161     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    162     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    163     const Matcher<Node*>& effect_matcher,
    164     const Matcher<Node*>& control_matcher);
    165 Matcher<Node*> IsTailCall(
    166     const Matcher<CallDescriptor const*>& descriptor_matcher,
    167     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    168     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    169     const Matcher<Node*>& value4_matcher, const Matcher<Node*>& effect_matcher,
    170     const Matcher<Node*>& control_matcher);
    171 Matcher<Node*> IsTailCall(
    172     const Matcher<CallDescriptor const*>& descriptor_matcher,
    173     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    174     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    175     const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
    176     const Matcher<Node*>& effect_matcher,
    177     const Matcher<Node*>& control_matcher);
    178 Matcher<Node*> IsTailCall(
    179     const Matcher<CallDescriptor const*>& descriptor_matcher,
    180     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    181     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    182     const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
    183     const Matcher<Node*>& value6_matcher, const Matcher<Node*>& effect_matcher,
    184     const Matcher<Node*>& control_matcher);
    185 Matcher<Node*> IsTailCall(
    186     const Matcher<CallDescriptor const*>& descriptor_matcher,
    187     const Matcher<Node*>& value0_matcher, const Matcher<Node*>& value1_matcher,
    188     const Matcher<Node*>& value2_matcher, const Matcher<Node*>& value3_matcher,
    189     const Matcher<Node*>& value4_matcher, const Matcher<Node*>& value5_matcher,
    190     const Matcher<Node*>& value6_matcher, const Matcher<Node*>& value7_matcher,
    191     const Matcher<Node*>& effect_matcher,
    192     const Matcher<Node*>& control_matcher);
    193 
    194 
    195 Matcher<Node*> IsBooleanNot(const Matcher<Node*>& value_matcher);
    196 Matcher<Node*> IsReferenceEqual(const Matcher<Type*>& type_matcher,
    197                                 const Matcher<Node*>& lhs_matcher,
    198                                 const Matcher<Node*>& rhs_matcher);
    199 Matcher<Node*> IsNumberEqual(const Matcher<Node*>& lhs_matcher,
    200                              const Matcher<Node*>& rhs_matcher);
    201 Matcher<Node*> IsNumberLessThan(const Matcher<Node*>& lhs_matcher,
    202                                 const Matcher<Node*>& rhs_matcher);
    203 Matcher<Node*> IsNumberAdd(const Matcher<Node*>& lhs_matcher,
    204                            const Matcher<Node*>& rhs_matcher);
    205 Matcher<Node*> IsSpeculativeNumberAdd(
    206     const Matcher<BinaryOperationHints::Hint>& hint_matcher,
    207     const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
    208     const Matcher<Node*>& effect_matcher,
    209     const Matcher<Node*>& control_matcher);
    210 Matcher<Node*> IsSpeculativeNumberSubtract(
    211     const Matcher<BinaryOperationHints::Hint>& hint_matcher,
    212     const Matcher<Node*>& lhs_matcher, const Matcher<Node*>& rhs_matcher,
    213     const Matcher<Node*>& effect_matcher,
    214     const Matcher<Node*>& control_matcher);
    215 Matcher<Node*> IsNumberSubtract(const Matcher<Node*>& lhs_matcher,
    216                                 const Matcher<Node*>& rhs_matcher);
    217 Matcher<Node*> IsNumberMultiply(const Matcher<Node*>& lhs_matcher,
    218                                 const Matcher<Node*>& rhs_matcher);
    219 Matcher<Node*> IsNumberShiftLeft(const Matcher<Node*>& lhs_matcher,
    220                                  const Matcher<Node*>& rhs_matcher);
    221 Matcher<Node*> IsNumberShiftRight(const Matcher<Node*>& lhs_matcher,
    222                                   const Matcher<Node*>& rhs_matcher);
    223 Matcher<Node*> IsNumberShiftRightLogical(const Matcher<Node*>& lhs_matcher,
    224                                          const Matcher<Node*>& rhs_matcher);
    225 Matcher<Node*> IsNumberImul(const Matcher<Node*>& lhs_matcher,
    226                             const Matcher<Node*>& rhs_matcher);
    227 Matcher<Node*> IsNumberAbs(const Matcher<Node*>& value_matcher);
    228 Matcher<Node*> IsNumberAtan(const Matcher<Node*>& value_matcher);
    229 Matcher<Node*> IsNumberAtan2(const Matcher<Node*>& lhs_matcher,
    230                              const Matcher<Node*>& rhs_matcher);
    231 Matcher<Node*> IsNumberAtanh(const Matcher<Node*>& value_matcher);
    232 Matcher<Node*> IsNumberCeil(const Matcher<Node*>& value_matcher);
    233 Matcher<Node*> IsNumberClz32(const Matcher<Node*>& value_matcher);
    234 Matcher<Node*> IsNumberCos(const Matcher<Node*>& value_matcher);
    235 Matcher<Node*> IsNumberExp(const Matcher<Node*>& value_matcher);
    236 Matcher<Node*> IsNumberExpm1(const Matcher<Node*>& value_matcher);
    237 Matcher<Node*> IsNumberFloor(const Matcher<Node*>& value_matcher);
    238 Matcher<Node*> IsNumberFround(const Matcher<Node*>& value_matcher);
    239 Matcher<Node*> IsNumberLog(const Matcher<Node*>& value_matcher);
    240 Matcher<Node*> IsNumberLog1p(const Matcher<Node*>& value_matcher);
    241 Matcher<Node*> IsNumberLog2(const Matcher<Node*>& value_matcher);
    242 Matcher<Node*> IsNumberLog10(const Matcher<Node*>& value_matcher);
    243 Matcher<Node*> IsNumberRound(const Matcher<Node*>& value_matcher);
    244 Matcher<Node*> IsNumberCbrt(const Matcher<Node*>& value_matcher);
    245 Matcher<Node*> IsNumberSin(const Matcher<Node*>& value_matcher);
    246 Matcher<Node*> IsNumberSqrt(const Matcher<Node*>& value_matcher);
    247 Matcher<Node*> IsNumberTan(const Matcher<Node*>& value_matcher);
    248 Matcher<Node*> IsNumberTrunc(const Matcher<Node*>& value_matcher);
    249 Matcher<Node*> IsStringFromCharCode(const Matcher<Node*>& value_matcher);
    250 Matcher<Node*> IsAllocate(const Matcher<Node*>& size_matcher,
    251                           const Matcher<Node*>& effect_matcher,
    252                           const Matcher<Node*>& control_matcher);
    253 Matcher<Node*> IsLoadField(const Matcher<FieldAccess>& access_matcher,
    254                            const Matcher<Node*>& base_matcher,
    255                            const Matcher<Node*>& effect_matcher,
    256                            const Matcher<Node*>& control_matcher);
    257 Matcher<Node*> IsStoreField(const Matcher<FieldAccess>& access_matcher,
    258                             const Matcher<Node*>& base_matcher,
    259                             const Matcher<Node*>& value_matcher,
    260                             const Matcher<Node*>& effect_matcher,
    261                             const Matcher<Node*>& control_matcher);
    262 Matcher<Node*> IsLoadBuffer(const Matcher<BufferAccess>& access_matcher,
    263                             const Matcher<Node*>& buffer_matcher,
    264                             const Matcher<Node*>& offset_matcher,
    265                             const Matcher<Node*>& length_matcher,
    266                             const Matcher<Node*>& effect_matcher,
    267                             const Matcher<Node*>& control_matcher);
    268 Matcher<Node*> IsStoreBuffer(const Matcher<BufferAccess>& access_matcher,
    269                              const Matcher<Node*>& buffer_matcher,
    270                              const Matcher<Node*>& offset_matcher,
    271                              const Matcher<Node*>& length_matcher,
    272                              const Matcher<Node*>& value_matcher,
    273                              const Matcher<Node*>& effect_matcher,
    274                              const Matcher<Node*>& control_matcher);
    275 Matcher<Node*> IsLoadElement(const Matcher<ElementAccess>& access_matcher,
    276                              const Matcher<Node*>& base_matcher,
    277                              const Matcher<Node*>& index_matcher,
    278                              const Matcher<Node*>& control_matcher,
    279                              const Matcher<Node*>& effect_matcher);
    280 Matcher<Node*> IsStoreElement(const Matcher<ElementAccess>& access_matcher,
    281                               const Matcher<Node*>& base_matcher,
    282                               const Matcher<Node*>& index_matcher,
    283                               const Matcher<Node*>& value_matcher,
    284                               const Matcher<Node*>& effect_matcher,
    285                               const Matcher<Node*>& control_matcher);
    286 Matcher<Node*> IsObjectIsReceiver(const Matcher<Node*>& value_matcher);
    287 Matcher<Node*> IsObjectIsSmi(const Matcher<Node*>& value_matcher);
    288 
    289 Matcher<Node*> IsLoad(const Matcher<LoadRepresentation>& rep_matcher,
    290                       const Matcher<Node*>& base_matcher,
    291                       const Matcher<Node*>& index_matcher,
    292                       const Matcher<Node*>& effect_matcher,
    293                       const Matcher<Node*>& control_matcher);
    294 Matcher<Node*> IsStore(const Matcher<StoreRepresentation>& rep_matcher,
    295                        const Matcher<Node*>& base_matcher,
    296                        const Matcher<Node*>& index_matcher,
    297                        const Matcher<Node*>& value_matcher,
    298                        const Matcher<Node*>& effect_matcher,
    299                        const Matcher<Node*>& control_matcher);
    300 Matcher<Node*> IsStackSlot(const Matcher<MachineRepresentation>& rep_matcher);
    301 Matcher<Node*> IsWord32And(const Matcher<Node*>& lhs_matcher,
    302                            const Matcher<Node*>& rhs_matcher);
    303 Matcher<Node*> IsWord32Or(const Matcher<Node*>& lhs_matcher,
    304                           const Matcher<Node*>& rhs_matcher);
    305 Matcher<Node*> IsWord32Xor(const Matcher<Node*>& lhs_matcher,
    306                            const Matcher<Node*>& rhs_matcher);
    307 Matcher<Node*> IsWord32Sar(const Matcher<Node*>& lhs_matcher,
    308                            const Matcher<Node*>& rhs_matcher);
    309 Matcher<Node*> IsWord32Shl(const Matcher<Node*>& lhs_matcher,
    310                            const Matcher<Node*>& rhs_matcher);
    311 Matcher<Node*> IsWord32Shr(const Matcher<Node*>& lhs_matcher,
    312                            const Matcher<Node*>& rhs_matcher);
    313 Matcher<Node*> IsWord32Ror(const Matcher<Node*>& lhs_matcher,
    314                            const Matcher<Node*>& rhs_matcher);
    315 Matcher<Node*> IsWord32Equal(const Matcher<Node*>& lhs_matcher,
    316                              const Matcher<Node*>& rhs_matcher);
    317 Matcher<Node*> IsWord32Clz(const Matcher<Node*>& value_matcher);
    318 Matcher<Node*> IsWord32Ctz(const Matcher<Node*>& value_matcher);
    319 Matcher<Node*> IsWord32Popcnt(const Matcher<Node*>& value_matcher);
    320 Matcher<Node*> IsWord64And(const Matcher<Node*>& lhs_matcher,
    321                            const Matcher<Node*>& rhs_matcher);
    322 Matcher<Node*> IsWord64Or(const Matcher<Node*>& lhs_matcher,
    323                           const Matcher<Node*>& rhs_matcher);
    324 Matcher<Node*> IsWord64Shl(const Matcher<Node*>& lhs_matcher,
    325                            const Matcher<Node*>& rhs_matcher);
    326 Matcher<Node*> IsWord64Sar(const Matcher<Node*>& lhs_matcher,
    327                            const Matcher<Node*>& rhs_matcher);
    328 Matcher<Node*> IsWord64Equal(const Matcher<Node*>& lhs_matcher,
    329                              const Matcher<Node*>& rhs_matcher);
    330 Matcher<Node*> IsInt32AddWithOverflow(const Matcher<Node*>& lhs_matcher,
    331                                       const Matcher<Node*>& rhs_matcher);
    332 Matcher<Node*> IsInt32Add(const Matcher<Node*>& lhs_matcher,
    333                           const Matcher<Node*>& rhs_matcher);
    334 Matcher<Node*> IsInt32Sub(const Matcher<Node*>& lhs_matcher,
    335                           const Matcher<Node*>& rhs_matcher);
    336 Matcher<Node*> IsInt32Mul(const Matcher<Node*>& lhs_matcher,
    337                           const Matcher<Node*>& rhs_matcher);
    338 Matcher<Node*> IsInt32MulHigh(const Matcher<Node*>& lhs_matcher,
    339                               const Matcher<Node*>& rhs_matcher);
    340 Matcher<Node*> IsInt32LessThan(const Matcher<Node*>& lhs_matcher,
    341                                const Matcher<Node*>& rhs_matcher);
    342 Matcher<Node*> IsUint32LessThan(const Matcher<Node*>& lhs_matcher,
    343                                 const Matcher<Node*>& rhs_matcher);
    344 Matcher<Node*> IsUint32LessThanOrEqual(const Matcher<Node*>& lhs_matcher,
    345                                        const Matcher<Node*>& rhs_matcher);
    346 Matcher<Node*> IsInt64Add(const Matcher<Node*>& lhs_matcher,
    347                           const Matcher<Node*>& rhs_matcher);
    348 Matcher<Node*> IsInt64Sub(const Matcher<Node*>& lhs_matcher,
    349                           const Matcher<Node*>& rhs_matcher);
    350 Matcher<Node*> IsJSAdd(const Matcher<Node*>& lhs_matcher,
    351                        const Matcher<Node*>& rhs_matcher);
    352 Matcher<Node*> IsTruncateFloat64ToWord32(const Matcher<Node*>& input_matcher);
    353 Matcher<Node*> IsChangeFloat64ToInt32(const Matcher<Node*>& input_matcher);
    354 Matcher<Node*> IsChangeFloat64ToUint32(const Matcher<Node*>& input_matcher);
    355 Matcher<Node*> IsChangeInt32ToFloat64(const Matcher<Node*>& input_matcher);
    356 Matcher<Node*> IsChangeInt32ToInt64(const Matcher<Node*>& input_matcher);
    357 Matcher<Node*> IsChangeUint32ToFloat64(const Matcher<Node*>& input_matcher);
    358 Matcher<Node*> IsChangeUint32ToUint64(const Matcher<Node*>& input_matcher);
    359 Matcher<Node*> IsTruncateFloat64ToFloat32(const Matcher<Node*>& input_matcher);
    360 Matcher<Node*> IsTruncateInt64ToInt32(const Matcher<Node*>& input_matcher);
    361 Matcher<Node*> IsFloat32Max(const Matcher<Node*>& lhs_matcher,
    362                             const Matcher<Node*>& rhs_matcher);
    363 Matcher<Node*> IsFloat32Min(const Matcher<Node*>& lhs_matcher,
    364                             const Matcher<Node*>& rhs_matcher);
    365 Matcher<Node*> IsFloat32Abs(const Matcher<Node*>& input_matcher);
    366 Matcher<Node*> IsFloat32Equal(const Matcher<Node*>& lhs_matcher,
    367                               const Matcher<Node*>& rhs_matcher);
    368 Matcher<Node*> IsFloat32LessThan(const Matcher<Node*>& lhs_matcher,
    369                                  const Matcher<Node*>& rhs_matcher);
    370 Matcher<Node*> IsFloat32LessThanOrEqual(const Matcher<Node*>& lhs_matcher,
    371                                         const Matcher<Node*>& rhs_matcher);
    372 Matcher<Node*> IsFloat64Max(const Matcher<Node*>& lhs_matcher,
    373                             const Matcher<Node*>& rhs_matcher);
    374 Matcher<Node*> IsFloat64Min(const Matcher<Node*>& lhs_matcher,
    375                             const Matcher<Node*>& rhs_matcher);
    376 Matcher<Node*> IsFloat64Sub(const Matcher<Node*>& lhs_matcher,
    377                             const Matcher<Node*>& rhs_matcher);
    378 Matcher<Node*> IsFloat64Abs(const Matcher<Node*>& input_matcher);
    379 Matcher<Node*> IsFloat64Sqrt(const Matcher<Node*>& input_matcher);
    380 Matcher<Node*> IsFloat64RoundDown(const Matcher<Node*>& input_matcher);
    381 Matcher<Node*> IsFloat64RoundTruncate(const Matcher<Node*>& input_matcher);
    382 Matcher<Node*> IsFloat64RoundTiesAway(const Matcher<Node*>& input_matcher);
    383 Matcher<Node*> IsFloat64ExtractLowWord32(const Matcher<Node*>& input_matcher);
    384 Matcher<Node*> IsFloat64ExtractHighWord32(const Matcher<Node*>& input_matcher);
    385 Matcher<Node*> IsFloat64InsertLowWord32(const Matcher<Node*>& lhs_matcher,
    386                                         const Matcher<Node*>& rhs_matcher);
    387 Matcher<Node*> IsFloat64InsertHighWord32(const Matcher<Node*>& lhs_matcher,
    388                                          const Matcher<Node*>& rhs_matcher);
    389 Matcher<Node*> IsToNumber(const Matcher<Node*>& base_matcher,
    390                           const Matcher<Node*>& context_matcher,
    391                           const Matcher<Node*>& effect_matcher,
    392                           const Matcher<Node*>& control_matcher);
    393 Matcher<Node*> IsLoadContext(const Matcher<ContextAccess>& access_matcher,
    394                              const Matcher<Node*>& context_matcher);
    395 Matcher<Node*> IsNumberToInt32(const Matcher<Node*>& input_matcher);
    396 Matcher<Node*> IsNumberToUint32(const Matcher<Node*>& input_matcher);
    397 Matcher<Node*> IsParameter(const Matcher<int> index_matcher);
    398 Matcher<Node*> IsLoadFramePointer();
    399 Matcher<Node*> IsLoadParentFramePointer();
    400 Matcher<Node*> IsPlainPrimitiveToNumber(const Matcher<Node*>& input_matcher);
    401 
    402 Matcher<Node*> IsInt32PairAdd(const Matcher<Node*>& a_matcher,
    403                               const Matcher<Node*>& b_matcher,
    404                               const Matcher<Node*>& c_matcher,
    405                               const Matcher<Node*>& d_matcher);
    406 Matcher<Node*> IsInt32PairSub(const Matcher<Node*>& a_matcher,
    407                               const Matcher<Node*>& b_matcher,
    408                               const Matcher<Node*>& c_matcher,
    409                               const Matcher<Node*>& d_matcher);
    410 Matcher<Node*> IsInt32PairMul(const Matcher<Node*>& a_matcher,
    411                               const Matcher<Node*>& b_matcher,
    412                               const Matcher<Node*>& c_matcher,
    413                               const Matcher<Node*>& d_matcher);
    414 
    415 Matcher<Node*> IsWord32PairShl(const Matcher<Node*>& lhs_matcher,
    416                                const Matcher<Node*>& mid_matcher,
    417                                const Matcher<Node*>& rhs_matcher);
    418 Matcher<Node*> IsWord32PairShr(const Matcher<Node*>& lhs_matcher,
    419                                const Matcher<Node*>& mid_matcher,
    420                                const Matcher<Node*>& rhs_matcher);
    421 
    422 Matcher<Node*> IsWord32PairSar(const Matcher<Node*>& lhs_matcher,
    423                                const Matcher<Node*>& mid_matcher,
    424                                const Matcher<Node*>& rhs_matcher);
    425 
    426 Matcher<Node*> IsStackSlot();
    427 Matcher<Node*> IsTypeGuard(const Matcher<Type*>& type_matcher,
    428                            const Matcher<Node*>& value_matcher,
    429                            const Matcher<Node*>& control_matcher);
    430 
    431 }  // namespace compiler
    432 }  // namespace internal
    433 }  // namespace v8
    434 
    435 #endif  // V8_UNITTESTS_COMPILER_NODE_TEST_UTILS_H_
    436