src/findtextrel.c - platform/external/elfutils.git - Git at Google

 /* Locate source files or functions which caused text relocations.
    Copyright (C) 2005-2010, 2012, 2014, 2018 Red Hat, Inc.
    This file is part of elfutils.
    Written by Ulrich Drepper <drepper@redhat.com>, 2005.

    This file 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.

    elfutils 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, see <http://www.gnu.org/licenses/>.  */

 #ifdef HAVE_CONFIG_H
 # include <config.h>
 #endif

 #include <argp.h>
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <gelf.h>
 #include <libdw.h>
 #include <libintl.h>
 #include <locale.h>
 #include <search.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>

 #include <printversion.h>
 #include "system.h"

 struct segments
 {
   GElf_Addr from;
   GElf_Addr to;
 };


 /* Name and version of program.  */
 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;

 /* Bug report address.  */
 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;

 /* Values for the parameters which have no short form.  */
 #define OPT_DEBUGINFO 0x100

 /* Definitions of arguments for argp functions.  */
 static const struct argp_option options[] =
 {
   { NULL, 0, NULL, 0, N_("Input Selection:"), 0 },
   { "root", 'r', "PATH", 0, N_("Prepend PATH to all file names"), 0 },
   { "debuginfo", OPT_DEBUGINFO, "PATH", 0,
     N_("Use PATH as root of debuginfo hierarchy"), 0 },

   { NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 },
   { NULL, 0, NULL, 0, NULL, 0 }
 };

 /* Short description of program.  */
 static const char doc[] = N_("\
 Locate source of text relocations in FILEs (a.out by default).");

 /* Strings for arguments in help texts.  */
 static const char args_doc[] = N_("[FILE...]");

 /* Prototype for option handler.  */
 static error_t parse_opt (int key, char *arg, struct argp_state *state);

 /* Data structure to communicate with argp functions.  */
 static struct argp argp =
 {
   options, parse_opt, args_doc, doc, NULL, NULL, NULL
 };


 /* Print symbols in file named FNAME.  */
 static int process_file (const char *fname, bool more_than_one);

 /* Check for text relocations in the given file.  The segment
    information is known.  */
 static void check_rel (size_t nsegments, struct segments segments[nsegments],
 		       GElf_Addr addr, Elf *elf, Elf_Scn *symscn, Dwarf *dw,
 		       const char *fname, bool more_than_one,
 		       void **knownsrcs);


 /* User-provided root directory.  */
 static const char *rootdir = "/";

 /* Root of debuginfo directory hierarchy.  */
 static const char *debuginfo_root;


 int
 main (int argc, char *argv[])
 {
   int remaining;
   int result = 0;

   /* Set locale.  */
   (void) setlocale (LC_ALL, "");

   /* Make sure the message catalog can be found.  */
   (void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);

   /* Initialize the message catalog.  */
   (void) textdomain (PACKAGE_TARNAME);

   /* Parse and process arguments.  */
   (void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);

   /* Tell the library which version we are expecting.  */
   elf_version (EV_CURRENT);

   /* If the user has not specified the root directory for the
      debuginfo hierarchy, we have to determine it ourselves.  */
   if (debuginfo_root == NULL)
     {
       // XXX The runtime should provide this information.
 #if defined __ia64__ || defined __alpha__
       debuginfo_root = "/usr/lib/debug";
 #else
       debuginfo_root = (sizeof (long int) == 4
 			? "/usr/lib/debug" : "/usr/lib64/debug");
 #endif
     }

   if (remaining == argc)
     result = process_file ("a.out", false);
   else
     {
       /* Process all the remaining files.  */
       const bool more_than_one = remaining + 1 < argc;

       do
 	result |= process_file (argv[remaining], more_than_one);
       while (++remaining < argc);
     }

   return result;
 }


 /* Handle program arguments.  */
 static error_t
 parse_opt (int key, char *arg,
 	   struct argp_state *state __attribute__ ((unused)))
 {
   switch (key)
     {
     case 'r':
       rootdir = arg;
       break;

     case OPT_DEBUGINFO:
       debuginfo_root = arg;
       break;

     default:
       return ARGP_ERR_UNKNOWN;
     }
   return 0;
 }


 static void
 noop (void *arg __attribute__ ((unused)))
 {
 }


 static int
 process_file (const char *fname, bool more_than_one)
 {
   int result = 0;
   void *knownsrcs = NULL;

   size_t fname_len = strlen (fname);
   size_t rootdir_len = strlen (rootdir);
   const char *real_fname = fname;
   if (fname[0] == '/' && (rootdir[0] != '/' || rootdir[1] != '\0'))
     {
       /* Prepend the user-provided root directory.  */
       char *new_fname = alloca (rootdir_len + fname_len + 2);
       *((char *) mempcpy (stpcpy (mempcpy (new_fname, rootdir, rootdir_len),
 				  "/"),
 			  fname, fname_len)) = '\0';
       real_fname = new_fname;
     }

   int fd = open (real_fname, O_RDONLY);
   if (fd == -1)
     {
       error (0, errno, gettext ("cannot open '%s'"), fname);
       return 1;
     }

   Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
   if (elf == NULL)
     {
       error (0, 0, gettext ("cannot create ELF descriptor for '%s': %s"),
 	     fname, elf_errmsg (-1));
       goto err_close;
     }

   /* Make sure the file is a DSO.  */
   GElf_Ehdr ehdr_mem;
   GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
   if (ehdr == NULL)
     {
       error (0, 0, gettext ("cannot get ELF header '%s': %s"),
 	     fname, elf_errmsg (-1));
     err_elf_close:
       elf_end (elf);
     err_close:
       close (fd);
       return 1;
     }

   if (ehdr->e_type != ET_DYN)
     {
       error (0, 0, gettext ("'%s' is not a DSO or PIE"), fname);
       goto err_elf_close;
     }

   /* Determine whether the DSO has text relocations at all and locate
      the symbol table.  */
   Elf_Scn *symscn = NULL;
   Elf_Scn *scn = NULL;
   bool seen_dynamic = false;
   bool have_textrel = false;
   while ((scn = elf_nextscn (elf, scn)) != NULL
 	 && (!seen_dynamic || symscn == NULL))
     {
       /* Handle the section if it is a symbol table.  */
       GElf_Shdr shdr_mem;
       GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

       if (shdr == NULL)
 	{
 	  error (0, 0,
 		 gettext ("getting get section header of section %zu: %s"),
 		 elf_ndxscn (scn), elf_errmsg (-1));
 	  goto err_elf_close;
 	}

       switch (shdr->sh_type)
 	{
 	case SHT_DYNAMIC:
 	  if (!seen_dynamic)
 	    {
 	      seen_dynamic = true;

 	      Elf_Data *data = elf_getdata (scn, NULL);
 	      size_t entries = (shdr->sh_entsize == 0
 				? 0 : shdr->sh_size / shdr->sh_entsize);

 	      for (size_t cnt = 0; cnt < entries; ++cnt)
 		{
 		  GElf_Dyn dynmem;
 		  GElf_Dyn *dyn;

 		  dyn = gelf_getdyn (data, cnt, &dynmem);
 		  if (dyn == NULL)
 		    {
 		      error (0, 0, gettext ("cannot read dynamic section: %s"),
 			     elf_errmsg (-1));
 		      goto err_elf_close;
 		    }

 		  if (dyn->d_tag == DT_TEXTREL
 		      || (dyn->d_tag == DT_FLAGS
 			  && (dyn->d_un.d_val & DF_TEXTREL) != 0))
 		    have_textrel = true;
 		}
 	    }
 	  break;

 	case SHT_SYMTAB:
 	  symscn = scn;
 	  break;
 	}
     }

   if (!have_textrel)
     {
       error (0, 0, gettext ("no text relocations reported in '%s'"), fname);
       goto err_elf_close;
     }

   int fd2 = -1;
   Elf *elf2 = NULL;
   /* Get the address ranges for the loaded segments.  */
   size_t nsegments_max = 10;
   size_t nsegments = 0;
   struct segments *segments
     = (struct segments *) malloc (nsegments_max * sizeof (segments[0]));
   if (segments == NULL)
     error (1, errno, gettext ("while reading ELF file"));

   size_t phnum;
   if (elf_getphdrnum (elf, &phnum) != 0)
     error (1, 0, gettext ("cannot get program header count: %s"),
            elf_errmsg (-1));


   for (size_t i = 0; i < phnum; ++i)
     {
       GElf_Phdr phdr_mem;
       GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
       if (phdr == NULL)
 	{
 	  error (0, 0,
 		 gettext ("cannot get program header index at offset %zd: %s"),
 		 i, elf_errmsg (-1));
 	  result = 1;
 	  goto next;
 	}

       if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_W) == 0)
 	{
 	  if (nsegments == nsegments_max)
 	    {
 	      nsegments_max *= 2;
 	      segments
 		= (struct segments *) realloc (segments,
 					       nsegments_max
 					       * sizeof (segments[0]));
 	      if (segments == NULL)
 		{
 		  error (0, 0, gettext ("\
 cannot get program header index at offset %zd: %s"),
 			 i, elf_errmsg (-1));
 		  result = 1;
 		  goto next;
 		}
 	    }

 	  segments[nsegments].from = phdr->p_vaddr;
 	  segments[nsegments].to = phdr->p_vaddr + phdr->p_memsz;
 	  ++nsegments;
 	}
     }

   if (nsegments > 0)
     {

       Dwarf *dw = dwarf_begin_elf (elf, DWARF_C_READ, NULL);
       /* Look for debuginfo files if the information is not the in
 	 opened file itself.  This makes only sense if the input file
 	 is specified with an absolute path.  */
       if (dw == NULL && fname[0] == '/')
 	{
 	  size_t debuginfo_rootlen = strlen (debuginfo_root);
 	  char *difname = (char *) alloca (rootdir_len + debuginfo_rootlen
 					   + fname_len + 8);
 	  strcpy (mempcpy (stpcpy (mempcpy (mempcpy (difname, rootdir,
 						     rootdir_len),
 					    debuginfo_root,
 					    debuginfo_rootlen),
 				   "/"),
 			   fname, fname_len),
 		  ".debug");

 	  fd2 = open (difname, O_RDONLY);
 	  if (fd2 != -1
 	      && (elf2 = elf_begin (fd2, ELF_C_READ_MMAP, NULL)) != NULL)
 	    dw = dwarf_begin_elf (elf2, DWARF_C_READ, NULL);
 	}

       /* Look at all relocations and determine which modify
 	 write-protected segments.  */
       scn = NULL;
       while ((scn = elf_nextscn (elf, scn)) != NULL)
 	{
 	  /* Handle the section if it is a symbol table.  */
 	  GElf_Shdr shdr_mem;
 	  GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

 	  if (shdr == NULL)
 	    {
 	      error (0, 0,
 		     gettext ("cannot get section header of section %zu: %s"),
 		     elf_ndxscn (scn), elf_errmsg (-1));
 	      result = 1;
 	      goto next;
 	    }

 	  if ((shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
 	      && symscn == NULL)
 	    {
 	      symscn = elf_getscn (elf, shdr->sh_link);
 	      if (symscn == NULL)
 		{
 		  error (0, 0, gettext ("\
 cannot get symbol table section %zu in '%s': %s"),
 			 (size_t) shdr->sh_link, fname, elf_errmsg (-1));
 		  result = 1;
 		  goto next;
 		}
 	    }

 	  if (shdr->sh_type == SHT_REL)
 	    {
 	      Elf_Data *data = elf_getdata (scn, NULL);
 	      size_t entries = (shdr->sh_entsize == 0
 				? 0 : shdr->sh_size / shdr->sh_entsize);

 	      for (int cnt = 0;
 		   (size_t) cnt < entries; ++cnt)
 		{
 		  GElf_Rel rel_mem;
 		  GElf_Rel *rel = gelf_getrel (data, cnt, &rel_mem);
 		  if (rel == NULL)
 		    {
 		      error (0, 0, gettext ("\
 cannot get relocation at index %d in section %zu in '%s': %s"),
 			     cnt, elf_ndxscn (scn), fname, elf_errmsg (-1));
 		      result = 1;
 		      goto next;
 		    }

 		  check_rel (nsegments, segments, rel->r_offset, elf,
 			     symscn, dw, fname, more_than_one, &knownsrcs);
 		}
 	    }
 	  else if (shdr->sh_type == SHT_RELA)
 	    {
 	      Elf_Data *data = elf_getdata (scn, NULL);
 	      size_t entries = (shdr->sh_entsize == 0
 				? 0 : shdr->sh_size / shdr->sh_entsize);

 	      for (int cnt = 0; (size_t) cnt < entries; ++cnt)
 		{
 		  GElf_Rela rela_mem;
 		  GElf_Rela *rela = gelf_getrela (data, cnt, &rela_mem);
 		  if (rela == NULL)
 		    {
 		      error (0, 0, gettext ("\
 cannot get relocation at index %d in section %zu in '%s': %s"),
 			     cnt, elf_ndxscn (scn), fname, elf_errmsg (-1));
 		      result = 1;
 		      goto next;
 		    }

 		  check_rel (nsegments, segments, rela->r_offset, elf,
 			     symscn, dw, fname, more_than_one, &knownsrcs);
 		}
 	    }
 	}

       dwarf_end (dw);
     }

  next:
   elf_end (elf);
   elf_end (elf2);
   close (fd);
   if (fd2 != -1)
     close (fd2);

   free (segments);
   tdestroy (knownsrcs, noop);

   return result;
 }


 static int
 ptrcompare (const void *p1, const void *p2)
 {
   if ((uintptr_t) p1 < (uintptr_t) p2)
     return -1;
   if ((uintptr_t) p1 > (uintptr_t) p2)
     return 1;
   return 0;
 }


 static void
 check_rel (size_t nsegments, struct segments segments[nsegments],
 	   GElf_Addr addr, Elf *elf, Elf_Scn *symscn, Dwarf *dw,
 	   const char *fname, bool more_than_one, void **knownsrcs)
 {
   for (size_t cnt = 0; cnt < nsegments; ++cnt)
     if (segments[cnt].from <= addr && segments[cnt].to > addr)
       {
 	Dwarf_Die die_mem;
 	Dwarf_Die *die;
 	Dwarf_Line *line;
 	const char *src;

 	if (more_than_one)
 	  printf ("%s: ", fname);

 	if ((die = dwarf_addrdie (dw, addr, &die_mem)) != NULL
 	    && (line = dwarf_getsrc_die (die, addr)) != NULL
 	    && (src = dwarf_linesrc (line, NULL, NULL)) != NULL)
 	  {
 	    /* There can be more than one relocation against one file.
 	       Try to avoid multiple messages.  And yes, the code uses
 	       pointer comparison.  */
 	    if (tfind (src, knownsrcs, ptrcompare) == NULL)
 	      {
 		printf (gettext ("%s not compiled with -fpic/-fPIC\n"), src);
 		tsearch (src, knownsrcs, ptrcompare);
 	      }
 	    return;
 	  }
 	else
 	  {
 	    /* At least look at the symbol table to see which function
 	       the modified address is in.  */
 	    Elf_Data *symdata = elf_getdata (symscn, NULL);
 	    GElf_Shdr shdr_mem;
 	    GElf_Shdr *shdr = gelf_getshdr (symscn, &shdr_mem);
 	    if (shdr != NULL)
 	      {
 		GElf_Addr lowaddr = 0;
 		int lowidx = -1;
 		GElf_Addr highaddr = ~0ul;
 		int highidx = -1;
 		GElf_Sym sym_mem;
 		GElf_Sym *sym;
 		size_t entries = (shdr->sh_entsize == 0
 				  ? 0 : shdr->sh_size / shdr->sh_entsize);

 		for (int i = 0; (size_t) i < entries; ++i)
 		  {
 		    sym = gelf_getsym (symdata, i, &sym_mem);
 		    if (sym == NULL)
 		      continue;

 		    if (sym->st_value < addr && sym->st_value > lowaddr)
 		      {
 			lowaddr = sym->st_value;
 			lowidx = i;
 		      }
 		    if (sym->st_value > addr && sym->st_value < highaddr)
 		      {
 			highaddr = sym->st_value;
 			highidx = i;
 		      }
 		  }

 		if (lowidx != -1)
 		  {
 		    sym = gelf_getsym (symdata, lowidx, &sym_mem);
 		    assert (sym != NULL);

 		    const char *lowstr = elf_strptr (elf, shdr->sh_link,
 						     sym->st_name);

 		    if (sym->st_value + sym->st_size > addr)
 		      {
 			/* It is this function.  */
 			if (tfind (lowstr, knownsrcs, ptrcompare) == NULL)
 			  {
 			    printf (gettext ("\
 the file containing the function '%s' is not compiled with -fpic/-fPIC\n"),
 				    lowstr);
 			    tsearch (lowstr, knownsrcs, ptrcompare);
 			  }
 		      }
 		    else if (highidx == -1)
 		      printf (gettext ("\
 the file containing the function '%s' might not be compiled with -fpic/-fPIC\n"),
 			      lowstr);
 		    else
 		      {
 			sym = gelf_getsym (symdata, highidx, &sym_mem);
 			assert (sym != NULL);

 			printf (gettext ("\
 either the file containing the function '%s' or the file containing the function '%s' is not compiled with -fpic/-fPIC\n"),
 				lowstr, elf_strptr (elf, shdr->sh_link,
 						    sym->st_name));
 		      }
 		    return;
 		  }
 		else if (highidx != -1)
 		  {
 		    sym = gelf_getsym (symdata, highidx, &sym_mem);
 		    assert (sym != NULL);

 		    printf (gettext ("\
 the file containing the function '%s' might not be compiled with -fpic/-fPIC\n"),
 			    elf_strptr (elf, shdr->sh_link, sym->st_name));
 		    return;
 		  }
 	      }
 	  }

 	printf (gettext ("\
 a relocation modifies memory at offset %llu in a write-protected segment\n"),
 		(unsigned long long int) addr);
 	break;
       }
 }


 #include "debugpred.h"
	/* Locate source files or functions which caused text relocations.
	Copyright (C) 2005-2010, 2012, 2014, 2018 Red Hat, Inc.
	This file is part of elfutils.
	Written by Ulrich Drepper <drepper@redhat.com>, 2005.

	This file 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.

	elfutils 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, see <http://www.gnu.org/licenses/>. */

	#ifdef HAVE_CONFIG_H
	# include <config.h>
	#endif

	#include <argp.h>
	#include <assert.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <gelf.h>
	#include <libdw.h>
	#include <libintl.h>
	#include <locale.h>
	#include <search.h>
	#include <stdbool.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>

	#include <printversion.h>
	#include "system.h"

	struct segments
	{
	GElf_Addr from;
	GElf_Addr to;
	};


	/* Name and version of program. */
	ARGP_PROGRAM_VERSION_HOOK_DEF = print_version;

	/* Bug report address. */
	ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT;

	/* Values for the parameters which have no short form. */
	#define OPT_DEBUGINFO 0x100

	/* Definitions of arguments for argp functions. */
	static const struct argp_option options[] =
	{
	{ NULL, 0, NULL, 0, N_("Input Selection:"), 0 },
	{ "root", 'r', "PATH", 0, N_("Prepend PATH to all file names"), 0 },
	{ "debuginfo", OPT_DEBUGINFO, "PATH", 0,
	N_("Use PATH as root of debuginfo hierarchy"), 0 },

	{ NULL, 0, NULL, 0, N_("Miscellaneous:"), 0 },
	{ NULL, 0, NULL, 0, NULL, 0 }
	};

	/* Short description of program. */
	static const char doc[] = N_("\
	Locate source of text relocations in FILEs (a.out by default).");

	/* Strings for arguments in help texts. */
	static const char args_doc[] = N_("[FILE...]");

	/* Prototype for option handler. */
	static error_t parse_opt (int key, char arg, struct argp_state state);

	/* Data structure to communicate with argp functions. */
	static struct argp argp =
	{
	options, parse_opt, args_doc, doc, NULL, NULL, NULL
	};


	/* Print symbols in file named FNAME. */
	static int process_file (const char *fname, bool more_than_one);

	/* Check for text relocations in the given file. The segment
	information is known. */
	static void check_rel (size_t nsegments, struct segments segments[nsegments],
	GElf_Addr addr, Elf elf, Elf_Scn symscn, Dwarf *dw,
	const char *fname, bool more_than_one,
	void **knownsrcs);



	/* User-provided root directory. */
	static const char *rootdir = "/";

	/* Root of debuginfo directory hierarchy. */
	static const char *debuginfo_root;


	int
	main (int argc, char *argv[])
	{
	int remaining;
	int result = 0;

	/* Set locale. */
	(void) setlocale (LC_ALL, "");

	/* Make sure the message catalog can be found. */
	(void) bindtextdomain (PACKAGE_TARNAME, LOCALEDIR);

	/* Initialize the message catalog. */
	(void) textdomain (PACKAGE_TARNAME);

	/* Parse and process arguments. */
	(void) argp_parse (&argp, argc, argv, 0, &remaining, NULL);

	/* Tell the library which version we are expecting. */
	elf_version (EV_CURRENT);

	/* If the user has not specified the root directory for the
	debuginfo hierarchy, we have to determine it ourselves. */
	if (debuginfo_root == NULL)
	{
	// XXX The runtime should provide this information.
	#if defined __ia64__ \|\| defined __alpha__
	debuginfo_root = "/usr/lib/debug";
	#else
	debuginfo_root = (sizeof (long int) == 4
	? "/usr/lib/debug" : "/usr/lib64/debug");
	#endif
	}

	if (remaining == argc)
	result = process_file ("a.out", false);
	else
	{
	/* Process all the remaining files. */
	const bool more_than_one = remaining + 1 < argc;

	do
	result \|= process_file (argv[remaining], more_than_one);
	while (++remaining < argc);
	}

	return result;
	}


	/* Handle program arguments. */
	static error_t
	parse_opt (int key, char *arg,
	struct argp_state *state __attribute__ ((unused)))
	{
	switch (key)
	{
	case 'r':
	rootdir = arg;
	break;

	case OPT_DEBUGINFO:
	debuginfo_root = arg;
	break;

	default:
	return ARGP_ERR_UNKNOWN;
	}
	return 0;
	}


	static void
	noop (void *arg __attribute__ ((unused)))
	{
	}


	static int
	process_file (const char *fname, bool more_than_one)
	{
	int result = 0;
	void *knownsrcs = NULL;

	size_t fname_len = strlen (fname);
	size_t rootdir_len = strlen (rootdir);
	const char *real_fname = fname;
	if (fname[0] == '/' && (rootdir[0] != '/' \|\| rootdir[1] != '\0'))
	{
	/* Prepend the user-provided root directory. */
	char *new_fname = alloca (rootdir_len + fname_len + 2);
	((char ) mempcpy (stpcpy (mempcpy (new_fname, rootdir, rootdir_len),
	"/"),
	fname, fname_len)) = '\0';
	real_fname = new_fname;
	}

	int fd = open (real_fname, O_RDONLY);
	if (fd == -1)
	{
	error (0, errno, gettext ("cannot open '%s'"), fname);
	return 1;
	}

	Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
	if (elf == NULL)
	{
	error (0, 0, gettext ("cannot create ELF descriptor for '%s': %s"),
	fname, elf_errmsg (-1));
	goto err_close;
	}

	/* Make sure the file is a DSO. */
	GElf_Ehdr ehdr_mem;
	GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
	if (ehdr == NULL)
	{
	error (0, 0, gettext ("cannot get ELF header '%s': %s"),
	fname, elf_errmsg (-1));
	err_elf_close:
	elf_end (elf);
	err_close:
	close (fd);
	return 1;
	}

	if (ehdr->e_type != ET_DYN)
	{
	error (0, 0, gettext ("'%s' is not a DSO or PIE"), fname);
	goto err_elf_close;
	}

	/* Determine whether the DSO has text relocations at all and locate
	the symbol table. */
	Elf_Scn *symscn = NULL;
	Elf_Scn *scn = NULL;
	bool seen_dynamic = false;
	bool have_textrel = false;
	while ((scn = elf_nextscn (elf, scn)) != NULL
	&& (!seen_dynamic \|\| symscn == NULL))
	{
	/* Handle the section if it is a symbol table. */
	GElf_Shdr shdr_mem;
	GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

	if (shdr == NULL)
	{
	error (0, 0,
	gettext ("getting get section header of section %zu: %s"),
	elf_ndxscn (scn), elf_errmsg (-1));
	goto err_elf_close;
	}

	switch (shdr->sh_type)
	{
	case SHT_DYNAMIC:
	if (!seen_dynamic)
	{
	seen_dynamic = true;

	Elf_Data *data = elf_getdata (scn, NULL);
	size_t entries = (shdr->sh_entsize == 0
	? 0 : shdr->sh_size / shdr->sh_entsize);

	for (size_t cnt = 0; cnt < entries; ++cnt)
	{
	GElf_Dyn dynmem;
	GElf_Dyn *dyn;

	dyn = gelf_getdyn (data, cnt, &dynmem);
	if (dyn == NULL)
	{
	error (0, 0, gettext ("cannot read dynamic section: %s"),
	elf_errmsg (-1));
	goto err_elf_close;
	}

	if (dyn->d_tag == DT_TEXTREL
	\|\| (dyn->d_tag == DT_FLAGS
	&& (dyn->d_un.d_val & DF_TEXTREL) != 0))
	have_textrel = true;
	}
	}
	break;

	case SHT_SYMTAB:
	symscn = scn;
	break;
	}
	}

	if (!have_textrel)
	{
	error (0, 0, gettext ("no text relocations reported in '%s'"), fname);
	goto err_elf_close;
	}

	int fd2 = -1;
	Elf *elf2 = NULL;
	/* Get the address ranges for the loaded segments. */
	size_t nsegments_max = 10;
	size_t nsegments = 0;
	struct segments *segments
	= (struct segments ) malloc (nsegments_max sizeof (segments[0]));
	if (segments == NULL)
	error (1, errno, gettext ("while reading ELF file"));

	size_t phnum;
	if (elf_getphdrnum (elf, &phnum) != 0)
	error (1, 0, gettext ("cannot get program header count: %s"),
	elf_errmsg (-1));


	for (size_t i = 0; i < phnum; ++i)
	{
	GElf_Phdr phdr_mem;
	GElf_Phdr *phdr = gelf_getphdr (elf, i, &phdr_mem);
	if (phdr == NULL)
	{
	error (0, 0,
	gettext ("cannot get program header index at offset %zd: %s"),
	i, elf_errmsg (-1));
	result = 1;
	goto next;
	}

	if (phdr->p_type == PT_LOAD && (phdr->p_flags & PF_W) == 0)
	{
	if (nsegments == nsegments_max)
	{
	nsegments_max *= 2;
	segments
	= (struct segments *) realloc (segments,
	nsegments_max
	* sizeof (segments[0]));
	if (segments == NULL)
	{
	error (0, 0, gettext ("\
	cannot get program header index at offset %zd: %s"),
	i, elf_errmsg (-1));
	result = 1;
	goto next;
	}
	}

	segments[nsegments].from = phdr->p_vaddr;
	segments[nsegments].to = phdr->p_vaddr + phdr->p_memsz;
	++nsegments;
	}
	}

	if (nsegments > 0)
	{

	Dwarf *dw = dwarf_begin_elf (elf, DWARF_C_READ, NULL);
	/* Look for debuginfo files if the information is not the in
	opened file itself. This makes only sense if the input file
	is specified with an absolute path. */
	if (dw == NULL && fname[0] == '/')
	{
	size_t debuginfo_rootlen = strlen (debuginfo_root);
	char difname = (char ) alloca (rootdir_len + debuginfo_rootlen
	+ fname_len + 8);
	strcpy (mempcpy (stpcpy (mempcpy (mempcpy (difname, rootdir,
	rootdir_len),
	debuginfo_root,
	debuginfo_rootlen),
	"/"),
	fname, fname_len),
	".debug");

	fd2 = open (difname, O_RDONLY);
	if (fd2 != -1
	&& (elf2 = elf_begin (fd2, ELF_C_READ_MMAP, NULL)) != NULL)
	dw = dwarf_begin_elf (elf2, DWARF_C_READ, NULL);
	}

	/* Look at all relocations and determine which modify
	write-protected segments. */
	scn = NULL;
	while ((scn = elf_nextscn (elf, scn)) != NULL)
	{
	/* Handle the section if it is a symbol table. */
	GElf_Shdr shdr_mem;
	GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);

	if (shdr == NULL)
	{
	error (0, 0,
	gettext ("cannot get section header of section %zu: %s"),
	elf_ndxscn (scn), elf_errmsg (-1));
	result = 1;
	goto next;
	}

	if ((shdr->sh_type == SHT_REL \|\| shdr->sh_type == SHT_RELA)
	&& symscn == NULL)
	{
	symscn = elf_getscn (elf, shdr->sh_link);
	if (symscn == NULL)
	{
	error (0, 0, gettext ("\
	cannot get symbol table section %zu in '%s': %s"),
	(size_t) shdr->sh_link, fname, elf_errmsg (-1));
	result = 1;
	goto next;
	}
	}

	if (shdr->sh_type == SHT_REL)
	{
	Elf_Data *data = elf_getdata (scn, NULL);
	size_t entries = (shdr->sh_entsize == 0
	? 0 : shdr->sh_size / shdr->sh_entsize);

	for (int cnt = 0;
	(size_t) cnt < entries; ++cnt)
	{
	GElf_Rel rel_mem;
	GElf_Rel *rel = gelf_getrel (data, cnt, &rel_mem);
	if (rel == NULL)
	{
	error (0, 0, gettext ("\
	cannot get relocation at index %d in section %zu in '%s': %s"),
	cnt, elf_ndxscn (scn), fname, elf_errmsg (-1));
	result = 1;
	goto next;
	}

	check_rel (nsegments, segments, rel->r_offset, elf,
	symscn, dw, fname, more_than_one, &knownsrcs);
	}
	}
	else if (shdr->sh_type == SHT_RELA)
	{
	Elf_Data *data = elf_getdata (scn, NULL);
	size_t entries = (shdr->sh_entsize == 0
	? 0 : shdr->sh_size / shdr->sh_entsize);

	for (int cnt = 0; (size_t) cnt < entries; ++cnt)
	{
	GElf_Rela rela_mem;
	GElf_Rela *rela = gelf_getrela (data, cnt, &rela_mem);
	if (rela == NULL)
	{
	error (0, 0, gettext ("\
	cannot get relocation at index %d in section %zu in '%s': %s"),
	cnt, elf_ndxscn (scn), fname, elf_errmsg (-1));
	result = 1;
	goto next;
	}

	check_rel (nsegments, segments, rela->r_offset, elf,
	symscn, dw, fname, more_than_one, &knownsrcs);
	}
	}
	}

	dwarf_end (dw);
	}

	next:
	elf_end (elf);
	elf_end (elf2);
	close (fd);
	if (fd2 != -1)
	close (fd2);

	free (segments);
	tdestroy (knownsrcs, noop);

	return result;
	}


	static int
	ptrcompare (const void p1, const void p2)
	{
	if ((uintptr_t) p1 < (uintptr_t) p2)
	return -1;
	if ((uintptr_t) p1 > (uintptr_t) p2)
	return 1;
	return 0;
	}


	static void
	check_rel (size_t nsegments, struct segments segments[nsegments],
	GElf_Addr addr, Elf elf, Elf_Scn symscn, Dwarf *dw,
	const char fname, bool more_than_one, void *knownsrcs)
	{
	for (size_t cnt = 0; cnt < nsegments; ++cnt)
	if (segments[cnt].from <= addr && segments[cnt].to > addr)
	{
	Dwarf_Die die_mem;
	Dwarf_Die *die;
	Dwarf_Line *line;
	const char *src;

	if (more_than_one)
	printf ("%s: ", fname);

	if ((die = dwarf_addrdie (dw, addr, &die_mem)) != NULL
	&& (line = dwarf_getsrc_die (die, addr)) != NULL
	&& (src = dwarf_linesrc (line, NULL, NULL)) != NULL)
	{
	/* There can be more than one relocation against one file.
	Try to avoid multiple messages. And yes, the code uses
	pointer comparison. */
	if (tfind (src, knownsrcs, ptrcompare) == NULL)
	{
	printf (gettext ("%s not compiled with -fpic/-fPIC\n"), src);
	tsearch (src, knownsrcs, ptrcompare);
	}
	return;
	}
	else
	{
	/* At least look at the symbol table to see which function
	the modified address is in. */
	Elf_Data *symdata = elf_getdata (symscn, NULL);
	GElf_Shdr shdr_mem;
	GElf_Shdr *shdr = gelf_getshdr (symscn, &shdr_mem);
	if (shdr != NULL)
	{
	GElf_Addr lowaddr = 0;
	int lowidx = -1;
	GElf_Addr highaddr = ~0ul;
	int highidx = -1;
	GElf_Sym sym_mem;
	GElf_Sym *sym;
	size_t entries = (shdr->sh_entsize == 0
	? 0 : shdr->sh_size / shdr->sh_entsize);

	for (int i = 0; (size_t) i < entries; ++i)
	{
	sym = gelf_getsym (symdata, i, &sym_mem);
	if (sym == NULL)
	continue;

	if (sym->st_value < addr && sym->st_value > lowaddr)
	{
	lowaddr = sym->st_value;
	lowidx = i;
	}
	if (sym->st_value > addr && sym->st_value < highaddr)
	{
	highaddr = sym->st_value;
	highidx = i;
	}
	}

	if (lowidx != -1)
	{
	sym = gelf_getsym (symdata, lowidx, &sym_mem);
	assert (sym != NULL);

	const char *lowstr = elf_strptr (elf, shdr->sh_link,
	sym->st_name);

	if (sym->st_value + sym->st_size > addr)
	{
	/* It is this function. */
	if (tfind (lowstr, knownsrcs, ptrcompare) == NULL)
	{
	printf (gettext ("\
	the file containing the function '%s' is not compiled with -fpic/-fPIC\n"),
	lowstr);
	tsearch (lowstr, knownsrcs, ptrcompare);
	}
	}
	else if (highidx == -1)
	printf (gettext ("\
	the file containing the function '%s' might not be compiled with -fpic/-fPIC\n"),
	lowstr);
	else
	{
	sym = gelf_getsym (symdata, highidx, &sym_mem);
	assert (sym != NULL);

	printf (gettext ("\
	either the file containing the function '%s' or the file containing the function '%s' is not compiled with -fpic/-fPIC\n"),
	lowstr, elf_strptr (elf, shdr->sh_link,
	sym->st_name));
	}
	return;
	}
	else if (highidx != -1)
	{
	sym = gelf_getsym (symdata, highidx, &sym_mem);
	assert (sym != NULL);

	printf (gettext ("\
	the file containing the function '%s' might not be compiled with -fpic/-fPIC\n"),
	elf_strptr (elf, shdr->sh_link, sym->st_name));
	return;
	}
	}
	}

	printf (gettext ("\
	a relocation modifies memory at offset %llu in a write-protected segment\n"),
	(unsigned long long int) addr);
	break;
	}
	}


	#include "debugpred.h"