bfd/vms-hdr.c

   1 /* vms-hdr.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
   2    EVAX (openVMS/Alpha) files.
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006,
   4    2007, 2008, 2009 Free Software Foundation, Inc.
   5
   6    HDR record handling functions
   7    EMH record handling functions
   8
   9    EOM record handling functions
  10    EEOM record handling functions
  11
  12    IHD record handling functions
  13    EIHD record handling functions
  14
  15    ISD record handling functions
  16    EISD record handling functions
  17
  18    IHS record handling functions
  19    EIHS record handling functions
  20
  21    DBG record handling functions
  22    EDBG record handling functions
  23
  24    TBT record handling functions
  25    ETBT record handling functions
  26
  27    DST/DMT section handling functions
  28
  29    Written by Klaus K"ampf (kkaempf@rmi.de)
  30
  31    This program is free software; you can redistribute it and/or modify
  32    it under the terms of the GNU General Public License as published by
  33    the Free Software Foundation; either version 3 of the License, or
  34    (at your option) any later version.
  35
  36    This program is distributed in the hope that it will be useful,
  37    but WITHOUT ANY WARRANTY; without even the implied warranty of
  38    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  39    GNU General Public License for more details.
  40
  41    You should have received a copy of the GNU General Public License
  42    along with this program; if not, write to the Free Software
  43    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  44    MA 02110-1301, USA.  */
  45
  46 #include "sysdep.h"
  47 #include "bfd.h"
  48 #include "bfdver.h"
  49 #include "bfdlink.h"
  50 #include "safe-ctype.h"
  51 #include "libbfd.h"
  52
  53 #include "vms.h"
  54
  55 static struct module *new_module (bfd *);
  56 static void parse_module
  57   (bfd *, struct module *, unsigned char *, unsigned int);
  58 static struct module *build_module_list (bfd *);
  59 static bfd_boolean module_find_nearest_line
  60   (bfd *, struct module *, bfd_vma, const char **, const char **,
  61    unsigned int *);
  62 static int vms_slurp_debug (bfd *);
  63
  64 #define SET_MODULE_PARSED(m) \
  65   do { if ((m)->name == NULL) (m)->name = ""; } while (0)
  66 #define IS_MODULE_PARSED(m) ((m)->name != NULL)
  67
  68
  69 /* Read & process emh record
  70    return 0 on success, -1 on error.  */
  71
  72 int
  73 _bfd_vms_slurp_hdr (bfd *abfd, int objtype)
  74 {
  75   unsigned char *ptr;
  76   unsigned char *vms_rec;
  77   int subtype;
  78
  79   vms_rec = PRIV(vms_rec);
  80
  81 #if VMS_DEBUG
  82   vms_debug(2, "HDR/EMH\n");
  83 #endif
  84
  85   switch (objtype)
  86     {
  87     case OBJ_S_C_HDR:
  88       subtype = vms_rec[1];
  89       break;
  90     case EOBJ_S_C_EMH:
  91       subtype = bfd_getl16 (vms_rec + 4) + EVAX_OFFSET;
  92       break;
  93     default:
  94       subtype = -1;
  95     }
  96
  97 #if VMS_DEBUG
  98   vms_debug(3, "subtype %d\n", subtype);
  99 #endif
 100
 101   switch (subtype)
 102     {
 103     case MHD_S_C_MHD:
 104       /* Module header.  */
 105       PRIV (hdr_data).hdr_b_strlvl = vms_rec[2];
 106       PRIV (hdr_data).hdr_l_recsiz = bfd_getl16 (vms_rec + 3);
 107       PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 5);
 108       ptr = vms_rec + 5 + vms_rec[5] + 1;
 109       PRIV (hdr_data).hdr_t_version = _bfd_vms_save_counted_string (ptr);
 110       ptr += *ptr + 1;
 111       PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
 112       break;
 113
 114     case MHD_S_C_LNM:
 115       PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
 116       break;
 117
 118     case MHD_S_C_SRC:
 119       PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
 120       break;
 121
 122     case MHD_S_C_TTL:
 123       PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 2));
 124       break;
 125
 126     case EMH_S_C_MHD + EVAX_OFFSET:
 127       /* Module header.  */
 128       PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
 129       PRIV (hdr_data).hdr_l_arch1  = bfd_getl32 (vms_rec + 8);
 130       PRIV (hdr_data).hdr_l_arch2  = bfd_getl32 (vms_rec + 12);
 131       PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
 132       PRIV (hdr_data).hdr_t_name   = _bfd_vms_save_counted_string (vms_rec + 20);
 133       ptr = vms_rec + 20 + vms_rec[20] + 1;
 134       PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
 135       ptr += *ptr + 1;
 136       PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
 137       break;
 138
 139     case EMH_S_C_LNM + EVAX_OFFSET:
 140       PRIV (hdr_data).hdr_c_lnm = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
 141       break;
 142
 143     case EMH_S_C_SRC + EVAX_OFFSET:
 144       PRIV (hdr_data).hdr_c_src = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
 145       break;
 146
 147     case EMH_S_C_TTL + EVAX_OFFSET:
 148       PRIV (hdr_data).hdr_c_ttl = _bfd_vms_save_sized_string (vms_rec, PRIV (rec_size - 6));
 149       break;
 150
 151     case MHD_S_C_CPR:
 152     case MHD_S_C_MTC:
 153     case MHD_S_C_GTX:
 154     case EMH_S_C_CPR + EVAX_OFFSET:
 155     case EMH_S_C_MTC + EVAX_OFFSET:
 156     case EMH_S_C_GTX + EVAX_OFFSET:
 157       break;
 158
 159     default:
 160       bfd_set_error (bfd_error_wrong_format);
 161       return -1;
 162     }
 163
 164   return 0;
 165 }
 166
 167 /* Output routines.  */
 168
 169 /* Manufacture a VMS like time on a unix based system.
 170    stolen from obj-vms.c.  */
 171
 172 static unsigned char *
 173 get_vms_time_string (void)
 174 {
 175   static unsigned char tbuf[18];
 176 #ifndef VMS
 177 #include <time.h>
 178
 179   char *pnt;
 180   time_t timeb;
 181
 182   time (& timeb);
 183   pnt = ctime (&timeb);
 184   pnt[3] = 0;
 185   pnt[7] = 0;
 186   pnt[10] = 0;
 187   pnt[16] = 0;
 188   pnt[24] = 0;
 189   sprintf ((char *) tbuf, "%2s-%3s-%s %s",
 190            pnt + 8, pnt + 4, pnt + 20, pnt + 11);
 191 #else
 192 #include <starlet.h>
 193   struct
 194   {
 195     int Size;
 196     unsigned char *Ptr;
 197   } Descriptor;
 198   Descriptor.Size = 17;
 199   Descriptor.Ptr = tbuf;
 200   SYS$ASCTIM (0, &Descriptor, 0, 0);
 201 #endif /* not VMS */
 202
 203 #if VMS_DEBUG
 204   vms_debug (6, "vmstimestring:'%s'\n", tbuf);
 205 #endif
 206
 207   return tbuf;
 208 }
 209
 210 /* Write object header for bfd abfd.  */
 211
 212 int
 213 _bfd_vms_write_hdr (bfd *abfd, int objtype)
 214 {
 215   asymbol *symbol;
 216   unsigned int symnum;
 217   int had_case = 0;
 218   int had_file = 0;
 219   char version [256];
 220
 221 #if VMS_DEBUG
 222   vms_debug (2, "vms_write_hdr (%p)\n", abfd);
 223 #endif
 224
 225   _bfd_vms_output_alignment (abfd, 2);
 226
 227   /* MHD.  */
 228   if (objtype != OBJ_S_C_HDR)
 229     {
 230       _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_MHD);
 231       _bfd_vms_output_short (abfd, EOBJ_S_C_STRLVL);
 232       _bfd_vms_output_long (abfd, 0);
 233       _bfd_vms_output_long (abfd, 0);
 234       _bfd_vms_output_long (abfd, MAX_OUTREC_SIZE);
 235     }
 236
 237   /* Create module name from filename.  */
 238   if (bfd_get_filename (abfd) != 0)
 239     {
 240       char *module = vms_get_module_name (bfd_get_filename (abfd), TRUE);
 241       _bfd_vms_output_counted (abfd, module);
 242       free (module);
 243     }
 244   else
 245     _bfd_vms_output_counted (abfd, "NONAME");
 246
 247   _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
 248   _bfd_vms_output_dump (abfd, get_vms_time_string (), EMH_DATE_LENGTH);
 249   _bfd_vms_output_fill (abfd, 0, EMH_DATE_LENGTH);
 250   _bfd_vms_output_flush (abfd);
 251
 252   /* LMN.  */
 253   _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
 254   snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
 255   _bfd_vms_output_dump (abfd, (unsigned char *)version, strlen (version));
 256   _bfd_vms_output_flush (abfd);
 257
 258   /* SRC.  */
 259   _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
 260
 261   for (symnum = 0; symnum < abfd->symcount; symnum++)
 262     {
 263       symbol = abfd->outsymbols[symnum];
 264
 265       if (symbol->flags & BSF_FILE)
 266         {
 267           if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
 268             {
 269               PRIV (flag_hash_long_names) = symbol->name[6] - '0';
 270               PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
 271
 272               if (had_file)
 273                 break;
 274               had_case = 1;
 275               continue;
 276             }
 277
 278           _bfd_vms_output_dump (abfd, (unsigned char *) symbol->name,
 279                                 (int) strlen (symbol->name));
 280           if (had_case)
 281             break;
 282           had_file = 1;
 283         }
 284     }
 285
 286   if (symnum == abfd->symcount)
 287     _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("noname"));
 288
 289   _bfd_vms_output_flush (abfd);
 290
 291   /* TTL.  */
 292   _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_TTL);
 293   _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("TTL"));
 294   _bfd_vms_output_flush (abfd);
 295
 296   /* CPR.  */
 297   _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_CPR);
 298   _bfd_vms_output_dump (abfd,
 299                          (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
 300                          39);
 301   _bfd_vms_output_flush (abfd);
 302
 303   return 0;
 304 }
 305
 306 /* Process EOM/EEOM record
 307    return 0 on success, -1 on error.  */
 308
 309 int
 310 _bfd_vms_slurp_eom (bfd *abfd, int objtype)
 311 {
 312   unsigned char *vms_rec;
 313
 314 #if VMS_DEBUG
 315   vms_debug(2, "EOM/EEOM\n");
 316 #endif
 317
 318   vms_rec = PRIV (vms_rec);
 319
 320   if ((objtype == OBJ_S_C_EOM)
 321      || (objtype == OBJ_S_C_EOMW))
 322     {
 323     }
 324   else
 325     {
 326       PRIV (eom_data).eom_l_total_lps
 327         = bfd_getl32 (vms_rec + EEOM_S_L_TOTAL_LPS);
 328       PRIV (eom_data).eom_w_comcod = bfd_getl16 (vms_rec + EEOM_S_W_COMCOD);
 329       if (PRIV (eom_data).eom_w_comcod > 1)
 330         {
 331           (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
 332           bfd_set_error (bfd_error_bad_value);
 333           return -1;
 334         }
 335       PRIV (eom_data).eom_has_transfer = FALSE;
 336       if (PRIV (rec_size) > 10)
 337         {
 338            PRIV (eom_data).eom_has_transfer = TRUE;
 339            PRIV (eom_data).eom_b_tfrflg = vms_rec[EEOM_S_B_TFRFLG];
 340            PRIV (eom_data).eom_l_psindx
 341              = bfd_getl32 (vms_rec + EEOM_S_L_PSINDX);
 342            PRIV (eom_data).eom_l_tfradr
 343              = bfd_getl32 (vms_rec + EEOM_S_L_TFRADR);
 344
 345            abfd->start_address = PRIV (eom_data).eom_l_tfradr;
 346         }
 347     }
 348   return 0;
 349 }
 350
 351 /* Write eom record for bfd abfd.  */
 352
 353 int
 354 _bfd_vms_write_eom (bfd *abfd, int objtype)
 355 {
 356 #if VMS_DEBUG
 357   vms_debug (2, "vms_write_eom (%p, %d)\n", abfd, objtype);
 358 #endif
 359
 360   _bfd_vms_output_begin (abfd, objtype, -1);
 361   _bfd_vms_output_long (abfd, (unsigned long) (PRIV (vms_linkage_index) >> 1));
 362   _bfd_vms_output_byte (abfd, 0);       /* Completion code.  */
 363   _bfd_vms_output_byte (abfd, 0);       /* Fill byte.  */
 364
 365   if (bfd_get_start_address (abfd) != (bfd_vma)-1)
 366     {
 367       asection *section;
 368
 369       section = bfd_get_section_by_name (abfd, ".link");
 370       if (section == 0)
 371         {
 372           bfd_set_error (bfd_error_nonrepresentable_section);
 373           return -1;
 374         }
 375       _bfd_vms_output_short (abfd, 0);
 376       _bfd_vms_output_long (abfd, (unsigned long) (section->index));
 377       _bfd_vms_output_long (abfd,
 378                              (unsigned long) bfd_get_start_address (abfd));
 379       _bfd_vms_output_long (abfd, 0);
 380     }
 381
 382   _bfd_vms_output_end (abfd);
 383   return 0;
 384 }
 385
 386 /* Read & process IHD/EIHD record.
 387    Return 0 on success, -1 on error  */
 388 int
 389 _bfd_vms_slurp_ihd (bfd *abfd, unsigned int *isd_offset,
 390                     unsigned int *ihs_offset)
 391 {
 392   unsigned int imgtype, size;
 393   bfd_vma symvva;
 394
 395 #if VMS_DEBUG
 396   vms_debug (8, "_bfd_vms_slurp_ihd\n");
 397 #endif
 398
 399   size = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
 400   imgtype = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_IMGTYPE);
 401
 402   if (imgtype == EIHD_S_K_EXE)
 403     abfd->flags |= EXEC_P;
 404
 405   symvva = bfd_getl64 (PRIV (vms_rec) + EIHD_S_Q_SYMVVA);
 406   if (symvva != 0)
 407     {
 408       PRIV (symvva) = symvva;
 409       abfd->flags |= DYNAMIC;
 410     }
 411
 412   *isd_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_ISDOFF);
 413   *ihs_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SYMDBGOFF);
 414
 415 #if VMS_DEBUG
 416   vms_debug (4, "EIHD record size %d imgtype %d symvva 0x%llx isd %d ihs %d\n",
 417              size, imgtype, symvva, *isd_offset, *ihs_offset);
 418 #endif
 419
 420   return 0;
 421 }
 422
 423 /* Read & process ISD/EISD record
 424    return 0 on success, -1 on error  */
 425
 426 int
 427 _bfd_vms_slurp_isd (bfd *abfd, unsigned int offset)
 428 {
 429   int section_count = 0;
 430   unsigned char *p;
 431   unsigned int rec_size;
 432
 433 #if VMS_DEBUG
 434   vms_debug (8, "_bfd_vms_slurp_isd\n");
 435 #endif
 436
 437   for (p = PRIV (vms_rec) + offset;
 438        (rec_size = bfd_getl32 (p + EISD_S_L_EISDSIZE)) != 0;
 439        p += rec_size)
 440     {
 441       unsigned long long vaddr = bfd_getl64 (p + EISD_S_Q_VIR_ADDR);
 442       unsigned int size = bfd_getl32 (p + EISD_S_L_SECSIZE);
 443       unsigned int flags = bfd_getl32 (p + EISD_S_L_FLAGS);
 444       unsigned int vbn = bfd_getl32 (p + EISD_S_L_VBN);
 445       char *name = NULL;
 446       asection *section;
 447       flagword bfd_flags;
 448
 449 #if VMS_DEBUG
 450       vms_debug (4, "EISD record at 0x%x size 0x%x addr 0x%x bfd_flags 0x%x block %d\n",
 451                  p - PRIV (vms_rec), size, vaddr, flags, vbn);
 452 #endif
 453
 454       /* VMS combines psects from .obj files into isects in the .exe.  This
 455          process doesn't preserve enough information to reliably determine
 456          what's in each section without examining the data.  This is
 457          especially true of DWARF debug sections.  */
 458       bfd_flags = SEC_ALLOC;
 459
 460       if (flags & EISD_S_M_EXE)
 461         bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
 462
 463       if (flags & EISD_S_M_NONSHRADR)
 464         bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
 465
 466       if (!(flags & EISD_S_M_WRT))
 467         bfd_flags |= SEC_READONLY;
 468
 469       if (flags & EISD_S_M_DZRO)
 470         bfd_flags |= SEC_DATA;
 471
 472       if (flags & EISD_S_M_FIXUPVEC)
 473         bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
 474
 475       if (flags & EISD_S_M_CRF)
 476         bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
 477
 478       if (flags & EISD_S_M_GBL)
 479         {
 480           name = _bfd_vms_save_counted_string (p + EISD_S_T_GBLNAM);
 481           bfd_flags |= SEC_COFF_SHARED_LIBRARY;
 482           bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
 483         }
 484       else
 485         {
 486           name = (char*) bfd_alloc (abfd, 32);
 487           sprintf (name, "$LOCAL_%03d$", section_count++);
 488         }
 489
 490       section = bfd_make_section (abfd, name);
 491
 492       if (!section)
 493         return -1;
 494
 495       section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : (unsigned int)-1;
 496       section->size = size;
 497       section->vma = vaddr;
 498
 499       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 500         return -1;
 501     }
 502
 503   return 0;
 504 }
 505
 506 /* Read & process IHS/EIHS record
 507    return 0 on success, -1 on error  */
 508 int
 509 _bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset)
 510 {
 511   unsigned char *p = PRIV (vms_rec) + offset;
 512   unsigned int gstvbn = bfd_getl32 (p + EIHS_S_L_GSTVBN);
 513   unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS_S_L_GSTSIZE);
 514   unsigned int dstvbn = bfd_getl32 (p + EIHS_S_L_DSTVBN);
 515   unsigned int dstsize = bfd_getl32 (p + EIHS_S_L_DSTSIZE);
 516   unsigned int dmtvbn = bfd_getl32 (p + EIHS_S_L_DMTVBN);
 517   unsigned int dmtbytes = bfd_getl32 (p + EIHS_S_L_DMTBYTES);
 518   asection *section;
 519
 520 #if VMS_DEBUG
 521   vms_debug (8, "_bfd_vms_slurp_ihs\n");
 522   vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
 523              gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
 524 #endif
 525
 526   if (dstvbn)
 527     {
 528       flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
 529
 530       section = bfd_make_section (abfd, "$DST$");
 531       if (!section)
 532         return -1;
 533
 534       section->size = dstsize;
 535       section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
 536
 537       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 538         return -1;
 539
 540       PRIV (dst_section) = section;
 541       abfd->flags |= (HAS_DEBUG | HAS_LINENO);
 542     }
 543
 544   if (dmtvbn)
 545     {
 546       flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
 547
 548       section = bfd_make_section (abfd, "$DMT$");
 549       if (!section)
 550         return -1;
 551
 552       section->size = dmtbytes;
 553       section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
 554
 555       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 556         return -1;
 557     }
 558
 559   if (gstvbn)
 560     {
 561       flagword bfd_flags = SEC_HAS_CONTENTS;
 562
 563       section = bfd_make_section (abfd, "$GST$");
 564       if (!section)
 565         return -1;
 566
 567       if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
 568         {
 569           bfd_set_error (bfd_error_file_truncated);
 570           return -1;
 571         }
 572
 573       if (_bfd_vms_slurp_object_records (abfd) != 0)
 574         return -1;
 575
 576       section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
 577       section->size = bfd_tell (abfd) - section->filepos;
 578
 579       if (!bfd_set_section_flags (abfd, section, bfd_flags))
 580         return -1;
 581
 582       abfd->flags |= HAS_SYMS;
 583     }
 584
 585   return 0;
 586 }
 587
 588 /* Build a new module for the specified BFD.  */
 589
 590 static struct module *
 591 new_module (bfd *abfd)
 592 {
 593   struct module *module
 594     = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
 595   module->file_table_count = 16; /* Arbitrary.  */
 596   module->file_table
 597     = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
 598   return module;
 599 }
 600
 601 /* Parse debug info for a module and internalize it.  */
 602
 603 static void
 604 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
 605               unsigned int length)
 606 {
 607   unsigned char *maxptr = ptr + length, *src_ptr, *pcl_ptr;
 608   unsigned int prev_linum = 0, curr_linenum = 0;
 609   bfd_vma prev_pc = 0, curr_pc = 0;
 610   struct srecinfo *curr_srec, *srec;
 611   struct lineinfo *curr_line, *line;
 612   struct funcinfo *funcinfo;
 613
 614   /* Initialize tables with zero element.  */
 615   curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
 616   module->srec_table = curr_srec;
 617
 618   curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
 619   module->line_table = curr_line;
 620
 621   while (ptr < maxptr)
 622     {
 623       /* The first byte is not counted in the recorded length.  */
 624       int rec_length = bfd_getl16 (ptr) + 1;
 625       int rec_type = bfd_getl16 (ptr + 2);
 626
 627 #if VMS_DEBUG
 628       _bfd_vms_debug (2, "DST record: length %d, type %d\n",
 629                       rec_length, rec_type);
 630 #endif
 631
 632       switch (rec_type)
 633         {
 634         case DST_S_C_MODBEG:
 635           module->name
 636             = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
 637
 638           curr_pc = 0;
 639           prev_pc = 0;
 640           curr_linenum = 0;
 641           prev_linum = 0;
 642
 643 #if VMS_DEBUG
 644           _bfd_vms_debug (3, "module: %s\n", module->name);
 645 #endif
 646           break;
 647
 648         case DST_S_C_MODEND:
 649 #if VMS_DEBUG
 650           _bfd_vms_debug (3, "end module\n");
 651 #endif
 652           break;
 653
 654         case DST_S_C_RTNBEG:
 655           funcinfo = (struct funcinfo *)
 656             bfd_zalloc (abfd, sizeof (struct funcinfo));
 657           funcinfo->name
 658             = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
 659           funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
 660           funcinfo->next = module->func_table;
 661           module->func_table = funcinfo;
 662
 663 #if VMS_DEBUG
 664           _bfd_vms_debug (3, "routine: %s at 0x%x\n",
 665                           funcinfo->name, funcinfo->low);
 666 #endif
 667           break;
 668
 669         case DST_S_C_RTNEND:
 670           module->func_table->high = module->func_table->low
 671             + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
 672
 673           if (module->func_table->high > module->high)
 674             module->high = module->func_table->high;
 675
 676 #if VMS_DEBUG
 677           _bfd_vms_debug (3, "end routine\n");
 678 #endif
 679           break;
 680
 681         case DST_S_C_PROLOG:
 682 #if VMS_DEBUG
 683           _bfd_vms_debug (3, "prologue\n");
 684 #endif
 685           break;
 686
 687         case DST_S_C_EPILOG:
 688 #if VMS_DEBUG
 689           _bfd_vms_debug (3, "epilog\n");
 690 #endif
 691           break;
 692
 693         case DST_S_C_BLKBEG:
 694 #if VMS_DEBUG
 695           _bfd_vms_debug (3, "block\n");
 696 #endif
 697           break;
 698
 699         case DST_S_C_BLKEND:
 700 #if VMS_DEBUG
 701           _bfd_vms_debug (3, "end block\n");
 702 #endif
 703           break;
 704
 705         case DST_S_C_SOURCE:
 706           src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
 707
 708 #if VMS_DEBUG
 709           _bfd_vms_debug (3, "source info\n");
 710 #endif
 711
 712           while (src_ptr < ptr + rec_length)
 713             {
 714               int cmd = src_ptr[0], cmd_length, data;
 715
 716               switch (cmd)
 717                 {
 718                 case DST_S_C_SRC_DECLFILE:
 719                   {
 720                     unsigned int fileid
 721                       = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
 722                     char *filename
 723                       = _bfd_vms_save_counted_string (src_ptr
 724                           + DST_S_B_SRC_DF_FILENAME);
 725
 726                     while (fileid >= module->file_table_count)
 727                       {
 728                         module->file_table_count *= 2;
 729                         module->file_table
 730                           = bfd_realloc (module->file_table,
 731                                          module->file_table_count
 732                                            * sizeof (struct fileinfo));
 733                       }
 734
 735                     module->file_table [fileid].name = filename;
 736                     module->file_table [fileid].srec = 1;
 737                     cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
 738 #if VMS_DEBUG
 739                     _bfd_vms_debug (4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
 740                                     fileid,
 741                                     module->file_table [fileid].name);
 742 #endif
 743                   }
 744                   break;
 745
 746                 case DST_S_C_SRC_DEFLINES_B:
 747                   /* Perform the association and set the next higher index
 748                      to the limit.  */
 749                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
 750                   srec = (struct srecinfo *)
 751                     bfd_zalloc (abfd, sizeof (struct srecinfo));
 752                   srec->line = curr_srec->line + data;
 753                   srec->srec = curr_srec->srec + data;
 754                   srec->sfile = curr_srec->sfile;
 755                   curr_srec->next = srec;
 756                   curr_srec = srec;
 757                   cmd_length = 2;
 758 #if VMS_DEBUG
 759                   _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_B: %d\n", data);
 760 #endif
 761                   break;
 762
 763                 case DST_S_C_SRC_DEFLINES_W:
 764                   /* Perform the association and set the next higher index
 765                      to the limit.  */
 766                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 767                   srec = (struct srecinfo *)
 768                     bfd_zalloc (abfd, sizeof (struct srecinfo));
 769                   srec->line = curr_srec->line + data;
 770                   srec->srec = curr_srec->srec + data,
 771                   srec->sfile = curr_srec->sfile;
 772                   curr_srec->next = srec;
 773                   curr_srec = srec;
 774                   cmd_length = 3;
 775 #if VMS_DEBUG
 776                   _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_W: %d\n", data);
 777 #endif
 778                   break;
 779
 780                 case DST_S_C_SRC_INCRLNUM_B:
 781                   data = src_ptr[DST_S_B_SRC_UNSBYTE];
 782                   curr_srec->line += data;
 783                   cmd_length = 2;
 784 #if VMS_DEBUG
 785                   _bfd_vms_debug (4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data);
 786 #endif
 787                   break;
 788
 789                 case DST_S_C_SRC_SETFILE:
 790                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 791                   curr_srec->sfile = data;
 792                   curr_srec->srec = module->file_table[data].srec;
 793                   cmd_length = 3;
 794 #if VMS_DEBUG
 795                   _bfd_vms_debug (4, "DST_S_C_SRC_SETFILE: %d\n", data);
 796 #endif
 797                   break;
 798
 799                 case DST_S_C_SRC_SETLNUM_L:
 800                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
 801                   curr_srec->line = data;
 802                   cmd_length = 5;
 803 #if VMS_DEBUG
 804                   _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_L: %d\n", data);
 805 #endif
 806                   break;
 807
 808                 case DST_S_C_SRC_SETLNUM_W:
 809                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 810                   curr_srec->line = data;
 811                   cmd_length = 3;
 812 #if VMS_DEBUG
 813                   _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_W: %d\n", data);
 814 #endif
 815                   break;
 816
 817                 case DST_S_C_SRC_SETREC_L:
 818                   data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
 819                   curr_srec->srec = data;
 820                   module->file_table[curr_srec->sfile].srec = data;
 821                   cmd_length = 5;
 822 #if VMS_DEBUG
 823                   _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_L: %d\n", data);
 824 #endif
 825                   break;
 826
 827                 case DST_S_C_SRC_SETREC_W:
 828                   data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
 829                   curr_srec->srec = data;
 830                   module->file_table[curr_srec->sfile].srec = data;
 831                   cmd_length = 3;
 832 #if VMS_DEBUG
 833                   _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_W: %d\n", data);
 834 #endif
 835                   break;
 836
 837                 case DST_S_C_SRC_FORMFEED:
 838                   cmd_length = 1;
 839 #if VMS_DEBUG
 840                   _bfd_vms_debug (4, "DST_S_C_SRC_FORMFEED\n");
 841 #endif
 842                   break;
 843
 844                 default:
 845                   (*_bfd_error_handler) (_("unknown source command %d"),
 846                                          cmd);
 847                   cmd_length = 2;
 848                   break;
 849                 }
 850
 851               src_ptr += cmd_length;
 852             }
 853           break;
 854
 855         case DST_S_C_LINE_NUM:
 856           pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
 857
 858 #if VMS_DEBUG
 859           _bfd_vms_debug (3, "line info\n");
 860 #endif
 861
 862           while (pcl_ptr < ptr + rec_length)
 863             {
 864               /* The command byte is signed so we must sign-extend it.  */
 865               int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
 866
 867               switch (cmd)
 868                 {
 869                 case DST_S_C_DELTA_PC_W:
 870                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 871                   curr_pc += data;
 872                   curr_linenum += 1;
 873                   cmd_length = 3;
 874 #if VMS_DEBUG
 875                   _bfd_vms_debug (4, "DST_S_C_DELTA_PC_W: %d\n", data);
 876 #endif
 877                   break;
 878
 879                 case DST_S_C_DELTA_PC_L:
 880                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 881                   curr_pc += data;
 882                   curr_linenum += 1;
 883                   cmd_length = 5;
 884 #if VMS_DEBUG
 885                   _bfd_vms_debug (4, "DST_S_C_DELTA_PC_L: %d\n", data);
 886 #endif
 887                   break;
 888
 889                 case DST_S_C_INCR_LINUM:
 890                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 891                   curr_linenum += data;
 892                   cmd_length = 2;
 893 #if VMS_DEBUG
 894                   _bfd_vms_debug (4, "DST_S_C_INCR_LINUM: %d\n", data);
 895 #endif
 896                   break;
 897
 898                 case DST_S_C_INCR_LINUM_W:
 899                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 900                   curr_linenum += data;
 901                   cmd_length = 3;
 902 #if VMS_DEBUG
 903                   _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_W: %d\n", data);
 904 #endif
 905                   break;
 906
 907                 case DST_S_C_INCR_LINUM_L:
 908                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 909                   curr_linenum += data;
 910                   cmd_length = 5;
 911 #if VMS_DEBUG
 912                   _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_L: %d\n", data);
 913 #endif
 914                   break;
 915
 916                 case DST_S_C_SET_LINUM_INCR:
 917                   (*_bfd_error_handler)
 918                     (_("DST_S_C_SET_LINUM_INCR not implemented"));
 919                   cmd_length = 2;
 920                   break;
 921
 922                 case DST_S_C_SET_LINUM_INCR_W:
 923                   (*_bfd_error_handler)
 924                     (_("DST_S_C_SET_LINUM_INCR_W not implemented"));
 925                   cmd_length = 3;
 926                   break;
 927
 928                 case DST_S_C_RESET_LINUM_INCR:
 929                   (*_bfd_error_handler)
 930                     (_("DST_S_C_RESET_LINUM_INCR not implemented"));
 931                   cmd_length = 1;
 932                   break;
 933
 934                 case DST_S_C_BEG_STMT_MODE:
 935                   (*_bfd_error_handler)
 936                     (_("DST_S_C_BEG_STMT_MODE not implemented"));
 937                   cmd_length = 1;
 938                   break;
 939
 940                 case DST_S_C_END_STMT_MODE:
 941                   (*_bfd_error_handler)
 942                     (_("DST_S_C_END_STMT_MODE not implemented"));
 943                   cmd_length = 1;
 944                   break;
 945
 946                 case DST_S_C_SET_LINUM_B:
 947                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 948                   curr_linenum = data;
 949                   cmd_length = 2;
 950 #if VMS_DEBUG
 951                   _bfd_vms_debug (4, "DST_S_C_SET_LINUM_B: %d\n", data);
 952 #endif
 953                   break;
 954
 955                 case DST_S_C_SET_LINE_NUM:
 956                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
 957                   curr_linenum = data;
 958                   cmd_length = 3;
 959 #if VMS_DEBUG
 960                   _bfd_vms_debug (4, "DST_S_C_SET_LINE_NUM: %d\n", data);
 961 #endif
 962                   break;
 963
 964                 case DST_S_C_SET_LINUM_L:
 965                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
 966                   curr_linenum = data;
 967                   cmd_length = 5;
 968 #if VMS_DEBUG
 969                   _bfd_vms_debug (4, "DST_S_C_SET_LINUM_L: %d\n", data);
 970 #endif
 971                   break;
 972
 973                 case DST_S_C_SET_PC:
 974                   (*_bfd_error_handler)
 975                     (_("DST_S_C_SET_PC not implemented"));
 976                   cmd_length = 2;
 977                   break;
 978
 979                 case DST_S_C_SET_PC_W:
 980                   (*_bfd_error_handler)
 981                     (_("DST_S_C_SET_PC_W not implemented"));
 982                   cmd_length = 3;
 983                   break;
 984
 985                 case DST_S_C_SET_PC_L:
 986                   (*_bfd_error_handler)
 987                     (_("DST_S_C_SET_PC_L not implemented"));
 988                   cmd_length = 5;
 989                   break;
 990
 991                 case DST_S_C_SET_STMTNUM:
 992                   (*_bfd_error_handler)
 993                     (_("DST_S_C_SET_STMTNUM not implemented"));
 994                   cmd_length = 2;
 995                   break;
 996
 997                 case DST_S_C_TERM:
 998                   data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
 999                   curr_pc += data;
1000                   cmd_length = 2;
1001 #if VMS_DEBUG
1002                   _bfd_vms_debug (4, "DST_S_C_TERM: %d\n", data);
1003 #endif
1004                   break;
1005
1006                 case DST_S_C_TERM_W:
1007                   data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
1008                   curr_pc += data;
1009                   cmd_length = 3;
1010 #if VMS_DEBUG
1011                   _bfd_vms_debug (4, "DST_S_C_TERM_W: %d\n", data);
1012 #endif
1013                   break;
1014
1015                 case DST_S_C_TERM_L:
1016                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
1017                   curr_pc += data;
1018                   cmd_length = 5;
1019 #if VMS_DEBUG
1020                   _bfd_vms_debug (4, "DST_S_C_TERM_L: %d\n", data);
1021 #endif
1022                   break;
1023
1024                 case DST_S_C_SET_ABS_PC:
1025                   data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
1026                   curr_pc = data;
1027                   cmd_length = 5;
1028 #if VMS_DEBUG
1029                   _bfd_vms_debug (4, "DST_S_C_SET_ABS_PC: 0x%x\n", data);
1030 #endif
1031                   break;
1032
1033                 default:
1034                   if (cmd <= 0)
1035                     {
1036                       curr_pc -= cmd;
1037                       curr_linenum += 1;
1038                       cmd_length = 1;
1039 #if VMS_DEBUG
1040                       _bfd_vms_debug (4, "bump pc to 0x%llx and line to %d\n",
1041                                       curr_pc, curr_linenum);
1042 #endif
1043                     }
1044                   else
1045                     {
1046                       (*_bfd_error_handler) (_("unknown line command %d"),
1047                                              cmd);
1048                       cmd_length = 2;
1049                     }
1050                   break;
1051                 }
1052
1053               if ((curr_linenum != prev_linum && curr_pc != prev_pc)
1054                   || cmd <= 0
1055                   || cmd == DST_S_C_DELTA_PC_L
1056                   || cmd == DST_S_C_DELTA_PC_W)
1057                 {
1058                   line = (struct lineinfo *)
1059                     bfd_zalloc (abfd, sizeof (struct lineinfo));
1060                   line->address = curr_pc;
1061                   line->line = curr_linenum;
1062
1063                   curr_line->next = line;
1064                   curr_line = line;
1065
1066                   prev_linum = curr_linenum;
1067                   prev_pc = curr_pc;
1068 #if VMS_DEBUG
1069                   _bfd_vms_debug (4, "-> correlate pc 0x%llx with line %d\n",
1070                                   curr_pc, curr_linenum);
1071 #endif
1072                 }
1073
1074               pcl_ptr += cmd_length;
1075             }
1076           break;
1077
1078         case 0x17: /* Undocumented type used by DEC C to declare equates.  */
1079 #if VMS_DEBUG
1080           _bfd_vms_debug (3, "undocumented type 0x17\n");
1081 #endif
1082           break;
1083
1084         default:
1085 #if VMS_DEBUG
1086           _bfd_vms_debug (3, "ignoring record\n");
1087 #endif
1088           break;
1089
1090         }
1091
1092       ptr += rec_length;
1093     }
1094
1095   /* Finalize tables with EOL marker.  */
1096   srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
1097   srec->line = (unsigned int) -1;
1098   srec->srec = (unsigned int) -1;
1099   curr_srec->next = srec;
1100
1101   line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
1102   line->line = (unsigned int) -1;
1103   line->address = (bfd_vma) -1;
1104   curr_line->next = line;
1105
1106   /* Advertise that this module has been parsed.  This is needed
1107      because parsing can be either performed at module creation
1108      or deferred until debug info is consumed.  */
1109   SET_MODULE_PARSED (module);
1110 }
1111
1112 /* Build the list of modules for the specified BFD.  */
1113
1114 static struct module *
1115 build_module_list (bfd *abfd)
1116 {
1117   struct module *module, *list = NULL;
1118   asection *dmt;
1119
1120   if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
1121     {
1122       /* We have a DMT section so this must be an image.  Parse the
1123          section and build the list of modules.  This is sufficient
1124          since we can compute the start address and the end address
1125          of every module from the section contents.  */
1126       bfd_size_type size = bfd_get_section_size (dmt);
1127       unsigned char *ptr, *end;
1128
1129       ptr = (unsigned char *) bfd_alloc (abfd, size);
1130       if (! ptr)
1131         return NULL;
1132
1133       if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
1134         return NULL;
1135
1136 #if VMS_DEBUG
1137       _bfd_vms_debug (2, "DMT\n");
1138 #endif
1139
1140       end = ptr + size;
1141
1142       while (ptr < end)
1143         {
1144           /* Each header declares a module with its start offset and size
1145              of debug info in the DST section, as well as the count of
1146              program sections (i.e. address spans) it contains.  */
1147           int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
1148           int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
1149           int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
1150           ptr += DBG_S_C_DMT_HEADER_SIZE;
1151
1152 #if VMS_DEBUG
1153           _bfd_vms_debug (3, "module: modbeg = %d, size = %d, count = %d\n",
1154                           modbeg, msize, count);
1155 #endif
1156
1157           /* We create a 'module' structure for each program section since
1158              we only support contiguous addresses in a 'module' structure.
1159              As a consequence, the actual debug info in the DST section is
1160              shared and can be parsed multiple times; that doesn't seem to
1161              cause problems in practice.  */
1162           while (count-- > 0)
1163             {
1164               int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
1165               int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
1166               module = new_module (abfd);
1167               module->modbeg = modbeg;
1168               module->size = msize;
1169               module->low = start;
1170               module->high = start + length;
1171               module->next = list;
1172               list = module;
1173               ptr += DBG_S_C_DMT_PSECT_SIZE;
1174
1175 #if VMS_DEBUG
1176               _bfd_vms_debug (4, "section: start = 0x%x, length = %d\n",
1177                               start, length);
1178 #endif
1179             }
1180         }
1181     }
1182   else
1183     {
1184       /* We don't have a DMT section so this must be an object.  Parse
1185          the module right now in order to compute its start address and
1186          end address.  */
1187       module = new_module (abfd);
1188       parse_module (abfd, module, PRIV (dst_section)->contents,
1189                     PRIV (dst_ptr_end) - PRIV (dst_section)->contents);
1190       list = module;
1191     }
1192
1193   return list;
1194 }
1195
1196 /* Calculate and return the name of the source file and the line nearest
1197    to the wanted location in the specified module.  */
1198
1199 static bfd_boolean
1200 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
1201                           const char **file, const char **func,
1202                           unsigned int *line)
1203 {
1204   struct funcinfo *funcinfo;
1205   struct lineinfo *lineinfo;
1206   struct srecinfo *srecinfo;
1207   bfd_boolean ret = FALSE;
1208
1209   /* Parse this module if that was not done at module creation.  */
1210   if (! IS_MODULE_PARSED (module))
1211     {
1212       unsigned int size = module->size;
1213       unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
1214       unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
1215
1216       if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
1217           || bfd_bread (buffer, size, abfd) != size)
1218         {
1219           bfd_set_error (bfd_error_no_debug_section);
1220           return FALSE;
1221         }
1222
1223       parse_module (abfd, module, buffer, size);
1224       free (buffer);
1225     }
1226
1227   /* Find out the function (if any) that contains the address.  */
1228   for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
1229     if (addr >= funcinfo->low && addr <= funcinfo->high)
1230       {
1231         *func = funcinfo->name;
1232         ret = TRUE;
1233         break;
1234       }
1235
1236   /* Find out the source file and the line nearest to the address.  */
1237   for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
1238     if (lineinfo->next && addr < lineinfo->next->address)
1239       {
1240         for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
1241           if (srecinfo->next && lineinfo->line < srecinfo->next->line)
1242             {
1243               if (srecinfo->sfile > 0)
1244                 {
1245                   *file = module->file_table[srecinfo->sfile].name;
1246                   *line = srecinfo->srec + lineinfo->line - srecinfo->line;
1247                 }
1248               else
1249                 {
1250                   *file = module->name;
1251                   *line = lineinfo->line;
1252                 }
1253               return TRUE;
1254             }
1255
1256         break;
1257       }
1258
1259   return ret;
1260 }
1261
1262 /* Provided a BFD, a section and an offset into the section, calculate and
1263    return the name of the source file and the line nearest to the wanted
1264    location.  */
1265
1266 bfd_boolean
1267 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
1268                                 asymbol **symbols ATTRIBUTE_UNUSED,
1269                                 bfd_vma offset, const char **file,
1270                                 const char **func, unsigned int *line)
1271 {
1272   struct module *module;
1273
1274   /* What address are we looking for?  */
1275   bfd_vma addr = section->vma + offset;
1276
1277   *file = NULL;
1278   *func = NULL;
1279   *line = 0;
1280
1281   if (PRIV (dst_section) == NULL)
1282     return FALSE;
1283
1284   if (PRIV (modules) == NULL)
1285     {
1286       PRIV (modules) = build_module_list (abfd);
1287       if (PRIV (modules) == NULL)
1288         return FALSE;
1289     }
1290
1291   for (module = PRIV (modules); module; module = module->next)
1292     if (addr >= module->low && addr <= module->high)
1293       return module_find_nearest_line (abfd, module, addr, file, func, line);
1294
1295   return FALSE;
1296 }
1297
1298 /* Process EDBG/ETBT record.
1299    Return 0 on success, -1 on error  */
1300
1301 static int
1302 vms_slurp_debug (bfd *abfd)
1303 {
1304   if (PRIV (dst_section) == NULL)
1305     {
1306       /* We have no way to find out beforehand how much debug info there
1307          is in an object file, so pick an initial amount and grow it as
1308          needed later.  */
1309       flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC;
1310       asection *section = bfd_make_section (abfd, "$DST$");
1311       if (!section)
1312         return -1;
1313       section->size = 1024;
1314       if (!bfd_set_section_flags (abfd, section, flags))
1315         return -1;
1316       section->contents = ((unsigned char *)
1317                            bfd_zmalloc (section->size));
1318       if (section->contents == NULL)
1319         return -1;
1320       section->filepos = (unsigned int)-1;
1321       PRIV (dst_section) = section;
1322     }
1323
1324   PRIV (image_section) = PRIV (dst_section);
1325   PRIV (image_ptr) = PRIV (dst_section)->contents;
1326
1327   return _bfd_vms_slurp_tir (abfd, EOBJ_S_C_ETIR);
1328 }
1329
1330 /* Process DBG/EDBG record.
1331    Return 0 on success, -1 on error.  */
1332
1333 int
1334 _bfd_vms_slurp_dbg (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
1335 {
1336 #if VMS_DEBUG
1337   _bfd_vms_debug (2, "DBG/EDBG\n");
1338 #endif
1339
1340   abfd->flags |= (HAS_DEBUG | HAS_LINENO);
1341
1342   return vms_slurp_debug (abfd);
1343 }
1344
1345 /* Process TBT/ETBT record.
1346    Return 0 on success, -1 on error.  */
1347
1348 int
1349 _bfd_vms_slurp_tbt (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
1350 {
1351 #if VMS_DEBUG
1352   _bfd_vms_debug (2, "TBT/ETBT\n");
1353 #endif
1354
1355   abfd->flags |= HAS_LINENO;
1356
1357   return vms_slurp_debug (abfd);
1358 }
1359
1360 /* Write DBG/EDBG record.  */
1361
1362 int
1363 _bfd_vms_write_dbg (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
1364 {
1365 #if VMS_DEBUG
1366   _bfd_vms_debug (2, "vms_write_dbg (%p, %d)\n", abfd, objtype);
1367 #endif
1368
1369   return 0;
1370 }
1371
1372 /* Write TBT/ETBT record.  */
1373
1374 int
1375 _bfd_vms_write_tbt (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
1376 {
1377 #if VMS_DEBUG
1378   _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
1379 #endif
1380
1381   return 0;
1382 }