Lines Matching refs:__
93 #define __ masm.
112 __ Hlt(0); \
113 __ FinalizeCode();
129 __ Push(r4); \
130 __ Push(r5); \
131 __ Push(r6); \
132 __ Push(r7); \
133 __ Push(r8); \
134 __ Push(r9); \
135 __ Push(r10); \
136 __ Push(r11); \
137 __ Push(ip); \
138 __ Push(lr); \
139 __ Mov(r0, 0); \
140 __ Msr(APSR_nzcvq, r0); \
141 __ Vmsr(FPSCR, r0); \
147 __ Pop(lr); \
148 __ Pop(ip); \
149 __ Pop(r11); \
150 __ Pop(r10); \
151 __ Pop(r9); \
152 __ Pop(r8); \
153 __ Pop(r7); \
154 __ Pop(r6); \
155 __ Pop(r5); \
156 __ Pop(r4); \
157 __ Bx(lr); \
158 __ FinalizeCode(); \
235 __ Mov(r0, 0);
236 __ Mov(r1, 1);
237 __ Mov(r2, 0x01234567);
238 __ Mov(r3, 0xfedcba98);
241 __ Adds(r0, r0, 0);
243 __ Adc(r4, r2, r3);
244 __ Adc(r5, r0, Operand(r1, LSL, 30));
245 __ Adc(r6, r0, Operand(r2, LSR, 16));
246 __ Adc(r7, r2, Operand(r3, ASR, 4));
247 __ Adc(r8, r2, Operand(r3, ROR, 8));
248 __ Adc(r9, r2, Operand(r3, RRX));
262 __ Mov(r0, 0);
263 __ Mov(r1, 1);
264 __ Mov(r2, 0x01234567);
265 __ Mov(r3, 0xfedcba98);
266 __ Mov(r4, 0xffffffff);
269 __ Adds(r0, r4, r1);
271 __ Adc(r5, r2, r3);
272 __ Adc(r6, r0, Operand(r1, LSL, 30));
273 __ Adc(r7, r0, Operand(r2, LSR, 16));
274 __ Adc(r8, r2, Operand(r3, ASR, 4));
275 __ Adc(r9, r2, Operand(r3, ROR, 8));
276 __ Adc(r10, r2, Operand(r3, RRX));
290 __ Mov(r0, 0);
291 __ Mov(r1, 0xffffffff);
292 __ Mov(r2, 1);
295 __ Adds(r0, r0, 0);
296 __ Adcs(r3, r2, r1);
305 __ Mov(r0, 0);
306 __ Mov(r1, 0x80000000);
307 __ Mov(r2, 1);
310 __ Adds(r0, r0, 0);
311 __ Adcs(r3, r2, Operand(r1, ASR, 31));
320 __ Mov(r0, 0);
321 __ Mov(r1, 0x80000000);
322 __ Mov(r2, 0xffffffff);
325 __ Adds(r0, r0, 0);
326 __ Adcs(r3, r2, Operand(r1, LSR, 31));
335 __ Mov(r0, 0);
336 __ Mov(r1, 0x07ffffff);
337 __ Mov(r2, 0x10);
340 __ Adds(r0, r0, 0);
341 __ Adcs(r3, r2, Operand(r1, LSL, 4));
350 __ Mov(r0, 0);
351 __ Mov(r1, 0xffffff00);
352 __ Mov(r2, 0xff000001);
355 __ Adds(r0, r0, 0);
356 __ Adcs(r3, r2, Operand(r1, ROR, 8));
365 __ Mov(r0, 0);
366 __ Mov(r1, 0xffffffff);
367 __ Mov(r2, 0x1);
370 __ Adds(r0, r0, 0);
371 __ Adcs(r3, r2, Operand(r1, RRX));
380 __ Mov(r0, 0);
381 __ Mov(r1, 0xffffffff);
382 __ Mov(r2, 0x1);
385 __ Adds(r0, r1, r2);
386 __ Adcs(r3, r2, Operand(r1, RRX));
400 __ Mov(r0, 0);
403 __ Adds(r0, r0, 0);
405 __ Adc(r1, r0, 0x12345678);
406 __ Adc(r2, r0, 0xffffffff);
409 __ Cmp(r0, r0);
411 __ Adc(r3, r0, 0x12345678);
412 __ Adc(r4, r0, 0xffffffff);
431 __ Mov(r0, 0);
432 __ Mov(r1, 0x1111);
433 __ Mov(r2, 0xffffffff);
434 __ Mov(r3, 0x80000000);
436 __ Add(r4, r0, 0x12);
437 __ Add(r5, r1, 0x120000);
438 __ Add(r6, r0, 0xab << 12);
439 __ Add(r7, r2, 1);
456 __ Mov(r0, 0);
457 __ Mov(r1, 1);
459 __ Add(r2, r0, 0x12345678);
460 __ Add(r3, r1, 0xffff);
474 __ Mov(r0, 0);
475 __ Mov(r1, 0x01234567);
476 __ Mov(r2, 0x76543210);
477 __ Mov(r3, 0xffffffff);
479 __ Add(r4, r1, r2);
480 __ Add(r5, r0, Operand(r1, LSL, 8));
481 __ Add(r6, r0, Operand(r1, LSR, 8));
482 __ Add(r7, r0, Operand(r1, ASR, 8));
483 __ Add(r8, r3, Operand(r1, ROR, 8));
486 __ Adds(r0, r3, 1);
487 __ Add(r9, r3, Operand(r1, RRX));
490 __ Adds(r0, r0, 0);
491 __ Add(r10, r3, Operand(r1, RRX));
511 __ Mov(r0, 0x0000fff0);
512 __ Mov(r1, 0xf00000ff);
513 __ Mov(r2, 0xffffffff);
515 __ And(r3, r0, r1);
516 __ And(r4, r0, Operand(r1, LSL, 4));
517 __ And(r5, r0, Operand(r1, LSR, 1));
518 __ And(r6, r0, Operand(r1, ASR, 20));
519 __ And(r7, r0, Operand(r1, ROR, 28));
520 __ And(r8, r0, 0xff);
523 __ Adds(r9, r2, 1);
524 __ And(r9, r1, Operand(r1, RRX));
527 __ Adds(r10, r0, 0);
528 __ And(r10, r1, Operand(r1, RRX));
548 __ Mov(r0, 0);
549 __ Mov(r1, 0xf00000ff);
551 __ Ands(r0, r1, r1);
560 __ Mov(r0, 0x00fff000);
561 __ Mov(r1, 0xf00000ff);
563 __ Ands(r0, r0, Operand(r1, LSL, 4));
572 __ Mov(r0, 0x0000fff0);
573 __ Mov(r1, 0xf00000ff);
575 __ Ands(r0, r0, Operand(r1, LSR, 4));
584 __ Mov(r0, 0xf000fff0);
585 __ Mov(r1, 0xf00000ff);
587 __ Ands(r0, r0, Operand(r1, ASR, 4));
596 __ Mov(r0, 0x80000000);
597 __ Mov(r1, 0x00000001);
599 __ Ands(r0, r0, Operand(r1, ROR, 1));
608 __ Mov(r0, 0x80000000);
609 __ Mov(r1, 0x80000001);
612 __ Adds(r2, r0, 0);
613 __ Ands(r2, r0, Operand(r1, RRX));
622 __ Mov(r0, 0x80000000);
623 __ Mov(r1, 0x80000001);
624 __ Mov(r2, 0xffffffff);
627 __ Adds(r2, r2, 1);
628 __ Ands(r2, r0, Operand(r1, RRX));
637 __ Mov(r0, 0xfff0);
639 __ Ands(r0, r0, 0xf);
648 __ Mov(r0, 0xff000000);
650 __ Ands(r0, r0, 0x80000000);
678 __ mov(r0, 0x0); // Set to zero to indicate success.
679 __ adr(r1, &label_3);
681 __ adr(r2, &label_1); // Multiple forward references to the same label.
682 __ adr(r3, &label_1);
683 __ adr(r4, &label_1);
685 __ bind(&label_2);
686 __ eor(r5, r2, r3); // Ensure that r2, r3 and r4 are identical.
687 __ eor(r6, r2, r4);
688 __ orr(r0, r5, r6);
692 __ orr(r2, r2, 1);
694 __ bx(r2); // label_1, label_3
696 __ bind(&label_3);
697 __ adr(r2, &label_3); // Self-reference (offset 0).
698 __ eor(r1, r1, r2);
699 __ adr(r2, &label_4); // Simple forward reference.
703 __ orr(r2, r2, 1);
705 __ bx(r2); // label_4
707 __ bind(&label_1);
708 __ adr(r2, &label_3); // Multiple reverse references to the same label.
709 __ adr(r3, &label_3);
710 __ adr(r4, &label_3);
711 __ adr(r5, &label_2); // Simple reverse reference.
715 __ orr(r5, r5, 1);
717 __ bx(r5); // label_2
719 __ bind(&label_4);
743 __ adr(Wide, r0, &label_0);
744 __ adr(Wide, r1, &label_1);
745 __ adr(Wide, r2, &label_2);
746 __ adr(Wide, r3, &label_3);
747 __ b(Wide, &label_end);
748 __ bind(&label_0);
749 __ GetBuffer()->EmitData("a", 1);
750 __ bind(&label_1);
751 __ GetBuffer()->EmitData("b", 1);
752 __ bind(&label_2);
753 __ GetBuffer()->EmitData("c", 1);
754 __ bind(&label_3);
755 __ GetBuffer()->EmitData("d", 1);
758 __ Bind(&label_end);
759 __ Ldrb(r0, MemOperand(r0));
760 __ Ldrb(r1, MemOperand(r1));
761 __ Ldrb(r2, MemOperand(r2));
762 __ Ldrb(r3, MemOperand(r3));
779 __ Mov(r0, 0);
780 __ Mov(r1, 0xfedcba98);
781 __ Mov(r2, 0xffffffff);
783 __ Lsl(r3, r1, 4);
784 __ Lsr(r4, r1, 8);
785 __ Asr(r5, r1, 16);
786 __ Ror(r6, r1, 20);
802 __ Mov(r0, 0);
803 __ Mov(r1, 0xfedcba98);
804 __ Mov(r2, 0xffffffff);
806 __ Add(r9, r0, 4);
807 __ Lsl(r3, r1, r9);
809 __ Add(r9, r0, 8);
810 __ Lsr(r4, r1, r9);
812 __ Add(r9, r0, 16);
813 __ Asr(r5, r1, r9);
815 __ Add(r9, r0, 20);
816 __ Ror(r6, r1, r9);
819 __ Adds(r7, r2, 1);
820 __ Rrx(r7, r1);
823 __ Adds(r8, r0, 0);
824 __ Rrx(r8, r1);
844 __ Mov(r0, 0x0);
845 __ Mov(r1, 0x1);
846 __ Mov(r2, 0x80000000);
848 __ Mov(r3, 0x1);
853 __ Cmp(r1, 0);
854 __ B(eq, &wrong);
855 __ B(lo, &wrong);
856 __ B(mi, &wrong);
857 __ B(vs, &wrong);
858 __ B(ls, &wrong);
859 __ B(lt, &wrong);
860 __ B(le, &wrong);
862 __ B(ne, &ok_1);
863 // TODO: Use __ Mov(r0, 0x0) instead.
864 __ Add(r3, r0, 0x0);
865 __ Bind(&ok_1);
867 __ Cmp(r1, 1);
868 __ B(ne, &wrong);
869 __ B(lo, &wrong);
870 __ B(mi, &wrong);
871 __ B(vs, &wrong);
872 __ B(hi, &wrong);
873 __ B(lt, &wrong);
874 __ B(gt, &wrong);
876 __ B(pl, &ok_2);
877 // TODO: Use __ Mov(r0, 0x0) instead.
878 __ Add(r3, r0, 0x0);
879 __ Bind(&ok_2);
881 __ Cmp(r1, 2);
882 __ B(eq, &wrong);
883 __ B(hs, &wrong);
884 __ B(pl, &wrong);
885 __ B(vs, &wrong);
886 __ B(hi, &wrong);
887 __ B(ge, &wrong);
888 __ B(gt, &wrong);
890 __ B(vc, &ok_3);
891 // TODO: Use __ Mov(r0, 0x0) instead.
892 __ Add(r3, r0, 0x0);
893 __ Bind(&ok_3);
895 __ Cmp(r2, 1);
896 __ B(eq, &wrong);
897 __ B(lo, &wrong);
898 __ B(mi, &wrong);
899 __ B(vc, &wrong);
900 __ B(ls, &wrong);
901 __ B(ge, &wrong);
902 __ B(gt, &wrong);
904 __ B(le, &ok_4);
905 // TODO: Use __ Mov(r0, 0x0) instead.
906 __ Add(r3, r0, 0x0);
907 __ Bind(&ok_4);
910 __ B(&ok_5);
911 // TODO: Use __ Mov(r0, 0x0) instead.
912 __ Add(r3, r0, 0x0);
913 __ Bind(&ok_5);
915 __ B(&done);
917 __ Bind(&wrong);
918 // TODO: Use __ Mov(r0, 0x0) instead.
919 __ Add(r3, r0, 0x0);
921 __ Bind(&done);
935 __ Mov(r0, 0xffffffff);
936 __ Mov(r1, 0x01234567);
937 __ Mov(r2, 0x0);
939 __ Bfc(r0, 0, 3);
940 __ Bfc(r0, 16, 5);
942 __ Bfi(r2, r1, 0, 8);
943 __ Bfi(r2, r1, 16, 16);
957 __ Mov(r0, 0xfff0);
958 __ Mov(r1, 0xf00000ff);
959 __ Mov(r2, 0xffffffff);
961 __ Bic(r3, r0, r1);
962 __ Bic(r4, r0, Operand(r1, LSL, 4));
963 __ Bic(r5, r0, Operand(r1, LSR, 1));
964 __ Bic(r6, r0, Operand(r1, ASR, 20));
965 __ Bic(r7, r0, Operand(r1, ROR, 28));
966 __ Bic(r8, r0, 0x1f);
969 __ Adds(r9, r2, 1);
970 __ Bic(r9, r1, Operand(r1, RRX));
973 __ Adds(r10, r0, 0);
974 __ Bic(r10, r1, Operand(r1, RRX));
994 __ Mov(r0, 0);
995 __ Mov(r1, 0xf00000ff);
997 __ Bics(r0, r1, r1);
1006 __ Mov(r0, 0x00fff000);
1007 __ Mov(r1, 0x0fffff00);
1009 __ Bics(r0, r0, Operand(r1, LSL, 4));
1018 __ Mov(r0, 0x0000fff0);
1019 __ Mov(r1, 0x0fffff00);
1021 __ Bics(r0, r0, Operand(r1, LSR, 4));
1030 __ Mov(r0, 0xf000fff0);
1031 __ Mov(r1, 0x0fffff00);
1033 __ Bics(r0, r0, Operand(r1, ASR, 4));
1042 __ Mov(r0, 0x80000000);
1043 __ Mov(r1, 0xfffffffe);
1045 __ Bics(r0, r0, Operand(r1, ROR, 1));
1054 __ Mov(r0, 0x80000000);
1055 __ Mov(r1, 0x80000001);
1058 __ Adds(r2, r0, 0);
1059 __ Bics(r2, r0, Operand(r1, RRX));
1068 __ Mov(r0, 0x80000000);
1069 __ Mov(r1, 0x80000001);
1070 __ Mov(r2, 0xffffffff);
1073 __ Adds(r2, r2, 1);
1074 __ Bics(r2, r0, Operand(r1, RRX));
1083 __ Mov(r0, 0xf000);
1085 __ Bics(r0, r0, 0xf000);
1094 __ Mov(r0, 0xff000000);
1096 __ Bics(r0, r0, 0x7fffffff);
1116 __ Mov(r0, 1);
1118 __ Bind(&start);
1119 __ Cbz(r0, &end);
1130 __ nop();
1141 __ Bind(&check);
1142 __ Mov(r0, 0);
1152 __ B(&start);
1153 __ Bind(&end);
1180 __ Adr(r4, &big_literal);
1185 __ Ldr(r0, &l1);
1190 __ Ldrd(r2, r3, &l1);
1192 __ Ldr(r4, MemOperand(r4)); // Load the first 4 characters in r4.
1221 __ Ldr(r0, &l1);
1229 __ Adr(r4, &big_literal);
1230 __ Ldrd(r2, r3, &l1);
1239 __ Ldr(r4, MemOperand(r4)); // Load the first 4 characters in r4.
1272 __ Mov(r1, 0);
1273 __ Cmp(r1, 0);
1281 __ Ldr(r4, &big_literal);
1286 __ Ldr(r0, &l1);
1295 __ nop();
1300 __ Ldrd(eq, r2, r3, &l1);
1302 __ Ldrd(r2, r3, &l1);
1346 __ Ldrd(r0, r1, &l0);
1348 __ Add(r2, r2, i);
1349 __ Ldrd(r4, r5, &l0);
1352 __ Ldrd(r2, r3, &l0);
1377 __ Ldrd(r0, r1, 0x1234567890abcdef);
1388 __ nop();
1399 __ Bind(&check);
1400 __ Mov(r2, 0x12345678);
1430 __ Ldrd(r0, r1, 0x1234567890abcdef);
1432 __ Vldr(s0, 1.0);
1433 __ Vldr(d1, 2.0);
1434 __ Vmov(d2, 4.1);
1435 __ Vmov(s8, 8.2);
1451 #undef __
1453 #define __ masm->
1477 __ Ldrd(r0, r1, 0x1234567890abcdef);
1488 __ nop();
1496 __ Nop();
1501 #undef __
1503 #define __ masm.
1524 __ Adr(r4, &big_literal);
1525 __ Ldrd(r2, r3, 0xcafebeefdeadbaba);
1534 __ Ldr(r4, MemOperand(r4)); // Load the first 4 characters in r4.
1568 __ Adr(r2, &big_literal);
1569 __ Mov(r0, 0);
1570 __ Mov(r1, 0);
1571 __ Mov(r3, 1);
1572 __ Cmp(r3, 1);
1573 __ Ldrd(eq, r0, r1, 0xcafebeefdeadbaba);
1574 __ Ldrd(ne, r0, r1, 0xdeadcafebeefbaba);
1583 __ Ldr(r2, MemOperand(r2)); // Load the first 4 characters in r2.
1617 __ Nop();
1629 __ Adr(r2, &big_literal);
1630 __ Mov(r0, 0);
1631 __ Mov(r1, 0);
1634 __ Ldrd(r0, r1, 0xcafebeefdeadbaba);
1637 __ Mov(r0, 0xffffffff);
1638 __ Mov(r1, r0);
1639 __ Mov(r3, 1);
1640 __ Cmp(r3, 1);
1641 __ Ldrd(eq, r0, r1, 0xcafebeefdeadbaba);
1644 __ Mov(r0, 0xdeadbaba);
1645 __ Mov(r1, 0xcafebeef);
1646 __ Mov(r3, 1);
1647 __ Cmp(r3, 1);
1648 __ Ldrd(ne, r0, r1, 0xdeadcafebeefbaba);
1651 __ Mov(r3, 1);
1652 __ Cmp(r3, 1);
1653 __ Ldrd(eq, r0, r1, 0xcafebeefdeadbaba);
1654 __ Ldrd(ne, r0, r1, 0xdeadcafebeefbaba);
1660 __ Ldr(r2, MemOperand(r2)); // Load the first 4 characters in r2.
1706 __ Nop();
1724 __ Ldr(r0, &lit);
1729 __ Ldrb(r1, &lit);
1730 __ Ldrsb(r2, &lit);
1731 __ Ldrh(r3, &lit);
1732 __ Ldrsh(r4, &lit);
1760 __ Ldr(r1, 0x12121212);
1768 __ nop();
1772 __ Ldrd(r2, r3, 0x1234567890abcdef);
1780 __ nop();
1787 __ Mov(r0, 0);
1810 __ Ldrd(r0, r1, &l0);
1811 __ Ldr(r2, &l1);
1812 __ Ldrh(r3, &l2);
1813 __ Ldrsh(r4, &l3);
1814 __ Ldrb(r5, &l4);
1815 __ Ldrsb(r6, &l5);
1856 __ Mov(r7, 1);
1857 __ Cmp(r7, 1);
1858 __ Ldrd(eq, r0, r1, &l0);
1859 __ Ldrd(ne, r0, r1, &l0_not_taken);
1860 __ Cmp(r7, 0);
1861 __ Ldr(gt, r2, &l1);
1862 __ Ldr(le, r2, &l1_not_taken);
1863 __ Cmp(r7, 2);
1864 __ Ldrh(lt, r3, &l2);
1865 __ Ldrh(ge, r3, &l2_not_taken);
1866 __ Ldrsh(le, r4, &l3);
1867 __ Ldrsh(gt, r4, &l3_not_taken);
1868 __ Cmp(r7, 1);
1869 __ Ldrb(ge, r5, &l4);
1870 __ Ldrb(lt, r5, &l4_not_taken);
1871 __ Ldrsb(eq, r6, &l5);
1872 __ Ldrsb(ne, r6, &l5_not_taken);
1873 __ Vldr(Condition(eq), s0, &l6);
1874 __ Vldr(Condition(ne), s0, &l6_not_taken);
1875 __ Vldr(Condition(eq), d1, &l7);
1876 __ Vldr(Condition(ne), d1, &l7_not_taken);
1923 __ Nop();
1927 __ Ldr(r6, 0x12345678);
1939 __ Ldr(r7, 0x90abcdef);
1955 __ nop();
2000 __ Nop();
2014 __ Mov(r0, 0);
2048 __ Ldrb(r1, &hello_string);
2050 __ Adr(r0, &hello_string);
2051 __ Ldrb(r2, MemOperand(r0));
2070 __ Ldr(r0, &l0);
2072 __ Ldr(r1, &l0);
2076 __ Ldrd(r8, r9, &cafebeefdeadbaba);
2078 __ Ldrd(r2, r3, &cafebeefdeadbaba);
2082 __ Adr(r4, &l1);
2083 __ Ldr(r4, MemOperand(r4));
2085 __ Adr(r5, &l1);
2086 __ Ldr(r5, MemOperand(r5));
2120 __ Ldrd(r0, r1, &l0);
2121 __ Ldr(r2, &l1);
2122 __ Ldrh(r3, &l2);
2123 __ Ldrsh(r4, &l3);
2124 __ Ldrb(r5, &l4);
2125 __ Ldrsb(r6, &l5);
2131 __ B(&after_pool);
2132 __ Place(&l0);
2133 __ Place(&l1);
2134 __ Place(&l2);
2135 __ Place(&l3);
2136 __ Place(&l4);
2137 __ Place(&l5);
2138 __ Bind(&after_pool);
2145 __ Ldrd(r8, r9, &l0);
2146 __ Ldr(r7, &l1);
2147 __ Ldrh(r10, &l2);
2148 __ Ldrsh(r11, &l3);
2149 __ Ldrb(temp, &l4);
2151 __ Ldrsb(lr, &l5);
2201 __ B(&end_of_pool_before);
2202 __ Place(&before);
2203 __ Bind(&end_of_pool_before);
2221 __ B(&end_of_pool_after);
2222 __ Place(&after);
2223 __ Bind(&end_of_pool_after);
2275 __ B(&test_start);
2276 __ Place(&before);
2283 __ nop();
2287 __ Bind(&test_start);
2296 __ nop();
2301 __ B(&after_pool);
2302 __ Place(&after);
2303 __ Bind(&after_pool);
2323 __ Bind(&start);
2325 __ Ldr(r0, i);
2347 __ Mov(r0, 0);
2348 __ B(&start);
2349 __ Bind(&end);
2350 __ Mov(r0, 1);
2351 __ B(&exit);
2352 __ Bind(&start);
2355 __ Cbz(r0, &end);
2356 __ Bind(&exit);
2371 __ Mov(r0, 0);
2372 __ Mov(r1, 0);
2373 __ Mov(r2, 0);
2374 __ Cbz(r0, &first);
2375 __ Bind(&first);
2376 __ Mov(r1, 1);
2377 __ Cbnz(r0, &second);
2378 __ Bind(&second);
2379 __ Mov(r2, 2);
2396 __ Mov(r0, 0);
2397 __ Mov(r1, 0);
2398 __ Mov(r2, 0);
2399 __ Cmp(r0, 0);
2400 __ B(ne, &first);
2401 __ B(gt, &second);
2402 __ Cbz(r0, &first);
2403 __ Bind(&first);
2404 __ Mov(r1, 1);
2405 __ Cbnz(r0, &second);
2406 __ Bind(&second);
2407 __ Mov(r2, 2);
2424 __ Cbz(r0, &first);
2425 __ B(ne, &first);
2426 __ Bind(&first);
2427 __ Cbnz(r0, &second);
2428 __ B(gt, &second);
2429 __ Bind(&second);
2442 __ Mov(r0, 0);
2444 __ Ldr(r1, 0x12345678);
2446 __ Cbz(r0, &zero);
2447 __ Mov(r0, 1);
2448 __ B(&exit);
2450 __ Mov(r1, 0);
2455 __ Bind(&zero);
2456 __ Mov(r0, 2);
2457 __ Bind(&exit);
2477 __ Movs(r0, 0);
2478 __ B(ne, &exit);
2479 __ B(&start);
2481 __ Mov(r1, 0);
2483 __ Bind(&start);
2484 __ Cbz(r0, &zero);
2485 __ Mov(r0, 1);
2486 __ B(&exit);
2488 __ Mov(r1, 0);
2490 __ Bind(&zero);
2491 __ Mov(r0, 2);
2492 __ Bind(&exit);
2507 __ Cbz(r0, &target);
2508 __ Nop();
2515 __ bind(&target);
2516 __ nop();
2538 __ Nop();
2540 __ Mov(r0, 0);
2541 __ Cmp(r0, 0);
2544 __ B(ne, &b_labels[i], kNear);
2552 __ nop();
2557 __ Cbz(r0, &cbz_label);
2567 __ nop();
2571 __ Mov(r0, 1);
2574 __ Bind(&b_labels[i]);
2577 __ Bind(&cbz_label);
2596 __ Mov(r0, 0);
2597 __ Cmp(r0, 0);
2600 __ B(ne, &b_labels[i], kNear);
2608 __ nop();
2613 __ Cbz(r0, &cbz_label);
2619 while (masm.GetCursorOffset() < end) __ Nop();
2621 __ Mov(r0, 1);
2624 __ Bind(&b_labels[i]);
2627 __ Bind(&cbz_label);
2645 __ B(&l[i]);
2649 __ B(ne, &l[i]);
2653 __ Clz(r0, r0);
2657 __ Bind(&l[i]);
2658 __ Nop();
2680 __ Ldr(r0, &l0);
2692 __ b(Narrow, &after_pool);
2693 __ place(&l0);
2695 __ bind(&after_pool);
2720 __ Ldr(r0, a32);
2721 __ Ldrd(r2, r3, a64);
2722 __ EmitLiteralPool();
2728 __ Ldr(r1, b32);
2729 __ Ldrd(r4, r5, b64);
2755 __ Bind(&start);
2756 __ Claim(0);
2757 __ Drop(0);
2760 __ Claim(32);
2761 __ Ldr(r0, 0xcafe0000);
2762 __ Ldr(r1, 0xcafe0001);
2763 __ Ldr(r2, 0xcafe0002);
2764 __ Poke(r0, 0);
2765 __ Poke(r1, 4);
2766 __ Poke(r2, 8);
2767 __ Peek(r2, 0);
2768 __ Peek(r0, 4);
2769 __ Peek(r1, 8);
2770 __ Drop(32);
2786 __ Mov(r0, 0xdead);
2787 __ Mov(r1, 0xdead);
2788 __ Mov(r2, 0xdead);
2789 __ Mov(r3, 0xb);
2790 __ Msr(APSR_nzcvqg, 0);
2791 __ Mrs(r0, APSR);
2792 __ Msr(APSR_nzcvqg, 0xffffffff);
2793 __ Mrs(r1, APSR);
2795 __ Lsl(r4, r3, 28);
2796 __ Msr(APSR_nzcvq, r4);
2797 __ Mrs(r2, APSR);
2813 __ Vmov(s0, 1.0);
2814 __ Vmov(s1, 2.0);
2815 __ Vmov(s2, 0.0);
2817 __ Vcmp(F32, s0, s1);
2818 __ Vmrs(RegisterOrAPSR_nzcv(r0.GetCode()), FPSCR);
2820 __ Vcmp(F32, s0, 0.0f);
2821 __ Vmrs(RegisterOrAPSR_nzcv(r1.GetCode()), FPSCR);
2823 __ Vcmp(F32, s2, 0.0f);
2824 __ Vmrs(RegisterOrAPSR_nzcv(r2.GetCode()), FPSCR);
2844 __ Vmov(d0, 1.0);
2845 __ Vmov(d1, 2.0);
2846 __ Vmov(d2, 0.0);
2848 __ Vcmp(F64, d0, d1);
2849 __ Vmrs(RegisterOrAPSR_nzcv(r0.GetCode()), FPSCR);
2851 __ Vcmp(F64, d0, 0.0);
2852 __ Vmrs(RegisterOrAPSR_nzcv(r1.GetCode()), FPSCR);
2854 __ Vcmp(F64, d2, 0.0);
2855 __ Vmrs(RegisterOrAPSR_nzcv(r2.GetCode()), FPSCR);
2875 __ Vmov(s0, 1.0);
2876 __ Vmov(s1, 2.0);
2877 __ Vmov(s2, 0.0);
2879 __ Vcmpe(F32, s0, s1);
2880 __ Vmrs(RegisterOrAPSR_nzcv(r0.GetCode()), FPSCR);
2882 __ Vcmpe(F32, s0, 0.0f);
2883 __ Vmrs(RegisterOrAPSR_nzcv(r1.GetCode()), FPSCR);
2885 __ Vcmpe(F32, s2, 0.0f);
2886 __ Vmrs(RegisterOrAPSR_nzcv(r2.GetCode()), FPSCR);
2906 __ Vmov(d0, 1.0);
2907 __ Vmov(d1, 2.0);
2908 __ Vmov(d2, 0.0);
2910 __ Vcmpe(F64, d0, d1);
2911 __ Vmrs(RegisterOrAPSR_nzcv(r0.GetCode()), FPSCR);
2913 __ Vcmpe(F64, d0, 0.0);
2914 __ Vmrs(RegisterOrAPSR_nzcv(r1.GetCode()), FPSCR);
2916 __ Vcmpe(F64, d2, 0.0);
2917 __ Vmrs(RegisterOrAPSR_nzcv(r2.GetCode()), FPSCR);
2937 __ Mov(r0, 0x2a000000);
2938 __ Vmsr(FPSCR, r0);
2939 __ Vmrs(RegisterOrAPSR_nzcv(r1.GetCode()), FPSCR);
2941 __ Mov(r0, 0x5a000000);
2942 __ Vmsr(FPSCR, r0);
2943 __ Vmrs(RegisterOrAPSR_nzcv(r2.GetCode()), FPSCR);
2946 __ Vmrs(RegisterOrAPSR_nzcv(pc.GetCode()), FPSCR);
2947 __ Mrs(r3, APSR);
2948 __ And(r3, r3, 0xf0000000);
2964 __ Mov(r0, 0xb00e0000);
2965 __ Msr(APSR_nzcvqg, r0);
2966 __ Mov(r0, sp);
2967 __ Printf("sp=%x\n", r0);
2968 // __ Printf("Hello world!\n");
2969 __ Mov(r0, 0x1234);
2970 __ Mov(r1, 0x5678);
2972 __ Adr(r2, &literal);
2973 __ Mov(r3, 5);
2974 __ Mov(r4, 0xdead4444);
2975 __ Mov(r5, 0xdead5555);
2976 __ Mov(r6, 0xdead6666);
2977 __ Mov(r7, 0xdead7777);
2978 __ Mov(r8, 0xdead8888);
2979 __ Mov(r9, 0xdead9999);
2980 __ Mov(r10, 0xdeadaaaa);
2981 __ Mov(r11, 0xdeadbbbb);
2982 __ Vldr(d0, 1.2345);
2983 __ Vldr(d1, 2.9876);
2984 __ Vldr(s4, 1.3333);
2985 __ Vldr(s5, 3.21);
2986 __ Vldr(d3, 3.333);
2987 __ Vldr(d4, 4.444);
2988 __ Vldr(d5, 5.555);
2989 __ Vldr(d6, 6.666);
2990 __ Vldr(d7, 7.777);
2991 __ Vldr(d8, 8.888);
2992 __ Vldr(d9, 9.999);
2993 __ Vldr(d10, 10.000);
2994 __ Vldr(d11, 11.111);
2995 __ Vldr(d12, 12.222);
2996 __ Vldr(d13, 13.333);
2997 __ Vldr(d14, 14.444);
2998 __ Vldr(d15, 15.555);
2999 __ Vldr(d16, 16.666);
3000 __ Vldr(d17, 17.777);
3001 __ Vldr(d18, 18.888);
3002 __ Vldr(d19, 19.999);
3003 __ Vldr(d20, 20.000);
3004 __ Vldr(d21, 21.111);
3005 __ Vldr(d22, 22.222);
3006 __ Vldr(d23, 23.333);
3007 __ Vldr(d24, 24.444);
3008 __ Vldr(d25, 25.555);
3009 __ Vldr(d26, 26.666);
3010 __ Vldr(d27, 27.777);
3011 __ Vldr(d28, 28.888);
3012 __ Vldr(d29, 29.999);
3013 __ Vldr(d30, 30.000);
3014 __ Vldr(d31, 31.111);
3020 __ Mov(r12, 0xdeadcccc);
3023 __ Printf("%% r0=%x r1=%x str=<%.*s>\n", r0, r1, r3, r2);
3024 __ Printf("r0=%d r1=%d str=<%s>\n", r0, r1, r2);
3025 __ Printf("d0=%g\n", d0);
3026 __ Printf("s4=%g\n", s4);
3027 __ Printf("d0=%g d1=%g s4=%g s5=%g\n", d0, d1, s4, s5);
3028 __ Printf("d0=%g r0=%x s4=%g r1=%x\n", d0, r0, s4, r1);
3029 __ Printf("r0=%x d0=%g r1=%x s4=%g\n", r0, d0, r1, s4);
3030 __ Mov(r0, sp);
3031 __ Printf("sp=%x\n", r0);
3032 __ Mrs(r0, APSR);
3034 __ Mov(r2, 0xf80f0200);
3035 __ And(r0, r0, r2);
3091 __ Mov(r0, 0x1234);
3092 __ Mov(r1, 0x5678);
3093 __ Vldr(d0, 1.2345);
3094 __ Vldr(s2, 2.9876);
3095 __ Printf("d0=%g d1=%g r0=%x r1=%x\n", d0, s2, r0, r1);
3264 __ Bind(&blob_1);
3265 __ Add(r0, r0, 0);
3266 __ And(r0, r0, 0xffffffff);
3267 __ Bic(r0, r0, 0);
3268 __ Eor(r0, r0, 0);
3269 __ Orn(r0, r0, 0xffffffff);
3270 __ Orr(r0, r0, 0);
3271 __ Sub(r0, r0, 0);
3275 __ Bind(&blob_2);
3276 __ Adds(r0, r0, 0);
3280 __ Bind(&blob_3);
3281 __ Ands(r0, r0, 0);
3285 __ Bind(&blob_4);
3286 __ Bics(r0, r0, 0);
3290 __ Bind(&blob_5);
3291 __ Eors(r0, r0, 0);
3295 __ Bind(&blob_6);
3296 __ Orns(r0, r0, 0);
3300 __ Bind(&blob_7);
3301 __ Orrs(r0, r0, 0);
3305 __ Bind(&blob_8);
3306 __ Subs(r0, r0, 0);
3309 __ Mov(r0, 0xbad);
3310 __ And(r1, r0, 0);
3311 __ Bic(r2, r0, 0xffffffff);
3312 __ Eor(r3, r0, 0xffffffff);
3313 __ Orn(r4, r0, 0);
3314 __ Orr(r5, r0, 0xffffffff);
3426 __ Bind(&start);
3427 __ Nop();
3445 __ Ldrd(r0, r1, 0x1234567890abcdef);
3459 __ nop();
3469 __ Nop();
3491 __ B(eq, &target);
3505 __ nop();
3517 __ Bind(&check);
3523 __ Bind(&target);
3546 __ Mov(r1, 0);
3549 __ Cmp(r1, r1);
3560 __ Mov(r0, 1);
3569 __ Bind(&l[label_index]);
3574 __ Add(r1, r1, 1);
3578 __ Cbz(r0, &l[label_index]);
3582 __ B(eq, &past_branch, kNear);
3583 __ Cbnz(r0, &l[label_index]);
3584 __ Bind(&past_branch);
3589 __ B(eq, &past_branch, kNear);
3590 __ B(&l[label_index], kNear);
3591 __ Bind(&past_branch);
3595 __ B(ne, &l[label_index], kNear);
3598 __ Nop();
3647 __ Mov(r1, 0);
3650 __ Mov(r4, 42);
3699 __ Bind(&labels[label_index]);
3704 __ Add(r1, r1, 1);
3711 __ Nop();
3714 __ Nop();
3715 __ Nop();
3716 __ Nop();
3717 __ Nop();
3718 __ Nop();
3719 __ Nop();
3720 __ Nop();
3721 __ Nop();
3722 __ Nop();
3725 __ Nop();
3726 __ Nop();
3727 __ Nop();
3730 __ Nop();
3731 __ Nop();
3732 __ Nop();
3733 __ Nop();
3734 __ Nop();
3735 __ Nop();
3736 __ Nop();
3739 __ Ldr(r2, literals[literal_index]);
3740 __ Cmp(r2, static_cast<uint32_t>(literal_values[literal_index]));
3741 __ B(ne, &fail);
3742 __ Mov(r2, 0);
3745 __ Ldrb(r2, literals[literal_index]);
3746 __ Cmp(r2,
3749 __ B(ne, &fail);
3750 __ Mov(r2, 0);
3753 __ Ldrd(r2, r3, literals[literal_index]);
3754 __ Cmp(r2, static_cast<uint32_t>(literal_values[literal_index]));
3755 __ B(ne, &fail);
3756 __ Mov(r2, 0);
3757 __ Cmp(r3,
3760 __ B(ne, &fail);
3761 __ Mov(r3, 0);
3764 __ Vldr(s0, literals[literal_index]);
3765 __ Vmov(s1, static_cast<uint32_t>(literal_values[literal_index]));
3766 __ Vcmp(s0, s1);
3767 __ B(ne, &fail);
3768 __ Vmov(s0, 0);
3772 __ B(&past_branch, kNear);
3773 __ Cbz(r0, &labels[label_index]);
3774 __ Bind(&past_branch);
3779 __ B(&past_branch, kNear);
3780 __ Cbnz(r0, &labels[label_index]);
3781 __ Bind(&past_branch);
3786 __ B(&past_branch, kNear);
3787 __ B(ne, &labels[label_index], kNear);
3788 __ Bind(&past_branch);
3793 __ B(&past_branch, kNear);
3794 __ B(&labels[label_index], kNear);
3795 __ Bind(&past_branch);
3800 __ B(&past_branch, kNear);
3801 __ B(ne, &labels[label_index]);
3802 __ Bind(&past_branch);
3807 __ B(&past_branch, kNear);
3808 __ B(&labels[label_index]);
3809 __ Bind(&past_branch);
3814 __ B(&past_branch, kNear);
3815 __ Bl(&labels[label_index]);
3816 __ Bind(&past_branch);
3820 __ Nop();
3821 __ Nop();
3822 __ Nop();
3823 __ Nop();
3824 __ Nop();
3827 __ Nop();
3828 __ Nop();
3829 __ Nop();
3830 __ Nop();
3831 __ Nop();
3832 __ Nop();
3835 __ Nop();
3836 __ Nop();
3837 __ Nop();
3838 __ Nop();
3841 __ Nop();
3842 __ Nop();
3843 __ Nop();
3844 __ Nop();
3845 __ Nop();
3846 __ Nop();
3847 __ Nop();
3848 __ Nop();
3851 __ Nop();
3852 __ Nop();
3868 __ B(&end);
3869 __ Bind(&fail);
3870 __ Mov(r4, 0);
3871 __ Bind(&end);
3921 __ nop();
3929 __ Nop();
3949 __ Cbz(r0, &target);
3959 __ nop();
3975 __ Bind(&target);
3992 int32_t end = __ GetCursorOffset() + space;
3996 while (__ GetCursorOffset() != end) {
3997 __ nop();
4005 __ Nop();
4019 __ Ldr(r0, literal);
4027 __ nop();
4038 __ nop(); \
4047 __ Ldr(r1, literal);
4049 __ Ldrb(r2, literal);
4051 __ Ldrsb(r3, literal);
4053 __ Ldrh(r4, literal);
4055 __ Ldrsh(r5, literal);
4057 __ Ldrd(r6, r7, literal);
4059 __ Vldr(d0, literal);
4061 __ Vldr(s3, literal);
4091 __ Ldr(r0, literal);
4100 __ nop();
4110 __ nop(); \
4119 __ Ldr(r1, literal);
4121 __ Ldrb(r2, literal);
4123 __ Ldrsb(r3, literal);
4125 __ Ldrh(r4, literal);
4127 __ Ldrsh(r5, literal);
4129 __ Ldrd(r6, r7, literal);
4151 __ Vldr(d0, literal);
4153 __ Vldr(s3, literal);
4184 __ Vldr(s4, literal);
4193 __ nop();
4204 __ nop(); \
4213 __ Ldr(r1, literal);
4215 __ Ldrb(r2, literal);
4217 __ Ldrsb(r3, literal);
4219 __ Ldrh(r4, literal);
4221 __ Ldrsh(r5, literal);
4223 __ Ldrd(r6, r7, literal);
4225 __ Vldr(d0, literal);
4227 __ Vldr(s3, literal);
4257 __ Vldr(s4, literal);
4266 __ nop();
4276 __ nop(); \
4285 __ Ldr(r1, literal);
4287 __ Ldrb(r2, literal);
4289 __ Ldrsb(r3, literal);
4291 __ Ldrh(r4, literal);
4293 __ Ldrsh(r5, literal);
4295 __ Ldrd(r6, r7, literal);
4297 __ Vldr(d0, literal);
4299 __ Vldr(s3, literal);
4329 __ Ldr(r0, literal);
4339 __ nop(); \
4349 __ Ldr(r1, literal);
4350 __ Ldrb(r2, literal);
4351 __ Ldrsb(r3, literal);
4352 __ Ldrh(r4, literal);
4353 __ Ldrsh(r5, literal);
4354 __ Ldrd(r6, r7, literal);
4355 __ Vldr(d0, literal);
4356 __ Vldr(s3, literal);
4361 __ Ldr(r1, literal);
4362 __ Ldrb(r2, literal);
4363 __ Ldrsb(r3, literal);
4364 __ Ldrh(r4, literal);
4365 __ Ldrsh(r5, literal);
4366 __ Ldrd(r6, r7, literal);
4373 __ Vldr(d0, literal);
4374 __ Vldr(s3, literal);
4403 __ Dmb(SY);
4404 __ Dmb(ST);
4405 __ Dmb(ISH);
4406 __ Dmb(ISHST);
4407 __ Dmb(NSH);
4408 __ Dmb(NSHST);
4409 __ Dmb(OSH);
4410 __ Dmb(OSHST);
4413 __ Dsb(SY);
4414 __ Dsb(ST);
4415 __ Dsb(ISH);
4416 __ Dsb(ISHST);
4417 __ Dsb(NSH);
4418 __ Dsb(NSHST);
4419 __ Dsb(OSH);
4420 __ Dsb(OSHST);
4423 __ Isb(SY);
4436 __ Pld(MemOperand(sp, 0));
4437 __ Pld(MemOperand(r0, 0));
4438 __ Pld(MemOperand(r1, 123));
4439 __ Pld(MemOperand(r2, 1234));
4440 __ Pld(MemOperand(r3, 4095));
4441 __ Pld(MemOperand(r4, -123));
4442 __ Pld(MemOperand(r5, -255));
4445 __ Pld(MemOperand(r6, -1234));
4446 __ Pld(MemOperand(r7, -4095));
4451 __ Pldw(MemOperand(sp, 0));
4452 __ Pldw(MemOperand(r0, 0));
4453 __ Pldw(MemOperand(r1, 123));
4454 __ Pldw(MemOperand(r2, 1234));
4455 __ Pldw(MemOperand(r3, 4095));
4456 __ Pldw(MemOperand(r4, -123));
4457 __ Pldw(MemOperand(r5, -255));
4460 __ Pldw(MemOperand(r6, -1234));
4461 __ Pldw(MemOperand(r7, -4095));
4465 __ Pld(MemOperand(r0, r1));
4466 __ Pld(MemOperand(r0, r1, LSL, 1));
4467 __ Pld(MemOperand(r0, r1, LSL, 2));
4468 __ Pld(MemOperand(r0, r1, LSL, 3));
4471 __ Pld(MemOperand(r0, r1, LSL, 4));
4472 __ Pld(MemOperand(r0, r1, LSL, 20));
4476 __ Pldw(MemOperand(r0, r1));
4477 __ Pldw(MemOperand(r0, r1, LSL, 1));
4478 __ Pldw(MemOperand(r0, r1, LSL, 2));
4479 __ Pldw(MemOperand(r0, r1, LSL, 3));
4482 __ Pldw(MemOperand(r0, r1, LSL, 4));
4483 __ Pldw(MemOperand(r0, r1, LSL, 20));
4487 __ Pli(MemOperand(sp, 0));
4488 __ Pli(MemOperand(r0, 0));
4489 __ Pli(MemOperand(r1, 123));
4490 __ Pli(MemOperand(r2, 1234));
4491 __ Pli(MemOperand(r3, 4095));
4492 __ Pli(MemOperand(r4, -123));
4493 __ Pli(MemOperand(r5, -255));
4496 __ Pli(MemOperand(r6, -1234));
4497 __ Pli(MemOperand(r7, -4095));
4501 __ Pli(MemOperand(r0, r1));
4502 __ Pli(MemOperand(r0, r1, LSL, 1));
4503 __ Pli(MemOperand(r0, r1, LSL, 2));
4504 __ Pli(MemOperand(r0, r1, LSL, 3));
4507 __ Pli(MemOperand(r0, r1, LSL, 4));
4508 __ Pli(MemOperand(r0, r1, LSL, 20));
4526 __ Cbz(r0, &targets[i]);
4530 __ Bind(&targets[branch_count - i - 1]);
4531 __ Orr(r0, r0, r0);
4547 __ And(r0, r0, r0);
4548 __ Cbz(r0, &l[30]);
4549 __ And(r0, r0, r0);
4550 __ Cbz(r0, &l[22]);
4551 __ And(r0, r0, r0);
4552 __ Cbz(r0, &l[1]);
4553 __ Cbz(r0, &l[15]);
4554 __ Cbz(r0, &l[9]);
4555 __ Cbz(r0, &l[6]);
4556 __ Bind(&l[26]);
4557 __ Cbz(r0, &l[29]);
4558 __ And(r0, r0, r0);
4559 __ And(r0, r0, r0);
4560 __ Cbz(r0, &l[22]);
4561 __ Bind(&l[12]);
4562 __ Bind(&l[22]);
4563 __ Cbz(r0, &l[10]);
4564 __ And(r0, r0, r0);
4565 __ Cbz(r0, &l[30]);
4566 __ Cbz(r0, &l[17]);
4567 __ Cbz(r0, &l[27]);
4568 __ Cbz(r0, &l[11]);
4569 __ Bind(&l[7]);
4570 __ Cbz(r0, &l[18]);
4571 __ Bind(&l[14]);
4572 __ Cbz(r0, &l[1]);
4573 __ Bind(&l[18]);
4574 __ Cbz(r0, &l[11]);
4575 __ Cbz(r0, &l[6]);
4576 __ Bind(&l[21]);
4577 __ Cbz(r0, &l[28]);
4578 __ And(r0, r0, r0);
4579 __ Cbz(r0, &l[28]);
4580 __ Cbz(r0, &l[22]);
4581 __ Bind(&l[23]);
4582 __ Cbz(r0, &l[21]);
4583 __ Cbz(r0, &l[28]);
4584 __ Cbz(r0, &l[9]);
4585 __ Bind(&l[9]);
4586 __ Cbz(r0, &l[4]);
4587 __ And(r0, r0, r0);
4588 __ Cbz(r0, &l[10]);
4589 __ And(r0, r0, r0);
4590 __ Bind(&l[8]);
4591 __ And(r0, r0, r0);
4592 __ Cbz(r0, &l[10]);
4593 __ And(r0, r0, r0);
4594 __ Cbz(r0, &l[17]);
4595 __ Bind(&l[10]);
4596 __ Cbz(r0, &l[8]);
4597 __ Cbz(r0, &l[25]);
4598 __ Cbz(r0, &l[4]);
4599 __ Bind(&l[28]);
4600 __ And(r0, r0, r0);
4601 __ Cbz(r0, &l[16]);
4602 __ Bind(&l[19]);
4603 __ Cbz(r0, &l[14]);
4604 __ Cbz(r0, &l[28]);
4605 __ Cbz(r0, &l[26]);
4606 __ Cbz(r0, &l[21]);
4607 __ And(r0, r0, r0);
4608 __ Bind(&l[24]);
4609 __ And(r0, r0, r0);
4610 __ Cbz(r0, &l[24]);
4611 __ Cbz(r0, &l[24]);
4612 __ Cbz(r0, &l[19]);
4613 __ Cbz(r0, &l[26]);
4614 __ Cbz(r0, &l[4]);
4615 __ And(r0, r0, r0);
4616 __ Cbz(r0, &l[27]);
4617 __ Cbz(r0, &l[14]);
4618 __ Cbz(r0, &l[5]);
4619 __ Cbz(r0, &l[18]);
4620 __ Cbz(r0, &l[5]);
4621 __ Cbz(r0, &l[6]);
4622 __ Cbz(r0, &l[28]);
4623 __ Cbz(r0, &l[15]);
4624 __ Cbz(r0, &l[0]);
4625 __ Cbz(r0, &l[10]);
4626 __ Cbz(r0, &l[16]);
4627 __ Cbz(r0, &l[30]);
4628 __ Cbz(r0, &l[8]);
4629 __ Cbz(r0, &l[16]);
4630 __ Cbz(r0, &l[22]);
4631 __ Cbz(r0, &l[27]);
4632 __ Cbz(r0, &l[12]);
4633 __ Cbz(r0, &l[0]);
4634 __ Cbz(r0, &l[23]);
4635 __ Cbz(r0, &l[27]);
4636 __ Cbz(r0, &l[16]);
4637 __ Cbz(r0, &l[24]);
4638 __ Cbz(r0, &l[17]);
4639 __ Cbz(r0, &l[4]);
4640 __ Cbz(r0, &l[11]);
4641 __ Cbz(r0, &l[6]);
4642 __ Cbz(r0, &l[23]);
4643 __ Bind(&l[16]);
4644 __ Cbz(r0, &l[10]);
4645 __ Cbz(r0, &l[17]);
4646 __ Cbz(r0, &l[12]);
4647 __ And(r0, r0, r0);
4648 __ Cbz(r0, &l[11]);
4649 __ Cbz(r0, &l[17]);
4650 __ Cbz(r0, &l[1]);
4651 __ Cbz(r0, &l[3]);
4652 __ Cbz(r0, &l[18]);
4653 __ Bind(&l[4]);
4654 __ Cbz(r0, &l[31]);
4655 __ Cbz(r0, &l[25]);
4656 __ Cbz(r0, &l[22]);
4657 __ And(r0, r0, r0);
4658 __ Cbz(r0, &l[19]);
4659 __ Cbz(r0, &l[16]);
4660 __ Cbz(r0, &l[21]);
4661 __ Cbz(r0, &l[27]);
4662 __ Bind(&l[1]);
4663 __ Cbz(r0, &l[9]);
4664 __ Cbz(r0, &l[13]);
4665 __ Cbz(r0, &l[10]);
4666 __ Cbz(r0, &l[6]);
4667 __ Cbz(r0, &l[30]);
4668 __ Cbz(r0, &l[28]);
4669 __ Cbz(r0, &l[7]);
4670 __ Cbz(r0, &l[17]);
4671 __ Bind(&l[0]);
4672 __ Cbz(r0, &l[13]);
4673 __ Cbz(r0, &l[11]);
4674 __ Cbz(r0, &l[19]);
4675 __ Cbz(r0, &l[22]);
4676 __ Cbz(r0, &l[9]);
4677 __ And(r0, r0, r0);
4678 __ Cbz(r0, &l[15]);
4679 __ Cbz(r0, &l[31]);
4680 __ Cbz(r0, &l[2]);
4681 __ And(r0, r0, r0);
4682 __ Cbz(r0, &l[6]);
4683 __ Bind(&l[27]);
4684 __ Bind(&l[13]);
4685 __ Cbz(r0, &l[23]);
4686 __ Cbz(r0, &l[7]);
4687 __ Bind(&l[2]);
4688 __ And(r0, r0, r0);
4689 __ Cbz(r0, &l[1]);
4690 __ Bind(&l[15]);
4691 __ Cbz(r0, &l[13]);
4692 __ Cbz(r0, &l[17]);
4693 __ Cbz(r0, &l[8]);
4694 __ Cbz(r0, &l[30]);
4695 __ Cbz(r0, &l[8]);
4696 __ Cbz(r0, &l[27]);
4697 __ Cbz(r0, &l[2]);
4698 __ Cbz(r0, &l[31]);
4699 __ Cbz(r0, &l[4]);
4700 __ Cbz(r0, &l[11]);
4701 __ Bind(&l[29]);
4702 __ Cbz(r0, &l[7]);
4703 __ Cbz(r0, &l[5]);
4704 __ Cbz(r0, &l[11]);
4705 __ Cbz(r0, &l[24]);
4706 __ Cbz(r0, &l[9]);
4707 __ Cbz(r0, &l[3]);
4708 __ Cbz(r0, &l[3]);
4709 __ Cbz(r0, &l[22]);
4710 __ Cbz(r0, &l[19]);
4711 __ Cbz(r0, &l[4]);
4712 __ Bind(&l[6]);
4713 __ And(r0, r0, r0);
4714 __ And(r0, r0, r0);
4715 __ Cbz(r0, &l[9]);
4716 __ Cbz(r0, &l[3]);
4717 __ Cbz(r0, &l[23]);
4718 __ Cbz(r0, &l[12]);
4719 __ Cbz(r0, &l[1]);
4720 __ Cbz(r0, &l[22]);
4721 __ Cbz(r0, &l[24]);
4722 __ And(r0, r0, r0);
4723 __ Cbz(r0, &l[16]);
4724 __ Cbz(r0, &l[19]);
4725 __ Cbz(r0, &l[20]);
4726 __ Cbz(r0, &l[1]);
4727 __ Cbz(r0, &l[4]);
4728 __ Cbz(r0, &l[1]);
4729 __ Cbz(r0, &l[25]);
4730 __ Cbz(r0, &l[21]);
4731 __ Cbz(r0, &l[20]);
4732 __ Cbz(r0, &l[29]);
4733 __ And(r0, r0, r0);
4734 __ Cbz(r0, &l[10]);
4735 __ Cbz(r0, &l[5]);
4736 __ And(r0, r0, r0);
4737 __ Cbz(r0, &l[25]);
4738 __ Cbz(r0, &l[26]);
4739 __ Cbz(r0, &l[28]);
4740 __ Cbz(r0, &l[19]);
4741 __ And(r0, r0, r0);
4742 __ Bind(&l[17]);
4743 __ And(r0, r0, r0);
4744 __ And(r0, r0, r0);
4745 __ And(r0, r0, r0);
4746 __ And(r0, r0, r0);
4747 __ Cbz(r0, &l[6]);
4748 __ And(r0, r0, r0);
4749 __ Cbz(r0, &l[5]);
4750 __ Cbz(r0, &l[26]);
4751 __ Cbz(r0, &l[28]);
4752 __ Cbz(r0, &l[24]);
4753 __ Bind(&l[20]);
4754 __ And(r0, r0, r0);
4755 __ Cbz(r0, &l[10]);
4756 __ Cbz(r0, &l[19]);
4757 __ Cbz(r0, &l[6]);
4758 __ And(r0, r0, r0);
4759 __ Cbz(r0, &l[13]);
4760 __ Cbz(r0, &l[15]);
4761 __ Cbz(r0, &l[22]);
4762 __ Cbz(r0, &l[8]);
4763 __ Cbz(r0, &l[6]);
4764 __ Cbz(r0, &l[23]);
4765 __ Cbz(r0, &l[6]);
4766 __ And(r0, r0, r0);
4767 __ Cbz(r0, &l[13]);
4768 __ Bind(&l[31]);
4769 __ Cbz(r0, &l[14]);
4770 __ Cbz(r0, &l[5]);
4771 __ Cbz(r0, &l[1]);
4772 __ Cbz(r0, &l[17]);
4773 __ Cbz(r0, &l[27]);
4774 __ Cbz(r0, &l[10]);
4775 __ Cbz(r0, &l[30]);
4776 __ Cbz(r0, &l[14]);
4777 __ Cbz(r0, &l[24]);
4778 __ Cbz(r0, &l[26]);
4779 __ And(r0, r0, r0);
4780 __ Cbz(r0, &l[2]);
4781 __ Cbz(r0, &l[21]);
4782 __ Cbz(r0, &l[5]);
4783 __ Cbz(r0, &l[24]);
4784 __ And(r0, r0, r0);
4785 __ Cbz(r0, &l[24]);
4786 __ Cbz(r0, &l[17]);
4787 __ And(r0, r0, r0);
4788 __ And(r0, r0, r0);
4789 __ Cbz(r0, &l[24]);
4790 __ And(r0, r0, r0);
4791 __ Cbz(r0, &l[17]);
4792 __ Cbz(r0, &l[12]);
4793 __ And(r0, r0, r0);
4794 __ Cbz(r0, &l[9]);
4795 __ Cbz(r0, &l[9]);
4796 __ Cbz(r0, &l[31]);
4797 __ Cbz(r0, &l[25]);
4798 __ And(r0, r0, r0);
4799 __ And(r0, r0, r0);
4800 __ Cbz(r0, &l[13]);
4801 __ Cbz(r0, &l[14]);
4802 __ Cbz(r0, &l[5]);
4803 __ Cbz(r0, &l[5]);
4804 __ Cbz(r0, &l[12]);
4805 __ Cbz(r0, &l[3]);
4806 __ Cbz(r0, &l[25]);
4807 __ Bind(&l[11]);
4808 __ Cbz(r0, &l[15]);
4809 __ Cbz(r0, &l[20]);
4810 __ Cbz(r0, &l[22]);
4811 __ Cbz(r0, &l[19]);
4812 __ And(r0, r0, r0);
4813 __ Cbz(r0, &l[19]);
4814 __ And(r0, r0, r0);
4815 __ Cbz(r0, &l[21]);
4816 __ Cbz(r0, &l[0]);
4817 __ And(r0, r0, r0);
4818 __ Cbz(r0, &l[16]);
4819 __ Cbz(r0, &l[28]);
4820 __ Cbz(r0, &l[18]);
4821 __ Cbz(r0, &l[3]);
4822 __ And(r0, r0, r0);
4823 __ Cbz(r0, &l[15]);
4824 __ Cbz(r0, &l[8]);
4825 __ Cbz(r0, &l[25]);
4826 __ Cbz(r0, &l[1]);
4827 __ Cbz(r0, &l[21]);
4828 __ Cbz(r0, &l[1]);
4829 __ Cbz(r0, &l[29]);
4830 __ Cbz(r0, &l[15]);
4831 __ And(r0, r0, r0);
4832 __ Cbz(r0, &l[24]);
4833 __ Cbz(r0, &l[3]);
4834 __ Cbz(r0, &l[9]);
4835 __ Cbz(r0, &l[9]);
4836 __ Cbz(r0, &l[24]);
4837 __ And(r0, r0, r0);
4838 __ Cbz(r0, &l[19]);
4839 __ And(r0, r0, r0);
4840 __ Cbz(r0, &l[30]);
4841 __ Bind(&l[25]);
4842 __ Bind(&l[3]);
4843 __ Bind(&l[30]);
4844 __ Bind(&l[5]);
4864 __ B(eq, &target_1);
4870 __ Nop();
4873 __ Cbz(r0, &target_2);
4878 __ Nop();
4881 __ Nop();
4883 __ Bind(&target_1);
4884 __ Bind(&target_2);
4901 __ B(eq, &target);
4907 __ Nop();
4910 __ Cbz(r0, &target);
4915 __ Nop();
4918 __ Nop();
4920 __ Bind(&target);
4941 __ Ldrd(r0, r1, 0x1234567890abcdef);
4947 __ Nop();
4955 __ Cbz(r0, &labels[j]);
4956 __ Nop();
4963 __ Nop();
4968 __ Bind(&labels[j]);
4969 __ Nop();
5002 __ Ldrd(r0, r1, 0x1234567890abcdef);
5006 __ Nop();
5011 __ Cbz(r0, &labels[i]);
5012 __ Nop();
5018 __ Nop();
5028 __ Nop();
5032 __ Bind(&labels[j]);
5033 __ Nop();
5062 __ Movs(r0, 0);
5065 __ B(ne, &labels[i]);
5069 __ Ldrd(r0, r1, 0x1234567890abcdef);
5072 __ Nop();
5076 __ Bind(&labels[i]);
5100 __ Movs(r0, 0);
5101 __ B(ne, &end);
5109 __ Ldr(r11, literal);
5122 __ nop();
5126 __ Cbz(r1, &end);
5131 __ nop();
5137 __ add(r1, r1, 3);
5139 __ Bind(&end);
5168 __ Adr(r11, &big_literal);
5176 __ nop();
5180 __ Cbz(r1, &labels[test_num]);
5184 __ add(r1, r1, 3);
5186 __ Bind(&labels[test_num]);
5189 __ EmitLiteralPool(PoolManager<int32_t>::kBranchRequired);
5206 __ Ldrd(r0, r1, 0x1111111111111111);
5207 __ Ldrd(r2, r3, 0x2222222222222222);
5208 __ Ldrd(r4, r5, 0x3333333333333333);
5209 __ Ldrd(r6, r7, 0x4444444444444444);
5210 __ Ldrd(r8, r9, 0x5555555555555555);
5211 __ Ldrd(r10, r11, 0x6666666666666666);
5212 __ Ldrd(r10, r11, 0x1234567890abcdef);
5220 __ nop();
5224 __ Cbz(r2, &t1);
5225 __ Cbz(r2, &t2);
5226 __ Cbz(r2, &t3);
5227 __ Cbz(r2, &t4);
5228 __ Cbz(r2, &t5);
5244 __ nop();
5252 __ Bind(&t1);
5253 __ Bind(&t2);
5254 __ Bind(&t3);
5255 __ Bind(&t4);
5256 __ Bind(&t5);
5289 __ Ldrd(r0, r1, literal);
5296 __ nop();
5303 __ Ldrd(r2, r3, literal);
5331 __ Ldrd(r0, r1, &l0);
5344 __ nop();
5352 __ Add(ne, r8, r9, 256);
5375 __ Mov(r0, reinterpret_cast<uintptr_t>(src));
5376 __ Ldm(r0, NO_WRITE_BACK, RegisterList(r1, r2, r3, r4));
5377 __ Ldm(r0, NO_WRITE_BACK, RegisterList(r5, r6, r9, r11));
5379 __ Mov(r0, reinterpret_cast<uintptr_t>(dst1));
5380 __ Stm(r0, NO_WRITE_BACK, RegisterList(r1, r2, r3, r4));
5382 __ Mov(r0, reinterpret_cast<uintptr_t>(dst2));
5383 __ Stm(r0, NO_WRITE_BACK, RegisterList(r5, r6, r9, r11));
5426 __ Mov(r0, reinterpret_cast<uintptr_t>(src));
5427 __ Ldm(r0, WRITE_BACK, RegisterList(r2, r3));
5428 __ Ldm(r0, WRITE_BACK, RegisterList(r4, r5));
5430 __ Mov(r1, reinterpret_cast<uintptr_t>(dst));
5431 __ Stm(r1, WRITE_BACK, RegisterList(r2, r3, r4, r5));
5432 __ Stm(r1, WRITE_BACK, RegisterList(r2, r3, r4, r5));
5468 __ Mov(r11, reinterpret_cast<uintptr_t>(src1 + 3));
5469 __ Ldmda(r11, WRITE_BACK, RegisterList(r0, r1));
5470 __ Ldmda(r11, NO_WRITE_BACK, RegisterList(r2, r3));
5472 __ Mov(r10, reinterpret_cast<uintptr_t>(src2) - sizeof(src2[0]));
5473 __ Ldmib(r10, WRITE_BACK, RegisterList(r4, r5));
5474 __ Ldmib(r10, NO_WRITE_BACK, RegisterList(r6, r7));
5476 __ Mov(r9, reinterpret_cast<uintptr_t>(dst1 + 3));
5477 __ Stmda(r9, WRITE_BACK, RegisterList(r0, r1));
5478 __ Stmda(r9, NO_WRITE_BACK, RegisterList(r2, r3));
5480 __ Mov(r8, reinterpret_cast<uintptr_t>(dst2) - sizeof(dst2[0]));
5481 __ Stmib(r8, WRITE_BACK, RegisterList(r4, r5));
5482 __ Stmib(r8, NO_WRITE_BACK, RegisterList(r6, r7));
5527 __ Mov(r11, reinterpret_cast<uintptr_t>(src + 6));
5528 __ Ldmdb(r11, WRITE_BACK, RegisterList(r1, r2));
5529 __ Ldmdb(r11, WRITE_BACK, RegisterList(r3, r4));
5530 __ Ldmdb(r11, NO_WRITE_BACK, RegisterList(r5, r6));
5532 __ Mov(r10, reinterpret_cast<uintptr_t>(dst + 6));
5533 __ Stmdb(r10, WRITE_BACK, RegisterList(r5, r6));
5534 __ Stmdb(r10, WRITE_BACK, RegisterList(r3, r4));
5535 __ Stmdb(r10, NO_WRITE_BACK, RegisterList(r1, r2));
5574 __ B(&test_start);
5576 __ Bind(&func1);
5577 __ Mov(r0, 0x11111111);
5578 __ Push(lr);
5590 __ adr(r11, &func2);
5594 __ orr(r11, r11, 1);
5596 __ blx(r11);
5597 __ pop(lr);
5598 __ bx(lr);
5600 __ bind(&func2);
5601 __ movw(r1, 0x2222);
5602 __ movt(r1, 0x2222);
5603 __ bx(lr);
5606 __ Bind(&test_start);
5607 __ Mov(r0, 0xdeadc0de);
5608 __ Mov(r1, 0xdeadc0de);
5609 __ Bl(&func1);
5628 __ Bind(&start);
5629 __ Nop();
5636 __ B(&start, kNear);
5644 __ nop();
5652 __ B(&start, kNear);
5659 __ B(&end, kNear);
5671 __ nop();
5679 __ Bind(&end);
5695 __ Bind(&start);
5696 __ Nop();
5703 __ B(&start, kFar);
5711 __ nop();
5719 __ B(&start, kFar);
5726 __ B(&end, kFar);
5729 __ Bind(&end);
5744 __ Bind(&start);
5745 __ Nop();
5751 __ B(eq, &start, kNear);
5759 __ nop();
5767 __ B(eq, &start, kNear);
5774 __ B(eq, &end, kNear);
5786 __ nop();
5794 __ Bind(&end);
5810 __ Bind(&start);
5811 __ Nop();
5818 __ B(eq, &start, kFar);
5826 __ nop();
5834 __ B(eq, &start, kFar);
5841 __ B(eq, &end, kFar);
5844 __ Bind(&end);
5862 __ Mov(r0, 0);
5865 __ B(&labels[i], kNear);
5868 __ Mov(r0, 1);
5870 __ Bind(&labels[i]);
5872 __ Nop();
5893 __ Mov(r0, 0);
5896 __ B(&b_labels[i], kNear);
5897 __ Cbz(r0, &cbz_labels[i]);
5900 __ Mov(r0, 1);
5902 __ Bind(&b_labels[i]);
5905 __ Mov(r0, 2);
5907 __ Bind(&cbz_labels[i]);
5910 __ Nop();
6136 __ Ldrd(r0, r1, 0x1234567890abcdef);
6145 __ b(&over_literal);
6155 __ nop();
6160 __ Place(&l0);
6164 __ Bind(&over_literal);
6166 __ Ldrd(r2, r3, &l0);
6191 __ nop();
6196 __ Ldrd(r0, r1, 0x1234567890abcdef);
6206 __ nop();
6211 __ Cbz(r0, &label);
6218 __ Bind(&label);
6299 __ Ldrd(r0, r1, &big_literal);
6305 __ Bind(&b_labels[i]);
6333 __ Ldr(r2, &big_literal);
6340 __ Ldrd(r0, r1, &big_literal2);
6345 __ Bind(&b_labels[i]);
6370 __ Ldrd(r2, r3, 0x12345678);
6376 __ Bind(&b_labels[i]);
6402 __ Ldrd(r0, r1, &big_literal);
6407 __ Bind(&b_labels[i]);
6429 __ Ldrd(r2, r3, 0x12345678);
6434 __ Bind(&b_labels[i]);
6447 __ B(eq, &label, kNear);
6455 __ bind(&label);
6487 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6499 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6514 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \
6529 masm.GetCursorOffset() + __ GetArchitectureStatePCOffset(); \