OSDN Git Service

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