Lines Matching refs:left
989 // take the sign of the left hand side {a}, which is negative.
1634 // that does one shift right instead of two shifts (right and then left).
1663 // that does one shift right instead of two shifts (right and then left).
8449 TNode<IntPtrT> CodeStubAssembler::IntPtrMax(TNode<IntPtrT> left,
8453 if (TryToIntPtrConstant(left, &left_constant) &&
8457 return SelectConstant<IntPtrT>(IntPtrGreaterThanOrEqual(left, right), left,
8461 TNode<IntPtrT> CodeStubAssembler::IntPtrMin(TNode<IntPtrT> left,
8465 if (TryToIntPtrConstant(left, &left_constant) &&
8469 return SelectConstant<IntPtrT>(IntPtrLessThanOrEqual(left, right), left,
8473 TNode<UintPtrT> CodeStubAssembler::UintPtrMin(TNode<UintPtrT> left,
8477 if (TryToIntPtrConstant(left, &left_constant) &&
8482 return SelectConstant<UintPtrT>(UintPtrLessThanOrEqual(left, right), left,
11331 // may be left in an invalid state.
11811 TNode<Number> left,
11820 TaggedIsSmi(left),
11822 TNode<Smi> smi_left = CAST(left);
11829 // Both {left} and {right} are Smi, so just perform a fast
11860 var_left_float = LoadHeapNumberValue(CAST(left));
11906 void CodeStubAssembler::GotoIfNumberGreaterThanOrEqual(TNode<Number> left,
11910 BranchIfNumberRelationalComparison(Operation::kGreaterThanOrEqual, left,
11973 Operation op, TNode<Object> left, TNode<Object> right,
11983 TVARIABLE(Object, var_left, left);
11996 left = var_left.value();
12000 Branch(TaggedIsSmi(left), &if_left_smi, &if_left_not_smi);
12004 TNode<Smi> smi_left = CAST(left);
12055 SmiConstant(Reverse(op)), right, left));
12073 TNode<Map> left_map = LoadMap(CAST(left));
12090 var_left_float = LoadHeapNumberValue(CAST(left));
12100 left, right));
12107 // Convert {left} to a Numeric; we don't need to perform the
12108 // dedicated ToPrimitive(left, hint Number) operation, as the
12109 // ToNumeric(left) will by itself already invoke ToPrimitive with
12111 var_left = CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
12143 var_left_float = LoadHeapNumberValue(CAST(left));
12154 SmiConstant(Reverse(op)), right, left));
12188 left, right));
12198 left, right));
12208 left, right));
12235 // Both {left} and {right} are strings.
12254 var_result = CAST(CallBuiltin(builtin, context(), left, right));
12261 // {left} is a String, while {right} isn't. Check if {right} is
12263 // {right} is a receiver, or ToNumeric(left) and then
12273 CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
12281 SmiConstant(Reverse(op)), right, left));
12297 // {left} is neither a Numeric nor a String, and {right} is not a Smi.
12299 // Collect NumberOrOddball feedback if {left} is an Oddball
12329 // If {left} is a receiver, call ToPrimitive(left, hint Number).
12330 // Otherwise call ToNumeric(right) and then ToNumeric(left), the
12338 var_left = CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
12345 var_left = CallStub(callable, context(), left);
12412 // left and the right hand side reference exactly the same value.
12500 TNode<Oddball> CodeStubAssembler::Equal(TNode<Object> left, TNode<Object> right,
12519 TVARIABLE(Object, var_left, left);
12532 left = var_left.value();
12536 GotoIf(TaggedNotEqual(left, right), &if_notsame);
12538 // {left} and {right} reference the exact same value, yet we need special
12540 GenerateEqual_Same(left, &if_equal, &if_notequal, var_type_feedback);
12545 Branch(TaggedIsSmi(left), &if_left_smi, &if_left_not_smi);
12556 // We have already checked for {left} and {right} being the same value,
12569 // {left} is Smi and {right} is not HeapNumber or Smi.
12581 var_left_float = SmiToFloat64(CAST(left));
12607 NoContextConstant(), right, left));
12631 TNode<Map> left_map = LoadMap(CAST(left));
12647 CAST(CallBuiltin(Builtin::kStringEqual, context(), left, right));
12661 var_left_float = LoadHeapNumberValue(CAST(left));
12713 NoContextConstant(), left, right));
12721 NoContextConstant(), left, right));
12729 NoContextConstant(), left, right));
12755 // {left} is either Null or Undefined. Check if {right} is
12812 // Otherwise, convert {left} to number and try again.
12813 var_left = LoadObjectField(CAST(left), Oddball::kToNumberOffset);
12822 // {right} is not a JSReceiver and also not the same Symbol as {left},
12842 // {left} is a Primitive and {right} is a JSReceiver, so swapping
12860 // {left} and {right} are different JSReceiver references.
12889 // convert {left} to Primitive too.
12892 var_left = CallStub(callable, context(), left);
12914 var_right = left;
13965 TNode<Number> CodeStubAssembler::BitwiseSmiOp(TNode<Smi> left, TNode<Smi> right,
13969 return SmiAnd(left, right);
13971 return SmiOr(left, right);
13973 return SmiXor(left, right);
13974 // Smi shift left and logical shift rihgt can have (Heap)Number output, so
13978 return BitwiseOp(SmiToInt32(left), SmiToInt32(right), bitwise_op);
13982 TNode<Int32T> left32 = SmiToInt32(left);