Lines Matching defs:lhs
567 TNode<UintPtrT> lhs, rhs;
571 lhs = WordAnd(WordShr(value, UintPtrConstant(1)), UintPtrConstant(mask[0]));
573 value = UintPtrAdd(lhs, rhs);
577 lhs = WordAnd(WordShr(value, UintPtrConstant(2)), UintPtrConstant(mask[1]));
579 value = UintPtrAdd(lhs, rhs);
583 lhs = WordAnd(WordShr(value, UintPtrConstant(4)), UintPtrConstant(mask[2]));
585 value = UintPtrAdd(lhs, rhs);
593 lhs = WordShr(value, UintPtrConstant(8));
594 value = UintPtrAdd(lhs, value);
598 lhs = WordShr(value, UintPtrConstant(16));
599 value = UintPtrAdd(lhs, value);
604 lhs = WordShr(value, UintPtrConstant(32));
605 value = UintPtrAdd(lhs, value);
657 TNode<Word64T> lhs = Word64Not(value);
659 return PopulationCount64(Word64And(lhs, rhs));
669 TNode<Word32T> lhs = Word32BitwiseNot(value);
671 return PopulationCount32(Word32And(lhs, rhs));
851 TNode<Smi> CodeStubAssembler::TrySmiAdd(TNode<Smi> lhs, TNode<Smi> rhs,
855 TryIntPtrAdd(BitcastTaggedToWordForTagAndSmiBits(lhs),
860 TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(lhs)),
869 TNode<Smi> CodeStubAssembler::TrySmiSub(TNode<Smi> lhs, TNode<Smi> rhs,
873 IntPtrSubWithOverflow(BitcastTaggedToWordForTagAndSmiBits(lhs),
882 TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(lhs)),
7171 const TNode<String> lhs =
7173 var_string_ = lhs;
7174 var_instance_type_ = LoadInstanceType(lhs);
12942 TNode<Object> lhs, TNode<Object> rhs, TVariable<Smi>* var_type_feedback) {
12945 // if (lhs == rhs) {
12946 // if (lhs->IsHeapNumber()) return HeapNumber::cast(lhs)->value() != NaN;
12949 // if (!lhs->IsSmi()) {
12950 // if (lhs->IsHeapNumber()) {
12952 // return Smi::ToInt(rhs) == HeapNumber::cast(lhs)->value();
12955 // HeapNumber::cast(lhs)->value();
12963 // if (lhs->IsString()) {
12965 // return %StringEqual(lhs, rhs);
12969 // } else if (lhs->IsBigInt()) {
12971 // return %BigIntEqualToBigInt(lhs, rhs);
12985 // return Smi::ToInt(lhs) == HeapNumber::cast(rhs)->value();
12998 // Check if {lhs} and {rhs} refer to the same object.
13000 Branch(TaggedEqual(lhs, rhs), &if_same, &if_notsame);
13004 // The {lhs} and {rhs} reference the exact same value, yet we need special
13006 GenerateEqual_Same(lhs, &if_equal, &if_notequal, var_type_feedback);
13011 // The {lhs} and {rhs} reference different objects, yet for Smi, HeapNumber,
13014 // Check if {lhs} is a Smi or a HeapObject.
13016 Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);
13020 // Load the map of {lhs}.
13021 TNode<Map> lhs_map = LoadMap(CAST(lhs));
13023 // Check if {lhs} is a HeapNumber.
13035 // Convert {lhs} and {rhs} to floating point values.
13036 TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs));
13041 // Perform a floating point comparison of {lhs} and {rhs}.
13057 // Convert {lhs} and {rhs} to floating point values.
13058 TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs));
13064 // Perform a floating point comparison of {lhs} and {rhs}.
13084 // Load the instance type of {lhs}.
13087 // Check if {lhs} is a String.
13113 NoContextConstant(), lhs, rhs));
13123 // Check if {lhs} is a BigInt.
13144 NoContextConstant(), lhs, rhs));
13245 // We already know that {lhs} and {rhs} are not reference equal, and {lhs}
13246 // is a Smi; so {lhs} and {rhs} can only be strictly equal if {rhs} is a
13263 // The {rhs} could be a HeapNumber with the same value as {lhs}.
13269 // Convert {lhs} and {rhs} to floating point values.
13270 TNode<Float64T> lhs_value = SmiToFloat64(CAST(lhs));
13275 // Perform a floating point comparison of {lhs} and {rhs}.
13317 void CodeStubAssembler::BranchIfSameValue(TNode<Object> lhs, TNode<Object> rhs,
13324 // Immediately jump to {if_true} if {lhs} == {rhs}, because - unlike
13326 GotoIf(TaggedEqual(lhs, rhs), if_true);
13328 // Check if the {lhs} is a Smi.
13330 Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisheapobject);
13334 // Since {lhs} is a Smi, the comparison can only yield true
13338 var_lhs_value = SmiToFloat64(CAST(lhs));
13351 // iff the {lhs} is a HeapNumber with the same float64 value.
13352 GotoIfNot(IsHeapNumber(CAST(lhs)), if_false);
13353 var_lhs_value = LoadHeapNumberValue(CAST(lhs));
13358 // Now this can only yield true if either both {lhs} and {rhs} are
13364 const TNode<Map> lhs_map = LoadMap(CAST(lhs));
13377 var_lhs_value = LoadHeapNumberValue(CAST(lhs));
13389 Builtin::kStringEqual, NoContextConstant(), lhs, rhs);
13397 Runtime::kBigIntEqualToBigInt, NoContextConstant(), lhs, rhs);
13421 // We still need to handle the case when {lhs} and {rhs} are -0.0 and
13434 // Return true iff both {rhs} and {lhs} are NaN.
14944 const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
14945 return lhs + rhs;
14948 const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
14949 return lhs << rhs;
14952 const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
14953 return lhs | rhs;