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