Lines Matching defs:expr
525 NaryCodeCoverageSlots(BytecodeGenerator* generator, NaryOperation* expr)
528 for (size_t i = 0; i < expr->subsequent_length(); i++) {
530 generator_->AllocateNaryBlockCoverageSlotIfEnabled(expr, i));
1285 FunctionLiteral* expr = literal.first;
1287 Compiler::GetSharedFunctionInfo(expr, script, isolate);
1298 NativeFunctionLiteral* expr = literal.first;
1303 expr->extension()->GetNativeFunctionTemplate(
1304 v8_isolate, Utils::ToLocal(expr->name()));
1309 isolate, Utils::OpenHandle(*info), expr->name());
1808 bool IsSmiLiteralSwitchCaseValue(Expression* expr) {
1809 if (expr->IsSmiLiteral() ||
1810 (expr->IsLiteral() && expr->AsLiteral()->IsNumber() &&
1811 expr->AsLiteral()->AsNumber() == 0.0)) {
1814 } else if (expr->IsLiteral() && expr->AsLiteral()->IsNumber()) {
1815 DCHECK(!IsSmiDouble(expr->AsLiteral()->AsNumber()));
1822 inline int ReduceToSmiSwitchCaseValue(Expression* expr) {
1823 if (V8_LIKELY(expr->IsSmiLiteral())) {
1824 return expr->AsLiteral()->AsSmiLiteral().value();
1827 DCHECK(expr->IsLiteral() && expr->AsLiteral()->IsNumber() &&
1828 expr->AsLiteral()->AsNumber() == -0.0);
1850 bool CaseExists(Expression* expr) {
1851 return IsSmiLiteralSwitchCaseValue(expr)
1852 ? CaseExists(ReduceToSmiSwitchCaseValue(expr))
2514 void BytecodeGenerator::VisitFunctionLiteral(FunctionLiteral* expr) {
2515 DCHECK_EQ(expr->scope()->outer_scope(), current_scope());
2517 expr->pretenure(), closure_scope()->is_function_scope(),
2520 builder()->CreateClosure(entry, GetCachedCreateClosureSlot(expr), flags);
2521 function_literals_.push_back(std::make_pair(expr, entry));
2522 AddToEagerLiteralsIfEager(expr);
2559 void BytecodeGenerator::BuildClassLiteral(ClassLiteral* expr, Register name) {
2562 class_literals_.push_back(std::make_pair(expr, class_boilerplate_entry));
2564 VisitDeclarations(expr->scope()->declarations());
2571 if (expr->scope()->brand() != nullptr) {
2574 expr->scope()->class_variable() != nullptr
2575 ? expr->scope()->class_variable()->raw_name()
2581 BuildVariableAssignment(expr->scope()->brand(), Token::INIT,
2586 for (int i = 0; i < expr->private_members()->length(); i++) {
2587 ClassLiteral::Property* property = expr->private_members()->at(i);
2644 VisitForAccumulatorValueOrTheHole(expr->extends());
2647 VisitFunctionLiteral(expr->constructor());
2655 for (int i = 0; i < expr->public_members()->length(); i++) {
2656 ClassLiteral::Property* property = expr->public_members()->at(i);
2708 Variable* home_object_variable = expr->home_object();
2715 Variable* static_home_object_variable = expr->static_home_object();
2725 Variable* class_variable = expr->scope()->class_variable();
2750 if (expr->instance_members_initializer_function() != nullptr) {
2752 VisitForRegisterValue(expr->instance_members_initializer_function());
2761 if (expr->static_initializer() != nullptr) {
2784 Register initializer = VisitForRegisterValue(expr->static_initializer());
2794 void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
2795 VisitClassLiteral(expr, Register::invalid_value());
2798 void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr, Register name) {
2799 CurrentScope current_scope(this, expr->scope());
2800 DCHECK_NOT_NULL(expr->scope());
2801 if (expr->scope()->NeedsContext()) {
2807 BuildNewLocalBlockContext(expr->scope());
2808 ContextScope scope(this, expr->scope());
2810 BuildClassLiteral(expr, name);
2812 BuildClassLiteral(expr, name);
2953 NativeFunctionLiteral* expr) {
2958 native_function_literals_.push_back(std::make_pair(expr, entry));
2961 void BytecodeGenerator::VisitConditional(Conditional* expr) {
2963 builder(), block_coverage_builder_, expr);
2965 if (expr->condition()->ToBooleanIsTrue()) {
2968 VisitForAccumulatorValue(expr->then_expression());
2969 } else if (expr->condition()->ToBooleanIsFalse()) {
2972 VisitForAccumulatorValue(expr->else_expression());
2974 VisitForTest(expr->condition(), conditional_builder.then_labels(),
2978 VisitForAccumulatorValue(expr->then_expression());
2982 VisitForAccumulatorValue(expr->else_expression());
2986 void BytecodeGenerator::VisitLiteral(Literal* expr) {
2988 switch (expr->type()) {
2990 builder()->LoadLiteral(expr->AsSmiLiteral());
2993 builder()->LoadLiteral(expr->AsNumber());
2999 builder()->LoadBoolean(expr->ToBooleanIsTrue());
3009 builder()->LoadLiteral(expr->AsRawString());
3013 builder()->LoadLiteral(expr->AsBigInt());
3018 void BytecodeGenerator::VisitRegExpLiteral(RegExpLiteral* expr) {
3021 expr->raw_pattern(), feedback_index(feedback_spec()->AddLiteralSlot()),
3022 expr->flags());
3036 void BytecodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
3037 expr->builder()->InitDepthAndFlags();
3041 if (expr->builder()->IsEmptyObjectLiteral()) {
3042 DCHECK(expr->builder()->IsFastCloningSupported());
3047 Variable* home_object = expr->home_object();
3057 expr->builder()->ComputeFlags(),
3058 expr->builder()->IsFastCloningSupported());
3065 expr->properties()->first()->kind() == ObjectLiteral::Property::SPREAD;
3072 Expression* property = expr->properties()->first()->value();
3082 if (expr->builder()->properties_count() == 0) {
3086 object_literals_.push_back(std::make_pair(expr->builder(), entry));
3093 for (; property_index < expr->properties()->length(); property_index++) {
3094 ObjectLiteral::Property* property = expr->properties()->at(property_index);
3190 for (; property_index < expr->properties()->length(); property_index++) {
3191 ObjectLiteral::Property* property = expr->properties()->at(property_index);
3352 const ZonePtrList<Expression>* elements, ArrayLiteral* expr) {
3389 if (expr != nullptr) {
3390 array_literal_builder = expr->builder();
3510 void BytecodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
3511 expr->builder()->InitDepthAndFlags();
3512 BuildCreateArrayLiteral(expr->values(), expr);
3884 BytecodeGenerator::AssignmentLhsData::NonProperty(Expression* expr) {
3885 return AssignmentLhsData(NON_PROPERTY, expr, RegisterList(), Register(),
4468 lhs_data.expr()->AsObjectLiteral()) {
4473 lhs_data.expr()->AsArrayLiteral()) {
4478 DCHECK(lhs_data.expr()->IsVariableProxy());
4479 VariableProxy* proxy = lhs_data.expr()->AsVariableProxy();
4518 Property* property = lhs_data.expr()->AsProperty();
4521 lhs_data.expr()->AsProperty());
4525 Property* property = lhs_data.expr()->AsProperty();
4528 lhs_data.expr()->AsProperty());
4535 Property* property = lhs_data.expr()->AsProperty();
4546 void BytecodeGenerator::VisitAssignment(Assignment* expr) {
4547 AssignmentLhsData lhs_data = PrepareAssignmentLhs(expr->target());
4549 VisitForAccumulatorValue(expr->value());
4551 builder()->SetExpressionPosition(expr);
4552 BuildAssignment(lhs_data, expr->op(), expr->lookup_hoisting_mode());
4555 void BytecodeGenerator::VisitCompoundAssignment(CompoundAssignment* expr) {
4556 AssignmentLhsData lhs_data = PrepareAssignmentLhs(expr->target());
4562 VariableProxy* proxy = expr->target()->AsVariableProxy();
4591 Property* property = lhs_data.expr()->AsProperty();
4600 Property* property = lhs_data.expr()->AsProperty();
4608 Property* property = lhs_data.expr()->AsProperty();
4611 lhs_data.expr()->AsProperty());
4616 BinaryOperation* binop = expr->binary_operation();
4625 VisitForAccumulatorValue(expr->value());
4628 VisitForAccumulatorValue(expr->value());
4631 VisitForAccumulatorValue(expr->value());
4632 } else if (expr->value()->IsSmiLiteral()) {
4634 binop->op(), expr->value()->AsLiteral()->AsSmiLiteral(),
4639 VisitForAccumulatorValue(expr->value());
4642 builder()->SetExpressionPosition(expr);
4644 BuildAssignment(lhs_data, expr->op(), expr->lookup_hoisting_mode());
4675 void BytecodeGenerator::VisitYield(Yield* expr) {
4676 builder()->SetExpressionPosition(expr);
4677 VisitForAccumulatorValue(expr->expression());
4706 BuildSuspendPoint(expr->position());
4712 if (expr->on_abrupt_resume() == Yield::kNoControl) {
4732 builder()->SetExpressionPosition(expr);
4751 BuildIncrementBlockCoverageCounterIfEnabled(expr,
4822 void BytecodeGenerator::VisitYieldStar(YieldStar* expr) {
4832 VisitForAccumulatorValue(expr->expression());
4893 BuildAwait(expr->position());
4913 BuildIteratorClose(iterator, expr);
4922 BuildAwait(expr->position());
4962 BuildSuspendPoint(expr->position());
4992 BuildIncrementBlockCoverageCounterIfEnabled(expr,
5053 void BytecodeGenerator::VisitAwait(Await* expr) {
5054 builder()->SetExpressionPosition(expr);
5055 VisitForAccumulatorValue(expr->expression());
5056 BuildAwait(expr->position());
5057 BuildIncrementBlockCoverageCounterIfEnabled(expr,
5061 void BytecodeGenerator::VisitThrow(Throw* expr) {
5062 AllocateBlockCoverageSlotIfEnabled(expr, SourceRangeKind::kContinuation);
5063 VisitForAccumulatorValue(expr->exception());
5064 builder()->SetExpressionPosition(expr);
5272 Property* expr,
5275 VisitPropertyLoad(obj, expr);
5347 void BytecodeGenerator::VisitOptionalChain(OptionalChain* expr) {
5348 BuildOptionalChain([&]() { VisitForAccumulatorValue(expr->expression()); });
5351 void BytecodeGenerator::VisitProperty(Property* expr) {
5352 AssignType property_kind = Property::GetAssignType(expr);
5355 Register obj = VisitForRegisterValue(expr->obj());
5356 VisitPropertyLoad(obj, expr);
5358 VisitPropertyLoad(Register::invalid_value(), expr);
5370 void BytecodeGenerator::VisitCall(Call* expr) {
5371 Expression* callee_expr = expr->expression();
5372 Call::CallType call_type = expr->GetCallType();
5375 return VisitCallSuper(expr);
5388 const Call::SpreadPosition spread_position = expr->spread_position();
5496 if (expr->is_optional_chain_link()) {
5499 AllocateBlockCoverageSlotIfEnabled(expr, SourceRangeKind::kRight);
5511 BuildCreateArrayLiteral(expr->arguments(), nullptr);
5519 VisitArguments(expr->arguments(), &args);
5521 CHECK_EQ(receiver_arg_count + expr->arguments()->length(),
5527 if (expr->is_possibly_eval() && expr->arguments()->length() > 0) {
5555 .LoadLiteral(Smi::FromInt(expr->position()))
5564 builder()->SetExpressionPosition(expr);
5586 void BytecodeGenerator::VisitCallSuper(Call* expr) {
5588 SuperCallReference* super = expr->expression()->AsSuperCallReference();
5589 const ZonePtrList<Expression>* args = expr->arguments();
5604 const Call::SpreadPosition spread_position = expr->spread_position();
5636 builder()->SetExpressionPosition(expr);
5708 void BytecodeGenerator::VisitCallNew(CallNew* expr) {
5714 VisitAndPushIntoRegisterList(expr->expression(), &args);
5726 const CallNew::SpreadPosition spread_position = expr->spread_position();
5729 BuildCreateArrayLiteral(expr->arguments(), nullptr);
5730 builder()->SetExpressionPosition(expr);
5740 VisitArguments(expr->arguments(), &args);
5744 builder()->SetExpressionPosition(expr);
5756 void BytecodeGenerator::VisitCallRuntime(CallRuntime* expr) {
5757 if (expr->is_jsruntime()) {
5759 VisitArguments(expr->arguments(), &args);
5760 builder()->CallJSRuntime(expr->context_index(), args);
5764 VisitArguments(expr->arguments(), &args);
5765 Runtime::FunctionId function_id = expr->function()->function_id;
5770 void BytecodeGenerator::VisitVoid(UnaryOperation* expr) {
5771 VisitForEffect(expr->expression());
5775 void BytecodeGenerator::VisitForTypeOfValue(Expression* expr) {
5776 if (expr->IsVariableProxy()) {
5779 VariableProxy* proxy = expr->AsVariableProxy();
5783 VisitForAccumulatorValue(expr);
5787 void BytecodeGenerator::VisitTypeOf(UnaryOperation* expr) {
5788 VisitForTypeOfValue(expr->expression());
5792 void BytecodeGenerator::VisitNot(UnaryOperation* expr) {
5794 VisitForEffect(expr->expression());
5801 VisitInSameTestExecutionScope(expr->expression());
5803 TypeHint type_hint = VisitForAccumulatorValue(expr->expression());
5810 void BytecodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
5811 switch (expr->op()) {
5813 VisitNot(expr);
5816 VisitTypeOf(expr);
5819 VisitVoid(expr);
5822 VisitDelete(expr);
5827 VisitForAccumulatorValue(expr->expression());
5828 builder()->SetExpressionPosition(expr);
5830 expr->op(), feedback_index(feedback_spec()->AddBinaryOpICSlot()));
5838 Expression* expr = unary->expression();
5839 if (expr->IsProperty()) {
5842 Property* property = expr->AsProperty();
5847 } else if (expr->IsOptionalChain()) {
5848 Expression* expr_inner = expr->AsOptionalChain()->expression();
5870 VisitForEffect(expr);
5873 } else if (expr->IsVariableProxy() &&
5874 !expr->AsVariableProxy()->is_new_target()) {
5878 Variable* variable = expr->AsVariableProxy()->var();
5911 VisitForEffect(expr);
5916 void BytecodeGenerator::VisitCountOperation(CountOperation* expr) {
5917 DCHECK(expr->expression()->IsValidReferenceExpression());
5920 Property* property = expr->expression()->AsProperty();
5923 bool is_postfix = expr->is_postfix() && !execution_result()->IsEffect();
5931 VariableProxy* proxy = expr->expression()->AsVariableProxy();
6025 builder()->UnaryOperation(expr->op(), feedback_index(count_slot));
6028 builder()->SetExpressionPosition(expr);
6031 VariableProxy* proxy = expr->expression()->AsVariableProxy();
6032 BuildVariableAssignment(proxy->var(), expr->op(),
6118 void BytecodeGenerator::VisitNaryOperation(NaryOperation* expr) {
6119 switch (expr->op()) {
6121 VisitNaryCommaExpression(expr);
6124 VisitNaryLogicalOrExpression(expr);
6127 VisitNaryLogicalAndExpression(expr);
6130 VisitNaryNullishExpression(expr);
6133 VisitNaryArithmeticExpression(expr);
6160 void BytecodeGenerator::VisitCompareOperation(CompareOperation* expr) {
6163 if (expr->IsLiteralCompareTypeof(&sub_expr, &literal)) {
6167 builder()->SetExpressionPosition(expr);
6175 } else if (expr->IsLiteralCompareUndefined(&sub_expr)) {
6177 builder()->SetExpressionPosition(expr);
6178 BuildLiteralCompareNil(expr->op(), BytecodeArrayBuilder::kUndefinedValue);
6179 } else if (expr->IsLiteralCompareNull(&sub_expr)) {
6181 builder()->SetExpressionPosition(expr);
6182 BuildLiteralCompareNil(expr->op(), BytecodeArrayBuilder::kNullValue);
6184 if (expr->op() == Token::IN && expr->left()->IsPrivateName()) {
6186 Variable* var = expr->left()->AsVariableProxy()->var();
6188 BuildPrivateMethodIn(var, expr->right());
6194 Register lhs = VisitForRegisterValue(expr->left());
6195 VisitForAccumulatorValue(expr->right());
6196 builder()->SetExpressionPosition(expr);
6198 if (expr->op() == Token::IN) {
6200 } else if (expr->op() == Token::INSTANCEOF) {
6205 builder()->CompareOperation(expr->op(), lhs, feedback_index(slot));
6211 void BytecodeGenerator::VisitArithmeticExpression(BinaryOperation* expr) {
6215 if (expr->IsSmiLiteralOperation(&subexpr, &literal)) {
6217 builder()->SetExpressionPosition(expr);
6218 builder()->BinaryOperationSmiLiteral(expr->op(), literal,
6220 if (expr->op() == Token::ADD && type_hint == TypeHint::kString) {
6224 TypeHint lhs_type = VisitForAccumulatorValue(expr->left());
6227 TypeHint rhs_type = VisitForAccumulatorValue(expr->right());
6228 if (expr->op() == Token::ADD &&
6233 builder()->SetExpressionPosition(expr);
6234 builder()->BinaryOperation(expr->op(), lhs, feedback_index(slot));
6238 void BytecodeGenerator::VisitNaryArithmeticExpression(NaryOperation* expr) {
6240 TypeHint type_hint = VisitForAccumulatorValue(expr->first());
6242 for (size_t i = 0; i < expr->subsequent_length(); ++i) {
6244 if (expr->subsequent(i)->IsSmiLiteral()) {
6245 builder()->SetExpressionPosition(expr->subsequent_op_position(i));
6247 expr->op(), expr->subsequent(i)->AsLiteral()->AsSmiLiteral(),
6252 TypeHint rhs_hint = VisitForAccumulatorValue(expr->subsequent(i));
6254 builder()->SetExpressionPosition(expr->subsequent_op_position(i));
6256 expr->op(), lhs,
6261 if (type_hint == TypeHint::kString && expr->op() == Token::ADD) {
6269 void BytecodeGenerator::VisitSpread(Spread* expr) { Visit(expr->expression()); }
6271 void BytecodeGenerator::VisitEmptyParentheses(EmptyParentheses* expr) {
6275 void BytecodeGenerator::VisitImportCallExpression(ImportCallExpression* expr) {
6276 const int register_count = expr->import_assertions() ? 3 : 2;
6278 VisitForRegisterValue(expr->specifier(), args[1]);
6279 if (expr->import_assertions()) {
6280 VisitForRegisterValue(expr->import_assertions(), args[2]);
6412 Expression* expr) {
6423 DCHECK_NOT_NULL(expr);
6424 BuildAwait(expr->position());
6439 void BytecodeGenerator::VisitGetTemplateObject(GetTemplateObject* expr) {
6440 builder()->SetExpressionPosition(expr);
6442 template_objects_.push_back(std::make_pair(expr, entry));
6447 void BytecodeGenerator::VisitTemplateLiteral(TemplateLiteral* expr) {
6448 const ZonePtrList<const AstRawString>& parts = *expr->string_parts();
6449 const ZonePtrList<Expression>& substitutions = *expr->substitutions();
6461 builder()->SetExpressionPosition(expr);
6505 void BytecodeGenerator::VisitThisExpression(ThisExpression* expr) {
6509 void BytecodeGenerator::VisitSuperCallReference(SuperCallReference* expr) {
6515 SuperPropertyReference* expr) {
6524 void BytecodeGenerator::VisitNaryCommaExpression(NaryOperation* expr) {
6525 DCHECK_GT(expr->subsequent_length(), 0);
6527 VisitForEffect(expr->first());
6528 for (size_t i = 0; i < expr->subsequent_length() - 1; ++i) {
6529 VisitForEffect(expr->subsequent(i));
6531 Visit(expr->subsequent(expr->subsequent_length() - 1));
6535 Token::Value token, Expression* expr, BytecodeLabels* then_labels,
6541 VisitForTest(expr, then_labels, &test_next, TestFallthrough::kElse);
6543 VisitForTest(expr, &test_next, else_labels, TestFallthrough::kThen);
6546 VisitForNullishTest(expr, then_labels, &test_next, else_labels);
6569 Token::Value token, NaryOperation* expr,
6572 DCHECK_GT(expr->subsequent_length(), 0);
6579 VisitLogicalTestSubExpression(token, expr->first(), then_labels, else_labels,
6581 for (size_t i = 0; i < expr->subsequent_length() - 1; ++i) {
6582 VisitLogicalTestSubExpression(token, expr->subsequent(i), then_labels,
6587 VisitForTest(expr->subsequent(expr->subsequent_length() - 1), then_labels,
6591 bool BytecodeGenerator::VisitLogicalOrSubExpression(Expression* expr,
6594 if (expr->ToBooleanIsTrue()) {
6595 VisitForAccumulatorValue(expr);
6598 } else if (!expr->ToBooleanIsFalse()) {
6599 TypeHint type_hint = VisitForAccumulatorValue(expr);
6609 bool BytecodeGenerator::VisitLogicalAndSubExpression(Expression* expr,
6612 if (expr->ToBooleanIsFalse()) {
6613 VisitForAccumulatorValue(expr);
6616 } else if (!expr->ToBooleanIsTrue()) {
6617 TypeHint type_hint = VisitForAccumulatorValue(expr);
6627 bool BytecodeGenerator::VisitNullishSubExpression(Expression* expr,
6630 if (expr->IsLiteralButNotNullOrUndefined()) {
6631 VisitForAccumulatorValue(expr);
6634 } else if (!expr->IsNullOrUndefinedLiteral()) {
6635 VisitForAccumulatorValue(expr);
6676 void BytecodeGenerator::VisitNaryLogicalOrExpression(NaryOperation* expr) {
6677 Expression* first = expr->first();
6678 DCHECK_GT(expr->subsequent_length(), 0);
6680 NaryCodeCoverageSlots coverage_slots(this, expr);
6687 VisitNaryLogicalTest(Token::OR, expr, &coverage_slots);
6696 for (size_t i = 0; i < expr->subsequent_length() - 1; ++i) {
6697 if (VisitLogicalOrSubExpression(expr->subsequent(i), &end_labels,
6704 VisitForAccumulatorValue(expr->subsequent(expr->subsequent_length() - 1));
6737 void BytecodeGenerator::VisitNaryLogicalAndExpression(NaryOperation* expr) {
6738 Expression* first = expr->first();
6739 DCHECK_GT(expr->subsequent_length(), 0);
6741 NaryCodeCoverageSlots coverage_slots(this, expr);
6748 VisitNaryLogicalTest(Token::AND, expr, &coverage_slots);
6757 for (size_t i = 0; i < expr->subsequent_length() - 1; ++i) {
6758 if (VisitLogicalAndSubExpression(expr->subsequent(i), &end_labels,
6765 VisitForAccumulatorValue(expr->subsequent(expr->subsequent_length() - 1));
6799 void BytecodeGenerator::VisitNaryNullishExpression(NaryOperation* expr) {
6800 Expression* first = expr->first();
6801 DCHECK_GT(expr->subsequent_length(), 0);
6803 NaryCodeCoverageSlots coverage_slots(this, expr);
6810 VisitNaryLogicalTest(Token::NULLISH, expr, &coverage_slots);
6819 for (size_t i = 0; i < expr->subsequent_length() - 1; ++i) {
6820 if (VisitNullishSubExpression(expr->subsequent(i), &end_labels,
6827 VisitForAccumulatorValue(expr->subsequent(expr->subsequent_length() - 1));
7043 // Visits the expression |expr| and places the result in the accumulator.
7045 Expression* expr) {
7047 Visit(expr);
7051 void BytecodeGenerator::VisitForAccumulatorValueOrTheHole(Expression* expr) {
7052 if (expr == nullptr) {
7055 VisitForAccumulatorValue(expr);
7059 // Visits the expression |expr| and discards the result.
7060 void BytecodeGenerator::VisitForEffect(Expression* expr) {
7062 Visit(expr);
7065 // Visits the expression |expr| and returns the register containing
7067 Register BytecodeGenerator::VisitForRegisterValue(Expression* expr) {
7068 VisitForAccumulatorValue(expr);
7074 // Visits the expression |expr| and stores the expression result in
7076 void BytecodeGenerator::VisitForRegisterValue(Expression* expr,
7079 Visit(expr);
7083 // Visits the expression |expr| and pushes the result into a new register
7085 void BytecodeGenerator::VisitAndPushIntoRegisterList(Expression* expr,
7089 Visit(expr);
7117 // Visits the expression |expr| for testing its boolean value and jumping to the
7119 void BytecodeGenerator::VisitForTest(Expression* expr,
7130 Visit(expr);
7145 // Visits the expression |expr| for testing its nullish value and jumping to the
7147 void BytecodeGenerator::VisitForNullishTest(Expression* expr,
7154 TypeHint type_hint = VisitForAccumulatorValue(expr);
7164 void BytecodeGenerator::VisitInSameTestExecutionScope(Expression* expr) {
7168 Visit(expr);
7243 FeedbackSlot BytecodeGenerator::GetCachedLoadICSlot(const Expression* expr,
7245 DCHECK(!expr->IsSuperPropertyReference());
7251 if (!expr->IsVariableProxy()) {
7254 const VariableProxy* proxy = expr->AsVariableProxy();
7283 FeedbackSlot BytecodeGenerator::GetCachedStoreICSlot(const Expression* expr,
7291 if (!expr->IsVariableProxy()) {
7294 const VariableProxy* proxy = expr->AsVariableProxy();