Revision ab1103de
| b/target-alpha/translate.c | ||
|---|---|---|
| 3410 | 3410 |
if (lj < j) {
|
| 3411 | 3411 |
lj++; |
| 3412 | 3412 |
while (lj < j) |
| 3413 |
gen_opc_instr_start[lj++] = 0; |
|
| 3413 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3414 | 3414 |
} |
| 3415 | 3415 |
tcg_ctx.gen_opc_pc[lj] = ctx.pc; |
| 3416 |
gen_opc_instr_start[lj] = 1; |
|
| 3416 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 3417 | 3417 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 3418 | 3418 |
} |
| 3419 | 3419 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) |
| ... | ... | |
| 3468 | 3468 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 3469 | 3469 |
lj++; |
| 3470 | 3470 |
while (lj <= j) |
| 3471 |
gen_opc_instr_start[lj++] = 0; |
|
| 3471 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3472 | 3472 |
} else {
|
| 3473 | 3473 |
tb->size = ctx.pc - pc_start; |
| 3474 | 3474 |
tb->icount = num_insns; |
| b/target-arm/translate.c | ||
|---|---|---|
| 9838 | 9838 |
if (lj < j) {
|
| 9839 | 9839 |
lj++; |
| 9840 | 9840 |
while (lj < j) |
| 9841 |
gen_opc_instr_start[lj++] = 0; |
|
| 9841 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 9842 | 9842 |
} |
| 9843 | 9843 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 9844 | 9844 |
gen_opc_condexec_bits[lj] = (dc->condexec_cond << 4) | (dc->condexec_mask >> 1); |
| 9845 |
gen_opc_instr_start[lj] = 1; |
|
| 9845 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 9846 | 9846 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 9847 | 9847 |
} |
| 9848 | 9848 |
|
| ... | ... | |
| 9977 | 9977 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 9978 | 9978 |
lj++; |
| 9979 | 9979 |
while (lj <= j) |
| 9980 |
gen_opc_instr_start[lj++] = 0; |
|
| 9980 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 9981 | 9981 |
} else {
|
| 9982 | 9982 |
tb->size = dc->pc - pc_start; |
| 9983 | 9983 |
tb->icount = num_insns; |
| b/target-cris/translate.c | ||
|---|---|---|
| 3301 | 3301 |
if (lj < j) {
|
| 3302 | 3302 |
lj++; |
| 3303 | 3303 |
while (lj < j) {
|
| 3304 |
gen_opc_instr_start[lj++] = 0; |
|
| 3304 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3305 | 3305 |
} |
| 3306 | 3306 |
} |
| 3307 | 3307 |
if (dc->delayed_branch == 1) {
|
| ... | ... | |
| 3309 | 3309 |
} else {
|
| 3310 | 3310 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 3311 | 3311 |
} |
| 3312 |
gen_opc_instr_start[lj] = 1; |
|
| 3312 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 3313 | 3313 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 3314 | 3314 |
} |
| 3315 | 3315 |
|
| ... | ... | |
| 3439 | 3439 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 3440 | 3440 |
lj++; |
| 3441 | 3441 |
while (lj <= j) {
|
| 3442 |
gen_opc_instr_start[lj++] = 0; |
|
| 3442 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3443 | 3443 |
} |
| 3444 | 3444 |
} else {
|
| 3445 | 3445 |
tb->size = dc->pc - pc_start; |
| b/target-i386/translate.c | ||
|---|---|---|
| 7988 | 7988 |
if (lj < j) {
|
| 7989 | 7989 |
lj++; |
| 7990 | 7990 |
while (lj < j) |
| 7991 |
gen_opc_instr_start[lj++] = 0; |
|
| 7991 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 7992 | 7992 |
} |
| 7993 | 7993 |
tcg_ctx.gen_opc_pc[lj] = pc_ptr; |
| 7994 | 7994 |
gen_opc_cc_op[lj] = dc->cc_op; |
| 7995 |
gen_opc_instr_start[lj] = 1; |
|
| 7995 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 7996 | 7996 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 7997 | 7997 |
} |
| 7998 | 7998 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) |
| ... | ... | |
| 8037 | 8037 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 8038 | 8038 |
lj++; |
| 8039 | 8039 |
while (lj <= j) |
| 8040 |
gen_opc_instr_start[lj++] = 0; |
|
| 8040 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 8041 | 8041 |
} |
| 8042 | 8042 |
|
| 8043 | 8043 |
#ifdef DEBUG_DISAS |
| ... | ... | |
| 8080 | 8080 |
int i; |
| 8081 | 8081 |
qemu_log("RESTORE:\n");
|
| 8082 | 8082 |
for(i = 0;i <= pc_pos; i++) {
|
| 8083 |
if (gen_opc_instr_start[i]) {
|
|
| 8083 |
if (tcg_ctx.gen_opc_instr_start[i]) {
|
|
| 8084 | 8084 |
qemu_log("0x%04x: " TARGET_FMT_lx "\n", i,
|
| 8085 | 8085 |
tcg_ctx.gen_opc_pc[i]); |
| 8086 | 8086 |
} |
| b/target-lm32/translate.c | ||
|---|---|---|
| 1051 | 1051 |
if (lj < j) {
|
| 1052 | 1052 |
lj++; |
| 1053 | 1053 |
while (lj < j) {
|
| 1054 |
gen_opc_instr_start[lj++] = 0; |
|
| 1054 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 1055 | 1055 |
} |
| 1056 | 1056 |
} |
| 1057 | 1057 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 1058 |
gen_opc_instr_start[lj] = 1; |
|
| 1058 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 1059 | 1059 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 1060 | 1060 |
} |
| 1061 | 1061 |
|
| ... | ... | |
| 1110 | 1110 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 1111 | 1111 |
lj++; |
| 1112 | 1112 |
while (lj <= j) {
|
| 1113 |
gen_opc_instr_start[lj++] = 0; |
|
| 1113 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 1114 | 1114 |
} |
| 1115 | 1115 |
} else {
|
| 1116 | 1116 |
tb->size = dc->pc - pc_start; |
| b/target-m68k/translate.c | ||
|---|---|---|
| 3019 | 3019 |
if (lj < j) {
|
| 3020 | 3020 |
lj++; |
| 3021 | 3021 |
while (lj < j) |
| 3022 |
gen_opc_instr_start[lj++] = 0; |
|
| 3022 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3023 | 3023 |
} |
| 3024 | 3024 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 3025 |
gen_opc_instr_start[lj] = 1; |
|
| 3025 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 3026 | 3026 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 3027 | 3027 |
} |
| 3028 | 3028 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) |
| ... | ... | |
| 3078 | 3078 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 3079 | 3079 |
lj++; |
| 3080 | 3080 |
while (lj <= j) |
| 3081 |
gen_opc_instr_start[lj++] = 0; |
|
| 3081 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 3082 | 3082 |
} else {
|
| 3083 | 3083 |
tb->size = dc->pc - pc_start; |
| 3084 | 3084 |
tb->icount = num_insns; |
| b/target-microblaze/translate.c | ||
|---|---|---|
| 1788 | 1788 |
if (lj < j) {
|
| 1789 | 1789 |
lj++; |
| 1790 | 1790 |
while (lj < j) |
| 1791 |
gen_opc_instr_start[lj++] = 0; |
|
| 1791 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 1792 | 1792 |
} |
| 1793 | 1793 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 1794 |
gen_opc_instr_start[lj] = 1; |
|
| 1794 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 1795 | 1795 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 1796 | 1796 |
} |
| 1797 | 1797 |
|
| ... | ... | |
| 1902 | 1902 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 1903 | 1903 |
lj++; |
| 1904 | 1904 |
while (lj <= j) |
| 1905 |
gen_opc_instr_start[lj++] = 0; |
|
| 1905 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 1906 | 1906 |
} else {
|
| 1907 | 1907 |
tb->size = dc->pc - pc_start; |
| 1908 | 1908 |
tb->icount = num_insns; |
| b/target-mips/translate.c | ||
|---|---|---|
| 15579 | 15579 |
if (lj < j) {
|
| 15580 | 15580 |
lj++; |
| 15581 | 15581 |
while (lj < j) |
| 15582 |
gen_opc_instr_start[lj++] = 0; |
|
| 15582 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 15583 | 15583 |
} |
| 15584 | 15584 |
tcg_ctx.gen_opc_pc[lj] = ctx.pc; |
| 15585 | 15585 |
gen_opc_hflags[lj] = ctx.hflags & MIPS_HFLAG_BMASK; |
| 15586 | 15586 |
gen_opc_btarget[lj] = ctx.btarget; |
| 15587 |
gen_opc_instr_start[lj] = 1; |
|
| 15587 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 15588 | 15588 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 15589 | 15589 |
} |
| 15590 | 15590 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) |
| ... | ... | |
| 15662 | 15662 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 15663 | 15663 |
lj++; |
| 15664 | 15664 |
while (lj <= j) |
| 15665 |
gen_opc_instr_start[lj++] = 0; |
|
| 15665 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 15666 | 15666 |
} else {
|
| 15667 | 15667 |
tb->size = ctx.pc - pc_start; |
| 15668 | 15668 |
tb->icount = num_insns; |
| b/target-openrisc/translate.c | ||
|---|---|---|
| 1707 | 1707 |
if (k < j) {
|
| 1708 | 1708 |
k++; |
| 1709 | 1709 |
while (k < j) {
|
| 1710 |
gen_opc_instr_start[k++] = 0; |
|
| 1710 |
tcg_ctx.gen_opc_instr_start[k++] = 0;
|
|
| 1711 | 1711 |
} |
| 1712 | 1712 |
} |
| 1713 | 1713 |
tcg_ctx.gen_opc_pc[k] = dc->pc; |
| 1714 |
gen_opc_instr_start[k] = 1; |
|
| 1714 |
tcg_ctx.gen_opc_instr_start[k] = 1;
|
|
| 1715 | 1715 |
tcg_ctx.gen_opc_icount[k] = num_insns; |
| 1716 | 1716 |
} |
| 1717 | 1717 |
|
| ... | ... | |
| 1787 | 1787 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 1788 | 1788 |
k++; |
| 1789 | 1789 |
while (k <= j) {
|
| 1790 |
gen_opc_instr_start[k++] = 0; |
|
| 1790 |
tcg_ctx.gen_opc_instr_start[k++] = 0;
|
|
| 1791 | 1791 |
} |
| 1792 | 1792 |
} else {
|
| 1793 | 1793 |
tb->size = dc->pc - pc_start; |
| b/target-ppc/translate.c | ||
|---|---|---|
| 9680 | 9680 |
if (lj < j) {
|
| 9681 | 9681 |
lj++; |
| 9682 | 9682 |
while (lj < j) |
| 9683 |
gen_opc_instr_start[lj++] = 0; |
|
| 9683 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 9684 | 9684 |
} |
| 9685 | 9685 |
tcg_ctx.gen_opc_pc[lj] = ctx.nip; |
| 9686 |
gen_opc_instr_start[lj] = 1; |
|
| 9686 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 9687 | 9687 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 9688 | 9688 |
} |
| 9689 | 9689 |
LOG_DISAS("----------------\n");
|
| ... | ... | |
| 9781 | 9781 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 9782 | 9782 |
lj++; |
| 9783 | 9783 |
while (lj <= j) |
| 9784 |
gen_opc_instr_start[lj++] = 0; |
|
| 9784 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 9785 | 9785 |
} else {
|
| 9786 | 9786 |
tb->size = ctx.nip - pc_start; |
| 9787 | 9787 |
tb->icount = num_insns; |
| b/target-s390x/translate.c | ||
|---|---|---|
| 5160 | 5160 |
if (lj < j) {
|
| 5161 | 5161 |
lj++; |
| 5162 | 5162 |
while (lj < j) {
|
| 5163 |
gen_opc_instr_start[lj++] = 0; |
|
| 5163 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 5164 | 5164 |
} |
| 5165 | 5165 |
} |
| 5166 | 5166 |
tcg_ctx.gen_opc_pc[lj] = dc.pc; |
| 5167 | 5167 |
gen_opc_cc_op[lj] = dc.cc_op; |
| 5168 |
gen_opc_instr_start[lj] = 1; |
|
| 5168 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 5169 | 5169 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 5170 | 5170 |
} |
| 5171 | 5171 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) {
|
| ... | ... | |
| 5212 | 5212 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 5213 | 5213 |
lj++; |
| 5214 | 5214 |
while (lj <= j) {
|
| 5215 |
gen_opc_instr_start[lj++] = 0; |
|
| 5215 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 5216 | 5216 |
} |
| 5217 | 5217 |
} else {
|
| 5218 | 5218 |
tb->size = dc.pc - pc_start; |
| b/target-sh4/translate.c | ||
|---|---|---|
| 2003 | 2003 |
if (ii < i) {
|
| 2004 | 2004 |
ii++; |
| 2005 | 2005 |
while (ii < i) |
| 2006 |
gen_opc_instr_start[ii++] = 0; |
|
| 2006 |
tcg_ctx.gen_opc_instr_start[ii++] = 0;
|
|
| 2007 | 2007 |
} |
| 2008 | 2008 |
tcg_ctx.gen_opc_pc[ii] = ctx.pc; |
| 2009 | 2009 |
gen_opc_hflags[ii] = ctx.flags; |
| 2010 |
gen_opc_instr_start[ii] = 1; |
|
| 2010 |
tcg_ctx.gen_opc_instr_start[ii] = 1;
|
|
| 2011 | 2011 |
tcg_ctx.gen_opc_icount[ii] = num_insns; |
| 2012 | 2012 |
} |
| 2013 | 2013 |
if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO)) |
| ... | ... | |
| 2061 | 2061 |
i = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 2062 | 2062 |
ii++; |
| 2063 | 2063 |
while (ii <= i) |
| 2064 |
gen_opc_instr_start[ii++] = 0; |
|
| 2064 |
tcg_ctx.gen_opc_instr_start[ii++] = 0;
|
|
| 2065 | 2065 |
} else {
|
| 2066 | 2066 |
tb->size = ctx.pc - pc_start; |
| 2067 | 2067 |
tb->icount = num_insns; |
| b/target-sparc/translate.c | ||
|---|---|---|
| 5283 | 5283 |
if (lj < j) {
|
| 5284 | 5284 |
lj++; |
| 5285 | 5285 |
while (lj < j) |
| 5286 |
gen_opc_instr_start[lj++] = 0; |
|
| 5286 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 5287 | 5287 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 5288 | 5288 |
gen_opc_npc[lj] = dc->npc; |
| 5289 |
gen_opc_instr_start[lj] = 1; |
|
| 5289 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 5290 | 5290 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 5291 | 5291 |
} |
| 5292 | 5292 |
} |
| ... | ... | |
| 5339 | 5339 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 5340 | 5340 |
lj++; |
| 5341 | 5341 |
while (lj <= j) |
| 5342 |
gen_opc_instr_start[lj++] = 0; |
|
| 5342 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 5343 | 5343 |
#if 0 |
| 5344 | 5344 |
log_page_dump(); |
| 5345 | 5345 |
#endif |
| b/target-unicore32/translate.c | ||
|---|---|---|
| 2003 | 2003 |
if (lj < j) {
|
| 2004 | 2004 |
lj++; |
| 2005 | 2005 |
while (lj < j) {
|
| 2006 |
gen_opc_instr_start[lj++] = 0; |
|
| 2006 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 2007 | 2007 |
} |
| 2008 | 2008 |
} |
| 2009 | 2009 |
tcg_ctx.gen_opc_pc[lj] = dc->pc; |
| 2010 |
gen_opc_instr_start[lj] = 1; |
|
| 2010 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 2011 | 2011 |
tcg_ctx.gen_opc_icount[lj] = num_insns; |
| 2012 | 2012 |
} |
| 2013 | 2013 |
|
| ... | ... | |
| 2117 | 2117 |
j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf; |
| 2118 | 2118 |
lj++; |
| 2119 | 2119 |
while (lj <= j) {
|
| 2120 |
gen_opc_instr_start[lj++] = 0; |
|
| 2120 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 2121 | 2121 |
} |
| 2122 | 2122 |
} else {
|
| 2123 | 2123 |
tb->size = dc->pc - pc_start; |
| b/target-xtensa/translate.c | ||
|---|---|---|
| 2897 | 2897 |
if (lj < j) {
|
| 2898 | 2898 |
lj++; |
| 2899 | 2899 |
while (lj < j) {
|
| 2900 |
gen_opc_instr_start[lj++] = 0; |
|
| 2900 |
tcg_ctx.gen_opc_instr_start[lj++] = 0;
|
|
| 2901 | 2901 |
} |
| 2902 | 2902 |
} |
| 2903 | 2903 |
tcg_ctx.gen_opc_pc[lj] = dc.pc; |
| 2904 |
gen_opc_instr_start[lj] = 1; |
|
| 2904 |
tcg_ctx.gen_opc_instr_start[lj] = 1;
|
|
| 2905 | 2905 |
tcg_ctx.gen_opc_icount[lj] = insn_count; |
| 2906 | 2906 |
} |
| 2907 | 2907 |
|
| b/translate-all.c | ||
|---|---|---|
| 146 | 146 |
if (j < 0) |
| 147 | 147 |
return -1; |
| 148 | 148 |
/* now find start of instruction before */ |
| 149 |
while (gen_opc_instr_start[j] == 0)
|
|
| 149 |
while (s->gen_opc_instr_start[j] == 0) {
|
|
| 150 | 150 |
j--; |
| 151 |
} |
|
| 151 | 152 |
env->icount_decr.u16.low -= s->gen_opc_icount[j]; |
| 152 | 153 |
|
| 153 | 154 |
restore_state_to_opc(env, tb, j); |
Also available in: Unified diff