自学教程：C++ GC_malloc函数代码示例

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 intregmatch_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_INLINEvoid* 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_TESTSTART_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];}