Lines Matching full:right
740 // JS_FUNCTION_TYPE is the last instance type and it is right
2176 // Generate code to jump to the right destination for all used
2626 // There are two cases where the target is not read in the right hand
2627 // side, that are easy to test for: the right hand side is a literal,
2628 // or the right hand side is a different variable. TakeValue invalidates
2744 // rdx (receiver). Touch up the stack with the right values.
2923 // Push the arguments ("left-to-right") on the stack.
2958 // Push the arguments ("left-to-right").
3297 // control flow), we force the right hand side to do the same. This
3309 // paths where we do have to evaluate the right subexpression.
3311 // We need to compile the right subexpression. If the jump to
3314 // have to jump around the code for the right subexpression.
3321 // right one is free to do so as well.
3322 LoadCondition(node->right(), destination(), false);
3332 // was just bound), so the right is free to do so as well.
3333 LoadCondition(node->right(), destination(), false);
3355 // Compile right side expression.
3357 Load(node->right());
3372 // paths where we do have to evaluate the right subexpression.
3374 // We need to compile the right subexpression. If the jump to
3377 // have to jump around the code for the right subexpression.
3384 // right one is free to do so as well.
3385 LoadCondition(node->right(), destination(), false);
3394 // was just bound), so the right is free to do so as well.
3395 LoadCondition(node->right(), destination(), false);
3417 // Compile right side expression.
3419 Load(node->right());
3432 } else if (node->right()->AsBinaryOperation() != NULL &&
3433 node->right()->AsBinaryOperation()->ResultOverwriteAllowed()) {
3438 Load(node->right());
3450 Expression* right = node->right();
3458 (right->AsLiteral() != NULL &&
3459 right->AsLiteral()->handle()->IsString())) {
3460 Handle<String> check(Handle<String>::cast(right->AsLiteral()->handle()));
3574 Load(right);
3581 Load(right);
3594 Load(right);
3861 // Check that the right hand side is the empty string (ie if this is really a
3932 Result right = frame_->Pop();
3934 right.ToRegister();
3936 __ cmpq(right.reg(), left.reg());
3937 right.Unuse();
4081 // right after LAST_JS_OBJECT_TYPE, we can avoid checking for
5019 // Right side is a constant smi and left side has been checked
5076 // the right side is the constant 'null'.
5161 Register right,
5163 : op_(op), dst_(dst), left_(left), right_(right), mode_(mode) {
5197 Result right = frame_->Pop();
5202 bool right_is_string = right.is_constant() && right.handle()->IsString();
5205 frame_->Push(&right);
5228 bool right_is_smi_constant = right.is_constant() && right.handle()->IsSmi();
5230 right.is_constant() && !right.handle()->IsSmi();
5235 int right_int = Smi::cast(*right.handle())->value();
5239 // Get number type of left and right sub-expressions.
5241 NumberInfo::Combine(left.number_info(), right.number_info());
5249 answer = stub.GenerateCall(masm_, frame_, &left, &right);
5251 answer = ConstantSmiBinaryOperation(op, &left, right.handle(),
5254 answer = ConstantSmiBinaryOperation(op, &right, left.handle(),
5263 answer = LikelySmiBinaryOperation(op, &left, &right, overwrite_mode);
5269 answer = stub.GenerateCall(masm_, frame_, &left, &right);
5279 result_type = right.number_info();
5299 result_type = (right.is_constant() && right.handle()->IsSmi()
5300 && Smi::cast(*right.handle())->value() >= 1)
5582 // We can swap left and right operands with no problem.
5583 // Swap left and right overwrite modes. 0->0, 1->2, 2->1.
5636 // Fall through if we did not find a power of 2 on the right hand side!
5657 Result* right,
5663 // register, neither left nor right in rax or rdx, and left copied
5670 (right->is_register() && right->reg().is(rax))) {
5685 if (right->is_register() && right->reg().is(rax)) {
5686 quotient = *right;
5687 *right = fresh;
5691 // Neither left nor right is in rax.
5696 ASSERT(!(right->is_register() && right->reg().is(rax)));
5701 (right->is_register() && right->reg().is(rdx))) {
5708 if (right->is_register() && right->reg().is(rdx)) {
5709 remainder = *right;
5710 *right = fresh;
5714 // Neither left nor right is in rdx.
5720 ASSERT(!(right->is_register() && right->reg().is(rdx)));
5723 right->ToRegister();
5727 // Check that left and right are smi tagged.
5732 right->reg(),
5734 __ JumpIfNotBothSmi(left->reg(), right->reg(), deferred->entry_label());
5737 __ SmiDiv(rax, left->reg(), right->reg(), deferred->entry_label());
5740 right->Unuse();
5744 __ SmiMod(rdx, left->reg(), right->reg(), deferred->entry_label());
5747 right->Unuse();
5763 right->ToRegister(rcx);
5766 ASSERT(right->is_register() && right->reg().is(rcx));
5768 // We will modify right, it must be spilled.
5810 right->Unuse();
5817 right->ToRegister();
5819 // registers containing left and right are not modified so they don't
5829 right->reg(),
5831 __ JumpIfNotBothSmi(left->reg(), right->reg(), deferred->entry_label());
5837 right->reg(),
5844 right->reg(),
5851 right->reg(),
5857 __ SmiOr(answer.reg(), left->reg(), right->reg());
5861 __ SmiAnd(answer.reg(), left->reg(), right->reg());
5865 __ SmiXor(answer.reg(), left->reg(), right->reg());
5874 right->Unuse();
6502 right) {
6507 if (Smi::IsValid(static_cast<intptr_t>(left) + right)) {
6508 answer_object = Smi::FromInt(left + right);
6513 if (Smi::IsValid(static_cast<intptr_t>(left) - right)) {
6514 answer_object = Smi::FromInt(left - right);
6518 double answer = static_cast<double>(left) * right;
6522 if (answer != 0 || (left + right) >= 0) {
6532 answer_object = Smi::FromInt(left | right);
6535 answer_object = Smi::FromInt(left & right);
6538 answer_object = Smi::FromInt(left ^ right);
6542 int shift_amount = right & 0x1F;
6549 int shift_amount = right & 0x1F;
6558 int shift_amount = right & 0x1F;
7384 // Push the arguments ("left-to-right") on the stack.
8171 // Input: rdx, rax are the left and right objects of a bit op.
8172 // Output: rax, rcx are left and right integers for a bit op.
8304 Register right) {
8308 __ push(right);
8310 // The calling convention with registers is left in rdx and right in rax.
8313 if (!(left.is(left_arg) && right.is(right_arg))) {
8314 if (left.is(right_arg) && right.is(left_arg)) {
8318 __ xchg(left, right);
8321 __ movq(right_arg, right);
8322 } else if (right.is(right_arg)) {
8326 __ movq(left_arg, right);
8331 __ movq(right_arg, right);
8333 } else if (right.is(left_arg)) {
8338 // Order of moves important to avoid destroying right argument.
8339 __ movq(right_arg, right);
8345 __ movq(right_arg, right);
8362 Smi* right) {
8366 __ Push(right);
8368 // The calling convention with registers is left in rdx and right in rax.
8372 __ Move(right_arg, right);
8374 __ Move(left_arg, right);
8382 __ Move(right_arg, right);
8398 Register right) {
8402 __ push(right);
8404 // The calling convention with registers is left in rdx and right in rax.
8407 if (right.is(right_arg)) {
8409 } else if (right.is(left_arg) && IsOperationCommutative()) {
8413 // For non-commutative operations, right and left_arg might be
8415 // important here in order to not overwrite right before moving
8417 __ movq(right_arg, right);
8433 Result* right) {
8436 return frame->CallStub(this, left, right);
8439 frame->Push(right);
8450 Register right = rax;
8453 right = rbx;
8460 __ movq(right, Operand(rsp, 1 * kPointerSize));
8469 __ JumpIfNotBothSmi(left, right, ¬_smis);
8478 ASSERT(right.is(rax));
8479 __ SmiAdd(right, right, left, &use_fp_on_smis); // ADD is commutative.
8484 __ SmiSub(left, left, right, &use_fp_on_smis);
8490 ASSERT(right.is(rax));
8491 __ SmiMul(right, right, left, &use_fp_on_smis); // MUL is commutative.
8496 __ SmiDiv(left, left, right, &use_fp_on_smis);
8501 __ SmiMod(left, left, right, slow);
8505 ASSERT(right.is(rax));
8506 __ movq(rcx, right); // Save the right operand.
8507 __ SmiOr(right, right, left); // BIT_OR is commutative.
8508 __ testb(right, Immediate(kSmiTagMask));
8513 ASSERT(right.is(rax));
8514 __ SmiAnd(right, right, left); // BIT_AND is commutative.
8518 ASSERT(right.is(rax));
8519 __ SmiXor(right, right, left); // BIT_XOR is commutative.
8527 __ SmiShiftArithmeticRight(left, left, right);
8530 __ SmiShiftLogicalRight(left, left, right, slow);
8533 __ SmiShiftLeft(left, left, right, slow);
8562 // left is rdx, right is rax.
8594 // Right operand is saved in rcx and rax was destroyed by the smi
9310 Register right,
9322 __ subl(scratch4, FieldOperand(right, String::kLengthOffset));
9323 // Register scratch4 now holds left.length - right.length.
9327 // The right string isn't longer that the left one.
9328 // Get the right string's length by subtracting the (non-negative) difference
9332 // Register scratch1 now holds Min(left.length, right.length).
9359 __ cmpb(scratch2, FieldOperand(right,
9379 // Unequal comparison of left to right, either character or length.
9398 // rsp[8]: right string
9402 __ movq(rax, Operand(rsp, 1 * kPointerSize)); // right
