int puts(const char *s) { // DS: Variable length array (C99) char str[__builtin_strlen(s) + 1]; __builtin_strcpy(str, s); str[__builtin_strlen(s)] = '\n'; return stdout->write(stdout->cookie, str, __builtin_strlen(s) + 1); }
__attribute__((noipa)) size_t foo (char *p, char *q, size_t *r) { size_t n0 = __builtin_strlen (p); __builtin_strncat (q, p, n0); /* { dg-warning "specified bound depends on the length" } */ size_t n1 = __builtin_strlen (p); *r = n0; return n1; }
static int parse_icap_version(char **buf){ parse_whitespaces(buf); if(strncasecmp(*buf,ICAP_VERSION_STR,__builtin_strlen(ICAP_VERSION_STR))){ bitch("Bad ICAP version: %s != %s\n",*buf,ICAP_VERSION_STR); return -1; } *buf += __builtin_strlen(ICAP_VERSION_STR); return 0; }
int main(int argc, char *argv[]) { char *source = "asdf"; char target[__builtin_strlen(source) + 1]; move(target, source, __builtin_strlen(source) + 1); if (__builtin_strcmp(target, source) != 0) { abort(); } else { exit(0); } }
// Returns 1 for a valid SSDP response, -1 for a valid SSDP query, 0 otherwise int handle_ssdp_packet(omphalos_packet *op,const void *frame,size_t len) { if(len < __builtin_strlen(SSDP_METHOD_NOTIFY)) { diagnostic("%s frame too short (%zu)",__func__,len); op->malformed = 1; return 0; } if(strncmp(frame,SSDP_METHOD_NOTIFY,__builtin_strlen(SSDP_METHOD_NOTIFY)) == 0) { return 1; } else if(strncmp(frame,SSDP_METHOD_SEARCH,__builtin_strlen(SSDP_METHOD_SEARCH)) == 0) { return -1; } return 0; }
unsigned g (void) { char d[8]; const char s[] = "0123"; __builtin_memcpy (d, s, sizeof s); return __builtin_strlen (d); }
void foo (void) { printf ("%zu\n", strspn ("abc", "abcdefg")); printf ("%zu\n", (size_t) strspn ("abc", "abcdefg")); printf ("%zu\n", __builtin_strspn ("abc", "abcdefg")); printf ("%zu\n", (size_t) __builtin_strspn ("abc", "abcdefg")); printf ("%zu\n", strcspn ("abc", "abcdefg")); printf ("%zu\n", (size_t) strcspn ("abc", "abcdefg")); printf ("%zu\n", __builtin_strcspn ("abc", "abcdefg")); printf ("%zu\n", (size_t) __builtin_strcspn ("abc", "abcdefg")); printf ("%zu\n", strlen ("abc")); printf ("%zu\n", (size_t) strlen ("abc")); printf ("%zu\n", __builtin_strlen ("abc")); printf ("%zu\n", (size_t) __builtin_strlen ("abc")); }
void _cgo_panic (const char *p) { intgo len; unsigned char *data; String *ps; Eface e; const struct __go_type_descriptor *td; runtime_exitsyscall (0); len = __builtin_strlen (p); data = alloc_saved (len); __builtin_memcpy (data, p, len); ps = alloc_saved (sizeof *ps); ps->str = data; ps->len = len; td = &string_type_descriptor; memcpy(&e._type, &td, sizeof td); /* This is a const_cast. */ e.data = ps; /* We don't call runtime_entersyscall here, because normally what will happen is that we will walk up the stack to a Go deferred function that calls recover. However, this will do the wrong thing if this panic is recovered and the stack unwinding is caught by a C++ exception handler. It might be possible to handle this by calling runtime_entersyscall in the personality function in go-unwind.c. FIXME. */ __go_panic (e); }
static enum user_response authenticate_user(request *req, char **user_name, struct user_info **user_item) { char *authent = ((void *)0); har resp = ha_no_value; enum user_response user_resp; int ret_val = no_user_response; if (req->authent && __builtin_strlen(req->authent)) { authent = req->authent; user_resp = get_user_info_from_header(req->internal_realm, user_name, user_item); if (user_resp == ok_user_response) { resp = has_auth_user(authent, 0, req->internal_realm, "", 1); if (resp == ha_no_error) ret_val = ok_user_response; else if (resp != he_stale_nonce) ret_val = access_denied_user_response; } else if (user_resp == access_denied_user_response) ret_val = access_denied_user_response; } if (resp != he_memory_too_small && resp != ha_no_error) resp = has_www_auth("", 1, req->internal_realm, resp); return ret_val; }
String Signame (intgo sig) { const char* s = NULL; char buf[100]; size_t len; byte *data; String ret; #if defined(HAVE_STRSIGNAL) s = strsignal (sig); #endif if (s == NULL) { snprintf(buf, sizeof buf, "signal %ld", (long) sig); s = buf; } len = __builtin_strlen (s); data = runtime_mallocgc (len, FlagNoPointers, 0, 0); __builtin_memcpy (data, s, len); ret.str = data; ret.len = len; return ret; }
int foo (const char *name) { if (name) return 6; return __builtin_strlen (name); /* { dg-warning "argument 1 null where non-null expected" } */ }
int main () { char a[8] = ""; __builtin_strcpy (a, "123"); size_t n0 = __builtin_strlen (a); __builtin_strncat (a + 3, a, n0); /* { dg-warning "specified bound depends on the length" } */ size_t n1 = __builtin_strlen (a); if (n1 == n0) __builtin_abort (); a[6] = '7'; __builtin_strcpy (a, "456"); size_t n2; if (foo (a, a + 3, &n2) != 6 || n2 != 3) __builtin_abort (); if (__builtin_memcmp (a, "456456\0", sizeof "456456\0")) __builtin_abort (); return 0; }
void verbose_text_loop (void *data) { FILE *dev_vcs; char buf[81]; GString *buf_str; gshort i, j; while (1) { for (i = 1; i <= 7; i++) { while (fgets (buf, 81, dev_vcs)) { for (j = 0; j < __builtin_strlen (buf); j++) if (buf[j] != ' ') break; for (; j < __builtin_strlen (buf); j++) g_string_append_c_inline (buf_str, buf[j]); } } } }
// FIXME is it safe to be using (possibly signed) naked chars? static int process_reverse_lookup(const char *buf,int *fam,void *addr){ const size_t len = strlen(buf); // First, check for mDNS if(len < __builtin_strlen(MDNS_REVSTR_DECODED)){ return -1; } const size_t xmlen = len - __builtin_strlen(MDNS_REVSTR_DECODED); if(strcmp(buf + xmlen,MDNS_REVSTR_DECODED) == 0){ // FIXME for now, do nothing with mDNS PTR records return -1; } // Check the IPv6 string first (it's shorter) if(len < __builtin_strlen(IP6_REVSTR_DECODED)){ return -1; } const size_t x6len = len - __builtin_strlen(IP6_REVSTR_DECODED); if(strcmp(buf + x6len,IP6_REVSTR_DECODED) == 0){ return process_reverse6_lookup(buf,fam,addr,x6len); } // Look for the IPv4 string if(len < __builtin_strlen(IP4_REVSTR_DECODED)){ return -1; } const size_t xlen = len - __builtin_strlen(IP4_REVSTR_DECODED); if(strcmp(buf + xlen,IP4_REVSTR_DECODED) == 0){ return process_reverse4_lookup(buf,fam,addr); } return -1; }
static int callback (void *data, uintptr_t pc __attribute__ ((unused)), const char *filename, int lineno, const char *function) { struct caller *c = (struct caller *) data; if (function == NULL) { c->fn.str = NULL; c->fn.len = 0; } else { byte *s; c->fn.len = __builtin_strlen (function); s = runtime_malloc (c->fn.len); __builtin_memcpy (s, function, c->fn.len); c->fn.str = s; } if (filename == NULL) { c->file.str = NULL; c->file.len = 0; } else { byte *s; c->file.len = __builtin_strlen (filename); s = runtime_malloc (c->file.len); __builtin_memcpy (s, filename, c->file.len); c->file.str = s; } c->line = lineno; return 0; }
String getgoroot () { const char *p; String ret; p = getenv ("GOROOT"); ret.str = (const byte *) p; if (ret.str == NULL) ret.len = 0; else ret.len = __builtin_strlen (p); return ret; }
void __go_panic_msg (const char* msg) { size_t len; unsigned char *sdata; struct __go_string s; struct __go_empty_interface arg; len = __builtin_strlen (msg); sdata = runtime_mallocgc (len, FlagNoPointers, 0, 0); __builtin_memcpy (sdata, msg, len); s.__data = sdata; s.__length = len; newErrorString(s, &arg); __go_panic (arg); }
checkv (const char *func, int line, int res, int min, int max, char *dst, const char *fmt, __builtin_va_list va) { int n = __builtin_vsprintf (dst, fmt, va); int len = __builtin_strlen (dst); ++ntests; int fail = 0; if (n != res) { __builtin_printf ("FAIL: %s:%i: \"%s\" expected result for \"%s\" " "doesn't match function call return value: ", func, line, fmt, dst); if (min == max) __builtin_printf ("%i != %i\n", n, min); else __builtin_printf ("%i not in [%i, %i]\n", n, min, max); fail = 1; } else { if (len < min || max < len) { __builtin_printf ("FAIL: %s:%i: \"%s\" expected result for \"%s\" " "doesn't match output length: ", func, line, fmt, dst); if (min == max) __builtin_printf ("%i != %i\n", len, min); else __builtin_printf ("%i not in [%i, %i]\n", len, min, max); fail = 1; } else if (min == max) __builtin_printf ("PASS: %s:%i: \"%s\" result %i: \"%s\"\n", func, line, fmt, n, dst); else __builtin_printf ("PASS: %s:%i: \"%s\" result %i in [%i, %i]: \"%s\"\n", func, line, fmt, n, min, max, dst); } if (fail) ++nfails; }
int main(void) { char buf[128]; int ab = __builtin_abs(-7) - __builtin_abs(5); printf("Res1: %d\n", ab); __builtin_memcpy(vals1, vals0, sizeof(vals0)); printf("Res2: %d\n", __builtin_memcmp(vals0, vals1, sizeof(vals0))); __builtin_memset(vals0, 0, sizeof(vals0)); printf("Res3: %d %d %d %d %d\n", vals0[0], vals0[1], vals0[2], vals0[3], vals0[4]); printf("Res4: %d\n", (int) __builtin_strlen("Hello World")); printf("Res5: %d\n", __builtin_strcmp(hello, "Hello World") > 0); __builtin_strcpy(buf, hello); printf("Res6: %s\n", buf); return 0; }
int C::foo (char ch, int offset) const { int len = __builtin_strlen (a); if (len == 0) return __INT_MAX__; if (offset >= len) offset = len - 1; while (bar (offset, ch) != 0) { if (offset == 0) return __INT_MAX__; offset--; } return offset; }
void _cgo_panic (const char *p) { int len; unsigned char *data; struct __go_string *ps; struct __go_empty_interface e; len = __builtin_strlen (p); data = __go_alloc (len); __builtin_memcpy (data, p, len); ps = __go_alloc (sizeof *ps); ps->__data = data; ps->__length = len; e.__type_descriptor = &string_type_descriptor; e.__object = ps; __go_panic (e); }
int main(int argc, char **argv) { int a; a = __builtin_bswap32(a); a = __builtin_bswap64(a); a = __builtin_constant_p(1); a = __builtin_constant_p("string"); char *b = __builtin_strchr("string", 's'); a = __builtin_expect(1, a); a = __builtin_strlen("string"); a = __builtin_strcmp("string1", "string2"); a = __builtin_offsetof(struct point, y); char c[100]; b = __builtin_strcpy(c, "a"); b = __builtin_strncpy(c, "a", 1); a = __builtin_ctzl(a); varargsfn(0); __builtin_prefetch(b); __builtin_prefetch(b, 1); __builtin_prefetch(b, 1, 1); return a; }
static int parse_icap_startline(char *line,struct pollfd_state *pfd,icap_status *istat){ icap_state *is = get_pfd_icap(pfd); const char *method; is->method = parse_method(&line); if(is->method == ICAP_METHOD_COUNT){ *istat = ICAPSTATUS_METHOD_NOT_IMPLEMENTED; return -1; } if((method = name_icap_method(is->method)) == NULL){ bitch("Couldn't stringize method %d\n",is->method); *istat = ICAPSTATUS_INTERNAL_ERROR; return -1; } // nag("Valid method: %s\n",method); inc_method_begun(is->method); if((is->icapuri = extract_uri(ICAP_URI_SCHEME,&line)) == NULL){ *istat = ICAPSTATUS_BAD_REQUEST; return -1; } if(verify_icap_uri(is->icapuri,is)){ bitch("Bad URI for %s\n",method); free_uri(&is->icapuri); *istat = ICAPSTATUS_METHOD_BAD_SERVICE; return -1; } if(parse_icap_version(&line)){ *istat = ICAPSTATUS_VERSION_NOT_SUPPORTED; return -1; } if(strcmp(line,CRLF)){ bitch("Excess data after ICAP version (%zu/%zu)\n", strlen(line),__builtin_strlen(CRLF)); *istat = ICAPSTATUS_BAD_REQUEST; return -1; } return 0; }
// file coreutils/basename.c line 49 signed int __main(signed int argc, char **argv) { unsigned long int m; unsigned long int n; char *s; if(!(argv == ((char **)NULL))) (void)0; else /* assertion !(argv == ((char **)((void*)0))) */ __VERIFIER_error(); signed int tmp_statement_expression$1; _Bool tmp_if_expr$2; signed int tmp_if_expr$5; signed int tmp_statement_expression$3; signed int return_value___builtin_strcmp$4; if(!(*(1l + argv) == ((char *)NULL))) { unsigned long int basename_main$$1$$1$$__s1_len; unsigned long int __s2_len; if((_Bool)1) { if(!((unsigned long int)("--" + 1l) + -((unsigned long int)"--") == 1ul)) goto __CPROVER_DUMP_L3; __s2_len=__builtin_strlen("--"); tmp_if_expr$2 = (__s2_len < (unsigned long int)4 ? (signed int)(1 != 0) : (signed int)(0 != 0)) != 0; } else { __CPROVER_DUMP_L3: ; tmp_if_expr$2 = 0 != 0; } if(!(tmp_if_expr$2 == (_Bool)0)) { const unsigned char *__s2; if(!(argv == ((char **)NULL))) (void)0; else /* assertion !(argv == ((char **)((void*)0))) */ __VERIFIER_error(); __s2 = (const char *)argv[(signed long int)1]; signed int __result; if(!(__s2 == ((const unsigned char *)NULL))) (void)0; else /* assertion !(__s2 == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); __result = (signed int)((const char *)"--")[(signed long int)0] - (signed int)__s2[(signed long int)0]; if(__s2_len > 0ul) { if(__result == 0) { if(!("--" == ((const char *)NULL))) (void)0; else /* assertion !("--" == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); if(!(__s2 == ((const unsigned char *)NULL))) (void)0; else /* assertion !(__s2 == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); __result = (signed int)((const char *)"--")[(signed long int)1] - (signed int)__s2[(signed long int)1]; if(__s2_len > 1ul) { if(__result == 0) { if(!("--" == ((const char *)NULL))) (void)0; else /* assertion !("--" == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); if(!(__s2 == ((const unsigned char *)NULL))) (void)0; else /* assertion !(__s2 == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); __result = (signed int)((const char *)"--")[(signed long int)2] - (signed int)__s2[(signed long int)2]; if(__s2_len > 2ul) { if(__result == 0) { if(!("--" == ((const char *)NULL))) (void)0; else /* assertion !("--" == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); /* assertion (_Bool)0 */ __VERIFIER_error(); if(!(__s2 == ((const unsigned char *)NULL))) (void)0; else /* assertion !(__s2 == ((const unsigned char *)((void*)0))) */ __VERIFIER_error(); __result = (signed int)((const char *)"--")[(signed long int)3] - (signed int)__s2[(signed long int)3]; } } } } } } tmp_statement_expression$3 = __result; tmp_if_expr$5 = -tmp_statement_expression$3; } else { if(!(argv == ((char **)NULL))) (void)0; else /* assertion !(argv == ((char **)((void*)0))) */ __VERIFIER_error(); return_value___builtin_strcmp$4=__builtin_strcmp(argv[(signed long int)1], "--"); tmp_if_expr$5 = return_value___builtin_strcmp$4; } tmp_statement_expression$1 = tmp_if_expr$5; if(tmp_statement_expression$1 == 0) { argv = argv + 1l; argc = argc - 1; } }
void main_test (void) { const char *const foo = "hello world"; if (strlen (foo) != 11) abort (); if (strlen (foo + 4) != 7) abort (); if (strlen (foo + (x++ & 7)) != 5) abort (); if (x != 7) abort (); if (strcmp (foo, "hello") <= 0) abort (); if (strcmp (foo + 2, "llo") <= 0) abort (); if (strcmp (foo, foo) != 0) abort (); if (strcmp (foo, "hello world ") >= 0) abort (); if (strcmp (foo + 10, "dx") >= 0) abort (); if (strcmp (10 + foo, "dx") >= 0) abort (); if (strcmp (bar, "") <= 0) abort (); if (strcmp ("", bar) >= 0) abort (); if (strcmp (bar+8, "") != 0) abort (); if (strcmp ("", bar+8) != 0) abort (); if (strcmp (bar+(--x), "") <= 0 || x != 6) abort (); if (strcmp ("", bar+(++x)) >= 0 || x != 7) abort (); if (strrchr (foo, 'x')) abort (); if (strrchr (foo, 'o') != foo + 7) abort (); if (strrchr (foo, 'e') != foo + 1) abort (); if (strrchr (foo + 3, 'e')) abort (); if (strrchr (foo, '\0') != foo + 11) abort (); if (strrchr (bar, '\0') != bar + 8) abort (); if (strrchr (bar + 4, '\0') != bar + 8) abort (); if (strrchr (bar + (x++ & 3), '\0') != bar + 8) abort (); if (x != 8) abort (); /* Test only one instance of rindex since the code path is the same as that of strrchr. */ if (rindex ("hello", 'z') != 0) abort (); /* Test at least one instance of the __builtin_ style. We do this to ensure that it works and that the prototype is correct. */ if (__builtin_rindex (foo, 'o') != foo + 7) abort (); if (__builtin_strrchr (foo, 'o') != foo + 7) abort (); if (__builtin_strlen (foo) != 11) abort (); if (__builtin_strcmp (foo, "hello") <= 0) abort (); }
size_t builtin_strlen (const CHAR *p) { return __builtin_strlen (p); }
void f(const char *s) { if (__PTRDIFF_MAX__ <= __builtin_strlen (s)) __builtin_abort (); }
char parity7[__builtin_parity(0xb826) == 1 ? 1 : -1]; char parity8[__builtin_parity(~0) == 0 ? 1 : -1]; char parity9[__builtin_parityl(1L << (BITSIZE(long) - 1)) == 1 ? 1 : -1]; char parity10[__builtin_parityll(1LL << (BITSIZE(long long) - 1)) == 1 ? 1 : -1]; char ffs1[__builtin_ffs(0) == 0 ? 1 : -1]; char ffs2[__builtin_ffs(1) == 1 ? 1 : -1]; char ffs3[__builtin_ffs(0xfbe71) == 1 ? 1 : -1]; char ffs4[__builtin_ffs(0xfbe70) == 5 ? 1 : -1]; char ffs5[__builtin_ffs(1U << (BITSIZE(int) - 1)) == BITSIZE(int) ? 1 : -1]; char ffs6[__builtin_ffsl(0x10L) == 5 ? 1 : -1]; char ffs7[__builtin_ffsll(0x100LL) == 9 ? 1 : -1]; #undef BITSIZE // GCC misc stuff extern int f(); int h0 = __builtin_types_compatible_p(int, float); //int h1 = __builtin_choose_expr(1, 10, f()); //int h2 = __builtin_expect(0, 0); int h3 = __builtin_bswap16(0x1234) == 0x3412 ? 1 : f(); int h4 = __builtin_bswap32(0x1234) == 0x34120000 ? 1 : f(); int h5 = __builtin_bswap64(0x1234) == 0x3412000000000000 ? 1 : f(); extern long int bi0; extern __typeof__(__builtin_expect(0, 0)) bi0; // Strings int array1[__builtin_strlen("ab\0cd")]; int array2[(sizeof(array1)/sizeof(int)) == 2? 1 : -1];
// file libbb/single_argv.c line 11 static char * single_argv(char **argv) { signed int tmp_statement_expression$1; _Bool tmp_if_expr$2; signed int tmp_if_expr$5; signed int tmp_statement_expression$3; signed int return_value___builtin_strcmp$4; if(!(*(1l + argv) == ((char *)NULL))) { unsigned long int __s1_len; unsigned long int __s2_len; if((_Bool)1) { if(!((unsigned long int)("--" + 1l) + -((unsigned long int)"--") == 1ul)) goto __CPROVER_DUMP_L1; __s2_len=__builtin_strlen("--"); tmp_if_expr$2 = (__s2_len < (unsigned long int)4 ? (signed int)(1 != 0) : (signed int)(0 != 0)) != 0; } else { __CPROVER_DUMP_L1: ; tmp_if_expr$2 = 0 != 0; } if(!(tmp_if_expr$2 == (_Bool)0)) { const unsigned char *__s2 = (const char *)argv[(signed long int)1]; signed int __result = (signed int)((const char *)"--")[(signed long int)0] - (signed int)__s2[(signed long int)0]; if(__s2_len > 0ul) { if(__result == 0) { __result = (signed int)((const char *)"--")[(signed long int)1] - (signed int)__s2[(signed long int)1]; if(__s2_len > 1ul) { if(__result == 0) { __result = (signed int)((const char *)"--")[(signed long int)2] - (signed int)__s2[(signed long int)2]; if(__s2_len > 2ul) { if(__result == 0) __result = (signed int)((const char *)"--")[(signed long int)3] - (signed int)__s2[(signed long int)3]; } } } } } tmp_statement_expression$3 = __result; tmp_if_expr$5 = -tmp_statement_expression$3; } else { return_value___builtin_strcmp$4=__builtin_strcmp(argv[(signed long int)1], "--"); tmp_if_expr$5 = return_value___builtin_strcmp$4; } tmp_statement_expression$1 = tmp_if_expr$5; if(tmp_statement_expression$1 == 0) argv = argv + 1l; } _Bool tmp_if_expr$6; if(*(1l + argv) == ((char *)NULL)) tmp_if_expr$6 = 1 != 0; else tmp_if_expr$6 = (argv[(signed long int)2] != (char *)NULL ? (signed int)(1 != 0) : (signed int)(0 != 0)) != 0; if(!(tmp_if_expr$6 == (_Bool)0)) bb_show_usage(); return argv[(signed long int)1]; }
int fputs(const char *s, FILE *stream) { return stream->write(stream->cookie, s, __builtin_strlen(s)); }