gcc/vmsdbgout.c

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