Lines Matching full:masm
41 #define __ ACCESS_MASM(masm)
43 static void EmitIdenticalObjectComparison(MacroAssembler* masm,
47 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
53 static void EmitTwoNonNanDoubleComparison(MacroAssembler* masm, Condition cc);
54 static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,
60 static void EmitCheckForHeapNumber(MacroAssembler* masm, Register operand,
69 void ToNumberStub::Generate(MacroAssembler* masm) {
77 EmitCheckForHeapNumber(masm, a0, a1, t0, &call_builtin);
87 void FastNewClosureStub::Generate(MacroAssembler* masm) {
144 void FastNewContextStub::Generate(MacroAssembler* masm) {
190 void FastNewBlockContextStub::Generate(MacroAssembler* masm) {
253 MacroAssembler* masm,
300 void FastCloneShallowArrayStub::Generate(MacroAssembler* masm) {
326 GenerateFastCloneShallowArrayCommon(masm, 0,
334 GenerateFastCloneShallowArrayCommon(masm, length_,
366 GenerateFastCloneShallowArrayCommon(masm, length_, mode, &slow_case);
376 void FastCloneShallowObjectStub::Generate(MacroAssembler* masm) {
454 void Generate(MacroAssembler* masm);
458 void ConvertToDoubleStub::Generate(MacroAssembler* masm) {
518 void FloatingPointHelper::LoadSmis(MacroAssembler* masm,
551 MacroAssembler* masm,
559 LoadNumber(masm, destination,
563 LoadNumber(masm, destination,
568 void FloatingPointHelper::LoadNumber(MacroAssembler* masm,
635 void FloatingPointHelper::ConvertNumberToInt32(MacroAssembler* masm,
676 void FloatingPointHelper::ConvertIntToDouble(MacroAssembler* masm,
758 void FloatingPointHelper::LoadNumberAsInt32Double(MacroAssembler* masm,
779 ConvertIntToDouble(masm, scratch1, destination, double_dst, dst1, dst2,
825 DoubleIs32BitInteger(masm, dst1, dst2, scratch1, scratch2, not_int32);
836 void FloatingPointHelper::LoadNumberAsInt32(MacroAssembler* masm,
893 DoubleIs32BitInteger(masm, scratch1, scratch2, dst, scratch3, not_int32);
919 void FloatingPointHelper::DoubleIs32BitInteger(MacroAssembler* masm,
980 MacroAssembler* masm,
1008 AllowExternalCallThatCantCauseGC scope(masm);
1010 ExternalReference::double_fp_operation(op, masm->isolate()), 0, 2);
1059 void WriteInt32ToHeapNumberStub::Generate(MacroAssembler* masm) {
1112 static void EmitIdenticalObjectComparison(MacroAssembler* masm,
1216 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
1308 void EmitNanCheck(MacroAssembler* masm, Condition cc) {
1365 static void EmitTwoNonNanDoubleComparison(MacroAssembler* masm, Condition cc) {
1428 AllowExternalCallThatCantCauseGC scope(masm);
1429 __ CallCFunction(ExternalReference::compare_doubles(masm->isolate()),
1455 static void EmitStrictTwoHeapObjectCompare(MacroAssembler* masm,
1494 static void EmitCheckForTwoHeapNumbers(MacroAssembler* masm,
1528 static void EmitCheckForSymbolsOrObjects(MacroAssembler* masm,
1572 void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
1598 Isolate* isolate = masm->isolate();
1668 void NumberToStringStub::Generate(MacroAssembler* masm) {
1674 GenerateLookupNumberStringCache(masm, a1, v0, a2, a3, t0, false, &runtime);
1686 void CompareStub::Generate(MacroAssembler* masm) {
1713 EmitIdenticalObjectComparison(masm, &slow, cc_, never_nan_nan_);
1729 EmitSmiNonsmiComparison(masm, lhs_, rhs_,
1737 Isolate* isolate = masm->isolate();
1775 EmitNanCheck(masm, cc_);
1779 EmitTwoNonNanDoubleComparison(masm, cc_);
1788 EmitStrictTwoHeapObjectCompare(masm, lhs_, rhs_);
1797 EmitCheckForTwoHeapNumbers(masm,
1809 EmitCheckForSymbolsOrObjects(masm, lhs_, rhs_, &flat_string_check, &slow);
1820 StringCompareStub::GenerateFlatAsciiStringEquals(masm,
1827 StringCompareStub::GenerateCompareFlatAsciiStrings(masm,
1866 void ToBooleanStub::Generate(MacroAssembler* masm) {
1874 CheckOddball(masm, UNDEFINED, Heap::kUndefinedValueRootIndex, false);
1877 CheckOddball(masm, BOOLEAN, Heap::kFalseValueRootIndex, false);
1878 CheckOddball(masm, BOOLEAN, Heap::kTrueValueRootIndex, true);
1881 CheckOddball(masm, NULL_TYPE, Heap::kNullValueRootIndex, false);
1941 GenerateTypeTransition(masm);
1945 void ToBooleanStub::CheckOddball(MacroAssembler* masm,
1963 void ToBooleanStub::GenerateTypeTransition(MacroAssembler* masm) {
1971 ExternalReference(IC_Utility(IC::kToBoolean_Patch), masm->isolate()),
1977 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
1990 AllowExternalCallThatCantCauseGC scope(masm);
1994 ExternalReference::store_buffer_overflow_function(masm->isolate()),
2021 void UnaryOpStub::Generate(MacroAssembler* masm) {
2024 GenerateTypeTransition(masm);
2027 GenerateSmiStub(masm);
2030 GenerateHeapNumberStub(masm);
2033 GenerateGenericStub(masm);
2039 void UnaryOpStub::GenerateTypeTransition(MacroAssembler* masm) {
2047 ExternalReference(IC_Utility(IC::kUnaryOp_Patch), masm->isolate()), 4, 1);
2052 void UnaryOpStub::GenerateSmiStub(MacroAssembler* masm) {
2055 GenerateSmiStubSub(masm);
2058 GenerateSmiStubBitNot(masm);
2066 void UnaryOpStub::GenerateSmiStubSub(MacroAssembler* masm) {
2068 GenerateSmiCodeSub(masm, &non_smi, &slow);
2071 GenerateTypeTransition(masm);
2075 void UnaryOpStub::GenerateSmiStubBitNot(MacroAssembler* masm) {
2077 GenerateSmiCodeBitNot(masm, &non_smi);
2079 GenerateTypeTransition(masm);
2083 void UnaryOpStub::GenerateSmiCodeSub(MacroAssembler* masm,
2098 void UnaryOpStub::GenerateSmiCodeBitNot(MacroAssembler* masm,
2110 void UnaryOpStub::GenerateHeapNumberStub(MacroAssembler* masm) {
2113 GenerateHeapNumberStubSub(masm);
2116 GenerateHeapNumberStubBitNot(masm);
2124 void UnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) {
2126 GenerateSmiCodeSub(masm, &non_smi, &call_builtin);
2128 GenerateHeapNumberCodeSub(masm, &slow);
2130 GenerateTypeTransition(masm);
2132 GenerateGenericCodeFallback(masm);
2136 void UnaryOpStub::GenerateHeapNumberStubBitNot(MacroAssembler* masm) {
2138 GenerateSmiCodeBitNot(masm, &non_smi);
2140 GenerateHeapNumberCodeBitNot(masm, &slow);
2142 GenerateTypeTransition(masm);
2146 void UnaryOpStub::GenerateHeapNumberCodeSub(MacroAssembler* masm,
2148 EmitCheckForHeapNumber(masm, a0, a1, t2, slow);
2161 FrameScope scope(masm, StackFrame::INTERNAL);
2181 MacroAssembler* masm,
2185 EmitCheckForHeapNumber(masm, a0, a1, t2, slow);
2209 FrameScope scope(masm, StackFrame::INTERNAL);
2250 void UnaryOpStub::GenerateGenericStub(MacroAssembler* masm) {
2253 GenerateGenericStubSub(masm);
2256 GenerateGenericStubBitNot(masm);
2264 void UnaryOpStub::GenerateGenericStubSub(MacroAssembler* masm) {
2266 GenerateSmiCodeSub(masm, &non_smi, &slow);
2268 GenerateHeapNumberCodeSub(masm, &slow);
2270 GenerateGenericCodeFallback(masm);
2274 void UnaryOpStub::GenerateGenericStubBitNot(MacroAssembler* masm) {
2276 GenerateSmiCodeBitNot(masm, &non_smi);
2278 GenerateHeapNumberCodeBitNot(masm, &slow);
2280 GenerateGenericCodeFallback(masm);
2285 MacroAssembler* masm) {
2301 void BinaryOpStub::GenerateTypeTransition(MacroAssembler* masm) {
2313 masm->isolate()),
2320 MacroAssembler* masm) {
2325 void BinaryOpStub::Generate(MacroAssembler* masm) {
2328 AllowStubCallsScope allow_stub_calls(masm, true);
2331 GenerateTypeTransition(masm);
2334 GenerateSmiStub(masm);
2337 GenerateInt32Stub(masm);
2340 GenerateHeapNumberStub(masm);
2343 GenerateOddballStub(masm);
2346 GenerateBothStringStub(masm);
2349 GenerateStringStub(masm);
2352 GenerateGeneric(masm);
2377 void BinaryOpStub::GenerateSmiSmiOperation(MacroAssembler* masm) {
2531 void BinaryOpStub::GenerateFPOperation(MacroAssembler* masm,
2567 masm, result, heap_number_map, scratch1, scratch2, gc_required);
2571 FloatingPointHelper::LoadSmis(masm, destination, scratch1, scratch2);
2573 FloatingPointHelper::LoadOperands(masm,
2612 FloatingPointHelper::CallCCodeForDoubleOperation(masm,
2633 FloatingPointHelper::ConvertNumberToInt32(masm,
2642 FloatingPointHelper::ConvertNumberToInt32(masm,
2704 masm, result, heap_number_map, scratch1, scratch2, gc_required);
2748 MacroAssembler* masm,
2764 GenerateSmiSmiOperation(masm);
2769 GenerateFPOperation(masm, true, use_runtime, gc_required);
2775 void BinaryOpStub::GenerateSmiStub(MacroAssembler* masm) {
2781 GenerateSmiCode(masm, &call_runtime, NULL, NO_HEAPNUMBER_RESULTS);
2785 GenerateSmiCode(masm,
2793 GenerateTypeTransition(masm);
2796 GenerateCallRuntime(masm);
2800 void BinaryOpStub::GenerateStringStub(MacroAssembler* masm) {
2804 GenerateAddStrings(masm);
2805 GenerateTypeTransition(masm);
2809 void BinaryOpStub::GenerateBothStringStub(MacroAssembler* masm) {
2831 GenerateRegisterArgsPush(masm);
2835 GenerateTypeTransition(masm);
2839 void BinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
2863 GenerateSmiSmiOperation(masm);
2881 FloatingPointHelper::LoadNumberAsInt32Double(masm,
2892 FloatingPointHelper::LoadNumberAsInt32Double(masm,
2969 GenerateHeapResultAllocation(masm,
2992 GenerateHeapResultAllocation(masm,
3004 masm, op_, heap_number_result, scratch1);
3028 FloatingPointHelper::LoadNumberAsInt32(masm,
3037 FloatingPointHelper::LoadNumberAsInt32(masm,
3106 GenerateHeapResultAllocation(masm,
3151 GenerateTypeTransition(masm);
3155 GenerateCallRuntime(masm);
3159 void BinaryOpStub::GenerateOddballStub(MacroAssembler* masm) {
3165 GenerateAddStrings(masm);
3188 GenerateHeapNumberStub(masm);
3192 masm) {
3194 GenerateFPOperation(masm, false, &call_runtime, &call_runtime);
3197 GenerateCallRuntime(masm);
3201 void BinaryOpStub::GenerateGeneric(MacroAssembler* masm) {
3204 GenerateSmiCode(masm, &call_runtime, &call_runtime, ALLOW_HEAPNUMBER_RESULTS);
3206 GenerateFPOperation(masm, false, &call_string_add_or_runtime, &call_runtime);
3210 GenerateAddStrings(masm);
3214 GenerateCallRuntime(masm);
3218 void BinaryOpStub::GenerateAddStrings(MacroAssembler* masm) {
3231 GenerateRegisterArgsPush(masm);
3241 GenerateRegisterArgsPush(masm);
3249 void BinaryOpStub::GenerateCallRuntime(MacroAssembler* masm) {
3250 GenerateRegisterArgsPush(masm);
3292 MacroAssembler* masm,
3325 void BinaryOpStub::GenerateRegisterArgsPush(MacroAssembler* masm) {
3331 void TranscendentalCacheStub::Generate(MacroAssembler* masm) {
3395 masm->isolate())));
3431 Counters* counters = masm->isolate()->counters();
3446 Counters* counters = masm->isolate()->counters();
3452 masm->isolate()),
3467 GenerateCallCFunction(masm, scratch0);
3491 FrameScope scope(masm, StackFrame::INTERNAL);
3501 GenerateCallCFunction(masm, scratch0);
3508 FrameScope scope(masm, StackFrame::INTERNAL);
3521 void TranscendentalCacheStub::GenerateCallCFunction(MacroAssembler* masm,
3530 AllowExternalCallThatCantCauseGC scope(masm);
3531 Isolate* isolate = masm->isolate();
3574 void StackCheckStub::Generate(MacroAssembler* masm) {
3579 void InterruptStub::Generate(MacroAssembler* masm) {
3584 void MathPowStub::Generate(MacroAssembler* masm) {
3698 AllowExternalCallThatCantCauseGC scope(masm);
3702 ExternalReference::power_double_double_function(masm->isolate()),
3764 Counters* counters = masm->isolate()->counters();
3783 AllowExternalCallThatCantCauseGC scope(masm);
3787 ExternalReference::power_double_double_function(masm->isolate()),
3836 void CEntryStub::GenerateCore(MacroAssembler* masm,
3847 Isolate* isolate = masm->isolate();
3881 { Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
3884 // Use masm-> here instead of the double-underscore macro since extra
3887 masm->bal(&find_ra); // bal exposes branch delay slot.
3888 masm->mov(a1, s1);
3889 masm->bind(&find_ra);
3895 masm->Addu(ra, ra, kNumInstructionsToJump * kPointerSize);
3896 masm->sw(ra, MemOperand(sp)); // This spot was reserved in EnterExitFrame.
3901 masm->mov(t9, s2); // Function pointer to t9 to conform to ABI for PIC.
3902 masm->jalr(t9);
3904 masm->addiu(sp, sp, -kCArgsSlotsSize);
3907 masm->InstructionsGeneratedSince(&find_ra));
3971 void CEntryStub::Generate(MacroAssembler* masm) {
3994 FrameScope scope(masm, StackFrame::MANUAL);
4006 GenerateCore(masm,
4014 GenerateCore(masm,
4024 GenerateCore(masm,
4033 Isolate* isolate = masm->isolate();
4056 void JSEntryStub::GenerateBody(MacroAssembler* masm, bool is_construct) {
4058 Isolate* isolate = masm->isolate();
4189 ExternalReference entry(Builtins::kJSEntryTrampoline, masm->isolate());
4243 void InstanceofStub::Generate(MacroAssembler* masm) {
4375 Operand(masm->isolate()->factory()->null_value()));
4400 FrameScope scope(masm, StackFrame::INTERNAL);
4419 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
4472 void ArgumentsAccessStub::GenerateNewNonStrictSlow(MacroAssembler* masm) {
4498 void ArgumentsAccessStub::GenerateNewNonStrictFast(MacroAssembler* masm) {
4717 void ArgumentsAccessStub::GenerateNewStrict(MacroAssembler* masm) {
4820 void RegExpExecStub::Generate(MacroAssembler* masm) {
4839 Isolate* isolate = masm->isolate();
5116 stub.GenerateCall(masm, t9);
5257 void RegExpConstructResultStub::Generate(MacroAssembler* masm) {
5293 __ li(t0, Operand(masm->isolate()->factory()->empty_fixed_array()));
5314 __ li(a2, Operand(masm->isolate()->factory()->fixed_array_map()));
5320 __ li(a2, Operand(masm->isolate()->factory()->the_hole_value()));
5344 static void GenerateRecordCallTarget(MacroAssembler* masm) {
5352 ASSERT_EQ(*TypeFeedbackCells::MegamorphicSentinel(masm->isolate()),
5353 masm->isolate()->heap()->undefined_value());
5354 ASSERT_EQ(*TypeFeedbackCells::UninitializedSentinel(masm->isolate()),
5355 masm->isolate()->heap()->the_hole_value());
5386 void CallFunctionStub::Generate(MacroAssembler* masm) {
5448 masm->isolate()->builtins()->ArgumentsAdaptorTrampoline();
5460 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
5465 void CallConstructStub::Generate(MacroAssembler* masm) {
5478 GenerateRecordCallTarget(masm);
5502 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
5547 void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
5578 StringCharLoadGenerator::Generate(masm,
5590 MacroAssembler* masm,
5602 call_helper.BeforeCall(masm);
5621 call_helper.AfterCall(masm);
5631 call_helper.BeforeCall(masm);
5638 call_helper.AfterCall(masm);
5648 void StringCharFromCodeGenerator::GenerateFast(MacroAssembler* masm) {
5676 MacroAssembler* masm,
5681 call_helper.BeforeCall(masm);
5686 call_helper.AfterCall(masm);
5696 void StringCharAtGenerator::GenerateFast(MacroAssembler* masm) {
5697 char_code_at_generator_.GenerateFast(masm);
5698 char_from_code_generator_.GenerateFast(masm);
5703 MacroAssembler* masm,
5705 char_code_at_generator_.GenerateSlow(masm, call_helper);
5706 char_from_code_generator_.GenerateSlow(masm, call_helper);
5710 void StringHelper::GenerateCopyCharacters(MacroAssembler* masm,
5743 void StringHelper::GenerateCopyCharactersLong(MacroAssembler* masm,
5855 void StringHelper::GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,
5891 StringHelper::GenerateHashInit(masm, hash, c1);
5892 StringHelper::GenerateHashAddCharacter(masm, hash, c2);
5893 StringHelper::GenerateHashGetHash(masm, hash);
5994 void StringHelper::GenerateHashInit(MacroAssembler* masm,
6010 void StringHelper::GenerateHashAddCharacter(MacroAssembler* masm,
6024 void StringHelper::GenerateHashGetHash(MacroAssembler* masm,
6045 void SubStringStub::Generate(MacroAssembler* masm) {
6116 masm, a3, t0, a1, t1, t2, t3, t4, &make_two_character_string);
6246 masm, a1, t1, a2, a3, t0, t2, t3, t4, COPY_ASCII | DEST_ALWAYS_ALIGNED);
6266 masm, a1, t1, a2, a3, t0, t2, t3, t4, DEST_ALWAYS_ALIGNED);
6269 Counters* counters = masm->isolate()->counters();
6279 void StringCompareStub::GenerateFlatAsciiStringEquals(MacroAssembler* masm,
6307 GenerateAsciiCharsCompareLoop(masm,
6317 masm,
6337 GenerateAsciiCharsCompareLoop(masm,
6363 MacroAssembler* masm,
6396 void StringCompareStub::Generate(MacroAssembler* masm) {
6399 Counters* counters = masm->isolate()->counters();
6423 GenerateCompareFlatAsciiStrings(masm, a1, a0, a2, a3, t0, t1);
6430 void StringAddStub::Generate(MacroAssembler* masm) {
6434 Counters* counters = masm->isolate()->counters();
6463 masm, 1 * kPointerSize, a0, a2, a3, t0, t1, &call_builtin);
6468 masm, 0 * kPointerSize, a1, a2, a3, t0, t1, &call_builtin);
6538 masm, a2, a3, t2, t3, t0, t1, t5, &make_two_character_string);
6682 StringHelper::GenerateCopyCharacters(masm, t2, t3, a2, t0, true);
6684 StringHelper::GenerateCopyCharacters(masm, t2, a1, a3, t0, true);
6697 StringHelper::GenerateCopyCharacters(masm, t2, t3, a2, t0, false);
6699 StringHelper::GenerateCopyCharacters(masm, t2, a1, a3, t0, false);
6715 void StringAddStub::GenerateConvertArgument(MacroAssembler* masm,
6733 NumberToStringStub::GenerateLookupNumberStringCache(masm,
6761 void ICCompareStub::GenerateSmis(MacroAssembler* masm) {
6779 GenerateMiss(masm);
6783 void ICCompareStub::GenerateHeapNumbers(MacroAssembler* masm) {
6851 GenerateMiss(masm);
6855 void ICCompareStub::GenerateSymbols(MacroAssembler* masm) {
6889 GenerateMiss(masm);
6893 void ICCompareStub::GenerateStrings(MacroAssembler* masm) {
6958 masm, left, right, tmp1, tmp2, tmp3);
6961 masm, left, right, tmp1, tmp2, tmp3, tmp4);
6974 GenerateMiss(masm);
6978 void ICCompareStub::GenerateObjects(MacroAssembler* masm) {
6994 GenerateMiss(masm);
6998 void ICCompareStub::GenerateKnownObjects(MacroAssembler* masm) {
7011 GenerateMiss(masm);
7014 void ICCompareStub::GenerateMiss(MacroAssembler* masm) {
7018 ExternalReference(IC_Utility(IC::kCompareIC_Miss), masm->isolate());
7019 FrameScope scope(masm, StackFrame::INTERNAL);
7036 void DirectCEntryStub::Generate(MacroAssembler* masm) {
7054 void DirectCEntryStub::GenerateCall(MacroAssembler* masm,
7057 this->GenerateCall(masm, t9);
7061 void DirectCEntryStub::GenerateCall(MacroAssembler* masm,
7070 Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm);
7074 masm->bal(&find_ra); // ra = pc + 8.
7075 masm->nop(); // Branch delay slot nop.
7076 masm->bind(&find_ra);
7079 masm->addiu(ra, ra, kNumInstructionsToJump * kPointerSize);
7082 masm->sw(ra, MemOperand(sp, kCArgsSlotsSize));
7083 masm->li(ra,
7088 masm->Jump(t9);
7090 ASSERT_EQ(kNumInstructionsToJump, masm->InstructionsGeneratedSince(&find_ra));
7094 void StringDictionaryLookupStub::GenerateNegativeLookup(MacroAssembler* masm,
7179 void StringDictionaryLookupStub::GeneratePositiveLookup(MacroAssembler* masm,
7256 void StringDictionaryLookupStub::Generate(MacroAssembler* masm) {
7440 void RecordWriteStub::Generate(MacroAssembler* masm) {
7465 GenerateIncremental(masm, INCREMENTAL);
7468 GenerateIncremental(masm, INCREMENTAL_COMPACTION);
7473 PatchBranchIntoNop(masm, 0);
7474 PatchBranchIntoNop(masm, 2 * Assembler::kInstrSize);
7478 void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) {
7479 regs_.Save(masm);
7498 masm, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker, mode);
7499 InformIncrementalMarker(masm, mode);
7500 regs_.Restore(masm);
7511 masm, kReturnOnNoNeedToInformIncrementalMarker, mode);
7512 InformIncrementalMarker(masm, mode);
7513 regs_.Restore(masm);
7518 void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm, Mode mode) {
7519 regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_);
7536 AllowExternalCallThatCantCauseGC scope(masm);
7540 masm->isolate()),
7546 masm->isolate()),
7549 regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_);
7554 MacroAssembler* masm,
7565 regs_.Restore(masm);
7609 regs_.Restore(masm);
7629 void StoreArrayLiteralElementStub::Generate(MacroAssembler* masm) {
