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