gcc/vmsdbgout.c

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