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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.c-torture/] [execute/] [builtins/] [lib/] [chk.c] - Blame information for rev 774

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


#include <stdarg.h>
#ifdef __unix__
#include <sys/types.h>
#endif
 
extern void abort (void);
 
extern int inside_main;
void *chk_fail_buf[256] __attribute__((aligned (16)));
volatile int chk_fail_allowed, chk_calls;
volatile int memcpy_disallowed, mempcpy_disallowed, memmove_disallowed;
volatile int memset_disallowed, strcpy_disallowed, stpcpy_disallowed;
volatile int strncpy_disallowed, stpncpy_disallowed, strcat_disallowed;
volatile int strncat_disallowed, sprintf_disallowed, vsprintf_disallowed;
volatile int snprintf_disallowed, vsnprintf_disallowed;
extern __SIZE_TYPE__ strlen (const char *);
extern int vsprintf (char *, const char *, va_list);
 
void __attribute__((noreturn))
__chk_fail (void)
{
  if (chk_fail_allowed)
    __builtin_longjmp (chk_fail_buf, 1);
  abort ();
}
 
void *
memcpy (void *dst, const void *src, __SIZE_TYPE__ n)
{
  const char *srcp;
  char *dstp;
 
#ifdef __OPTIMIZE__
  if (memcpy_disallowed && inside_main)
    abort ();
#endif
 
  srcp = src;
  dstp = dst;
  while (n-- != 0)
    *dstp++ = *srcp++;
 
  return dst;
}
 
void *
__memcpy_chk (void *dst, const void *src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into memcpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return memcpy (dst, src, n);
}
 
void *
mempcpy (void *dst, const void *src, __SIZE_TYPE__ n)
{
  const char *srcp;
  char *dstp;
 
#ifdef __OPTIMIZE__
  if (mempcpy_disallowed && inside_main)
    abort ();
#endif
 
  srcp = src;
  dstp = dst;
  while (n-- != 0)
    *dstp++ = *srcp++;
 
  return dstp;
}
 
void *
__mempcpy_chk (void *dst, const void *src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into mempcpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return mempcpy (dst, src, n);
}
 
void *
memmove (void *dst, const void *src, __SIZE_TYPE__ n)
{
  const char *srcp;
  char *dstp;
 
#ifdef __OPTIMIZE__
  if (memmove_disallowed && inside_main)
    abort ();
#endif
 
  srcp = src;
  dstp = dst;
  if (srcp < dstp)
    while (n-- != 0)
      dstp[n] = srcp[n];
  else
    while (n-- != 0)
      *dstp++ = *srcp++;
 
  return dst;
}
 
void *
__memmove_chk (void *dst, const void *src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into memmove.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return memmove (dst, src, n);
}
 
void *
memset (void *dst, int c, __SIZE_TYPE__ n)
{
  /* Single-byte memsets should be done inline when optimisation
     is enabled.  */
#ifdef __OPTIMIZE__
  if (memset_disallowed && inside_main && n < 2)
    abort ();
#endif
 
  while (n-- != 0)
    n[(char *) dst] = c;
 
  return dst;
}
 
void *
__memset_chk (void *dst, int c, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into memset.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return memset (dst, c, n);
}
 
char *
strcpy (char *d, const char *s)
{
  char *r = d;
#ifdef __OPTIMIZE__
  if (strcpy_disallowed && inside_main)
    abort ();
#endif
  while ((*d++ = *s++));
  return r;
}
 
char *
__strcpy_chk (char *d, const char *s, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into strcpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (strlen (s) >= size)
    __chk_fail ();
  return strcpy (d, s);
}
 
char *
stpcpy (char *dst, const char *src)
{
#ifdef __OPTIMIZE__
  if (stpcpy_disallowed && inside_main)
    abort ();
#endif
 
  while (*src != 0)
    *dst++ = *src++;
 
  *dst = 0;
  return dst;
}
 
char *
__stpcpy_chk (char *d, const char *s, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into stpcpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (strlen (s) >= size)
    __chk_fail ();
  return stpcpy (d, s);
}
 
char *
stpncpy (char *dst, const char *src, __SIZE_TYPE__ n)
{
#ifdef __OPTIMIZE__
  if (stpncpy_disallowed && inside_main)
    abort ();
#endif
 
  for (; *src && n; n--)
    *dst++ = *src++;
 
  char *ret = dst;
 
  while (n--)
    *dst++ = 0;
 
  return ret;
}
 
 
char *
__stpncpy_chk (char *s1, const char *s2, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into stpncpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return stpncpy (s1, s2, n);
}
 
char *
strncpy (char *s1, const char *s2, __SIZE_TYPE__ n)
{
  char *dest = s1;
#ifdef __OPTIMIZE__
  if (strncpy_disallowed && inside_main)
    abort();
#endif
  for (; *s2 && n; n--)
    *s1++ = *s2++;
  while (n--)
    *s1++ = 0;
  return dest;
}
 
char *
__strncpy_chk (char *s1, const char *s2, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into strncpy.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (n > size)
    __chk_fail ();
  return strncpy (s1, s2, n);
}
 
char *
strcat (char *dst, const char *src)
{
  char *p = dst;
 
#ifdef __OPTIMIZE__
  if (strcat_disallowed && inside_main)
    abort ();
#endif
 
  while (*p)
    p++;
  while ((*p++ = *src++))
    ;
  return dst;
}
 
char *
__strcat_chk (char *d, const char *s, __SIZE_TYPE__ size)
{
  /* If size is -1, GCC should always optimize the call into strcat.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  if (strlen (d) + strlen (s) >= size)
    __chk_fail ();
  return strcat (d, s);
}
 
char *
strncat (char *s1, const char *s2, __SIZE_TYPE__ n)
{
  char *dest = s1;
  char c;
#ifdef __OPTIMIZE__
  if (strncat_disallowed && inside_main)
    abort();
#endif
  while (*s1) s1++;
  c = '\0';
  while (n > 0)
    {
      c = *s2++;
      *s1++ = c;
      if (c == '\0')
        return dest;
      n--;
    }
  if (c != '\0')
    *s1 = '\0';
  return dest;
}
 
char *
__strncat_chk (char *d, const char *s, __SIZE_TYPE__ n, __SIZE_TYPE__ size)
{
  __SIZE_TYPE__ len = strlen (d), n1 = n;
  const char *s1 = s;
 
  /* If size is -1, GCC should always optimize the call into strncat.  */
  if (size == (__SIZE_TYPE__) -1)
    abort ();
  ++chk_calls;
  while (len < size && n1 > 0)
    {
      if (*s1++ == '\0')
        break;
      ++len;
      --n1;
    }
 
  if (len >= size)
    __chk_fail ();
  return strncat (d, s, n);
}
 
/* No chk test in GCC testsuite needs more bytes than this.
   As we can't expect vsnprintf to be available on the target,
   assume 4096 bytes is enough.  */
static char chk_sprintf_buf[4096];
 
int
__sprintf_chk (char *str, int flag, __SIZE_TYPE__ size, const char *fmt, ...)
{
  int ret;
  va_list ap;
 
  /* If size is -1 and flag 0, GCC should always optimize the call into
     sprintf.  */
  if (size == (__SIZE_TYPE__) -1 && flag == 0)
    abort ();
  ++chk_calls;
#ifdef __OPTIMIZE__
  if (sprintf_disallowed && inside_main)
    abort();
#endif
  va_start (ap, fmt);
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  va_end (ap);
  if (ret >= 0)
    {
      if (ret >= size)
        __chk_fail ();
      memcpy (str, chk_sprintf_buf, ret + 1);
    }
  return ret;
}
 
int
__vsprintf_chk (char *str, int flag, __SIZE_TYPE__ size, const char *fmt,
                va_list ap)
{
  int ret;
 
  /* If size is -1 and flag 0, GCC should always optimize the call into
     vsprintf.  */
  if (size == (__SIZE_TYPE__) -1 && flag == 0)
    abort ();
  ++chk_calls;
#ifdef __OPTIMIZE__
  if (vsprintf_disallowed && inside_main)
    abort();
#endif
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  if (ret >= 0)
    {
      if (ret >= size)
        __chk_fail ();
      memcpy (str, chk_sprintf_buf, ret + 1);
    }
  return ret;
}
 
int
__snprintf_chk (char *str, __SIZE_TYPE__ len, int flag, __SIZE_TYPE__ size,
                const char *fmt, ...)
{
  int ret;
  va_list ap;
 
  /* If size is -1 and flag 0, GCC should always optimize the call into
     snprintf.  */
  if (size == (__SIZE_TYPE__) -1 && flag == 0)
    abort ();
  ++chk_calls;
  if (size < len)
    __chk_fail ();
#ifdef __OPTIMIZE__
  if (snprintf_disallowed && inside_main)
    abort();
#endif
  va_start (ap, fmt);
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  va_end (ap);
  if (ret >= 0)
    {
      if (ret < len)
        memcpy (str, chk_sprintf_buf, ret + 1);
      else
        {
          memcpy (str, chk_sprintf_buf, len - 1);
          str[len - 1] = '\0';
        }
    }
  return ret;
}
 
int
__vsnprintf_chk (char *str, __SIZE_TYPE__ len, int flag, __SIZE_TYPE__ size,
                 const char *fmt, va_list ap)
{
  int ret;
 
  /* If size is -1 and flag 0, GCC should always optimize the call into
     vsnprintf.  */
  if (size == (__SIZE_TYPE__) -1 && flag == 0)
    abort ();
  ++chk_calls;
  if (size < len)
    __chk_fail ();
#ifdef __OPTIMIZE__
  if (vsnprintf_disallowed && inside_main)
    abort();
#endif
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  if (ret >= 0)
    {
      if (ret < len)
        memcpy (str, chk_sprintf_buf, ret + 1);
      else
        {
          memcpy (str, chk_sprintf_buf, len - 1);
          str[len - 1] = '\0';
        }
    }
  return ret;
}
 
int
snprintf (char *str, __SIZE_TYPE__ len, const char *fmt, ...)
{
  int ret;
  va_list ap;
 
#ifdef __OPTIMIZE__
  if (snprintf_disallowed && inside_main)
    abort();
#endif
  va_start (ap, fmt);
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  va_end (ap);
  if (ret >= 0)
    {
      if (ret < len)
        memcpy (str, chk_sprintf_buf, ret + 1);
      else if (len)
        {
          memcpy (str, chk_sprintf_buf, len - 1);
          str[len - 1] = '\0';
        }
    }
  return ret;
}
 
/* uClibc's vsprintf calls vsnprintf.  */
#ifndef __UCLIBC__
int
vsnprintf (char *str, __SIZE_TYPE__ len, const char *fmt, va_list ap)
{
  int ret;
 
#ifdef __OPTIMIZE__
  if (vsnprintf_disallowed && inside_main)
    abort();
#endif
  ret = vsprintf (chk_sprintf_buf, fmt, ap);
  if (ret >= 0)
    {
      if (ret < len)
        memcpy (str, chk_sprintf_buf, ret + 1);
      else if (len)
        {
          memcpy (str, chk_sprintf_buf, len - 1);
          str[len - 1] = '\0';
        }
    }
  return ret;
}
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.c-torture/] [execute/] [builtins/] [lib/] [chk.c] - Blame information for rev 774

Line No.	Rev	Author	Line
1	688	jeremybenn	`#include <stdarg.h>`
2			`#ifdef __unix__`
3			`#include <sys/types.h>`
4			`#endif`
5
6			`extern void abort (void);`
7
8			`extern int inside_main;`
9			`void *chk_fail_buf[256] __attribute__((aligned (16)));`
10			`volatile int chk_fail_allowed, chk_calls;`
11			`volatile int memcpy_disallowed, mempcpy_disallowed, memmove_disallowed;`
12			`volatile int memset_disallowed, strcpy_disallowed, stpcpy_disallowed;`
13			`volatile int strncpy_disallowed, stpncpy_disallowed, strcat_disallowed;`
14			`volatile int strncat_disallowed, sprintf_disallowed, vsprintf_disallowed;`
15			`volatile int snprintf_disallowed, vsnprintf_disallowed;`
16			`extern __SIZE_TYPE__ strlen (const char *);`
17			`extern int vsprintf (char , const char , va_list);`
18
19			`void __attribute__((noreturn))`
20			`__chk_fail (void)`
21			`{`
22			`if (chk_fail_allowed)`
23			`__builtin_longjmp (chk_fail_buf, 1);`
24			`abort ();`
25			`}`
26
27			`void *`
28			`memcpy (void dst, const void src, __SIZE_TYPE__ n)`
29			`{`
30			`const char *srcp;`
31			`char *dstp;`
32
33			`#ifdef __OPTIMIZE__`
34			`if (memcpy_disallowed && inside_main)`
35			`abort ();`
36			`#endif`
37
38			`srcp = src;`
39			`dstp = dst;`
40			`while (n-- != 0)`
41			`dstp++ = srcp++;`
42
43			`return dst;`
44			`}`
45
46			`void *`
47			`__memcpy_chk (void dst, const void src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
48			`{`
49			`/* If size is -1, GCC should always optimize the call into memcpy. */`
50			`if (size == (__SIZE_TYPE__) -1)`
51			`abort ();`
52			`++chk_calls;`
53			`if (n > size)`
54			`__chk_fail ();`
55			`return memcpy (dst, src, n);`
56			`}`
57
58			`void *`
59			`mempcpy (void dst, const void src, __SIZE_TYPE__ n)`
60			`{`
61			`const char *srcp;`
62			`char *dstp;`
63
64			`#ifdef __OPTIMIZE__`
65			`if (mempcpy_disallowed && inside_main)`
66			`abort ();`
67			`#endif`
68
69			`srcp = src;`
70			`dstp = dst;`
71			`while (n-- != 0)`
72			`dstp++ = srcp++;`
73
74			`return dstp;`
75			`}`
76
77			`void *`
78			`__mempcpy_chk (void dst, const void src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
79			`{`
80			`/* If size is -1, GCC should always optimize the call into mempcpy. */`
81			`if (size == (__SIZE_TYPE__) -1)`
82			`abort ();`
83			`++chk_calls;`
84			`if (n > size)`
85			`__chk_fail ();`
86			`return mempcpy (dst, src, n);`
87			`}`
88
89			`void *`
90			`memmove (void dst, const void src, __SIZE_TYPE__ n)`
91			`{`
92			`const char *srcp;`
93			`char *dstp;`
94
95			`#ifdef __OPTIMIZE__`
96			`if (memmove_disallowed && inside_main)`
97			`abort ();`
98			`#endif`
99
100			`srcp = src;`
101			`dstp = dst;`
102			`if (srcp < dstp)`
103			`while (n-- != 0)`
104			`dstp[n] = srcp[n];`
105			`else`
106			`while (n-- != 0)`
107			`dstp++ = srcp++;`
108
109			`return dst;`
110			`}`
111
112			`void *`
113			`__memmove_chk (void dst, const void src, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
114			`{`
115			`/* If size is -1, GCC should always optimize the call into memmove. */`
116			`if (size == (__SIZE_TYPE__) -1)`
117			`abort ();`
118			`++chk_calls;`
119			`if (n > size)`
120			`__chk_fail ();`
121			`return memmove (dst, src, n);`
122			`}`
123
124			`void *`
125			`memset (void *dst, int c, __SIZE_TYPE__ n)`
126			`{`
127			`/* Single-byte memsets should be done inline when optimisation`
128			`is enabled. */`
129			`#ifdef __OPTIMIZE__`
130			`if (memset_disallowed && inside_main && n < 2)`
131			`abort ();`
132			`#endif`
133
134			`while (n-- != 0)`
135			`n[(char *) dst] = c;`
136
137			`return dst;`
138			`}`
139
140			`void *`
141			`__memset_chk (void *dst, int c, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
142			`{`
143			`/* If size is -1, GCC should always optimize the call into memset. */`
144			`if (size == (__SIZE_TYPE__) -1)`
145			`abort ();`
146			`++chk_calls;`
147			`if (n > size)`
148			`__chk_fail ();`
149			`return memset (dst, c, n);`
150			`}`
151
152			`char *`
153			`strcpy (char d, const char s)`
154			`{`
155			`char *r = d;`
156			`#ifdef __OPTIMIZE__`
157			`if (strcpy_disallowed && inside_main)`
158			`abort ();`
159			`#endif`
160			`while ((d++ = s++));`
161			`return r;`
162			`}`
163
164			`char *`
165			`__strcpy_chk (char d, const char s, __SIZE_TYPE__ size)`
166			`{`
167			`/* If size is -1, GCC should always optimize the call into strcpy. */`
168			`if (size == (__SIZE_TYPE__) -1)`
169			`abort ();`
170			`++chk_calls;`
171			`if (strlen (s) >= size)`
172			`__chk_fail ();`
173			`return strcpy (d, s);`
174			`}`
175
176			`char *`
177			`stpcpy (char dst, const char src)`
178			`{`
179			`#ifdef __OPTIMIZE__`
180			`if (stpcpy_disallowed && inside_main)`
181			`abort ();`
182			`#endif`
183
184			`while (*src != 0)`
185			`dst++ = src++;`
186
187			`*dst = 0;`
188			`return dst;`
189			`}`
190
191			`char *`
192			`__stpcpy_chk (char d, const char s, __SIZE_TYPE__ size)`
193			`{`
194			`/* If size is -1, GCC should always optimize the call into stpcpy. */`
195			`if (size == (__SIZE_TYPE__) -1)`
196			`abort ();`
197			`++chk_calls;`
198			`if (strlen (s) >= size)`
199			`__chk_fail ();`
200			`return stpcpy (d, s);`
201			`}`
202
203			`char *`
204			`stpncpy (char dst, const char src, __SIZE_TYPE__ n)`
205			`{`
206			`#ifdef __OPTIMIZE__`
207			`if (stpncpy_disallowed && inside_main)`
208			`abort ();`
209			`#endif`
210
211			`for (; *src && n; n--)`
212			`dst++ = src++;`
213
214			`char *ret = dst;`
215
216			`while (n--)`
217			`*dst++ = 0;`
218
219			`return ret;`
220			`}`
221
222
223			`char *`
224			`__stpncpy_chk (char s1, const char s2, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
225			`{`
226			`/* If size is -1, GCC should always optimize the call into stpncpy. */`
227			`if (size == (__SIZE_TYPE__) -1)`
228			`abort ();`
229			`++chk_calls;`
230			`if (n > size)`
231			`__chk_fail ();`
232			`return stpncpy (s1, s2, n);`
233			`}`
234
235			`char *`
236			`strncpy (char s1, const char s2, __SIZE_TYPE__ n)`
237			`{`
238			`char *dest = s1;`
239			`#ifdef __OPTIMIZE__`
240			`if (strncpy_disallowed && inside_main)`
241			`abort();`
242			`#endif`
243			`for (; *s2 && n; n--)`
244			`s1++ = s2++;`
245			`while (n--)`
246			`*s1++ = 0;`
247			`return dest;`
248			`}`
249
250			`char *`
251			`__strncpy_chk (char s1, const char s2, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
252			`{`
253			`/* If size is -1, GCC should always optimize the call into strncpy. */`
254			`if (size == (__SIZE_TYPE__) -1)`
255			`abort ();`
256			`++chk_calls;`
257			`if (n > size)`
258			`__chk_fail ();`
259			`return strncpy (s1, s2, n);`
260			`}`
261
262			`char *`
263			`strcat (char dst, const char src)`
264			`{`
265			`char *p = dst;`
266
267			`#ifdef __OPTIMIZE__`
268			`if (strcat_disallowed && inside_main)`
269			`abort ();`
270			`#endif`
271
272			`while (*p)`
273			`p++;`
274			`while ((p++ = src++))`
275			`;`
276			`return dst;`
277			`}`
278
279			`char *`
280			`__strcat_chk (char d, const char s, __SIZE_TYPE__ size)`
281			`{`
282			`/* If size is -1, GCC should always optimize the call into strcat. */`
283			`if (size == (__SIZE_TYPE__) -1)`
284			`abort ();`
285			`++chk_calls;`
286			`if (strlen (d) + strlen (s) >= size)`
287			`__chk_fail ();`
288			`return strcat (d, s);`
289			`}`
290
291			`char *`
292			`strncat (char s1, const char s2, __SIZE_TYPE__ n)`
293			`{`
294			`char *dest = s1;`
295			`char c;`
296			`#ifdef __OPTIMIZE__`
297			`if (strncat_disallowed && inside_main)`
298			`abort();`
299			`#endif`
300			`while (*s1) s1++;`
301			`c = '\0';`
302			`while (n > 0)`
303			`{`
304			`c = *s2++;`
305			`*s1++ = c;`
306			`if (c == '\0')`
307			`return dest;`
308			`n--;`
309			`}`
310			`if (c != '\0')`
311			`*s1 = '\0';`
312			`return dest;`
313			`}`
314
315			`char *`
316			`__strncat_chk (char d, const char s, __SIZE_TYPE__ n, __SIZE_TYPE__ size)`
317			`{`
318			`__SIZE_TYPE__ len = strlen (d), n1 = n;`
319			`const char *s1 = s;`
320
321			`/* If size is -1, GCC should always optimize the call into strncat. */`
322			`if (size == (__SIZE_TYPE__) -1)`
323			`abort ();`
324			`++chk_calls;`
325			`while (len < size && n1 > 0)`
326			`{`
327			`if (*s1++ == '\0')`
328			`break;`
329			`++len;`
330			`--n1;`
331			`}`
332
333			`if (len >= size)`
334			`__chk_fail ();`
335			`return strncat (d, s, n);`
336			`}`
337
338			`/* No chk test in GCC testsuite needs more bytes than this.`
339			`As we can't expect vsnprintf to be available on the target,`
340			`assume 4096 bytes is enough. */`
341			`static char chk_sprintf_buf[4096];`
342
343			`int`
344			`__sprintf_chk (char str, int flag, __SIZE_TYPE__ size, const char fmt, ...)`
345			`{`
346			`int ret;`
347			`va_list ap;`
348
349			`/* If size is -1 and flag 0, GCC should always optimize the call into`
350			`sprintf. */`
351			`if (size == (__SIZE_TYPE__) -1 && flag == 0)`
352			`abort ();`
353			`++chk_calls;`
354			`#ifdef __OPTIMIZE__`
355			`if (sprintf_disallowed && inside_main)`
356			`abort();`
357			`#endif`
358			`va_start (ap, fmt);`
359			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
360			`va_end (ap);`
361			`if (ret >= 0)`
362			`{`
363			`if (ret >= size)`
364			`__chk_fail ();`
365			`memcpy (str, chk_sprintf_buf, ret + 1);`
366			`}`
367			`return ret;`
368			`}`
369
370			`int`
371			`__vsprintf_chk (char str, int flag, __SIZE_TYPE__ size, const char fmt,`
372			`va_list ap)`
373			`{`
374			`int ret;`
375
376			`/* If size is -1 and flag 0, GCC should always optimize the call into`
377			`vsprintf. */`
378			`if (size == (__SIZE_TYPE__) -1 && flag == 0)`
379			`abort ();`
380			`++chk_calls;`
381			`#ifdef __OPTIMIZE__`
382			`if (vsprintf_disallowed && inside_main)`
383			`abort();`
384			`#endif`
385			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
386			`if (ret >= 0)`
387			`{`
388			`if (ret >= size)`
389			`__chk_fail ();`
390			`memcpy (str, chk_sprintf_buf, ret + 1);`
391			`}`
392			`return ret;`
393			`}`
394
395			`int`
396			`__snprintf_chk (char *str, __SIZE_TYPE__ len, int flag, __SIZE_TYPE__ size,`
397			`const char *fmt, ...)`
398			`{`
399			`int ret;`
400			`va_list ap;`
401
402			`/* If size is -1 and flag 0, GCC should always optimize the call into`
403			`snprintf. */`
404			`if (size == (__SIZE_TYPE__) -1 && flag == 0)`
405			`abort ();`
406			`++chk_calls;`
407			`if (size < len)`
408			`__chk_fail ();`
409			`#ifdef __OPTIMIZE__`
410			`if (snprintf_disallowed && inside_main)`
411			`abort();`
412			`#endif`
413			`va_start (ap, fmt);`
414			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
415			`va_end (ap);`
416			`if (ret >= 0)`
417			`{`
418			`if (ret < len)`
419			`memcpy (str, chk_sprintf_buf, ret + 1);`
420			`else`
421			`{`
422			`memcpy (str, chk_sprintf_buf, len - 1);`
423			`str[len - 1] = '\0';`
424			`}`
425			`}`
426			`return ret;`
427			`}`
428
429			`int`
430			`__vsnprintf_chk (char *str, __SIZE_TYPE__ len, int flag, __SIZE_TYPE__ size,`
431			`const char *fmt, va_list ap)`
432			`{`
433			`int ret;`
434
435			`/* If size is -1 and flag 0, GCC should always optimize the call into`
436			`vsnprintf. */`
437			`if (size == (__SIZE_TYPE__) -1 && flag == 0)`
438			`abort ();`
439			`++chk_calls;`
440			`if (size < len)`
441			`__chk_fail ();`
442			`#ifdef __OPTIMIZE__`
443			`if (vsnprintf_disallowed && inside_main)`
444			`abort();`
445			`#endif`
446			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
447			`if (ret >= 0)`
448			`{`
449			`if (ret < len)`
450			`memcpy (str, chk_sprintf_buf, ret + 1);`
451			`else`
452			`{`
453			`memcpy (str, chk_sprintf_buf, len - 1);`
454			`str[len - 1] = '\0';`
455			`}`
456			`}`
457			`return ret;`
458			`}`
459
460			`int`
461			`snprintf (char str, __SIZE_TYPE__ len, const char fmt, ...)`
462			`{`
463			`int ret;`
464			`va_list ap;`
465
466			`#ifdef __OPTIMIZE__`
467			`if (snprintf_disallowed && inside_main)`
468			`abort();`
469			`#endif`
470			`va_start (ap, fmt);`
471			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
472			`va_end (ap);`
473			`if (ret >= 0)`
474			`{`
475			`if (ret < len)`
476			`memcpy (str, chk_sprintf_buf, ret + 1);`
477			`else if (len)`
478			`{`
479			`memcpy (str, chk_sprintf_buf, len - 1);`
480			`str[len - 1] = '\0';`
481			`}`
482			`}`
483			`return ret;`
484			`}`
485
486			`/* uClibc's vsprintf calls vsnprintf. */`
487			`#ifndef __UCLIBC__`
488			`int`
489			`vsnprintf (char str, __SIZE_TYPE__ len, const char fmt, va_list ap)`
490			`{`
491			`int ret;`
492
493			`#ifdef __OPTIMIZE__`
494			`if (vsnprintf_disallowed && inside_main)`
495			`abort();`
496			`#endif`
497			`ret = vsprintf (chk_sprintf_buf, fmt, ap);`
498			`if (ret >= 0)`
499			`{`
500			`if (ret < len)`
501			`memcpy (str, chk_sprintf_buf, ret + 1);`
502			`else if (len)`
503			`{`
504			`memcpy (str, chk_sprintf_buf, len - 1);`
505			`str[len - 1] = '\0';`
506			`}`
507			`}`
508			`return ret;`
509			`}`
510			`#endif`