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