gcc/vmsdbgout.c

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