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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [testsuite/] [gcc.c-torture/] [execute/] [builtins/] [lib/] [chk.c] - Blame information for rev 154

Details | Compare with Previous | View Log


#include <stdarg.h>
 
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, strcat_disallowed, strncat_disallowed;
volatile int 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 *
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;
}
 
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;
}

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [testsuite/] [gcc.c-torture/] [execute/] [builtins/] [lib/] [chk.c] - Blame information for rev 154

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