Automatic date update in version.in
[binutils-gdb.git] / bfd / vms-misc.c
blobab725b09c365de59bcd090d14a17ae32bc385125
1 /* vms-misc.c -- BFD back-end for VMS/VAX (openVMS/VAX) and
2 EVAX (openVMS/Alpha) files.
3 Copyright (C) 1996-2022 Free Software Foundation, Inc.
5 Miscellaneous functions.
7 Written by Klaus K"ampf (kkaempf@rmi.de)
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 #if __STDC__
25 #include <stdarg.h>
26 #endif
28 #include "sysdep.h"
29 #include "bfd.h"
30 #include "bfdlink.h"
31 #include "libbfd.h"
32 #include "safe-ctype.h"
34 #ifdef VMS
35 #define __NEW_STARLET
36 #include <rms.h>
37 #include <unixlib.h>
38 #include <gen64def.h>
39 #include <starlet.h>
40 #define RME$C_SETRFM 0x00000001
41 #include <unistd.h>
42 #endif
43 #include <time.h>
45 #include "vms.h"
46 #include "vms/emh.h"
48 #if VMS_DEBUG
49 /* Debug functions. */
51 /* Debug function for all vms extensions evaluates environment
52 variable VMS_DEBUG for a numerical value on the first call all
53 error levels below this value are printed:
55 Levels:
56 1 toplevel bfd calls (functions from the bfd vector)
57 2 functions called by bfd calls
58 ...
59 9 almost everything
61 Level is also indentation level. Indentation is performed
62 if level > 0. */
64 void
65 _bfd_vms_debug (int level, char *format, ...)
67 static int min_level = -1;
68 static FILE *output = NULL;
69 char *eptr;
70 va_list args;
71 int abslvl = (level > 0) ? level : - level;
73 if (min_level == -1)
75 if ((eptr = getenv ("VMS_DEBUG")) != NULL)
77 min_level = atoi (eptr);
78 output = stderr;
80 else
81 min_level = 0;
83 if (output == NULL)
84 return;
85 if (abslvl > min_level)
86 return;
88 while (--level > 0)
89 fprintf (output, " ");
90 va_start (args, format);
91 vfprintf (output, format, args);
92 fflush (output);
93 va_end (args);
96 /* A debug function
97 hex dump 'size' bytes starting at 'ptr'. */
99 void
100 _bfd_hexdump (int level, unsigned char *ptr, int size, int offset)
102 unsigned char *lptr = ptr;
103 int count = 0;
104 long start = offset;
106 while (size-- > 0)
108 if ((count % 16) == 0)
109 vms_debug (level, "%08lx:", start);
110 vms_debug (-level, " %02x", *ptr++);
111 count++;
112 start++;
113 if (size == 0)
115 while ((count % 16) != 0)
117 vms_debug (-level, " ");
118 count++;
121 if ((count % 16) == 0)
123 vms_debug (-level, " ");
124 while (lptr < ptr)
126 vms_debug (-level, "%c", (*lptr < 32) ? '.' : *lptr);
127 lptr++;
129 vms_debug (-level, "\n");
132 if ((count % 16) != 0)
133 vms_debug (-level, "\n");
135 #endif
138 /* Copy sized string (string with fixed size) to new allocated area.
139 Size is string size (size of record). */
141 char *
142 _bfd_vms_save_sized_string (bfd *abfd, unsigned char *str, size_t size)
144 char *newstr;
146 if (size == (size_t) -1)
148 bfd_set_error (bfd_error_no_memory);
149 return NULL;
151 newstr = bfd_alloc (abfd, size + 1);
152 if (newstr == NULL)
153 return NULL;
154 memcpy (newstr, str, size);
155 newstr[size] = 0;
157 return newstr;
160 /* Copy counted string (string with size at first byte) to new allocated area.
161 PTR points to size byte on entry. */
163 char *
164 _bfd_vms_save_counted_string (bfd *abfd, unsigned char *ptr, size_t maxlen)
166 unsigned int len;
168 if (maxlen == 0)
169 return NULL;
170 len = *ptr++;
171 if (len > maxlen - 1)
172 return NULL;
173 return _bfd_vms_save_sized_string (abfd, ptr, len);
176 /* Object output routines. */
178 /* Begin new record.
179 Write 2 bytes rectype and 2 bytes record length. */
181 void
182 _bfd_vms_output_begin (struct vms_rec_wr *recwr, int rectype)
184 vms_debug2 ((6, "_bfd_vms_output_begin (type %d)\n", rectype));
186 /* Record must have been closed. */
187 BFD_ASSERT (recwr->size == 0);
189 _bfd_vms_output_short (recwr, (unsigned int) rectype);
191 /* Placeholder for length. */
192 _bfd_vms_output_short (recwr, 0);
195 /* Begin new sub-record.
196 Write 2 bytes rectype, and 2 bytes record length. */
198 void
199 _bfd_vms_output_begin_subrec (struct vms_rec_wr *recwr, int rectype)
201 vms_debug2 ((6, "_bfd_vms_output_begin_subrec (type %d)\n", rectype));
203 /* Subrecord must have been closed. */
204 BFD_ASSERT (recwr->subrec_offset == 0);
206 /* Save start of subrecord offset. */
207 recwr->subrec_offset = recwr->size;
209 /* Subrecord type. */
210 _bfd_vms_output_short (recwr, (unsigned int) rectype);
212 /* Placeholder for length. */
213 _bfd_vms_output_short (recwr, 0);
216 /* Set record/subrecord alignment. */
218 void
219 _bfd_vms_output_alignment (struct vms_rec_wr *recwr, int alignto)
221 vms_debug2 ((6, "_bfd_vms_output_alignment (%d)\n", alignto));
222 recwr->align = alignto;
225 /* Align the size of the current record (whose length is LENGTH).
226 Warning: this obviously changes the record (and the possible subrecord)
227 length. */
229 static void
230 _bfd_vms_output_align (struct vms_rec_wr *recwr, unsigned int length)
232 unsigned int real_size = recwr->size;
233 unsigned int aligncount;
235 /* Pad with 0 if alignment is required. */
236 aligncount = (recwr->align - (length % recwr->align)) % recwr->align;
237 vms_debug2 ((6, "align: adding %d bytes\n", aligncount));
238 while (aligncount-- > 0)
239 recwr->buf[real_size++] = 0;
241 recwr->size = real_size;
244 /* Ends current sub-record. Set length field. */
246 void
247 _bfd_vms_output_end_subrec (struct vms_rec_wr *recwr)
249 int real_size = recwr->size;
250 int length;
252 /* Subrecord must be open. */
253 BFD_ASSERT (recwr->subrec_offset != 0);
255 length = real_size - recwr->subrec_offset;
257 if (length == 0)
258 return;
260 _bfd_vms_output_align (recwr, length);
262 /* Put length to buffer. */
263 bfd_putl16 ((bfd_vma) (recwr->size - recwr->subrec_offset),
264 recwr->buf + recwr->subrec_offset + 2);
266 /* Close the subrecord. */
267 recwr->subrec_offset = 0;
270 /* Ends current record (and write it). */
272 void
273 _bfd_vms_output_end (bfd *abfd, struct vms_rec_wr *recwr)
275 vms_debug2 ((6, "_bfd_vms_output_end (size %u)\n", recwr->size));
277 /* Subrecord must have been closed. */
278 BFD_ASSERT (recwr->subrec_offset == 0);
280 if (recwr->size == 0)
281 return;
283 _bfd_vms_output_align (recwr, recwr->size);
285 /* Write the length word. */
286 bfd_putl16 ((bfd_vma) recwr->size, recwr->buf + 2);
288 /* File is open in undefined (UDF) format on VMS, but ultimately will be
289 converted to variable length (VAR) format. VAR format has a length
290 word first which must be explicitly output in UDF format. */
291 /* So, first the length word. */
292 bfd_bwrite (recwr->buf + 2, 2, abfd);
294 /* Align. */
295 if (recwr->size & 1)
296 recwr->buf[recwr->size++] = 0;
298 /* Then the record. */
299 bfd_bwrite (recwr->buf, (size_t) recwr->size, abfd);
301 recwr->size = 0;
304 /* Check remaining buffer size. Return what's left. */
307 _bfd_vms_output_check (struct vms_rec_wr *recwr, int size)
309 vms_debug2 ((6, "_bfd_vms_output_check (%d)\n", size));
311 return (MAX_OUTREC_SIZE - (recwr->size + size + MIN_OUTREC_LUFT));
314 /* Output byte (8 bit) value. */
316 void
317 _bfd_vms_output_byte (struct vms_rec_wr *recwr, unsigned int value)
319 vms_debug2 ((6, "_bfd_vms_output_byte (%02x)\n", value));
321 *(recwr->buf + recwr->size) = value;
322 recwr->size += 1;
325 /* Output short (16 bit) value. */
327 void
328 _bfd_vms_output_short (struct vms_rec_wr *recwr, unsigned int value)
330 vms_debug2 ((6, "_bfd_vms_output_short (%04x)\n", value));
332 bfd_putl16 ((bfd_vma) value & 0xffff, recwr->buf + recwr->size);
333 recwr->size += 2;
336 /* Output long (32 bit) value. */
338 void
339 _bfd_vms_output_long (struct vms_rec_wr *recwr, unsigned long value)
341 vms_debug2 ((6, "_bfd_vms_output_long (%08lx)\n", value));
343 bfd_putl32 ((bfd_vma) value, recwr->buf + recwr->size);
344 recwr->size += 4;
347 /* Output quad (64 bit) value. */
349 void
350 _bfd_vms_output_quad (struct vms_rec_wr *recwr, bfd_vma value)
352 vms_debug2 ((6, "_bfd_vms_output_quad (%08lx)\n", (unsigned long)value));
354 bfd_putl64 (value, recwr->buf + recwr->size);
355 recwr->size += 8;
358 /* Output c-string as counted string. */
360 void
361 _bfd_vms_output_counted (struct vms_rec_wr *recwr, const char *value)
363 int len;
365 vms_debug2 ((6, "_bfd_vms_output_counted (%s)\n", value));
367 len = strlen (value);
368 if (len == 0)
370 _bfd_error_handler (_("_bfd_vms_output_counted called with zero bytes"));
371 return;
373 if (len > 255)
375 _bfd_error_handler (_("_bfd_vms_output_counted called with too many bytes"));
376 return;
378 _bfd_vms_output_byte (recwr, (unsigned int) len & 0xff);
379 _bfd_vms_output_dump (recwr, (const unsigned char *)value, len);
382 /* Output character area. */
384 void
385 _bfd_vms_output_dump (struct vms_rec_wr *recwr, const unsigned char *data, int len)
387 vms_debug2 ((6, "_bfd_vms_output_dump (%d)\n", len));
389 if (len == 0)
390 return;
392 memcpy (recwr->buf + recwr->size, data, (size_t) len);
393 recwr->size += len;
396 /* Output count bytes of value. */
398 void
399 _bfd_vms_output_fill (struct vms_rec_wr *recwr, int value, int count)
401 vms_debug2 ((6, "_bfd_vms_output_fill (val %02x times %d)\n", value, count));
403 if (count == 0)
404 return;
405 memset (recwr->buf + recwr->size, value, (size_t) count);
406 recwr->size += count;
409 #ifdef VMS
410 /* Convert the file to variable record length format. This is done
411 using undocumented system call sys$modify().
412 Pure VMS version. */
414 static void
415 vms_convert_to_var (char * vms_filename)
417 struct FAB fab = cc$rms_fab;
419 fab.fab$l_fna = vms_filename;
420 fab.fab$b_fns = strlen (vms_filename);
421 fab.fab$b_fac = FAB$M_PUT;
422 fab.fab$l_fop = FAB$M_ESC;
423 fab.fab$l_ctx = RME$C_SETRFM;
425 sys$open (&fab);
427 fab.fab$b_rfm = FAB$C_VAR;
429 sys$modify (&fab);
430 sys$close (&fab);
433 static int
434 vms_convert_to_var_1 (char *filename, int type)
436 if (type != DECC$K_FILE)
437 return false;
438 vms_convert_to_var (filename);
439 return true;
442 /* Convert the file to variable record length format. This is done
443 using undocumented system call sys$modify().
444 Unix filename version. */
447 _bfd_vms_convert_to_var_unix_filename (const char *unix_filename)
449 if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
450 return false;
451 return true;
453 #endif /* VMS */
455 /* Manufacture a VMS like time on a unix based system.
456 stolen from obj-vms.c. */
458 unsigned char *
459 get_vms_time_string (unsigned char *tbuf)
461 #ifndef VMS
462 char *pnt;
463 time_t timeb;
465 time (& timeb);
466 pnt = ctime (&timeb);
467 pnt[3] = 0;
468 pnt[7] = 0;
469 pnt[10] = 0;
470 pnt[16] = 0;
471 pnt[24] = 0;
472 sprintf ((char *) tbuf, "%2s-%3s-%s %s",
473 pnt + 8, pnt + 4, pnt + 20, pnt + 11);
474 #else
475 struct
477 int Size;
478 unsigned char *Ptr;
479 } Descriptor;
480 Descriptor.Size = 17;
481 Descriptor.Ptr = tbuf;
482 SYS$ASCTIM (0, &Descriptor, 0, 0);
483 #endif /* not VMS */
485 vms_debug2 ((6, "vmstimestring:'%s'\n", tbuf));
487 return tbuf;
490 /* Create module name from filename (ie, extract the basename and convert it
491 in upper cases). Works on both VMS and UNIX pathes.
492 The result has to be free(). */
494 char *
495 vms_get_module_name (const char *filename, bool upcase)
497 char *fname, *fptr;
498 const char *fout;
500 /* Strip VMS path. */
501 fout = strrchr (filename, ']');
502 if (fout == NULL)
503 fout = strchr (filename, ':');
504 if (fout != NULL)
505 fout++;
506 else
507 fout = filename;
509 /* Strip UNIX path. */
510 fptr = strrchr (fout, '/');
511 if (fptr != NULL)
512 fout = fptr + 1;
514 fname = strdup (fout);
516 /* Strip suffix. */
517 fptr = strrchr (fname, '.');
518 if (fptr != 0)
519 *fptr = 0;
521 /* Convert to upper case and truncate at 31 characters.
522 (VMS object file format restricts module name length to 31). */
523 fptr = fname;
524 for (fptr = fname; *fptr != 0; fptr++)
526 if (*fptr == ';' || (fptr - fname) >= 31)
528 *fptr = 0;
529 break;
531 if (upcase)
532 *fptr = TOUPPER (*fptr);
534 return fname;
537 /* Compared to usual UNIX time_t, VMS time has less limits:
538 - 64 bit (63 bits in fact as the MSB must be 0)
539 - 100ns granularity
540 - epoch is Nov 17, 1858.
541 Here has the constants and the routines used to convert VMS from/to UNIX time.
542 The conversion routines don't assume 64 bits arithmetic.
544 Here we assume that the definition of time_t is the UNIX one, ie integer
545 type, expressing seconds since the epoch. */
547 /* UNIX time granularity for VMS, ie 1s / 100ns. */
548 #define VMS_TIME_FACTOR 10000000
550 /* Number of seconds since VMS epoch of the UNIX epoch. */
551 #define VMS_TIME_OFFSET 3506716800U
553 /* Convert a VMS time to a unix time. */
555 time_t
556 vms_time_to_time_t (unsigned int hi, unsigned int lo)
558 unsigned int tmp;
559 unsigned int rlo;
560 int i;
561 time_t res;
563 /* First convert to seconds. */
564 tmp = hi % VMS_TIME_FACTOR;
565 hi = hi / VMS_TIME_FACTOR;
566 rlo = 0;
567 for (i = 0; i < 4; i++)
569 tmp = (tmp << 8) | (lo >> 24);
570 lo <<= 8;
572 rlo = (rlo << 8) | (tmp / VMS_TIME_FACTOR);
573 tmp %= VMS_TIME_FACTOR;
575 lo = rlo;
577 /* Return 0 in case of overflow. */
578 if (hi > 1
579 || (hi == 1 && lo >= VMS_TIME_OFFSET))
580 return 0;
582 /* Return 0 in case of underflow. */
583 if (hi == 0 && lo < VMS_TIME_OFFSET)
584 return 0;
586 res = lo - VMS_TIME_OFFSET;
587 if (res <= 0)
588 return 0;
589 return res;
592 /* Convert a time_t to a VMS time. */
594 void
595 vms_time_t_to_vms_time (time_t ut, unsigned int *hi, unsigned int *lo)
597 unsigned int val[4];
598 unsigned int tmp[4];
599 unsigned int carry;
600 int i;
602 /* Put into val. */
603 val[0] = ut & 0xffff;
604 val[1] = (ut >> 16) & 0xffff;
605 val[2] = sizeof (ut) > 4 ? (ut >> 32) & 0xffff : 0;
606 val[3] = sizeof (ut) > 4 ? (ut >> 48) & 0xffff : 0;
608 /* Add offset. */
609 tmp[0] = VMS_TIME_OFFSET & 0xffff;
610 tmp[1] = VMS_TIME_OFFSET >> 16;
611 tmp[2] = 0;
612 tmp[3] = 0;
613 carry = 0;
614 for (i = 0; i < 4; i++)
616 carry += tmp[i] + val[i];
617 val[i] = carry & 0xffff;
618 carry = carry >> 16;
621 /* Multiply by factor, well first by 10000 and then by 1000. */
622 carry = 0;
623 for (i = 0; i < 4; i++)
625 carry += val[i] * 10000;
626 val[i] = carry & 0xffff;
627 carry = carry >> 16;
629 carry = 0;
630 for (i = 0; i < 4; i++)
632 carry += val[i] * 1000;
633 val[i] = carry & 0xffff;
634 carry = carry >> 16;
637 /* Write the result. */
638 *lo = val[0] | (val[1] << 16);
639 *hi = val[2] | (val[3] << 16);
642 /* Convert a raw (stored in a buffer) VMS time to a unix time. */
644 time_t
645 vms_rawtime_to_time_t (unsigned char *buf)
647 unsigned int hi = bfd_getl32 (buf + 4);
648 unsigned int lo = bfd_getl32 (buf + 0);
650 return vms_time_to_time_t (hi, lo);
653 void
654 vms_get_time (unsigned int *hi, unsigned int *lo)
656 #ifdef VMS
657 struct _generic_64 t;
659 sys$gettim (&t);
660 *lo = t.gen64$q_quadword;
661 *hi = t.gen64$q_quadword >> 32;
662 #else
663 time_t t;
665 time (&t);
666 vms_time_t_to_vms_time (t, hi, lo);
667 #endif
670 /* Get the current time into a raw buffer BUF. */
672 void
673 vms_raw_get_time (unsigned char *buf)
675 unsigned int hi, lo;
677 vms_get_time (&hi, &lo);
678 bfd_putl32 (lo, buf + 0);
679 bfd_putl32 (hi, buf + 4);