/* Wrapper to call lto. Used by collect2 and the linker plugin.
|
/* Wrapper to call lto. Used by collect2 and the linker plugin.
|
Copyright (C) 2009, 2010 Free Software Foundation, Inc.
|
Copyright (C) 2009, 2010 Free Software Foundation, Inc.
|
|
|
Factored out of collect2 by Rafael Espindola <espindola@google.com>
|
Factored out of collect2 by Rafael Espindola <espindola@google.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
/* This program is passed a gcc, a list of gcc arguments and a list of
|
/* This program is passed a gcc, a list of gcc arguments and a list of
|
object files containing IL. It scans the argument list to check if
|
object files containing IL. It scans the argument list to check if
|
we are in whopr mode or not modifies the arguments and needed and
|
we are in whopr mode or not modifies the arguments and needed and
|
prints a list of output files on stdout.
|
prints a list of output files on stdout.
|
|
|
Example:
|
Example:
|
|
|
$ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
|
$ lto-wrapper gcc/xgcc -B gcc a.o b.o -o test -flto
|
|
|
The above will print something like
|
The above will print something like
|
/tmp/ccwbQ8B2.lto.o
|
/tmp/ccwbQ8B2.lto.o
|
|
|
If -fwhopr is used instead, more than one file might be produced
|
If -fwhopr is used instead, more than one file might be produced
|
./ccXj2DTk.lto.ltrans.o
|
./ccXj2DTk.lto.ltrans.o
|
./ccCJuXGv.lto.ltrans.o
|
./ccCJuXGv.lto.ltrans.o
|
*/
|
*/
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "intl.h"
|
#include "intl.h"
|
#include "libiberty.h"
|
#include "libiberty.h"
|
|
|
int debug; /* true if -debug */
|
int debug; /* true if -debug */
|
|
|
enum lto_mode_d {
|
enum lto_mode_d {
|
LTO_MODE_NONE, /* Not doing LTO. */
|
LTO_MODE_NONE, /* Not doing LTO. */
|
LTO_MODE_LTO, /* Normal LTO. */
|
LTO_MODE_LTO, /* Normal LTO. */
|
LTO_MODE_WHOPR /* WHOPR. */
|
LTO_MODE_WHOPR /* WHOPR. */
|
};
|
};
|
|
|
/* Current LTO mode. */
|
/* Current LTO mode. */
|
static enum lto_mode_d lto_mode = LTO_MODE_NONE;
|
static enum lto_mode_d lto_mode = LTO_MODE_NONE;
|
|
|
static char *ltrans_output_file;
|
static char *ltrans_output_file;
|
static char *flto_out;
|
static char *flto_out;
|
static char *args_name;
|
static char *args_name;
|
|
|
static void maybe_unlink_file (const char *);
|
static void maybe_unlink_file (const char *);
|
|
|
/* Delete tempfiles and exit function. */
|
/* Delete tempfiles and exit function. */
|
|
|
static void
|
static void
|
lto_wrapper_exit (int status)
|
lto_wrapper_exit (int status)
|
{
|
{
|
static bool cleanup_done = false;
|
static bool cleanup_done = false;
|
if (!cleanup_done)
|
if (!cleanup_done)
|
{
|
{
|
/* Setting cleanup_done prevents an infinite loop if one of the
|
/* Setting cleanup_done prevents an infinite loop if one of the
|
calls to maybe_unlink_file fails. */
|
calls to maybe_unlink_file fails. */
|
cleanup_done = true;
|
cleanup_done = true;
|
|
|
if (ltrans_output_file)
|
if (ltrans_output_file)
|
maybe_unlink_file (ltrans_output_file);
|
maybe_unlink_file (ltrans_output_file);
|
if (flto_out)
|
if (flto_out)
|
maybe_unlink_file (flto_out);
|
maybe_unlink_file (flto_out);
|
if (args_name)
|
if (args_name)
|
maybe_unlink_file (args_name);
|
maybe_unlink_file (args_name);
|
}
|
}
|
exit (status);
|
exit (status);
|
}
|
}
|
|
|
/* Just die. CMSGID is the error message. */
|
/* Just die. CMSGID is the error message. */
|
|
|
static void __attribute__ ((format (printf, 1, 2)))
|
static void __attribute__ ((format (printf, 1, 2)))
|
fatal (const char * cmsgid, ...)
|
fatal (const char * cmsgid, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
|
|
va_start (ap, cmsgid);
|
va_start (ap, cmsgid);
|
fprintf (stderr, "lto-wrapper: ");
|
fprintf (stderr, "lto-wrapper: ");
|
vfprintf (stderr, _(cmsgid), ap);
|
vfprintf (stderr, _(cmsgid), ap);
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
va_end (ap);
|
va_end (ap);
|
|
|
lto_wrapper_exit (FATAL_EXIT_CODE);
|
lto_wrapper_exit (FATAL_EXIT_CODE);
|
}
|
}
|
|
|
|
|
/* Die when sys call fails. CMSGID is the error message. */
|
/* Die when sys call fails. CMSGID is the error message. */
|
|
|
static void __attribute__ ((format (printf, 1, 2)))
|
static void __attribute__ ((format (printf, 1, 2)))
|
fatal_perror (const char *cmsgid, ...)
|
fatal_perror (const char *cmsgid, ...)
|
{
|
{
|
int e = errno;
|
int e = errno;
|
va_list ap;
|
va_list ap;
|
|
|
va_start (ap, cmsgid);
|
va_start (ap, cmsgid);
|
fprintf (stderr, "lto-wrapper: ");
|
fprintf (stderr, "lto-wrapper: ");
|
vfprintf (stderr, _(cmsgid), ap);
|
vfprintf (stderr, _(cmsgid), ap);
|
fprintf (stderr, ": %s\n", xstrerror (e));
|
fprintf (stderr, ": %s\n", xstrerror (e));
|
va_end (ap);
|
va_end (ap);
|
|
|
lto_wrapper_exit (FATAL_EXIT_CODE);
|
lto_wrapper_exit (FATAL_EXIT_CODE);
|
}
|
}
|
|
|
|
|
/* Execute a program, and wait for the reply. ARGV are the arguments. The
|
/* Execute a program, and wait for the reply. ARGV are the arguments. The
|
last one must be NULL. */
|
last one must be NULL. */
|
|
|
static struct pex_obj *
|
static struct pex_obj *
|
collect_execute (char **argv)
|
collect_execute (char **argv)
|
{
|
{
|
struct pex_obj *pex;
|
struct pex_obj *pex;
|
const char *errmsg;
|
const char *errmsg;
|
int err;
|
int err;
|
|
|
if (debug)
|
if (debug)
|
{
|
{
|
char **p_argv;
|
char **p_argv;
|
const char *str;
|
const char *str;
|
|
|
for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
|
for (p_argv = argv; (str = *p_argv) != (char *) 0; p_argv++)
|
fprintf (stderr, " %s", str);
|
fprintf (stderr, " %s", str);
|
|
|
fprintf (stderr, "\n");
|
fprintf (stderr, "\n");
|
}
|
}
|
|
|
fflush (stdout);
|
fflush (stdout);
|
fflush (stderr);
|
fflush (stderr);
|
|
|
pex = pex_init (0, "lto-wrapper", NULL);
|
pex = pex_init (0, "lto-wrapper", NULL);
|
if (pex == NULL)
|
if (pex == NULL)
|
fatal_perror ("pex_init failed");
|
fatal_perror ("pex_init failed");
|
|
|
errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], argv, NULL,
|
errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0], argv, NULL,
|
NULL, &err);
|
NULL, &err);
|
if (errmsg != NULL)
|
if (errmsg != NULL)
|
{
|
{
|
if (err != 0)
|
if (err != 0)
|
{
|
{
|
errno = err;
|
errno = err;
|
fatal_perror (errmsg);
|
fatal_perror (errmsg);
|
}
|
}
|
else
|
else
|
fatal (errmsg);
|
fatal (errmsg);
|
}
|
}
|
|
|
return pex;
|
return pex;
|
}
|
}
|
|
|
|
|
/* Wait for a process to finish, and exit if a nonzero status is found.
|
/* Wait for a process to finish, and exit if a nonzero status is found.
|
PROG is the program name. PEX is the process we should wait for. */
|
PROG is the program name. PEX is the process we should wait for. */
|
|
|
static int
|
static int
|
collect_wait (const char *prog, struct pex_obj *pex)
|
collect_wait (const char *prog, struct pex_obj *pex)
|
{
|
{
|
int status;
|
int status;
|
|
|
if (!pex_get_status (pex, 1, &status))
|
if (!pex_get_status (pex, 1, &status))
|
fatal_perror ("can't get program status");
|
fatal_perror ("can't get program status");
|
pex_free (pex);
|
pex_free (pex);
|
|
|
if (status)
|
if (status)
|
{
|
{
|
if (WIFSIGNALED (status))
|
if (WIFSIGNALED (status))
|
{
|
{
|
int sig = WTERMSIG (status);
|
int sig = WTERMSIG (status);
|
if (WCOREDUMP (status))
|
if (WCOREDUMP (status))
|
fatal ("%s terminated with signal %d [%s], core dumped",
|
fatal ("%s terminated with signal %d [%s], core dumped",
|
prog, sig, strsignal (sig));
|
prog, sig, strsignal (sig));
|
else
|
else
|
fatal ("%s terminated with signal %d [%s]",
|
fatal ("%s terminated with signal %d [%s]",
|
prog, sig, strsignal (sig));
|
prog, sig, strsignal (sig));
|
}
|
}
|
|
|
if (WIFEXITED (status))
|
if (WIFEXITED (status))
|
fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
|
fatal ("%s returned %d exit status", prog, WEXITSTATUS (status));
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
|
|
/* Unlink a temporary LTRANS file unless requested otherwise. */
|
/* Unlink a temporary LTRANS file unless requested otherwise. */
|
|
|
static void
|
static void
|
maybe_unlink_file (const char *file)
|
maybe_unlink_file (const char *file)
|
{
|
{
|
if (! debug)
|
if (! debug)
|
{
|
{
|
if (unlink_if_ordinary (file))
|
if (unlink_if_ordinary (file))
|
fatal_perror ("deleting LTRANS file %s", file);
|
fatal_perror ("deleting LTRANS file %s", file);
|
}
|
}
|
else
|
else
|
fprintf (stderr, "[Leaving LTRANS %s]\n", file);
|
fprintf (stderr, "[Leaving LTRANS %s]\n", file);
|
}
|
}
|
|
|
|
|
/* Execute program ARGV[0] with arguments ARGV. Wait for it to finish. */
|
/* Execute program ARGV[0] with arguments ARGV. Wait for it to finish. */
|
|
|
static void
|
static void
|
fork_execute (char **argv)
|
fork_execute (char **argv)
|
{
|
{
|
struct pex_obj *pex;
|
struct pex_obj *pex;
|
char *new_argv[3];
|
char *new_argv[3];
|
char *at_args;
|
char *at_args;
|
FILE *args;
|
FILE *args;
|
int status;
|
int status;
|
|
|
args_name = make_temp_file (".args");
|
args_name = make_temp_file (".args");
|
at_args = concat ("@", args_name, NULL);
|
at_args = concat ("@", args_name, NULL);
|
args = fopen (args_name, "w");
|
args = fopen (args_name, "w");
|
if (args == NULL)
|
if (args == NULL)
|
fatal ("failed to open %s", args_name);
|
fatal ("failed to open %s", args_name);
|
|
|
status = writeargv (&argv[1], args);
|
status = writeargv (&argv[1], args);
|
|
|
if (status)
|
if (status)
|
fatal ("could not write to temporary file %s", args_name);
|
fatal ("could not write to temporary file %s", args_name);
|
|
|
fclose (args);
|
fclose (args);
|
|
|
new_argv[0] = argv[0];
|
new_argv[0] = argv[0];
|
new_argv[1] = at_args;
|
new_argv[1] = at_args;
|
new_argv[2] = NULL;
|
new_argv[2] = NULL;
|
|
|
pex = collect_execute (new_argv);
|
pex = collect_execute (new_argv);
|
collect_wait (new_argv[0], pex);
|
collect_wait (new_argv[0], pex);
|
|
|
maybe_unlink_file (args_name);
|
maybe_unlink_file (args_name);
|
free (at_args);
|
free (at_args);
|
}
|
}
|
|
|
|
|
/* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
|
/* Execute gcc. ARGC is the number of arguments. ARGV contains the arguments. */
|
|
|
static void
|
static void
|
run_gcc (unsigned argc, char *argv[])
|
run_gcc (unsigned argc, char *argv[])
|
{
|
{
|
unsigned i;
|
unsigned i;
|
unsigned new_argc = argc;
|
unsigned new_argc = argc;
|
const char **new_argv;
|
const char **new_argv;
|
const char **argv_ptr;
|
const char **argv_ptr;
|
char *list_option_full = NULL;
|
char *list_option_full = NULL;
|
|
|
new_argc += 12;
|
new_argc += 12;
|
new_argv = (const char **) xcalloc (sizeof (char *), new_argc);
|
new_argv = (const char **) xcalloc (sizeof (char *), new_argc);
|
|
|
argv_ptr = new_argv;
|
argv_ptr = new_argv;
|
|
|
*argv_ptr++ = argv[0];
|
*argv_ptr++ = argv[0];
|
*argv_ptr++ = "-combine";
|
*argv_ptr++ = "-combine";
|
*argv_ptr++ = "-x";
|
*argv_ptr++ = "-x";
|
*argv_ptr++ = "lto";
|
*argv_ptr++ = "lto";
|
*argv_ptr++ = "-c";
|
*argv_ptr++ = "-c";
|
if (lto_mode == LTO_MODE_LTO)
|
if (lto_mode == LTO_MODE_LTO)
|
{
|
{
|
flto_out = make_temp_file (".lto.o");
|
flto_out = make_temp_file (".lto.o");
|
*argv_ptr++ = "-o";
|
*argv_ptr++ = "-o";
|
*argv_ptr++ = flto_out;
|
*argv_ptr++ = flto_out;
|
}
|
}
|
else if (lto_mode == LTO_MODE_WHOPR)
|
else if (lto_mode == LTO_MODE_WHOPR)
|
{
|
{
|
const char *list_option = "-fltrans-output-list=";
|
const char *list_option = "-fltrans-output-list=";
|
size_t list_option_len = strlen (list_option);
|
size_t list_option_len = strlen (list_option);
|
char *tmp;
|
char *tmp;
|
|
|
ltrans_output_file = make_temp_file (".ltrans.out");
|
ltrans_output_file = make_temp_file (".ltrans.out");
|
list_option_full = (char *) xmalloc (sizeof (char) *
|
list_option_full = (char *) xmalloc (sizeof (char) *
|
(strlen (ltrans_output_file) + list_option_len + 1));
|
(strlen (ltrans_output_file) + list_option_len + 1));
|
tmp = list_option_full;
|
tmp = list_option_full;
|
|
|
*argv_ptr++ = tmp;
|
*argv_ptr++ = tmp;
|
strcpy (tmp, list_option);
|
strcpy (tmp, list_option);
|
tmp += list_option_len;
|
tmp += list_option_len;
|
strcpy (tmp, ltrans_output_file);
|
strcpy (tmp, ltrans_output_file);
|
|
|
*argv_ptr++ = "-fwpa";
|
*argv_ptr++ = "-fwpa";
|
}
|
}
|
else
|
else
|
fatal ("invalid LTO mode");
|
fatal ("invalid LTO mode");
|
|
|
/* Add inherited GCC options to the LTO back end command line.
|
/* Add inherited GCC options to the LTO back end command line.
|
Filter out some obviously inappropriate options that will
|
Filter out some obviously inappropriate options that will
|
conflict with the options that we force above. We pass
|
conflict with the options that we force above. We pass
|
all of the remaining options on to LTO, and let it complain
|
all of the remaining options on to LTO, and let it complain
|
about any it doesn't like. Note that we invoke LTO via the
|
about any it doesn't like. Note that we invoke LTO via the
|
`gcc' driver, so the usual option processing takes place.
|
`gcc' driver, so the usual option processing takes place.
|
Except for `-flto' and `-fwhopr', we should only filter options that
|
Except for `-flto' and `-fwhopr', we should only filter options that
|
are meaningful to `ld', lest an option go silently unclaimed. */
|
are meaningful to `ld', lest an option go silently unclaimed. */
|
for (i = 1; i < argc; i++)
|
for (i = 1; i < argc; i++)
|
{
|
{
|
const char *s = argv[i];
|
const char *s = argv[i];
|
|
|
if (strcmp (s, "-flto") == 0 || strcmp (s, "-fwhopr") == 0)
|
if (strcmp (s, "-flto") == 0 || strcmp (s, "-fwhopr") == 0)
|
/* We've handled this LTO option, don't pass it on. */
|
/* We've handled this LTO option, don't pass it on. */
|
;
|
;
|
else if (*s == '-' && s[1] == 'o')
|
else if (*s == '-' && s[1] == 'o')
|
{
|
{
|
/* Drop `-o' and its filename argument. We will use a
|
/* Drop `-o' and its filename argument. We will use a
|
temporary file for the LTO output. The `-o' option
|
temporary file for the LTO output. The `-o' option
|
will be interpreted by the linker. */
|
will be interpreted by the linker. */
|
if (s[2] == '\0')
|
if (s[2] == '\0')
|
{
|
{
|
char *output_dir, *base, *name;
|
char *output_dir, *base, *name;
|
|
|
i++;
|
i++;
|
output_dir = xstrdup (argv[i]);
|
output_dir = xstrdup (argv[i]);
|
base = output_dir;
|
base = output_dir;
|
for (name = base; *name; name++)
|
for (name = base; *name; name++)
|
if (IS_DIR_SEPARATOR (*name))
|
if (IS_DIR_SEPARATOR (*name))
|
base = name + 1;
|
base = name + 1;
|
*base = '\0';
|
*base = '\0';
|
|
|
*argv_ptr++ = "-dumpbase";
|
*argv_ptr++ = "-dumpbase";
|
if (*output_dir == '\0')
|
if (*output_dir == '\0')
|
{
|
{
|
static char current_dir[] =
|
static char current_dir[] =
|
{ '.', DIR_SEPARATOR, '\0' };
|
{ '.', DIR_SEPARATOR, '\0' };
|
output_dir = current_dir;
|
output_dir = current_dir;
|
*argv_ptr++ = argv[i];
|
*argv_ptr++ = argv[i];
|
}
|
}
|
else
|
else
|
*argv_ptr++ = &argv[i][base - output_dir];
|
*argv_ptr++ = &argv[i][base - output_dir];
|
|
|
*argv_ptr++ = "-dumpdir";
|
*argv_ptr++ = "-dumpdir";
|
*argv_ptr++ = output_dir;
|
*argv_ptr++ = output_dir;
|
}
|
}
|
}
|
}
|
else
|
else
|
/* Pass the option or argument to LTO. */
|
/* Pass the option or argument to LTO. */
|
*argv_ptr++ = s;
|
*argv_ptr++ = s;
|
}
|
}
|
|
|
*argv_ptr = NULL;
|
*argv_ptr = NULL;
|
|
|
fork_execute (CONST_CAST (char **, new_argv));
|
fork_execute (CONST_CAST (char **, new_argv));
|
free (new_argv);
|
free (new_argv);
|
new_argv = NULL;
|
new_argv = NULL;
|
|
|
if (lto_mode == LTO_MODE_LTO)
|
if (lto_mode == LTO_MODE_LTO)
|
{
|
{
|
printf("%s\n", flto_out);
|
printf("%s\n", flto_out);
|
free (flto_out);
|
free (flto_out);
|
flto_out = NULL;
|
flto_out = NULL;
|
}
|
}
|
else if (lto_mode == LTO_MODE_WHOPR)
|
else if (lto_mode == LTO_MODE_WHOPR)
|
{
|
{
|
FILE *stream = fopen (ltrans_output_file, "r");
|
FILE *stream = fopen (ltrans_output_file, "r");
|
int c;
|
int c;
|
|
|
if (!stream)
|
if (!stream)
|
fatal_perror ("fopen: %s", ltrans_output_file);
|
fatal_perror ("fopen: %s", ltrans_output_file);
|
|
|
while ((c = getc (stream)) != EOF)
|
while ((c = getc (stream)) != EOF)
|
putc (c, stdout);
|
putc (c, stdout);
|
fclose (stream);
|
fclose (stream);
|
maybe_unlink_file (ltrans_output_file);
|
maybe_unlink_file (ltrans_output_file);
|
free (list_option_full);
|
free (list_option_full);
|
}
|
}
|
else
|
else
|
fatal ("invalid LTO mode");
|
fatal ("invalid LTO mode");
|
}
|
}
|
|
|
|
|
/* Parse the command line. Copy any unused argument to GCC_ARGV. ARGC is the
|
/* Parse the command line. Copy any unused argument to GCC_ARGV. ARGC is the
|
number of arguments. ARGV contains the arguments. */
|
number of arguments. ARGV contains the arguments. */
|
|
|
static int
|
static int
|
process_args (int argc, char *argv[], char *gcc_argv[])
|
process_args (int argc, char *argv[], char *gcc_argv[])
|
{
|
{
|
int i;
|
int i;
|
int j = 0;
|
int j = 0;
|
|
|
for (i = 1; i < argc; i ++)
|
for (i = 1; i < argc; i ++)
|
{
|
{
|
if (! strcmp (argv[i], "-debug"))
|
if (! strcmp (argv[i], "-debug"))
|
debug = 1;
|
debug = 1;
|
else if (! strcmp (argv[i], "-flto"))
|
else if (! strcmp (argv[i], "-flto"))
|
lto_mode = LTO_MODE_LTO;
|
lto_mode = LTO_MODE_LTO;
|
else if (! strcmp (argv[i], "-fwhopr"))
|
else if (! strcmp (argv[i], "-fwhopr"))
|
lto_mode = LTO_MODE_WHOPR;
|
lto_mode = LTO_MODE_WHOPR;
|
else
|
else
|
{
|
{
|
gcc_argv[j] = argv[i];
|
gcc_argv[j] = argv[i];
|
j++;
|
j++;
|
}
|
}
|
}
|
}
|
|
|
return j;
|
return j;
|
}
|
}
|
|
|
|
|
/* Entry point. */
|
/* Entry point. */
|
|
|
int
|
int
|
main (int argc, char *argv[])
|
main (int argc, char *argv[])
|
{
|
{
|
char **gcc_argv;
|
char **gcc_argv;
|
int gcc_argc;
|
int gcc_argc;
|
|
|
gcc_init_libintl ();
|
gcc_init_libintl ();
|
|
|
/* We may be called with all the arguments stored in some file and
|
/* We may be called with all the arguments stored in some file and
|
passed with @file. Expand them into argv before processing. */
|
passed with @file. Expand them into argv before processing. */
|
expandargv (&argc, &argv);
|
expandargv (&argc, &argv);
|
gcc_argv = (char **) xcalloc (sizeof (char *), argc);
|
gcc_argv = (char **) xcalloc (sizeof (char *), argc);
|
gcc_argc = process_args (argc, argv, gcc_argv);
|
gcc_argc = process_args (argc, argv, gcc_argv);
|
run_gcc (gcc_argc, gcc_argv);
|
run_gcc (gcc_argc, gcc_argv);
|
free (gcc_argv);
|
free (gcc_argv);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
