URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.dg/] [builtin-object-size-1.c] - Blame information for rev 701

Go to most recent revision | Details | Compare with Previous | View Log


/* { dg-do run } */
/* { dg-options "-O2" } */
 
typedef __SIZE_TYPE__ size_t;
extern void abort (void);
extern void exit (int);
extern void *malloc (size_t);
extern void *calloc (size_t, size_t);
extern void *alloca (size_t);
extern void *memcpy (void *, const void *, size_t);
extern void *memset (void *, int, size_t);
extern char *strcpy (char *, const char *);
 
struct A
{
  char a[10];
  int b;
  char c[10];
} y, w[4];
 
extern char exta[];
extern char extb[30];
extern struct A zerol[0];
 
void
__attribute__ ((noinline))
test1 (void *q, int x)
{
  struct A a;
  void *p = &a.a[3], *r;
  char var[x + 10];
  if (x < 0)
    r = &a.a[9];
  else
    r = &a.c[1];
  if (__builtin_object_size (p, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 3)
    abort ();
  if (__builtin_object_size (&a.c[9], 0)
      != sizeof (a) - __builtin_offsetof (struct A, c) - 9)
    abort ();
  if (__builtin_object_size (q, 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (r, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 9)
    abort ();
  if (x < 6)
    r = &w[2].a[1];
  else
    r = &a.a[6];
  if (__builtin_object_size (&y, 0)
      != sizeof (y))
    abort ();
  if (__builtin_object_size (w, 0)
      != sizeof (w))
    abort ();
  if (__builtin_object_size (&y.b, 0)
      != sizeof (a) - __builtin_offsetof (struct A, b))
    abort ();
  if (__builtin_object_size (r, 0)
      != 2 * sizeof (w[0]) - __builtin_offsetof (struct A, a) - 1)
    abort ();
  if (x < 20)
    r = malloc (30);
  else
    r = calloc (2, 16);
  /* We may duplicate this test onto the two exit paths.  On one path
     the size will be 32, the other it will be 30.  If we don't duplicate
     this test, then the size will be 32.  */
  if (__builtin_object_size (r, 0) != 2 * 16
      && __builtin_object_size (r, 0) != 30)
    abort ();
  if (x < 20)
    r = malloc (30);
  else
    r = calloc (2, 14);
  if (__builtin_object_size (r, 0) != 30)
    abort ();
  if (x < 30)
    r = malloc (sizeof (a));
  else
    r = &a.a[3];
  if (__builtin_object_size (r, 0) != sizeof (a))
    abort ();
  r = memcpy (r, "a", 2);
  if (__builtin_object_size (r, 0) != sizeof (a))
    abort ();
  r = memcpy (r + 2, "b", 2) + 2;
  if (__builtin_object_size (r, 0) != sizeof (a) - 4)
    abort ();
  r = &a.a[4];
  r = memset (r, 'a', 2);
  if (__builtin_object_size (r, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 4)
    abort ();
  r = memset (r + 2, 'b', 2) + 2;
  if (__builtin_object_size (r, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 8)
    abort ();
  r = &a.a[1];
  r = strcpy (r, "ab");
  if (__builtin_object_size (r, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 1)
    abort ();
  r = strcpy (r + 2, "cd") + 2;
  if (__builtin_object_size (r, 0)
      != sizeof (a) - __builtin_offsetof (struct A, a) - 5)
    abort ();
  if (__builtin_object_size (exta, 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (exta + 10, 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (&exta[5], 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (extb, 0) != sizeof (extb))
    abort ();
  if (__builtin_object_size (extb + 10, 0) != sizeof (extb) - 10)
    abort ();
  if (__builtin_object_size (&extb[5], 0) != sizeof (extb) - 5)
    abort ();
  if (__builtin_object_size (var, 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (var + 10, 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (&var[5], 0) != (size_t) -1)
    abort ();
  if (__builtin_object_size (zerol, 0) != 0)
    abort ();
  if (__builtin_object_size (&zerol, 0) != 0)
    abort ();
  if (__builtin_object_size (&zerol[0], 0) != 0)
    abort ();
  if (__builtin_object_size (zerol[0].a, 0) != 0)
    abort ();
  if (__builtin_object_size (&zerol[0].a[0], 0) != 0)
    abort ();
  if (__builtin_object_size (&zerol[0].b, 0) != 0)
    abort ();
  if (__builtin_object_size ("abcdefg", 0) != sizeof ("abcdefg"))
    abort ();
  if (__builtin_object_size ("abcd\0efg", 0) != sizeof ("abcd\0efg"))
    abort ();
  if (__builtin_object_size (&"abcd\0efg", 0) != sizeof ("abcd\0efg"))
    abort ();
  if (__builtin_object_size (&"abcd\0efg"[0], 0) != sizeof ("abcd\0efg"))
    abort ();
  if (__builtin_object_size (&"abcd\0efg"[4], 0) != sizeof ("abcd\0efg") - 4)
    abort ();
  if (__builtin_object_size ("abcd\0efg" + 5, 0) != sizeof ("abcd\0efg") - 5)
    abort ();
  if (__builtin_object_size (L"abcdefg", 0) != sizeof (L"abcdefg"))
    abort ();
  r = (char *) L"abcd\0efg";
  if (__builtin_object_size (r + 2, 0) != sizeof (L"abcd\0efg") - 2)
    abort ();
}
 
size_t l1 = 1;
 
void
__attribute__ ((noinline))
test2 (void)
{
  struct B { char buf1[10]; char buf2[10]; } a;
  char *r, buf3[20];
  int i;
 
  if (sizeof (a) != 20)
    return;
 
  r = buf3;
  for (i = 0; i < 4; ++i)
    {
      if (i == l1 - 1)
        r = &a.buf1[1];
      else if (i == l1)
        r = &a.buf2[7];
      else if (i == l1 + 1)
        r = &buf3[5];
      else if (i == l1 + 2)
        r = &a.buf1[9];
    }
  if (__builtin_object_size (r, 0) != 20)
    abort ();
  r = &buf3[20];
  for (i = 0; i < 4; ++i)
    {
      if (i == l1 - 1)
        r = &a.buf1[7];
      else if (i == l1)
        r = &a.buf2[7];
      else if (i == l1 + 1)
        r = &buf3[5];
      else if (i == l1 + 2)
        r = &a.buf1[9];
    }
  if (__builtin_object_size (r, 0) != 15)
    abort ();
  r += 8;
  if (__builtin_object_size (r, 0) != 7)
    abort ();
  if (__builtin_object_size (r + 6, 0) != 1)
    abort ();
  r = &buf3[18];
  for (i = 0; i < 4; ++i)
    {
      if (i == l1 - 1)
        r = &a.buf1[9];
      else if (i == l1)
        r = &a.buf2[9];
      else if (i == l1 + 1)
        r = &buf3[5];
      else if (i == l1 + 2)
        r = &a.buf1[4];
    }
  if (__builtin_object_size (r + 12, 0) != 4)
    abort ();
}
 
void
__attribute__ ((noinline))
test3 (void)
{
  char buf4[10];
  struct B { struct A a[2]; struct A b; char c[4]; char d; double e;
             _Complex double f; } x;
  double y;
  _Complex double z;
  double *dp;
 
  if (__builtin_object_size (buf4, 0) != sizeof (buf4))
    abort ();
  if (__builtin_object_size (&buf4, 0) != sizeof (buf4))
    abort ();
  if (__builtin_object_size (&buf4[0], 0) != sizeof (buf4))
    abort ();
  if (__builtin_object_size (&buf4[1], 0) != sizeof (buf4) - 1)
    abort ();
  if (__builtin_object_size (&x, 0) != sizeof (x))
    abort ();
  if (__builtin_object_size (&x.a, 0) != sizeof (x))
    abort ();
  if (__builtin_object_size (&x.a[0], 0) != sizeof (x))
    abort ();
  if (__builtin_object_size (&x.a[0].a, 0) != sizeof (x))
    abort ();
  if (__builtin_object_size (&x.a[0].a[0], 0) != sizeof (x))
    abort ();
  if (__builtin_object_size (&x.a[0].a[3], 0) != sizeof (x) - 3)
    abort ();
  if (__builtin_object_size (&x.a[0].b, 0)
      != sizeof (x) - __builtin_offsetof (struct A, b))
    abort ();
  if (__builtin_object_size (&x.a[1].c, 0)
      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
    abort ();
  if (__builtin_object_size (&x.a[1].c[0], 0)
      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))
    abort ();
  if (__builtin_object_size (&x.a[1].c[3], 0)
      != sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3)
    abort ();
  if (__builtin_object_size (&x.b, 0)
      != sizeof (x) - __builtin_offsetof (struct B, b))
    abort ();
  if (__builtin_object_size (&x.b.a, 0)
      != sizeof (x) - __builtin_offsetof (struct B, b))
    abort ();
  if (__builtin_object_size (&x.b.a[0], 0)
      != sizeof (x) - __builtin_offsetof (struct B, b))
    abort ();
  if (__builtin_object_size (&x.b.a[3], 0)
      != sizeof (x) - __builtin_offsetof (struct B, b) - 3)
    abort ();
  if (__builtin_object_size (&x.b.b, 0)
      != sizeof (x) - __builtin_offsetof (struct B, b)
         - __builtin_offsetof (struct A, b))
    abort ();
  if (__builtin_object_size (&x.b.c, 0)
      != sizeof (x) - __builtin_offsetof (struct B, b)
         - __builtin_offsetof (struct A, c))
    abort ();
  if (__builtin_object_size (&x.b.c[0], 0)
      != sizeof (x) - __builtin_offsetof (struct B, b)
         - __builtin_offsetof (struct A, c))
    abort ();
  if (__builtin_object_size (&x.b.c[3], 0)
      != sizeof (x) - __builtin_offsetof (struct B, b)
         - __builtin_offsetof (struct A, c) - 3)
    abort ();
  if (__builtin_object_size (&x.c, 0)
      != sizeof (x) - __builtin_offsetof (struct B, c))
    abort ();
  if (__builtin_object_size (&x.c[0], 0)
      != sizeof (x) - __builtin_offsetof (struct B, c))
    abort ();
  if (__builtin_object_size (&x.c[1], 0)
      != sizeof (x) - __builtin_offsetof (struct B, c) - 1)
    abort ();
  if (__builtin_object_size (&x.d, 0)
      != sizeof (x) - __builtin_offsetof (struct B, d))
    abort ();
  if (__builtin_object_size (&x.e, 0)
      != sizeof (x) - __builtin_offsetof (struct B, e))
    abort ();
  if (__builtin_object_size (&x.f, 0)
      != sizeof (x) - __builtin_offsetof (struct B, f))
    abort ();
  dp = &__real__ x.f;
  if (__builtin_object_size (dp, 0)
      != sizeof (x) - __builtin_offsetof (struct B, f))
    abort ();
  dp = &__imag__ x.f;
  if (__builtin_object_size (dp, 0)
      != sizeof (x) - __builtin_offsetof (struct B, f)
         - sizeof (x.f) / 2)
    abort ();
  dp = &y;
  if (__builtin_object_size (dp, 0) != sizeof (y))
    abort ();
  if (__builtin_object_size (&z, 0) != sizeof (z))
    abort ();
  dp = &__real__ z;
  if (__builtin_object_size (dp, 0) != sizeof (z))
    abort ();
  dp = &__imag__ z;
  if (__builtin_object_size (dp, 0) != sizeof (z) / 2)
    abort ();
}
 
struct S { unsigned int a; };
 
char *
__attribute__ ((noinline))
test4 (char *x, int y)
{
  register int i;
  struct A *p;
 
  for (i = 0; i < y; i++)
    {
      p = (struct A *) x;
      x = (char *) &p[1];
      if (__builtin_object_size (p, 0) != (size_t) -1)
        abort ();
    }
  return x;
}
 
void
__attribute__ ((noinline))
test5 (size_t x)
{
  char buf[64];
  char *p = &buf[8];
  size_t i;
 
  for (i = 0; i < x; ++i)
    p = p + 4;
  /* My understanding of ISO C99 6.5.6 is that a conforming
     program will not end up with p equal to &buf[0]
     through &buf[7], i.e. calling this function with say
     UINTPTR_MAX / 4 results in undefined behaviour.
     If that's true, then the maximum number of remaining
     bytes from p until end of the object is 56, otherwise
     it would be 64 (or conservative (size_t) -1 == unknown).  */
  if (__builtin_object_size (p, 0) != sizeof (buf) - 8)
    abort ();
  memset (p, ' ', sizeof (buf) - 8 - 4 * 4);
}
 
void
__attribute__ ((noinline))
test6 (size_t x)
{
  struct T { char buf[64]; char buf2[64]; } t;
  char *p = &t.buf[8];
  size_t i;
 
  for (i = 0; i < x; ++i)
    p = p + 4;
  if (__builtin_object_size (p, 0) != sizeof (t) - 8)
    abort ();
  memset (p, ' ', sizeof (t) - 8 - 4 * 4);
}
 
void
__attribute__ ((noinline))
test7 (void)
{
  char buf[64];
  struct T { char buf[64]; char buf2[64]; } t;
  char *p = &buf[64], *q = &t.buf[64];
 
  if (__builtin_object_size (p + 64, 0) != 0)
    abort ();
  if (__builtin_object_size (q + 63, 0) != sizeof (t) - 64 - 63)
    abort ();
  if (__builtin_object_size (q + 64, 0) != sizeof (t) - 64 - 64)
    abort ();
  if (__builtin_object_size (q + 256, 0) != 0)
    abort ();
}
 
void
__attribute__ ((noinline))
test8 (void)
{
  struct T { char buf[10]; char buf2[10]; } t;
  char *p = &t.buf2[-4];
  char *q = &t.buf2[0];
  if (__builtin_object_size (p, 0) != sizeof (t) - 10 + 4)
    abort ();
  if (__builtin_object_size (q, 0) != sizeof (t) - 10)
    abort ();
  /* GCC only handles additions, not subtractions.  */
  q = q - 8;
  if (__builtin_object_size (q, 0) != (size_t) -1
      && __builtin_object_size (q, 0) != sizeof (t) - 10 + 8)
    abort ();
  p = &t.buf[-4];
  if (__builtin_object_size (p, 0) != 0)
    abort ();
}
 
int
main (void)
{
  struct S s[10];
  __asm ("" : "=r" (l1) : "0" (l1));
  test1 (main, 6);
  test2 ();
  test3 ();
  test4 ((char *) s, 10);
  test5 (4);
  test6 (4);
  test7 ();
  test8 ();
  exit (0);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.dg/] [builtin-object-size-1.c] - Blame information for rev 701

Line No.	Rev	Author	Line
1	689	jeremybenn	`/* { dg-do run } */`
2			`/* { dg-options "-O2" } */`
3
4			`typedef __SIZE_TYPE__ size_t;`
5			`extern void abort (void);`
6			`extern void exit (int);`
7			`extern void *malloc (size_t);`
8			`extern void *calloc (size_t, size_t);`
9			`extern void *alloca (size_t);`
10			`extern void memcpy (void , const void *, size_t);`
11			`extern void memset (void , int, size_t);`
12			`extern char strcpy (char , const char *);`
13
14			`struct A`
15			`{`
16			`char a[10];`
17			`int b;`
18			`char c[10];`
19			`} y, w[4];`
20
21			`extern char exta[];`
22			`extern char extb[30];`
23			`extern struct A zerol[0];`
24
25			`void`
26			`__attribute__ ((noinline))`
27			`test1 (void *q, int x)`
28			`{`
29			`struct A a;`
30			`void p = &a.a[3], r;`
31			`char var[x + 10];`
32			`if (x < 0)`
33			`r = &a.a[9];`
34			`else`
35			`r = &a.c[1];`
36			`if (__builtin_object_size (p, 0)`
37			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 3)`
38			`abort ();`
39			`if (__builtin_object_size (&a.c[9], 0)`
40			`!= sizeof (a) - __builtin_offsetof (struct A, c) - 9)`
41			`abort ();`
42			`if (__builtin_object_size (q, 0) != (size_t) -1)`
43			`abort ();`
44			`if (__builtin_object_size (r, 0)`
45			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 9)`
46			`abort ();`
47			`if (x < 6)`
48			`r = &w[2].a[1];`
49			`else`
50			`r = &a.a[6];`
51			`if (__builtin_object_size (&y, 0)`
52			`!= sizeof (y))`
53			`abort ();`
54			`if (__builtin_object_size (w, 0)`
55			`!= sizeof (w))`
56			`abort ();`
57			`if (__builtin_object_size (&y.b, 0)`
58			`!= sizeof (a) - __builtin_offsetof (struct A, b))`
59			`abort ();`
60			`if (__builtin_object_size (r, 0)`
61			`!= 2 * sizeof (w[0]) - __builtin_offsetof (struct A, a) - 1)`
62			`abort ();`
63			`if (x < 20)`
64			`r = malloc (30);`
65			`else`
66			`r = calloc (2, 16);`
67			`/* We may duplicate this test onto the two exit paths. On one path`
68			`the size will be 32, the other it will be 30. If we don't duplicate`
69			`this test, then the size will be 32. */`
70			`if (__builtin_object_size (r, 0) != 2 * 16`
71			`&& __builtin_object_size (r, 0) != 30)`
72			`abort ();`
73			`if (x < 20)`
74			`r = malloc (30);`
75			`else`
76			`r = calloc (2, 14);`
77			`if (__builtin_object_size (r, 0) != 30)`
78			`abort ();`
79			`if (x < 30)`
80			`r = malloc (sizeof (a));`
81			`else`
82			`r = &a.a[3];`
83			`if (__builtin_object_size (r, 0) != sizeof (a))`
84			`abort ();`
85			`r = memcpy (r, "a", 2);`
86			`if (__builtin_object_size (r, 0) != sizeof (a))`
87			`abort ();`
88			`r = memcpy (r + 2, "b", 2) + 2;`
89			`if (__builtin_object_size (r, 0) != sizeof (a) - 4)`
90			`abort ();`
91			`r = &a.a[4];`
92			`r = memset (r, 'a', 2);`
93			`if (__builtin_object_size (r, 0)`
94			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 4)`
95			`abort ();`
96			`r = memset (r + 2, 'b', 2) + 2;`
97			`if (__builtin_object_size (r, 0)`
98			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 8)`
99			`abort ();`
100			`r = &a.a[1];`
101			`r = strcpy (r, "ab");`
102			`if (__builtin_object_size (r, 0)`
103			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 1)`
104			`abort ();`
105			`r = strcpy (r + 2, "cd") + 2;`
106			`if (__builtin_object_size (r, 0)`
107			`!= sizeof (a) - __builtin_offsetof (struct A, a) - 5)`
108			`abort ();`
109			`if (__builtin_object_size (exta, 0) != (size_t) -1)`
110			`abort ();`
111			`if (__builtin_object_size (exta + 10, 0) != (size_t) -1)`
112			`abort ();`
113			`if (__builtin_object_size (&exta[5], 0) != (size_t) -1)`
114			`abort ();`
115			`if (__builtin_object_size (extb, 0) != sizeof (extb))`
116			`abort ();`
117			`if (__builtin_object_size (extb + 10, 0) != sizeof (extb) - 10)`
118			`abort ();`
119			`if (__builtin_object_size (&extb[5], 0) != sizeof (extb) - 5)`
120			`abort ();`
121			`if (__builtin_object_size (var, 0) != (size_t) -1)`
122			`abort ();`
123			`if (__builtin_object_size (var + 10, 0) != (size_t) -1)`
124			`abort ();`
125			`if (__builtin_object_size (&var[5], 0) != (size_t) -1)`
126			`abort ();`
127			`if (__builtin_object_size (zerol, 0) != 0)`
128			`abort ();`
129			`if (__builtin_object_size (&zerol, 0) != 0)`
130			`abort ();`
131			`if (__builtin_object_size (&zerol[0], 0) != 0)`
132			`abort ();`
133			`if (__builtin_object_size (zerol[0].a, 0) != 0)`
134			`abort ();`
135			`if (__builtin_object_size (&zerol[0].a[0], 0) != 0)`
136			`abort ();`
137			`if (__builtin_object_size (&zerol[0].b, 0) != 0)`
138			`abort ();`
139			`if (__builtin_object_size ("abcdefg", 0) != sizeof ("abcdefg"))`
140			`abort ();`
141			`if (__builtin_object_size ("abcd\0efg", 0) != sizeof ("abcd\0efg"))`
142			`abort ();`
143			`if (__builtin_object_size (&"abcd\0efg", 0) != sizeof ("abcd\0efg"))`
144			`abort ();`
145			`if (__builtin_object_size (&"abcd\0efg"[0], 0) != sizeof ("abcd\0efg"))`
146			`abort ();`
147			`if (__builtin_object_size (&"abcd\0efg"[4], 0) != sizeof ("abcd\0efg") - 4)`
148			`abort ();`
149			`if (__builtin_object_size ("abcd\0efg" + 5, 0) != sizeof ("abcd\0efg") - 5)`
150			`abort ();`
151			`if (__builtin_object_size (L"abcdefg", 0) != sizeof (L"abcdefg"))`
152			`abort ();`
153			`r = (char *) L"abcd\0efg";`
154			`if (__builtin_object_size (r + 2, 0) != sizeof (L"abcd\0efg") - 2)`
155			`abort ();`
156			`}`
157
158			`size_t l1 = 1;`
159
160			`void`
161			`__attribute__ ((noinline))`
162			`test2 (void)`
163			`{`
164			`struct B { char buf1[10]; char buf2[10]; } a;`
165			`char *r, buf3[20];`
166			`int i;`
167
168			`if (sizeof (a) != 20)`
169			`return;`
170
171			`r = buf3;`
172			`for (i = 0; i < 4; ++i)`
173			`{`
174			`if (i == l1 - 1)`
175			`r = &a.buf1[1];`
176			`else if (i == l1)`
177			`r = &a.buf2[7];`
178			`else if (i == l1 + 1)`
179			`r = &buf3[5];`
180			`else if (i == l1 + 2)`
181			`r = &a.buf1[9];`
182			`}`
183			`if (__builtin_object_size (r, 0) != 20)`
184			`abort ();`
185			`r = &buf3[20];`
186			`for (i = 0; i < 4; ++i)`
187			`{`
188			`if (i == l1 - 1)`
189			`r = &a.buf1[7];`
190			`else if (i == l1)`
191			`r = &a.buf2[7];`
192			`else if (i == l1 + 1)`
193			`r = &buf3[5];`
194			`else if (i == l1 + 2)`
195			`r = &a.buf1[9];`
196			`}`
197			`if (__builtin_object_size (r, 0) != 15)`
198			`abort ();`
199			`r += 8;`
200			`if (__builtin_object_size (r, 0) != 7)`
201			`abort ();`
202			`if (__builtin_object_size (r + 6, 0) != 1)`
203			`abort ();`
204			`r = &buf3[18];`
205			`for (i = 0; i < 4; ++i)`
206			`{`
207			`if (i == l1 - 1)`
208			`r = &a.buf1[9];`
209			`else if (i == l1)`
210			`r = &a.buf2[9];`
211			`else if (i == l1 + 1)`
212			`r = &buf3[5];`
213			`else if (i == l1 + 2)`
214			`r = &a.buf1[4];`
215			`}`
216			`if (__builtin_object_size (r + 12, 0) != 4)`
217			`abort ();`
218			`}`
219
220			`void`
221			`__attribute__ ((noinline))`
222			`test3 (void)`
223			`{`
224			`char buf4[10];`
225			`struct B { struct A a[2]; struct A b; char c[4]; char d; double e;`
226			`_Complex double f; } x;`
227			`double y;`
228			`_Complex double z;`
229			`double *dp;`
230
231			`if (__builtin_object_size (buf4, 0) != sizeof (buf4))`
232			`abort ();`
233			`if (__builtin_object_size (&buf4, 0) != sizeof (buf4))`
234			`abort ();`
235			`if (__builtin_object_size (&buf4[0], 0) != sizeof (buf4))`
236			`abort ();`
237			`if (__builtin_object_size (&buf4[1], 0) != sizeof (buf4) - 1)`
238			`abort ();`
239			`if (__builtin_object_size (&x, 0) != sizeof (x))`
240			`abort ();`
241			`if (__builtin_object_size (&x.a, 0) != sizeof (x))`
242			`abort ();`
243			`if (__builtin_object_size (&x.a[0], 0) != sizeof (x))`
244			`abort ();`
245			`if (__builtin_object_size (&x.a[0].a, 0) != sizeof (x))`
246			`abort ();`
247			`if (__builtin_object_size (&x.a[0].a[0], 0) != sizeof (x))`
248			`abort ();`
249			`if (__builtin_object_size (&x.a[0].a[3], 0) != sizeof (x) - 3)`
250			`abort ();`
251			`if (__builtin_object_size (&x.a[0].b, 0)`
252			`!= sizeof (x) - __builtin_offsetof (struct A, b))`
253			`abort ();`
254			`if (__builtin_object_size (&x.a[1].c, 0)`
255			`!= sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))`
256			`abort ();`
257			`if (__builtin_object_size (&x.a[1].c[0], 0)`
258			`!= sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c))`
259			`abort ();`
260			`if (__builtin_object_size (&x.a[1].c[3], 0)`
261			`!= sizeof (x) - sizeof (struct A) - __builtin_offsetof (struct A, c) - 3)`
262			`abort ();`
263			`if (__builtin_object_size (&x.b, 0)`
264			`!= sizeof (x) - __builtin_offsetof (struct B, b))`
265			`abort ();`
266			`if (__builtin_object_size (&x.b.a, 0)`
267			`!= sizeof (x) - __builtin_offsetof (struct B, b))`
268			`abort ();`
269			`if (__builtin_object_size (&x.b.a[0], 0)`
270			`!= sizeof (x) - __builtin_offsetof (struct B, b))`
271			`abort ();`
272			`if (__builtin_object_size (&x.b.a[3], 0)`
273			`!= sizeof (x) - __builtin_offsetof (struct B, b) - 3)`
274			`abort ();`
275			`if (__builtin_object_size (&x.b.b, 0)`
276			`!= sizeof (x) - __builtin_offsetof (struct B, b)`
277			`- __builtin_offsetof (struct A, b))`
278			`abort ();`
279			`if (__builtin_object_size (&x.b.c, 0)`
280			`!= sizeof (x) - __builtin_offsetof (struct B, b)`
281			`- __builtin_offsetof (struct A, c))`
282			`abort ();`
283			`if (__builtin_object_size (&x.b.c[0], 0)`
284			`!= sizeof (x) - __builtin_offsetof (struct B, b)`
285			`- __builtin_offsetof (struct A, c))`
286			`abort ();`
287			`if (__builtin_object_size (&x.b.c[3], 0)`
288			`!= sizeof (x) - __builtin_offsetof (struct B, b)`
289			`- __builtin_offsetof (struct A, c) - 3)`
290			`abort ();`
291			`if (__builtin_object_size (&x.c, 0)`
292			`!= sizeof (x) - __builtin_offsetof (struct B, c))`
293			`abort ();`
294			`if (__builtin_object_size (&x.c[0], 0)`
295			`!= sizeof (x) - __builtin_offsetof (struct B, c))`
296			`abort ();`
297			`if (__builtin_object_size (&x.c[1], 0)`
298			`!= sizeof (x) - __builtin_offsetof (struct B, c) - 1)`
299			`abort ();`
300			`if (__builtin_object_size (&x.d, 0)`
301			`!= sizeof (x) - __builtin_offsetof (struct B, d))`
302			`abort ();`
303			`if (__builtin_object_size (&x.e, 0)`
304			`!= sizeof (x) - __builtin_offsetof (struct B, e))`
305			`abort ();`
306			`if (__builtin_object_size (&x.f, 0)`
307			`!= sizeof (x) - __builtin_offsetof (struct B, f))`
308			`abort ();`
309			`dp = &__real__ x.f;`
310			`if (__builtin_object_size (dp, 0)`
311			`!= sizeof (x) - __builtin_offsetof (struct B, f))`
312			`abort ();`
313			`dp = &__imag__ x.f;`
314			`if (__builtin_object_size (dp, 0)`
315			`!= sizeof (x) - __builtin_offsetof (struct B, f)`
316			`- sizeof (x.f) / 2)`
317			`abort ();`
318			`dp = &y;`
319			`if (__builtin_object_size (dp, 0) != sizeof (y))`
320			`abort ();`
321			`if (__builtin_object_size (&z, 0) != sizeof (z))`
322			`abort ();`
323			`dp = &__real__ z;`
324			`if (__builtin_object_size (dp, 0) != sizeof (z))`
325			`abort ();`
326			`dp = &__imag__ z;`
327			`if (__builtin_object_size (dp, 0) != sizeof (z) / 2)`
328			`abort ();`
329			`}`
330
331			`struct S { unsigned int a; };`
332
333			`char *`
334			`__attribute__ ((noinline))`
335			`test4 (char *x, int y)`
336			`{`
337			`register int i;`
338			`struct A *p;`
339
340			`for (i = 0; i < y; i++)`
341			`{`
342			`p = (struct A *) x;`
343			`x = (char *) &p[1];`
344			`if (__builtin_object_size (p, 0) != (size_t) -1)`
345			`abort ();`
346			`}`
347			`return x;`
348			`}`
349
350			`void`
351			`__attribute__ ((noinline))`
352			`test5 (size_t x)`
353			`{`
354			`char buf[64];`
355			`char *p = &buf[8];`
356			`size_t i;`
357
358			`for (i = 0; i < x; ++i)`
359			`p = p + 4;`
360			`/* My understanding of ISO C99 6.5.6 is that a conforming`
361			`program will not end up with p equal to &buf[0]`
362			`through &buf[7], i.e. calling this function with say`
363			`UINTPTR_MAX / 4 results in undefined behaviour.`
364			`If that's true, then the maximum number of remaining`
365			`bytes from p until end of the object is 56, otherwise`
366			`it would be 64 (or conservative (size_t) -1 == unknown). */`
367			`if (__builtin_object_size (p, 0) != sizeof (buf) - 8)`
368			`abort ();`
369			`memset (p, ' ', sizeof (buf) - 8 - 4 * 4);`
370			`}`
371
372			`void`
373			`__attribute__ ((noinline))`
374			`test6 (size_t x)`
375			`{`
376			`struct T { char buf[64]; char buf2[64]; } t;`
377			`char *p = &t.buf[8];`
378			`size_t i;`
379
380			`for (i = 0; i < x; ++i)`
381			`p = p + 4;`
382			`if (__builtin_object_size (p, 0) != sizeof (t) - 8)`
383			`abort ();`
384			`memset (p, ' ', sizeof (t) - 8 - 4 * 4);`
385			`}`
386
387			`void`
388			`__attribute__ ((noinline))`
389			`test7 (void)`
390			`{`
391			`char buf[64];`
392			`struct T { char buf[64]; char buf2[64]; } t;`
393			`char p = &buf[64], q = &t.buf[64];`
394
395			`if (__builtin_object_size (p + 64, 0) != 0)`
396			`abort ();`
397			`if (__builtin_object_size (q + 63, 0) != sizeof (t) - 64 - 63)`
398			`abort ();`
399			`if (__builtin_object_size (q + 64, 0) != sizeof (t) - 64 - 64)`
400			`abort ();`
401			`if (__builtin_object_size (q + 256, 0) != 0)`
402			`abort ();`
403			`}`
404
405			`void`
406			`__attribute__ ((noinline))`
407			`test8 (void)`
408			`{`
409			`struct T { char buf[10]; char buf2[10]; } t;`
410			`char *p = &t.buf2[-4];`
411			`char *q = &t.buf2[0];`
412			`if (__builtin_object_size (p, 0) != sizeof (t) - 10 + 4)`
413			`abort ();`
414			`if (__builtin_object_size (q, 0) != sizeof (t) - 10)`
415			`abort ();`
416			`/* GCC only handles additions, not subtractions. */`
417			`q = q - 8;`
418			`if (__builtin_object_size (q, 0) != (size_t) -1`
419			`&& __builtin_object_size (q, 0) != sizeof (t) - 10 + 8)`
420			`abort ();`
421			`p = &t.buf[-4];`
422			`if (__builtin_object_size (p, 0) != 0)`
423			`abort ();`
424			`}`
425
426			`int`
427			`main (void)`
428			`{`
429			`struct S s[10];`
430			`__asm ("" : "=r" (l1) : "0" (l1));`
431			`test1 (main, 6);`
432			`test2 ();`
433			`test3 ();`
434			`test4 ((char *) s, 10);`
435			`test5 (4);`
436			`test6 (4);`
437			`test7 ();`
438			`test8 ();`
439			`exit (0);`
440			`}`