musl does not provide GNU version of basename and lately have removed
the definiton from string.h [1] which exposes this problem. It can be
made to work by providing a local implementation of basename which
implements the GNU basename behavior, this makes it work across C
libraries which have POSIX implementation only.
[1] https://git.musl-libc.org/cgit/musl/commit/?id=
725e17ed6dff4d0cd22487bb64470881e86a92e7
* lib/system.h (xbasename): New static inline functions.
Poison basename.
* libdw/dwarf_getsrc_file.c (dwarf_getsrc_file): Use xbasename.
* libdwfl/core-file.c (dwfl_core_file_report): Likewise.
* libdwfl/dwfl_module_getsrc_file.c (dwfl_module_getsrc_file):
Likewise.
* libdwfl/dwfl_segment_report_module.c (dwfl_segment_report_module):
Likewise.
* libdwfl/find-debuginfo.c (find_debuginfo_in_path): Likewise.
* libdwfl/link_map.c (report_r_debug): Likewise.
* libdwfl/linux-kernel-modules.c (try_kernel_name): Likewise.
* src/addr2line.c (print_dwarf_function): Likewise.
(print_src): Likewise.
* src/ar.c (do_oper_insert): Likewise.
And cast away const in entry.key assignment.
* src/nm.c (show_symbols): Use xbasename.
* src/stack.c (module_callback): Likewise.
* src/strip.c (handle_elf): Likewise.
* tests/show-die-info.c: Include system.h.
(dwarf_tag_string): Use xbasename.
* tests/varlocs.c: Likewise.
* debuginfod/debuginfod.cxx: Move include system.h to the end.
(register_file_name): Rename basename to filename.
Signed-off-by: Khem Raj <raj.khem@gmail.com>
Signed-off-by: Mark Wielaard <mark@klomp.org>
}
#endif
-extern "C" {
-#include "printversion.h"
-#include "system.h"
-}
-
#include "debuginfod.h"
#include <dwarf.h>
#define tid() pthread_self()
#endif
+extern "C" {
+#include "printversion.h"
+#include "system.h"
+}
+
inline bool
string_endswith(const string& haystack, const string& needle)
const string& name)
{
std::size_t slash = name.rfind('/');
- string dirname, basename;
+ string dirname, filename;
if (slash == std::string::npos)
{
dirname = "";
- basename = name;
+ filename = name;
}
else
{
dirname = name.substr(0, slash);
- basename = name.substr(slash+1);
+ filename = name.substr(slash+1);
}
// intern the two substrings
.step_ok_done();
ps_upsert_fileparts
.reset()
- .bind(1, basename)
+ .bind(1, filename)
.step_ok_done();
// intern the tuple
ps_upsert_file
.reset()
.bind(1, dirname)
- .bind(2, basename)
+ .bind(2, filename)
.step_ok_done();
// look up the tuple's id
ps_lookup_file
.reset()
.bind(1, dirname)
- .bind(2, basename);
+ .bind(2, filename);
int rc = ps_lookup_file.step();
if (rc != SQLITE_ROW) throw sqlite_exception(rc, "step");
/* Declarations for common convenience functions.
Copyright (C) 2006-2011 Red Hat, Inc.
Copyright (C) 2022 Mark J. Wielaard <mark@klomp.org>
+ Copyright (C) 2023 Khem Raj.
This file is part of elfutils.
This file is free software; you can redistribute it and/or modify
extern int never_defined_just_used_for_checking[(expr) ? 1 : -1] \
__attribute__ ((unused))
+/* We really want a basename implementation that doesn't modify the
+ input argument. Normally you get that from string.h with _GNU_SOURCE
+ define. But some libc implementations don't define it and other
+ define it, but provide an implementation that still modifies the
+ argument. So define our own and poison a bare basename symbol. */
+static inline const char *
+xbasename(const char *s)
+{
+ const char *p = strrchr(s, '/');
+ return p ? p+1 : s;
+}
+#pragma GCC poison basename
+
#endif /* system.h */
/* Match the name with the name the user provided. */
const char *fname2 = line->files->info[lastfile].name;
if (is_basename)
- lastmatch = strcmp (basename (fname2), fname) == 0;
+ lastmatch = strcmp (xbasename (fname2), fname) == 0;
else
lastmatch = strcmp (fname2, fname) == 0;
}
if (! __libdwfl_dynamic_vaddr_get (module->elf, &file_dynamic_vaddr))
continue;
Dwfl_Module *mod;
- mod = __libdwfl_report_elf (dwfl, basename (module->name), module->name,
+ mod = __libdwfl_report_elf (dwfl, xbasename (module->name), module->name,
module->fd, module->elf,
module->l_ld - file_dynamic_vaddr,
true, true);
{
/* Match the name with the name the user provided. */
lastfile = file;
- lastmatch = !strcmp (is_basename ? basename (file) : file,
+ lastmatch = !strcmp (is_basename ? xbasename (file) : file,
fname);
}
}
bias += fixup;
if (module->name[0] != '\0')
{
- name = basename (module->name);
+ name = xbasename (module->name);
name_is_final = true;
}
break;
prevents premature closure of the correct ELF in cases
where segments of a module are non-contiguous in memory. */
if (name != NULL && module->name[0] != '\0'
- && strcmp (basename (module->name), basename (name)) == 0)
+ && strcmp (xbasename (module->name), xbasename (name)) == 0)
{
elf_end (module->elf);
close (module->fd);
{
bool cancheck = debuglink_crc != (GElf_Word) 0;
- const char *file_basename = file_name == NULL ? NULL : basename (file_name);
+ const char *file_basename = file_name == NULL ? NULL : xbasename (file_name);
char *localname = NULL;
/* We invent a debuglink .debug name if NULL, but then want to try the
else
{
subdir = NULL;
- file = basename (debuglink_file);
+ file = xbasename (debuglink_file);
}
try_file_basename = debuglink_null;
break;
if (mod->dw != NULL && (p[0] == '\0' || p[0] == '/'))
{
fd = try_open (&main_stat, dir, ".dwz",
- basename (file), &fname);
+ xbasename (file), &fname);
if (fd < 0)
{
if (errno != ENOENT && errno != ENOTDIR)
if (r_debug_info_module == NULL)
{
// XXX hook for sysroot
- mod = __libdwfl_report_elf (dwfl, basename (name),
+ mod = __libdwfl_report_elf (dwfl, xbasename (name),
name, fd, elf, base,
true, true);
if (mod != NULL)
/* Try the file's unadorned basename as DEBUGLINK_FILE,
to look only for "vmlinux" files. */
fd = INTUSE(dwfl_standard_find_debuginfo) (&fakemod, NULL, NULL, 0,
- *fname, basename (*fname),
+ *fname, xbasename (*fname),
0, &fakemod.debug.name);
if (fakemod.debug.name != NULL)
if (file == NULL)
file = "???";
else if (only_basenames)
- file = basename (file);
+ file = xbasename (file);
else if (use_comp_dir && file[0] != '/')
{
const char *const *dirs;
const char *comp_dir_sep = "";
if (only_basenames)
- src = basename (src);
+ src = xbasename (src);
else if (use_comp_dir && src[0] != '/')
{
Dwarf_Attribute attr;
for (int cnt = 0; cnt < argc; ++cnt)
{
ENTRY entry;
- entry.key = full_path ? argv[cnt] : basename (argv[cnt]);
+ entry.key = full_path ? argv[cnt] : (char*)xbasename (argv[cnt]);
entry.data = &argv[cnt];
if (hsearch (entry, ENTER) == NULL)
error_exit (errno, _("cannot insert into hash table"));
/* Open all the new files, get their sizes and add all symbols. */
for (int cnt = 0; cnt < argc; ++cnt)
{
- const char *bname = basename (argv[cnt]);
+ const char *bname = xbasename (argv[cnt]);
size_t bnamelen = strlen (bname);
if (found[cnt] == NULL)
{
int lineno;
(void) dwarf_lineno (line, &lineno);
const char *file = dwarf_linesrc (line, NULL, NULL);
- file = (file != NULL) ? basename (file) : "???";
+ file = (file != NULL) ? xbasename (file) : "???";
int n;
n = obstack_printf (&whereob, "%s:%d%c", file,
lineno, '\0');
{
/* We found the line. */
int n = obstack_printf (&whereob, "%s:%" PRIu64 "%c",
- basename ((*found)->file),
+ xbasename ((*found)->file),
(*found)->lineno,
'\0');
sym_mem[nentries_used].where = obstack_finish (&whereob);
int width = get_addr_width (mod);
printf ("0x%0*" PRIx64 "-0x%0*" PRIx64 " %s\n",
- width, start, width, end, basename (name));
+ width, start, width, end, xbasename (name));
const unsigned char *id;
GElf_Addr id_vaddr;
elf_errmsg (-1));
}
- char *debug_basename = basename (debug_fname_embed ?: debug_fname);
+ const char *debug_basename = xbasename (debug_fname_embed ?: debug_fname);
off_t crc_offset = strlen (debug_basename) + 1;
/* Align to 4 byte boundary */
crc_offset = ((crc_offset - 1) & ~3) + 4;
#include <unistd.h>
#include "../libdw/known-dwarf.h"
+#include "../lib/system.h"
static const char *
dwarf_tag_string (unsigned int tag)
int fd = open (argv[cnt], O_RDONLY);
Dwarf *dbg;
- printf ("file: %s\n", basename (argv[cnt]));
+ printf ("file: %s\n", xbasename (argv[cnt]));
dbg = dwarf_begin (fd, DWARF_C_READ);
if (dbg == NULL)
const char *name = (modname[0] != '\0'
? modname
- : basename (mainfile));
+ : xbasename (mainfile));
printf ("module '%s'\n", name);
print_die (&cudie, "CU", 0);