contrib/gcc-5.0/gcc/vmsdbgout.c

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