gdb/solib-osf.c

   1 /* Handle OSF/1, Digital UNIX, and Tru64 shared libraries
   2    for GDB, the GNU Debugger.
   3    Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* When handling shared libraries, GDB has to find out the pathnames
  22    of all shared libraries that are currently loaded (to read in their
  23    symbols) and where the shared libraries are loaded in memory
  24    (to relocate them properly from their prelinked addresses to the
  25    current load address).
  26
  27    Under OSF/1 there are two possibilities to get at this information:
  28
  29    1) Peek around in the runtime loader structures.
  30    These are not documented, and they are not defined in the system
  31    header files. The definitions below were obtained by experimentation,
  32    but they seem stable enough.
  33
  34    2) Use the libxproc.a library, which contains the equivalent ldr_*
  35    routines.  The library is documented in Tru64 5.x, but as of 5.1, it
  36    only allows a process to examine itself.  On earlier versions, it
  37    may require that the GDB executable be dynamically linked and that
  38    NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context
  39    for GDB and all applications that are using libgdb.
  40
  41    We will use the peeking approach until libxproc.a works for other
  42    processes.  */
  43
  44 #include "defs.h"
  45
  46 #include <sys/types.h>
  47 #include <signal.h>
  48 #include "gdb_string.h"
  49
  50 #include "bfd.h"
  51 #include "symtab.h"
  52 #include "symfile.h"
  53 #include "objfiles.h"
  54 #include "target.h"
  55 #include "inferior.h"
  56 #include "solist.h"
  57
  58 #ifdef USE_LDR_ROUTINES
  59 # include <loader.h>
  60 #endif
  61
  62 #ifndef USE_LDR_ROUTINES
  63 /* Definition of runtime loader structures, found by experimentation.  */
  64 #define RLD_CONTEXT_ADDRESS     0x3ffc0000000
  65
  66 /* Per-module information structure referenced by ldr_context_t.head.  */
  67
  68 typedef struct
  69   {
  70     CORE_ADDR next;
  71     CORE_ADDR previous;
  72     CORE_ADDR unknown1;
  73     CORE_ADDR module_name;
  74     CORE_ADDR modinfo_addr;     /* used by next_link_map_member() to detect
  75                                    the end of the shared module list */
  76     long module_id;
  77     CORE_ADDR unknown2;
  78     CORE_ADDR unknown3;
  79     long region_count;
  80     CORE_ADDR regioninfo_addr;
  81   }
  82 ldr_module_info_t;
  83
  84 /* Per-region structure referenced by ldr_module_info_t.regioninfo_addr.  */
  85
  86 typedef struct
  87   {
  88     long unknown1;
  89     CORE_ADDR regionname_addr;
  90     long protection;
  91     CORE_ADDR vaddr;
  92     CORE_ADDR mapaddr;
  93     long size;
  94     long unknown2[5];
  95   }
  96 ldr_region_info_t;
  97
  98 /* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses
  99    of the shared module list.  */
 100
 101 typedef struct
 102   {
 103     CORE_ADDR unknown1;
 104     CORE_ADDR unknown2;
 105     CORE_ADDR head;
 106     CORE_ADDR tail;
 107   }
 108 ldr_context_t;
 109 #endif   /* !USE_LDR_ROUTINES */
 110
 111 /* Per-section information, stored in struct lm_info.secs.  */
 112
 113 struct lm_sec
 114   {
 115     CORE_ADDR offset;           /* difference between default and actual
 116                                    virtual addresses of section .name */
 117     CORE_ADDR nameaddr;         /* address in inferior of section name */
 118     const char *name;           /* name of section, null if not fetched */
 119   };
 120
 121 /* Per-module information, stored in struct so_list.lm_info.  */
 122
 123 struct lm_info
 124   {
 125     int isloader;               /* whether the module is /sbin/loader */
 126     int nsecs;                  /* length of .secs */
 127     struct lm_sec secs[1];      /* variable-length array of sections, sorted
 128                                    by name */
 129   };
 130
 131 /* Context for iterating through the inferior's shared module list.  */
 132
 133 struct read_map_ctxt
 134   {
 135 #ifdef USE_LDR_ROUTINES
 136     ldr_process_t proc;
 137     ldr_module_t next;
 138 #else
 139     CORE_ADDR next;             /* next element in module list */
 140     CORE_ADDR tail;             /* last element in module list */
 141 #endif
 142   };
 143
 144 /* Forward declaration for this module's autoinit function.  */
 145
 146 extern void _initialize_osf_solib (void);
 147
 148 #ifdef USE_LDR_ROUTINES
 149 # if 0
 150 /* This routine is intended to be called by ldr_* routines to read memory from
 151    the current target.  Usage:
 152
 153      ldr_process = ldr_core_process ();
 154      ldr_set_core_reader (ldr_read_memory);
 155      ldr_xdetach (ldr_process);
 156      ldr_xattach (ldr_process);
 157
 158    ldr_core_process() and ldr_read_memory() are neither documented nor
 159    declared in system header files.  They work with OSF/1 2.x, and they might
 160    work with later versions as well.  */
 161
 162 static int
 163 ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring)
 164 {
 165   int result;
 166   char *buffer;
 167
 168   if (readstring)
 169     {
 170       target_read_string (memaddr, &buffer, len, &result);
 171       if (result == 0)
 172         strcpy (myaddr, buffer);
 173       xfree (buffer);
 174     }
 175   else
 176     result = target_read_memory (memaddr, myaddr, len);
 177
 178   if (result != 0)
 179     result = -result;
 180   return result;
 181 }
 182 # endif   /* 0 */
 183 #endif   /* USE_LDR_ROUTINES */
 184
 185 /* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to
 186    whether lm_sec *P1's name is lexically less than, equal to, or greater
 187    than that of *P2.  */
 188
 189 static int
 190 lm_sec_cmp (const void *p1, const void *p2)
 191 {
 192   const struct lm_sec *lms1 = p1, *lms2 = p2;
 193   return strcmp (lms1->name, lms2->name);
 194 }
 195
 196 /* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search
 197    it.  */
 198
 199 static void
 200 lm_secs_sort (struct lm_info *lmi)
 201 {
 202   qsort (lmi->secs, lmi->nsecs, sizeof *lmi->secs, lm_sec_cmp);
 203 }
 204
 205 /* Populate name fields of LMI->secs.  */
 206
 207 static void
 208 fetch_sec_names (struct lm_info *lmi)
 209 {
 210 #ifndef USE_LDR_ROUTINES
 211   int i, errcode;
 212   struct lm_sec *lms;
 213   char *name;
 214
 215   for (i = 0; i < lmi->nsecs; i++)
 216     {
 217       lms = lmi->secs + i;
 218       target_read_string (lms->nameaddr, &name, PATH_MAX, &errcode);
 219       if (errcode != 0)
 220         {
 221           warning (_("unable to read shared sec name at 0x%lx"), lms->nameaddr);
 222           name = xstrdup ("");
 223         }
 224       lms->name = name;
 225     }
 226   lm_secs_sort (lmi);
 227 #endif
 228 }
 229
 230 /* target_so_ops callback.  Adjust SEC's addresses after it's been mapped into
 231    the process.  */
 232
 233 static void
 234 osf_relocate_section_addresses (struct so_list *so,
 235                                 struct section_table *sec)
 236 {
 237   struct lm_info *lmi;
 238   struct lm_sec lms_key, *lms;
 239
 240   /* Fetch SO's section names if we haven't done so already.  */
 241   lmi = so->lm_info;
 242   if (lmi->nsecs && !lmi->secs[0].name)
 243     fetch_sec_names (lmi);
 244
 245   /* Binary-search for offset information corresponding to SEC.  */
 246   lms_key.name = sec->the_bfd_section->name;
 247   lms = bsearch (&lms_key, lmi->secs, lmi->nsecs, sizeof *lms, lm_sec_cmp);
 248   if (lms)
 249     {
 250       sec->addr += lms->offset;
 251       sec->endaddr += lms->offset;
 252     }
 253 }
 254
 255 /* target_so_ops callback.  Free parts of SO allocated by this file.  */
 256
 257 static void
 258 osf_free_so (struct so_list *so)
 259 {
 260   int i;
 261   const char *name;
 262
 263   for (i = 0; i < so->lm_info->nsecs; i++)
 264     {
 265       name = so->lm_info->secs[i].name;
 266       if (name)
 267         xfree ((void *) name);
 268     }
 269   xfree (so->lm_info);
 270 }
 271
 272 /* target_so_ops callback.  Discard information accumulated by this file and
 273    not freed by osf_free_so().  */
 274
 275 static void
 276 osf_clear_solib (void)
 277 {
 278   return;
 279 }
 280
 281 /* target_so_ops callback.  Prepare to handle shared libraries after the
 282    inferior process has been created but before it's executed any
 283    instructions.
 284
 285    For a statically bound executable, the inferior's first instruction is the
 286    one at "_start", or a similar text label. No further processing is needed
 287    in that case.
 288
 289    For a dynamically bound executable, this first instruction is somewhere
 290    in the rld, and the actual user executable is not yet mapped in.
 291    We continue the inferior again, rld then maps in the actual user
 292    executable and any needed shared libraries and then sends
 293    itself a SIGTRAP.
 294
 295    At that point we discover the names of all shared libraries and
 296    read their symbols in.
 297
 298    FIXME
 299
 300    This code does not properly handle hitting breakpoints which the
 301    user might have set in the rld itself.  Proper handling would have
 302    to check if the SIGTRAP happened due to a kill call.
 303
 304    Also, what if child has exit()ed?  Must exit loop somehow.  */
 305
 306 static void
 307 osf_solib_create_inferior_hook (void)
 308 {
 309   /* If we are attaching to the inferior, the shared libraries
 310      have already been mapped, so nothing more to do.  */
 311   if (attach_flag)
 312     return;
 313
 314   /* Nothing to do for statically bound executables.  */
 315
 316   if (symfile_objfile == NULL
 317       || symfile_objfile->obfd == NULL
 318       || ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0))
 319     return;
 320
 321   /* Now run the target.  It will eventually get a SIGTRAP, at
 322      which point all of the libraries will have been mapped in and we
 323      can go groveling around in the rld structures to find
 324      out what we need to know about them.
 325
 326      If debugging from a core file, we cannot resume the execution
 327      of the inferior.  But this is actually not an issue, because
 328      shared libraries have already been mapped anyways, which means
 329      we have nothing more to do.  */
 330   if (!target_can_run (&current_target))
 331     return;
 332
 333   clear_proceed_status ();
 334   stop_soon = STOP_QUIETLY;
 335   stop_signal = TARGET_SIGNAL_0;
 336   do
 337     {
 338       target_resume (minus_one_ptid, 0, stop_signal);
 339       wait_for_inferior (0);
 340     }
 341   while (stop_signal != TARGET_SIGNAL_TRAP);
 342
 343   /*  solib_add will call reinit_frame_cache.
 344      But we are stopped in the runtime loader and we do not have symbols
 345      for the runtime loader. So heuristic_proc_start will be called
 346      and will put out an annoying warning.
 347      Delaying the resetting of stop_soon until after symbol loading
 348      suppresses the warning.  */
 349   solib_add ((char *) 0, 0, (struct target_ops *) 0, auto_solib_add);
 350   stop_soon = NO_STOP_QUIETLY;
 351 }
 352
 353 /* target_so_ops callback.  Do additional symbol handling, lookup, etc. after
 354    symbols for a shared object have been loaded.  */
 355
 356 static void
 357 osf_special_symbol_handling (void)
 358 {
 359   return;
 360 }
 361
 362 /* Initialize CTXT in preparation for iterating through the inferior's module
 363    list using read_map().  Return success.  */
 364
 365 static int
 366 open_map (struct read_map_ctxt *ctxt)
 367 {
 368 #ifdef USE_LDR_ROUTINES
 369   /* Note: As originally written, ldr_my_process() was used to obtain
 370      the value for ctxt->proc.  This is incorrect, however, since
 371      ldr_my_process() retrieves the "unique identifier" associated
 372      with the current process (i.e. GDB) and not the one being
 373      debugged.  Presumably, the pid of the process being debugged is
 374      compatible with the "unique identifier" used by the ldr_
 375      routines, so we use that.  */
 376   ctxt->proc = ptid_get_pid (inferior_ptid);
 377   if (ldr_xattach (ctxt->proc) != 0)
 378     return 0;
 379   ctxt->next = LDR_NULL_MODULE;
 380 #else
 381   CORE_ADDR ldr_context_addr, prev, next;
 382   ldr_context_t ldr_context;
 383
 384   if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS,
 385                           (char *) &ldr_context_addr,
 386                           sizeof (CORE_ADDR)) != 0)
 387     return 0;
 388   if (target_read_memory (ldr_context_addr,
 389                           (char *) &ldr_context,
 390                           sizeof (ldr_context_t)) != 0)
 391     return 0;
 392   ctxt->next = ldr_context.head;
 393   ctxt->tail = ldr_context.tail;
 394 #endif
 395   return 1;
 396 }
 397
 398 /* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and
 399    space for NSECS sections.  */
 400
 401 static void
 402 init_so (struct so_list *so, char *name, int isloader, int nsecs)
 403 {
 404   int namelen, i;
 405
 406   /* solib.c requires various fields to be initialized to 0.  */
 407   memset (so, 0, sizeof *so);
 408
 409   /* Copy the name.  */
 410   namelen = strlen (name);
 411   if (namelen >= SO_NAME_MAX_PATH_SIZE)
 412     namelen = SO_NAME_MAX_PATH_SIZE - 1;
 413
 414   memcpy (so->so_original_name, name, namelen);
 415   so->so_original_name[namelen] = '\0';
 416   memcpy (so->so_name, so->so_original_name, namelen + 1);
 417
 418   /* Allocate section space.  */
 419   so->lm_info = xmalloc ((unsigned) &(((struct lm_info *)0)->secs) +
 420                          nsecs * sizeof *so->lm_info);
 421   so->lm_info->isloader = isloader;
 422   so->lm_info->nsecs = nsecs;
 423   for (i = 0; i < nsecs; i++)
 424     so->lm_info->secs[i].name = NULL;
 425 }
 426
 427 /* Initialize SO's section SECIDX with name address NAMEADDR, name string
 428    NAME, default virtual address VADDR, and actual virtual address
 429    MAPADDR.  */
 430
 431 static void
 432 init_sec (struct so_list *so, int secidx, CORE_ADDR nameaddr,
 433           const char *name, CORE_ADDR vaddr, CORE_ADDR mapaddr)
 434 {
 435   struct lm_sec *lms;
 436
 437   lms = so->lm_info->secs + secidx;
 438   lms->nameaddr = nameaddr;
 439   lms->name = name;
 440   lms->offset = mapaddr - vaddr;
 441 }
 442
 443 /* If there are more elements starting at CTXT in inferior's module list,
 444    store the next element in SO, advance CTXT to the next element, and return
 445    1, else return 0.  */
 446
 447 static int
 448 read_map (struct read_map_ctxt *ctxt, struct so_list *so)
 449 {
 450   ldr_module_info_t minf;
 451   ldr_region_info_t rinf;
 452
 453 #ifdef USE_LDR_ROUTINES
 454   size_t size;
 455   ldr_region_t i;
 456
 457   /* Retrieve the next element.  */
 458   if (ldr_next_module (ctxt->proc, &ctxt->next) != 0)
 459     return 0;
 460   if (ctxt->next == LDR_NULL_MODULE)
 461     return 0;
 462   if (ldr_inq_module (ctxt->proc, ctxt->next, &minf, sizeof minf, &size) != 0)
 463     return 0;
 464
 465   /* Initialize the module name and section count.  */
 466   init_so (so, minf.lmi_name, 0, minf.lmi_nregion);
 467
 468   /* Retrieve section names and offsets.  */
 469   for (i = 0; i < minf.lmi_nregion; i++)
 470     {
 471       if (ldr_inq_region (ctxt->proc, ctxt->next, i, &rinf,
 472                           sizeof rinf, &size) != 0)
 473         goto err;
 474       init_sec (so, (int) i, 0, xstrdup (rinf.lri_name),
 475                 (CORE_ADDR) rinf.lri_vaddr, (CORE_ADDR) rinf.lri_mapaddr);
 476     }
 477   lm_secs_sort (so->lm_info);
 478 #else
 479   char *name;
 480   int errcode, i;
 481
 482   /* Retrieve the next element.  */
 483   if (!ctxt->next)
 484     return 0;
 485   if (target_read_memory (ctxt->next, (char *) &minf, sizeof minf) != 0)
 486     return 0;
 487   if (ctxt->next == ctxt->tail)
 488     ctxt->next = 0;
 489   else
 490     ctxt->next = minf.next;
 491
 492   /* Initialize the module name and section count.  */
 493   target_read_string (minf.module_name, &name, PATH_MAX, &errcode);
 494   if (errcode != 0)
 495     return 0;
 496   init_so (so, name, !minf.modinfo_addr, minf.region_count);
 497   xfree (name);
 498
 499   /* Retrieve section names and offsets.  */
 500   for (i = 0; i < minf.region_count; i++)
 501     {
 502       if (target_read_memory (minf.regioninfo_addr + i * sizeof rinf,
 503                               (char *) &rinf, sizeof rinf) != 0)
 504         goto err;
 505       init_sec (so, i, rinf.regionname_addr, NULL, rinf.vaddr, rinf.mapaddr);
 506     }
 507 #endif   /* !USE_LDR_ROUTINES */
 508   return 1;
 509
 510  err:
 511   osf_free_so (so);
 512   return 0;
 513 }
 514
 515 /* Free resources allocated by open_map (CTXT).  */
 516
 517 static void
 518 close_map (struct read_map_ctxt *ctxt)
 519 {
 520 #ifdef USE_LDR_ROUTINES
 521   ldr_xdetach (ctxt->proc);
 522 #endif
 523 }
 524
 525 /* target_so_ops callback.  Return a list of shared objects currently loaded
 526    in the inferior.  */
 527
 528 static struct so_list *
 529 osf_current_sos (void)
 530 {
 531   struct so_list *head = NULL, *tail, *newtail, so;
 532   struct read_map_ctxt ctxt;
 533   int skipped_main;
 534
 535   if (!open_map (&ctxt))
 536     return NULL;
 537
 538   /* Read subsequent elements.  */
 539   for (skipped_main = 0;;)
 540     {
 541       if (!read_map (&ctxt, &so))
 542         break;
 543
 544       /* Skip the main program module, which is first in the list after
 545          /sbin/loader.  */
 546       if (!so.lm_info->isloader && !skipped_main)
 547         {
 548           osf_free_so (&so);
 549           skipped_main = 1;
 550           continue;
 551         }
 552
 553       newtail = xmalloc (sizeof *newtail);
 554       if (!head)
 555         head = newtail;
 556       else
 557         tail->next = newtail;
 558       tail = newtail;
 559
 560       memcpy (tail, &so, sizeof so);
 561       tail->next = NULL;
 562     }
 563
 564   close_map (&ctxt);
 565   return head;
 566 }
 567
 568 /* target_so_ops callback.  Attempt to locate and open the main symbol
 569    file.  */
 570
 571 static int
 572 osf_open_symbol_file_object (void *from_ttyp)
 573 {
 574   struct read_map_ctxt ctxt;
 575   struct so_list so;
 576   int found;
 577
 578   if (symfile_objfile)
 579     if (!query ("Attempt to reload symbols from process? "))
 580       return 0;
 581
 582   /* The first module after /sbin/loader is the main program.  */
 583   if (!open_map (&ctxt))
 584     return 0;
 585   for (found = 0; !found;)
 586     {
 587       if (!read_map (&ctxt, &so))
 588         break;
 589       found = !so.lm_info->isloader;
 590       osf_free_so (&so);
 591     }
 592   close_map (&ctxt);
 593
 594   if (found)
 595     symbol_file_add_main (so.so_name, *(int *) from_ttyp);
 596   return found;
 597 }
 598
 599 /* target_so_ops callback.  Return whether PC is in the dynamic linker.  */
 600
 601 static int
 602 osf_in_dynsym_resolve_code (CORE_ADDR pc)
 603 {
 604   /* This function currently always return False. This is a temporary
 605      solution which only consequence is to introduce a minor incovenience
 606      for the user: When stepping inside a subprogram located in a shared
 607      library, gdb might stop inside the dynamic loader code instead of
 608      inside the subprogram itself. See the explanations in infrun.c about
 609      the IN_SOLIB_DYNSYM_RESOLVE_CODE macro for more details. */
 610   return 0;
 611 }
 612
 613 static struct target_so_ops osf_so_ops;
 614
 615 void
 616 _initialize_osf_solib (void)
 617 {
 618   osf_so_ops.relocate_section_addresses = osf_relocate_section_addresses;
 619   osf_so_ops.free_so = osf_free_so;
 620   osf_so_ops.clear_solib = osf_clear_solib;
 621   osf_so_ops.solib_create_inferior_hook = osf_solib_create_inferior_hook;
 622   osf_so_ops.special_symbol_handling = osf_special_symbol_handling;
 623   osf_so_ops.current_sos = osf_current_sos;
 624   osf_so_ops.open_symbol_file_object = osf_open_symbol_file_object;
 625   osf_so_ops.in_dynsym_resolve_code = osf_in_dynsym_resolve_code;
 626
 627   /* FIXME: Don't do this here.  *_gdbarch_init() should set so_ops. */
 628   current_target_so_ops = &osf_so_ops;
 629 }