tcc_error_noabort(): always use this unless compiling

This avoids 'exit(1)' with errors outside of compilation (nasty in particular with libtcc usage) As a sideeffect multiple errors can be seen for linker errors (such as undefined symbols, relocation errors, ...)

grischka committed 3 years ago

Commit 7916cf71 parent 19ef02417 files · +189 −180Browse files

Unified · Split

17 files

arm-link.c +3 −3
arm64-link.c +5 −5
c67-link.c +1 −1
i386-link.c +3 −3
libtcc.c +55 −48
libtcc.h +1 −1
riscv64-link.c +10 −10
tcc.c +13 −11
tcc.h +6 −3
tcccoff.c +3 −0
tccelf.c +45 −53
tccgen.c +1 −2
tccmacho.c +3 −0
tccpe.c +8 −17
tccrun.c +17 −11
tcctools.c +12 −9
x86_64-link.c +3 −3

arm-link.c+3−3

@@ -214,7 +214,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 213 unmodified lines
214	h = x & 2;	214	h = x & 2;
215	th_ko = (x & 3) && (!blx_avail \|\| !is_call);	215	th_ko = (x & 3) && (!blx_avail \|\| !is_call);
216	if (th_ko \|\| x >= 0x2000000 \|\| x < -0x2000000)	216	if (th_ko \|\| x >= 0x2000000 \|\| x < -0x2000000)
217	tcc_error("can't relocate value at %x,%d",addr, type);	217	tcc_error_noabort("can't relocate value at %x,%d",addr, type);
218	x >>= 2;	218	x >>= 2;
219	x &= 0xffffff;	219	x &= 0xffffff;
220	/* Only reached if blx is avail and it is a call */	220	/* Only reached if blx is avail and it is a call */
@@ -303,7 +303,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 82 unmodified lines
303	- instruction must be a call (bl) or a jump to PLT */	303	- instruction must be a call (bl) or a jump to PLT */
304	if (!to_thumb \|\| x >= 0x1000000 \|\| x < -0x1000000)	304	if (!to_thumb \|\| x >= 0x1000000 \|\| x < -0x1000000)
305	if (to_thumb \|\| (val & 2) \|\| (!is_call && !to_plt))	305	if (to_thumb \|\| (val & 2) \|\| (!is_call && !to_plt))
306	tcc_error("can't relocate value at %x,%d",addr, type);	306	tcc_error_noabort("can't relocate value at %x,%d",addr, type);
307		307
308	/* Compute and store final offset */	308	/* Compute and store final offset */
309	s = (x >> 24) & 1;	309	s = (x >> 24) & 1;
@@ -374,7 +374,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 64 unmodified lines
374	x = (x * 2) / 2;	374	x = (x * 2) / 2;
375	x += val - addr;	375	x += val - addr;
376	if((x^(x>>1))&0x40000000)	376	if((x^(x>>1))&0x40000000)
377	tcc_error("can't relocate value at %x,%d",addr, type);	377	tcc_error_noabort("can't relocate value at %x,%d",addr, type);
378	((int )ptr) \|= x & 0x7fffffff;	378	((int )ptr) \|= x & 0x7fffffff;
379	}	379	}
380	return;	380	return;

arm64-link.c+5−5

c67-link.c+1−1

@@ -67,7 +67,7 @@ int gotplt_entry_type (int reloc_type) · 66 unmodified lines
67		67
68	ST_FUNC unsigned create_plt_entry(TCCState s1, unsigned got_offset, struct sym_attr attr)	68	ST_FUNC unsigned create_plt_entry(TCCState s1, unsigned got_offset, struct sym_attr attr)
69	{	69	{
70	tcc_error("C67 got not implemented");	70	tcc_error_noabort("C67 got not implemented");
71	return 0;	71	return 0;
72	}	72	}
73		73

i386-link.c+3−3

@@ -227,7 +227,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 226 unmodified lines
227	case R_386_16:	227	case R_386_16:
228	if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {	228	if (s1->output_format != TCC_OUTPUT_FORMAT_BINARY) {
229	output_file:	229	output_file:
230	tcc_error("can only produce 16-bit binary files");	230	tcc_error_noabort("can only produce 16-bit binary files");
231	}	231	}
232	write16le(ptr, read16le(ptr) + val);	232	write16le(ptr, read16le(ptr) + val);
233	return;	233	return;
@@ -274,7 +274,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 40 unmodified lines
274	add32le(ptr + 5, -x);	274	add32le(ptr + 5, -x);
275	}	275	}
276	else	276	else
277	tcc_error("unexpected R_386_TLS_GD pattern");	277	tcc_error_noabort("unexpected R_386_TLS_GD pattern");
278	}	278	}
279	return;	279	return;
280	case R_386_TLS_LDM:	280	case R_386_TLS_LDM:
@@ -297,7 +297,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 16 unmodified lines
297	rel[1].r_info = ELFW(R_INFO)(0, R_386_NONE);	297	rel[1].r_info = ELFW(R_INFO)(0, R_386_NONE);
298	}	298	}
299	else	299	else
300	tcc_error("unexpected R_386_TLS_LDM pattern");	300	tcc_error_noabort("unexpected R_386_TLS_LDM pattern");
301	}	301	}
302	return;	302	return;
303	case R_386_TLS_LDO_32:	303	case R_386_TLS_LDO_32:

libtcc.c+55−48

 #undef malloc
 #undef realloc
+void mem_error(const char *msg)
+{
+    fprintf(stderr, "%s\n", msg);
+    exit (1);
+}
 #ifndef MEM_DEBUG
 PUB_FUNC void tcc_free(void *ptr)
     void *ptr;
     ptr = malloc(size);
     if (!ptr && size)
-        _tcc_error("memory full (malloc)");
+        mem_error("memory full (malloc)");
     return ptr;
 }
     void *ptr1;
     ptr1 = realloc(ptr, size);
     if (!ptr1 && size)
-        _tcc_error("memory full (realloc)");
+        mem_error("memory full (realloc)");
     return ptr1;
 }
     header = malloc(sizeof(mem_debug_header_t) + size);
     if (!header)
-        _tcc_error("memory full (malloc)");
+        mem_error("memory full (malloc)");
     header->magic1 = MEM_DEBUG_MAGIC1;
     header->magic2 = MEM_DEBUG_MAGIC2;
     mem_debug_chain_update = (header == mem_debug_chain);
     header = realloc(header, sizeof(mem_debug_header_t) + size);
     if (!header)
-        _tcc_error("memory full (realloc)");
+        mem_error("memory full (realloc)");
     header->size = size;
     write32le(MEM_DEBUG_CHECK3(header), MEM_DEBUG_MAGIC3);
     if (header->next)
     TCCState *s1 = tcc_state;
     CString cs;
-    cstr_new(&cs);
-    if (s1 == NULL)
-        /* can happen only if called from tcc_malloc(): 'out of memory' */
-        goto no_file;
     tcc_exit_state(s1);
     if (mode == ERROR_WARN) {
             return;
     }
+    cstr_new(&cs);
     f = NULL;
     if (s1->error_set_jmp_enabled) { /* we're called while parsing a file */
         /* use upper file if inline ":asm:" or token ":paste:" */
     } else if (s1->current_filename) {
         cstr_printf(&cs, "%s: ", s1->current_filename);
     }
-no_file:
     if (0 == cs.size)
         cstr_printf(&cs, "tcc: ");
     cstr_printf(&cs, mode == ERROR_WARN ? "warning: " : "error: ");
         s1->error_func(s1->error_opaque, (char*)cs.data);
     }
     cstr_free(&cs);
-    if (s1) {
+    if (mode != ERROR_WARN)
-        if (mode != ERROR_WARN)
+        s1->nb_errors++;
-            s1->nb_errors++;
+    if (mode == ERROR_ERROR && s1->error_set_jmp_enabled)
-        if (mode != ERROR_ERROR)
+        longjmp(s1->error_jmp_buf, 1);
-            return;
-        if (s1->error_set_jmp_enabled)
-            longjmp(s1->error_jmp_buf, 1);
-    }
-    exit(1);
 }
 LIBTCCAPI void tcc_set_error_func(TCCState *s, void *error_opaque, TCCErrorFunc error_func)
 }
 /* error without aborting current compilation */
-PUB_FUNC void _tcc_error_noabort(const char *fmt, ...)
+PUB_FUNC int _tcc_error_noabort(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
     error1(ERROR_NOABORT, fmt, ap);
     va_end(ap);
+    return -1;
 }
+#undef _tcc_error
 PUB_FUNC void _tcc_error(const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
-    for (;;) error1(ERROR_ERROR, fmt, ap);
+    error1(ERROR_ERROR, fmt, ap);
+    exit(1);
 }
+#define _tcc_error use_tcc_error_noabort
 PUB_FUNC void _tcc_warning(const char *fmt, ...)
 {
     va_end(ap);
 }
 /********************************************************/
 /* I/O layer */
     dynarray_reset(&s1->argv, &s1->argc);
     cstr_free(&s1->cmdline_defs);
     cstr_free(&s1->cmdline_incl);
+    cstr_free(&s1->linker_arg);
 #ifdef TCC_IS_NATIVE
     /* free runtime memory */
     tcc_run_free(s1);
 {
     if (-1 == tcc_add_library_internal(s1, "%s/%s",
         filename, 0, s1->crt_paths, s1->nb_crt_paths))
-        tcc_error_noabort("file '%s' not found", filename);
+        return tcc_error_noabort("file '%s' not found", filename);
     return 0;
 }
 #endif
             return 0;
         } else {
     err:
-            tcc_error("unsupported linker option '%s'", option);
+            return tcc_error_noabort("unsupported linker option '%s'", option);
         }
         if (ignoring)
             tcc_warning_c(warn_unsupported)("unsupported linker option '%s'", option);
 }
 /* read list file */
-static void args_parser_listfile(TCCState *s,
+static int args_parser_listfile(TCCState *s,
     const char *filename, int optind, int *pargc, char ***pargv)
 {
     TCCState *s1 = s;
     fd = open(filename, O_RDONLY | O_BINARY);
     if (fd < 0)
-        tcc_error("listfile '%s' not found", filename);
+        return tcc_error_noabort("listfile '%s' not found", filename);
     p = tcc_load_text(fd);
     for (i = 0; i < *pargc; ++i)
     tcc_free(p);
     dynarray_reset(&s->argv, &s->argc);
     *pargc = s->argc = argc, *pargv = s->argv = argv;
+    return 0;
 }
 #if defined TCC_TARGET_MACHO
              c = strtoul(&last[1], &last, 10);
     }
     if (*last || a > 0xffff || b > 0xff || c > 0xff)
-        tcc_error("version a.b.c not correct: %s", version);
+        tcc_error_noabort("version a.b.c not correct: %s", version);
     return (a << 16) | (b << 8) | c;
 }
 #endif
     const char *optarg, *r;
     const char *run = NULL;
     int x;
-    CString linker_arg; /* collect -Wl options */
     int tool = 0, arg_start = 0, noaction = optind;
     char **argv = *pargv;
     int argc = *pargc;
-    cstr_new(&linker_arg);
+    cstr_reset(&s->linker_arg);
     while (optind < argc) {
         r = argv[optind];
         if (r[0] == '@' && r[1] != '\0') {
-            args_parser_listfile(s, r + 1, optind, &argc, &argv);
+            if (args_parser_listfile(s, r + 1, optind, &argc, &argv))
+                return -1;
             continue;
         }
         optind++;
             if (r[0] != '@') /* allow "tcc file(s) -run @ args ..." */
                 args_parser_add_file(s, r, s->filetype);
             if (run) {
-                tcc_set_options(s, run);
+                if (tcc_set_options(s, run))
+                    return -1;
                 arg_start = optind - 1;
                 break;
             }
             const char *p1 = popt->name;
             const char *r1 = r + 1;
             if (p1 == NULL)
-                tcc_error("invalid option -- '%s'", r);
+                return tcc_error_noabort("invalid option -- '%s'", r);
             if (!strstart(p1, &r1))
                 continue;
             optarg = r1;
                 if (*r1 == '\0' && !(popt->flags & TCC_OPTION_NOSEP)) {
                     if (optind >= argc)
                 arg_err:
-                        tcc_error("argument to '%s' is missing", r);
+                        return tcc_error_noabort("argument to '%s' is missing", r);
                     optarg = argv[optind++];
                 }
             } else if (*r1 != '\0')
             break;
         case TCC_OPTION_run:
 #ifndef TCC_IS_NATIVE
-            tcc_error("-run is not available in a cross compiler");
+            return tcc_error_noabort("-run is not available in a cross compiler");
-#endif
+#else
             run = optarg;
             x = TCC_OUTPUT_MEMORY;
             goto set_output_type;
+#endif
         case TCC_OPTION_v:
             do ++s->verbose; while (*optarg++ == 'v');
             ++noaction;
             } else if (!strcmp(optarg, "hard"))
                 s->float_abi = ARM_HARD_FLOAT;
             else
-                tcc_error("unsupported float abi '%s'", optarg);
+                return tcc_error_noabort("unsupported float abi '%s'", optarg);
             break;
 #endif
         case TCC_OPTION_m:
             s->rdynamic = 1;
             break;
         case TCC_OPTION_Wl:
-            if (linker_arg.size)
+            if (s->linker_arg.size)
-                --linker_arg.size, cstr_ccat(&linker_arg, ',');
+                ((char*)s->linker_arg.data)[s->linker_arg.size - 1] = ',';
-            cstr_cat(&linker_arg, optarg, 0);
+            cstr_cat(&s->linker_arg, optarg, 0);
-            if (tcc_set_linker(s, linker_arg.data))
+            x = tcc_set_linker(s, s->linker_arg.data);
-                cstr_free(&linker_arg);
+            if (x)
+                cstr_reset(&s->linker_arg);
+            if (x < 0)
+                return -1;
             break;
         case TCC_OPTION_Wp:
             r = optarg;
         extra_action:
             arg_start = optind - 1;
             if (arg_start != noaction)
-                tcc_error("cannot parse %s here", r);
+                return tcc_error_noabort("cannot parse %s here", r);
             tool = x;
             break;
         default:
             break;
         }
     }
-    if (linker_arg.size) {
+    if (s->linker_arg.size) {
-        r = linker_arg.data;
+        r = s->linker_arg.data;
         goto arg_err;
     }
     *pargc = argc - arg_start;
     return OPT_HELP;
 }
-LIBTCCAPI void tcc_set_options(TCCState *s, const char *r)
+LIBTCCAPI int tcc_set_options(TCCState *s, const char *r)
 {
     char **argv = NULL;
-    int argc = 0;
+    int argc = 0, ret;
     args_parser_make_argv(r, &argc, &argv);
-    tcc_parse_args(s, &argc, &argv, 0);
+    ret = tcc_parse_args(s, &argc, &argv, 0);
     dynarray_reset(&argv, &argc);
+    return ret < 0 ? ret : 0;
 }
 PUB_FUNC void tcc_print_stats(TCCState *s1, unsigned total_time)

libtcc.h+1−1

@@ -34,7 +34,7 @@ LIBTCCAPI TCCErrorFunc tcc_get_error_func(TCCState *s); · 33 unmodified lines
34	LIBTCCAPI void tcc_get_error_opaque(TCCState s);	34	LIBTCCAPI void tcc_get_error_opaque(TCCState s);
35		35
36	/* set options as from command line (multiple supported) */	36	/* set options as from command line (multiple supported) */
37	LIBTCCAPI void tcc_set_options(TCCState s, const char str);	37	LIBTCCAPI int tcc_set_options(TCCState s, const char str);
38		38
39	/*****************************/	39	/*****************************/
40	/* preprocessor */	40	/* preprocessor */

riscv64-link.c+10−10

@@ -127,7 +127,7 @@ ST_FUNC void relocate_plt(TCCState *s1) · 126 unmodified lines
127	uint64_t got = s1->got->sh_addr;	127	uint64_t got = s1->got->sh_addr;
128	uint64_t off = (got - plt + 0x800) >> 12;	128	uint64_t off = (got - plt + 0x800) >> 12;
129	if ((off + ((uint32_t)1 << 20)) >> 21)	129	if ((off + ((uint32_t)1 << 20)) >> 21)
130	tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);	130	tcc_error_noabort("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
131	write32le(p, 0x397 \| (off << 12)); // auipc t2, %pcrel_hi(got)	131	write32le(p, 0x397 \| (off << 12)); // auipc t2, %pcrel_hi(got)
132	write32le(p + 4, 0x41c30333); // sub t1, t1, t3	132	write32le(p + 4, 0x41c30333); // sub t1, t1, t3
133	write32le(p + 8, 0x0003be03 // ld t3, %pcrel_lo(got)(t2)	133	write32le(p + 8, 0x0003be03 // ld t3, %pcrel_lo(got)(t2)
@@ -144,7 +144,7 @@ ST_FUNC void relocate_plt(TCCState *s1) · 10 unmodified lines
144	uint64_t addr = got + read64le(p);	144	uint64_t addr = got + read64le(p);
145	uint64_t off = (addr - pc + 0x800) >> 12;	145	uint64_t off = (addr - pc + 0x800) >> 12;
146	if ((off + ((uint32_t)1 << 20)) >> 21)	146	if ((off + ((uint32_t)1 << 20)) >> 21)
147	tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);	147	tcc_error_noabort("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
148	write32le(p, 0xe17 \| (off << 12)); // auipc t3, %pcrel_hi(func@got)	148	write32le(p, 0xe17 \| (off << 12)); // auipc t3, %pcrel_hi(func@got)
149	write32le(p + 4, 0x000e3e03 // ld t3, %pcrel_lo(func@got)(t3)	149	write32le(p + 4, 0x000e3e03 // ld t3, %pcrel_lo(func@got)(t3)
150	\| (((addr - pc) & 0xfff) << 20));	150	\| (((addr - pc) & 0xfff) << 20));
@@ -179,7 +179,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 28 unmodified lines
179	case R_RISCV_BRANCH:	179	case R_RISCV_BRANCH:
180	off64 = val - addr;	180	off64 = val - addr;
181	if ((off64 + (1 << 12)) & ~(uint64_t)0x1ffe)	181	if ((off64 + (1 << 12)) & ~(uint64_t)0x1ffe)
182	tcc_error("R_RISCV_BRANCH relocation failed"	182	tcc_error_noabort("R_RISCV_BRANCH relocation failed"
183	" (val=%lx, addr=%lx)", (long)val, (long)addr);	183	" (val=%lx, addr=%lx)", (long)val, (long)addr);
184	off32 = off64 >> 1;	184	off32 = off64 >> 1;
185	write32le(ptr, (read32le(ptr) & ~0xfe000f80)	185	write32le(ptr, (read32le(ptr) & ~0xfe000f80)
@@ -191,7 +191,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 5 unmodified lines
191	case R_RISCV_JAL:	191	case R_RISCV_JAL:
192	off64 = val - addr;	192	off64 = val - addr;
193	if ((off64 + (1 << 21)) & ~(((uint64_t)1 << 22) - 2))	193	if ((off64 + (1 << 21)) & ~(((uint64_t)1 << 22) - 2))
194	tcc_error("R_RISCV_JAL relocation failed"	194	tcc_error_noabort("R_RISCV_JAL relocation failed"
195	" (val=%lx, addr=%lx)", (long)val, (long)addr);	195	" (val=%lx, addr=%lx)", (long)val, (long)addr);
196	off32 = off64;	196	off32 = off64;
197	write32le(ptr, (read32le(ptr) & 0xfff)	197	write32le(ptr, (read32le(ptr) & 0xfff)
@@ -213,7 +213,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 15 unmodified lines
213	#endif	213	#endif
214	off64 = (int64_t)(val - addr + 0x800) >> 12;	214	off64 = (int64_t)(val - addr + 0x800) >> 12;
215	if ((off64 + ((uint64_t)1 << 20)) >> 21)	215	if ((off64 + ((uint64_t)1 << 20)) >> 21)
216	tcc_error("R_RISCV_PCREL_HI20 relocation failed: off=%lx cond=%lx sym=%s",	216	tcc_error_noabort("R_RISCV_PCREL_HI20 relocation failed: off=%lx cond=%lx sym=%s",
217	(long)off64, (long)((int64_t)(off64 + ((uint64_t)1 << 20)) >> 21),	217	(long)off64, (long)((int64_t)(off64 + ((uint64_t)1 << 20)) >> 21),
218	symtab_section->link->data + sym->st_name);	218	symtab_section->link->data + sym->st_name);
219	write32le(ptr, (read32le(ptr) & 0xfff)	219	write32le(ptr, (read32le(ptr) & 0xfff)
@@ -225,7 +225,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 5 unmodified lines
225	val = s1->got->sh_addr + get_sym_attr(s1, sym_index, 0)->got_offset;	225	val = s1->got->sh_addr + get_sym_attr(s1, sym_index, 0)->got_offset;
226	off64 = (int64_t)(val - addr + 0x800) >> 12;	226	off64 = (int64_t)(val - addr + 0x800) >> 12;
227	if ((off64 + ((uint64_t)1 << 20)) >> 21)	227	if ((off64 + ((uint64_t)1 << 20)) >> 21)
228	tcc_error("R_RISCV_GOT_HI20 relocation failed");	228	tcc_error_noabort("R_RISCV_GOT_HI20 relocation failed");
229	last_hi.addr = addr;	229	last_hi.addr = addr;
230	last_hi.val = val;	230	last_hi.val = val;
231	write32le(ptr, (read32le(ptr) & 0xfff)	231	write32le(ptr, (read32le(ptr) & 0xfff)
@@ -236,7 +236,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 4 unmodified lines
236	printf("PCREL_LO12_I: val=%lx addr=%lx\n", (long)val, (long)addr);	236	printf("PCREL_LO12_I: val=%lx addr=%lx\n", (long)val, (long)addr);
237	#endif	237	#endif
238	if (val != last_hi.addr)	238	if (val != last_hi.addr)
239	tcc_error("unsupported hi/lo pcrel reloc scheme");	239	tcc_error_noabort("unsupported hi/lo pcrel reloc scheme");
240	val = last_hi.val;	240	val = last_hi.val;
241	addr = last_hi.addr;	241	addr = last_hi.addr;
242	write32le(ptr, (read32le(ptr) & 0xfffff)	242	write32le(ptr, (read32le(ptr) & 0xfffff)
@@ -244,7 +244,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 1 unmodified line
244	return;	244	return;
245	case R_RISCV_PCREL_LO12_S:	245	case R_RISCV_PCREL_LO12_S:
246	if (val != last_hi.addr)	246	if (val != last_hi.addr)
247	tcc_error("unsupported hi/lo pcrel reloc scheme");	247	tcc_error_noabort("unsupported hi/lo pcrel reloc scheme");
248	val = last_hi.val;	248	val = last_hi.val;
249	addr = last_hi.addr;	249	addr = last_hi.addr;
250	off32 = val - addr;	250	off32 = val - addr;
@@ -256,7 +256,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 5 unmodified lines
256	case R_RISCV_RVC_BRANCH:	256	case R_RISCV_RVC_BRANCH:
257	off64 = (val - addr);	257	off64 = (val - addr);
258	if ((off64 + (1 << 8)) & ~(uint64_t)0x1fe)	258	if ((off64 + (1 << 8)) & ~(uint64_t)0x1fe)
259	tcc_error("R_RISCV_RVC_BRANCH relocation failed"	259	tcc_error_noabort("R_RISCV_RVC_BRANCH relocation failed"
260	" (val=%lx, addr=%lx)", (long)val, (long)addr);	260	" (val=%lx, addr=%lx)", (long)val, (long)addr);
261	off32 = off64;	261	off32 = off64;
262	write16le(ptr, (read16le(ptr) & 0xe383)	262	write16le(ptr, (read16le(ptr) & 0xe383)
@@ -269,7 +269,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, · 6 unmodified lines
269	case R_RISCV_RVC_JUMP:	269	case R_RISCV_RVC_JUMP:
270	off64 = (val - addr);	270	off64 = (val - addr);
271	if ((off64 + (1 << 11)) & ~(uint64_t)0xffe)	271	if ((off64 + (1 << 11)) & ~(uint64_t)0xffe)
272	tcc_error("R_RISCV_RVC_BRANCH relocation failed"	272	tcc_error_noabort("R_RISCV_RVC_BRANCH relocation failed"
273	" (val=%lx, addr=%lx)", (long)val, (long)addr);	273	" (val=%lx, addr=%lx)", (long)val, (long)addr);
274	off32 = off64;	274	off32 = off64;
275	write16le(ptr, (read16le(ptr) & 0xe003)	275	write16le(ptr, (read16le(ptr) & 0xe003)

tcc.c+13−11

@@ -286,6 +286,8 @@ redo: · 285 unmodified lines
286	tcc_set_options(s, CONFIG_TCC_SWITCHES);	286	tcc_set_options(s, CONFIG_TCC_SWITCHES);
287	#endif	287	#endif
288	opt = tcc_parse_args(s, &argc, &argv, 1);	288	opt = tcc_parse_args(s, &argc, &argv, 1);
		289	if (opt < 0)
		290	return 1;
289		291
290	if (n == 0) {	292	if (n == 0) {
291	if (opt == OPT_HELP) {	293	if (opt == OPT_HELP) {
@@ -299,7 +301,7 @@ redo: · 7 unmodified lines
299	return 0;	301	return 0;
300	}	302	}
301	if (opt == OPT_M32 \|\| opt == OPT_M64)	303	if (opt == OPT_M32 \|\| opt == OPT_M64)
302	tcc_tool_cross(s, argv, opt); /* never returns */	304	return tcc_tool_cross(s, argv, opt);
303	if (s->verbose)	305	if (s->verbose)
304	printf(version);	306	printf(version);
305	if (opt == OPT_AR)	307	if (opt == OPT_AR)
@@ -318,22 +320,22 @@ redo: · 12 unmodified lines
318	return 0;	320	return 0;
319	}	321	}
320		322
321	if (s->nb_files == 0)	323	if (s->nb_files == 0) {
322	tcc_error("no input files");	324	tcc_error_noabort("no input files");
323		325	} else if (s->output_type == TCC_OUTPUT_PREPROCESS) {
324	if (s->output_type == TCC_OUTPUT_PREPROCESS) {
325	if (s->outfile && 0!=strcmp("-",s->outfile)) {	326	if (s->outfile && 0!=strcmp("-",s->outfile)) {
326	ppfp = fopen(s->outfile, "w");	327	ppfp = fopen(s->outfile, "w");
327	if (!ppfp)	328	if (!ppfp)
328	tcc_error("could not write '%s'", s->outfile);	329	tcc_error_noabort("could not write '%s'", s->outfile);
329	}	330	}
330	} else if (s->output_type == TCC_OUTPUT_OBJ && !s->option_r) {	331	} else if (s->output_type == TCC_OUTPUT_OBJ && !s->option_r) {
331	if (s->nb_libraries)	332	if (s->nb_libraries)
332	tcc_error("cannot specify libraries with -c");	333	tcc_error_noabort("cannot specify libraries with -c");
333	if (s->nb_files > 1 && s->outfile)	334	else if (s->nb_files > 1 && s->outfile)
334	tcc_error("cannot specify output file with -c many files");	335	tcc_error_noabort("cannot specify output file with -c many files");
335	}	336	}
336		337	if (s->nb_errors)
		338	return 1;
337	if (s->do_bench)	339	if (s->do_bench)
338	start_time = getclock_ms();	340	start_time = getclock_ms();
339	}	341	}
@@ -391,7 +393,7 @@ redo: · 51 unmodified lines
391	if (!s->just_deps && tcc_output_file(s, s->outfile))	393	if (!s->just_deps && tcc_output_file(s, s->outfile))
392	ret = 1;	394	ret = 1;
393	else if (s->gen_deps)	395	else if (s->gen_deps)
394	gen_makedeps(s, s->outfile, s->deps_outfile);	396	ret = gen_makedeps(s, s->outfile, s->deps_outfile);
395	}	397	}
396	}	398	}
397		399

tcc.h+6−3

     char *deps_outfile; /* option -MF */
     int argc;
     char **argv;
+    CString linker_arg; /* collect -Wl options */
 };
 struct filespec {
 #define realloc(p, s) use_tcc_realloc(p, s)
 #undef strdup
 #define strdup(s) use_tcc_strdup(s)
-PUB_FUNC void _tcc_error_noabort(const char *fmt, ...) PRINTF_LIKE(1,2);
+PUB_FUNC int _tcc_error_noabort(const char *fmt, ...) PRINTF_LIKE(1,2);
 PUB_FUNC NORETURN void _tcc_error(const char *fmt, ...) PRINTF_LIKE(1,2);
 PUB_FUNC void _tcc_warning(const char *fmt, ...) PRINTF_LIKE(1,2);
 #define tcc_internal_error(msg) tcc_error("internal compiler error\n"\
 #ifdef TCC_TARGET_PE
 ST_FUNC int tcc_tool_impdef(TCCState *s, int argc, char **argv);
 #endif
-ST_FUNC void tcc_tool_cross(TCCState *s, char **argv, int option);
+ST_FUNC int tcc_tool_cross(TCCState *s, char **argv, int option);
-ST_FUNC void gen_makedeps(TCCState *s, const char *target, const char *filename);
+ST_FUNC int gen_makedeps(TCCState *s, const char *target, const char *filename);
 #endif
 /* ------------ tccdbg.c ------------ */
 # define TCC_STATE_VAR(sym) tcc_state->sym
 # define TCC_SET_STATE(fn) fn
 # undef USING_GLOBALS
+# undef _tcc_error
 #else
 # define TCC_STATE_VAR(sym) s1->sym
 # define TCC_SET_STATE(fn) (tcc_enter_state(s1),fn)
+# define _tcc_error use_tcc_error_noabort
 #endif

tcccoff.c+3−0

@@ -21,6 +21,9 @@ · 20 unmodified lines
21		21
22	#include "tcc.h"	22	#include "tcc.h"
23		23
		24	/* XXX: this file uses tcc_error() to the effect of exit(1) */
		25	#undef _tcc_error
		26
24	#define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS */	27	#define MAXNSCNS 255 /* MAXIMUM NUMBER OF SECTIONS */
25	#define MAX_STR_TABLE 1000000	28	#define MAX_STR_TABLE 1000000
26	AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER */	29	AOUTHDR o_filehdr; /* OPTIONAL (A.OUT) FILE HEADER */

tccelf.c+45−53

     sym = &((ElfW(Sym) *)s1->symtab->data)[sym_index];
     if (!sym_index || sym->st_shndx == SHN_UNDEF) {
         if (err)
-            tcc_error("%s not defined", name);
+            tcc_error_noabort("%s not defined", name);
         return (addr_t)-1;
     }
     return sym->st_value;
     rel->r_addend = addend;
 #endif
     if (SHT_RELX != SHT_RELA && addend)
-        tcc_error("non-zero addend on REL architecture");
+        tcc_error_noabort("non-zero addend on REL architecture");
 }
 ST_FUNC void put_elf_reloc(Section *symtab, Section *s, unsigned long offset,
 				 PTR_SIZE * bloom_size +
 				 nbuckets * 4 +
 				 (nb_syms - (q - new_syms)) * 4)
-	tcc_error ("gnu_hash size incorrect");
+	tcc_error_noabort ("gnu_hash size incorrect");
     /* find buckets */
     for(i = 0; i < nbuckets; i++)
         for_each_elem(s, 0, rel, ElfW_Rel) {
             type = ELFW(R_TYPE)(rel->r_info);
             gotplt_entry = gotplt_entry_type(type);
-            if (gotplt_entry == -1)
+            if (gotplt_entry == -1) {
-                tcc_error ("Unknown relocation type for got: %d", type);
+                tcc_error_noabort ("Unknown relocation type for got: %d", type);
+                continue;
+            }
             sym_index = ELFW(R_SYM)(rel->r_info);
             sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
             }
 #endif
             reloc_type = code_reloc(type);
-            if (reloc_type == -1)
+            if (reloc_type == -1) {
-                tcc_error ("Unknown relocation type: %d", type);
+                tcc_error_noabort ("Unknown relocation type: %d", type);
+                continue;
+            }
             if (reloc_type != 0) {
         jmp_slot:
 	    struct sym_attr *attr = get_sym_attr(s1, sym_index, 0);
 	    unsigned offset = attr->got_offset;
 	    if (offset != rel->r_offset - s1->got->sh_addr)
-	      tcc_error_noabort("huh");
+	        tcc_error_noabort("fill_local_got_entries: huh?");
 	    rel->r_info = ELFW(R_INFO)(0, R_RELATIVE);
 #if SHT_RELX == SHT_RELA
 	    rel->r_addend = sym->st_value;
 /* Create an ELF file on disk.
    This function handle ELF specific layout requirements */
-static void tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
+static int tcc_output_elf(TCCState *s1, FILE *f, int phnum, ElfW(Phdr) *phdr,
                            int file_offset, int *sec_order)
 {
     int i, shnum, offset, size, file_type;
             ehdr.e_entry = get_sym_addr(s1, "_start", !!(file_type & TCC_OUTPUT_EXE), 0);
         if (ehdr.e_entry == (addr_t)-1)
             ehdr.e_entry = text_section->sh_addr;
+        if (s1->nb_errors)
+            return -1;
     }
     ehdr.e_machine = EM_TCC_TARGET;
         }
         fwrite(sh, 1, sizeof(ElfW(Shdr)), f);
     }
+    return 0;
 }
-static void tcc_output_binary(TCCState *s1, FILE *f,
+static int tcc_output_binary(TCCState *s1, FILE *f,
                               const int *sec_order)
 {
     Section *s;
             offset += size;
         }
     }
+    return 0;
 }
 /* Write an elf, coff or "binary" file */
 static int tcc_write_elf_file(TCCState *s1, const char *filename, int phnum,
                               ElfW(Phdr) *phdr, int file_offset, int *sec_order)
 {
-    int fd, mode, file_type;
+    int fd, mode, file_type, ret;
     FILE *f;
     file_type = s1->output_type;
         mode = 0777;
     unlink(filename);
     fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
-    if (fd < 0 || (f = fdopen(fd, "wb")) == NULL) {
+    if (fd < 0 || (f = fdopen(fd, "wb")) == NULL)
-        tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
+        return tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
-        return -1;
-    }
     if (s1->verbose)
         printf("<- %s\n", filename);
 #ifdef TCC_TARGET_COFF
     if (s1->output_format == TCC_OUTPUT_FORMAT_COFF)
         tcc_output_coff(s1, f);
     else
 #endif
     if (s1->output_format == TCC_OUTPUT_FORMAT_ELF)
-        tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
+        ret = tcc_output_elf(s1, f, phnum, phdr, file_offset, sec_order);
     else
-        tcc_output_binary(s1, f, sec_order);
+        ret = tcc_output_binary(s1, f, sec_order);
     fclose(f);
-    return 0;
+    return ret;
 }
 #ifndef ELF_OBJ_ONLY
     lseek(fd, file_offset, SEEK_SET);
     if (tcc_object_type(fd, &ehdr) != AFF_BINTYPE_REL)
-        goto fail1;
+        goto invalid;
     /* test CPU specific stuff */
     if (ehdr.e_ident[5] != ELFDATA2LSB ||
         ehdr.e_machine != EM_TCC_TARGET) {
-    fail1:
+invalid:
-        tcc_error_noabort("invalid object file");
+        return tcc_error_noabort("invalid object file");
-        return -1;
     }
     /* read sections */
     shdr = load_data(fd, file_offset + ehdr.e_shoff,
     nb_syms = 0;
     seencompressed = 0;
     stab_index = stabstr_index = 0;
+    ret = -1;
     for(i = 1; i < ehdr.e_shnum; i++) {
         sh = &shdr[i];
         if (sh->sh_type == SHT_SYMTAB) {
             if (symtab) {
                 tcc_error_noabort("object must contain only one symtab");
-            fail:
-                ret = -1;
                 goto the_end;
             }
             nb_syms = sh->sh_size / sizeof(ElfW(Sym));
         s->sh_entsize = sh->sh_entsize;
         sm_table[i].new_section = 1;
     found:
-        if (sh->sh_type != s->sh_type) {
+        if (sh->sh_type != s->sh_type
 #if TARGETOS_OpenBSD || TARGETOS_FreeBSD || TARGETOS_NetBSD
-            if (strcmp (s->name, ".eh_frame"))
+            && strcmp (s->name, ".eh_frame")
 #endif
-            {
+            ) {
-                tcc_error_noabort("invalid section type");
+            tcc_error_noabort("invalid section type");
-                goto fail;
+            goto the_end;
-	    }
         }
         /* align start of section */
         s->data_offset += -s->data_offset & (sh->sh_addralign - 1);
                 invalid_reloc:
                     tcc_error_noabort("Invalid relocation entry [%2d] '%s' @ %.8x",
                         i, strsec + sh->sh_name, (int)rel->r_offset);
-                    goto fail;
+                    goto the_end;
                 }
                 rel->r_info = ELFW(R_INFO)(sym_index, type);
                 /* offset the relocation offset */
         len = read_ar_header(fd, file_offset, &hdr);
         if (len == 0)
             return 0;
-        if (len < 0) {
+        if (len < 0)
-            tcc_error_noabort("invalid archive");
+            return tcc_error_noabort("invalid archive");
-            return -1;
-        }
         file_offset += len;
         size = strtol(hdr.ar_size, NULL, 0);
         /* align to even */
     /* test CPU specific stuff */
     if (ehdr.e_ident[5] != ELFDATA2LSB ||
         ehdr.e_machine != EM_TCC_TARGET) {
-        tcc_error_noabort("bad architecture");
+        return tcc_error_noabort("bad architecture");
-        return -1;
     }
     /* read sections */
             if (tcc_add_dllref(s1, name, -1))
                 continue;
             if (tcc_add_dll(s1, name, AFF_REFERENCED_DLL) < 0) {
-                tcc_error_noabort("referenced dll '%s' not found", name);
+                ret = tcc_error_noabort("referenced dll '%s' not found", name);
                 goto the_end;
             }
         }
         s1->new_undef_sym = 0;
     t = ld_next(s1, filename, sizeof(filename));
     if (t != '(') {
-        tcc_error_noabort("( expected");
+        ret = tcc_error_noabort("( expected");
-        ret = -1;
         goto lib_parse_error;
     }
     t = ld_next(s1, filename, sizeof(filename));
     for(;;) {
         libname[0] = '\0';
         if (t == LD_TOK_EOF) {
-            tcc_error_noabort("unexpected end of file");
+            ret = tcc_error_noabort("unexpected end of file");
-            ret = -1;
             goto lib_parse_error;
         } else if (t == ')') {
             break;
         } else if (t == '-') {
             t = ld_next(s1, filename, sizeof(filename));
             if ((t != LD_TOK_NAME) || (filename[0] != 'l')) {
-                tcc_error_noabort("library name expected");
+                ret = tcc_error_noabort("library name expected");
-                ret = -1;
                 goto lib_parse_error;
             }
             pstrcpy(libname, sizeof libname, &filename[1]);
                 snprintf(filename, sizeof filename, "lib%s.so", libname);
             }
         } else if (t != LD_TOK_NAME) {
-            tcc_error_noabort("filename expected");
+            ret = tcc_error_noabort("filename expected");
-            ret = -1;
             goto lib_parse_error;
         }
         if (!strcmp(filename, "AS_NEEDED")) {
                    !strcmp(cmd, "TARGET")) {
             /* ignore some commands */
             t = ld_next(s1, cmd, sizeof(cmd));
-            if (t != '(') {
+            if (t != '(')
-                tcc_error_noabort("( expected");
+                return tcc_error_noabort("( expected");
-                return -1;
-            }
             for(;;) {
                 t = ld_next(s1, filename, sizeof(filename));
                 if (t == LD_TOK_EOF) {
-                    tcc_error_noabort("unexpected end of file");
+                    return tcc_error_noabort("unexpected end of file");
-                    return -1;
                 } else if (t == ')') {
                     break;
                 }

tccgen.c+1−2

 	}
 	goto redo;
     } else if (!combine_types(&combtype, vtop - 1, vtop, op)) {
-        tcc_error_noabort("invalid operand types for binary operation");
+        tcc_error("invalid operand types for binary operation");
-        vpop();
     } else if (bt1 == VT_PTR || bt2 == VT_PTR) {
         /* at least one operand is a pointer */
         /* relational op: must be both pointers */

tccmacho.c+3−0

@@ -35,6 +35,9 @@ · 34 unmodified lines
35	#error Platform not supported	35	#error Platform not supported
36	#endif	36	#endif
37		37
		38	/* XXX: this file uses tcc_error() to the effect of exit(1) */
		39	#undef _tcc_error
		40
38	#define DEBUG_MACHO 0	41	#define DEBUG_MACHO 0
39	#define dprintf if (DEBUG_MACHO) printf	42	#define dprintf if (DEBUG_MACHO) printf
40		43

tccpe.c+8−17

     TCCState *s1 = pe->s1;
     pf.op = fopen(pe->filename, "wb");
-    if (NULL == pf.op) {
+    if (NULL == pf.op)
-        tcc_error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
+        return tcc_error_noabort("could not write '%s': %s", pe->filename, strerror(errno));
-        return -1;
-    }
     pe->sizeofheaders = pe_file_align(pe,
         sizeof (struct pe_header)
             if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
                 /* STB_WEAK undefined symbols are accepted */
                 continue;
-            tcc_error_noabort("undefined symbol '%s'%s", name,
+            ret = tcc_error_noabort("undefined symbol '%s'%s", name,
                 imp_sym < 0 ? ", missing __declspec(dllimport)?":"");
-            ret = -1;
         } else if (pe->s1->rdynamic
                    && ELFW(ST_BIND)(sym->st_info) != STB_LOCAL) {
 ST_FUNC int pe_output_file(TCCState *s1, const char *filename)
 {
-    int ret;
     struct pe_info pe;
     memset(&pe, 0, sizeof pe);
     pe_add_runtime(s1, &pe);
     resolve_common_syms(s1);
     pe_set_options(s1, &pe);
+    pe_check_symbols(&pe);
-    ret = pe_check_symbols(&pe);
+    if (s1->nb_errors)
-    if (ret)
         ;
     else if (filename) {
         pe_assign_addresses(&pe);
         relocate_sections(s1);
         pe.start_addr = (DWORD)
             (get_sym_addr(s1, pe.start_symbol, 1, 1) - pe.imagebase);
-        if (s1->nb_errors)
+        if (0 == s1->nb_errors)
-            ret = -1;
+            pe_write(&pe);
-        else
-            ret = pe_write(&pe);
         dynarray_reset(&pe.sec_info, &pe.sec_count);
     } else {
 #ifdef TCC_IS_NATIVE
 #endif
 #endif
     }
     pe_free_imports(&pe);
 #if PE_PRINT_SECTIONS
     if (s1->g_debug & 8)
         pe_print_sections(s1, "tcc.log");
 #endif
-    return ret;
+    return s1->nb_errors ? -1 : 0;
 }
 /* ------------------------------------------------------------- */

tccrun.c+17−11

@@ -63,7 +63,7 @@ static void rt_exit(int code); · 62 unmodified lines
63	# include <sys/mman.h>	63	# include <sys/mman.h>
64	#endif	64	#endif
65		65
66	static void set_pages_executable(TCCState s1, int mode, void ptr, unsigned long length);	66	static int set_pages_executable(TCCState s1, int mode, void ptr, unsigned long length);
67	static int tcc_relocate_ex(TCCState s1, void ptr, addr_t ptr_diff);	67	static int tcc_relocate_ex(TCCState s1, void ptr, addr_t ptr_diff);
68		68
69	#ifdef _WIN64	69	#ifdef _WIN64
@@ -100,16 +100,17 @@ LIBTCCAPI int tcc_relocate(TCCState s1, void ptr) · 30 unmodified lines
100	ptr = mmap(NULL, size * 2, PROT_READ\|PROT_WRITE, MAP_SHARED, fd, 0);	100	ptr = mmap(NULL, size * 2, PROT_READ\|PROT_WRITE, MAP_SHARED, fd, 0);
101	/* mmap RX memory at a fixed distance */	101	/* mmap RX memory at a fixed distance */
102	prx = mmap((char*)ptr + size, size, PROT_READ\|PROT_EXEC, MAP_SHARED\|MAP_FIXED, fd, 0);	102	prx = mmap((char*)ptr + size, size, PROT_READ\|PROT_EXEC, MAP_SHARED\|MAP_FIXED, fd, 0);
		103	close(fd);
103	if (ptr == MAP_FAILED \|\| prx == MAP_FAILED)	104	if (ptr == MAP_FAILED \|\| prx == MAP_FAILED)
104	tcc_error("tccrun: could not map memory");	105	return tcc_error_noabort("tccrun: could not map memory");
105	ptr_diff = (char)prx - (char)ptr;	106	ptr_diff = (char)prx - (char)ptr;
106	close(fd);
107	//printf("map %p %p %p\n", ptr, prx, (void*)ptr_diff);	107	//printf("map %p %p %p\n", ptr, prx, (void*)ptr_diff);
108	}	108	}
109	#else	109	#else
110	ptr = tcc_malloc(size);	110	ptr = tcc_malloc(size);
111	#endif	111	#endif
112	tcc_relocate_ex(s1, ptr, ptr_diff); /* no more errors expected */	112	if (tcc_relocate_ex(s1, ptr, ptr_diff))
		113	return -1;
113	dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, (void*)(addr_t)size);	114	dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, (void*)(addr_t)size);
114	dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, ptr);	115	dynarray_add(&s1->runtime_mem, &s1->nb_runtime_mem, ptr);
115	return 0;	116	return 0;
@@ -237,6 +238,8 @@ LIBTCCAPI int tcc_run(TCCState s1, int argc, char *argv) · 121 unmodified lines
237	if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)	238	if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
238	return -1;	239	return -1;
239	prog_main = (void*)get_sym_addr(s1, s1->runtime_main, 1, 1);	240	prog_main = (void*)get_sym_addr(s1, s1->runtime_main, 1, 1);
		241	if ((addr_t)-1 == (addr_t)prog_main)
		242	return -1;
240		243
241	#ifdef CONFIG_TCC_BACKTRACE	244	#ifdef CONFIG_TCC_BACKTRACE
242	memset(rc, 0, sizeof *rc);	245	memset(rc, 0, sizeof *rc);
@@ -409,8 +412,10 @@ redo: · 166 unmodified lines
409	#if DEBUG_RUNMEN	412	#if DEBUG_RUNMEN
410	printf("protect %d %p %04x\n", f, (void*)addr, n);	413	printf("protect %d %p %04x\n", f, (void*)addr, n);
411	#endif	414	#endif
412	if (n)	415	if (n) {
413	set_pages_executable(s1, f, (void*)addr, n);	416	if (set_pages_executable(s1, f, (void*)addr, n))
		417	return -1;
		418	}
414	}	419	}
415	}	420	}
416		421
@@ -440,7 +445,7 @@ redo: · 23 unmodified lines
440	/* ------------------------------------------------------------- */	445	/* ------------------------------------------------------------- */
441	/* allow to run code in memory */	446	/* allow to run code in memory */
442		447
443	static void set_pages_executable(TCCState s1, int mode, void ptr, unsigned long length)	448	static int set_pages_executable(TCCState s1, int mode, void ptr, unsigned long length)
444	{	449	{
445	#ifdef _WIN32	450	#ifdef _WIN32
446	static const unsigned char protect[] = {	451	static const unsigned char protect[] = {
@@ -450,7 +455,9 @@ static void set_pages_executable(TCCState s1, int mode, void ptr, unsigned lon · 3 unmodified lines
450	PAGE_EXECUTE_READWRITE	455	PAGE_EXECUTE_READWRITE
451	};	456	};
452	DWORD old;	457	DWORD old;
453	VirtualProtect(ptr, length, protect[mode], &old);	458	if (!VirtualProtect(ptr, length, protect[mode], &old))
		459	return -1;
		460	return 0;
454	#else	461	#else
455	static const unsigned char protect[] = {	462	static const unsigned char protect[] = {
456	PROT_READ \| PROT_EXEC,	463	PROT_READ \| PROT_EXEC,
@@ -463,8 +470,7 @@ static void set_pages_executable(TCCState s1, int mode, void ptr, unsigned lon · 6 unmodified lines
463	end = (addr_t)ptr + length;	470	end = (addr_t)ptr + length;
464	end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);	471	end = (end + PAGESIZE - 1) & ~(PAGESIZE - 1);
465	if (mprotect((void *)start, end - start, protect[mode]))	472	if (mprotect((void *)start, end - start, protect[mode]))
466	tcc_error("mprotect failed: did you mean to configure --with-selinux?");	473	return tcc_error_noabort("mprotect failed: did you mean to configure --with-selinux?");
467
468	/* XXX: BSD sometimes dump core with bad system call */	474	/* XXX: BSD sometimes dump core with bad system call */
469	# if (defined TCC_TARGET_ARM && !TARGETOS_BSD) \|\| defined TCC_TARGET_ARM64	475	# if (defined TCC_TARGET_ARM && !TARGETOS_BSD) \|\| defined TCC_TARGET_ARM64
470	if (mode == 0 \|\| mode == 3) {	476	if (mode == 0 \|\| mode == 3) {
@@ -472,7 +478,7 @@ static void set_pages_executable(TCCState s1, int mode, void ptr, unsigned lon · 1 unmodified line
472	__clear_cache(ptr, (char *)ptr + length);	478	__clear_cache(ptr, (char *)ptr + length);
473	}	479	}
474	# endif	480	# endif
475		481	return 0;
476	#endif	482	#endif
477	}	483	}
478		484

tcctools.c+12−9

 #if !defined TCC_TARGET_I386 && !defined TCC_TARGET_X86_64
-ST_FUNC void tcc_tool_cross(TCCState *s1, char **argv, int option)
+ST_FUNC int tcc_tool_cross(TCCState *s1, char **argv, int option)
 {
-    tcc_error("-m%d not implemented.", option);
+    tcc_error_noabort("-m%d not implemented.", option);
+    return 1;
 }
 #else
 #define execvp execvp_win32
 #endif /* _WIN32 */
-ST_FUNC void tcc_tool_cross(TCCState *s1, char **argv, int target)
+ST_FUNC int tcc_tool_cross(TCCState *s1, char **argv, int target)
 {
     char program[4096];
     char *a0 = argv[0];
     if (strcmp(a0, program))
         execvp(argv[0] = program, argv);
-    tcc_error("could not run '%s'", program);
+    tcc_error_noabort("could not run '%s'", program);
+    return 1;
 }
 #endif /* TCC_TARGET_I386 && TCC_TARGET_X86_64 */
     return res;
 }
-ST_FUNC void gen_makedeps(TCCState *s1, const char *target, const char *filename)
+ST_FUNC int gen_makedeps(TCCState *s1, const char *target, const char *filename)
 {
     FILE *depout;
     char buf[1024], *escaped_target;
         filename = buf;
     }
-    if (s1->verbose)
-        printf("<- %s\n", filename);
     if(!strcmp(filename, "-"))
         depout = fdopen(1, "w");
     else
         /* XXX return err codes instead of error() ? */
         depout = fopen(filename, "w");
     if (!depout)
-        tcc_error("could not open '%s'", filename);
+        return tcc_error_noabort("could not open '%s'", filename);
+    if (s1->verbose)
+        printf("<- %s\n", filename);
     fprintf(depout, "%s:", target);
     for (i = 0; i<s1->nb_target_deps; ++i) {
         for (k = 0; k < i; ++k)
     }
     fprintf(depout, "\n");
     fclose(depout);
+    return 0;
 }
 /* -------------------------------------------------------------- */

x86_64-link.c+3−3

@@ -251,7 +251,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 250 unmodified lines
251	/* ignore overflow with undefined weak symbols */	251	/* ignore overflow with undefined weak symbols */
252	if (((ElfW(Sym)*)symtab_section->data)[sym_index].st_shndx != SHN_UNDEF)	252	if (((ElfW(Sym)*)symtab_section->data)[sym_index].st_shndx != SHN_UNDEF)
253	#endif	253	#endif
254	tcc_error("internal error: relocation failed");	254	tcc_error_noabort("internal error: relocation failed");
255	}	255	}
256	add32le(ptr, diff);	256	add32le(ptr, diff);
257	}	257	}
@@ -336,7 +336,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 78 unmodified lines
336	add32le(ptr + 8, x);	336	add32le(ptr + 8, x);
337	}	337	}
338	else	338	else
339	tcc_error("unexpected R_X86_64_TLSGD pattern");	339	tcc_error_noabort("unexpected R_X86_64_TLSGD pattern");
340	}	340	}
341	break;	341	break;
342	case R_X86_64_TLSLD:	342	case R_X86_64_TLSLD:
@@ -356,7 +356,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 13 unmodified lines
356	rel[1].r_info = ELFW(R_INFO)(0, R_X86_64_NONE);	356	rel[1].r_info = ELFW(R_INFO)(0, R_X86_64_NONE);
357	}	357	}
358	else	358	else
359	tcc_error("unexpected R_X86_64_TLSLD pattern");	359	tcc_error_noabort("unexpected R_X86_64_TLSLD pattern");
360	}	360	}
361	break;	361	break;
362	case R_X86_64_DTPOFF32:	362	case R_X86_64_DTPOFF32:

tcc_error_noabort(): always use this unless compiling

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -126,7 +126,7 @@ ST_FUNC void relocate_plt(TCCState *s1) · 125 unmodified lines
126	uint64_t got = s1->got->sh_addr + 16;	126	uint64_t got = s1->got->sh_addr + 16;
127	uint64_t off = (got >> 12) - (plt >> 12);	127	uint64_t off = (got >> 12) - (plt >> 12);
128	if ((off + ((uint32_t)1 << 20)) >> 21)	128	if ((off + ((uint32_t)1 << 20)) >> 21)
129	tcc_error("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);	129	tcc_error_noabort("Failed relocating PLT (off=0x%lx, got=0x%lx, plt=0x%lx)", (long)off, (long)got, (long)plt);
130	write32le(p, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!	130	write32le(p, 0xa9bf7bf0); // stp x16,x30,[sp,#-16]!
131	write32le(p + 4, (0x90000010 \| // adrp x16,...	131	write32le(p + 4, (0x90000010 \| // adrp x16,...
132	(off & 0x1ffffc) << 3 \| (off & 3) << 29));	132	(off & 0x1ffffc) << 3 \| (off & 3) << 29));
@@ -145,7 +145,7 @@ ST_FUNC void relocate_plt(TCCState *s1) · 12 unmodified lines
145	uint64_t addr = got + read64le(p);	145	uint64_t addr = got + read64le(p);
146	uint64_t off = (addr >> 12) - (pc >> 12);	146	uint64_t off = (addr >> 12) - (pc >> 12);
147	if ((off + ((uint32_t)1 << 20)) >> 21)	147	if ((off + ((uint32_t)1 << 20)) >> 21)
148	tcc_error("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);	148	tcc_error_noabort("Failed relocating PLT (off=0x%lx, addr=0x%lx, pc=0x%lx)", (long)off, (long)addr, (long)pc);
149	write32le(p, (0x90000010 \| // adrp x16,...	149	write32le(p, (0x90000010 \| // adrp x16,...
150	(off & 0x1ffffc) << 3 \| (off & 3) << 29));	150	(off & 0x1ffffc) << 3 \| (off & 3) << 29));
151	write32le(p + 4, (0xf9400211 \| // ldr x17,[x16,#...]	151	write32le(p + 4, (0xf9400211 \| // ldr x17,[x16,#...]
@@ -239,7 +239,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 87 unmodified lines
239	case R_AARCH64_ADR_PREL_PG_HI21: {	239	case R_AARCH64_ADR_PREL_PG_HI21: {
240	uint64_t off = (val >> 12) - (addr >> 12);	240	uint64_t off = (val >> 12) - (addr >> 12);
241	if ((off + ((uint64_t)1 << 20)) >> 21)	241	if ((off + ((uint64_t)1 << 20)) >> 21)
242	tcc_error("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");	242	tcc_error_noabort("R_AARCH64_ADR_PREL_PG_HI21 relocation failed");
243	write32le(ptr, ((read32le(ptr) & 0x9f00001f) \|	243	write32le(ptr, ((read32le(ptr) & 0x9f00001f) \|
244	(off & 0x1ffffc) << 3 \| (off & 3) << 29));	244	(off & 0x1ffffc) << 3 \| (off & 3) << 29));
245	return;	245	return;
@@ -272,7 +272,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 26 unmodified lines
272	(char *) symtab_section->link->data + sym->st_name);	272	(char *) symtab_section->link->data + sym->st_name);
273	#endif	273	#endif
274	if (((val - addr) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc)	274	if (((val - addr) + ((uint64_t)1 << 27)) & ~(uint64_t)0xffffffc)
275	tcc_error("R_AARCH64_(JUMP\|CALL)26 relocation failed"	275	tcc_error_noabort("R_AARCH64_(JUMP\|CALL)26 relocation failed"
276	" (val=%lx, addr=%lx)", (long)val, (long)addr);	276	" (val=%lx, addr=%lx)", (long)val, (long)addr);
277	write32le(ptr, (0x14000000 \|	277	write32le(ptr, (0x14000000 \|
278	(uint32_t)(type == R_AARCH64_CALL26) << 31 \|	278	(uint32_t)(type == R_AARCH64_CALL26) << 31 \|
@@ -283,7 +283,7 @@ void relocate(TCCState s1, ElfW_Rel rel, int type, unsigned char *ptr, addr_t · 4 unmodified lines
283	(((s1->got->sh_addr +	283	(((s1->got->sh_addr +
284	get_sym_attr(s1, sym_index, 0)->got_offset) >> 12) - (addr >> 12));	284	get_sym_attr(s1, sym_index, 0)->got_offset) >> 12) - (addr >> 12));
285	if ((off + ((uint64_t)1 << 20)) >> 21)	285	if ((off + ((uint64_t)1 << 20)) >> 21)
286	tcc_error("R_AARCH64_ADR_GOT_PAGE relocation failed");	286	tcc_error_noabort("R_AARCH64_ADR_GOT_PAGE relocation failed");
287	write32le(ptr, ((read32le(ptr) & 0x9f00001f) \|	287	write32le(ptr, ((read32le(ptr) & 0x9f00001f) \|
288	(off & 0x1ffffc) << 3 \| (off & 3) << 29));	288	(off & 0x1ffffc) << 3 \| (off & 3) << 29));
289	return;	289	return;