gcc/vmsdbgout.c

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