Lines Matching full:load
382 // Load the closure.
387 // Load the function context (which is the incoming, outer context).
437 // Emit code to load the value of an expression to the top of the
479 Load(expression);
485 void CodeGenerator::Load(Expression* expr) {
574 // load to make sure we do not get reference errors.
588 Load(expr);
687 Load(property->obj());
691 Load(property->key());
699 // generator will load the global object into eax, which is where
711 Load(e);
823 // Test if operands are smis or heap numbers and load them
827 // Test if operands are numbers (smi or HeapNumber objects), and load
2334 // Otherwise load the first character.
2429 Load(args->at(i));
2461 // Load applicand.apply onto the stack. This will usually
2462 // give us a megamorphic load site. Not super, but it works.
2463 Load(applicand);
2471 // Load the receiver and the existing arguments object onto the
2473 Load(receiver);
2754 Load(node->fun());
2777 Load(val);
2794 Load(expression);
2926 Load(node->expression());
2979 Load(node->expression());
3016 Load(node->tag());
3049 Load(clause->label());
3553 // prototype load.
3571 // Load the prototype from the map and loop if non-null.
3575 // The enum cache is valid. Load the map of the object being
3634 __ mov(eax, frame_->ElementAt(0)); // load the current count
4107 Load(node->else_expression());
4112 Load(node->then_expression());
4116 Load(node->then_expression());
4121 Load(node->else_expression());
4198 Comment cmnt(masm_, "[ Load const");
4284 // Load next context in chain.
4311 // Load next context in chain.
4320 // load IC call.
4322 // will load the global object directly into eax, which is where the LoadIC
4544 // Load the literals array of the function.
4548 // Load the literal at the ast saved index.
4572 // Load a writable copy of the function of this activation in a
4579 // Load the literals array of the function.
4609 Load(property->value());
4619 Load(property->key());
4620 Load(property->value());
4628 Load(property->key());
4630 Load(property->value());
4638 Load(property->key());
4640 Load(property->value());
4654 // Load a writable copy of the function of this activation in a
4661 // Load the literals array of the function.
4693 Load(value);
4727 Load(node->key());
4728 Load(node->value());
4749 Load(node->value());
4758 Load(node->value());
4791 if (!is_trivial_receiver) Load(prop->obj());
4818 // Freeing eax causes the code generator to load the global into it.
4826 Load(node->value());
4835 Load(node->value());
4880 Load(prop->obj());
4896 Load(prop->key());
4905 Load(node->value());
4914 Load(node->value());
4962 Load(node->target());
4975 Load(node->exception());
5018 Load(function);
5024 Load(args->at(i));
5070 // Load the arguments.
5073 Load(args->at(i));
5093 // Load the function from the context. Sync the frame so we can
5107 // Load the receiver.
5139 Load(property->obj());
5141 // Load the arguments.
5144 Load(args->at(i));
5164 // Load the function to call from the property through a reference.
5173 Load(property->obj());
5175 Load(property->key());
5191 // Load the function.
5192 Load(function);
5215 Load(node->expression());
5222 Load(args->at(i));
5236 Load(args->at(0));
5257 Load(args->at(1));
5258 Load(args->at(2));
5269 Load(args->at(0));
5296 Load(args->at(0));
5297 Load(args->at(1));
5380 // Load the 2-byte character code into the temp register.
5389 // Load the byte into the temp register.
5427 Load(args->at(0));
5446 Load(args->at(0));
5467 Load(args->at(0));
5498 Load(args->at(0));
5514 Load(args->at(0));
5570 Load(args->at(0)); // Load the object.
5634 Load(args->at(0)); // Load the object.
5658 Load(args->at(0)); // Load the object.
5659 Load(args->at(1)); // Load the value.
5703 Load(args->at(0));
5717 // Load the two objects into registers and perform the comparison.
5718 Load(args->at(0));
5719 Load(args->at(1));
5769 Load(args->at(0));
5770 Load(args->at(1));
5781 Load(args->at(0));
5782 Load(args->at(1));
5783 Load(args->at(2));
5794 Load(args->at(0));
5795 Load(args->at(1));
5806 // Load the arguments on the stack and call the stub.
5807 Load(args->at(0));
5808 Load(args->at(1));
5809 Load(args->at(2));
5810 Load(args->at(3));
5820 // Load the argument on the stack and call the stub.
5821 Load(args->at(0));
5830 Load(args->at(0));
5839 Load(args->at(0));
5867 Load(args->at(i));
5902 Load(property->obj());
5903 Load(property->key());
5944 Load(node->expression()); // may have side-effects
5968 Load(node->expression());
5973 Load(node->expression());
6293 Load(node->right());
6355 Load(node->right());
6373 Load(node->left());
6374 Load(node->right());
6404 // Load the operand and move it to a register.
6503 Load
6554 if (!left_already_loaded) Load(left);
6555 Load(right);
6561 if (!left_already_loaded) Load(left);
6562 Load(right);
6574 if (!left_already_loaded) Load(left);
6575 Load(right);
6759 Comment cmnt(masm(), "[ Load from named Property");
6772 Comment cmnt(masm(), "[ Inlined named property load");
6795 // The delta from the patch label to the load offset must be statically
6829 // Inline array load code if inside of a loop. We do not know the
6834 Comment cmnt(masm_, "[ Inlined load from keyed Property");
6841 // Use a fresh temporary to load the elements without destroying
6888 // Load and check that the result is not the hole.
6900 Comment cmnt(masm_, "[ Load from keyed Property");
6905 // keyed load. The explicit nop instruction is here because
7038 // Record the source position for the property load.
7046 Comment cmnt(masm, "[ Load from Slot");
7257 // Load boilerplate object into ecx and check if we need to create a
7499 Comment load_comment(masm, "-- Load arguments");
7926 // All ops except SHR return a signed int32 that we load in a HeapNumber.
8156 // Input is a smi. Untag and load it onto the FPU stack.
8157 // Then load the low and high words of the double into ebx, edx.
8172 // Input is a HeapNumber. Push it on the FPU stack and load its
8374 // Load x87 register with heap number.
8380 __ mov(ecx, Operand(esp, 0)); // Load low word of answer into ecx.
8383 // Load ecx with zero. We use this either for the final shift or
8563 // Load operand in edx into xmm0.
8569 // Load operand in eax into xmm1.
8593 // Load operand in edx into xmm0, or branch to not_numbers.
8600 // Load operand in eax into xmm1, or branch to not_numbers.
9198 // Load used arguments before starting to push arguments for call to native
9277 // Load RegExp data.
9288 // Load last_match_info which is still known to be a fast case JSArray.
9374 // Load the number string cache.
9973 // Load the type of the current stack handler.
10286 // Load the two arguments.
10433 // Load first argument and locate first character.
10442 // Load second argument and locate first character.
10471 // Load first argument and locate first character.
10481 // Load second argument and locate first character.
10621 // Load the symbol table.
10656 // Load the entry from the symble table.
10847 // Load string argument and locate character of sub string start.
10882 // Load string argument and locate character of sub string start.
