void ParamPaths_init(void) { register int i0, i1; _mid = _register_module(&ParamPaths_md.md, &ParamPaths__NewFilesDesc_td.td); { char *_mem, *_var; _mem = GC_malloc(_not_zero(20)+8); if (!_mem) _new_failed(_P(18198)); _var = _mem+8; ((_Type*)_var)[-1] = &ParamPaths__PathsSectionDesc_td.td; i0 = (int)_var; } ParamPaths__paths = (void*)i0; i1 = (int)ParamPaths__paths; i0 = i1 + 16; *(unsigned char*)i0 = 0; i1 = (int)ParamPaths__paths; i0 = i1 + 12; *(void**)i0 = (void*)0; { char *_mem, *_var; _mem = GC_malloc(_not_zero(20)+8); if (!_mem) _new_failed(_P(18272)); _var = _mem+8; ((_Type*)_var)[-1] = &ParamPaths__NewFilesDesc_td.td; i0 = (int)_var; } ParamPaths__newFiles = (void*)i0; i0 = (int)ParamPaths__paths; i1 = i0 + 16; *(unsigned char*)i1 = 0; i0 = (int)ParamPaths__newFiles; i1 = i0 + 12; *(void**)i1 = (void*)0; }
lstrvec* lstrvec_alloc(int size) { lstrvec* vec = GC_malloc(sizeof(lstrvec)); vec->size = size; if (size != 0) vec->xs = GC_malloc(size * sizeof(char*)); return vec; }
static int regmatch_sub_anytime(struct MatchingContext2 *c, Regex *regex, regexchar * pat2, char *str, char *end_p, int iter_limit, int firstp) { switch (c->label) { case 1: goto label1; case 2: goto label2; case 3: goto label3; } c->ctx = GC_malloc(sizeof(struct MatchingContext1)); c->ctx2 = GC_malloc(sizeof(struct MatchingContext2)); c->ctx->label = 0; c->regex = regex; c->n_any = 0; c->str = str; c->firstp = firstp; for (;;) { c->ctx->label = 0; while (regmatch_iter(c->ctx, c->regex->re, c->str, end_p, c->firstp)) { c->n_any = c->ctx->lastpos - c->str; if (c->n_any <= 0) continue; c->firstp = 0; if (RE_MODE(pat2) == RE_ENDMARK) { c->lastpos = c->str + c->n_any; YIELD(1, c, 1); } else if (regmatch(pat2, c->str + c->n_any, end_p, c->firstp, &c->lastpos) == 1) { YIELD(1, c, 2); } if (iter_limit == 1) continue; c->ctx2->label = 0; while (regmatch_sub_anytime(c->ctx2, regex, pat2, c->str + c->n_any, end_p, iter_limit - 1, c->firstp)) { c->lastpos = c->ctx2->lastpos; YIELD(1, c, 3); } } if (c->regex->alt_regex == NULL) break; c->regex = c->regex->alt_regex; } return 0; }
TreeNode* alloc_tree_node(int type) { TreeNode* tn = GC_malloc(sizeof(TreeNode)); tn->type = type; return tn; }
/* * GC strdup() */ extern char *GC_strdup(const char *str) { size_t len = strlen(str); char *copy = (char *)GC_malloc(len+1); strcpy(copy, str); return copy; }
static struct stack_block *mem_block_alloc(size_t min_size) { struct stack_block *block; size_t prev_size, alloc_size; prev_size = current_block == NULL ? 0 : current_block->size; alloc_size = nearest_power(prev_size + min_size); #ifndef USE_GC block = malloc(SIZEOF_MEMBLOCK + alloc_size); #else block = GC_malloc(SIZEOF_MEMBLOCK + alloc_size); #endif if (unlikely(block == NULL)) { if (outofmem) { if (min_size > outofmem_area.block.left) abort(); return &outofmem_area.block; } outofmem = TRUE; i_panic("data stack: Out of memory when allocating %" PRIuSIZE_T" bytes", alloc_size + SIZEOF_MEMBLOCK); } block->size = alloc_size; block->left = 0; block->lowwater = block->size; block->next = NULL; #ifdef DEBUG memset(STACK_BLOCK_DATA(block), CLEAR_CHR, alloc_size); #endif return block; }
static void *pool_system_malloc(pool_t pool ATTR_UNUSED, size_t size) { void *mem; #ifdef DEBUG int old_errno = errno; #endif if (unlikely(size == 0 || size > SSIZE_T_MAX)) i_panic("Trying to allocate %"PRIuSIZE_T" bytes", size); #ifndef USE_GC mem = calloc(size, 1); #else mem = GC_malloc(size); #endif if (unlikely(mem == NULL)) { i_fatal_status(FATAL_OUTOFMEM, "pool_system_malloc(%"PRIuSIZE_T "): Out of memory", size); } #ifdef DEBUG /* we rely on errno not changing. it shouldn't. */ i_assert(errno == old_errno); #endif return mem; }
static value_t* alloc_value (ptable_t *ptable, size_t size) { value_t *v = GC_malloc (size); v->ptable = ptable; return v; }
ParamPaths__Path ParamPaths__ParsePatterns_PathList_NewPath(unsigned char* str, int str_0d) { register int i0, i1, i2; { char *_mem, *_var; _mem = GC_malloc(_not_zero(8)+8); if (!_mem) _new_failed(_P(6224)); _var = _mem+8; ((_Type*)_var)[-1] = &ParamPaths__PathDesc_td.td; i0 = (int)_var; } i2 = Strings__Length((const unsigned char*)(int)str, str_0d); i1 = i0 + 4; i2++; { char *_mem, *_var; int* _dim_ptr; if(i2 < 0) _invalid_length(i2, _P(6281)); _mem = GC_malloc_atomic(_not_zero(i2*1)+8); if (!_mem) _new_failed(_P(6244)); _var = _mem+8; _dim_ptr = (void*)(_var-4); *(--_dim_ptr) = i2; i2 = (int)_var; } *(void**)i1 = (void*)i2; i1 = (int)*(void**)i1; i2 = *(int*)(i1-8); _string_copy(i1, (int)str, i2); *(void**)i0 = (void*)0; return (void*)i0; }
scm *run_lisp(struct sexp a_sexp) { switch (a_sexp.type) { case LIST:; // Get the first element (which should be a symbol representing a function) and evaluate it scm *callee = run_lisp(a_sexp.list[0]); assert(callee->type == SCM_FN); scm *args = NULL; struct sexp *remaining = a_sexp.list + 1; while (remaining->type != END_OF_LIST) { args = append(args, run_lisp(*remaining)); remaining++; } return callee->fn(args); case SYMBOL:; char *name = a_sexp.symbol; if (strcmp(name, "+") == 0) { return &_plus_scm; } assert(0 && "Stuff ain't implemented yet!"); break; case INTEGER:; scm *val = GC_malloc(sizeof(scm)); val->type = SCM_INT; val->integer = a_sexp.integer; return val; default: assert(0 && "Whoops..."); } }
ss_INLINE void* ss_malloc(size_t s) { ss_malloc_bytes += s; ss_malloc_objects ++; return GC_malloc(s); }
void *api_call_method(int numargs, void *obj, void *initptr, va_list vl) { ffi_cif cif; ffi_type *args[numargs + 1]; void *values[numargs + 1]; void **val_heap = (void**)GC_malloc((numargs + 1) * sizeof(void*)); /*new void*[numargs + 1];*/ void *rv; args[0] = &ffi_type_pointer; values[0] = &val_heap[0]; for (int i = 0; i < numargs; i++) { args[i + 1] = &ffi_type_pointer; values[i + 1] = (void*)&val_heap[i + 1]; } int rc = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, numargs + 1, &ffi_type_pointer, args); assert(rc == FFI_OK); val_heap[0] = (void*)obj; for (int i = 0; i < numargs; i++) { val_heap[i + 1] = va_arg(vl, void*); } ffi_call(&cif, (void(*)())initptr, &rv, values); va_end(vl); GC_free(val_heap); /*delete[] val_heap;*/ return rv; }
END_TEST START_TEST(test_message_send) { message * msg; int * sock = GC_malloc(sizeof(int) * 2); socketpair(AF_UNIX, SOCK_STREAM, 0, sock); msg = message_create_echo(MESSAGE_TYPE_REQUEST, "hey"); message_send(sock[0], msg); char * header_buf = GC_malloc(8); char * data = GC_malloc(7); ck_assert_int_eq(recv(sock[1], header_buf, 8, MSG_DONTWAIT), 8); ck_assert_int_eq(memcmp(header_buf, "\x00\x00\x00\x07\xfb\x65\x78\xa3", 8), 0); ck_assert_int_eq(recv(sock[1], data, 7, MSG_DONTWAIT), 7); ck_assert_int_eq(memcmp(data, "\x93\x00\x01\xa3hey", 7), 0); }
sinfo_t __init_new_thread_stack (caps_t c, int len,void *(*f)(void *) , void *targ,int arg_len) { len = merge_caps(c,len); // sum caps // it should be at least 16 or we'll be ssinfo_t ss = __get_stack_size(len,arg_len,stack_space); sinfo_t i = (sinfo_t) GC_malloc(ss.real_size); i->tid = _next_tid(); i->thread = f; i->info = ss; i->h = create_hashtable(25); // fprintf(stderr,"\nthread_malloc: %p", i); memcpy(i+1,targ,arg_len); struct _XTreeHandle *r = (struct _XTreeHandle *) (((char *)(i+1)) + arg_len); // fill-in the new tree and transfer capabilities __treecopy(c,r,len,i->tid,&i->h); // set stack guard page so as to handle, page faults. // Here we simply quit. // char *guard = (char *) ALIGN_PG(((char *) i) + ss.end_offset); // if(mprotect(guard,1024,1)) // errquit("__init_new_thread: mprotect failed"); //i->info.end_offset = (unsigned long long)guard - // (unsigned long long)i; //assert(i->info.end_offset+1024 <= i->info.real_size); return i; }
GC_PTR GC_local_malloc(size_t bytes) { if (EXPECT(!SMALL_ENOUGH(bytes),0)) { return(GC_malloc(bytes)); } else { int index = INDEX_FROM_BYTES(bytes); ptr_t * my_fl; ptr_t my_entry; # if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC) GC_key_t k = GC_thread_key; # endif void * tsd; # if defined(REDIRECT_MALLOC) && !defined(USE_PTHREAD_SPECIFIC) if (EXPECT(0 == k, 0)) { /* This can happen if we get called when the world is */ /* being initialized. Whether we can actually complete */ /* the initialization then is unclear. */ GC_init_parallel(); k = GC_thread_key; } # endif tsd = GC_getspecific(GC_thread_key); # ifdef GC_ASSERTIONS LOCK(); GC_ASSERT(tsd == (void *)GC_lookup_thread(pthread_self())); UNLOCK(); # endif my_fl = ((GC_thread)tsd) -> normal_freelists + index; my_entry = *my_fl; if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { ptr_t next = obj_link(my_entry); GC_PTR result = (GC_PTR)my_entry; *my_fl = next; obj_link(my_entry) = 0; PREFETCH_FOR_WRITE(next); return result; } else if ((word)my_entry - 1 < DIRECT_GRANULES) { *my_fl = my_entry + index + 1; return GC_malloc(bytes); } else { GC_generic_malloc_many(BYTES_FROM_INDEX(index), NORMAL, my_fl); if (*my_fl == 0) return GC_oom_fn(bytes); return GC_local_malloc(bytes); } } }
static void* allocate(std::size_t n) { IMMER_GC_INIT_GUARD_; auto p = GC_malloc(n); if (IMMER_UNLIKELY(!p)) throw std::bad_alloc{}; return p; }
GEN box_DF(double a) { dfloat_t *val = GC_malloc(sizeof(dfloat_t)); val->descriptor = dfloat_key; val->dval = a; return (GEN)val; }
/* This makes sure that the garbage collector sees all allocations, even those that we can't be bothered collecting, especially standard STL objects */ void* operator new(size_t n) { #ifdef DONT_COLLECT_STL return GC_malloc_uncollectable(n); // Don't collect, but mark #else return GC_malloc(n); // Collect everything #endif }
GEN box_SI(LONG a) { integer_t *val = GC_malloc(sizeof(integer_t)); val->descriptor = integer_key; val->ival = a; return (GEN)val; }
message * message_create(message_type type, message_action action) { message * mess = GC_malloc(sizeof(message)); mess->type = type; mess->action = action; mess->to_msgpack = message_to_msgpack_base; return mess; }
static ptable_t* alloc_ptable (int type) { ptable_t *ptable = GC_malloc (sizeof (ptable_t)); ptable->type = type; ptable->entries = &empty_ptable_entry; return ptable; }
void * objc_malloc (size_t size) { void *res = (void *)(GC_malloc (size)); if (! res) _objc_abort ("Virtual memory exhausted\n"); return res; }
static environment_t* alloc_env (environment_t *up, int num_bindings) { environment_t *env = GC_malloc (sizeof (environment_t) + num_bindings * sizeof (value_t*)); env->up = up; env->num_bindings = num_bindings; return env; }
unsigned long int* T() { unsigned long int* aux; aux = GC_malloc(SIZE, sizeof(unsigned long int) ); int i; for(i = 0; i < SIZE; i++) { aux[i] = Z( i ); } return init( aux , 0 , (unsigned long int) 9876 ); }
GEN CONS(GEN fst, GEN snd) { cons_t *val = GC_malloc(sizeof(cons_t)); val->descriptor = cons_key; val->fst = fst; val->snd = snd; return (GEN)val; }
smap* smap_alloc(int64_t size, stype* ktype, stype* vtype) { smap* map = GC_malloc(sizeof(smap)); map->size = size; map->ktype = ktype; map->vtype = vtype; if (size == 0) { map->data = 0 } else { int64_t item_size = ktype->size + vtype->size; map->data = GC_malloc(2 * item_size); } return map; }
void *safe_malloc(size_t size) { void *result = GC_malloc(size); if(!result) { perror("malloc"); exit(EXIT_FAILURE); } return result; }
static value_t* make_string_from_unichar (gunichar c) { gchar *buf = GC_malloc (7); string_t *s = (string_t*) alloc_value (PTABLE_NAME (cljc_DOT_core_SLASH_String), sizeof (string_t)); buf [g_unichar_to_utf8 (c, buf)] = '\0'; s->utf8 = buf; return &s->val; }
half_edge alloc_half_edge(void* v) { half_edge e = (half_edge) GC_malloc(sizeof(struct half_edge_cell)); e->vertex = v; e->opp = NULL; e->next = NULL; e->prev = NULL; e->visited = 0; return e; }
unsigned long int jsort() { unsigned long int* aux; aux = GC_malloc(SIZE, sizeof(unsigned long int) ); int i; for(i = 0; i < SIZE; i++) { aux[i] = J( i ); } return insort( aux )[0]; }