Fix some code suppression fallout

Some more subtle issues with code suppression: - outputting asms but not their operand setup is broken - but global asms must always be output - statement expressions are transparent to code suppression - vtop can't be transformed from VT_CMP/VT_JMP when nocode_wanted Also remove .exe files from tests2 if they don't fail.

Michael Matz committed 9 years ago

Commit 42e2a671 parent 559ee1e8 files · +138 −20Browse files

Unified · Split

8 files

tccasm.c +16 −16
tccgen.c +16 −3
tests/tcctest.c +32 −0
tests/tests2/85-asm-outside-function.c +2 −0
tests/tests2/85-asm-outside-function.expect +1 −0
tests/tests2/88_codeopt.c +68 −0
tests/tests2/88_codeopt.expect +2 −0
tests/tests2/Makefile +1 −1

tccasm.c+16−16

 }
 ST_FUNC void asm_expr(TCCState *s1, ExprValue *pe);
-static int tcc_assemble_internal(TCCState *s1, int do_preprocess);
+static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global);
 static Sym sym_dot;
 /* Return a symbol we can use inside the assembler, having name NAME.
     use_section1(s1, prev);
 }
-static void asm_parse_directive(TCCState *s1)
+static void asm_parse_directive(TCCState *s1, int global)
 {
     int n, offset, v, size, tok1;
     Section *sec;
             save_parse_state(&saved_parse_state);
             begin_macro(init_str, 1);
             while (repeat-- > 0) {
-                tcc_assemble_internal(s1, (parse_flags & PARSE_FLAG_PREPROCESS));
+                tcc_assemble_internal(s1, (parse_flags & PARSE_FLAG_PREPROCESS),
+				      global);
                 macro_ptr = init_str->str;
             }
             end_macro();
 /* assemble a file */
-static int tcc_assemble_internal(TCCState *s1, int do_preprocess)
+static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global)
 {
-    int saved_nocode_wanted;
     int opcode;
-    saved_nocode_wanted = nocode_wanted;
-    nocode_wanted = 0;
     /* XXX: undefine C labels */
     ch = file->buf_ptr[0];
             while (tok != TOK_LINEFEED)
                 next();
         } else if (tok >= TOK_ASMDIR_FIRST && tok <= TOK_ASMDIR_LAST) {
-            asm_parse_directive(s1);
+            asm_parse_directive(s1, global);
         } else if (tok == TOK_PPNUM) {
 	    Sym *sym;
             const char *p;
                 /* handle "extern void vide(void); __asm__("vide: ret");" as
                 "__asm__("globl vide\nvide: ret");" */
                 Sym *sym = sym_find(opcode);
-                if (sym && (sym->type.t & VT_EXTERN) && saved_nocode_wanted) {
+                if (sym && (sym->type.t & VT_EXTERN) && global) {
                     sym = label_find(opcode);
                     if (!sym) {
                         sym = label_push(&s1->asm_labels, opcode, 0);
     asm_free_labels(s1);
-    nocode_wanted = saved_nocode_wanted;
     return 0;
 }
                 ELFW(ST_INFO)(STB_LOCAL, STT_FILE), 0,
                 SHN_ABS, file->filename);
-    ret = tcc_assemble_internal(s1, do_preprocess);
+    ret = tcc_assemble_internal(s1, do_preprocess, 1);
     cur_text_section->data_offset = ind;
 /* assemble the string 'str' in the current C compilation unit without
    C preprocessing. NOTE: str is modified by modifying the '\0' at the
    end */
-static void tcc_assemble_inline(TCCState *s1, char *str, int len)
+static void tcc_assemble_inline(TCCState *s1, char *str, int len, int global)
 {
     int saved_parse_flags;
     const int *saved_macro_ptr;
     memcpy(file->buffer, str, len);
     macro_ptr = NULL;
-    tcc_assemble_internal(s1, 0);
+    tcc_assemble_internal(s1, 0, global);
     tcc_close();
     parse_flags = saved_parse_flags;
                  clobber_regs, out_reg);
     /* assemble the string with tcc internal assembler */
-    tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1);
+    tcc_assemble_inline(tcc_state, astr1.data, astr1.size - 1, 0);
     /* restore the current C token */
     next();
 ST_FUNC void asm_global_instr(void)
 {
     CString astr;
+    int saved_nocode_wanted = nocode_wanted;
+    /* Global asm blocks are always emitted.  */
+    nocode_wanted = 0;
     next();
     parse_asm_str(&astr);
     skip(')');
     ind = cur_text_section->data_offset;
     /* assemble the string with tcc internal assembler */
-    tcc_assemble_inline(tcc_state, astr.data, astr.size - 1);
+    tcc_assemble_inline(tcc_state, astr.data, astr.size - 1, 1);
     cur_text_section->data_offset = ind;
     next();
     cstr_free(&astr);
+    nocode_wanted = saved_nocode_wanted;
 }
 #endif /* CONFIG_TCC_ASM */

tccgen.c+16−3

@@ -575,8 +575,16 @@ static void vsetc(CType type, int r, CValue vc) · 574 unmodified lines
575	tcc_error("memory full (vstack)");	575	tcc_error("memory full (vstack)");
576	/* cannot let cpu flags if other instruction are generated. Also	576	/* cannot let cpu flags if other instruction are generated. Also
577	avoid leaving VT_JMP anywhere except on the top of the stack	577	avoid leaving VT_JMP anywhere except on the top of the stack
578	because it would complicate the code generator. */	578	because it would complicate the code generator.
579	if (vtop >= vstack) {	579
		580	Don't do this when nocode_wanted. vtop might come from
		581	!nocode_wanted regions (see 88_codeopt.c) and transforming
		582	it to a register without actually generating code is wrong
		583	as their value might still be used for real. All values
		584	we push under nocode_wanted will eventually be popped
		585	again, so that the VT_CMP/VT_JMP value will be in vtop
		586	when code is unsuppressed again. */
		587	if (vtop >= vstack && !nocode_wanted) {
580	v = vtop->r & VT_VALMASK;	588	v = vtop->r & VT_VALMASK;
581	if (v == VT_CMP \|\| (v & ~1) == VT_JMP)	589	if (v == VT_CMP \|\| (v & ~1) == VT_JMP)
582	gv(RC_INT);	590	gv(RC_INT);
@@ -4367,13 +4375,18 @@ ST_FUNC void unary(void) · 3784 unmodified lines
4367	gen_cast(&type);	4375	gen_cast(&type);
4368	}	4376	}
4369	} else if (tok == '{') {	4377	} else if (tok == '{') {
		4378	int saved_nocode_wanted = nocode_wanted;
4370	if (const_wanted)	4379	if (const_wanted)
4371	tcc_error("expected constant");	4380	tcc_error("expected constant");
4372	/* save all registers */	4381	/* save all registers */
4373	save_regs(0);	4382	save_regs(0);
4374	/* statement expression : we do not accept break/continue	4383	/* statement expression : we do not accept break/continue
4375	inside as GCC does */	4384	inside as GCC does. We do retain the nocode_wanted state,
		4385	as statement expressions can't ever be entered from the
		4386	outside, so any reactivation of code emission (from labels
		4387	or loop heads) can be disabled again after the end of it. */
4376	block(NULL, NULL, 1);	4388	block(NULL, NULL, 1);
		4389	nocode_wanted = saved_nocode_wanted;
4377	skip(')');	4390	skip(')');
4378	} else {	4391	} else {
4379	gexpr();	4392	gexpr();

tests/tcctest.c+32−0

@@ -1404,6 +1404,15 @@ void optimize_out(void) · 1403 unmodified lines
1404	if (defined_function() && 0)	1404	if (defined_function() && 0)
1405	refer_to_undefined();	1405	refer_to_undefined();
1406		1406
		1407	if (0) {
		1408	(void)sizeof( ({
		1409	do { } while (0);
		1410	0;
		1411	}) );
		1412	undefined_function();
		1413	}
		1414
		1415	/* Leave the "if(1)return; printf()" in this order and last in the function */
1407	if (1)	1416	if (1)
1408	return;	1417	return;
1409	printf ("oor:%d\n", undefined_function());	1418	printf ("oor:%d\n", undefined_function());
@@ -3251,6 +3260,28 @@ void trace_console(long len, long len2) · 1841 unmodified lines
3251	}	3260	}
3252	#endif	3261	#endif
3253	}	3262	}
		3263
		3264	void test_asm_dead_code(void)
		3265	{
		3266	long rdi;
		3267	/* Try to make sure that xdi contains a zero, and hence will
		3268	lead to a segfault if the next asm is evaluated without
		3269	arguments being set up. */
		3270	asm volatile ("" : "=D" (rdi) : "0" (0));
		3271	(void)sizeof (({
		3272	int var;
		3273	/* This shouldn't trigger a segfault, either the argument
		3274	registers need to be set up and the asm emitted despite
		3275	this being in an unevaluated context, or both the argument
		3276	setup _and_ the asm emission need to be suppressed. The latter
		3277	is better. Disabling asm code gen when suppression is on
		3278	also fixes the above trace_console bug, but that came earlier
		3279	than asm suppression. */
		3280	asm volatile ("movl $0,(%0)" : : "D" (&var) : "memory");
		3281	var;
		3282	}));
		3283	}
		3284
3254	void asm_test(void)	3285	void asm_test(void)
3255	{	3286	{
3256	char buf[128];	3287	char buf[128];
@@ -3334,6 +3365,7 @@ void asm_test(void) · 77 unmodified lines
3334	printf ("regvar=%x\n", regvar);	3365	printf ("regvar=%x\n", regvar);
3335	test_high_clobbers();	3366	test_high_clobbers();
3336	trace_console(8, 8);	3367	trace_console(8, 8);
		3368	test_asm_dead_code();
3337	return;	3369	return;
3338	label1:	3370	label1:
3339	goto label2;	3371	goto label2;

tests/tests2/85-asm-outside-function.c+2−0

+extern int printf (const char *, ...);
 extern void vide(void);
 __asm__("vide: ret");
 int main() {
     vide();
+    printf ("okay\n");
     return 0;
 }

tests/tests2/85-asm-outside-function.expect+1−0

@@ -0,0 +1 @@
		1	okay

tests/tests2/88_codeopt.c+68−0

@@ -0,0 +1,68 @@
	1	/* Check some way in where code suppression caused various
	2	miscompilations. */
	3	extern int printf (const char *, ...);
	4	typedef unsigned long size_t;
	5
	6	size_t _brk_start, _brk_end;
	7	void * extend_brk(size_t size, size_t align)
	8	{
	9	size_t mask = align - 1;
	10	void *ret = 0;
	11
	12	do {
	13	if (__builtin_expect(!!(_brk_start == 0), 0))
	14	do {
	15	printf("wrong1\n");
	16	} while (0);
	17	} while (0);
	18	_brk_end = (_brk_end + mask) & ~mask;
	19	ret = (void *)_brk_end;
	20	_brk_end += size;
	21
	22	return ret;
	23	}
	24
	25	static void get_args (int a, int b)
	26	{
	27	if (a != 1)
	28	printf("wrong2\n");
	29	else
	30	printf("okay\n");
	31	}
	32
	33	void bla(void)
	34	{
	35	int __ret = 42;
	36	({
	37	if (__builtin_expect(!!(0), 0)) {
	38	if (__builtin_expect(!!__ret, 0))
	39	printf("wrong3\n");
	40	int x = !!(__ret);
	41	}
	42	__ret;
	43	});
	44	get_args(!!__ret, sizeof(__ret));
	45	}
	46
	47	_Bool chk(unsigned long addr, unsigned long limit, unsigned long size)
	48	{
	49	_Bool ret;
	50	/* This just needs to compile, no runtime test. (And it doesn't compile
	51	only with certain internal checking added that's not committed). */
	52	if (0)
	53	ret = 0 != (!!(addr > limit - size));
	54	}
	55
	56	int main()
	57	{
	58	void *r;
	59	_brk_start = 1024;
	60	_brk_end = 1024;
	61	r = extend_brk (4096, 16);
	62	if (!r)
	63	printf("wrong4\n");
	64	else
	65	printf("okay\n");
	66	bla();
	67	return 0;
	68	}

tests/tests2/88_codeopt.expect+2−0

@@ -0,0 +1,2 @@
	1	okay
	2	okay

tests/tests2/Makefile+1−1

@@ -59,7 +59,7 @@ all test: $(filter-out $(SKIP),$(TESTS)) · 58 unmodified lines
59	$(TCC) $< -o ./$*.exe $(FILTER) 2>&1 && \	59	$(TCC) $< -o ./$*.exe $(FILTER) 2>&1 && \
60	./$.exe $(ARGS) >$.output 2>&1 \|\| true; \	60	./$.exe $(ARGS) >$.output 2>&1 \|\| true; \
61	fi	61	fi
62	@diff -Nbu $(SRC)/$.expect $.output && rm -f $*.output	62	@diff -Nbu $(SRC)/$.expect $.output && rm -f $.output $.exe
63		63
64	# automatically generate .expect files with gcc:	64	# automatically generate .expect files with gcc:
65	%.expect : %.c	65	%.expect : %.c

Fix some code suppression fallout

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code