Revision db8d9902

b/dyngen-exec.h
198 198
#error unsupported CPU
199 199
#endif
200 200

  
201
/* force GCC to generate only one epilog at the end of the function */
202
#define FORCE_RET() __asm__ __volatile__("" : : : "memory");
203

  
204 201
#define xglue(x, y) x ## y
205 202
#define glue(x, y) xglue(x, y)
206 203
#define stringify(s)	tostring(s)
b/target-arm/op_helper.c
509 509
    rm = ((T1 & 0xff00ff00) >> 8) | (T0 & 0xff00ff00);
510 510
    T0 = rd;
511 511
    T1 = rm;
512
    FORCE_RET();
513 512
}
514 513

  
515 514
void HELPER(neon_trn_u16)(void)
......
520 519
    rm = (T1 >> 16) | (T0 & 0xffff0000);
521 520
    T0 = rd;
522 521
    T1 = rm;
523
    FORCE_RET();
524 522
}
525 523

  
526 524
/* Worker routines for zip and unzip.  */
......
534 532
         | ((T1 << 8) & 0xff0000) | (T1 & 0xff000000);
535 533
    T0 = rd;
536 534
    T1 = rm;
537
    FORCE_RET();
538 535
}
539 536

  
540 537
void HELPER(neon_zip_u8)(void)
......
547 544
         | ((T0 >> 8) & 0xff0000) | (T1 & 0xff000000);
548 545
    T0 = rd;
549 546
    T1 = rm;
550
    FORCE_RET();
551 547
}
552 548

  
553 549
void HELPER(neon_zip_u16)(void)
......
557 553
    tmp = (T0 & 0xffff) | (T1 << 16);
558 554
    T1 = (T1 & 0xffff0000) | (T0 >> 16);
559 555
    T0 = tmp;
560
    FORCE_RET();
561 556
}
b/target-cris/exec.h
25 25
#include "cpu.h"
26 26
#include "exec-all.h"
27 27

  
28
#define RETURN() __asm__ __volatile__("" : : : "memory");
29

  
30 28
static inline void env_to_regs(void)
31 29
{
32 30
}
b/target-cris/op_helper.c
189 189
	}
190 190
#endif
191 191
	env->regs[reg] = env->sregs[srs][sreg];
192
	RETURN();
193 192
}
194 193

  
195 194
static void cris_ccs_rshift(CPUState *env)
b/target-i386/op_helper.c
1745 1745
    }
1746 1746
    EAX = (EAX & ~0xffff) | al | (ah << 8);
1747 1747
    CC_SRC = eflags;
1748
    FORCE_RET();
1749 1748
}
1750 1749

  
1751 1750
void helper_aas(void)
......
1770 1769
    }
1771 1770
    EAX = (EAX & ~0xffff) | al | (ah << 8);
1772 1771
    CC_SRC = eflags;
1773
    FORCE_RET();
1774 1772
}
1775 1773

  
1776 1774
void helper_daa(void)
......
1798 1796
    eflags |= parity_table[al]; /* pf */
1799 1797
    eflags |= (al & 0x80); /* sf */
1800 1798
    CC_SRC = eflags;
1801
    FORCE_RET();
1802 1799
}
1803 1800

  
1804 1801
void helper_das(void)
......
1829 1826
    eflags |= parity_table[al]; /* pf */
1830 1827
    eflags |= (al & 0x80); /* sf */
1831 1828
    CC_SRC = eflags;
1832
    FORCE_RET();
1833 1829
}
1834 1830

  
1835 1831
void helper_into(int next_eip_addend)
......
3553 3549

  
3554 3550
    ret = floatx_compare(ST0, FT0, &env->fp_status);
3555 3551
    env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret + 1];
3556
    FORCE_RET();
3557 3552
}
3558 3553

  
3559 3554
void helper_fucom_ST0_FT0(void)
......
3562 3557

  
3563 3558
    ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3564 3559
    env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret+ 1];
3565
    FORCE_RET();
3566 3560
}
3567 3561

  
3568 3562
static const int fcomi_ccval[4] = {CC_C, CC_Z, 0, CC_Z | CC_P | CC_C};
......
3576 3570
    eflags = helper_cc_compute_all(CC_OP);
3577 3571
    eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3578 3572
    CC_SRC = eflags;
3579
    FORCE_RET();
3580 3573
}
3581 3574

  
3582 3575
void helper_fucomi_ST0_FT0(void)
......
3588 3581
    eflags = helper_cc_compute_all(CC_OP);
3589 3582
    eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3590 3583
    CC_SRC = eflags;
3591
    FORCE_RET();
3592 3584
}
3593 3585

  
3594 3586
void helper_fadd_ST0_FT0(void)
......
3773 3765
{
3774 3766
    if (env->fpus & FPUS_SE)
3775 3767
        fpu_raise_exception();
3776
    FORCE_RET();
3777 3768
}
3778 3769

  
3779 3770
void helper_fninit(void)
......
4629 4620
    if (v < low || v > high) {
4630 4621
        raise_exception(EXCP05_BOUND);
4631 4622
    }
4632
    FORCE_RET();
4633 4623
}
4634 4624

  
4635 4625
void helper_boundl(target_ulong a0, int v)
......
4640 4630
    if (v < low || v > high) {
4641 4631
        raise_exception(EXCP05_BOUND);
4642 4632
    }
4643
    FORCE_RET();
4644 4633
}
4645 4634

  
4646 4635
static float approx_rsqrt(float a)
b/target-i386/ops_sse.h
58 58
        d->W(7) >>= shift;
59 59
#endif
60 60
    }
61
    FORCE_RET();
62 61
}
63 62

  
64 63
void glue(helper_psraw, SUFFIX)(Reg *d, Reg *s)
......
104 103
        d->W(7) <<= shift;
105 104
#endif
106 105
    }
107
    FORCE_RET();
108 106
}
109 107

  
110 108
void glue(helper_psrld, SUFFIX)(Reg *d, Reg *s)
......
125 123
        d->L(3) >>= shift;
126 124
#endif
127 125
    }
128
    FORCE_RET();
129 126
}
130 127

  
131 128
void glue(helper_psrad, SUFFIX)(Reg *d, Reg *s)
......
163 160
        d->L(3) <<= shift;
164 161
#endif
165 162
    }
166
    FORCE_RET();
167 163
}
168 164

  
169 165
void glue(helper_psrlq, SUFFIX)(Reg *d, Reg *s)
......
182 178
        d->Q(1) >>= shift;
183 179
#endif
184 180
    }
185
    FORCE_RET();
186 181
}
187 182

  
188 183
void glue(helper_psllq, SUFFIX)(Reg *d, Reg *s)
......
201 196
        d->Q(1) <<= shift;
202 197
#endif
203 198
    }
204
    FORCE_RET();
205 199
}
206 200

  
207 201
#if SHIFT == 1
......
216 210
        d->B(i) = d->B(i + shift);
217 211
    for(i = 16 - shift; i < 16; i++)
218 212
        d->B(i) = 0;
219
    FORCE_RET();
220 213
}
221 214

  
222 215
void glue(helper_pslldq, SUFFIX)(Reg *d, Reg *s)
......
230 223
        d->B(i) = d->B(i - shift);
231 224
    for(i = 0; i < shift; i++)
232 225
        d->B(i) = 0;
233
    FORCE_RET();
234 226
}
235 227
#endif
236 228

  
......
432 424
        d->L(i) = (int16_t)s->W(2*i) * (int16_t)d->W(2*i) +
433 425
            (int16_t)s->W(2*i+1) * (int16_t)d->W(2*i+1);
434 426
    }
435
    FORCE_RET();
436 427
}
437 428

  
438 429
#if SHIFT == 0
......
479 470
        if (s->B(i) & 0x80)
480 471
            stb(a0 + i, d->B(i));
481 472
    }
482
    FORCE_RET();
483 473
}
484 474

  
485 475
void glue(helper_movl_mm_T0, SUFFIX) (Reg *d, uint32_t val)
......
917 907
    s1 = s->XMM_S(0);
918 908
    ret = float32_compare_quiet(s0, s1, &env->sse_status);
919 909
    CC_SRC = comis_eflags[ret + 1];
920
    FORCE_RET();
921 910
}
922 911

  
923 912
void helper_comiss(Reg *d, Reg *s)
......
929 918
    s1 = s->XMM_S(0);
930 919
    ret = float32_compare(s0, s1, &env->sse_status);
931 920
    CC_SRC = comis_eflags[ret + 1];
932
    FORCE_RET();
933 921
}
934 922

  
935 923
void helper_ucomisd(Reg *d, Reg *s)
......
941 929
    d1 = s->XMM_D(0);
942 930
    ret = float64_compare_quiet(d0, d1, &env->sse_status);
943 931
    CC_SRC = comis_eflags[ret + 1];
944
    FORCE_RET();
945 932
}
946 933

  
947 934
void helper_comisd(Reg *d, Reg *s)
......
953 940
    d1 = s->XMM_D(0);
954 941
    ret = float64_compare(d0, d1, &env->sse_status);
955 942
    CC_SRC = comis_eflags[ret + 1];
956
    FORCE_RET();
957 943
}
958 944

  
959 945
uint32_t helper_movmskps(Reg *s)
b/target-sh4/exec.h
43 43
#include "softmmu_exec.h"
44 44
#endif
45 45

  
46
#define RETURN() __asm__ __volatile__("")
47

  
48 46
static inline void regs_to_env(void)
49 47
{
50 48
    /* XXXXX */

Also available in: Unified diff