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

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

@ -3,7 +3,7 @@
All rights reserved. All rights reserved.
Please see full copyright in the documentation Please see full copyright in the documentation
Search for "FIXME" for known improvement points Search for "FIXME" for known improvement points
This is a hybrid copying/mark-compact collector. The nursery This is a hybrid copying/mark-compact collector. The nursery
(generation 0) is copied into the old generation (generation 1), (generation 0) is copied into the old generation (generation 1),
@ -27,7 +27,7 @@
/* #define GC_MP_CNT */ /* #define GC_MP_CNT */
/* GC MProtect Counters */ /* GC MProtect Counters */
#ifdef GC_MP_CNT #ifdef GC_MP_CNT
int mp_write_barrier_cnt; int mp_write_barrier_cnt;
int mp_mark_cnt; int mp_mark_cnt;
int mp_alloc_med_big_cnt; int mp_alloc_med_big_cnt;
@ -58,7 +58,7 @@ intptr_t mp_ac_freed;
#include "platforms.h" #include "platforms.h"
#include "../src/schpriv.h" #include "../src/schpriv.h"
#include "gc2.h" #include "gc2.h"
#include "gc2_dump.h" #include "gc2_dump.h"
/* the number of tags to use for tagged objects */ /* the number of tags to use for tagged objects */
#define NUMBER_OF_TAGS 512 #define NUMBER_OF_TAGS 512
@ -121,15 +121,15 @@ enum {
MMU_NON_PROTECTABLE = 0, MMU_NON_PROTECTABLE = 0,
MMU_PROTECTABLE = 1, MMU_PROTECTABLE = 1,
}; };
static const char *type_name[PAGE_TYPES] = {
"tagged", static const char *type_name[PAGE_TYPES] = {
"atomic", "tagged",
"atomic",
"array", "array",
"tagged array", "tagged array",
"pair", "pair",
"big" "big"
}; };
#include "newgc.h" #include "newgc.h"
@ -181,12 +181,12 @@ static void free_mpage(mpage *page);
#if defined(MZ_USE_PLACES) && defined(GC_DEBUG_PAGES) #if defined(MZ_USE_PLACES) && defined(GC_DEBUG_PAGES)
static FILE* gcdebugOUT(NewGC *gc) { static FILE* gcdebugOUT(NewGC *gc) {
if (gc->GCVERBOSEFH) { fflush(gc->GCVERBOSEFH); } if (gc->GCVERBOSEFH) { fflush(gc->GCVERBOSEFH); }
else { else {
char buf[50]; char buf[50];
sprintf(buf, "GCDEBUGOUT_%i", gc->place_id); sprintf(buf, "GCDEBUGOUT_%i", gc->place_id);
gc->GCVERBOSEFH = fopen(buf, "w"); gc->GCVERBOSEFH = fopen(buf, "w");
} }
return gc->GCVERBOSEFH; return gc->GCVERBOSEFH;
} }
@ -262,7 +262,7 @@ MAYBE_UNUSED static void GCVERBOSEprintf(NewGC *gc, const char *fmt, ...) {
/* # define LOG_APAGE_SIZE ... see gc2_obj.h */ /* # define LOG_APAGE_SIZE ... see gc2_obj.h */
/* These are computed from the previous settings. You shouldn't mess with /* These are computed from the previous settings. You shouldn't mess with
them */ them */
#define PTR(x) ((void*)(x)) #define PTR(x) ((void*)(x))
#define PPTR(x) ((void**)(x)) #define PPTR(x) ((void**)(x))
@ -337,14 +337,13 @@ inline static size_t size_to_apage_count(size_t len) {
return (len / APAGE_SIZE) + (((len % APAGE_SIZE) == 0) ? 0 : 1); return (len / APAGE_SIZE) + (((len % APAGE_SIZE) == 0) ? 0 : 1);
} }
inline static size_t round_to_apage_size(size_t sizeb) { inline static size_t round_to_apage_size(size_t sizeb) {
sizeb += APAGE_SIZE - 1; sizeb += APAGE_SIZE - 1;
sizeb -= sizeb & (APAGE_SIZE - 1); sizeb -= sizeb & (APAGE_SIZE - 1);
return sizeb; return sizeb;
} }
inline static void check_used_against_max(NewGC *gc, size_t len)
inline static void check_used_against_max(NewGC *gc, size_t len)
{ {
intptr_t page_count; intptr_t page_count;
@ -364,7 +363,7 @@ inline static void check_used_against_max(NewGC *gc, size_t len)
if(gc->used_pages > gc->max_pages_for_use) { if(gc->used_pages > gc->max_pages_for_use) {
garbage_collect(gc, 1, 0, NULL); /* hopefully *this* will free enough space */ garbage_collect(gc, 1, 0, NULL); /* hopefully *this* will free enough space */
if(gc->used_pages > gc->max_pages_for_use) { if(gc->used_pages > gc->max_pages_for_use) {
/* too much memory allocated. /* too much memory allocated.
* Inform the thunk and then die semi-gracefully */ * Inform the thunk and then die semi-gracefully */
if(GC_out_of_memory) { if(GC_out_of_memory) {
gc->used_pages -= page_count; gc->used_pages -= page_count;
@ -390,9 +389,9 @@ void shared_pagemap_set(void *ptr, size_t len, NewGC *owner)
if (!lock) { if (!lock) {
mzrt_mutex_create(&lock); mzrt_mutex_create(&lock);
# ifdef SIXTY_FOUR_BIT_INTEGERS # ifdef SIXTY_FOUR_BIT_INTEGERS
shared_pagemap = ofm_malloc_zero(PAGEMAP64_LEVEL1_SIZE * sizeof (mpage***)); shared_pagemap = ofm_malloc_zero(PAGEMAP64_LEVEL1_SIZE * sizeof (mpage***));
# else # else
shared_pagemap = ofm_malloc_zero(PAGEMAP32_SIZE * sizeof (mpage*)); shared_pagemap = ofm_malloc_zero(PAGEMAP32_SIZE * sizeof (mpage*));
# endif # endif
} }
@ -412,7 +411,7 @@ void check_page_owner(NewGC *gc, const void *p)
mzrt_mutex_lock(lock); mzrt_mutex_lock(lock);
owner = (NewGC *)pagemap_find_page(shared_pagemap, p); owner = (NewGC *)pagemap_find_page(shared_pagemap, p);
if (owner && (owner != gc) && (owner != MASTERGC) && (owner != SHARED_PAGE_ORPHANED)) { if (owner && (owner != gc) && (owner != MASTERGC) && (owner != SHARED_PAGE_ORPHANED)) {
printf("%p is owned by place %i not the current place %i\n", p, owner->place_id, gc->place_id); printf("%p is owned by place %i not the current place %i\n", p, owner->place_id, gc->place_id);
abort(); abort();
} }
mzrt_mutex_unlock(lock); mzrt_mutex_unlock(lock);
@ -446,7 +445,7 @@ static void free_pages(NewGC *gc, void *p, size_t len, int type, int expect_mpro
static void check_excessive_free_pages(NewGC *gc) { static void check_excessive_free_pages(NewGC *gc) {
/* If we have too many idle pages --- 4 times used pages --- then flush. /* If we have too many idle pages --- 4 times used pages --- then flush.
We choose 4 instead of 2 for "excessive" because a block cache (when We choose 4 instead of 2 for "excessive" because a block cache (when
available) has a fill factor of 2, and flushing will not reduce that. */ available) has a fill factor of 2, and flushing will not reduce that. */
if (mmu_memory_allocated(gc->mmu) > ((gc->used_pages << (LOG_APAGE_SIZE + 2)))) { if (mmu_memory_allocated(gc->mmu) > ((gc->used_pages << (LOG_APAGE_SIZE + 2)))) {
mmu_flush_freed_pages(gc->mmu); mmu_flush_freed_pages(gc->mmu);
@ -593,7 +592,7 @@ static void dump_page_map(NewGC *gc, const char *when)
#endif #endif
mpage *page; mpage *page;
intptr_t skips = 0, did_one = 0; intptr_t skips = 0, did_one = 0;
printf("Page map (%s):\n", when); printf("Page map (%s):\n", when);
@ -681,12 +680,12 @@ static void dump_page_map(NewGC *gc, const char *when)
/* These procedures modify or use the page map. The page map provides us very /* These procedures modify or use the page map. The page map provides us very
fast mappings from pointers to the page the reside on, if any. The page fast mappings from pointers to the page the reside on, if any. The page
map itself serves two important purposes: map itself serves two important purposes:
Between collections, it maps pointers to write-protected pages, so that Between collections, it maps pointers to write-protected pages, so that
the write-barrier can identify what page a write has happened to and the write-barrier can identify what page a write has happened to and
mark it as potentially containing pointers from gen 1 to gen 0. mark it as potentially containing pointers from gen 1 to gen 0.
During collections, it maps pointers to "from" pages. */ During collections, it maps pointers to "from" pages. */
@ -746,7 +745,7 @@ int GC_is_allocated(void *p)
#endif #endif
/* struct objhead is defined in gc2_obj.h */ /* struct objhead is defined in gc2_obj.h */
/* Make sure alloction starts out double-word aligned. /* Make sure alloction starts out double-word aligned.
The header on each allocated object is one word, so to make The header on each allocated object is one word, so to make
the content double-word aligned, we may need a prefix. */ the content double-word aligned, we may need a prefix. */
#ifdef GC_ALIGN_SIXTEEN #ifdef GC_ALIGN_SIXTEEN
@ -756,7 +755,7 @@ int GC_is_allocated(void *p)
# define PREFIX_WSIZE 3 # define PREFIX_WSIZE 3
# endif # endif
# define CHECK_ALIGN_MASK 0xF # define CHECK_ALIGN_MASK 0xF
#elif defined(GC_ALIGN_EIGHT) #elif defined(GC_ALIGN_EIGHT)
# if defined(SIXTY_FOUR_BIT_INTEGERS) # if defined(SIXTY_FOUR_BIT_INTEGERS)
# define PREFIX_WSIZE 0 # define PREFIX_WSIZE 0
# else # else
@ -773,7 +772,7 @@ int GC_is_allocated(void *p)
+ (NUM(p) & (~(APAGE_SIZE - 1))) + PREFIX_SIZE))) + (NUM(p) & (~(APAGE_SIZE - 1))) + PREFIX_SIZE)))
/* this is the maximum size of an object that will fit on a page, in words. /* this is the maximum size of an object that will fit on a page, in words.
the "- 3" is basically used as a fudge/safety factor, and has no real, the "- 3" is basically used as a fudge/safety factor, and has no real,
important meaning. */ important meaning. */
#define MAX_OBJECT_SIZE (APAGE_SIZE - ((PREFIX_WSIZE + 3) * WORD_SIZE)) #define MAX_OBJECT_SIZE (APAGE_SIZE - ((PREFIX_WSIZE + 3) * WORD_SIZE))
@ -782,7 +781,7 @@ int GC_is_allocated(void *p)
#define ASSERT_VALID_INFOPTR(objptr) GC_ASSERT(!(((intptr_t)(objptr) + sizeof(objhead)) & CHECK_ALIGN_MASK)) #define ASSERT_VALID_INFOPTR(objptr) GC_ASSERT(!(((intptr_t)(objptr) + sizeof(objhead)) & CHECK_ALIGN_MASK))
/* Generation 0. Generation 0 is a set of very large pages in a list(gc->gen0.pages), /* Generation 0. Generation 0 is a set of very large pages in a list(gc->gen0.pages),
plus a set of smaller bigpages in a separate list(gc->gen0.big_pages). plus a set of smaller bigpages in a separate list(gc->gen0.big_pages).
The former is purely an optimization, saving us from constantly deallocating The former is purely an optimization, saving us from constantly deallocating
and allocating the entire nursery on every GC. The latter is useful because it simplifies and allocating the entire nursery on every GC. The latter is useful because it simplifies
the allocation process (which is also a speed hack, come to think of it) the allocation process (which is also a speed hack, come to think of it)
@ -1657,7 +1656,8 @@ intptr_t GC_message_objects_size(void *param) {
MsgMemory *msgm = (MsgMemory *) param; MsgMemory *msgm = (MsgMemory *) param;
if (!msgm) { return sizeof(param); } if (!msgm) { return sizeof(param); }
if (msgm->big_pages && msgm->size < 1024) { 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); exit(1);
} }
return msgm->size; return msgm->size;
@ -2612,7 +2612,7 @@ static void master_collect_initiate(NewGC *gc) {
} }
} }
if (count != (MASTERGCINFO->alive -1)) { 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(); abort();
} }
#if defined(GC_DEBUG_PAGES) #if defined(GC_DEBUG_PAGES)
@ -3654,12 +3654,14 @@ void GC_dump_with_traces(int flags,
sprintf(buf, "unknown,%d", i); sprintf(buf, "unknown,%d", i);
tn = buf; 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"); 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++) { for(i = 0; i < PAGE_TYPES; i++) {
uintptr_t total_use = 0, count = 0; uintptr_t total_use = 0, count = 0;
@ -3668,7 +3670,7 @@ void GC_dump_with_traces(int flags,
total_use += page->size; total_use += page->size;
count++; 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)); type_name[i], total_use, count));
} }
@ -3690,20 +3692,21 @@ void GC_dump_with_traces(int flags,
start += info->size; 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,"\n")); GCWARN((GCOUTF,"\n"));
GCWARN((GCOUTF,"Current memory use: %li\n", GC_get_memory_use(NULL))); GCWARN((GCOUTF,"Current memory use: %" PRIdPTR "i\n", GC_get_memory_use(NULL)));
GCWARN((GCOUTF,"Peak memory use after a collection: %li\n", gc->peak_memory_use)); GCWARN((GCOUTF,"Peak memory use after a collection: %" PRIdPTR "i\n", gc->peak_memory_use));
GCWARN((GCOUTF,"Allocated (+reserved) page sizes: %li (+%li)\n", GCWARN((GCOUTF,"Allocated (+reserved) page sizes: %" PRIdPTR "i (+%" PRIdPTR "i)\n",
gc->used_pages * APAGE_SIZE, gc->used_pages * APAGE_SIZE,
mmu_memory_allocated(gc->mmu) - (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 major collections: %" PRIdPTR "i\n", gc->num_major_collects));
GCWARN((GCOUTF,"# of minor collections: %li\n", gc->num_minor_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 installed finalizers: %i\n", gc->num_fnls));
GCWARN((GCOUTF,"# of traced ephemerons: %i\n", gc->num_last_seen_ephemerons)); GCWARN((GCOUTF,"# of traced ephemerons: %i\n", gc->num_last_seen_ephemerons));
GCWARN((GCOUTF,"# of immobile boxes: %i\n", num_immobiles)); 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) jitinline.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
jitprep.@LTO@: $(COMMON_HEADERS) \ jitprep.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(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) jitstate.@LTO@: $(COMMON_HEADERS) $(JIT_HEADERS)
list.@LTO@: $(COMMON_HEADERS) \ list.@LTO@: $(COMMON_HEADERS) \
$(srcdir)/stypes.h $(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 #ifndef invert_limb
#define invert_limb(invxl,xl) \ #define invert_limb(invxl,xl) \
do { \ do { \
mp_limb_t dummy; \ mp_limb_t dummy USED_ONLY_SOMETIMES; \
if (xl << 1 == 0) \ if (xl << 1 == 0) \
invxl = ~(mp_limb_t) 0; \ invxl = ~(mp_limb_t) 0; \
else \ 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. */ has to be set. Put the quotient in Q and the remainder in R. */
#define udiv_qrnnd_preinv(q, r, nh, nl, d, di) \ #define udiv_qrnnd_preinv(q, r, nh, nl, d, di) \
do { \ do { \
mp_limb_t _q, _ql, _r; \ mp_limb_t _q, _r; \
mp_limb_t _ql USED_ONLY_SOMETIMES; \
mp_limb_t _xh, _xl; \ mp_limb_t _xh, _xl; \
umul_ppmm (_q, _ql, (nh), (di)); \ umul_ppmm (_q, _ql, (nh), (di)); \
_q += (nh); /* DI is 2**BITS_PER_MP_LIMB too small */\ _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 "gmp-impl.h"
#include "gmplonglong.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_malloc_gmp(uintptr_t, void **mem_pool);
extern void scheme_free_gmp(void *, void **mem_pool); extern void scheme_free_gmp(void *, void **mem_pool);
THREAD_LOCAL_DECL(static void *gmp_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 */ else /* not base 10 */
{ {
unsigned chars_per_limb; unsigned chars_per_limb;
mp_limb_t big_base, big_base_inverted; mp_limb_t big_base;
unsigned normalization_steps; mp_limb_t big_base_inverted USED_ONLY_SOMETIMES;
unsigned normalization_steps USED_ONLY_SOMETIMES;
chars_per_limb = __mp_bases[base].chars_per_limb; chars_per_limb = __mp_bases[base].chars_per_limb;
big_base = __mp_bases[base].big_base; 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. */ it catches all cases where the quotient is 2 too large. */
{ {
mp_limb_t dl, x; 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) if (in - 2 < 0)
dl = 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_size_t i;
mp_limb_t n1, n0, r; mp_limb_t n1, n0, r;
mp_limb_t dummy; mp_limb_t dummy USED_ONLY_SOMETIMES;
ASSERT (un >= 0); ASSERT (un >= 0);
ASSERT (d != 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 && if (usize == 2 && vsize == 2 &&
(d == GMP_NUMB_BITS || d == 2*GMP_NUMB_BITS)) (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; mp_limb_t q = (up[0] * v_inv) & GMP_NUMB_MASK;
umul_ppmm (hi, lo, q, vp[0] << GMP_NAIL_BITS); umul_ppmm (hi, lo, q, vp[0] << GMP_NAIL_BITS);
up[0] = 0; 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 = scheme_mz_flostack_pos(jitter, local_pos);
offset = JIT_FRAME_FLOSTACK_OFFSET - offset; offset = JIT_FRAME_FLOSTACK_OFFSET - offset;
if (jitter->unbox) { if (jitter->unbox) {
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth); fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_FPSEL_ldxi_xd_fppush(extfl, fpr0, JIT_FP, offset); jit_FPSEL_ldxi_xd_fppush(extfl, fpr0, JIT_FP, offset);
jitter->unbox_depth++; jitter->unbox_depth++;
@ -1202,7 +1202,7 @@ static int generate_closure(Scheme_Closure_Data *data,
# endif # endif
{ {
/* Non-inlined alloc */ /* 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(); 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); scheme_mz_load_retained(jitter, JIT_R0, code);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_make_native_closure, refr);
} }
jit_retval(JIT_R0); 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); scheme_mz_load_retained(jitter, JIT_R0, ndata);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_make_native_case_closure, refr);
} }
jit_retval(JIT_R1); 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 # ifdef MZ_USE_LWC
/* For lighweight continuations, we need to be able to recognize /* For lighweight continuations, we need to be able to recognize
and adjust mark-stack depths: */ 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 */ mz_pushr_p(JIT_R2); /* no sync */
# endif # 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, /* Other parts of the JIT rely on this code modifying only the target register,
unless the type is SCHEME_FLONUM_TYPE */ unless the type is SCHEME_FLONUM_TYPE */
int pos, flonum, extfl; int pos, flonum;
int extfl USED_ONLY_IF_FLONUM_UNBOXING;
START_JIT_DATA(); START_JIT_DATA();
#ifdef USE_FLONUM_UNBOXING #ifdef USE_FLONUM_UNBOXING
flonum = (SCHEME_GET_LOCAL_TYPE(obj) == SCHEME_LOCAL_TYPE_FLONUM); 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); mz_prepare(1);
jit_pusharg_p(JIT_R2); 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); (void)mz_finish_lwe(ts_scheme_make_envunbox, refr);
} }
jit_retval(JIT_R0); 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_R2);
jit_pusharg_p(JIT_R1); jit_pusharg_p(JIT_R1);
{ {
GC_CAN_IGNORE jit_insn *refr; GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
if (is_const) { if (is_const) {
(void)mz_finish_lwe(ts_make_global_const_ref, refr); (void)mz_finish_lwe(ts_make_global_const_ref, refr);
} else { } else {
@ -2774,7 +2775,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w
mz_prepare(1); mz_prepare(1);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_make_envunbox, refr);
} }
jit_retval(JIT_R0); 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(); mz_rs_sync();
jit_movi_i(JIT_R0, WORDS_TO_BYTES(c)); 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_R1, (int)(intptr_t)&(((Scheme_Prefix *)0x0)->a[i + p + 1]));
jit_movi_i(JIT_R2, (int)&(((Scheme_Prefix *)0x0)->a[p])); jit_movi_i(JIT_R2, (int)(intptr_t)&(((Scheme_Prefix *)0x0)->a[p]));
(void)jit_calli(sjc.quote_syntax_code); (void)jit_calli(sjc.quote_syntax_code);
CHECK_LIMIT(); 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 #ifdef MZ_LONG_DOUBLE
if (jitter->unbox_extflonum) { if (jitter->unbox_extflonum) {
long_double d; long_double d;
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
if (SCHEME_LONG_DBLP(obj)) if (SCHEME_LONG_DBLP(obj))
d = SCHEME_LONG_DBL_VAL(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 #endif
{ {
double d; double d;
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
if (SCHEME_FLOATP(obj)) if (SCHEME_FLOATP(obj))
d = SCHEME_FLOAT_VAL(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 (has_rest && data->num_params) {
/* If runstack == argv and argc == cnt, then we didn't /* If runstack == argv and argc == cnt, then we didn't
copy args down, and we need to make room for scheme_null. */ 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(); 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 true dynamically for all jumps to the code. Also, at JIT time, make sure
that jitter is initialized with a size-3 prolog. */ 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); __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_Closure_Data *data;
Scheme_Object *o; Scheme_Object *o;
int i, cnt, has_rest, offset, num_params; 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; cnt = c->count;
for (i = 0; i < cnt; i++) { for (i = 0; i < cnt; i++) {

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

@ -31,7 +31,6 @@
#ifdef __GNUC__ #ifdef __GNUC__
#pragma GCC diagnostic ignored "-Waddress" #pragma GCC diagnostic ignored "-Waddress"
#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
#endif #endif
/* Separate JIT_PRECISE_GC lets us test some 3m support in non-3m mode: */ /* Separate JIT_PRECISE_GC lets us test some 3m support in non-3m mode: */
@ -169,6 +168,30 @@ END_XFORM_ARITH;
# endif # endif
#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" #include "jitfpu.h"
#if 0 #if 0
@ -1085,18 +1108,18 @@ static jit_insn *fp_tmpr;
#ifdef MZ_USE_LWC #ifdef MZ_USE_LWC
# ifdef JIT_RUNSTACK_BASE # 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 # else
# define SAVE_RS_BASE_REG() (void)0 # define SAVE_RS_BASE_REG() (void)0
# endif # endif
# define adjust_lwc_return_address(pc) ((jit_insn *)((char *)(pc) - jit_return_pop_insn_len())) # 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), \ # 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((intptr_t)&((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((intptr_t)&((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)->saved_v1, JIT_R0, JIT_V1), \
SAVE_RS_BASE_REG(), \ SAVE_RS_BASE_REG(), \
refr = jit_patchable_movi_p(JIT_R1, jit_forward()), \ 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), \ mz_finish(d), \
jit_patch_movi(refr, adjust_lwc_return_address(_jit.x.pc))) jit_patch_movi(refr, adjust_lwc_return_address(_jit.x.pc)))
#else #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_GET_W_DEFAULT 5
#define INLINE_STRUCT_PROC_PROP_PRED 6 #define INLINE_STRUCT_PROC_PROP_PRED 6
#define INLINE_STRUCT_PROC_CONSTR 7 #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) 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 #ifdef JIT_USE_FP_OPS
if (i == 2) { 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 scheme_generate_unboxing(mz_jit_state *jitter, int target)
{ {
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
#ifdef MZ_LONG_DOUBLE #ifdef MZ_LONG_DOUBLE
if (jitter->unbox_extflonum) { 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) #if defined(INLINE_FP_OPS) || defined(INLINE_FP_COMP)
GC_CAN_IGNORE jit_insn *ref8, *ref9, *ref10, *refd, *refdt, *refs = NULL, *refs2 = NULL; 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) { if (!unsafe_fl && !unboxed) {
/* Maybe they're doubles */ /* 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 (!(inlined_flonum1 && inlined_flonum2)) {
if ((can_direct1 || (unsafe_fl > 0)) && !inlined_flonum2) { if ((can_direct1 || (unsafe_fl > 0)) && !inlined_flonum2) {
#ifdef USE_FLONUM_UNBOXING #ifdef USE_FLONUM_UNBOXING
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth); fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
mz_ld_fppush(fpr0, jitter->flostack_offset, extfl); mz_ld_fppush(fpr0, jitter->flostack_offset, extfl);
scheme_mz_flostack_restore(jitter, flostack, flopos, 1, 1); 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(); CHECK_LIMIT();
} else if (arith == ARITH_EX_INEX) { } else if (arith == ARITH_EX_INEX) {
/* exact->inexact */ /* exact->inexact */
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth); fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_rshi_l(JIT_R0, JIT_R0, 1); jit_rshi_l(JIT_R0, JIT_R0, 1);
jit_FPSEL_extr_l_xd_fppush(extfl, fpr0, JIT_R0); 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) 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); (void)mz_finish_lwe(ts__scheme_apply_from_native, refr);
return 1; return 1;
} }
int scheme_generate_finish_tail_apply(mz_jit_state *jitter) 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); (void)mz_finish_lwe(_scheme_tail_apply_from_native, refr);
return 1; return 1;
} }
int scheme_generate_finish_multi_apply(mz_jit_state *jitter) 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); (void)mz_finish_lwe(ts__scheme_apply_multi_from_native, refr);
return 1; 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_i(JIT_R0);
jit_pusharg_p(JIT_V1); jit_pusharg_p(JIT_V1);
if (direct_native > 1) { /* => some_args_already_in_place */ 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); (void)mz_finish_lwe(_scheme_tail_apply_from_native_fixup_args, refr);
} else { } 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); (void)mz_finish_lwe(ts__scheme_tail_apply_from_native, refr);
} }
CHECK_LIMIT(); 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 < 0, then argc is in R0, and need to pop runstack before returning.
If num_rands == -1, skip prolog. */ If num_rands == -1, skip prolog. */
GC_CAN_IGNORE jit_insn *ref, *ref2, *ref4, *ref5, *ref6, *ref7, *ref8, *ref9; 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 #ifndef FUEL_AUTODECEREMENTS
GC_CAN_IGNORE jit_insn *ref11; GC_CAN_IGNORE jit_insn *ref11;
#endif #endif
@ -1076,7 +1077,9 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i
/* Last argument is in R0 */ /* Last argument is in R0 */
{ {
GC_CAN_IGNORE jit_insn *refslow, *refagain; 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 closure_size = jitter->self_closure_size;
int space, offset; int space, offset;
#ifdef USE_FLONUM_UNBOXING #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) if (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_data, i)
|| CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i)) { || CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i)) {
GC_CAN_IGNORE jit_insn *iref; GC_CAN_IGNORE jit_insn *iref;
int extfl; int extfl USED_ONLY_IF_LONG_DOUBLE;
extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i); extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i);
mz_pushr_p(JIT_R0); mz_pushr_p(JIT_R0);
mz_ld_runstack_base_alt(JIT_R2); 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) static int common0(mz_jit_state *jitter, void *_data)
{ {
int in; 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 *** */ /* *** check_arity_code *** */
/* Called as a function: */ /* 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) static int common1(mz_jit_state *jitter, void *_data)
{ {
int i; 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 *** */ /* *** [bad_][m]{car,cdr,...,{imag,real}_part}_code *** */
/* Argument is in R2 for cXX+r, R0 otherwise */ /* 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 */ jit_retval(JIT_R1); /* = pointer to a stack_cache_stack element */
CHECK_LIMIT(); CHECK_LIMIT();
/* Extract old return address and jump to it */ /* 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); (void)jit_movi_p(JIT_R2, NULL);
jit_stxi_l((int)&((Stack_Cache_Elem *)0x0)->orig_result, JIT_R1, JIT_R2); jit_stxi_l(&((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_ldxi_l(JIT_R2, JIT_R1, &((Stack_Cache_Elem *)0x0)->orig_return_address);
jit_movr_p(JIT_RET, JIT_R0); jit_movr_p(JIT_RET, JIT_R0);
#ifdef MZ_USE_JIT_PPC #ifdef MZ_USE_JIT_PPC
jit_ldxi_p(JIT_AUX, JIT_SP, 44); jit_ldxi_p(JIT_AUX, JIT_SP, 44);
@ -911,7 +912,8 @@ static int common2(mz_jit_state *jitter, void *_data)
/*** values_code ***/ /*** values_code ***/
/* Arguments on runstack, V1 has count */ /* 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(); sjc.values_code = jit_get_ip();
mz_prolog(JIT_R1); 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; original chaperone and index on runstack;
for setter, put back result in R2, vec in R0, and index in V1 */ 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(); CHECK_LIMIT();
jit_ldr_p(JIT_R2, JIT_RUNSTACK); 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 (iii = 0; iii < 2; iii++) { /* ref, set */
for (ii = -1; ii < 4; ii++) { /* chap-vector, vector, string, bytes, fx */ for (ii = -1; ii < 4; ii++) { /* chap-vector, vector, string, bytes, fx */
for (i = 0; i < 2; i++) { /* check index? */ 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; Scheme_Type ty;
int offset, count_offset, log_elem_size; int offset, count_offset, log_elem_size;
void *code; void *code;
@ -1064,8 +1068,8 @@ static int common3(mz_jit_state *jitter, void *_data)
case -1: case -1:
case 0: case 0:
ty = scheme_vector_type; ty = scheme_vector_type;
offset = (int)&SCHEME_VEC_ELS(0x0); offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
count_offset = (int)&SCHEME_VEC_SIZE(0x0); count_offset = (int)(intptr_t)&SCHEME_VEC_SIZE(0x0);
log_elem_size = JIT_LOG_WORD_SIZE; log_elem_size = JIT_LOG_WORD_SIZE;
if (ii == -1) { if (ii == -1) {
if (!iii) { if (!iii) {
@ -1097,8 +1101,8 @@ static int common3(mz_jit_state *jitter, void *_data)
break; break;
case 1: case 1:
ty = scheme_char_string_type; ty = scheme_char_string_type;
offset = (int)&SCHEME_CHAR_STR_VAL(0x0); offset = (int)(intptr_t)&SCHEME_CHAR_STR_VAL(0x0);
count_offset = (int)&SCHEME_CHAR_STRLEN_VAL(0x0); count_offset = (int)(intptr_t)&SCHEME_CHAR_STRLEN_VAL(0x0);
log_elem_size = LOG_MZCHAR_SIZE; log_elem_size = LOG_MZCHAR_SIZE;
if (!iii) { if (!iii) {
if (!i) { if (!i) {
@ -1116,8 +1120,8 @@ static int common3(mz_jit_state *jitter, void *_data)
break; break;
case 2: case 2:
ty = scheme_byte_string_type; ty = scheme_byte_string_type;
offset = (int)&SCHEME_BYTE_STR_VAL(0x0); offset = (int)(intptr_t)&SCHEME_BYTE_STR_VAL(0x0);
count_offset = (int)&SCHEME_BYTE_STRLEN_VAL(0x0); count_offset = (int)(intptr_t)&SCHEME_BYTE_STRLEN_VAL(0x0);
log_elem_size = 0; log_elem_size = 0;
if (!iii) { if (!iii) {
if (!i) { if (!i) {
@ -1136,8 +1140,8 @@ static int common3(mz_jit_state *jitter, void *_data)
default: default:
case 3: case 3:
ty = scheme_fxvector_type; ty = scheme_fxvector_type;
offset = (int)&SCHEME_VEC_ELS(0x0); offset = (int)(intptr_t)&SCHEME_VEC_ELS(0x0);
count_offset = (int)&SCHEME_VEC_SIZE(0x0); count_offset = (int)(intptr_t)&SCHEME_VEC_SIZE(0x0);
log_elem_size = JIT_LOG_WORD_SIZE; log_elem_size = JIT_LOG_WORD_SIZE;
if (!iii) { if (!iii) {
if (!i) { 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 **_bref5,
GC_CAN_IGNORE jit_insn **_bref6) 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)); jit_subi_p(JIT_RUNSTACK, JIT_RUNSTACK, WORDS_TO_BYTES((kind == 3) ? 2 : 1));
CHECK_RUNSTACK_OVERFLOW(); 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) static int common4(mz_jit_state *jitter, void *_data)
{ {
int i, ii, iii; 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 *** */ /* *** {flvector}_{ref,set}_check_index_code *** */
/* Same calling convention as for vector ops. */ /* Same calling convention as for vector ops. */
@ -1769,7 +1774,8 @@ static int common4(mz_jit_state *jitter, void *_data)
/* *** syntax_e_code *** */ /* *** syntax_e_code *** */
/* R0 is (potential) syntax object */ /* 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(); sjc.syntax_e_code = jit_get_ip();
__START_TINY_JUMPS__(1); __START_TINY_JUMPS__(1);
mz_prolog(JIT_R2); mz_prolog(JIT_R2);
@ -2521,7 +2527,7 @@ static int common6(mz_jit_state *jitter, void *_data)
/* wcm_chaperone */ /* wcm_chaperone */
/* key and value are on runstack and are updated there */ /* 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(); sjc.wcm_chaperone = jit_get_ip();
mz_prolog(JIT_R2); 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 */ /* first argument is in R0, second in R1 */
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
void *code; 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 *refmaybedone, *refresume;
GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
code = jit_get_ip(); code = jit_get_ip();
if (i == 0) if (i == 0)
@ -2903,7 +2910,8 @@ static int common10(mz_jit_state *jitter, void *_data)
/* proc_arity_includes_code */ /* proc_arity_includes_code */
/* R0 has proc, R1 has arity */ /* 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(); 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 */ /* bad_char_to_integer_code */
/* R0 has argument */ /* 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(); 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 */ /* slow_integer_to_char_code */
/* R0 has argument */ /* 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(); 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 *** */ /* *** check_proc_extract_code *** */
/* arguments are on the Scheme stack */ /* 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(); sjc.struct_proc_extract_code = jit_get_ip();
mz_prolog(JIT_V1); 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 code; put them back in place just before we get to the
continuation */ continuation */
#ifdef JIT_X86_64 #ifdef JIT_X86_64
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r14, JIT_R0, JIT_R(14)); jit_stxi_p((intptr_t)&((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_r15, JIT_R0, JIT_R(15));
# ifdef _WIN64 # ifdef _WIN64
jit_stxi_p((int)&((Apply_LWC_Args *)0x0)->saved_r12, JIT_R0, JIT_R(12)); jit_stxi_p((intptr_t)&((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_r13, JIT_R0, JIT_R(13));
# endif # endif
#endif #endif
@ -3686,38 +3695,38 @@ static int more_common1(mz_jit_state *jitter, void *_data)
jit_movr_p(JIT_FP, JIT_R2); jit_movr_p(JIT_FP, JIT_R2);
/* Restore saved V1: */ /* Restore saved V1: */
jit_ldxi_p(JIT_R1, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->lwc); jit_ldxi_p(JIT_R1, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_V1, JIT_R1, (int)&((Scheme_Current_LWC *)0x0)->saved_v1); jit_ldxi_l(JIT_V1, JIT_R1, (intptr_t)&((Scheme_Current_LWC *)0x0)->saved_v1);
CHECK_LIMIT(); CHECK_LIMIT();
/* Restore runstack, runstack_start, and thread-local pointer */ /* 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 # 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 # 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 # endif
# ifdef JIT_X86_64 # 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 # endif
/* restore preserved registers that we otherwise don't use */ /* restore preserved registers that we otherwise don't use */
# ifdef JIT_X86_64 # ifdef JIT_X86_64
/* saved_r14 is installed in the topmost frame already */ /* 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 # ifdef _WIN64
jit_ldxi_p(JIT_R(12), JIT_R0, (int)&((Apply_LWC_Args *)0x0)->saved_r12); jit_ldxi_p(JIT_R(12), JIT_R0, (intptr_t)&((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(13), JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->saved_r13);
# endif # endif
# endif # endif
CHECK_LIMIT(); CHECK_LIMIT();
/* Prepare to jump to original return: */ /* Prepare to jump to original return: */
jit_ldxi_p(JIT_R1, JIT_R0, (int)&((Apply_LWC_Args *)0x0)->lwc); jit_ldxi_p(JIT_R1, JIT_R0, (intptr_t)&((Apply_LWC_Args *)0x0)->lwc);
jit_ldxi_l(JIT_R2, JIT_R1, (int)&((Scheme_Current_LWC *)0x0)->original_dest); jit_ldxi_l(JIT_R2, JIT_R1, (intptr_t)&((Scheme_Current_LWC *)0x0)->original_dest);
/* install result value: */ /* 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); 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. For nary case, args on are on runstack.
If num_args is -1, nary and R1 has the count.*/ 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; int always_slow = 0;
#ifndef CAN_INLINE_ALLOC #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"))) { || IS_NAMED_PRIM(rator, "unsafe-extflvector-length"))) {
GC_CAN_IGNORE jit_insn *reffail, *ref; GC_CAN_IGNORE jit_insn *reffail, *ref;
int unsafe = 0, for_fl = 0, for_fx = 0, can_chaperone = 0; 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") if (IS_NAMED_PRIM(rator, "unsafe-vector*-length")
|| IS_NAMED_PRIM(rator, "unsafe-fxvector-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); mz_prepare(1);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_box, refr);
} }
jit_retval(dest); 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?")) { || IS_NAMED_PRIM(rator, "fsemaphore-try-wait?")) {
/* Inline calls to future functions that specially support /* Inline calls to future functions that specially support
running in the future thread: */ 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); mz_runstack_skipped(jitter, 1);
scheme_generate_non_tail(app->rand, jitter, 0, 1, 0); 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) { if (!direct) {
/* Extract character value */ /* Extract character value */
jit_ldxi_i(JIT_R0, JIT_R0, (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, (int)&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); ref = jit_bner_i(jit_forward(), JIT_R0, JIT_R1);
} else { } else {
ref = jit_bner_p(jit_forward(), JIT_R0, JIT_R1); 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); (void)jit_bmci_ul(reffail, JIT_R2, 0x1);
if (for_fx) { if (for_fx) {
(void)mz_bnei_t(reffail, JIT_R0, scheme_fxvector_type, JIT_R2); (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) { } else if (!for_fl) {
(void)mz_bnei_t(reffail, JIT_R0, scheme_vector_type, JIT_R2); (void)mz_bnei_t(reffail, JIT_R0, scheme_vector_type, JIT_R2);
if (check_mutable) { if (check_mutable) {
jit_ldxi_s(JIT_R2, JIT_R0, &MZ_OPT_HASH_KEY((Scheme_Inclhash_Object *)0x0)); jit_ldxi_s(JIT_R2, JIT_R0, &MZ_OPT_HASH_KEY((Scheme_Inclhash_Object *)0x0));
(void)jit_bmsi_ul(reffail, JIT_R2, 0x1); (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 { } else {
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
(void)mz_bnei_t(reffail, JIT_R0, scheme_extflvector_type, JIT_R2), (void)mz_bnei_t(reffail, JIT_R0, scheme_extflvector_type, JIT_R2),
(void)mz_bnei_t(reffail, JIT_R0, scheme_flvector_type, JIT_R2)); (void)mz_bnei_t(reffail, JIT_R0, scheme_flvector_type, JIT_R2));
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
jit_ldxi_l(JIT_R2, JIT_R0, (int)&SCHEME_EXTFLVEC_SIZE(0x0)), jit_ldxi_l(JIT_R2, JIT_R0, (intptr_t)&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_FLVEC_SIZE(0x0)));
} }
if (!int_ready) { if (!int_ready) {
jit_rshi_ul(JIT_V1, JIT_R1, 1); 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) { if (!for_fl) {
jit_ldxr_p(dest, JIT_R0, JIT_V1); jit_ldxr_p(dest, JIT_R0, JIT_V1);
} else { } else {
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth); fpr0 = JIT_FPUSEL_FPR_0(extfl, jitter->unbox_depth);
jit_FPSEL_ldxr_xd_fppush(extfl, fpr0, JIT_R0, JIT_V1); jit_FPSEL_ldxr_xd_fppush(extfl, fpr0, JIT_R0, JIT_V1);
if (unbox_flonum) 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_R1);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_make_complex, refr);
} }
jit_retval(dest); jit_retval(dest);
@ -2461,7 +2462,8 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
return 1; return 1;
} else if (IS_NAMED_PRIM(rator, "equal?")) { } 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); scheme_generate_two_args(app->rand1, app->rand2, jitter, 0, 2);
CHECK_LIMIT(); 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, "fxvector-ref")
|| IS_NAMED_PRIM(rator, "unsafe-fxvector-ref")) { || IS_NAMED_PRIM(rator, "unsafe-fxvector-ref")) {
int simple; 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; mz_jit_unbox_state ubs;
int can_chaperone = 1, for_struct = 0, for_fx = 0; int can_chaperone = 1, for_struct = 0, for_fx = 0;
int extfl = 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"))) if (MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "extflvector-ref")))
extfl = 1; extfl = 1;
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
base_offset = ((int)&SCHEME_EXTFLVEC_ELS(0x0)), base_offset = (int)(intptr_t)&SCHEME_EXTFLVEC_ELS(0x0),
base_offset = ((int)&SCHEME_FLVEC_ELS(0x0))); base_offset = (int)(intptr_t)&SCHEME_FLVEC_ELS(0x0));
} else if (IS_NAMED_PRIM(rator, "unsafe-struct*-ref")) { } else if (IS_NAMED_PRIM(rator, "unsafe-struct*-ref")) {
which = 0; which = 0;
unsafe = 1; unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots); base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
can_chaperone = 0; can_chaperone = 0;
for_struct = 1; for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "unsafe-struct-ref")) { } else if (IS_NAMED_PRIM(rator, "unsafe-struct-ref")) {
which = 0; which = 0;
unsafe = 1; unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots); base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
for_struct = 1; for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "string-ref")) } else if (IS_NAMED_PRIM(rator, "string-ref"))
which = 1; 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") || IS_NAMED_PRIM(rator, "unsafe-flvector-ref")
|| MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "unsafe-extflvector-ref") || MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "unsafe-extflvector-ref")
|| IS_NAMED_PRIM(rator, "unsafe-f80vector-ref"))) { || IS_NAMED_PRIM(rator, "unsafe-f80vector-ref"))) {
int fpr0; int fpr0 USED_ONLY_SOMETIMES;
int is_f64; int is_f64;
int extfl; int extfl;
mz_jit_unbox_state ubs; 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)); jit_lshi_ul(JIT_R1, JIT_R1, JIT_LOG_DOUBLE_SIZE));
if (!is_f64) { if (!is_f64) {
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_EXTFLVEC_ELS(0x0))), jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&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_FLVEC_ELS(0x0))));
} }
if (jitter->unbox) 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_R1);
jit_pusharg_p(JIT_R0); 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); (void)mz_finish_lwe(ts_scheme_make_mutable_pair, refr);
} }
jit_retval(dest); jit_retval(dest);
@ -3501,7 +3503,7 @@ int scheme_generate_inlined_binary(mz_jit_state *jitter, Scheme_App3_Rec *app, i
return 1; return 1;
} else if (IS_NAMED_PRIM(rator, "continuation-mark-set-first")) { } 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")); 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-s16vector-set!")
|| IS_NAMED_PRIM(rator, "unsafe-u16vector-set!")) { || IS_NAMED_PRIM(rator, "unsafe-u16vector-set!")) {
int simple, constval, can_delay_vec, can_delay_index; 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 pushed, flonum_arg;
int can_chaperone = 1, for_struct = 0, for_fx = 0, check_mutable = 0; int can_chaperone = 1, for_struct = 0, for_fx = 0, check_mutable = 0;
int extfl = 0; int extfl = 0;
@ -3715,21 +3717,21 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
unsafe = 1; unsafe = 1;
} else if (IS_NAMED_PRIM(rator, "flvector-set!")) { } else if (IS_NAMED_PRIM(rator, "flvector-set!")) {
which = 3; 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!"))) { } else if (MZ_LONG_DOUBLE_AND(IS_NAMED_PRIM(rator, "extflvector-set!"))) {
extfl = 1; extfl = 1;
which = 3; 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!")) { } else if (IS_NAMED_PRIM(rator, "unsafe-struct*-set!")) {
which = 0; which = 0;
unsafe = 1; unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots); base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
can_chaperone = 0; can_chaperone = 0;
for_struct = 1; for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "unsafe-struct-set!")) { } else if (IS_NAMED_PRIM(rator, "unsafe-struct-set!")) {
which = 0; which = 0;
unsafe = 1; unsafe = 1;
base_offset = ((int)&((Scheme_Structure *)0x0)->slots); base_offset = (int)(intptr_t)&((Scheme_Structure *)0x0)->slots;
for_struct = 1; for_struct = 1;
} else if (IS_NAMED_PRIM(rator, "string-set!")) } else if (IS_NAMED_PRIM(rator, "string-set!"))
which = 1; 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)); jit_lshi_ul(JIT_R1, JIT_R1, JIT_LOG_DOUBLE_SIZE));
if (!is_f64) { if (!is_f64) {
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
jit_addi_ul(JIT_R1, JIT_R1, (int)(&SCHEME_EXTFLVEC_ELS(0x0))), jit_addi_ul(JIT_R1, JIT_R1, (intptr_t)(&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_FLVEC_ELS(0x0))));
} }
MZ_FPUSEL_STMT(extfl, MZ_FPUSEL_STMT(extfl,
jit_fpu_stxr_ld_fppop(JIT_R1, JIT_R0, JIT_FPU_FPR0), 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_l(JIT_R0);
jit_pusharg_p(JIT_RUNSTACK); jit_pusharg_p(JIT_RUNSTACK);
{ {
GC_CAN_IGNORE jit_insn *refr; GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
if (star) if (star)
(void)mz_finish_lwe(ts_scheme_jit_make_list_star, refr); (void)mz_finish_lwe(ts_scheme_jit_make_list_star, refr);
else else
@ -4175,8 +4177,8 @@ int scheme_generate_inlined_nary(mz_jit_state *jitter, Scheme_App_Rec *app, int
mz_runstack_popped(jitter, c); mz_runstack_popped(jitter, c);
} else { } else {
mz_tl_ldi_p(JIT_R2, tl_scheme_current_thread); 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_l(&((Scheme_Thread *)0x0)->ku.multiple.count, JIT_R2, 0);
jit_stixi_p(((int)&((Scheme_Thread *)0x0)->ku.multiple.array), JIT_R2, NULL); jit_stixi_p(&((Scheme_Thread *)0x0)->ku.multiple.array, JIT_R2, NULL);
(void)jit_movi_p(dest, SCHEME_MULTIPLE_VALUES); (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); 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); (void)mz_finish_lwe(ts_scheme_make_pair, refr);
} }
jit_retval(dest); jit_retval(dest);
@ -4312,7 +4314,7 @@ static int generate_vector_alloc(mz_jit_state *jitter, Scheme_Object *rator,
#else #else
{ {
/* Non-inlined */ /* Non-inlined */
GC_CAN_IGNORE jit_insn *refr; GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES;
JIT_UPDATE_THREAD_RSPTR_IF_NEEDED(); JIT_UPDATE_THREAD_RSPTR_IF_NEEDED();
if (c == 1) { if (c == 1) {
mz_prepare(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)) #define jit_extr_s_l(d, rs) (jit_lshi_l((d), (rs), 48), jit_rshi_l((d), (d), 48))
#endif #endif
#ifndef jit_extr_i_l #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 #endif
#ifndef jit_extr_c_ul #ifndef jit_extr_c_ul
#define jit_extr_c_ul(d, rs) jit_andi_l((d), (rs), 0xFF) #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) #define jit_extr_s_ul(d, rs) jit_andi_l((d), (rs), 0xFFFF)
#endif #endif
#ifndef jit_extr_i_ul #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
#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_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_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_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), (is)) #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), (s2)) #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), (is)) #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), (s2)) #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), (is)) #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), (s2)) #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), (is)) #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), (s2)) #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), (is)) #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), (s2)) #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), (is)) #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_ui(rd) jit_retval_i((rd))
#define jit_retval_uc(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) #define _jit_stixi_l(id, rd, is) MOVQim((is), (id), (rd), 0, 0)
#ifdef JIT_X86_64 #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_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_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_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 #else
# define jit_ldi_l(d, is) _jit_ldi_l(d, is) # define jit_ldi_l(d, is) _jit_ldi_l(d, is)
# define jit_sti_l(id, rs) _jit_sti_l(id, rs) # 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) # define jit_stixi_l(id, rd, is) _jit_stixi_l(id, rd, is)
#endif #endif
#define jit_stir_p(rd, is) jit_stir_l(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, 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_i(rd, rs) LOCK_PREFIX(CMPXCHGr(rd, rs))
#define jit_lock_cmpxchgr_s(rd, rs) LOCK_PREFIX(CMPXCHGWr(rd, rs)) #define jit_lock_cmpxchgr_s(rd, rs) LOCK_PREFIX(CMPXCHGWr(rd, rs))

14
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_f(f0, r0) MOVSSmr(0, r0, _NOREG, _SCL1, f0)
#define jit_ldr_d(f0, r0) MOVSDmr(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 #ifdef JIT_X86_64
# define jit_ldi_d(f0, i0) \ # define jit_ldi_d(f0, i0) \
(_u32P((intptr_t)(i0)) \ (_u32P((intptr_t)(i0)) \
? _jit_ldi_d(f0, 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 #else
# define jit_ldi_d(f0, i0) _jit_ldi_d(f0, i0) # define jit_ldi_d(f0, i0) _jit_ldi_d(f0, i0)
#endif #endif
@ -106,8 +106,8 @@
#ifdef JIT_X86_64 #ifdef JIT_X86_64
# define jit_sti_d(i0, f0) \ # define jit_sti_d(i0, f0) \
(_u32P((intptr_t)(i0)) \ (_u32P((intptr_t)(i0)) \
? _jit_sti_d(i0, f0) \ ? _jit_sti_d((intptr_t)(i0), f0) \
: (jit_movi_l(JIT_REXTMP, i0), jit_str_d(JIT_REXTMP, f0))) : (jit_movi_l(JIT_REXTMP, (intptr_t)(i0)), jit_str_d(JIT_REXTMP, f0)))
#else #else
# define jit_sti_d(i0, f0) _jit_sti_d(i0, f0) # define jit_sti_d(i0, f0) _jit_sti_d(i0, f0)
#endif #endif

37
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_PI_FLAG_DEBUG_FRAME 32
#define UNW_UNUSED(x) /* empty*/
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/ /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
/* region-based memory management */ /* region-based memory management */
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/ /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*/
@ -1036,7 +1038,8 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
struct dwarf_cie_info *dci) struct dwarf_cie_info *dci)
{ {
unw_word_t curr_ip, operand = 0, regnum, val, len, fde_encoding; 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_addr_space_t as;
unw_accessors_t *a; unw_accessors_t *a;
uint8_t u8, op; uint8_t u8, op;
@ -1228,7 +1231,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
goto fail; goto fail;
} }
memcpy (&sr->rs_current.reg, &rs_stack->reg, sizeof (rs_stack->reg)); 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; rs_stack = rs_stack->next;
free_reg_state (old_rs); free_reg_state (old_rs);
Debug (15, "CFA_restore_state\n"); Debug (15, "CFA_restore_state\n");
@ -1345,6 +1348,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
ret = 0; ret = 0;
fail: fail:
UNW_UNUSED(
/* Free the register-state stack, if not empty already. */ /* Free the register-state stack, if not empty already. */
while (rs_stack) while (rs_stack)
{ {
@ -1352,6 +1356,7 @@ run_cfi_program (struct dwarf_cursor *c, dwarf_state_record_t *sr,
rs_stack = rs_stack->next; rs_stack = rs_stack->next;
free_reg_state (old_rs); free_reg_state (old_rs);
} }
)
return ret; return ret;
} }
@ -2327,7 +2332,7 @@ dwarf_find_debug_frame (unw_addr_space_t unw_local_addr_space,
di->start_ip = fdesc->start; di->start_ip = fdesc->start;
di->end_ip = fdesc->end; di->end_ip = fdesc->end;
di->u.rti.name_ptr = (unw_word_t) (uintptr_t) obj_name; 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.table_len = sizeof (*fdesc) / sizeof (unw_word_t);
di->u.rti.segbase = segbase; 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; unw_dyn_info_t *di = &cb_data->di;
const Elf_W(Phdr) *phdr, *p_eh_hdr, *p_dynamic, *p_text; 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; 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; int ret, need_unwind_info = cb_data->need_unwind_info;
unw_proc_info_t *pi = cb_data->pi; unw_proc_info_t *pi = cb_data->pi;
struct dwarf_eh_frame_hdr *hdr; 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 */ #endif /* CONFIG_DEBUG_FRAME */
} }
/* segbase is currently unused: */
UNW_UNUSED(
if (likely (p_eh_hdr->p_vaddr >= p_text->p_vaddr 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 */ /* normal case: eh-hdr is inside text segment */
segbase = p_text->p_vaddr + load_base; segbase = p_text->p_vaddr + load_base;
else } else
{ {
/* Special case: eh-hdr is in some other segment; this may /* Special case: eh-hdr is in some other segment; this may
happen, e.g., for the Linux kernel's gate DSO, for 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) 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 * 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); unsigned long table_len = table_size / sizeof (struct table_entry);
const struct table_entry *e = 0; const struct table_entry *e = 0;
@ -2813,15 +2822,13 @@ unw_get_reg (unw_cursor_t *cursor, int regnum, unw_word_t *valp)
{ {
case UNW_X86_64_RIP: case UNW_X86_64_RIP:
if (write) c->dwarf.ip = *valp; /* also update the RIP cache */
c->dwarf.ip = *valp; /* also update the RIP cache */
loc = c->dwarf.loc[REG_RIP]; loc = c->dwarf.loc[REG_RIP];
break; break;
case UNW_X86_64_CFA: case UNW_X86_64_CFA:
case UNW_X86_64_RSP: case UNW_X86_64_RSP:
if (write) return -UNW_EREADONLYREG;
return -UNW_EREADONLYREG;
*valp = c->dwarf.cfa; *valp = c->dwarf.cfa;
return 0; return 0;
@ -2829,13 +2836,7 @@ unw_get_reg (unw_cursor_t *cursor, int regnum, unw_word_t *valp)
case UNW_X86_64_RDX: case UNW_X86_64_RDX:
arg_num = regnum - UNW_X86_64_RAX; arg_num = regnum - UNW_X86_64_RAX;
mask = (1 << arg_num); mask = (1 << arg_num);
if (write) if ((c->dwarf.eh_valid_mask & mask) != 0)
{
c->dwarf.eh_args[arg_num] = *valp;
c->dwarf.eh_valid_mask |= mask;
return 0;
}
else if ((c->dwarf.eh_valid_mask & mask) != 0)
{ {
*valp = c->dwarf.eh_args[arg_num]; *valp = c->dwarf.eh_args[arg_num];
return 0; return 0;

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

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