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 Free Software Foundation, Inc.
   4    Contributed by Douglas B. Rupp (rupp@gnat.com).
   5    Updated by Bernard W. Giroud (bgiroud@users.sourceforge.net).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 2, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING.  If not, write to the Free
  21 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  22 02110-1301, USA.  */
  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    avmdbgout_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 (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 (char *, char *, const char *, int);
 158 static int write_debug_string (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 (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,       /* 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 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 (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 (char *label1, char *label2, const char *comment,
 672                     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 (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 (basename ((char *) 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   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 = (char *)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 ((char *) 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 (file_info_entry.file_name,
1154                                  "source file name", dosizeonly);
1155   totsize += write_debug_data1 (src_cmdtrlr.dst_b_src_df_libmodname,
1156                                 "source_corr (libmodname)", dosizeonly);
1157
1158   src_command_sf.dst_b_src_command = DST_K_SRC_SETFILE;
1159   src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword = fileid;
1160
1161   src_command_sr.dst_b_src_command = DST_K_SRC_SETREC_W;
1162   src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword = 1;
1163
1164   src_command_sl.dst_b_src_command = DST_K_SRC_SETLNUM_L;
1165   src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong = linestart + 1;
1166
1167   src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
1168
1169   if (linesleft > 65534)
1170     linesleft = linesleft - 65534, linestodo = 65534;
1171   else
1172     linestodo = linesleft, linesleft = 0;
1173
1174   src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
1175
1176   src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1177     = DST_K_SOURCE_CORR_HEADER_SIZE + 3 + 3 + 5 + 3 - 1;
1178   src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1179     = DST_K_SOURCE;
1180
1181   if (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword)
1182     {
1183       totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1184                                      "source corr", dosizeonly);
1185
1186       totsize += write_debug_data1 (src_command_sf.dst_b_src_command,
1187                                     "source_corr (src setfile)", dosizeonly);
1188
1189       totsize += write_debug_data2
1190         (src_command_sf.dst_a_src_cmd_fields.dst_w_src_unsword,
1191          "source_corr (fileid)", dosizeonly);
1192
1193       totsize += write_debug_data1 (src_command_sr.dst_b_src_command,
1194                                     "source_corr (setrec)", dosizeonly);
1195
1196       totsize += write_debug_data2
1197         (src_command_sr.dst_a_src_cmd_fields.dst_w_src_unsword,
1198          "source_corr (recnum)", dosizeonly);
1199
1200       totsize += write_debug_data1 (src_command_sl.dst_b_src_command,
1201                                     "source_corr (setlnum)", dosizeonly);
1202
1203       totsize += write_debug_data4
1204         (src_command_sl.dst_a_src_cmd_fields.dst_l_src_unslong,
1205          "source_corr (linenum)", dosizeonly);
1206
1207       totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
1208                                     "source_corr (deflines)", dosizeonly);
1209
1210       sprintf (buff, "source_corr (%d)",
1211                src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
1212       totsize += write_debug_data2
1213         (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
1214          buff, dosizeonly);
1215
1216       while (linesleft > 0)
1217         {
1218           src_header.dst_a_source_corr_header.dst__header_length.dst_w_length
1219             = DST_K_SOURCE_CORR_HEADER_SIZE + 3 - 1;
1220           src_header.dst_a_source_corr_header.dst__header_type.dst_w_type
1221             = DST_K_SOURCE;
1222           src_command_dl.dst_b_src_command = DST_K_SRC_DEFLINES_W;
1223
1224           if (linesleft > 65534)
1225             linesleft = linesleft - 65534, linestodo = 65534;
1226           else
1227             linestodo = linesleft, linesleft = 0;
1228
1229           src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword = linestodo;
1230
1231           totsize += write_debug_header (&src_header.dst_a_source_corr_header,
1232                                          "source corr", dosizeonly);
1233           totsize += write_debug_data1 (src_command_dl.dst_b_src_command,
1234                                         "source_corr (deflines)", dosizeonly);
1235           sprintf (buff, "source_corr (%d)",
1236                    src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword);
1237           totsize += write_debug_data2
1238             (src_command_dl.dst_a_src_cmd_fields.dst_w_src_unsword,
1239              buff, dosizeonly);
1240         }
1241     }
1242
1243   return totsize;
1244 }
1245
1246 /* Output all the source correlation entries and return the size.  Just return
1247    the size if DOSIZEONLY is nonzero.  */
1248
1249 static int
1250 write_srccorrs (int dosizeonly)
1251 {
1252   unsigned int i;
1253   int totsize = 0;
1254
1255   for (i = 1; i < file_info_table_in_use; i++)
1256     totsize += write_srccorr (i, file_info_table[i], dosizeonly);
1257
1258   return totsize;
1259 }
1260 \f
1261 /* Output a marker (i.e. a label) for the beginning of a function, before
1262    the prologue.  */
1263
1264 static void
1265 vmsdbgout_begin_prologue (unsigned int line, const char *file)
1266 {
1267   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1268
1269   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1270     (*dwarf2_debug_hooks.begin_prologue) (line, file);
1271
1272   if (debug_info_level > DINFO_LEVEL_NONE)
1273     {
1274       ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1275                                    current_function_funcdef_no);
1276       ASM_OUTPUT_LABEL (asm_out_file, label);
1277     }
1278 }
1279
1280 /* Output a marker (i.e. a label) for the beginning of a function, after
1281    the prologue.  */
1282
1283 static void
1284 vmsdbgout_end_prologue (unsigned int line, const char *file)
1285 {
1286   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1287
1288   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1289     (*dwarf2_debug_hooks.end_prologue) (line, file);
1290
1291   if (debug_info_level > DINFO_LEVEL_TERSE)
1292     {
1293       ASM_GENERATE_INTERNAL_LABEL (label, FUNC_PROLOG_LABEL,
1294                                    current_function_funcdef_no);
1295       ASM_OUTPUT_LABEL (asm_out_file, label);
1296
1297       /* VMS PCA expects every PC range to correlate to some line and file.  */
1298       vmsdbgout_source_line (line, file);
1299     }
1300 }
1301
1302 /* No output for VMS debug, but make obligatory call to Dwarf2 debug */
1303
1304 static void
1305 vmsdbgout_end_function (unsigned int line)
1306 {
1307   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1308     (*dwarf2_debug_hooks.end_function) (line);
1309 }
1310
1311 /* Output a marker (i.e. a label) for the absolute end of the generated code
1312    for a function definition.  This gets called *after* the epilogue code has
1313    been generated.  */
1314
1315 static void
1316 vmsdbgout_end_epilogue (unsigned int line, const char *file)
1317 {
1318   char label[MAX_ARTIFICIAL_LABEL_BYTES];
1319
1320   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1321     (*dwarf2_debug_hooks.end_epilogue) (line, file);
1322
1323   if (debug_info_level > DINFO_LEVEL_NONE)
1324     {
1325       /* Output a label to mark the endpoint of the code generated for this
1326          function.  */
1327       ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1328                                    current_function_funcdef_no);
1329       ASM_OUTPUT_LABEL (asm_out_file, label);
1330
1331       /* VMS PCA expects every PC range to correlate to some line and file.  */
1332       vmsdbgout_source_line (line, file);
1333     }
1334 }
1335
1336 /* Output a marker (i.e. a label) for the beginning of the generated code for
1337    a lexical block.  */
1338
1339 static void
1340 vmsdbgout_begin_block (register unsigned line, register unsigned blocknum)
1341 {
1342   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1343     (*dwarf2_debug_hooks.begin_block) (line, blocknum);
1344
1345   if (debug_info_level > DINFO_LEVEL_TERSE)
1346     targetm.asm_out.internal_label (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
1347 }
1348
1349 /* Output a marker (i.e. a label) for the end of the generated code for a
1350    lexical block.  */
1351
1352 static void
1353 vmsdbgout_end_block (register unsigned line, register unsigned blocknum)
1354 {
1355   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1356     (*dwarf2_debug_hooks.end_block) (line, blocknum);
1357
1358   if (debug_info_level > DINFO_LEVEL_TERSE)
1359     targetm.asm_out.internal_label (asm_out_file, BLOCK_END_LABEL, blocknum);
1360 }
1361
1362 /* Not implemented in VMS Debug.  */
1363
1364 static bool
1365 vmsdbgout_ignore_block (tree block)
1366 {
1367   bool retval = 0;
1368
1369   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1370     retval = (*dwarf2_debug_hooks.ignore_block) (block);
1371
1372   return retval;
1373 }
1374
1375 /* Add an entry for function DECL into the func_table.  */
1376
1377 static void
1378 vmsdbgout_begin_function (tree decl)
1379 {
1380   const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1381   vms_func_ref fde;
1382
1383   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1384     (*dwarf2_debug_hooks.begin_function) (decl);
1385
1386   if (func_table_in_use == func_table_allocated)
1387     {
1388       func_table_allocated += FUNC_TABLE_INCREMENT;
1389       func_table
1390         = (vms_func_ref) xrealloc (func_table,
1391                                    func_table_allocated * sizeof (vms_func_node));
1392     }
1393
1394   /* Add the new entry to the end of the function name table.  */
1395   fde = &func_table[func_table_in_use++];
1396   fde->vms_func_name = xstrdup (name);
1397   fde->funcdef_number = current_function_funcdef_no;
1398
1399 }
1400
1401 static char fullname_buff [4096];
1402
1403 /* Return the full file specification for FILENAME.  The specification must be
1404    in VMS syntax in order to be processed by VMS Debug.  */
1405
1406 static char *
1407 full_name (const char *filename)
1408 {
1409 #ifdef VMS
1410   FILE *fp = fopen (filename, "r");
1411
1412   fgetname (fp, fullname_buff, 1);
1413   fclose (fp);
1414 #else
1415   getcwd (fullname_buff, sizeof (fullname_buff));
1416
1417   strcat (fullname_buff, "/");
1418   strcat (fullname_buff, filename);
1419
1420   /* ??? Insert hairy code here to translate Unix style file specification
1421      to VMS style.  */
1422 #endif
1423
1424   return fullname_buff;
1425 }
1426
1427 /* Lookup a filename (in the list of filenames that we know about here in
1428    vmsdbgout.c) and return its "index".  The index of each (known) filename is
1429    just a unique number which is associated with only that one filename.  We
1430    need such numbers for the sake of generating labels  and references
1431    to those files numbers.  If the filename given as an argument is not
1432    found in our current list, add it to the list and assign it the next
1433    available unique index number.  In order to speed up searches, we remember
1434    the index of the filename was looked up last.  This handles the majority of
1435    all searches.  */
1436
1437 static unsigned int
1438 lookup_filename (const char *file_name)
1439 {
1440   static unsigned int last_file_lookup_index = 0;
1441   register char *fn;
1442   register unsigned i;
1443   char *fnam;
1444   long long cdt;
1445   long ebk;
1446   short ffb;
1447   char rfo;
1448   char flen;
1449   struct stat statbuf;
1450
1451   if (stat (file_name, &statbuf) == 0)
1452     {
1453       long gmtoff;
1454 #ifdef VMS
1455       struct tm *ts;
1456
1457       /* Adjust for GMT.  */
1458       ts = (struct tm *) localtime (&statbuf.st_ctime);
1459       gmtoff = ts->tm_gmtoff;
1460
1461       /* VMS has multiple file format types.  */
1462       rfo = statbuf.st_fab_rfm;
1463 #else
1464       /* Is GMT adjustment an issue with a cross-compiler? */
1465       gmtoff = 0;
1466
1467       /* Assume stream LF type file.  */
1468       rfo = 2;
1469 #endif
1470       cdt = 10000000 * (statbuf.st_ctime + gmtoff + vms_epoch_offset);
1471       ebk = statbuf.st_size / 512 + 1;
1472       ffb = statbuf.st_size - ((statbuf.st_size / 512) * 512);
1473       fnam = full_name (file_name);
1474       flen = strlen (fnam);
1475     }
1476   else
1477     {
1478       cdt = 0;
1479       ebk = 0;
1480       ffb = 0;
1481       rfo = 0;
1482       fnam = (char *) "";
1483       flen = 0;
1484     }
1485
1486   /* Check to see if the file name that was searched on the previous call
1487      matches this file name. If so, return the index.  */
1488   if (last_file_lookup_index != 0)
1489     {
1490       fn = file_info_table[last_file_lookup_index].file_name;
1491       if (strcmp (fnam, fn) == 0)
1492         return last_file_lookup_index;
1493     }
1494
1495   /* Didn't match the previous lookup, search the table */
1496   for (i = 1; i < file_info_table_in_use; ++i)
1497     {
1498       fn = file_info_table[i].file_name;
1499       if (strcmp (fnam, fn) == 0)
1500         {
1501           last_file_lookup_index = i;
1502           return i;
1503         }
1504     }
1505
1506   /* Prepare to add a new table entry by making sure there is enough space in
1507      the table to do so.  If not, expand the current table.  */
1508   if (file_info_table_in_use == file_info_table_allocated)
1509     {
1510
1511       file_info_table_allocated += FILE_TABLE_INCREMENT;
1512       file_info_table = xrealloc (file_info_table,
1513                                   (file_info_table_allocated
1514                                    * sizeof (dst_file_info_entry)));
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 = xrealloc (line_info_table,
1552                                       (line_info_table_allocated
1553                                        * sizeof (dst_line_info_entry)));
1554         }
1555
1556       /* Add the new entry at the end of the line_info_table.  */
1557       line_info = &line_info_table[line_info_table_in_use++];
1558       line_info->dst_file_num = lookup_filename (filename);
1559       line_info->dst_line_num = line;
1560       if (line > file_info_table[line_info->dst_file_num].max_line)
1561         file_info_table[line_info->dst_file_num].max_line = line;
1562     }
1563 }
1564
1565 /* Record the beginning of a new source file, for later output.
1566    At present, unimplemented.  */
1567
1568 static void
1569 vmsdbgout_start_source_file (unsigned int lineno, const char *filename)
1570 {
1571   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1572     (*dwarf2_debug_hooks.start_source_file) (lineno, filename);
1573 }
1574
1575 /* Record the end of a source file, for later output.
1576    At present, unimplemented.  */
1577
1578 static void
1579 vmsdbgout_end_source_file (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 (const char *main_input_filename)
1589 {
1590   const char *language_string = lang_hooks.name;
1591
1592   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1593     (*dwarf2_debug_hooks.init) (main_input_filename);
1594
1595   if (debug_info_level == DINFO_LEVEL_NONE)
1596     return;
1597
1598   /* Remember the name of the primary input file.  */
1599   primary_filename = main_input_filename;
1600
1601   /* Allocate the initial hunk of the file_info_table.  */
1602   file_info_table
1603     = xcalloc (FILE_TABLE_INCREMENT, sizeof (dst_file_info_entry));
1604   file_info_table_allocated = FILE_TABLE_INCREMENT;
1605
1606   /* Skip the first entry - file numbers begin at 1 */
1607   file_info_table_in_use = 1;
1608
1609   func_table = (vms_func_ref) xcalloc (FUNC_TABLE_INCREMENT, sizeof (vms_func_node));
1610   func_table_allocated = FUNC_TABLE_INCREMENT;
1611   func_table_in_use = 1;
1612
1613   /* Allocate the initial hunk of the line_info_table.  */
1614   line_info_table
1615     = xcalloc (LINE_INFO_TABLE_INCREMENT, sizeof (dst_line_info_entry));
1616   line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
1617   /* zero-th entry is allocated, but unused */
1618   line_info_table_in_use = 1;
1619
1620   lookup_filename (primary_filename);
1621
1622   if (!strcmp (language_string, "GNU C"))
1623     module_language = DST_K_C;
1624   else if (!strcmp (language_string, "GNU C++"))
1625     module_language = DST_K_CXX;
1626   else if (!strcmp (language_string, "GNU Ada"))
1627     module_language = DST_K_ADA;
1628   else if (!strcmp (language_string, "GNU F77"))
1629     module_language = DST_K_FORTRAN;
1630   else
1631     module_language = DST_K_UNKNOWN;
1632
1633   module_producer = concat (language_string, " ", version_string, NULL);
1634
1635   ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
1636
1637 }
1638
1639 /* Not implemented in VMS Debug.  */
1640
1641 static void
1642 vmsdbgout_define (unsigned int lineno, const char *buffer)
1643 {
1644   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1645     (*dwarf2_debug_hooks.define) (lineno, buffer);
1646 }
1647
1648 /* Not implemented in VMS Debug.  */
1649
1650 static void
1651 vmsdbgout_undef (unsigned int lineno, const char *buffer)
1652 {
1653   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1654     (*dwarf2_debug_hooks.undef) (lineno, buffer);
1655 }
1656
1657 /* Not implemented in VMS Debug.  */
1658
1659 static void
1660 vmsdbgout_decl (tree decl)
1661 {
1662   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1663     (*dwarf2_debug_hooks.function_decl) (decl);
1664 }
1665
1666 /* Not implemented in VMS Debug.  */
1667
1668 static void
1669 vmsdbgout_global_decl (tree decl)
1670 {
1671   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1672     (*dwarf2_debug_hooks.global_decl) (decl);
1673 }
1674
1675 /* Not implemented in VMS Debug.  */
1676
1677 static void
1678 vmsdbgout_abstract_function (tree decl)
1679 {
1680   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1681     (*dwarf2_debug_hooks.outlining_inline_function) (decl);
1682 }
1683
1684 /* Output stuff that Debug requires at the end of every file and generate the
1685    VMS Debug debugging info.  */
1686
1687 static void
1688 vmsdbgout_finish (const char *main_input_filename ATTRIBUTE_UNUSED)
1689 {
1690   unsigned int i;
1691   int totsize;
1692
1693   if (write_symbols == VMS_AND_DWARF2_DEBUG)
1694     (*dwarf2_debug_hooks.finish) (main_input_filename);
1695
1696   if (debug_info_level == DINFO_LEVEL_NONE)
1697     return;
1698
1699   /* Output a terminator label for the .text section.  */
1700   switch_to_section (text_section);
1701   targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
1702
1703   /* Output debugging information.
1704      Warning! Do not change the name of the .vmsdebug section without
1705      changing it in the assembler also.  */
1706   switch_to_section (get_named_section (NULL, ".vmsdebug", 0));
1707   ASM_OUTPUT_ALIGN (asm_out_file, 0);
1708
1709   totsize = write_modbeg (1);
1710   for (i = 1; i < func_table_in_use; i++)
1711     {
1712       totsize += write_rtnbeg (i, 1);
1713       totsize += write_rtnend (i, 1);
1714     }
1715   totsize += write_pclines (1);
1716
1717   write_modbeg (0);
1718   for (i = 1; i < func_table_in_use; i++)
1719     {
1720       write_rtnbeg (i, 0);
1721       write_rtnend (i, 0);
1722     }
1723   write_pclines (0);
1724
1725   if (debug_info_level > DINFO_LEVEL_TERSE)
1726     {
1727       totsize = write_srccorrs (1);
1728       write_srccorrs (0);
1729     }
1730
1731   totsize = write_modend (1);
1732   write_modend (0);
1733 }
1734 #endif /* VMS_DEBUGGING_INFO */