Unified · Split
| @@ -190,7 +190,7 @@ typedef struct AttributeDef { · 189 unmodified lines | ||
| 190 | 190 | #define MACRO_OBJ 0 /* object like macro */ |
| 191 | 191 | #define MACRO_FUNC 1 /* function like macro */ |
| 192 | 192 | |
| 193 | −/* field 'Sym.t' for labels */ | |
| 193 | +/* field 'Sym.r' for labels */ | |
| 194 | 194 | #define LABEL_FORWARD 1 /* label is forward defined */ |
| 195 | 195 | |
| 196 | 196 | /* type_decl() types */ |
| @@ -305,6 +305,10 @@ int gnu_ext = 1; · 108 unmodified lines | ||
| 305 | 305 | /* use Tiny C extensions */ |
| 306 | 306 | int tcc_ext = 1; |
| 307 | 307 | |
| 308 | +/* max number of callers shown if error */ | |
| 309 | +static int num_callers = 6; | |
| 310 | +static const char **rt_bound_error_msg; | |
| 311 | + | |
| 308 | 312 | /* XXX: suppress that ASAP */ |
| 309 | 313 | static struct TCCState *tcc_state; |
| 310 | 314 | |
| @@ -572,7 +576,7 @@ int parse_btype(int *type_ptr, AttributeDef *ad); · 261 unmodified lines | ||
| 572 | 576 | int type_decl(AttributeDef *ad, int *v, int t, int td); |
| 573 | 577 | |
| 574 | 578 | void error(const char *fmt, ...); |
| 575 | −void rt_error(unsigned long pc, const char *fmt, ...); | |
| 579 | +void rt_error(struct ucontext *uc, const char *fmt, ...); | |
| 576 | 580 | void vpushi(int v); |
| 577 | 581 | void vset(int t, int r, int v); |
| 578 | 582 | void type_to_str(char *buf, int buf_size, |
| @@ -910,6 +914,7 @@ static void put_extern_sym(Sym *sym, Section *section, · 331 unmodified lines | ||
| 910 | 914 | name = get_tok_str(sym->v, NULL); |
| 911 | 915 | #ifdef CONFIG_TCC_BCHECK |
| 912 | 916 | if (do_bounds_check) { |
| 917 | + /* XXX: avoid doing that for statics ? */ | |
| 913 | 918 | /* if bound checking is activated, we change some function |
| 914 | 919 | names by adding the "__bound" prefix */ |
| 915 | 920 | switch(sym->v) { |
| @@ -5475,8 +5480,7 @@ static void unary(void) · 4559 unmodified lines | ||
| 5475 | 5480 | test_lvalue(); |
| 5476 | 5481 | vtop->t = mk_pointer(vtop->t); |
| 5477 | 5482 | gaddrof(); |
| 5478 | − } else | |
| 5479 | − if (t == '!') { | |
| 5483 | + } else if (t == '!') { | |
| 5480 | 5484 | unary(); |
| 5481 | 5485 | if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) |
| 5482 | 5486 | vtop->c.i = !vtop->c.i; |
| @@ -5484,21 +5488,18 @@ static void unary(void) · 1 unmodified line | ||
| 5484 | 5488 | vtop->c.i = vtop->c.i ^ 1; |
| 5485 | 5489 | else |
| 5486 | 5490 | vset(VT_INT, VT_JMP, gtst(1, 0)); |
| 5487 | − } else | |
| 5488 | − if (t == '~') { | |
| 5491 | + } else if (t == '~') { | |
| 5489 | 5492 | unary(); |
| 5490 | 5493 | vpushi(-1); |
| 5491 | 5494 | gen_op('^'); |
| 5492 | − } else | |
| 5493 | − if (t == '+') { | |
| 5495 | + } else if (t == '+') { | |
| 5494 | 5496 | /* in order to force cast, we add zero */ |
| 5495 | 5497 | unary(); |
| 5496 | 5498 | if ((vtop->t & VT_BTYPE) == VT_PTR) |
| 5497 | 5499 | error("pointer not accepted for unary plus"); |
| 5498 | 5500 | vpushi(0); |
| 5499 | 5501 | gen_op('+'); |
| 5500 | − } else | |
| 5501 | − if (t == TOK_SIZEOF || t == TOK_ALIGNOF) { | |
| 5502 | + } else if (t == TOK_SIZEOF || t == TOK_ALIGNOF) { | |
| 5502 | 5503 | if (tok == '(') { |
| 5503 | 5504 | ft = parse_expr_type(); |
| 5504 | 5505 | } else { |
| @@ -5509,16 +5510,28 @@ static void unary(void) · 4 unmodified lines | ||
| 5509 | 5510 | vpushi(size); |
| 5510 | 5511 | else |
| 5511 | 5512 | vpushi(align); |
| 5512 | − } else | |
| 5513 | − if (t == TOK_INC || t == TOK_DEC) { | |
| 5513 | + } else if (t == TOK_INC || t == TOK_DEC) { | |
| 5514 | 5514 | unary(); |
| 5515 | 5515 | inc(0, t); |
| 5516 | 5516 | } else if (t == '-') { |
| 5517 | 5517 | vpushi(0); |
| 5518 | 5518 | unary(); |
| 5519 | 5519 | gen_op('-'); |
| 5520 | − } else | |
| 5521 | − { | |
| 5520 | + } else if (t == TOK_LAND && gnu_ext) { | |
| 5521 | + /* allow to take the address of a label */ | |
| 5522 | + if (tok < TOK_UIDENT) | |
| 5523 | + expect("label identifier"); | |
| 5524 | + s = sym_find1(&label_stack, tok); | |
| 5525 | + if (!s) { | |
| 5526 | + s = sym_push1(&label_stack, tok, 0, 0); | |
| 5527 | + s->r = LABEL_FORWARD; | |
| 5528 | + } | |
| 5529 | + if (!s->t) | |
| 5530 | + s->t = mk_pointer(VT_VOID) | VT_STATIC; | |
| 5531 | + vset(s->t, VT_CONST | VT_SYM, 0); | |
| 5532 | + vtop->sym = s; | |
| 5533 | + next(); | |
| 5534 | + } else { | |
| 5522 | 5535 | if (t < TOK_UIDENT) |
| 5523 | 5536 | expect("identifier"); |
| 5524 | 5537 | s = sym_find(t); |
| @@ -6200,16 +6213,29 @@ static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_re · 675 unmodified lines | ||
| 6200 | 6213 | } else |
| 6201 | 6214 | if (tok == TOK_GOTO) { |
| 6202 | 6215 | next(); |
| 6203 | − s = sym_find1(&label_stack, tok); | |
| 6204 | − /* put forward definition if needed */ | |
| 6205 | − if (!s) | |
| 6206 | − s = sym_push1(&label_stack, tok, LABEL_FORWARD, 0); | |
| 6207 | − /* label already defined */ | |
| 6208 | − if (s->t & LABEL_FORWARD) | |
| 6209 | − s->c = gjmp(s->c); | |
| 6210 | − else | |
| 6211 | − gjmp_addr(s->c); | |
| 6212 | − next(); | |
| 6216 | + if (tok == '*' && gnu_ext) { | |
| 6217 | + /* computed goto */ | |
| 6218 | + next(); | |
| 6219 | + gexpr(); | |
| 6220 | + if ((vtop->t & VT_BTYPE) != VT_PTR) | |
| 6221 | + expect("pointer"); | |
| 6222 | + ggoto(); | |
| 6223 | + } else if (tok >= TOK_UIDENT) { | |
| 6224 | + s = sym_find1(&label_stack, tok); | |
| 6225 | + /* put forward definition if needed */ | |
| 6226 | + if (!s) { | |
| 6227 | + s = sym_push1(&label_stack, tok, 0, 0); | |
| 6228 | + s->r = LABEL_FORWARD; | |
| 6229 | + } | |
| 6230 | + /* label already defined */ | |
| 6231 | + if (s->r & LABEL_FORWARD) | |
| 6232 | + s->next = (void *)gjmp((long)s->next); | |
| 6233 | + else | |
| 6234 | + gjmp_addr((long)s->next); | |
| 6235 | + next(); | |
| 6236 | + } else { | |
| 6237 | + expect("label identifier"); | |
| 6238 | + } | |
| 6213 | 6239 | skip(';'); |
| 6214 | 6240 | } else { |
| 6215 | 6241 | b = is_label(); |
| @@ -6217,14 +6243,14 @@ static void block(int *bsym, int *csym, int *case_sym, int *def_sym, int case_re · 1 unmodified line | ||
| 6217 | 6243 | /* label case */ |
| 6218 | 6244 | s = sym_find1(&label_stack, b); |
| 6219 | 6245 | if (s) { |
| 6220 | − if (!(s->t & LABEL_FORWARD)) | |
| 6246 | + if (!(s->r & LABEL_FORWARD)) | |
| 6221 | 6247 | error("multiple defined label"); |
| 6222 | − gsym(s->c); | |
| 6223 | − s->c = ind; | |
| 6224 | − s->t = 0; | |
| 6248 | + gsym((long)s->next); | |
| 6225 | 6249 | } else { |
| 6226 | − sym_push1(&label_stack, b, 0, ind); | |
| 6250 | + s = sym_push1(&label_stack, b, 0, 0); | |
| 6227 | 6251 | } |
| 6252 | + s->next = (void *)ind; | |
| 6253 | + s->r = 0; | |
| 6228 | 6254 | /* we accept this, but it is a mistake */ |
| 6229 | 6255 | if (tok == '}') |
| 6230 | 6256 | warning("deprecated use of label at end of compound statement"); |
| @@ -6997,6 +7023,22 @@ static void decl(int l) · 766 unmodified lines | ||
| 6997 | 7023 | gsym(rsym); |
| 6998 | 7024 | gfunc_epilog(); |
| 6999 | 7025 | cur_text_section->data_offset = ind; |
| 7026 | + /* look if any labels are undefined. Define symbols if | |
| 7027 | + '&&label' was used. */ | |
| 7028 | + { | |
| 7029 | + Sym *s; | |
| 7030 | + for(s = label_stack.top; s != NULL; s = s->prev) { | |
| 7031 | + if (s->r & LABEL_FORWARD) { | |
| 7032 | + error("label '%s' used but not defined", | |
| 7033 | + get_tok_str(s->v, NULL)); | |
| 7034 | + } | |
| 7035 | + if (s->c) { | |
| 7036 | + /* define corresponding symbol. A size of | |
| 7037 | + 1 is put. */ | |
| 7038 | + put_extern_sym(s, cur_text_section, (long)s->next, 1); | |
| 7039 | + } | |
| 7040 | + } | |
| 7041 | + } | |
| 7000 | 7042 | sym_pop(&label_stack, NULL); /* reset label stack */ |
| 7001 | 7043 | sym_pop(&local_stack, NULL); /* reset local stack */ |
| 7002 | 7044 | /* end of function */ |
| @@ -7234,6 +7276,8 @@ static void rt_printline(unsigned long wanted_pc) · 231 unmodified lines | ||
| 7234 | 7276 | int incl_index, len, last_line_num, i; |
| 7235 | 7277 | const char *str, *p; |
| 7236 | 7278 | |
| 7279 | + fprintf(stderr, "0x%08lx:", wanted_pc); | |
| 7280 | + | |
| 7237 | 7281 | func_name[0] = '\0'; |
| 7238 | 7282 | func_addr = 0; |
| 7239 | 7283 | incl_index = 0; |
| @@ -7247,6 +7291,10 @@ static void rt_printline(unsigned long wanted_pc) · 7 unmodified lines | ||
| 7247 | 7291 | /* function start or end */ |
| 7248 | 7292 | case N_FUN: |
| 7249 | 7293 | if (sym->n_strx == 0) { |
| 7294 | + /* we test if between last line and end of function */ | |
| 7295 | + pc = sym->n_value + func_addr; | |
| 7296 | + if (wanted_pc >= last_pc && wanted_pc < pc) | |
| 7297 | + goto found; | |
| 7250 | 7298 | func_name[0] = '\0'; |
| 7251 | 7299 | func_addr = 0; |
| 7252 | 7300 | } else { |
| @@ -7300,31 +7348,98 @@ static void rt_printline(unsigned long wanted_pc) · 47 unmodified lines | ||
| 7300 | 7348 | } |
| 7301 | 7349 | sym++; |
| 7302 | 7350 | } |
| 7303 | − /* did not find line number info: */ | |
| 7304 | − fprintf(stderr, "(no debug info, pc=0x%08lx): ", wanted_pc); | |
| 7351 | + | |
| 7352 | + /* second pass: we try symtab symbols (no line number info) */ | |
| 7353 | + incl_index = 0; | |
| 7354 | + { | |
| 7355 | + Elf32_Sym *sym, *sym_end; | |
| 7356 | + int type; | |
| 7357 | + | |
| 7358 | + sym_end = (Elf32_Sym *)(symtab_section->data + symtab_section->data_offset); | |
| 7359 | + for(sym = (Elf32_Sym *)symtab_section->data + 1; | |
| 7360 | + sym < sym_end; | |
| 7361 | + sym++) { | |
| 7362 | + type = ELF32_ST_TYPE(sym->st_info); | |
| 7363 | + if (type == STT_FUNC) { | |
| 7364 | + if (wanted_pc >= sym->st_value && | |
| 7365 | + wanted_pc < sym->st_value + sym->st_size) { | |
| 7366 | + pstrcpy(last_func_name, sizeof(last_func_name), | |
| 7367 | + strtab_section->data + sym->st_name); | |
| 7368 | + goto found; | |
| 7369 | + } | |
| 7370 | + } | |
| 7371 | + } | |
| 7372 | + } | |
| 7373 | + /* did not find any info: */ | |
| 7374 | + fprintf(stderr, " ???\n"); | |
| 7305 | 7375 | return; |
| 7306 | 7376 | found: |
| 7307 | − for(i = 0; i < incl_index - 1; i++) | |
| 7308 | − fprintf(stderr, "In file included from %s\n", | |
| 7309 | − incl_files[i]); | |
| 7377 | + if (last_func_name[0] != '\0') { | |
| 7378 | + fprintf(stderr, " %s()", last_func_name); | |
| 7379 | + } | |
| 7310 | 7380 | if (incl_index > 0) { |
| 7311 | − fprintf(stderr, "%s:%d: ", | |
| 7381 | + fprintf(stderr, " (%s:%d", | |
| 7312 | 7382 | incl_files[incl_index - 1], last_line_num); |
| 7383 | + for(i = incl_index - 2; i >= 0; i--) | |
| 7384 | + fprintf(stderr, ", included from %s", incl_files[i]); | |
| 7385 | + fprintf(stderr, ")"); | |
| 7313 | 7386 | } |
| 7314 | − if (last_func_name[0] != '\0') { | |
| 7315 | − fprintf(stderr, "in function '%s()': ", last_func_name); | |
| 7387 | + fprintf(stderr, "\n"); | |
| 7388 | +} | |
| 7389 | + | |
| 7390 | +#ifdef __i386__ | |
| 7391 | + | |
| 7392 | +#ifndef EIP | |
| 7393 | +#define EIP 14 | |
| 7394 | +#define EBP 6 | |
| 7395 | +#endif | |
| 7396 | + | |
| 7397 | +/* return the PC at frame level 'level'. Return non zero if not found */ | |
| 7398 | +static int rt_get_caller_pc(unsigned long *paddr, | |
| 7399 | + struct ucontext *uc, int level) | |
| 7400 | +{ | |
| 7401 | + unsigned long fp; | |
| 7402 | + int i; | |
| 7403 | + | |
| 7404 | + if (level == 0) { | |
| 7405 | + *paddr = uc->uc_mcontext.gregs[EIP]; | |
| 7406 | + return 0; | |
| 7407 | + } else { | |
| 7408 | + fp = uc->uc_mcontext.gregs[EBP]; | |
| 7409 | + for(i=1;i<level;i++) { | |
| 7410 | + /* XXX: check address validity with program info */ | |
| 7411 | + if (fp <= 0x1000 || fp >= 0xc0000000) | |
| 7412 | + return -1; | |
| 7413 | + fp = ((unsigned long *)fp)[0]; | |
| 7414 | + } | |
| 7415 | + *paddr = ((unsigned long *)fp)[1]; | |
| 7416 | + return 0; | |
| 7316 | 7417 | } |
| 7317 | 7418 | } |
| 7419 | +#else | |
| 7420 | +#error add corresponding function | |
| 7421 | +#endif | |
| 7318 | 7422 | |
| 7319 | 7423 | /* emit a run time error at position 'pc' */ |
| 7320 | −void rt_error(unsigned long pc, const char *fmt, ...) | |
| 7424 | +void rt_error(struct ucontext *uc, const char *fmt, ...) | |
| 7321 | 7425 | { |
| 7322 | 7426 | va_list ap; |
| 7323 | − va_start(ap, fmt); | |
| 7427 | + unsigned long pc; | |
| 7428 | + int i; | |
| 7324 | 7429 | |
| 7325 | − rt_printline(pc); | |
| 7430 | + va_start(ap, fmt); | |
| 7431 | + fprintf(stderr, "Runtime error: "); | |
| 7326 | 7432 | vfprintf(stderr, fmt, ap); |
| 7327 | 7433 | fprintf(stderr, "\n"); |
| 7434 | + for(i=0;i<num_callers;i++) { | |
| 7435 | + if (rt_get_caller_pc(&pc, uc, i) < 0) | |
| 7436 | + break; | |
| 7437 | + if (i == 0) | |
| 7438 | + fprintf(stderr, "at "); | |
| 7439 | + else | |
| 7440 | + fprintf(stderr, "by "); | |
| 7441 | + rt_printline(pc); | |
| 7442 | + } | |
| 7328 | 7443 | exit(255); |
| 7329 | 7444 | va_end(ap); |
| 7330 | 7445 | } |
| @@ -7334,38 +7449,34 @@ void rt_error(unsigned long pc, const char *fmt, ...) · 3 unmodified lines | ||
| 7334 | 7449 | static void sig_error(int signum, siginfo_t *siginf, void *puc) |
| 7335 | 7450 | { |
| 7336 | 7451 | struct ucontext *uc = puc; |
| 7337 | − unsigned long pc; | |
| 7338 | − | |
| 7339 | −#ifdef __i386__ | |
| 7340 | − pc = uc->uc_mcontext.gregs[14]; | |
| 7341 | −#else | |
| 7342 | −#error please put the right sigcontext field | |
| 7343 | −#endif | |
| 7344 | 7452 | |
| 7345 | 7453 | switch(signum) { |
| 7346 | 7454 | case SIGFPE: |
| 7347 | 7455 | switch(siginf->si_code) { |
| 7348 | 7456 | case FPE_INTDIV: |
| 7349 | 7457 | case FPE_FLTDIV: |
| 7350 | − rt_error(pc, "division by zero"); | |
| 7458 | + rt_error(uc, "division by zero"); | |
| 7351 | 7459 | break; |
| 7352 | 7460 | default: |
| 7353 | − rt_error(pc, "floating point exception"); | |
| 7461 | + rt_error(uc, "floating point exception"); | |
| 7354 | 7462 | break; |
| 7355 | 7463 | } |
| 7356 | 7464 | break; |
| 7357 | 7465 | case SIGBUS: |
| 7358 | 7466 | case SIGSEGV: |
| 7359 | − rt_error(pc, "dereferencing invalid pointer"); | |
| 7467 | + if (rt_bound_error_msg && *rt_bound_error_msg) | |
| 7468 | + rt_error(uc, *rt_bound_error_msg); | |
| 7469 | + else | |
| 7470 | + rt_error(uc, "dereferencing invalid pointer"); | |
| 7360 | 7471 | break; |
| 7361 | 7472 | case SIGILL: |
| 7362 | − rt_error(pc, "illegal instruction"); | |
| 7473 | + rt_error(uc, "illegal instruction"); | |
| 7363 | 7474 | break; |
| 7364 | 7475 | case SIGABRT: |
| 7365 | − rt_error(pc, "abort() called"); | |
| 7476 | + rt_error(uc, "abort() called"); | |
| 7366 | 7477 | break; |
| 7367 | 7478 | default: |
| 7368 | − rt_error(pc, "caught signal %d", signum); | |
| 7479 | + rt_error(uc, "caught signal %d", signum); | |
| 7369 | 7480 | break; |
| 7370 | 7481 | } |
| 7371 | 7482 | exit(255); |
| @@ -7440,11 +7551,9 @@ int tcc_run(TCCState *s1, int argc, char **argv) · 68 unmodified lines | ||
| 7440 | 7551 | #ifdef CONFIG_TCC_BCHECK |
| 7441 | 7552 | if (do_bounds_check) { |
| 7442 | 7553 | void (*bound_init)(void); |
| 7443 | − void **bound_error_func; | |
| 7444 | 7554 | |
| 7445 | 7555 | /* set error function */ |
| 7446 | − bound_error_func = (void **)tcc_get_symbol(s1, "__bound_error_func"); | |
| 7447 | − *bound_error_func = rt_error; | |
| 7556 | + rt_bound_error_msg = (void *)tcc_get_symbol(s1, "__bound_error_msg"); | |
| 7448 | 7557 | |
| 7449 | 7558 | /* XXX: use .init section so that it also work in binary ? */ |
| 7450 | 7559 | bound_init = (void *)tcc_get_symbol(s1, "__bound_init"); |
| @@ -7782,9 +7891,9 @@ int tcc_set_output_type(TCCState *s, int output_type) · 331 unmodified lines | ||
| 7782 | 7891 | |
| 7783 | 7892 | void help(void) |
| 7784 | 7893 | { |
| 7785 | − printf("tcc version 0.9.12 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n" | |
| 7894 | + printf("tcc version 0.9.13 - Tiny C Compiler - Copyright (C) 2001, 2002 Fabrice Bellard\n" | |
| 7786 | 7895 | "usage: tcc [-c] [-o outfile] [-Bdir] [-bench] [-Idir] [-Dsym[=val]] [-Usym]\n" |
| 7787 | − " [-g] [-b] [-Ldir] [-llib] [-shared] [-static]\n" | |
| 7896 | + " [-g] [-b] [-bt N] [-Ldir] [-llib] [-shared] [-static]\n" | |
| 7788 | 7897 | " [--] infile1 [infile2... --] [infile_args...]\n" |
| 7789 | 7898 | "\n" |
| 7790 | 7899 | "General options:\n" |
| @@ -7798,17 +7907,18 @@ void help(void) · 7 unmodified lines | ||
| 7798 | 7907 | " -Idir add include path 'dir'\n" |
| 7799 | 7908 | " -Dsym[=val] define 'sym' with value 'val'\n" |
| 7800 | 7909 | " -Usym undefine 'sym'\n" |
| 7801 | − "C compiler options:\n" | |
| 7802 | − " -g generate runtime debug info\n" | |
| 7803 | −#ifdef CONFIG_TCC_BCHECK | |
| 7804 | − " -b compile with built-in memory and bounds checker (implies -g)\n" | |
| 7805 | −#endif | |
| 7806 | 7910 | "Linker options:\n" |
| 7807 | 7911 | " -Ldir add library path 'dir'\n" |
| 7808 | 7912 | " -llib link with dynamic or static library 'lib'\n" |
| 7809 | 7913 | " -shared generate a shared library\n" |
| 7810 | 7914 | " -static static linking\n" |
| 7811 | 7915 | " -r relocatable output\n" |
| 7916 | + "Debugger options:\n" | |
| 7917 | + " -g generate runtime debug info\n" | |
| 7918 | +#ifdef CONFIG_TCC_BCHECK | |
| 7919 | + " -b compile with built-in memory and bounds checker (implies -g)\n" | |
| 7920 | +#endif | |
| 7921 | + " -bt N show N callers in stack traces\n" | |
| 7812 | 7922 | ); |
| 7813 | 7923 | } |
| 7814 | 7924 | |
| @@ -7884,7 +7994,9 @@ int main(int argc, char **argv) · 69 unmodified lines | ||
| 7884 | 7994 | nb_libraries++; |
| 7885 | 7995 | } else if (!strcmp(r + 1, "bench")) { |
| 7886 | 7996 | do_bench = 1; |
| 7887 | − } else | |
| 7997 | + } else if (!strcmp(r + 1, "bt")) { | |
| 7998 | + num_callers = atoi(argv[optind++]); | |
| 7999 | + } else | |
| 7888 | 8000 | #ifdef CONFIG_TCC_BCHECK |
| 7889 | 8001 | if (r[1] == 'b') { |
| 7890 | 8002 | do_bounds_check = 1; |
| @@ -7982,7 +8094,9 @@ int main(int argc, char **argv) · 91 unmodified lines | ||
| 7982 | 8094 | ret = tcc_run(s, argc - optind, argv + optind); |
| 7983 | 8095 | } |
| 7984 | 8096 | the_end: |
| 7985 | − tcc_delete(s); | |
| 8097 | + /* XXX: cannot do it with bound checking because of the malloc hooks */ | |
| 8098 | + if (!do_bounds_check) | |
| 8099 | + tcc_delete(s); | |
| 7986 | 8100 | |
| 7987 | 8101 | #ifdef MEM_DEBUG |
| 7988 | 8102 | if (do_bench) { |