int
main(int ac, char **av)
{
char *input_file = NULL;
int opt;
static struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{NULL, no_argument, 0, 0}
};
#if defined(HAVE_SETLOCALE) && defined(HAVE_LC_MESSAGES)
setlocale(LC_MESSAGES, "");
#endif /* HAVE_SETLOCALE && HAVE_LC_MESSAGES */
#if defined(HAVE_SETLOCALE)
setlocale(LC_CTYPE, "");
#endif /* HAVE_SETLOCALE */
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
program_name = av[0];
xmalloc_set_program_name (program_name);
while ((opt = getopt_long(ac, av, "HhVv", long_options, (int *)NULL)) != EOF)
{
switch (opt)
{
case 'H':
case 'h':
show_usage(stdout, 0);
/*NOTREACHED*/
case 'v':
case 'V':
print_version("sysdump");
exit (0);
/*NOTREACHED*/
case 0:
break;
default:
show_usage(stderr, 1);
/*NOTREACHED*/
}
}
/* The input and output files may be named on the command line: */
if (optind < ac)
input_file = av[optind];
if (!input_file)
fatal(_("no input file specified"));
file = fopen(input_file, FOPEN_RB);
if (!file)
fatal(_("cannot open input file %s"), input_file);
module();
return 0;
}
int
main (int argc, char **argv)
{
int c;
char *target = default_target;
program_name = *argv;
xmalloc_set_program_name (program_name);
bfd_init ();
set_default_bfd_target ();
while ((c = getopt_long (argc, argv, "aip0svb?",
long_options, (int *) 0)) != EOF)
switch (c)
{
case 'a' :
sort_by_address = 1;
break;
case 'v' :
verbose = 1;
break;
case 'p' :
physical_addresses = 1;
break;
case 'i' :
physical_addresses = 0;
break;
case '0' :
a0_address_mapping = 1;
break;
case 's' :
a0_address_mapping = 0;
break;
case 'b' :
target = optarg;
break;
case '?' :
show_usage = 1;
break;
default :
show_usage = 1;
break;
}
if (show_usage)
usage (stdout, 0);
if (optind == argc)
{
char *file = strdup ("a.out");
hexify_file (file, target);
free (file);
}
else
for (; optind < argc;)
hexify_file (argv[optind++], target);
return exit_status;
}
/* Initialization of the front end environment, before command line
options are parsed. Signal handlers, internationalization etc.
ARGV0 is main's argv[0]. */
static void
general_init (const char *argv0)
{
const char *p;
p = argv0 + strlen (argv0);
while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
--p;
progname = p;
xmalloc_set_program_name (progname);
hex_init ();
gcc_init_libintl ();
line_table = XNEW (struct line_maps);
linemap_init (line_table);
line_table->reallocator = xrealloc;
}
void
initialize ( int argc, char** argv )
{
xmalloc_set_program_name (argv[0]);
switch (argc)
{
case 1:
break;
case 2:
if (strcmp (argv[1], "-v") == 0)
do_version ();
if (freopen (argv[1], "r", stdin) == (FILE*)NULL)
{
fprintf (stderr, "Error %d (%s) reopening %s as stdin\n",
errno, xstrerror (errno), argv[1] );
exit (EXIT_FAILURE);
}
break;
default:
fputs ("fixincl ERROR: too many command line arguments\n", stderr);
exit (EXIT_FAILURE);
}
#ifdef SIGCHLD
/* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
receive the signal. A different setting is inheritable */
signal (SIGCHLD, SIG_DFL);
#endif
initialize_opts ();
if (ISDIGIT ( *pz_verbose ))
verbose_level = (te_verbose)atoi( pz_verbose );
else
switch (*pz_verbose) {
case 's':
case 'S':
verbose_level = VERB_SILENT; break;
case 'f':
case 'F':
verbose_level = VERB_FIXES; break;
case 'a':
case 'A':
verbose_level = VERB_APPLIES; break;
default:
case 'p':
case 'P':
verbose_level = VERB_PROGRESS; break;
case 't':
case 'T':
verbose_level = VERB_TESTS; break;
case 'e':
case 'E':
verbose_level = VERB_EVERYTHING; break;
}
if (verbose_level >= VERB_EVERYTHING) {
verbose_level = VERB_EVERYTHING;
fputs ("fixinc verbosity: EVERYTHING\n", stderr);
}
while ((pz_find_base[0] == '.') && (pz_find_base[1] == '/'))
pz_find_base += 2;
if ((pz_find_base[0] != '.') || (pz_find_base[1] != NUL))
find_base_len = strlen( pz_find_base );
/* Compile all the regular expressions now.
That way, it is done only once for the whole run.
*/
run_compiles ();
# ifdef SEPARATE_FIX_PROC
/* NULL as the first argument to `tempnam' causes it to DTRT
wrt the temporary directory where the file will be created. */
pz_temp_file = tempnam( NULL, "fxinc" );
# endif
signal (SIGQUIT, SIG_IGN);
signal (SIGIOT, SIG_IGN);
signal (SIGPIPE, SIG_IGN);
signal (SIGALRM, SIG_IGN);
signal (SIGTERM, SIG_IGN);
}
int
main (int argc, char **argv)
{
char *emulation;
long start_time = get_run_time ();
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
program_name = argv[0];
xmalloc_set_program_name (program_name);
START_PROGRESS (program_name, 0);
expandargv (&argc, &argv);
bfd_init ();
bfd_set_error_program_name (program_name);
xatexit (ld_cleanup);
/* Set up the sysroot directory. */
ld_sysroot = get_sysroot (argc, argv);
if (*ld_sysroot)
{
if (*TARGET_SYSTEM_ROOT == 0)
{
einfo ("%P%F: this linker was not configured to use sysroots\n");
ld_sysroot = "";
}
else
ld_canon_sysroot = lrealpath (ld_sysroot);
}
if (ld_canon_sysroot)
ld_canon_sysroot_len = strlen (ld_canon_sysroot);
else
ld_canon_sysroot_len = -1;
/* Set the default BFD target based on the configured target. Doing
this permits the linker to be configured for a particular target,
and linked against a shared BFD library which was configured for
a different target. The macro TARGET is defined by Makefile. */
if (! bfd_set_default_target (TARGET))
{
einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
xexit (1);
}
#if YYDEBUG
{
extern int yydebug;
yydebug = 1;
}
#endif
config.build_constructors = TRUE;
config.rpath_separator = ':';
config.split_by_reloc = (unsigned) -1;
config.split_by_file = (bfd_size_type) -1;
config.make_executable = TRUE;
config.magic_demand_paged = TRUE;
config.text_read_only = TRUE;
command_line.warn_mismatch = TRUE;
command_line.warn_search_mismatch = TRUE;
command_line.check_section_addresses = -1;
command_line.disable_target_specific_optimizations = -1;
/* We initialize DEMANGLING based on the environment variable
COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
output of the linker, unless COLLECT_NO_DEMANGLE is set in the
environment. Acting the same way here lets us provide the same
interface by default. */
demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
link_info.allow_undefined_version = TRUE;
link_info.keep_memory = TRUE;
link_info.combreloc = TRUE;
link_info.strip_discarded = TRUE;
link_info.emit_hash = TRUE;
link_info.callbacks = &link_callbacks;
link_info.input_bfds_tail = &link_info.input_bfds;
/* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
and _fini symbols. We are compatible. */
link_info.init_function = "_init";
link_info.fini_function = "_fini";
link_info.relax_pass = 1;
link_info.pei386_auto_import = -1;
link_info.spare_dynamic_tags = 5;
link_info.path_separator = ':';
ldfile_add_arch ("");
emulation = get_emulation (argc, argv);
ldemul_choose_mode (emulation);
default_target = ldemul_choose_target (argc, argv);
config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
lang_init ();
ldemul_before_parse ();
lang_has_input_file = FALSE;
parse_args (argc, argv);
if (config.hash_table_size != 0)
bfd_hash_set_default_size (config.hash_table_size);
ldemul_set_symbols ();
if (link_info.relocatable)
{
if (command_line.check_section_addresses < 0)
command_line.check_section_addresses = 0;
if (link_info.shared)
einfo (_("%P%F: -r and -shared may not be used together\n"));
}
/* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data,
--dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and
--dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are
for shared libraries. -Bsymbolic overrides all others and vice
versa. */
switch (command_line.symbolic)
{
case symbolic_unset:
break;
case symbolic:
/* -Bsymbolic is for shared library only. */
if (link_info.shared)
{
link_info.symbolic = TRUE;
/* Should we free the unused memory? */
link_info.dynamic_list = NULL;
command_line.dynamic_list = dynamic_list_unset;
}
break;
case symbolic_functions:
/* -Bsymbolic-functions is for shared library only. */
if (link_info.shared)
command_line.dynamic_list = dynamic_list_data;
break;
}
switch (command_line.dynamic_list)
{
case dynamic_list_unset:
break;
case dynamic_list_data:
link_info.dynamic_data = TRUE;
case dynamic_list:
link_info.dynamic = TRUE;
break;
}
if (! link_info.shared)
{
if (command_line.filter_shlib)
einfo (_("%P%F: -F may not be used without -shared\n"));
if (command_line.auxiliary_filters)
einfo (_("%P%F: -f may not be used without -shared\n"));
}
if (! link_info.shared || link_info.pie)
link_info.executable = TRUE;
/* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I
don't see how else this can be handled, since in this case we
must preserve all externally visible symbols. */
if (link_info.relocatable && link_info.strip == strip_all)
{
link_info.strip = strip_debugger;
if (link_info.discard == discard_sec_merge)
link_info.discard = discard_all;
}
/* If we have not already opened and parsed a linker script,
try the default script from command line first. */
if (saved_script_handle == NULL
&& command_line.default_script != NULL)
{
ldfile_open_command_file (command_line.default_script);
parser_input = input_script;
yyparse ();
}
/* If we have not already opened and parsed a linker script
read the emulation's appropriate default script. */
if (saved_script_handle == NULL)
{
int isfile;
char *s = ldemul_get_script (&isfile);
if (isfile)
ldfile_open_default_command_file (s);
else
{
lex_string = s;
lex_redirect (s);
}
parser_input = input_script;
yyparse ();
lex_string = NULL;
}
if (trace_file_tries)
{
if (saved_script_handle)
info_msg (_("using external linker script:"));
else
info_msg (_("using internal linker script:"));
info_msg ("\n==================================================\n");
if (saved_script_handle)
{
static const int ld_bufsz = 8193;
size_t n;
char *buf = (char *) xmalloc (ld_bufsz);
rewind (saved_script_handle);
while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
{
buf[n] = 0;
info_msg (buf);
}
rewind (saved_script_handle);
free (buf);
}
else
{
int isfile;
info_msg (ldemul_get_script (&isfile));
}
info_msg ("\n==================================================\n");
}
lang_final ();
if (!lang_has_input_file)
{
if (version_printed)
xexit (0);
einfo (_("%P%F: no input files\n"));
}
if (trace_files)
info_msg (_("%P: mode %s\n"), emulation);
ldemul_after_parse ();
if (config.map_filename)
{
if (strcmp (config.map_filename, "-") == 0)
{
config.map_file = stdout;
}
else
{
config.map_file = fopen (config.map_filename, FOPEN_WT);
if (config.map_file == (FILE *) NULL)
{
bfd_set_error (bfd_error_system_call);
einfo (_("%P%F: cannot open map file %s: %E\n"),
config.map_filename);
}
}
}
lang_process ();
/* Print error messages for any missing symbols, for any warning
symbols, and possibly multiple definitions. */
if (link_info.relocatable)
link_info.output_bfd->flags &= ~EXEC_P;
else
link_info.output_bfd->flags |= EXEC_P;
ldwrite ();
if (config.map_file != NULL)
lang_map ();
if (command_line.cref)
output_cref (config.map_file != NULL ? config.map_file : stdout);
if (nocrossref_list != NULL)
check_nocrossrefs ();
lang_finish ();
/* Even if we're producing relocatable output, some non-fatal errors should
be reported in the exit status. (What non-fatal errors, if any, do we
want to ignore for relocatable output?) */
if (!config.make_executable && !force_make_executable)
{
if (trace_files)
einfo (_("%P: link errors found, deleting executable `%s'\n"),
output_filename);
/* The file will be removed by remove_output. */
xexit (1);
}
else
{
if (! bfd_close (link_info.output_bfd))
einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
/* If the --force-exe-suffix is enabled, and we're making an
executable file and it doesn't end in .exe, copy it to one
which does. */
if (! link_info.relocatable && command_line.force_exe_suffix)
{
int len = strlen (output_filename);
if (len < 4
|| (strcasecmp (output_filename + len - 4, ".exe") != 0
&& strcasecmp (output_filename + len - 4, ".dll") != 0))
{
FILE *src;
FILE *dst;
const int bsize = 4096;
char *buf = (char *) xmalloc (bsize);
int l;
char *dst_name = (char *) xmalloc (len + 5);
strcpy (dst_name, output_filename);
strcat (dst_name, ".exe");
src = fopen (output_filename, FOPEN_RB);
dst = fopen (dst_name, FOPEN_WB);
if (!src)
einfo (_("%X%P: unable to open for source of copy `%s'\n"),
output_filename);
if (!dst)
einfo (_("%X%P: unable to open for destination of copy `%s'\n"),
dst_name);
while ((l = fread (buf, 1, bsize, src)) > 0)
{
int done = fwrite (buf, 1, l, dst);
if (done != l)
einfo (_("%P: Error writing file `%s'\n"), dst_name);
}
fclose (src);
if (fclose (dst) == EOF)
einfo (_("%P: Error closing file `%s'\n"), dst_name);
free (dst_name);
free (buf);
}
}
}
END_PROGRESS (program_name);
if (config.stats)
{
#ifdef HAVE_SBRK
char *lim = (char *) sbrk (0);
#endif
long run_time = get_run_time () - start_time;
fflush (stdout);
fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
program_name, run_time / 1000000, run_time % 1000000);
#ifdef HAVE_SBRK
fprintf (stderr, _("%s: data size %ld\n"), program_name,
(long) (lim - (char *) &environ));
#endif
fflush (stderr);
}
/* Prevent remove_output from doing anything, after a successful link. */
output_filename = NULL;
xexit (0);
return 0;
}
void
general_init(const char *argv0)
{
const char *p;
p = argv0 + strlen(argv0);
while(p != argv0 && !IS_DIR_SEPARATOR(p[-1]))
--p;
progname = p;
xmalloc_set_program_name(progname);
hex_init();
/* Unlock the stdio streams. */
unlock_std_streams();
gcc_init_libintl();
/* Initialize the diagnostics reporting machinery, so option parsing
can give warnings and errors. */
diagnostic_initialize(global_dc);
/* Set a default printer. Language specific initializations will
override it later. */
pp_format_decoder(global_dc->printer) = &default_tree_printer;
/* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
#ifdef SIGSEGV
signal(SIGSEGV, crash_signal);
#endif
#ifdef SIGILL
signal(SIGILL, crash_signal);
#endif
#ifdef SIGBUS
signal(SIGBUS, crash_signal);
#endif
#ifdef SIGABRT
signal(SIGABRT, crash_signal);
#endif
#if defined SIGIOT &&(!defined SIGABRT || SIGABRT != SIGIOT)
signal(SIGIOT, crash_signal);
#endif
#ifdef SIGFPE
signal(SIGFPE, crash_signal);
#endif
/* Other host-specific signal setup. */
(*host_hooks.extra_signals)();
/* Initialize the garbage-collector, string pools and tree type hash
table. */
init_ggc();
init_stringpool();
linemap_init(&line_table);
init_ttree();
/* Initialize register usage now so switches may override. */
init_reg_sets();
/* Register the language-independent parameters. */
add_params(lang_independent_params, LAST_PARAM);
/* This must be done after add_params but before argument processing. */
init_ggc_heuristics();
init_optimization_passes();
}
int
main (int argc, char **argv)
{
int c;
const char *valid_symbols;
enum demangling_styles style = auto_demangling;
program_name = argv[0];
xmalloc_set_program_name (program_name);
bfd_set_error_program_name (program_name);
expandargv (&argc, &argv);
while ((c = getopt_long (argc, argv, "_hinps:tv", long_options, (int *) 0)) != EOF)
{
switch (c)
{
case '?':
usage (stderr, 1);
break;
case 'h':
usage (stdout, 0);
case 'n':
strip_underscore = 0;
break;
case 'p':
flags &= ~ DMGL_PARAMS;
break;
case 't':
flags |= DMGL_TYPES;
break;
case 'i':
flags &= ~ DMGL_VERBOSE;
break;
case 'v':
print_version ("c++filt");
return 0;
case '_':
strip_underscore = 1;
break;
case 's':
style = cplus_demangle_name_to_style (optarg);
if (style == unknown_demangling)
{
fprintf (stderr, "%s: unknown demangling style `%s'\n",
program_name, optarg);
return 1;
}
cplus_demangle_set_style (style);
break;
}
}
if (optind < argc)
{
for ( ; optind < argc; optind++)
{
demangle_it (argv[optind]);
putchar ('\n');
}
return 0;
}
switch (current_demangling_style)
{
case gnu_demangling:
case lucid_demangling:
case arm_demangling:
case java_demangling:
case edg_demangling:
case gnat_demangling:
case gnu_v3_demangling:
case dlang_demangling:
case auto_demangling:
valid_symbols = standard_symbol_characters ();
break;
case hp_demangling:
valid_symbols = hp_symbol_characters ();
break;
default:
/* Folks should explicitly indicate the appropriate alphabet for
each demangling. Providing a default would allow the
question to go unconsidered. */
fatal ("Internal error: no symbol alphabet for current style");
}
for (;;)
{
static char mbuffer[32767];
unsigned i = 0;
c = getchar ();
/* Try to read a mangled name. */
while (c != EOF && (ISALNUM (c) || strchr (valid_symbols, c)))
{
if (i >= sizeof (mbuffer) - 1)
break;
mbuffer[i++] = c;
c = getchar ();
}
if (i > 0)
{
mbuffer[i] = 0;
demangle_it (mbuffer);
}
if (c == EOF)
break;
/* Echo the whitespace characters so that the output looks
like the input, only with the mangled names demangled. */
putchar (c);
if (c == '\n')
fflush (stdout);
}
fflush (stdout);
return 0;
}
int
main (int argc, char **argv)
{
char *classname, *p;
FILE *stream;
const char *mangled_classname;
int i, last_arg;
int indirect = 0;
char *prog_name = argv[0];
p = argv[0] + strlen (argv[0]);
while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
--p;
progname = p;
xmalloc_set_program_name (progname);
/* Unlock the stdio streams. */
unlock_std_streams ();
gcc_init_libintl ();
diagnostic_initialize (global_dc, 0);
if (argc > 1 && ! strcmp (argv[1], "-findirect-dispatch"))
{
indirect = 1;
++argv;
--argc;
}
if (argc < 2)
usage (prog_name);
for (i = 1; i < argc; ++i)
{
if (! strncmp (argv[i], "-D", 2))
{
/* Handled later. Check "-D XXX=YYY". */
if (argv[i][2] == '\0')
i++;
}
else
break;
}
if (i < argc - 2 || i == argc)
usage (prog_name);
last_arg = i;
classname = argv[i];
/* gcj always appends `main' to classname. We need to strip this here. */
p = strrchr (classname, 'm');
if (p == NULL || p == classname || strcmp (p, "main") != 0)
usage (prog_name);
else
*p = '\0';
gcc_obstack_init (mangle_obstack);
mangled_classname = do_mangle_classname (classname);
if (i < argc - 1 && strcmp (argv[i + 1], "-") != 0)
{
const char *outfile = argv[i + 1];
stream = fopen (outfile, "w");
if (stream == NULL)
{
fprintf (stderr, _("%s: Cannot open output file: %s\n"),
prog_name, outfile);
exit (1);
}
}
else
stream = stdout;
/* At this point every element of ARGV from 1 to LAST_ARG is a `-D'
option. Process them appropriately. */
fprintf (stream, "extern const char **_Jv_Compiler_Properties;\n");
if (indirect)
fprintf (stream, "extern void JvRunMainName ();\n");
else
fprintf (stream, "extern void JvRunMain ();\n");
fprintf (stream, "static const char *props[] =\n{\n");
for (i = 1; i < last_arg; ++i)
{
const char *p;
if (strcmp (argv[i], "-D") == 0)
continue;
fprintf (stream, " \"");
for (p = argv[i]; *p; ++p)
{
if (! ISPRINT (*p))
fprintf (stream, "\\%o", *p);
else if (*p == '\\' || *p == '"')
fprintf (stream, "\\%c", *p);
else
putc (*p, stream);
}
fprintf (stream, "\",\n");
}
fprintf (stream, " 0\n};\n\n");
fprintf (stream, "int main (int argc, const char **argv)\n");
fprintf (stream, "{\n");
fprintf (stream, " _Jv_Compiler_Properties = props;\n");
if (indirect)
fprintf (stream, " JvRunMainName (\"%s\", argc, argv);\n", classname);
else
{
fprintf (stream, " extern char %s;\n", mangled_classname);
fprintf (stream, " JvRunMain (&%s, argc, argv);\n", mangled_classname);
}
fprintf (stream, "}\n");
if (stream != stdout && fclose (stream) != 0)
{
fprintf (stderr, _("%s: Failed to close output file %s\n"),
prog_name, argv[2]);
exit (1);
}
return 0;
}
int
main (int argc, char **argv)
{
char *emulation;
long start_time = get_run_time ();
#ifdef HAVE_SBRK
char *start_sbrk = (char *) sbrk (0);
#endif
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
program_name = argv[0];
xmalloc_set_program_name (program_name);
START_PROGRESS (program_name, 0);
expandargv (&argc, &argv);
bfd_init ();
bfd_set_error_program_name (program_name);
/* We want to notice and fail on those nasty BFD assertions which are
likely to signal incorrect output being generated but otherwise may
leave no trace. */
default_bfd_assert_handler = bfd_set_assert_handler (ld_bfd_assert_handler);
xatexit (ld_cleanup);
/* Set up the sysroot directory. */
ld_sysroot = get_sysroot (argc, argv);
if (*ld_sysroot)
ld_canon_sysroot = lrealpath (ld_sysroot);
if (ld_canon_sysroot)
ld_canon_sysroot_len = strlen (ld_canon_sysroot);
else
ld_canon_sysroot_len = -1;
/* Set the default BFD target based on the configured target. Doing
this permits the linker to be configured for a particular target,
and linked against a shared BFD library which was configured for
a different target. The macro TARGET is defined by Makefile. */
if (! bfd_set_default_target (TARGET))
{
einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET);
xexit (1);
}
#if YYDEBUG
{
extern int yydebug;
yydebug = 1;
}
#endif
config.build_constructors = TRUE;
config.rpath_separator = ':';
config.split_by_reloc = (unsigned) -1;
config.split_by_file = (bfd_size_type) -1;
config.make_executable = TRUE;
config.magic_demand_paged = TRUE;
config.text_read_only = TRUE;
link_info.disable_target_specific_optimizations = -1;
command_line.warn_mismatch = TRUE;
command_line.warn_search_mismatch = TRUE;
command_line.check_section_addresses = -1;
/* We initialize DEMANGLING based on the environment variable
COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the
output of the linker, unless COLLECT_NO_DEMANGLE is set in the
environment. Acting the same way here lets us provide the same
interface by default. */
demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL;
link_info.allow_undefined_version = TRUE;
link_info.keep_memory = TRUE;
link_info.combreloc = TRUE;
link_info.strip_discarded = TRUE;
link_info.emit_hash = TRUE;
link_info.callbacks = &link_callbacks;
link_info.input_bfds_tail = &link_info.input_bfds;
/* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init
and _fini symbols. We are compatible. */
link_info.init_function = "_init";
link_info.fini_function = "_fini";
link_info.relax_pass = 1;
link_info.extern_protected_data = -1;
link_info.dynamic_undefined_weak = -1;
link_info.pei386_auto_import = -1;
link_info.spare_dynamic_tags = 5;
link_info.path_separator = ':';
#ifdef DEFAULT_FLAG_COMPRESS_DEBUG
link_info.compress_debug = COMPRESS_DEBUG_GABI_ZLIB;
#endif
ldfile_add_arch ("");
emulation = get_emulation (argc, argv);
ldemul_choose_mode (emulation);
default_target = ldemul_choose_target (argc, argv);
config.maxpagesize = bfd_emul_get_maxpagesize (default_target);
config.commonpagesize = bfd_emul_get_commonpagesize (default_target);
lang_init ();
ldexp_init ();
ldemul_before_parse ();
lang_has_input_file = FALSE;
parse_args (argc, argv);
if (config.hash_table_size != 0)
bfd_hash_set_default_size (config.hash_table_size);
#ifdef ENABLE_PLUGINS
/* Now all the plugin arguments have been gathered, we can load them. */
plugin_load_plugins ();
#endif /* ENABLE_PLUGINS */
ldemul_set_symbols ();
/* If we have not already opened and parsed a linker script,
try the default script from command line first. */
if (saved_script_handle == NULL
&& command_line.default_script != NULL)
{
ldfile_open_command_file (command_line.default_script);
parser_input = input_script;
yyparse ();
}
/* If we have not already opened and parsed a linker script
read the emulation's appropriate default script. */
if (saved_script_handle == NULL)
{
int isfile;
char *s = ldemul_get_script (&isfile);
if (isfile)
ldfile_open_default_command_file (s);
else
{
lex_string = s;
lex_redirect (s, _("built in linker script"), 1);
}
parser_input = input_script;
yyparse ();
lex_string = NULL;
}
if (verbose)
{
if (saved_script_handle)
info_msg (_("using external linker script:"));
else
info_msg (_("using internal linker script:"));
info_msg ("\n==================================================\n");
if (saved_script_handle)
{
static const int ld_bufsz = 8193;
size_t n;
char *buf = (char *) xmalloc (ld_bufsz);
rewind (saved_script_handle);
while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0)
{
buf[n] = 0;
info_msg (buf);
}
rewind (saved_script_handle);
free (buf);
}
else
{
int isfile;
info_msg (ldemul_get_script (&isfile));
}
info_msg ("\n==================================================\n");
}
if (command_line.print_output_format)
info_msg ("%s\n", lang_get_output_target ());
lang_final ();
/* If the only command line argument has been -v or --version or --verbose
then ignore any input files provided by linker scripts and exit now.
We do not want to create an output file when the linker is just invoked
to provide version information. */
if (argc == 2 && version_printed)
xexit (0);
if (!lang_has_input_file)
{
if (version_printed || command_line.print_output_format)
xexit (0);
einfo (_("%P%F: no input files\n"));
}
if (trace_files)
info_msg (_("%P: mode %s\n"), emulation);
ldemul_after_parse ();
if (config.map_filename)
{
if (strcmp (config.map_filename, "-") == 0)
{
config.map_file = stdout;
}
else
{
config.map_file = fopen (config.map_filename, FOPEN_WT);
if (config.map_file == (FILE *) NULL)
{
bfd_set_error (bfd_error_system_call);
einfo (_("%P%F: cannot open map file %s: %E\n"),
config.map_filename);
}
}
}
lang_process ();
/* Print error messages for any missing symbols, for any warning
symbols, and possibly multiple definitions. */
if (bfd_link_relocatable (&link_info))
link_info.output_bfd->flags &= ~EXEC_P;
else
link_info.output_bfd->flags |= EXEC_P;
if ((link_info.compress_debug & COMPRESS_DEBUG))
{
link_info.output_bfd->flags |= BFD_COMPRESS;
if (link_info.compress_debug == COMPRESS_DEBUG_GABI_ZLIB)
link_info.output_bfd->flags |= BFD_COMPRESS_GABI;
}
ldwrite ();
if (config.map_file != NULL)
lang_map ();
if (command_line.cref)
output_cref (config.map_file != NULL ? config.map_file : stdout);
if (nocrossref_list != NULL)
check_nocrossrefs ();
if (command_line.print_memory_usage)
lang_print_memory_usage ();
#if 0
{
struct bfd_link_hash_entry * h;
h = bfd_link_hash_lookup (link_info.hash, "__image_base__", 0,0,1);
fprintf (stderr, "lookup = %p val %lx\n", h, h ? h->u.def.value : 1);
}
#endif
ldexp_finish ();
lang_finish ();
/* Even if we're producing relocatable output, some non-fatal errors should
be reported in the exit status. (What non-fatal errors, if any, do we
want to ignore for relocatable output?) */
if (!config.make_executable && !force_make_executable)
{
if (trace_files)
einfo (_("%P: link errors found, deleting executable `%s'\n"),
output_filename);
/* The file will be removed by ld_cleanup. */
xexit (1);
}
else
{
if (! bfd_close (link_info.output_bfd))
einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd);
/* If the --force-exe-suffix is enabled, and we're making an
executable file and it doesn't end in .exe, copy it to one
which does. */
if (!bfd_link_relocatable (&link_info)
&& command_line.force_exe_suffix)
{
int len = strlen (output_filename);
if (len < 4
|| (strcasecmp (output_filename + len - 4, ".exe") != 0
&& strcasecmp (output_filename + len - 4, ".dll") != 0))
{
FILE *src;
FILE *dst;
const int bsize = 4096;
char *buf = (char *) xmalloc (bsize);
int l;
char *dst_name = (char *) xmalloc (len + 5);
strcpy (dst_name, output_filename);
strcat (dst_name, ".exe");
src = fopen (output_filename, FOPEN_RB);
dst = fopen (dst_name, FOPEN_WB);
if (!src)
einfo (_("%P%F: unable to open for source of copy `%s'\n"),
output_filename);
if (!dst)
einfo (_("%P%F: unable to open for destination of copy `%s'\n"),
dst_name);
while ((l = fread (buf, 1, bsize, src)) > 0)
{
int done = fwrite (buf, 1, l, dst);
if (done != l)
einfo (_("%P: Error writing file `%s'\n"), dst_name);
}
fclose (src);
if (fclose (dst) == EOF)
einfo (_("%P: Error closing file `%s'\n"), dst_name);
free (dst_name);
free (buf);
}
}
}
END_PROGRESS (program_name);
if (config.stats)
{
#ifdef HAVE_SBRK
char *lim = (char *) sbrk (0);
#endif
long run_time = get_run_time () - start_time;
fflush (stdout);
fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"),
program_name, run_time / 1000000, run_time % 1000000);
#ifdef HAVE_SBRK
fprintf (stderr, _("%s: data size %ld\n"), program_name,
(long) (lim - start_sbrk));
#endif
fflush (stderr);
}
/* Prevent ld_cleanup from doing anything, after a successful link. */
output_filename = NULL;
xexit (0);
return 0;
}
int
main (int argc, char **argv)
{
extern int chdir (char *);
char *srcdir = NULL;
int c;
FILE *table;
program_name = *argv;
xmalloc_set_program_name (program_name);
while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
switch (c)
{
case OPTION_SRCDIR:
srcdir = optarg;
break;
case 'V':
case 'v':
print_version ();
break;
case 'd':
debug = 1;
break;
case 'h':
case '?':
usage (stderr, 0);
default:
case 0:
break;
}
if (optind != argc)
usage (stdout, 1);
if (srcdir != NULL)
if (chdir (srcdir) != 0)
fail (_("unable to change directory to \"%s\", errno = %s\n"),
srcdir, xstrerror (errno));
/* Check the unused bitfield in i386_cpu_flags. */
#ifndef CpuUnused
c = CpuNumOfBits - CpuMax - 1;
if (c)
fail (_("%d unused bits in i386_cpu_flags.\n"), c);
#endif
/* Check the unused bitfield in i386_operand_type. */
#ifndef OTUnused
c = OTNumOfBits - OTMax - 1;
if (c)
fail (_("%d unused bits in i386_operand_type.\n"), c);
#endif
qsort (cpu_flags, ARRAY_SIZE (cpu_flags), sizeof (cpu_flags [0]),
compare);
qsort (opcode_modifiers, ARRAY_SIZE (opcode_modifiers),
sizeof (opcode_modifiers [0]), compare);
qsort (operand_types, ARRAY_SIZE (operand_types),
sizeof (operand_types [0]), compare);
table = fopen ("i386-tbl.h", "w");
if (table == NULL)
fail (_("can't create i386-tbl.h, errno = %s\n"),
xstrerror (errno));
process_copyright (table);
process_i386_opcodes (table);
process_i386_registers (table);
process_i386_initializers ();
fclose (table);
exit (0);
}
int
main (int argc, char **argv)
{
int o;
int save_trace;
bfd *prog;
int rc;
xmalloc_set_program_name (argv[0]);
while ((o = getopt (argc, argv, "tvdr:D:")) != -1)
{
switch (o)
{
case 't':
trace ++;
break;
case 'v':
verbose ++;
break;
case 'd':
disassemble ++;
break;
case 'r':
mem_ram_size (atoi (optarg));
break;
case 'D':
dump_counts_filename = optarg;
break;
case '?':
{
fprintf (stderr,
"usage: run [options] program [arguments]\n");
fprintf (stderr,
"\t-v\t\t- increase verbosity.\n"
"\t-t\t\t- trace.\n"
"\t-d\t\t- disassemble.\n"
"\t-r <bytes>\t- ram size.\n"
"\t-D <filename>\t- dump cycle count histogram\n");
exit (1);
}
}
}
prog = bfd_openr (argv[optind], 0);
if (!prog)
{
fprintf (stderr, "Can't read %s\n", argv[optind]);
exit (1);
}
if (!bfd_check_format (prog, bfd_object))
{
fprintf (stderr, "%s not a rl78 program\n", argv[optind]);
exit (1);
}
init_cpu ();
rl78_in_gdb = 0;
save_trace = trace;
trace = 0;
rl78_load (prog, 0, argv[0]);
trace = save_trace;
sim_disasm_init (prog);
rc = setjmp (decode_jmp_buf);
if (rc == 0)
{
if (!trace && !disassemble)
{
/* This will longjmp to the above if an exception
happens. */
for (;;)
decode_opcode ();
}
else
while (1)
{
if (trace)
printf ("\n");
if (disassemble)
sim_disasm_one ();
rc = decode_opcode ();
if (trace)
trace_register_changes ();
}
}
if (RL78_HIT_BREAK (rc))
done (1);
else if (RL78_EXITED (rc))
done (RL78_EXIT_STATUS (rc));
else if (RL78_STOPPED (rc))
{
if (verbose)
printf ("Stopped on signal %d\n", RL78_STOP_SIG (rc));
exit (1);
}
done (0);
exit (0);
}
int
main (int argc, char** argv)
{
JCF jcf[1];
int argi, opt;
const char *p;
p = argv[0] + strlen (argv[0]);
while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
--p;
progname = p;
xmalloc_set_program_name (progname);
/* Unlock the stdio streams. */
unlock_std_streams ();
gcc_init_libintl ();
diagnostic_initialize (global_dc, 0);
if (argc <= 1)
{
fprintf (stderr, _("jcf-dump: no classes specified\n"));
usage ();
}
jcf_path_init ();
/* We use getopt_long_only to allow single `-' long options. For
some of our options this is more natural. */
while ((opt = getopt_long_only (argc, argv, "o:I:vc", options, NULL)) != -1)
{
switch (opt)
{
case 0:
/* Already handled. */
break;
case 'o':
output_file = optarg;
break;
case 'I':
jcf_path_include_arg (optarg);
break;
case 'v':
verbose++;
break;
case 'c':
flag_disassemble_methods = 1;
break;
case OPT_classpath:
jcf_path_classpath_arg (optarg);
break;
case OPT_bootclasspath:
jcf_path_bootclasspath_arg (optarg);
break;
case OPT_extdirs:
jcf_path_extdirs_arg (optarg);
break;
case OPT_HELP:
help ();
break;
case OPT_VERSION:
version ();
break;
case OPT_JAVAP:
flag_javap_compatible++;
flag_print_constant_pool = 0;
flag_print_attributes = 0;
break;
default:
usage ();
}
}
if (verbose && ! flag_javap_compatible)
flag_print_constant_pool = 1;
if (optind == argc)
{
fprintf (stderr, _("jcf-dump: no classes specified\n"));
usage ();
}
jcf_path_seal (verbose);
if (flag_print_main)
{
flag_print_fields = 0;
flag_print_methods = 0;
flag_print_constant_pool = 0;
flag_print_attributes = 0;
flag_print_class_info = 0;
}
if (output_file)
{
out = fopen (output_file, "w");
if (! out)
{
fprintf (stderr, _("Cannot open '%s' for output.\n"), output_file);
return FATAL_EXIT_CODE;
}
}
else
out = stdout;
if (optind >= argc)
{
fprintf (out, "Reading .class from <standard input>.\n");
open_class ("<stdio>", jcf, 0, NULL);
process_class (jcf);
}
else
{
for (argi = optind; argi < argc; argi++)
{
char *arg = argv[argi];
const char *class_filename = find_class (arg, strlen (arg), jcf);
if (class_filename == NULL)
class_filename = find_classfile (arg, jcf, NULL);
if (class_filename == NULL)
{
perror ("Could not find class");
return FATAL_EXIT_CODE;
}
JCF_FILL (jcf, 4);
if (GET_u4 (jcf->read_ptr) == ZIPMAGIC)
{
long compressed_size, member_size;
int compression_method, filename_length, extra_length;
const char *filename;
int total_length;
if (flag_print_class_info)
fprintf (out, "Reading classes from archive %s.\n",
class_filename);
for (;;)
{
int skip = 0;
jcf_filbuf_t save_filbuf = jcf->filbuf;
long magic = JCF_readu4_le (jcf);
if (magic == 0x02014b50 || magic == 0x06054b50)
break; /* got to central directory */
if (magic != 0x04034b50) /* ZIPMAGIC (little-endian) */
{
fprintf (stderr, _("bad format of .zip/.jar archive\n"));
return FATAL_EXIT_CODE;
}
JCF_FILL (jcf, 26);
JCF_SKIP (jcf, 2);
(void) /* general_purpose_bits = */ JCF_readu2_le (jcf);
compression_method = JCF_readu2_le (jcf);
JCF_SKIP (jcf, 8);
compressed_size = JCF_readu4_le (jcf);
member_size = JCF_readu4_le (jcf);
filename_length = JCF_readu2_le (jcf);
extra_length = JCF_readu2_le (jcf);
total_length = filename_length + extra_length
+ compressed_size;
if (jcf->read_end - jcf->read_ptr < total_length)
jcf_trim_old_input (jcf);
JCF_FILL (jcf, total_length);
filename = (const char *) jcf->read_ptr;
JCF_SKIP (jcf, filename_length);
JCF_SKIP (jcf, extra_length);
if (filename_length > 0
&& filename[filename_length-1] == '/')
{
if (flag_print_class_info)
fprintf (out, "[Skipping directory %.*s]\n",
filename_length, filename);
skip = 1;
}
else if (compression_method != 0)
{
if (flag_print_class_info)
fprintf (out, "[Skipping compressed file %.*s]\n",
filename_length, filename);
skip = 1;
}
else if (member_size < 4
|| GET_u4 (jcf->read_ptr) != 0xcafebabe)
{
if (flag_print_class_info)
fprintf (out, "[Skipping non-.class member %.*s]\n",
filename_length, filename);
skip = 1;
}
else
{
if (flag_print_class_info)
fprintf (out, "Reading class member: %.*s.\n",
filename_length, filename);
}
if (skip)
{
JCF_SKIP (jcf, compressed_size);
}
else
{
unsigned char *save_end;
jcf->filbuf = jcf_unexpected_eof;
save_end = jcf->read_end;
jcf->read_end = jcf->read_ptr + compressed_size;
process_class (jcf);
jcf->filbuf = save_filbuf;
jcf->read_end = save_end;
}
}
}
else
{
if (flag_print_class_info)
fprintf (out, "Reading .class from %s.\n", class_filename);
process_class (jcf);
}
JCF_FINISH(jcf);
}
}
return SUCCESS_EXIT_CODE;
}
int
main(int ac, char **av)
{
bfd *abfd;
struct coff_ofile *tree;
char **matching;
char *input_file = NULL;
int opt;
static struct option long_options[] =
{
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'V' },
{ NULL, no_argument, 0, 0 }
};
#if defined(HAVE_SETLOCALE) && defined(HAVE_LC_MESSAGES)
setlocale(LC_MESSAGES, "");
#endif /* HAVE_SETLOCALE && HAVE_LC_MESSAGES */
#if defined(HAVE_SETLOCALE)
setlocale(LC_CTYPE, "");
#endif /* HAVE_SETLOCALE */
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
program_name = av[0];
xmalloc_set_program_name (program_name);
while ((opt = getopt_long(ac, av, "HhVv", long_options,
(int *)NULL)) != EOF)
{
switch (opt)
{
case 'H':
case 'h':
show_usage(stdout, 0);
break;
case 'v':
case 'V':
print_version("coffdump");
xexit(0);
case 0:
break;
default:
show_usage(stderr, 1);
break;
}
}
if (optind < ac)
{
input_file = av[optind];
}
if (!input_file)
fatal(_("no input file specified"));
abfd = bfd_openr(input_file, 0);
if (!abfd)
bfd_fatal(input_file);
if (! bfd_check_format_matches(abfd, bfd_object, &matching))
{
bfd_nonfatal(input_file);
if (bfd_get_error() == bfd_error_file_ambiguously_recognized)
{
list_matching_formats(matching);
free(matching);
}
xexit(1);
}
tree = coff_grok(abfd);
coff_dump(tree);
printf("\n");
return 0;
}
