Lines Matching refs:masm
199 static void LoadFloatOperand(MacroAssembler* masm, Register scratch);
205 static void LoadFloatOperand(MacroAssembler* masm,
213 static void LoadFloatOperands(MacroAssembler* masm,
218 static void LoadFloatOperandsFromSmis(MacroAssembler* masm,
228 static void LoadFloatOperands(MacroAssembler* masm,
235 static void CheckNumberOperands(MacroAssembler* masm,
240 static void LoadAsIntegers(MacroAssembler* masm,
249 CodeGenerator::CodeGenerator(MacroAssembler* masm)
251 masm_(masm),
5920 // Use masm-> here instead of the double underscore macro since extra
5995 #define __ ACCESS_MASM(masm)
6019 MacroAssembler* masm = cgen_->masm();
6029 Comment cmnt(masm, "[ Load from Slot");
6048 Comment cmnt(masm, "[ Load from named Property");
6062 Comment cmnt(masm, "[ Inlined named property load");
6091 masm->Move(kScratchRegister, Factory::null_value());
6092 masm->cmpq(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
6097 masm->j(not_equal, deferred->entry_label());
6101 ASSERT(masm->SizeOfCodeGeneratedSince(deferred->patch_site()) ==
6107 masm->movq(value.reg(), FieldOperand(receiver.reg(), offset));
6118 Comment cmnt(masm, "[ Load from keyed Property");
6180 MacroAssembler* masm = cgen_->masm();
6183 Comment cmnt(masm, "[ Store to Slot");
6192 Comment cmnt(masm, "[ Store to named Property");
6201 Comment cmnt(masm, "[ Store to keyed Property");
6210 Comment cmnt(masm, "[ Inlined store to keyed Property");
6268 masm->movq(kScratchRegister, Factory::fixed_array_map(),
6276 masm->SmiToIndex(kScratchRegister, key.reg(), kPointerSizeLog2);
6295 masm->nop();
6308 void FastNewClosureStub::Generate(MacroAssembler* masm) {
6351 void FastNewContextStub::Generate(MacroAssembler* masm) {
6393 void FastCloneShallowArrayStub::Generate(MacroAssembler* masm) {
6409 SmiIndex index = masm->SmiToIndex(rax, rax, kPointerSizeLog2);
6450 void ToBooleanStub::Generate(MacroAssembler* masm) {
6591 void IntegerConvert(MacroAssembler* masm,
6722 void GenericUnaryOpStub::Generate(MacroAssembler* masm) {
6768 IntegerConvert(masm, rax, CpuFeatures::IsSupported(SSE3), &slow);
6800 void RegExpExecStub::Generate(MacroAssembler* masm) {
6845 Condition is_smi = masm->CheckSmi(rcx);
6873 Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);
6993 masm->ArgumentStackSlotsForCFunctionCall(kRegExpExecuteArguments);
7157 void CompareStub::Generate(MacroAssembler* masm) {
7276 FloatingPointHelper::CheckNumberOperands(masm, &check_for_symbols);
7277 FloatingPointHelper::LoadFloatOperands(masm, rax, rdx);
7304 BranchIfNonSymbol(masm, &check_for_strings, rax, kScratchRegister);
7305 BranchIfNonSymbol(masm, &check_for_strings, rdx, kScratchRegister);
7318 StringCompareStub::GenerateCompareFlatAsciiStrings(masm,
7363 void CompareStub::BranchIfNonSymbol(MacroAssembler* masm,
7404 void InstanceofStub::Generate(MacroAssembler* masm) {
7462 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* masm) {
7490 SmiIndex index = masm->SmiToIndex(rbx, rcx, kPointerSizeLog2);
7500 index = masm->SmiToIndex(rcx, rcx, kPointerSizeLog2);
7567 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
7593 SmiIndex index = masm->SmiToIndex(rax, rax, kPointerSizeLog2);
7595 index = masm->SmiToNegativeIndex(rdx, rdx, kPointerSizeLog2);
7608 index = masm->SmiToIndex(rax, rcx, kPointerSizeLog2);
7610 index = masm->SmiToNegativeIndex(rdx, rdx, kPointerSizeLog2);
7626 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* masm) {
7643 void CEntryStub::GenerateThrowTOS(MacroAssembler* masm) {
7672 void CEntryStub::GenerateCore(MacroAssembler* masm,
7800 void CEntryStub::GenerateThrowUncatchable(MacroAssembler* masm,
7853 void CallFunctionStub::Generate(MacroAssembler* masm) {
7909 void CEntryStub::Generate(MacroAssembler* masm) {
7941 GenerateCore(masm,
7949 GenerateCore(masm,
7959 GenerateCore(masm,
7967 GenerateThrowUncatchable(masm, OUT_OF_MEMORY);
7970 GenerateThrowUncatchable(masm, TERMINATION);
7973 GenerateThrowTOS(masm);
7977 void ApiGetterEntryStub::Generate(MacroAssembler* masm) {
7982 void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
8099 // Stub classes have public member named masm, not masm_.
8101 void StackCheckStub::Generate(MacroAssembler* masm) {
8116 void FloatingPointHelper::LoadFloatOperand(MacroAssembler* masm,
8134 void FloatingPointHelper::LoadFloatOperand(MacroAssembler* masm,
8151 void FloatingPointHelper::LoadFloatOperands(MacroAssembler* masm,
8155 LoadFloatOperand(masm, kScratchRegister, dst1);
8157 LoadFloatOperand(masm, kScratchRegister, dst2);
8161 void FloatingPointHelper::LoadFloatOperandsFromSmis(MacroAssembler* masm,
8173 void FloatingPointHelper::LoadAsIntegers(MacroAssembler* masm,
8197 IntegerConvert(masm, rdx, use_sse3, conversion_failure);
8220 IntegerConvert(masm, rax, use_sse3, conversion_failure);
8226 void FloatingPointHelper::LoadFloatOperands(MacroAssembler* masm,
8255 void FloatingPointHelper::CheckNumberOperands(MacroAssembler* masm,
8302 MacroAssembler* masm,
8360 MacroAssembler* masm,
8396 MacroAssembler* masm,
8430 Result GenericBinaryOpStub::GenerateCall(MacroAssembler* masm,
8445 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
8448 Comment load_comment(masm, "-- Load arguments");
8468 Comment smi_check_comment(masm, "-- Smi check arguments");
8474 Comment perform_smi(masm, "-- Perform smi operation");
8547 GenerateReturn(masm);
8564 FloatingPointHelper::LoadFloatOperandsFromSmis(masm, xmm4, xmm5);
8574 GenerateReturn(masm);
8582 Comment done_comment(masm, "-- Enter non-smi code");
8605 void GenericBinaryOpStub::Generate(MacroAssembler* masm) {
8608 GenerateSmiCode(masm, &call_runtime);
8610 GenerateLoadArguments(masm);
8627 FloatingPointHelper::CheckNumberOperands(masm, &call_runtime);
8631 FloatingPointHelper::LoadFloatOperands(masm, xmm4, xmm5);
8673 GenerateReturn(masm);
8686 FloatingPointHelper::LoadAsIntegers(masm, use_sse3_, &call_runtime);
8705 GenerateReturn(masm);
8731 GenerateReturn(masm);
8764 is_smi = masm->CheckSmi(rdx);
8770 is_smi = masm->CheckSmi(rax);
8789 is_smi = masm->CheckSmi(rax);
8842 void GenericBinaryOpStub::GenerateLoadArguments(MacroAssembler* masm) {
8851 void GenericBinaryOpStub::GenerateReturn(MacroAssembler* masm) {
8912 void StringAddStub::Generate(MacroAssembler* masm) {
8922 is_smi = masm->CheckSmi(rax);
8928 is_smi = masm->CheckSmi(rdx);
9058 GenerateCopyCharacters(masm, rcx, rax, rdi, true);
9066 GenerateCopyCharacters(masm, rcx, rdx, rdi, true);
9095 GenerateCopyCharacters(masm, rcx, rax, rdi, false);
9103 GenerateCopyCharacters(masm, rcx, rdx, rdi, false);
9114 void StringStubBase::GenerateCopyCharacters(MacroAssembler* masm,
9139 void StringStubBase::GenerateCopyCharactersREP(MacroAssembler* masm,
9195 void SubStringStub::Generate(MacroAssembler* masm) {
9214 Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);
9252 SmiIndex smi_as_index = masm->SmiToIndex(rbx, rbx, times_1);
9262 GenerateCopyCharactersREP(masm
9287 SmiIndex smi_as_index = masm->SmiToIndex(rbx, rbx, times_2);
9297 GenerateCopyCharactersREP(masm, rdi, rsi, rcx, false);
9308 void StringCompareStub::GenerateCompareFlatAsciiStrings(MacroAssembler* masm,
9393 void StringCompareStub::Generate(MacroAssembler* masm) {
9419 GenerateCompareFlatAsciiStrings(masm, rdx, rax, rcx, rbx, rdi, r8);
9429 #define __ masm.
9440 Assembler masm(buffer, static_cast<int>(actual_size));
9513 masm.GetCode(&desc);
