extra: track array values
[smatch.git] / lib.c
blobc8ab2a2aabec3edcac8e980de47688ffdcf87eff
1 /*
2 * 'sparse' library helper routines.
4 * Copyright (C) 2003 Transmeta Corp.
5 * 2003-2004 Linus Torvalds
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
25 #include <ctype.h>
26 #include <fcntl.h>
27 #include <stdarg.h>
28 #include <stddef.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 #include <assert.h>
35 #include <sys/types.h>
37 #include "lib.h"
38 #include "allocate.h"
39 #include "token.h"
40 #include "parse.h"
41 #include "symbol.h"
42 #include "expression.h"
43 #include "scope.h"
44 #include "linearize.h"
45 #include "target.h"
46 #include "version.h"
48 int verbose, optimize, optimize_size, preprocessing;
49 int die_if_error = 0;
51 #ifndef __GNUC__
52 # define __GNUC__ 2
53 # define __GNUC_MINOR__ 95
54 # define __GNUC_PATCHLEVEL__ 0
55 #endif
57 int gcc_major = __GNUC__;
58 int gcc_minor = __GNUC_MINOR__;
59 int gcc_patchlevel = __GNUC_PATCHLEVEL__;
61 static const char *gcc_base_dir = GCC_BASE;
63 struct token *skip_to(struct token *token, int op)
65 while (!match_op(token, op) && !eof_token(token))
66 token = token->next;
67 return token;
70 struct token *expect(struct token *token, int op, const char *where)
72 if (!match_op(token, op)) {
73 static struct token bad_token;
74 if (token != &bad_token) {
75 bad_token.next = token;
76 sparse_error(token->pos, "Expected %s %s", show_special(op), where);
77 sparse_error(token->pos, "got %s", show_token(token));
79 if (op == ';')
80 return skip_to(token, op);
81 return &bad_token;
83 return token->next;
86 unsigned int hexval(unsigned int c)
88 int retval = 256;
89 switch (c) {
90 case '0'...'9':
91 retval = c - '0';
92 break;
93 case 'a'...'f':
94 retval = c - 'a' + 10;
95 break;
96 case 'A'...'F':
97 retval = c - 'A' + 10;
98 break;
100 return retval;
103 static void do_warn(const char *type, struct position pos, const char * fmt, va_list args)
105 static char buffer[512];
106 const char *name;
108 vsprintf(buffer, fmt, args);
109 name = stream_name(pos.stream);
111 fprintf(stderr, "%s:%d:%d: %s%s\n",
112 name, pos.line, pos.pos, type, buffer);
115 static int max_warnings = 100;
116 static int show_info = 1;
118 void info(struct position pos, const char * fmt, ...)
120 va_list args;
122 if (!show_info)
123 return;
124 va_start(args, fmt);
125 do_warn("", pos, fmt, args);
126 va_end(args);
129 static void do_error(struct position pos, const char * fmt, va_list args)
131 static int errors = 0;
132 die_if_error = 1;
133 show_info = 1;
134 /* Shut up warnings after an error */
135 max_warnings = 0;
136 if (errors > 100) {
137 static int once = 0;
138 show_info = 0;
139 if (once)
140 return;
141 fmt = "too many errors";
142 once = 1;
145 do_warn("error: ", pos, fmt, args);
146 errors++;
149 void warning(struct position pos, const char * fmt, ...)
151 va_list args;
153 if (Werror) {
154 va_start(args, fmt);
155 do_error(pos, fmt, args);
156 va_end(args);
157 return;
160 if (!max_warnings) {
161 show_info = 0;
162 return;
165 if (!--max_warnings) {
166 show_info = 0;
167 fmt = "too many warnings";
170 va_start(args, fmt);
171 do_warn("warning: ", pos, fmt, args);
172 va_end(args);
175 void sparse_error(struct position pos, const char * fmt, ...)
177 va_list args;
178 va_start(args, fmt);
179 do_error(pos, fmt, args);
180 va_end(args);
183 void expression_error(struct expression *expr, const char *fmt, ...)
185 va_list args;
186 va_start(args, fmt);
187 do_error(expr->pos, fmt, args);
188 va_end(args);
189 expr->ctype = &bad_ctype;
192 void error_die(struct position pos, const char * fmt, ...)
194 va_list args;
195 va_start(args, fmt);
196 do_warn("error: ", pos, fmt, args);
197 va_end(args);
198 exit(1);
201 void die(const char *fmt, ...)
203 va_list args;
204 static char buffer[512];
206 va_start(args, fmt);
207 vsnprintf(buffer, sizeof(buffer), fmt, args);
208 va_end(args);
210 fprintf(stderr, "%s\n", buffer);
211 exit(1);
214 static struct token *pre_buffer_begin = NULL;
215 static struct token *pre_buffer_end = NULL;
217 int Waddress_space = 1;
218 int Wbitwise = 0;
219 int Wcast_to_as = 0;
220 int Wcast_truncate = 1;
221 int Wcontext = 1;
222 int Wdecl = 1;
223 int Wdeclarationafterstatement = -1;
224 int Wdefault_bitfield_sign = 0;
225 int Wdesignated_init = 1;
226 int Wdo_while = 0;
227 int Winit_cstring = 0;
228 int Wenum_mismatch = 1;
229 int Werror = 0;
230 int Wnon_pointer_null = 1;
231 int Wold_initializer = 1;
232 int Wone_bit_signed_bitfield = 1;
233 int Wparen_string = 0;
234 int Wptr_subtraction_blows = 0;
235 int Wreturn_void = 0;
236 int Wshadow = 0;
237 int Wsizeof_bool = 0;
238 int Wtransparent_union = 0;
239 int Wtypesign = 0;
240 int Wundef = 0;
241 int Wuninitialized = 1;
242 int Wvla = 1;
244 int dbg_entry = 0;
245 int dbg_dead = 0;
247 int preprocess_only;
249 static enum { STANDARD_C89,
250 STANDARD_C94,
251 STANDARD_C99,
252 STANDARD_GNU89,
253 STANDARD_GNU99, } standard = STANDARD_GNU89;
255 #ifdef __x86_64__
256 #define ARCH_M64_DEFAULT 1
257 #else
258 #define ARCH_M64_DEFAULT 0
259 #endif
261 int arch_m64 = ARCH_M64_DEFAULT;
262 int arch_msize_long = 0;
264 #define CMDLINE_INCLUDE 20
265 static int cmdline_include_nr = 0;
266 static char *cmdline_include[CMDLINE_INCLUDE];
269 void add_pre_buffer(const char *fmt, ...)
271 va_list args;
272 unsigned int size;
273 struct token *begin, *end;
274 char buffer[4096];
276 va_start(args, fmt);
277 size = vsnprintf(buffer, sizeof(buffer), fmt, args);
278 va_end(args);
279 begin = tokenize_buffer(buffer, size, &end);
280 if (!pre_buffer_begin)
281 pre_buffer_begin = begin;
282 if (pre_buffer_end)
283 pre_buffer_end->next = begin;
284 pre_buffer_end = end;
287 static char **handle_switch_D(char *arg, char **next)
289 const char *name = arg + 1;
290 const char *value = "1";
292 if (!*name || isspace(*name))
293 die("argument to `-D' is missing");
295 for (;;) {
296 char c;
297 c = *++arg;
298 if (!c)
299 break;
300 if (isspace((unsigned char)c) || c == '=') {
301 *arg = '\0';
302 value = arg + 1;
303 break;
306 add_pre_buffer("#define %s %s\n", name, value);
307 return next;
310 static char **handle_switch_E(char *arg, char **next)
312 if (arg[1] == '\0')
313 preprocess_only = 1;
314 return next;
317 static char **handle_switch_I(char *arg, char **next)
319 char *path = arg+1;
321 switch (arg[1]) {
322 case '-':
323 add_pre_buffer("#split_include\n");
324 break;
326 case '\0': /* Plain "-I" */
327 path = *++next;
328 if (!path)
329 die("missing argument for -I option");
330 /* Fall through */
331 default:
332 add_pre_buffer("#add_include \"%s/\"\n", path);
334 return next;
337 static void add_cmdline_include(char *filename)
339 if (cmdline_include_nr >= CMDLINE_INCLUDE)
340 die("too many include files for %s\n", filename);
341 cmdline_include[cmdline_include_nr++] = filename;
344 static char **handle_switch_i(char *arg, char **next)
346 if (*next && !strcmp(arg, "include"))
347 add_cmdline_include(*++next);
348 else if (*next && !strcmp(arg, "imacros"))
349 add_cmdline_include(*++next);
350 else if (*next && !strcmp(arg, "isystem")) {
351 char *path = *++next;
352 if (!path)
353 die("missing argument for -isystem option");
354 add_pre_buffer("#add_isystem \"%s/\"\n", path);
355 } else if (*next && !strcmp(arg, "idirafter")) {
356 char *path = *++next;
357 if (!path)
358 die("missing argument for -idirafter option");
359 add_pre_buffer("#add_dirafter \"%s/\"\n", path);
361 return next;
364 static char **handle_switch_M(char *arg, char **next)
366 if (!strcmp(arg, "MF") || !strcmp(arg,"MQ") || !strcmp(arg,"MT")) {
367 if (!*next)
368 die("missing argument for -%s option", arg);
369 return next + 1;
371 return next;
374 static char **handle_switch_m(char *arg, char **next)
376 if (!strcmp(arg, "m64")) {
377 arch_m64 = 1;
378 } else if (!strcmp(arg, "m32")) {
379 arch_m64 = 0;
380 } else if (!strcmp(arg, "msize-long")) {
381 arch_msize_long = 1;
383 return next;
386 static void handle_arch_m64_finalize(void)
388 if (arch_m64) {
389 bits_in_long = 64;
390 max_int_alignment = 8;
391 bits_in_pointer = 64;
392 pointer_alignment = 8;
393 size_t_ctype = &ulong_ctype;
394 ssize_t_ctype = &long_ctype;
395 #ifdef __x86_64__
396 add_pre_buffer("#weak_define __x86_64__ 1\n");
397 #endif
401 static void handle_arch_msize_long_finalize(void)
403 if (arch_msize_long) {
404 size_t_ctype = &ulong_ctype;
405 ssize_t_ctype = &long_ctype;
409 static void handle_arch_finalize(void)
411 handle_arch_m64_finalize();
412 handle_arch_msize_long_finalize();
416 static char **handle_switch_o(char *arg, char **next)
418 if (!strcmp (arg, "o")) { // "-o foo"
419 if (!*++next)
420 die("argument to '-o' is missing");
422 // else "-ofoo"
424 return next;
427 static const struct warning {
428 const char *name;
429 int *flag;
430 } warnings[] = {
431 { "address-space", &Waddress_space },
432 { "bitwise", &Wbitwise },
433 { "cast-to-as", &Wcast_to_as },
434 { "cast-truncate", &Wcast_truncate },
435 { "context", &Wcontext },
436 { "decl", &Wdecl },
437 { "declaration-after-statement", &Wdeclarationafterstatement },
438 { "default-bitfield-sign", &Wdefault_bitfield_sign },
439 { "designated-init", &Wdesignated_init },
440 { "do-while", &Wdo_while },
441 { "enum-mismatch", &Wenum_mismatch },
442 { "error", &Werror },
443 { "init-cstring", &Winit_cstring },
444 { "non-pointer-null", &Wnon_pointer_null },
445 { "old-initializer", &Wold_initializer },
446 { "one-bit-signed-bitfield", &Wone_bit_signed_bitfield },
447 { "paren-string", &Wparen_string },
448 { "ptr-subtraction-blows", &Wptr_subtraction_blows },
449 { "return-void", &Wreturn_void },
450 { "shadow", &Wshadow },
451 { "sizeof-bool", &Wsizeof_bool },
452 { "transparent-union", &Wtransparent_union },
453 { "typesign", &Wtypesign },
454 { "undef", &Wundef },
455 { "uninitialized", &Wuninitialized },
456 { "vla", &Wvla },
459 enum {
460 WARNING_OFF,
461 WARNING_ON,
462 WARNING_FORCE_OFF
466 static char **handle_onoff_switch(char *arg, char **next, const struct warning warnings[], int n)
468 int flag = WARNING_ON;
469 char *p = arg + 1;
470 unsigned i;
472 if (!strcmp(p, "sparse-all")) {
473 for (i = 0; i < n; i++) {
474 if (*warnings[i].flag != WARNING_FORCE_OFF && warnings[i].flag != &Werror)
475 *warnings[i].flag = WARNING_ON;
479 // Prefixes "no" and "no-" mean to turn warning off.
480 if (p[0] == 'n' && p[1] == 'o') {
481 p += 2;
482 if (p[0] == '-')
483 p++;
484 flag = WARNING_FORCE_OFF;
487 for (i = 0; i < n; i++) {
488 if (!strcmp(p,warnings[i].name)) {
489 *warnings[i].flag = flag;
490 return next;
494 // Unknown.
495 return NULL;
498 static char **handle_switch_W(char *arg, char **next)
500 char ** ret = handle_onoff_switch(arg, next, warnings, ARRAY_SIZE(warnings));
501 if (ret)
502 return ret;
504 // Unknown.
505 return next;
508 static struct warning debugs[] = {
509 { "entry", &dbg_entry},
510 { "dead", &dbg_dead},
514 static char **handle_switch_v(char *arg, char **next)
516 char ** ret = handle_onoff_switch(arg, next, debugs, ARRAY_SIZE(debugs));
517 if (ret)
518 return ret;
520 // Unknown.
521 do {
522 verbose++;
523 } while (*++arg == 'v');
524 return next;
528 static void handle_onoff_switch_finalize(const struct warning warnings[], int n)
530 unsigned i;
532 for (i = 0; i < n; i++) {
533 if (*warnings[i].flag == WARNING_FORCE_OFF)
534 *warnings[i].flag = WARNING_OFF;
538 static void handle_switch_W_finalize(void)
540 handle_onoff_switch_finalize(warnings, ARRAY_SIZE(warnings));
542 /* default Wdeclarationafterstatement based on the C dialect */
543 if (-1 == Wdeclarationafterstatement)
545 switch (standard)
547 case STANDARD_C89:
548 case STANDARD_C94:
549 Wdeclarationafterstatement = 1;
550 break;
552 case STANDARD_C99:
553 case STANDARD_GNU89:
554 case STANDARD_GNU99:
555 Wdeclarationafterstatement = 0;
556 break;
558 default:
559 assert (0);
565 static void handle_switch_v_finalize(void)
567 handle_onoff_switch_finalize(debugs, ARRAY_SIZE(debugs));
570 static char **handle_switch_U(char *arg, char **next)
572 const char *name = arg + 1;
573 add_pre_buffer ("#undef %s\n", name);
574 return next;
577 static char **handle_switch_O(char *arg, char **next)
579 int level = 1;
580 if (arg[1] >= '0' && arg[1] <= '9')
581 level = arg[1] - '0';
582 optimize = level;
583 optimize_size = arg[1] == 's';
584 return next;
587 static char **handle_switch_ftabstop(char *arg, char **next)
589 char *end;
590 unsigned long val;
592 if (*arg == '\0')
593 die("error: missing argument to \"-ftabstop=\"");
595 /* we silently ignore silly values */
596 val = strtoul(arg, &end, 10);
597 if (*end == '\0' && 1 <= val && val <= 100)
598 tabstop = val;
600 return next;
603 static int funsigned_char;
604 static void handle_funsigned_char(void)
606 if (funsigned_char) {
607 char_ctype.ctype.modifiers &= ~MOD_SIGNED;
608 char_ctype.ctype.modifiers |= MOD_UNSIGNED;
612 static char **handle_switch_f(char *arg, char **next)
614 arg++;
616 if (!strncmp(arg, "tabstop=", 8))
617 return handle_switch_ftabstop(arg+8, next);
619 if (!strcmp(arg, "unsigned-char")) {
620 funsigned_char = 1;
621 return next;
624 /* handle switches w/ arguments above, boolean and only boolean below */
626 if (!strncmp(arg, "no-", 3)) {
627 arg += 3;
629 /* handle switch here.. */
630 return next;
633 static char **handle_switch_G(char *arg, char **next)
635 if (!strcmp (arg, "G") && *next)
636 return next + 1; // "-G 0"
637 else
638 return next; // "-G0" or (bogus) terminal "-G"
641 static char **handle_switch_a(char *arg, char **next)
643 if (!strcmp (arg, "ansi"))
644 standard = STANDARD_C89;
646 return next;
649 static char **handle_switch_s(char *arg, char **next)
651 if (!strncmp (arg, "std=", 4))
653 arg += 4;
655 if (!strcmp (arg, "c89") ||
656 !strcmp (arg, "iso9899:1990"))
657 standard = STANDARD_C89;
659 else if (!strcmp (arg, "iso9899:199409"))
660 standard = STANDARD_C94;
662 else if (!strcmp (arg, "c99") ||
663 !strcmp (arg, "c9x") ||
664 !strcmp (arg, "iso9899:1999") ||
665 !strcmp (arg, "iso9899:199x"))
666 standard = STANDARD_C99;
668 else if (!strcmp (arg, "gnu89"))
669 standard = STANDARD_GNU89;
671 else if (!strcmp (arg, "gnu99") || !strcmp (arg, "gnu9x"))
672 standard = STANDARD_GNU99;
674 else
675 die ("Unsupported C dialect");
678 return next;
681 static char **handle_nostdinc(char *arg, char **next)
683 add_pre_buffer("#nostdinc\n");
684 return next;
687 static char **handle_switch_n(char *arg, char **next)
689 if (!strcmp (arg, "nostdinc"))
690 return handle_nostdinc(arg, next);
692 return next;
695 static char **handle_base_dir(char *arg, char **next)
697 gcc_base_dir = *++next;
698 if (!gcc_base_dir)
699 die("missing argument for -gcc-base-dir option");
700 return next;
703 static char **handle_no_lineno(char *arg, char **next)
705 no_lineno = 1;
706 return next;
709 static char **handle_switch_g(char *arg, char **next)
711 if (!strcmp (arg, "gcc-base-dir"))
712 return handle_base_dir(arg, next);
714 return next;
717 static char **handle_version(char *arg, char **next)
719 printf("%s\n", SPARSE_VERSION);
720 exit(0);
723 static char **handle_param(char *arg, char **next)
725 char *value = NULL;
727 /* For now just skip any '--param=*' or '--param *' */
728 if (*arg == '\0') {
729 value = *++next;
730 } else if (isspace(*arg) || *arg == '=') {
731 value = ++arg;
734 if (!value)
735 die("missing argument for --param option");
737 return next;
740 struct switches {
741 const char *name;
742 char **(*fn)(char *, char **);
743 unsigned int prefix:1;
746 static char **handle_long_options(char *arg, char **next)
748 static struct switches cmd[] = {
749 { "param", handle_param, 1 },
750 { "version", handle_version },
751 { "nostdinc", handle_nostdinc },
752 { "gcc-base-dir", handle_base_dir},
753 { "no-lineno", handle_no_lineno},
754 { NULL, NULL }
756 struct switches *s = cmd;
758 while (s->name) {
759 int optlen = strlen(s->name);
760 if (!strncmp(s->name, arg, optlen + !s->prefix))
761 return s->fn(arg + optlen, next);
762 s++;
764 return next;
767 static char **handle_switch(char *arg, char **next)
769 switch (*arg) {
770 case 'a': return handle_switch_a(arg, next);
771 case 'D': return handle_switch_D(arg, next);
772 case 'E': return handle_switch_E(arg, next);
773 case 'f': return handle_switch_f(arg, next);
774 case 'g': return handle_switch_g(arg, next);
775 case 'G': return handle_switch_G(arg, next);
776 case 'I': return handle_switch_I(arg, next);
777 case 'i': return handle_switch_i(arg, next);
778 case 'M': return handle_switch_M(arg, next);
779 case 'm': return handle_switch_m(arg, next);
780 case 'n': return handle_switch_n(arg, next);
781 case 'o': return handle_switch_o(arg, next);
782 case 'O': return handle_switch_O(arg, next);
783 case 's': return handle_switch_s(arg, next);
784 case 'U': return handle_switch_U(arg, next);
785 case 'v': return handle_switch_v(arg, next);
786 case 'W': return handle_switch_W(arg, next);
787 case '-': return handle_long_options(arg + 1, next);
788 default:
789 break;
793 * Ignore unknown command line options:
794 * they're probably gcc switches
796 return next;
799 void declare_builtin_functions(void)
801 /* Gaah. gcc knows tons of builtin <string.h> functions */
802 add_pre_buffer("extern void *__builtin_memcpy(void *, const void *, __SIZE_TYPE__);\n");
803 add_pre_buffer("extern void *__builtin_mempcpy(void *, const void *, __SIZE_TYPE__);\n");
804 add_pre_buffer("extern void *__builtin_memset(void *, int, __SIZE_TYPE__);\n");
805 add_pre_buffer("extern int __builtin_memcmp(const void *, const void *, __SIZE_TYPE__);\n");
806 add_pre_buffer("extern char *__builtin_strcat(char *, const char *);\n");
807 add_pre_buffer("extern char *__builtin_strncat(char *, const char *, __SIZE_TYPE__);\n");
808 add_pre_buffer("extern int __builtin_strcmp(const char *, const char *);\n");
809 add_pre_buffer("extern char *__builtin_strchr(const char *, int);\n");
810 add_pre_buffer("extern char *__builtin_strcpy(char *, const char *);\n");
811 add_pre_buffer("extern char *__builtin_strncpy(char *, const char *, __SIZE_TYPE__);\n");
812 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strspn(const char *, const char *);\n");
813 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strcspn(const char *, const char *);\n");
814 add_pre_buffer("extern char * __builtin_strpbrk(const char *, const char *);\n");
815 add_pre_buffer("extern char* __builtin_stpcpy(const char *, const char*);\n");
816 add_pre_buffer("extern __SIZE_TYPE__ __builtin_strlen(const char *);\n");
818 /* And bitwise operations.. */
819 add_pre_buffer("extern int __builtin_clz(int);\n");
820 add_pre_buffer("extern int __builtin_clzl(long);\n");
821 add_pre_buffer("extern int __builtin_clzll(long long);\n");
822 add_pre_buffer("extern int __builtin_ctz(int);\n");
823 add_pre_buffer("extern int __builtin_ctzl(long);\n");
824 add_pre_buffer("extern int __builtin_ctzll(long long);\n");
825 add_pre_buffer("extern int __builtin_ffs(int);\n");
826 add_pre_buffer("extern int __builtin_ffsl(long);\n");
827 add_pre_buffer("extern int __builtin_ffsll(long long);\n");
828 add_pre_buffer("extern int __builtin_popcount(unsigned int);\n");
829 add_pre_buffer("extern int __builtin_popcountl(unsigned long);\n");
830 add_pre_buffer("extern int __builtin_popcountll(unsigned long long);\n");
832 /* And byte swaps.. */
833 add_pre_buffer("extern unsigned short __builtin_bswap16(unsigned short);\n");
834 add_pre_buffer("extern unsigned int __builtin_bswap32(unsigned int);\n");
835 add_pre_buffer("extern unsigned long long __builtin_bswap64(unsigned long long);\n");
837 /* And atomic memory access functions.. */
838 add_pre_buffer("extern int __sync_fetch_and_add(void *, ...);\n");
839 add_pre_buffer("extern int __sync_fetch_and_sub(void *, ...);\n");
840 add_pre_buffer("extern int __sync_fetch_and_or(void *, ...);\n");
841 add_pre_buffer("extern int __sync_fetch_and_and(void *, ...);\n");
842 add_pre_buffer("extern int __sync_fetch_and_xor(void *, ...);\n");
843 add_pre_buffer("extern int __sync_fetch_and_nand(void *, ...);\n");
844 add_pre_buffer("extern int __sync_add_and_fetch(void *, ...);\n");
845 add_pre_buffer("extern int __sync_sub_and_fetch(void *, ...);\n");
846 add_pre_buffer("extern int __sync_or_and_fetch(void *, ...);\n");
847 add_pre_buffer("extern int __sync_and_and_fetch(void *, ...);\n");
848 add_pre_buffer("extern int __sync_xor_and_fetch(void *, ...);\n");
849 add_pre_buffer("extern int __sync_nand_and_fetch(void *, ...);\n");
850 add_pre_buffer("extern int __sync_bool_compare_and_swap(void *, ...);\n");
851 add_pre_buffer("extern int __sync_val_compare_and_swap(void *, ...);\n");
852 add_pre_buffer("extern void __sync_synchronize();\n");
853 add_pre_buffer("extern int __sync_lock_test_and_set(void *, ...);\n");
854 add_pre_buffer("extern void __sync_lock_release(void *, ...);\n");
856 /* And some random ones.. */
857 add_pre_buffer("extern void *__builtin_return_address(unsigned int);\n");
858 add_pre_buffer("extern void *__builtin_extract_return_addr(void *);\n");
859 add_pre_buffer("extern void *__builtin_frame_address(unsigned int);\n");
860 add_pre_buffer("extern void __builtin_trap(void);\n");
861 add_pre_buffer("extern void *__builtin_alloca(__SIZE_TYPE__);\n");
862 add_pre_buffer("extern void __builtin_prefetch (const void *, ...);\n");
863 add_pre_buffer("extern long __builtin_alpha_extbl(long, long);\n");
864 add_pre_buffer("extern long __builtin_alpha_extwl(long, long);\n");
865 add_pre_buffer("extern long __builtin_alpha_insbl(long, long);\n");
866 add_pre_buffer("extern long __builtin_alpha_inswl(long, long);\n");
867 add_pre_buffer("extern long __builtin_alpha_insql(long, long);\n");
868 add_pre_buffer("extern long __builtin_alpha_inslh(long, long);\n");
869 add_pre_buffer("extern long __builtin_alpha_cmpbge(long, long);\n");
870 add_pre_buffer("extern long __builtin_labs(long);\n");
871 add_pre_buffer("extern double __builtin_fabs(double);\n");
872 add_pre_buffer("extern __SIZE_TYPE__ __builtin_va_arg_pack_len(void);\n");
874 /* Add Blackfin-specific stuff */
875 add_pre_buffer(
876 "#ifdef __bfin__\n"
877 "extern void __builtin_bfin_csync(void);\n"
878 "extern void __builtin_bfin_ssync(void);\n"
879 "extern int __builtin_bfin_norm_fr1x32(int);\n"
880 "#endif\n"
883 /* And some floating point stuff.. */
884 add_pre_buffer("extern int __builtin_isgreater(float, float);\n");
885 add_pre_buffer("extern int __builtin_isgreaterequal(float, float);\n");
886 add_pre_buffer("extern int __builtin_isless(float, float);\n");
887 add_pre_buffer("extern int __builtin_islessequal(float, float);\n");
888 add_pre_buffer("extern int __builtin_islessgreater(float, float);\n");
889 add_pre_buffer("extern int __builtin_isunordered(float, float);\n");
891 /* And some __FORTIFY_SOURCE ones.. */
892 add_pre_buffer ("extern __SIZE_TYPE__ __builtin_object_size(void *, int);\n");
893 add_pre_buffer ("extern void * __builtin___memcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
894 add_pre_buffer ("extern void * __builtin___memmove_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
895 add_pre_buffer ("extern void * __builtin___mempcpy_chk(void *, const void *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
896 add_pre_buffer ("extern void * __builtin___memset_chk(void *, int, __SIZE_TYPE__, __SIZE_TYPE__);\n");
897 add_pre_buffer ("extern int __builtin___sprintf_chk(char *, int, __SIZE_TYPE__, const char *, ...);\n");
898 add_pre_buffer ("extern int __builtin___snprintf_chk(char *, __SIZE_TYPE__, int , __SIZE_TYPE__, const char *, ...);\n");
899 add_pre_buffer ("extern char * __builtin___stpcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
900 add_pre_buffer ("extern char * __builtin___strcat_chk(char *, const char *, __SIZE_TYPE__);\n");
901 add_pre_buffer ("extern char * __builtin___strcpy_chk(char *, const char *, __SIZE_TYPE__);\n");
902 add_pre_buffer ("extern char * __builtin___strncat_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
903 add_pre_buffer ("extern char * __builtin___strncpy_chk(char *, const char *, __SIZE_TYPE__, __SIZE_TYPE__);\n");
904 add_pre_buffer ("extern int __builtin___vsprintf_chk(char *, int, __SIZE_TYPE__, const char *, __builtin_va_list);\n");
905 add_pre_buffer ("extern int __builtin___vsnprintf_chk(char *, __SIZE_TYPE__, int, __SIZE_TYPE__, const char *, __builtin_va_list ap);\n");
906 add_pre_buffer ("extern void __builtin_unreachable(void);\n");
909 void create_builtin_stream(void)
911 add_pre_buffer("#weak_define __GNUC__ %d\n", gcc_major);
912 add_pre_buffer("#weak_define __GNUC_MINOR__ %d\n", gcc_minor);
913 add_pre_buffer("#weak_define __GNUC_PATCHLEVEL__ %d\n", gcc_patchlevel);
915 /* We add compiler headers path here because we have to parse
916 * the arguments to get it, falling back to default. */
917 add_pre_buffer("#add_system \"%s/include\"\n", gcc_base_dir);
918 add_pre_buffer("#add_system \"%s/include-fixed\"\n", gcc_base_dir);
920 add_pre_buffer("#define __extension__\n");
921 add_pre_buffer("#define __pragma__\n");
923 // gcc defines __SIZE_TYPE__ to be size_t. For linux/i86 and
924 // solaris/sparc that is really "unsigned int" and for linux/x86_64
925 // it is "long unsigned int". In either case we can probably
926 // get away with this. We need the #weak_define as cgcc will define
927 // the right __SIZE_TYPE__.
928 if (size_t_ctype == &ulong_ctype)
929 add_pre_buffer("#weak_define __SIZE_TYPE__ long unsigned int\n");
930 else
931 add_pre_buffer("#weak_define __SIZE_TYPE__ unsigned int\n");
932 add_pre_buffer("#weak_define __STDC__ 1\n");
934 switch (standard)
936 case STANDARD_C89:
937 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
938 break;
940 case STANDARD_C94:
941 add_pre_buffer("#weak_define __STDC_VERSION__ 199409L\n");
942 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
943 break;
945 case STANDARD_C99:
946 add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
947 add_pre_buffer("#weak_define __STRICT_ANSI__\n");
948 break;
950 case STANDARD_GNU89:
951 break;
953 case STANDARD_GNU99:
954 add_pre_buffer("#weak_define __STDC_VERSION__ 199901L\n");
955 break;
957 default:
958 assert (0);
961 add_pre_buffer("#define __builtin_stdarg_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
962 add_pre_buffer("#define __builtin_va_start(a,b) ((a) = (__builtin_va_list)(&(b)))\n");
963 add_pre_buffer("#define __builtin_ms_va_start(a,b) ((a) = (__builtin_ms_va_list)(&(b)))\n");
964 add_pre_buffer("#define __builtin_va_arg(arg,type) ({ type __va_arg_ret = *(type *)(arg); arg += sizeof(type); __va_arg_ret; })\n");
965 add_pre_buffer("#define __builtin_va_alist (*(void *)0)\n");
966 add_pre_buffer("#define __builtin_va_arg_incr(x) ((x) + 1)\n");
967 add_pre_buffer("#define __builtin_va_copy(dest, src) ({ dest = src; (void)0; })\n");
968 add_pre_buffer("#define __builtin_va_end(arg)\n");
969 add_pre_buffer("#define __builtin_ms_va_end(arg)\n");
970 add_pre_buffer("#define __builtin_va_arg_pack()\n");
972 /* FIXME! We need to do these as special magic macros at expansion time! */
973 add_pre_buffer("#define __BASE_FILE__ \"base_file.c\"\n");
975 if (optimize)
976 add_pre_buffer("#define __OPTIMIZE__ 1\n");
977 if (optimize_size)
978 add_pre_buffer("#define __OPTIMIZE_SIZE__ 1\n");
980 /* GCC defines these for limits.h */
981 add_pre_buffer("#weak_define __SHRT_MAX__ " STRINGIFY(__SHRT_MAX__) "\n");
982 add_pre_buffer("#weak_define __SCHAR_MAX__ " STRINGIFY(__SCHAR_MAX__) "\n");
983 add_pre_buffer("#weak_define __INT_MAX__ " STRINGIFY(__INT_MAX__) "\n");
984 add_pre_buffer("#weak_define __LONG_MAX__ " STRINGIFY(__LONG_MAX__) "\n");
985 add_pre_buffer("#weak_define __LONG_LONG_MAX__ " STRINGIFY(__LONG_LONG_MAX__) "\n");
986 add_pre_buffer("#weak_define __WCHAR_MAX__ " STRINGIFY(__WCHAR_MAX__) "\n");
987 add_pre_buffer("#weak_define __SIZEOF_POINTER__ " STRINGIFY(__SIZEOF_POINTER__) "\n");
988 add_pre_buffer("#weak_define __CHAR_BIT__ " STRINGIFY(__CHAR_BIT__) "\n");
991 static struct symbol_list *sparse_tokenstream(struct token *token)
993 // Preprocess the stream
994 token = preprocess(token);
996 if (preprocess_only) {
997 while (!eof_token(token)) {
998 int prec = 1;
999 struct token *next = token->next;
1000 const char *separator = "";
1001 if (next->pos.whitespace)
1002 separator = " ";
1003 if (next->pos.newline) {
1004 separator = "\n\t\t\t\t\t";
1005 prec = next->pos.pos;
1006 if (prec > 4)
1007 prec = 4;
1009 printf("%s%.*s", show_token(token), prec, separator);
1010 token = next;
1012 putchar('\n');
1014 return NULL;
1017 // Parse the resulting C code
1018 while (!eof_token(token))
1019 token = external_declaration(token, &translation_unit_used_list);
1020 return translation_unit_used_list;
1023 static struct symbol_list *sparse_file(const char *filename)
1025 int fd;
1026 struct token *token;
1028 if (strcmp (filename, "-") == 0) {
1029 fd = 0;
1030 } else {
1031 fd = open(filename, O_RDONLY);
1032 if (fd < 0)
1033 die("No such file: %s", filename);
1036 // Tokenize the input stream
1037 token = tokenize(filename, fd, NULL, includepath);
1038 store_all_tokens(token);
1039 close(fd);
1041 return sparse_tokenstream(token);
1045 * This handles the "-include" directive etc: we're in global
1046 * scope, and all types/macros etc will affect all the following
1047 * files.
1049 * NOTE NOTE NOTE! "#undef" of anything in this stage will
1050 * affect all subsequent files too, i.e. we can have non-local
1051 * behaviour between files!
1053 static struct symbol_list *sparse_initial(void)
1055 int i;
1057 // Prepend any "include" file to the stream.
1058 // We're in global scope, it will affect all files!
1059 for (i = 0; i < cmdline_include_nr; i++)
1060 add_pre_buffer("#argv_include \"%s\"\n", cmdline_include[i]);
1062 return sparse_tokenstream(pre_buffer_begin);
1065 struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list **filelist)
1067 char **args;
1068 struct symbol_list *list;
1070 // Initialize symbol stream first, so that we can add defines etc
1071 init_symbols();
1073 args = argv;
1074 for (;;) {
1075 char *arg = *++args;
1076 if (!arg)
1077 break;
1079 if (arg[0] == '-' && arg[1]) {
1080 args = handle_switch(arg+1, args);
1081 continue;
1083 add_ptr_list_notag(filelist, arg);
1085 handle_switch_W_finalize();
1086 handle_switch_v_finalize();
1088 handle_arch_finalize();
1090 list = NULL;
1091 if (!ptr_list_empty(filelist)) {
1092 // Initialize type system
1093 init_ctype();
1094 handle_funsigned_char();
1096 create_builtin_stream();
1097 add_pre_buffer("#define __CHECKER__ 1\n");
1098 if (!preprocess_only)
1099 declare_builtin_functions();
1101 list = sparse_initial();
1104 * Protect the initial token allocations, since
1105 * they need to survive all the others
1107 protect_token_alloc();
1109 return list;
1112 struct symbol_list * sparse_keep_tokens(char *filename)
1114 struct symbol_list *res;
1116 /* Clear previous symbol list */
1117 translation_unit_used_list = NULL;
1119 new_file_scope();
1120 res = sparse_file(filename);
1122 /* And return it */
1123 return res;
1127 struct symbol_list * __sparse(char *filename)
1129 struct symbol_list *res;
1131 res = sparse_keep_tokens(filename);
1133 /* Drop the tokens for this file after parsing */
1134 clear_token_alloc();
1136 /* And return it */
1137 return res;
1140 struct symbol_list * sparse(char *filename)
1142 struct symbol_list *res = __sparse(filename);
1144 /* Evaluate the complete symbol list */
1145 evaluate_symbol_list(res);
1147 return res;