sigrid/tinycc

Makefile+7−16

 LIBTCC = libtcc.a
 LIBTCC1 = libtcc1.a
-LIBTCCB1 = libtccb1.a
 LINK_LIBTCC =
 LIBS =
 CFLAGS += -I$(TOP)
 # running top Makefile
 PROGS = tcc$(EXESUF)
-TCCLIBS = $(LIBTCC1) $(LIBTCCB1) $(LIBTCC) $(LIBTCCDEF)
+TCCLIBS = $(LIBTCC1) $(LIBTCC) $(LIBTCCDEF)
 TCCDOCS = tcc.1 tcc-doc.html tcc-doc.info
 all: $(PROGS) $(TCCLIBS) $(TCCDOCS)
 LIBTCC1_X = i386 x86_64 i386-win32 x86_64-win32 x86_64-osx arm arm64 arm-wince
 LIBTCC1_X += riscv64
-# cross libtccb1.a targets to build
-LIBTCCB1_X = i386 x86_64 i386-win32 x86_64-win32
 PROGS_CROSS = $(foreach X,$(TCC_X),$X-tcc$(EXESUF))
 LIBTCC1_CROSS = $(foreach X,$(LIBTCC1_X),$X-libtcc1.a)
-LIBTCCB1_CROSS = $(foreach X,$(LIBTCCB1_X),$X-libtcc1.a)
 # build cross compilers & libs
-cross: $(LIBTCC1_CROSS) $(LIBTCCB1_CROSS) $(PROGS_CROSS)
+cross: $(LIBTCC1_CROSS) $(PROGS_CROSS)
 # build specific cross compiler & lib
 cross-%: %-tcc$(EXESUF) %-libtcc1.a ;
 ifneq ($(X),)
 ifeq ($(CONFIG_WIN32),yes)
-DEF-win += -DTCC_LIBTCC1="\"$(X)libtcc1.a\"" -DTCC_LIBTCCB1="\"$(X)libtccb1.a\""
+DEF-win += -DTCC_LIBTCC1="\"$(X)libtcc1.a\""
-DEF-unx += -DTCC_LIBTCC1="\"lib/$(X)libtcc1.a\"" -DTCC_LIBTCCB1="\"lib/$(X)libtccb1.a\""
+DEF-unx += -DTCC_LIBTCC1="\"lib/$(X)libtcc1.a\""
 else
-DEF-all += -DTCC_LIBTCC1="\"$(X)libtcc1.a\"" -DTCC_LIBTCCB1="\"$(X)libtccb1.a\""
+DEF-all += -DTCC_LIBTCC1="\"$(X)libtcc1.a\""
 DEF-win += -DCONFIG_TCCDIR="\"$(tccdir)/win32\""
 endif
 endif
 LIBTCC1_W = $(filter %-win32-libtcc1.a %-wince-libtcc1.a,$(LIBTCC1_CROSS))
 LIBTCC1_U = $(filter-out $(LIBTCC1_W),$(LIBTCC1_CROSS))
-LIBTCCB1_W = $(filter %-win32-libtccb1.a %-wince-libtccb1.a,$(LIBTCCB1_CROSS))
-LIBTCCB1_U = $(filter-out $(LIBTCCB1_W),$(LIBTCCB1_CROSS))
 IB = $(if $1,mkdir -p $2 && $(INSTALLBIN) $1 $2)
 IBw = $(call IB,$(wildcard $1),$2)
 IF = $(if $1,mkdir -p $2 && $(INSTALL) $1 $2)
 # install progs & libs
 install-unx:
 	$(call IBw,$(PROGS) $(PROGS_CROSS),"$(bindir)")
-	$(call IFw,$(LIBTCC1) $(LIBTCC1_U),"$(tccdir)")
+	$(call IFw,$(LIBTCC1) bcheck.o $(LIBTCC1_U),"$(tccdir)")
-	$(call IFw,$(LIBTCCB1) $(LIBTCCB1_U),"$(tccdir)")
 	$(call IF,$(TOPSRC)/include/*.h $(TOPSRC)/tcclib.h,"$(tccdir)/include")
 	$(call $(if $(findstring .so,$(LIBTCC)),IBw,IFw),$(LIBTCC),"$(libdir)")
 	$(call IF,$(TOPSRC)/libtcc.h,"$(includedir)")
 install-win:
 	$(call IBw,$(PROGS) $(PROGS_CROSS) $(subst libtcc.a,,$(LIBTCC)),"$(bindir)")
 	$(call IF,$(TOPSRC)/win32/lib/*.def,"$(tccdir)/lib")
-	$(call IFw,libtcc1.a $(LIBTCC1_W),"$(tccdir)/lib")
+	$(call IFw,libtcc1.a bcheck.o $(LIBTCC1_W),"$(tccdir)/lib")
-	$(call IFw,libtccb1.a $(LIBTCCB1_W),"$(tccdir)/lib")
 	$(call IF,$(TOPSRC)/include/*.h $(TOPSRC)/tcclib.h,"$(tccdir)/include")
 	$(call IR,$(TOPSRC)/win32/include,"$(tccdir)/include")
 	$(call IR,$(TOPSRC)/win32/examples,"$(tccdir)/examples")

i386-gen.c+23−115

@@ -425,6 +425,11 @@ ST_FUNC void gfunc_call(int nb_args) · 424 unmodified lines
425	int size, align, r, args_size, i, func_call;	425	int size, align, r, args_size, i, func_call;
426	Sym *func_sym;	426	Sym *func_sym;
427		427
		428	#ifdef CONFIG_TCC_BCHECK
		429	if (tcc_state->do_bounds_check)
		430	gbound_args(nb_args);
		431	#endif
		432
428	args_size = 0;	433	args_size = 0;
429	for(i = 0;i < nb_args; i++) {	434	for(i = 0;i < nb_args; i++) {
430	if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {	435	if ((vtop->type.t & VT_BTYPE) == VT_STRUCT) {
@@ -1051,119 +1056,18 @@ ST_FUNC void ggoto(void) · 620 unmodified lines
1051		1056
1052	/* bound check support functions */	1057	/* bound check support functions */
1053	#ifdef CONFIG_TCC_BCHECK	1058	#ifdef CONFIG_TCC_BCHECK
1054
1055	ST_FUNC void tcc_add_bcheck(TCCState s1, Section bound_sec, Section *sym_sec)
1056	{
1057	addr_t *ptr;
1058	int loc_glob;
1059	int sym_index;
1060	int bsym_index;
1061
1062	if (0 == s1->do_bounds_check)
1063	return;
1064	/* XXX: add an object file to do that */
1065	ptr = section_ptr_add(bound_sec, sizeof(*ptr));
1066	*ptr = 0;
1067	loc_glob = s1->output_type != TCC_OUTPUT_MEMORY ? STB_LOCAL : STB_GLOBAL;
1068	bsym_index = set_elf_sym(sym_sec, 0, 0,
1069	ELFW(ST_INFO)(loc_glob, STT_NOTYPE), 0,
1070	bound_sec->sh_num, "__bounds_start");
1071	/* pull bcheck.o from libtcc1.a */
1072	sym_index = set_elf_sym(sym_sec, 0, 0,
1073	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1074	SHN_UNDEF, "__bound_init");
1075	if (s1->output_type != TCC_OUTPUT_MEMORY) {
1076	/* add 'call __bound_init()' in .init section */
1077	Section *init_section = find_section(s1, ".init");
1078	unsigned char *pinit;
1079	#ifdef TCC_TARGET_PE
1080	pinit = section_ptr_add(init_section, 3);
1081	pinit[0] = 0x55; /* push %rbp */
1082	pinit[1] = 0x89; /* mov %esp,%ebp */
1083	pinit[2] = 0xe5;
1084	#endif
1085	pinit = section_ptr_add(init_section, 5);
1086	pinit[0] = 0xe8;
1087	write32le(pinit + 1, -4);
1088	put_elf_reloc(sym_sec, init_section,
1089	init_section->data_offset - 4, R_386_PC32, sym_index);
1090	/* R_386_PC32 = R_X86_64_PC32 = 2 */
1091	pinit = section_ptr_add(init_section, 6);
1092	pinit[0] = 0xb8; /* mov xx,%eax */
1093	write32le(pinit + 1, 0);
1094	pinit[5] = 0x50; /* push %eax */
1095	put_elf_reloc(sym_sec, init_section,
1096	init_section->data_offset - 5, R_386_32, bsym_index);
1097	sym_index = set_elf_sym(sym_sec, 0, 0,
1098	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1099	SHN_UNDEF, "__bounds_add_static_var");
1100	pinit = section_ptr_add(init_section, 5);
1101	pinit[0] = 0xe8;
1102	write32le(pinit + 1, -4);
1103	put_elf_reloc(sym_sec, init_section,
1104	init_section->data_offset - 4, R_386_PC32, sym_index);
1105	/* R_386_PC32 = R_X86_64_PC32 = 2 */
1106	pinit = section_ptr_add(init_section, 3);
1107	pinit[0] = 0x83; /* add $0x4,%esp */
1108	pinit[1] = 0xc4;
1109	pinit[2] = 0x04;
1110	#ifdef TCC_TARGET_PE
1111	{
1112	int init_index = set_elf_sym(sym_sec,
1113	0, 0,
1114	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
1115	init_section->sh_num, "__init_start");
1116	Sym sym;
1117	init_section->sh_flags \|= SHF_EXECINSTR;
1118	pinit = section_ptr_add(init_section, 2);
1119	pinit[0] = 0xc9; /* leave */
1120	pinit[1] = 0xc3; /* ret */
1121	sym.c = init_index;
1122	add_init_array (s1, &sym);
1123	}
1124	#endif
1125	}
1126	}
1127
1128	/* generate a bounded pointer addition */	1059	/* generate a bounded pointer addition */
1129	ST_FUNC void gen_bounded_ptr_add(void)	1060	ST_FUNC void gen_bounded_ptr_add(void)
1130	{	1061	{
1131	/* save all temporary registers */	1062	vpush_global_sym(&func_old_type, TOK___bound_ptr_add);
1132	save_regs(0);	1063	vrott(3);
1133	/* prepare fast i386 function call (args in eax and edx) */	1064	gfunc_call(2);
1134	gv2(RC_EAX, RC_EDX);	1065	vpushi(0);
1135	vtop -= 2;
1136	/* add line, filename */
1137	{
1138	static addr_t offset;
1139	static char last_filename[1024];
1140	Sym *sym_data;
1141
1142	if (strcmp (last_filename, file->filename) != 0) {
1143	void *ptr;
1144	int len = strlen (file->filename) + 1;
1145
1146	offset = data_section->data_offset;
1147	ptr = section_ptr_add(data_section, len);
1148	memcpy (ptr, file->filename, len);
1149	memcpy (last_filename, file->filename, len);
1150	}
1151	o(0xb9); /* mov $xx,%ecx */
1152	gen_le32 (0);
1153	sym_data = get_sym_ref(&char_pointer_type, data_section,
1154	offset, data_section->data_offset);
1155	greloca(cur_text_section, sym_data, ind - 4, R_386_32, 0);
1156	o(0x51); /* push %ecx */
1157	}
1158	o(0xb9); /* mov $xx,%ecx */
1159	gen_le32 (file->line_num);
1160	/* do a fast function call */
1161	gen_static_call(TOK___bound_ptr_add);
1162	o(0x04c483); /* add $4,%esp */
1163	/* returned pointer is in eax */	1066	/* returned pointer is in eax */
1164	vtop++;
1165	vtop->r = TREG_EAX \| VT_BOUNDED;	1067	vtop->r = TREG_EAX \| VT_BOUNDED;
1166	/* address of bounding function call point */	1068	if (nocode_wanted)
		1069	return;
		1070	/* relocation offset of the bounding function call point */
1167	vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));	1071	vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(Elf32_Rel));
1168	}	1072	}
1169		1073
@@ -1176,6 +1080,9 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 6 unmodified lines
1176	Elf32_Rel *rel;	1080	Elf32_Rel *rel;
1177	Sym *sym;	1081	Sym *sym;
1178		1082
		1083	if (nocode_wanted)
		1084	return;
		1085
1179	size = 0;	1086	size = 0;
1180	/* XXX: put that code in generic part of tcc */	1087	/* XXX: put that code in generic part of tcc */
1181	if (!is_float(vtop->type.t)) {	1088	if (!is_float(vtop->type.t)) {
@@ -1194,17 +1101,18 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 12 unmodified lines
1194	case 12: func = TOK___bound_ptr_indir12; break;	1101	case 12: func = TOK___bound_ptr_indir12; break;
1195	case 16: func = TOK___bound_ptr_indir16; break;	1102	case 16: func = TOK___bound_ptr_indir16; break;
1196	default:	1103	default:
1197	tcc_error("unhandled size when dereferencing bounded pointer");	1104	/* may happen with struct member access */
1198	func = 0;	1105	return;
1199	break;	1106	//tcc_error("unhandled size when dereferencing bounded pointer");
		1107	//func = 0;
		1108	//break;
1200	}	1109	}
1201
1202	/* patch relocation */
1203	/* XXX: find a better solution ? */
1204	rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.i);
1205	sym = external_global_sym(func, &func_old_type);	1110	sym = external_global_sym(func, &func_old_type);
1206	if (!sym->c)	1111	if (!sym->c)
1207	put_extern_sym(sym, NULL, 0, 0);	1112	put_extern_sym(sym, NULL, 0, 0);
		1113	/* patch relocation */
		1114	/* XXX: find a better solution ? */
		1115	rel = (Elf32_Rel *)(cur_text_section->reloc->data + vtop->c.i);
1208	rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));	1116	rel->r_info = ELF32_R_INFO(sym->c, ELF32_R_TYPE(rel->r_info));
1209	}	1117	}
1210	#endif	1118	#endif

i386-link.c+75−0

@@ -235,4 +235,79 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 234 unmodified lines
235	}	235	}
236	}	236	}
237		237
		238	#ifdef CONFIG_TCC_BCHECK
		239	ST_FUNC void tcc_add_bcheck(TCCState *s1)
		240	{
		241	addr_t *ptr;
		242	int loc_glob;
		243	int sym_index;
		244	int bsym_index;
		245
		246	if (0 == s1->do_bounds_check)
		247	return;
		248	/* XXX: add an object file to do that */
		249	ptr = section_ptr_add(bounds_section, sizeof(*ptr));
		250	*ptr = 0;
		251	loc_glob = s1->output_type != TCC_OUTPUT_MEMORY ? STB_LOCAL : STB_GLOBAL;
		252	bsym_index = set_elf_sym(symtab_section, 0, 0,
		253	ELFW(ST_INFO)(loc_glob, STT_NOTYPE), 0,
		254	bounds_section->sh_num, "__bounds_start");
		255	/* pull bcheck.o from libtcc1.a */
		256	sym_index = set_elf_sym(symtab_section, 0, 0,
		257	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		258	SHN_UNDEF, "__bound_init");
		259	if (s1->output_type != TCC_OUTPUT_MEMORY) {
		260	/* add 'call __bound_init()' in .init section */
		261	Section *init_section = find_section(s1, ".init");
		262	unsigned char *pinit;
		263	#ifdef TCC_TARGET_PE
		264	pinit = section_ptr_add(init_section, 3);
		265	pinit[0] = 0x55; /* push %rbp */
		266	pinit[1] = 0x89; /* mov %esp,%ebp */
		267	pinit[2] = 0xe5;
		268	#endif
		269	pinit = section_ptr_add(init_section, 5);
		270	pinit[0] = 0xe8;
		271	write32le(pinit + 1, -4);
		272	put_elf_reloc(symtab_section, init_section,
		273	init_section->data_offset - 4, R_386_PC32, sym_index);
		274	/* R_386_PC32 = R_X86_64_PC32 = 2 */
		275	pinit = section_ptr_add(init_section, 6);
		276	pinit[0] = 0xb8; /* mov xx,%eax */
		277	write32le(pinit + 1, 0);
		278	pinit[5] = 0x50; /* push %eax */
		279	put_elf_reloc(symtab_section, init_section,
		280	init_section->data_offset - 5, R_386_32, bsym_index);
		281	sym_index = set_elf_sym(symtab_section, 0, 0,
		282	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		283	SHN_UNDEF, "__bounds_add_static_var");
		284	pinit = section_ptr_add(init_section, 5);
		285	pinit[0] = 0xe8;
		286	write32le(pinit + 1, -4);
		287	put_elf_reloc(symtab_section, init_section,
		288	init_section->data_offset - 4, R_386_PC32, sym_index);
		289	/* R_386_PC32 = R_X86_64_PC32 = 2 */
		290	pinit = section_ptr_add(init_section, 3);
		291	pinit[0] = 0x83; /* add $0x4,%esp */
		292	pinit[1] = 0xc4;
		293	pinit[2] = 0x04;
		294	#ifdef TCC_TARGET_PE
		295	{
		296	int init_index = set_elf_sym(symtab_section,
		297	0, 0,
		298	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		299	init_section->sh_num, "__init_start");
		300	Sym sym;
		301	init_section->sh_flags \|= SHF_EXECINSTR;
		302	pinit = section_ptr_add(init_section, 2);
		303	pinit[0] = 0xc9; /* leave */
		304	pinit[1] = 0xc3; /* ret */
		305	sym.c = init_index;
		306	add_init_array (s1, &sym);
		307	}
		308	#endif
		309	}
		310	}
		311	#endif
		312
238	#endif /* !TARGET_DEFS_ONLY */	313	#endif /* !TARGET_DEFS_ONLY */

lib/Makefile+17−32

@@ -7,8 +7,6 @@ include $(TOP)/Makefile · 6 unmodified lines
7	VPATH = $(TOPSRC)/lib $(TOPSRC)/win32/lib	7	VPATH = $(TOPSRC)/lib $(TOPSRC)/win32/lib
8	T = $(or $(CROSS_TARGET),$(NATIVE_TARGET),unknown)	8	T = $(or $(CROSS_TARGET),$(NATIVE_TARGET),unknown)
9	X = $(if $(CROSS_TARGET),$(CROSS_TARGET)-)	9	X = $(if $(CROSS_TARGET),$(CROSS_TARGET)-)
10	BIN = $(TOP)/$(X)libtcc1.a
11	BINB = $(TOP)/$(X)libtccb1.a
12		10
13	XTCC ?= $(TOP)/$(X)tcc$(EXESUF)	11	XTCC ?= $(TOP)/$(X)tcc$(EXESUF)
14	XCC = $(XTCC)	12	XCC = $(XTCC)
@@ -20,8 +18,6 @@ XCFG = $(or $(findstring -win,$T),-unx) · 5 unmodified lines
20		18
21	# in order to use gcc, tyoe: make <target>-libtcc1-usegcc=yes	19	# in order to use gcc, tyoe: make <target>-libtcc1-usegcc=yes
22	arm-libtcc1-usegcc ?= no	20	arm-libtcc1-usegcc ?= no
23	x86_64-libtcc1-usegcc ?= no
24	i386-libtcc1-usegcc ?= no
25		21
26	ifeq "$($(T)-libtcc1-usegcc)" "yes"	22	ifeq "$($(T)-libtcc1-usegcc)" "yes"
27	XCC = $(CC)	23	XCC = $(CC)
@@ -42,8 +38,6 @@ ifdef CONFIG_OSX · 14 unmodified lines
42	XFLAGS += -D_ANSI_SOURCE	38	XFLAGS += -D_ANSI_SOURCE
43	endif	39	endif
44		40
45	XFLAGS += -g
46
47	I386_O = libtcc1.o alloca86.o alloca86-bt.o	41	I386_O = libtcc1.o alloca86.o alloca86-bt.o
48	X86_64_O = libtcc1.o alloca86_64.o alloca86_64-bt.o	42	X86_64_O = libtcc1.o alloca86_64.o alloca86_64-bt.o
49	ARM_O = libtcc1.o armeabi.o alloca-arm.o armflush.o	43	ARM_O = libtcc1.o armeabi.o alloca-arm.o armflush.o
@@ -51,11 +45,11 @@ ARM64_O = lib-arm64.o · 1 unmodified line
51	RISCV64_O = lib-arm64.o	45	RISCV64_O = lib-arm64.o
52	WIN_O = crt1.o crt1w.o wincrt1.o wincrt1w.o dllcrt1.o dllmain.o	46	WIN_O = crt1.o crt1w.o wincrt1.o wincrt1w.o dllcrt1.o dllmain.o
53		47
54	OBJ-i386 = $(I386_O) $(DSO_O)	48	OBJ-i386 = $(I386_O) $(BCHECK_O) $(DSO_O)
55	OBJ-x86_64 = $(X86_64_O) va_list.o $(DSO_O)	49	OBJ-x86_64 = $(X86_64_O) va_list.o $(BCHECK_O) $(DSO_O)
56	OBJ-x86_64-osx = $(X86_64_O) va_list.o	50	OBJ-x86_64-osx = $(X86_64_O) va_list.o
57	OBJ-i386-win32 = $(I386_O) chkstk.o $(WIN_O)	51	OBJ-i386-win32 = $(I386_O) chkstk.o bcheck.o $(WIN_O)
58	OBJ-x86_64-win32 = $(X86_64_O) chkstk.o (WIN_O)	52	OBJ-x86_64-win32 = $(X86_64_O) chkstk.o bcheck.o $(WIN_O)
59	OBJ-arm64 = $(ARM64_O) $(DSO_O)	53	OBJ-arm64 = $(ARM64_O) $(DSO_O)
60	OBJ-arm = $(ARM_O) $(DSO_O)	54	OBJ-arm = $(ARM_O) $(DSO_O)
61	OBJ-arm-fpa = $(ARM_O) $(DSO_O)	55	OBJ-arm-fpa = $(ARM_O) $(DSO_O)
@@ -66,27 +60,14 @@ OBJ-arm-eabihf = $(ARM_O) $(DSO_O) · 4 unmodified lines
66	OBJ-arm-wince = $(ARM_O) $(WIN_O)	60	OBJ-arm-wince = $(ARM_O) $(WIN_O)
67	OBJ-riscv64 = $(RISCV64_O) $(DSO_O)	61	OBJ-riscv64 = $(RISCV64_O) $(DSO_O)
68		62
69	OBJB-i386 = $(BCHECK_O)	63	OBJ-extra = $(filter bcheck.o,$(OBJ-$T))
70	OBJB-x86_64 = $(BCHECK_O)	64	OBJ-libtcc1 = $(addprefix $(X),$(filter-out $(OBJ-extra),$(OBJ-$T)))
71	OBJB-x86_64-osx = dummy.o	65
72	OBJB-i386-win32 = bcheck.o	66	ALL = $(addprefix $(TOP)/,$(X)libtcc1.a $(OBJ-extra))
73	OBJB-x86_64-win32 = bcheck.o	67
74	OBJB-arm64 = dummy.o	68	all: $(ALL)
75	OBJB-arm = dummy.o
76	OBJB-arm-fpa = dummy.o
77	OBJB-arm-fpa-ld = dummy.o
78	OBJB-arm-vfp = dummy.o
79	OBJB-arm-eabi = dummy.o
80	OBJB-arm-eabihf = dummy.o
81	OBJB-arm-wince = dummy.o
82	OBJB-riscv64 = dummy.o
83
84	all: $(BIN) $(BINB)
85
86	$(BIN) : $(patsubst %.o,$(X)%.o,$(OBJ-$T))
87	$(XAR) rcs $@ $^
88		69
89	$(BINB) : $(patsubst %.o,$(X)%.o,$(OBJB-$T))	70	$(TOP)/$(X)libtcc1.a : $(OBJ-libtcc1)
90	$(XAR) rcs $@ $^	71	$(XAR) rcs $@ $^
91		72
92	$(X)%.o : %.c	73	$(X)%.o : %.c
@@ -95,8 +76,12 @@ $(X)%.o : %.c · 2 unmodified lines
95	$(X)%.o : %.S	76	$(X)%.o : %.S
96	$(XCC) -c $< -o $@ $(XFLAGS)	77	$(XCC) -c $< -o $@ $(XFLAGS)
97		78
		79	$(TOP)/%.o : %.c
		80	$(XCC) -c $< -o $@ $(XFLAGS)
		81
		82	$(TOP)/bcheck.o : XFLAGS += -g
		83
98	$(X)crt1w.o : crt1.c	84	$(X)crt1w.o : crt1.c
99	$(X)wincrt1w.o : wincrt1.c	85	$(X)wincrt1w.o : wincrt1.c
100
101	clean :	86	clean :
102	rm -f .a .o $(BIN) $(BINB)	87	rm -f .a .o $(ALL)

lib/alloca86_64-bt.S+9−28

 __bound_alloca:
 #ifdef _WIN32
-    pop     %rdx
+    inc %rcx            # add one extra to separate regions
-    mov     %rcx,%rax
+    jmp alloca
-    add     $15,%rax
+.globl __bound_alloca_nr
-    and     $-16,%rax
+__bound_alloca_nr:
-    jz      p3
+    dec     %rcx
-p1:
-    cmp     $4096,%rax
-    jbe     p2
-    test    %rax,-4096(%rsp)
-    sub     $4096,%rsp
-    sub     $4096,%rax
-    jmp p1
-p2:
-    sub     %rax,%rsp
-    mov     %rsp,%rax
-    push    %rdx
     push    %rax
     mov     %rcx,%rdx
     mov     %rax,%rcx
-    sub     $20,%rsp
+    sub     $32,%rsp
-    call   __bound_new_region
+    call    __bound_new_region
-    add     $20,%rsp
+    add     $32,%rsp
     pop     %rax
-    pop     %rdx
-    add     $32,%rax
-p3:
-    push    %rdx
     ret
 #else
     pop     %rdx
     mov     %rdi,%rax
     mov     %rax,%rsi	# size, a second parm to the __bound_new_region
-    add     $15,%rax
+    add     $15 + 1,%rax  # add one extra to separate regions
     and     $-16,%rax
     jz      p3

lib/alloca86_64.S+0−4

     jmp p1
 p2:
 #endif
     sub     %rax,%rsp
     mov     %rsp,%rax
-#ifdef _WIN32
-    add     $32,%rax
-#endif
 p3:
     push    %rdx
     ret

lib/bcheck.c+17−14

     no_checking = no_check;
 }
+#define no_FASTCALL
+//#define no_checking 1
 /* print a bound error message */
 static void bound_error(const char *fmt, ...)
 {
 /* return '(p + offset)' for pointer arithmetic (a pointer can reach
    the end of a region in this case */
-void * FASTCALL __bound_ptr_add(void *p, size_t offset,
+void * no_FASTCALL __bound_ptr_add(void *p, size_t offset)
-                                size_t line, const char *filename)
 {
     size_t addr = (size_t)p;
         return p + offset;
     }
-    dprintf(stderr, "%s %s (%s:%u): %p 0x%x\n",
+    dprintf(stderr, "%s %s : %p 0x%x\n",
-            __FILE__, __FUNCTION__, filename, line, p, (unsigned)offset);
+            __FILE__, __FUNCTION__, p, (unsigned)offset);
     WAIT_SEM ();
     INCR_COUNT(bound_ptr_add_count);
         if (addr <= tree->size) {
             addr += offset;
             if (tree->is_invalid || addr > tree->size) {
-                fprintf(stderr,"%s %s (%s:%u): %p is outside of the region\n",
+        #if 0
-                        __FILE__, __FUNCTION__, filename, line, p + offset);
+                fprintf(stderr,"%s %s : %p is outside of the region\n",
+                        __FILE__, __FUNCTION__, p + offset);
+        #endif
                 if (never_fatal == 0) {
                     POST_SEM ();
                     return INVALID_POINTER; /* return an invalid pointer */
 /* return '(p + offset)' for pointer indirection (the resulting must
    be strictly inside the region */
 #define BOUND_PTR_INDIR(dsize)                                                 \
-void * FASTCALL __bound_ptr_indir ## dsize (void *p, size_t offset,            \
+void * no_FASTCALL __bound_ptr_indir ## dsize (void *p, size_t offset)         \
-                                            size_t line, const char *filename) \
 {                                                                              \
     size_t addr = (size_t)p;                                                   \
                                                                                \
     if (no_checking) {                                                         \
         return p + offset;                                                     \
     }                                                                          \
-    dprintf(stderr, "%s %s (%s:%u): %p 0x%x start\n",                          \
+    dprintf(stderr, "%s %s : %p 0x%x start\n",                                 \
-            __FILE__, __FUNCTION__, filename, line,  p, (unsigned)offset);     \
+            __FILE__, __FUNCTION__, p, (unsigned)offset);                      \
     WAIT_SEM ();                                                               \
     INCR_COUNT(bound_ptr_indir ## dsize ## _count);                            \
     if (tree) {                                                                \
         if (addr <= tree->size) {                                              \
             addr += offset + dsize;                                            \
             if (tree->is_invalid || addr > tree->size) {                       \
-                fprintf(stderr,"%s %s (%s:%u): %p is outside of the region\n", \
+                fprintf(stderr,"%s %s : %p is outside of the region\n",        \
-                    __FILE__, __FUNCTION__, filename, line, p + offset);       \
+                    __FILE__, __FUNCTION__, p + offset);                       \
                 if (never_fatal == 0) {                                        \
                     POST_SEM ();                                               \
                     return INVALID_POINTER; /* return an invalid pointer */    \
         return;
     if (size == 0)
         return;
-    p = __bound_ptr_add((void *)p, size, 0, function);
+    p = __bound_ptr_add((void *)p, size);
     if (p == INVALID_POINTER)
         bound_error("invalid pointer");
 }
     INCR_COUNT(bound_strlen_count);
     while (*p++);
     len = (p - s) - 1;
-    p = __bound_ptr_indir1((char *)s, len, 0, "strlen");
+    p = __bound_ptr_indir1((char *)s, len);
     if (p == INVALID_POINTER)
         bound_error("bad pointer in strlen()");
     return len;

lib/dummy.c+0−1

@@ -1 +0,0 @@
1	static char dummy;

libtcc.c+0−4

 #endif
 #ifdef CONFIG_TCC_BCHECK
     { "b", TCC_OPTION_b, 0 },
-    { "ba", TCC_OPTION_ba, 0 },
 #endif
     { "g", TCC_OPTION_g, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
     { "c", TCC_OPTION_c, 0 },
             s->do_bounds_check = 1;
             s->do_debug = 1;
             break;
-        case TCC_OPTION_ba:
-            s->do_bounds_check_address = 1;
-            break;
 #endif
         case TCC_OPTION_g:
             s->do_debug = 1;

tcc.c+0−1

@@ -59,7 +59,6 @@ static const char help[] = · 58 unmodified lines
59	" -g generate runtime debug info\n"	59	" -g generate runtime debug info\n"
60	#ifdef CONFIG_TCC_BCHECK	60	#ifdef CONFIG_TCC_BCHECK
61	" -b compile with built-in memory and bounds checker (implies -g)\n"	61	" -b compile with built-in memory and bounds checker (implies -g)\n"
62	" -ba Enable better address checking with bounds checker\n"
63	#endif	62	#endif
64	#ifdef CONFIG_TCC_BACKTRACE	63	#ifdef CONFIG_TCC_BACKTRACE
65	" -bt N show N callers in stack traces\n"	64	" -bt N show N callers in stack traces\n"

tcc.h+4−5

 #ifndef TCC_LIBTCC1
 # define TCC_LIBTCC1 "libtcc1.a"
 #endif
-#ifndef TCC_LIBTCCB1
-# define TCC_LIBTCCB1 "libtccb1.a"
-#endif
 /* library to use with CONFIG_USE_LIBGCC instead of libtcc1.a */
 #if defined CONFIG_USE_LIBGCC && !defined TCC_LIBGCC
 #ifdef CONFIG_TCC_BCHECK
     /* compile with built-in memory and bounds checker */
     unsigned char do_bounds_check;
-    unsigned char do_bounds_check_address;
 #endif
 #ifdef TCC_TARGET_ARM
     enum float_abi float_abi; /* float ABI of the generated code*/
 #endif
 ST_FUNC int tcc_add_dll(TCCState *s, const char *filename, int flags);
 #ifdef CONFIG_TCC_BCHECK
-ST_FUNC void tcc_add_bcheck(TCCState *s1, Section *bound_sec, Section *sym_sec);
+ST_FUNC void tcc_add_bcheck(TCCState *s1);
 #endif
 ST_FUNC void tcc_add_pragma_libs(TCCState *s1);
 PUB_FUNC int tcc_add_library_err(TCCState *s, const char *f);
 #if defined TCC_TARGET_X86_64 && !defined TCC_TARGET_PE
 ST_FUNC int classify_x86_64_va_arg(CType *ty);
 #endif
+#ifdef CONFIG_TCC_BCHECK
+ST_FUNC void gbound_args(int nb_args);
+#endif
 /* ------------ tccelf.c ------------ */

tccelf.c+2−2

@@ -1321,7 +1321,7 @@ ST_FUNC void tcc_add_runtime(TCCState *s1) · 1320 unmodified lines
1321	{	1321	{
1322	s1->filetype = 0;	1322	s1->filetype = 0;
1323	#ifdef CONFIG_TCC_BCHECK	1323	#ifdef CONFIG_TCC_BCHECK
1324	tcc_add_bcheck(s1, bounds_section, symtab_section);	1324	tcc_add_bcheck(s1);
1325	#endif	1325	#endif
1326	tcc_add_pragma_libs(s1);	1326	tcc_add_pragma_libs(s1);
1327	#ifndef TCC_TARGET_PE	1327	#ifndef TCC_TARGET_PE
@@ -1340,7 +1340,7 @@ ST_FUNC void tcc_add_runtime(TCCState *s1) · 12 unmodified lines
1340	if (s1->do_bounds_check && s1->output_type != TCC_OUTPUT_DLL) {	1340	if (s1->do_bounds_check && s1->output_type != TCC_OUTPUT_DLL) {
1341	tcc_add_library_err(s1, "pthread");	1341	tcc_add_library_err(s1, "pthread");
1342	tcc_add_library_err(s1, "dl");	1342	tcc_add_library_err(s1, "dl");
1343	tcc_add_support(s1, TCC_LIBTCCB1);	1343	tcc_add_support(s1, "bcheck.o");
1344	}	1344	}
1345	#endif	1345	#endif
1346	tcc_add_support(s1, TCC_LIBTCC1);	1346	tcc_add_support(s1, TCC_LIBTCC1);

tccgen.c+21−20

                     type = &int_type;
 #endif
                 size = type_size(type, &align);
+#ifdef CONFIG_TCC_BCHECK
+                if (tcc_state->do_bounds_check)
+                    l = loc = (loc - size) & -align;
+                else
+#endif
                 l=get_temp_local_var(size,align);
                 sv.type.t = type->t;
                 sv.r = VT_LOCAL | VT_LVAL;
     vtop->r &= ~VT_MUSTBOUND;
     /* if lvalue, then use checking code before dereferencing */
-    if ((vtop->r & VT_LVAL) && !nocode_wanted) {
+    if (vtop->r & VT_LVAL) {
         /* if not VT_BOUNDED value, then make one */
         if (!(vtop->r & VT_BOUNDED)) {
             lval_type = vtop->r & (VT_LVAL_TYPE | VT_LVAL);
         gen_bounded_ptr_deref();
     }
 }
+/* we need to call __bound_ptr_add before we start to load function
+   args into registers */
+ST_FUNC void gbound_args(int nb_args)
+{
+    int i;
+    for (i = 1; i <= nb_args; ++i)
+        if (vtop[1 - i].r & VT_MUSTBOUND) {
+            vrotb(i);
+            gbound();
+            vrott(i);
+        }
+}
 #endif
 static void incr_bf_adr(int o)
             }
             gen_op('*');
 #ifdef CONFIG_TCC_BCHECK
-    /* The main reason to removing this code:
+            if (tcc_state->do_bounds_check && !const_wanted) {
-	#include <stdio.h>
-	int main ()
-	{
-	    int v[10];
-	    int i = 10;
-	    int j = 9;
-	    fprintf(stderr, "v+i-j  = %p\n", v+i-j);
-	    fprintf(stderr, "v+(i-j)  = %p\n", v+(i-j));
-	}
-    When this code is on. then the output looks like
-	v+i-j = 0xfffffffe
-	v+(i-j) = 0xbff84000
-    This should now work in updated bcheck.c version.
-    */
-            /* if evaluating constant expression, no code should be
-               generated, so no bound check */
-            if (tcc_state->do_bounds_check && tcc_state->do_bounds_check_address
-                && !const_wanted && !nocode_wanted) {
                 /* if bounded pointers, we generate a special code to
                    test bounds */
                 if (op == '-') {
                     vswap();
                     gen_op('-');
                 }
+                vtop[-1].r &= ~VT_MUSTBOUND;
                 gen_bounded_ptr_add();
             } else
 #endif

tccpe.c+14−22

 #define PE_STDSYM(n,s) "_" n s
 #endif
+static void tcc_add_support(TCCState *s1, const char *filename)
+{
+    if (tcc_add_dll(s1, filename, 0) < 0)
+        tcc_error_noabort("%s not found", filename);
+}
 static void pe_add_runtime(TCCState *s1, struct pe_info *pe)
 {
     const char *start_symbol;
     if (0 == s1->nostdlib) {
         static const char *libs[] = {
-            TCC_LIBTCC1,
-#ifdef CONFIG_TCC_BCHECK
-            TCC_LIBTCCB1,
-#endif
             "msvcrt", "kernel32", "", "user32", "gdi32", NULL
         };
         const char **pp, *p;
-        for (pp = libs; 0 != (p = *pp); ++pp) {
+#ifdef TCC_IS_NATIVE
-#ifdef CONFIG_TCC_BCHECK
+        if (s1->do_bounds_check)
-            if (pp == libs + 1 &&
+            tcc_add_support(s1, "bcheck.o");
-                (s1->do_bounds_check == 0 || s1->output_type == TCC_OUTPUT_DLL)) {
-                continue;
-            }
-#endif
-            if (0 == *p) {
-                if (PE_DLL != pe_type && PE_GUI != pe_type)
-                    break;
-            } else if (pp == libs && tcc_add_dll(s1, p, 0) >= 0) {
-                continue;
-#ifdef CONFIG_TCC_BCHECK
-            } else if (pp == libs + 1 && tcc_add_dll(s1, p, 0) >= 0) {
-                continue;
 #endif
-            } else {
+        tcc_add_support(s1, TCC_LIBTCC1);
+        for (pp = libs; 0 != (p = *pp); ++pp) {
+            if (*p)
                 tcc_add_library_err(s1, p);
-            }
+            else if (PE_DLL != pe_type && PE_GUI != pe_type)
+                break;
         }
     }
     if (TCC_OUTPUT_MEMORY == s1->output_type)
         pe_type = PE_RUN;
     pe->type = pe_type;

tccpp.c+3−4

 ST_FUNC int cstr_printf(CString *cstr, const char *fmt, ...)
 {
     va_list v;
-    va_list vc;
     int len, size;
     va_start(v, fmt);
-    va_copy (vc, v);
+    len = vsnprintf(NULL, 0, fmt, v);
-    len = vsnprintf(NULL, 0, fmt, vc);
+    va_end(v);
-    va_end(vc);
     size = cstr->size + len + 1;
     if (size > cstr->size_allocated)
         cstr_realloc(cstr, size);
+    va_start(v, fmt);
     vsnprintf((char*)cstr->data + cstr->size, size, fmt, v);
     va_end(v);
     cstr->size += len;

tcctok.h+3−0

      DEF(TOK___bound_local_new, "__bound_local_new")
      DEF(TOK___bound_local_delete, "__bound_local_delete")
 # ifdef TCC_TARGET_PE
+#  ifdef TCC_TARGET_X86_64
+     DEF(TOK___bound_alloca_nr, "__bound_alloca_nr")
+#  endif
      DEF(TOK_malloc, "malloc")
      DEF(TOK_free, "free")
      DEF(TOK_realloc, "realloc")

tests/Makefile+7−8

  tests2-dir \
  pp-dir
-BTESTS = test1b test3b btest test4
+BTESTS = btest test2b
 # test4_static -- Not all relocation types are implemented yet.
 # asmtest / asmtest2 -- minor differences with gcc
 	$(TCC) $(RUN_TCC) $(RUN_TCC) $(RUN_TCC) -run $< > test.out3
 	@diff -u test.ref test.out3 && echo "Auto Test3 OK"
-test%b : TCCFLAGS += -b -ba
+test%b : TCCFLAGS += -b
 # binary output test
 test4: tcctest.c test.ref
 	./tcctest1 > test1.out
 	@if diff -u test.ref test1.out ; then echo "Dynamic Auto Test OK"; fi
 # dynamic output + bound check
-	$(TCC) -b -ba -o tcctest4 $<
+	$(TCC) -b -o tcctest4 $<
 	./tcctest4 > test4.out
 	@if diff -u test.ref test4.out ; then echo "BCheck Auto Test OK"; fi
 # memory and bound check auto test
-BOUNDS_OK  = 1 3 4 8 10 14 16
+BOUNDS_OK  = 1 4 8 10 14 16
 BOUNDS_FAIL= 2 5 6 7 9 11 12 13 15 17
 btest: boundtest.c
 	@echo ------------ $@ ------------
-	@ulimit -c 0; \
+	@for i in $(BOUNDS_OK); do \
-	for i in $(BOUNDS_OK); do \
 	   echo ; echo --- boundtest $$i ---; \
-	   if $(TCC) -b -ba -run $< $$i ; then \
+	   if $(TCC) -b -run $< $$i ; then \
 	       echo succeeded as expected; \
 	   else\
 	       echo Failed positive test $$i ; exit 1 ; \
 	done ;\
 	for i in $(BOUNDS_FAIL); do \
 	   echo ; echo --- boundtest $$i ---; \
-	   if $(TCC) -b -ba -run $< $$i ; then \
+	   if $(TCC) -b -run $< $$i ; then \
 	       echo Failed negative test $$i ; exit 1 ;\
 	   else\
 	       echo failed as expected; \

x86_64-gen.c+37−230

@@ -142,9 +142,6 @@ ST_DATA const int reg_classes[NB_REGS] = { · 141 unmodified lines
142		142
143	static unsigned long func_sub_sp_offset;	143	static unsigned long func_sub_sp_offset;
144	static int func_ret_sub;	144	static int func_ret_sub;
145	static int nested_call;
146	static int call_used_nr_reg;
147	static int call_used_regs[20];
148		145
149	/* XXX: make it faster ? */	146	/* XXX: make it faster ? */
150	ST_FUNC void g(int c)	147	ST_FUNC void g(int c)
@@ -654,218 +651,19 @@ static void gen_bounds_call(int v) · 503 unmodified lines
654	#endif	651	#endif
655	}	652	}
656		653
657	ST_FUNC void tcc_add_bcheck(TCCState s1, Section bound_sec, Section *sym_sec)
658	{
659	addr_t *ptr;
660	int loc_glob;
661	int sym_index;
662	int bsym_index;
663
664	if (0 == s1->do_bounds_check)
665	return;
666	/* XXX: add an object file to do that */
667	ptr = section_ptr_add(bound_sec, sizeof(*ptr));
668	*ptr = 0;
669	loc_glob = s1->output_type != TCC_OUTPUT_MEMORY ? STB_LOCAL : STB_GLOBAL;
670	bsym_index = set_elf_sym(sym_sec, 0, 0,
671	ELFW(ST_INFO)(loc_glob, STT_NOTYPE), 0,
672	bound_sec->sh_num, "__bounds_start");
673	/* pull bcheck.o from libtcc1.a */
674	sym_index = set_elf_sym(sym_sec, 0, 0,
675	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
676	SHN_UNDEF, "__bound_init");
677	if (s1->output_type != TCC_OUTPUT_MEMORY) {
678	/* add 'call __bound_init()' in .init section */
679	Section *init_section = find_section(s1, ".init");
680	unsigned char *pinit;
681	#ifdef TCC_TARGET_PE
682	pinit = section_ptr_add(init_section, 8);
683	pinit[0] = 0x55; /* push %rbp */
684	pinit[1] = 0x48; /* mov %rsp,%rpb */
685	pinit[2] = 0x89;
686	pinit[3] = 0xe5;
687	pinit[4] = 0x48; /* sub $0x10,%rsp */
688	pinit[5] = 0x83;
689	pinit[6] = 0xec;
690	pinit[7] = 0x10;
691	#endif
692	pinit = section_ptr_add(init_section, 5);
693	pinit[0] = 0xe8;
694	write32le(pinit + 1, -4);
695	put_elf_reloc(sym_sec, init_section,
696	init_section->data_offset - 4, R_386_PC32, sym_index);
697	/* R_386_PC32 = R_X86_64_PC32 = 2 */
698	pinit = section_ptr_add(init_section, 13);
699	pinit[0] = 0x48; /* mov xx,%rax */
700	pinit[1] = 0xb8;
701	write64le(pinit + 2, 0);
702	#ifdef TCC_TARGET_PE
703	pinit[10] = 0x48; /* mov %rax,%rcx */
704	pinit[11] = 0x89;
705	pinit[12] = 0xc1;
706	#else
707	pinit[10] = 0x48; /* mov %rax,%rdi */
708	pinit[11] = 0x89;
709	pinit[12] = 0xc7;
710	#endif
711	put_elf_reloc(sym_sec, init_section,
712	init_section->data_offset - 11, R_X86_64_64, bsym_index);
713	sym_index = set_elf_sym(sym_sec, 0, 0,
714	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
715	SHN_UNDEF, "__bounds_add_static_var");
716	pinit = section_ptr_add(init_section, 5);
717	pinit[0] = 0xe8;
718	write32le(pinit + 1, -4);
719	put_elf_reloc(sym_sec, init_section,
720	init_section->data_offset - 4, R_386_PC32, sym_index);
721	/* R_386_PC32 = R_X86_64_PC32 = 2 */
722	#ifdef TCC_TARGET_PE
723	{
724	int init_index = set_elf_sym(sym_sec,
725	0, 0,
726	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
727	init_section->sh_num, "__init_start");
728	Sym sym;
729	init_section->sh_flags \|= SHF_EXECINSTR;
730	pinit = section_ptr_add(init_section, 2);
731	pinit[0] = 0xc9; /* leave */
732	pinit[1] = 0xc3; /* ret */
733	sym.c = init_index;
734	add_init_array (s1, &sym);
735	}
736	#endif
737	}
738	}
739
740	/* generate a bounded pointer addition */	654	/* generate a bounded pointer addition */
741	ST_FUNC void gen_bounded_ptr_add(void)	655	ST_FUNC void gen_bounded_ptr_add(void)
742	{	656	{
743	int i;	657	vpush_global_sym(&func_old_type, TOK___bound_ptr_add);
744		658	vrott(3);
745	nested_call++;	659	gfunc_call(2);
746		660	vpushi(0);
747	/* save all temporary registers */
748	save_regs(0);
749
750	for (i = 0; i < call_used_nr_reg; i++) {
751	switch (call_used_regs[i]) {
752	case TREG_RAX: case TREG_RCX: case TREG_RDX: case TREG_RSP:
753	case TREG_RSI: case TREG_RDI:
754	o(0x50 + call_used_regs[i]); /* push reg */
755	break;
756	case TREG_R8: case TREG_R9: case TREG_R10: case TREG_R11:
757	o(0x5041 + (call_used_regs[i] - TREG_R8) * 0x100); /* push reg */
758	break;
759	case TREG_XMM0: case TREG_XMM1: case TREG_XMM2: case TREG_XMM3:
760	case TREG_XMM4: case TREG_XMM5: case TREG_XMM6: case TREG_XMM7:
761	o(0x10ec8348); /* sub $10,%rsp */
762	/* vmovdqu %xmmx,(%rsp) */
763	o(0x047ffac5 + (call_used_regs[i] - TREG_XMM0) * 0x8000000); o(0x24);
764	break;
765	}
766	}
767
768	if (nested_call > 1) {
769	#ifdef TCC_TARGET_PE
770	o(0x5152); /* push %rdx/%rcx */
771	o(0x51415041); /* push %r8/%r9 */
772	#else
773	o(0x51525657); /* push %rdi/%rsi/%rdx/%rcx */
774	#endif
775	}
776	/* prepare fast x86_64 function call */
777	gv(RC_RAX);
778	#ifdef TCC_TARGET_PE
779	o(0xc28948); // mov %rax,%rdx ## second arg in %rdx, this must be size
780	#else
781	o(0xc68948); // mov %rax,%rsi ## second arg in %rsi, this must be size
782	#endif
783	vtop--;
784
785	gv(RC_RAX);
786	#ifdef TCC_TARGET_PE
787	o(0xc18948); // mov %rax,%rcx ## first arg in %rcx, this must be ptr
788	#else
789	o(0xc78948); // mov %rax,%rdi ## first arg in %rdi, this must be ptr
790	#endif
791	vtop--;
792
793	/* add line, filename */
794	#ifdef TCC_TARGET_PE
795	o(0xc0c749); /* mov $xx,%r8 */
796	#else
797	o(0xba); /* mov $xx,%edx */
798	#endif
799	gen_le32 (file->line_num);
800	{
801	static addr_t offset;
802	static char last_filename[1024];
803	Sym *sym_data;
804
805	if (strcmp (last_filename, file->filename) != 0) {
806	void *ptr;
807	int len = strlen (file->filename) + 1;
808
809	offset = data_section->data_offset;
810	ptr = section_ptr_add(data_section, len);
811	memcpy (ptr, file->filename, len);
812	memcpy (last_filename, file->filename, len);
813	}
814	#ifdef TCC_TARGET_PE
815	o(0xb949); /* mov $xx,%r9 */
816	#else
817	o(0xb948); /* mov $xx,%rcx */
818	#endif
819	gen_le64 (0);
820	sym_data = get_sym_ref(&char_pointer_type, data_section,
821	offset, data_section->data_offset);
822	greloca(cur_text_section, sym_data, ind - 8, R_X86_64_64, 0);
823	}
824
825	#ifdef TCC_TARGET_PE
826	o(0x20ec8348); /* sub $20, %rsp */
827	#endif
828
829	/* do a fast function call */
830	gen_bounds_call(TOK___bound_ptr_add);
831
832	#ifdef TCC_TARGET_PE
833	o(0x20c48348); /* add $20, %rsp */
834	#endif
835
836	if (nested_call > 1) {
837	#ifdef TCC_TARGET_PE
838	o(0x58415941); /* pop %r9/%r8 */
839	o(0x5a59); /* pop %rcx/%rdx */
840	#else
841	o(0x5f5e5a59); /* pop $rcx/%rdx/%rsi/%rdi */
842	#endif
843	}
844	/* returned pointer is in rax */	661	/* returned pointer is in rax */
845	vtop++;
846	vtop->r = TREG_RAX \| VT_BOUNDED;	662	vtop->r = TREG_RAX \| VT_BOUNDED;
847		663	if (nocode_wanted)
848	for (i = call_used_nr_reg - 1; i >= 0; i--) {	664	return;
849	switch (call_used_regs[i]) {
850	case TREG_RAX: case TREG_RCX: case TREG_RDX: case TREG_RSP:
851	case TREG_RSI: case TREG_RDI:
852	o(0x58 + call_used_regs[i]); /* pop reg */
853	break;
854	case TREG_R8: case TREG_R9: case TREG_R10: case TREG_R11:
855	o(0x5841 + (call_used_regs[i] - TREG_R8) * 0x100); /* pop reg */
856	break;
857	case TREG_XMM0: case TREG_XMM1: case TREG_XMM2: case TREG_XMM3:
858	case TREG_XMM4: case TREG_XMM5: case TREG_XMM6: case TREG_XMM7:
859	/* vmovdqu (%rsp),%xmmx */
860	o(0x046ffac5 + (call_used_regs[i] - TREG_XMM0) * 0x8000000); o(0x24);
861	o(0x10c48348); /* add $10,%rsp */
862	break;
863	}
864	}
865
866	/* relocation offset of the bounding function call point */	665	/* relocation offset of the bounding function call point */
867	vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(ElfW(Rela)));	666	vtop->c.i = (cur_text_section->reloc->data_offset - sizeof(ElfW(Rela)));
868	nested_call--;
869	}	667	}
870		668
871	/* patch pointer addition in vtop so that pointer dereferencing is	669	/* patch pointer addition in vtop so that pointer dereferencing is
@@ -877,6 +675,9 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 5 unmodified lines
877	ElfW(Rela) *rel;	675	ElfW(Rela) *rel;
878	Sym *sym;	676	Sym *sym;
879		677
		678	if (nocode_wanted)
		679	return;
		680
880	size = 0;	681	size = 0;
881	/* XXX: put that code in generic part of tcc */	682	/* XXX: put that code in generic part of tcc */
882	if (!is_float(vtop->type.t)) {	683	if (!is_float(vtop->type.t)) {
@@ -886,7 +687,7 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 3 unmodified lines
886	size = 2;	687	size = 2;
887	}	688	}
888	if (!size)	689	if (!size)
889	size = type_size(&vtop->type, &align);	690	size = type_size(&vtop->type, &align);
890	switch(size) {	691	switch(size) {
891	case 1: func = TOK___bound_ptr_indir1; break;	692	case 1: func = TOK___bound_ptr_indir1; break;
892	case 2: func = TOK___bound_ptr_indir2; break;	693	case 2: func = TOK___bound_ptr_indir2; break;
@@ -895,18 +696,17 @@ ST_FUNC void gen_bounded_ptr_deref(void) · 2 unmodified lines
895	case 12: func = TOK___bound_ptr_indir12; break;	696	case 12: func = TOK___bound_ptr_indir12; break;
896	case 16: func = TOK___bound_ptr_indir16; break;	697	case 16: func = TOK___bound_ptr_indir16; break;
897	default:	698	default:
898	tcc_error("unhandled size when dereferencing bounded pointer");	699	/* may happen with struct member access */
899	func = 0;	700	return;
900	break;	701	//tcc_error("unhandled size when dereferencing bounded pointer");
		702	//func = 0;
		703	//break;
901	}	704	}
902
903	sym = external_global_sym(func, &func_old_type);	705	sym = external_global_sym(func, &func_old_type);
904	if (!sym->c)	706	if (!sym->c)
905	put_extern_sym(sym, NULL, 0, 0);	707	put_extern_sym(sym, NULL, 0, 0);
906
907	/* patch relocation */	708	/* patch relocation */
908	/* XXX: find a better solution ? */	709	/* XXX: find a better solution ? */
909
910	rel = (ElfW(Rela) *)(cur_text_section->reloc->data + vtop->c.i);	710	rel = (ElfW(Rela) *)(cur_text_section->reloc->data + vtop->c.i);
911	rel->r_info = ELF64_R_INFO(sym->c, ELF64_R_TYPE(rel->r_info));	711	rel->r_info = ELF64_R_INFO(sym->c, ELF64_R_TYPE(rel->r_info));
912	}	712	}
@@ -992,6 +792,11 @@ void gfunc_call(int nb_args) · 79 unmodified lines
992	int size, r, args_size, i, d, bt, struct_size;	792	int size, r, args_size, i, d, bt, struct_size;
993	int arg;	793	int arg;
994		794
		795	#ifdef CONFIG_TCC_BCHECK
		796	if (tcc_state->do_bounds_check)
		797	gbound_args(nb_args);
		798	#endif
		799
995	args_size = (nb_args < REGN ? REGN : nb_args) * PTR_SIZE;	800	args_size = (nb_args < REGN ? REGN : nb_args) * PTR_SIZE;
996	arg = nb_args;	801	arg = nb_args;
997		802
@@ -1051,7 +856,6 @@ void gfunc_call(int nb_args) · 53 unmodified lines
1051	} else {	856	} else {
1052	d = arg_prepare_reg(arg);	857	d = arg_prepare_reg(arg);
1053	gen_offs_sp(0x8d, d, struct_size);	858	gen_offs_sp(0x8d, d, struct_size);
1054	call_used_regs[call_used_nr_reg++] = d;
1055	}	859	}
1056	struct_size += size;	860	struct_size += size;
1057	} else {	861	} else {
@@ -1070,7 +874,6 @@ void gfunc_call(int nb_args) · 12 unmodified lines
1070	o(0x66);	874	o(0x66);
1071	orex(1,d,0, 0x7e0f);	875	orex(1,d,0, 0x7e0f);
1072	o(0xc0 + arg*8 + REG_VALUE(d));	876	o(0xc0 + arg*8 + REG_VALUE(d));
1073	call_used_regs[call_used_nr_reg++] = d;
1074	}	877	}
1075	} else {	878	} else {
1076	if (bt == VT_STRUCT) {	879	if (bt == VT_STRUCT) {
@@ -1086,7 +889,6 @@ void gfunc_call(int nb_args) · 9 unmodified lines
1086	d = arg_prepare_reg(arg);	889	d = arg_prepare_reg(arg);
1087	orex(1,d,r,0x89); /* mov */	890	orex(1,d,r,0x89); /* mov */
1088	o(0xc0 + REG_VALUE(r) * 8 + REG_VALUE(d));	891	o(0xc0 + REG_VALUE(r) * 8 + REG_VALUE(d));
1089	call_used_regs[call_used_nr_reg++] = d;
1090	}	892	}
1091	}	893	}
1092	}	894	}
@@ -1105,7 +907,12 @@ void gfunc_call(int nb_args) · 12 unmodified lines
1105		907
1106	if ((vtop->r & VT_SYM) && vtop->sym->v == TOK_alloca) {	908	if ((vtop->r & VT_SYM) && vtop->sym->v == TOK_alloca) {
1107	/* need to add the "func_scratch" area after alloca */	909	/* need to add the "func_scratch" area after alloca */
1108	o(0x48); func_alloca = oad(0x2d, func_alloca); /* sub $NN, %rax */	910	o(0x48); func_alloca = oad(0x05, func_alloca); /* add $NN, %rax */
		911	#ifdef CONFIG_TCC_BCHECK
		912	if (tcc_state->do_bounds_check)
		913	gen_bounds_call(TOK___bound_alloca_nr); /* new region */
		914	#endif
		915
1109	}	916	}
1110		917
1111	/* other compilers don't clear the upper bits when returning char/short */	918	/* other compilers don't clear the upper bits when returning char/short */
@@ -1125,7 +932,6 @@ void gfunc_call(int nb_args) · 13 unmodified lines
1125	o(0xc089); /* mov %eax,%eax */	932	o(0xc089); /* mov %eax,%eax */
1126	#endif	933	#endif
1127	vtop--;	934	vtop--;
1128	call_used_nr_reg = 0;
1129	}	935	}
1130		936
1131		937
@@ -1141,7 +947,7 @@ void gfunc_prolog(Sym *func_sym) · 9 unmodified lines
1141	int n_arg = 0;	947	int n_arg = 0;
1142		948
1143	func_ret_sub = 0;	949	func_ret_sub = 0;
1144	func_scratch = 0;	950	func_scratch = 32;
1145	func_alloca = 0;	951	func_alloca = 0;
1146	loc = 0;	952	loc = 0;
1147		953
@@ -1228,6 +1034,10 @@ void gfunc_epilog(void) · 80 unmodified lines
1228	{	1034	{
1229	int v, saved_ind;	1035	int v, saved_ind;
1230		1036
		1037	/* align local size to word & save local variables */
		1038	func_scratch = (func_scratch + 15) & -16;
		1039	loc = (loc & -16) - func_scratch;
		1040
1231	#ifdef CONFIG_TCC_BCHECK	1041	#ifdef CONFIG_TCC_BCHECK
1232	if (tcc_state->do_bounds_check	1042	if (tcc_state->do_bounds_check
1233	&& func_bound_offset != lbounds_section->data_offset)	1043	&& func_bound_offset != lbounds_section->data_offset)
@@ -1273,9 +1083,7 @@ void gfunc_epilog(void) · 39 unmodified lines
1273		1083
1274	saved_ind = ind;	1084	saved_ind = ind;
1275	ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;	1085	ind = func_sub_sp_offset - FUNC_PROLOG_SIZE;
1276	/* align local size to word & save local variables */	1086	v = -loc;
1277	func_scratch = (func_scratch + 15) & -16;
1278	v = (func_scratch + -loc + 15) & -16;
1279		1087
1280	if (v >= 4096) {	1088	if (v >= 4096) {
1281	Sym *sym = external_global_sym(TOK___chkstk, &func_old_type);	1089	Sym *sym = external_global_sym(TOK___chkstk, &func_old_type);
@@ -1479,6 +1287,11 @@ void gfunc_call(int nb_args) · 197 unmodified lines
1479	int sse_reg, gen_reg;	1287	int sse_reg, gen_reg;
1480	char _onstack[nb_args ? nb_args : 1], *onstack = _onstack;	1288	char _onstack[nb_args ? nb_args : 1], *onstack = _onstack;
1481		1289
		1290	#ifdef CONFIG_TCC_BCHECK
		1291	if (tcc_state->do_bounds_check)
		1292	gbound_args(nb_args);
		1293	#endif
		1294
1482	/* calculate the number of integer/float register arguments, remember	1295	/* calculate the number of integer/float register arguments, remember
1483	arguments to be passed via stack (in onstack[]), and also remember	1296	arguments to be passed via stack (in onstack[]), and also remember
1484	if we have to align the stack pointer to 16 (onstack[i] == 2). Needs	1297	if we have to align the stack pointer to 16 (onstack[i] == 2). Needs
@@ -1611,14 +1424,11 @@ void gfunc_call(int nb_args) · 126 unmodified lines
1611	o(0x280f);	1424	o(0x280f);
1612	o(0xc0 + (sse_reg << 3));	1425	o(0xc0 + (sse_reg << 3));
1613	}	1426	}
1614	call_used_regs[call_used_nr_reg++] = sse_reg + TREG_XMM0;
1615	call_used_regs[call_used_nr_reg++] = sse_reg + 1 + TREG_XMM0;
1616	} else {	1427	} else {
1617	assert(reg_count == 1);	1428	assert(reg_count == 1);
1618	--sse_reg;	1429	--sse_reg;
1619	/* Load directly to register */	1430	/* Load directly to register */
1620	gv(RC_XMM0 << sse_reg);	1431	gv(RC_XMM0 << sse_reg);
1621	call_used_regs[call_used_nr_reg++] = sse_reg + TREG_XMM0;
1622	}	1432	}
1623	} else if (mode == x86_64_mode_integer) {	1433	} else if (mode == x86_64_mode_integer) {
1624	/* simple type */	1434	/* simple type */
@@ -1629,12 +1439,10 @@ void gfunc_call(int nb_args) · 4 unmodified lines
1629	d = arg_prepare_reg(gen_reg);	1439	d = arg_prepare_reg(gen_reg);
1630	orex(1,d,r,0x89); /* mov */	1440	orex(1,d,r,0x89); /* mov */
1631	o(0xc0 + REG_VALUE(r) * 8 + REG_VALUE(d));	1441	o(0xc0 + REG_VALUE(r) * 8 + REG_VALUE(d));
1632	call_used_regs[call_used_nr_reg++] = d;
1633	if (reg_count == 2) {	1442	if (reg_count == 2) {
1634	d = arg_prepare_reg(gen_reg+1);	1443	d = arg_prepare_reg(gen_reg+1);
1635	orex(1,d,vtop->r2,0x89); /* mov */	1444	orex(1,d,vtop->r2,0x89); /* mov */
1636	o(0xc0 + REG_VALUE(vtop->r2) * 8 + REG_VALUE(d));	1445	o(0xc0 + REG_VALUE(vtop->r2) * 8 + REG_VALUE(d));
1637	call_used_regs[call_used_nr_reg++] = d;
1638	}	1446	}
1639	}	1447	}
1640	vtop--;	1448	vtop--;
@@ -1677,7 +1485,6 @@ void gfunc_call(int nb_args) · 36 unmodified lines
1677	else if (bt == (VT_SHORT \| VT_UNSIGNED))	1485	else if (bt == (VT_SHORT \| VT_UNSIGNED))
1678	o(0xc0b70f); /* movzwl %al, %eax */	1486	o(0xc0b70f); /* movzwl %al, %eax */
1679	vtop--;	1487	vtop--;
1680	call_used_nr_reg = 0;
1681	}	1488	}
1682		1489
1683		1490

x86_64-link.c+85−0

@@ -287,4 +287,89 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 286 unmodified lines
287	}	287	}
288	}	288	}
289		289
		290	#ifdef CONFIG_TCC_BCHECK
		291	ST_FUNC void tcc_add_bcheck(TCCState *s1)
		292	{
		293	addr_t *ptr;
		294	int loc_glob;
		295	int sym_index;
		296	int bsym_index;
		297
		298	if (0 == s1->do_bounds_check)
		299	return;
		300	/* XXX: add an object file to do that */
		301	ptr = section_ptr_add(bounds_section, sizeof(*ptr));
		302	*ptr = 0;
		303	loc_glob = s1->output_type != TCC_OUTPUT_MEMORY ? STB_LOCAL : STB_GLOBAL;
		304	bsym_index = set_elf_sym(symtab_section, 0, 0,
		305	ELFW(ST_INFO)(loc_glob, STT_NOTYPE), 0,
		306	bounds_section->sh_num, "__bounds_start");
		307	/* pull bcheck.o from libtcc1.a */
		308	sym_index = set_elf_sym(symtab_section, 0, 0,
		309	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		310	SHN_UNDEF, "__bound_init");
		311	if (s1->output_type != TCC_OUTPUT_MEMORY) {
		312	/* add 'call __bound_init()' in .init section */
		313	Section *init_section = find_section(s1, ".init");
		314	unsigned char *pinit;
		315	#ifdef TCC_TARGET_PE
		316	pinit = section_ptr_add(init_section, 8);
		317	pinit[0] = 0x55; /* push %rbp */
		318	pinit[1] = 0x48; /* mov %rsp,%rpb */
		319	pinit[2] = 0x89;
		320	pinit[3] = 0xe5;
		321	pinit[4] = 0x48; /* sub $0x10,%rsp */
		322	pinit[5] = 0x83;
		323	pinit[6] = 0xec;
		324	pinit[7] = 0x10;
		325	#endif
		326	pinit = section_ptr_add(init_section, 5);
		327	pinit[0] = 0xe8;
		328	write32le(pinit + 1, -4);
		329	put_elf_reloc(symtab_section, init_section,
		330	init_section->data_offset - 4, R_386_PC32, sym_index);
		331	/* R_386_PC32 = R_X86_64_PC32 = 2 */
		332	pinit = section_ptr_add(init_section, 13);
		333	pinit[0] = 0x48; /* mov xx,%rax */
		334	pinit[1] = 0xb8;
		335	write64le(pinit + 2, 0);
		336	#ifdef TCC_TARGET_PE
		337	pinit[10] = 0x48; /* mov %rax,%rcx */
		338	pinit[11] = 0x89;
		339	pinit[12] = 0xc1;
		340	#else
		341	pinit[10] = 0x48; /* mov %rax,%rdi */
		342	pinit[11] = 0x89;
		343	pinit[12] = 0xc7;
		344	#endif
		345	put_elf_reloc(symtab_section, init_section,
		346	init_section->data_offset - 11, R_X86_64_64, bsym_index);
		347	sym_index = set_elf_sym(symtab_section, 0, 0,
		348	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		349	SHN_UNDEF, "__bounds_add_static_var");
		350	pinit = section_ptr_add(init_section, 5);
		351	pinit[0] = 0xe8;
		352	write32le(pinit + 1, -4);
		353	put_elf_reloc(symtab_section, init_section,
		354	init_section->data_offset - 4, R_386_PC32, sym_index);
		355	/* R_386_PC32 = R_X86_64_PC32 = 2 */
		356	#ifdef TCC_TARGET_PE
		357	{
		358	int init_index = set_elf_sym(symtab_section,
		359	0, 0,
		360	ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0,
		361	init_section->sh_num, "__init_start");
		362	Sym sym;
		363	init_section->sh_flags \|= SHF_EXECINSTR;
		364	pinit = section_ptr_add(init_section, 2);
		365	pinit[0] = 0xc9; /* leave */
		366	pinit[1] = 0xc3; /* ret */
		367	sym.c = init_index;
		368	add_init_array (s1, &sym);
		369	}
		370	#endif
		371	}
		372	}
		373	#endif
		374
290	#endif /* !TARGET_DEFS_ONLY */	375	#endif /* !TARGET_DEFS_ONLY */

bcheck cleanup

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code