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 *);
 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 \f
 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 \f
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 */