Lines Matching refs:masm
93 #define __ masm.
106 MacroAssembler masm(BUF_SIZE, isa); \
107 TestMacroAssembler test(&masm);
109 #define START() masm.GetBuffer()->Reset();
121 MacroAssembler masm(BUF_SIZE, isa); \
122 TestMacroAssembler test(&masm); \
126 harness_scratch.Open(&masm); \
128 masm.GetBuffer()->Reset(); \
146 core.Dump(&masm); \
167 int pcs_offset = masm.IsUsingT32() ? 1 : 0; \
168 masm.GetBuffer()->SetExecutable(); \
169 ExecuteMemory(masm.GetBuffer()->GetStartAddress<byte*>(), \
170 masm.GetSizeOfCodeGenerated(), \
172 masm.GetBuffer()->SetWritable(); \
217 if (masm.IsUsingT32()) { \
218 dis.DisassembleT32Buffer(masm.GetBuffer()->GetStartAddress<uint16_t*>(), \
219 masm.GetCursorOffset()); \
221 dis.DisassembleA32Buffer(masm.GetBuffer()->GetStartAddress<uint32_t*>(), \
222 masm.GetCursorOffset()); \
668 if (masm.IsUsingA32()) {
674 ExactAssemblyScope scope(&masm,
689 if (masm.IsUsingT32()) {
700 if (masm.IsUsingT32()) {
712 if (masm.IsUsingT32()) {
740 ExactAssemblyScope scope(&masm,
1126 int32_t space = test.GetPoolCheckpoint() - masm.GetCursorOffset();
1128 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
1137 VIXL_CHECK(test.GetPoolCheckpoint() == masm.GetCursorOffset());
1148 VIXL_CHECK(masm.GetSizeOfCodeGeneratedSince(&check) ==
1173 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1176 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1215 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1225 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1236 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1259 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1261 const int nop_size = masm.IsUsingA32() ? 4 : 2;
1268 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1291 ExactAssemblyScope scope(&masm,
1342 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1384 int32_t space = test.GetPoolCheckpoint() - masm.GetCursorOffset();
1386 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
1395 VIXL_CHECK(test.GetPoolCheckpoint() == masm.GetCursorOffset());
1407 VIXL_CHECK(masm.GetSizeOfCodeGeneratedSince(&check) ==
1426 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1453 #define __ masm->
1457 void EmitLdrdLiteralTest(MacroAssembler* masm, TestMacroAssembler* test) {
1458 const int ldrd_range = masm->IsUsingA32() ? 255 : 1020;
1466 AlignDown(masm->GetBuffer()->GetCursorOffset() +
1467 masm->GetArchitectureStatePCOffset(),
1480 int32_t margin = test->GetPoolCheckpoint() - masm->GetCursorOffset();
1483 ExactAssemblyScope scope(masm, margin, ExactAssemblyScope::kExactSize);
1487 while (masm->GetCursorOffset() < end) {
1490 VIXL_CHECK(masm->GetCursorOffset() == end);
1503 #define __ masm.
1515 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1518 EmitLdrdLiteralTest(&masm, &test);
1520 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1532 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1561 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1564 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1581 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1618 VIXL_ASSERT((masm.GetBuffer()->GetCursorOffset() % 4) == 2);
1622 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1625 const int ldrd_range = masm.IsUsingA32() ? 255 : 1020;
1658 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1702 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
1708 EmitLdrdLiteralTest(&masm, &test);
1765 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
1766 int32_t end = masm.GetCursorOffset() + space;
1767 while (masm.GetCursorOffset() < end) {
1777 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
1778 for (int32_t end = masm.GetCursorOffset() + space;
1779 masm.GetCursorOffset() < end;) {
1924 VIXL_ASSERT((masm.GetBuffer()->GetCursorOffset() % 4) == 2);
1936 while ((test.GetPoolCheckpoint() - masm.GetCursorOffset() -
1946 int space = test.GetPoolCheckpoint() - masm.GetCursorOffset();
1947 int end = masm.GetCursorOffset() + space;
1950 ExactAssemblyScope accurate_scope(&masm, space); // This should not
1954 while (masm.GetCursorOffset() < end) {
1963 (masm.*test_case.instruction)(test_case.result_reg, &literal);
1995 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2001 VIXL_ASSERT((masm.GetBuffer()->GetCursorOffset() % 4) == 2);
2005 (masm.*test_case.instruction)(test_case.result_reg, &literal);
2011 masm.GetBuffer()->GetCursorOffset() +
2012 ((masm.IsUsingA32()) ? test_case.a32_range : test_case.t32_range);
2013 while (masm.GetBuffer()->GetCursorOffset() < end) {
2043 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2066 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2071 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2077 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2084 masm.EmitLiteralPool();
2110 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2141 UseScratchRegisterScope temps(&masm);
2188 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2211 (masm.*test_case.instruction)(r0, &before);
2212 (masm.*test_case.instruction)(r1, &after);
2244 const int nop_size = masm.IsUsingA32() ? kA32InstructionSizeInBytes
2247 masm.IsUsingA32() ? test_case.a32_range : test_case.t32_range;
2251 const int margin = masm.IsUsingT32() ? 4 : 0;
2255 range - masm.GetArchitectureStatePCOffset() - sizeof(uint32_t) - margin;
2265 const int padding_after = range + masm.GetArchitectureStatePCOffset() -
2280 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
2281 for (int32_t end = masm.GetCursorOffset() + space;
2282 masm.GetCursorOffset() < end;) {
2288 (masm.*test_case.instruction)(r0, &before);
2289 (masm.*test_case.instruction)(r1, &after);
2293 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
2294 for (int32_t end = masm.GetCursorOffset() + space;
2295 masm.GetCursorOffset() < end;) {
2328 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&start) == 4000);
2512 ExactAssemblyScope scope(&masm,
2548 ExactAssemblyScope scope(&masm,
2562 int32_t margin = end - masm.GetCursorOffset();
2565 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
2566 while (masm.GetCursorOffset() < end) {
2604 ExactAssemblyScope scope(&masm,
2619 while (masm.GetCursorOffset() < end) __ Nop();
2664 masm.FinalizeCode();
2683 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
2689 ExactAssemblyScope scope(&masm,
2694 VIXL_ASSERT((masm.GetBuffer()->GetCursorOffset() % 4) == 2);
2732 a32->UpdateValue(0x12345678, masm.GetBuffer());
2733 a64->UpdateValue(UINT64_C(0x13579bdf02468ace), masm.GetBuffer());
2734 b32->UpdateValue(0x87654321, masm.GetBuffer());
2735 b64->UpdateValue(UINT64_C(0x1032547698badcfe), masm.GetBuffer());
2758 VIXL_CHECK((masm.GetCursorOffset() - start.GetLocation()) == 0);
3016 UseScratchRegisterScope temps(&masm);
3021 VIXL_CHECK(masm.GetScratchRegisterList()->IsEmpty());
3181 MacroAssembler masm;
3182 CheckInstructionSetA32(masm);
3183 masm.UseT32();
3184 CheckInstructionSetT32(masm);
3185 masm.UseA32();
3186 CheckInstructionSetA32(masm);
3187 masm.UseInstructionSet(T32);
3188 CheckInstructionSetT32(masm);
3189 masm.UseInstructionSet(A32);
3190 CheckInstructionSetA32(masm);
3214 MacroAssembler masm(A32);
3215 CheckInstructionSetA32(masm);
3216 masm.Bx(lr);
3217 VIXL_ASSERT(masm.GetCursorOffset() > 0);
3218 CheckInstructionSetA32(masm);
3219 masm.UseA32();
3220 CheckInstructionSetA32(masm);
3221 masm.UseInstructionSet(A32);
3222 CheckInstructionSetA32(masm);
3223 masm.FinalizeCode();
3242 MacroAssembler masm(T32);
3243 CheckInstructionSetT32(masm);
3244 masm.Bx(lr);
3245 VIXL_ASSERT(masm.GetCursorOffset() > 0);
3246 CheckInstructionSetT32(masm);
3247 masm.UseT32();
3248 CheckInstructionSetT32(masm);
3249 masm.UseInstructionSet(T32);
3250 CheckInstructionSetT32(masm);
3251 masm.FinalizeCode();
3272 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_1) == 0);
3277 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_2) != 0);
3282 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_3) != 0);
3287 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_4) != 0);
3292 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_5) != 0);
3297 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_6) != 0);
3302 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_7) != 0);
3307 VIXL_ASSERT(masm.GetSizeOfCodeGeneratedSince(&blob_8) != 0);
3336 UseScratchRegisterScope temps(&masm);
3338 VIXL_CHECK(masm.GetScratchRegisterList()->GetList() ==
3343 // masm.AliasesAvailableScratchRegister(reg) == temps.IsAvailable(reg).
3346 VIXL_CHECK(masm.AliasesAvailableScratchRegister(reg) ==
3360 UseScratchRegisterScope temps(&masm);
3363 VIXL_CHECK(masm.GetScratchVRegisterList()->GetList() == 0);
3375 VIXL_CHECK(masm.GetScratchVRegisterList()->GetList() ==
3398 VIXL_CHECK(masm.AliasesAvailableScratchRegister(SRegister(s)));
3399 VIXL_CHECK(masm.AliasesAvailableScratchRegister(DRegister(s / 2)));
3400 VIXL_CHECK(masm.AliasesAvailableScratchRegister(QRegister(s / 4)));
3403 VIXL_CHECK(!masm.AliasesAvailableScratchRegister(SRegister(s)));
3411 VIXL_CHECK(masm.AliasesAvailableScratchRegister(DRegister(d)));
3412 VIXL_CHECK(masm.AliasesAvailableScratchRegister(QRegister(d / 2)));
3415 VIXL_CHECK(!masm.AliasesAvailableScratchRegister(DRegister(d)));
3431 VIXL_CHECK(masm.GetSizeOfCodeGeneratedSince(&start) >= nop_size);
3433 masm.FinalizeCode();
3451 int32_t margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
3454 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
3458 while (masm.GetCursorOffset() < end) {
3461 VIXL_CHECK(masm.GetCursorOffset() == end);
3466 VIXL_CHECK(test.GetPoolCheckpoint() == masm.GetCursorOffset());
3497 int32_t margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
3500 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
3504 while (masm.GetCursorOffset() < end) {
3507 VIXL_CHECK(masm.GetCursorOffset() == end);
3510 VIXL_CHECK(test.GetPoolCheckpoint() == masm.GetCursorOffset());
3519 ExactAssemblyScope scope(&masm, 2, ExactAssemblyScope::kMaximumSize);
3522 VIXL_CHECK(masm.GetSizeOfCodeGeneratedSince(&check) > 0);
3613 masm.FinalizeCode(MacroAssembler::kFallThrough);
3876 masm.FinalizeCode(MacroAssembler::kFallThrough);
3911 MacroAssembler masm(kBaseBufferSize, T32);
3913 VIXL_CHECK(masm.GetBuffer()->GetCapacity() == kBaseBufferSize);
3917 ExactAssemblyScope scope(&masm,
3926 VIXL_CHECK(masm.GetBuffer()->GetCapacity() == kBaseBufferSize);
3931 VIXL_CHECK(masm.GetBuffer()->GetCapacity() > kBaseBufferSize);
3933 masm.FinalizeCode();
3940 MacroAssembler masm(kBaseBufferSize, T32);
3941 TestMacroAssembler test(&masm);
3943 VIXL_CHECK(masm.GetBuffer()->GetCapacity() == kBaseBufferSize);
3953 VIXL_CHECK(IsUint32(masm.GetBuffer()->GetRemainingBytes()));
3954 uint32_t space = static_cast<uint32_t>(masm.GetBuffer()->GetRemainingBytes());
3957 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
3966 VIXL_CHECK(masm.GetBuffer()->GetCapacity() == kBaseBufferSize);
3967 VIXL_CHECK(masm.GetBuffer()->GetRemainingBytes() == 0);
3972 test.GetPoolCheckpoint() - masm.GetCursorOffset() + 1;
3973 masm.EnsureEmitFor(past_cbz_range);
3979 masm.FinalizeCode();
3986 MacroAssembler masm(kBaseBufferSize);
3988 VIXL_CHECK(masm.GetBuffer()->GetCapacity() == kBaseBufferSize);
3990 VIXL_CHECK(IsUint32(masm.GetBuffer()->GetRemainingBytes()));
3991 int32_t space = static_cast<int32_t>(masm.GetBuffer()->GetRemainingBytes());
3995 ExactAssemblyScope scope(&masm, space, ExactAssemblyScope::kExactSize);
4002 VIXL_CHECK(!masm.GetBuffer()->HasSpaceFor(4));
4003 masm.EnsureEmitFor(4);
4004 VIXL_CHECK(masm.GetBuffer()->HasSpaceFor(4));
4007 masm.FinalizeCode();
4024 ExactAssemblyScope scope(&masm, space, CodeBufferCheckScope::kExactSize);
4025 VIXL_ASSERT(masm.IsUsingT32());
4034 masm.GetCursorOffset())) { \
4035 ExactAssemblyScope scope(&masm, \
4041 IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())); \
4097 ExactAssemblyScope scope(&masm, space, CodeBufferCheckScope::kExactSize);
4098 VIXL_ASSERT(masm.IsUsingT32());
4106 if (IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())) { \
4107 ExactAssemblyScope scope(&masm, \
4113 !IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())); \
4148 UseScratchRegisterScope temps(&masm);
4190 ExactAssemblyScope scope(&masm, space, CodeBufferCheckScope::kExactSize);
4191 VIXL_ASSERT(masm.IsUsingT32());
4200 masm.GetCursorOffset())) { \
4201 ExactAssemblyScope scope(&masm, \
4207 IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())); \
4263 ExactAssemblyScope scope(&masm, space, CodeBufferCheckScope::kExactSize);
4264 VIXL_ASSERT(masm.IsUsingT32());
4272 if (IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())) { \
4273 ExactAssemblyScope scope(&masm, \
4279 !IsMultiple<k32BitT32InstructionSizeInBytes>(masm.GetCursorOffset())); \
4334 ExactAssemblyScope scope(&masm, \
4337 VIXL_ASSERT(masm.IsUsingT32()); \
4371 UseScratchRegisterScope temps(&masm);
4444 if (masm.IsUsingA32()) {
4459 if (masm.IsUsingA32()) {
4470 if (masm.IsUsingA32()) {
4481 if (masm.IsUsingA32()) {
4495 if (masm.IsUsingA32()) {
4506 if (masm.IsUsingA32()) {
4868 int end_1 = masm.GetCursorOffset() + target_1_size_1;
4869 while (masm.GetCursorOffset() < end_1) {
4876 int end_2 = masm.GetCursorOffset() + target_1_size_2;
4877 while (masm.GetCursorOffset() < end_2) {
4905 int end_1 = masm.GetCursorOffset() + target_1_size_1;
4906 while (masm.GetCursorOffset() < end_1) {
4913 int end_2 = masm.GetCursorOffset() + target_1_size_2;
4914 while (masm.GetCursorOffset() < end_2) {
5016 while (test.GetPoolCheckpoint() - masm.GetCursorOffset() >=
5024 VIXL_ASSERT(test.GetPoolCheckpoint() - masm.GetCursorOffset() <
5120 ExactAssemblyScope aas(&masm, 2 * NUM1, CodeBufferCheckScope::kMaximumSize);
5129 ExactAssemblyScope aas(&masm, 2 * NUM2, CodeBufferCheckScope::kMaximumSize);
5136 ExactAssemblyScope aas(&masm, 4, CodeBufferCheckScope::kMaximumSize);
5172 ExactAssemblyScope aas(&masm,
5183 ExactAssemblyScope aas(&masm, 4, CodeBufferCheckScope::kMaximumSize);
5218 ExactAssemblyScope scope(&masm, nop_size, CodeBufferCheckScope::kExactSize);
5237 VIXL_CHECK(test.GetPoolCheckpoint() - masm.GetCursorOffset() < kCbzCbnzRange);
5242 ExactAssemblyScope scope(&masm, nop_size, CodeBufferCheckScope::kExactSize);
5250 VIXL_CHECK(test.GetPoolCheckpoint() - masm.GetCursorOffset() > kCbzCbnzRange);
5291 const int nop_size = masm.IsUsingA32() ? 4 : 2;
5293 (masm.GetCursorOffset() +
5295 ExactAssemblyScope scope(&masm, nop_size, ExactAssemblyScope::kExactSize);
5327 masm.EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
5337 int32_t margin = test.GetPoolCheckpoint() - masm.GetCursorOffset() -
5339 int32_t end = masm.GetCursorOffset() + margin;
5342 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
5343 while (masm.GetCursorOffset() < end) {
5347 VIXL_CHECK((test.GetPoolCheckpoint() - masm.GetCursorOffset()) ==
5581 if (masm.IsUsingA32()) {
5587 ExactAssemblyScope scope(&masm,
5591 if (masm.IsUsingT32()) {
5633 EmissionCheckScope scope(&masm,
5639 ExactAssemblyScope scope(&masm,
5649 EmissionCheckScope scope(&masm,
5656 EmissionCheckScope scope(&masm,
5662 int32_t margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
5666 ExactAssemblyScope scope(&masm,
5676 margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
5700 EmissionCheckScope scope(&masm,
5706 ExactAssemblyScope scope(&masm,
5716 EmissionCheckScope scope(&masm,
5723 EmissionCheckScope scope(&masm,
5748 EmissionCheckScope scope(&masm,
5754 ExactAssemblyScope scope(&masm,
5764 EmissionCheckScope scope(&masm,
5771 EmissionCheckScope scope(&masm,
5777 int32_t margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
5781 ExactAssemblyScope scope(&masm,
5791 margin = test.GetPoolCheckpoint() - masm.GetCursorOffset();
5815 EmissionCheckScope scope(&masm,
5821 ExactAssemblyScope scope(&masm,
5831 EmissionCheckScope scope(&masm,
5838 EmissionCheckScope scope(&masm,
6142 ExactAssemblyScope scope(&masm,
6150 test.GetPoolCheckpoint() - masm.GetCursorOffset() - l0.GetSize() / 2;
6151 int32_t end = masm.GetCursorOffset() + margin;
6153 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
6154 while (masm.GetCursorOffset() < end) {
6187 ExactAssemblyScope scope(&masm,
6190 while (masm.GetCursorOffset() % 4 != 0) {
6201 test.GetPoolCheckpoint() - masm.GetCursorOffset() - kPaddingBytes;
6202 int32_t end = masm.GetCursorOffset() + margin;
6204 ExactAssemblyScope scope(&masm, margin, ExactAssemblyScope::kExactSize);
6205 while (masm.GetCursorOffset() < end) {
6216 VIXL_ASSERT((masm.GetBuffer()->GetCursorOffset() % 4) == 0);
6230 static void AddBranchesAndGetCloseToCheckpoint(MacroAssembler* masm,
6237 masm->B(&b_labels[i]);
6242 const int kAddSize = masm->IsUsingT32() ? k16BitT32InstructionSizeInBytes
6245 int32_t space = end - masm->GetCursorOffset() - margin;
6247 ExactAssemblyScope scope(masm, space, ExactAssemblyScope::kExactSize);
6249 masm->add(r0, r0, r0);
6259 static void EmitIndividualNops(MacroAssembler* masm, const int kNops) {
6261 masm->Nop();
6265 static void EmitNopsInExactAssemblyScope(MacroAssembler* masm,
6267 const int kNopSize = masm->IsUsingT32() ? k16BitT32InstructionSizeInBytes
6270 ExactAssemblyScope scope(masm,
6274 masm->nop();
6287 AddBranchesAndGetCloseToCheckpoint(&masm,
6301 EmitIndividualNops(&masm, 1000);
6322 AddBranchesAndGetCloseToCheckpoint(&masm,
6342 EmitIndividualNops(&masm, 1000);
6361 AddBranchesAndGetCloseToCheckpoint(&masm,
6373 EmitNopsInExactAssemblyScope(&masm, 4096);
6394 AddBranchesAndGetCloseToCheckpoint(&masm,
6404 EmitIndividualNops(&masm, 2000);
6423 AddBranchesAndGetCloseToCheckpoint(&masm,
6431 EmitNopsInExactAssemblyScope(&masm, 4096);
6454 ExactAssemblyScope scope(&masm, 2, ExactAssemblyScope::kMaximumSize);
6461 EmitNopsInExactAssemblyScope(&masm, 4096);
6480 can_encode = masm.INFO; \
6483 ExactAssemblyScope scope(&masm, \
6487 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6492 masm.ASM; \
6495 ExactAssemblyScope scope(&masm, \
6499 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6504 masm.ASM; \
6510 ExactAssemblyScope scope(&masm, \
6514 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6519 masm.ASM; \
6525 ExactAssemblyScope scope(&masm, \
6529 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6534 masm.ASM; \
6544 MacroAssembler masm(BUF_SIZE, T32);
6679 masm.FinalizeCode();
6683 MacroAssembler masm(BUF_SIZE, A32);
6767 masm.FinalizeCode();