lael-labs/tinycc

libtcc.c+15−20

 /* XXX: get rid of this ASAP (or maybe not) */
 ST_DATA struct TCCState *tcc_state;
+#ifdef MEM_DEBUG
 static int nb_states;
+#endif
 /********************************************************/
 #ifdef _WIN32
     return ptr;
 }
-PUB_FUNC void tcc_memcheck(void)
-{
-}
 #else
 #define MEM_DEBUG_MAGIC1 0xFEEDDEB1
 ST_FUNC void tcc_close(void)
 {
+    TCCState *s1 = tcc_state;
     BufferedFile *bf = file;
     if (bf->fd > 0) {
         close(bf->fd);
 /* compile the file opened in 'file'. Return non zero if errors. */
 static int tcc_compile(TCCState *s1, int filetype, const char *str, int fd)
 {
-    tccelf_begin_file(s1);
     /* Here we enter the code section where we use the global variables for
        parsing and code generation (tccpp.c, tccgen.c, <target>-gen.c).
        Other threads need to wait until we're done.
-       Alternatively we could of course pass TCCState *s1 everwhere
-       except that it would look extremly ugly.
        Alternatively we could use thread local storage for those global
        variables, which may or may not have advantages */
         }
         is_asm = !!(filetype & (AFF_TYPE_ASM|AFF_TYPE_ASMPP));
+        tccelf_begin_file(s1);
         preprocess_start(s1, is_asm);
+        tccgen_init(s1);
         if (s1->output_type == TCC_OUTPUT_PREPROCESS) {
             tcc_preprocess(s1);
         } else if (is_asm) {
         }
     }
     s1->error_set_jmp_enabled = 0;
-    tccgen_finish(s1, 1);
+    tccgen_finish(s1);
     preprocess_end(s1);
-    tccgen_finish(s1, 2);
+    tccelf_end_file(s1);
     tcc_state = NULL;
     POST_SEM();
-    tccelf_end_file(s1);
     return s1->nb_errors != 0 ? -1 : 0;
 }
     s = tcc_mallocz(sizeof(TCCState));
     if (!s)
         return NULL;
-    WAIT_SEM();
+#ifdef MEM_DEBUG
     ++nb_states;
-    POST_SEM();
+#endif
 #undef gnu_ext
 #endif
     tcc_free(s1);
-    WAIT_SEM();
+#ifdef MEM_DEBUG
     if (0 == --nb_states)
         tcc_memcheck();
-    POST_SEM();
+#endif
 }
 LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
             else if (*optarg == 't')
                 s->dflag = 16;
             else if (isnum(*optarg))
-                g_debug = atoi(optarg);
+                s->g_debug |= atoi(optarg);
             else
                 goto unsupported_option;
             break;
             tcc_add_sysinclude_path(s, optarg);
             break;
         case TCC_OPTION_include:
-            cstr_printf(&s->cmdline_defs, "#include \"%s\"\n", optarg);
+            cstr_printf(&s->cmdline_incl, "#include \"%s\"\n", optarg);
             break;
         case TCC_OPTION_nostdinc:
             s->nostdinc = 1;
     dynarray_reset(&argv, &argc);
 }
-PUB_FUNC void tcc_print_stats(TCCState *s, unsigned total_time)
+PUB_FUNC void tcc_print_stats(TCCState *s1, unsigned total_time)
 {
     if (total_time < 1)
         total_time = 1;
         total_bytes = 1;
     fprintf(stderr, "* %d idents, %d lines, %d bytes\n"
                     "* %0.3f s, %u lines/s, %0.1f MB/s\n",
-           tok_ident - TOK_IDENT, total_lines, total_bytes,
+           total_idents, total_lines, total_bytes,
            (double)total_time/1000,
            (unsigned)total_lines*1000/total_time,
            (double)total_bytes/1000/total_time);

tcc.h+16−8

 /* #define PP_DEBUG */
 /* include file debug */
 /* #define INC_DEBUG */
-/* memory leak debug */
+/* memory leak debug (only for single threaded usage) */
 /* #define MEM_DEBUG */
 /* assembler debug */
 /* #define ASM_DEBUG */
     int fd, cc; /* used by tcc_load_ldscript */
+    /* benchmark info */
+    int total_idents;
+    int total_lines;
+    int total_bytes;
+    /* option -dnum (for general development purposes) */
+    int g_debug;
     /* used by main and tcc_parse_args only */
     struct filespec **files; /* files seen on command line */
     int nb_files; /* number thereof */
 #define realloc(p, s) use_tcc_realloc(p, s)
 #undef strdup
 #define strdup(s) use_tcc_strdup(s)
-PUB_FUNC void tcc_memcheck(void);
 PUB_FUNC void _tcc_error_noabort(const char *fmt, ...);
 PUB_FUNC NORETURN void _tcc_error(const char *fmt, ...);
 PUB_FUNC void _tcc_warning(const char *fmt, ...);
 ST_DATA CString tokcstr; /* current parsed string, if any */
 /* display benchmark infos */
-ST_DATA int total_lines;
-ST_DATA int total_bytes;
 ST_DATA int tok_ident;
 ST_DATA TokenSym **table_ident;
 ST_DATA Sym *global_label_stack;
 ST_DATA Sym *define_stack;
 ST_DATA CType char_pointer_type, func_old_type, int_type, size_type;
-ST_DATA SValue __vstack[1+/*to make bcheck happy*/ VSTACK_SIZE], *vtop, *pvtop;
+ST_DATA SValue *vtop;
-#define vstack  (__vstack + 1)
 ST_DATA int rsym, anon_sym, ind, loc;
 ST_DATA int const_wanted; /* true if constant wanted */
 ST_DATA int func_var; /* true if current function is variadic */
 ST_DATA int func_vc;
 ST_DATA const char *funcname;
-ST_DATA int g_debug;
 ST_FUNC void tcc_debug_start(TCCState *s1);
 ST_FUNC void tcc_debug_end(TCCState *s1);
 ST_FUNC void tcc_debug_funcend(TCCState *s1, int size);
 ST_FUNC void tcc_debug_line(TCCState *s1);
+ST_FUNC void tccgen_init(TCCState *s1);
 ST_FUNC int tccgen_compile(TCCState *s1);
-ST_FUNC void tccgen_finish(TCCState *s1, int f);
+ST_FUNC void tccgen_finish(TCCState *s1);
 ST_FUNC void check_vstack(void);
 ST_INLN int is_float(int t);
 #define tcc_error           TCC_SET_STATE(_tcc_error)
 #define tcc_warning         TCC_SET_STATE(_tcc_warning)
+#define total_idents        TCC_STATE_VAR(total_idents)
+#define total_lines         TCC_STATE_VAR(total_lines)
+#define total_bytes         TCC_STATE_VAR(total_bytes)
 PUB_FUNC void tcc_enter_state(TCCState *s1);
 /********************************************************/

tccelf.c+9−4

     if (!as_needed)
         s1->new_undef_sym = 0;
     t = ld_next(s1, filename, sizeof(filename));
-    if (t != '(')
+    if (t != '(') {
-        expect("(");
+        tcc_error_noabort("( expected");
+        ret = -1;
+        goto lib_parse_error;
+    }
     t = ld_next(s1, filename, sizeof(filename));
     for(;;) {
         libname[0] = '\0';
                    !strcmp(cmd, "TARGET")) {
             /* ignore some commands */
             t = ld_next(s1, cmd, sizeof(cmd));
-            if (t != '(')
+            if (t != '(') {
-                expect("(");
+                tcc_error_noabort("( expected");
+                return -1;
+            }
             for(;;) {
                 t = ld_next(s1, filename, sizeof(filename));
                 if (t == LD_TOK_EOF) {

tccgen.c+29−27

@@ -47,7 +47,9 @@ static int in_sizeof; · 46 unmodified lines
47	static int in_generic;	47	static int in_generic;
48	static int section_sym;	48	static int section_sym;
49		49
50	ST_DATA SValue __vstack[1+VSTACK_SIZE], vtop, pvtop;	50	ST_DATA SValue *vtop;
		51	static SValue _vstack[1 + VSTACK_SIZE];
		52	#define vstack (_vstack + 1)
51		53
52	ST_DATA int const_wanted; /* true if constant wanted */	54	ST_DATA int const_wanted; /* true if constant wanted */
53	ST_DATA int nocode_wanted; /* no code generation wanted */	55	ST_DATA int nocode_wanted; /* no code generation wanted */
@@ -77,7 +79,6 @@ ST_DATA int func_var; /* true if current function is variadic (used by return in · 23 unmodified lines
77	ST_DATA int func_vc;	79	ST_DATA int func_vc;
78	static int last_line_num, new_file, func_ind; /* debug info control */	80	static int last_line_num, new_file, func_ind; /* debug info control */
79	ST_DATA const char *funcname;	81	ST_DATA const char *funcname;
80	ST_DATA int g_debug;
81		82
82	ST_DATA CType char_pointer_type, func_old_type, int_type, size_type, ptrdiff_type;	83	ST_DATA CType char_pointer_type, func_old_type, int_type, size_type, ptrdiff_type;
83		84
@@ -180,8 +181,8 @@ ST_FUNC void test_lvalue(void) · 96 unmodified lines
180		181
181	ST_FUNC void check_vstack(void)	182	ST_FUNC void check_vstack(void)
182	{	183	{
183	if (pvtop != vtop)	184	if (vtop != vstack - 1)
184	tcc_error("internal compiler error: vstack leak (%d)", vtop - pvtop);	185	tcc_error("internal compiler error: vstack leak (%d)", vtop - vstack + 1);
185	}	186	}
186		187
187	/* ------------------------------------------------------------------------- */	188	/* ------------------------------------------------------------------------- */
@@ -325,15 +326,11 @@ ST_FUNC void tcc_debug_eincl(TCCState *s1) · 137 unmodified lines
325	}	326	}
326		327
327	/* ------------------------------------------------------------------------- */	328	/* ------------------------------------------------------------------------- */
328	ST_FUNC int tccgen_compile(TCCState *s1)	329	/* initialize vstack and types. This must be done also for tcc -E */
		330	ST_FUNC void tccgen_init(TCCState *s1)
329	{	331	{
330	cur_text_section = NULL;	332	vtop = vstack - 1;
331	funcname = "";	333	memset(vtop, 0, sizeof *vtop);
332	anon_sym = SYM_FIRST_ANOM;
333	section_sym = 0;
334	const_wanted = 0;
335	nocode_wanted = 0x80000000;
336	local_scope = 0;
337		334
338	/* define some often used types */	335	/* define some often used types */
339	int_type.t = VT_INT;	336	int_type.t = VT_INT;
@@ -353,17 +350,25 @@ ST_FUNC int tccgen_compile(TCCState *s1) · 13 unmodified lines
353	func_old_type.ref = sym_push(SYM_FIELD, &int_type, 0, 0);	350	func_old_type.ref = sym_push(SYM_FIELD, &int_type, 0, 0);
354	func_old_type.ref->f.func_call = FUNC_CDECL;	351	func_old_type.ref->f.func_call = FUNC_CDECL;
355	func_old_type.ref->f.func_type = FUNC_OLD;	352	func_old_type.ref->f.func_type = FUNC_OLD;
		353	}
356		354
357	tcc_debug_start(s1);	355	ST_FUNC int tccgen_compile(TCCState *s1)
		356	{
		357	cur_text_section = NULL;
		358	funcname = "";
		359	anon_sym = SYM_FIRST_ANOM;
		360	section_sym = 0;
		361	const_wanted = 0;
		362	nocode_wanted = 0x80000000;
		363	local_scope = 0;
358		364
		365	tcc_debug_start(s1);
359	#ifdef TCC_TARGET_ARM	366	#ifdef TCC_TARGET_ARM
360	arm_init(s1);	367	arm_init(s1);
361	#endif	368	#endif
362
363	#ifdef INC_DEBUG	369	#ifdef INC_DEBUG
364	printf("%s: **** new file\n", file->filename);	370	printf("%s: **** new file\n", file->filename);
365	#endif	371	#endif
366
367	parse_flags = PARSE_FLAG_PREPROCESS \| PARSE_FLAG_TOK_NUM \| PARSE_FLAG_TOK_STR;	372	parse_flags = PARSE_FLAG_PREPROCESS \| PARSE_FLAG_TOK_NUM \| PARSE_FLAG_TOK_STR;
368	next();	373	next();
369	decl(VT_CONST);	374	decl(VT_CONST);
@@ -374,19 +379,16 @@ ST_FUNC int tccgen_compile(TCCState *s1) · 4 unmodified lines
374	return 0;	379	return 0;
375	}	380	}
376		381
377	ST_FUNC void tccgen_finish(TCCState *s1, int f)	382	ST_FUNC void tccgen_finish(TCCState *s1)
378	{	383	{
379	if (f == 1) {	384	free_inline_functions(s1);
380	free_inline_functions(s1);	385	sym_pop(&global_stack, NULL, 0);
381	sym_pop(&global_stack, NULL, 0);	386	sym_pop(&local_stack, NULL, 0);
382	sym_pop(&local_stack, NULL, 0);	387	/* free preprocessor macros */
383	}	388	free_defines(NULL);
384		389	/* free sym_pools */
385	if (f == 2) {	390	dynarray_reset(&sym_pools, &nb_sym_pools);
386	/* free sym_pools */	391	sym_free_first = NULL;
387	dynarray_reset(&sym_pools, &nb_sym_pools);
388	sym_free_first = NULL;
389	}
390	}	392	}
391		393
392	/* ------------------------------------------------------------------------- */	394	/* ------------------------------------------------------------------------- */

tccpe.c+4−2

         switch (si->cls) {
             case sec_text:
-                pe_header.opthdr.BaseOfCode = addr;
+                if (!pe_header.opthdr.BaseOfCode)
+                    pe_header.opthdr.BaseOfCode = addr;
                 break;
             case sec_data:
 #ifndef TCC_TARGET_X86_64
-                pe_header.opthdr.BaseOfData = addr;
+                if (!pe_header.opthdr.BaseOfData)
+                    pe_header.opthdr.BaseOfData = addr;
 #endif
                 break;

tccpp.c+6−11

 ST_DATA CString tokcstr; /* current parsed string, if any */
 /* display benchmark infos */
-ST_DATA int total_lines;
-ST_DATA int total_bytes;
 ST_DATA int tok_ident;
 ST_DATA TokenSym **table_ident;
 /* return the current character, handling end of block if necessary
    (but not stray) */
-ST_FUNC int handle_eob(void)
+static int handle_eob(void)
 {
     BufferedFile *bf = file;
     int len;
 }
 /* read next char from current input file and handle end of input buffer */
-ST_INLN void inp(void)
+static inline void inp(void)
 {
     ch = *(++(file->buf_ptr));
     /* end of buffer/file handling */
 /* input with '\[\r]\n' handling. Note that this function cannot
    handle other characters after '\', so you cannot call it inside
    strings or comments */
-ST_FUNC void minp(void)
+static void minp(void)
 {
     inp();
     if (ch == '\\')
 }
 /* C comments */
-ST_FUNC uint8_t *parse_comment(uint8_t *p)
+static uint8_t *parse_comment(uint8_t *p)
 {
     int c;
     pp_counter = 0;
     pp_debug_tok = pp_debug_symv = 0;
     pp_once++;
-    pvtop = vtop = vstack - 1;
-    memset(vtop, 0, sizeof *vtop);
     s1->pack_stack[0] = 0;
     s1->pack_stack_ptr = s1->pack_stack;
     while (macro_stack)
         end_macro();
     macro_ptr = NULL;
     while (file)
         tcc_close();
     tccpp_delete(s1);
 }
 {
     int i, n;
-    free_defines(NULL);
     dynarray_reset(&s->cached_includes, &s->nb_cached_includes);
     /* free tokens */
     n = tok_ident - TOK_IDENT;
+    if (n > total_idents)
+        total_idents = n;
     for(i = 0; i < n; i++)
         tal_free(toksym_alloc, table_ident[i]);
     tcc_free(table_ident);

tccrun.c+1−1

@@ -373,7 +373,7 @@ static addr_t rt_printline(TCCState s1, addr_t wanted_pc, const char msg) · 372 unmodified lines
373	if (symtab_section) {	373	if (symtab_section) {
374	esym_start = (ElfW(Sym) *)(symtab_section->data);	374	esym_start = (ElfW(Sym) *)(symtab_section->data);
375	esym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);	375	esym_end = (ElfW(Sym) *)(symtab_section->data + symtab_section->data_offset);
376	elf_str = symtab_section->link->data;	376	elf_str = (char *) symtab_section->link->data;
377	}	377	}
378		378
379	for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {	379	for (sym = stab_sym + 1; sym < stab_sym_end; ++sym) {

tests/libtcc_test_mt.c+3−2

     argv[argc] = NULL;
     s = new_state(1);
-    sleep_ms(1);
+    sleep_ms(2);
     ret = tcc_add_file(s, argv[0]);
-    sleep_ms(1);
+    sleep_ms(3);
     if (ret >= 0)
         tcc_run(s, argc, argv);
     tcc_delete(s);
+    fflush(stdout);
     return 0;
 }