Lines Matching refs:right
1009 // Merge non-deopt blocks first to ensure environment has right size for
2064 HValue* right,
2068 HInstruction* right_instance_type = AddLoadStringInstanceType(right);
2136 Add<HStoreNamedField>(result, HObjectAccess::ForConsStringSecond(), right);
2182 HValue* right,
2186 HValue* right_length = AddLoadStringLength(right);
2196 // The right string contains at least one character.
2197 return BuildCreateConsString(length, left, right, allocation_mode);
2204 return BuildCreateConsString(length, left, right, allocation_mode);
2215 Push(BuildCreateConsString(length, left, right, allocation_mode));
2221 HValue* right_instance_type = AddLoadStringInstanceType(right);
2304 // Copy characters from the right string.
2306 right, graph()->GetConstant0(), String::TWO_BYTE_ENCODING,
2318 // Copy characters from the right string.
2320 right, graph()->GetConstant0(), String::ONE_BYTE_ENCODING,
2335 Add<HPushArguments>(left, right);
2351 HValue* right,
2357 HValue* right_length = AddLoadStringLength(right);
2368 // Just return the right string.
2369 Push(right);
2373 // Check if right string is empty.
2388 Push(BuildUncheckedStringAdd(left, right, allocation_mode));
6624 HValue* right = Pop();
6627 Push(BuildBinaryOperation(operation, left, right, PUSH_BEFORE_SIMULATE));
8125 HValue* right = Pop();
8128 HInstruction* op = HMul::NewImul(zone(), context(), left, right);
8197 HValue* right = Pop();
8202 if (right->IsConstant() && HConstant::cast(right)->HasDoubleValue()) {
8203 double exponent = HConstant::cast(right)->DoubleValue();
8220 result = NewUncasted<HPower>(left, right);
8229 HValue* right = Pop();
8234 HInstruction* result = NewUncasted<HMathMinMax>(left, right, op);
8241 HValue* right = Pop();
8244 HInstruction* result = HMul::NewImul(zone(), context(), left, right);
10127 return sub->left()->EqualsInteger32Constant(32) && sub->right() == sa;
10131 right are shift instructions with the oposite
10132 // directions that can be replaced by one rotate right instruction or not.
10136 HValue* right,
10141 if (left->IsShl() && right->IsShr()) {
10143 shr = HShr::cast(right);
10144 } else if (left->IsShr() && right->IsShl()) {
10145 shl = HShl::cast(right);
10152 if (!ShiftAmountsAllowReplaceByRotate(shl->right(), shr->right()) &&
10153 !ShiftAmountsAllowReplaceByRotate(shr->right(), shl->right())) {
10157 *shift_amount = shr->right();
10162 bool CanBeZero(HValue* right) {
10163 if (right->IsConstant()) {
10164 HConstant* right_const = HConstant::cast(right);
10230 HValue* right,
10233 Type* right_type = expr->right()->bounds().lower;
10244 expr->op(), left, right, left_type, right_type, result_type,
10265 HValue* right,
10297 if (!maybe_string_add) right = TruncateToNumber(right, &right_type);
10309 // Validate type feedback for right argument.
10311 right = BuildCheckString(right);
10321 Add<HPushArguments>(left, right);
10325 // Convert right argument as necessary.
10328 right = BuildNumberToString(right, right_type);
10332 Add<HPushArguments>(left, right);
10340 return right;
10342 if (right->IsConstant() &&
10343 HConstant::cast(right)->HasStringValue() &&
10344 HConstant::cast(right)->StringValue()->length() == 0) {
10365 (right->IsConstant() &&
10366 HConstant::cast(right)->HasStringValue() &&
10367 HConstant::cast(right)->StringValue()->length() + 1 >=
10369 return BuildStringAdd(left, right, allocation_mode);
10374 left, right, allocation_mode.GetPretenureMode(),
10380 right = EnforceNumberType(right, right_type);
10394 Add<HPushArguments>(left, right);
10399 instr = AddUncasted<HAdd>(left, right);
10402 instr = AddUncasted<HSub>(left, right);
10405 instr = AddUncasted<HMul>(left, right);
10409 !right->EqualsInteger32Constant(fixed_right_arg.value)) {
10413 if_same.If<HCompareNumericAndBranch>(right, fixed_right, Token::EQ);
10416 right = fixed_right;
10418 instr = AddUncasted<HMod>(left, right);
10422 instr = AddUncasted<HDiv>(left, right);
10426 instr = AddUncasted<HBitwise>(op, left, right);
10432 MatchRotateRight(left, right, &operand, &shift_amount)) {
10435 instr = AddUncasted<HBitwise>(op, left, right);
10440 instr = AddUncasted<HSar>(left, right);
10443 instr = AddUncasted<HShr>(left, right);
10445 CanBeZero(right)) {
10450 instr = AddUncasted<HShl>(left, right);
10470 if (right->IsForceRepresentation()) {
10471 right->CopyFlag(HValue::kTruncatingToSmi, instr);
10472 right->CopyFlag(HValue::kTruncatingToInt32, instr);
10485 Literal* literal = expr->right()->AsLiteral();
10514 // Visit the right subexpression in the same AST context as the entire
10516 Visit(expr->right());
10536 // Translate right subexpression by visiting it in the same AST
10541 Visit(expr->right());
10557 CHECK_ALIVE(VisitForValue(expr->right()));
10573 CHECK_BAILOUT(VisitForValue(expr->right()));
10608 CHECK_BAILOUT(VisitForEffect(expr->right()));
10625 CHECK_ALIVE(VisitForValue(expr->right()));
10627 HValue* right = Pop();
10630 BuildBinaryOperation(expr, left, right,
10637 ScriptPositionToSourcePosition(expr->right()->position()));
10657 HValue* right) {
10661 (right->IsConstant() &&
10662 HConstant::cast(right)->handle(isolate)->IsBoolean()));
10674 // with the full codegen: We don't push both left and right values onto
10693 Literal* literal = expr->right()->AsLiteral();
10700 Type* right_type = expr->right()->bounds().lower;
10704 CHECK_ALIVE(VisitForValue(expr->right()));
10708 HValue* right = Pop();
10712 if (IsLiteralCompareBool(isolate(), left, op, right)) {
10714 New<HCompareObjectEqAndBranch>(left, right);
10723 VariableProxy* proxy = expr->right()->AsVariableProxy();
10743 HInstanceOf* result = New<HInstanceOf>(left, right);
10746 Add<HCheckValue>(right, target);
10756 Add<HPushArguments>(left, right);
10767 op, left, right, left_type, right_type, combined_type,
10769 ScriptPositionToSourcePosition(expr->right()->position()),
10779 HValue* right,
10806 (right->IsConstant() &&
10807 HConstant::cast(right)->HasNumberValue())) {
10815 left->block()->block_id() < right->block()->block_id() ? left : right;
10820 New<HCompareObjectEqAndBranch>(left, right);
10831 New<HCompareObjectEqAndBranch>(left, right);
10844 (right->IsConstant() &&
10845 !HConstant::cast(right)->HasInternalizedStringValue())) {
10853 BuildCheckHeapObject(right);
10854 Add<HCheckInstanceType>(right, HCheckInstanceType::IS_INTERNALIZED_STRING);
10856 New<HCompareObjectEqAndBranch>(left, right);
10861 BuildCheckHeapObject(right);
10862 Add<HCheckInstanceType>(right, HCheckInstanceType::IS_STRING);
10864 New<HStringCompareAndBranch>(left, right, op);
10868 HCompareGeneric* result = Add<HCompareGeneric>(left, right, op);
10885 New<HCompareNumericAndBranch>(left, right, op);
11678 HValue* right = Pop();
11681 New<HCompareObjectEqAndBranch>(left, right);
11691 HValue* right = Pop();
11693 HInstruction* result = NewUncasted<HStringAdd>(left, right);
11838 HValue* right = Pop();
11840 HInstruction* result = NewUncasted<HPower>(left, right);
