suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix various compiler warnings

Browse Source 
Resort to gcc annotations in some cases, but avoid disabling whole
classes of warnings.
This commit is contained in:
Matthew Flatt 2013-04-09 09:45:50 -06:00 committed by Matthew Flatt
parent b721565488
commit 97fdd976f3
16 changed files with 270 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
src/racket/gc2/newgc.c
View File

@ -343,7 +343,6 @@ inline static size_t round_to_apage_size(size_t sizeb) {
return sizeb;
}
inline static void check_used_against_max(NewGC *gc, size_t len)
{
intptr_t page_count;
@ -1657,7 +1656,8 @@ intptr_t GC_message_objects_size(void *param) {
MsgMemory *msgm = (MsgMemory *) param;
if (!msgm) { return sizeof(param); }
if (msgm->big_pages && msgm->size < 1024) {
printf("Error: message allocators with big pages should be bigger than %lu!\n", msgm->size);
printf("Error: message allocators with big pages should be bigger than %" PRIdPTR "u!\n",
msgm->size);
exit(1);
}
return msgm->size;
@ -2612,7 +2612,7 @@ static void master_collect_initiate(NewGC *gc) {
}
}
if (count != (MASTERGCINFO->alive -1)) {
printf("GC2 count != MASTERGCINFO->alive %i %li\n", count, MASTERGCINFO->alive);
printf("GC2 count != MASTERGCINFO->alive %i %" PRIdPTR "i\n", count, MASTERGCINFO->alive);
abort();
}
#if defined(GC_DEBUG_PAGES)
@ -3654,12 +3654,14 @@ void GC_dump_with_traces(int flags,
sprintf(buf, "unknown,%d", i);
tn = buf;
}
GCPRINT(GCOUTF, " %20.20s: %10ld %10ld\n", tn, counts[i], gcWORDS_TO_BYTES(sizes[i]));
GCPRINT(GCOUTF, " %20.20s: %10" PRIdPTR "d %10" PRIdPTR "d\n",
tn, counts[i], gcWORDS_TO_BYTES(sizes[i]));
}
}
GCPRINT(GCOUTF, "End Racket3m\n");
GCWARN((GCOUTF, "Generation 0: %lu of %li bytes used\n", (uintptr_t) gen0_size_in_use(gc), gc->gen0.max_size));
GCWARN((GCOUTF, "Generation 0: %" PRIdPTR "u of %" PRIdPTR "i bytes used\n",
(uintptr_t) gen0_size_in_use(gc), gc->gen0.max_size));
for(i = 0; i < PAGE_TYPES; i++) {
uintptr_t total_use = 0, count = 0;
@ -3668,7 +3670,7 @@ void GC_dump_with_traces(int flags,
total_use += page->size;
count++;
}
GCWARN((GCOUTF, "Generation 1 [%s]: %li bytes used in %li pages\n",
GCWARN((GCOUTF, "Generation 1 [%s]: %" PRIdPTR "i bytes used in %" PRIdPTR "i pages\n",
type_name[i], total_use, count));
}
@ -3690,20 +3692,21 @@ void GC_dump_with_traces(int flags,
start += info->size;
}
}
GCWARN((GCOUTF, " %li [%li/%li]", count, page_count, gc->med_pages[i]->size));
GCWARN((GCOUTF, " %" PRIdPTR "i [%" PRIdPTR "i/%" PRIdPTR "i]",
count, page_count, gc->med_pages[i]->size));
}
}
GCWARN((GCOUTF, "\n"));
GCWARN((GCOUTF,"\n"));
GCWARN((GCOUTF,"Current memory use: %li\n", GC_get_memory_use(NULL)));
GCWARN((GCOUTF,"Peak memory use after a collection: %li\n", gc->peak_memory_use));
GCWARN((GCOUTF,"Allocated (+reserved) page sizes: %li (+%li)\n",
GCWARN((GCOUTF,"Current memory use: %" PRIdPTR "i\n", GC_get_memory_use(NULL)));
GCWARN((GCOUTF,"Peak memory use after a collection: %" PRIdPTR "i\n", gc->peak_memory_use));
GCWARN((GCOUTF,"Allocated (+reserved) page sizes: %" PRIdPTR "i (+%" PRIdPTR "i)\n",
gc->used_pages * APAGE_SIZE,
mmu_memory_allocated(gc->mmu) - (gc->used_pages * APAGE_SIZE)));
GCWARN((GCOUTF,"# of major collections: %li\n", gc->num_major_collects));
GCWARN((GCOUTF,"# of minor collections: %li\n", gc->num_minor_collects));
GCWARN((GCOUTF,"# of major collections: %" PRIdPTR "i\n", gc->num_major_collects));
GCWARN((GCOUTF,"# of minor collections: %" PRIdPTR "i\n", gc->num_minor_collects));
GCWARN((GCOUTF,"# of installed finalizers: %i\n", gc->num_fnls));
GCWARN((GCOUTF,"# of traced ephemerons: %i\n", gc->num_last_seen_ephemerons));
GCWARN((GCOUTF,"# of immobile boxes: %i\n", num_immobiles));

3
src/racket/src/Makefile.in
View File

@ -357,7 +357,8 @@ jitcommon.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
jitinline.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
jitprep.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h
jitstack.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS) $(srcdir)/codetab.inc
jitstack.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS) $(srcdir)/codetab.inc \
$(srcdir)/unwind/libunwind.h
jitstate.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
list.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h

5
src/racket/src/gmp/gmp-impl.h
View File

@ -730,7 +730,7 @@ mp_limb_t mpn_invert_limb _PROTO ((mp_limb_t));
#ifndef invert_limb
#define invert_limb(invxl,xl) \
do { \
mp_limb_t dummy; \
mp_limb_t dummy USED_ONLY_SOMETIMES; \
if (xl << 1 == 0) \
invxl = ~(mp_limb_t) 0; \
else \
@ -745,7 +745,8 @@ mp_limb_t mpn_invert_limb _PROTO ((mp_limb_t));
has to be set. Put the quotient in Q and the remainder in R. */
#define udiv_qrnnd_preinv(q, r, nh, nl, d, di) \
do { \
mp_limb_t _q, _ql, _r; \
mp_limb_t _q, _r; \
mp_limb_t _ql USED_ONLY_SOMETIMES; \
mp_limb_t _xh, _xl; \
umul_ppmm (_q, _ql, (nh), (di)); \
_q += (nh); /* DI is 2**BITS_PER_MP_LIMB too small */\

19
src/racket/src/gmp/gmp.c
View File

@ -22,6 +22,12 @@ MA 02111-1307, USA. */
#include "gmp-impl.h"
#include "gmplonglong.h"
#if defined(__GNUC__)
# define USED_ONLY_SOMETIMES __attribute__((unused))
#else
# define USED_ONLY_SOMETIMES /* empty */
#endif
extern void *scheme_malloc_gmp(uintptr_t, void **mem_pool);
extern void scheme_free_gmp(void *, void **mem_pool);
THREAD_LOCAL_DECL(static void *gmp_mem_pool);
@ -1882,8 +1888,9 @@ mpn_sb_get_str (unsigned char *str, size_t len,
else /* not base 10 */
{
unsigned chars_per_limb;
mp_limb_t big_base, big_base_inverted;
unsigned normalization_steps;
mp_limb_t big_base;
mp_limb_t big_base_inverted USED_ONLY_SOMETIMES;
unsigned normalization_steps USED_ONLY_SOMETIMES;
chars_per_limb = __mp_bases[base].chars_per_limb;
big_base = __mp_bases[base].big_base;
@ -2759,7 +2766,8 @@ mpn_tdiv_qr (qp, rp, qxn, np, nn, dp, dn)
it catches all cases where the quotient is 2 too large. */
{
mp_limb_t dl, x;
mp_limb_t h, l;
mp_limb_t h;
mp_limb_t l USED_ONLY_SOMETIMES;
if (in - 2 < 0)
dl = 0;
@ -4355,7 +4363,7 @@ mpn_mod_1 (mp_srcptr up, mp_size_t un, mp_limb_t d)
{
mp_size_t i;
mp_limb_t n1, n0, r;
mp_limb_t dummy;
mp_limb_t dummy USED_ONLY_SOMETIMES;
ASSERT (un >= 0);
ASSERT (d != 0);
@ -5032,7 +5040,8 @@ mpn_bdivmod (mp_ptr qp, mp_ptr up, mp_size_t usize,
if (usize == 2 && vsize == 2 &&
(d == GMP_NUMB_BITS || d == 2*GMP_NUMB_BITS))
{
mp_limb_t hi, lo;
mp_limb_t hi;
mp_limb_t lo USED_ONLY_SOMETIMES;
mp_limb_t q = (up[0] * v_inv) & GMP_NUMB_MASK;
umul_ppmm (hi, lo, q, vp[0] << GMP_NAIL_BITS);
up[0] = 0;

36
src/racket/src/jit.c
View File

@ -1117,7 +1117,7 @@ static int generate_flonum_local_boxing(mz_jit_state *jitter, int pos, int local
offset = scheme_mz_flostack_pos(jitter, local_pos);
offset = JIT_FRAME_FLOSTACK_OFFSET - offset;
if (jitter->unbox) {
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_FPSEL_ldxi_xd_fppush(extfl, fpr0, JIT_FP, offset);
jitter->unbox_depth++;
@ -1202,7 +1202,7 @@ static int generate_closure(Scheme_Closure_Data *data,
# endif
{
/* Non-inlined alloc */
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
JIT_UPDATE_THREAD_RSPTR_IF_NEEDED();
@ -1232,7 +1232,7 @@ static int generate_closure(Scheme_Closure_Data *data,
scheme_mz_load_retained(jitter, JIT_R0, code);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_native_closure, refr);
}
jit_retval(JIT_R0);
@ -1380,7 +1380,7 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t
scheme_mz_load_retained(jitter, JIT_R0, ndata);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_native_case_closure, refr);
}
jit_retval(JIT_R1);
@ -1491,7 +1491,7 @@ static int generate_non_tail_with_branch(Scheme_Object *obj, mz_jit_state *jitte
# ifdef MZ_USE_LWC
/* For lighweight continuations, we need to be able to recognize
and adjust mark-stack depths: */
jit_movi_l(JIT_R2, SCHEME_EVAL_WAITING);
jit_movi_p(JIT_R2, SCHEME_EVAL_WAITING);
mz_pushr_p(JIT_R2); /* no sync */
# endif
}
@ -1984,7 +1984,8 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
{
/* Other parts of the JIT rely on this code modifying only the target register,
unless the type is SCHEME_FLONUM_TYPE */
int pos, flonum, extfl;
int pos, flonum;
int extfl USED_ONLY_IF_FLONUM_UNBOXING;
START_JIT_DATA();
#ifdef USE_FLONUM_UNBOXING
flonum = (SCHEME_GET_LOCAL_TYPE(obj) == SCHEME_LOCAL_TYPE_FLONUM);
@ -2434,7 +2435,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
mz_prepare(1);
jit_pusharg_p(JIT_R2);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_envunbox, refr);
}
jit_retval(JIT_R0);
@ -2486,7 +2487,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
jit_pusharg_p(JIT_R2);
jit_pusharg_p(JIT_R1);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
if (is_const) {
(void)mz_finish_lwe(ts_make_global_const_ref, refr);
} else {
@ -2774,7 +2775,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
mz_prepare(1);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_envunbox, refr);
}
jit_retval(JIT_R0);
@ -3022,8 +3023,8 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
mz_rs_sync();
jit_movi_i(JIT_R0, WORDS_TO_BYTES(c));
jit_movi_i(JIT_R1, (int)&(((Scheme_Prefix *)0x0)->a[i + p + 1]));
jit_movi_i(JIT_R2, (int)&(((Scheme_Prefix *)0x0)->a[p]));
jit_movi_i(JIT_R1, (int)(intptr_t)&(((Scheme_Prefix *)0x0)->a[i + p + 1]));
jit_movi_i(JIT_R2, (int)(intptr_t)&(((Scheme_Prefix *)0x0)->a[p]));
(void)jit_calli(sjc.quote_syntax_code);
CHECK_LIMIT();
@ -3049,7 +3050,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
#ifdef MZ_LONG_DOUBLE
if (jitter->unbox_extflonum) {
long_double d;
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
if (SCHEME_LONG_DBLP(obj))
d = SCHEME_LONG_DBL_VAL(obj);
@ -3064,7 +3065,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
#endif
{
double d;
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
if (SCHEME_FLOATP(obj))
d = SCHEME_FLOAT_VAL(obj);
@ -3318,7 +3319,8 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data)
if (has_rest && data->num_params) {
/* If runstack == argv and argc == cnt, then we didn't
copy args down, and we need to make room for scheme_null. */
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3, *refrts;
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
CHECK_LIMIT();
@ -3800,7 +3802,8 @@ static int generate_simple_arity_check(mz_jit_state *jitter, int num_params, int
true dynamically for all jumps to the code. Also, at JIT time, make sure
that jitter is initialized with a size-3 prolog. */
GC_CAN_IGNORE jit_insn *ref, *ref2, *refrts;
GC_CAN_IGNORE jit_insn *ref, *ref2;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
__START_TINY_JUMPS__(1);
@ -3912,7 +3915,8 @@ static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambd
Scheme_Closure_Data *data;
Scheme_Object *o;
int i, cnt, has_rest, offset, num_params;
GC_CAN_IGNORE jit_insn *ref = NULL, *refrts;
GC_CAN_IGNORE jit_insn *ref = NULL;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
cnt = c->count;
for (i = 0; i < cnt; i++) {

39
src/racket/src/jit.h
View File

@ -31,7 +31,6 @@
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Waddress"
#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
#endif
/* Separate JIT_PRECISE_GC lets us test some 3m support in non-3m mode: */
@ -169,6 +168,30 @@ END_XFORM_ARITH;
# endif
#endif
#if defined(__GNUC__)
# define USED_ONLY_SOMETIMES __attribute__((unused))
#else
# define USED_ONLY_SOMETIMES /* empty */
#endif
#if !defined(MZ_USE_FUTURES)
# define USED_ONLY_FOR_FUTURES USED_ONLY_SOMETIMES
#else
# define USED_ONLY_FOR_FUTURES /* empty */
#endif
#if !defined(USE_FLONUM_UNBOXING)
# define USED_ONLY_IF_FLONUM_UNBOXING USED_ONLY_SOMETIMES
#else
# define USED_ONLY_IF_FLONUM_UNBOXING /* empty */
#endif
#if !defined(MZ_LONG_DOUBLE)
# define USED_ONLY_IF_LONG_DOUBLE USED_ONLY_SOMETIMES
#else
# define USED_ONLY_IF_LONG_DOUBLE /* empty */
#endif
#include "jitfpu.h"
#if 0
@ -1085,18 +1108,18 @@ static jit_insn *fp_tmpr;
#ifdef MZ_USE_LWC
# ifdef JIT_RUNSTACK_BASE
# define SAVE_RS_BASE_REG() jit_stxi_p((int)&((Scheme_Current_LWC *)0x0)->runstack_base_end, JIT_R0, JIT_RUNSTACK_BASE)
# define SAVE_RS_BASE_REG() jit_stxi_p((intptr_t)&((Scheme_Current_LWC *)0x0)->runstack_base_end, JIT_R0, JIT_RUNSTACK_BASE)
# else
# define SAVE_RS_BASE_REG() (void)0
# endif
# define adjust_lwc_return_address(pc) ((jit_insn *)((char *)(pc) - jit_return_pop_insn_len()))
# define mz_finish_lwe(d, refr) (mz_tl_ldi_p(JIT_R0, tl_scheme_current_lwc), \
jit_stxi_p((int)&((Scheme_Current_LWC *)0x0)->frame_end, JIT_R0, JIT_FP), \
jit_stxi_p((int)&((Scheme_Current_LWC *)0x0)->stack_end, JIT_R0, JIT_SP), \
jit_stxi_p((int)&((Scheme_Current_LWC *)0x0)->saved_v1, JIT_R0, JIT_V1), \
jit_stxi_p((intptr_t)&((Scheme_Current_LWC *)0x0)->frame_end, JIT_R0, JIT_FP), \
jit_stxi_p((intptr_t)&((Scheme_Current_LWC *)0x0)->stack_end, JIT_R0, JIT_SP), \
jit_stxi_p((intptr_t)&((Scheme_Current_LWC *)0x0)->saved_v1, JIT_R0, JIT_V1), \
SAVE_RS_BASE_REG(), \
refr = jit_patchable_movi_p(JIT_R1, jit_forward()), \
jit_stxi_p((int)&((Scheme_Current_LWC *)0x0)->original_dest, JIT_R0, JIT_R1), \
jit_stxi_p((intptr_t)&((Scheme_Current_LWC *)0x0)->original_dest, JIT_R0, JIT_R1), \
mz_finish(d), \
jit_patch_movi(refr, adjust_lwc_return_address(_jit.x.pc)))
#else
@ -1614,7 +1637,3 @@ Scheme_Object *scheme_jit_continuation_apply_install(Apply_LWC_Args *args);
#define INLINE_STRUCT_PROC_PROP_GET_W_DEFAULT 5
#define INLINE_STRUCT_PROC_PROP_PRED 6
#define INLINE_STRUCT_PROC_CONSTR 7

2
src/racket/src/jitalloc.c
View File

@ -309,7 +309,7 @@ long_double ld1;
int scheme_generate_alloc_retry(mz_jit_state *jitter, int i)
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
#ifdef JIT_USE_FP_OPS
if (i == 2) {

9
src/racket/src/jitarith.c
View File

@ -515,7 +515,7 @@ typedef void (*call_extfp_bin_proc)(void);
int scheme_generate_unboxing(mz_jit_state *jitter, int target)
{
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
#ifdef MZ_LONG_DOUBLE
if (jitter->unbox_extflonum) {
@ -601,7 +601,8 @@ static int generate_float_point_arith(mz_jit_state *jitter, Scheme_Object *rator
{
#if defined(INLINE_FP_OPS) || defined(INLINE_FP_COMP)
GC_CAN_IGNORE jit_insn *ref8, *ref9, *ref10, *refd, *refdt, *refs = NULL, *refs2 = NULL;
int no_alloc = unboxed_result, need_post_pop = 0;
int no_alloc = unboxed_result;
int need_post_pop USED_ONLY_SOMETIMES = 0;
if (!unsafe_fl && !unboxed) {
/* Maybe they're doubles */
@ -1237,7 +1238,7 @@ int scheme_generate_arith_for(mz_jit_state *jitter, Scheme_Object *rator, Scheme
if (!(inlined_flonum1 && inlined_flonum2)) {
if ((can_direct1 || (unsafe_fl > 0)) && !inlined_flonum2) {
#ifdef USE_FLONUM_UNBOXING
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
mz_ld_fppush(fpr0, jitter->flostack_offset, extfl);
scheme_mz_flostack_restore(jitter, flostack, flopos, 1, 1);
@ -1885,7 +1886,7 @@ int scheme_generate_arith_for(mz_jit_state *jitter, Scheme_Object *rator, Scheme
CHECK_LIMIT();
} else if (arith == ARITH_EX_INEX) {
/* exact->inexact */
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_rshi_l(JIT_R0, JIT_R0, 1);
jit_FPSEL_extr_l_xd_fppush(extfl, fpr0, JIT_R0);

19
src/racket/src/jitcall.c
View File

@ -520,21 +520,21 @@ int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_na
int scheme_generate_finish_apply(mz_jit_state *jitter)
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts__scheme_apply_from_native, refr);
return 1;
}
int scheme_generate_finish_tail_apply(mz_jit_state *jitter)
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(_scheme_tail_apply_from_native, refr);
return 1;
}
int scheme_generate_finish_multi_apply(mz_jit_state *jitter)
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts__scheme_apply_multi_from_native, refr);
return 1;
}
@ -547,10 +547,10 @@ int scheme_generate_finish_tail_call(mz_jit_state *jitter, int direct_native)
jit_pusharg_i(JIT_R0);
jit_pusharg_p(JIT_V1);
if (direct_native > 1) { /* => some_args_already_in_place */
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(_scheme_tail_apply_from_native_fixup_args, refr);
} else {
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts__scheme_tail_apply_from_native, refr);
}
CHECK_LIMIT();
@ -730,7 +730,8 @@ int scheme_generate_non_tail_call(mz_jit_state *jitter, int num_rands, int direc
If num_rands < 0, then argc is in R0, and need to pop runstack before returning.
If num_rands == -1, skip prolog. */
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref4, *ref5, *ref6, *ref7, *ref8, *ref9;
GC_CAN_IGNORE jit_insn *ref10, *reftop = NULL, *refagain, *refrts;
GC_CAN_IGNORE jit_insn *ref10, *reftop = NULL, *refagain;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
#ifndef FUEL_AUTODECEREMENTS
GC_CAN_IGNORE jit_insn *ref11;
#endif
@ -1076,7 +1077,9 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i
/* Last argument is in R0 */
{
GC_CAN_IGNORE jit_insn *refslow, *refagain;
int i, jmp_tiny, jmp_short;
int i;
int jmp_tiny USED_ONLY_SOMETIMES;
int jmp_short USED_ONLY_SOMETIMES;
int closure_size = jitter->self_closure_size;
int space, offset;
#ifdef USE_FLONUM_UNBOXING
@ -1233,7 +1236,7 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i
if (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_data, i)
|| CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i)) {
GC_CAN_IGNORE jit_insn *iref;
int extfl;
int extfl USED_ONLY_IF_LONG_DOUBLE;
extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i);
mz_pushr_p(JIT_R0);
mz_ld_runstack_base_alt(JIT_R2);

91
src/racket/src/jitcommon.c
View File

@ -200,7 +200,8 @@ static Scheme_Object **ts_scheme_on_demand(Scheme_Object **rs) XFORM_SKIP_PROC
static int common0(mz_jit_state *jitter, void *_data)
{
int in;
GC_CAN_IGNORE jit_insn *ref, *ref2;
GC_CAN_IGNORE jit_insn *ref;
GC_CAN_IGNORE jit_insn *ref2 USED_ONLY_FOR_FUTURES;
/* *** check_arity_code *** */
/* Called as a function: */
@ -321,7 +322,7 @@ static int common0(mz_jit_state *jitter, void *_data)
static int common1(mz_jit_state *jitter, void *_data)
{
int i;
GC_CAN_IGNORE jit_insn *ref;
GC_CAN_IGNORE jit_insn *ref USED_ONLY_FOR_FUTURES;
/* *** [bad_][m]{car,cdr,...,{imag,real}_part}_code *** */
/* Argument is in R2 for cXX+r, R0 otherwise */
@ -864,10 +865,10 @@ static int common2(mz_jit_state *jitter, void *_data)
jit_retval(JIT_R1); /* = pointer to a stack_cache_stack element */
CHECK_LIMIT();
/* Extract old return address and jump to it */
jit_ldxi_l(JIT_R0, JIT_R1, (int)&((Stack_Cache_Elem *)0x0)->orig_result);
jit_ldxi_l(JIT_R0, JIT_R1, &((Stack_Cache_Elem *)0x0)->orig_result);
(void)jit_movi_p(JIT_R2, NULL);
jit_stxi_l((int)&((Stack_Cache_Elem *)0x0)->orig_result, JIT_R1, JIT_R2);
jit_ldxi_l(JIT_R2, JIT_R1, (int)&((Stack_Cache_Elem *)0x0)->orig_return_address);
jit_stxi_l(&((Stack_Cache_Elem *)0x0)->orig_result, JIT_R1, JIT_R2);
jit_ldxi_l(JIT_R2, JIT_R1, &((Stack_Cache_Elem *)0x0)->orig_return_address);
jit_movr_p(JIT_RET, JIT_R0);
#ifdef MZ_USE_JIT_PPC
jit_ldxi_p(JIT_AUX, JIT_SP, 44);
@ -911,7 +912,8 @@ static int common2(mz_jit_state *jitter, void *_data)
/*** values_code ***/
/* Arguments on runstack, V1 has count */
{
GC_CAN_IGNORE jit_insn *refslow, *ref1, *refloop, *ref2;
GC_CAN_IGNORE jit_insn *refslow, *ref1, *refloop;
GC_CAN_IGNORE jit_insn *ref2 USED_ONLY_FOR_FUTURES;
sjc.values_code = jit_get_ip();
mz_prolog(JIT_R1);
@ -968,7 +970,8 @@ static int generate_apply_proxy(mz_jit_state *jitter, int setter)
original chaperone and index on runstack;
for setter, put back result in R2, vec in R0, and index in V1 */
{
GC_CAN_IGNORE jit_insn *ref, *ref1, *ref2, *refrts;
GC_CAN_IGNORE jit_insn *ref, *ref1, *ref2;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
CHECK_LIMIT();
jit_ldr_p(JIT_R2, JIT_RUNSTACK);
@ -1053,7 +1056,8 @@ static int common3(mz_jit_state *jitter, void *_data)
for (iii = 0; iii < 2; iii++) { /* ref, set */
for (ii = -1; ii < 4; ii++) { /* chap-vector, vector, string, bytes, fx */
for (i = 0; i < 2; i++) { /* check index? */
GC_CAN_IGNORE jit_insn *ref, *reffail, *refrts;
GC_CAN_IGNORE jit_insn *ref, *reffail;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
Scheme_Type ty;
int offset, count_offset, log_elem_size;
void *code;
@ -1064,8 +1068,8 @@ static int common3(mz_jit_state *jitter, void *_data)
case -1:
case 0:
ty = scheme_vector_type;
offset = (int)&SCHEME_VEC_ELS(0x0);
count_offset = (int)&SCHEME_VEC_SIZE(0x0);
offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
count_offset = (int)(intptr_t)&SCHEME_VEC_SIZE(0x0);
log_elem_size = JIT_LOG_WORD_SIZE;
if (ii == -1) {
if (!iii) {
@ -1097,8 +1101,8 @@ static int common3(mz_jit_state *jitter, void *_data)
break;
case 1:
ty = scheme_char_string_type;
offset = (int)&SCHEME_CHAR_STR_VAL(0x0);
count_offset = (int)&SCHEME_CHAR_STRLEN_VAL(0x0);
offset = (int)(intptr_t)&SCHEME_CHAR_STR_VAL(0x0);
count_offset = (int)(intptr_t)&SCHEME_CHAR_STRLEN_VAL(0x0);
log_elem_size = LOG_MZCHAR_SIZE;
if (!iii) {
if (!i) {
@ -1116,8 +1120,8 @@ static int common3(mz_jit_state *jitter, void *_data)
break;
case 2:
ty = scheme_byte_string_type;
offset = (int)&SCHEME_BYTE_STR_VAL(0x0);
count_offset = (int)&SCHEME_BYTE_STRLEN_VAL(0x0);
offset = (int)(intptr_t)&SCHEME_BYTE_STR_VAL(0x0);
count_offset = (int)(intptr_t)&SCHEME_BYTE_STRLEN_VAL(0x0);
log_elem_size = 0;
if (!iii) {
if (!i) {
@ -1136,8 +1140,8 @@ static int common3(mz_jit_state *jitter, void *_data)
default:
case 3:
ty = scheme_fxvector_type;
offset = (int)&SCHEME_VEC_ELS(0x0);
count_offset = (int)&SCHEME_VEC_SIZE(0x0);
offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
count_offset = (int)(intptr_t)&SCHEME_VEC_SIZE(0x0);
log_elem_size = JIT_LOG_WORD_SIZE;
if (!iii) {
if (!i) {
@ -1382,7 +1386,8 @@ static int gen_struct_slow(mz_jit_state *jitter, int kind, int ok_proc,
GC_CAN_IGNORE jit_insn **_bref5,
GC_CAN_IGNORE jit_insn **_bref6)
{
GC_CAN_IGNORE jit_insn *bref5, *bref6, *refrts;
GC_CAN_IGNORE jit_insn *bref5, *bref6;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
jit_subi_p(JIT_RUNSTACK, JIT_RUNSTACK, WORDS_TO_BYTES((kind == 3) ? 2 : 1));
CHECK_RUNSTACK_OVERFLOW();
@ -1669,7 +1674,7 @@ int scheme_generate_struct_op(mz_jit_state *jitter, int kind, int for_branch,
static int common4(mz_jit_state *jitter, void *_data)
{
int i, ii, iii;
GC_CAN_IGNORE jit_insn *ref;
GC_CAN_IGNORE jit_insn *ref USED_ONLY_FOR_FUTURES;
/* *** {flvector}_{ref,set}_check_index_code *** */
/* Same calling convention as for vector ops. */
@ -1769,7 +1774,8 @@ static int common4(mz_jit_state *jitter, void *_data)
/* *** syntax_e_code *** */
/* R0 is (potential) syntax object */
{
GC_CAN_IGNORE jit_insn *ref, *reffail, *refrts;
GC_CAN_IGNORE jit_insn *ref, *reffail;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
sjc.syntax_e_code = jit_get_ip();
__START_TINY_JUMPS__(1);
mz_prolog(JIT_R2);
@ -2521,7 +2527,7 @@ static int common6(mz_jit_state *jitter, void *_data)
/* wcm_chaperone */
/* key and value are on runstack and are updated there */
{
GC_CAN_IGNORE jit_insn *ref2;
GC_CAN_IGNORE jit_insn *ref2 USED_ONLY_FOR_FUTURES;
sjc.wcm_chaperone = jit_get_ip();
mz_prolog(JIT_R2);
@ -2747,8 +2753,9 @@ static int common8_5(mz_jit_state *jitter, void *_data)
/* first argument is in R0, second in R1 */
for (i = 0; i < 2; i++) {
void *code;
GC_CAN_IGNORE jit_insn *refslow, *refloop, *refdone, *ref, *refr;
GC_CAN_IGNORE jit_insn *refslow, *refloop, *refdone, *ref;
GC_CAN_IGNORE jit_insn *refmaybedone, *refresume;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
code = jit_get_ip();
if (i == 0)
@ -2903,7 +2910,8 @@ static int common10(mz_jit_state *jitter, void *_data)
/* proc_arity_includes_code */
/* R0 has proc, R1 has arity */
{
GC_CAN_IGNORE jit_insn *ref, *refslow, *refr ,*ref_nc, *ref_prim, *refno;
GC_CAN_IGNORE jit_insn *ref, *refslow, *ref_nc, *ref_prim, *refno;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
sjc.proc_arity_includes_code = jit_get_ip();
@ -3019,7 +3027,7 @@ static int common11(mz_jit_state *jitter, void *_data)
/* bad_char_to_integer_code */
/* R0 has argument */
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
sjc.bad_char_to_integer_code = jit_get_ip();
@ -3044,7 +3052,7 @@ static int common11(mz_jit_state *jitter, void *_data)
/* slow_integer_to_char_code */
/* R0 has argument */
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
sjc.slow_integer_to_char_code = jit_get_ip();
@ -3098,7 +3106,8 @@ static int more_common0(mz_jit_state *jitter, void *_data)
/* *** check_proc_extract_code *** */
/* arguments are on the Scheme stack */
{
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3, *refslow, *refrts;
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3, *refslow;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
sjc.struct_proc_extract_code = jit_get_ip();
mz_prolog(JIT_V1);
@ -3649,11 +3658,11 @@ static int more_common1(mz_jit_state *jitter, void *_data)
code; put them back in place just before we get to the
continuation */
#ifdef JIT_X86_64
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r14, JIT_R0, JIT_R(14));
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r15, JIT_R0, JIT_R(15));
jit_stxi_p((intptr_t)&((Apply_LWC_Args *)0x0)->saved_r14, JIT_R0, JIT_R(14));
jit_stxi_p((intptr_t)&((Apply_LWC_Args *)0x0)->saved_r15, JIT_R0, JIT_R(15));
# ifdef _WIN64
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r12, JIT_R0, JIT_R(12));
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r13, JIT_R0, JIT_R(13));
jit_stxi_p((intptr_t)&((Apply_LWC_Args *)0x0)->saved_r12, JIT_R0, JIT_R(12));
jit_stxi_p((intptr_t)&((Apply_LWC_Args *)0x0)->saved_r13, JIT_R0, JIT_R(13));
# endif
#endif
@ -3686,38 +3695,38 @@ static int more_common1(mz_jit_state *jitter, void *_data)
jit_movr_p(JIT_FP, JIT_R2);
/* Restore saved V1: */
jit_ldxi_p(JIT_R1, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_V1, JIT_R1, (int)&((Scheme_Current_LWC *)0x0)->saved_v1);
jit_ldxi_p(JIT_R1, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_V1, JIT_R1, (intptr_t)&((Scheme_Current_LWC *)0x0)->saved_v1);
CHECK_LIMIT();
/* Restore runstack, runstack_start, and thread-local pointer */
jit_ldxi_p(JIT_RUNSTACK, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->new_runstack);
jit_ldxi_p(JIT_RUNSTACK, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->new_runstack);
# ifdef THREAD_LOCAL_USES_JIT_V2
jit_ldxi_p(JIT_V2, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->new_threadlocal);
jit_ldxi_p(JIT_V2, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->new_threadlocal);
# else
jit_ldxi_p(JIT_RUNSTACK_BASE, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->new_runstack_base);
jit_ldxi_p(JIT_RUNSTACK_BASE, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->new_runstack_base);
# endif
# ifdef JIT_X86_64
jit_ldxi_p(JIT_R14, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->new_threadlocal);
jit_ldxi_p(JIT_R14, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->new_threadlocal);
# endif
/* restore preserved registers that we otherwise don't use */
# ifdef JIT_X86_64
/* saved_r14 is installed in the topmost frame already */
jit_ldxi_p(JIT_R(15), JIT_R0, (int)&((Apply_LWC_Args *)0x0)->saved_r15);
jit_ldxi_p(JIT_R(15), JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->saved_r15);
# ifdef _WIN64
jit_ldxi_p(JIT_R(12), JIT_R0, (int)&((Apply_LWC_Args *)0x0)->saved_r12);
jit_ldxi_p(JIT_R(13), JIT_R0, (int)&((Apply_LWC_Args *)0x0)->saved_r13);
jit_ldxi_p(JIT_R(12), JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->saved_r12);
jit_ldxi_p(JIT_R(13), JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->saved_r13);
# endif
# endif
CHECK_LIMIT();
/* Prepare to jump to original return: */
jit_ldxi_p(JIT_R1, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_R2, JIT_R1, (int)&((Scheme_Current_LWC *)0x0)->original_dest);
jit_ldxi_p(JIT_R1, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_R2, JIT_R1, (intptr_t)&((Scheme_Current_LWC *)0x0)->original_dest);
/* install result value: */
jit_ldxi_p(JIT_R0, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->result);
jit_ldxi_p(JIT_R0, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->result);
jit_jmpr(JIT_R2);

72
src/racket/src/jitinline.c
View File

@ -640,7 +640,8 @@ int scheme_generate_struct_alloc(mz_jit_state *jitter, int num_args,
For nary case, args on are on runstack.
If num_args is -1, nary and R1 has the count.*/
{
GC_CAN_IGNORE jit_insn *ref, *refslow, *refrts, *refdone;
GC_CAN_IGNORE jit_insn *ref, *refslow, *refdone;
GC_CAN_IGNORE jit_insn *refrts USED_ONLY_FOR_FUTURES;
int always_slow = 0;
#ifndef CAN_INLINE_ALLOC
@ -1356,7 +1357,7 @@ int scheme_generate_inlined_unary(mz_jit_state *jitter, Scheme_App2_Rec *app, in
|| IS_NAMED_PRIM(rator, "unsafe-extflvector-length"))) {
GC_CAN_IGNORE jit_insn *reffail, *ref;
int unsafe = 0, for_fl = 0, for_fx = 0, can_chaperone = 0;
int extfl = 0;
int extfl USED_ONLY_IF_LONG_DOUBLE = 0;
if (IS_NAMED_PRIM(rator, "unsafe-vector*-length")
|| IS_NAMED_PRIM(rator, "unsafe-fxvector-length")) {
@ -1822,7 +1823,7 @@ int scheme_generate_inlined_unary(mz_jit_state *jitter, Scheme_App2_Rec *app, in
mz_prepare(1);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_box, refr);
}
jit_retval(dest);
@ -1903,7 +1904,7 @@ int scheme_generate_inlined_unary(mz_jit_state *jitter, Scheme_App2_Rec *app, in
|| IS_NAMED_PRIM(rator, "fsemaphore-try-wait?")) {
/* Inline calls to future functions that specially support
running in the future thread: */
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
mz_runstack_skipped(jitter, 1);
scheme_generate_non_tail(app->rand, jitter, 0, 1, 0);
@ -2124,8 +2125,8 @@ static int generate_binary_char(mz_jit_state *jitter, Scheme_App3_Rec *app,
if (!direct) {
/* Extract character value */
jit_ldxi_i(JIT_R0, JIT_R0, (int)&SCHEME_CHAR_VAL((Scheme_Object *)0x0));
jit_ldxi_i(JIT_R1, JIT_R1, (int)&SCHEME_CHAR_VAL((Scheme_Object *)0x0));
jit_ldxi_i(JIT_R0, JIT_R0, (intptr_t)&SCHEME_CHAR_VAL((Scheme_Object *)0x0));
jit_ldxi_i(JIT_R1, JIT_R1, (intptr_t)&SCHEME_CHAR_VAL((Scheme_Object *)0x0));
ref = jit_bner_i(jit_forward(), JIT_R0, JIT_R1);
} else {
ref = jit_bner_p(jit_forward(), JIT_R0, JIT_R1);
@ -2219,21 +2220,21 @@ static int generate_vector_op(mz_jit_state *jitter, int set, int int_ready, int
(void)jit_bmci_ul(reffail, JIT_R2, 0x1);
if (for_fx) {
(void)mz_bnei_t(reffail, JIT_R0, scheme_fxvector_type, JIT_R2);
jit_ldxi_l(JIT_R2, JIT_R0, (int)&SCHEME_FXVEC_SIZE(0x0));
jit_ldxi_l(JIT_R2, JIT_R0, (intptr_t)&SCHEME_FXVEC_SIZE(0x0));
} else if (!for_fl) {
(void)mz_bnei_t(reffail, JIT_R0, scheme_vector_type, JIT_R2);
if (check_mutable) {
jit_ldxi_s(JIT_R2, JIT_R0, &MZ_OPT_HASH_KEY((Scheme_Inclhash_Object *)0x0));
(void)jit_bmsi_ul(reffail, JIT_R2, 0x1);
}
jit_ldxi_l(JIT_R2, JIT_R0, (int)&SCHEME_VEC_SIZE(0x0));
jit_ldxi_l(JIT_R2, JIT_R0, (intptr_t)&SCHEME_VEC_SIZE(0x0));
} else {
MZ_FPUSEL_STMT(extfl,
(void)mz_bnei_t(reffail, JIT_R0, scheme_extflvector_type, JIT_R2),
(void)mz_bnei_t(reffail, JIT_R0, scheme_flvector_type, JIT_R2));
MZ_FPUSEL_STMT(extfl,
jit_ldxi_l(JIT_R2, JIT_R0, (int)&SCHEME_EXTFLVEC_SIZE(0x0)),
jit_ldxi_l(JIT_R2, JIT_R0, (int)&SCHEME_FLVEC_SIZE(0x0)));
jit_ldxi_l(JIT_R2, JIT_R0, (intptr_t)&SCHEME_EXTFLVEC_SIZE(0x0)),
jit_ldxi_l(JIT_R2, JIT_R0, (intptr_t)&SCHEME_FLVEC_SIZE(0x0)));
}
if (!int_ready) {
jit_rshi_ul(JIT_V1, JIT_R1, 1);
@ -2298,7 +2299,7 @@ static int generate_vector_op(mz_jit_state *jitter, int set, int int_ready, int
if (!for_fl) {
jit_ldxr_p(dest, JIT_R0, JIT_V1);
} else {
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_FPSEL_ldxr_xd_fppush(extfl, fpr0, JIT_R0, JIT_V1);
if (unbox_flonum)
@ -2330,7 +2331,7 @@ static int allocate_rectangular(mz_jit_state *jitter, int dest)
jit_pusharg_p(JIT_R1);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_complex, refr);
}
jit_retval(dest);
@ -2461,7 +2462,8 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
return 1;
} else if (IS_NAMED_PRIM(rator, "equal?")) {
GC_CAN_IGNORE jit_insn *ref_f, *ref_d, *refr;
GC_CAN_IGNORE jit_insn *ref_f, *ref_d;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
scheme_generate_two_args(app->rand1, app->rand2, jitter, 0, 2);
CHECK_LIMIT();
@ -2897,7 +2899,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
|| IS_NAMED_PRIM(rator, "fxvector-ref")
|| IS_NAMED_PRIM(rator, "unsafe-fxvector-ref")) {
int simple;
int which, unsafe = 0, base_offset = ((int)&SCHEME_VEC_ELS(0x0));
int which, unsafe = 0, base_offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
mz_jit_unbox_state ubs;
int can_chaperone = 1, for_struct = 0, for_fx = 0;
int extfl = 0;
@ -2933,18 +2935,18 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
if (MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "extflvector-ref")))
extfl = 1;
MZ_FPUSEL_STMT(extfl,
base_offset = ((int)&SCHEME_EXTFLVEC_ELS(0x0)),
base_offset = ((int)&SCHEME_FLVEC_ELS(0x0)));
base_offset = (int)(intptr_t)&SCHEME_EXTFLVEC_ELS(0x0),
base_offset = (int)(intptr_t)&SCHEME_FLVEC_ELS(0x0));
} else if (IS_NAMED_PRIM(rator, "unsafe-struct*-ref")) {
which = 0;
unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots);
base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
can_chaperone = 0;
for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "unsafe-struct-ref")) {
which = 0;
unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots);
base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "string-ref"))
which = 1;
@ -3081,7 +3083,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
|| IS_NAMED_PRIM(rator, "unsafe-flvector-ref")
|| MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "unsafe-extflvector-ref")
|| IS_NAMED_PRIM(rator, "unsafe-f80vector-ref"))) {
int fpr0;
int fpr0 USED_ONLY_SOMETIMES;
int is_f64;
int extfl;
mz_jit_unbox_state ubs;
@ -3106,8 +3108,8 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
jit_lshi_ul(JIT_R1, JIT_R1, JIT_LOG_DOUBLE_SIZE));
if (!is_f64) {
MZ_FPUSEL_STMT(extfl,
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_EXTFLVEC_ELS(0x0))),
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_FLVEC_ELS(0x0))));
jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&SCHEME_EXTFLVEC_ELS(0x0))),
jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&SCHEME_FLVEC_ELS(0x0))));
}
if (jitter->unbox)
@ -3345,7 +3347,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
jit_pusharg_p(JIT_R1);
jit_pusharg_p(JIT_R0);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_mutable_pair, refr);
}
jit_retval(dest);
@ -3501,7 +3503,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
return 1;
} else if (IS_NAMED_PRIM(rator, "continuation-mark-set-first")) {
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
LOG_IT(("inlined continuation-mark-set-first\n"));
@ -3686,7 +3688,7 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
|| IS_NAMED_PRIM(rator, "unsafe-s16vector-set!")
|| IS_NAMED_PRIM(rator, "unsafe-u16vector-set!")) {
int simple, constval, can_delay_vec, can_delay_index;
int which, unsafe = 0, base_offset = ((int)&SCHEME_VEC_ELS(0x0));
int which, unsafe = 0, base_offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
int pushed, flonum_arg;
int can_chaperone = 1, for_struct = 0, for_fx = 0, check_mutable = 0;
int extfl = 0;
@ -3715,21 +3717,21 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
unsafe = 1;
} else if (IS_NAMED_PRIM(rator, "flvector-set!")) {
which = 3;
base_offset = ((int)&SCHEME_FLVEC_ELS(0x0));
base_offset = (int)(intptr_t)&SCHEME_FLVEC_ELS(0x0);
} else if (MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "extflvector-set!"))) {
extfl = 1;
which = 3;
base_offset = MZ_FPUSEL(extfl, ((int)&SCHEME_EXTFLVEC_ELS(0x0)), 0);
base_offset = MZ_FPUSEL(extfl, (intptr_t)&SCHEME_EXTFLVEC_ELS(0x0), 0);
} else if (IS_NAMED_PRIM(rator, "unsafe-struct*-set!")) {
which = 0;
unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots);
base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
can_chaperone = 0;
for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "unsafe-struct-set!")) {
which = 0;
unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots);
base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "string-set!"))
which = 1;
@ -4079,8 +4081,8 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
jit_lshi_ul(JIT_R1, JIT_R1, JIT_LOG_DOUBLE_SIZE));
if (!is_f64) {
MZ_FPUSEL_STMT(extfl,
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_EXTFLVEC_ELS(0x0))),
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_FLVEC_ELS(0x0))));
jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&SCHEME_EXTFLVEC_ELS(0x0))),
jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&SCHEME_FLVEC_ELS(0x0))));
}
MZ_FPUSEL_STMT(extfl,
jit_fpu_stxr_ld_fppop(JIT_R1, JIT_R0, JIT_FPU_FPR0),
@ -4141,7 +4143,7 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
jit_pusharg_l(JIT_R0);
jit_pusharg_p(JIT_RUNSTACK);
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
if (star)
(void)mz_finish_lwe(ts_scheme_jit_make_list_star, refr);
else
@ -4175,8 +4177,8 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
mz_runstack_popped(jitter, c);
} else {
mz_tl_ldi_p(JIT_R2, tl_scheme_current_thread);
jit_stixi_l(((int)&((Scheme_Thread *)0x0)->ku.multiple.count), JIT_R2, 0);
jit_stixi_p(((int)&((Scheme_Thread *)0x0)->ku.multiple.array), JIT_R2, NULL);
jit_stixi_l(&((Scheme_Thread *)0x0)->ku.multiple.count, JIT_R2, 0);
jit_stixi_p(&((Scheme_Thread *)0x0)->ku.multiple.array, JIT_R2, NULL);
(void)jit_movi_p(dest, SCHEME_MULTIPLE_VALUES);
}
@ -4254,7 +4256,7 @@ int scheme_generate_cons_alloc(mz_jit_state *jitter, int rev, int inline_retry,
jit_pusharg_p(JIT_R0);
}
{
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
(void)mz_finish_lwe(ts_scheme_make_pair, refr);
}
jit_retval(dest);
@ -4312,7 +4314,7 @@ static int generate_vector_alloc(mz_jit_state *jitter, Scheme_Object *rator,
#else
{
/* Non-inlined */
GC_CAN_IGNORE jit_insn *refr;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
JIT_UPDATE_THREAD_RSPTR_IF_NEEDED();
if (c == 1) {
mz_prepare(1);

36
src/racket/src/lightning/i386/core-common.h
View File

@ -242,7 +242,11 @@ static jit_state _jit;
#define jit_extr_s_l(d, rs) (jit_lshi_l((d), (rs), 48), jit_rshi_l((d), (d), 48))
#endif
#ifndef jit_extr_i_l
#define jit_extr_i_l(d, rs) (jit_lshi_l((d), (rs), 32), jit_rshi_l((d), (d), 32))
# if defined(JIT_X86_64)
# define jit_extr_i_l(d, rs) (jit_lshi_l((d), (rs), 32), jit_rshi_l((d), (d), 32))
# else
# define jit_extr_i_l(d, rs) 0
# endif
#endif
#ifndef jit_extr_c_ul
#define jit_extr_c_ul(d, rs) jit_andi_l((d), (rs), 0xFF)
@ -251,7 +255,11 @@ static jit_state _jit;
#define jit_extr_s_ul(d, rs) jit_andi_l((d), (rs), 0xFFFF)
#endif
#ifndef jit_extr_i_ul
#define jit_extr_i_ul(d, rs) jit_andi_l((d), (rs), 0xFFFFFFFFUL)
# if defined(JIT_X86_64)
# define jit_extr_i_ul(d, rs) jit_andi_l((d), (rs), 0xFFFFFFFFUL)
# else
# define jit_extr_i_ul(d, rs) 0
# endif
#endif
#endif
@ -406,18 +414,18 @@ static jit_state _jit;
#define jit_ner_p(d, s1, s2) jit_ner_ul((d), (s1), (s2))
#define jit_nei_p(d, rs, is) jit_nei_ul((d), (rs), (is))
#define jit_bltr_p(label, s1, s2) jit_bltr_ul((label), (s1), (s2))
#define jit_blti_p(label, rs, is) jit_blti_ul((label), (rs), (is))
#define jit_bler_p(label, s1, s2) jit_bler_ul((label), (s1), (s2))
#define jit_blei_p(label, rs, is) jit_blei_ul((label), (rs), (is))
#define jit_bgtr_p(label, s1, s2) jit_bgtr_ul((label), (s1), (s2))
#define jit_bgti_p(label, rs, is) jit_bgti_ul((label), (rs), (is))
#define jit_bger_p(label, s1, s2) jit_bger_ul((label), (s1), (s2))
#define jit_bgei_p(label, rs, is) jit_bgei_ul((label), (rs), (is))
#define jit_beqr_p(label, s1, s2) jit_beqr_ul((label), (s1), (s2))
#define jit_beqi_p(label, rs, is) jit_beqi_ul((label), (rs), (is))
#define jit_bner_p(label, s1, s2) jit_bner_ul((label), (s1), (s2))
#define jit_bnei_p(label, rs, is) jit_bnei_ul((label), (rs), (is))
#define jit_bltr_p(label, s1, s2) jit_bltr_ul((label), (s1), (uintptr_t)(s2))
#define jit_blti_p(label, rs, is) jit_blti_ul((label), (rs), (uintptr_t)(is))
#define jit_bler_p(label, s1, s2) jit_bler_ul((label), (s1), (uintptr_t)(s2))
#define jit_blei_p(label, rs, is) jit_blei_ul((label), (rs), (uintptr_t)(is))
#define jit_bgtr_p(label, s1, s2) jit_bgtr_ul((label), (s1), (uintptr_t)(s2))
#define jit_bgti_p(label, rs, is) jit_bgti_ul((label), (rs), (uintptr_t)(is))
#define jit_bger_p(label, s1, s2) jit_bger_ul((label), (s1), (uintptr_t)(s2))
#define jit_bgei_p(label, rs, is) jit_bgei_ul((label), (rs), (uintptr_t)(is))
#define jit_beqr_p(label, s1, s2) jit_beqr_ul((label), (s1), (uintptr_t)(s2))
#define jit_beqi_p(label, rs, is) jit_beqi_ul((label), (rs), (uintptr_t)(is))
#define jit_bner_p(label, s1, s2) jit_bner_ul((label), (s1), (uintptr_t)(s2))
#define jit_bnei_p(label, rs, is) jit_bnei_ul((label), (rs), (uintptr_t)(is))
#define jit_retval_ui(rd) jit_retval_i((rd))
#define jit_retval_uc(rd) jit_retval_i((rd))

10
src/racket/src/lightning/i386/core.h
View File

@ -703,12 +703,12 @@ XFORM_NONGCING static intptr_t _CHECK_TINY(intptr_t diff) { if ((diff < -128) ||
#define _jit_stixi_l(id, rd, is) MOVQim((is), (id), (rd), 0, 0)
#ifdef JIT_X86_64
# define jit_ldi_l(d, is) (_u32P((intptr_t)(is)) ? _jit_ldi_l(d, is) : (jit_movi_l(d, is), jit_ldr_l(d, d)))
# define jit_ldi_l(d, is) (_u32P((intptr_t)(is)) ? _jit_ldi_l(d, (int)(intptr_t)(is)) : (jit_movi_l(d, (intptr_t)(is)), jit_ldr_l(d, d)))
# define jit_sti_l(id, rs) (_u32P((intptr_t)(id)) ? _jit_sti_l(id, rs) : (jit_movi_l(JIT_REXTMP, (intptr_t)(id)), MOVQrQm(rs, 0, JIT_REXTMP, 0, 0)))
# define jit_ldi_i(d, is) (_u32P((intptr_t)(is)) ? _jit_ldi_i(d, is) : (jit_movi_l(d, is), jit_ldr_i(d, d)))
# define jit_ldi_i(d, is) (_u32P((intptr_t)(is)) ? _jit_ldi_i(d, (intptr_t)(is)) : (jit_movi_l(d, (intptr_t)(is)), jit_ldr_i(d, d)))
# define jit_sti_i(id, rs) (_u32P((intptr_t)(id)) ? _jit_sti_i(id, rs) : (jit_movi_l(JIT_REXTMP, (intptr_t)(id)), MOVQrm(rs, 0, JIT_REXTMP, 0, 0)))
# define jit_stir_l(rd, is) (_u32P((intptr_t)(is)) ? _jit_stir_l(rd, is) : (jit_movi_l(JIT_REXTMP, (intptr_t)(is)), jit_str_l(rd, JIT_REXTMP)))
# define jit_stixi_l(id, rd, is) (_u32P((intptr_t)(is)) ? _jit_stixi_l(id, rd, is) : (jit_movi_l(JIT_REXTMP, is), jit_stxi_l(id, rd, JIT_REXTMP)))
# define jit_stixi_l(id, rd, is) (_u32P(is) ? _jit_stixi_l((intptr_t)(id), rd, is) : (jit_movi_l(JIT_REXTMP, is), jit_stxi_l((intptr_t)(id), rd, JIT_REXTMP)))
#else
# define jit_ldi_l(d, is) _jit_ldi_l(d, is)
# define jit_sti_l(id, rs) _jit_sti_l(id, rs)
@ -718,8 +718,8 @@ XFORM_NONGCING static intptr_t _CHECK_TINY(intptr_t diff) { if ((diff < -128) ||
# define jit_stixi_l(id, rd, is) _jit_stixi_l(id, rd, is)
#endif
#define jit_stir_p(rd, is) jit_stir_l(rd, is)
#define jit_stixi_p(id, rd, is) jit_stixi_l(id, rd, is)
#define jit_stir_p(rd, is) jit_stir_l(rd, (intptr_t)(is))
#define jit_stixi_p(id, rd, is) jit_stixi_l(id, rd, (intptr_t)(is))
#define jit_lock_cmpxchgr_i(rd, rs) LOCK_PREFIX(CMPXCHGr(rd, rs))
#define jit_lock_cmpxchgr_s(rd, rs) LOCK_PREFIX(CMPXCHGWr(rd, rs))

8
src/racket/src/lightning/i386/fp-sse.h
View File

@ -86,12 +86,12 @@
#define jit_ldr_f(f0, r0) MOVSSmr(0, r0, _NOREG, _SCL1, f0)
#define jit_ldr_d(f0, r0) MOVSDmr(0, r0, _NOREG, _SCL1, f0)
#define _jit_ldi_d(f0, i0) MOVSDmr((long)i0, _NOREG, _NOREG, _SCL1, f0)
#define _jit_ldi_d(f0, i0) MOVSDmr((intptr_t)(i0), _NOREG, _NOREG, _SCL1, f0)
#ifdef JIT_X86_64
# define jit_ldi_d(f0, i0) \
(_u32P((intptr_t)(i0)) \
? _jit_ldi_d(f0, i0) \
: (jit_movi_l(JIT_REXTMP, i0), jit_ldr_d(f0, JIT_REXTMP)))
: (jit_movi_l(JIT_REXTMP, (intptr_t)(i0)), jit_ldr_d(f0, JIT_REXTMP)))
#else
# define jit_ldi_d(f0, i0) _jit_ldi_d(f0, i0)
#endif
@ -106,8 +106,8 @@
#ifdef JIT_X86_64
# define jit_sti_d(i0, f0) \
(_u32P((intptr_t)(i0)) \
? _jit_sti_d(i0, f0) \
: (jit_movi_l(JIT_REXTMP, i0), jit_str_d(JIT_REXTMP, f0)))
? _jit_sti_d((intptr_t)(i0), f0) \
: (jit_movi_l(JIT_REXTMP, (intptr_t)(i0)), jit_str_d(JIT_REXTMP, f0)))
#else
# define jit_sti_d(i0, f0) _jit_sti_d(i0, f0)
#endif

33
src/racket/src/unwind/libunwind.c
View File

@ -40,6 +40,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
#define UNW_PI_FLAG_DEBUG_FRAME 32
#define UNW_UNUSED(x) /* empty*/
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
/* region-based memory management */
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
@ -1036,7 +1038,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
struct dwarf_cie_info *dci)
{
unw_word_t curr_ip, operand = 0, regnum, val, len, fde_encoding;
dwarf_reg_state_t *rs_stack = NULL, *new_rs, *old_rs;
dwarf_reg_state_t *rs_stack = NULL, *new_rs;
UNW_UNUSED(dwarf_reg_state_t *old_rs;)
unw_addr_space_t as;
unw_accessors_t *a;
uint8_t u8, op;
@ -1228,7 +1231,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
goto fail;
}
memcpy (&sr->rs_current.reg, &rs_stack->reg, sizeof (rs_stack->reg));
old_rs = rs_stack;
UNW_UNUSED(old_rs = rs_stack);
rs_stack = rs_stack->next;
free_reg_state (old_rs);
Debug (15, "CFA_restore_state\n");
@ -1345,6 +1348,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
ret = 0;
fail:
UNW_UNUSED(
/* Free the register-state stack, if not empty already. */
while (rs_stack)
{
@ -1352,6 +1356,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
rs_stack = rs_stack->next;
free_reg_state (old_rs);
}
)
return ret;
}
@ -2327,7 +2332,7 @@ dwarf_find_debug_frame (unw_addr_space_t unw_local_addr_space,
di->start_ip = fdesc->start;
di->end_ip = fdesc->end;
di->u.rti.name_ptr = (unw_word_t) (uintptr_t) obj_name;
di->u.rti.table_data = (unw_word_t *) fdesc;
di->u.rti.table_data = (unw_word_t) (uintptr_t) fdesc;
di->u.rti.table_len = sizeof (*fdesc) / sizeof (unw_word_t);
di->u.rti.segbase = segbase;
@ -2349,7 +2354,8 @@ callback (struct dl_phdr_info *info, size_t size, void *ptr)
unw_dyn_info_t *di = &cb_data->di;
const Elf_W(Phdr) *phdr, *p_eh_hdr, *p_dynamic, *p_text;
unw_word_t addr, eh_frame_start, eh_frame_end, fde_count, ip;
Elf_W(Addr) load_base, segbase = 0, max_load_addr = 0;
Elf_W(Addr) load_base, max_load_addr = 0;
UNW_UNUSED(Elf_W(Addr) segbase = 0;)
int ret, need_unwind_info = cb_data->need_unwind_info;
unw_proc_info_t *pi = cb_data->pi;
struct dwarf_eh_frame_hdr *hdr;
@ -2426,11 +2432,13 @@ callback (struct dl_phdr_info *info, size_t size, void *ptr)
#endif /* CONFIG_DEBUG_FRAME */
}
/* segbase is currently unused: */
UNW_UNUSED(
if (likely (p_eh_hdr->p_vaddr >= p_text->p_vaddr
&& p_eh_hdr->p_vaddr < p_text->p_vaddr + p_text->p_memsz))
&& p_eh_hdr->p_vaddr < p_text->p_vaddr + p_text->p_memsz)) {
/* normal case: eh-hdr is inside text segment */
segbase = p_text->p_vaddr + load_base;
else
} else
{
/* Special case: eh-hdr is in some other segment; this may
happen, e.g., for the Linux kernel's gate DSO, for
@ -2446,6 +2454,7 @@ callback (struct dl_phdr_info *info, size_t size, void *ptr)
}
}
}
)
if (p_dynamic)
{
@ -2578,7 +2587,7 @@ dwarf_find_proc_info (unw_addr_space_t as, unw_word_t ip,
}
static inline const struct table_entry *
lookup (struct table_entry *table, size_t table_size, int32_t rel_ip)
lookup (const struct table_entry *table, size_t table_size, int32_t rel_ip)
{
unsigned long table_len = table_size / sizeof (struct table_entry);
const struct table_entry *e = 0;
@ -2813,14 +2822,12 @@ unw_get_reg (unw_cursor_t *cursor, int regnum, unw_word_t *valp)
{
case UNW_X86_64_RIP:
if (write)
c->dwarf.ip = *valp; /* also update the RIP cache */
loc = c->dwarf.loc[REG_RIP];
break;
case UNW_X86_64_CFA:
case UNW_X86_64_RSP:
if (write)
return -UNW_EREADONLYREG;
*valp = c->dwarf.cfa;
return 0;
@ -2829,13 +2836,7 @@ unw_get_reg (unw_cursor_t *cursor, int regnum, unw_word_t *valp)
case UNW_X86_64_RDX:
arg_num = regnum - UNW_X86_64_RAX;
mask = (1 << arg_num);
if (write)
{
c->dwarf.eh_args[arg_num] = *valp;
c->dwarf.eh_valid_mask |= mask;
return 0;
}
else if ((c->dwarf.eh_valid_mask & mask) != 0)
if ((c->dwarf.eh_valid_mask & mask) != 0)
{
*valp = c->dwarf.eh_args[arg_num];
return 0;

4
src/racket/src/unwind/libunwind.h
View File

@ -301,7 +301,7 @@ typedef struct {
#ifndef __thumb__
#define unw_tdep_getcontext(uc) (({ \
unw_tdep_context_t *unw_ctx = (uc); \
register unsigned long *unw_base asm ("r0") = unw_ctx; \
register unsigned long *unw_base asm ("r0") = (unsigned long *)unw_ctx; \
__asm__ __volatile__ ( \
"stmia %[base], {r0-r15}" \
: : [base] "r" (unw_base) : "memory"); \
@ -309,7 +309,7 @@ typedef struct {
#else /* __thumb__ */
#define unw_tdep_getcontext(uc) (({ \
unw_tdep_context_t *unw_ctx = (uc); \
register unsigned long *unw_base asm ("r0") = unw_ctx; \
register unsigned long *unw_base asm ("r0") = (unsigned long *)unw_ctx; \
__asm__ __volatile__ ( \
".align 2\nbx pc\nnop\n.code 32\n" \
"stmia %[base], {r0-r15}\n" \