Mon Feb 20 19:20:43 PST 2012 John Meacham <[email protected]> * add support for monolithic blocks that are plain malloced memory and can be big.
New patches:
[add support for monolithic blocks that are plain malloced memory and can be big. John Meacham <[email protected]>**20120221032043 Ignore-this: 201ba4e67027f3336cfa5e984aefa89 ] hunk ./rts/rts/gc_jgc.c 5 #include "sys/queue.h" #include "sys/bitarray.h" #include "rts/cdefs.h" +#include "rts/constants.h" #if _JHC_GC == _JHC_GC_JGC hunk ./rts/rts/gc_jgc.c 17 SLIST_HEAD(,s_cache) caches; SLIST_HEAD(,s_block) monolithic_blocks; SLIST_HEAD(,s_megablock) megablocks; + unsigned number_gcs; // number of garbage collections + unsigned number_allocs; // number of allocations since last garbage collection }; struct s_megablock { hunk ./rts/rts/gc_jgc.c 27 SLIST_ENTRY(s_megablock) next; }; -struct s_block_info { - unsigned char color; - unsigned char size; - unsigned char num_ptrs; - unsigned char flags; -}; - struct s_block { SLIST_ENTRY(s_block) link; hunk ./rts/rts/gc_jgc.c 29 - struct s_block_info pi; - unsigned short num_free; - unsigned short next_free; + unsigned char flags; // defined in rts/constants.h + unsigned char color; // offset in words to first entry. + union { + // A normal block. + struct { + unsigned char num_ptrs; + unsigned char size; + unsigned short num_free; + unsigned short next_free; + } pi; + // A monolithic block. + struct { + unsigned num_ptrs; + } m; + } u; bitarray_t used[]; }; hunk ./rts/rts/gc_jgc.c 51 SLIST_ENTRY(s_cache) next; SLIST_HEAD(,s_block) blocks; SLIST_HEAD(,s_block) full_blocks; - struct s_block_info pi; + unsigned char color; + unsigned char size; + unsigned char num_ptrs; + unsigned char flags; unsigned short num_entries; struct s_arena *arena; void (*init_fn)(void *); hunk ./rts/rts/gc_jgc.c 66 gc_t saved_gc; struct s_arena *arena; -static unsigned number_gcs; // number of garbage collections -static unsigned number_allocs; // number of allocations since last garbage collection static gc_t gc_stack_base; #define TO_GCPTR(x) (entry_t *)(FROM_SPTR(x)) hunk ./rts/rts/gc_jgc.c 74 static bool s_set_used_bit(void *val) A_UNUSED; static void clear_used_bits(struct s_arena *arena) A_UNUSED; static void s_cleanup_blocks(struct s_arena *arena); +static struct s_block *get_free_block(gc_t gc, struct s_arena *arena); +static void *aligned_alloc(unsigned size); typedef struct { sptr_t ptrs[0]; hunk ./rts/rts/gc_jgc.c 133 static void gc_add_grey(struct stack *stack, entry_t *s) { - VALGRIND_MAKE_MEM_DEFINED(s,(S_BLOCK(s))->pi.size * sizeof(uintptr_t)); + VALGRIND_MAKE_MEM_DEFINED(s,(S_BLOCK(s))->u.pi.size * sizeof(uintptr_t)); if(gc_check_heap(s) && s_set_used_bit(s)) stack->stack[stack->ptr++] = s; } hunk ./rts/rts/gc_jgc.c 142 gc_perform_gc(gc_t gc) { profile_push(&gc_gc_time); - number_gcs++; + arena->number_gcs++; unsigned number_redirects = 0; unsigned number_stack = 0; hunk ./rts/rts/gc_jgc.c 198 while(stack.ptr) { entry_t *e = stack.stack[--stack.ptr]; struct s_block *pg = S_BLOCK(e); - VALGRIND_MAKE_MEM_DEFINED(e,pg->pi.size * sizeof(uintptr_t)); + if(!(pg->flags & SLAB_MONOLITH)) + VALGRIND_MAKE_MEM_DEFINED(e,pg->u.pi.size * sizeof(uintptr_t)); debugf("Processing Grey: %p\n",e); hunk ./rts/rts/gc_jgc.c 201 - - stack_check(&stack, pg->pi.num_ptrs); - for(int i = 0; i < pg->pi.num_ptrs; i++) { + unsigned num_ptrs = pg->flags & SLAB_MONOLITH ? pg->u.m.num_ptrs : pg->u.pi.num_ptrs; + stack_check(&stack, num_ptrs); + for(unsigned i = 0; i < num_ptrs; i++) { if(1 && (P_LAZY == GET_PTYPE(e->ptrs[i]))) { VALGRIND_MAKE_MEM_DEFINED(FROM_SPTR(e->ptrs[i]), sizeof(uintptr_t)); if(!IS_LAZY(GETHEAD(FROM_SPTR(e->ptrs[i])))) { hunk ./rts/rts/gc_jgc.c 223 s_cleanup_blocks(arena); if(JHC_STATUS) { fprintf(stderr, "%3u - %6u Used: %4u Thresh: %4u Ss: %5u Ps: %5u Rs: %5u Root: %3u\n", - number_gcs, - number_allocs, + arena->number_gcs, + arena->number_allocs, (unsigned)arena->block_used, (unsigned)arena->block_threshold, number_stack, hunk ./rts/rts/gc_jgc.c 232 number_redirects, (unsigned)root_stack.ptr ); - number_allocs = 0; + arena->number_allocs = 0; } profile_pop(&gc_gc_time); } hunk ./rts/rts/gc_jgc.c 238 // 7 to share caches with the first 7 tuples -#define GC_STATIC_ARRAY_NUM 256 +#define GC_STATIC_ARRAY_NUM 7 +#define GC_MAX_BLOCK_ENTRIES 100 hunk ./rts/rts/gc_jgc.c 241 -static struct s_cache *static_array_caches[GC_STATIC_ARRAY_NUM]; +static struct s_cache *array_caches[GC_STATIC_ARRAY_NUM]; +static struct s_cache *array_atomic_caches[GC_STATIC_ARRAY_NUM]; void jhc_alloc_init(void) { hunk ./rts/rts/gc_jgc.c 259 } } for (int i = 0; i < GC_STATIC_ARRAY_NUM; i++) { - find_cache(&static_array_caches[i], arena, i + 1, i + 1); + find_cache(&array_caches[i], arena, i + 1, i + 1); } } hunk ./rts/rts/gc_jgc.c 276 } } -void * +heap_t A_STD (gc_alloc)(gc_t gc,struct s_cache **sc, unsigned count, unsigned nptrs) { hunk ./rts/rts/gc_jgc.c 279 - profile_push(&gc_alloc_time); - if (JHC_STATUS) - number_allocs++; assert(nptrs <= count); entry_t *e = s_alloc(gc, find_cache(sc, arena, count, nptrs)); VALGRIND_MAKE_MEM_UNDEFINED(e,sizeof(uintptr_t)*count); hunk ./rts/rts/gc_jgc.c 282 - debugf("allocated: %p %i %i\n",(void *)e, count, nptrs); - profile_pop(&gc_alloc_time); + debugf("gc_alloc: %p %i %i\n",(void *)e, count, nptrs); return (void *)e; } hunk ./rts/rts/gc_jgc.c 286 +static heap_t A_STD +s_monoblock(struct s_arena *arena, unsigned size, unsigned nptrs) { + struct s_block *b = aligned_alloc(size * sizeof(uintptr_t)); + b->flags = SLAB_MONOLITH; + b->color = (sizeof(struct s_block) + BITARRAY_SIZE_IN_BYTES(1) + + sizeof(uintptr_t) - 1) / sizeof(uintptr_t); + b->u.m.num_ptrs = nptrs; + SLIST_INSERT_HEAD(&arena->monolithic_blocks, b, link); + b->used[0] = 1; + return (void *)b + b->color*sizeof(uintptr_t); +} + // Allocate an array of count garbage collectable locations in the garbage collected heap hunk ./rts/rts/gc_jgc.c 299 -void * +heap_t A_STD gc_array_alloc(gc_t gc, unsigned count) { if (!count) hunk ./rts/rts/gc_jgc.c 305 return NULL; if (count <= GC_STATIC_ARRAY_NUM) - return (wptr_t)s_alloc(gc,static_array_caches[count - 1]); - //if (count < GC_MAX_BLOCK_ENTRIES) + return (wptr_t)s_alloc(gc,array_caches[count - 1]); + if (count < GC_MAX_BLOCK_ENTRIES) return s_alloc(gc, find_cache(NULL, arena, count, count)); hunk ./rts/rts/gc_jgc.c 308 + return s_monoblock(arena, count, count); abort(); } hunk ./rts/rts/gc_jgc.c 332 } while (1); } -struct s_megablock * -s_new_megablock(struct s_arena *arena) -{ - struct s_megablock *mb = malloc(sizeof(*mb)); +static void * +aligned_alloc(unsigned size) { + void *base; #if defined(__WIN32__) hunk ./rts/rts/gc_jgc.c 336 - mb->base = _aligned_malloc(MEGABLOCK_SIZE, BLOCK_SIZE); + base = _aligned_malloc(MEGABLOCK_SIZE, BLOCK_SIZE); int ret = !mb->base; #elif defined(__ARM_EABI__) hunk ./rts/rts/gc_jgc.c 339 - mb->base = memalign(BLOCK_SIZE,MEGABLOCK_SIZE); + base = memalign(BLOCK_SIZE, MEGABLOCK_SIZE); int ret = !mb->base; #elif (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 1060) assert(sysconf(_SC_PAGESIZE) == BLOCK_SIZE); hunk ./rts/rts/gc_jgc.c 343 - mb->base = valloc(MEGABLOCK_SIZE); + base = valloc(MEGABLOCK_SIZE); int ret = !mb->base; #else hunk ./rts/rts/gc_jgc.c 346 - int ret = posix_memalign(&mb->base,BLOCK_SIZE,MEGABLOCK_SIZE); + int ret = posix_memalign(&base,BLOCK_SIZE,MEGABLOCK_SIZE); #endif if(ret != 0) { hunk ./rts/rts/gc_jgc.c 349 - fprintf(stderr,"Unable to allocate memory for megablock\n"); + fprintf(stderr,"Unable to allocate memory for aligned alloc: %u\n", size); abort(); } hunk ./rts/rts/gc_jgc.c 352 + return base; +} + +struct s_megablock * +s_new_megablock(struct s_arena *arena) +{ + struct s_megablock *mb = malloc(sizeof(*mb)); + mb->base = aligned_alloc(MEGABLOCK_SIZE); VALGRIND_MAKE_MEM_NOACCESS(mb->base,MEGABLOCK_SIZE); hunk ./rts/rts/gc_jgc.c 361 - //VALGRIND_FREELIKE_BLOCK(mb->base,0); mb->next_free = 0; return mb; } hunk ./rts/rts/gc_jgc.c 392 arena->current_megablock = NULL; } VALGRIND_MAKE_MEM_UNDEFINED(pg,sizeof(struct s_block)); - pg->num_free = 0; + pg->u.pi.num_free = 0; return pg; } } hunk ./rts/rts/gc_jgc.c 434 } while(pg) { struct s_block *npg = SLIST_NEXT(pg,link); - if(__predict_false(pg->num_free == 0)) { + if(__predict_false(pg->u.pi.num_free == 0)) { // Add full blockes to the cache's full block list. SLIST_INSERT_HEAD(&sc->full_blocks,pg,link); hunk ./rts/rts/gc_jgc.c 437 - } else if(__predict_true(pg->num_free == sc->num_entries)) { + } else if(__predict_true(pg->u.pi.num_free == sc->num_entries)) { // Return completely free block to arena free block list. arena->block_used--; VALGRIND_MAKE_MEM_NOACCESS((char *)pg + sizeof(struct s_block), hunk ./rts/rts/gc_jgc.c 445 SLIST_INSERT_HEAD(&arena->free_blocks,pg,link); } else { if(!best) { - free_best = pg->num_free; + free_best = pg->u.pi.num_free; best = pg; } else { hunk ./rts/rts/gc_jgc.c 448 - if(pg->num_free < free_best) { + if(pg->u.pi.num_free < free_best) { struct s_block *tmp = best; best = pg; pg = tmp; hunk ./rts/rts/gc_jgc.c 451 - free_best = pg->num_free; + free_best = pg->u.pi.num_free; } SLIST_INSERT_HEAD(&sc->blocks,pg,link); } hunk ./rts/rts/gc_jgc.c 470 inline static void clear_block_used_bits(unsigned num_entries, struct s_block *pg) { - pg->num_free = num_entries; + pg->u.pi.num_free = num_entries; memset(pg->used,0,BITARRAY_SIZE_IN_BYTES(num_entries) - sizeof(pg->used[0])); int excess = num_entries % BITS_PER_UNIT; pg->used[BITARRAY_SIZE(num_entries) - 1] = ~((1UL << excess) - 1); hunk ./rts/rts/gc_jgc.c 480 #endif } -void * A_STD +/* + * allocators + */ + +heap_t A_STD s_alloc(gc_t gc, struct s_cache *sc) { #if _JHC_PROFILE hunk ./rts/rts/gc_jgc.c 489 sc->allocations++; + sc->arena->number_allocs++; #endif struct s_block *pg = SLIST_FIRST(&sc->blocks); if(__predict_false(!pg)) { hunk ./rts/rts/gc_jgc.c 496 pg = get_free_block(gc, sc->arena); VALGRIND_MAKE_MEM_NOACCESS(pg, BLOCK_SIZE); VALGRIND_MAKE_MEM_DEFINED(pg, sizeof(struct s_block)); - if(sc->num_entries != pg->num_free) + if(sc->num_entries != pg->u.pi.num_free) VALGRIND_MAKE_MEM_UNDEFINED((char *)pg->used, BITARRAY_SIZE_IN_BYTES(sc->num_entries)); else hunk ./rts/rts/gc_jgc.c 503 VALGRIND_MAKE_MEM_DEFINED((char *)pg->used, BITARRAY_SIZE_IN_BYTES(sc->num_entries)); assert(pg); - pg->pi = sc->pi; - pg->next_free = 0; + pg->flags = sc->flags; + pg->color = sc->color; + pg->u.pi.num_ptrs = sc->num_ptrs; + pg->u.pi.size = sc->size; + pg->u.pi.next_free = 0; SLIST_INSERT_HEAD(&sc->blocks,pg,link); hunk ./rts/rts/gc_jgc.c 509 - if(sc->num_entries != pg->num_free) + if(sc->num_entries != pg->u.pi.num_free) clear_block_used_bits(sc->num_entries, pg); pg->used[0] = 1; //set the first bit hunk ./rts/rts/gc_jgc.c 512 - pg->num_free = sc->num_entries - 1; - return (uintptr_t *)pg + pg->pi.color; + pg->u.pi.num_free = sc->num_entries - 1; + return (uintptr_t *)pg + pg->color; } else { __builtin_prefetch(pg->used,1); hunk ./rts/rts/gc_jgc.c 516 - pg->num_free--; - unsigned next_free = pg->next_free; + pg->u.pi.num_free--; + unsigned next_free = pg->u.pi.next_free; unsigned found = bitset_find_free(&next_free,BITARRAY_SIZE(sc->num_entries),pg->used); hunk ./rts/rts/gc_jgc.c 519 - pg->next_free = next_free; - void *val = (uintptr_t *)pg + pg->pi.color + found*pg->pi.size; - if(__predict_false(0 == pg->num_free)) { + pg->u.pi.next_free = next_free; + void *val = (uintptr_t *)pg + pg->color + found*pg->u.pi.size; + if(__predict_false(0 == pg->u.pi.num_free)) { assert(pg == SLIST_FIRST(&sc->blocks)); SLIST_REMOVE_HEAD(&sc->blocks,link); SLIST_INSERT_HEAD(&sc->full_blocks,pg,link); hunk ./rts/rts/gc_jgc.c 538 struct s_cache *sc = malloc(sizeof(*sc)); memset(sc,0,sizeof(*sc)); sc->arena = arena; - sc->pi.size = size; - sc->pi.num_ptrs = num_ptrs; - sc->pi.flags = 0; + sc->size = size; + sc->num_ptrs = num_ptrs; + sc->flags = 0; size_t excess = BLOCK_SIZE - sizeof(struct s_block); sc->num_entries = (8*excess) / (8*sizeof(uintptr_t)*size + 1) - 1; hunk ./rts/rts/gc_jgc.c 543 - sc->pi.color = (sizeof(struct s_block) + BITARRAY_SIZE_IN_BYTES(sc->num_entries) + + sc->color = (sizeof(struct s_block) + BITARRAY_SIZE_IN_BYTES(sc->num_entries) + sizeof(uintptr_t) - 1) / sizeof(uintptr_t); SLIST_INIT(&sc->blocks); SLIST_INIT(&sc->full_blocks); hunk ./rts/rts/gc_jgc.c 555 static void clear_used_bits(struct s_arena *arena) { + struct s_block *pg; + SLIST_FOREACH(pg, &arena->monolithic_blocks, link) + pg->used[0] = 0; struct s_cache *sc = SLIST_FIRST(&arena->caches); for(;sc;sc = SLIST_NEXT(sc,next)) { hunk ./rts/rts/gc_jgc.c 560 - struct s_block *pg = SLIST_FIRST(&sc->blocks); - struct s_block *fpg = SLIST_FIRST(&sc->full_blocks); - do { - for(;pg;pg = SLIST_NEXT(pg,link)) - clear_block_used_bits(sc->num_entries,pg); - pg = fpg; - fpg = NULL; - } while(pg); + SLIST_FOREACH(pg, &sc->blocks, link) + clear_block_used_bits(sc->num_entries,pg); + SLIST_FOREACH(pg, &sc->full_blocks, link) + clear_block_used_bits(sc->num_entries,pg); } } hunk ./rts/rts/gc_jgc.c 576 { assert(val); struct s_block *pg = S_BLOCK(val); - unsigned int offset = ((uintptr_t *)val - (uintptr_t *)pg) - pg->pi.color; - if(__predict_true(BIT_IS_UNSET(pg->used,offset/pg->pi.size))) { - BIT_SET(pg->used,offset/pg->pi.size); - pg->num_free--; - return (bool)pg->pi.num_ptrs; + unsigned int offset = ((uintptr_t *)val - (uintptr_t *)pg) - pg->color; + if(__predict_true(BIT_IS_UNSET(pg->used,offset/pg->u.pi.size))) { + if (pg->flags & SLAB_MONOLITH) { + pg->used[0] = 1; + return (bool)pg->u.m.num_ptrs; + + } else { + BIT_SET(pg->used,offset/pg->u.pi.size); + pg->u.pi.num_free--; + return (bool)pg->u.pi.num_ptrs; + } } return false; } hunk ./rts/rts/gc_jgc.c 599 return *rsc; struct s_cache *sc = SLIST_FIRST(&arena->caches); for(;sc;sc = SLIST_NEXT(sc,next)) { - if(sc->pi.size == size && sc->pi.num_ptrs == num_ptrs) + if(sc->size == size && sc->num_ptrs == num_ptrs) goto found; } sc = new_cache(arena,size,num_ptrs); hunk ./rts/rts/gc_jgc.c 628 (int)sc->num_entries, sizeof(struct s_block) + BITARRAY_SIZE_IN_BYTES(sc->num_entries)); fprintf(stderr, " size: %i words %i ptrs\n", - (int)sc->pi.size,(int)sc->pi.num_ptrs); + (int)sc->size,(int)sc->num_ptrs); #if _JHC_PROFILE fprintf(stderr, " allocations: %lu\n", (unsigned long)sc->allocations); #endif hunk ./rts/rts/gc_jgc.c 638 fprintf(stderr, "%20s %9s %9s %s\n", "block", "num_free", "next_free", "status"); struct s_block *pg; SLIST_FOREACH(pg,&sc->blocks,link) - fprintf(stderr, "%20p %9i %9i %c\n", pg, pg->num_free, pg->next_free, 'P'); + fprintf(stderr, "%20p %9i %9i %c\n", pg, pg->u.pi.num_free, pg->u.pi.next_free, 'P'); SLIST_FOREACH(pg,&sc->full_blocks,link) hunk ./rts/rts/gc_jgc.c 640 - fprintf(stderr, "%20p %9i %9i %c\n", pg, pg->num_free, pg->next_free, 'F'); + fprintf(stderr, "%20p %9i %9i %c\n", pg, pg->u.pi.num_free, pg->u.pi.next_free, 'F'); } #endif hunk ./rts/rts/gc_jgc.h 11 struct s_arena; struct s_cache; typedef void* *gc_t; +typedef void* heap_t; // a pointer into the GCed heap. #define BLOCK_SIZE (1UL << 12) #define MEGABLOCK_SIZE (1UL << 20) hunk ./rts/rts/gc_jgc.h 22 extern struct s_arena *arena; extern gc_t saved_gc; -void *s_alloc(gc_t gc, struct s_cache *sc) A_STD; void print_cache(struct s_cache *sc); struct s_cache *new_cache(struct s_arena *arena, unsigned short size, unsigned short num_ptrs); hunk ./rts/rts/gc_jgc.h 28 struct s_arena *new_arena(void); struct s_cache *find_cache(struct s_cache **rsc, struct s_arena *arena, unsigned short size, unsigned short num_ptrs); -void *(gc_alloc)(gc_t gc,struct s_cache **sc, unsigned count, unsigned nptrs); void gc_add_root(gc_t gc, void * root); hunk ./rts/rts/gc_jgc.h 29 -void *gc_array_alloc(gc_t gc, unsigned count); + +heap_t s_alloc(gc_t gc, struct s_cache *sc) A_STD; +heap_t (gc_alloc)(gc_t gc,struct s_cache **sc, unsigned count, unsigned nptrs); +heap_t gc_array_alloc(gc_t gc, unsigned count); +heap_t gc_array_alloc_atomic(gc_t gc, unsigned count); #define gc_frame0(gc,n,...) void *ptrs[n] = { __VA_ARGS__ }; \ for(int i = 0; i < n; i++) gc[i] = (sptr_t)ptrs[i]; \ Context: [introduce dedicated array allocation routine. clean up jgc garbage collector John Meacham <[email protected]>**20120221011655 Ignore-this: b8e153205aeaf94af76a97b0ee9aa895 ] [make 'div' and 'mod' round to -Infinity properly John Meacham <[email protected]>**20120220094634 Ignore-this: c46b383b9a2a6a63ff44e30a8a63f376 ] [add prototype for gc_alloc John Meacham <[email protected]>**20120220050616 Ignore-this: 444b34148332459dc0e3d32b7c55d3e0 ] [fix deriving rules for read/show when it comes to labels John Meacham <[email protected]>**20120220044322 Ignore-this: 20c9c89ae066716fe3ec8eb4d37c6034 ] [disabled buggy unused transformation in type analysis pass John Meacham <[email protected]>**20120220031442 Ignore-this: 8ad84739daff7f4faff0ba251898ea1a ] [move debugging routines to rts/profile.c John Meacham <[email protected]>**20120217052015 Ignore-this: d2e087faf6e3408dc135fd905d85244b ] [fix rts unit tests John Meacham <[email protected]>**20120217035045 Ignore-this: 460d7eadde056908b668ea27d5a69aa5 ] [export gc_alloc John Meacham <[email protected]>**20120217002235 Ignore-this: dcb70b3ad303f0343147b4e1d6d413b9 ] [Makes the class deriving mechanism more robust: [email protected]**20120216214017 Ignore-this: 6d93691849d255c310b2af7098572ea8 - the names of the classes to be derived may be given qualified. - the functions from the Prelude internally used need not be in scope and won't clash with other bindings. ] [Moved Jhc.List.drop to module Jhc.Basics (since it is used in instance deriving) [email protected]**20120214222939 Ignore-this: f95d4818bad6d79d8fc7566ee0912714 ] [The typechecker now verifies that the main function has a type that can be unified with IO a. This is required by the Haskell 98 Report. [email protected]**20120211050446 Ignore-this: 8a1d8ca36929c0de0fb4357538ea6c5b Failing to do so allows both to accept invalid programs like: > main :: [()] > main = return () and to reject valid programs like: > main = return () ] [Improves the error message shown when a monomorphic pattern has a polymorphic type that cannot be defaulted. [email protected]**20120211045931 Ignore-this: efd70b7535eb0444148aabdbe96ed0b9 The previous error message seemed more like an internal error ("withDefaults.ambiguity: ...") ] [fix for building rts in different modes, profile,debug,windows John Meacham <[email protected]>**20120216201402 Ignore-this: 39b08c82b7239beaeaa6e77a3b986cd4 ] [move rest of rts into seperate c files rather than including it directly. John Meacham <[email protected]>**20120216090215 Ignore-this: d0bf719a38e306f78e182a5c0107573d ] [add pragmaExp to the lexer/parser John Meacham <[email protected]>**20120216044837 Ignore-this: 77393cb5bdd28fba526d57d26ac099b8 ] [update documentation with new extensions John Meacham <[email protected]>**20120214172359 Ignore-this: 2f412f29f20127ce3f97f200674ed8b6 ] [fixes for android John Meacham <[email protected]>**20120213150333 Ignore-this: cf6df59b212e3402ec21507410485270 ] [make += work with '-m' command line options John Meacham <[email protected]>**20120213102300 Ignore-this: 36cb4039cd34ba73d2cc973b7c00798b ] [move jhc_rts_alloc to gc_none John Meacham <[email protected]>**20120213100906 Ignore-this: 1c2e9028d72127acd5a448971266f627 ] [added rts/rts_support, cleaned up rts code. John Meacham <[email protected]>**20120213070644 Ignore-this: 79533860331fbd02057748e3d1b81666 ] [make 'Requires' a simple set, include the calling convention with the requirements. John Meacham <[email protected]>**20120212053838 Ignore-this: b7fa6f8ece79c96073d8638a876456de ] [move slub.c and jhc_jgc.* to rts directory John Meacham <[email protected]>**20120212040246 Ignore-this: a40354544b8908732c733bf8a38e7e68 ] [add unit tests for stableptr John Meacham <[email protected]>**20120212031148 Ignore-this: 17b41baeec806fb53ca2c10c6489097 ] [reorganize rts/ directory, add README for it John Meacham <[email protected]>**20120212022718 Ignore-this: c8a9f067696233958757830b62a7264b ] [add rts/test directory John Meacham <[email protected]>**20120212004706 Ignore-this: 1e6d0cb4ba809a1d6089d04704d5a60f ] [allow being explicit in export/import lists by specifying 'kind', 'class', 'type', or 'data'. add PTS rule to allow proper typing of Complex_ John Meacham <[email protected]>**20120211052157 Ignore-this: 12155286186022f896d3474a2bb5d23a ] [fix Options.hs makefile dependency John Meacham <[email protected]>**20120211024909 Ignore-this: a0742d7ce4eba41314741b6ca2d6498d ] [added user defined kind extension John Meacham <[email protected]>**20120211042248 Ignore-this: ded329985c5c81aa8c4612f7aa19559b ] [Add missing src/Options.hs to jhc tarball Sergei Trofimovich <[email protected]>**20120209065334 Ignore-this: dfc50115ee26986ab2d303a462cd29b9 ] [added mingw32-gcc to MINGW search Sergei Trofimovich <[email protected]>**20110414073938 Ignore-this: 87fa46f0e4532663a9d92930c9c38152 ] [add c-- types for complex and vector values John Meacham <[email protected]>**20120210051026 Ignore-this: 4a1e4c8cec01f73b75913622c22fa55 ] [add documentation for the multi-return ccall extension, clean up code. John Meacham <[email protected]>**20120209201351 Ignore-this: 47504b653ee9f71bde40e91959238292 ] [add extension to allow multiple return values from c functions John Meacham <[email protected]>**20120209142228 Ignore-this: 51e4a3f9ca80ff2eae7f21376f0a0992 ] [fix obscure error message for invalid instance reported by roman John Meacham <[email protected]>**20120209114221 Ignore-this: 98d60e20cb63caaebbe1269887160b9f ] [remove APrim type, use Prim directly, clean up corresponding cruft. John Meacham <[email protected]>**20120209104920 Ignore-this: 8a3fbeea72e7f52809a3468df2b8b228 ] [turn ExtType into a real abstract type John Meacham <[email protected]>**20120209100704 Ignore-this: c802a07fee0f2461cca19aa28f99ff61 ] [add 'capi' foreign function call type, simplify type of E.FromHs monad, check for more FFI related errors John Meacham <[email protected]>**20120209091611 Ignore-this: 1945b5336e6001d6da6cd63a77bd1efd ] [add md5lazyIO, check for bad paths in createTempFile John Meacham <[email protected]>**20120209091527 Ignore-this: f9e5f0dafc9615d5c5c50cb49829c5a5 ] [add foreign types, interpret Ptr when creating external C types John Meacham <[email protected]>**20120209090647 Ignore-this: c49bea3938e2edabda9d7528cfb1121a ] [Add some more exotic primitive ops, ffs,clz,ctz,byteswap,popcount,parity. John Meacham <[email protected]>**20120209070848 Ignore-this: b61b1c08db35ccad33f24536b99913df ] [jhc.spec fixes John Meacham <[email protected]>**20120209015329 Ignore-this: 64488edc34893a734f81b1c01c0b1ff4 ] [TAG 0.8.0 John Meacham <[email protected]>**20120208020026 Ignore-this: 2d0d963331a43650879ae72d81ff62e8 ] Patch bundle hash: ae9749a7850ba47f055b105fe3a4f740e034c486
_______________________________________________ jhc mailing list [email protected] http://www.haskell.org/mailman/listinfo/jhc
