Lines Matching defs:rhs
263 Node* BuildUint32Mod(Node* lhs, Node* rhs);
2076 Node* rhs = node->InputAt(2);
2086 rhs, __ NoContextConstant());
2094 Node* rhs = node->InputAt(1);
2096 Node* value = __ Int32AddWithOverflow(lhs, rhs);
2106 Node* rhs = node->InputAt(1);
2108 Node* value = __ Int32SubWithOverflow(lhs, rhs);
2118 Node* rhs = node->InputAt(1);
2121 // Check if the {rhs} is a known power of two.
2122 Int32Matcher m(rhs);
2124 // Since we know that {rhs} is a power of two, we can perform a fast
2141 // Check if {rhs} is positive (and not zero).
2142 Node* check_rhs_positive = __ Int32LessThan(zero, rhs);
2148 __ Goto(&done, __ Int32Div(lhs, rhs));
2156 // Check if {rhs} is zero.
2157 Node* check_rhs_zero = __ Word32Equal(rhs, zero);
2166 // Check if {lhs} is kMinInt and {rhs} is -1, in which case we'd have
2173 // Check that {rhs} is not -1, otherwise result would be -kMinInt.
2174 Node* check_rhs_minusone = __ Word32Equal(rhs, __ Int32Constant(-1));
2179 __ Goto(&done, __ Int32Div(lhs, rhs));
2185 __ Goto(&done, __ Int32Div(lhs, rhs));
2193 Node* check = __ Word32Equal(lhs, __ Int32Mul(value, rhs));
2230 Node* EffectControlLinearizer::BuildUint32Mod(Node* lhs, Node* rhs) {
2234 // Compute the mask for the {rhs}.
2236 Node* msk = __ Int32Sub(rhs, one);
2238 // Check if the {rhs} is a power of two.
2239 __ GotoIf(__ Word32Equal(__ Word32And(rhs, msk), __ Int32Constant(0)),
2242 // The {rhs} is not a power of two, do a generic Uint32Mod.
2243 __ Goto(&done, __ Uint32Mod(lhs, rhs));
2248 // The {rhs} is a power of two, just do a fast bit masking.
2261 // if rhs <= 0 then
2262 // rhs = -rhs
2263 // deopt if rhs == 0
2264 // let msk = rhs - 1 in
2267 // let res = if rhs & msk == 0 then
2270 // lhs_abs % rhs in
2277 // if rhs & msk == 0 then
2280 // lhs % rhs
2283 Node* rhs = node->InputAt(1);
2293 // Check if {rhs} is not strictly positive.
2294 Node* check0 = __ Int32LessThanOrEqual(rhs, zero);
2296 __ Goto(&rhs_checked, rhs);
2300 // Negate {rhs}, might still produce a negative result in case of
2302 Node* vtrue0 = __ Int32Sub(zero, rhs);
2304 // Ensure that {rhs} is not zero, otherwise we'd have to return NaN.
2311 rhs = rhs_checked.PhiAt(0);
2316 __ Goto(&done, BuildUint32Mod(lhs, rhs));
2323 // would try to figure out whether {rhs} is a power of two,
2325 Node* res = __ Uint32Mod(__ Int32Sub(zero, lhs), rhs);
2340 Node* rhs = node->InputAt(1);
2343 // Check if the {rhs} is a known power of two.
2344 Uint32Matcher m(rhs);
2346 // Since we know that {rhs} is a power of two, we can perform a fast
2359 // Ensure that {rhs} is not zero, otherwise we'd have to return NaN.
2360 Node* check = __ Word32Equal(rhs, zero);
2365 Node* value = __ Uint32Div(lhs, rhs);
2368 check = __ Word32Equal(lhs, __ Int32Mul(rhs, value));
2378 Node* rhs = node->InputAt(1);
2382 // Ensure that {rhs} is not zero, otherwise we'd have to return NaN.
2383 Node* check = __ Word32Equal(rhs, zero);
2388 return BuildUint32Mod(lhs, rhs);
2395 Node* rhs = node->InputAt(1);
2397 Node* projection = __ Int32MulWithOverflow(lhs, rhs);
2414 Node* check_or = __ Int32LessThan(__ Word32Or(lhs, rhs), zero);
3752 Node* rhs = node->InputAt(1);
3761 return __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs, rhs,
3767 Node* rhs = node->InputAt(1);
3776 return __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs, rhs,
3782 Node* rhs = node->InputAt(1);
3787 __ GotoIf(__ Float64Equal(lhs, rhs), &is_float64_equal);
3789 // Return true iff both {lhs} and {rhs} are NaN.
3791 __ GotoIf(__ Float64Equal(rhs, rhs), &done, __ Int32Constant(0));
3798 Node* rhs_hi = __ Float64ExtractHighWord32(rhs);
4316 Node* rhs = node->InputAt(1);
4323 return __ Call(call_descriptor, __ HeapConstant(callable.code()), lhs, rhs,
4360 Node* rhs = node->InputAt(1);
4369 rhs, __ NoContextConstant());
4381 Node* rhs = node->InputAt(1);
4390 rhs, __ NoContextConstant());