| /* ldmisc.c |
| Copyright (C) 1991-2024 Free Software Foundation, Inc. |
| Written by Steve Chamberlain of Cygnus Support. |
| |
| This file is part of the GNU Binutils. |
| |
| This program 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 Software Foundation; either version 3 of the License, or |
| (at your option) any later version. |
| |
| This program 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 General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
| MA 02110-1301, USA. */ |
| |
| #include "sysdep.h" |
| #include "bfd.h" |
| #include "bfdlink.h" |
| #include "libiberty.h" |
| #include "ctf-api.h" |
| #include "safe-ctype.h" |
| #include "filenames.h" |
| #include "demangle.h" |
| #include <stdarg.h> |
| #include "ld.h" |
| #include "ldmisc.h" |
| #include "ldexp.h" |
| #include "ldlang.h" |
| #include <ldgram.h> |
| #include "ldlex.h" |
| #include "ldmain.h" |
| #include "ldfile.h" |
| |
| /* |
| %% literal % |
| %C clever filename:linenumber with function |
| %D like %C, but no function name |
| %E current bfd error or errno |
| %F error is fatal |
| %G like %D, but only function name |
| %H like %C but in addition emit section+offset |
| %P print program name |
| %V hex bfd_vma |
| %W hex bfd_vma with 0x with no leading zeros taking up 10 spaces |
| %X no object output, fail return |
| %d integer, like printf |
| %ld long, like printf |
| %lu unsigned long, like printf |
| %lx unsigned long, like printf |
| %p native (host) void* pointer, like printf |
| %pA section name from a section |
| %pB filename from a bfd |
| %pI filename from a lang_input_statement_type |
| %pR info about a relent |
| %pS print script file and linenumber from etree_type. |
| %pT symbol name |
| %pU print script file without linenumber from etree_type. |
| %s arbitrary string, like printf |
| %u integer, like printf |
| %v hex bfd_vma, no leading zeros |
| %x integer, like printf |
| */ |
| |
| void |
| vfinfo (FILE *fp, const char *fmt, va_list ap, bool is_warning) |
| { |
| bool fatal = false; |
| const char *scan; |
| int arg_type; |
| unsigned int arg_count = 0; |
| unsigned int arg_no; |
| union vfinfo_args |
| { |
| int i; |
| long l; |
| void *p; |
| bfd_vma v; |
| struct { |
| bfd *abfd; |
| asection *sec; |
| bfd_vma off; |
| } reladdr; |
| enum |
| { |
| Bad, |
| Int, |
| Long, |
| Ptr, |
| Vma, |
| RelAddr |
| } type; |
| } args[9]; |
| |
| if (is_warning && config.no_warnings) |
| return; |
| |
| for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++) |
| args[arg_no].type = Bad; |
| |
| arg_count = 0; |
| scan = fmt; |
| while (*scan != '\0') |
| { |
| while (*scan != '%' && *scan != '\0') |
| scan++; |
| |
| if (*scan == '%') |
| { |
| scan++; |
| |
| arg_no = arg_count; |
| if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$') |
| { |
| arg_no = *scan - '1'; |
| scan += 2; |
| } |
| |
| arg_type = Bad; |
| switch (*scan++) |
| { |
| case '\0': |
| --scan; |
| break; |
| |
| case 'V': |
| case 'v': |
| case 'W': |
| arg_type = Vma; |
| break; |
| |
| case 's': |
| arg_type = Ptr; |
| break; |
| |
| case 'p': |
| if (*scan == 'A' || *scan == 'B' || *scan == 'I' |
| || *scan == 'R' || *scan == 'S' || *scan == 'T') |
| scan++; |
| arg_type = Ptr; |
| break; |
| |
| case 'C': |
| case 'D': |
| case 'G': |
| case 'H': |
| arg_type = RelAddr; |
| break; |
| |
| case 'd': |
| case 'u': |
| case 'x': |
| arg_type = Int; |
| break; |
| |
| case 'l': |
| if (*scan == 'd' || *scan == 'u' || *scan == 'x') |
| { |
| ++scan; |
| arg_type = Long; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| if (arg_type != Bad) |
| { |
| if (arg_no >= sizeof (args) / sizeof (args[0])) |
| abort (); |
| args[arg_no].type = arg_type; |
| ++arg_count; |
| } |
| } |
| } |
| |
| for (arg_no = 0; arg_no < arg_count; arg_no++) |
| { |
| switch (args[arg_no].type) |
| { |
| case Int: |
| args[arg_no].i = va_arg (ap, int); |
| break; |
| case Long: |
| args[arg_no].l = va_arg (ap, long); |
| break; |
| case Ptr: |
| args[arg_no].p = va_arg (ap, void *); |
| break; |
| case Vma: |
| args[arg_no].v = va_arg (ap, bfd_vma); |
| break; |
| case RelAddr: |
| args[arg_no].reladdr.abfd = va_arg (ap, bfd *); |
| args[arg_no].reladdr.sec = va_arg (ap, asection *); |
| args[arg_no].reladdr.off = va_arg (ap, bfd_vma); |
| break; |
| default: |
| abort (); |
| } |
| } |
| |
| arg_count = 0; |
| while (*fmt != '\0') |
| { |
| const char *str = fmt; |
| while (*fmt != '%' && *fmt != '\0') |
| fmt++; |
| if (fmt != str) |
| if (fwrite (str, 1, fmt - str, fp)) |
| { |
| /* Ignore. */ |
| } |
| |
| if (*fmt == '%') |
| { |
| fmt++; |
| |
| arg_no = arg_count; |
| if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$') |
| { |
| arg_no = *fmt - '1'; |
| fmt += 2; |
| } |
| |
| switch (*fmt++) |
| { |
| case '\0': |
| --fmt; |
| /* Fall through. */ |
| |
| case '%': |
| /* literal % */ |
| putc ('%', fp); |
| break; |
| |
| case 'X': |
| /* no object output, fail return */ |
| config.make_executable = false; |
| break; |
| |
| case 'V': |
| /* hex bfd_vma */ |
| { |
| char buf[32]; |
| bfd_vma value; |
| |
| value = args[arg_no].v; |
| ++arg_count; |
| bfd_sprintf_vma (link_info.output_bfd, buf, value); |
| fprintf (fp, "%s", buf); |
| } |
| break; |
| |
| case 'v': |
| /* hex bfd_vma, no leading zeros */ |
| { |
| uint64_t value = args[arg_no].v; |
| ++arg_count; |
| fprintf (fp, "%" PRIx64, value); |
| } |
| break; |
| |
| case 'W': |
| /* hex bfd_vma with 0x with no leading zeroes taking up |
| 10 spaces (including the 0x). */ |
| { |
| char buf[32]; |
| uint64_t value; |
| |
| value = args[arg_no].v; |
| ++arg_count; |
| sprintf (buf, "0x%" PRIx64, value); |
| fprintf (fp, "%10s", buf); |
| } |
| break; |
| |
| case 'F': |
| /* Error is fatal. */ |
| fatal = true; |
| break; |
| |
| case 'P': |
| /* Print program name. */ |
| fprintf (fp, "%s", program_name); |
| break; |
| |
| case 'E': |
| /* current bfd error or errno */ |
| fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); |
| break; |
| |
| case 'C': |
| case 'D': |
| case 'G': |
| case 'H': |
| /* Clever filename:linenumber with function name if possible. |
| The arguments are a BFD, a section, and an offset. */ |
| { |
| static bfd *last_bfd; |
| static char *last_file; |
| static char *last_function; |
| bfd *abfd; |
| asection *section; |
| bfd_vma offset; |
| asymbol **asymbols = NULL; |
| const char *filename; |
| const char *functionname; |
| unsigned int linenumber; |
| bool discard_last; |
| bool done; |
| bfd_error_type last_bfd_error = bfd_get_error (); |
| |
| abfd = args[arg_no].reladdr.abfd; |
| section = args[arg_no].reladdr.sec; |
| offset = args[arg_no].reladdr.off; |
| ++arg_count; |
| |
| if (abfd != NULL) |
| { |
| if (!bfd_generic_link_read_symbols (abfd)) |
| einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd); |
| |
| asymbols = bfd_get_outsymbols (abfd); |
| } |
| |
| /* The GNU Coding Standard requires that error messages |
| be of the form: |
| |
| source-file-name:lineno: message |
| |
| We do not always have a line number available so if |
| we cannot find them we print out the section name and |
| offset instead. */ |
| discard_last = true; |
| if (abfd != NULL |
| && bfd_find_nearest_line (abfd, section, asymbols, offset, |
| &filename, &functionname, |
| &linenumber)) |
| { |
| if (functionname != NULL |
| && (fmt[-1] == 'C' || fmt[-1] == 'H')) |
| { |
| /* Detect the case where we are printing out a |
| message for the same function as the last |
| call to vinfo ("%C"). In this situation do |
| not print out the ABFD filename or the |
| function name again. Note - we do still |
| print out the source filename, as this will |
| allow programs that parse the linker's output |
| (eg emacs) to correctly locate multiple |
| errors in the same source file. */ |
| if (last_bfd == NULL |
| || last_function == NULL |
| || last_bfd != abfd |
| || (last_file == NULL) != (filename == NULL) |
| || (filename != NULL |
| && filename_cmp (last_file, filename) != 0) |
| || strcmp (last_function, functionname) != 0) |
| { |
| lfinfo (fp, _("%pB: in function `%pT':\n"), |
| abfd, functionname); |
| |
| last_bfd = abfd; |
| free (last_file); |
| last_file = NULL; |
| if (filename) |
| last_file = xstrdup (filename); |
| free (last_function); |
| last_function = xstrdup (functionname); |
| } |
| discard_last = false; |
| } |
| else |
| lfinfo (fp, "%pB:", abfd); |
| |
| if (filename != NULL) |
| fprintf (fp, "%s:", filename); |
| |
| done = fmt[-1] != 'H'; |
| if (functionname != NULL && fmt[-1] == 'G') |
| lfinfo (fp, "%pT", functionname); |
| else if (filename != NULL && linenumber != 0) |
| fprintf (fp, "%u%s", linenumber, done ? "" : ":"); |
| else |
| done = false; |
| } |
| else |
| { |
| lfinfo (fp, "%pB:", abfd); |
| done = false; |
| } |
| if (!done) |
| lfinfo (fp, "(%pA+0x%v)", section, offset); |
| bfd_set_error (last_bfd_error); |
| |
| if (discard_last) |
| { |
| last_bfd = NULL; |
| free (last_file); |
| last_file = NULL; |
| free (last_function); |
| last_function = NULL; |
| } |
| } |
| break; |
| |
| case 'p': |
| if (*fmt == 'A') |
| { |
| /* section name from a section */ |
| asection *sec; |
| bfd *abfd; |
| |
| fmt++; |
| sec = (asection *) args[arg_no].p; |
| ++arg_count; |
| fprintf (fp, "%s", sec->name); |
| abfd = sec->owner; |
| if (abfd != NULL) |
| { |
| const char *group = bfd_group_name (abfd, sec); |
| if (group != NULL) |
| fprintf (fp, "[%s]", group); |
| } |
| } |
| else if (*fmt == 'B') |
| { |
| /* filename from a bfd */ |
| bfd *abfd = (bfd *) args[arg_no].p; |
| |
| fmt++; |
| ++arg_count; |
| if (abfd == NULL) |
| fprintf (fp, "%s generated", program_name); |
| else if (abfd->my_archive != NULL |
| && !bfd_is_thin_archive (abfd->my_archive)) |
| fprintf (fp, "%s(%s)", |
| bfd_get_filename (abfd->my_archive), |
| bfd_get_filename (abfd)); |
| else |
| fprintf (fp, "%s", bfd_get_filename (abfd)); |
| } |
| else if (*fmt == 'I') |
| { |
| /* filename from a lang_input_statement_type */ |
| lang_input_statement_type *i; |
| |
| fmt++; |
| i = (lang_input_statement_type *) args[arg_no].p; |
| ++arg_count; |
| if (i->the_bfd != NULL |
| && i->the_bfd->my_archive != NULL |
| && !bfd_is_thin_archive (i->the_bfd->my_archive)) |
| fprintf (fp, "(%s)%s", |
| bfd_get_filename (i->the_bfd->my_archive), |
| i->local_sym_name); |
| else |
| fprintf (fp, "%s", i->filename); |
| } |
| else if (*fmt == 'R') |
| { |
| /* Print all that's interesting about a relent. */ |
| arelent *relent = (arelent *) args[arg_no].p; |
| |
| fmt++; |
| ++arg_count; |
| lfinfo (fp, "%s+0x%v (type %s)", |
| (*(relent->sym_ptr_ptr))->name, |
| relent->addend, |
| relent->howto->name); |
| } |
| else if (*fmt == 'S' || *fmt == 'U') |
| { |
| /* Print script file and perhaps the associated linenumber. */ |
| etree_type node; |
| etree_type *tp = (etree_type *) args[arg_no].p; |
| |
| fmt++; |
| ++arg_count; |
| if (tp == NULL) |
| { |
| tp = &node; |
| tp->type.filename = ldlex_filename (); |
| tp->type.lineno = lineno; |
| } |
| if (tp->type.filename != NULL && fmt[-1] == 'S') |
| fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); |
| else if (tp->type.filename != NULL && fmt[-1] == 'U') |
| fprintf (fp, "%s", tp->type.filename); |
| } |
| else if (*fmt == 'T') |
| { |
| /* Symbol name. */ |
| const char *name = (const char *) args[arg_no].p; |
| |
| fmt++; |
| ++arg_count; |
| if (name == NULL || *name == 0) |
| { |
| fprintf (fp, _("no symbol")); |
| break; |
| } |
| else if (demangling) |
| { |
| char *demangled; |
| |
| demangled = bfd_demangle (link_info.output_bfd, name, |
| DMGL_ANSI | DMGL_PARAMS); |
| if (demangled != NULL) |
| { |
| fprintf (fp, "%s", demangled); |
| free (demangled); |
| break; |
| } |
| } |
| fprintf (fp, "%s", name); |
| } |
| else |
| { |
| /* native (host) void* pointer, like printf */ |
| fprintf (fp, "%p", args[arg_no].p); |
| ++arg_count; |
| } |
| break; |
| |
| case 's': |
| /* arbitrary string, like printf */ |
| fprintf (fp, "%s", (char *) args[arg_no].p); |
| ++arg_count; |
| break; |
| |
| case 'd': |
| /* integer, like printf */ |
| fprintf (fp, "%d", args[arg_no].i); |
| ++arg_count; |
| break; |
| |
| case 'u': |
| /* unsigned integer, like printf */ |
| fprintf (fp, "%u", args[arg_no].i); |
| ++arg_count; |
| break; |
| |
| case 'x': |
| /* unsigned integer, like printf */ |
| fprintf (fp, "%x", args[arg_no].i); |
| ++arg_count; |
| break; |
| |
| case 'l': |
| if (*fmt == 'd') |
| { |
| fprintf (fp, "%ld", args[arg_no].l); |
| ++arg_count; |
| ++fmt; |
| break; |
| } |
| else if (*fmt == 'u') |
| { |
| fprintf (fp, "%lu", args[arg_no].l); |
| ++arg_count; |
| ++fmt; |
| break; |
| } |
| else if (*fmt == 'x') |
| { |
| fprintf (fp, "%lx", args[arg_no].l); |
| ++arg_count; |
| ++fmt; |
| break; |
| } |
| /* Fallthru */ |
| |
| default: |
| fprintf (fp, "%%%c", fmt[-1]); |
| break; |
| } |
| } |
| } |
| |
| if (is_warning && config.fatal_warnings) |
| config.make_executable = false; |
| |
| if (fatal) |
| xexit (1); |
| } |
| |
| /* Format info message and print on stdout. */ |
| |
| /* (You would think this should be called just "info", but then you |
| would be hosed by LynxOS, which defines that name in its libc.) */ |
| |
| void |
| info_msg (const char *fmt, ...) |
| { |
| va_list arg; |
| |
| va_start (arg, fmt); |
| vfinfo (stdout, fmt, arg, false); |
| va_end (arg); |
| } |
| |
| /* ('e' for error.) Format info message and print on stderr. */ |
| |
| void |
| einfo (const char *fmt, ...) |
| { |
| va_list arg; |
| |
| fflush (stdout); |
| va_start (arg, fmt); |
| vfinfo (stderr, fmt, arg, true); |
| va_end (arg); |
| fflush (stderr); |
| } |
| |
| /* The buffer size for each command-line option warning. */ |
| #define CMDLINE_WARNING_SIZE 256 |
| |
| /* A linked list of command-line option warnings. */ |
| |
| struct cmdline_warning_list |
| { |
| struct cmdline_warning_list *next; |
| char *warning; |
| }; |
| |
| /* The head of the linked list of command-line option warnings. */ |
| static struct cmdline_warning_list *cmdline_warning_head = NULL; |
| |
| /* The tail of the linked list of command-line option warnings. */ |
| static struct cmdline_warning_list **cmdline_warning_tail |
| = &cmdline_warning_head; |
| |
| /* Queue an unknown command-line option warning. */ |
| |
| void |
| queue_unknown_cmdline_warning (const char *fmt, ...) |
| { |
| va_list arg; |
| struct cmdline_warning_list *warning_ptr |
| = xmalloc (sizeof (*warning_ptr)); |
| warning_ptr->warning = xmalloc (CMDLINE_WARNING_SIZE); |
| warning_ptr->next = NULL; |
| int written; |
| |
| va_start (arg, fmt); |
| written = vsnprintf (warning_ptr->warning, CMDLINE_WARNING_SIZE, fmt, |
| arg); |
| if (written < 0 || written >= CMDLINE_WARNING_SIZE) |
| { |
| /* If vsnprintf fails or truncates, output the warning directly. */ |
| fflush (stdout); |
| va_start (arg, fmt); |
| vfinfo (stderr, fmt, arg, true); |
| fflush (stderr); |
| } |
| else |
| { |
| *cmdline_warning_tail = warning_ptr; |
| cmdline_warning_tail = &warning_ptr->next; |
| } |
| va_end (arg); |
| } |
| |
| /* Output queued unknown command-line option warnings. */ |
| |
| void |
| output_unknown_cmdline_warnings (void) |
| { |
| struct cmdline_warning_list *list = cmdline_warning_head; |
| struct cmdline_warning_list *next; |
| if (list == NULL) |
| return; |
| |
| fflush (stdout); |
| |
| for (; list != NULL; list = next) |
| { |
| next = list->next; |
| if (config.fatal_warnings) |
| einfo (_("%P: error: unsupported option: %s\n"), list->warning); |
| else |
| einfo (_("%P: warning: %s ignored\n"), list->warning); |
| free (list->warning); |
| free (list); |
| } |
| |
| fflush (stderr); |
| } |
| |
| void |
| info_assert (const char *file, unsigned int line) |
| { |
| einfo (_("%F%P: internal error %s %d\n"), file, line); |
| } |
| |
| /* ('m' for map) Format info message and print on map. */ |
| |
| void |
| minfo (const char *fmt, ...) |
| { |
| if (config.map_file != NULL) |
| { |
| va_list arg; |
| |
| va_start (arg, fmt); |
| if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0) |
| { |
| /* Stash info about --as-needed shared libraries. Print |
| later so they don't appear intermingled with archive |
| library info. */ |
| struct asneeded_minfo *m = xmalloc (sizeof *m); |
| |
| m->next = NULL; |
| m->soname = va_arg (arg, const char *); |
| m->ref = va_arg (arg, bfd *); |
| m->name = va_arg (arg, const char *); |
| *asneeded_list_tail = m; |
| asneeded_list_tail = &m->next; |
| } |
| else |
| vfinfo (config.map_file, fmt, arg, false); |
| va_end (arg); |
| } |
| } |
| |
| void |
| lfinfo (FILE *file, const char *fmt, ...) |
| { |
| va_list arg; |
| |
| va_start (arg, fmt); |
| vfinfo (file, fmt, arg, false); |
| va_end (arg); |
| } |
| |
| /* Functions to print the link map. */ |
| |
| void |
| print_spaces (int count) |
| { |
| fprintf (config.map_file, "%*s", count, ""); |
| } |
| |
| void |
| print_nl (void) |
| { |
| fprintf (config.map_file, "\n"); |
| } |
| |
| /* A more or less friendly abort message. In ld.h abort is defined to |
| call this function. */ |
| |
| void |
| ld_abort (const char *file, int line, const char *fn) |
| { |
| if (fn != NULL) |
| einfo (_("%P: internal error: aborting at %s:%d in %s\n"), |
| file, line, fn); |
| else |
| einfo (_("%P: internal error: aborting at %s:%d\n"), |
| file, line); |
| einfo (_("%F%P: please report this bug\n")); |
| xexit (1); |
| } |