Lines Matching full:load
685 // Load applicand.apply onto the stack. This will usually
686 // give us a megamorphic load site. Not super, but it works.
687 Load(applicand);
694 // Load the receiver and the existing arguments object onto the
696 Load(receiver);
959 Load(node->fun());
982 Load(val);
999 Load(expression);
1131 Load(node->expression());
1153 Load(node->expression());
1192 Load(node->tag());
1225 Load(clause->label());
1730 // prototype load.
1748 // Load the prototype from the map and loop if non-null.
1752 // The enum cache is valid. Load the map of the object being
1809 __ movq(rax, frame_->ElementAt(0)); // load the current count
2288 Load(node->else_expression());
2293 Load(node->then_expression());
2297 Load(node->then_expression());
2302 Load(node->else_expression());
2384 // Load the literals array of the function.
2388 // Load the literal at the ast saved index.
2412 // Load a writable copy of the function of this activation in a
2419 // Load the literals array of the function.
2449 Load(property->value());
2459 Load(property->key());
2460 Load(property->value());
2468 Load(property->key());
2470 Load(property->value());
2478 Load(property->key());
2480 Load(property->value());
2494 // Load a writable copy of the function of this activation in a
2501 // Load the literals array of the function.
2533 Load(value);
2567 Load(node->key());
2568 Load(node->value());
2618 Load(node->value());
2636 Load(node->value());
2676 Load(node->exception());
2719 Load(function);
2725 Load(args->at(i));
2771 // Load the arguments.
2774 Load(args->at(i));
2795 // Load the function from the context. Sync the frame so we can
2809 // Load the receiver.
2841 Load(property->obj());
2843 // Load the arguments.
2846 Load(args->at(i));
2866 // Load the function to call from the property through a reference.
2896 // Load the function.
2897 Load(function);
2920 Load(node->expression());
2927 Load(args->at(i));
2961 Load(args->at(i));
2996 Load(property->obj());
2997 Load(property->key());
3038 Load(node->expression()); // may have side-effects
3062 Load(node->expression());
3070 Load(node->expression());
3357 Load(node->right());
3419 Load(node->right());
3437 Load(node->left());
3438 Load(node->right());
3462 // Load the operand and move it to a register.
3573 Load(left);
3574 Load(right);
3580 Load(left);
3581 Load(right);
3593 Load(left);
3594 Load(right);
3609 Load(args->at(0));
3622 Load(args->at(0));
3638 Load(args->at(0));
3656 Load(args->at(0));
3683 Load(args->at(0));
3696 Load(args->at(0));
3756 Load
3757 Load(args->at(1));
3836 // Load the 2-byte character code into the temp register.
3845 // Load the byte into the temp register.
3883 Load(args->at(0));
3895 Load(args->at(0));
3916 Load(args->at(1));
3917 Load(args->at(2));
3929 // Load the two objects into registers and perform the comparison.
3930 Load(args->at(0));
3931 Load(args->at(1));
3985 // Load the arguments on the stack and call the runtime system.
3986 Load(args->at(0));
3987 Load(args->at(1));
3988 Load(args->at(2));
3989 Load(args->at(3));
3999 // Load the argument on the stack and jump to the runtime.
4000 Load(args->at(0));
4009 // Load the argument on the stack and jump to the runtime.
4010 Load(args->at(0));
4018 // Load the argument on the stack and jump to the runtime.
4019 Load(args->at(0));
4028 Load(args->at(0));
4029 Load(args->at(1));
4040 Load(args->at(0));
4041 Load(args->at(1));
4042 Load(args->at(2));
4053 Load(args->at(0));
4054 Load(args->at(1));
4065 Load(args->at(0)); // Load the object.
4125 Load(args->at(0)); // Load the object.
4126 Load(args->at(1)); // Load the value.
4168 Load(args->at(0)); // Load the object.
4196 Load(expression);
4202 void CodeGenerator::Load(Expression* expr) {
4265 // Emit code to load the value of an expression to the top of the
4407 Load(property->obj());
4411 Load(property->key());
4426 Load(e);
4466 // Load the closure.
4471 // Load the function context (which is the incoming, outer context).
4596 Comment cmnt(masm_, "[ Load const");
4780 // Load next context in chain.
4799 // Load map for comparison into register, outside loop.
4808 // Load next context in chain.
4817 // load IC call.
4923 // load to make sure we do not get reference errors.
4935 Load(expr);
5881 Comment cmnt(masm_, "[ Load from keyed Property");
5882 // Inline array load code if inside of a loop. We do not know
5887 Comment cmnt(masm_, "[ Inlined load from keyed Property");
5894 // Use a fresh temporary to load the elements without destroying
5911 // is not a load from the global context) and that it has the
5922 // root array to load null_value, since it must be patched with
5951 // Load and check that the result is not the hole. We could
5978 Comment cmnt(masm_, "[ Load from keyed Property");
5986 // keyed load. The explicit nop instruction is here because
6021 // Record the source position for the property load.
6029 Comment cmnt(masm, "[ Load from Slot");
6048 Comment cmnt(masm, "[ Load from named Property");
6062 Comment cmnt(masm, "[ Inlined named property load");
6099 // The delta from the patch label to the load offset must be
6118 Comment cmnt(masm, "[ Load from keyed Property");
6404 // Load boilerplate object into rcx and check if we need to create a
6485 __ fldz(); // Load zero onto fp stack
6486 // Load heap-number double value onto fp stack
6611 // Load x87 register with heap number.
6617 __ movl(rcx, Operand(rsp, 0)); // Load low word of answer into rcx.
6620 // Load rcx with zero. We use this either for the final shift or
6975 // Load used arguments before starting to push arguments for call to native
7085 // Load RegExp data.
7095 // Load last_match_info which is still known to be a fast case JSArray.
7387 Load(args->at(i));
7810 // Load the type of the current stack handler.
8045 // builtin and pop the faked function when we return. We load the address
8448 Comment load_comment(masm, "-- Load arguments");
8707 // All ops except SHR return a signed int32 that we load in a HeapNumber.
8915 // Load the two arguments.
9248 // Load string argument and locate character of sub string start.
9283 // Load string argument and locate character of sub string start.
9351 // TODO(lrn): Could we load more than one character at a time?
9356 // Increment index and use -1 modifier on next load to give
9357 // the previous load extra time to complete.
9451 // Load y and x (use argument backing store as temporary storage).
