Mercurial > hg > CbC > CbC_gcc

comparison gcc/vmsdbgout.c @ 0:a06113de4d67

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