8c56b0cf90
This reverts commit 59e18aee0e.
tcc is being stabilized now in order to do a new release soon.
Therefore, such a change is not appropriate now.
615 lines
19 KiB
C
615 lines
19 KiB
C
/*
|
|
* TCC - Tiny C Compiler
|
|
*
|
|
* Copyright (c) 2001-2004 Fabrice Bellard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#ifdef ONE_SOURCE
|
|
#include "libtcc.c"
|
|
#else
|
|
#include "tcc.h"
|
|
#endif
|
|
|
|
static char **files;
|
|
static int nb_files, nb_libraries;
|
|
static int multiple_files;
|
|
static int print_search_dirs;
|
|
static int output_type;
|
|
static int reloc_output;
|
|
static char *outfile;
|
|
static int do_bench = 0;
|
|
static int gen_deps;
|
|
static const char *deps_outfile;
|
|
static const char *m_option;
|
|
static CString linker_arg;
|
|
|
|
#define TCC_OPTION_HAS_ARG 0x0001
|
|
#define TCC_OPTION_NOSEP 0x0002 /* cannot have space before option and arg */
|
|
|
|
static void help(void)
|
|
{
|
|
printf("tcc version " TCC_VERSION " - Tiny C Compiler - Copyright (C) 2001-2006 Fabrice Bellard\n"
|
|
"Usage: tcc [options...] [-o outfile] [-c] infile(s)...\n"
|
|
" tcc [options...] -run infile [arguments...]\n"
|
|
"General options:\n"
|
|
" -v display current version, increase verbosity\n"
|
|
" -c compile only - generate an object file\n"
|
|
" -o outfile set output filename\n"
|
|
" -Bdir set tcc internal library and include path\n"
|
|
" -bench output compilation statistics\n"
|
|
" -run run compiled source\n"
|
|
" -fflag set or reset (with 'no-' prefix) 'flag' (see man page)\n"
|
|
" -Wwarning set or reset (with 'no-' prefix) 'warning' (see man page)\n"
|
|
" -w disable all warnings\n"
|
|
"Preprocessor options:\n"
|
|
" -E preprocess only\n"
|
|
" -Idir add include path 'dir'\n"
|
|
" -Dsym[=val] define 'sym' with value 'val'\n"
|
|
" -Usym undefine 'sym'\n"
|
|
"Linker options:\n"
|
|
" -Ldir add library path 'dir'\n"
|
|
" -llib link with dynamic or static library 'lib'\n"
|
|
" -pthread link with -lpthread and -D_REENTRANT (POSIX Linux)\n"
|
|
" -shared generate a shared library\n"
|
|
" -soname set name for shared library to be used at runtime\n"
|
|
" -static static linking\n"
|
|
" -rdynamic export all global symbols to dynamic linker\n"
|
|
" -r generate (relocatable) object file\n"
|
|
"Debugger options:\n"
|
|
" -g generate runtime debug info\n"
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
" -b compile with built-in memory and bounds checker (implies -g)\n"
|
|
#endif
|
|
#ifdef CONFIG_TCC_BACKTRACE
|
|
" -bt N show N callers in stack traces\n"
|
|
#endif
|
|
"Misc options:\n"
|
|
" -MD generate target dependencies for make\n"
|
|
" -MF depfile put generated dependencies here\n"
|
|
);
|
|
}
|
|
|
|
typedef struct TCCOption {
|
|
const char *name;
|
|
uint16_t index;
|
|
uint16_t flags;
|
|
} TCCOption;
|
|
|
|
enum {
|
|
TCC_OPTION_HELP,
|
|
TCC_OPTION_I,
|
|
TCC_OPTION_D,
|
|
TCC_OPTION_U,
|
|
TCC_OPTION_L,
|
|
TCC_OPTION_B,
|
|
TCC_OPTION_l,
|
|
TCC_OPTION_bench,
|
|
TCC_OPTION_bt,
|
|
TCC_OPTION_b,
|
|
TCC_OPTION_g,
|
|
TCC_OPTION_c,
|
|
TCC_OPTION_static,
|
|
TCC_OPTION_shared,
|
|
TCC_OPTION_soname,
|
|
TCC_OPTION_o,
|
|
TCC_OPTION_r,
|
|
TCC_OPTION_s,
|
|
TCC_OPTION_Wl,
|
|
TCC_OPTION_W,
|
|
TCC_OPTION_O,
|
|
TCC_OPTION_m,
|
|
TCC_OPTION_f,
|
|
TCC_OPTION_isystem,
|
|
TCC_OPTION_nostdinc,
|
|
TCC_OPTION_nostdlib,
|
|
TCC_OPTION_print_search_dirs,
|
|
TCC_OPTION_rdynamic,
|
|
TCC_OPTION_pedantic,
|
|
TCC_OPTION_pthread,
|
|
TCC_OPTION_run,
|
|
TCC_OPTION_v,
|
|
TCC_OPTION_w,
|
|
TCC_OPTION_pipe,
|
|
TCC_OPTION_E,
|
|
TCC_OPTION_MD,
|
|
TCC_OPTION_MF,
|
|
TCC_OPTION_x,
|
|
};
|
|
|
|
static const TCCOption tcc_options[] = {
|
|
{ "h", TCC_OPTION_HELP, 0 },
|
|
{ "-help", TCC_OPTION_HELP, 0 },
|
|
{ "?", TCC_OPTION_HELP, 0 },
|
|
{ "I", TCC_OPTION_I, TCC_OPTION_HAS_ARG },
|
|
{ "D", TCC_OPTION_D, TCC_OPTION_HAS_ARG },
|
|
{ "U", TCC_OPTION_U, TCC_OPTION_HAS_ARG },
|
|
{ "L", TCC_OPTION_L, TCC_OPTION_HAS_ARG },
|
|
{ "B", TCC_OPTION_B, TCC_OPTION_HAS_ARG },
|
|
{ "l", TCC_OPTION_l, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "bench", TCC_OPTION_bench, 0 },
|
|
#ifdef CONFIG_TCC_BACKTRACE
|
|
{ "bt", TCC_OPTION_bt, TCC_OPTION_HAS_ARG },
|
|
#endif
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
{ "b", TCC_OPTION_b, 0 },
|
|
#endif
|
|
{ "g", TCC_OPTION_g, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "c", TCC_OPTION_c, 0 },
|
|
{ "static", TCC_OPTION_static, 0 },
|
|
{ "shared", TCC_OPTION_shared, 0 },
|
|
{ "soname", TCC_OPTION_soname, TCC_OPTION_HAS_ARG },
|
|
{ "o", TCC_OPTION_o, TCC_OPTION_HAS_ARG },
|
|
{ "pedantic", TCC_OPTION_pedantic, 0},
|
|
{ "pthread", TCC_OPTION_pthread, 0},
|
|
{ "run", TCC_OPTION_run, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "rdynamic", TCC_OPTION_rdynamic, 0 },
|
|
{ "r", TCC_OPTION_r, 0 },
|
|
{ "s", TCC_OPTION_s, 0 },
|
|
{ "Wl,", TCC_OPTION_Wl, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "W", TCC_OPTION_W, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "O", TCC_OPTION_O, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "m", TCC_OPTION_m, TCC_OPTION_HAS_ARG },
|
|
{ "f", TCC_OPTION_f, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "isystem", TCC_OPTION_isystem, TCC_OPTION_HAS_ARG },
|
|
{ "nostdinc", TCC_OPTION_nostdinc, 0 },
|
|
{ "nostdlib", TCC_OPTION_nostdlib, 0 },
|
|
{ "print-search-dirs", TCC_OPTION_print_search_dirs, 0 },
|
|
{ "v", TCC_OPTION_v, TCC_OPTION_HAS_ARG | TCC_OPTION_NOSEP },
|
|
{ "w", TCC_OPTION_w, 0 },
|
|
{ "pipe", TCC_OPTION_pipe, 0},
|
|
{ "E", TCC_OPTION_E, 0},
|
|
{ "MD", TCC_OPTION_MD, 0},
|
|
{ "MF", TCC_OPTION_MF, TCC_OPTION_HAS_ARG },
|
|
{ "x", TCC_OPTION_x, TCC_OPTION_HAS_ARG },
|
|
{ NULL },
|
|
};
|
|
|
|
static int64_t getclock_us(void)
|
|
{
|
|
#ifdef _WIN32
|
|
struct _timeb tb;
|
|
_ftime(&tb);
|
|
return (tb.time * 1000LL + tb.millitm) * 1000LL;
|
|
#else
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return tv.tv_sec * 1000000LL + tv.tv_usec;
|
|
#endif
|
|
}
|
|
|
|
/* convert 'str' into an array of space separated strings */
|
|
static int expand_args(char ***pargv, const char *str)
|
|
{
|
|
const char *s1;
|
|
char **argv, *arg;
|
|
int argc, len;
|
|
|
|
argc = 0;
|
|
argv = NULL;
|
|
for(;;) {
|
|
while (is_space(*str))
|
|
str++;
|
|
if (*str == '\0')
|
|
break;
|
|
s1 = str;
|
|
while (*str != '\0' && !is_space(*str))
|
|
str++;
|
|
len = str - s1;
|
|
arg = tcc_malloc(len + 1);
|
|
memcpy(arg, s1, len);
|
|
arg[len] = '\0';
|
|
dynarray_add((void ***)&argv, &argc, arg);
|
|
}
|
|
*pargv = argv;
|
|
return argc;
|
|
}
|
|
|
|
/* re-execute the i386/x86_64 cross-compilers with tcc -m32/-m64: */
|
|
#if defined TCC_TARGET_I386 || defined TCC_TARGET_X86_64
|
|
#ifdef _WIN32
|
|
#include <process.h>
|
|
static int execvp_win32(const char *prog, char **argv)
|
|
{
|
|
int ret = spawnvp(P_NOWAIT, prog, (char const*const*)argv);
|
|
if (-1 == ret)
|
|
return ret;
|
|
cwait(&ret, ret, WAIT_CHILD);
|
|
exit(ret);
|
|
}
|
|
#define execvp execvp_win32
|
|
#endif
|
|
static void exec_other_tcc(TCCState *s, char **argv, const char *optarg)
|
|
{
|
|
char child_path[4096], *child_name; const char *target;
|
|
switch (atoi(optarg)) {
|
|
#ifdef TCC_TARGET_I386
|
|
case 32: break;
|
|
case 64: target = "x86_64";
|
|
#else
|
|
case 64: break;
|
|
case 32: target = "i386";
|
|
#endif
|
|
pstrcpy(child_path, sizeof child_path - 40, argv[0]);
|
|
child_name = tcc_basename(child_path);
|
|
strcpy(child_name, target);
|
|
#ifdef TCC_TARGET_PE
|
|
strcat(child_name, "-win32");
|
|
#endif
|
|
strcat(child_name, "-tcc");
|
|
if (strcmp(argv[0], child_path)) {
|
|
if (s->verbose > 0)
|
|
printf("tcc: using '%s'\n", child_name), fflush(stdout);
|
|
execvp(argv[0] = child_path, argv);
|
|
}
|
|
tcc_error("'%s' not found", child_name);
|
|
case 0: /* ignore -march etc. */
|
|
break;
|
|
default:
|
|
tcc_warning("unsupported option \"-m%s\"", optarg);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void parse_option_D(TCCState *s1, const char *optarg)
|
|
{
|
|
char *sym = tcc_strdup(optarg);
|
|
char *value = strchr(sym, '=');
|
|
if (value)
|
|
*value++ = '\0';
|
|
tcc_define_symbol(s1, sym, value);
|
|
tcc_free(sym);
|
|
}
|
|
|
|
static int parse_args(TCCState *s, int argc, char **argv)
|
|
{
|
|
int optind;
|
|
const TCCOption *popt;
|
|
const char *optarg, *p1, *r1;
|
|
char *r;
|
|
int was_pthread;
|
|
|
|
was_pthread = 0; /* is set if commandline contains -pthread key */
|
|
optind = 0;
|
|
cstr_new(&linker_arg);
|
|
|
|
while (optind < argc) {
|
|
|
|
r = argv[optind++];
|
|
if (r[0] != '-' || r[1] == '\0') {
|
|
/* add a new file */
|
|
dynarray_add((void ***)&files, &nb_files, r);
|
|
if (!multiple_files) {
|
|
optind--;
|
|
/* argv[0] will be this file */
|
|
break;
|
|
}
|
|
} else {
|
|
/* find option in table (match only the first chars */
|
|
popt = tcc_options;
|
|
for(;;) {
|
|
p1 = popt->name;
|
|
if (p1 == NULL)
|
|
tcc_error("invalid option -- '%s'", r);
|
|
r1 = r + 1;
|
|
for(;;) {
|
|
if (*p1 == '\0')
|
|
goto option_found;
|
|
if (*r1 != *p1)
|
|
break;
|
|
p1++;
|
|
r1++;
|
|
}
|
|
popt++;
|
|
}
|
|
option_found:
|
|
if (popt->flags & TCC_OPTION_HAS_ARG) {
|
|
if (*r1 != '\0' || (popt->flags & TCC_OPTION_NOSEP)) {
|
|
optarg = r1;
|
|
} else {
|
|
if (optind >= argc)
|
|
tcc_error("argument to '%s' is missing", r);
|
|
optarg = argv[optind++];
|
|
}
|
|
} else {
|
|
if (*r1 != '\0')
|
|
return 0;
|
|
optarg = NULL;
|
|
}
|
|
|
|
switch(popt->index) {
|
|
case TCC_OPTION_HELP:
|
|
return 0;
|
|
|
|
case TCC_OPTION_I:
|
|
if (tcc_add_include_path(s, optarg) < 0)
|
|
tcc_error("too many include paths");
|
|
break;
|
|
case TCC_OPTION_D:
|
|
parse_option_D(s, optarg);
|
|
break;
|
|
case TCC_OPTION_U:
|
|
tcc_undefine_symbol(s, optarg);
|
|
break;
|
|
case TCC_OPTION_L:
|
|
tcc_add_library_path(s, optarg);
|
|
break;
|
|
case TCC_OPTION_B:
|
|
/* set tcc utilities path (mainly for tcc development) */
|
|
tcc_set_lib_path(s, optarg);
|
|
break;
|
|
case TCC_OPTION_l:
|
|
dynarray_add((void ***)&files, &nb_files, r);
|
|
nb_libraries++;
|
|
break;
|
|
case TCC_OPTION_pthread:
|
|
was_pthread = 1;
|
|
parse_option_D(s, "_REENTRANT");
|
|
break;
|
|
case TCC_OPTION_bench:
|
|
do_bench = 1;
|
|
break;
|
|
#ifdef CONFIG_TCC_BACKTRACE
|
|
case TCC_OPTION_bt:
|
|
tcc_set_num_callers(atoi(optarg));
|
|
break;
|
|
#endif
|
|
#ifdef CONFIG_TCC_BCHECK
|
|
case TCC_OPTION_b:
|
|
s->do_bounds_check = 1;
|
|
s->do_debug = 1;
|
|
break;
|
|
#endif
|
|
case TCC_OPTION_g:
|
|
s->do_debug = 1;
|
|
break;
|
|
case TCC_OPTION_c:
|
|
multiple_files = 1;
|
|
output_type = TCC_OUTPUT_OBJ;
|
|
break;
|
|
case TCC_OPTION_static:
|
|
s->static_link = 1;
|
|
break;
|
|
case TCC_OPTION_shared:
|
|
output_type = TCC_OUTPUT_DLL;
|
|
break;
|
|
case TCC_OPTION_soname:
|
|
s->soname = optarg;
|
|
break;
|
|
case TCC_OPTION_m:
|
|
m_option = optarg;
|
|
break;
|
|
case TCC_OPTION_o:
|
|
multiple_files = 1;
|
|
outfile = tcc_strdup(optarg);
|
|
break;
|
|
case TCC_OPTION_r:
|
|
/* generate a .o merging several output files */
|
|
reloc_output = 1;
|
|
output_type = TCC_OUTPUT_OBJ;
|
|
break;
|
|
case TCC_OPTION_isystem:
|
|
tcc_add_sysinclude_path(s, optarg);
|
|
break;
|
|
case TCC_OPTION_nostdinc:
|
|
s->nostdinc = 1;
|
|
break;
|
|
case TCC_OPTION_nostdlib:
|
|
s->nostdlib = 1;
|
|
break;
|
|
case TCC_OPTION_print_search_dirs:
|
|
print_search_dirs = 1;
|
|
break;
|
|
case TCC_OPTION_run:
|
|
{
|
|
int argc1;
|
|
char **argv1;
|
|
argc1 = expand_args(&argv1, optarg);
|
|
if (argc1 > 0) {
|
|
parse_args(s, argc1, argv1);
|
|
}
|
|
multiple_files = 0;
|
|
output_type = TCC_OUTPUT_MEMORY;
|
|
break;
|
|
}
|
|
case TCC_OPTION_v:
|
|
do ++s->verbose; while (*optarg++ == 'v');
|
|
break;
|
|
case TCC_OPTION_f:
|
|
if (tcc_set_flag(s, optarg, 1) < 0 && s->warn_unsupported)
|
|
goto unsupported_option;
|
|
break;
|
|
case TCC_OPTION_W:
|
|
if (tcc_set_warning(s, optarg, 1) < 0 &&
|
|
s->warn_unsupported)
|
|
goto unsupported_option;
|
|
break;
|
|
case TCC_OPTION_w:
|
|
s->warn_none = 1;
|
|
break;
|
|
case TCC_OPTION_rdynamic:
|
|
s->rdynamic = 1;
|
|
break;
|
|
case TCC_OPTION_Wl:
|
|
if (linker_arg.size)
|
|
--linker_arg.size, cstr_ccat(&linker_arg, ',');
|
|
cstr_cat(&linker_arg, optarg);
|
|
cstr_ccat(&linker_arg, '\0');
|
|
break;
|
|
case TCC_OPTION_E:
|
|
output_type = TCC_OUTPUT_PREPROCESS;
|
|
break;
|
|
case TCC_OPTION_MD:
|
|
gen_deps = 1;
|
|
break;
|
|
case TCC_OPTION_MF:
|
|
deps_outfile = optarg;
|
|
break;
|
|
case TCC_OPTION_x:
|
|
break;
|
|
default:
|
|
if (s->warn_unsupported) {
|
|
unsupported_option:
|
|
tcc_warning("unsupported option '%s'", r);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (NULL != (r1 = tcc_set_linker(s, (char *) linker_arg.data, TRUE)))
|
|
tcc_error("unsupported linker option '%s'", r1);
|
|
/* fixme: these options could be different on your platform */
|
|
if (was_pthread && output_type != TCC_OUTPUT_OBJ) {
|
|
dynarray_add((void ***)&files, &nb_files, "-lpthread");
|
|
nb_libraries++;
|
|
}
|
|
return optind;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
int i;
|
|
TCCState *s;
|
|
int nb_objfiles, ret, optind;
|
|
int64_t start_time = 0;
|
|
const char *default_file = NULL;
|
|
|
|
s = tcc_new();
|
|
|
|
output_type = TCC_OUTPUT_EXE;
|
|
outfile = NULL;
|
|
multiple_files = 1;
|
|
files = NULL;
|
|
nb_files = 0;
|
|
nb_libraries = 0;
|
|
reloc_output = 0;
|
|
print_search_dirs = 0;
|
|
m_option = NULL;
|
|
ret = 0;
|
|
|
|
optind = parse_args(s, argc - 1, argv + 1);
|
|
|
|
#if defined TCC_TARGET_X86_64 || defined TCC_TARGET_I386
|
|
if (m_option)
|
|
exec_other_tcc(s, argv, m_option);
|
|
#endif
|
|
|
|
if (print_search_dirs) {
|
|
/* enough for Linux kernel */
|
|
printf("install: %s/\n", s->tcc_lib_path);
|
|
return 0;
|
|
}
|
|
|
|
if (s->verbose)
|
|
printf("tcc version %s\n", TCC_VERSION);
|
|
|
|
if (optind == 0 || nb_files == 0) {
|
|
if (optind && s->verbose)
|
|
return 0;
|
|
help();
|
|
return 1;
|
|
}
|
|
|
|
nb_objfiles = nb_files - nb_libraries;
|
|
|
|
/* if outfile provided without other options, we output an
|
|
executable */
|
|
if (outfile && output_type == TCC_OUTPUT_MEMORY)
|
|
output_type = TCC_OUTPUT_EXE;
|
|
|
|
/* check -c consistency : only single file handled. XXX: checks file type */
|
|
if (output_type == TCC_OUTPUT_OBJ && !reloc_output) {
|
|
/* accepts only a single input file */
|
|
if (nb_objfiles != 1)
|
|
tcc_error("cannot specify multiple files with -c");
|
|
if (nb_libraries != 0)
|
|
tcc_error("cannot specify libraries with -c");
|
|
}
|
|
|
|
if (output_type == TCC_OUTPUT_PREPROCESS) {
|
|
if (!outfile) {
|
|
s->outfile = stdout;
|
|
} else {
|
|
s->outfile = fopen(outfile, "w");
|
|
if (!s->outfile)
|
|
tcc_error("could not open '%s'", outfile);
|
|
}
|
|
}
|
|
|
|
if (do_bench) {
|
|
start_time = getclock_us();
|
|
}
|
|
|
|
tcc_set_output_type(s, output_type);
|
|
s->reloc_output = reloc_output;
|
|
|
|
/* compile or add each files or library */
|
|
for(i = 0; i < nb_files && ret == 0; i++) {
|
|
const char *filename;
|
|
|
|
filename = files[i];
|
|
if (filename[0] == '-' && filename[1] == 'l') {
|
|
if (tcc_add_library(s, filename + 2) < 0) {
|
|
tcc_error_noabort("cannot find %s", filename);
|
|
ret = 1;
|
|
}
|
|
} else {
|
|
if (1 == s->verbose)
|
|
printf("-> %s\n", filename);
|
|
if (tcc_add_file(s, filename) < 0)
|
|
ret = 1;
|
|
if (!default_file)
|
|
default_file = filename;
|
|
}
|
|
}
|
|
|
|
/* free all files */
|
|
tcc_free(files);
|
|
|
|
if (0 == ret) {
|
|
if (do_bench)
|
|
tcc_print_stats(s, getclock_us() - start_time);
|
|
|
|
if (s->output_type == TCC_OUTPUT_MEMORY) {
|
|
#ifdef TCC_IS_NATIVE
|
|
ret = tcc_run(s, argc - 1 - optind, argv + 1 + optind);
|
|
#else
|
|
tcc_error_noabort("-run is not available in a cross compiler");
|
|
#endif
|
|
} else if (s->output_type == TCC_OUTPUT_PREPROCESS) {
|
|
if (s->outfile)
|
|
fclose(s->outfile);
|
|
} else {
|
|
if (!outfile)
|
|
outfile = tcc_default_target(s, default_file);
|
|
ret = !!tcc_output_file(s, outfile);
|
|
/* dump collected dependencies */
|
|
if (gen_deps && !ret)
|
|
tcc_gen_makedeps(s, outfile, deps_outfile);
|
|
}
|
|
}
|
|
|
|
tcc_delete(s);
|
|
cstr_free(&linker_arg);
|
|
tcc_free(outfile);
|
|
|
|
#ifdef MEM_DEBUG
|
|
if (do_bench) {
|
|
printf("memory: %d bytes, max = %d bytes\n", mem_cur_size, mem_max_size);
|
|
}
|
|
#endif
|
|
return ret;
|
|
}
|