../deps/v8/src/compiler/machine-operator-reducer.cc

Bug Summary

File:	out/../deps/v8/src/compiler/machine-operator-reducer.cc
Warning:	line 269, column 11 Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name machine-operator-reducer.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/compiler/machine-operator-reducer.cc

../deps/v8/src/compiler/machine-operator-reducer.cc

→

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.

5#include "src/compiler/machine-operator-reducer.h"

7#include <cmath>
8#include <limits>

10#include "src/base/bits.h"
11#include "src/base/division-by-constant.h"
12#include "src/base/ieee754.h"
13#include "src/base/logging.h"
14#include "src/base/overflowing-math.h"
15#include "src/codegen/tnode.h"
16#include "src/compiler/diamond.h"
17#include "src/compiler/graph.h"
18#include "src/compiler/js-operator.h"
19#include "src/compiler/machine-graph.h"
20#include "src/compiler/node-matchers.h"
21#include "src/compiler/node-properties.h"
22#include "src/compiler/opcodes.h"
23#include "src/numbers/conversions-inl.h"

25namespace v8 {
26namespace internal {
27namespace compiler {

29// Some optimizations performed by the MachineOperatorReducer can be applied
30// to both Word32 and Word64 operations. Those are implemented in a generic
31// way to be reused for different word sizes.
32// This class adapts a generic algorithm to Word32 operations.
33class Word32Adapter {
public:
using IntNBinopMatcher = Int32BinopMatcher;
using UintNBinopMatcher = Uint32BinopMatcher;
using intN_t = int32_t;
// WORD_SIZE refers to the N for which this adapter specializes.
static constexpr std::size_t WORD_SIZE = 32;

explicit Word32Adapter(MachineOperatorReducer* reducer) : r_(reducer) {}

template <typename T>
static bool IsWordNAnd(const T& x) {
  return x.IsWord32And();
}
template <typename T>
static bool IsWordNShl(const T& x) {
  return x.IsWord32Shl();
}
template <typename T>
static bool IsWordNShr(const T& x) {
  return x.IsWord32Shr();
}
template <typename T>
static bool IsWordNSar(const T& x) {
  return x.IsWord32Sar();
}
template <typename T>
static bool IsWordNXor(const T& x) {
  return x.IsWord32Xor();
}
template <typename T>
static bool IsIntNAdd(const T& x) {
  return x.IsInt32Add();
}
template <typename T>
static bool IsIntNMul(const T& x) {
  return x.IsInt32Mul();
}

const Operator* IntNAdd(MachineOperatorBuilder* machine) {
  return machine->Int32Add();
}

Reduction ReplaceIntN(int32_t value) { return r_->ReplaceInt32(value); }
Reduction ReduceWordNAnd(Node* node) { return r_->ReduceWord32And(node); }
Reduction ReduceIntNAdd(Node* node) { return r_->ReduceInt32Add(node); }
Reduction TryMatchWordNRor(Node* node) { return r_->TryMatchWord32Ror(node); }

Node* IntNConstant(int32_t value) { return r_->Int32Constant(value); }
Node* UintNConstant(uint32_t value) { return r_->Uint32Constant(value); }
Node* WordNAnd(Node* lhs, Node* rhs) { return r_->Word32And(lhs, rhs); }

private:
MachineOperatorReducer* r_;
87};

89// Some optimizations performed by the MachineOperatorReducer can be applied
90// to both Word32 and Word64 operations. Those are implemented in a generic
91// way to be reused for different word sizes.
92// This class adapts a generic algorithm to Word64 operations.
93class Word64Adapter {
public:
using IntNBinopMatcher = Int64BinopMatcher;
using UintNBinopMatcher = Uint64BinopMatcher;
using intN_t = int64_t;
// WORD_SIZE refers to the N for which this adapter specializes.
static constexpr std::size_t WORD_SIZE = 64;

explicit Word64Adapter(MachineOperatorReducer* reducer) : r_(reducer) {}

template <typename T>
static bool IsWordNAnd(const T& x) {
  return x.IsWord64And();
}
template <typename T>
static bool IsWordNShl(const T& x) {
  return x.IsWord64Shl();
}
template <typename T>
static bool IsWordNShr(const T& x) {
  return x.IsWord64Shr();
}
template <typename T>
static bool IsWordNSar(const T& x) {
  return x.IsWord64Sar();
}
template <typename T>
static bool IsWordNXor(const T& x) {
  return x.IsWord64Xor();
}
template <typename T>
static bool IsIntNAdd(const T& x) {
  return x.IsInt64Add();
}
template <typename T>
static bool IsIntNMul(const T& x) {
  return x.IsInt64Mul();
}

static const Operator* IntNAdd(MachineOperatorBuilder* machine) {
  return machine->Int64Add();
}

Reduction ReplaceIntN(int64_t value) { return r_->ReplaceInt64(value); }
Reduction ReduceWordNAnd(Node* node) { return r_->ReduceWord64And(node); }
Reduction ReduceIntNAdd(Node* node) { return r_->ReduceInt64Add(node); }
Reduction TryMatchWordNRor(Node* node) {
  // TODO(nicohartmann@): Add a MachineOperatorReducer::TryMatchWord64Ror.
  return r_->NoChange();
}

Node* IntNConstant(int64_t value) { return r_->Int64Constant(value); }
Node* UintNConstant(uint64_t value) { return r_->Uint64Constant(value); }
Node* WordNAnd(Node* lhs, Node* rhs) { return r_->Word64And(lhs, rhs); }

private:
MachineOperatorReducer* r_;
150};

152namespace {

154// TODO(jgruber): Consider replacing all uses of this function by
155// std::numeric_limits<T>::quiet_NaN().
156template <class T>
157T SilenceNaN(T x) {
DCHECK(std::isnan(x))((void) 0);
// Do some calculation to make a signalling NaN quiet.
return x - x;
161}

163}  // namespace

165MachineOperatorReducer::MachineOperatorReducer(Editor* editor,
                                             MachineGraph* mcgraph,
                                             bool allow_signalling_nan)
  : AdvancedReducer(editor),
    mcgraph_(mcgraph),
    allow_signalling_nan_(allow_signalling_nan) {}

172MachineOperatorReducer::~MachineOperatorReducer() = default;


175Node* MachineOperatorReducer::Float32Constant(volatile float value) {
return graph()->NewNode(common()->Float32Constant(value));
177}

179Node* MachineOperatorReducer::Float64Constant(volatile double value) {
return mcgraph()->Float64Constant(value);
181}

183Node* MachineOperatorReducer::Int32Constant(int32_t value) {
return mcgraph()->Int32Constant(value);
185}

187Node* MachineOperatorReducer::Int64Constant(int64_t value) {
return graph()->NewNode(common()->Int64Constant(value));
189}

191Node* MachineOperatorReducer::Float64Mul(Node* lhs, Node* rhs) {
return graph()->NewNode(machine()->Float64Mul(), lhs, rhs);
193}

195Node* MachineOperatorReducer::Float64PowHalf(Node* value) {
value =
    graph()->NewNode(machine()->Float64Add(), Float64Constant(0.0), value);
Diamond d(graph(), common(),
          graph()->NewNode(machine()->Float64LessThanOrEqual(), value,
                           Float64Constant(-V8_INFINITYstd::numeric_limits<double>::infinity())),
          BranchHint::kFalse);
return d.Phi(MachineRepresentation::kFloat64, Float64Constant(V8_INFINITYstd::numeric_limits<double>::infinity()),
             graph()->NewNode(machine()->Float64Sqrt(), value));
204}

206Node* MachineOperatorReducer::Word32And(Node* lhs, Node* rhs) {
Node* const node = graph()->NewNode(machine()->Word32And(), lhs, rhs);
Reduction const reduction = ReduceWord32And(node);
return reduction.Changed() ? reduction.replacement() : node;
210}

212Node* MachineOperatorReducer::Word32Sar(Node* lhs, uint32_t rhs) {
if (rhs == 0) return lhs;
return graph()->NewNode(machine()->Word32Sar(), lhs, Uint32Constant(rhs));
215}

217Node* MachineOperatorReducer::Word32Shr(Node* lhs, uint32_t rhs) {
if (rhs == 0) return lhs;
return graph()->NewNode(machine()->Word32Shr(), lhs, Uint32Constant(rhs));
220}

222Node* MachineOperatorReducer::Word32Equal(Node* lhs, Node* rhs) {
return graph()->NewNode(machine()->Word32Equal(), lhs, rhs);
224}

226Node* MachineOperatorReducer::Word64And(Node* lhs, Node* rhs) {
Node* const node = graph()->NewNode(machine()->Word64And(), lhs, rhs);
Reduction const reduction = ReduceWord64And(node);
return reduction.Changed() ? reduction.replacement() : node;
230}

232Node* MachineOperatorReducer::Int32Add(Node* lhs, Node* rhs) {
Node* const node = graph()->NewNode(machine()->Int32Add(), lhs, rhs);
Reduction const reduction = ReduceInt32Add(node);
return reduction.Changed() ? reduction.replacement() : node;
236}

238Node* MachineOperatorReducer::Int32Sub(Node* lhs, Node* rhs) {
Node* const node = graph()->NewNode(machine()->Int32Sub(), lhs, rhs);
Reduction const reduction = ReduceInt32Sub(node);
return reduction.Changed() ? reduction.replacement() : node;
242}

244Node* MachineOperatorReducer::Int32Mul(Node* lhs, Node* rhs) {
return graph()->NewNode(machine()->Int32Mul(), lhs, rhs);
246}

248Node* MachineOperatorReducer::Int32Div(Node* dividend, int32_t divisor) {
DCHECK_NE(0, divisor)((void) 0);
DCHECK_NE(std::numeric_limits<int32_t>::min(), divisor)((void) 0);
base::MagicNumbersForDivision<uint32_t> const mag =
    base::SignedDivisionByConstant(bit_cast<uint32_t>(divisor));
Node* quotient = graph()->NewNode(machine()->Int32MulHigh(), dividend,
                                  Uint32Constant(mag.multiplier));
if (divisor > 0 && bit_cast<int32_t>(mag.multiplier) < 0) {
  quotient = Int32Add(quotient, dividend);
} else if (divisor < 0 && bit_cast<int32_t>(mag.multiplier) > 0) {
  quotient = Int32Sub(quotient, dividend);
}
return Int32Add(Word32Sar(quotient, mag.shift), Word32Shr(dividend, 31));
261}

263Node* MachineOperatorReducer::Uint32Div(Node* dividend, uint32_t divisor) {
DCHECK_LT(0u, divisor)((void) 0);
// If the divisor is even, we can avoid using the expensive fixup by shifting
// the dividend upfront.
unsigned const shift = base::bits::CountTrailingZeros(divisor);
1
Calling 'CountTrailingZeros<unsigned int, 32U>'→
5
←
Returning from 'CountTrailingZeros<unsigned int, 32U>'→
6
←
'shift' initialized to 32→
dividend = Word32Shr(dividend, shift);
divisor >>= shift;
7
←
Assigned value is garbage or undefined
// Compute the magic number for the (shifted) divisor.
base::MagicNumbersForDivision<uint32_t> const mag =
    base::UnsignedDivisionByConstant(divisor, shift);
Node* quotient = graph()->NewNode(machine()->Uint32MulHigh(), dividend,
                                  Uint32Constant(mag.multiplier));
if (mag.add) {
  DCHECK_LE(1u, mag.shift)((void) 0);
  quotient = Word32Shr(
      Int32Add(Word32Shr(Int32Sub(dividend, quotient), 1), quotient),
      mag.shift - 1);
} else {
  quotient = Word32Shr(quotient, mag.shift);
}
return quotient;
284}

286Node* MachineOperatorReducer::TruncateInt64ToInt32(Node* value) {
Node* const node = graph()->NewNode(machine()->TruncateInt64ToInt32(), value);
Reduction const reduction = ReduceTruncateInt64ToInt32(node);
return reduction.Changed() ? reduction.replacement() : node;
290}

292namespace {
293bool ObjectsMayAlias(Node* a, Node* b) {
if (a != b) {
  if (NodeProperties::IsFreshObject(b)) std::swap(a, b);
  if (NodeProperties::IsFreshObject(a) &&
      (NodeProperties::IsFreshObject(b) ||
       b->opcode() == IrOpcode::kParameter ||
       b->opcode() == IrOpcode::kLoadImmutable ||
       IrOpcode::IsConstantOpcode(b->opcode()))) {
    return false;
  }
}
return true;
305}
306}  // namespace

308// Perform constant folding and strength reduction on machine operators.
309Reduction MachineOperatorReducer::Reduce(Node* node) {
switch (node->opcode()) {
  case IrOpcode::kProjection:
    return ReduceProjection(ProjectionIndexOf(node->op()), node->InputAt(0));
  case IrOpcode::kWord32And:
    return ReduceWord32And(node);
  case IrOpcode::kWord64And:
    return ReduceWord64And(node);
  case IrOpcode::kWord32Or:
    return ReduceWord32Or(node);
  case IrOpcode::kWord64Or:
    return ReduceWord64Or(node);
  case IrOpcode::kWord32Xor:
    return ReduceWord32Xor(node);
  case IrOpcode::kWord64Xor:
    return ReduceWord64Xor(node);
  case IrOpcode::kWord32Shl:
    return ReduceWord32Shl(node);
  case IrOpcode::kWord64Shl:
    return ReduceWord64Shl(node);
  case IrOpcode::kWord32Shr:
    return ReduceWord32Shr(node);
  case IrOpcode::kWord64Shr:
    return ReduceWord64Shr(node);
  case IrOpcode::kWord32Sar:
    return ReduceWord32Sar(node);
  case IrOpcode::kWord64Sar:
    return ReduceWord64Sar(node);
  case IrOpcode::kWord32Ror: {
    Int32BinopMatcher m(node);
    if (m.right().Is(0)) return Replace(m.left().node());  // x ror 0 => x
    if (m.IsFoldable()) {  // K ror K => K  (K stands for arbitrary constants)
      return ReplaceInt32(base::bits::RotateRight32(
          m.left().ResolvedValue(), m.right().ResolvedValue() & 31));
    }
    break;
  }
  case IrOpcode::kWord32Equal: {
    return ReduceWord32Equal(node);
  }
  case IrOpcode::kWord64Equal: {
    Int64BinopMatcher m(node);
    if (m.IsFoldable()) {  // K == K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() ==
                         m.right().ResolvedValue());
    }
    if (m.left().IsInt64Sub() && m.right().Is(0)) {  // x - y == 0 => x == y
      Int64BinopMatcher msub(m.left().node());
      node->ReplaceInput(0, msub.left().node());
      node->ReplaceInput(1, msub.right().node());
      return Changed(node);
    }
    // TODO(turbofan): fold HeapConstant, ExternalReference, pointer compares
    if (m.LeftEqualsRight()) return ReplaceBool(true);  // x == x => true
    // This is a workaround for not having escape analysis for wasm
    // (machine-level) turbofan graphs.
    if (!ObjectsMayAlias(m.left().node(), m.right().node())) {
      return ReplaceBool(false);
    }
    break;
  }
  case IrOpcode::kInt32Add:
    return ReduceInt32Add(node);
  case IrOpcode::kInt64Add:
    return ReduceInt64Add(node);
  case IrOpcode::kInt32Sub:
    return ReduceInt32Sub(node);
  case IrOpcode::kInt64Sub:
    return ReduceInt64Sub(node);
  case IrOpcode::kInt32Mul: {
    Int32BinopMatcher m(node);
    if (m.right().Is(0)) return Replace(m.right().node());  // x * 0 => 0
    if (m.right().Is(1)) return Replace(m.left().node());   // x * 1 => x
    if (m.IsFoldable()) {  // K * K => K  (K stands for arbitrary constants)
      return ReplaceInt32(base::MulWithWraparound(m.left().ResolvedValue(),
                                                  m.right().ResolvedValue()));
    }
    if (m.right().Is(-1)) {  // x * -1 => 0 - x
      node->ReplaceInput(0, Int32Constant(0));
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Int32Sub());
      return Changed(node);
    }
    if (m.right().IsPowerOf2()) {  // x * 2^n => x << n
      node->ReplaceInput(1, Int32Constant(base::bits::WhichPowerOfTwo(
                                m.right().ResolvedValue())));
      NodeProperties::ChangeOp(node, machine()->Word32Shl());
      return Changed(node).FollowedBy(ReduceWord32Shl(node));
    }
    // (x * Int32Constant(a)) * Int32Constant(b)) => x * Int32Constant(a * b)
    if (m.right().HasResolvedValue() && m.left().IsInt32Mul()) {
      Int32BinopMatcher n(m.left().node());
      if (n.right().HasResolvedValue() && m.OwnsInput(m.left().node())) {
        node->ReplaceInput(
            1, Int32Constant(base::MulWithWraparound(
                   m.right().ResolvedValue(), n.right().ResolvedValue())));
        node->ReplaceInput(0, n.left().node());
        return Changed(node);
      }
    }
    break;
  }
  case IrOpcode::kInt32MulWithOverflow: {
    Int32BinopMatcher m(node);
    if (m.right().Is(2)) {
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Int32AddWithOverflow());
      return Changed(node);
    }
    if (m.right().Is(-1)) {
      node->ReplaceInput(0, Int32Constant(0));
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Int32SubWithOverflow());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kInt64Mul:
    return ReduceInt64Mul(node);
  case IrOpcode::kInt32Div:
    return ReduceInt32Div(node);
  case IrOpcode::kUint32Div:
    return ReduceUint32Div(node);
  case IrOpcode::kInt32Mod:
    return ReduceInt32Mod(node);
  case IrOpcode::kUint32Mod:
    return ReduceUint32Mod(node);
  case IrOpcode::kInt32LessThan: {
    Int32BinopMatcher m(node);
    if (m.IsFoldable()) {  // K < K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <
                         m.right().ResolvedValue());
    }
    if (m.LeftEqualsRight()) return ReplaceBool(false);  // x < x => false
    if (m.left().IsWord32Or() && m.right().Is(0)) {
      // (x | K) < 0 => true or (K | x) < 0 => true iff K < 0
      Int32BinopMatcher mleftmatcher(m.left().node());
      if (mleftmatcher.left().IsNegative() ||
          mleftmatcher.right().IsNegative()) {
        return ReplaceBool(true);
      }
    }
    return ReduceWord32Comparisons(node);
  }
  case IrOpcode::kInt32LessThanOrEqual: {
    Int32BinopMatcher m(node);
    if (m.IsFoldable()) {  // K <= K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <=
                         m.right().ResolvedValue());
    }
    if (m.LeftEqualsRight()) return ReplaceBool(true);  // x <= x => true
    return ReduceWord32Comparisons(node);
  }
  case IrOpcode::kUint32LessThan: {
    Uint32BinopMatcher m(node);
    if (m.left().Is(kMaxUInt32)) return ReplaceBool(false);  // M < x => false
    if (m.right().Is(0)) return ReplaceBool(false);          // x < 0 => false
    if (m.IsFoldable()) {  // K < K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <
                         m.right().ResolvedValue());
    }
    if (m.LeftEqualsRight()) return ReplaceBool(false);  // x < x => false
    if (m.left().IsWord32Sar() && m.right().HasResolvedValue()) {
      Int32BinopMatcher mleft(m.left().node());
      if (mleft.right().HasResolvedValue()) {
        // (x >> K) < C => x < (C << K)
        // when C < (M >> K)
        const uint32_t c = m.right().ResolvedValue();
        const uint32_t k = mleft.right().ResolvedValue() & 0x1F;
        if (c < static_cast<uint32_t>(kMaxInt >> k)) {
          node->ReplaceInput(0, mleft.left().node());
          node->ReplaceInput(1, Uint32Constant(c << k));
          return Changed(node);
        }
        // TODO(turbofan): else the comparison is always true.
      }
    }
    return ReduceWord32Comparisons(node);
  }
  case IrOpcode::kUint32LessThanOrEqual: {
    Uint32BinopMatcher m(node);
    if (m.left().Is(0)) return ReplaceBool(true);            // 0 <= x => true
    if (m.right().Is(kMaxUInt32)) return ReplaceBool(true);  // x <= M => true
    if (m.IsFoldable()) {  // K <= K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <=
                         m.right().ResolvedValue());
    }
    if (m.LeftEqualsRight()) return ReplaceBool(true);  // x <= x => true
    return ReduceWord32Comparisons(node);
  }
  case IrOpcode::kFloat32Sub: {
    Float32BinopMatcher m(node);
    if (allow_signalling_nan_ && m.right().Is(0) &&
        (std::copysign(1.0, m.right().ResolvedValue()) > 0)) {
      return Replace(m.left().node());  // x - 0 => x
    }
    if (m.right().IsNaN()) {  // x - NaN => NaN
      return ReplaceFloat32(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {  // NaN - x => NaN
      return ReplaceFloat32(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // L - R => (L - R)
      return ReplaceFloat32(m.left().ResolvedValue() -
                            m.right().ResolvedValue());
    }
    if (allow_signalling_nan_ && m.left().IsMinusZero()) {
      // -0.0 - round_down(-0.0 - R) => round_up(R)
      if (machine()->Float32RoundUp().IsSupported() &&
          m.right().IsFloat32RoundDown()) {
        if (m.right().InputAt(0)->opcode() == IrOpcode::kFloat32Sub) {
          Float32BinopMatcher mright0(m.right().InputAt(0));
          if (mright0.left().IsMinusZero()) {
            return Replace(graph()->NewNode(machine()->Float32RoundUp().op(),
                                            mright0.right().node()));
          }
        }
      }
      // -0.0 - R => -R
      node->RemoveInput(0);
      NodeProperties::ChangeOp(node, machine()->Float32Neg());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kFloat64Add: {
    Float64BinopMatcher m(node);
    if (m.right().IsNaN()) {  // x + NaN => NaN
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {  // NaN + x => NaN
      return ReplaceFloat64(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // K + K => K  (K stands for arbitrary constants)
      return ReplaceFloat64(m.left().ResolvedValue() +
                            m.right().ResolvedValue());
    }
    break;
  }
  case IrOpcode::kFloat64Sub: {
    Float64BinopMatcher m(node);
    if (allow_signalling_nan_ && m.right().Is(0) &&
        (base::Double(m.right().ResolvedValue()).Sign() > 0)) {
      return Replace(m.left().node());  // x - 0 => x
    }
    if (m.right().IsNaN()) {  // x - NaN => NaN
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {  // NaN - x => NaN
      return ReplaceFloat64(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // L - R => (L - R)
      return ReplaceFloat64(m.left().ResolvedValue() -
                            m.right().ResolvedValue());
    }
    if (allow_signalling_nan_ && m.left().IsMinusZero()) {
      // -0.0 - round_down(-0.0 - R) => round_up(R)
      if (machine()->Float64RoundUp().IsSupported() &&
          m.right().IsFloat64RoundDown()) {
        if (m.right().InputAt(0)->opcode() == IrOpcode::kFloat64Sub) {
          Float64BinopMatcher mright0(m.right().InputAt(0));
          if (mright0.left().IsMinusZero()) {
            return Replace(graph()->NewNode(machine()->Float64RoundUp().op(),
                                            mright0.right().node()));
          }
        }
      }
      // -0.0 - R => -R
      node->RemoveInput(0);
      NodeProperties::ChangeOp(node, machine()->Float64Neg());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kFloat64Mul: {
    Float64BinopMatcher m(node);
    if (allow_signalling_nan_ && m.right().Is(1))
      return Replace(m.left().node());  // x * 1.0 => x
    if (m.right().Is(-1)) {  // x * -1.0 => -0.0 - x
      node->ReplaceInput(0, Float64Constant(-0.0));
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Float64Sub());
      return Changed(node);
    }
    if (m.right().IsNaN()) {                               // x * NaN => NaN
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // K * K => K  (K stands for arbitrary constants)
      return ReplaceFloat64(m.left().ResolvedValue() *
                            m.right().ResolvedValue());
    }
    if (m.right().Is(2)) {  // x * 2.0 => x + x
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Float64Add());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kFloat64Div: {
    Float64BinopMatcher m(node);
    if (allow_signalling_nan_ && m.right().Is(1))
      return Replace(m.left().node());  // x / 1.0 => x
    // TODO(ahaas): We could do x / 1.0 = x if we knew that x is not an sNaN.
    if (m.right().IsNaN()) {                               // x / NaN => NaN
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {  // NaN / x => NaN
      return ReplaceFloat64(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // K / K => K  (K stands for arbitrary constants)
      return ReplaceFloat64(
          base::Divide(m.left().ResolvedValue(), m.right().ResolvedValue()));
    }
    if (allow_signalling_nan_ && m.right().Is(-1)) {  // x / -1.0 => -x
      node->RemoveInput(1);
      NodeProperties::ChangeOp(node, machine()->Float64Neg());
      return Changed(node);
    }
    if (m.right().IsNormal() && m.right().IsPositiveOrNegativePowerOf2()) {
      // All reciprocals of non-denormal powers of two can be represented
      // exactly, so division by power of two can be reduced to
      // multiplication by reciprocal, with the same result.
      node->ReplaceInput(1, Float64Constant(1.0 / m.right().ResolvedValue()));
      NodeProperties::ChangeOp(node, machine()->Float64Mul());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kFloat64Mod: {
    Float64BinopMatcher m(node);
    if (m.right().Is(0)) {  // x % 0 => NaN
      return ReplaceFloat64(std::numeric_limits<double>::quiet_NaN());
    }
    if (m.right().IsNaN()) {  // x % NaN => NaN
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {  // NaN % x => NaN
      return ReplaceFloat64(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {  // K % K => K  (K stands for arbitrary constants)
      return ReplaceFloat64(
          Modulo(m.left().ResolvedValue(), m.right().ResolvedValue()));
    }
    break;
  }
  case IrOpcode::kFloat64Acos: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::acos(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Acosh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::acosh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Asin: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::asin(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Asinh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::asinh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Atan: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::atan(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Atanh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::atanh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Atan2: {
    Float64BinopMatcher m(node);
    if (m.right().IsNaN()) {
      return ReplaceFloat64(SilenceNaN(m.right().ResolvedValue()));
    }
    if (m.left().IsNaN()) {
      return ReplaceFloat64(SilenceNaN(m.left().ResolvedValue()));
    }
    if (m.IsFoldable()) {
      return ReplaceFloat64(base::ieee754::atan2(m.left().ResolvedValue(),
                                                 m.right().ResolvedValue()));
    }
    break;
  }
  case IrOpcode::kFloat64Cbrt: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::cbrt(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Cos: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::cos(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Cosh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::cosh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Exp: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::exp(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Expm1: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::expm1(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Log: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::log(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Log1p: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::log1p(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Log10: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::log10(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Log2: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::log2(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Pow: {
    Float64BinopMatcher m(node);
    if (m.IsFoldable()) {
      return ReplaceFloat64(base::ieee754::pow(m.left().ResolvedValue(),
                                               m.right().ResolvedValue()));
    } else if (m.right().Is(0.0)) {  // x ** +-0.0 => 1.0
      return ReplaceFloat64(1.0);
    } else if (m.right().Is(2.0)) {  // x ** 2.0 => x * x
      node->ReplaceInput(1, m.left().node());
      NodeProperties::ChangeOp(node, machine()->Float64Mul());
      return Changed(node);
    } else if (m.right().Is(0.5)) {
      // x ** 0.5 => if x <= -Infinity then Infinity else sqrt(0.0 + x)
      return Replace(Float64PowHalf(m.left().node()));
    }
    break;
  }
  case IrOpcode::kFloat64Sin: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::sin(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Sinh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::sinh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Tan: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::tan(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kFloat64Tanh: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(base::ieee754::tanh(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kChangeFloat32ToFloat64: {
    Float32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue()) {
      if (!allow_signalling_nan_ && std::isnan(m.ResolvedValue())) {
        return ReplaceFloat64(SilenceNaN(m.ResolvedValue()));
      }
      return ReplaceFloat64(m.ResolvedValue());
    }
    break;
  }
  case IrOpcode::kChangeFloat64ToInt32: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceInt32(FastD2IChecked(m.ResolvedValue()));
    if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kChangeFloat64ToInt64: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceInt64(static_cast<int64_t>(m.ResolvedValue()));
    if (m.IsChangeInt64ToFloat64()) return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kChangeFloat64ToUint32: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceInt32(FastD2UI(m.ResolvedValue()));
    if (m.IsChangeUint32ToFloat64()) return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kChangeInt32ToFloat64: {
    Int32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(FastI2D(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kBitcastWord32ToWord64: {
    Int32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue()) return ReplaceInt64(m.ResolvedValue());
    break;
  }
  case IrOpcode::kChangeInt32ToInt64: {
    Int32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue()) return ReplaceInt64(m.ResolvedValue());
    break;
  }
  case IrOpcode::kChangeInt64ToFloat64: {
    Int64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(static_cast<double>(m.ResolvedValue()));
    if (m.IsChangeFloat64ToInt64()) return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kChangeUint32ToFloat64: {
    Uint32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceFloat64(FastUI2D(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kChangeUint32ToUint64: {
    Uint32Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceInt64(static_cast<uint64_t>(m.ResolvedValue()));
    break;
  }
  case IrOpcode::kTruncateFloat64ToWord32: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue())
      return ReplaceInt32(DoubleToInt32(m.ResolvedValue()));
    if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
    return NoChange();
  }
  case IrOpcode::kTruncateInt64ToInt32:
    return ReduceTruncateInt64ToInt32(node);
  case IrOpcode::kTruncateFloat64ToFloat32: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue()) {
      if (!allow_signalling_nan_ && m.IsNaN()) {
        return ReplaceFloat32(DoubleToFloat32(SilenceNaN(m.ResolvedValue())));
      }
      return ReplaceFloat32(DoubleToFloat32(m.ResolvedValue()));
    }
    if (allow_signalling_nan_ && m.IsChangeFloat32ToFloat64())
      return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kRoundFloat64ToInt32: {
    Float64Matcher m(node->InputAt(0));
    if (m.HasResolvedValue()) {
      return ReplaceInt32(DoubleToInt32(m.ResolvedValue()));
    }
    if (m.IsChangeInt32ToFloat64()) return Replace(m.node()->InputAt(0));
    break;
  }
  case IrOpcode::kFloat64InsertLowWord32:
    return ReduceFloat64InsertLowWord32(node);
  case IrOpcode::kFloat64InsertHighWord32:
    return ReduceFloat64InsertHighWord32(node);
  case IrOpcode::kStore:
  case IrOpcode::kUnalignedStore:
    return ReduceStore(node);
  case IrOpcode::kFloat64Equal:
  case IrOpcode::kFloat64LessThan:
  case IrOpcode::kFloat64LessThanOrEqual:
    return ReduceFloat64Compare(node);
  case IrOpcode::kFloat64RoundDown:
    return ReduceFloat64RoundDown(node);
  case IrOpcode::kBitcastTaggedToWord:
  case IrOpcode::kBitcastTaggedToWordForTagAndSmiBits: {
    NodeMatcher m(node->InputAt(0));
    if (m.IsBitcastWordToTaggedSigned()) {
      RelaxEffectsAndControls(node);
      return Replace(m.InputAt(0));
    }
    break;
  }
  case IrOpcode::kBranch:
  case IrOpcode::kDeoptimizeIf:
  case IrOpcode::kDeoptimizeUnless:
  case IrOpcode::kTrapIf:
  case IrOpcode::kTrapUnless:
    return ReduceConditional(node);
  case IrOpcode::kInt64LessThan: {
    Int64BinopMatcher m(node);
    if (m.IsFoldable()) {  // K < K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <
                         m.right().ResolvedValue());
    }
    return ReduceWord64Comparisons(node);
  }
  case IrOpcode::kInt64LessThanOrEqual: {
    Int64BinopMatcher m(node);
    if (m.IsFoldable()) {  // K <= K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <=
                         m.right().ResolvedValue());
    }
    return ReduceWord64Comparisons(node);
  }
  case IrOpcode::kUint64LessThan: {
    Uint64BinopMatcher m(node);
    if (m.IsFoldable()) {  // K < K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <
                         m.right().ResolvedValue());
    }
    return ReduceWord64Comparisons(node);
  }
  case IrOpcode::kUint64LessThanOrEqual: {
    Uint64BinopMatcher m(node);
    if (m.IsFoldable()) {  // K <= K => K  (K stands for arbitrary constants)
      return ReplaceBool(m.left().ResolvedValue() <=
                         m.right().ResolvedValue());
    }
    return ReduceWord64Comparisons(node);
  }
  case IrOpcode::kFloat32Select:
  case IrOpcode::kFloat64Select:
  case IrOpcode::kWord32Select:
  case IrOpcode::kWord64Select: {
    Int32Matcher match(node->InputAt(0));
    if (match.HasResolvedValue()) {
      if (match.Is(0)) {
        return Replace(node->InputAt(2));
      } else {
        return Replace(node->InputAt(1));
      }
    }
    break;
  }
  default:
    break;
}
return NoChange();
972}

974Reduction MachineOperatorReducer::ReduceTruncateInt64ToInt32(Node* node) {
Int64Matcher m(node->InputAt(0));
if (m.HasResolvedValue())
  return ReplaceInt32(static_cast<int32_t>(m.ResolvedValue()));
if (m.IsChangeInt32ToInt64()) return Replace(m.node()->InputAt(0));
return NoChange();
980}

982Reduction MachineOperatorReducer::ReduceInt32Add(Node* node) {
DCHECK_EQ(IrOpcode::kInt32Add, node->opcode())((void) 0);
Int32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x + 0 => x
if (m.IsFoldable()) {  // K + K => K  (K stands for arbitrary constants)
  return ReplaceInt32(base::AddWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.left().IsInt32Sub()) {
  Int32BinopMatcher mleft(m.left().node());
  if (mleft.left().Is(0)) {  // (0 - x) + y => y - x
    node->ReplaceInput(0, m.right().node());
    node->ReplaceInput(1, mleft.right().node());
    NodeProperties::ChangeOp(node, machine()->Int32Sub());
    return Changed(node).FollowedBy(ReduceInt32Sub(node));
  }
}
if (m.right().IsInt32Sub()) {
  Int32BinopMatcher mright(m.right().node());
  if (mright.left().Is(0)) {  // y + (0 - x) => y - x
    node->ReplaceInput(1, mright.right().node());
    NodeProperties::ChangeOp(node, machine()->Int32Sub());
    return Changed(node).FollowedBy(ReduceInt32Sub(node));
  }
}
// (x + Int32Constant(a)) + Int32Constant(b)) => x + Int32Constant(a + b)
if (m.right().HasResolvedValue() && m.left().IsInt32Add()) {
  Int32BinopMatcher n(m.left().node());
  if (n.right().HasResolvedValue() && m.OwnsInput(m.left().node())) {
    node->ReplaceInput(
        1, Int32Constant(base::AddWithWraparound(m.right().ResolvedValue(),
                                                 n.right().ResolvedValue())));
    node->ReplaceInput(0, n.left().node());
    return Changed(node);
  }
}

return NoChange();
1020}

1022Reduction MachineOperatorReducer::ReduceInt64Add(Node* node) {
DCHECK_EQ(IrOpcode::kInt64Add, node->opcode())((void) 0);
Int64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x + 0 => 0
if (m.IsFoldable()) {
  return ReplaceInt64(base::AddWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
// (x + Int64Constant(a)) + Int64Constant(b) => x + Int64Constant(a + b)
if (m.right().HasResolvedValue() && m.left().IsInt64Add()) {
  Int64BinopMatcher n(m.left().node());
  if (n.right().HasResolvedValue() && m.OwnsInput(m.left().node())) {
    node->ReplaceInput(
        1, Int64Constant(base::AddWithWraparound(m.right().ResolvedValue(),
                                                 n.right().ResolvedValue())));
    node->ReplaceInput(0, n.left().node());
    return Changed(node);
  }
}
return NoChange();
1042}

1044Reduction MachineOperatorReducer::ReduceInt32Sub(Node* node) {
DCHECK_EQ(IrOpcode::kInt32Sub, node->opcode())((void) 0);
Int32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x - 0 => x
if (m.IsFoldable()) {  // K - K => K  (K stands for arbitrary constants)
  return ReplaceInt32(base::SubWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.LeftEqualsRight()) return ReplaceInt32(0);  // x - x => 0
if (m.right().HasResolvedValue()) {               // x - K => x + -K
  node->ReplaceInput(
      1,
      Int32Constant(base::NegateWithWraparound(m.right().ResolvedValue())));
  NodeProperties::ChangeOp(node, machine()->Int32Add());
  return Changed(node).FollowedBy(ReduceInt32Add(node));
}
return NoChange();
1061}

1063Reduction MachineOperatorReducer::ReduceInt64Sub(Node* node) {
DCHECK_EQ(IrOpcode::kInt64Sub, node->opcode())((void) 0);
Int64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x - 0 => x
if (m.IsFoldable()) {  // K - K => K  (K stands for arbitrary constants)
  return ReplaceInt64(base::SubWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.LeftEqualsRight()) return Replace(Int64Constant(0));  // x - x => 0
if (m.right().HasResolvedValue()) {                         // x - K => x + -K
  node->ReplaceInput(
      1,
      Int64Constant(base::NegateWithWraparound(m.right().ResolvedValue())));
  NodeProperties::ChangeOp(node, machine()->Int64Add());
  return Changed(node).FollowedBy(ReduceInt64Add(node));
}
return NoChange();
1080}

1082Reduction MachineOperatorReducer::ReduceInt64Mul(Node* node) {
DCHECK_EQ(IrOpcode::kInt64Mul, node->opcode())((void) 0);
Int64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.right().node());  // x * 0 => 0
if (m.right().Is(1)) return Replace(m.left().node());   // x * 1 => x
if (m.IsFoldable()) {  // K * K => K  (K stands for arbitrary constants)
  return ReplaceInt64(base::MulWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.right().Is(-1)) {  // x * -1 => 0 - x
  node->ReplaceInput(0, Int64Constant(0));
  node->ReplaceInput(1, m.left().node());
  NodeProperties::ChangeOp(node, machine()->Int64Sub());
  return Changed(node);
}
if (m.right().IsPowerOf2()) {  // x * 2^n => x << n
  node->ReplaceInput(
      1,
      Int64Constant(base::bits::WhichPowerOfTwo(m.right().ResolvedValue())));
  NodeProperties::ChangeOp(node, machine()->Word64Shl());
  return Changed(node).FollowedBy(ReduceWord64Shl(node));
}
// (x * Int64Constant(a)) * Int64Constant(b)) => x * Int64Constant(a * b)
if (m.right().HasResolvedValue() && m.left().IsInt64Mul()) {
  Int64BinopMatcher n(m.left().node());
  if (n.right().HasResolvedValue() && m.OwnsInput(m.left().node())) {
    node->ReplaceInput(
        1, Int64Constant(base::MulWithWraparound(m.right().ResolvedValue(),
                                                 n.right().ResolvedValue())));
    node->ReplaceInput(0, n.left().node());
    return Changed(node);
  }
}
return NoChange();
1116}

1118Reduction MachineOperatorReducer::ReduceInt32Div(Node* node) {
Int32BinopMatcher m(node);
if (m.left().Is(0)) return Replace(m.left().node());    // 0 / x => 0
if (m.right().Is(0)) return Replace(m.right().node());  // x / 0 => 0
if (m.right().Is(1)) return Replace(m.left().node());   // x / 1 => x
if (m.IsFoldable()) {  // K / K => K  (K stands for arbitrary constants)
  return ReplaceInt32(base::bits::SignedDiv32(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.LeftEqualsRight()) {  // x / x => x != 0
  Node* const zero = Int32Constant(0);
  return Replace(Word32Equal(Word32Equal(m.left().node(), zero), zero));
}
if (m.right().Is(-1)) {  // x / -1 => 0 - x
  node->ReplaceInput(0, Int32Constant(0));
  node->ReplaceInput(1, m.left().node());
  node->TrimInputCount(2);
  NodeProperties::ChangeOp(node, machine()->Int32Sub());
  return Changed(node);
}
if (m.right().HasResolvedValue()) {
  int32_t const divisor = m.right().ResolvedValue();
  Node* const dividend = m.left().node();
  Node* quotient = dividend;
  if (base::bits::IsPowerOfTwo(Abs(divisor))) {
    uint32_t const shift = base::bits::WhichPowerOfTwo(Abs(divisor));
    DCHECK_NE(0u, shift)((void) 0);
    if (shift > 1) {
      quotient = Word32Sar(quotient, 31);
    }
    quotient = Int32Add(Word32Shr(quotient, 32u - shift), dividend);
    quotient = Word32Sar(quotient, shift);
  } else {
    quotient = Int32Div(quotient, Abs(divisor));
  }
  if (divisor < 0) {
    node->ReplaceInput(0, Int32Constant(0));
    node->ReplaceInput(1, quotient);
    node->TrimInputCount(2);
    NodeProperties::ChangeOp(node, machine()->Int32Sub());
    return Changed(node);
  }
  return Replace(quotient);
}
return NoChange();
1163}

1165Reduction MachineOperatorReducer::ReduceUint32Div(Node* node) {
Uint32BinopMatcher m(node);
if (m.left().Is(0)) return Replace(m.left().node());    // 0 / x => 0
if (m.right().Is(0)) return Replace(m.right().node());  // x / 0 => 0
if (m.right().Is(1)) return Replace(m.left().node());   // x / 1 => x
if (m.IsFoldable()) {  // K / K => K  (K stands for arbitrary constants)
  return ReplaceUint32(base::bits::UnsignedDiv32(m.left().ResolvedValue(),
                                                 m.right().ResolvedValue()));
}
if (m.LeftEqualsRight()) {  // x / x => x != 0
  Node* const zero = Int32Constant(0);
  return Replace(Word32Equal(Word32Equal(m.left().node(), zero), zero));
}
if (m.right().HasResolvedValue()) {
  Node* const dividend = m.left().node();
  uint32_t const divisor = m.right().ResolvedValue();
  if (base::bits::IsPowerOfTwo(divisor)) {  // x / 2^n => x >> n
    node->ReplaceInput(1, Uint32Constant(base::bits::WhichPowerOfTwo(
                              m.right().ResolvedValue())));
    node->TrimInputCount(2);
    NodeProperties::ChangeOp(node, machine()->Word32Shr());
    return Changed(node);
  } else {
    return Replace(Uint32Div(dividend, divisor));
  }
}
return NoChange();
1192}

1194Reduction MachineOperatorReducer::ReduceInt32Mod(Node* node) {
Int32BinopMatcher m(node);
if (m.left().Is(0)) return Replace(m.left().node());    // 0 % x  => 0
if (m.right().Is(0)) return Replace(m.right().node());  // x % 0  => 0
if (m.right().Is(1)) return ReplaceInt32(0);            // x % 1  => 0
if (m.right().Is(-1)) return ReplaceInt32(0);           // x % -1 => 0
if (m.LeftEqualsRight()) return ReplaceInt32(0);        // x % x  => 0
if (m.IsFoldable()) {  // K % K => K  (K stands for arbitrary constants)
  return ReplaceInt32(base::bits::SignedMod32(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.right().HasResolvedValue()) {
  Node* const dividend = m.left().node();
  uint32_t const divisor = Abs(m.right().ResolvedValue());
  if (base::bits::IsPowerOfTwo(divisor)) {
    uint32_t const mask = divisor - 1;
    Node* const zero = Int32Constant(0);
    Diamond d(graph(), common(),
              graph()->NewNode(machine()->Int32LessThan(), dividend, zero),
              BranchHint::kFalse);
    return Replace(
        d.Phi(MachineRepresentation::kWord32,
              Int32Sub(zero, Word32And(Int32Sub(zero, dividend), mask)),
              Word32And(dividend, mask)));
  } else {
    Node* quotient = Int32Div(dividend, divisor);
    DCHECK_EQ(dividend, node->InputAt(0))((void) 0);
    node->ReplaceInput(1, Int32Mul(quotient, Int32Constant(divisor)));
    node->TrimInputCount(2);
    NodeProperties::ChangeOp(node, machine()->Int32Sub());
  }
  return Changed(node);
}
return NoChange();
1228}

1230Reduction MachineOperatorReducer::ReduceUint32Mod(Node* node) {
Uint32BinopMatcher m(node);
if (m.left().Is(0)) return Replace(m.left().node());    // 0 % x => 0
if (m.right().Is(0)) return Replace(m.right().node());  // x % 0 => 0
if (m.right().Is(1)) return ReplaceUint32(0);           // x % 1 => 0
if (m.LeftEqualsRight()) return ReplaceInt32(0);        // x % x  => 0
if (m.IsFoldable()) {  // K % K => K  (K stands for arbitrary constants)
  return ReplaceUint32(base::bits::UnsignedMod32(m.left().ResolvedValue(),
                                                 m.right().ResolvedValue()));
}
if (m.right().HasResolvedValue()) {
  Node* const dividend = m.left().node();
  uint32_t const divisor = m.right().ResolvedValue();
  if (base::bits::IsPowerOfTwo(divisor)) {  // x % 2^n => x & 2^n-1
    node->ReplaceInput(1, Uint32Constant(m.right().ResolvedValue() - 1));
    node->TrimInputCount(2);
    NodeProperties::ChangeOp(node, machine()->Word32And());
  } else {
    Node* quotient = Uint32Div(dividend, divisor);
    DCHECK_EQ(dividend, node->InputAt(0))((void) 0);
    node->ReplaceInput(1, Int32Mul(quotient, Uint32Constant(divisor)));
    node->TrimInputCount(2);
    NodeProperties::ChangeOp(node, machine()->Int32Sub());
  }
  return Changed(node);
}
return NoChange();
1257}

1259Reduction MachineOperatorReducer::ReduceStore(Node* node) {
NodeMatcher nm(node);
DCHECK(nm.IsStore() || nm.IsUnalignedStore())((void) 0);
MachineRepresentation rep =
    nm.IsStore() ? StoreRepresentationOf(node->op()).representation()
                 : UnalignedStoreRepresentationOf(node->op());

const int value_input = 2;
Node* const value = node->InputAt(value_input);

switch (value->opcode()) {
  case IrOpcode::kWord32And: {
    Uint32BinopMatcher m(value);
    if (m.right().HasResolvedValue() &&
        ((rep == MachineRepresentation::kWord8 &&
          (m.right().ResolvedValue() & 0xFF) == 0xFF) ||
         (rep == MachineRepresentation::kWord16 &&
          (m.right().ResolvedValue() & 0xFFFF) == 0xFFFF))) {
      node->ReplaceInput(value_input, m.left().node());
      return Changed(node);
    }
    break;
  }
  case IrOpcode::kWord32Sar: {
    Int32BinopMatcher m(value);
    if (m.left().IsWord32Shl() && ((rep == MachineRepresentation::kWord8 &&
                                    m.right().IsInRange(1, 24)) ||
                                   (rep == MachineRepresentation::kWord16 &&
                                    m.right().IsInRange(1, 16)))) {
      Int32BinopMatcher mleft(m.left().node());
      if (mleft.right().Is(m.right().ResolvedValue())) {
        node->ReplaceInput(value_input, mleft.left().node());
        return Changed(node);
      }
    }
    break;
  }
  default:
    break;
}
return NoChange();
1300}

1302Reduction MachineOperatorReducer::ReduceProjection(size_t index, Node* node) {
switch (node->opcode()) {
  case IrOpcode::kInt32AddWithOverflow: {
    DCHECK(index == 0 || index == 1)((void) 0);
    Int32BinopMatcher m(node);
    if (m.IsFoldable()) {
      int32_t val;
      bool ovf = base::bits::SignedAddOverflow32(
          m.left().ResolvedValue(), m.right().ResolvedValue(), &val);
      return ReplaceInt32(index == 0 ? val : ovf);
    }
    if (m.right().Is(0)) {
      return Replace(index == 0 ? m.left().node() : m.right().node());
    }
    break;
  }
  case IrOpcode::kInt32SubWithOverflow: {
    DCHECK(index == 0 || index == 1)((void) 0);
    Int32BinopMatcher m(node);
    if (m.IsFoldable()) {
      int32_t val;
      bool ovf = base::bits::SignedSubOverflow32(
          m.left().ResolvedValue(), m.right().ResolvedValue(), &val);
      return ReplaceInt32(index == 0 ? val : ovf);
    }
    if (m.right().Is(0)) {
      return Replace(index == 0 ? m.left().node() : m.right().node());
    }
    break;
  }
  case IrOpcode::kInt32MulWithOverflow: {
    DCHECK(index == 0 || index == 1)((void) 0);
    Int32BinopMatcher m(node);
    if (m.IsFoldable()) {
      int32_t val;
      bool ovf = base::bits::SignedMulOverflow32(
          m.left().ResolvedValue(), m.right().ResolvedValue(), &val);
      return ReplaceInt32(index == 0 ? val : ovf);
    }
    if (m.right().Is(0)) {
      return Replace(m.right().node());
    }
    if (m.right().Is(1)) {
      return index == 0 ? Replace(m.left().node()) : ReplaceInt32(0);
    }
    break;
  }
  default:
    break;
}
return NoChange();
1353}

1355namespace {

1357// Returns true if "value << shift >> shift == value". This can be interpreted
1358// as "left shifting |value| by |shift| doesn't shift away significant bits".
1359// Or, equivalently, "left shifting |value| by |shift| doesn't have signed
1360// overflow".
1361bool CanRevertLeftShiftWithRightShift(int32_t value, int32_t shift) {
if (shift < 0 || shift >= 32) {
  // This shift would be UB in C++
  return false;
}
if (static_cast<int32_t>(static_cast<uint32_t>(value) << shift) >> shift !=
    static_cast<int32_t>(value)) {
  return false;
}
return true;
1371}

1373}  // namespace

1375Reduction MachineOperatorReducer::ReduceWord32Comparisons(Node* node) {
DCHECK(node->opcode() == IrOpcode::kInt32LessThan ||((void) 0)
       node->opcode() == IrOpcode::kInt32LessThanOrEqual ||((void) 0)
       node->opcode() == IrOpcode::kUint32LessThan ||((void) 0)
       node->opcode() == IrOpcode::kUint32LessThanOrEqual)((void) 0);
Int32BinopMatcher m(node);
// (x >> K) < (y >> K) => x < y   if only zeros shifted out
if (m.left().op() == machine()->Word32SarShiftOutZeros() &&
    m.right().op() == machine()->Word32SarShiftOutZeros()) {
  Int32BinopMatcher mleft(m.left().node());
  Int32BinopMatcher mright(m.right().node());
  if (mleft.right().HasResolvedValue() &&
      mright.right().Is(mleft.right().ResolvedValue())) {
    node->ReplaceInput(0, mleft.left().node());
    node->ReplaceInput(1, mright.left().node());
    return Changed(node);
  }
}
// Simplifying (x >> n) <= k into x <= (k << n), with "k << n" being
// computed here at compile time.
if (m.right().HasResolvedValue() &&
    m.left().op() == machine()->Word32SarShiftOutZeros() &&
    m.left().node()->UseCount() == 1) {
  uint32_t right = m.right().ResolvedValue();
  Int32BinopMatcher mleft(m.left().node());
  if (mleft.right().HasResolvedValue()) {
    auto shift = mleft.right().ResolvedValue();
    if (CanRevertLeftShiftWithRightShift(right, shift)) {
      node->ReplaceInput(0, mleft.left().node());
      node->ReplaceInput(1, Int32Constant(right << shift));
      return Changed(node);
    }
  }
}
// Simplifying k <= (x >> n) into (k << n) <= x, with "k << n" being
// computed here at compile time.
if (m.left().HasResolvedValue() &&
    m.right().op() == machine()->Word32SarShiftOutZeros() &&
    m.right().node()->UseCount() == 1) {
  uint32_t left = m.left().ResolvedValue();
  Int32BinopMatcher mright(m.right().node());
  if (mright.right().HasResolvedValue()) {
    auto shift = mright.right().ResolvedValue();
    if (CanRevertLeftShiftWithRightShift(left, shift)) {
      node->ReplaceInput(0, Int32Constant(left << shift));
      node->ReplaceInput(1, mright.left().node());
      return Changed(node);
    }
  }
}
return NoChange();
1426}

1428const Operator* MachineOperatorReducer::Map64To32Comparison(
  const Operator* op, bool sign_extended) {
switch (op->opcode()) {
  case IrOpcode::kInt64LessThan:
    return sign_extended ? machine()->Int32LessThan()
                         : machine()->Uint32LessThan();
  case IrOpcode::kInt64LessThanOrEqual:
    return sign_extended ? machine()->Int32LessThanOrEqual()
                         : machine()->Uint32LessThanOrEqual();
  case IrOpcode::kUint64LessThan:
    return machine()->Uint32LessThan();
  case IrOpcode::kUint64LessThanOrEqual:
    return machine()->Uint32LessThanOrEqual();
  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}
1444}

1446Reduction MachineOperatorReducer::ReduceWord64Comparisons(Node* node) {
DCHECK(node->opcode() == IrOpcode::kInt64LessThan ||((void) 0)
       node->opcode() == IrOpcode::kInt64LessThanOrEqual ||((void) 0)
       node->opcode() == IrOpcode::kUint64LessThan ||((void) 0)
       node->opcode() == IrOpcode::kUint64LessThanOrEqual)((void) 0);
Int64BinopMatcher m(node);

bool sign_extended =
    m.left().IsChangeInt32ToInt64() && m.right().IsChangeInt32ToInt64();
if (sign_extended || (m.left().IsChangeUint32ToUint64() &&
                      m.right().IsChangeUint32ToUint64())) {
  node->ReplaceInput(0, NodeProperties::GetValueInput(m.left().node(), 0));
  node->ReplaceInput(1, NodeProperties::GetValueInput(m.right().node(), 0));
  NodeProperties::ChangeOp(node,
                           Map64To32Comparison(node->op(), sign_extended));
  return Changed(node).FollowedBy(Reduce(node));
}

// (x >> K) < (y >> K) => x < y   if only zeros shifted out
// This is useful for Smi untagging, which results in such a shift.
if (m.left().op() == machine()->Word64SarShiftOutZeros() &&
    m.right().op() == machine()->Word64SarShiftOutZeros()) {
  Int64BinopMatcher mleft(m.left().node());
  Int64BinopMatcher mright(m.right().node());
  if (mleft.right().HasResolvedValue() &&
      mright.right().Is(mleft.right().ResolvedValue())) {
    node->ReplaceInput(0, mleft.left().node());
    node->ReplaceInput(1, mright.left().node());
    return Changed(node);
  }
}

return NoChange();
1479}

1481Reduction MachineOperatorReducer::ReduceWord32Shifts(Node* node) {
DCHECK((node->opcode() == IrOpcode::kWord32Shl) ||((void) 0)
       (node->opcode() == IrOpcode::kWord32Shr) ||((void) 0)
       (node->opcode() == IrOpcode::kWord32Sar))((void) 0);
if (machine()->Word32ShiftIsSafe()) {
  // Remove the explicit 'and' with 0x1F if the shift provided by the machine
  // instruction matches that required by JavaScript.
  Int32BinopMatcher m(node);
  if (m.right().IsWord32And()) {
    Int32BinopMatcher mright(m.right().node());
    if (mright.right().Is(0x1F)) {
      node->ReplaceInput(1, mright.left().node());
      return Changed(node);
    }
  }
}
return NoChange();
1498}

1500Reduction MachineOperatorReducer::ReduceWord32Shl(Node* node) {
DCHECK_EQ(IrOpcode::kWord32Shl, node->opcode())((void) 0);
Int32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x << 0 => x
if (m.IsFoldable()) {  // K << K => K  (K stands for arbitrary constants)
  return ReplaceInt32(base::ShlWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.right().IsInRange(1, 31)) {
  if (m.left().IsWord32Sar() || m.left().IsWord32Shr()) {
    Int32BinopMatcher mleft(m.left().node());

    // If x >> K only shifted out zeros:
    // (x >> K) << L => x           if K == L
    // (x >> K) << L => x >> (K-L) if K > L
    // (x >> K) << L => x << (L-K)  if K < L
    // Since this is used for Smi untagging, we currently only need it for
    // signed shifts.
    if (mleft.op() == machine()->Word32SarShiftOutZeros() &&
        mleft.right().IsInRange(1, 31)) {
      Node* x = mleft.left().node();
      int k = mleft.right().ResolvedValue();
      int l = m.right().ResolvedValue();
      if (k == l) {
        return Replace(x);
      } else if (k > l) {
        node->ReplaceInput(0, x);
        node->ReplaceInput(1, Uint32Constant(k - l));
        NodeProperties::ChangeOp(node, machine()->Word32Sar());
        return Changed(node).FollowedBy(ReduceWord32Sar(node));
      } else {
        DCHECK(k < l)((void) 0);
        node->ReplaceInput(0, x);
        node->ReplaceInput(1, Uint32Constant(l - k));
        return Changed(node);
      }
    }

    // (x >>> K) << K => x & ~(2^K - 1)
    // (x >> K) << K => x & ~(2^K - 1)
    if (mleft.right().Is(m.right().ResolvedValue())) {
      node->ReplaceInput(0, mleft.left().node());
      node->ReplaceInput(1,
                         Uint32Constant(std::numeric_limits<uint32_t>::max()
                                        << m.right().ResolvedValue()));
      NodeProperties::ChangeOp(node, machine()->Word32And());
      return Changed(node).FollowedBy(ReduceWord32And(node));
    }
  }
}
return ReduceWord32Shifts(node);
1551}

1553Reduction MachineOperatorReducer::ReduceWord64Shl(Node* node) {
DCHECK_EQ(IrOpcode::kWord64Shl, node->opcode())((void) 0);
Int64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x << 0 => x
if (m.IsFoldable()) {  // K << K => K  (K stands for arbitrary constants)
  return ReplaceInt64(base::ShlWithWraparound(m.left().ResolvedValue(),
                                              m.right().ResolvedValue()));
}
if (m.right().IsInRange(1, 63) &&
    (m.left().IsWord64Sar() || m.left().IsWord64Shr())) {
  Int64BinopMatcher mleft(m.left().node());

  // If x >> K only shifted out zeros:
  // (x >> K) << L => x           if K == L
  // (x >> K) << L => x >> (K-L) if K > L
  // (x >> K) << L => x << (L-K)  if K < L
  // Since this is used for Smi untagging, we currently only need it for
  // signed shifts.
  if (mleft.op() == machine()->Word64SarShiftOutZeros() &&
      mleft.right().IsInRange(1, 63)) {
    Node* x = mleft.left().node();
    int64_t k = mleft.right().ResolvedValue();
    int64_t l = m.right().ResolvedValue();
    if (k == l) {
      return Replace(x);
    } else if (k > l) {
      node->ReplaceInput(0, x);
      node->ReplaceInput(1, Uint64Constant(k - l));
      NodeProperties::ChangeOp(node, machine()->Word64Sar());
      return Changed(node).FollowedBy(ReduceWord64Sar(node));
    } else {
      DCHECK(k < l)((void) 0);
      node->ReplaceInput(0, x);
      node->ReplaceInput(1, Uint64Constant(l - k));
      return Changed(node);
    }
  }

  // (x >>> K) << K => x & ~(2^K - 1)
  // (x >> K) << K => x & ~(2^K - 1)
  if (mleft.right().Is(m.right().ResolvedValue())) {
    node->ReplaceInput(0, mleft.left().node());
    node->ReplaceInput(1, Uint64Constant(std::numeric_limits<uint64_t>::max()
                                         << m.right().ResolvedValue()));
    NodeProperties::ChangeOp(node, machine()->Word64And());
    return Changed(node).FollowedBy(ReduceWord64And(node));
  }
}
return NoChange();
1602}

1604Reduction MachineOperatorReducer::ReduceWord32Shr(Node* node) {
Uint32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x >>> 0 => x
if (m.IsFoldable()) {  // K >>> K => K  (K stands for arbitrary constants)
  return ReplaceInt32(m.left().ResolvedValue() >>
                      (m.right().ResolvedValue() & 31));
}
if (m.left().IsWord32And() && m.right().HasResolvedValue()) {
  Uint32BinopMatcher mleft(m.left().node());
  if (mleft.right().HasResolvedValue()) {
    uint32_t shift = m.right().ResolvedValue() & 31;
    uint32_t mask = mleft.right().ResolvedValue();
    if ((mask >> shift) == 0) {
      // (m >>> s) == 0 implies ((x & m) >>> s) == 0
      return ReplaceInt32(0);
    }
  }
}
return ReduceWord32Shifts(node);
1623}

1625Reduction MachineOperatorReducer::ReduceWord64Shr(Node* node) {
DCHECK_EQ(IrOpcode::kWord64Shr, node->opcode())((void) 0);
Uint64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x >>> 0 => x
if (m.IsFoldable()) {  // K >> K => K  (K stands for arbitrary constants)
  return ReplaceInt64(m.left().ResolvedValue() >>
                      (m.right().ResolvedValue() & 63));
}
return NoChange();
1634}

1636Reduction MachineOperatorReducer::ReduceWord32Sar(Node* node) {
Int32BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x >> 0 => x
if (m.IsFoldable()) {  // K >> K => K  (K stands for arbitrary constants)
  return ReplaceInt32(m.left().ResolvedValue() >>
                      (m.right().ResolvedValue() & 31));
}
if (m.left().IsWord32Shl()) {
  Int32BinopMatcher mleft(m.left().node());
  if (mleft.left().IsComparison()) {
    if (m.right().Is(31) && mleft.right().Is(31)) {
      // Comparison << 31 >> 31 => 0 - Comparison
      node->ReplaceInput(0, Int32Constant(0));
      node->ReplaceInput(1, mleft.left().node());
      NodeProperties::ChangeOp(node, machine()->Int32Sub());
      return Changed(node).FollowedBy(ReduceInt32Sub(node));
    }
  } else if (mleft.left().IsLoad()) {
    LoadRepresentation const rep =
        LoadRepresentationOf(mleft.left().node()->op());
    if (m.right().Is(24) && mleft.right().Is(24) &&
        rep == MachineType::Int8()) {
      // Load[kMachInt8] << 24 >> 24 => Load[kMachInt8]
      return Replace(mleft.left().node());
    }
    if (m.right().Is(16) && mleft.right().Is(16) &&
        rep == MachineType::Int16()) {
      // Load[kMachInt16] << 16 >> 16 => Load[kMachInt8]
      return Replace(mleft.left().node());
    }
  }
}
return ReduceWord32Shifts(node);
1669}

1671Reduction MachineOperatorReducer::ReduceWord64Sar(Node* node) {
Int64BinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x >> 0 => x
if (m.IsFoldable()) {
  return ReplaceInt64(m.left().ResolvedValue() >>
                      (m.right().ResolvedValue() & 63));
}
return NoChange();
1679}

1681template <typename WordNAdapter>
1682Reduction MachineOperatorReducer::ReduceWordNAnd(Node* node) {
using A = WordNAdapter;
A a(this);

typename A::IntNBinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.right().node());  // x & 0  => 0
if (m.right().Is(-1)) return Replace(m.left().node());  // x & -1 => x
if (m.left().IsComparison() && m.right().Is(1)) {       // CMP & 1 => CMP
  return Replace(m.left().node());
}
if (m.IsFoldable()) {  // K & K  => K  (K stands for arbitrary constants)
  return a.ReplaceIntN(m.left().ResolvedValue() & m.right().ResolvedValue());
}
if (m.LeftEqualsRight()) return Replace(m.left().node());  // x & x => x
if (A::IsWordNAnd(m.left()) && m.right().HasResolvedValue()) {
  typename A::IntNBinopMatcher mleft(m.left().node());
  if (mleft.right().HasResolvedValue()) {  // (x & K) & K => x & K
    node->ReplaceInput(0, mleft.left().node());
    node->ReplaceInput(1, a.IntNConstant(m.right().ResolvedValue() &
                                         mleft.right().ResolvedValue()));
    return Changed(node).FollowedBy(a.ReduceWordNAnd(node));
  }
}
if (m.right().IsNegativePowerOf2()) {
  typename A::intN_t const mask = m.right().ResolvedValue();
  typename A::intN_t const neg_mask = base::NegateWithWraparound(mask);
  if (A::IsWordNShl(m.left())) {
    typename A::UintNBinopMatcher mleft(m.left().node());
    if (mleft.right().HasResolvedValue() &&
        (mleft.right().ResolvedValue() & (A::WORD_SIZE - 1)) >=
            base::bits::CountTrailingZeros(mask)) {
      // (x << L) & (-1 << K) => x << L iff L >= K
      return Replace(mleft.node());
    }
  } else if (A::IsIntNAdd(m.left())) {
    typename A::IntNBinopMatcher mleft(m.left().node());
    if (mleft.right().HasResolvedValue() &&
        (mleft.right().ResolvedValue() & mask) ==
            mleft.right().ResolvedValue()) {
      // (x + (K << L)) & (-1 << L) => (x & (-1 << L)) + (K << L)
      node->ReplaceInput(0,
                         a.WordNAnd(mleft.left().node(), m.right().node()));
      node->ReplaceInput(1, mleft.right().node());
      NodeProperties::ChangeOp(node, a.IntNAdd(machine()));
      return Changed(node).FollowedBy(a.ReduceIntNAdd(node));
    }
    if (A::IsIntNMul(mleft.left())) {
      typename A::IntNBinopMatcher mleftleft(mleft.left().node());
      if (mleftleft.right().IsMultipleOf(neg_mask)) {
        // (y * (K << L) + x) & (-1 << L) => (x & (-1 << L)) + y * (K << L)
        node->ReplaceInput(
            0, a.WordNAnd(mleft.right().node(), m.right().node()));
        node->ReplaceInput(1, mleftleft.node());
        NodeProperties::ChangeOp(node, a.IntNAdd(machine()));
        return Changed(node).FollowedBy(a.ReduceIntNAdd(node));
      }
    }
    if (A::IsIntNMul(mleft.right())) {
      typename A::IntNBinopMatcher mleftright(mleft.right().node());
      if (mleftright.right().IsMultipleOf(neg_mask)) {
        // (x + y * (K << L)) & (-1 << L) => (x & (-1 << L)) + y * (K << L)
        node->ReplaceInput(0,
                           a.WordNAnd(mleft.left().node(), m.right().node()));
        node->ReplaceInput(1, mleftright.node());
        NodeProperties::ChangeOp(node, a.IntNAdd(machine()));
        return Changed(node).FollowedBy(a.ReduceIntNAdd(node));
      }
    }
    if (A::IsWordNShl(mleft.left())) {
      typename A::IntNBinopMatcher mleftleft(mleft.left().node());
      if (mleftleft.right().Is(base::bits::CountTrailingZeros(mask))) {
        // (y << L + x) & (-1 << L) => (x & (-1 << L)) + y << L
        node->ReplaceInput(
            0, a.WordNAnd(mleft.right().node(), m.right().node()));
        node->ReplaceInput(1, mleftleft.node());
        NodeProperties::ChangeOp(node, a.IntNAdd(machine()));
        return Changed(node).FollowedBy(a.ReduceIntNAdd(node));
      }
    }
    if (A::IsWordNShl(mleft.right())) {
      typename A::IntNBinopMatcher mleftright(mleft.right().node());
      if (mleftright.right().Is(base::bits::CountTrailingZeros(mask))) {
        // (x + y << L) & (-1 << L) => (x & (-1 << L)) + y << L
        node->ReplaceInput(0,
                           a.WordNAnd(mleft.left().node(), m.right().node()));
        node->ReplaceInput(1, mleftright.node());
        NodeProperties::ChangeOp(node, a.IntNAdd(machine()));
        return Changed(node).FollowedBy(a.ReduceIntNAdd(node));
      }
    }
  } else if (A::IsIntNMul(m.left())) {
    typename A::IntNBinopMatcher mleft(m.left().node());
    if (mleft.right().IsMultipleOf(neg_mask)) {
      // (x * (K << L)) & (-1 << L) => x * (K << L)
      return Replace(mleft.node());
    }
  }
}
return NoChange();
1781}

1783namespace {

1785// Represents an operation of the form `(source & mask) == masked_value`.
1786// where each bit set in masked_value also has to be set in mask.
1787struct BitfieldCheck {
Node* const source;
uint32_t const mask;
uint32_t const masked_value;
bool const truncate_from_64_bit;

BitfieldCheck(Node* source, uint32_t mask, uint32_t masked_value,
              bool truncate_from_64_bit)
    : source(source),
      mask(mask),
      masked_value(masked_value),
      truncate_from_64_bit(truncate_from_64_bit) {
  CHECK_EQ(masked_value & ~mask, 0)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(masked_value & ~mask)>
::type, typename ::v8::base::pass_value_or_ref<decltype(0)
>::type>((masked_value & ~mask), (0)); do { if ((__builtin_expect
(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "masked_value & ~mask"
 " " "==" " " "0"); } } while (false); } while (false);
}

static base::Optional<BitfieldCheck> Detect(Node* node) {
  // There are two patterns to check for here:
  // 1. Single-bit checks: `(val >> shift) & 1`, where:
  //    - the shift may be omitted, and/or
  //    - the result may be truncated from 64 to 32
  // 2. Equality checks: `(val & mask) == expected`, where:
  //    - val may be truncated from 64 to 32 before masking (see
  //      ReduceWord32EqualForConstantRhs)
  if (node->opcode() == IrOpcode::kWord32Equal) {
    Uint32BinopMatcher eq(node);
    if (eq.left().IsWord32And()) {
      Uint32BinopMatcher mand(eq.left().node());
      if (mand.right().HasResolvedValue() && eq.right().HasResolvedValue()) {
        uint32_t mask = mand.right().ResolvedValue();
        uint32_t masked_value = eq.right().ResolvedValue();
        if ((masked_value & ~mask) != 0) return {};
        if (mand.left().IsTruncateInt64ToInt32()) {
          return BitfieldCheck(
              NodeProperties::GetValueInput(mand.left().node(), 0), mask,
              masked_value, true);
        } else {
          return BitfieldCheck(mand.left().node(), mask, masked_value, false);
        }
      }
    }
  } else {
    if (node->opcode() == IrOpcode::kTruncateInt64ToInt32) {
      return TryDetectShiftAndMaskOneBit<Word64Adapter>(
          NodeProperties::GetValueInput(node, 0));
    } else {
      return TryDetectShiftAndMaskOneBit<Word32Adapter>(node);
    }
  }
  return {};
}

base::Optional<BitfieldCheck> TryCombine(const BitfieldCheck& other) {
  if (source != other.source ||
      truncate_from_64_bit != other.truncate_from_64_bit)
    return {};
  uint32_t overlapping_bits = mask & other.mask;
  // It would be kind of strange to have any overlapping bits, but they can be
  // allowed as long as they don't require opposite values in the same
  // positions.
  if ((masked_value & overlapping_bits) !=
      (other.masked_value & overlapping_bits))
    return {};
  return BitfieldCheck{source, mask | other.mask,
                       masked_value | other.masked_value,
                       truncate_from_64_bit};
}

private:
template <typename WordNAdapter>
static base::Optional<BitfieldCheck> TryDetectShiftAndMaskOneBit(Node* node) {
  // Look for the pattern `(val >> shift) & 1`. The shift may be omitted.
  if (WordNAdapter::IsWordNAnd(NodeMatcher(node))) {
    typename WordNAdapter::IntNBinopMatcher mand(node);
    if (mand.right().HasResolvedValue() &&
        mand.right().ResolvedValue() == 1) {
      if (WordNAdapter::IsWordNShr(mand.left()) ||
          WordNAdapter::IsWordNSar(mand.left())) {
        typename WordNAdapter::UintNBinopMatcher shift(mand.left().node());
        if (shift.right().HasResolvedValue() &&
            shift.right().ResolvedValue() < 32u) {
          uint32_t mask = 1 << shift.right().ResolvedValue();
          return BitfieldCheck{shift.left().node(), mask, mask,
                               WordNAdapter::WORD_SIZE == 64};
        }
      }
      return BitfieldCheck{mand.left().node(), 1, 1,
                           WordNAdapter::WORD_SIZE == 64};
    }
  }
  return {};
}
1878};

1880}  // namespace

1882Reduction MachineOperatorReducer::ReduceWord32And(Node* node) {
DCHECK_EQ(IrOpcode::kWord32And, node->opcode())((void) 0);
Reduction reduction = ReduceWordNAnd<Word32Adapter>(node);
if (reduction.Changed()) {
  return reduction;
}

// Attempt to detect multiple bitfield checks from the same bitfield struct
// and fold them into a single check.
Int32BinopMatcher m(node);
if (auto right_bitfield = BitfieldCheck::Detect(m.right().node())) {
  if (auto left_bitfield = BitfieldCheck::Detect(m.left().node())) {
    if (auto combined_bitfield = left_bitfield->TryCombine(*right_bitfield)) {
      Node* source = combined_bitfield->source;
      if (combined_bitfield->truncate_from_64_bit) {
        source = TruncateInt64ToInt32(source);
      }
      node->ReplaceInput(0, Word32And(source, combined_bitfield->mask));
      node->ReplaceInput(1, Int32Constant(combined_bitfield->masked_value));
      NodeProperties::ChangeOp(node, machine()->Word32Equal());
      return Changed(node).FollowedBy(ReduceWord32Equal(node));
    }
  }
}

return NoChange();
1908}

1910Reduction MachineOperatorReducer::ReduceWord64And(Node* node) {
DCHECK_EQ(IrOpcode::kWord64And, node->opcode())((void) 0);
return ReduceWordNAnd<Word64Adapter>(node);
1913}

1915Reduction MachineOperatorReducer::TryMatchWord32Ror(Node* node) {
// Recognize rotation, we are matching and transforming as follows:
//   x << y         |  x >>> (32 - y)    =>  x ror (32 - y)
//   x << (32 - y)  |  x >>> y           =>  x ror y
//   x << y         ^  x >>> (32 - y)    =>  x ror (32 - y)   if y & 31 != 0
//   x << (32 - y)  ^  x >>> y           =>  x ror y          if y & 31 != 0
// (As well as the commuted forms.)
// Note the side condition for XOR: the optimization doesn't hold for
// multiples of 32.

DCHECK(IrOpcode::kWord32Or == node->opcode() ||((void) 0)
       IrOpcode::kWord32Xor == node->opcode())((void) 0);
Int32BinopMatcher m(node);
Node* shl = nullptr;
Node* shr = nullptr;
if (m.left().IsWord32Shl() && m.right().IsWord32Shr()) {
  shl = m.left().node();
  shr = m.right().node();
} else if (m.left().IsWord32Shr() && m.right().IsWord32Shl()) {
  shl = m.right().node();
  shr = m.left().node();
} else {
  return NoChange();
}

Int32BinopMatcher mshl(shl);
Int32BinopMatcher mshr(shr);
if (mshl.left().node() != mshr.left().node()) return NoChange();

if (mshl.right().HasResolvedValue() && mshr.right().HasResolvedValue()) {
  // Case where y is a constant.
  if (mshl.right().ResolvedValue() + mshr.right().ResolvedValue() != 32) {
    return NoChange();
  }
  if (node->opcode() == IrOpcode::kWord32Xor &&
      (mshl.right().ResolvedValue() & 31) == 0) {
    return NoChange();
  }
} else {
  Node* sub = nullptr;
  Node* y = nullptr;
  if (mshl.right().IsInt32Sub()) {
    sub = mshl.right().node();
    y = mshr.right().node();
  } else if (mshr.right().IsInt32Sub()) {
    sub = mshr.right().node();
    y = mshl.right().node();
  } else {
    return NoChange();
  }

  Int32BinopMatcher msub(sub);
  if (!msub.left().Is(32) || msub.right().node() != y) return NoChange();
  if (node->opcode() == IrOpcode::kWord32Xor) {
    return NoChange();  // Can't guarantee y & 31 != 0.
  }
}

node->ReplaceInput(0, mshl.left().node());
node->ReplaceInput(1, mshr.right().node());
NodeProperties::ChangeOp(node, machine()->Word32Ror());
return Changed(node);
1977}

1979template <typename WordNAdapter>
1980Reduction MachineOperatorReducer::ReduceWordNOr(Node* node) {
using A = WordNAdapter;
A a(this);

typename A::IntNBinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());    // x | 0  => x
if (m.right().Is(-1)) return Replace(m.right().node());  // x | -1 => -1
if (m.IsFoldable()) {  // K | K  => K  (K stands for arbitrary constants)
  return a.ReplaceIntN(m.left().ResolvedValue() | m.right().ResolvedValue());
}
if (m.LeftEqualsRight()) return Replace(m.left().node());  // x | x => x

// (x & K1) | K2 => x | K2 if K2 has ones for every zero bit in K1.
// This case can be constructed by UpdateWord and UpdateWord32 in CSA.
if (m.right().HasResolvedValue()) {
  if (A::IsWordNAnd(m.left())) {
    typename A::IntNBinopMatcher mand(m.left().node());
    if (mand.right().HasResolvedValue()) {
      if ((m.right().ResolvedValue() | mand.right().ResolvedValue()) == -1) {
        node->ReplaceInput(0, mand.left().node());
        return Changed(node);
      }
    }
  }
}

return a.TryMatchWordNRor(node);
2007}

2009Reduction MachineOperatorReducer::ReduceWord32Or(Node* node) {
DCHECK_EQ(IrOpcode::kWord32Or, node->opcode())((void) 0);
return ReduceWordNOr<Word32Adapter>(node);
2012}

2014Reduction MachineOperatorReducer::ReduceWord64Or(Node* node) {
DCHECK_EQ(IrOpcode::kWord64Or, node->opcode())((void) 0);
return ReduceWordNOr<Word64Adapter>(node);
2017}

2019template <typename WordNAdapter>
2020Reduction MachineOperatorReducer::ReduceWordNXor(Node* node) {
using A = WordNAdapter;
A a(this);

typename A::IntNBinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node());  // x ^ 0 => x
if (m.IsFoldable()) {  // K ^ K => K  (K stands for arbitrary constants)
  return a.ReplaceIntN(m.left().ResolvedValue() ^ m.right().ResolvedValue());
}
if (m.LeftEqualsRight()) return ReplaceInt32(0);  // x ^ x => 0
if (A::IsWordNXor(m.left()) && m.right().Is(-1)) {
  typename A::IntNBinopMatcher mleft(m.left().node());
  if (mleft.right().Is(-1)) {  // (x ^ -1) ^ -1 => x
    return Replace(mleft.left().node());
  }
}

return a.TryMatchWordNRor(node);
2038}

2040Reduction MachineOperatorReducer::ReduceWord32Xor(Node* node) {
DCHECK_EQ(IrOpcode::kWord32Xor, node->opcode())((void) 0);
Int32BinopMatcher m(node);
if (m.right().IsWord32Equal() && m.left().Is(1)) {
  return Replace(Word32Equal(m.right().node(), Int32Constant(0)));
}
return ReduceWordNXor<Word32Adapter>(node);
2047}

2049Reduction MachineOperatorReducer::ReduceWord64Xor(Node* node) {
DCHECK_EQ(IrOpcode::kWord64Xor, node->opcode())((void) 0);
return ReduceWordNXor<Word64Adapter>(node);
2052}

2054Reduction MachineOperatorReducer::ReduceWord32Equal(Node* node) {
Int32BinopMatcher m(node);
if (m.IsFoldable()) {  // K == K => K  (K stands for arbitrary constants)
  return ReplaceBool(m.left().ResolvedValue() == m.right().ResolvedValue());
}
if (m.left().IsInt32Sub() && m.right().Is(0)) {  // x - y == 0 => x == y
  Int32BinopMatcher msub(m.left().node());
  node->ReplaceInput(0, msub.left().node());
  node->ReplaceInput(1, msub.right().node());
  return Changed(node);
}
// TODO(turbofan): fold HeapConstant, ExternalReference, pointer compares
if (m.LeftEqualsRight()) return ReplaceBool(true);  // x == x => true
if (m.right().HasResolvedValue()) {
  base::Optional<std::pair<Node*, uint32_t>> replacements;
  if (m.left().IsTruncateInt64ToInt32()) {
    replacements = ReduceWord32EqualForConstantRhs<Word64Adapter>(
        NodeProperties::GetValueInput(m.left().node(), 0),
        static_cast<uint32_t>(m.right().ResolvedValue()));
  } else {
    replacements = ReduceWord32EqualForConstantRhs<Word32Adapter>(
        m.left().node(), static_cast<uint32_t>(m.right().ResolvedValue()));
  }
  if (replacements) {
    node->ReplaceInput(0, replacements->first);
    node->ReplaceInput(1, Uint32Constant(replacements->second));
    return Changed(node);
  }
}
// This is a workaround for not having escape analysis for wasm
// (machine-level) turbofan graphs.
if (!ObjectsMayAlias(m.left().node(), m.right().node())) {
  return ReplaceBool(false);
}

return NoChange();
2090}

2092Reduction MachineOperatorReducer::ReduceFloat64InsertLowWord32(Node* node) {
DCHECK_EQ(IrOpcode::kFloat64InsertLowWord32, node->opcode())((void) 0);
Float64Matcher mlhs(node->InputAt(0));
Uint32Matcher mrhs(node->InputAt(1));
if (mlhs.HasResolvedValue() && mrhs.HasResolvedValue()) {
  return ReplaceFloat64(
      bit_cast<double>((bit_cast<uint64_t>(mlhs.ResolvedValue()) &
                        uint64_t{0xFFFFFFFF00000000}) |
                       mrhs.ResolvedValue()));
}
return NoChange();
2103}

2105Reduction MachineOperatorReducer::ReduceFloat64InsertHighWord32(Node* node) {
DCHECK_EQ(IrOpcode::kFloat64InsertHighWord32, node->opcode())((void) 0);
Float64Matcher mlhs(node->InputAt(0));
Uint32Matcher mrhs(node->InputAt(1));
if (mlhs.HasResolvedValue() && mrhs.HasResolvedValue()) {
  return ReplaceFloat64(bit_cast<double>(
      (bit_cast<uint64_t>(mlhs.ResolvedValue()) & uint64_t{0xFFFFFFFF}) |
      (static_cast<uint64_t>(mrhs.ResolvedValue()) << 32)));
}
return NoChange();
2115}

2117namespace {

2119bool IsFloat64RepresentableAsFloat32(const Float64Matcher& m) {
if (m.HasResolvedValue()) {
  double v = m.ResolvedValue();
  return DoubleToFloat32(v) == v;
}
return false;
2125}

2127}  // namespace

2129Reduction MachineOperatorReducer::ReduceFloat64Compare(Node* node) {
DCHECK(IrOpcode::kFloat64Equal == node->opcode() ||((void) 0)
       IrOpcode::kFloat64LessThan == node->opcode() ||((void) 0)
       IrOpcode::kFloat64LessThanOrEqual == node->opcode())((void) 0);
Float64BinopMatcher m(node);
if (m.IsFoldable()) {
  switch (node->opcode()) {
    case IrOpcode::kFloat64Equal:
      return ReplaceBool(m.left().ResolvedValue() ==
                         m.right().ResolvedValue());
    case IrOpcode::kFloat64LessThan:
      return ReplaceBool(m.left().ResolvedValue() <
                         m.right().ResolvedValue());
    case IrOpcode::kFloat64LessThanOrEqual:
      return ReplaceBool(m.left().ResolvedValue() <=
                         m.right().ResolvedValue());
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
} else if ((m.left().IsChangeFloat32ToFloat64() &&
            m.right().IsChangeFloat32ToFloat64()) ||
           (m.left().IsChangeFloat32ToFloat64() &&
            IsFloat64RepresentableAsFloat32(m.right())) ||
           (IsFloat64RepresentableAsFloat32(m.left()) &&
            m.right().IsChangeFloat32ToFloat64())) {
  // As all Float32 values have an exact representation in Float64, comparing
  // two Float64 values both converted from Float32 is equivalent to comparing
  // the original Float32s, so we can ignore the conversions. We can also
  // reduce comparisons of converted Float64 values against constants that
  // can be represented exactly as Float32.
  switch (node->opcode()) {
    case IrOpcode::kFloat64Equal:
      NodeProperties::ChangeOp(node, machine()->Float32Equal());
      break;
    case IrOpcode::kFloat64LessThan:
      NodeProperties::ChangeOp(node, machine()->Float32LessThan());
      break;
    case IrOpcode::kFloat64LessThanOrEqual:
      NodeProperties::ChangeOp(node, machine()->Float32LessThanOrEqual());
      break;
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
  node->ReplaceInput(
      0, m.left().HasResolvedValue()
             ? Float32Constant(static_cast<float>(m.left().ResolvedValue()))
             : m.left().InputAt(0));
  node->ReplaceInput(
      1, m.right().HasResolvedValue()
             ? Float32Constant(static_cast<float>(m.right().ResolvedValue()))
             : m.right().InputAt(0));
  return Changed(node);
}
return NoChange();
2183}

2185Reduction MachineOperatorReducer::ReduceFloat64RoundDown(Node* node) {
DCHECK_EQ(IrOpcode::kFloat64RoundDown, node->opcode())((void) 0);
Float64Matcher m(node->InputAt(0));
if (m.HasResolvedValue()) {
  return ReplaceFloat64(std::floor(m.ResolvedValue()));
}
return NoChange();
2192}

2194namespace {

2196// Returns true if |node| is a constant whose value is 0.
2197bool IsZero(Node* node) {
switch (node->opcode()) {
2199#define CASE_IS_ZERO(opcode, matcher) \
case IrOpcode::opcode: {            \
  matcher m(node);                  \
  return m.Is(0);                   \
}
  CASE_IS_ZERO(kInt32Constant, Int32Matcher)
  CASE_IS_ZERO(kInt64Constant, Int64Matcher)
2206#undef CASE_IS_ZERO
  default:
    break;
}
return false;
2211}

2213// If |node| is of the form "x == 0", then return "x" (in order to remove the
2214// "== 0" part).
2215base::Optional<Node*> TryGetInvertedCondition(Node* cond) {
if (cond->opcode() == IrOpcode::kWord32Equal) {
  Int32BinopMatcher m(cond);
  if (IsZero(m.right().node())) {
    return m.left().node();
  }
}
return base::nullopt;
2223}

2225struct SimplifiedCondition {
Node* condition;
bool is_inverted;
2228};

2230// Tries to simplifies |cond| by removing all top-level "== 0". Everytime such a
2231// construction is removed, the meaning of the comparison is inverted. This is
2232// recorded by the variable |is_inverted| throughout this function, and returned
2233// at the end. If |is_inverted| is true at the end, the caller should invert the
2234// if/else branches following the comparison.
2235base::Optional<SimplifiedCondition> TrySimplifyCompareZero(Node* cond) {
bool is_inverted = false;
bool changed = false;
base::Optional<Node*> new_cond;
while ((new_cond = TryGetInvertedCondition(cond)).has_value()) {
  cond = *new_cond;
  is_inverted = !is_inverted;
  changed = true;
}
if (changed) {
  return SimplifiedCondition{cond, is_inverted};
} else {
  return {};
}
2249}

2251}  // namespace

2253void MachineOperatorReducer::SwapBranches(Node* node) {
DCHECK_EQ(node->opcode(), IrOpcode::kBranch)((void) 0);
for (Node* const use : node->uses()) {
  switch (use->opcode()) {
    case IrOpcode::kIfTrue:
      NodeProperties::ChangeOp(use, common()->IfFalse());
      break;
    case IrOpcode::kIfFalse:
      NodeProperties::ChangeOp(use, common()->IfTrue());
      break;
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
}
NodeProperties::ChangeOp(
    node, common()->Branch(NegateBranchHint(BranchHintOf(node->op()))));
2269}

2271// If |node| is a branch, removes all top-level 32-bit "== 0" from |node|.
2272Reduction MachineOperatorReducer::SimplifyBranch(Node* node) {
Node* cond = node->InputAt(0);
if (auto simplified = TrySimplifyCompareZero(cond)) {
  node->ReplaceInput(0, simplified->condition);
  if (simplified->is_inverted) {
    switch (node->opcode()) {
      case IrOpcode::kBranch:
        SwapBranches(node);
        break;
      case IrOpcode::kTrapIf:
        NodeProperties::ChangeOp(node,
                                 common()->TrapUnless(TrapIdOf(node->op())));
        break;
      case IrOpcode::kTrapUnless:
        NodeProperties::ChangeOp(node,
                                 common()->TrapIf(TrapIdOf(node->op())));
        break;
      case IrOpcode::kDeoptimizeIf: {
        DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
        NodeProperties::ChangeOp(
            node, common()->DeoptimizeUnless(p.reason(), p.feedback()));
        break;
      }
      case IrOpcode::kDeoptimizeUnless: {
        DeoptimizeParameters p = DeoptimizeParametersOf(node->op());
        NodeProperties::ChangeOp(
            node, common()->DeoptimizeIf(p.reason(), p.feedback()));
        break;
      }
      default:

        UNREACHABLE()V8_Fatal("unreachable code");
    }
  }
  return Changed(node);
}
return NoChange();
2309}

2311Reduction MachineOperatorReducer::ReduceConditional(Node* node) {
DCHECK(node->opcode() == IrOpcode::kBranch ||((void) 0)
       node->opcode() == IrOpcode::kDeoptimizeIf ||((void) 0)
       node->opcode() == IrOpcode::kDeoptimizeUnless ||((void) 0)
       node->opcode() == IrOpcode::kTrapIf ||((void) 0)
       node->opcode() == IrOpcode::kTrapUnless)((void) 0);
// This reducer only applies operator reductions to the branch condition.
// Reductions involving control flow happen elsewhere. Non-zero inputs are
// considered true in all conditional ops.
NodeMatcher condition(NodeProperties::GetValueInput(node, 0));
Reduction reduction = NoChange();
if (condition.IsTruncateInt64ToInt32()) {
  if (auto replacement =
          ReduceConditionalN<Word64Adapter>(condition.node())) {
    NodeProperties::ReplaceValueInput(node, *replacement, 0);
    reduction = Changed(node);
  }
} else if (auto replacement = ReduceConditionalN<Word32Adapter>(node)) {
  NodeProperties::ReplaceValueInput(node, *replacement, 0);
  reduction = Changed(node);
}
return reduction.FollowedBy(SimplifyBranch(node));
2333}

2335template <typename WordNAdapter>
2336base::Optional<Node*> MachineOperatorReducer::ReduceConditionalN(Node* node) {
NodeMatcher condition(NodeProperties::GetValueInput(node, 0));
// Branch conditions are 32-bit comparisons against zero, so they are the
// opposite of a 32-bit `x == 0` node. To avoid repetition, we can reuse logic
// for Word32Equal: if `x == 0` can reduce to `y == 0`, then branch(x) can
// reduce to branch(y).
auto replacements =
    ReduceWord32EqualForConstantRhs<WordNAdapter>(condition.node(), 0);
if (replacements && replacements->second == 0) return replacements->first;
return {};
2346}

2348template <typename WordNAdapter>
2349base::Optional<std::pair<Node*, uint32_t>>
2350MachineOperatorReducer::ReduceWord32EqualForConstantRhs(Node* lhs,
                                                      uint32_t rhs) {
if (WordNAdapter::IsWordNAnd(NodeMatcher(lhs))) {
  typename WordNAdapter::UintNBinopMatcher mand(lhs);
  if ((WordNAdapter::IsWordNShr(mand.left()) ||
       WordNAdapter::IsWordNSar(mand.left())) &&
      mand.right().HasResolvedValue()) {
    typename WordNAdapter::UintNBinopMatcher mshift(mand.left().node());
    // ((x >> K1) & K2) == K3 => (x & (K2 << K1)) == (K3 << K1)
    if (mshift.right().HasResolvedValue()) {
      auto shift_bits = mshift.right().ResolvedValue();
      auto mask = mand.right().ResolvedValue();
      // Make sure that we won't shift data off the end, and that all of the
      // data ends up in the lower 32 bits for 64-bit mode.
      if (shift_bits <= base::bits::CountLeadingZeros(mask) &&
          shift_bits <= base::bits::CountLeadingZeros(rhs) &&
          mask << shift_bits <= std::numeric_limits<uint32_t>::max()) {
        Node* new_input = mshift.left().node();
        uint32_t new_mask = static_cast<uint32_t>(mask << shift_bits);
        uint32_t new_rhs = rhs << shift_bits;
        if (WordNAdapter::WORD_SIZE == 64) {
          // We can truncate before performing the And.
          new_input = TruncateInt64ToInt32(new_input);
        }
        return std::make_pair(Word32And(new_input, new_mask), new_rhs);
      }
    }
  }
}
// Replaces (x >> n) == k with x == k << n, with "k << n" being computed
// here at compile time.
if (lhs->op() == machine()->Word32SarShiftOutZeros() &&
    lhs->UseCount() == 1) {
  typename WordNAdapter::UintNBinopMatcher mshift(lhs);
  if (mshift.right().HasResolvedValue()) {
    int32_t shift = static_cast<int32_t>(mshift.right().ResolvedValue());
    if (CanRevertLeftShiftWithRightShift(rhs, shift)) {
      return std::make_pair(mshift.left().node(), rhs << shift);
    }
  }
}
return {};
2392}

2394CommonOperatorBuilder* MachineOperatorReducer::common() const {
return mcgraph()->common();
2396}

2398MachineOperatorBuilder* MachineOperatorReducer::machine() const {
return mcgraph()->machine();
2400}

2402Graph* MachineOperatorReducer::graph() const { return mcgraph()->graph(); }

2404}  // namespace compiler
2405}  // namespace internal
2406}  // namespace v8

←

../deps/v8/src/base/bits.h

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_BASE_BITS_H_
6#define V8_BASE_BITS_H_
7 
8#include <stdint.h>
9#include <type_traits>
10 
11#include "src/base/base-export.h"
12#include "src/base/macros.h"
13#if V8_CC_MSVC
14#include <intrin.h>
15#endif
16#if V8_OS_WIN32
17#include "src/base/win32-headers.h"
18#endif
19 
20namespace v8 {
21namespace base {
22namespace bits {
23 
24// CountPopulation(value) returns the number of bits set in |value|.
25template <typename T>
26constexpr inline
27    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
28                            unsigned>::type
29    CountPopulation(T value) {
30  STATIC_ASSERT(sizeof(T) <= 8)static_assert(sizeof(T) <= 8, "sizeof(T) <= 8");
31#if V8_HAS_BUILTIN_POPCOUNT(1)
32  return sizeof(T) == 8 ? __builtin_popcountll(static_cast<uint64_t>(value))
33                        : __builtin_popcount(static_cast<uint32_t>(value));
34#else
35  // Fall back to divide-and-conquer popcount (see "Hacker's Delight" by Henry
36  // S. Warren, Jr.), chapter 5-1.
37  constexpr uint64_t mask[] = {0x5555555555555555, 0x3333333333333333,
38                               0x0f0f0f0f0f0f0f0f};
39  // Start with 64 buckets of 1 bits, holding values from [0,1].
40  value = ((value >> 1) & mask[0]) + (value & mask[0]);
41  // Having 32 buckets of 2 bits, holding values from [0,2] now.
42  value = ((value >> 2) & mask[1]) + (value & mask[1]);
43  // Having 16 buckets of 4 bits, holding values from [0,4] now.
44  value = ((value >> 4) & mask[2]) + (value & mask[2]);
45  // Having 8 buckets of 8 bits, holding values from [0,8] now.
46  // From this point on, the buckets are bigger than the number of bits
47  // required to hold the values, and the buckets are bigger the maximum
48  // result, so there's no need to mask value anymore, since there's no
49  // more risk of overflow between buckets.
50  if (sizeof(T) > 1) value = (value >> (sizeof(T) > 1 ? 8 : 0)) + value;
51  // Having 4 buckets of 16 bits, holding values from [0,16] now.
52  if (sizeof(T) > 2) value = (value >> (sizeof(T) > 2 ? 16 : 0)) + value;
53  // Having 2 buckets of 32 bits, holding values from [0,32] now.
54  if (sizeof(T) > 4) value = (value >> (sizeof(T) > 4 ? 32 : 0)) + value;
55  // Having 1 buckets of 64 bits, holding values from [0,64] now.
56  return static_cast<unsigned>(value & 0xff);
57#endif
58}
59 
60// ReverseBits(value) returns |value| in reverse bit order.
61template <typename T>
62T ReverseBits(T value) {
63  STATIC_ASSERT((sizeof(value) == 1) || (sizeof(value) == 2) ||static_assert((sizeof(value) == 1) || (sizeof(value) == 2) ||
 (sizeof(value) == 4) || (sizeof(value) == 8), "(sizeof(value) == 1) || (sizeof(value) == 2) || (sizeof(value) == 4) || (sizeof(value) == 8)"
)
64                (sizeof(value) == 4) || (sizeof(value) == 8))static_assert((sizeof(value) == 1) || (sizeof(value) == 2) ||
 (sizeof(value) == 4) || (sizeof(value) == 8), "(sizeof(value) == 1) || (sizeof(value) == 2) || (sizeof(value) == 4) || (sizeof(value) == 8)"
);
65  T result = 0;
66  for (unsigned i = 0; i < (sizeof(value) * 8); i++) {
67    result = (result << 1) | (value & 1);
68    value >>= 1;
69  }
70  return result;
71}
72 
73// CountLeadingZeros(value) returns the number of zero bits following the most
74// significant 1 bit in |value| if |value| is non-zero, otherwise it returns
75// {sizeof(T) * 8}.
76template <typename T, unsigned bits = sizeof(T) * 8>
77inline constexpr
78    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
79                            unsigned>::type
80    CountLeadingZeros(T value) {
81  static_assert(bits > 0, "invalid instantiation");
82#if V8_HAS_BUILTIN_CLZ(1)
83  return value == 0
84             ? bits
85             : bits == 64
86                   ? __builtin_clzll(static_cast<uint64_t>(value))
87                   : __builtin_clz(static_cast<uint32_t>(value)) - (32 - bits);
88#else
89  // Binary search algorithm taken from "Hacker's Delight" (by Henry S. Warren,
90  // Jr.), figures 5-11 and 5-12.
91  if (bits == 1) return static_cast<unsigned>(value) ^ 1;
92  T upper_half = value >> (bits / 2);
93  T next_value = upper_half != 0 ? upper_half : value;
94  unsigned add = upper_half != 0 ? 0 : bits / 2;
95  constexpr unsigned next_bits = bits == 1 ? 1 : bits / 2;
96  return CountLeadingZeros<T, next_bits>(next_value) + add;
97#endif
98}
99 
100inline constexpr unsigned CountLeadingZeros32(uint32_t value) {
101  return CountLeadingZeros(value);
102}
103inline constexpr unsigned CountLeadingZeros64(uint64_t value) {
104  return CountLeadingZeros(value);
105}
106 
107// CountTrailingZeros(value) returns the number of zero bits preceding the
108// least significant 1 bit in |value| if |value| is non-zero, otherwise it
109// returns {sizeof(T) * 8}.
110// See CountTrailingZerosNonZero for an optimized version for the case that
111// |value| is guaranteed to be non-zero.
112template <typename T, unsigned bits = sizeof(T) * 8>
113inline constexpr
114    typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
115                            unsigned>::type
116    CountTrailingZeros(T value) {
117#if V8_HAS_BUILTIN_CTZ(1)
118  return value == 0 ? bits
2
←
Assuming 'value' is equal to 0→
3
←
'?' condition is true→
4
←
Returning the value 32→
119                    : bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
120                                 : __builtin_ctz(static_cast<uint32_t>(value));
121#else
122  // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
123  // chapter 5-4. On x64, since is faster than counting in a loop and faster
124  // than doing binary search.
125  using U = typename std::make_unsigned<T>::type;
126  U u = value;
127  return CountPopulation(static_cast<U>(~u & (u - 1u)));
128#endif
129}
130 
131inline constexpr unsigned CountTrailingZeros32(uint32_t value) {
132  return CountTrailingZeros(value);
133}
134inline constexpr unsigned CountTrailingZeros64(uint64_t value) {
135  return CountTrailingZeros(value);
136}
137 
138// CountTrailingZerosNonZero(value) returns the number of zero bits preceding
139// the least significant 1 bit in |value| if |value| is non-zero, otherwise the
140// behavior is undefined.
141// See CountTrailingZeros for an alternative version that allows |value| == 0.
142template <typename T, unsigned bits = sizeof(T) * 8>
143inline constexpr
144    typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
145                            unsigned>::type
146    CountTrailingZerosNonZero(T value) {
147  DCHECK_NE(0, value)((void) 0);
148#if V8_HAS_BUILTIN_CTZ(1)
149  return bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
150                    : __builtin_ctz(static_cast<uint32_t>(value));
151#else
152  return CountTrailingZeros<T, bits>(value);
153#endif
154}
155 
156// Returns true iff |value| is a power of 2.
157template <typename T,
158          typename = typename std::enable_if<std::is_integral<T>::value ||
159                                             std::is_enum<T>::value>::type>
160constexpr inline bool IsPowerOfTwo(T value) {
161  return value > 0 && (value & (value - 1)) == 0;
162}
163 
164// Identical to {CountTrailingZeros}, but only works for powers of 2.
165template <typename T,
166          typename = typename std::enable_if<std::is_integral<T>::value>::type>
167inline constexpr int WhichPowerOfTwo(T value) {
168  DCHECK(IsPowerOfTwo(value))((void) 0);
169#if V8_HAS_BUILTIN_CTZ(1)
170  STATIC_ASSERT(sizeof(T) <= 8)static_assert(sizeof(T) <= 8, "sizeof(T) <= 8");
171  return sizeof(T) == 8 ? __builtin_ctzll(static_cast<uint64_t>(value))
172                        : __builtin_ctz(static_cast<uint32_t>(value));
173#else
174  // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
175  // chapter 5-4. On x64, since is faster than counting in a loop and faster
176  // than doing binary search.
177  using U = typename std::make_unsigned<T>::type;
178  U u = value;
179  return CountPopulation(static_cast<U>(u - 1));
180#endif
181}
182 
183// RoundUpToPowerOfTwo32(value) returns the smallest power of two which is
184// greater than or equal to |value|. If you pass in a |value| that is already a
185// power of two, it is returned as is. |value| must be less than or equal to
186// 0x80000000u. Uses computation based on leading zeros if we have compiler
187// support for that. Falls back to the implementation from "Hacker's Delight" by
188// Henry S. Warren, Jr., figure 3-3, page 48, where the function is called clp2.
189V8_BASE_EXPORT uint32_t RoundUpToPowerOfTwo32(uint32_t value);
190// Same for 64 bit integers. |value| must be <= 2^63
191V8_BASE_EXPORT uint64_t RoundUpToPowerOfTwo64(uint64_t value);
192// Same for size_t integers.
193inline size_t RoundUpToPowerOfTwo(size_t value) {
194  if (sizeof(size_t) == sizeof(uint64_t)) {
195    return RoundUpToPowerOfTwo64(value);
196  } else {
197    // Without windows.h included this line triggers a truncation warning on
198    // 64-bit builds. Presumably windows.h disables the relevant warning.
199    return RoundUpToPowerOfTwo32(static_cast<uint32_t>(value));
200  }
201}
202 
203// RoundDownToPowerOfTwo32(value) returns the greatest power of two which is
204// less than or equal to |value|. If you pass in a |value| that is already a
205// power of two, it is returned as is.
206inline uint32_t RoundDownToPowerOfTwo32(uint32_t value) {
207  if (value > 0x80000000u) return 0x80000000u;
208  uint32_t result = RoundUpToPowerOfTwo32(value);
209  if (result > value) result >>= 1;
210  return result;
211}
212 
213 
214// Precondition: 0 <= shift < 32
215inline constexpr uint32_t RotateRight32(uint32_t value, uint32_t shift) {
216  return (value >> shift) | (value << ((32 - shift) & 31));
217}
218 
219// Precondition: 0 <= shift < 32
220inline constexpr uint32_t RotateLeft32(uint32_t value, uint32_t shift) {
221  return (value << shift) | (value >> ((32 - shift) & 31));
222}
223 
224// Precondition: 0 <= shift < 64
225inline constexpr uint64_t RotateRight64(uint64_t value, uint64_t shift) {
226  return (value >> shift) | (value << ((64 - shift) & 63));
227}
228 
229// Precondition: 0 <= shift < 64
230inline constexpr uint64_t RotateLeft64(uint64_t value, uint64_t shift) {
231  return (value << shift) | (value >> ((64 - shift) & 63));
232}
233 
234// SignedAddOverflow32(lhs,rhs,val) performs a signed summation of |lhs| and
235// |rhs| and stores the result into the variable pointed to by |val| and
236// returns true if the signed summation resulted in an overflow.
237inline bool SignedAddOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
238#if V8_HAS_BUILTIN_SADD_OVERFLOW(1)
239  return __builtin_sadd_overflow(lhs, rhs, val);
240#else
241  uint32_t res = static_cast<uint32_t>(lhs) + static_cast<uint32_t>(rhs);
242  *val = bit_cast<int32_t>(res);
243  return ((res ^ lhs) & (res ^ rhs) & (1U << 31)) != 0;
244#endif
245}
246 
247 
248// SignedSubOverflow32(lhs,rhs,val) performs a signed subtraction of |lhs| and
249// |rhs| and stores the result into the variable pointed to by |val| and
250// returns true if the signed subtraction resulted in an overflow.
251inline bool SignedSubOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
252#if V8_HAS_BUILTIN_SSUB_OVERFLOW(1)
253  return __builtin_ssub_overflow(lhs, rhs, val);
254#else
255  uint32_t res = static_cast<uint32_t>(lhs) - static_cast<uint32_t>(rhs);
256  *val = bit_cast<int32_t>(res);
257  return ((res ^ lhs) & (res ^ ~rhs) & (1U << 31)) != 0;
258#endif
259}
260 
261// SignedMulOverflow32(lhs,rhs,val) performs a signed multiplication of |lhs|
262// and |rhs| and stores the result into the variable pointed to by |val| and
263// returns true if the signed multiplication resulted in an overflow.
264V8_BASE_EXPORT bool SignedMulOverflow32(int32_t lhs, int32_t rhs, int32_t* val);
265 
266// SignedAddOverflow64(lhs,rhs,val) performs a signed summation of |lhs| and
267// |rhs| and stores the result into the variable pointed to by |val| and
268// returns true if the signed summation resulted in an overflow.
269inline bool SignedAddOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
270  uint64_t res = static_cast<uint64_t>(lhs) + static_cast<uint64_t>(rhs);
271  *val = bit_cast<int64_t>(res);
272  return ((res ^ lhs) & (res ^ rhs) & (1ULL << 63)) != 0;
273}
274 
275 
276// SignedSubOverflow64(lhs,rhs,val) performs a signed subtraction of |lhs| and
277// |rhs| and stores the result into the variable pointed to by |val| and
278// returns true if the signed subtraction resulted in an overflow.
279inline bool SignedSubOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
280  uint64_t res = static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs);
281  *val = bit_cast<int64_t>(res);
282  return ((res ^ lhs) & (res ^ ~rhs) & (1ULL << 63)) != 0;
283}
284 
285// SignedMulHigh32(lhs, rhs) multiplies two signed 32-bit values |lhs| and
286// |rhs|, extracts the most significant 32 bits of the result, and returns
287// those.
288V8_BASE_EXPORT int32_t SignedMulHigh32(int32_t lhs, int32_t rhs);
289 
290// SignedMulHighAndAdd32(lhs, rhs, acc) multiplies two signed 32-bit values
291// |lhs| and |rhs|, extracts the most significant 32 bits of the result, and
292// adds the accumulate value |acc|.
293V8_BASE_EXPORT int32_t SignedMulHighAndAdd32(int32_t lhs, int32_t rhs,
294                                             int32_t acc);
295 
296// SignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
297// truncated to int32. If |rhs| is zero, then zero is returned. If |lhs|
298// is minint and |rhs| is -1, it returns minint.
299V8_BASE_EXPORT int32_t SignedDiv32(int32_t lhs, int32_t rhs);
300 
301// SignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
302// truncated to int32. If either |rhs| is zero or |lhs| is minint and |rhs|
303// is -1, it returns zero.
304V8_BASE_EXPORT int32_t SignedMod32(int32_t lhs, int32_t rhs);
305 
306// UnsignedAddOverflow32(lhs,rhs,val) performs an unsigned summation of |lhs|
307// and |rhs| and stores the result into the variable pointed to by |val| and
308// returns true if the unsigned summation resulted in an overflow.
309inline bool UnsignedAddOverflow32(uint32_t lhs, uint32_t rhs, uint32_t* val) {
310#if V8_HAS_BUILTIN_SADD_OVERFLOW(1)
311  return __builtin_uadd_overflow(lhs, rhs, val);
312#else
313  *val = lhs + rhs;
314  return *val < (lhs | rhs);
315#endif
316}
317 
318 
319// UnsignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
320// truncated to uint32. If |rhs| is zero, then zero is returned.
321inline uint32_t UnsignedDiv32(uint32_t lhs, uint32_t rhs) {
322  return rhs ? lhs / rhs : 0u;
323}
324 
325 
326// UnsignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
327// truncated to uint32. If |rhs| is zero, then zero is returned.
328inline uint32_t UnsignedMod32(uint32_t lhs, uint32_t rhs) {
329  return rhs ? lhs % rhs : 0u;
330}
331 
332// Wraparound integer arithmetic without undefined behavior.
333 
334inline int32_t WraparoundAdd32(int32_t lhs, int32_t rhs) {
335  return static_cast<int32_t>(static_cast<uint32_t>(lhs) +
336                              static_cast<uint32_t>(rhs));
337}
338 
339inline int32_t WraparoundNeg32(int32_t x) {
340  return static_cast<int32_t>(-static_cast<uint32_t>(x));
341}
342 
343// SignedSaturatedAdd64(lhs, rhs) adds |lhs| and |rhs|,
344// checks and returns the result.
345V8_BASE_EXPORT int64_t SignedSaturatedAdd64(int64_t lhs, int64_t rhs);
346 
347// SignedSaturatedSub64(lhs, rhs) subtracts |lhs| by |rhs|,
348// checks and returns the result.
349V8_BASE_EXPORT int64_t SignedSaturatedSub64(int64_t lhs, int64_t rhs);
350 
351}  // namespace bits
352}  // namespace base
353}  // namespace v8
354 
355#endif  // V8_BASE_BITS_H_