1 /* Output VMS debug format symbol table information from GCC.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Douglas B. Rupp (rupp@gnat.com).
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27
28 #ifdef VMS_DEBUGGING_INFO
29 #include "tree.h"
30 #include "flags.h"
31 #include "rtl.h"
32 #include "output.h"
33 #include "vmsdbg.h"
34 #include "debug.h"
35 #include "langhooks.h"
36 #include "function.h"
37 #include "target.h"
38
39 /* Difference in seconds between the VMS Epoch and the Unix Epoch */
40 static const long long vms_epoch_offset = 3506716800ll;
41
42 /* NOTE: In the comments in this file, many references are made to "Debug
43 Symbol Table". This term is abbreviated as `DST' throughout the remainder
44 of this file. */
45
46 typedef struct dst_line_info_struct *dst_line_info_ref;
47
48 /* Each entry in the line_info_table maintains the file and
49 line number associated with the label generated for that
50 entry. The label gives the PC value associated with
51 the line number entry. */
52 typedef struct dst_line_info_struct
53 {
54 unsigned long dst_file_num;
55 unsigned long dst_line_num;
56 }
57 dst_line_info_entry;
58
59 typedef struct dst_file_info_struct *dst_file_info_ref;
60
61 typedef struct dst_file_info_struct
62 {
63 char *file_name;
64 unsigned int max_line;
65 unsigned int listing_line_start;
66 long long cdt;
67 long ebk;
68 short ffb;
69 char rfo;
70 char flen;
71 }
72 dst_file_info_entry;
73
74 /* How to start an assembler comment. */
75 #ifndef ASM_COMMENT_START
76 #define ASM_COMMENT_START ";#"
77 #endif
78
79 /* Maximum size (in bytes) of an artificially generated label. */
80 #define MAX_ARTIFICIAL_LABEL_BYTES 30
81
82 /* Make sure we know the sizes of the various types debug can describe. These
83 are only defaults. If the sizes are different for your target, you should
84 override these values by defining the appropriate symbols in your tm.h
85 file. */
86 #ifndef PTR_SIZE
87 #define PTR_SIZE 4 /* Must be 32 bits for VMS debug info */
88 #endif
89
90 /* Pointer to a structure of filenames referenced by this compilation unit. */
91 static dst_file_info_ref file_info_table;
92
93 /* Total number of entries in the table (i.e. array) pointed to by
94 `file_info_table'. This is the *total* and includes both used and unused
95 slots. */
96 static unsigned int file_info_table_allocated;
97
98 /* Number of entries in the file_info_table which are actually in use. */
99 static unsigned int file_info_table_in_use;
100
101 /* Size (in elements) of increments by which we may expand the filename
102 table. */
103 #define FILE_TABLE_INCREMENT 64
104
105 static char **func_table;
106 static unsigned int func_table_allocated;
107 static unsigned int func_table_in_use;
108 #define FUNC_TABLE_INCREMENT 256
109
110 /* Local pointer to the name of the main input file. Initialized in
111 avmdbgout_init. */
112 static const char *primary_filename;
113
114 static char *module_producer;
115 static unsigned int module_language;
116
117 /* A pointer to the base of a table that contains line information
118 for each source code line in .text in the compilation unit. */
119 static dst_line_info_ref line_info_table;
120
121 /* Number of elements currently allocated for line_info_table. */
122 static unsigned int line_info_table_allocated;
123
124 /* Number of elements in line_info_table currently in use. */
125 static unsigned int line_info_table_in_use;
126
127 /* Size (in elements) of increments by which we may expand line_info_table. */
128 #define LINE_INFO_TABLE_INCREMENT 1024
129
130 /* Forward declarations for functions defined in this file. */
131 static char *full_name (const char *);
132 static unsigned int lookup_filename (const char *);
133 static void addr_const_to_string (char *, rtx);
134 static int write_debug_header (DST_HEADER *, const char *, int);
135 static int write_debug_addr (char *, const char *, int);
136 static int write_debug_data1 (unsigned int, const char *, int);
137 static int write_debug_data2 (unsigned int, const char *, int);
138 static int write_debug_data4 (unsigned long, const char *, int);
139 static int write_debug_data8 (unsigned long long, const char *, int);
140 static int write_debug_delta4 (char *, char *, const char *, int);
141 static int write_debug_string (char *, const char *, int);
142 static int write_modbeg (int);
143 static int write_modend (int);
144 static int write_rtnbeg (int, int);
145 static int write_rtnend (int, int);
146 static int write_pclines (int);
147 static int write_srccorr (int, dst_file_info_entry, int);
148 static int write_srccorrs (int);
149
150 static void vmsdbgout_init (const char *);
151 static void vmsdbgout_finish (const char *);
152 static void vmsdbgout_define (unsigned int, const char *);
153 static void vmsdbgout_undef (unsigned int, const char *);
154 static void vmsdbgout_start_source_file (unsigned int, const char *);
155 static void vmsdbgout_end_source_file (unsigned int);
156 static void vmsdbgout_begin_block (unsigned int, unsigned int);
157 static void vmsdbgout_end_block (unsigned int, unsigned int);
158 static bool vmsdbgout_ignore_block (tree);
159 static void vmsdbgout_source_line (unsigned int, const char *);
160 static void vmsdbgout_begin_prologue (unsigned int, const char *);
161 static void vmsdbgout_end_prologue (unsigned int, const char *);
162 static void vmsdbgout_end_function (unsigned int);
163 static void vmsdbgout_end_epilogue (unsigned int, const char *);
164 static void vmsdbgout_begin_function (tree);
165 static void vmsdbgout_decl (tree);
166 static void vmsdbgout_global_decl (tree);
167 static void vmsdbgout_abstract_function (tree);
168
169 /* The debug hooks structure. */
170
171 const struct gcc_debug_hooks vmsdbg_debug_hooks
172 = {vmsdbgout_init,
173 vmsdbgout_finish,
174 vmsdbgout_define,
175 vmsdbgout_undef,
176 vmsdbgout_start_source_file,
177 vmsdbgout_end_source_file,
178 vmsdbgout_begin_block,
179 vmsdbgout_end_block,
180 vmsdbgout_ignore_block,
181 vmsdbgout_source_line,
182 vmsdbgout_begin_prologue,
183 vmsdbgout_end_prologue,
184 vmsdbgout_end_epilogue,
185 vmsdbgout_begin_function,
186 vmsdbgout_end_function,
187 vmsdbgout_decl,
188 vmsdbgout_global_decl,
189 debug_nothing_tree, /* deferred_inline_function */
190 vmsdbgout_abstract_function,
191 debug_nothing_rtx, /* label */
192 debug_nothing_int /* handle_pch */
193 };
194
195 /* Definitions of defaults for assembler-dependent names of various
196 pseudo-ops and section names.
197 Theses may be overridden in the tm.h file (if necessary) for a particular
198 assembler. */
199 #ifdef UNALIGNED_SHORT_ASM_OP
200 #undef UNALIGNED_SHORT_ASM_OP
201 #endif
202 #define UNALIGNED_SHORT_ASM_OP ".word"
203
204 #ifdef UNALIGNED_INT_ASM_OP
205 #undef UNALIGNED_INT_ASM_OP
206 #endif
207 #define UNALIGNED_INT_ASM_OP ".long"
208
209 #ifdef UNALIGNED_LONG_ASM_OP
210 #undef UNALIGNED_LONG_ASM_OP
211 #endif
212 #define UNALIGNED_LONG_ASM_OP ".long"
213
214 #ifdef UNALIGNED_DOUBLE_INT_ASM_OP
215 #undef UNALIGNED_DOUBLE_INT_ASM_OP
216 #endif
217 #define UNALIGNED_DOUBLE_INT_ASM_OP ".quad"
218
219 #ifdef ASM_BYTE_OP
220 #undef ASM_BYTE_OP
221 #endif
222 #define ASM_BYTE_OP ".byte"
223
224 #define NUMBYTES(I) ((I) < 256 ? 1 : (I) < 65536 ? 2 : 4)
225
226 #define NUMBYTES0(I) ((I) < 128 ? 0 : (I) < 65536 ? 2 : 4)
227
228 #ifndef UNALIGNED_PTR_ASM_OP
229 #define UNALIGNED_PTR_ASM_OP \
230 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
231 #endif
232
233 #ifndef UNALIGNED_OFFSET_ASM_OP
234 #define UNALIGNED_OFFSET_ASM_OP(OFFSET) \
235 (NUMBYTES(OFFSET) == 4 \
236 ? UNALIGNED_LONG_ASM_OP \
237 : (NUMBYTES(OFFSET) == 2 ? UNALIGNED_SHORT_ASM_OP : ASM_BYTE_OP))
238 #endif
239
240 /* Definitions of defaults for formats and names of various special
241 (artificial) labels which may be generated within this file (when the -g
242 options is used and VMS_DEBUGGING_INFO is in effect. If necessary, these
243 may be overridden from within the tm.h file, but typically, overriding these
244 defaults is unnecessary. */
245
246 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
247
248 #ifndef TEXT_END_LABEL
249 #define TEXT_END_LABEL "Lvetext"
250 #endif
251 #ifndef FUNC_BEGIN_LABEL
252 #define FUNC_BEGIN_LABEL "LVFB"
253 #endif
254 #ifndef FUNC_PROLOG_LABEL
255 #define FUNC_PROLOG_LABEL "LVFP"
256 #endif
257 #ifndef FUNC_END_LABEL
258 #define FUNC_END_LABEL "LVFE"
259 #endif
260 #ifndef BLOCK_BEGIN_LABEL
261 #define BLOCK_BEGIN_LABEL "LVBB"
262 #endif
263 #ifndef BLOCK_END_LABEL
264 #define BLOCK_END_LABEL "LVBE"
265 #endif
266 #ifndef LINE_CODE_LABEL
267 #define LINE_CODE_LABEL "LVM"
268 #endif
269
270 #ifndef ASM_OUTPUT_DEBUG_DELTA2
271 #define ASM_OUTPUT_DEBUG_DELTA2(FILE,LABEL1,LABEL2) \
272 do \
273 { \
274 fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
275 assemble_name (FILE, LABEL1); \
276 fprintf (FILE, "-"); \
277 assemble_name (FILE, LABEL2); \
278 } \
279 while (0)
280 #endif
281
282 #ifndef ASM_OUTPUT_DEBUG_DELTA4
283 #define ASM_OUTPUT_DEBUG_DELTA4(FILE,LABEL1,LABEL2) \
284 do \
285 { \
286 fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
287 assemble_name (FILE, LABEL1); \
288 fprintf (FILE, "-"); \
289 assemble_name (FILE, LABEL2); \
290 } \
291 while (0)
292 #endif
293
294 #ifndef ASM_OUTPUT_DEBUG_ADDR_DELTA
295 #define ASM_OUTPUT_DEBUG_ADDR_DELTA(FILE,LABEL1,LABEL2) \
296 do \
297 { \
298 fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP); \
299 assemble_name (FILE, LABEL1); \
300 fprintf (FILE, "-"); \
301 assemble_name (FILE, LABEL2); \
302 } \
303 while (0)
304 #endif
305
306 #ifndef ASM_OUTPUT_DEBUG_ADDR
307 #define ASM_OUTPUT_DEBUG_ADDR(FILE,LABEL) \
308 do \
309 { \
310 fprintf ((FILE), "\t%s\t", UNALIGNED_PTR_ASM_OP); \
311 assemble_name (FILE, LABEL); \
312 } \
313 while (0)
314 #endif
315
316 #ifndef ASM_OUTPUT_DEBUG_ADDR_CONST
317 #define ASM_OUTPUT_DEBUG_ADDR_CONST(FILE,ADDR) \
318 fprintf ((FILE), "\t%s\t%s", UNALIGNED_PTR_ASM_OP, (ADDR))
319 #endif
320
321 #ifndef ASM_OUTPUT_DEBUG_DATA1
322 #define ASM_OUTPUT_DEBUG_DATA1(FILE,VALUE) \
323 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned char) VALUE)
324 #endif
325
326 #ifndef ASM_OUTPUT_DEBUG_DATA2
327 #define ASM_OUTPUT_DEBUG_DATA2(FILE,VALUE) \
328 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, \
329 (unsigned short) VALUE)
330 #endif
331
332 #ifndef ASM_OUTPUT_DEBUG_DATA4
333 #define ASM_OUTPUT_DEBUG_DATA4(FILE,VALUE) \
334 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (unsigned long) VALUE)
335 #endif
336
337 #ifndef ASM_OUTPUT_DEBUG_DATA
338 #define ASM_OUTPUT_DEBUG_DATA(FILE,VALUE) \
339 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP(VALUE), VALUE)
340 #endif
341
342 #ifndef ASM_OUTPUT_DEBUG_ADDR_DATA
343 #define ASM_OUTPUT_DEBUG_ADDR_DATA(FILE,VALUE) \
344 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_PTR_ASM_OP, \
345 (unsigned long) VALUE)
346 #endif
347
348 #ifndef ASM_OUTPUT_DEBUG_DATA8
349 #define ASM_OUTPUT_DEBUG_DATA8(FILE,VALUE) \
350 fprintf ((FILE), "\t%s\t0x%llx", UNALIGNED_DOUBLE_INT_ASM_OP, \
351 (unsigned long long) VALUE)
352 #endif
353
354 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
355 newline is produced. When flag_verbose_asm is asserted, we add commentary
356 at the end of the line, so we must avoid output of a newline here. */
357 #ifndef ASM_OUTPUT_DEBUG_STRING
358 #define ASM_OUTPUT_DEBUG_STRING(FILE,P) \
359 do \
360 { \
361 register int slen = strlen(P); \
362 register char *p = (P); \
363 register int i; \
364 fprintf (FILE, "\t.ascii \""); \
365 for (i = 0; i < slen; i++) \
366 { \
367 register int c = p[i]; \
368 if (c == '\"' || c == '\\') \
369 putc ('\\', FILE); \
370 if (c >= ' ' && c < 0177) \
371 putc (c, FILE); \
372 else \
373 fprintf (FILE, "\\%o", c); \
374 } \
375 fprintf (FILE, "\""); \
376 } \
377 while (0)
378 #endif
379
380 /* Convert a reference to the assembler name of a C-level name. This
381 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
382 a string rather than writing to a file. */
383 #ifndef ASM_NAME_TO_STRING
384 #define ASM_NAME_TO_STRING(STR, NAME) \
385 do \
386 { \
387 if ((NAME)[0] == '*') \
388 strcpy (STR, NAME+1); \
389 else \
390 strcpy (STR, NAME); \
391 } \
392 while (0)
393 #endif
394
395
396 /* General utility functions. */
397
398 /* Convert an integer constant expression into assembler syntax. Addition and
399 subtraction are the only arithmetic that may appear in these expressions.
400 This is an adaptation of output_addr_const in final.c. Here, the target
401 of the conversion is a string buffer. We can't use output_addr_const
402 directly, because it writes to a file. */
403
404 static void
addr_const_to_string(char * str,rtx x)405 addr_const_to_string (char *str, rtx x)
406 {
407 char buf1[256];
408 char buf2[256];
409
410 restart:
411 str[0] = '\0';
412 switch (GET_CODE (x))
413 {
414 case PC:
415 if (flag_pic)
416 strcat (str, ",");
417 else
418 abort ();
419 break;
420
421 case SYMBOL_REF:
422 ASM_NAME_TO_STRING (buf1, XSTR (x, 0));
423 strcat (str, buf1);
424 break;
425
426 case LABEL_REF:
427 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
428 ASM_NAME_TO_STRING (buf2, buf1);
429 strcat (str, buf2);
430 break;
431
432 case CODE_LABEL:
433 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
434 ASM_NAME_TO_STRING (buf2, buf1);
435 strcat (str, buf2);
436 break;
437
438 case CONST_INT:
439 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
440 strcat (str, buf1);
441 break;
442
443 case CONST:
444 /* This used to output parentheses around the expression, but that does
445 not work on the 386 (either ATT or BSD assembler). */
446 addr_const_to_string (buf1, XEXP (x, 0));
447 strcat (str, buf1);
448 break;
449
450 case CONST_DOUBLE:
451 if (GET_MODE (x) == VOIDmode)
452 {
453 /* We can use %d if the number is one word and positive. */
454 if (CONST_DOUBLE_HIGH (x))
455 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
456 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
457 else if (CONST_DOUBLE_LOW (x) < 0)
458 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
459 else
460 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
461 CONST_DOUBLE_LOW (x));
462 strcat (str, buf1);
463 }
464 else
465 /* We can't handle floating point constants; PRINT_OPERAND must
466 handle them. */
467 output_operand_lossage ("floating constant misused");
468 break;
469
470 case PLUS:
471 /* Some assemblers need integer constants to appear last (eg masm). */
472 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
473 {
474 addr_const_to_string (buf1, XEXP (x, 1));
475 strcat (str, buf1);
476 if (INTVAL (XEXP (x, 0)) >= 0)
477 strcat (str, "+");
478 addr_const_to_string (buf1, XEXP (x, 0));
479 strcat (str, buf1);
480 }
481 else
482 {
483 addr_const_to_string (buf1, XEXP (x, 0));
484 strcat (str, buf1);
485 if (INTVAL (XEXP (x, 1)) >= 0)
486 strcat (str, "+");
487 addr_const_to_string (buf1, XEXP (x, 1));
488 strcat (str, buf1);
489 }
490 break;
491
492 case MINUS:
493 /* Avoid outputting things like x-x or x+5-x, since some assemblers
494 can't handle that. */
495 x = simplify_subtraction (x);
496 if (GET_CODE (x) != MINUS)
497 goto restart;
498
499 addr_const_to_string (buf1, XEXP (x, 0));
500 strcat (str, buf1);
501 strcat (str, "-");
502 if (GET_CODE (XEXP (x, 1)) == CONST_INT
503 && INTVAL (XEXP (x, 1)) < 0)
504 {
505 strcat (str, "(");
506 addr_const_to_string (buf1, XEXP (x, 1));
507 strcat (str, buf1);
508 strcat (str, ")");
509 }
510 else
511 {
512 addr_const_to_string (buf1, XEXP (x, 1));
513 strcat (str, buf1);
514 }
515 break;
516
517 case ZERO_EXTEND:
518 case SIGN_EXTEND:
519 addr_const_to_string (buf1, XEXP (x, 0));
520 strcat (str, buf1);
521 break;
522
523 default:
524 output_operand_lossage ("invalid expression as operand");
525 }
526 }
527
528 /* Output the debug header HEADER. Also output COMMENT if flag_verbose_asm is
529 set. Return the header size. Just return the size if DOSIZEONLY is
530 nonzero. */
531
532 static int
write_debug_header(DST_HEADER * header,const char * comment,int dosizeonly)533 write_debug_header (DST_HEADER *header, const char *comment, int dosizeonly)
534 {
535 if (!dosizeonly)
536 {
537 ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
538 header->dst__header_length.dst_w_length);
539
540 if (flag_verbose_asm)
541 fprintf (asm_out_file, "\t%s record length", ASM_COMMENT_START);
542 fputc ('\n', asm_out_file);
543
544 ASM_OUTPUT_DEBUG_DATA2 (asm_out_file,
545 header->dst__header_type.dst_w_type);
546
547 if (flag_verbose_asm)
548 fprintf (asm_out_file, "\t%s record type (%s)", ASM_COMMENT_START,
549 comment);
550
551 fputc ('\n', asm_out_file);
552 }
553
554 return 4;
555 }
556
557 /* Output the address of SYMBOL. Also output COMMENT if flag_verbose_asm is
558 set. Return the address size. Just return the size if DOSIZEONLY is
559 nonzero. */
560
561 static int
write_debug_addr(char * symbol,const char * comment,int dosizeonly)562 write_debug_addr (char *symbol, const char *comment, int dosizeonly)
563 {
564 if (!dosizeonly)
565 {
566 ASM_OUTPUT_DEBUG_ADDR (asm_out_file, symbol);
567 if (flag_verbose_asm)
568 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
569 fputc ('\n', asm_out_file);
570 }
571
572 return PTR_SIZE;
573 }
574
575 /* Output the single byte DATA1. Also output COMMENT if flag_verbose_asm is
576 set. Return the data size. Just return the size if DOSIZEONLY is
577 nonzero. */
578
579 static int
write_debug_data1(unsigned int data1,const char * comment,int dosizeonly)580 write_debug_data1 (unsigned int data1, const char *comment, int dosizeonly)
581 {
582 if (!dosizeonly)
583 {
584 ASM_OUTPUT_DEBUG_DATA1 (asm_out_file, data1);
585 if (flag_verbose_asm)
586 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
587 fputc ('\n', asm_out_file);
588 }
589
590 return 1;
591 }
592
593 /* Output the single word DATA2. Also output COMMENT if flag_verbose_asm is
594 set. Return the data size. Just return the size if DOSIZEONLY is
595 nonzero. */
596
597 static int
write_debug_data2(unsigned int data2,const char * comment,int dosizeonly)598 write_debug_data2 (unsigned int data2, const char *comment, int dosizeonly)
599 {
600 if (!dosizeonly)
601 {
602 ASM_OUTPUT_DEBUG_DATA2 (asm_out_file, data2);
603 if (flag_verbose_asm)
604 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
605 fputc ('\n', asm_out_file);
606 }
607
608 return 2;
609 }
610
611 /* Output double word DATA4. Also output COMMENT if flag_verbose_asm is set.
612 Return the data size. Just return the size if DOSIZEONLY is nonzero. */
613
614 static int
write_debug_data4(unsigned long data4,const char * comment,int dosizeonly)615 write_debug_data4 (unsigned long data4, const char *comment, int dosizeonly)
616 {
617 if (!dosizeonly)
618 {
619 ASM_OUTPUT_DEBUG_DATA4 (asm_out_file, data4);
620 if (flag_verbose_asm)
621 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
622 fputc ('\n', asm_out_file);
623 }
624
625 return 4;
626 }
627
628 /* Output quad word DATA8. Also output COMMENT if flag_verbose_asm is set.
629 Return the data size. Just return the size if DOSIZEONLY is nonzero. */
630
631 static int
write_debug_data8(unsigned long long data8,const char * comment,int dosizeonly)632 write_debug_data8 (unsigned long long data8, const char *comment,
633 int dosizeonly)
634 {
635 if (!dosizeonly)
636 {
637 ASM_OUTPUT_DEBUG_DATA8 (asm_out_file, data8);
638 if (flag_verbose_asm)
639 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
640 fputc ('\n', asm_out_file);
641 }
642
643 return 8;
644 }
645
646 /* Output the difference between LABEL1 and LABEL2. Also output COMMENT if
647 flag_verbose_asm is set. Return the data size. Just return the size if
648 DOSIZEONLY is nonzero. */
649
650 static int
write_debug_delta4(char * label1,char * label2,const char * comment,int dosizeonly)651 write_debug_delta4 (char *label1, char *label2, const char *comment,
652 int dosizeonly)
653 {
654 if (!dosizeonly)
655 {
656 ASM_OUTPUT_DEBUG_DELTA4 (asm_out_file, label1, label2);
657 if (flag_verbose_asm)
658 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
659 fputc ('\n', asm_out_file);
660 }
661
662 return 4;
663 }
664
665 /* Output a character string STRING. Also write COMMENT if flag_verbose_asm is
666 set. Return the string length. Just return the length if DOSIZEONLY is
667 nonzero. */
668
669 static int
write_debug_string(char * string,const char * comment,int dosizeonly)670 write_debug_string (char *string, const char *comment, int dosizeonly)
671 {
672 if (!dosizeonly)
673 {
674 ASM_OUTPUT_DEBUG_STRING (asm_out_file, string);
675 if (flag_verbose_asm)
676 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, comment);
677 fputc ('\n', asm_out_file);
678 }
679
680 return strlen (string);
681 }
682
683 /* Output a module begin header and return the header size. Just return the
684 size if DOSIZEONLY is nonzero. */
685
686 static int
write_modbeg(int dosizeonly)687 write_modbeg (int dosizeonly)
688 {
689 DST_MODULE_BEGIN modbeg;
690 DST_MB_TRLR mb_trlr;
691 int i;
692 char *module_name, *m;
693 int modnamelen;
694 int prodnamelen;
695 int totsize = 0;
696
697 /* Assumes primary filename has Unix syntax file spec. */
698 module_name = xstrdup (basename ((char *) primary_filename));
699
700 m = strrchr (module_name, '.');
701 if (m)
702 *m = 0;
703
704 modnamelen = strlen (module_name);
705 for (i = 0; i < modnamelen; i++)
706 module_name[i] = TOUPPER (module_name[i]);
707
708 prodnamelen = strlen (module_producer);
709
710 modbeg.dst_a_modbeg_header.dst__header_length.dst_w_length
711 = DST_K_MODBEG_SIZE + modnamelen + DST_K_MB_TRLR_SIZE + prodnamelen - 1;
712 modbeg.dst_a_modbeg_header.dst__header_type.dst_w_type = DST_K_MODBEG;
713 modbeg.dst_b_modbeg_flags.dst_v_modbeg_hide = 0;
714 modbeg.dst_b_modbeg_flags.dst_v_modbeg_version = 1;
715 modbeg.dst_b_modbeg_flags.dst_v_modbeg_unused = 0;
716 modbeg.dst_b_modbeg_unused = 0;
717 modbeg.dst_l_modbeg_language = module_language;
718 modbeg.dst_w_version_major = DST_K_VERSION_MAJOR;
719 modbeg.dst_w_version_minor = DST_K_VERSION_MINOR;
720 modbeg.dst_b_modbeg_name = strlen (module_name);
721
722 mb_trlr.dst_b_compiler = strlen (module_producer);
723
724 totsize += write_debug_header (&modbeg.dst_a_modbeg_header,
725 "modbeg", dosizeonly);
726 totsize += write_debug_data1 (*((char *) &modbeg.dst_b_modbeg_flags),
727 "flags", dosizeonly);
728 totsize += write_debug_data1 (modbeg.dst_b_modbeg_unused,
729 "unused", dosizeonly);
730 totsize += write_debug_data4 (modbeg.dst_l_modbeg_language,
731 "language", dosizeonly);
732 totsize += write_debug_data2 (modbeg.dst_w_version_major,
733 "DST major version", dosizeonly);
734 totsize += write_debug_data2 (modbeg.dst_w_version_minor,
735 "DST minor version", dosizeonly);
736 totsize += write_debug_data1 (modbeg.dst_b_modbeg_name,
737 "length of module name", dosizeonly);
738 totsize += write_debug_string (module_name, "module name", dosizeonly);
739 totsize += write_debug_data1 (mb_trlr.dst_b_compiler,
740 "length of compiler name", dosizeonly);
741 totsize += write_debug_string (module_producer, "compiler name", dosizeonly);
742
743 return totsize;
744 }
745
746 /* Output a module end trailer and return the trailer size. Just return
747 the size if DOSIZEONLY is nonzero. */
748
749 static int
write_modend(int dosizeonly)750 write_modend (int dosizeonly)
751 {
752 DST_MODULE_END modend;
753 int totsize = 0;
754
755 modend.dst_a_modend_header.dst__header_length.dst_w_length
756 = DST_K_MODEND_SIZE - 1;
757 modend.dst_a_modend_header.dst__header_type.dst_w_type = DST_K_MODEND;
758
759 totsize += write_debug_header (&modend.dst_a_modend_header, "modend",
760 dosizeonly);
761
762 return totsize;
763 }
764
765 /* Output a routine begin header routine RTNNUM and return the header size.
766 Just return the size if DOSIZEONLY is nonzero. */
767
768 static int
write_rtnbeg(int rtnnum,int dosizeonly)769 write_rtnbeg (int rtnnum, int dosizeonly)
770 {
771 char *rtnname;
772 int rtnnamelen;
773 char *rtnentryname;
774 int totsize = 0;
775 char label[MAX_ARTIFICIAL_LABEL_BYTES];
776 DST_ROUTINE_BEGIN rtnbeg;
777 DST_PROLOG prolog;
778
779 rtnname = func_table[rtnnum];
780 rtnnamelen = strlen (rtnname);
781 rtnentryname = concat (rtnname, "..en", NULL);
782
783 if (!strcmp (rtnname, "main"))
784 {
785 DST_HEADER header;
786 const char *go = "TRANSFER$BREAK$GO";
787
788 /* This command isn't documented in DSTRECORDS, so it's made to
789 look like what DEC C does */
790
791 /* header size - 1st byte + flag byte + STO_LW size
792 + string count byte + string length */
793 header.dst__header_length.dst_w_length
794 = DST_K_DST_HEADER_SIZE - 1 + 1 + 4 + 1 + strlen (go);
795 header.dst__header_type.dst_w_type = 0x17;
796
797 totsize += write_debug_header (&header, "transfer", dosizeonly);
798
799 /* I think this is a flag byte, but I don't know what this flag means */
800 totsize += write_debug_data1 (0x1, "flags ???", dosizeonly);
801
802 /* Routine Begin PD Address */
803 totsize += write_debug_addr (rtnname, "main procedure descriptor",
804 dosizeonly);
805 totsize += write_debug_data1 (strlen (go), "length of main_name",
806 dosizeonly);
807 totsize += write_debug_string ((char *) go, "main name", dosizeonly);
808 }
809
810 /* The header length never includes the length byte. */
811 rtnbeg.dst_a_rtnbeg_header.dst__header_length.dst_w_length
812 = DST_K_RTNBEG_SIZE + rtnnamelen - 1;
813 rtnbeg.dst_a_rtnbeg_header.dst__header_type.dst_w_type = DST_K_RTNBEG;
814 rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unused = 0;
815 rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_unalloc = 0;
816 rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_prototype = 0;
817 rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_inlined = 0;
818 rtnbeg.dst_b_rtnbeg_flags.dst_v_rtnbeg_no_call = 1;
819 rtnbeg.dst_b_rtnbeg_name = rtnnamelen;
820
821 totsize += write_debug_header (&rtnbeg.dst_a_rtnbeg_header, "rtnbeg",
822 dosizeonly);
823 totsize += write_debug_data1 (*((char *) &rtnbeg.dst_b_rtnbeg_flags),
824 "flags", dosizeonly);
825
826 /* Routine Begin Address */
827 totsize += write_debug_addr (rtnentryname, "routine entry name", dosizeonly);
828
829 /* Routine Begin PD Address */
830 totsize += write_debug_addr (rtnname, "routine procedure descriptor",
831 dosizeonly);
832
833 /* Routine Begin Name */
834 totsize += write_debug_data1 (rtnbeg.dst_b_rtnbeg_name,
835 "length of routine name", dosizeonly);
836
837 totsize += write_debug_string (rtnname, "routine name", dosizeonly);
838
839 free (rtnentryname);
840
841 if (debug_info_level > DINFO_LEVEL_TERSE)
842 {
843 prolog.dst_a_prolog_header.dst__header_length.dst_w_length
844 = DST_K_PROLOG_SIZE - 1;
845 prolog.dst_a_prolog_header.dst__header_type.dst_w_type = DST_K_PROLOG;
846
847 totsize += write_debug_header (&prolog.dst_a_prolog_header, "prolog",
848 dosizeonly);
849
850 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL, rtnnum);
851 totsize += write_debug_addr (label, "prolog breakpoint addr",
852 dosizeonly);
853 }
854
855 return totsize;
856 }
857
858 /* Output a routine end trailer for routine RTNNUM and return the header size.
859 Just return the size if DOSIZEONLY is nonzero. */
860
861 static int
write_rtnend(int rtnnum,int dosizeonly)862 write_rtnend (int rtnnum, int dosizeonly)
863 {
864 DST_ROUTINE_END rtnend;
865 char label1[MAX_ARTIFICIAL_LABEL_BYTES];
866 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
867 int totsize;
868
869 totsize = 0;
870
871 rtnend.dst_a_rtnend_header.dst__header_length.dst_w_length
872 = DST_K_RTNEND_SIZE - 1;
873 rtnend.dst_a_rtnend_header.dst__header_type.dst_w_type = DST_K_RTNEND;
874 rtnend.dst_b_rtnend_unused = 0;
875 rtnend.dst_l_rtnend_size = 0; /* Calculated below. */
876
877 totsize += write_debug_header (&rtnend.dst_a_rtnend_header, "rtnend",
878 dosizeonly);
879 totsize += write_debug_data1 (rtnend.dst_b_rtnend_unused, "unused",
880 dosizeonly);
881
882 ASM_GENERATE_INTERNAL_LABEL (label1, FUNC_BEGIN_LABEL, rtnnum);
883 ASM_GENERATE_INTERNAL_LABEL (label2, FUNC_END_LABEL, rtnnum);
884 totsize += write_debug_delta4 (label2, label1, "routine size", dosizeonly);
885
886 return totsize;
887 }
888
889 #define K_DELTA_PC(I) \
890 ((I) < 128 ? -(I) : (I) < 65536 ? DST_K_DELTA_PC_W : DST_K_DELTA_PC_L)
891
892 #define K_SET_LINUM(I) \
893 ((I) < 256 ? DST_K_SET_LINUM_B \
894 : (I) < 65536 ? DST_K_SET_LINUM : DST_K_SET_LINUM_L)
895
896 #define K_INCR_LINUM(I) \
897 ((I) < 256 ? DST_K_INCR_LINUM \
898 : (I) < 65536 ? DST_K_INCR_LINUM_W : DST_K_INCR_LINUM_L)
899
900 /* Output the PC to line number correlations and return the size. Just return
901 the size if DOSIZEONLY is nonzero */
902
903 static int
write_pclines(int dosizeonly)904 write_pclines (int dosizeonly)
905 {
906 unsigned i;
907 int fn;
908 int ln, lastln;
909 int linestart = 0;
910 int max_line;
911 DST_LINE_NUM_HEADER line_num;
912 DST_PCLINE_COMMANDS pcline;
913 char label[MAX_ARTIFICIAL_LABEL_BYTES];
914 char lastlabel[MAX_ARTIFICIAL_LABEL_BYTES];
915 int totsize = 0;
916 char buff[256];
917
918 max_line = file_info_table[1].max_line;
919 file_info_table[1].listing_line_start = linestart;
920 linestart = linestart + ((max_line / 100000) + 1) * 100000;
921
922 for (i = 2; i < file_info_table_in_use; i++)
923 {
924 max_line = file_info_table[i].max_line;
925 file_info_table[i].listing_line_start = linestart;
926 linestart = linestart + ((max_line / 10000) + 1) * 10000;
927 }
928
929 /* Set starting address to beginning of text section. */
930 line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 8;
931 line_num.dst_a_line_num_header.dst__header_type.dst_w_type = DST_K_LINE_NUM;
932 pcline.dst_b_pcline_command = DST_K_SET_ABS_PC;
933
934 totsize += write_debug_header (&line_num.dst_a_line_num_header,
935 "line_num", dosizeonly);
936 totsize += write_debug_data1 (pcline.dst_b_pcline_command,
937 "line_num (SET ABS PC)", dosizeonly);
938
939 if (dosizeonly)
940 totsize += 4;
941 else
942 {
943 ASM_OUTPUT_DEBUG_ADDR (asm_out_file, TEXT_SECTION_ASM_OP);
944 if (flag_verbose_asm)
945 fprintf (asm_out_file, "\t%s line_num", ASM_COMMENT_START);
946 fputc ('\n', asm_out_file);
947 }
948
949 fn = line_info_table[1].dst_file_num;
950 ln = (file_info_table[fn].listing_line_start
951 + line_info_table[1].dst_line_num);
952 line_num.dst_a_line_num_header.dst__header_length.dst_w_length = 4 + 4;
953 pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
954
955 totsize += write_debug_header (&line_num.dst_a_line_num_header,
956 "line_num", dosizeonly);
957 totsize += write_debug_data1 (pcline.dst_b_pcline_command,
958 "line_num (SET LINUM LONG)", dosizeonly);
959
960 sprintf (buff, "line_num (%d)", ln ? ln - 1 : 0);
961 totsize += write_debug_data4 (ln ? ln - 1 : 0, buff, dosizeonly);
962
963 lastln = ln;
964 strcpy (lastlabel, TEXT_SECTION_ASM_OP);
965 for (i = 1; i < line_info_table_in_use; i++)
966 {
967 int extrabytes;
968
969 fn = line_info_table[i].dst_file_num;
970 ln = (file_info_table[fn].listing_line_start
971 + line_info_table[i].dst_line_num);
972
973 if (ln - lastln > 1)
974 extrabytes = 5; /* NUMBYTES (ln - lastln - 1) + 1; */
975 else if (ln <= lastln)
976 extrabytes = 5; /* NUMBYTES (ln - 1) + 1; */
977 else
978 extrabytes = 0;
979
980 line_num.dst_a_line_num_header.dst__header_length.dst_w_length
981 = 8 + extrabytes;
982
983 totsize += write_debug_header
984 (&line_num.dst_a_line_num_header, "line_num", dosizeonly);
985
986 if (ln - lastln > 1)
987 {
988 int lndif = ln - lastln - 1;
989
990 /* K_INCR_LINUM (lndif); */
991 pcline.dst_b_pcline_command = DST_K_INCR_LINUM_L;
992
993 totsize += write_debug_data1 (pcline.dst_b_pcline_command,
994 "line_num (INCR LINUM LONG)",
995 dosizeonly);
996
997 sprintf (buff, "line_num (%d)", lndif);
998 totsize += write_debug_data4 (lndif, buff, dosizeonly);
999 }
1000 else if (ln <= lastln)
1001 {
1002 /* K_SET_LINUM (ln-1); */
1003 pcline.dst_b_pcline_command = DST_K_SET_LINUM_L;
1004
1005 totsize += write_debug_data1 (pcline.dst_b_pcline_command,
1006 "line_num (SET LINUM LONG)",
1007 dosizeonly);
1008
1009 sprintf (buff, "line_num (%d)", ln - 1);
1010 totsize += write_debug_data4 (ln - 1, buff, dosizeonly);
1011 }
1012
1013 pcline.dst_b_pcline_command = DST_K_DELTA_PC_L;
1014
1015 totsize += write_debug_data1 (pcline.dst_b_pcline_command,
1016 "line_num (DELTA PC LONG)", dosizeonly);
1017
1018 ASM_GENERATE_INTERNAL_LABEL (label, LINE_CODE_LABEL, i);
1019 totsize += write_debug_delta4 (label, lastlabel, "increment line_num",
1020 dosizeonly);
1021
1022 lastln = ln;
1023 strcpy (lastlabel, label);
1024 }
1025
1026 return totsize;
1027 }
1028
1029 /* Output a source correlation for file FILEID using information saved in
1030 FILE_INFO_ENTRY and return the size. Just return the size if DOSIZEONLY is
1031 nonzero. */
1032
1033 static int
write_srccorr(int fileid,dst_file_info_entry file_info_entry,int dosizeonly)1034 write_srccorr (int fileid, dst_file_info_entry file_info_entry,
1035 int dosizeonly)
1036 {
1037 int src_command_size;
1038 int linesleft = file_info_entry.max_line;
1039 int linestart = file_info_entry.listing_line_start;
1040 int flen = file_info_entry.flen;
1041 int linestodo = 0;
1042 DST_SOURCE_CORR src_header;
1043 DST_SRC_COMMAND src_command;
1044 DST_SRC_COMMAND src_command_sf;
1045 DST_SRC_COMMAND src_command_sl;
1046 DST_SRC_COMMAND src_command_sr;
1047 DST_SRC_COMMAND src_command_dl;
1048 DST_SRC_CMDTRLR src_cmdtrlr;
1049 char buff[256];
1050 int totsize = 0;
1051
1052 if (fileid == 1)
1053 {
1054 src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1055 = DST_K_SOURCE_CORR_HEADER_SIZE + 1 - 1;
1056 src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1057 = DST_K_SOURCE;
1058 src_command.dst_b_src_command = DST_K_SRC_FORMFEED;
1059
1060 totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1061 "source corr", dosizeonly);
1062
1063 totsize += write_debug_data1 (src_command.dst_b_src_command,
1064 "source_corr (SRC FORMFEED)",
1065 dosizeonly);
1066 }
1067
1068 src_command_size
1069 = DST_K_SRC_COMMAND_SIZE + flen + DST_K_SRC_CMDTRLR_SIZE;
1070 src_command.dst_b_src_command = DST_K_SRC_DECLFILE;
1071 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length
1072 = src_command_size - 2;
1073 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags = 0;
1074 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid
1075 = fileid;
1076 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt
1077 = file_info_entry.cdt;
1078 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk
1079 = file_info_entry.ebk;
1080 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb
1081 = file_info_entry.ffb;
1082 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo
1083 = file_info_entry.rfo;
1084 src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename
1085 = file_info_entry.flen;
1086
1087 src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1088 = DST_K_SOURCE_CORR_HEADER_SIZE + src_command_size - 1;
1089 src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1090 = DST_K_SOURCE;
1091
1092 src_cmdtrlr.dst_b_src_df_libmodname = 0;
1093
1094 totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1095 "source corr", dosizeonly);
1096 totsize += write_debug_data1 (src_command.dst_b_src_command,
1097 "source_corr (DECL SRC FILE)", dosizeonly);
1098 totsize += write_debug_data1
1099 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_length,
1100 "source_corr (length)", dosizeonly);
1101
1102 totsize += write_debug_data1
1103 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_flags,
1104 "source_corr (flags)", dosizeonly);
1105
1106 totsize += write_debug_data2
1107 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_fileid,
1108 "source_corr (fileid)", dosizeonly);
1109
1110 totsize += write_debug_data8
1111 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_q_src_df_rms_cdt,
1112 "source_corr (creation date)", dosizeonly);
1113
1114 totsize += write_debug_data4
1115 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_l_src_df_rms_ebk,
1116 "source_corr (EOF block number)", dosizeonly);
1117
1118 totsize += write_debug_data2
1119 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_w_src_df_rms_ffb,
1120 "source_corr (first free byte)", dosizeonly);
1121
1122 totsize += write_debug_data1
1123 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_rms_rfo,
1124 "source_corr (record and file organization)", dosizeonly);
1125
1126 totsize += write_debug_data1
1127 (src_command.dst_a_src_cmd_fields.dst_a_src_decl_src.dst_b_src_df_filename,
1128 "source_corr (filename length)", dosizeonly);
1129
1130 totsize += write_debug_string (file_info_entry.file_name,
1131 "source file name", dosizeonly);
1132 totsize += write_debug_data1 (src_cmdtrlr.dst_b_src_df_libmodname,
1133 "source_corr (libmodname)", dosizeonly);
1134
1135 src_command_sf.dst_b_src_command = DST_K_SRC_SETFILE;
1136 src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword = fileid;
1137
1138 src_command_sr.dst_b_src_command = DST_K_SRC_SETREC_W;
1139 src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword = 1;
1140
1141 src_command_sl.dst_b_src_command = DST_K_SRC_SETLNUM_L;
1142 src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong = linestart + 1;
1143
1144 src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
1145
1146 if (linesleft > 65534)
1147 linesleft = linesleft - 65534, linestodo = 65534;
1148 else
1149 linestodo = linesleft, linesleft = 0;
1150
1151 src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
1152
1153 src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1154 = DST_K_SOURCE_CORR_HEADER_SIZE + 3 + 3 + 5 + 3 - 1;
1155 src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1156 = DST_K_SOURCE;
1157
1158 if (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword)
1159 {
1160 totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1161 "source corr", dosizeonly);
1162
1163 totsize += write_debug_data1 (src_command_sf.dst_b_src_command,
1164 "source_corr (src setfile)", dosizeonly);
1165
1166 totsize += write_debug_data2
1167 (src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword,
1168 "source_corr (fileid)", dosizeonly);
1169
1170 totsize += write_debug_data1 (src_command_sr.dst_b_src_command,
1171 "source_corr (setrec)", dosizeonly);
1172
1173 totsize += write_debug_data2
1174 (src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword,
1175 "source_corr (recnum)", dosizeonly);
1176
1177 totsize += write_debug_data1 (src_command_sl.dst_b_src_command,
1178 "source_corr (setlnum)", dosizeonly);
1179
1180 totsize += write_debug_data4
1181 (src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong,
1182 "source_corr (linenum)", dosizeonly);
1183
1184 totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
1185 "source_corr (deflines)", dosizeonly);
1186
1187 sprintf (buff, "source_corr (%d)",
1188 src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
1189 totsize += write_debug_data2
1190 (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
1191 buff, dosizeonly);
1192
1193 while (linesleft > 0)
1194 {
1195 src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1196 = DST_K_SOURCE_CORR_HEADER_SIZE + 3 - 1;
1197 src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1198 = DST_K_SOURCE;
1199 src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
1200
1201 if (linesleft > 65534)
1202 linesleft = linesleft - 65534, linestodo = 65534;
1203 else
1204 linestodo = linesleft, linesleft = 0;
1205
1206 src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
1207
1208 totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1209 "source corr", dosizeonly);
1210 totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
1211 "source_corr (deflines)", dosizeonly);
1212 sprintf (buff, "source_corr (%d)",
1213 src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
1214 totsize += write_debug_data2
1215 (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
1216 buff, dosizeonly);
1217 }
1218 }
1219
1220 return totsize;
1221 }
1222
1223 /* Output all the source correlation entries and return the size. Just return
1224 the size if DOSIZEONLY is nonzero. */
1225
1226 static int
write_srccorrs(int dosizeonly)1227 write_srccorrs (int dosizeonly)
1228 {
1229 unsigned int i;
1230 int totsize = 0;
1231
1232 for (i = 1; i < file_info_table_in_use; i++)
1233 totsize += write_srccorr (i, file_info_table[i], dosizeonly);
1234
1235 return totsize;
1236 }
1237
1238 /* Output a marker (i.e. a label) for the beginning of a function, before
1239 the prologue. */
1240
1241 static void
vmsdbgout_begin_prologue(unsigned int line,const char * file)1242 vmsdbgout_begin_prologue (unsigned int line, const char *file)
1243 {
1244 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1245
1246 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1247 (*dwarf2_debug_hooks.begin_prologue) (line, file);
1248
1249 if (debug_info_level > DINFO_LEVEL_NONE)
1250 {
1251 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1252 current_function_funcdef_no);
1253 ASM_OUTPUT_LABEL (asm_out_file, label);
1254 }
1255 }
1256
1257 /* Output a marker (i.e. a label) for the beginning of a function, after
1258 the prologue. */
1259
1260 static void
vmsdbgout_end_prologue(unsigned int line,const char * file)1261 vmsdbgout_end_prologue (unsigned int line, const char *file)
1262 {
1263 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1264
1265 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1266 (*dwarf2_debug_hooks.end_prologue) (line, file);
1267
1268 if (debug_info_level > DINFO_LEVEL_TERSE)
1269 {
1270 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL,
1271 current_function_funcdef_no);
1272 ASM_OUTPUT_LABEL (asm_out_file, label);
1273
1274 /* VMS PCA expects every PC range to correlate to some line and file. */
1275 vmsdbgout_source_line (line, file);
1276 }
1277 }
1278
1279 /* No output for VMS debug, but make obligatory call to Dwarf2 debug */
1280
1281 static void
vmsdbgout_end_function(unsigned int line)1282 vmsdbgout_end_function (unsigned int line)
1283 {
1284 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1285 (*dwarf2_debug_hooks.end_function) (line);
1286 }
1287
1288 /* Output a marker (i.e. a label) for the absolute end of the generated code
1289 for a function definition. This gets called *after* the epilogue code has
1290 been generated. */
1291
1292 static void
vmsdbgout_end_epilogue(unsigned int line,const char * file)1293 vmsdbgout_end_epilogue (unsigned int line, const char *file)
1294 {
1295 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1296
1297 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1298 (*dwarf2_debug_hooks.end_epilogue) (line, file);
1299
1300 if (debug_info_level > DINFO_LEVEL_NONE)
1301 {
1302 /* Output a label to mark the endpoint of the code generated for this
1303 function. */
1304 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1305 current_function_funcdef_no);
1306 ASM_OUTPUT_LABEL (asm_out_file, label);
1307
1308 /* VMS PCA expects every PC range to correlate to some line and file. */
1309 vmsdbgout_source_line (line, file);
1310 }
1311 }
1312
1313 /* Output a marker (i.e. a label) for the beginning of the generated code for
1314 a lexical block. */
1315
1316 static void
vmsdbgout_begin_block(register unsigned line,register unsigned blocknum)1317 vmsdbgout_begin_block (register unsigned line, register unsigned blocknum)
1318 {
1319 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1320 (*dwarf2_debug_hooks.begin_block) (line, blocknum);
1321
1322 if (debug_info_level > DINFO_LEVEL_TERSE)
1323 (*targetm.asm_out.internal_label) (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
1324 }
1325
1326 /* Output a marker (i.e. a label) for the end of the generated code for a
1327 lexical block. */
1328
1329 static void
vmsdbgout_end_block(register unsigned line,register unsigned blocknum)1330 vmsdbgout_end_block (register unsigned line, register unsigned blocknum)
1331 {
1332 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1333 (*dwarf2_debug_hooks.end_block) (line, blocknum);
1334
1335 if (debug_info_level > DINFO_LEVEL_TERSE)
1336 (*targetm.asm_out.internal_label) (asm_out_file, BLOCK_END_LABEL, blocknum);
1337 }
1338
1339 /* Not implemented in VMS Debug. */
1340
1341 static bool
vmsdbgout_ignore_block(tree block)1342 vmsdbgout_ignore_block (tree block)
1343 {
1344 bool retval = 0;
1345
1346 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1347 retval = (*dwarf2_debug_hooks.ignore_block) (block);
1348
1349 return retval;
1350 }
1351
1352 /* Add an entry for function DECL into the func_table. */
1353
1354 static void
vmsdbgout_begin_function(tree decl)1355 vmsdbgout_begin_function (tree decl)
1356 {
1357 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1358
1359 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1360 (*dwarf2_debug_hooks.begin_function) (decl);
1361
1362 if (func_table_in_use == func_table_allocated)
1363 {
1364 func_table_allocated += FUNC_TABLE_INCREMENT;
1365 func_table = xrealloc (func_table,
1366 func_table_allocated * sizeof (char *));
1367 }
1368
1369 /* Add the new entry to the end of the function name table. */
1370 func_table[func_table_in_use++] = xstrdup (name);
1371 }
1372
1373 static char fullname_buff [4096];
1374
1375 /* Return the full file specification for FILENAME. The specification must be
1376 in VMS syntax in order to be processed by VMS Debug. */
1377
1378 static char *
full_name(const char * filename)1379 full_name (const char *filename)
1380 {
1381 #ifdef VMS
1382 FILE *fp = fopen (filename, "r");
1383
1384 fgetname (fp, fullname_buff, 1);
1385 fclose (fp);
1386 #else
1387 getcwd (fullname_buff, sizeof (fullname_buff));
1388
1389 strcat (fullname_buff, "/");
1390 strcat (fullname_buff, filename);
1391
1392 /* ??? Insert hairy code here to translate Unix style file specification
1393 to VMS style. */
1394 #endif
1395
1396 return fullname_buff;
1397 }
1398
1399 /* Lookup a filename (in the list of filenames that we know about here in
1400 vmsdbgout.c) and return its "index". The index of each (known) filename is
1401 just a unique number which is associated with only that one filename. We
1402 need such numbers for the sake of generating labels and references
1403 to those files numbers. If the filename given as an argument is not
1404 found in our current list, add it to the list and assign it the next
1405 available unique index number. In order to speed up searches, we remember
1406 the index of the filename was looked up last. This handles the majority of
1407 all searches. */
1408
1409 static unsigned int
lookup_filename(const char * file_name)1410 lookup_filename (const char *file_name)
1411 {
1412 static unsigned int last_file_lookup_index = 0;
1413 register char *fn;
1414 register unsigned i;
1415 char *fnam;
1416 long long cdt;
1417 long ebk;
1418 short ffb;
1419 char rfo;
1420 char flen;
1421 struct stat statbuf;
1422
1423 if (stat (file_name, &statbuf) == 0)
1424 {
1425 long gmtoff;
1426 #ifdef VMS
1427 struct tm *ts;
1428
1429 /* Adjust for GMT. */
1430 ts = (struct tm *) localtime (&statbuf.st_ctime);
1431 gmtoff = ts->tm_gmtoff;
1432
1433 /* VMS has multiple file format types. */
1434 rfo = statbuf.st_fab_rfm;
1435 #else
1436 /* Is GMT adjustment an issue with a cross-compiler? */
1437 gmtoff = 0;
1438
1439 /* Assume stream LF type file. */
1440 rfo = 2;
1441 #endif
1442 cdt = 10000000 * (statbuf.st_ctime + gmtoff + vms_epoch_offset);
1443 ebk = statbuf.st_size / 512 + 1;
1444 ffb = statbuf.st_size - ((statbuf.st_size / 512) * 512);
1445 fnam = full_name (file_name);
1446 flen = strlen (fnam);
1447 }
1448 else
1449 {
1450 cdt = 0;
1451 ebk = 0;
1452 ffb = 0;
1453 rfo = 0;
1454 fnam = (char *) "";
1455 flen = 0;
1456 }
1457
1458 /* Check to see if the file name that was searched on the previous call
1459 matches this file name. If so, return the index. */
1460 if (last_file_lookup_index != 0)
1461 {
1462 fn = file_info_table[last_file_lookup_index].file_name;
1463 if (strcmp (fnam, fn) == 0)
1464 return last_file_lookup_index;
1465 }
1466
1467 /* Didn't match the previous lookup, search the table */
1468 for (i = 1; i < file_info_table_in_use; ++i)
1469 {
1470 fn = file_info_table[i].file_name;
1471 if (strcmp (fnam, fn) == 0)
1472 {
1473 last_file_lookup_index = i;
1474 return i;
1475 }
1476 }
1477
1478 /* Prepare to add a new table entry by making sure there is enough space in
1479 the table to do so. If not, expand the current table. */
1480 if (file_info_table_in_use == file_info_table_allocated)
1481 {
1482
1483 file_info_table_allocated += FILE_TABLE_INCREMENT;
1484 file_info_table = xrealloc (file_info_table,
1485 (file_info_table_allocated
1486 * sizeof (dst_file_info_entry)));
1487 }
1488
1489 /* Add the new entry to the end of the filename table. */
1490 file_info_table[file_info_table_in_use].file_name = xstrdup (fnam);
1491 file_info_table[file_info_table_in_use].max_line = 0;
1492 file_info_table[file_info_table_in_use].cdt = cdt;
1493 file_info_table[file_info_table_in_use].ebk = ebk;
1494 file_info_table[file_info_table_in_use].ffb = ffb;
1495 file_info_table[file_info_table_in_use].rfo = rfo;
1496 file_info_table[file_info_table_in_use].flen = flen;
1497
1498 last_file_lookup_index = file_info_table_in_use++;
1499 return last_file_lookup_index;
1500 }
1501
1502 /* Output a label to mark the beginning of a source code line entry
1503 and record information relating to this source line, in
1504 'line_info_table' for later output of the .debug_line section. */
1505
1506 static void
vmsdbgout_source_line(register unsigned line,register const char * filename)1507 vmsdbgout_source_line (register unsigned line, register const char *filename)
1508 {
1509 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1510 (*dwarf2_debug_hooks.source_line) (line, filename);
1511
1512 if (debug_info_level >= DINFO_LEVEL_TERSE)
1513 {
1514 dst_line_info_ref line_info;
1515
1516 (*targetm.asm_out.internal_label) (asm_out_file, LINE_CODE_LABEL,
1517 line_info_table_in_use);
1518
1519 /* Expand the line info table if necessary. */
1520 if (line_info_table_in_use == line_info_table_allocated)
1521 {
1522 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
1523 line_info_table = xrealloc (line_info_table,
1524 (line_info_table_allocated
1525 * sizeof (dst_line_info_entry)));
1526 }
1527
1528 /* Add the new entry at the end of the line_info_table. */
1529 line_info = &line_info_table[line_info_table_in_use++];
1530 line_info->dst_file_num = lookup_filename (filename);
1531 line_info->dst_line_num = line;
1532 if (line > file_info_table[line_info->dst_file_num].max_line)
1533 file_info_table[line_info->dst_file_num].max_line = line;
1534 }
1535 }
1536
1537 /* Record the beginning of a new source file, for later output.
1538 At present, unimplemented. */
1539
1540 static void
vmsdbgout_start_source_file(unsigned int lineno,const char * filename)1541 vmsdbgout_start_source_file (unsigned int lineno, const char *filename)
1542 {
1543 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1544 (*dwarf2_debug_hooks.start_source_file) (lineno, filename);
1545 }
1546
1547 /* Record the end of a source file, for later output.
1548 At present, unimplemented. */
1549
1550 static void
vmsdbgout_end_source_file(unsigned int lineno ATTRIBUTE_UNUSED)1551 vmsdbgout_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
1552 {
1553 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1554 (*dwarf2_debug_hooks.end_source_file) (lineno);
1555 }
1556
1557 /* Set up for Debug output at the start of compilation. */
1558
1559 static void
vmsdbgout_init(const char * main_input_filename)1560 vmsdbgout_init (const char *main_input_filename)
1561 {
1562 const char *language_string = lang_hooks.name;
1563
1564 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1565 (*dwarf2_debug_hooks.init) (main_input_filename);
1566
1567 if (debug_info_level == DINFO_LEVEL_NONE)
1568 return;
1569
1570 /* Remember the name of the primary input file. */
1571 primary_filename = main_input_filename;
1572
1573 /* Allocate the initial hunk of the file_info_table. */
1574 file_info_table
1575 = xcalloc (FILE_TABLE_INCREMENT, sizeof (dst_file_info_entry));
1576 file_info_table_allocated = FILE_TABLE_INCREMENT;
1577
1578 /* Skip the first entry - file numbers begin at 1 */
1579 file_info_table_in_use = 1;
1580
1581 func_table = xcalloc (FUNC_TABLE_INCREMENT, sizeof (char *));
1582 func_table_allocated = FUNC_TABLE_INCREMENT;
1583 func_table_in_use = 1;
1584
1585 /* Allocate the initial hunk of the line_info_table. */
1586 line_info_table
1587 = xcalloc (LINE_INFO_TABLE_INCREMENT, sizeof (dst_line_info_entry));
1588 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
1589 /* zero-th entry is allocated, but unused */
1590 line_info_table_in_use = 1;
1591
1592 lookup_filename (primary_filename);
1593
1594 if (!strcmp (language_string, "GNU C"))
1595 module_language = DST_K_C;
1596 else if (!strcmp (language_string, "GNU C++"))
1597 module_language = DST_K_CXX;
1598 else if (!strcmp (language_string, "GNU Ada"))
1599 module_language = DST_K_ADA;
1600 else if (!strcmp (language_string, "GNU F77"))
1601 module_language = DST_K_FORTRAN;
1602 else
1603 module_language = DST_K_UNKNOWN;
1604
1605 module_producer = concat (language_string, " ", version_string, NULL);
1606
1607 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
1608
1609 }
1610
1611 /* Not implemented in VMS Debug. */
1612
1613 static void
vmsdbgout_define(unsigned int lineno,const char * buffer)1614 vmsdbgout_define (unsigned int lineno, const char *buffer)
1615 {
1616 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1617 (*dwarf2_debug_hooks.define) (lineno, buffer);
1618 }
1619
1620 /* Not implemented in VMS Debug. */
1621
1622 static void
vmsdbgout_undef(unsigned int lineno,const char * buffer)1623 vmsdbgout_undef (unsigned int lineno, const char *buffer)
1624 {
1625 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1626 (*dwarf2_debug_hooks.undef) (lineno, buffer);
1627 }
1628
1629 /* Not implemented in VMS Debug. */
1630
1631 static void
vmsdbgout_decl(tree decl)1632 vmsdbgout_decl (tree decl)
1633 {
1634 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1635 (*dwarf2_debug_hooks.function_decl) (decl);
1636 }
1637
1638 /* Not implemented in VMS Debug. */
1639
1640 static void
vmsdbgout_global_decl(tree decl)1641 vmsdbgout_global_decl (tree decl)
1642 {
1643 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1644 (*dwarf2_debug_hooks.global_decl) (decl);
1645 }
1646
1647 /* Not implemented in VMS Debug. */
1648
1649 static void
vmsdbgout_abstract_function(tree decl)1650 vmsdbgout_abstract_function (tree decl)
1651 {
1652 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1653 (*dwarf2_debug_hooks.outlining_inline_function) (decl);
1654 }
1655
1656 /* Output stuff that Debug requires at the end of every file and generate the
1657 VMS Debug debugging info. */
1658
1659 static void
vmsdbgout_finish(const char * main_input_filename ATTRIBUTE_UNUSED)1660 vmsdbgout_finish (const char *main_input_filename ATTRIBUTE_UNUSED)
1661 {
1662 unsigned int i;
1663 int totsize;
1664
1665 if (write_symbols == VMS_AND_DWARF2_DEBUG)
1666 (*dwarf2_debug_hooks.finish) (main_input_filename);
1667
1668 if (debug_info_level == DINFO_LEVEL_NONE)
1669 return;
1670
1671 /* Output a terminator label for the .text section. */
1672 text_section ();
1673 (*targetm.asm_out.internal_label) (asm_out_file, TEXT_END_LABEL, 0);
1674
1675 /* Output debugging information.
1676 Warning! Do not change the name of the .vmsdebug section without
1677 changing it in the assembler also. */
1678 named_section (NULL_TREE, ".vmsdebug", 0);
1679 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1680
1681 totsize = write_modbeg (1);
1682 for (i = 1; i < func_table_in_use; i++)
1683 {
1684 totsize += write_rtnbeg (i, 1);
1685 totsize += write_rtnend (i, 1);
1686 }
1687 totsize += write_pclines (1);
1688
1689 write_modbeg (0);
1690 for (i = 1; i < func_table_in_use; i++)
1691 {
1692 write_rtnbeg (i, 0);
1693 write_rtnend (i, 0);
1694 }
1695 write_pclines (0);
1696
1697 if (debug_info_level > DINFO_LEVEL_TERSE)
1698 {
1699 totsize = write_srccorrs (1);
1700 write_srccorrs (0);
1701 }
1702
1703 totsize = write_modend (1);
1704 write_modend (0);
1705 }
1706 #endif /* VMS_DEBUGGING_INFO */
1707