projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add -Wshadow to the gcc command line options used when compiling the binutils.
[deliverable/binutils-gdb.git] / 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 /* Strip path and suffix information. */
241 char *fname, *fout, *fptr;
242
243 fptr = bfd_get_filename (abfd);
244 fname = strdup (fptr);
245
246 /* Strip VMS path. */
247 fout = strrchr (fname, ']');
248 if (fout == NULL)
249 fout = strchr (fname, ':');
250 if (fout != NULL)
251 fout++;
252 else
253 fout = fname;
254
255 /* Strip UNIX path. */
256 fptr = strrchr (fout, '/');
257 if (fptr != NULL)
258 fout = fptr + 1;
259
260 /* Strip suffix. */
261 fptr = strrchr (fout, '.');
262 if (fptr != 0)
263 *fptr = 0;
264
265 /* Convert to upper case and truncate at 31 characters.
266 (VMS object file format restricts module name length to 31). */
267 fptr = fout;
268 while (*fptr != 0)
269 {
270 *fptr = TOUPPER (*fptr);
271 fptr++;
272 if (*fptr == ';' || (fptr - fout) >= 31)
273 *fptr = 0;
274 }
275 _bfd_vms_output_counted (abfd, fout);
276 free (fname);
277 }
278 else
279 _bfd_vms_output_counted (abfd, "NONAME");
280
281 _bfd_vms_output_counted (abfd, BFD_VERSION_STRING);
282 _bfd_vms_output_dump (abfd, get_vms_time_string (), EMH_DATE_LENGTH);
283 _bfd_vms_output_fill (abfd, 0, EMH_DATE_LENGTH);
284 _bfd_vms_output_flush (abfd);
285
286 /* LMN. */
287 _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_LNM);
288 snprintf (version, sizeof (version), "GAS BFD v%s", BFD_VERSION_STRING);
289 _bfd_vms_output_dump (abfd, (unsigned char *)version, strlen (version));
290 _bfd_vms_output_flush (abfd);
291
292 /* SRC. */
293 _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_SRC);
294
295 for (symnum = 0; symnum < abfd->symcount; symnum++)
296 {
297 symbol = abfd->outsymbols[symnum];
298
299 if (symbol->flags & BSF_FILE)
300 {
301 if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
302 {
303 PRIV (flag_hash_long_names) = symbol->name[6] - '0';
304 PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
305
306 if (had_file)
307 break;
308 had_case = 1;
309 continue;
310 }
311
312 _bfd_vms_output_dump (abfd, (unsigned char *) symbol->name,
313 (int) strlen (symbol->name));
314 if (had_case)
315 break;
316 had_file = 1;
317 }
318 }
319
320 if (symnum == abfd->symcount)
321 _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("noname"));
322
323 _bfd_vms_output_flush (abfd);
324
325 /* TTL. */
326 _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_TTL);
327 _bfd_vms_output_dump (abfd, (unsigned char *) STRING_COMMA_LEN ("TTL"));
328 _bfd_vms_output_flush (abfd);
329
330 /* CPR. */
331 _bfd_vms_output_begin (abfd, EOBJ_S_C_EMH, EMH_S_C_CPR);
332 _bfd_vms_output_dump (abfd,
333 (unsigned char *)"GNU BFD ported by Klaus Kämpf 1994-1996",
334 39);
335 _bfd_vms_output_flush (abfd);
336
337 return 0;
338 }
339
340 /* Process EOM/EEOM record
341 return 0 on success, -1 on error. */
342
343 int
344 _bfd_vms_slurp_eom (bfd *abfd, int objtype)
345 {
346 unsigned char *vms_rec;
347
348 #if VMS_DEBUG
349 vms_debug(2, "EOM/EEOM\n");
350 #endif
351
352 vms_rec = PRIV (vms_rec);
353
354 if ((objtype == OBJ_S_C_EOM)
355 || (objtype == OBJ_S_C_EOMW))
356 {
357 }
358 else
359 {
360 PRIV (eom_data).eom_l_total_lps
361 = bfd_getl32 (vms_rec + EEOM_S_L_TOTAL_LPS);
362 PRIV (eom_data).eom_w_comcod = bfd_getl16 (vms_rec + EEOM_S_W_COMCOD);
363 if (PRIV (eom_data).eom_w_comcod > 1)
364 {
365 (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
366 bfd_set_error (bfd_error_bad_value);
367 return -1;
368 }
369 PRIV (eom_data).eom_has_transfer = FALSE;
370 if (PRIV (rec_size) > 10)
371 {
372 PRIV (eom_data).eom_has_transfer = TRUE;
373 PRIV (eom_data).eom_b_tfrflg = vms_rec[EEOM_S_B_TFRFLG];
374 PRIV (eom_data).eom_l_psindx
375 = bfd_getl32 (vms_rec + EEOM_S_L_PSINDX);
376 PRIV (eom_data).eom_l_tfradr
377 = bfd_getl32 (vms_rec + EEOM_S_L_TFRADR);
378
379 abfd->start_address = PRIV (eom_data).eom_l_tfradr;
380 }
381 }
382 return 0;
383 }
384
385 /* Write eom record for bfd abfd. */
386
387 int
388 _bfd_vms_write_eom (bfd *abfd, int objtype)
389 {
390 #if VMS_DEBUG
391 vms_debug (2, "vms_write_eom (%p, %d)\n", abfd, objtype);
392 #endif
393
394 _bfd_vms_output_begin (abfd, objtype, -1);
395 _bfd_vms_output_long (abfd, (unsigned long) (PRIV (vms_linkage_index) >> 1));
396 _bfd_vms_output_byte (abfd, 0); /* Completion code. */
397 _bfd_vms_output_byte (abfd, 0); /* Fill byte. */
398
399 if (bfd_get_start_address (abfd) != (bfd_vma)-1)
400 {
401 asection *section;
402
403 section = bfd_get_section_by_name (abfd, ".link");
404 if (section == 0)
405 {
406 bfd_set_error (bfd_error_nonrepresentable_section);
407 return -1;
408 }
409 _bfd_vms_output_short (abfd, 0);
410 _bfd_vms_output_long (abfd, (unsigned long) (section->index));
411 _bfd_vms_output_long (abfd,
412 (unsigned long) bfd_get_start_address (abfd));
413 _bfd_vms_output_long (abfd, 0);
414 }
415
416 _bfd_vms_output_end (abfd);
417 return 0;
418 }
419
420 /* Read & process IHD/EIHD record.
421 Return 0 on success, -1 on error */
422 int
423 _bfd_vms_slurp_ihd (bfd *abfd, unsigned int *isd_offset,
424 unsigned int *ihs_offset)
425 {
426 unsigned int imgtype, size;
427 bfd_vma symvva;
428
429 #if VMS_DEBUG
430 vms_debug (8, "_bfd_vms_slurp_ihd\n");
431 #endif
432
433 size = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SIZE);
434 imgtype = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_IMGTYPE);
435
436 if (imgtype == EIHD_S_K_EXE)
437 abfd->flags |= EXEC_P;
438
439 symvva = bfd_getl64 (PRIV (vms_rec) + EIHD_S_Q_SYMVVA);
440 if (symvva != 0)
441 {
442 PRIV (symvva) = symvva;
443 abfd->flags |= DYNAMIC;
444 }
445
446 *isd_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_ISDOFF);
447 *ihs_offset = bfd_getl32 (PRIV (vms_rec) + EIHD_S_L_SYMDBGOFF);
448
449 #if VMS_DEBUG
450 vms_debug (4, "EIHD record size %d imgtype %d symvva 0x%llx isd %d ihs %d\n",
451 size, imgtype, symvva, *isd_offset, *ihs_offset);
452 #endif
453
454 return 0;
455 }
456
457 /* Read & process ISD/EISD record
458 return 0 on success, -1 on error */
459
460 int
461 _bfd_vms_slurp_isd (bfd *abfd, unsigned int offset)
462 {
463 int section_count = 0;
464 unsigned char *p;
465 unsigned int rec_size;
466
467 #if VMS_DEBUG
468 vms_debug (8, "_bfd_vms_slurp_isd\n");
469 #endif
470
471 for (p = PRIV (vms_rec) + offset;
472 (rec_size = bfd_getl32 (p + EISD_S_L_EISDSIZE)) != 0;
473 p += rec_size)
474 {
475 unsigned long long vaddr = bfd_getl64 (p + EISD_S_Q_VIR_ADDR);
476 unsigned int size = bfd_getl32 (p + EISD_S_L_SECSIZE);
477 unsigned int flags = bfd_getl32 (p + EISD_S_L_FLAGS);
478 unsigned int vbn = bfd_getl32 (p + EISD_S_L_VBN);
479 char *name = NULL;
480 asection *section;
481 flagword bfd_flags;
482
483 #if VMS_DEBUG
484 vms_debug (4, "EISD record at 0x%x size 0x%x addr 0x%x bfd_flags 0x%x block %d\n",
485 p - PRIV (vms_rec), size, vaddr, flags, vbn);
486 #endif
487
488 /* VMS combines psects from .obj files into isects in the .exe. This
489 process doesn't preserve enough information to reliably determine
490 what's in each section without examining the data. This is
491 especially true of DWARF debug sections. */
492 bfd_flags = SEC_ALLOC;
493
494 if (flags & EISD_S_M_EXE)
495 bfd_flags |= SEC_CODE | SEC_HAS_CONTENTS | SEC_LOAD;
496
497 if (flags & EISD_S_M_NONSHRADR)
498 bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
499
500 if (!(flags & EISD_S_M_WRT))
501 bfd_flags |= SEC_READONLY;
502
503 if (flags & EISD_S_M_DZRO)
504 bfd_flags |= SEC_DATA;
505
506 if (flags & EISD_S_M_FIXUPVEC)
507 bfd_flags |= SEC_DATA | SEC_HAS_CONTENTS | SEC_LOAD;
508
509 if (flags & EISD_S_M_CRF)
510 bfd_flags |= SEC_HAS_CONTENTS | SEC_LOAD;
511
512 if (flags & EISD_S_M_GBL)
513 {
514 name = _bfd_vms_save_counted_string (p + EISD_S_T_GBLNAM);
515 bfd_flags |= SEC_COFF_SHARED_LIBRARY;
516 bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
517 }
518 else
519 {
520 name = (char*) bfd_alloc (abfd, 32);
521 sprintf (name, "$LOCAL_%03d$", section_count++);
522 }
523
524 section = bfd_make_section (abfd, name);
525
526 if (!section)
527 return -1;
528
529 section->filepos = vbn ? VMS_BLOCK_SIZE * (vbn - 1) : (unsigned int)-1;
530 section->size = size;
531 section->vma = vaddr;
532
533 if (!bfd_set_section_flags (abfd, section, bfd_flags))
534 return -1;
535 }
536
537 return 0;
538 }
539
540 /* Read & process IHS/EIHS record
541 return 0 on success, -1 on error */
542 int
543 _bfd_vms_slurp_ihs (bfd *abfd, unsigned int offset)
544 {
545 unsigned char *p = PRIV (vms_rec) + offset;
546 unsigned int gstvbn = bfd_getl32 (p + EIHS_S_L_GSTVBN);
547 unsigned int gstsize ATTRIBUTE_UNUSED = bfd_getl32 (p + EIHS_S_L_GSTSIZE);
548 unsigned int dstvbn = bfd_getl32 (p + EIHS_S_L_DSTVBN);
549 unsigned int dstsize = bfd_getl32 (p + EIHS_S_L_DSTSIZE);
550 unsigned int dmtvbn = bfd_getl32 (p + EIHS_S_L_DMTVBN);
551 unsigned int dmtbytes = bfd_getl32 (p + EIHS_S_L_DMTBYTES);
552 asection *section;
553
554 #if VMS_DEBUG
555 vms_debug (8, "_bfd_vms_slurp_ihs\n");
556 vms_debug (4, "EIHS record gstvbn %d gstsize %d dstvbn %d dstsize %d dmtvbn %d dmtbytes %d\n",
557 gstvbn, gstsize, dstvbn, dstsize, dmtvbn, dmtbytes);
558 #endif
559
560 if (dstvbn)
561 {
562 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
563
564 section = bfd_make_section (abfd, "$DST$");
565 if (!section)
566 return -1;
567
568 section->size = dstsize;
569 section->filepos = VMS_BLOCK_SIZE * (dstvbn - 1);
570
571 if (!bfd_set_section_flags (abfd, section, bfd_flags))
572 return -1;
573
574 PRIV (dst_section) = section;
575 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
576 }
577
578 if (dmtvbn)
579 {
580 flagword bfd_flags = SEC_HAS_CONTENTS | SEC_DEBUGGING;
581
582 section = bfd_make_section (abfd, "$DMT$");
583 if (!section)
584 return -1;
585
586 section->size = dmtbytes;
587 section->filepos = VMS_BLOCK_SIZE * (dmtvbn - 1);
588
589 if (!bfd_set_section_flags (abfd, section, bfd_flags))
590 return -1;
591 }
592
593 if (gstvbn)
594 {
595 flagword bfd_flags = SEC_HAS_CONTENTS;
596
597 section = bfd_make_section (abfd, "$GST$");
598 if (!section)
599 return -1;
600
601 if (bfd_seek (abfd, VMS_BLOCK_SIZE * (gstvbn - 1), SEEK_SET))
602 {
603 bfd_set_error (bfd_error_file_truncated);
604 return -1;
605 }
606
607 if (_bfd_vms_slurp_object_records (abfd) != 0)
608 return -1;
609
610 section->filepos = VMS_BLOCK_SIZE * (gstvbn - 1);
611 section->size = bfd_tell (abfd) - section->filepos;
612
613 if (!bfd_set_section_flags (abfd, section, bfd_flags))
614 return -1;
615
616 abfd->flags |= HAS_SYMS;
617 }
618
619 return 0;
620 }
621
622 /* Build a new module for the specified BFD. */
623
624 static struct module *
625 new_module (bfd *abfd)
626 {
627 struct module *module
628 = (struct module *) bfd_zalloc (abfd, sizeof (struct module));
629 module->file_table_count = 16; /* Arbitrary. */
630 module->file_table
631 = bfd_malloc (module->file_table_count * sizeof (struct fileinfo));
632 return module;
633 }
634
635 /* Parse debug info for a module and internalize it. */
636
637 static void
638 parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
639 unsigned int length)
640 {
641 unsigned char *maxptr = ptr + length, *src_ptr, *pcl_ptr;
642 unsigned int prev_linum = 0, curr_linenum = 0;
643 bfd_vma prev_pc = 0, curr_pc = 0;
644 struct srecinfo *curr_srec, *srec;
645 struct lineinfo *curr_line, *line;
646 struct funcinfo *funcinfo;
647
648 /* Initialize tables with zero element. */
649 curr_srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
650 module->srec_table = curr_srec;
651
652 curr_line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
653 module->line_table = curr_line;
654
655 while (ptr < maxptr)
656 {
657 /* The first byte is not counted in the recorded length. */
658 int rec_length = bfd_getl16 (ptr) + 1;
659 int rec_type = bfd_getl16 (ptr + 2);
660
661 #if VMS_DEBUG
662 _bfd_vms_debug (2, "DST record: length %d, type %d\n",
663 rec_length, rec_type);
664 #endif
665
666 switch (rec_type)
667 {
668 case DST_S_C_MODBEG:
669 module->name
670 = _bfd_vms_save_counted_string (ptr + DST_S_B_MODBEG_NAME);
671
672 curr_pc = 0;
673 prev_pc = 0;
674 curr_linenum = 0;
675 prev_linum = 0;
676
677 #if VMS_DEBUG
678 _bfd_vms_debug (3, "module: %s\n", module->name);
679 #endif
680 break;
681
682 case DST_S_C_MODEND:
683 #if VMS_DEBUG
684 _bfd_vms_debug (3, "end module\n");
685 #endif
686 break;
687
688 case DST_S_C_RTNBEG:
689 funcinfo = (struct funcinfo *)
690 bfd_zalloc (abfd, sizeof (struct funcinfo));
691 funcinfo->name
692 = _bfd_vms_save_counted_string (ptr + DST_S_B_RTNBEG_NAME);
693 funcinfo->low = bfd_getl32 (ptr + DST_S_L_RTNBEG_ADDRESS);
694 funcinfo->next = module->func_table;
695 module->func_table = funcinfo;
696
697 #if VMS_DEBUG
698 _bfd_vms_debug (3, "routine: %s at 0x%x\n",
699 funcinfo->name, funcinfo->low);
700 #endif
701 break;
702
703 case DST_S_C_RTNEND:
704 module->func_table->high = module->func_table->low
705 + bfd_getl32 (ptr + DST_S_L_RTNEND_SIZE) - 1;
706
707 if (module->func_table->high > module->high)
708 module->high = module->func_table->high;
709
710 #if VMS_DEBUG
711 _bfd_vms_debug (3, "end routine\n");
712 #endif
713 break;
714
715 case DST_S_C_PROLOG:
716 #if VMS_DEBUG
717 _bfd_vms_debug (3, "prologue\n");
718 #endif
719 break;
720
721 case DST_S_C_EPILOG:
722 #if VMS_DEBUG
723 _bfd_vms_debug (3, "epilog\n");
724 #endif
725 break;
726
727 case DST_S_C_BLKBEG:
728 #if VMS_DEBUG
729 _bfd_vms_debug (3, "block\n");
730 #endif
731 break;
732
733 case DST_S_C_BLKEND:
734 #if VMS_DEBUG
735 _bfd_vms_debug (3, "end block\n");
736 #endif
737 break;
738
739 case DST_S_C_SOURCE:
740 src_ptr = ptr + DST_S_C_SOURCE_HEADER_SIZE;
741
742 #if VMS_DEBUG
743 _bfd_vms_debug (3, "source info\n");
744 #endif
745
746 while (src_ptr < ptr + rec_length)
747 {
748 int cmd = src_ptr[0], cmd_length, data;
749
750 switch (cmd)
751 {
752 case DST_S_C_SRC_DECLFILE:
753 {
754 unsigned int fileid
755 = bfd_getl16 (src_ptr + DST_S_W_SRC_DF_FILEID);
756 char *filename
757 = _bfd_vms_save_counted_string (src_ptr
758 + DST_S_B_SRC_DF_FILENAME);
759
760 while (fileid >= module->file_table_count)
761 {
762 module->file_table_count *= 2;
763 module->file_table
764 = bfd_realloc (module->file_table,
765 module->file_table_count
766 * sizeof (struct fileinfo));
767 }
768
769 module->file_table [fileid].name = filename;
770 module->file_table [fileid].srec = 1;
771 cmd_length = src_ptr[DST_S_B_SRC_DF_LENGTH] + 2;
772 #if VMS_DEBUG
773 _bfd_vms_debug (4, "DST_S_C_SRC_DECLFILE: %d, %s\n",
774 fileid,
775 module->file_table [fileid].name);
776 #endif
777 }
778 break;
779
780 case DST_S_C_SRC_DEFLINES_B:
781 /* Perform the association and set the next higher index
782 to the limit. */
783 data = src_ptr[DST_S_B_SRC_UNSBYTE];
784 srec = (struct srecinfo *)
785 bfd_zalloc (abfd, sizeof (struct srecinfo));
786 srec->line = curr_srec->line + data;
787 srec->srec = curr_srec->srec + data;
788 srec->sfile = curr_srec->sfile;
789 curr_srec->next = srec;
790 curr_srec = srec;
791 cmd_length = 2;
792 #if VMS_DEBUG
793 _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_B: %d\n", data);
794 #endif
795 break;
796
797 case DST_S_C_SRC_DEFLINES_W:
798 /* Perform the association and set the next higher index
799 to the limit. */
800 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
801 srec = (struct srecinfo *)
802 bfd_zalloc (abfd, sizeof (struct srecinfo));
803 srec->line = curr_srec->line + data;
804 srec->srec = curr_srec->srec + data,
805 srec->sfile = curr_srec->sfile;
806 curr_srec->next = srec;
807 curr_srec = srec;
808 cmd_length = 3;
809 #if VMS_DEBUG
810 _bfd_vms_debug (4, "DST_S_C_SRC_DEFLINES_W: %d\n", data);
811 #endif
812 break;
813
814 case DST_S_C_SRC_INCRLNUM_B:
815 data = src_ptr[DST_S_B_SRC_UNSBYTE];
816 curr_srec->line += data;
817 cmd_length = 2;
818 #if VMS_DEBUG
819 _bfd_vms_debug (4, "DST_S_C_SRC_INCRLNUM_B: %d\n", data);
820 #endif
821 break;
822
823 case DST_S_C_SRC_SETFILE:
824 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
825 curr_srec->sfile = data;
826 curr_srec->srec = module->file_table[data].srec;
827 cmd_length = 3;
828 #if VMS_DEBUG
829 _bfd_vms_debug (4, "DST_S_C_SRC_SETFILE: %d\n", data);
830 #endif
831 break;
832
833 case DST_S_C_SRC_SETLNUM_L:
834 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
835 curr_srec->line = data;
836 cmd_length = 5;
837 #if VMS_DEBUG
838 _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_L: %d\n", data);
839 #endif
840 break;
841
842 case DST_S_C_SRC_SETLNUM_W:
843 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
844 curr_srec->line = data;
845 cmd_length = 3;
846 #if VMS_DEBUG
847 _bfd_vms_debug (4, "DST_S_C_SRC_SETLNUM_W: %d\n", data);
848 #endif
849 break;
850
851 case DST_S_C_SRC_SETREC_L:
852 data = bfd_getl32 (src_ptr + DST_S_L_SRC_UNSLONG);
853 curr_srec->srec = data;
854 module->file_table[curr_srec->sfile].srec = data;
855 cmd_length = 5;
856 #if VMS_DEBUG
857 _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_L: %d\n", data);
858 #endif
859 break;
860
861 case DST_S_C_SRC_SETREC_W:
862 data = bfd_getl16 (src_ptr + DST_S_W_SRC_UNSWORD);
863 curr_srec->srec = data;
864 module->file_table[curr_srec->sfile].srec = data;
865 cmd_length = 3;
866 #if VMS_DEBUG
867 _bfd_vms_debug (4, "DST_S_C_SRC_SETREC_W: %d\n", data);
868 #endif
869 break;
870
871 case DST_S_C_SRC_FORMFEED:
872 cmd_length = 1;
873 #if VMS_DEBUG
874 _bfd_vms_debug (4, "DST_S_C_SRC_FORMFEED\n");
875 #endif
876 break;
877
878 default:
879 (*_bfd_error_handler) (_("unknown source command %d"),
880 cmd);
881 cmd_length = 2;
882 break;
883 }
884
885 src_ptr += cmd_length;
886 }
887 break;
888
889 case DST_S_C_LINE_NUM:
890 pcl_ptr = ptr + DST_S_C_LINE_NUM_HEADER_SIZE;
891
892 #if VMS_DEBUG
893 _bfd_vms_debug (3, "line info\n");
894 #endif
895
896 while (pcl_ptr < ptr + rec_length)
897 {
898 /* The command byte is signed so we must sign-extend it. */
899 int cmd = ((signed char *)pcl_ptr)[0], cmd_length, data;
900
901 switch (cmd)
902 {
903 case DST_S_C_DELTA_PC_W:
904 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
905 curr_pc += data;
906 curr_linenum += 1;
907 cmd_length = 3;
908 #if VMS_DEBUG
909 _bfd_vms_debug (4, "DST_S_C_DELTA_PC_W: %d\n", data);
910 #endif
911 break;
912
913 case DST_S_C_DELTA_PC_L:
914 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
915 curr_pc += data;
916 curr_linenum += 1;
917 cmd_length = 5;
918 #if VMS_DEBUG
919 _bfd_vms_debug (4, "DST_S_C_DELTA_PC_L: %d\n", data);
920 #endif
921 break;
922
923 case DST_S_C_INCR_LINUM:
924 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
925 curr_linenum += data;
926 cmd_length = 2;
927 #if VMS_DEBUG
928 _bfd_vms_debug (4, "DST_S_C_INCR_LINUM: %d\n", data);
929 #endif
930 break;
931
932 case DST_S_C_INCR_LINUM_W:
933 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
934 curr_linenum += data;
935 cmd_length = 3;
936 #if VMS_DEBUG
937 _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_W: %d\n", data);
938 #endif
939 break;
940
941 case DST_S_C_INCR_LINUM_L:
942 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
943 curr_linenum += data;
944 cmd_length = 5;
945 #if VMS_DEBUG
946 _bfd_vms_debug (4, "DST_S_C_INCR_LINUM_L: %d\n", data);
947 #endif
948 break;
949
950 case DST_S_C_SET_LINUM_INCR:
951 (*_bfd_error_handler)
952 (_("DST_S_C_SET_LINUM_INCR not implemented"));
953 cmd_length = 2;
954 break;
955
956 case DST_S_C_SET_LINUM_INCR_W:
957 (*_bfd_error_handler)
958 (_("DST_S_C_SET_LINUM_INCR_W not implemented"));
959 cmd_length = 3;
960 break;
961
962 case DST_S_C_RESET_LINUM_INCR:
963 (*_bfd_error_handler)
964 (_("DST_S_C_RESET_LINUM_INCR not implemented"));
965 cmd_length = 1;
966 break;
967
968 case DST_S_C_BEG_STMT_MODE:
969 (*_bfd_error_handler)
970 (_("DST_S_C_BEG_STMT_MODE not implemented"));
971 cmd_length = 1;
972 break;
973
974 case DST_S_C_END_STMT_MODE:
975 (*_bfd_error_handler)
976 (_("DST_S_C_END_STMT_MODE not implemented"));
977 cmd_length = 1;
978 break;
979
980 case DST_S_C_SET_LINUM_B:
981 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
982 curr_linenum = data;
983 cmd_length = 2;
984 #if VMS_DEBUG
985 _bfd_vms_debug (4, "DST_S_C_SET_LINUM_B: %d\n", data);
986 #endif
987 break;
988
989 case DST_S_C_SET_LINE_NUM:
990 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
991 curr_linenum = data;
992 cmd_length = 3;
993 #if VMS_DEBUG
994 _bfd_vms_debug (4, "DST_S_C_SET_LINE_NUM: %d\n", data);
995 #endif
996 break;
997
998 case DST_S_C_SET_LINUM_L:
999 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
1000 curr_linenum = data;
1001 cmd_length = 5;
1002 #if VMS_DEBUG
1003 _bfd_vms_debug (4, "DST_S_C_SET_LINUM_L: %d\n", data);
1004 #endif
1005 break;
1006
1007 case DST_S_C_SET_PC:
1008 (*_bfd_error_handler)
1009 (_("DST_S_C_SET_PC not implemented"));
1010 cmd_length = 2;
1011 break;
1012
1013 case DST_S_C_SET_PC_W:
1014 (*_bfd_error_handler)
1015 (_("DST_S_C_SET_PC_W not implemented"));
1016 cmd_length = 3;
1017 break;
1018
1019 case DST_S_C_SET_PC_L:
1020 (*_bfd_error_handler)
1021 (_("DST_S_C_SET_PC_L not implemented"));
1022 cmd_length = 5;
1023 break;
1024
1025 case DST_S_C_SET_STMTNUM:
1026 (*_bfd_error_handler)
1027 (_("DST_S_C_SET_STMTNUM not implemented"));
1028 cmd_length = 2;
1029 break;
1030
1031 case DST_S_C_TERM:
1032 data = pcl_ptr[DST_S_B_PCLINE_UNSBYTE];
1033 curr_pc += data;
1034 cmd_length = 2;
1035 #if VMS_DEBUG
1036 _bfd_vms_debug (4, "DST_S_C_TERM: %d\n", data);
1037 #endif
1038 break;
1039
1040 case DST_S_C_TERM_W:
1041 data = bfd_getl16 (pcl_ptr + DST_S_W_PCLINE_UNSWORD);
1042 curr_pc += data;
1043 cmd_length = 3;
1044 #if VMS_DEBUG
1045 _bfd_vms_debug (4, "DST_S_C_TERM_W: %d\n", data);
1046 #endif
1047 break;
1048
1049 case DST_S_C_TERM_L:
1050 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
1051 curr_pc += data;
1052 cmd_length = 5;
1053 #if VMS_DEBUG
1054 _bfd_vms_debug (4, "DST_S_C_TERM_L: %d\n", data);
1055 #endif
1056 break;
1057
1058 case DST_S_C_SET_ABS_PC:
1059 data = bfd_getl32 (pcl_ptr + DST_S_L_PCLINE_UNSLONG);
1060 curr_pc = data;
1061 cmd_length = 5;
1062 #if VMS_DEBUG
1063 _bfd_vms_debug (4, "DST_S_C_SET_ABS_PC: 0x%x\n", data);
1064 #endif
1065 break;
1066
1067 default:
1068 if (cmd <= 0)
1069 {
1070 curr_pc -= cmd;
1071 curr_linenum += 1;
1072 cmd_length = 1;
1073 #if VMS_DEBUG
1074 _bfd_vms_debug (4, "bump pc to 0x%llx and line to %d\n",
1075 curr_pc, curr_linenum);
1076 #endif
1077 }
1078 else
1079 {
1080 (*_bfd_error_handler) (_("unknown line command %d"),
1081 cmd);
1082 cmd_length = 2;
1083 }
1084 break;
1085 }
1086
1087 if ((curr_linenum != prev_linum && curr_pc != prev_pc)
1088 || cmd <= 0
1089 || cmd == DST_S_C_DELTA_PC_L
1090 || cmd == DST_S_C_DELTA_PC_W)
1091 {
1092 line = (struct lineinfo *)
1093 bfd_zalloc (abfd, sizeof (struct lineinfo));
1094 line->address = curr_pc;
1095 line->line = curr_linenum;
1096
1097 curr_line->next = line;
1098 curr_line = line;
1099
1100 prev_linum = curr_linenum;
1101 prev_pc = curr_pc;
1102 #if VMS_DEBUG
1103 _bfd_vms_debug (4, "-> correlate pc 0x%llx with line %d\n",
1104 curr_pc, curr_linenum);
1105 #endif
1106 }
1107
1108 pcl_ptr += cmd_length;
1109 }
1110 break;
1111
1112 case 0x17: /* Undocumented type used by DEC C to declare equates. */
1113 #if VMS_DEBUG
1114 _bfd_vms_debug (3, "undocumented type 0x17\n");
1115 #endif
1116 break;
1117
1118 default:
1119 #if VMS_DEBUG
1120 _bfd_vms_debug (3, "ignoring record\n");
1121 #endif
1122 break;
1123
1124 }
1125
1126 ptr += rec_length;
1127 }
1128
1129 /* Finalize tables with EOL marker. */
1130 srec = (struct srecinfo *) bfd_zalloc (abfd, sizeof (struct srecinfo));
1131 srec->line = (unsigned int) -1;
1132 srec->srec = (unsigned int) -1;
1133 curr_srec->next = srec;
1134
1135 line = (struct lineinfo *) bfd_zalloc (abfd, sizeof (struct lineinfo));
1136 line->line = (unsigned int) -1;
1137 line->address = (bfd_vma) -1;
1138 curr_line->next = line;
1139
1140 /* Advertise that this module has been parsed. This is needed
1141 because parsing can be either performed at module creation
1142 or deferred until debug info is consumed. */
1143 SET_MODULE_PARSED (module);
1144 }
1145
1146 /* Build the list of modules for the specified BFD. */
1147
1148 static struct module *
1149 build_module_list (bfd *abfd)
1150 {
1151 struct module *module, *list = NULL;
1152 asection *dmt;
1153
1154 if ((dmt = bfd_get_section_by_name (abfd, "$DMT$")))
1155 {
1156 /* We have a DMT section so this must be an image. Parse the
1157 section and build the list of modules. This is sufficient
1158 since we can compute the start address and the end address
1159 of every module from the section contents. */
1160 bfd_size_type size = bfd_get_section_size (dmt);
1161 unsigned char *ptr, *end;
1162
1163 ptr = (unsigned char *) bfd_alloc (abfd, size);
1164 if (! ptr)
1165 return NULL;
1166
1167 if (! bfd_get_section_contents (abfd, dmt, ptr, 0, size))
1168 return NULL;
1169
1170 #if VMS_DEBUG
1171 _bfd_vms_debug (2, "DMT\n");
1172 #endif
1173
1174 end = ptr + size;
1175
1176 while (ptr < end)
1177 {
1178 /* Each header declares a module with its start offset and size
1179 of debug info in the DST section, as well as the count of
1180 program sections (i.e. address spans) it contains. */
1181 int modbeg = bfd_getl32 (ptr + DBG_S_L_DMT_MODBEG);
1182 int msize = bfd_getl32 (ptr + DBG_S_L_DST_SIZE);
1183 int count = bfd_getl16 (ptr + DBG_S_W_DMT_PSECT_COUNT);
1184 ptr += DBG_S_C_DMT_HEADER_SIZE;
1185
1186 #if VMS_DEBUG
1187 _bfd_vms_debug (3, "module: modbeg = %d, size = %d, count = %d\n",
1188 modbeg, msize, count);
1189 #endif
1190
1191 /* We create a 'module' structure for each program section since
1192 we only support contiguous addresses in a 'module' structure.
1193 As a consequence, the actual debug info in the DST section is
1194 shared and can be parsed multiple times; that doesn't seem to
1195 cause problems in practice. */
1196 while (count-- > 0)
1197 {
1198 int start = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_START);
1199 int length = bfd_getl32 (ptr + DBG_S_L_DMT_PSECT_LENGTH);
1200 module = new_module (abfd);
1201 module->modbeg = modbeg;
1202 module->size = msize;
1203 module->low = start;
1204 module->high = start + length;
1205 module->next = list;
1206 list = module;
1207 ptr += DBG_S_C_DMT_PSECT_SIZE;
1208
1209 #if VMS_DEBUG
1210 _bfd_vms_debug (4, "section: start = 0x%x, length = %d\n",
1211 start, length);
1212 #endif
1213 }
1214 }
1215 }
1216 else
1217 {
1218 /* We don't have a DMT section so this must be an object. Parse
1219 the module right now in order to compute its start address and
1220 end address. */
1221 module = new_module (abfd);
1222 parse_module (abfd, module, PRIV (dst_section)->contents,
1223 PRIV (dst_ptr_end) - PRIV (dst_section)->contents);
1224 list = module;
1225 }
1226
1227 return list;
1228 }
1229
1230 /* Calculate and return the name of the source file and the line nearest
1231 to the wanted location in the specified module. */
1232
1233 static bfd_boolean
1234 module_find_nearest_line (bfd *abfd, struct module *module, bfd_vma addr,
1235 const char **file, const char **func,
1236 unsigned int *line)
1237 {
1238 struct funcinfo *funcinfo;
1239 struct lineinfo *lineinfo;
1240 struct srecinfo *srecinfo;
1241 bfd_boolean ret = FALSE;
1242
1243 /* Parse this module if that was not done at module creation. */
1244 if (! IS_MODULE_PARSED (module))
1245 {
1246 unsigned int size = module->size;
1247 unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
1248 unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
1249
1250 if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
1251 || bfd_bread (buffer, size, abfd) != size)
1252 {
1253 bfd_set_error (bfd_error_no_debug_section);
1254 return FALSE;
1255 }
1256
1257 parse_module (abfd, module, buffer, size);
1258 free (buffer);
1259 }
1260
1261 /* Find out the function (if any) that contains the address. */
1262 for (funcinfo = module->func_table; funcinfo; funcinfo = funcinfo->next)
1263 if (addr >= funcinfo->low && addr <= funcinfo->high)
1264 {
1265 *func = funcinfo->name;
1266 ret = TRUE;
1267 break;
1268 }
1269
1270 /* Find out the source file and the line nearest to the address. */
1271 for (lineinfo = module->line_table; lineinfo; lineinfo = lineinfo->next)
1272 if (lineinfo->next && addr < lineinfo->next->address)
1273 {
1274 for (srecinfo = module->srec_table; srecinfo; srecinfo = srecinfo->next)
1275 if (srecinfo->next && lineinfo->line < srecinfo->next->line)
1276 {
1277 if (srecinfo->sfile > 0)
1278 {
1279 *file = module->file_table[srecinfo->sfile].name;
1280 *line = srecinfo->srec + lineinfo->line - srecinfo->line;
1281 }
1282 else
1283 {
1284 *file = module->name;
1285 *line = lineinfo->line;
1286 }
1287 return TRUE;
1288 }
1289
1290 break;
1291 }
1292
1293 return ret;
1294 }
1295
1296 /* Provided a BFD, a section and an offset into the section, calculate and
1297 return the name of the source file and the line nearest to the wanted
1298 location. */
1299
1300 bfd_boolean
1301 _bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
1302 asymbol **symbols ATTRIBUTE_UNUSED,
1303 bfd_vma offset, const char **file,
1304 const char **func, unsigned int *line)
1305 {
1306 struct module *module;
1307
1308 /* What address are we looking for? */
1309 bfd_vma addr = section->vma + offset;
1310
1311 *file = NULL;
1312 *func = NULL;
1313 *line = 0;
1314
1315 if (PRIV (dst_section) == NULL)
1316 return FALSE;
1317
1318 if (PRIV (modules) == NULL)
1319 {
1320 PRIV (modules) = build_module_list (abfd);
1321 if (PRIV (modules) == NULL)
1322 return FALSE;
1323 }
1324
1325 for (module = PRIV (modules); module; module = module->next)
1326 if (addr >= module->low && addr <= module->high)
1327 return module_find_nearest_line (abfd, module, addr, file, func, line);
1328
1329 return FALSE;
1330 }
1331
1332 /* Process EDBG/ETBT record.
1333 Return 0 on success, -1 on error */
1334
1335 static int
1336 vms_slurp_debug (bfd *abfd)
1337 {
1338 if (PRIV (dst_section) == NULL)
1339 {
1340 /* We have no way to find out beforehand how much debug info there
1341 is in an object file, so pick an initial amount and grow it as
1342 needed later. */
1343 flagword flags = SEC_HAS_CONTENTS | SEC_DEBUGGING | SEC_RELOC;
1344 asection *section = bfd_make_section (abfd, "$DST$");
1345 if (!section)
1346 return -1;
1347 section->size = 1024;
1348 if (!bfd_set_section_flags (abfd, section, flags))
1349 return -1;
1350 section->contents = ((unsigned char *)
1351 bfd_zmalloc (section->size));
1352 if (section->contents == NULL)
1353 return -1;
1354 section->filepos = (unsigned int)-1;
1355 PRIV (dst_section) = section;
1356 }
1357
1358 PRIV (image_section) = PRIV (dst_section);
1359 PRIV (image_ptr) = PRIV (dst_section)->contents;
1360
1361 return _bfd_vms_slurp_tir (abfd, EOBJ_S_C_ETIR);
1362 }
1363
1364 /* Process DBG/EDBG record.
1365 Return 0 on success, -1 on error. */
1366
1367 int
1368 _bfd_vms_slurp_dbg (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
1369 {
1370 #if VMS_DEBUG
1371 _bfd_vms_debug (2, "DBG/EDBG\n");
1372 #endif
1373
1374 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
1375
1376 return vms_slurp_debug (abfd);
1377 }
1378
1379 /* Process TBT/ETBT record.
1380 Return 0 on success, -1 on error. */
1381
1382 int
1383 _bfd_vms_slurp_tbt (bfd *abfd, int objtype ATTRIBUTE_UNUSED)
1384 {
1385 #if VMS_DEBUG
1386 _bfd_vms_debug (2, "TBT/ETBT\n");
1387 #endif
1388
1389 abfd->flags |= HAS_LINENO;
1390
1391 return vms_slurp_debug (abfd);
1392 }
1393
1394 /* Write DBG/EDBG record. */
1395
1396 int
1397 _bfd_vms_write_dbg (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
1398 {
1399 #if VMS_DEBUG
1400 _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
1401 #endif
1402
1403 return 0;
1404 }
1405
1406 /* Write TBT/ETBT record. */
1407
1408 int
1409 _bfd_vms_write_tbt (bfd *abfd ATTRIBUTE_UNUSED, int objtype ATTRIBUTE_UNUSED)
1410 {
1411 #if VMS_DEBUG
1412 _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
1413 #endif
1414
1415 return 0;
1416 }
GDB Binutils - Deliverables
This page took 0.086227 seconds and 4 git commands to generate.