allow tcc be build from separate objects

If you want that, run: make NOTALLINONE=1

grischka committed 16 years ago

Commit 88a3cca1 parent 7fa712e16 files · +1317 −1040Browse files

Unified · Split

16 files

Makefile +26 −13
arm-gen.c +39 −31
c67-gen.c +50 −45
i386-asm.c +11 −9
i386-gen.c +44 −34
libtcc.c +108 −624
tcc.c +16 −16
tcc.h +406 −28
tccasm.c +10 −8
tcccoff.c +3 −1
tccelf.c +27 −35
tccgen.c +290 −52
tccpe.c +62 −67
tccpp.c +179 −42
tccrun.c +22 −21
x86_64-gen.c +24 −14

 PROGS+=$(PROGS_CROSS)
 endif
+# NOTALLINONE = 1
 all: $(PROGS) $(LIBTCC1) $(BCHECK_O) libtcc.a tcc-doc.html tcc.1 libtcc_test$(EXESUF)
 # Host Tiny C Compiler
-tcc$(EXESUF): $(NATIVE_FILES)
+tcc$(EXESUF): tcc.o libtcc.a
-	$(CC) -o $@ $< $(NATIVE_TARGET) $(CFLAGS) $(LIBS)
+	$(CC) -o $@ $^ $(LIBS)
 # Cross Tiny C Compilers
 i386-tcc$(EXESUF): $(I386_FILES)
 	$(CC) -o $@ $< -DTCC_TARGET_ARM -DTCC_ARM_EABI $(CFLAGS) $(LIBS)
 # libtcc generation and test
-libtcc.o: $(NATIVE_FILES)
-	$(CC) -o $@ -c libtcc.c $(NATIVE_TARGET) $(CFLAGS)
-libtcc.a: libtcc.o
+ifdef NOTALLINONE
+LIBTCC_OBJ = $(filter-out tcc.o,$(patsubst %.c,%.o,$(filter %.c,$(NATIVE_FILES))))
+LIBTCC_INC = $(filter %.h,$(CORE_FILES)) $(filter-out $(CORE_FILES),$(NATIVE_FILES))
+$(LIBTCC_OBJ) : DEFINES += -DNOTALLINONE
+else
+LIBTCC_OBJ = libtcc.o
+LIBTCC_INC = $(NATIVE_FILES)
+endif
+tcc.o : DEFINES += -DNOTALLINONE
+$(LIBTCC_OBJ) tcc.o : %.o : %.c $(LIBTCC_INC)
+	$(CC) -o $@ -c $< $(NATIVE_TARGET) $(CFLAGS) $(DEFINES)
+libtcc.a: $(LIBTCC_OBJ)
 	$(AR) rcs $@ $^
 libtcc_test$(EXESUF): tests/libtcc_test.c libtcc.a
 	rm -rf /tmp/$(TCC-VERSION)
 # in tests subdir
-test clean:
+%est:
 	$(MAKE) -C tests $@
-config.mak:
+clean:
-	@echo Running configure ...
-	@./configure
-# clean
-clean: local_clean
-local_clean:
 	rm -vf $(PROGS) tcc_p$(EXESUF) tcc.pod *~ *.o *.a *.out libtcc_test$(EXESUF)
+	$(MAKE) -C tests $@
 distclean: clean
 	rm -vf config.h config.mak config.texi tcc.1
+config.mak:
+	@echo Running configure ...
+	@./configure
 endif # ifeq ($(TOP),.)

arm-gen.c+39−31

@@ -20,11 +20,12 @@ · 19 unmodified lines
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21	*/	21	*/
22		22
		23	#ifdef TARGET_DEFS_ONLY
		24
23	#ifdef TCC_ARM_EABI	25	#ifdef TCC_ARM_EABI
24	#define TCC_ARM_VFP	26	#define TCC_ARM_VFP
25	#endif	27	#endif
26		28
27
28	/* number of available registers */	29	/* number of available registers */
29	#ifdef TCC_ARM_VFP	30	#ifdef TCC_ARM_VFP
30	#define NB_REGS 13	31	#define NB_REGS 13
@@ -75,32 +76,6 @@ enum { · 44 unmodified lines
75	#endif	76	#endif
76	};	77	};
77		78
78	const int reg_classes[NB_REGS] = {
79	/* r0 */ RC_INT \| RC_R0,
80	/* r1 */ RC_INT \| RC_R1,
81	/* r2 */ RC_INT \| RC_R2,
82	/* r3 */ RC_INT \| RC_R3,
83	/* r12 */ RC_INT \| RC_R12,
84	/* f0 */ RC_FLOAT \| RC_F0,
85	/* f1 */ RC_FLOAT \| RC_F1,
86	/* f2 */ RC_FLOAT \| RC_F2,
87	/* f3 */ RC_FLOAT \| RC_F3,
88	#ifdef TCC_ARM_VFP
89	/* d4/s8 */ RC_FLOAT \| RC_F4,
90	/* d5/s10 */ RC_FLOAT \| RC_F5,
91	/* d6/s12 */ RC_FLOAT \| RC_F6,
92	/* d7/s14 */ RC_FLOAT \| RC_F7,
93	#endif
94	};
95
96	static int two2mask(int a,int b) {
97	return (reg_classes[a]\|reg_classes[b])&~(RC_INT\|RC_FLOAT);
98	}
99
100	static int regmask(int r) {
101	return reg_classes[r]&~(RC_INT\|RC_FLOAT);
102	}
103
104	#ifdef TCC_ARM_VFP	79	#ifdef TCC_ARM_VFP
105	#define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)	80	#define T2CPR(t) (((t) & VT_BTYPE) != VT_FLOAT ? 0x100 : 0)
106	#endif	81	#endif
@@ -171,10 +146,42 @@ static CType float_type, double_type, func_float_type, func_double_type; · 64 unmodified lines
171	#define ELF_PAGE_SIZE 0x1000	146	#define ELF_PAGE_SIZE 0x1000
172		147
173	/******************************************************/	148	/******************************************************/
		149	#else /* ! TARGET_DEFS_ONLY */
		150	/******************************************************/
		151	#include "tcc.h"
		152
		153	ST_DATA const int reg_classes[NB_REGS] = {
		154	/* r0 */ RC_INT \| RC_R0,
		155	/* r1 */ RC_INT \| RC_R1,
		156	/* r2 */ RC_INT \| RC_R2,
		157	/* r3 */ RC_INT \| RC_R3,
		158	/* r12 */ RC_INT \| RC_R12,
		159	/* f0 */ RC_FLOAT \| RC_F0,
		160	/* f1 */ RC_FLOAT \| RC_F1,
		161	/* f2 */ RC_FLOAT \| RC_F2,
		162	/* f3 */ RC_FLOAT \| RC_F3,
		163	#ifdef TCC_ARM_VFP
		164	/* d4/s8 */ RC_FLOAT \| RC_F4,
		165	/* d5/s10 */ RC_FLOAT \| RC_F5,
		166	/* d6/s12 */ RC_FLOAT \| RC_F6,
		167	/* d7/s14 */ RC_FLOAT \| RC_F7,
		168	#endif
		169	};
		170
174	static unsigned long func_sub_sp_offset,last_itod_magic;	171	static unsigned long func_sub_sp_offset,last_itod_magic;
175	static int leaffunc;	172	static int leaffunc;
176		173
177	void o(unsigned long i)	174	static int two2mask(int a,int b) {
		175	return (reg_classes[a]\|reg_classes[b])&~(RC_INT\|RC_FLOAT);
		176	}
		177
		178	static int regmask(int r) {
		179	return reg_classes[r]&~(RC_INT\|RC_FLOAT);
		180	}
		181
		182	/******************************************************/
		183
		184	void o(unsigned int i)
178	{	185	{
179	/* this is a good place to start adding big-endian support*/	186	/* this is a good place to start adding big-endian support*/
180	int ind1;	187	int ind1;
@@ -304,7 +311,7 @@ void stuff_const_harder(unsigned long op,unsigned long v) { · 123 unmodified lines
304	}	311	}
305	}	312	}
306		313
307	unsigned long encbranch(int pos,int addr,int fail)	314	ST_FUNC unsigned long encbranch(int pos,int addr,int fail)
308	{	315	{
309	addr-=pos+8;	316	addr-=pos+8;
310	addr/=4;	317	addr/=4;
@@ -1571,7 +1578,7 @@ void gen_opf(int op) · 1260 unmodified lines
1571		1578
1572	/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'	1579	/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
1573	and 'long long' cases. */	1580	and 'long long' cases. */
1574	void gen_cvt_itof1(int t)	1581	ST_FUNC void gen_cvt_itof1(int t)
1575	{	1582	{
1576	int r,r2,bt;	1583	int r,r2,bt;
1577	bt=vtop->type.t & VT_BTYPE;	1584	bt=vtop->type.t & VT_BTYPE;
@@ -1732,4 +1739,5 @@ void ggoto(void) · 154 unmodified lines
1732		1739
1733	/* end of ARM code generator */	1740	/* end of ARM code generator */
1734	/*************************************************************/	1741	/*************************************************************/
1735		1742	#endif
		1743	/*************************************************************/

c67-gen.c+50−45

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#ifdef TARGET_DEFS_ONLY
 //#define ASSEMBLY_LISTING_C67
 /* number of available registers */
     TREG_C67_B13,
 };
-const int reg_classes[NB_REGS] = {
-						/* eax */ RC_INT | RC_FLOAT | RC_EAX,
-						// only allow even regs for floats (allow for doubles)
-    /* ecx */ RC_INT | RC_ECX,
-								/* edx */ RC_INT | RC_INT_BSIDE | RC_FLOAT | RC_EDX,
-								// only allow even regs for floats (allow for doubles)
-    /* st0 */ RC_INT | RC_INT_BSIDE | RC_ST0,
-    /* A4  */ RC_C67_A4,
-    /* A5  */ RC_C67_A5,
-    /* B4  */ RC_C67_B4,
-    /* B5  */ RC_C67_B5,
-    /* A6  */ RC_C67_A6,
-    /* A7  */ RC_C67_A7,
-    /* B6  */ RC_C67_B6,
-    /* B7  */ RC_C67_B7,
-    /* A8  */ RC_C67_A8,
-    /* A9  */ RC_C67_A9,
-    /* B8  */ RC_C67_B8,
-    /* B9  */ RC_C67_B9,
-    /* A10  */ RC_C67_A10,
-    /* A11  */ RC_C67_A11,
-    /* B10  */ RC_C67_B10,
-    /* B11  */ RC_C67_B11,
-    /* A12  */ RC_C67_A10,
-    /* A13  */ RC_C67_A11,
-    /* B12  */ RC_C67_B10,
-    /* B13  */ RC_C67_B11
-};
 /* return registers for function */
 #define REG_IRET TREG_C67_A4	/* single word int return register */
 #define REG_LRET TREG_C67_A5	/* second word return register (for long long) */
 #define REG_FRET TREG_C67_A4	/* float return register */
 #define ALWAYS_ASSERT(x) \
 do {\
    if (!(x))\
        error("internal compiler error file at %s:%d", __FILE__, __LINE__);\
 } while (0)
-// although tcc thinks it is passing parameters on the stack,
-// the C67 really passes up to the first 10 params in special
-// regs or regs pairs (for 64 bit params).  So keep track of
-// the stack offsets so we can translate to the appropriate
-// reg (pair)
-#define NoCallArgsPassedOnStack 10
-int NoOfCurFuncArgs;
-int TranslateStackToReg[NoCallArgsPassedOnStack];
-int ParamLocOnStack[NoCallArgsPassedOnStack];
-int TotalBytesPushedOnStack;
 /* defined if function parameters must be evaluated in reverse order */
 //#define INVERT_FUNC_PARAMS
 /* defined if structures are passed as pointers. Otherwise structures
 #define ELF_PAGE_SIZE  0x1000
 /******************************************************/
+#else /* ! TARGET_DEFS_ONLY */
+/******************************************************/
+#include "tcc.h"
+ST_DATA const int reg_classes[NB_REGS] = {
+    /* eax */ RC_INT | RC_FLOAT | RC_EAX,
+    // only allow even regs for floats (allow for doubles)
+    /* ecx */ RC_INT | RC_ECX,
+    /* edx */ RC_INT | RC_INT_BSIDE | RC_FLOAT | RC_EDX,
+    // only allow even regs for floats (allow for doubles)
+    /* st0 */ RC_INT | RC_INT_BSIDE | RC_ST0,
+    /* A4  */ RC_C67_A4,
+    /* A5  */ RC_C67_A5,
+    /* B4  */ RC_C67_B4,
+    /* B5  */ RC_C67_B5,
+    /* A6  */ RC_C67_A6,
+    /* A7  */ RC_C67_A7,
+    /* B6  */ RC_C67_B6,
+    /* B7  */ RC_C67_B7,
+    /* A8  */ RC_C67_A8,
+    /* A9  */ RC_C67_A9,
+    /* B8  */ RC_C67_B8,
+    /* B9  */ RC_C67_B9,
+    /* A10  */ RC_C67_A10,
+    /* A11  */ RC_C67_A11,
+    /* B10  */ RC_C67_B10,
+    /* B11  */ RC_C67_B11,
+    /* A12  */ RC_C67_A10,
+    /* A13  */ RC_C67_A11,
+    /* B12  */ RC_C67_B10,
+    /* B13  */ RC_C67_B11
+};
+// although tcc thinks it is passing parameters on the stack,
+// the C67 really passes up to the first 10 params in special
+// regs or regs pairs (for 64 bit params).  So keep track of
+// the stack offsets so we can translate to the appropriate
+// reg (pair)
+#define NoCallArgsPassedOnStack 10
+int NoOfCurFuncArgs;
+int TranslateStackToReg[NoCallArgsPassedOnStack];
+int ParamLocOnStack[NoCallArgsPassedOnStack];
+int TotalBytesPushedOnStack;
+/******************************************************/
 static unsigned long func_sub_sp_offset;
 static int func_ret_sub;
     vtop--;
 }
-/* end of X86 code generator */
+/* end of C67 code generator */
+/*************************************************************/
+#endif
 /*************************************************************/

i386-asm.c+11−9

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#include "tcc.h"
+// #define NB_ASM_REGS 8
 #define MAX_OPERANDS 3
+#define NB_SAVED_REGS 3
 #define TOK_ASM_first TOK_ASM_clc
 #define TOK_ASM_last TOK_ASM_emms
     op->type |= indir;
 }
-static void gen_expr32(ExprValue *pe)
+/* XXX: unify with C code output ? */
+ST_FUNC void gen_expr32(ExprValue *pe)
 {
     gen_addr32(pe->sym ? VT_SYM : 0, pe->sym, pe->v);
 }
     }
 }
-static void asm_opcode(TCCState *s1, int opcode)
+ST_FUNC void asm_opcode(TCCState *s1, int opcode)
 {
     const ASMInstr *pa;
     int i, modrm_index, reg, v, op1, is_short_jmp, seg_prefix;
 #endif
 }
-#define NB_SAVED_REGS 3
-#define NB_ASM_REGS 8
 /* return the constraint priority (we allocate first the lowest
    numbered constraints) */
 static inline int constraint_priority(const char *str)
 #define is_reg_allocated(reg) (regs_allocated[reg] & reg_mask)
-static void asm_compute_constraints(ASMOperand *operands,
+ST_FUNC void asm_compute_constraints(ASMOperand *operands,
                                     int nb_operands, int nb_outputs,
                                     const uint8_t *clobber_regs,
                                     int *pout_reg)
 #endif
 }
-static void subst_asm_operand(CString *add_str,
+ST_FUNC void subst_asm_operand(CString *add_str,
                               SValue *sv, int modifier)
 {
     int r, reg, size, val;
 }
 /* generate prolog and epilog code for asm statment */
-static void asm_gen_code(ASMOperand *operands, int nb_operands,
+ST_FUNC void asm_gen_code(ASMOperand *operands, int nb_operands,
                          int nb_outputs, int is_output,
                          uint8_t *clobber_regs,
                          int out_reg)
     }
 }
-static void asm_clobber(uint8_t *clobber_regs, const char *str)
+ST_FUNC void asm_clobber(uint8_t *clobber_regs, const char *str)
 {
     int reg;
     TokenSym *ts;

i386-gen.c+44−34

@@ -18,8 +18,11 @@ · 17 unmodified lines
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/	19	*/
20		20
		21	#ifdef TARGET_DEFS_ONLY
		22
21	/* number of available registers */	23	/* number of available registers */
22	#define NB_REGS 4	24	#define NB_REGS 4
		25	#define NB_ASM_REGS 8
23		26
24	/* a register can belong to several classes. The classes must be	27	/* a register can belong to several classes. The classes must be
25	sorted from more general to more precise (see gv2() code which does	28	sorted from more general to more precise (see gv2() code which does
@@ -42,13 +45,6 @@ enum { · 16 unmodified lines
42	TREG_ST0,	45	TREG_ST0,
43	};	46	};
44		47
45	const int reg_classes[NB_REGS] = {
46	/* eax */ RC_INT \| RC_EAX,
47	/* ecx */ RC_INT \| RC_ECX,
48	/* edx */ RC_INT \| RC_EDX,
49	/* st0 */ RC_FLOAT \| RC_ST0,
50	};
51
52	/* return registers for function */	48	/* return registers for function */
53	#define REG_IRET TREG_EAX /* single word int return register */	49	#define REG_IRET TREG_EAX /* single word int return register */
54	#define REG_LRET TREG_EDX /* second word return register (for long long) */	50	#define REG_LRET TREG_EDX /* second word return register (for long long) */
@@ -70,6 +66,9 @@ const int reg_classes[NB_REGS] = { · 15 unmodified lines
70	/* maximum alignment (for aligned attribute support) */	66	/* maximum alignment (for aligned attribute support) */
71	#define MAX_ALIGN 8	67	#define MAX_ALIGN 8
72		68
		69
		70	#define psym oad
		71
73	/******************************************************/	72	/******************************************************/
74	/* ELF defines */	73	/* ELF defines */
75		74
@@ -85,6 +84,16 @@ const int reg_classes[NB_REGS] = { · 9 unmodified lines
85	#define ELF_PAGE_SIZE 0x1000	84	#define ELF_PAGE_SIZE 0x1000
86		85
87	/******************************************************/	86	/******************************************************/
		87	#else /* ! TARGET_DEFS_ONLY */
		88	/******************************************************/
		89	#include "tcc.h"
		90
		91	ST_DATA const int reg_classes[NB_REGS] = {
		92	/* eax */ RC_INT \| RC_EAX,
		93	/* ecx */ RC_INT \| RC_ECX,
		94	/* edx */ RC_INT \| RC_EDX,
		95	/* st0 */ RC_FLOAT \| RC_ST0,
		96	};
88		97
89	static unsigned long func_sub_sp_offset;	98	static unsigned long func_sub_sp_offset;
90	static int func_ret_sub;	99	static int func_ret_sub;
@@ -93,7 +102,7 @@ static unsigned long func_bound_offset; · 2 unmodified lines
93	#endif	102	#endif
94		103
95	/* XXX: make it faster ? */	104	/* XXX: make it faster ? */
96	void g(int c)	105	ST_FUNC void g(int c)
97	{	106	{
98	int ind1;	107	int ind1;
99	ind1 = ind + 1;	108	ind1 = ind + 1;
@@ -103,7 +112,7 @@ void g(int c) · 3 unmodified lines
103	ind = ind1;	112	ind = ind1;
104	}	113	}
105		114
106	void o(unsigned int c)	115	ST_FUNC void o(unsigned int c)
107	{	116	{
108	while (c) {	117	while (c) {
109	g(c);	118	g(c);
@@ -111,13 +120,13 @@ void o(unsigned int c) · 1 unmodified line
111	}	120	}
112	}	121	}
113		122
114	void gen_le16(int v)	123	ST_FUNC void gen_le16(int v)
115	{	124	{
116	g(v);	125	g(v);
117	g(v >> 8);	126	g(v >> 8);
118	}	127	}
119		128
120	void gen_le32(int c)	129	ST_FUNC void gen_le32(int c)
121	{	130	{
122	g(c);	131	g(c);
123	g(c >> 8);	132	g(c >> 8);
@@ -126,7 +135,7 @@ void gen_le32(int c) · 2 unmodified lines
126	}	135	}
127		136
128	/* output a symbol and patch all calls to it */	137	/* output a symbol and patch all calls to it */
129	void gsym_addr(int t, int a)	138	ST_FUNC void gsym_addr(int t, int a)
130	{	139	{
131	int n, *ptr;	140	int n, *ptr;
132	while (t) {	141	while (t) {
@@ -137,7 +146,7 @@ void gsym_addr(int t, int a) · 4 unmodified lines
137	}	146	}
138	}	147	}
139		148
140	void gsym(int t)	149	ST_FUNC void gsym(int t)
141	{	150	{
142	gsym_addr(t, ind);	151	gsym_addr(t, ind);
143	}	152	}
@@ -147,7 +156,7 @@ void gsym(int t) · 3 unmodified lines
147	#define psym oad	156	#define psym oad
148		157
149	/* instruction + 4 bytes data. Return the address of the data */	158	/* instruction + 4 bytes data. Return the address of the data */
150	static int oad(int c, int s)	159	ST_FUNC int oad(int c, int s)
151	{	160	{
152	int ind1;	161	int ind1;
153		162
@@ -162,14 +171,14 @@ static int oad(int c, int s) · 8 unmodified lines
162	}	171	}
163		172
164	/* output constant with relocation if 'r & VT_SYM' is true */	173	/* output constant with relocation if 'r & VT_SYM' is true */
165	static void gen_addr32(int r, Sym *sym, int c)	174	ST_FUNC void gen_addr32(int r, Sym *sym, int c)
166	{	175	{
167	if (r & VT_SYM)	176	if (r & VT_SYM)
168	greloc(cur_text_section, sym, ind, R_386_32);	177	greloc(cur_text_section, sym, ind, R_386_32);
169	gen_le32(c);	178	gen_le32(c);
170	}	179	}
171		180
172	static void gen_addrpc32(int r, Sym *sym, int c)	181	ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
173	{	182	{
174	if (r & VT_SYM)	183	if (r & VT_SYM)
175	greloc(cur_text_section, sym, ind, R_386_PC32);	184	greloc(cur_text_section, sym, ind, R_386_PC32);
@@ -200,7 +209,7 @@ static void gen_modrm(int op_reg, int r, Sym *sym, int c) · 24 unmodified lines
200	}	209	}
201		210
202	/* load 'r' from value 'sv' */	211	/* load 'r' from value 'sv' */
203	void load(int r, SValue *sv)	212	ST_FUNC void load(int r, SValue *sv)
204	{	213	{
205	int v, t, ft, fc, fr;	214	int v, t, ft, fc, fr;
206	SValue v1;	215	SValue v1;
@@ -269,7 +278,7 @@ void load(int r, SValue *sv) · 62 unmodified lines
269	}	278	}
270		279
271	/* store register 'r' in lvalue 'v' */	280	/* store register 'r' in lvalue 'v' */
272	void store(int r, SValue *v)	281	ST_FUNC void store(int r, SValue *v)
273	{	282	{
274	int fr, bt, ft, fc;	283	int fr, bt, ft, fc;
275		284
@@ -349,7 +358,7 @@ static uint8_t fastcallw_regs[2] = { TREG_ECX, TREG_EDX }; · 73 unmodified lines
349	/* Generate function call. The function address is pushed first, then	358	/* Generate function call. The function address is pushed first, then
350	all the parameters in call order. This functions pops all the	359	all the parameters in call order. This functions pops all the
351	parameters and the function address. */	360	parameters and the function address. */
352	void gfunc_call(int nb_args)	361	ST_FUNC void gfunc_call(int nb_args)
353	{	362	{
354	int size, align, r, args_size, i, func_call;	363	int size, align, r, args_size, i, func_call;
355	Sym *func_sym;	364	Sym *func_sym;
@@ -442,7 +451,7 @@ void gfunc_call(int nb_args) · 86 unmodified lines
442	#endif	451	#endif
443		452
444	/* generate function prolog of type 't' */	453	/* generate function prolog of type 't' */
445	void gfunc_prolog(CType *func_type)	454	ST_FUNC void gfunc_prolog(CType *func_type)
446	{	455	{
447	int addr, align, size, func_call, fastcall_nb_regs;	456	int addr, align, size, func_call, fastcall_nb_regs;
448	int param_index, param_addr;	457	int param_index, param_addr;
@@ -524,7 +533,7 @@ void gfunc_prolog(CType *func_type) · 75 unmodified lines
524	}	533	}
525		534
526	/* generate function epilog */	535	/* generate function epilog */
527	void gfunc_epilog(void)	536	ST_FUNC void gfunc_epilog(void)
528	{	537	{
529	int v, saved_ind;	538	int v, saved_ind;
530		539
@@ -595,13 +604,13 @@ void gfunc_epilog(void) · 64 unmodified lines
595	}	604	}
596		605
597	/* generate a jump to a label */	606	/* generate a jump to a label */
598	int gjmp(int t)	607	ST_FUNC int gjmp(int t)
599	{	608	{
600	return psym(0xe9, t);	609	return psym(0xe9, t);
601	}	610	}
602		611
603	/* generate a jump to a fixed address */	612	/* generate a jump to a fixed address */
604	void gjmp_addr(int a)	613	ST_FUNC void gjmp_addr(int a)
605	{	614	{
606	int r;	615	int r;
607	r = a - ind - 2;	616	r = a - ind - 2;
@@ -614,7 +623,7 @@ void gjmp_addr(int a) · 6 unmodified lines
614	}	623	}
615		624
616	/* generate a test. set 'inv' to invert test. Stack entry is popped */	625	/* generate a test. set 'inv' to invert test. Stack entry is popped */
617	int gtst(int inv, int t)	626	ST_FUNC int gtst(int inv, int t)
618	{	627	{
619	int v, *p;	628	int v, *p;
620		629
@@ -659,7 +668,7 @@ int gtst(int inv, int t) · 38 unmodified lines
659	}	668	}
660		669
661	/* generate an integer binary operation */	670	/* generate an integer binary operation */
662	void gen_opi(int op)	671	ST_FUNC void gen_opi(int op)
663	{	672	{
664	int r, fr, opc, c;	673	int r, fr, opc, c;
665		674
@@ -793,7 +802,7 @@ void gen_opi(int op) · 127 unmodified lines
793	/* generate a floating point operation 'v = t1 op t2' instruction. The	802	/* generate a floating point operation 'v = t1 op t2' instruction. The
794	two operands are guaranted to have the same floating point type */	803	two operands are guaranted to have the same floating point type */
795	/* XXX: need to use ST1 too */	804	/* XXX: need to use ST1 too */
796	void gen_opf(int op)	805	ST_FUNC void gen_opf(int op)
797	{	806	{
798	int a, ft, fc, swapped, r;	807	int a, ft, fc, swapped, r;
799		808
@@ -905,7 +914,7 @@ void gen_opf(int op) · 105 unmodified lines
905		914
906	/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'	915	/* convert integers to fp 't' type. Must handle 'int', 'unsigned int'
907	and 'long long' cases. */	916	and 'long long' cases. */
908	void gen_cvt_itof(int t)	917	ST_FUNC void gen_cvt_itof(int t)
909	{	918	{
910	save_reg(TREG_ST0);	919	save_reg(TREG_ST0);
911	gv(RC_INT);	920	gv(RC_INT);
@@ -935,7 +944,7 @@ void gen_cvt_itof(int t) · 23 unmodified lines
935		944
936	/* convert fp to int 't' type */	945	/* convert fp to int 't' type */
937	/* XXX: handle long long case */	946	/* XXX: handle long long case */
938	void gen_cvt_ftoi(int t)	947	ST_FUNC void gen_cvt_ftoi(int t)
939	{	948	{
940	int r, r2, size;	949	int r, r2, size;
941	Sym *sym;	950	Sym *sym;
@@ -986,14 +995,14 @@ void gen_cvt_ftoi(int t) · 44 unmodified lines
986	}	995	}
987		996
988	/* convert from one floating point type to another */	997	/* convert from one floating point type to another */
989	void gen_cvt_ftof(int t)	998	ST_FUNC void gen_cvt_ftof(int t)
990	{	999	{
991	/* all we have to do on i386 is to put the float in a register */	1000	/* all we have to do on i386 is to put the float in a register */
992	gv(RC_FLOAT);	1001	gv(RC_FLOAT);
993	}	1002	}
994		1003
995	/* computed goto support */	1004	/* computed goto support */
996	void ggoto(void)	1005	ST_FUNC void ggoto(void)
997	{	1006	{
998	gcall_or_jmp(1);	1007	gcall_or_jmp(1);
999	vtop--;	1008	vtop--;
@@ -1003,7 +1012,7 @@ void ggoto(void) · 3 unmodified lines
1003	#ifdef CONFIG_TCC_BCHECK	1012	#ifdef CONFIG_TCC_BCHECK
1004		1013
1005	/* generate a bounded pointer addition */	1014	/* generate a bounded pointer addition */
1006	void gen_bounded_ptr_add(void)	1015	ST_FUNC void gen_bounded_ptr_add(void)
1007	{	1016	{
1008	Sym *sym;	1017	Sym *sym;
1009		1018
@@ -1026,7 +1035,7 @@ void gen_bounded_ptr_add(void) · 16 unmodified lines
1026		1035
1027	/* patch pointer addition in vtop so that pointer dereferencing is	1036	/* patch pointer addition in vtop so that pointer dereferencing is
1028	also tested */	1037	also tested */
1029	void gen_bounded_ptr_deref(void)	1038	ST_FUNC void gen_bounded_ptr_deref(void)
1030	{	1039	{
1031	int func;	1040	int func;
1032	int size, align;	1041	int size, align;
@@ -1068,4 +1077,5 @@ void gen_bounded_ptr_deref(void) · 35 unmodified lines
1068		1077
1069	/* end of X86 code generator */	1078	/* end of X86 code generator */
1070	/*************************************************************/	1079	/*************************************************************/
1071		1080	#endif
		1081	/*************************************************************/

libtcc.c+108−624

@@ -23,344 +23,70 @@ · 22 unmodified lines
23	/********************************************************/	23	/********************************************************/
24	/* global variables */	24	/* global variables */
25		25
26	/* display benchmark infos */
27	int total_lines;
28	int total_bytes;
29
30	/* parser */
31	static struct BufferedFile *file;
32	static int ch, tok;
33	static CValue tokc;
34	static CString tokcstr; /* current parsed string, if any */
35	/* additional informations about token */
36	static int tok_flags;
37	#define TOK_FLAG_BOL 0x0001 /* beginning of line before */
38	#define TOK_FLAG_BOF 0x0002 /* beginning of file before */
39	#define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
40	#define TOK_FLAG_EOF 0x0008 /* end of file */
41
42	static int macro_ptr, macro_ptr_allocated;
43	static int *unget_saved_macro_ptr;
44	static int unget_saved_buffer[TOK_MAX_SIZE + 1];
45	static int unget_buffer_enabled;
46	static int parse_flags;
47	#define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
48	#define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
49	#define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
50	token. line feed is also
51	returned at eof */
52	#define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
53	#define PARSE_FLAG_SPACES 0x0010 /* next() returns space tokens (for -E) */
54
55	static Section text_section, data_section, bss_section; / predefined sections */
56	static Section cur_text_section; / current section where function code is
57	generated */
58	#ifdef CONFIG_TCC_ASM
59	static Section last_text_section; / to handle .previous asm directive */
60	#endif
61
62	#ifdef CONFIG_TCC_BCHECK
63	/* bound check related sections */
64	static Section bounds_section; / contains global data bound description */
65	static Section lbounds_section; / contains local data bound description */
66	#endif
67
68	/* symbol sections */
69	static Section symtab_section, strtab_section;
70
71	/* debug sections */
72	static Section stab_section, stabstr_section;
73
74	/* loc : local variable index
75	ind : output code index
76	rsym: return symbol
77	anon_sym: anonymous symbol index
78	*/
79	static int rsym, anon_sym, ind, loc;
80	/* expression generation modifiers */
81	static int const_wanted; /* true if constant wanted */
82	static int nocode_wanted; /* true if no code generation wanted for an expression */
83	static int global_expr; /* true if compound literals must be allocated
84	globally (used during initializers parsing */
85	static CType func_vt; /* current function return type (used by return
86	instruction) */
87	static int func_vc;
88	static int last_line_num, last_ind, func_ind; /* debug last line number and pc */
89	static int tok_ident;
90	static TokenSym **table_ident;
91	static TokenSym *hash_ident[TOK_HASH_SIZE];
92	static char token_buf[STRING_MAX_SIZE + 1];
93	static char *funcname;
94	static Sym global_stack, local_stack;
95	static Sym *define_stack;
96	static Sym global_label_stack, local_label_stack;
97	/* symbol allocator */
98	#define SYM_POOL_NB (8192 / sizeof(Sym))
99	static Sym *sym_free_first;
100	static void **sym_pools;
101	static int nb_sym_pools;
102
103	static SValue vstack[VSTACK_SIZE], *vtop;
104	/* some predefined types */
105	static CType char_pointer_type, func_old_type, int_type;
106
107	/* use GNU C extensions */	26	/* use GNU C extensions */
108	static int gnu_ext = 1;	27	ST_DATA int gnu_ext = 1;
109		28
110	/* use Tiny C extensions */	29	/* use TinyCC extensions */
111	static int tcc_ext = 1;	30	ST_DATA int tcc_ext = 1;
112
113	/* max number of callers shown if error */
114	#ifdef CONFIG_TCC_BACKTRACE
115	int num_callers = 6;
116	void *rt_prog_main;
117	const char **rt_bound_error_msg;
118	#endif
119		31
120	/* XXX: get rid of this ASAP */	32	/* XXX: get rid of this ASAP */
121	static struct TCCState *tcc_state;	33	ST_DATA struct TCCState *tcc_state;
122
123	/********************************************************/
124	/* function prototypes */
125
126	/* tccpp.c */
127	static void next(void);
128	char get_tok_str(int v, CValue cv);
129
130	/* tccgen.c */
131	static void parse_expr_type(CType *type);
132	static void expr_type(CType *type);
133	static void unary_type(CType *type);
134	static void block(int bsym, int csym, int case_sym, int def_sym,
135	int case_reg, int is_expr);
136	static int expr_const(void);
137	static void expr_eq(void);
138	static void gexpr(void);
139	static void gen_inline_functions(void);
140	static void decl(int l);
141	static void decl_initializer(CType type, Section sec, unsigned long c,
142	int first, int size_only);
143	static void decl_initializer_alloc(CType type, AttributeDef ad, int r,
144	int has_init, int v, int scope);
145	int gv(int rc);
146	void gv2(int rc1, int rc2);
147	void move_reg(int r, int s);
148	void save_regs(int n);
149	void save_reg(int r);
150	void vpop(void);
151	void vswap(void);
152	void vdup(void);
153	int get_reg(int rc);
154	int get_reg_ex(int rc,int rc2);
155
156	void gen_op(int op);
157	void force_charshort_cast(int t);
158	static void gen_cast(CType *type);
159	void vstore(void);
160	static Sym *sym_find(int v);
161	static Sym sym_push(int v, CType type, int r, int c);
162
163	/* type handling */
164	static int type_size(CType type, int a);
165	static inline CType pointed_type(CType type);
166	static int pointed_size(CType *type);
167	static int lvalue_type(int t);
168	static int parse_btype(CType type, AttributeDef ad);
169	static void type_decl(CType type, AttributeDef ad, int *v, int td);
170	static int compare_types(CType type1, CType type2, int unqualified);
171	static int is_compatible_types(CType type1, CType type2);
172	static int is_compatible_parameter_types(CType type1, CType type2);
173
174	int ieee_finite(double d);
175	void vpushi(int v);
176	void vpushll(long long v);
177	void vrott(int n);
178	void vnrott(int n);
179	void lexpand_nr(void);
180	static void vpush_global_sym(CType *type, int v);
181	void vset(CType *type, int r, int v);
182	void type_to_str(char *buf, int buf_size,
183	CType type, const char varstr);
184	static Sym get_sym_ref(CType type, Section *sec,
185	unsigned long offset, unsigned long size);
186	static Sym external_global_sym(int v, CType type, int r);
187
188	/* section generation */
189	static void section_realloc(Section *sec, unsigned long new_size);
190	static void section_ptr_add(Section sec, unsigned long size);
191	static void put_extern_sym(Sym sym, Section section,
192	unsigned long value, unsigned long size);
193	static void greloc(Section s, Sym sym, unsigned long addr, int type);
194	static int put_elf_str(Section s, const char sym);
195	static int put_elf_sym(Section *s,
196	unsigned long value, unsigned long size,
197	int info, int other, int shndx, const char *name);
198	static int add_elf_sym(Section *s, uplong value, unsigned long size,
199	int info, int other, int sh_num, const char *name);
200	static void put_elf_reloc(Section symtab, Section s, unsigned long offset,
201	int type, int symbol);
202	static void put_stabs(const char *str, int type, int other, int desc,
203	unsigned long value);
204	static void put_stabs_r(const char *str, int type, int other, int desc,
205	unsigned long value, Section *sec, int sym_index);
206	static void put_stabn(int type, int other, int desc, int value);
207	static void put_stabd(int type, int other, int desc);
208	static int tcc_add_dll(TCCState s, const char filename, int flags);
209
210	#define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
211	#define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
212	#define AFF_PREPROCESS 0x0004 /* preprocess file */
213	static int tcc_add_file_internal(TCCState s, const char filename, int flags);
214
215	/* tcccoff.c */
216	int tcc_output_coff(TCCState s1, FILE f);
217
218	/* tccpe.c */
219	int pe_load_file(struct TCCState s1, const char filename, int fd);
220	int pe_output_file(struct TCCState s1, const char filename);
221	int pe_dllimport(int r, SValue sv, void (fn)(int r, SValue *sv));
222
223	/* tccasm.c */
224	#ifdef CONFIG_TCC_ASM
225	static void asm_expr(TCCState s1, ExprValue pe);
226	static int asm_int_expr(TCCState *s1);
227	static int find_constraint(ASMOperand *operands, int nb_operands,
228	const char name, const char *pp);
229		34
230	static int tcc_assemble(TCCState *s1, int do_preprocess);	35	#ifdef CONFIG_TCC_BACKTRACE
		36	ST_DATA int num_callers = 6;
		37	ST_DATA const char **rt_bound_error_msg;
		38	ST_DATA void *rt_prog_main;
231	#endif	39	#endif
232		40
233	static void asm_instr(void);
234	static void asm_global_instr(void);
235
236	/********************************************************/
237	/* libtcc.c */
238
239	static Sym *__sym_malloc(void);
240	static inline Sym *sym_malloc(void);
241	static inline void sym_free(Sym *sym);
242	Section new_section(TCCState s1, const char *name, int sh_type, int sh_flags);
243	static void free_section(Section *s);
244	static void section_realloc(Section *sec, unsigned long new_size);
245	static void section_ptr_add(Section sec, unsigned long size);
246	Section find_section(TCCState s1, const char *name);
247	static void put_extern_sym2(
248	Sym sym, Section section,
249	unsigned long value, unsigned long size, int can_add_underscore);
250	static void put_extern_sym(
251	Sym sym, Section section,
252	unsigned long value, unsigned long size);
253	static void greloc(Section s, Sym sym, unsigned long offset, int type);
254
255	static void strcat_vprintf(char buf, int buf_size, const char fmt, va_list ap);
256	static void strcat_printf(char buf, int buf_size, const char fmt, ...);
257
258	/* CString handling */
259	static void cstr_realloc(CString *cstr, int new_size);
260	static inline void cstr_ccat(CString *cstr, int ch);
261	static void cstr_cat(CString cstr, const char str);
262	static void cstr_wccat(CString *cstr, int ch);
263	static void cstr_new(CString *cstr);
264	static void cstr_free(CString *cstr);
265	#define cstr_reset(cstr) cstr_free(cstr)
266	static void add_char(CString *cstr, int c);
267
268	static Sym sym_push2(Sym *ps, int v, int t, long c);
269	static Sym sym_find2(Sym s, int v);
270	static inline Sym *struct_find(int v);
271	static inline Sym *sym_find(int v);
272	static Sym sym_push(int v, CType type, int r, int c);
273	static Sym *global_identifier_push(int v, int t, int c);
274	static void sym_pop(Sym *ptop, Sym b);
275
276	BufferedFile tcc_open(TCCState s1, const char *filename);
277	void tcc_close(BufferedFile *bf);
278	static int tcc_compile(TCCState *s1);
279
280	void expect(const char *msg);
281	void skip(int c);
282	static void test_lvalue(void);
283	void resolve_sym(TCCState s1, const char *sym);
284
285	static inline int isid(int c)
286	{
287	return (c >= 'a' && c <= 'z')
288	\|\| (c >= 'A' && c <= 'Z')
289	\|\| c == '_';
290	}
291
292	static inline int isnum(int c)
293	{
294	return c >= '0' && c <= '9';
295	}
296
297	static inline int isoct(int c)
298	{
299	return c >= '0' && c <= '7';
300	}
301
302	static inline int toup(int c)
303	{
304	if (c >= 'a' && c <= 'z')
305	return c - 'a' + 'A';
306	else
307	return c;
308	}
309
310	/********************************************************/	41	/********************************************************/
311		42
		43	#ifndef NOTALLINONE
		44	#include "tccpp.c"
		45	#include "tccgen.c"
		46	#include "tccelf.c"
		47	#include "tccrun.c"
312	#ifdef TCC_TARGET_I386	48	#ifdef TCC_TARGET_I386
313	#include "i386-gen.c"	49	#include "i386-gen.c"
314	#endif	50	#endif
315
316	#ifdef TCC_TARGET_ARM	51	#ifdef TCC_TARGET_ARM
317	#include "arm-gen.c"	52	#include "arm-gen.c"
318	#endif	53	#endif
319
320	#ifdef TCC_TARGET_C67	54	#ifdef TCC_TARGET_C67
321	#include "c67-gen.c"	55	#include "c67-gen.c"
322	#endif	56	#endif
323
324	#ifdef TCC_TARGET_X86_64	57	#ifdef TCC_TARGET_X86_64
325	#include "x86_64-gen.c"	58	#include "x86_64-gen.c"
326	#endif	59	#endif
327
328	#include "tccpp.c"
329	#include "tccgen.c"
330
331	#ifdef CONFIG_TCC_ASM	60	#ifdef CONFIG_TCC_ASM
332		61	#include "tccasm.c"
333	#if defined TCC_TARGET_I386 \|\| defined TCC_TARGET_X86_64	62	#if defined TCC_TARGET_I386 \|\| defined TCC_TARGET_X86_64
334	#include "i386-asm.c"	63	#include "i386-asm.c"
335	#endif	64	#endif
336
337	#include "tccasm.c"
338	#else
339	static void asm_instr(void)
340	{
341	error("inline asm() not supported");
342	}
343	static void asm_global_instr(void)
344	{
345	error("inline asm() not supported");
346	}
347	#endif	65	#endif
348
349	#include "tccelf.c"
350
351	#ifdef TCC_TARGET_COFF	66	#ifdef TCC_TARGET_COFF
352	#include "tcccoff.c"	67	#include "tcccoff.c"
353	#endif	68	#endif
354
355	#ifdef TCC_TARGET_PE	69	#ifdef TCC_TARGET_PE
356	#include "tccpe.c"	70	#include "tccpe.c"
357	#endif	71	#endif
		72	#endif /* ALL_IN_ONE */
358		73
359	#include "tccrun.c"	74	/********************************************************/
		75	#ifndef CONFIG_TCC_ASM
		76	ST_FUNC void asm_instr(void)
		77	{
		78	error("inline asm() not supported");
		79	}
		80	ST_FUNC void asm_global_instr(void)
		81	{
		82	error("inline asm() not supported");
		83	}
		84	#endif
360		85
361	/********************************************************/	86	/********************************************************/
		87
362	#ifdef _WIN32	88	#ifdef _WIN32
363	char normalize_slashes(char path)	89	static char normalize_slashes(char path)
364	{	90	{
365	char *p;	91	char *p;
366	for (p = path; *p; ++p)	92	for (p = path; *p; ++p)
@@ -369,10 +95,10 @@ char normalize_slashes(char path) · 2 unmodified lines
369	return path;	95	return path;
370	}	96	}
371		97
372	HMODULE tcc_module;	98	static HMODULE tcc_module;
373		99
374	/* on win32, we suppose the lib and includes are at the location of 'tcc.exe' */	100	/* on win32, we suppose the lib and includes are at the location of 'tcc.exe' */
375	void tcc_set_lib_path_w32(TCCState *s)	101	static void tcc_set_lib_path_w32(TCCState *s)
376	{	102	{
377	char path[1024], *p;	103	char path[1024], *p;
378	GetModuleFileNameA(tcc_module, path, sizeof path);	104	GetModuleFileNameA(tcc_module, path, sizeof path);
@@ -396,18 +122,8 @@ BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved) · 17 unmodified lines
396	#endif	122	#endif
397		123
398	/********************************************************/	124	/********************************************************/
399
400	/* we use our own 'finite' function to avoid potential problems with
401	non standard math libs */
402	/* XXX: endianness dependent */
403	int ieee_finite(double d)
404	{
405	int p = (int )&d;
406	return ((unsigned)((p[1] \| 0x800fffff) + 1)) >> 31;
407	}
408
409	/* copy a string and truncate it. */	125	/* copy a string and truncate it. */
410	char pstrcpy(char buf, int buf_size, const char *s)	126	PUB_FUNC char pstrcpy(char buf, int buf_size, const char *s)
411	{	127	{
412	char q, q_end;	128	char q, q_end;
413	int c;	129	int c;
@@ -427,7 +143,7 @@ char pstrcpy(char buf, int buf_size, const char *s) · 13 unmodified lines
427	}	143	}
428		144
429	/* strcat and truncate. */	145	/* strcat and truncate. */
430	char pstrcat(char buf, int buf_size, const char *s)	146	PUB_FUNC char pstrcat(char buf, int buf_size, const char *s)
431	{	147	{
432	int len;	148	int len;
433	len = strlen(buf);	149	len = strlen(buf);
@@ -437,7 +153,7 @@ char pstrcat(char buf, int buf_size, const char *s) · 3 unmodified lines
437	}	153	}
438		154
439	/* extract the basename of a file */	155	/* extract the basename of a file */
440	char tcc_basename(const char name)	156	PUB_FUNC char tcc_basename(const char name)
441	{	157	{
442	char *p = strchr(name, 0);	158	char *p = strchr(name, 0);
443	while (p > name && !IS_PATHSEP(p[-1]))	159	while (p > name && !IS_PATHSEP(p[-1]))
@@ -445,21 +161,27 @@ char tcc_basename(const char name) · 1 unmodified line
445	return p;	161	return p;
446	}	162	}
447		163
448	char tcc_fileextension (const char name)	164	PUB_FUNC char tcc_fileextension (const char name)
449	{	165	{
450	char *b = tcc_basename(name);	166	char *b = tcc_basename(name);
451	char *e = strrchr(b, '.');	167	char *e = strrchr(b, '.');
452	return e ? e : strchr(b, 0);	168	return e ? e : strchr(b, 0);
453	}	169	}
454		170
		171	/********************************************************/
455	/* memory management */	172	/* memory management */
		173
		174	#undef free
		175	#undef malloc
		176	#undef realloc
		177
456	#ifdef MEM_DEBUG	178	#ifdef MEM_DEBUG
457	int mem_cur_size;	179	int mem_cur_size;
458	int mem_max_size;	180	int mem_max_size;
459	unsigned malloc_usable_size(void*);	181	unsigned malloc_usable_size(void*);
460	#endif	182	#endif
461		183
462	void tcc_free(void *ptr)	184	PUB_FUNC void tcc_free(void *ptr)
463	{	185	{
464	#ifdef MEM_DEBUG	186	#ifdef MEM_DEBUG
465	mem_cur_size -= malloc_usable_size(ptr);	187	mem_cur_size -= malloc_usable_size(ptr);
@@ -467,7 +189,7 @@ void tcc_free(void *ptr) · 1 unmodified line
467	free(ptr);	189	free(ptr);
468	}	190	}
469		191
470	void *tcc_malloc(unsigned long size)	192	PUB_FUNC void *tcc_malloc(unsigned long size)
471	{	193	{
472	void *ptr;	194	void *ptr;
473	ptr = malloc(size);	195	ptr = malloc(size);
@@ -481,7 +203,7 @@ void *tcc_malloc(unsigned long size) · 7 unmodified lines
481	return ptr;	203	return ptr;
482	}	204	}
483		205
484	void *tcc_mallocz(unsigned long size)	206	PUB_FUNC void *tcc_mallocz(unsigned long size)
485	{	207	{
486	void *ptr;	208	void *ptr;
487	ptr = tcc_malloc(size);	209	ptr = tcc_malloc(size);
@@ -489,7 +211,7 @@ void *tcc_mallocz(unsigned long size) · 1 unmodified line
489	return ptr;	211	return ptr;
490	}	212	}
491		213
492	void tcc_realloc(void ptr, unsigned long size)	214	PUB_FUNC void tcc_realloc(void ptr, unsigned long size)
493	{	215	{
494	void *ptr1;	216	void *ptr1;
495	#ifdef MEM_DEBUG	217	#ifdef MEM_DEBUG
@@ -505,7 +227,7 @@ void tcc_realloc(void ptr, unsigned long size) · 9 unmodified lines
505	return ptr1;	227	return ptr1;
506	}	228	}
507		229
508	char tcc_strdup(const char str)	230	PUB_FUNC char tcc_strdup(const char str)
509	{	231	{
510	char *ptr;	232	char *ptr;
511	ptr = tcc_malloc(strlen(str) + 1);	233	ptr = tcc_malloc(strlen(str) + 1);
@@ -513,7 +235,7 @@ char tcc_strdup(const char str) · 1 unmodified line
513	return ptr;	235	return ptr;
514	}	236	}
515		237
516	void tcc_memstats(void)	238	PUB_FUNC void tcc_memstats(void)
517	{	239	{
518	#ifdef MEM_DEBUG	240	#ifdef MEM_DEBUG
519	printf("memory in use: %d\n", mem_cur_size);	241	printf("memory in use: %d\n", mem_cur_size);
@@ -524,7 +246,10 @@ void tcc_memstats(void) · 4 unmodified lines
524	#define malloc(s) use_tcc_malloc(s)	246	#define malloc(s) use_tcc_malloc(s)
525	#define realloc(p, s) use_tcc_realloc(p, s)	247	#define realloc(p, s) use_tcc_realloc(p, s)
526		248
527	void dynarray_add(void **ptab, int nb_ptr, void *data)	249	/********************************************************/
		250	/* dynarrays */
		251
		252	PUB_FUNC void dynarray_add(void **ptab, int nb_ptr, void *data)
528	{	253	{
529	int nb, nb_alloc;	254	int nb, nb_alloc;
530	void **pp;	255	void **pp;
@@ -546,7 +271,7 @@ void dynarray_add(void **ptab, int nb_ptr, void *data) · 15 unmodified lines
546	*nb_ptr = nb;	271	*nb_ptr = nb;
547	}	272	}
548		273
549	void dynarray_reset(void pp, int n)	274	PUB_FUNC void dynarray_reset(void pp, int n)
550	{	275	{
551	void **p;	276	void **p;
552	for (p = (void*)pp; n; ++p, --*n)	277	for (p = (void*)pp; n; ++p, --*n)
@@ -556,43 +281,18 @@ void dynarray_reset(void pp, int n) · 3 unmodified lines
556	(void*)pp = NULL;	281	(void*)pp = NULL;
557	}	282	}
558		283
559	/* symbol allocator */	284	/* we use our own 'finite' function to avoid potential problems with
560	static Sym *__sym_malloc(void)	285	non standard math libs */
561	{	286	/* XXX: endianness dependent */
562	Sym sym_pool, sym, *last_sym;	287	ST_FUNC int ieee_finite(double d)
563	int i;
564
565	sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym));
566	dynarray_add(&sym_pools, &nb_sym_pools, sym_pool);
567
568	last_sym = sym_free_first;
569	sym = sym_pool;
570	for(i = 0; i < SYM_POOL_NB; i++) {
571	sym->next = last_sym;
572	last_sym = sym;
573	sym++;
574	}
575	sym_free_first = last_sym;
576	return last_sym;
577	}
578
579	static inline Sym *sym_malloc(void)
580	{	288	{
581	Sym *sym;	289	int p = (int )&d;
582	sym = sym_free_first;	290	return ((unsigned)((p[1] \| 0x800fffff) + 1)) >> 31;
583	if (!sym)
584	sym = __sym_malloc();
585	sym_free_first = sym->next;
586	return sym;
587	}	291	}
588		292
589	static inline void sym_free(Sym *sym)	293	/********************************************************/
590	{
591	sym->next = sym_free_first;
592	sym_free_first = sym;
593	}
594		294
595	Section new_section(TCCState s1, const char *name, int sh_type, int sh_flags)	295	ST_FUNC Section new_section(TCCState s1, const char *name, int sh_type, int sh_flags)
596	{	296	{
597	Section *sec;	297	Section *sec;
598		298
@@ -633,7 +333,7 @@ static void free_section(Section *s) · 34 unmodified lines
633	}	333	}
634		334
635	/* realloc section and set its content to zero */	335	/* realloc section and set its content to zero */
636	static void section_realloc(Section *sec, unsigned long new_size)	336	ST_FUNC void section_realloc(Section *sec, unsigned long new_size)
637	{	337	{
638	unsigned long size;	338	unsigned long size;
639	unsigned char *data;	339	unsigned char *data;
@@ -653,7 +353,7 @@ static void section_realloc(Section *sec, unsigned long new_size) · 13 unmodified lines
653		353
654	/* reserve at least 'size' bytes in section 'sec' from	354	/* reserve at least 'size' bytes in section 'sec' from
655	sec->data_offset. */	355	sec->data_offset. */
656	static void section_ptr_add(Section sec, unsigned long size)	356	ST_FUNC void section_ptr_add(Section sec, unsigned long size)
657	{	357	{
658	unsigned long offset, offset1;	358	unsigned long offset, offset1;
659		359
@@ -667,7 +367,7 @@ static void section_ptr_add(Section sec, unsigned long size) · 7 unmodified lines
667		367
668	/* return a reference to a section, and create it if it does not	368	/* return a reference to a section, and create it if it does not
669	exists */	369	exists */
670	Section find_section(TCCState s1, const char *name)	370	ST_FUNC Section find_section(TCCState s1, const char *name)
671	{	371	{
672	Section *sec;	372	Section *sec;
673	int i;	373	int i;
@@ -682,7 +382,7 @@ Section find_section(TCCState s1, const char *name) · 8 unmodified lines
682		382
683	/* update sym->c so that it points to an external symbol in section	383	/* update sym->c so that it points to an external symbol in section
684	'section' with value 'value' */	384	'section' with value 'value' */
685	static void put_extern_sym2(Sym sym, Section section,	385	ST_FUNC void put_extern_sym2(Sym sym, Section section,
686	unsigned long value, unsigned long size,	386	unsigned long value, unsigned long size,
687	int can_add_underscore)	387	int can_add_underscore)
688	{	388	{
@@ -779,14 +479,14 @@ static void put_extern_sym2(Sym sym, Section section, · 90 unmodified lines
779	}	479	}
780	}	480	}
781		481
782	static void put_extern_sym(Sym sym, Section section,	482	ST_FUNC void put_extern_sym(Sym sym, Section section,
783	unsigned long value, unsigned long size)	483	unsigned long value, unsigned long size)
784	{	484	{
785	put_extern_sym2(sym, section, value, size, 1);	485	put_extern_sym2(sym, section, value, size, 1);
786	}	486	}
787		487
788	/* add a new relocation entry to symbol 'sym' in section 's' */	488	/* add a new relocation entry to symbol 'sym' in section 's' */
789	static void greloc(Section s, Sym sym, unsigned long offset, int type)	489	ST_FUNC void greloc(Section s, Sym sym, unsigned long offset, int type)
790	{	490	{
791	int c = 0;	491	int c = 0;
792	if (sym) {	492	if (sym) {
@@ -798,6 +498,8 @@ static void greloc(Section s, Sym sym, unsigned long offset, int type) · 5 unmodified lines
798	put_elf_reloc(symtab_section, s, offset, type, c);	498	put_elf_reloc(symtab_section, s, offset, type, c);
799	}	499	}
800		500
		501	/********************************************************/
		502
801	static void strcat_vprintf(char buf, int buf_size, const char fmt, va_list ap)	503	static void strcat_vprintf(char buf, int buf_size, const char fmt, va_list ap)
802	{	504	{
803	int len;	505	int len;
@@ -813,7 +515,7 @@ static void strcat_printf(char buf, int buf_size, const char fmt, ...) · 9 unmodified lines
813	va_end(ap);	515	va_end(ap);
814	}	516	}
815		517
816	void error1(TCCState s1, int is_warning, const char fmt, va_list ap)	518	static void error1(TCCState s1, int is_warning, const char fmt, va_list ap)
817	{	519	{
818	char buf[2048];	520	char buf[2048];
819	BufferedFile **f;	521	BufferedFile **f;
@@ -850,7 +552,7 @@ void error1(TCCState s1, int is_warning, const char fmt, va_list ap) · 30 unmodified lines
850	s1->nb_errors++;	552	s1->nb_errors++;
851	}	553	}
852		554
853	void tcc_set_error_func(TCCState s, void error_opaque,	555	LIBTCCAPI void tcc_set_error_func(TCCState s, void error_opaque,
854	void (error_func)(void opaque, const char *msg))	556	void (error_func)(void opaque, const char *msg))
855	{	557	{
856	s->error_opaque = error_opaque;	558	s->error_opaque = error_opaque;
@@ -858,7 +560,7 @@ void tcc_set_error_func(TCCState s, void error_opaque, · 1 unmodified line
858	}	560	}
859		561
860	/* error without aborting current compilation */	562	/* error without aborting current compilation */
861	void error_noabort(const char *fmt, ...)	563	PUB_FUNC void error_noabort(const char *fmt, ...)
862	{	564	{
863	TCCState *s1 = tcc_state;	565	TCCState *s1 = tcc_state;
864	va_list ap;	566	va_list ap;
@@ -868,7 +570,7 @@ void error_noabort(const char *fmt, ...) · 3 unmodified lines
868	va_end(ap);	570	va_end(ap);
869	}	571	}
870		572
871	void error(const char *fmt, ...)	573	PUB_FUNC void error(const char *fmt, ...)
872	{	574	{
873	TCCState *s1 = tcc_state;	575	TCCState *s1 = tcc_state;
874	va_list ap;	576	va_list ap;
@@ -885,12 +587,12 @@ void error(const char *fmt, ...) · 10 unmodified lines
885	}	587	}
886	}	588	}
887		589
888	void expect(const char *msg)	590	PUB_FUNC void expect(const char *msg)
889	{	591	{
890	error("%s expected", msg);	592	error("%s expected", msg);
891	}	593	}
892		594
893	void warning(const char *fmt, ...)	595	PUB_FUNC void warning(const char *fmt, ...)
894	{	596	{
895	TCCState *s1 = tcc_state;	597	TCCState *s1 = tcc_state;
896	va_list ap;	598	va_list ap;
@@ -903,233 +605,10 @@ void warning(const char *fmt, ...) · 6 unmodified lines
903	va_end(ap);	605	va_end(ap);
904	}	606	}
905		607
906	void skip(int c)	608	/********************************************************/
907	{
908	if (tok != c)
909	error("'%c' expected", c);
910	next();
911	}
912
913	static void test_lvalue(void)
914	{
915	if (!(vtop->r & VT_LVAL))
916	expect("lvalue");
917	}
918
919	/* CString handling */
920
921	static void cstr_realloc(CString *cstr, int new_size)
922	{
923	int size;
924	void *data;
925
926	size = cstr->size_allocated;
927	if (size == 0)
928	size = 8; /* no need to allocate a too small first string */
929	while (size < new_size)
930	size = size * 2;
931	data = tcc_realloc(cstr->data_allocated, size);
932	if (!data)
933	error("memory full");
934	cstr->data_allocated = data;
935	cstr->size_allocated = size;
936	cstr->data = data;
937	}
938
939	/* add a byte */
940	static inline void cstr_ccat(CString *cstr, int ch)
941	{
942	int size;
943	size = cstr->size + 1;
944	if (size > cstr->size_allocated)
945	cstr_realloc(cstr, size);
946	((unsigned char *)cstr->data)[size - 1] = ch;
947	cstr->size = size;
948	}
949
950	static void cstr_cat(CString cstr, const char str)
951	{
952	int c;
953	for(;;) {
954	c = *str;
955	if (c == '\0')
956	break;
957	cstr_ccat(cstr, c);
958	str++;
959	}
960	}
961
962	/* add a wide char */
963	static void cstr_wccat(CString *cstr, int ch)
964	{
965	int size;
966	size = cstr->size + sizeof(nwchar_t);
967	if (size > cstr->size_allocated)
968	cstr_realloc(cstr, size);
969	(nwchar_t )(((unsigned char *)cstr->data) + size - sizeof(nwchar_t)) = ch;
970	cstr->size = size;
971	}
972
973	static void cstr_new(CString *cstr)
974	{
975	memset(cstr, 0, sizeof(CString));
976	}
977
978	/* free string and reset it to NULL */
979	static void cstr_free(CString *cstr)
980	{
981	tcc_free(cstr->data_allocated);
982	cstr_new(cstr);
983	}
984
985	#define cstr_reset(cstr) cstr_free(cstr)
986
987	/* XXX: unicode ? */
988	static void add_char(CString *cstr, int c)
989	{
990	if (c == '\'' \|\| c == '\"' \|\| c == '\\') {
991	/* XXX: could be more precise if char or string */
992	cstr_ccat(cstr, '\\');
993	}
994	if (c >= 32 && c <= 126) {
995	cstr_ccat(cstr, c);
996	} else {
997	cstr_ccat(cstr, '\\');
998	if (c == '\n') {
999	cstr_ccat(cstr, 'n');
1000	} else {
1001	cstr_ccat(cstr, '0' + ((c >> 6) & 7));
1002	cstr_ccat(cstr, '0' + ((c >> 3) & 7));
1003	cstr_ccat(cstr, '0' + (c & 7));
1004	}
1005	}
1006	}
1007
1008	/* push, without hashing */
1009	static Sym sym_push2(Sym *ps, int v, int t, long c)
1010	{
1011	Sym *s;
1012	s = sym_malloc();
1013	s->v = v;
1014	s->type.t = t;
1015	s->type.ref = NULL;
1016	#ifdef _WIN64
1017	s->d = NULL;
1018	#endif
1019	s->c = c;
1020	s->next = NULL;
1021	/* add in stack */
1022	s->prev = *ps;
1023	*ps = s;
1024	return s;
1025	}
1026
1027	/* find a symbol and return its associated structure. 's' is the top
1028	of the symbol stack */
1029	static Sym sym_find2(Sym s, int v)
1030	{
1031	while (s) {
1032	if (s->v == v)
1033	return s;
1034	s = s->prev;
1035	}
1036	return NULL;
1037	}
1038
1039	/* structure lookup */
1040	static inline Sym *struct_find(int v)
1041	{
1042	v -= TOK_IDENT;
1043	if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1044	return NULL;
1045	return table_ident[v]->sym_struct;
1046	}
1047
1048	/* find an identifier */
1049	static inline Sym *sym_find(int v)
1050	{
1051	v -= TOK_IDENT;
1052	if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
1053	return NULL;
1054	return table_ident[v]->sym_identifier;
1055	}
1056
1057	/* push a given symbol on the symbol stack */
1058	static Sym sym_push(int v, CType type, int r, int c)
1059	{
1060	Sym s, *ps;
1061	TokenSym *ts;
1062
1063	if (local_stack)
1064	ps = &local_stack;
1065	else
1066	ps = &global_stack;
1067	s = sym_push2(ps, v, type->t, c);
1068	s->type.ref = type->ref;
1069	s->r = r;
1070	/* don't record fields or anonymous symbols */
1071	/* XXX: simplify */
1072	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1073	/* record symbol in token array */
1074	ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1075	if (v & SYM_STRUCT)
1076	ps = &ts->sym_struct;
1077	else
1078	ps = &ts->sym_identifier;
1079	s->prev_tok = *ps;
1080	*ps = s;
1081	}
1082	return s;
1083	}
1084
1085	/* push a global identifier */
1086	static Sym *global_identifier_push(int v, int t, int c)
1087	{
1088	Sym s, *ps;
1089	s = sym_push2(&global_stack, v, t, c);
1090	/* don't record anonymous symbol */
1091	if (v < SYM_FIRST_ANOM) {
1092	ps = &table_ident[v - TOK_IDENT]->sym_identifier;
1093	/* modify the top most local identifier, so that
1094	sym_identifier will point to 's' when popped */
1095	while (*ps != NULL)
1096	ps = &(*ps)->prev_tok;
1097	s->prev_tok = NULL;
1098	*ps = s;
1099	}
1100	return s;
1101	}
1102
1103	/* pop symbols until top reaches 'b' */
1104	static void sym_pop(Sym *ptop, Sym b)
1105	{
1106	Sym s, ss, **ps;
1107	TokenSym *ts;
1108	int v;
1109
1110	s = *ptop;
1111	while(s != b) {
1112	ss = s->prev;
1113	v = s->v;
1114	/* remove symbol in token array */
1115	/* XXX: simplify */
1116	if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
1117	ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
1118	if (v & SYM_STRUCT)
1119	ps = &ts->sym_struct;
1120	else
1121	ps = &ts->sym_identifier;
1122	*ps = s->prev_tok;
1123	}
1124	sym_free(s);
1125	s = ss;
1126	}
1127	*ptop = b;
1128	}
1129
1130	/* I/O layer */	609	/* I/O layer */
1131		610
1132	BufferedFile tcc_open(TCCState s1, const char *filename)	611	ST_FUNC BufferedFile tcc_open(TCCState s1, const char *filename)
1133	{	612	{
1134	int fd;	613	int fd;
1135	BufferedFile *bf;	614	BufferedFile *bf;
@@ -1159,7 +638,7 @@ BufferedFile tcc_open(TCCState s1, const char *filename) · 23 unmodified lines
1159	return bf;	638	return bf;
1160	}	639	}
1161		640
1162	void tcc_close(BufferedFile *bf)	641	ST_FUNC void tcc_close(BufferedFile *bf)
1163	{	642	{
1164	total_lines += bf->line_num;	643	total_lines += bf->line_num;
1165	close(bf->fd);	644	close(bf->fd);
@@ -1272,7 +751,7 @@ static int tcc_compile(TCCState *s1) · 106 unmodified lines
1272	return s1->nb_errors != 0 ? -1 : 0;	751	return s1->nb_errors != 0 ? -1 : 0;
1273	}	752	}
1274		753
1275	int tcc_compile_string(TCCState s, const char str)	754	LIBTCCAPI int tcc_compile_string(TCCState s, const char str)
1276	{	755	{
1277	BufferedFile bf1, *bf = &bf1;	756	BufferedFile bf1, *bf = &bf1;
1278	int ret, len;	757	int ret, len;
@@ -1301,7 +780,7 @@ int tcc_compile_string(TCCState s, const char str) · 22 unmodified lines
1301	}	780	}
1302		781
1303	/* define a preprocessor symbol. A value can also be provided with the '=' operator */	782	/* define a preprocessor symbol. A value can also be provided with the '=' operator */
1304	void tcc_define_symbol(TCCState s1, const char sym, const char *value)	783	LIBTCCAPI void tcc_define_symbol(TCCState s1, const char sym, const char *value)
1305	{	784	{
1306	BufferedFile bf1, *bf = &bf1;	785	BufferedFile bf1, *bf = &bf1;
1307		786
@@ -1331,7 +810,7 @@ void tcc_define_symbol(TCCState s1, const char sym, const char *value) · 23 unmodified lines
1331	}	810	}
1332		811
1333	/* undefine a preprocessor symbol */	812	/* undefine a preprocessor symbol */
1334	void tcc_undefine_symbol(TCCState s1, const char sym)	813	LIBTCCAPI void tcc_undefine_symbol(TCCState s1, const char sym)
1335	{	814	{
1336	TokenSym *ts;	815	TokenSym *ts;
1337	Sym *s;	816	Sym *s;
@@ -1369,7 +848,7 @@ static void tcc_cleanup(void) · 31 unmodified lines
1369	macro_ptr = NULL;	848	macro_ptr = NULL;
1370	}	849	}
1371		850
1372	TCCState *tcc_new(void)	851	LIBTCCAPI TCCState *tcc_new(void)
1373	{	852	{
1374	TCCState *s;	853	TCCState *s;
1375	char buffer[100];	854	char buffer[100];
@@ -1477,6 +956,7 @@ TCCState *tcc_new(void) · 101 unmodified lines
1477	".dynstrtab",	956	".dynstrtab",
1478	".dynhashtab", SHF_PRIVATE);	957	".dynhashtab", SHF_PRIVATE);
1479	s->alacarte_link = 1;	958	s->alacarte_link = 1;
		959	s->nocommon = 1;
1480		960
1481	#ifdef CHAR_IS_UNSIGNED	961	#ifdef CHAR_IS_UNSIGNED
1482	s->char_is_unsigned = 1;	962	s->char_is_unsigned = 1;
@@ -1485,17 +965,15 @@ TCCState *tcc_new(void) · 2 unmodified lines
1485	/* XXX: currently the PE linker is not ready to support that */	965	/* XXX: currently the PE linker is not ready to support that */
1486	s->leading_underscore = 1;	966	s->leading_underscore = 1;
1487	#endif	967	#endif
1488
1489	if (s->section_align == 0)	968	if (s->section_align == 0)
1490	s->section_align = ELF_PAGE_SIZE;	969	s->section_align = ELF_PAGE_SIZE;
1491
1492	#ifdef TCC_TARGET_I386	970	#ifdef TCC_TARGET_I386
1493	s->seg_size = 32;	971	s->seg_size = 32;
1494	#endif	972	#endif
1495	return s;	973	return s;
1496	}	974	}
1497		975
1498	void tcc_delete(TCCState *s1)	976	LIBTCCAPI void tcc_delete(TCCState *s1)
1499	{	977	{
1500	int i;	978	int i;
1501		979
@@ -1533,7 +1011,7 @@ void tcc_delete(TCCState *s1) · 31 unmodified lines
1533	tcc_free(s1);	1011	tcc_free(s1);
1534	}	1012	}
1535		1013
1536	int tcc_add_include_path(TCCState s1, const char pathname)	1014	LIBTCCAPI int tcc_add_include_path(TCCState s1, const char pathname)
1537	{	1015	{
1538	char *pathname1;	1016	char *pathname1;
1539		1017
@@ -1542,7 +1020,7 @@ int tcc_add_include_path(TCCState s1, const char pathname) · 2 unmodified lines
1542	return 0;	1020	return 0;
1543	}	1021	}
1544		1022
1545	int tcc_add_sysinclude_path(TCCState s1, const char pathname)	1023	LIBTCCAPI int tcc_add_sysinclude_path(TCCState s1, const char pathname)
1546	{	1024	{
1547	char *pathname1;	1025	char *pathname1;
1548		1026
@@ -1668,7 +1146,7 @@ the_end: · 119 unmodified lines
1668	return ret;	1146	return ret;
1669	}	1147	}
1670		1148
1671	int tcc_add_file(TCCState s, const char filename)	1149	LIBTCCAPI int tcc_add_file(TCCState s, const char filename)
1672	{	1150	{
1673	if (s->output_type == TCC_OUTPUT_PREPROCESS)	1151	if (s->output_type == TCC_OUTPUT_PREPROCESS)
1674	return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR \| AFF_PREPROCESS);	1152	return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR \| AFF_PREPROCESS);
@@ -1676,7 +1154,7 @@ int tcc_add_file(TCCState s, const char filename) · 1 unmodified line
1676	return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR);	1154	return tcc_add_file_internal(s, filename, AFF_PRINT_ERROR);
1677	}	1155	}
1678		1156
1679	int tcc_add_library_path(TCCState s, const char pathname)	1157	LIBTCCAPI int tcc_add_library_path(TCCState s, const char pathname)
1680	{	1158	{
1681	char *pathname1;	1159	char *pathname1;
1682		1160
@@ -1687,7 +1165,7 @@ int tcc_add_library_path(TCCState s, const char pathname) · 4 unmodified lines
1687		1165
1688	/* find and load a dll. Return non zero if not found */	1166	/* find and load a dll. Return non zero if not found */
1689	/* XXX: add '-rpath' option support ? */	1167	/* XXX: add '-rpath' option support ? */
1690	static int tcc_add_dll(TCCState s, const char filename, int flags)	1168	ST_FUNC int tcc_add_dll(TCCState s, const char filename, int flags)
1691	{	1169	{
1692	char buf[1024];	1170	char buf[1024];
1693	int i;	1171	int i;
@@ -1702,7 +1180,7 @@ static int tcc_add_dll(TCCState s, const char filename, int flags) · 8 unmodified lines
1702	}	1180	}
1703		1181
1704	/* the library name is the same as the argument of the '-l' option */	1182	/* the library name is the same as the argument of the '-l' option */
1705	int tcc_add_library(TCCState s, const char libraryname)	1183	LIBTCCAPI int tcc_add_library(TCCState s, const char libraryname)
1706	{	1184	{
1707	char buf[1024];	1185	char buf[1024];
1708	int i;	1186	int i;
@@ -1728,7 +1206,7 @@ int tcc_add_library(TCCState s, const char libraryname) · 19 unmodified lines
1728	return -1;	1206	return -1;
1729	}	1207	}
1730		1208
1731	int tcc_add_symbol(TCCState s, const char name, void *val)	1209	LIBTCCAPI int tcc_add_symbol(TCCState s, const char name, void *val)
1732	{	1210	{
1733	add_elf_sym(symtab_section, (uplong)val, 0,	1211	add_elf_sym(symtab_section, (uplong)val, 0,
1734	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,	1212	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
@@ -1736,7 +1214,7 @@ int tcc_add_symbol(TCCState s, const char name, void *val) · 1 unmodified line
1736	return 0;	1214	return 0;
1737	}	1215	}
1738		1216
1739	int tcc_set_output_type(TCCState *s, int output_type)	1217	LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type)
1740	{	1218	{
1741	char buf[1024];	1219	char buf[1024];
1742		1220
@@ -1825,7 +1303,7 @@ static const FlagDef warning_defs[] = { · 82 unmodified lines
1825	"implicit-function-declaration" },	1303	"implicit-function-declaration" },
1826	};	1304	};
1827		1305
1828	static int set_flag(TCCState s, const FlagDef flags, int nb_flags,	1306	ST_FUNC int set_flag(TCCState s, const FlagDef flags, int nb_flags,
1829	const char *name, int value)	1307	const char *name, int value)
1830	{	1308	{
1831	int i;	1309	int i;
@@ -1849,9 +1327,8 @@ static int set_flag(TCCState s, const FlagDef flags, int nb_flags, · 17 unmodified lines
1849	return 0;	1327	return 0;
1850	}	1328	}
1851		1329
1852
1853	/* set/reset a warning */	1330	/* set/reset a warning */
1854	int tcc_set_warning(TCCState s, const char warning_name, int value)	1331	LIBTCCAPI int tcc_set_warning(TCCState s, const char warning_name, int value)
1855	{	1332	{
1856	int i;	1333	int i;
1857	const FlagDef *p;	1334	const FlagDef *p;
@@ -1876,20 +1353,13 @@ static const FlagDef flag_defs[] = { · 18 unmodified lines
1876	};	1353	};
1877		1354
1878	/* set/reset a flag */	1355	/* set/reset a flag */
1879	int tcc_set_flag(TCCState s, const char flag_name, int value)	1356	PUB_FUNC int tcc_set_flag(TCCState s, const char flag_name, int value)
1880	{	1357	{
1881	return set_flag(s, flag_defs, countof(flag_defs),	1358	return set_flag(s, flag_defs, countof(flag_defs),
1882	flag_name, value);	1359	flag_name, value);
1883	}	1360	}
1884		1361
1885	/* set CONFIG_TCCDIR at runtime */	1362	PUB_FUNC void tcc_print_stats(TCCState *s, int64_t total_time)
1886	void tcc_set_lib_path(TCCState s, const char path)
1887	{
1888	tcc_free(s->tcc_lib_path);
1889	s->tcc_lib_path = tcc_strdup(path);
1890	}
1891
1892	void tcc_print_stats(TCCState *s, int64_t total_time)
1893	{	1363	{
1894	double tt;	1364	double tt;
1895	tt = (double)total_time / 1000000.0;	1365	tt = (double)total_time / 1000000.0;
@@ -1902,3 +1372,17 @@ void tcc_print_stats(TCCState *s, int64_t total_time) · 6 unmodified lines
1902	tt, (int)(total_lines / tt),	1372	tt, (int)(total_lines / tt),
1903	total_bytes / tt / 1000000.0);	1373	total_bytes / tt / 1000000.0);
1904	}	1374	}
		1375
		1376	/* set CONFIG_TCCDIR at runtime */
		1377	LIBTCCAPI void tcc_set_lib_path(TCCState s, const char path)
		1378	{
		1379	tcc_free(s->tcc_lib_path);
		1380	s->tcc_lib_path = tcc_strdup(path);
		1381	}
		1382
		1383	PUB_FUNC void set_num_callers(int n)
		1384	{
		1385	#ifdef CONFIG_TCC_BACKTRACE
		1386	num_callers = n;
		1387	#endif
		1388	}

tcc.c+16−16

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#ifdef TCC_USE_LIBTCC
+#if defined NOTALLINONE || defined TCC_USE_LIBTCC
 #include "tcc.h"
 #else
 #include "libtcc.c"
 #endif
-void help(void)
+static char **files;
+static int nb_files, nb_libraries;
+static int multiple_files;
+static int print_search_dirs;
+static int output_type;
+static int reloc_output;
+static const char *outfile;
+static int do_bench = 0;
+#define TCC_OPTION_HAS_ARG 0x0001
+#define TCC_OPTION_NOSEP   0x0002 /* cannot have space before option and arg */
+static void help(void)
 {
     printf("tcc version " TCC_VERSION " - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
            "usage: tcc [-v] [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n"
            );
 }
-static char **files;
-static int nb_files, nb_libraries;
-static int multiple_files;
-static int print_search_dirs;
-static int output_type;
-static int reloc_output;
-static const char *outfile;
-static int do_bench = 0;
-#define TCC_OPTION_HAS_ARG 0x0001
-#define TCC_OPTION_NOSEP   0x0002 /* cannot have space before option and arg */
 typedef struct TCCOption {
     const char *name;
     uint16_t index;
     return argc;
 }
-int parse_args(TCCState *s, int argc, char **argv)
+static int parse_args(TCCState *s, int argc, char **argv)
 {
     int optind;
     const TCCOption *popt;
                 break;
 #ifdef CONFIG_TCC_BACKTRACE
             case TCC_OPTION_bt:
-                num_callers = atoi(optarg);
+                set_num_callers(atoi(optarg));
                 break;
 #endif
 #ifdef CONFIG_TCC_BCHECK

tcc.h+406−28

@@ -18,6 +18,9 @@ · 17 unmodified lines
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/	19	*/
20		20
		21	#ifndef _TCC_H
		22	#define _TCC_H
		23
21	#define _GNU_SOURCE	24	#define _GNU_SOURCE
22	#include "config.h"	25	#include "config.h"
23		26
@@ -46,6 +49,7 @@ · 22 unmodified lines
46	#include <direct.h> /* getcwd */	49	#include <direct.h> /* getcwd */
47	#define inline __inline	50	#define inline __inline
48	#define inp next_inp	51	#define inp next_inp
		52	#define dlclose FreeLibrary
49	#ifdef _WIN64	53	#ifdef _WIN64
50	#define uplong unsigned long long	54	#define uplong unsigned long long
51	#endif	55	#endif
@@ -56,6 +60,7 @@ · 4 unmodified lines
56	#include <sys/time.h>	60	#include <sys/time.h>
57	#include <sys/ucontext.h>	61	#include <sys/ucontext.h>
58	#include <sys/mman.h>	62	#include <sys/mman.h>
		63	#include <dlfcn.h>
59	#endif	64	#endif
60		65
61	#endif /* !CONFIG_TCCBOOT */	66	#endif /* !CONFIG_TCCBOOT */
@@ -766,11 +771,11 @@ enum tcc_token { · 704 unmodified lines
766	#elif defined(TCC_UCLIBC) \|\| defined(__FreeBSD__) \|\| defined(__DragonFly__) \	771	#elif defined(TCC_UCLIBC) \|\| defined(__FreeBSD__) \|\| defined(__DragonFly__) \
767	\|\| defined(__OpenBSD__)	772	\|\| defined(__OpenBSD__)
768	/* currently incorrect */	773	/* currently incorrect */
769	long double strtold(const char nptr, char *endptr)	774	static inline long double strtold(const char nptr, char *endptr)
770	{	775	{
771	return (long double)strtod(nptr, endptr);	776	return (long double)strtod(nptr, endptr);
772	}	777	}
773	float strtof(const char nptr, char *endptr)	778	static inline float strtof(const char nptr, char *endptr)
774	{	779	{
775	return (float)strtod(nptr, endptr);	780	return (float)strtod(nptr, endptr);
776	}	781	}
@@ -790,38 +795,411 @@ extern long double strtold (const char __nptr, char *__endptr); · 13 unmodified lines
790	#define PATHCMP strcmp	795	#define PATHCMP strcmp
791	#endif	796	#endif
792		797
793	void error(const char *fmt, ...);	798	/* space exlcuding newline */
794	void error_noabort(const char *fmt, ...);	799	static inline int is_space(int ch)
795	void warning(const char *fmt, ...);	800	{
796		801	return ch == ' ' \|\| ch == '\t' \|\| ch == '\v' \|\| ch == '\f' \|\| ch == '\r';
797	void tcc_set_lib_path_w32(TCCState *s);	802	}
798	int tcc_set_flag(TCCState s, const char flag_name, int value);
799	void tcc_print_stats(TCCState *s, int64_t total_time);
800		803
801	void tcc_free(void *ptr);	804	static inline int isid(int c)
802	void *tcc_malloc(unsigned long size);	805	{
803	void *tcc_mallocz(unsigned long size);	806	return (c >= 'a' && c <= 'z') \|\| (c >= 'A' && c <= 'Z') \|\| c == '_';
804	void tcc_realloc(void ptr, unsigned long size);	807	}
805	char tcc_strdup(const char str);
806		808
807	char tcc_basename(const char name);	809	static inline int isnum(int c)
808	char tcc_fileextension (const char name);	810	{
809	char pstrcpy(char buf, int buf_size, const char *s);	811	return c >= '0' && c <= '9';
810	char pstrcat(char buf, int buf_size, const char *s);	812	}
811	void dynarray_add(void **ptab, int nb_ptr, void *data);
812	void dynarray_reset(void pp, int n);
813		813
814	/* true if float/double/long double type */	814	static inline int isoct(int c)
815	static inline int is_float(int t)
816	{	815	{
817	int bt;	816	return c >= '0' && c <= '7';
818	bt = t & VT_BTYPE;
819	return bt == VT_LDOUBLE \|\| bt == VT_DOUBLE \|\| bt == VT_FLOAT;
820	}	817	}
821		818
822	/* space exlcuding newline */	819	static inline int toup(int c)
823	static inline int is_space(int ch)
824	{	820	{
825	return ch == ' ' \|\| ch == '\t' \|\| ch == '\v' \|\| ch == '\f' \|\| ch == '\r';	821	return (c >= 'a' && c <= 'z') ? c - 'a' + 'A' : c;
826	}	822	}
827		823
		824	#define PUB_FUNC
		825
		826	#ifndef NOTALLINONE
		827	#define ST_INLN static inline
		828	#define ST_FUNC static
		829	#define ST_DATA static
		830	#else
		831	#define ST_INLN
		832	#define ST_FUNC
		833	#define ST_DATA extern
		834	#endif
		835
		836	/* ------------ libtcc.c ------------ */
		837
		838	/* use GNU C extensions */
		839	ST_DATA int gnu_ext;
		840	/* use Tiny C extensions */
		841	ST_DATA int tcc_ext;
		842	/* XXX: get rid of this ASAP */
		843	ST_DATA struct TCCState *tcc_state;
		844
		845	#ifdef CONFIG_TCC_BACKTRACE
		846	ST_DATA int num_callers;
		847	ST_DATA const char **rt_bound_error_msg;
		848	ST_DATA void *rt_prog_main;
		849	#endif
		850
		851	#define AFF_PRINT_ERROR 0x0001 /* print error if file not found */
		852	#define AFF_REFERENCED_DLL 0x0002 /* load a referenced dll from another dll */
		853	#define AFF_PREPROCESS 0x0004 /* preprocess file */
		854
		855	/* public functions currently used by the tcc main function */
		856	PUB_FUNC char pstrcpy(char buf, int buf_size, const char *s);
		857	PUB_FUNC char pstrcat(char buf, int buf_size, const char *s);
		858	PUB_FUNC char tcc_basename(const char name);
		859	PUB_FUNC char tcc_fileextension (const char name);
		860	PUB_FUNC void tcc_free(void *ptr);
		861	PUB_FUNC void *tcc_malloc(unsigned long size);
		862	PUB_FUNC void *tcc_mallocz(unsigned long size);
		863	PUB_FUNC void tcc_realloc(void ptr, unsigned long size);
		864	PUB_FUNC char tcc_strdup(const char str);
		865	#define free(p) use_tcc_free(p)
		866	#define malloc(s) use_tcc_malloc(s)
		867	#define realloc(p, s) use_tcc_realloc(p, s)
		868	#undef strdup
		869	#define strdup(s) use_tcc_strdup(s)
		870	PUB_FUNC void tcc_memstats(void);
		871	PUB_FUNC void dynarray_add(void **ptab, int nb_ptr, void *data);
		872	PUB_FUNC void dynarray_reset(void pp, int n);
		873	PUB_FUNC void error_noabort(const char *fmt, ...);
		874	PUB_FUNC void error(const char *fmt, ...);
		875	PUB_FUNC void expect(const char *msg);
		876	PUB_FUNC void warning(const char *fmt, ...);
		877
		878	/* other utilities */
		879	ST_INLN void cstr_ccat(CString *cstr, int ch);
		880	ST_FUNC void cstr_cat(CString cstr, const char str);
		881	ST_FUNC void cstr_wccat(CString *cstr, int ch);
		882	ST_FUNC void cstr_new(CString *cstr);
		883	ST_FUNC void cstr_free(CString *cstr);
		884	ST_FUNC void add_char(CString *cstr, int c);
		885	#define cstr_reset(cstr) cstr_free(cstr)
		886
		887	ST_FUNC Section new_section(TCCState s1, const char *name, int sh_type, int sh_flags);
		888	ST_FUNC void section_realloc(Section *sec, unsigned long new_size);
		889	ST_FUNC void section_ptr_add(Section sec, unsigned long size);
		890	ST_FUNC Section find_section(TCCState s1, const char *name);
		891
		892	ST_FUNC void put_extern_sym2(Sym sym, Section section, unsigned long value, unsigned long size, int can_add_underscore);
		893	ST_FUNC void put_extern_sym(Sym sym, Section section, unsigned long value, unsigned long size);
		894	ST_FUNC void greloc(Section s, Sym sym, unsigned long offset, int type);
		895
		896	ST_INLN void sym_free(Sym *sym);
		897	ST_FUNC Sym sym_push2(Sym *ps, int v, int t, long c);
		898	ST_FUNC Sym sym_find2(Sym s, int v);
		899	ST_FUNC Sym sym_push(int v, CType type, int r, int c);
		900	ST_FUNC void sym_pop(Sym *ptop, Sym b);
		901	ST_INLN Sym *struct_find(int v);
		902	ST_INLN Sym *sym_find(int v);
		903	ST_FUNC Sym *global_identifier_push(int v, int t, int c);
		904
		905	ST_FUNC BufferedFile tcc_open(TCCState s1, const char *filename);
		906	ST_FUNC void tcc_close(BufferedFile *bf);
		907	ST_FUNC int tcc_add_dll(TCCState s, const char filename, int flags);
		908	PUB_FUNC int tcc_set_flag(TCCState s, const char flag_name, int value);
		909	PUB_FUNC void tcc_print_stats(TCCState *s, int64_t total_time);
		910	PUB_FUNC void set_num_callers(int n);
		911
		912	ST_FUNC int ieee_finite(double d);
		913
		914	/* ------------ tccpp.c ------------ */
		915
		916	ST_DATA struct BufferedFile *file;
		917	ST_DATA int ch, tok;
		918	ST_DATA CValue tokc;
		919	ST_DATA int *macro_ptr;
		920	ST_DATA int parse_flags;
		921	ST_DATA int tok_flags;
		922	ST_DATA CString tokcstr; /* current parsed string, if any */
		923
		924	/* display benchmark infos */
		925	ST_DATA int total_lines;
		926	ST_DATA int total_bytes;
		927	ST_DATA int tok_ident;
		928	ST_DATA TokenSym **table_ident;
		929
		930	#define TOK_FLAG_BOL 0x0001 /* beginning of line before */
		931	#define TOK_FLAG_BOF 0x0002 /* beginning of file before */
		932	#define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
		933	#define TOK_FLAG_EOF 0x0008 /* end of file */
		934
		935	#define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
		936	#define PARSE_FLAG_TOK_NUM 0x0002 /* return numbers instead of TOK_PPNUM */
		937	#define PARSE_FLAG_LINEFEED 0x0004 /* line feed is returned as a
		938	token. line feed is also
		939	returned at eof */
		940	#define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
		941	#define PARSE_FLAG_SPACES 0x0010 /* next() returns space tokens (for -E) */
		942
		943	ST_FUNC TokenSym tok_alloc(const char str, int len);
		944	ST_FUNC char get_tok_str(int v, CValue cv);
		945	ST_FUNC void save_parse_state(ParseState *s);
		946	ST_FUNC void restore_parse_state(ParseState *s);
		947	ST_INLN void tok_str_new(TokenString *s);
		948	ST_FUNC void tok_str_free(int *str);
		949	ST_FUNC void tok_str_add(TokenString *s, int t);
		950	ST_FUNC void tok_str_add_tok(TokenString *s);
		951	ST_INLN void define_push(int v, int macro_type, int str, Sym first_arg);
		952	ST_FUNC void define_undef(Sym *s);
		953	ST_INLN Sym *define_find(int v);
		954	ST_FUNC void free_defines(Sym *b);
		955	ST_FUNC Sym *label_find(int v);
		956	ST_FUNC Sym label_push(Sym *ptop, int v, int flags);
		957	ST_FUNC void label_pop(Sym *ptop, Sym slast);
		958	ST_FUNC void parse_define(void);
		959	ST_FUNC void preprocess(int is_bof);
		960	ST_FUNC void next_nomacro(void);
		961	ST_FUNC void next(void);
		962	ST_INLN void unget_tok(int last_tok);
		963	ST_FUNC void preprocess_init(TCCState *s1);
		964	ST_FUNC void preprocess_new();
		965	ST_FUNC int tcc_preprocess(TCCState *s1);
		966	ST_FUNC void skip(int c);
		967
		968	/* ------------ tccgen.c ------------ */
		969
		970	ST_DATA Section text_section, data_section, bss_section; / predefined sections */
		971	ST_DATA Section cur_text_section; / current section where function code is generated */
		972	#ifdef CONFIG_TCC_ASM
		973	ST_DATA Section last_text_section; / to handle .previous asm directive */
		974	#endif
		975	#ifdef CONFIG_TCC_BCHECK
		976	/* bound check related sections */
		977	ST_DATA Section bounds_section; / contains global data bound description */
		978	ST_DATA Section lbounds_section; / contains local data bound description */
		979	#endif
		980	/* symbol sections */
		981	ST_DATA Section symtab_section, strtab_section;
		982	/* debug sections */
		983	ST_DATA Section stab_section, stabstr_section;
		984
		985	#define SYM_POOL_NB (8192 / sizeof(Sym))
		986	ST_DATA Sym *sym_free_first;
		987	ST_DATA void **sym_pools;
		988	ST_DATA int nb_sym_pools;
		989
		990	ST_DATA Sym *global_stack;
		991	ST_DATA Sym *local_stack;
		992	ST_DATA Sym *local_label_stack;
		993	ST_DATA Sym *global_label_stack;
		994	ST_DATA Sym *define_stack;
		995	ST_DATA CType char_pointer_type, func_old_type, int_type;
		996	ST_DATA SValue vstack[VSTACK_SIZE], *vtop;
		997	ST_DATA int rsym, anon_sym, ind, loc;
		998
		999	ST_DATA int const_wanted; /* true if constant wanted */
		1000	ST_DATA int nocode_wanted; /* true if no code generation wanted for an expression */
		1001	ST_DATA int global_expr; /* true if compound literals must be allocated globally (used during initializers parsing */
		1002	ST_DATA CType func_vt; /* current function return type (used by return instruction) */
		1003	ST_DATA int func_vc;
		1004	ST_DATA int last_line_num, last_ind, func_ind; /* debug last line number and pc */
		1005	ST_DATA char *funcname;
		1006
		1007	ST_INLN int is_float(int t);
		1008	ST_FUNC void test_lvalue(void);
		1009	ST_FUNC void swap(int p, int q);
		1010	ST_FUNC void vpushi(int v);
		1011	ST_FUNC Sym external_global_sym(int v, CType type, int r);
		1012	ST_FUNC void vset(CType *type, int r, int v);
		1013	ST_FUNC void vswap(void);
		1014	ST_FUNC void save_reg(int r);
		1015	ST_FUNC int get_reg(int rc);
		1016	ST_FUNC void save_regs(int n);
		1017	ST_FUNC int gv(int rc);
		1018	ST_FUNC void gv2(int rc1, int rc2);
		1019	ST_FUNC void vpop(void);
		1020	ST_FUNC void gen_op(int op);
		1021	ST_FUNC int type_size(CType type, int a);
		1022	ST_FUNC void mk_pointer(CType *type);
		1023	ST_FUNC void vstore(void);
		1024	ST_FUNC void inc(int post, int c);
		1025	ST_FUNC int lvalue_type(int t);
		1026	ST_FUNC void indir(void);
		1027	ST_FUNC void unary(void);
		1028	ST_FUNC void expr_prod(void);
		1029	ST_FUNC void expr_sum(void);
		1030	ST_FUNC void gexpr(void);
		1031	ST_FUNC int expr_const(void);
		1032	ST_FUNC void gen_inline_functions(void);
		1033	ST_FUNC void decl(int l);
		1034	#ifdef CONFIG_TCC_BCHECK
		1035	ST_FUNC Sym get_sym_ref(CType type, Section *sec, unsigned long offset, unsigned long size);
		1036	#endif
		1037
		1038	/* ------------ tccelf.c ------------ */
		1039
		1040	#define ARMAG "!<arch>\012" /* For COFF and a.out archives */
		1041
		1042	typedef struct {
		1043	unsigned int n_strx; /* index into string table of name */
		1044	unsigned char n_type; /* type of symbol */
		1045	unsigned char n_other; /* misc info (usually empty) */
		1046	unsigned short n_desc; /* description field */
		1047	unsigned int n_value; /* value of symbol */
		1048	} Stab_Sym;
		1049
		1050	ST_FUNC Section new_symtab(TCCState s1, const char symtab_name, int sh_type, int sh_flags, const char strtab_name, const char *hash_name, int hash_sh_flags);
		1051
		1052	ST_FUNC int put_elf_str(Section s, const char sym);
		1053	ST_FUNC int put_elf_sym(Section s, unsigned long value, unsigned long size, int info, int other, int shndx, const char name);
		1054	ST_FUNC int add_elf_sym(Section s, uplong value, unsigned long size, int info, int other, int sh_num, const char name);
		1055	ST_FUNC int find_elf_sym(Section s, const char name);
		1056	ST_FUNC void put_elf_reloc(Section symtab, Section s, unsigned long offset, int type, int symbol);
		1057
		1058	ST_FUNC void put_stabs(const char *str, int type, int other, int desc, unsigned long value);
		1059	ST_FUNC void put_stabs_r(const char str, int type, int other, int desc, unsigned long value, Section sec, int sym_index);
		1060	ST_FUNC void put_stabn(int type, int other, int desc, int value);
		1061	ST_FUNC void put_stabd(int type, int other, int desc);
		1062
		1063	ST_FUNC void relocate_common_syms(void);
		1064	ST_FUNC void relocate_syms(TCCState *s1, int do_resolve);
		1065	ST_FUNC void relocate_section(TCCState s1, Section s);
		1066
		1067	ST_FUNC void tcc_add_linker_symbols(TCCState *s1);
		1068	ST_FUNC int tcc_load_object_file(TCCState *s1, int fd, unsigned long file_offset);
		1069	ST_FUNC int tcc_load_archive(TCCState *s1, int fd);
		1070	ST_FUNC void tcc_get_symbol_err(TCCState s, const char *name);
		1071	ST_FUNC void tcc_add_bcheck(TCCState *s1);
		1072
		1073	ST_FUNC void build_got_entries(TCCState *s1);
		1074	ST_FUNC void tcc_add_runtime(TCCState *s1);
		1075
		1076	#ifndef TCC_TARGET_PE
		1077	ST_FUNC int tcc_load_dll(TCCState s1, int fd, const char filename, int level);
		1078	ST_FUNC int tcc_load_ldscript(TCCState *s1);
		1079	ST_FUNC uint8_t parse_comment(uint8_t p);
		1080	ST_FUNC void minp(void);
		1081	ST_INLN void inp(void);
		1082	ST_FUNC int handle_eob(void);
		1083	#endif
		1084
		1085	/* ------------ xxx-gen.c ------------ */
		1086
		1087	ST_FUNC void gsym_addr(int t, int a);
		1088	ST_FUNC void gsym(int t);
		1089	ST_FUNC void load(int r, SValue *sv);
		1090	ST_FUNC void store(int r, SValue *v);
		1091	ST_FUNC void gfunc_call(int nb_args);
		1092	ST_FUNC void gfunc_prolog(CType *func_type);
		1093	ST_FUNC void gfunc_epilog(void);
		1094	ST_FUNC int gjmp(int t);
		1095	ST_FUNC void gjmp_addr(int a);
		1096	ST_FUNC int gtst(int inv, int t);
		1097	ST_FUNC void gen_opi(int op);
		1098	ST_FUNC void gen_opf(int op);
		1099	ST_FUNC void gen_cvt_ftoi(int t);
		1100	ST_FUNC void gen_cvt_ftof(int t);
		1101	ST_FUNC void ggoto(void);
		1102	#ifndef TCC_TARGET_C67
		1103	ST_FUNC void o(unsigned int c);
		1104	#endif
		1105	#ifndef TCC_TARGET_ARM
		1106	ST_FUNC void gen_cvt_itof(int t);
		1107	#endif
		1108
		1109	/* ------------ i386-gen.c ------------ */
		1110	#if defined TCC_TARGET_I386 \|\| defined TCC_TARGET_X86_64
		1111	ST_FUNC void g(int c);
		1112	ST_FUNC int oad(int c, int s);
		1113	ST_FUNC void gen_le16(int c);
		1114	ST_FUNC void gen_le32(int c);
		1115	ST_FUNC void gen_addr32(int r, Sym *sym, int c);
		1116	ST_FUNC void gen_addrpc32(int r, Sym *sym, int c);
		1117	#endif
		1118
		1119	#ifdef CONFIG_TCC_BCHECK
		1120	ST_FUNC void gen_bounded_ptr_add(void);
		1121	ST_FUNC void gen_bounded_ptr_deref(void);
		1122	#endif
		1123
		1124	/* ------------ x86_64-gen.c ------------ */
		1125	#ifdef TCC_TARGET_X86_64
		1126	ST_FUNC void gen_addr64(int r, Sym *sym, int64_t c);
		1127	#endif
		1128
		1129	/* ------------ arm-gen.c ------------ */
		1130	#ifdef TCC_TARGET_ARM
		1131	ST_FUNC unsigned long encbranch(int pos,int addr,int fail);
		1132	ST_FUNC void gen_cvt_itof1(int t);
		1133	#endif
		1134
		1135	/* ------------ c67-gen.c ------------ */
		1136	#ifdef TCC_TARGET_C67
		1137	#endif
		1138
		1139	/* ------------ tcccoff.c ------------ */
		1140
		1141	#ifdef TCC_TARGET_COFF
		1142	ST_FUNC int tcc_output_coff(TCCState s1, FILE f);
		1143	#endif
		1144
		1145	/* ------------ tccasm.c ------------ */
		1146	ST_FUNC void asm_instr(void);
		1147	ST_FUNC void asm_global_instr(void);
		1148
		1149	#ifdef CONFIG_TCC_ASM
		1150	ST_FUNC int find_constraint(ASMOperand operands, int nb_operands, const char name, const char **pp);
		1151	ST_FUNC void asm_expr(TCCState s1, ExprValue pe);
		1152	ST_FUNC int asm_int_expr(TCCState *s1);
		1153	ST_FUNC int tcc_assemble(TCCState *s1, int do_preprocess);
		1154	/* ------------ i386-asm.c ------------ */
		1155	ST_FUNC void gen_expr32(ExprValue *pe);
		1156	ST_FUNC void asm_opcode(TCCState *s1, int opcode);
		1157	ST_FUNC void asm_compute_constraints(ASMOperand operands, int nb_operands, int nb_outputs, const uint8_t clobber_regs, int *pout_reg);
		1158	ST_FUNC void subst_asm_operand(CString add_str, SValue sv, int modifier);
		1159	ST_FUNC void asm_gen_code(ASMOperand operands, int nb_operands, int nb_outputs, int is_output, uint8_t clobber_regs, int out_reg);
		1160	ST_FUNC void asm_clobber(uint8_t clobber_regs, const char str);
		1161	#endif
		1162	/* ------------ tccpe.c -------------- */
		1163	#ifdef TCC_TARGET_PE
		1164	ST_FUNC int pe_load_file(struct TCCState s1, const char filename, int fd);
		1165	ST_FUNC int pe_add_dll(struct TCCState s, const char libraryname);
		1166	ST_FUNC int pe_output_file(TCCState * s1, const char *filename);
		1167	ST_FUNC int pe_dllimport(int r, SValue sv, void (fn)(int r, SValue *sv));
		1168	/* tiny_impdef.c */
		1169	ST_FUNC char get_export_names(FILE fp);
		1170	#endif
		1171
		1172	/* ------------ tccrun.c ----------------- */
		1173	#if !defined CONFIG_TCC_STATIC && !defined _WIN32
		1174	ST_FUNC void resolve_sym(TCCState s1, const char *symbol);
		1175	#endif
		1176
		1177	/********************************************************/
		1178	/* include the target specific definitions */
		1179
		1180	#define TARGET_DEFS_ONLY
		1181	#ifdef TCC_TARGET_I386
		1182	#include "i386-gen.c"
		1183	#endif
		1184	#ifdef TCC_TARGET_X86_64
		1185	#include "x86_64-gen.c"
		1186	#endif
		1187	#ifdef TCC_TARGET_ARM
		1188	#include "arm-gen.c"
		1189	#endif
		1190	#ifdef TCC_TARGET_C67
		1191	#include "c67-gen.c"
		1192	#endif
		1193	#undef TARGET_DEFS_ONLY
		1194
		1195	ST_DATA const int reg_classes[NB_REGS];
		1196
		1197	/********************************************************/
		1198	#undef ST_DATA
		1199	#ifndef NOTALLINONE
		1200	#define ST_DATA static
		1201	#else
		1202	#define ST_DATA
		1203	#endif
		1204	/********************************************************/
		1205	#endif /* _TCC_H */

tccasm.c+10−8

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-static int asm_get_local_label_name(TCCState *s1, unsigned int n)
+#include "tcc.h"
+ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n)
 {
     char buf[64];
     TokenSym *ts;
     return ts->tok;
 }
-static void asm_expr(TCCState *s1, ExprValue *pe);
+ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe);
 /* We do not use the C expression parser to handle symbols. Maybe the
    C expression parser could be tweaked to do so. */
     }
 }
-static void asm_expr(TCCState *s1, ExprValue *pe)
+ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe)
 {
     asm_expr_sum(s1, pe);
 }
-static int asm_int_expr(TCCState *s1)
+ST_FUNC int asm_int_expr(TCCState *s1)
 {
     ExprValue e;
     asm_expr(s1, &e);
 }
 /* Assemble the current file */
-static int tcc_assemble(TCCState *s1, int do_preprocess)
+ST_FUNC int tcc_assemble(TCCState *s1, int do_preprocess)
 {
     Sym *define_start;
     int ret;
 /* find a constraint by its number or id (gcc 3 extended
    syntax). return -1 if not found. Return in *pp in char after the
    constraint */
-static int find_constraint(ASMOperand *operands, int nb_operands,
+ST_FUNC int find_constraint(ASMOperand *operands, int nb_operands,
                            const char *name, const char **pp)
 {
     int index;
 }
 /* parse the GCC asm() instruction */
-static void asm_instr(void)
+ST_FUNC void asm_instr(void)
 {
     CString astr, astr1;
     ASMOperand operands[MAX_ASM_OPERANDS];
     cstr_free(&astr1);
 }
-static void asm_global_instr(void)
+ST_FUNC void asm_global_instr(void)
 {
     CString astr;

tcccoff.c+3−1

  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#include "tcc.h"
 #include "coff.h"
 #define MAXNSCNS 255		/* MAXIMUM NUMBER OF SECTIONS         */
     unsigned short dummy4;
 } AUXEF;
-int tcc_output_coff(TCCState *s1, FILE *f)
+ST_FUNC int tcc_output_coff(TCCState *s1, FILE *f)
 {
     Section *tcc_sect;
     SCNHDR *coff_sec;

tccelf.c+27−35

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#include "tcc.h"
 #ifdef TCC_TARGET_X86_64
 #define ElfW_Rel ElfW(Rela)
 #define SHT_RELX SHT_RELA
 /* XXX: DLL with PLT would only work with x86-64 for now */
 //#define TCC_OUTPUT_DLL_WITH_PLT
-static int put_elf_str(Section *s, const char *sym)
+ST_FUNC int put_elf_str(Section *s, const char *sym)
 {
     int offset, len;
     char *ptr;
 }
 /* return the symbol number */
-static int put_elf_sym(Section *s,
+ST_FUNC int put_elf_sym(Section *s,
                        unsigned long value, unsigned long size,
                        int info, int other, int shndx, const char *name)
 {
 /* find global ELF symbol 'name' and return its index. Return 0 if not
    found. */
-static int find_elf_sym(Section *s, const char *name)
+ST_FUNC int find_elf_sym(Section *s, const char *name)
 {
     ElfW(Sym) *sym;
     Section *hs;
 }
 /* return elf symbol value */
-void *tcc_get_symbol(TCCState *s, const char *name)
+LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name)
 {
     return get_elf_sym_addr(s, name, 0);
 }
 /* return elf symbol value or error */
-void *tcc_get_symbol_err(TCCState *s, const char *name)
+ST_FUNC void *tcc_get_symbol_err(TCCState *s, const char *name)
 {
     return get_elf_sym_addr(s, name, 1);
 }
 /* add an elf symbol : check if it is already defined and patch
    it. Return symbol index. NOTE that sh_num can be SHN_UNDEF. */
-static int add_elf_sym(Section *s, uplong value, unsigned long size,
+ST_FUNC int add_elf_sym(Section *s, uplong value, unsigned long size,
                        int info, int other, int sh_num, const char *name)
 {
     ElfW(Sym) *esym;
 }
 /* put relocation */
-static void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
+ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
                           int type, int symbol)
 {
     char buf[256];
 /* put stab debug information */
-typedef struct {
+ST_FUNC void put_stabs(const char *str, int type, int other, int desc,
-    unsigned int n_strx;         /* index into string table of name */
-    unsigned char n_type;         /* type of symbol */
-    unsigned char n_other;        /* misc info (usually empty) */
-    unsigned short n_desc;        /* description field */
-    unsigned int n_value;        /* value of symbol */
-} Stab_Sym;
-static void put_stabs(const char *str, int type, int other, int desc,
                       unsigned long value)
 {
     Stab_Sym *sym;
     sym->n_value = value;
 }
-static void put_stabs_r(const char *str, int type, int other, int desc,
+ST_FUNC void put_stabs_r(const char *str, int type, int other, int desc,
                         unsigned long value, Section *sec, int sym_index)
 {
     put_stabs(str, type, other, desc, value);
                   R_DATA_32, sym_index);
 }
-static void put_stabn(int type, int other, int desc, int value)
+ST_FUNC void put_stabn(int type, int other, int desc, int value)
 {
     put_stabs(NULL, type, other, desc, value);
 }
-static void put_stabd(int type, int other, int desc)
+ST_FUNC void put_stabd(int type, int other, int desc)
 {
     put_stabs(NULL, type, other, desc, 0);
 }
 }
 /* relocate common symbols in the .bss section */
-static void relocate_common_syms(void)
+ST_FUNC void relocate_common_syms(void)
 {
     ElfW(Sym) *sym, *sym_end;
     unsigned long offset, align;
 /* relocate symbol table, resolve undefined symbols if do_resolve is
    true and output error if undefined symbol. */
-static void relocate_syms(TCCState *s1, int do_resolve)
+ST_FUNC void relocate_syms(TCCState *s1, int do_resolve)
 {
     ElfW(Sym) *sym, *esym, *sym_end;
     int sym_bind, sh_num, sym_index;
 #endif
 /* relocate a given section (CPU dependent) */
-static void relocate_section(TCCState *s1, Section *s)
+ST_FUNC void relocate_section(TCCState *s1, Section *s)
 {
     Section *sr;
     ElfW_Rel *rel, *rel_end, *qrel;
 }
 /* build GOT and PLT entries */
-static void build_got_entries(TCCState *s1)
+ST_FUNC void build_got_entries(TCCState *s1)
 {
     Section *s, *symtab;
     ElfW_Rel *rel, *rel_end;
     }
 }
-static Section *new_symtab(TCCState *s1,
+ST_FUNC Section *new_symtab(TCCState *s1,
                            const char *symtab_name, int sh_type, int sh_flags,
                            const char *strtab_name,
                            const char *hash_name, int hash_sh_flags)
                 s->sh_num, sym_end);
 }
-static void tcc_add_bcheck(TCCState *s1)
+ST_FUNC void tcc_add_bcheck(TCCState *s1)
 {
 #ifdef CONFIG_TCC_BCHECK
     unsigned long *ptr;
 }
 /* add tcc runtime libraries */
-static void tcc_add_runtime(TCCState *s1)
+ST_FUNC void tcc_add_runtime(TCCState *s1)
 {
     tcc_add_bcheck(s1);
 /* add various standard linker symbols (must be done after the
    sections are filled (for example after allocating common
    symbols)) */
-static void tcc_add_linker_symbols(TCCState *s1)
+ST_FUNC void tcc_add_linker_symbols(TCCState *s1)
 {
     char buf[1024];
     int i;
 /* output an ELF file */
 /* XXX: suppress unneeded sections */
-int elf_output_file(TCCState *s1, const char *filename)
+static int elf_output_file(TCCState *s1, const char *filename)
 {
     ElfW(Ehdr) ehdr;
     FILE *f;
     return ret;
 }
-int tcc_output_file(TCCState *s, const char *filename)
+LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename)
 {
     int ret;
 #ifdef TCC_TARGET_PE
 /* load an object file and merge it with current files */
 /* XXX: handle correctly stab (debug) info */
-static int tcc_load_object_file(TCCState *s1,
+ST_FUNC int tcc_load_object_file(TCCState *s1,
                                 int fd, unsigned long file_offset)
 {
     ElfW(Ehdr) ehdr;
     return ret;
 }
-#define ARMAG  "!<arch>\012"    /* For COFF and a.out archives */
 typedef struct ArchiveHeader {
     char ar_name[16];           /* name of this member */
     char ar_date[12];           /* file mtime */
 }
 /* load a '.a' file */
-static int tcc_load_archive(TCCState *s1, int fd)
+ST_FUNC int tcc_load_archive(TCCState *s1, int fd)
 {
     ArchiveHeader hdr;
     char ar_size[11];
 /* load a DLL and all referenced DLLs. 'level = 0' means that the DLL
    is referenced by the user (so it should be added as DT_NEEDED in
    the generated ELF file) */
-static int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
+ST_FUNC int tcc_load_dll(TCCState *s1, int fd, const char *filename, int level)
 {
     ElfW(Ehdr) ehdr;
     ElfW(Shdr) *shdr, *sh, *sh1;
 /* interpret a subset of GNU ldscripts to handle the dummy libc.so
    files */
-static int tcc_load_ldscript(TCCState *s1)
+ST_FUNC int tcc_load_ldscript(TCCState *s1)
 {
     char cmd[64];
     char filename[1024];

tccgen.c+290−52

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-void swap(int *p, int *q)
+#include "tcc.h"
+/********************************************************/
+/* global variables */
+/* loc : local variable index
+   ind : output code index
+   rsym: return symbol
+   anon_sym: anonymous symbol index
+*/
+ST_DATA int rsym, anon_sym, ind, loc;
+ST_DATA Section *text_section, *data_section, *bss_section; /* predefined sections */
+ST_DATA Section *cur_text_section; /* current section where function code is generated */
+#ifdef CONFIG_TCC_ASM
+ST_DATA Section *last_text_section; /* to handle .previous asm directive */
+#endif
+#ifdef CONFIG_TCC_BCHECK
+/* bound check related sections */
+ST_DATA Section *bounds_section; /* contains global data bound description */
+ST_DATA Section *lbounds_section; /* contains local data bound description */
+#endif
+/* symbol sections */
+ST_DATA Section *symtab_section, *strtab_section;
+/* debug sections */
+ST_DATA Section *stab_section, *stabstr_section;
+ST_DATA Sym *sym_free_first;
+ST_DATA void **sym_pools;
+ST_DATA int nb_sym_pools;
+ST_DATA Sym *global_stack;
+ST_DATA Sym *local_stack;
+ST_DATA Sym *define_stack;
+ST_DATA Sym *global_label_stack;
+ST_DATA Sym *local_label_stack;
+ST_DATA SValue vstack[VSTACK_SIZE], *vtop;
+ST_DATA int const_wanted; /* true if constant wanted */
+ST_DATA int nocode_wanted; /* true if no code generation wanted for an expression */
+ST_DATA int global_expr;  /* true if compound literals must be allocated globally (used during initializers parsing */
+ST_DATA CType func_vt; /* current function return type (used by return instruction) */
+ST_DATA int func_vc;
+ST_DATA int last_line_num, last_ind, func_ind; /* debug last line number and pc */
+ST_DATA char *funcname;
+ST_DATA CType char_pointer_type, func_old_type, int_type;
+/* ------------------------------------------------------------------------- */
+static void gen_cast(CType *type);
+static inline CType *pointed_type(CType *type);
+static int is_compatible_types(CType *type1, CType *type2);
+static int parse_btype(CType *type, AttributeDef *ad);
+static void type_decl(CType *type, AttributeDef *ad, int *v, int td);
+static void parse_expr_type(CType *type);
+static void decl_initializer(CType *type, Section *sec, unsigned long c, int first, int size_only);
+static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_reg, int is_expr);
+static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
+static void expr_eq(void);
+static void unary_type(CType *type);
+static int is_compatible_parameter_types(CType *type1, CType *type2);
+static void expr_type(CType *type);
+ST_INLN int is_float(int t)
+{
+    int bt;
+    bt = t & VT_BTYPE;
+    return bt == VT_LDOUBLE || bt == VT_DOUBLE || bt == VT_FLOAT;
+}
+ST_FUNC void test_lvalue(void)
+{
+    if (!(vtop->r & VT_LVAL))
+        expect("lvalue");
+}
+/* ------------------------------------------------------------------------- */
+/* symbol allocator */
+static Sym *__sym_malloc(void)
+{
+    Sym *sym_pool, *sym, *last_sym;
+    int i;
+    sym_pool = tcc_malloc(SYM_POOL_NB * sizeof(Sym));
+    dynarray_add(&sym_pools, &nb_sym_pools, sym_pool);
+    last_sym = sym_free_first;
+    sym = sym_pool;
+    for(i = 0; i < SYM_POOL_NB; i++) {
+        sym->next = last_sym;
+        last_sym = sym;
+        sym++;
+    }
+    sym_free_first = last_sym;
+    return last_sym;
+}
+static inline Sym *sym_malloc(void)
+{
+    Sym *sym;
+    sym = sym_free_first;
+    if (!sym)
+        sym = __sym_malloc();
+    sym_free_first = sym->next;
+    return sym;
+}
+ST_INLN void sym_free(Sym *sym)
+{
+    sym->next = sym_free_first;
+    sym_free_first = sym;
+}
+/* push, without hashing */
+ST_FUNC Sym *sym_push2(Sym **ps, int v, int t, long c)
+{
+    Sym *s;
+    s = sym_malloc();
+    s->v = v;
+    s->type.t = t;
+    s->type.ref = NULL;
+#ifdef _WIN64
+    s->d = NULL;
+#endif
+    s->c = c;
+    s->next = NULL;
+    /* add in stack */
+    s->prev = *ps;
+    *ps = s;
+    return s;
+}
+/* find a symbol and return its associated structure. 's' is the top
+   of the symbol stack */
+ST_FUNC Sym *sym_find2(Sym *s, int v)
+{
+    while (s) {
+        if (s->v == v)
+            return s;
+        s = s->prev;
+    }
+    return NULL;
+}
+/* structure lookup */
+ST_INLN Sym *struct_find(int v)
+{
+    v -= TOK_IDENT;
+    if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
+        return NULL;
+    return table_ident[v]->sym_struct;
+}
+/* find an identifier */
+ST_INLN Sym *sym_find(int v)
+{
+    v -= TOK_IDENT;
+    if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
+        return NULL;
+    return table_ident[v]->sym_identifier;
+}
+/* push a given symbol on the symbol stack */
+ST_FUNC Sym *sym_push(int v, CType *type, int r, int c)
+{
+    Sym *s, **ps;
+    TokenSym *ts;
+    if (local_stack)
+        ps = &local_stack;
+    else
+        ps = &global_stack;
+    s = sym_push2(ps, v, type->t, c);
+    s->type.ref = type->ref;
+    s->r = r;
+    /* don't record fields or anonymous symbols */
+    /* XXX: simplify */
+    if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
+        /* record symbol in token array */
+        ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
+        if (v & SYM_STRUCT)
+            ps = &ts->sym_struct;
+        else
+            ps = &ts->sym_identifier;
+        s->prev_tok = *ps;
+        *ps = s;
+    }
+    return s;
+}
+/* push a global identifier */
+ST_FUNC Sym *global_identifier_push(int v, int t, int c)
+{
+    Sym *s, **ps;
+    s = sym_push2(&global_stack, v, t, c);
+    /* don't record anonymous symbol */
+    if (v < SYM_FIRST_ANOM) {
+        ps = &table_ident[v - TOK_IDENT]->sym_identifier;
+        /* modify the top most local identifier, so that
+           sym_identifier will point to 's' when popped */
+        while (*ps != NULL)
+            ps = &(*ps)->prev_tok;
+        s->prev_tok = NULL;
+        *ps = s;
+    }
+    return s;
+}
+/* pop symbols until top reaches 'b' */
+ST_FUNC void sym_pop(Sym **ptop, Sym *b)
+{
+    Sym *s, *ss, **ps;
+    TokenSym *ts;
+    int v;
+    s = *ptop;
+    while(s != b) {
+        ss = s->prev;
+        v = s->v;
+        /* remove symbol in token array */
+        /* XXX: simplify */
+        if (!(v & SYM_FIELD) && (v & ~SYM_STRUCT) < SYM_FIRST_ANOM) {
+            ts = table_ident[(v & ~SYM_STRUCT) - TOK_IDENT];
+            if (v & SYM_STRUCT)
+                ps = &ts->sym_struct;
+            else
+                ps = &ts->sym_identifier;
+            *ps = s->prev_tok;
+        }
+        sym_free(s);
+        s = ss;
+    }
+    *ptop = b;
+}
+/* ------------------------------------------------------------------------- */
+ST_FUNC void swap(int *p, int *q)
 {
     int t;
     t = *p;
     *q = t;
 }
-void vsetc(CType *type, int r, CValue *vc)
+static void vsetc(CType *type, int r, CValue *vc)
 {
     int v;
 }
 /* push integer constant */
-void vpushi(int v)
+ST_FUNC void vpushi(int v)
 {
     CValue cval;
     cval.i = v;
 }
 /* push long long constant */
-void vpushll(long long v)
+static void vpushll(long long v)
 {
     CValue cval;
     CType ctype;
 }
 /* Return a static symbol pointing to a section */
-static Sym *get_sym_ref(CType *type, Section *sec,
+ST_FUNC Sym *get_sym_ref(CType *type, Section *sec, unsigned long offset, unsigned long size)
-                        unsigned long offset, unsigned long size)
 {
     int v;
     Sym *sym;
 }
 /* define a new external reference to a symbol 'v' of type 'u' */
-static Sym *external_global_sym(int v, CType *type, int r)
+ST_FUNC Sym *external_global_sym(int v, CType *type, int r)
 {
     Sym *s;
     vtop->sym = sym;
 }
-void vset(CType *type, int r, int v)
+ST_FUNC void vset(CType *type, int r, int v)
 {
     CValue cval;
     vsetc(type, r, &cval);
 }
-void vseti(int r, int v)
+static void vseti(int r, int v)
 {
     CType type;
     type.t = VT_INT;
     vset(&type, r, v);
 }
-void vswap(void)
+ST_FUNC void vswap(void)
 {
     SValue tmp;
     vtop[-1] = tmp;
 }
-void vpushv(SValue *v)
+static void vpushv(SValue *v)
 {
     if (vtop >= vstack + (VSTACK_SIZE - 1))
         error("memory full");
     *vtop = *v;
 }
-void vdup(void)
+static void vdup(void)
 {
     vpushv(vtop);
 }
 /* save r to the memory stack, and mark it as being free */
-void save_reg(int r)
+ST_FUNC void save_reg(int r)
 {
     int l, saved, size, align;
     SValue *p, sv;
     }
 }
+#ifdef TCC_TARGET_ARM
 /* find a register of class 'rc2' with at most one reference on stack.
  * If none, call get_reg(rc) */
-int get_reg_ex(int rc, int rc2)
+ST_FUNC int get_reg_ex(int rc, int rc2)
 {
     int r;
     SValue *p;
     }
     return get_reg(rc);
 }
+#endif
 /* find a free register of class 'rc'. If none, save one register */
-int get_reg(int rc)
+ST_FUNC int get_reg(int rc)
 {
     int r;
     SValue *p;
 }
 /* save registers up to (vtop - n) stack entry */
-void save_regs(int n)
+ST_FUNC void save_regs(int n)
 {
     int r;
     SValue *p, *p1;
 /* move register 's' to 'r', and flush previous value of r to memory
    if needed */
-void move_reg(int r, int s)
+static void move_reg(int r, int s)
 {
     SValue sv;
 }
 /* get address of vtop (vtop MUST BE an lvalue) */
-void gaddrof(void)
+static void gaddrof(void)
 {
     vtop->r &= ~VT_LVAL;
     /* tricky: if saved lvalue, then we can go back to lvalue */
 #ifdef CONFIG_TCC_BCHECK
 /* generate lvalue bound code */
-void gbound(void)
+static void gbound(void)
 {
     int lval_type;
     CType type1;
 /* store vtop a register belonging to class 'rc'. lvalues are
    converted to values. Cannot be used if cannot be converted to
    register value (such as structures). */
-int gv(int rc)
+ST_FUNC int gv(int rc)
 {
     int r, rc2, bit_pos, bit_size, size, align, i;
 }
 /* generate vtop[-1] and vtop[0] in resp. classes rc1 and rc2 */
-void gv2(int rc1, int rc2)
+ST_FUNC void gv2(int rc1, int rc2)
 {
     int v;
 }
 /* wrapper around RC_FRET to return a register by type */
-int rc_fret(int t)
+static int rc_fret(int t)
 {
 #ifdef TCC_TARGET_X86_64
     if (t == VT_LDOUBLE) {
 }
 /* wrapper around REG_FRET to return a register by type */
-int reg_fret(int t)
+static int reg_fret(int t)
 {
 #ifdef TCC_TARGET_X86_64
     if (t == VT_LDOUBLE) {
 }
 /* expand long long on stack in two int registers */
-void lexpand(void)
+static void lexpand(void)
 {
     int u;
 #ifdef TCC_TARGET_ARM
 /* expand long long on stack */
-void lexpand_nr(void)
+ST_FUNC void lexpand_nr(void)
 {
     int u,v;
 #endif
 /* build a long long from two ints */
-void lbuild(int t)
+static void lbuild(int t)
 {
     gv2(RC_INT, RC_INT);
     vtop[-1].r2 = vtop[0].r;
 /* rotate n first stack elements to the bottom
    I1 ... In -> I2 ... In I1 [top is right]
 */
-void vrotb(int n)
+static void vrotb(int n)
 {
     int i;
     SValue tmp;
 /* rotate n first stack elements to the top
    I1 ... In -> In I1 ... I(n-1)  [top is right]
  */
-void vrott(int n)
+static void vrott(int n)
 {
     int i;
     SValue tmp;
 #endif
 /* pop stack value */
-void vpop(void)
+ST_FUNC void vpop(void)
 {
     int v;
     v = vtop->r & VT_VALMASK;
 /* convert stack entry to register and duplicate its value in another
    register */
-void gv_dup(void)
+static void gv_dup(void)
 {
     int rc, t, r, r1;
     SValue sv;
 #ifndef TCC_TARGET_X86_64
 /* generate CPU independent (unsigned) long long operations */
-void gen_opl(int op)
+static void gen_opl(int op)
 {
     int t, a, b, op1, c, i;
     int func;
 /* handle integer constant optimizations and various machine
    independent opt */
-void gen_opic(int op)
+static void gen_opic(int op)
 {
     int c1, c2, t1, t2, n;
     SValue *v1, *v2;
 }
 /* generate a floating point operation with constant propagation */
-void gen_opif(int op)
+static void gen_opif(int op)
 {
     int c1, c2;
     SValue *v1, *v2;
 }
 /* generic gen_op: handles types problems */
-void gen_op(int op)
+ST_FUNC void gen_op(int op)
 {
     int u, t1, t2, bt1, bt2, t;
     CType type1;
 #ifndef TCC_TARGET_ARM
 /* generic itof for unsigned long long case */
-void gen_cvt_itof1(int t)
+static void gen_cvt_itof1(int t)
 {
     if ((vtop->type.t & (VT_BTYPE | VT_UNSIGNED)) ==
         (VT_LLONG | VT_UNSIGNED)) {
 #endif
 /* generic ftoi for unsigned long long case */
-void gen_cvt_ftoi1(int t)
+static void gen_cvt_ftoi1(int t)
 {
     int st;
 }
 /* force char or short cast */
-void force_charshort_cast(int t)
+static void force_charshort_cast(int t)
 {
     int bits, dbt;
     dbt = t & VT_BTYPE;
 }
 /* return type size. Put alignment at 'a' */
-static int type_size(CType *type, int *a)
+ST_FUNC int type_size(CType *type, int *a)
 {
     Sym *s;
     int bt;
 }
 /* modify type so that its it is a pointer to type. */
-static void mk_pointer(CType *type)
+ST_FUNC void mk_pointer(CType *type)
 {
     Sym *s;
     s = sym_push(SYM_FIELD, type, 0, -1);
    printed in the type */
 /* XXX: union */
 /* XXX: add array and function pointers */
-void type_to_str(char *buf, int buf_size,
+static void type_to_str(char *buf, int buf_size,
                  CType *type, const char *varstr)
 {
     int bt, v, t;
 }
 /* store vtop in lvalue pushed on stack */
-void vstore(void)
+ST_FUNC void vstore(void)
 {
     int sbt, dbt, ft, r, t, size, align, bit_size, bit_pos, rc, delayed_cast;
 }
 /* post defines POST/PRE add. c is the token ++ or -- */
-void inc(int post, int c)
+ST_FUNC void inc(int post, int c)
 {
     test_lvalue();
     vdup(); /* save lvalue */
 }
 /* compute the lvalue VT_LVAL_xxx needed to match type t. */
-static int lvalue_type(int t)
+ST_FUNC int lvalue_type(int t)
 {
     int bt, r;
     r = VT_LVAL;
 }
 /* indirection with full error checking and bound check */
-static void indir(void)
+ST_FUNC void indir(void)
 {
     if ((vtop->type.t & VT_BTYPE) != VT_PTR) {
         if ((vtop->type.t & VT_BTYPE) == VT_FUNC)
     vsetc(&type, VT_CONST, &tokc);
 }
-static void unary(void)
+ST_FUNC void unary(void)
 {
     int n, t, align, size, r;
     CType type;
     }
 }
-static void expr_prod(void)
+ST_FUNC void expr_prod(void)
 {
     int t;
     }
 }
-static void expr_sum(void)
+ST_FUNC void expr_sum(void)
 {
     int t;
     }
 }
-static void gexpr(void)
+ST_FUNC void gexpr(void)
 {
     while (1) {
         expr_eq();
 }
 /* parse an integer constant and return its value. */
-static int expr_const(void)
+ST_FUNC int expr_const(void)
 {
     int c;
     expr_const1();
  no_alloc: ;
 }
-void put_func_debug(Sym *sym)
+static void put_func_debug(Sym *sym)
 {
     char buf[512];
     nocode_wanted = saved_nocode_wanted;
 }
-static void gen_inline_functions(void)
+ST_FUNC void gen_inline_functions(void)
 {
     Sym *sym;
     int *str, inline_generated, i;
 }
 /* 'l' is VT_LOCAL or VT_CONST to define default storage type */
-static void decl(int l)
+ST_FUNC void decl(int l)
 {
     int v, has_init, r;
     CType type, btype;

tccpe.c+62−67

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#ifdef TCC_TARGET_PE
+#include "tcc.h"
-#define ST_FN static
-#define ST_DATA static
-#define PUB_FN
 #ifndef _WIN32
 #define stricmp strcasecmp
     sec_last
 };
-ST_DATA const DWORD pe_sec_flags[] = {
+static const DWORD pe_sec_flags[] = {
     0x60000020, /* ".text"     , */
     0xC0000040, /* ".data"     , */
     0xC0000080, /* ".bss"      , */
 /* --------------------------------------------*/
-ST_FN const char* get_alt_symbol(char *buffer, const char *symbol)
+static const char* get_alt_symbol(char *buffer, const char *symbol)
 {
     const char *p;
     p = strrchr(symbol, '@');
     return buffer;
 }
-ST_FN int pe_find_import(TCCState * s1, const char *symbol)
+static int pe_find_import(TCCState * s1, const char *symbol)
 {
     char buffer[200];
     const char *s;
 /*----------------------------------------------------------------------------*/
-ST_FN int dynarray_assoc(void **pp, int n, int key)
+static int dynarray_assoc(void **pp, int n, int key)
 {
     int i;
     for (i = 0; i < n; ++i, ++pp)
 }
 #endif
-ST_FN DWORD umax(DWORD a, DWORD b)
+static DWORD umax(DWORD a, DWORD b)
 {
     return a < b ? b : a;
 }
-ST_FN DWORD pe_file_align(struct pe_info *pe, DWORD n)
+static DWORD pe_file_align(struct pe_info *pe, DWORD n)
 {
     return (n + (pe->file_align - 1)) & ~(pe->file_align - 1);
 }
-ST_FN DWORD pe_virtual_align(struct pe_info *pe, DWORD n)
+static DWORD pe_virtual_align(struct pe_info *pe, DWORD n)
 {
     return (n + (pe->section_align - 1)) & ~(pe->section_align - 1);
 }
-ST_FN void pe_align_section(Section *s, int a)
+static void pe_align_section(Section *s, int a)
 {
     int i = s->data_offset & (a-1);
     if (i)
         section_ptr_add(s, a - i);
 }
-ST_FN void pe_set_datadir(struct pe_header *hdr, int dir, DWORD addr, DWORD size)
+static void pe_set_datadir(struct pe_header *hdr, int dir, DWORD addr, DWORD size)
 {
     hdr->opthdr.DataDirectory[dir].VirtualAddress = addr;
     hdr->opthdr.DataDirectory[dir].Size = size;
 }
-ST_FN int pe_fwrite(void *data, unsigned len, FILE *fp, DWORD *psum)
+static int pe_fwrite(void *data, unsigned len, FILE *fp, DWORD *psum)
 {
     if (psum) {
         DWORD sum = *psum;
     return len == fwrite(data, 1, len, fp) ? 0 : -1;
 }
-ST_FN void pe_fpad(FILE *fp, DWORD new_pos)
+static void pe_fpad(FILE *fp, DWORD new_pos)
 {
     DWORD pos = ftell(fp);
     while (++pos <= new_pos)
 }
 /*----------------------------------------------------------------------------*/
-ST_FN int pe_write(struct pe_info *pe)
+static int pe_write(struct pe_info *pe)
 {
     static const struct pe_header pe_template = {
     {
 #endif
 /*----------------------------------------------------------------------------*/
-ST_FN struct import_symbol *pe_add_import(struct pe_info *pe, int sym_index)
+static struct import_symbol *pe_add_import(struct pe_info *pe, int sym_index)
 {
     int i;
     int dll_index;
 }
 /*----------------------------------------------------------------------------*/
-ST_FN void pe_build_imports(struct pe_info *pe)
+static void pe_build_imports(struct pe_info *pe)
 {
     int thk_ptr, ent_ptr, dll_ptr, sym_cnt, i;
     DWORD rva_base = pe->thunk->sh_addr - pe->imagebase;
     const char *name;
 };
-ST_FN int sym_cmp(const void *va, const void *vb)
+static int sym_cmp(const void *va, const void *vb)
 {
     const char *ca = (*(struct pe_sort_sym**)va)->name;
     const char *cb = (*(struct pe_sort_sym**)vb)->name;
     return strcmp(ca, cb);
 }
-ST_FN void pe_build_exports(struct pe_info *pe)
+static void pe_build_exports(struct pe_info *pe)
 {
     ElfW(Sym) *sym;
     int sym_index, sym_end;
 }
 /* ------------------------------------------------------------- */
-ST_FN void pe_build_reloc (struct pe_info *pe)
+static void pe_build_reloc (struct pe_info *pe)
 {
     DWORD offset, block_ptr, addr;
     int count, i;
 }
 /* ------------------------------------------------------------- */
-ST_FN int pe_section_class(Section *s)
+static int pe_section_class(Section *s)
 {
     int type, flags;
     const char *name;
     return -1;
 }
-ST_FN int pe_assign_addresses (struct pe_info *pe)
+static int pe_assign_addresses (struct pe_info *pe)
 {
     int i, k, o, c;
     DWORD addr;
 }
 /* ------------------------------------------------------------- */
-ST_FN void pe_relocate_rva (struct pe_info *pe, Section *s)
+static void pe_relocate_rva (struct pe_info *pe, Section *s)
 {
     Section *sr = s->reloc;
     ElfW_Rel *rel, *rel_end;
 }
 /*----------------------------------------------------------------------------*/
 static int pe_isafunc(int sym_index)
 {
     Section *sr = text_section->reloc;
 }
 /*----------------------------------------------------------------------------*/
-ST_FN int pe_check_symbols(struct pe_info *pe)
+static int pe_check_symbols(struct pe_info *pe)
 {
     ElfW(Sym) *sym;
     int sym_index, sym_end;
 /*----------------------------------------------------------------------------*/
 #ifdef PE_PRINT_SECTIONS
-ST_FN void pe_print_section(FILE * f, Section * s)
+static void pe_print_section(FILE * f, Section * s)
 {
     /* just if you'r curious */
     BYTE *p, *e, b;
     fprintf(f, "\n\n");
 }
-ST_FN void pe_print_sections(TCCState *s1, const char *fname)
+static void pe_print_sections(TCCState *s1, const char *fname)
 {
     Section *s;
     FILE *f;
 #endif
 /* ------------------------------------------------------------- */
-/* helper function for load/store to insert one more indirection */
-int pe_dllimport(int r, SValue *sv, void (*fn)(int r, SValue *sv))
+static int read_mem(FILE *fp, unsigned offset, void *buffer, unsigned len)
-{
-    int t;
-    if ((sv->r & (VT_VALMASK|VT_SYM|VT_CONST)) != (VT_SYM|VT_CONST))
-        return 0;
-    t = sv->sym->type.t;
-    if (0 == (t & VT_IMPORT))
-        return 0;
-    sv->sym->type.t = t & ~VT_IMPORT;
-    //printf("import %x %04x %s\n", t, ind, get_tok_str(sv->sym->v, NULL));
-    *++vtop = *sv;
-    vtop->type.t &= ~(VT_ARRAY|VT_IMPORT);
-    mk_pointer(&vtop->type);
-    indir();
-    fn(r, vtop);
-    --vtop;
-    sv->sym->type.t = t;
-    return 1;
-}
-/* ------------------------------------------------------------- */
-ST_FN int read_mem(FILE *fp, unsigned offset, void *buffer, unsigned len)
 {
     fseek(fp, offset, 0);
     return len == fread(buffer, 1, len, fp);
  *  as generated by 'windres.exe -O coff ...'.
  */
-ST_FN int pe_load_res(TCCState *s1, FILE *fp)
+static int pe_load_res(TCCState *s1, FILE *fp)
 {
     struct pe_rsrc_header hdr;
     Section *rsrc_section;
 }
 /* ------------------------------------------------------------- */
-ST_FN char *trimfront(char *p)
+static char *trimfront(char *p)
 {
     while (*p && (unsigned char)*p <= ' ')
         ++p;
     return p;
 }
-ST_FN char *trimback(char *a, char *e)
+static char *trimback(char *a, char *e)
 {
     while (e > a && (unsigned char)e[-1] <= ' ')
         --e;
     return a;
 }
-ST_FN char *get_line(char *line, int size, FILE *fp)
+static char *get_line(char *line, int size, FILE *fp)
 {
     if (NULL == fgets(line, size, fp))
         return NULL;
 }
 /* ------------------------------------------------------------- */
-ST_FN int pe_load_def(TCCState *s1, FILE *fp)
+static int pe_load_def(TCCState *s1, FILE *fp)
 {
     DLLReference *dllref;
     int state = 0, ret = -1;
 #define TINY_IMPDEF_GET_EXPORT_NAMES_ONLY
 #include "win32/tools/tiny_impdef.c"
-ST_FN int pe_load_dll(TCCState *s1, const char *dllname, FILE *fp)
+static int pe_load_dll(TCCState *s1, const char *dllname, FILE *fp)
 {
     int i = 0;
     char *p, *q;
 }
 /* ------------------------------------------------------------- */
-PUB_FN int pe_load_file(struct TCCState *s1, const char *filename, int fd)
+ST_FUNC int pe_load_file(struct TCCState *s1, const char *filename, int fd)
 {
     FILE *fp = fdopen(dup(fd), "rb");
     int ret = -1;
     return ret;
 }
-int pe_add_dll(struct TCCState *s, const char *libname)
+ST_FUNC int pe_add_dll(struct TCCState *s, const char *libname)
 {
     static const char *pat[] = {
         "%s.def", "lib%s.def", "%s.dll", "lib%s.dll", NULL
     return -1;
 }
+/* ------------------------------------------------------------- */
+/* helper function for load/store to insert one more indirection */
+ST_FUNC int pe_dllimport(int r, SValue *sv, void (*fn)(int r, SValue *sv))
+{
+    int t;
+    if ((sv->r & (VT_VALMASK|VT_SYM|VT_CONST)) != (VT_SYM|VT_CONST))
+	return 0;
+    t = sv->sym->type.t;
+    if (0 == (t & VT_IMPORT))
+	return 0;
+    sv->sym->type.t = t & ~VT_IMPORT;
+    //printf("import %x %04x %s\n", t, ind, get_tok_str(sv->sym->v, NULL));
+    *++vtop = *sv;
+    vtop->type.t &= ~(VT_ARRAY|VT_IMPORT);
+    mk_pointer(&vtop->type);
+    indir();
+    fn(r, vtop);
+    --vtop;
+    sv->sym->type.t = t;
+    return 1;
+}
 /* ------------------------------------------------------------- */
 #ifdef TCC_TARGET_X86_64
 #define PE_STDSYM(n,s) n
 #define PE_STDSYM(n,s) "_" n s
 #endif
-ST_FN void pe_add_runtime_ex(TCCState *s1, struct pe_info *pe)
+static void pe_add_runtime_ex(TCCState *s1, struct pe_info *pe)
 {
     const char *start_symbol;
     unsigned long addr = 0;
     pe->start_addr = addr;
 }
-PUB_FN int pe_output_file(TCCState * s1, const char *filename)
+ST_FUNC int pe_output_file(TCCState * s1, const char *filename)
 {
     int ret;
     struct pe_info pe;
 }
 /* ------------------------------------------------------------- */
-#endif /* def TCC_TARGET_PE */
-/* ------------------------------------------------------------- */

tccpp.c+179−42

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#include "tcc.h"
+/********************************************************/
+/* global variables */
+ST_DATA int tok_flags;
+/* additional informations about token */
+#define TOK_FLAG_BOL   0x0001 /* beginning of line before */
+#define TOK_FLAG_BOF   0x0002 /* beginning of file before */
+#define TOK_FLAG_ENDIF 0x0004 /* a endif was found matching starting #ifdef */
+#define TOK_FLAG_EOF   0x0008 /* end of file */
+ST_DATA int parse_flags;
+#define PARSE_FLAG_PREPROCESS 0x0001 /* activate preprocessing */
+#define PARSE_FLAG_TOK_NUM    0x0002 /* return numbers instead of TOK_PPNUM */
+#define PARSE_FLAG_LINEFEED   0x0004 /* line feed is returned as a
+                                        token. line feed is also
+                                        returned at eof */
+#define PARSE_FLAG_ASM_COMMENTS 0x0008 /* '#' can be used for line comment */
+#define PARSE_FLAG_SPACES     0x0010 /* next() returns space tokens (for -E) */
+ST_DATA struct BufferedFile *file;
+ST_DATA int ch, tok;
+ST_DATA CValue tokc;
+ST_DATA int *macro_ptr;
+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;
+/* ------------------------------------------------------------------------- */
+static int *macro_ptr_allocated;
+static int *unget_saved_macro_ptr;
+static int unget_saved_buffer[TOK_MAX_SIZE + 1];
+static int unget_buffer_enabled;
+static TokenSym *hash_ident[TOK_HASH_SIZE];
+static char token_buf[STRING_MAX_SIZE + 1];
+/* true if isid(c) || isnum(c) */
+static unsigned char isidnum_table[256-CH_EOF];
 static const char tcc_keywords[] =
 #define DEF(id, str) str "\0"
     "<=\236>=\235!=\225&&\240||\241++\244--\242==\224<<\1>>\2+=\253"
     "-=\255*=\252/=\257%=\245&=\246^=\336|=\374->\313..\250##\266";
-/* true if isid(c) || isnum(c) */
-static unsigned char isidnum_table[256-CH_EOF];
 struct macro_level {
     struct macro_level *prev;
     int *p;
 };
-static void next_nomacro(void);
+ST_FUNC void next_nomacro(void);
 static void next_nomacro_spc(void);
-static void macro_subst(TokenString *tok_str, Sym **nested_list,
+static void macro_subst(
-                        const int *macro_str, struct macro_level **can_read_stream);
+    TokenString *tok_str,
+    Sym **nested_list,
+    const int *macro_str,
+    struct macro_level **can_read_stream
+    );
+ST_FUNC void skip(int c)
+{
+    if (tok != c)
+        error("'%c' expected", c);
+    next();
+}
+/* ------------------------------------------------------------------------- */
+/* CString handling */
+static void cstr_realloc(CString *cstr, int new_size)
+{
+    int size;
+    void *data;
+    size = cstr->size_allocated;
+    if (size == 0)
+        size = 8; /* no need to allocate a too small first string */
+    while (size < new_size)
+        size = size * 2;
+    data = tcc_realloc(cstr->data_allocated, size);
+    if (!data)
+        error("memory full");
+    cstr->data_allocated = data;
+    cstr->size_allocated = size;
+    cstr->data = data;
+}
+/* add a byte */
+ST_INLN void cstr_ccat(CString *cstr, int ch)
+{
+    int size;
+    size = cstr->size + 1;
+    if (size > cstr->size_allocated)
+        cstr_realloc(cstr, size);
+    ((unsigned char *)cstr->data)[size - 1] = ch;
+    cstr->size = size;
+}
+ST_FUNC void cstr_cat(CString *cstr, const char *str)
+{
+    int c;
+    for(;;) {
+        c = *str;
+        if (c == '\0')
+            break;
+        cstr_ccat(cstr, c);
+        str++;
+    }
+}
+/* add a wide char */
+ST_FUNC void cstr_wccat(CString *cstr, int ch)
+{
+    int size;
+    size = cstr->size + sizeof(nwchar_t);
+    if (size > cstr->size_allocated)
+        cstr_realloc(cstr, size);
+    *(nwchar_t *)(((unsigned char *)cstr->data) + size - sizeof(nwchar_t)) = ch;
+    cstr->size = size;
+}
+ST_FUNC void cstr_new(CString *cstr)
+{
+    memset(cstr, 0, sizeof(CString));
+}
+/* free string and reset it to NULL */
+ST_FUNC void cstr_free(CString *cstr)
+{
+    tcc_free(cstr->data_allocated);
+    cstr_new(cstr);
+}
+/* XXX: unicode ? */
+ST_FUNC void add_char(CString *cstr, int c)
+{
+    if (c == '\'' || c == '\"' || c == '\\') {
+        /* XXX: could be more precise if char or string */
+        cstr_ccat(cstr, '\\');
+    }
+    if (c >= 32 && c <= 126) {
+        cstr_ccat(cstr, c);
+    } else {
+        cstr_ccat(cstr, '\\');
+        if (c == '\n') {
+            cstr_ccat(cstr, 'n');
+        } else {
+            cstr_ccat(cstr, '0' + ((c >> 6) & 7));
+            cstr_ccat(cstr, '0' + ((c >> 3) & 7));
+            cstr_ccat(cstr, '0' + (c & 7));
+        }
+    }
+}
+/* ------------------------------------------------------------------------- */
 /* allocate a new token */
 static TokenSym *tok_alloc_new(TokenSym **pts, const char *str, int len)
 {
 #define TOK_HASH_FUNC(h, c) ((h) * 263 + (c))
 /* find a token and add it if not found */
-static TokenSym *tok_alloc(const char *str, int len)
+ST_FUNC TokenSym *tok_alloc(const char *str, int len)
 {
     TokenSym *ts, **pts;
     int i;
 /* XXX: buffer overflow */
 /* XXX: float tokens */
-char *get_tok_str(int v, CValue *cv)
+ST_FUNC char *get_tok_str(int v, CValue *cv)
 {
     static char buf[STRING_MAX_SIZE + 1];
     static CString cstr_buf;
 /* return the current character, handling end of block if necessary
    (but not stray) */
-static int handle_eob(void)
+ST_FUNC int handle_eob(void)
 {
     return tcc_peekc_slow(file);
 }
 /* read next char from current input file and handle end of input buffer */
-static inline void inp(void)
+ST_INLN 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 */
-static void minp(void)
+ST_FUNC void minp(void)
 {
     inp();
     if (ch == '\\')
 }
 /* C comments */
-static uint8_t *parse_comment(uint8_t *p)
+ST_FUNC uint8_t *parse_comment(uint8_t *p)
 {
     int c;
 /* skip block of text until #else, #elif or #endif. skip also pairs of
    #if/#endif */
-void preprocess_skip(void)
+static void preprocess_skip(void)
 {
     int a, start_of_line, c, in_warn_or_error;
     uint8_t *p;
    files */
 /* save current parse state in 's' */
-void save_parse_state(ParseState *s)
+ST_FUNC void save_parse_state(ParseState *s)
 {
     s->line_num = file->line_num;
     s->macro_ptr = macro_ptr;
 }
 /* restore parse state from 's' */
-void restore_parse_state(ParseState *s)
+ST_FUNC void restore_parse_state(ParseState *s)
 {
     file->line_num = s->line_num;
     macro_ptr = s->macro_ptr;
 /* token string handling */
-static inline void tok_str_new(TokenString *s)
+ST_INLN void tok_str_new(TokenString *s)
 {
     s->str = NULL;
     s->len = 0;
     s->last_line_num = -1;
 }
-static void tok_str_free(int *str)
+ST_FUNC void tok_str_free(int *str)
 {
     tcc_free(str);
 }
     return str;
 }
-static void tok_str_add(TokenString *s, int t)
+ST_FUNC void tok_str_add(TokenString *s, int t)
 {
     int len, *str;
 }
 /* add the current parse token in token string 's' */
-static void tok_str_add_tok(TokenString *s)
+ST_FUNC void tok_str_add_tok(TokenString *s)
 {
     CValue cval;
 }
 /* defines handling */
-static inline void define_push(int v, int macro_type, int *str, Sym *first_arg)
+ST_INLN void define_push(int v, int macro_type, int *str, Sym *first_arg)
 {
     Sym *s;
 }
 /* undefined a define symbol. Its name is just set to zero */
-static void define_undef(Sym *s)
+ST_FUNC void define_undef(Sym *s)
 {
     int v;
     v = s->v;
     s->v = 0;
 }
-static inline Sym *define_find(int v)
+ST_INLN Sym *define_find(int v)
 {
     v -= TOK_IDENT;
     if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
 }
 /* free define stack until top reaches 'b' */
-static void free_defines(Sym *b)
+ST_FUNC void free_defines(Sym *b)
 {
     Sym *top, *top1;
     int v;
 }
 /* label lookup */
-static Sym *label_find(int v)
+ST_FUNC Sym *label_find(int v)
 {
     v -= TOK_IDENT;
     if ((unsigned)v >= (unsigned)(tok_ident - TOK_IDENT))
     return table_ident[v]->sym_label;
 }
-static Sym *label_push(Sym **ptop, int v, int flags)
+ST_FUNC Sym *label_push(Sym **ptop, int v, int flags)
 {
     Sym *s, **ps;
     s = sym_push2(ptop, v, 0, 0);
 /* pop labels until element last is reached. Look if any labels are
    undefined. Define symbols if '&&label' was used. */
-static void label_pop(Sym **ptop, Sym *slast)
+ST_FUNC void label_pop(Sym **ptop, Sym *slast)
 {
     Sym *s, *s1;
     for(s = *ptop; s != slast; s = s1) {
 #endif
 /* parse after #define */
-static void parse_define(void)
+ST_FUNC void parse_define(void)
 {
     Sym *s, *first, **ps;
     int v, t, varg, is_vaargs, spc;
 }
 /* is_bof is true if first non space token at beginning of file */
-static void preprocess(int is_bof)
+ST_FUNC void preprocess(int is_bof)
 {
     TCCState *s1 = tcc_state;
     int i, c, n, saved_parse_flags;
             pstrcpy(f->inc_filename, sizeof(f->inc_filename), buf1);
             file = f;
             /* add include file debug info */
-            if (tcc_state->do_debug) {
+            if (s1->do_debug) {
                 put_stabs(file->filename, N_BINCL, 0, 0, 0);
             }
             tok_flags |= TOK_FLAG_BOF | TOK_FLAG_BOL;
 #define BN_SIZE 2
 /* bn = (bn << shift) | or_val */
-void bn_lshift(unsigned int *bn, int shift, int or_val)
+static void bn_lshift(unsigned int *bn, int shift, int or_val)
 {
     int i;
     unsigned int v;
     }
 }
-void bn_zero(unsigned int *bn)
+static void bn_zero(unsigned int *bn)
 {
     int i;
     for(i=0;i<BN_SIZE;i++) {
 /* parse number in null terminated string 'p' and return it in the
    current token */
-void parse_number(const char *p)
+static void parse_number(const char *p)
 {
     int b, t, shift, frac_bits, s, exp_val, ch;
     char *q;
     }
 }
-static void next_nomacro(void)
+ST_FUNC void next_nomacro(void)
 {
     do {
         next_nomacro_spc();
 }
 /* return next token with macro substitution */
-static void next(void)
+ST_FUNC void next(void)
 {
     Sym *nested_list, *s;
     TokenString str;
 /* push back current token and set current token to 'last_tok'. Only
    identifier case handled for labels. */
-static inline void unget_tok(int last_tok)
+ST_INLN void unget_tok(int last_tok)
 {
     int i, n;
     int *q;
 /* better than nothing, but needs extension to handle '-E' option
    correctly too */
-static void preprocess_init(TCCState *s1)
+ST_FUNC void preprocess_init(TCCState *s1)
 {
     s1->include_stack_ptr = s1->include_stack;
     /* XXX: move that before to avoid having to initialize
     s1->pack_stack_ptr = s1->pack_stack;
 }
-void preprocess_new()
+ST_FUNC void preprocess_new()
 {
     int i, c;
     const char *p, *r;
 }
 /* Preprocess the current file */
-static int tcc_preprocess(TCCState *s1)
+ST_FUNC int tcc_preprocess(TCCState *s1)
 {
     Sym *define_start;
     BufferedFile *file_ref, **iptr, **iptr_new;
     int token_seen, line_ref, d;
     const char *s;
     token_seen = 0;
     line_ref = 0;
     file_ref = NULL;
     iptr = s1->include_stack_ptr;
     for (;;) {
         next();
         if (tok == TOK_EOF) {
         }
         fputs(get_tok_str(tok, &tokc), s1->outfile);
     }
     free_defines(define_start);
     return 0;
 }

tccrun.c+22−21

 /*
- *  TCC - Tiny C Compiler
+ *  TCC - Tiny C Compiler - Support for -run switch
  *
  *  Copyright (c) 2001-2004 Fabrice Bellard
  *
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-/* tccrun.c - support for tcc -run */
+#include "tcc.h"
 #ifdef _WIN32
 #define ucontext_t CONTEXT
 static void set_pages_executable(void *ptr, unsigned long length);
 static void set_exception_handler(void);
-static int rt_get_caller_pc(unsigned long *paddr, ucontext_t *uc, int level);
+static int rt_get_caller_pc(uplong *paddr, ucontext_t *uc, int level);
 static void rt_error(ucontext_t *uc, const char *fmt, ...);
 static int tcc_relocate_ex(TCCState *s1, void *ptr);
     VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old_protect);
 #else
     unsigned long start, end;
-    start = (unsigned long)ptr & ~(PAGESIZE - 1);
+    start = (uplong)ptr & ~(PAGESIZE - 1);
-    end = (unsigned long)ptr + length;
+    end = (uplong)ptr + length;
     end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
     mprotect((void *)start, end - start, PROT_READ | PROT_WRITE | PROT_EXEC);
 #endif
 /* print the position in the source file of PC value 'pc' by reading
    the stabs debug information */
-static unsigned long rt_printline(unsigned long wanted_pc)
+static uplong rt_printline(uplong wanted_pc)
 {
     Stab_Sym *sym, *sym_end;
     char func_name[128], last_func_name[128];
     int incl_index, len, last_line_num, i;
     const char *str, *p;
-    fprintf(stderr, "0x%08lx:", wanted_pc);
+    fprintf(stderr, "0x%08lx:", (unsigned long)wanted_pc);
     func_name[0] = '\0';
     func_addr = 0;
 static void rt_error(ucontext_t *uc, const char *fmt, ...)
 {
     va_list ap;
-    unsigned long pc;
+    uplong pc;
     int i;
     va_start(ap, fmt);
         else
             fprintf(stderr, "by ");
         pc = rt_printline(pc);
-        if (pc == (unsigned long)rt_prog_main && pc)
+        if (pc == (uplong)rt_prog_main && pc)
             break;
     }
     exit(255);
     SetUnhandledExceptionFilter(cpu_exception_handler);
 }
+#ifdef _WIN64
+#define Eip Rip
+#define Ebp Rbp
+#endif
 /* return the PC at frame level 'level'. Return non zero if not found */
-static int rt_get_caller_pc(unsigned long *paddr,
+static int rt_get_caller_pc(uplong *paddr, CONTEXT *uc, int level)
-			    CONTEXT *uc, int level)
 {
-    unsigned long fp;
+    uplong fp;
     int i;
     if (level == 0) {
 	    /* XXX: check address validity with program info */
 	    if (fp <= 0x1000 || fp >= 0xc0000000)
 		return -1;
-	    fp = ((unsigned long *)fp)[0];
+	    fp = ((uplong*)fp)[0];
 	}
-	*paddr = ((unsigned long *)fp)[1];
+	*paddr = ((uplong*)fp)[1];
 	return 0;
     }
 }
+#undef Eip
+#undef Ebp
 #endif /* _WIN32 */
 #endif /* CONFIG_TCC_BACKTRACE */
 /* ------------------------------------------------------------- */
     return NULL;
 }
-#elif defined(_WIN32)
+#elif !defined(_WIN32)
-#define dlclose FreeLibrary
-#else
-#include <dlfcn.h>
 void *resolve_sym(TCCState *s1, const char *sym)
 {

x86_64-gen.c+24−14

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-#include <assert.h>
+#ifdef TARGET_DEFS_ONLY
 /* number of available registers */
-#define NB_REGS             5
+#define NB_REGS         5
+#define NB_ASM_REGS     8
 /* a register can belong to several classes. The classes must be
    sorted from more general to more precise (see gv2() code which does
 #define REX_BASE(reg) (((reg) >> 3) & 1)
 #define REG_VALUE(reg) ((reg) & 7)
-const int reg_classes[NB_REGS] = {
-    /* eax */ RC_INT | RC_RAX,
-    /* ecx */ RC_INT | RC_RCX,
-    /* edx */ RC_INT | RC_RDX,
-    /* xmm0 */ RC_FLOAT | RC_XMM0,
-    /* st0 */ RC_ST0,
-};
 /* return registers for function */
 #define REG_IRET TREG_RAX /* single word int return register */
 #define REG_LRET TREG_RDX /* second word return register (for long long) */
 /* maximum alignment (for aligned attribute support) */
 #define MAX_ALIGN     8
+ST_FUNC void gen_opl(int op);
+ST_FUNC void gen_le64(int64_t c);
 /******************************************************/
 /* ELF defines */
 #define ELF_PAGE_SIZE  0x1000
 /******************************************************/
+#else /* ! TARGET_DEFS_ONLY */
+/******************************************************/
+#include "tcc.h"
+#include <assert.h>
+ST_DATA const int reg_classes[NB_REGS] = {
+    /* eax */ RC_INT | RC_RAX,
+    /* ecx */ RC_INT | RC_RCX,
+    /* edx */ RC_INT | RC_RDX,
+    /* xmm0 */ RC_FLOAT | RC_XMM0,
+    /* st0 */ RC_ST0,
+};
 static unsigned long func_sub_sp_offset;
 static int func_ret_sub;
 }
 /* instruction + 4 bytes data. Return the address of the data */
-static int oad(int c, int s)
+ST_FUNC int oad(int c, int s)
 {
     int ind1;
     return s;
 }
-static void gen_addr32(int r, Sym *sym, int c)
+ST_FUNC void gen_addr32(int r, Sym *sym, int c)
 {
     if (r & VT_SYM)
         greloc(cur_text_section, sym, ind, R_X86_64_32);
 }
 /* output constant with relocation if 'r & VT_SYM' is true */
-static void gen_addr64(int r, Sym *sym, int64_t c)
+ST_FUNC void gen_addr64(int r, Sym *sym, int64_t c)
 {
     if (r & VT_SYM)
         greloc(cur_text_section, sym, ind, R_X86_64_64);
 }
 /* output constant with relocation if 'r & VT_SYM' is true */
-static void gen_addrpc32(int r, Sym *sym, int c)
+ST_FUNC void gen_addrpc32(int r, Sym *sym, int c)
 {
     if (r & VT_SYM)
         greloc(cur_text_section, sym, ind, R_X86_64_PC32);
 /* end of x86-64 code generator */
 /*************************************************************/
+#endif /* ! TARGET_DEFS_ONLY */
+/******************************************************/

allow tcc be build from separate objects

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code