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