void f (void) { unsigned n = 0; T (__builtin_malloc (n)); n = 1024; /* 1 kibibyte (KB or KiB) */ T (__builtin_malloc (n)); n = 1025; T (__builtin_malloc (n)); /* { dg-warning "argument 1 value .1025. exceeds maximum object size 1024" } */ }
int main () { /* Heap allocated memory. */ char *p = (char *)__builtin_malloc (42); int r = foo (p); __builtin_free (p); p = (char *)__builtin_malloc (1024); bar (p, p + 1024); bar (p + 1024, p + 1023); bar (p + 1, p + 1023); __builtin_free (p); p = (char *)__builtin_malloc (4096); bar (p, p + 4096); bar (p + 10, p + 100); bar (p + 1024, p + 4096); bar (p + 4095, p + 4096); bar (p + 4095, p + 4094); bar (p + 100, p + 4096); bar (p + 100, p + 4094); __builtin_free (p); /* Global variable. */ bar (&global[0], &global[1]); bar (&global[1], &global[2]); bar (&global[2], &global[1]); bar (&global[0], &global[100]); bar (&global[1000], &global[7000]); bar (&global[500], &global[10]); p = &global[0]; bar (p, p + 8192); p = &global[8000]; bar (p, p + 192); p = &small_global[0]; bar (p, p + 1); bar (p, p + 7); bar (p + 7, p + 1); bar (p + 6, p + 7); bar (p + 7, p + 7); /* Stack variable. */ char stack[10000]; bar (&stack[0], &stack[100]); bar (&stack[1000], &stack[9000]); bar (&stack[500], &stack[10]); baz (0, &stack[10]); return 0; }
static void * inl (const char *x, const char *y) { T t = { &xa, &xb }; int *f = (int *) __builtin_malloc (sizeof (int)); const char *z; int o = 0; void *r = 0; for (z = y; *z; z++) { if (*z == 'r') o |= 1; if (*z == 'w') o |= 2; } if (o == 1) *f = baz (x, 0); if (o == 2) *f = baz (x, 1); if (o == 3) *f = baz (x, 2); if (o && *f > 0) r = bar (f, "w", t); return r; }
void test2(void) { int *p = __builtin_malloc (sizeof (int) * 4); if (p == (void *)0) __builtin_abort (); __builtin_free (p); }
void test3(int b) { int *p = __builtin_malloc (sizeof (int) * 4); if (b) __builtin_free (p); *p = 5; }
void foo(char *str) { int len2 = strlen (str); char *a = (char *) __builtin_malloc (0); char *b = (char *) __builtin_malloc (len2*3); if ((int) (a-b) < (len2*3)) { #ifdef _WIN32 abort (); #endif free(a); free(b); return; } free(a); free(b); }
void f (void) { size_t n = 0; T (__builtin_malloc (n)); n = __PTRDIFF_MAX__; T (__builtin_malloc (n)); n += 1; T (__builtin_malloc (n)); n = __SIZE_MAX__ - 1; T (__builtin_malloc (n)); n = __SIZE_MAX__; T (__builtin_malloc (n)); }
void test (void *p, unsigned n) { TEST (__builtin_aligned_alloc (n, 8)); TEST (__builtin_alloca (n)); TEST (__builtin_calloc (4, n)); TEST (__builtin_malloc (n)); TEST (__builtin_realloc (p, n + 1)); }
void test1(void) { int *p = __builtin_malloc (sizeof (int) * 4); int *q = p; *q++ = 4; *q++ = 4; __builtin_free (p); }
void f(int n) { char *p = __builtin_malloc (1); int i; do *p = 0; while (++i < n); }
int main() { void *p = __builtin_malloc (sizeof (B)); new (p) B; foo(p); reinterpret_cast<A *>(p)->~A(); return 0; }
void f1 (const char *c) { A *s = (A*) __builtin_malloc (sizeof (A)); double *p = &s->d; s->i = 42; __builtin_memcpy (p, c, sizeof (double)); int j = s->i; if (j != 42) __builtin_abort(); }
int main (void) { volatile int a[5]; a[4] = 1; a[2] = a[3]; fn_p (a[4]); fn_a (a); int i = 4; a[i] = 1; a[2] = a[i]; fn_p (a[i]); foo_i (i); const int n = 5; volatile int b[n]; b[4] = 1; b[2] = b[3]; fn_p (b[4]); fn_a (b); volatile int c[n][n][n]; c[2][2][2] = 2; i = c[4][4][4]; volatile struct S s; s.a[9] = 1; i = s.a[9]; /* Don't instrument flexible array members. */ struct T *t = (struct T *) __builtin_malloc (sizeof (struct T) + 10); t->a[1] = 1; struct U *u = (struct U *) __builtin_malloc (sizeof (struct U) + 10); u->a[1] = 1; long int *d[10][5]; d[9][0] = (long int *) 0; d[8][3] = d[9][0]; return 0; }
void foo(int n) { int * f = (int*) __builtin_malloc (n * sizeof (int)); int * ff = (int*) __builtin_malloc (n * sizeof (int)); int i; for (i = 0; i < n; ++i) { f[i] = 1; ff[i] = 2; if (f[i] != 1) link_error (); if (ff[i] != 2) link_error (); } __builtin_free (f); __builtin_free (ff); }
static void *bar(__SIZE_TYPE__ n, int cond) { void *p; if (cond) p = foo (n); else p = __builtin_malloc (n); return p; }
int main (void) { unsigned long d = 0; while (1) { switch (b) case 'S': d = a; c = __builtin_malloc (d); } return 0; }
int main () { int i = 1; int **p; j = 0; p = __builtin_malloc (sizeof (int *)); *p = &i; p = __builtin_realloc (p, 2 * sizeof (int *)); **p = 0; if (i != 0) __builtin_abort (); return j; }
int main () { struct S *p = __builtin_malloc (sizeof (struct S) + 16); if (p) { p->a = 1; __builtin_strcpy (p->b, "abcdefg"); if (foo (p) != 7 || bar (p) != 7) __builtin_abort (); __builtin_free (p); } return 0; }
int foobar (unsigned short length) { char *pbuf; __SIZE_TYPE__ size = (__SIZE_TYPE__) length; if (size < 4032) pbuf = (char *) __builtin_alloca(size); else pbuf = (char *) __builtin_malloc (size); useit(pbuf); return 0; }
inline void* operator new(size_t sz) { void *p; if (sz == 0) sz = 1; while ((p = __builtin_malloc (sz)) == 0) { handler_t handler = get_handle (); if (! handler) throw 42; handler (); } return p; }
void f(){ char*p=__builtin_malloc(42); __builtin_memset(p,3,10); __builtin_memset(p,7,33); }
void h(){ char*p=__builtin_malloc(42); g=__builtin_memset(p,3,10); __builtin_free(p); }
void test5(int b) { int *p = __builtin_malloc (sizeof (int) * 4); if (p) __builtin_free (p); }
char*i(){ char*p=__builtin_malloc(42); __builtin_memset(p,3,10); __builtin_memset(p,7,33); return p; }
void * foo (void) { return __builtin_malloc (5); }
static void *foo (__SIZE_TYPE__ n) { return __builtin_malloc (n * 10); }
void*f(){ char*p=__builtin_malloc(42); __builtin_memset(p,0,42); __builtin_memset(p,0,42); return p; };
void *test1(size_t n) { return __builtin_malloc(n); }
inline void* operator new(__SIZE_TYPE__ n){ return __builtin_malloc(n); }