1 /* vms.c -- Write out a VAX/VMS object file
2 Copyright 1987, 1988, 1992, 1993, 1994, 1995, 1997, 1998, 2000, 2001,
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* Written by David L. Kashtan */
24 /* Modified by Eric Youngdale to write VMS debug records for program
27 /* Want all of obj-vms.h (as obj-format.h, via targ-env.h, via as.h). */
28 #define WANT_VMS_OBJ_DEFS
32 #include "safe-ctype.h"
37 /* What we do if there is a goof. */
38 #define error as_fatal
40 #ifdef VMS /* These are of no use if we are cross assembling. */
41 #include <fab.h> /* Define File Access Block. */
42 #include <nam.h> /* Define NAM Block. */
43 #include <xab.h> /* Define XAB - all different types. */
44 extern int sys$
open(), sys$
close(), sys$
asctim();
47 /* Version string of the compiler that produced the code we are
48 assembling. (And this assembler, if we do not have compiler info). */
49 char *compiler_version_string
;
51 extern int flag_hash_long_names
; /* -+ */
52 extern int flag_one
; /* -1; compatibility with gcc 1.x */
53 extern int flag_show_after_trunc
; /* -H */
54 extern int flag_no_hash_mixed_case
; /* -h NUM */
56 /* Flag that determines how we map names. This takes several values, and
57 is set with the -h switch. A value of zero implies names should be
58 upper case, and the presence of the -h switch inhibits the case hack.
59 No -h switch at all sets vms_name_mapping to 0, and allows case hacking.
60 A value of 2 (set with -h2) implies names should be
61 all lower case, with no case hack. A value of 3 (set with -h3) implies
62 that case should be preserved. */
64 /* If the -+ switch is given, then the hash is appended to any name that is
65 longer than 31 characters, regardless of the setting of the -h switch. */
67 char vms_name_mapping
= 0;
69 static symbolS
*Entry_Point_Symbol
= 0; /* Pointer to "_main" */
71 /* We augment the "gas" symbol structure with this. */
75 struct VMS_Symbol
*Next
;
82 struct VMS_Symbol
*VMS_Symbols
= 0;
83 struct VMS_Symbol
*Ctors_Symbols
= 0;
84 struct VMS_Symbol
*Dtors_Symbols
= 0;
86 /* We need this to keep track of the various input files, so that we can
87 give the debugger the correct source line. */
91 struct input_file
*next
;
92 struct input_file
*same_file_fpnt
;
102 static struct input_file
*file_root
= (struct input_file
*) NULL
;
104 /* Styles of PSECTS (program sections) that we generate; just shorthand
105 to avoid lists of section attributes. Used by VMS_Psect_Spec(). */
108 ps_TEXT
, ps_DATA
, ps_COMMON
, ps_CONST
, ps_CTORS
, ps_DTORS
111 /* This enum is used to keep track of the various types of variables that
116 BASIC
, POINTER
, ARRAY
, ENUM
, STRUCT
, UNION
, FUNCTION
, VOID
, ALIAS
, UNKNOWN
119 /* This structure contains the information from the stabs directives, and the
120 information is filled in by VMS_typedef_parse. Everything that is needed
121 to generate the debugging record for a given symbol is present here.
122 This could be done more efficiently, using nested struct/unions, but for
123 now I am happy that it works. */
125 struct VMS_DBG_Symbol
127 struct VMS_DBG_Symbol
*next
;
128 /* Description of what this is. */
129 enum advanced_type advanced
;
130 /* This record is for this type. */
132 /* For advanced types this is the type referred to. I.e., the type
133 a pointer points to, or the type of object that makes up an
136 /* Use this type when generating a variable def. */
138 /* Used for arrays - this will be present for all. */
140 /* Entries, but will be meaningless for non-arrays. */
142 /* Size in bytes of the data type. For an array, this is the size
143 of one element in the array. */
145 /* Number of the structure/union/enum - used for ref. */
149 #define SYMTYPLST_SIZE (1<<4) /* 16; Must be power of two. */
150 #define SYMTYP_HASH(x) ((unsigned) (x) & (SYMTYPLST_SIZE - 1))
152 struct VMS_DBG_Symbol
*VMS_Symbol_type_list
[SYMTYPLST_SIZE
];
154 /* We need this structure to keep track of forward references to
155 struct/union/enum that have not been defined yet. When they are
156 ultimately defined, then we can go back and generate the TIR
157 commands to make a back reference. */
161 struct forward_ref
*next
;
167 struct forward_ref
*f_ref_root
= (struct forward_ref
*) NULL
;
169 /* This routine is used to compare the names of certain types to various
170 fixed types that are known by the debugger. */
172 #define type_check(X) !strcmp (symbol_name, X)
174 /* This variable is used to keep track of the name of the symbol we are
175 working on while we are parsing the stabs directives. */
177 static const char *symbol_name
;
179 /* We use this counter to assign numbers to all of the structures, unions
180 and enums that we define. When we actually declare a variable to the
181 debugger, we can simply do it by number, rather than describing the
182 whole thing each time. */
184 static int structure_count
= 0;
186 /* This variable is used to indicate that we are making the last attempt to
187 parse the stabs, and that we should define as much as we can, and ignore
190 static int final_pass
;
192 /* This variable is used to keep track of the current structure number
193 for a given variable. If this is < 0, that means that the structure
194 has not yet been defined to the debugger. This is still cool, since
195 the VMS object language has ways of fixing things up after the fact,
196 so we just make a note of this, and generate fixups at the end. */
198 static int struct_number
;
200 /* This is used to distinguish between D_float and G_float for telling
201 the debugger about doubles. gcc outputs the same .stabs regardless
202 of whether -mg is used to select alternate doubles. */
204 static int vax_g_doubles
= 0;
206 /* Local symbol references (used to handle N_ABS symbols; gcc does not
207 generate those, but they're possible with hand-coded assembler input)
208 are always made relative to some particular environment. If the current
209 input has any such symbols, then we expect this to get incremented
210 exactly once and end up having all of them be in environment #0. */
212 static int Current_Environment
= -1;
214 /* Every object file must specify an module name, which is also used by
215 traceback records. Set in Write_VMS_MHD_Records(). */
217 static char Module_Name
[255+1];
219 /* Variable descriptors are used tell the debugger the data types of certain
220 more complicated variables (basically anything involving a structure,
221 union, enum, array or pointer). Some non-pointer variables of the
222 basic types that the debugger knows about do not require a variable
225 Since it is impossible to have a variable descriptor longer than 128
226 bytes by virtue of the way that the VMS object language is set up,
227 it makes not sense to make the arrays any longer than this, or worrying
228 about dynamic sizing of the array.
230 These are the arrays and counters that we use to build a variable
233 #define MAX_DEBUG_RECORD 128
234 static char Local
[MAX_DEBUG_RECORD
]; /* Buffer for variable descriptor. */
235 static char Asuffix
[MAX_DEBUG_RECORD
]; /* Buffer for array descriptor. */
236 static int Lpnt
; /* Index into Local. */
237 static int Apoint
; /* Index into Asuffix. */
238 static char overflow
; /* Flag to indicate we have written too much. */
239 static int total_len
; /* Used to calculate the total length of
240 variable descriptor plus array descriptor
241 - used for len byte. */
243 /* Flag if we have told user about finding global constants in the text
245 static int gave_compiler_message
= 0;
247 /* Global data (Object records limited to 512 bytes by VAX-11 "C" runtime). */
249 static int VMS_Object_File_FD
; /* File Descriptor for object file. */
250 static char Object_Record_Buffer
[512]; /* Buffer for object file records. */
251 static size_t Object_Record_Offset
; /* Offset to end of data. */
252 static int Current_Object_Record_Type
; /* Type of record in above. */
254 /* Macros for moving data around. Must work on big-endian systems. */
256 #ifdef VMS /* These are more efficient for VMS->VMS systems. */
257 #define COPY_LONG(dest,val) ( *(long *) (dest) = (val) )
258 #define COPY_SHORT(dest,val) ( *(short *) (dest) = (val) )
260 #define COPY_LONG(dest,val) md_number_to_chars ((dest), (val), 4)
261 #define COPY_SHORT(dest,val) md_number_to_chars ((dest), (val), 2)
264 /* Macros for placing data into the object record buffer. */
266 #define PUT_LONG(val) \
267 ( COPY_LONG (&Object_Record_Buffer[Object_Record_Offset], (val)), \
268 Object_Record_Offset += 4 )
270 #define PUT_SHORT(val) \
271 ( COPY_SHORT (&Object_Record_Buffer[Object_Record_Offset], (val)), \
272 Object_Record_Offset += 2 )
274 #define PUT_CHAR(val) (Object_Record_Buffer[Object_Record_Offset++] = (val))
276 #define PUT_COUNTED_STRING(cp) \
279 const char *p = (cp); \
281 PUT_CHAR ((char) strlen (p)); \
287 /* Macro for determining if a Name has psect attributes attached
290 #define PSECT_ATTRIBUTES_STRING "$$PsectAttributes_"
291 #define PSECT_ATTRIBUTES_STRING_LENGTH 18
293 #define HAS_PSECT_ATTRIBUTES(Name) \
294 (strncmp ((*Name == '_' ? Name + 1 : Name), \
295 PSECT_ATTRIBUTES_STRING, \
296 PSECT_ATTRIBUTES_STRING_LENGTH) == 0)
299 /* in: segT out: N_TYPE bits */
300 const short seg_N_TYPE
[] =
306 N_UNDF
, /* unknown */
308 N_UNDF
, /* expression */
312 N_REGISTER
, /* register */
315 const segT N_TYPE_seg
[N_TYPE
+ 2] =
316 { /* N_TYPE == 0x1E = 32-2 */
317 SEG_UNKNOWN
, /* N_UNDF == 0 */
319 SEG_ABSOLUTE
, /* N_ABS == 2 */
321 SEG_TEXT
, /* N_TEXT == 4 */
323 SEG_DATA
, /* N_DATA == 6 */
325 SEG_BSS
, /* N_BSS == 8 */
327 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
328 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
329 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
330 SEG_REGISTER
, /* dummy N_REGISTER for regs = 30 */
335 /* The following code defines the special types of pseudo-ops that we
338 unsigned char const_flag
= IN_DEFAULT_SECTION
;
343 /* Since we don't need `arg', use it as our scratch variable so that
344 we won't get any "not used" warnings about it. */
345 arg
= get_absolute_expression ();
346 subseg_set (SEG_DATA
, (subsegT
) arg
);
348 demand_empty_rest_of_line ();
351 const pseudo_typeS obj_pseudo_table
[] =
353 {"const", s_const
, 0},
355 }; /* obj_pseudo_table */
357 /* Routine to perform RESOLVE_SYMBOL_REDEFINITION(). */
360 vms_resolve_symbol_redef (symbolS
*sym
)
362 /* If the new symbol is .comm AND it has a size of zero,
363 we ignore it (i.e. the old symbol overrides it). */
364 if (SEGMENT_TO_SYMBOL_TYPE ((int) now_seg
) == (N_UNDF
| N_EXT
)
365 && frag_now_fix () == 0)
367 as_warn (_("compiler emitted zero-size common symbol `%s' already defined"),
371 /* If the old symbol is .comm and it has a size of zero,
372 we override it with the new symbol value. */
373 if (S_IS_EXTERNAL (sym
) && S_IS_DEFINED (sym
) && S_GET_VALUE (sym
) == 0)
375 as_warn (_("compiler redefined zero-size common symbol `%s'"),
377 sym
->sy_frag
= frag_now
;
378 S_SET_OTHER (sym
, const_flag
);
379 S_SET_VALUE (sym
, frag_now_fix ());
380 /* Keep N_EXT bit. */
381 sym
->sy_symbol
.n_type
|= SEGMENT_TO_SYMBOL_TYPE ((int) now_seg
);
388 /* `tc_frob_label' handler for colon(symbols.c), used to examine the
389 dummy label(s) gcc inserts at the beginning of each file it generates.
390 gcc 1.x put "gcc_compiled."; gcc 2.x (as of 2.7) puts "gcc2_compiled."
391 and "__gnu_language_<name>" and possibly "__vax_<type>_doubles". */
394 vms_check_for_special_label (symbolS
*symbolP
)
396 /* Special labels only occur prior to explicit section directives. */
397 if ((const_flag
& IN_DEFAULT_SECTION
) != 0)
399 char *sym_name
= S_GET_NAME (symbolP
);
401 if (*sym_name
== '_')
404 if (!strcmp (sym_name
, "__vax_g_doubles"))
410 obj_read_begin_hook (void)
415 obj_crawl_symbol_chain (object_headers
*headers
)
419 int symbol_number
= 0;
421 symbolPP
= &symbol_rootP
; /* -> last symbol chain link. */
422 while ((symbolP
= *symbolPP
) != NULL
)
424 resolve_symbol_value (symbolP
);
426 /* OK, here is how we decide which symbols go out into the
427 brave new symtab. Symbols that do are:
429 * symbols with no name (stabd's?)
430 * symbols with debug info in their N_TYPE
431 * symbols with \1 as their 3rd character (numeric labels)
432 * "local labels" needed for PIC fixups
434 Symbols that don't are:
435 * symbols that are registers
437 All other symbols are output. We complain if a deleted
438 symbol was marked external. */
440 if (!S_IS_REGISTER (symbolP
))
442 symbolP
->sy_number
= symbol_number
++;
443 symbolP
->sy_name_offset
= 0;
444 symbolPP
= &symbolP
->sy_next
;
448 if (S_IS_EXTERNAL (symbolP
) || !S_IS_DEFINED (symbolP
))
449 as_bad (_("Local symbol %s never defined"),
450 S_GET_NAME (symbolP
));
452 /* Unhook it from the chain. */
453 *symbolPP
= symbol_next (symbolP
);
457 H_SET_STRING_SIZE (headers
, string_byte_count
);
458 H_SET_SYMBOL_TABLE_SIZE (headers
, symbol_number
);
462 /* VMS OBJECT FILE HACKING ROUTINES. */
464 /* Create the VMS object file. */
467 Create_VMS_Object_File (void)
470 VMS_Object_File_FD
= creat (out_file_name
, 0777, "var");
473 VMS_Object_File_FD
= creat (out_file_name
, 0777);
475 VMS_Object_File_FD
= creat (out_file_name
, 0, "rfm=var",
476 "ctx=bin", "mbc=16", "deq=64", "fop=tef",
480 /* Deal with errors. */
481 if (VMS_Object_File_FD
< 0)
482 as_fatal (_("Couldn't create VMS object file \"%s\""), out_file_name
);
483 /* Initialize object file hacking variables. */
484 Object_Record_Offset
= 0;
485 Current_Object_Record_Type
= -1;
488 /* Flush the object record buffer to the object file. */
491 Flush_VMS_Object_Record_Buffer (void)
493 /* If the buffer is empty, there's nothing to do. */
494 if (Object_Record_Offset
== 0)
497 #ifndef VMS /* For cross-assembly purposes. */
501 /* "Variable-length record" files have a two byte length field
502 prepended to each record. It's normally out-of-band, and native
503 VMS output will insert it automatically for this type of file.
504 When cross-assembling, we must write it explicitly. */
505 md_number_to_chars (RecLen
, Object_Record_Offset
, 2);
506 if (write (VMS_Object_File_FD
, RecLen
, 2) != 2)
507 error (_("I/O error writing VMS object file (length prefix)"));
508 /* We also need to force the actual record to be an even number of
509 bytes. For native output, that's automatic; when cross-assembling,
510 pad with a NUL byte if length is odd. Do so _after_ writing the
511 pre-padded length. Since our buffer is defined with even size,
512 an odd offset implies that it has some room left. */
513 if ((Object_Record_Offset
& 1) != 0)
514 Object_Record_Buffer
[Object_Record_Offset
++] = '\0';
518 /* Write the data to the file. */
519 if ((size_t) write (VMS_Object_File_FD
, Object_Record_Buffer
,
520 Object_Record_Offset
) != Object_Record_Offset
)
521 error (_("I/O error writing VMS object file"));
523 /* The buffer is now empty. */
524 Object_Record_Offset
= 0;
527 /* Declare a particular type of object file record. */
530 Set_VMS_Object_File_Record (int Type
)
532 /* If the type matches, we are done. */
533 if (Type
== Current_Object_Record_Type
)
535 /* Otherwise: flush the buffer. */
536 Flush_VMS_Object_Record_Buffer ();
537 /* Remember the new type. */
538 Current_Object_Record_Type
= Type
;
541 /* Close the VMS Object file. */
544 Close_VMS_Object_File (void)
546 /* Flush (should never be necessary) and reset saved record-type context. */
547 Set_VMS_Object_File_Record (-1);
549 #ifndef VMS /* For cross-assembly purposes. */
554 /* Write a 2 byte record-length field of -1 into the file, which
555 means end-of-block when read, hence end-of-file when occurring
556 in the file's last block. It is only needed for variable-length
557 record files transferred to VMS as fixed-length record files
558 (typical for binary FTP; NFS shouldn't need it, but it won't hurt). */
559 md_number_to_chars (RecLen
, minus_one
, 2);
560 write (VMS_Object_File_FD
, RecLen
, 2);
563 /* When written on a VMS system, the file header (cf inode) will record
564 the actual end-of-file position and no inline marker is needed. */
567 close (VMS_Object_File_FD
);
570 /* Text Information and Relocation routines. */
572 /* Stack Psect base followed by signed, varying-sized offset.
573 Common to several object records. */
576 vms_tir_stack_psect (int Psect_Index
, int Offset
, int Force
)
578 int psect_width
, offset_width
;
580 psect_width
= ((unsigned) Psect_Index
> 255) ? 2 : 1;
581 offset_width
= (Force
|| Offset
> 32767 || Offset
< -32768) ? 4
582 : (Offset
> 127 || Offset
< -128) ? 2 : 1;
583 #define Sta_P(p,o) (((o)<<1) | ((p)-1))
584 /* Byte or word psect; byte, word, or longword offset. */
585 switch (Sta_P(psect_width
,offset_width
))
587 case Sta_P(1,1): PUT_CHAR (TIR_S_C_STA_PB
);
588 PUT_CHAR ((char) (unsigned char) Psect_Index
);
589 PUT_CHAR ((char) Offset
);
591 case Sta_P(1,2): PUT_CHAR (TIR_S_C_STA_PW
);
592 PUT_CHAR ((char) (unsigned char) Psect_Index
);
595 case Sta_P(1,4): PUT_CHAR (TIR_S_C_STA_PL
);
596 PUT_CHAR ((char) (unsigned char) Psect_Index
);
599 case Sta_P(2,1): PUT_CHAR (TIR_S_C_STA_WPB
);
600 PUT_SHORT (Psect_Index
);
601 PUT_CHAR ((char) Offset
);
603 case Sta_P(2,2): PUT_CHAR (TIR_S_C_STA_WPW
);
604 PUT_SHORT (Psect_Index
);
607 case Sta_P(2,4): PUT_CHAR (TIR_S_C_STA_WPL
);
608 PUT_SHORT (Psect_Index
);
615 /* Store immediate data in current Psect. */
618 VMS_Store_Immediate_Data (const char *Pointer
, int Size
, int Record_Type
)
622 Set_VMS_Object_File_Record (Record_Type
);
623 /* We can only store as most 128 bytes at a time due to the way that
624 TIR commands are encoded. */
627 i
= (Size
> 128) ? 128 : Size
;
629 /* If we cannot accommodate this record, flush the buffer. */
630 if ((Object_Record_Offset
+ i
+ 1) >= sizeof Object_Record_Buffer
)
631 Flush_VMS_Object_Record_Buffer ();
632 /* If the buffer is empty we must insert record type. */
633 if (Object_Record_Offset
== 0)
634 PUT_CHAR (Record_Type
);
635 /* Store the count. The Store Immediate TIR command is implied by
636 a negative command byte, and the length of the immediate data
637 is abs(command_byte). So, we write the negated length value. */
638 PUT_CHAR ((char) (-i
& 0xff));
639 /* Now store the data. */
641 PUT_CHAR (*Pointer
++);
643 /* Flush the buffer if it is more than 75% full. */
644 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
645 Flush_VMS_Object_Record_Buffer ();
648 /* Make a data reference. */
651 VMS_Set_Data (int Psect_Index
, int Offset
, int Record_Type
, int Force
)
653 Set_VMS_Object_File_Record (Record_Type
);
654 /* If the buffer is empty we must insert the record type. */
655 if (Object_Record_Offset
== 0)
656 PUT_CHAR (Record_Type
);
657 /* Stack the Psect base with its offset. */
658 vms_tir_stack_psect (Psect_Index
, Offset
, Force
);
659 /* Set relocation base. */
660 PUT_CHAR (TIR_S_C_STO_PIDR
);
661 /* Flush the buffer if it is more than 75% full. */
662 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
663 Flush_VMS_Object_Record_Buffer ();
666 /* Make a debugger reference to a struct, union or enum. */
669 VMS_Store_Struct (int Struct_Index
)
671 /* We are writing a debug record. */
672 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
673 /* If the buffer is empty we must insert the record type. */
674 if (Object_Record_Offset
== 0)
675 PUT_CHAR (OBJ_S_C_DBG
);
676 PUT_CHAR (TIR_S_C_STA_UW
);
677 PUT_SHORT (Struct_Index
);
678 PUT_CHAR (TIR_S_C_CTL_STKDL
);
679 PUT_CHAR (TIR_S_C_STO_L
);
680 /* Flush the buffer if it is more than 75% full. */
681 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
682 Flush_VMS_Object_Record_Buffer ();
685 /* Make a debugger reference to partially define a struct, union or enum. */
688 VMS_Def_Struct (int Struct_Index
)
690 /* We are writing a debug record. */
691 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
692 /* If the buffer is empty we must insert the record type. */
693 if (Object_Record_Offset
== 0)
694 PUT_CHAR (OBJ_S_C_DBG
);
695 PUT_CHAR (TIR_S_C_STA_UW
);
696 PUT_SHORT (Struct_Index
);
697 PUT_CHAR (TIR_S_C_CTL_DFLOC
);
698 /* Flush the buffer if it is more than 75% full. */
699 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
700 Flush_VMS_Object_Record_Buffer ();
704 VMS_Set_Struct (int Struct_Index
)
706 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
707 if (Object_Record_Offset
== 0)
708 PUT_CHAR (OBJ_S_C_DBG
);
709 PUT_CHAR (TIR_S_C_STA_UW
);
710 PUT_SHORT (Struct_Index
);
711 PUT_CHAR (TIR_S_C_CTL_STLOC
);
712 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
713 Flush_VMS_Object_Record_Buffer ();
716 /* Traceback Information routines. */
718 /* Write the Traceback Module Begin record. */
721 VMS_TBT_Module_Begin (void)
727 /* Arrange to store the data locally (leave room for size byte). */
730 *cp
++ = DST_S_C_MODBEG
;
731 *cp
++ = 0; /* flags; not used */
732 /* Language type == "C"
733 (FIXME: this should be based on the input...) */
734 COPY_LONG (cp
, DST_S_C_C
);
736 /* Store the module name. */
737 *cp
++ = (char) strlen (Module_Name
);
741 /* Now we can store the record size. */
744 /* Put it into the object record. */
745 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_TBT
);
748 /* Write the Traceback Module End record. */
751 VMS_TBT_Module_End (void)
757 Local
[1] = DST_S_C_MODEND
;
758 /* Put it into the object record. */
759 VMS_Store_Immediate_Data (Local
, 2, OBJ_S_C_TBT
);
762 /* Write a Traceback Routine Begin record. */
765 VMS_TBT_Routine_Begin (symbolS
*symbolP
, int Psect
)
773 /* Strip the leading "_" from the name. */
774 Name
= S_GET_NAME (symbolP
);
777 /* Get the text psect offset. */
778 Offset
= S_GET_VALUE (symbolP
);
779 /* Set the record size. */
780 Size
= 1 + 1 + 4 + 1 + strlen (Name
);
782 /* DST type "routine begin". */
783 Local
[1] = DST_S_C_RTNBEG
;
784 /* Uses CallS/CallG. */
786 /* Store the data so far. */
787 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_TBT
);
788 /* Make sure we are still generating a OBJ_S_C_TBT record. */
789 if (Object_Record_Offset
== 0)
790 PUT_CHAR (OBJ_S_C_TBT
);
791 /* Stack the address. */
792 vms_tir_stack_psect (Psect
, Offset
, 0);
793 /* Store the data reference. */
794 PUT_CHAR (TIR_S_C_STO_PIDR
);
795 /* Store the counted string as data. */
798 Size
= strlen (cp1
) + 1;
802 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_TBT
);
805 /* Write a Traceback Routine End record.
807 We *must* search the symbol table to find the next routine, since the
808 assembler has a way of reassembling the symbol table OUT OF ORDER Thus
809 the next routine in the symbol list is not necessarily the next one in
810 memory. For debugging to work correctly we must know the size of the
814 VMS_TBT_Routine_End (int Max_Size
, symbolS
*sp
)
817 unsigned long Size
= 0x7fffffff;
819 valueT sym_value
, sp_value
= S_GET_VALUE (sp
);
821 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
823 if (!S_IS_DEBUG (symbolP
) && S_GET_TYPE (symbolP
) == N_TEXT
)
825 if (*S_GET_NAME (symbolP
) == 'L')
827 sym_value
= S_GET_VALUE (symbolP
);
828 if (sym_value
> sp_value
&& sym_value
< Size
)
831 /* Dummy labels like "gcc_compiled." should no longer reach here. */
834 if (Size
== 0x7fffffff)
836 Size
-= sp_value
; /* and get the size of the routine */
839 /* DST type is "routine end". */
840 Local
[1] = DST_S_C_RTNEND
;
841 Local
[2] = 0; /* unused */
842 /* Size of routine. */
843 COPY_LONG (&Local
[3], Size
);
844 /* Store the record. */
845 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_TBT
);
848 /* Write a Traceback Block Begin record. */
851 VMS_TBT_Block_Begin (symbolS
*symbolP
, int Psect
, char *Name
)
858 /* Set the record size. */
859 Size
= 1 + 1 + 4 + 1 + strlen (Name
);
861 /* DST type is "begin block"; we simulate with a phony routine. */
862 Local
[1] = DST_S_C_BLKBEG
;
863 /* Uses CallS/CallG. */
865 /* Store the data so far. */
866 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_DBG
);
867 /* Make sure we are still generating a debug record. */
868 if (Object_Record_Offset
== 0)
869 PUT_CHAR (OBJ_S_C_DBG
);
870 /* Now get the symbol address. */
871 PUT_CHAR (TIR_S_C_STA_WPL
);
873 /* Get the text psect offset. */
874 Offset
= S_GET_VALUE (symbolP
);
876 /* Store the data reference. */
877 PUT_CHAR (TIR_S_C_STO_PIDR
);
878 /* Store the counted string as data. */
881 Size
= strlen (cp1
) + 1;
885 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_DBG
);
888 /* Write a Traceback Block End record. */
891 VMS_TBT_Block_End (valueT Size
)
895 Local
[0] = 6; /* record length */
896 /* DST type is "block end"; simulate with a phony end routine. */
897 Local
[1] = DST_S_C_BLKEND
;
898 Local
[2] = 0; /* unused, must be zero */
899 COPY_LONG (&Local
[3], Size
);
900 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_DBG
);
904 /* Write a Line number <-> Program Counter correlation record. */
907 VMS_TBT_Line_PC_Correlation (int Line_Number
, int Offset
,
908 int Psect
, int Do_Delta
)
915 /* If not delta, set our PC/Line number correlation. */
916 cp
= &Local
[1]; /* Put size in Local[0] later. */
917 /* DST type is "Line Number/PC correlation". */
918 *cp
++ = DST_S_C_LINE_NUM
;
919 /* Set Line number. */
920 if (Line_Number
- 1 <= 255)
922 *cp
++ = DST_S_C_SET_LINUM_B
;
923 *cp
++ = (char) (Line_Number
- 1);
925 else if (Line_Number
- 1 <= 65535)
927 *cp
++ = DST_S_C_SET_LINE_NUM
;
928 COPY_SHORT (cp
, Line_Number
- 1), cp
+= 2;
932 *cp
++ = DST_S_C_SET_LINUM_L
;
933 COPY_LONG (cp
, Line_Number
- 1), cp
+= 4;
936 *cp
++ = DST_S_C_SET_ABS_PC
;
937 /* Store size now that we know it, then output the data. */
938 Local
[0] = cp
- &Local
[1];
939 /* Account for the space that TIR_S_C_STO_PIDR will use for the PC. */
940 Local
[0] += 4; /* size includes length of another longword */
941 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
942 /* Make sure we are still generating a OBJ_S_C_TBT record. */
943 if (Object_Record_Offset
== 0)
944 PUT_CHAR (OBJ_S_C_TBT
);
945 vms_tir_stack_psect (Psect
, Offset
, 0);
946 PUT_CHAR (TIR_S_C_STO_PIDR
);
947 /* Do a PC offset of 0 to register the line number. */
949 Local
[1] = DST_S_C_LINE_NUM
;
950 Local
[2] = 0; /* Increment PC by 0 and register line # */
951 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_TBT
);
957 /* When delta is negative, terminate the line numbers. */
958 Local
[0] = 1 + 1 + 4;
959 Local
[1] = DST_S_C_LINE_NUM
;
960 Local
[2] = DST_S_C_TERM_L
;
961 COPY_LONG (&Local
[3], Offset
);
962 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_TBT
);
965 /* Do a PC/Line delta. */
967 *cp
++ = DST_S_C_LINE_NUM
;
970 /* We need to increment the line number. */
971 if (Line_Number
- 1 <= 255)
973 *cp
++ = DST_S_C_INCR_LINUM
;
974 *cp
++ = Line_Number
- 1;
976 else if (Line_Number
- 1 <= 65535)
978 *cp
++ = DST_S_C_INCR_LINUM_W
;
979 COPY_SHORT (cp
, Line_Number
- 1), cp
+= 2;
983 *cp
++ = DST_S_C_INCR_LINUM_L
;
984 COPY_LONG (cp
, Line_Number
- 1), cp
+= 4;
987 /* Increment the PC. */
990 /* Small offsets are encoded as negative numbers, rather than the
991 usual non-negative type code followed by another data field. */
992 *cp
++ = (char) -Offset
;
994 else if (Offset
<= 65535)
996 *cp
++ = DST_S_C_DELTA_PC_W
;
997 COPY_SHORT (cp
, Offset
), cp
+= 2;
1001 *cp
++ = DST_S_C_DELTA_PC_L
;
1002 COPY_LONG (cp
, Offset
), cp
+= 4;
1004 /* Set size now that be know it, then output the data. */
1005 Local
[0] = cp
- &Local
[1];
1006 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1011 /* Describe a source file to the debugger. */
1014 VMS_TBT_Source_File (char *Filename
, int ID_Number
)
1017 int len
, rfo
, ffb
, ebk
;
1020 #ifdef VMS /* Used for native assembly */
1022 struct FAB fab
; /* RMS file access block */
1023 struct NAM nam
; /* file name information */
1024 struct XABDAT xabdat
; /* date+time fields */
1025 struct XABFHC xabfhc
; /* file header characteristics */
1026 char resultant_string_buffer
[255 + 1];
1028 /* Set up RMS structures: */
1029 /* FAB -- file access block */
1030 memset ((char *) &fab
, 0, sizeof fab
);
1031 fab
.fab$b_bid
= FAB$C_BID
;
1032 fab
.fab$b_bln
= (unsigned char) sizeof fab
;
1033 fab
.fab$l_fna
= Filename
;
1034 fab
.fab$b_fns
= (unsigned char) strlen (Filename
);
1035 fab
.fab$l_nam
= (char *) &nam
;
1036 fab
.fab$l_xab
= (char *) &xabdat
;
1037 /* NAM -- file name block. */
1038 memset ((char *) &nam
, 0, sizeof nam
);
1039 nam
.nam$b_bid
= NAM$C_BID
;
1040 nam
.nam$b_bln
= (unsigned char) sizeof nam
;
1041 nam
.nam$l_rsa
= resultant_string_buffer
;
1042 nam
.nam$b_rss
= (unsigned char) (sizeof resultant_string_buffer
- 1);
1043 /* XABs -- extended attributes blocks. */
1044 memset ((char *) &xabdat
, 0, sizeof xabdat
);
1045 xabdat
.xab$b_cod
= XAB$C_DAT
;
1046 xabdat
.xab$b_bln
= (unsigned char) sizeof xabdat
;
1047 xabdat
.xab$l_nxt
= (char *) &xabfhc
;
1048 memset ((char *) &xabfhc
, 0, sizeof xabfhc
);
1049 xabfhc
.xab$b_cod
= XAB$C_FHC
;
1050 xabfhc
.xab$b_bln
= (unsigned char) sizeof xabfhc
;
1051 xabfhc
.xab$l_nxt
= 0;
1053 /* Get the file information. */
1054 Status
= sys$
open (&fab
);
1057 as_tsktsk (_("Couldn't find source file \"%s\", status=%%X%x"),
1062 /* Now extract fields of interest. */
1063 memcpy (cdt
, (char *) &xabdat
.xab$q_cdt
, 8); /* creation date */
1064 ebk
= xabfhc
.xab$l_ebk
; /* end-of-file block */
1065 ffb
= xabfhc
.xab$w_ffb
; /* first free byte of last block */
1066 rfo
= xabfhc
.xab$b_rfo
; /* record format */
1067 len
= nam
.nam$b_rsl
; /* length of Filename */
1068 resultant_string_buffer
[len
] = '\0';
1069 Filename
= resultant_string_buffer
; /* full filename */
1070 #else /* Cross-assembly */
1071 /* [Perhaps we ought to use actual values derived from stat() here?] */
1072 memset (cdt
, 0, 8); /* null VMS quadword binary time */
1073 ebk
= ffb
= rfo
= 0;
1074 len
= strlen (Filename
);
1075 if (len
> 255) /* a single byte is used as count prefix */
1077 Filename
+= (len
- 255); /* tail end is more significant */
1082 cp
= &Local
[1]; /* fill in record length later */
1083 *cp
++ = DST_S_C_SOURCE
; /* DST type is "source file" */
1084 *cp
++ = DST_S_C_SRC_FORMFEED
; /* formfeeds count as source records */
1085 *cp
++ = DST_S_C_SRC_DECLFILE
; /* declare source file */
1086 know (cp
== &Local
[4]);
1087 *cp
++ = 0; /* fill in this length below */
1088 *cp
++ = 0; /* flags; must be zero */
1089 COPY_SHORT (cp
, ID_Number
), cp
+= 2; /* file ID number */
1090 memcpy (cp
, cdt
, 8), cp
+= 8; /* creation date+time */
1091 COPY_LONG (cp
, ebk
), cp
+= 4; /* end-of-file block */
1092 COPY_SHORT (cp
, ffb
), cp
+= 2; /* first free byte of last block */
1093 *cp
++ = (char) rfo
; /* RMS record format */
1097 *cp
++ = *Filename
++;
1098 /* Library module name (none). */
1100 /* Now that size is known, fill it in and write out the record. */
1101 Local
[4] = cp
- &Local
[5]; /* source file declaration size */
1102 Local
[0] = cp
- &Local
[1]; /* TBT record size */
1103 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1107 /* Traceback information is described in terms of lines from compiler
1108 listing files, not lines from source files. We need to set up the
1109 correlation between listing line numbers and source line numbers.
1110 Since gcc's .stabn directives refer to the source lines, we just
1111 need to describe a one-to-one correspondence. */
1114 VMS_TBT_Source_Lines (int ID_Number
, int Starting_Line_Number
,
1115 int Number_Of_Lines
)
1119 char Local
[128]; /* room enough to describe 1310700 lines... */
1121 cp
= &Local
[1]; /* Put size in Local[0] later. */
1122 *cp
++ = DST_S_C_SOURCE
; /* DST type is "source file". */
1123 *cp
++ = DST_S_C_SRC_SETFILE
; /* Set Source File. */
1124 COPY_SHORT (cp
, ID_Number
), cp
+= 2; /* File ID Number. */
1125 /* Set record number and define lines. Since no longword form of
1126 SRC_DEFLINES is available, we need to be able to cope with any huge
1127 files a chunk at a time. It doesn't matter for tracebacks, since
1128 unspecified lines are mapped one-to-one and work out right, but it
1129 does matter within the debugger. Without this explicit mapping,
1130 it will complain about lines not existing in the module. */
1131 chunk_limit
= (sizeof Local
- 5) / 6;
1132 if (Number_Of_Lines
> 65535 * chunk_limit
) /* avoid buffer overflow */
1133 Number_Of_Lines
= 65535 * chunk_limit
;
1134 while (Number_Of_Lines
> 65535)
1136 *cp
++ = DST_S_C_SRC_SETREC_L
;
1137 COPY_LONG (cp
, Starting_Line_Number
), cp
+= 4;
1138 *cp
++ = DST_S_C_SRC_DEFLINES_W
;
1139 COPY_SHORT (cp
, 65535), cp
+= 2;
1140 Starting_Line_Number
+= 65535;
1141 Number_Of_Lines
-= 65535;
1143 /* Set record number and define lines, normal case. */
1144 if (Starting_Line_Number
<= 65535)
1146 *cp
++ = DST_S_C_SRC_SETREC_W
;
1147 COPY_SHORT (cp
, Starting_Line_Number
), cp
+= 2;
1151 *cp
++ = DST_S_C_SRC_SETREC_L
;
1152 COPY_LONG (cp
, Starting_Line_Number
), cp
+= 4;
1154 *cp
++ = DST_S_C_SRC_DEFLINES_W
;
1155 COPY_SHORT (cp
, Number_Of_Lines
), cp
+= 2;
1156 /* Set size now that be know it, then output the data. */
1157 Local
[0] = cp
- &Local
[1];
1158 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1162 /* Debugger Information support routines. */
1164 /* This routine locates a file in the list of files. If an entry does
1165 not exist, one is created. For include files, a new entry is always
1166 created such that inline functions can be properly debugged. */
1168 static struct input_file
*
1169 find_file (symbolS
*sp
)
1171 struct input_file
*same_file
= 0;
1172 struct input_file
*fpnt
, *last
= 0;
1175 for (fpnt
= file_root
; fpnt
; fpnt
= fpnt
->next
)
1177 if (fpnt
->spnt
== sp
)
1181 sp_name
= S_GET_NAME (sp
);
1182 for (fpnt
= file_root
; fpnt
; fpnt
= fpnt
->next
)
1184 if (strcmp (sp_name
, fpnt
->name
) == 0)
1186 if (fpnt
->flag
== 1)
1192 fpnt
= xmalloc (sizeof (struct input_file
));
1198 fpnt
->name
= sp_name
;
1199 fpnt
->min_line
= 0x7fffffff;
1203 fpnt
->file_number
= 0;
1205 fpnt
->same_file_fpnt
= same_file
;
1209 /* This routine converts a number string into an integer, and stops when
1210 it sees an invalid character. The return value is the address of the
1211 character just past the last character read. No error is generated. */
1214 cvt_integer (char *str
, int *rtn
)
1216 int ival
= 0, sgn
= 1;
1220 while (*str
>= '0' && *str
<= '9')
1221 ival
= 10 * ival
+ *str
++ - '0';
1227 /* The following functions and definitions are used to generate object
1228 records that will describe program variables to the VMS debugger.
1230 This file contains many of the routines needed to output debugging info
1231 into the object file that the VMS debugger needs to understand symbols.
1232 These routines are called very late in the assembly process, and thus
1233 we can be fairly lax about changing things, since the GSD and the TIR
1234 sections have already been output. */
1236 /* This routine fixes the names that are generated by C++, ".this" is a good
1237 example. The period does not work for the debugger, since it looks like
1238 the syntax for a structure element, and thus it gets mightily confused.
1240 We also use this to strip the PsectAttribute hack from the name before we
1241 write a debugger record. */
1244 fix_name (char *pnt
)
1248 /* Kill any leading "_". */
1252 /* Is there a Psect Attribute to skip?? */
1253 if (HAS_PSECT_ATTRIBUTES (pnt
))
1256 pnt
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
1259 if ((pnt
[0] == '$') && (pnt
[1] == '$'))
1268 /* Here we fix the .this -> $this conversion. */
1269 for (pnt1
= pnt
; *pnt1
!= 0; pnt1
++)
1276 /* When defining a structure, this routine is called to find the name of
1277 the actual structure. It is assumed that str points to the equal sign
1278 in the definition, and it moves backward until it finds the start of the
1279 name. If it finds a 0, then it knows that this structure def is in the
1280 outermost level, and thus symbol_name points to the symbol name. */
1283 get_struct_name (char *str
)
1287 while ((*pnt
!= ':') && (*pnt
!= '\0'))
1290 return (char *) symbol_name
;
1292 while ((*pnt
!= ';') && (*pnt
!= '='))
1296 while ((*pnt
< '0') || (*pnt
> '9'))
1298 while ((*pnt
>= '0') && (*pnt
<= '9'))
1303 /* Search symbol list for type number dbx_type.
1304 Return a pointer to struct. */
1306 static struct VMS_DBG_Symbol
*
1307 find_symbol (int dbx_type
)
1309 struct VMS_DBG_Symbol
*spnt
;
1311 spnt
= VMS_Symbol_type_list
[SYMTYP_HASH (dbx_type
)];
1314 if (spnt
->dbx_type
== dbx_type
)
1318 if (!spnt
|| spnt
->advanced
!= ALIAS
)
1320 return find_symbol (spnt
->type2
);
1324 fpush (int value
, int size
)
1326 if (Apoint
+ size
>= MAX_DEBUG_RECORD
)
1329 Apoint
= MAX_DEBUG_RECORD
- 1;
1333 Asuffix
[Apoint
++] = (char) value
;
1336 md_number_to_chars (&Asuffix
[Apoint
], value
, size
);
1342 rpush (int value
, int size
)
1351 Local
[Lpnt
--] = (char) value
;
1355 md_number_to_chars (&Local
[Lpnt
+ 1], value
, size
);
1359 /* This routine generates the array descriptor for a given array. */
1362 array_suffix (struct VMS_DBG_Symbol
*spnt2
)
1364 struct VMS_DBG_Symbol
*spnt
;
1365 struct VMS_DBG_Symbol
*spnt1
;
1371 while (spnt
->advanced
!= ARRAY
)
1373 spnt
= find_symbol (spnt
->type2
);
1379 while (spnt1
->advanced
== ARRAY
)
1382 total_size
*= (spnt1
->index_max
- spnt1
->index_min
+ 1);
1383 spnt1
= find_symbol (spnt1
->type2
);
1385 total_size
= total_size
* spnt1
->data_size
;
1386 fpush (spnt1
->data_size
, 2); /* element size */
1387 if (spnt1
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
1390 fpush (spnt1
->VMS_type
, 1); /* element type */
1391 fpush (DSC_K_CLASS_A
, 1); /* descriptor class */
1392 fpush (0, 4); /* base address */
1393 fpush (0, 1); /* scale factor -- not applicable */
1394 fpush (0, 1); /* digit count -- not applicable */
1395 fpush (0xc0, 1); /* flags: multiplier block & bounds present */
1396 fpush (rank
, 1); /* number of dimensions */
1397 fpush (total_size
, 4);
1398 fpush (0, 4); /* pointer to element [0][0]...[0] */
1400 while (spnt1
->advanced
== ARRAY
)
1402 fpush (spnt1
->index_max
- spnt1
->index_min
+ 1, 4);
1403 spnt1
= find_symbol (spnt1
->type2
);
1406 while (spnt1
->advanced
== ARRAY
)
1408 fpush (spnt1
->index_min
, 4);
1409 fpush (spnt1
->index_max
, 4);
1410 spnt1
= find_symbol (spnt1
->type2
);
1414 /* This routine generates the start of a variable descriptor based upon
1415 a struct/union/enum that has yet to be defined. We define this spot as
1416 a new location, and save four bytes for the address. When the struct is
1417 finally defined, then we can go back and plug in the correct address. */
1420 new_forward_ref (int dbx_type
)
1422 struct forward_ref
*fpnt
;
1424 fpnt
= xmalloc (sizeof (struct forward_ref
));
1425 fpnt
->next
= f_ref_root
;
1427 fpnt
->dbx_type
= dbx_type
;
1428 fpnt
->struc_numb
= ++structure_count
;
1429 fpnt
->resolved
= 'N';
1430 rpush (DST_K_TS_IND
, 1); /* indirect type specification */
1432 rpush (total_len
, 2);
1433 struct_number
= -fpnt
->struc_numb
;
1436 /* This routine generates the variable descriptor used to describe non-basic
1437 variables. It calls itself recursively until it gets to the bottom of it
1438 all, and then builds the descriptor backwards. It is easiest to do it
1439 this way since we must periodically write length bytes, and it is easiest
1440 if we know the value when it is time to write it. */
1443 gen1 (struct VMS_DBG_Symbol
*spnt
, int array_suffix_len
)
1445 struct VMS_DBG_Symbol
*spnt1
;
1448 switch (spnt
->advanced
)
1451 rpush (DBG_S_C_VOID
, 1);
1453 rpush (total_len
, 2);
1457 if (array_suffix_len
== 0)
1459 rpush (spnt
->VMS_type
, 1);
1460 rpush (DBG_S_C_BASIC
, 1);
1462 rpush (total_len
, 2);
1466 rpush (DST_K_VFLAGS_DSC
, 1);
1467 rpush (DST_K_TS_DSC
, 1); /* Descriptor type specification. */
1473 struct_number
= spnt
->struc_numb
;
1474 if (struct_number
< 0)
1476 new_forward_ref (spnt
->dbx_type
);
1479 rpush (DBG_S_C_STRUCT
, 1);
1481 rpush (total_len
, 2);
1484 spnt1
= find_symbol (spnt
->type2
);
1487 new_forward_ref (spnt
->type2
);
1489 i
= gen1 (spnt1
, 0);
1492 /* (*void) is a special case, do not put pointer suffix. */
1493 rpush (DBG_S_C_POINTER
, 1);
1495 rpush (total_len
, 2);
1500 while (spnt1
->advanced
== ARRAY
)
1502 spnt1
= find_symbol (spnt1
->type2
);
1505 as_tsktsk (_("debugger forward reference error, dbx type %d"),
1510 /* It is too late to generate forward references, so the user
1511 gets a message. This should only happen on a compiler error. */
1512 (void) gen1 (spnt1
, 1);
1514 array_suffix (spnt
);
1515 array_suffix_len
= Apoint
- i
;
1516 switch (spnt1
->advanced
)
1524 rpush (total_len
, 2);
1525 rpush (DST_K_VFLAGS_DSC
, 1);
1526 rpush (1, 1); /* Flags: element value spec included. */
1527 rpush (1, 1); /* One dimension. */
1528 rpush (DBG_S_C_COMPLEX_ARRAY
, 1);
1530 total_len
+= array_suffix_len
+ 8;
1531 rpush (total_len
, 2);
1539 /* This generates a suffix for a variable. If it is not a defined type yet,
1540 then dbx_type contains the type we are expecting so we can generate a
1541 forward reference. This calls gen1 to build most of the descriptor, and
1542 then it puts the icing on at the end. It then dumps whatever is needed
1543 to get a complete descriptor (i.e. struct reference, array suffix). */
1546 generate_suffix (struct VMS_DBG_Symbol
*spnt
, int dbx_type
)
1548 static const char pvoid
[6] =
1550 5, /* record.length == 5 */
1551 DST_K_TYPSPEC
, /* record.type == 1 (type specification) */
1552 0, /* name.length == 0, no name follows */
1553 1, 0, /* type.length == 1 {2 bytes, little endian} */
1554 DBG_S_C_VOID
/* type.type == 5 (pointer to unspecified) */
1559 Lpnt
= MAX_DEBUG_RECORD
- 1;
1564 new_forward_ref (dbx_type
);
1567 if (spnt
->VMS_type
!= DBG_S_C_ADVANCED_TYPE
)
1568 return; /* no suffix needed */
1571 rpush (0, 1); /* no name (len==0) */
1572 rpush (DST_K_TYPSPEC
, 1);
1574 rpush (total_len
, 1);
1575 /* If the variable descriptor overflows the record, output a descriptor
1576 for a pointer to void. */
1577 if ((total_len
>= MAX_DEBUG_RECORD
) || overflow
)
1579 as_warn (_("Variable descriptor %d too complicated. Defined as `void *'."),
1581 VMS_Store_Immediate_Data (pvoid
, 6, OBJ_S_C_DBG
);
1585 while (Lpnt
< MAX_DEBUG_RECORD
- 1)
1586 Local
[i
++] = Local
[++Lpnt
];
1588 /* We use this for reference to structure that has already been defined. */
1589 if (struct_number
> 0)
1591 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1593 VMS_Store_Struct (struct_number
);
1595 /* We use this for a forward reference to a structure that has yet to
1596 be defined. We store four bytes of zero to make room for the actual
1597 address once it is known. */
1598 if (struct_number
< 0)
1600 struct_number
= -struct_number
;
1601 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1603 VMS_Def_Struct (struct_number
);
1604 COPY_LONG (&Local
[Lpnt
], 0L);
1606 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1611 Local
[Lpnt
++] = Asuffix
[i
++];
1613 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1617 /* "novel length" type doesn't work for simple atomic types. */
1618 #define USE_BITSTRING_DESCRIPTOR(t) ((t)->advanced == BASIC)
1619 #undef SETUP_BASIC_TYPES
1621 /* This routine generates a type description for a bitfield. */
1624 bitfield_suffix (struct VMS_DBG_Symbol
*spnt
, int width
)
1626 Local
[Lpnt
++] = 13; /* rec.len==13 */
1627 Local
[Lpnt
++] = DST_K_TYPSPEC
; /* a type specification record */
1628 Local
[Lpnt
++] = 0; /* not named */
1629 COPY_SHORT (&Local
[Lpnt
], 9); /* typ.len==9 */
1631 Local
[Lpnt
++] = DST_K_TS_NOV_LENG
; /* This type is a "novel length"
1632 incarnation of some other type. */
1633 COPY_LONG (&Local
[Lpnt
], width
); /* size in bits == novel length */
1635 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1637 /* assert( spnt->struc_numb > 0 ); */
1638 VMS_Store_Struct (spnt
->struc_numb
); /* output 4 more bytes */
1641 /* Formally define a builtin type, so that it can serve as the target of
1642 an indirect reference. It makes bitfield_suffix() easier by avoiding
1643 the need to use a forward reference for the first occurrence of each
1644 type used in a bitfield. */
1647 setup_basic_type (struct VMS_DBG_Symbol
*spnt ATTRIBUTE_UNUSED
)
1649 #ifdef SETUP_BASIC_TYPES
1650 /* This would be very useful if "novel length" fields actually worked
1651 with basic types like they do with enumerated types. However,
1652 they do not, so this isn't worth doing just so that you can use
1653 EXAMINE/TYPE=(__long_long_int) instead of EXAMINE/QUAD. */
1655 #ifndef SETUP_SYNONYM_TYPES
1656 /* This determines whether compatible things like `int' and `long int'
1657 ought to have distinct type records rather than sharing one. */
1658 struct VMS_DBG_Symbol
*spnt2
;
1660 /* First check whether this type has already been seen by another name. */
1661 for (spnt2
= VMS_Symbol_type_list
[SYMTYP_HASH (spnt
->VMS_type
)];
1663 spnt2
= spnt2
->next
)
1664 if (spnt2
!= spnt
&& spnt2
->VMS_type
== spnt
->VMS_type
)
1666 spnt
->struc_numb
= spnt2
->struc_numb
;
1671 /* `structure number' doesn't really mean `structure'; it means an index
1672 into a linker maintained set of saved locations which can be referenced
1674 spnt
->struc_numb
= ++structure_count
;
1675 VMS_Def_Struct (spnt
->struc_numb
); /* remember where this type lives */
1676 /* define the simple scalar type */
1677 Local
[Lpnt
++] = 6 + strlen (symbol_name
) + 2; /* rec.len */
1678 Local
[Lpnt
++] = DST_K_TYPSPEC
; /* rec.typ==type specification */
1679 Local
[Lpnt
++] = strlen (symbol_name
) + 2;
1680 Local
[Lpnt
++] = '_'; /* prefix name with "__" */
1681 Local
[Lpnt
++] = '_';
1682 for (p
= symbol_name
; *p
; p
++)
1683 Local
[Lpnt
++] = *p
== ' ' ? '_' : *p
;
1684 COPY_SHORT (&Local
[Lpnt
], 2); /* typ.len==2 */
1686 Local
[Lpnt
++] = DST_K_TS_ATOM
; /* typ.kind is simple type */
1687 Local
[Lpnt
++] = spnt
->VMS_type
; /* typ.type */
1688 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1690 #endif /* SETUP_BASIC_TYPES */
1693 /* This routine generates a symbol definition for a C symbol for the
1694 debugger. It takes a psect and offset for global symbols; if psect < 0,
1695 then this is a local variable and the offset is relative to FP. In this
1696 case it can be either a variable (Offset < 0) or a parameter (Offset > 0). */
1699 VMS_DBG_record (struct VMS_DBG_Symbol
*spnt
, int Psect
,
1700 int Offset
, char *Name
)
1706 /* If there are bad characters in name, convert them. */
1707 Name_pnt
= fix_name (Name
);
1709 len
= strlen (Name_pnt
);
1712 /* This is a local variable, referenced to SP. */
1713 Local
[i
++] = 7 + len
;
1714 Local
[i
++] = spnt
->VMS_type
;
1715 Local
[i
++] = (Offset
> 0) ? DBG_C_FUNCTION_PARAM
: DBG_C_LOCAL_SYM
;
1716 COPY_LONG (&Local
[i
], Offset
);
1721 Local
[i
++] = 7 + len
;
1722 Local
[i
++] = spnt
->VMS_type
;
1723 Local
[i
++] = DST_K_VALKIND_ADDR
;
1724 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
1726 VMS_Set_Data (Psect
, Offset
, OBJ_S_C_DBG
, 0);
1729 while (*Name_pnt
!= '\0')
1730 Local
[i
++] = *Name_pnt
++;
1731 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
1732 if (spnt
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
1733 generate_suffix (spnt
, 0);
1736 /* This routine parses the stabs entries in order to make the definition
1737 for the debugger of local symbols and function parameters. */
1740 VMS_local_stab_Parse (symbolS
*sp
)
1742 struct VMS_DBG_Symbol
*spnt
;
1749 str
= S_GET_NAME (sp
);
1750 pnt
= (char *) strchr (str
, ':');
1754 /* Save this for later, and skip colon. */
1757 /* Ignore static constants. */
1761 /* There is one little catch that we must be aware of. Sometimes function
1762 parameters are optimized into registers, and the compiler, in its
1763 infiite wisdom outputs stabs records for *both*. In general we want to
1764 use the register if it is present, so we must search the rest of the
1765 symbols for this function to see if this parameter is assigned to a
1774 for (sp1
= symbol_next (sp
); sp1
; sp1
= symbol_next (sp1
))
1776 if (!S_IS_DEBUG (sp1
))
1778 if (S_GET_RAW_TYPE (sp1
) == N_FUN
)
1780 pnt2
= (char *) strchr (S_GET_NAME (sp1
), ':') + 1;
1781 if (*pnt2
== 'F' || *pnt2
== 'f')
1784 if (S_GET_RAW_TYPE (sp1
) != N_RSYM
)
1786 str1
= S_GET_NAME (sp1
); /* and get the name */
1788 while (*pnt2
!= ':')
1795 if (*str1
== ':' && *pnt2
== ':')
1796 return; /* They are the same! Let's skip this one. */
1799 /* Skip p in case no register. */
1804 pnt
= cvt_integer (pnt
, &dbx_type
);
1806 spnt
= find_symbol (dbx_type
);
1808 /* Dunno what this is. */
1812 VMS_DBG_record (spnt
, -1, S_GET_VALUE (sp
), str
);
1814 /* ...and restore the string. */
1818 /* This routine parses a stabs entry to find the information required
1819 to define a variable. It is used for global and static variables.
1820 Basically we need to know the address of the symbol. With older
1821 versions of the compiler, const symbols are treated differently, in
1822 that if they are global they are written into the text psect. The
1823 global symbol entry for such a const is actually written as a program
1824 entry point (Yuk!!), so if we cannot find a symbol in the list of
1825 psects, we must search the entry points as well. static consts are
1826 even harder, since they are never assigned a memory address. The
1827 compiler passes a stab to tell us the value, but I am not sure what
1831 VMS_stab_parse (symbolS
*sp
, int expected_type
,
1832 int type1
, int type2
, int Text_Psect
)
1838 struct VMS_DBG_Symbol
*spnt
;
1839 struct VMS_Symbol
*vsp
;
1843 str
= S_GET_NAME (sp
);
1845 pnt
= (char *) strchr (str
, ':');
1847 /* No colon present. */
1850 /* Save this for later. */
1853 if (*pnt
== expected_type
)
1855 pnt
= cvt_integer (pnt
+ 1, &dbx_type
);
1856 spnt
= find_symbol (dbx_type
);
1858 return; /*Dunno what this is*/
1859 /* Now we need to search the symbol table to find the psect and
1860 offset for this variable. */
1865 pnt
= S_GET_NAME (vsp
->Symbol
);
1866 if (pnt
&& *pnt
++ == '_'
1867 /* make sure name is the same and symbol type matches */
1868 && strcmp (pnt
, str
) == 0
1869 && (S_GET_RAW_TYPE (vsp
->Symbol
) == type1
1870 || S_GET_RAW_TYPE (vsp
->Symbol
) == type2
))
1876 VMS_DBG_record (spnt
, vsp
->Psect_Index
, vsp
->Psect_Offset
, str
);
1877 *pnt1
= ':'; /* and restore the string */
1880 /* The symbol was not in the symbol list, but it may be an
1881 "entry point" if it was a constant. */
1882 for (sp1
= symbol_rootP
; sp1
; sp1
= symbol_next (sp1
))
1884 /* Dispatch on STAB type. */
1885 if (S_IS_DEBUG (sp1
) || (S_GET_TYPE (sp1
) != N_TEXT
))
1887 pnt
= S_GET_NAME (sp1
);
1890 if (strcmp (pnt
, str
) == 0)
1892 if (!gave_compiler_message
&& expected_type
== 'G')
1894 char *long_const_msg
= _("\
1895 ***Warning - the assembly code generated by the compiler has placed \n\
1896 global constant(s) in the text psect. These will not be available to \n\
1897 other modules, since this is not the correct way to handle this. You \n\
1898 have two options: 1) get a patched compiler that does not put global \n\
1899 constants in the text psect, or 2) remove the 'const' keyword from \n\
1900 definitions of global variables in your source module(s). Don't say \n\
1901 I didn't warn you! \n");
1903 as_tsktsk (long_const_msg
);
1904 gave_compiler_message
= 1;
1906 VMS_DBG_record (spnt
,
1911 /* Fool assembler to not output this as a routine in the TBT. */
1912 pnt1
= S_GET_NAME (sp1
);
1914 S_SET_NAME (sp1
, pnt1
);
1920 /* ...and restore the string. */
1924 /* Simpler interfaces into VMS_stab_parse(). */
1927 VMS_GSYM_Parse (symbolS
*sp
, int Text_Psect
)
1928 { /* Global variables */
1929 VMS_stab_parse (sp
, 'G', (N_UNDF
| N_EXT
), (N_DATA
| N_EXT
), Text_Psect
);
1933 VMS_LCSYM_Parse (symbolS
*sp
, int Text_Psect
)
1935 VMS_stab_parse (sp
, 'S', N_BSS
, -1, Text_Psect
);
1939 VMS_STSYM_Parse (symbolS
*sp
, int Text_Psect
)
1941 VMS_stab_parse (sp
, 'S', N_DATA
, -1, Text_Psect
);
1944 /* For register symbols, we must figure out what range of addresses
1945 within the psect are valid. We will use the brackets in the stab
1946 directives to give us guidance as to the PC range that this variable
1947 is in scope. I am still not completely comfortable with this but
1948 as I learn more, I seem to get a better handle on what is going on.
1952 VMS_RSYM_Parse (symbolS
*sp
, symbolS
*Current_Routine ATTRIBUTE_UNUSED
,
1956 struct VMS_DBG_Symbol
*spnt
;
1964 int Min_Offset
= -1; /* min PC of validity */
1965 int Max_Offset
= 0; /* max PC of validity */
1967 for (symbolP
= sp
; symbolP
; symbolP
= symbol_next (symbolP
))
1969 /* Dispatch on STAB type. */
1970 switch (S_GET_RAW_TYPE (symbolP
))
1974 Min_Offset
= S_GET_VALUE (symbolP
);
1978 Max_Offset
= S_GET_VALUE (symbolP
) - 1;
1981 if ((Min_Offset
!= -1) && (bcnt
== 0))
1983 if (S_GET_RAW_TYPE (symbolP
) == N_FUN
)
1985 pnt
= (char *) strchr (S_GET_NAME (symbolP
), ':') + 1;
1986 if (*pnt
== 'F' || *pnt
== 'f') break;
1990 /* Check to see that the addresses were defined. If not, then there
1991 were no brackets in the function, and we must try to search for
1992 the next function. Since functions can be in any order, we should
1993 search all of the symbol list to find the correct ending address. */
1994 if (Min_Offset
== -1)
1996 int Max_Source_Offset
;
1999 Min_Offset
= S_GET_VALUE (sp
);
2000 Max_Source_Offset
= Min_Offset
; /* just in case no N_SLINEs found */
2001 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2002 switch (S_GET_RAW_TYPE (symbolP
))
2004 case N_TEXT
| N_EXT
:
2005 This_Offset
= S_GET_VALUE (symbolP
);
2006 if (This_Offset
> Min_Offset
&& This_Offset
< Max_Offset
)
2007 Max_Offset
= This_Offset
;
2010 This_Offset
= S_GET_VALUE (symbolP
);
2011 if (This_Offset
> Max_Source_Offset
)
2012 Max_Source_Offset
= This_Offset
;
2015 /* If this is the last routine, then we use the PC of the last source
2016 line as a marker of the max PC for which this reg is valid. */
2017 if (Max_Offset
== 0x7fffffff)
2018 Max_Offset
= Max_Source_Offset
;
2022 str
= S_GET_NAME (sp
);
2023 if ((pnt
= (char *) strchr (str
, ':')) == 0)
2024 return; /* no colon present */
2025 pnt1
= pnt
; /* save this for later*/
2029 pnt
= cvt_integer (pnt
+ 1, &dbx_type
);
2030 spnt
= find_symbol (dbx_type
);
2032 return; /*Dunno what this is yet*/
2034 pnt
= fix_name (S_GET_NAME (sp
)); /* if there are bad characters in name, convert them */
2036 Local
[i
++] = 25 + len
;
2037 Local
[i
++] = spnt
->VMS_type
;
2038 Local
[i
++] = DST_K_VFLAGS_TVS
; /* trailing value specified */
2039 COPY_LONG (&Local
[i
], 1 + len
); /* relative offset, beyond name */
2041 Local
[i
++] = len
; /* name length (ascic prefix) */
2042 while (*pnt
!= '\0')
2043 Local
[i
++] = *pnt
++;
2044 Local
[i
++] = DST_K_VS_FOLLOWS
; /* value specification follows */
2045 COPY_SHORT (&Local
[i
], 15); /* length of rest of record */
2047 Local
[i
++] = DST_K_VS_ALLOC_SPLIT
; /* split lifetime */
2048 Local
[i
++] = 1; /* one binding follows */
2049 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2051 VMS_Set_Data (Text_Psect
, Min_Offset
, OBJ_S_C_DBG
, 1);
2052 VMS_Set_Data (Text_Psect
, Max_Offset
, OBJ_S_C_DBG
, 1);
2053 Local
[i
++] = DST_K_VALKIND_REG
; /* nested value spec */
2054 COPY_LONG (&Local
[i
], S_GET_VALUE (sp
));
2056 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2058 if (spnt
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
2059 generate_suffix (spnt
, 0);
2062 /* This function examines a structure definition, checking all of the elements
2063 to make sure that all of them are fully defined. The only thing that we
2064 kick out are arrays of undefined structs, since we do not know how big
2065 they are. All others we can handle with a normal forward reference. */
2068 forward_reference (char *pnt
)
2070 struct VMS_DBG_Symbol
*spnt
, *spnt1
;
2073 pnt
= cvt_integer (pnt
+ 1, &i
);
2075 return 0; /* no forward references */
2078 pnt
= (char *) strchr (pnt
, ':');
2079 pnt
= cvt_integer (pnt
+ 1, &i
);
2080 spnt
= find_symbol (i
);
2081 while (spnt
&& (spnt
->advanced
== POINTER
|| spnt
->advanced
== ARRAY
))
2083 spnt1
= find_symbol (spnt
->type2
);
2084 if (spnt
->advanced
== ARRAY
&& !spnt1
)
2088 pnt
= cvt_integer (pnt
+ 1, &i
);
2089 pnt
= cvt_integer (pnt
+ 1, &i
);
2090 } while (*++pnt
!= ';');
2091 return 0; /* no forward references found */
2094 /* Used to check a single element of a structure on the final pass. */
2097 final_forward_reference (struct VMS_DBG_Symbol
*spnt
)
2099 struct VMS_DBG_Symbol
*spnt1
;
2101 while (spnt
&& (spnt
->advanced
== POINTER
|| spnt
->advanced
== ARRAY
))
2103 spnt1
= find_symbol (spnt
->type2
);
2104 if (spnt
->advanced
== ARRAY
&& !spnt1
)
2108 return 0; /* no forward references found */
2111 /* This routine parses the stabs directives to find any definitions of dbx
2112 type numbers. It makes a note of all of them, creating a structure
2113 element of VMS_DBG_Symbol that describes it. This also generates the
2114 info for the debugger that describes the struct/union/enum, so that
2115 further references to these data types will be by number
2117 We have to process pointers right away, since there can be references
2118 to them later in the same stabs directive. We cannot have forward
2119 references to pointers, (but we can have a forward reference to a
2120 pointer to a structure/enum/union) and this is why we process them
2121 immediately. After we process the pointer, then we search for defs
2122 that are nested even deeper.
2124 8/15/92: We have to process arrays right away too, because there can
2125 be multiple references to identical array types in one structure
2126 definition, and only the first one has the definition. */
2129 VMS_typedef_parse (char *str
)
2136 struct forward_ref
*fpnt
;
2137 int i1
, i2
, i3
, len
;
2138 struct VMS_DBG_Symbol
*spnt
;
2139 struct VMS_DBG_Symbol
*spnt1
;
2141 /* check for any nested def's */
2142 pnt
= (char *) strchr (str
+ 1, '=');
2143 if (pnt
&& str
[1] != '*' && (str
[1] != 'a' || str
[2] != 'r')
2144 && VMS_typedef_parse (pnt
) == 1)
2146 /* now find dbx_type of entry */
2149 { /* check for static constants */
2150 *str
= '\0'; /* for now we ignore them */
2153 while ((*pnt
<= '9') && (*pnt
>= '0'))
2155 pnt
++; /* and get back to the number */
2156 cvt_integer (pnt
, &i1
);
2157 spnt
= find_symbol (i1
);
2158 /* First see if this has been defined already, due to forward reference. */
2161 i2
= SYMTYP_HASH (i1
);
2162 spnt
= xmalloc (sizeof (struct VMS_DBG_Symbol
));
2163 spnt
->next
= VMS_Symbol_type_list
[i2
];
2164 VMS_Symbol_type_list
[i2
] = spnt
;
2165 spnt
->dbx_type
= i1
; /* and save the type */
2166 spnt
->type2
= spnt
->VMS_type
= spnt
->data_size
= 0;
2167 spnt
->index_min
= spnt
->index_max
= spnt
->struc_numb
= 0;
2170 /* For structs and unions, do a partial parse, otherwise we sometimes get
2171 circular definitions that are impossible to resolve. We read enough
2172 info so that any reference to this type has enough info to be resolved. */
2174 /* Point to character past equal sign. */
2177 if (*pnt
>= '0' && *pnt
<= '9')
2179 if (type_check ("void"))
2180 { /* this is the void symbol */
2182 spnt
->advanced
= VOID
;
2185 if (type_check ("unknown type"))
2188 spnt
->advanced
= UNKNOWN
;
2191 pnt1
= cvt_integer (pnt
, &i1
);
2192 if (i1
!= spnt
->dbx_type
)
2194 spnt
->advanced
= ALIAS
;
2199 as_tsktsk (_("debugginer output: %d is an unknown untyped variable."),
2201 return 1; /* do not know what this is */
2204 /* Point to character past equal sign. */
2210 spnt
->advanced
= BASIC
;
2211 if (type_check ("int"))
2213 spnt
->VMS_type
= DBG_S_C_SLINT
;
2214 spnt
->data_size
= 4;
2216 else if (type_check ("long int"))
2218 spnt
->VMS_type
= DBG_S_C_SLINT
;
2219 spnt
->data_size
= 4;
2221 else if (type_check ("unsigned int"))
2223 spnt
->VMS_type
= DBG_S_C_ULINT
;
2224 spnt
->data_size
= 4;
2226 else if (type_check ("long unsigned int"))
2228 spnt
->VMS_type
= DBG_S_C_ULINT
;
2229 spnt
->data_size
= 4;
2231 else if (type_check ("short int"))
2233 spnt
->VMS_type
= DBG_S_C_SSINT
;
2234 spnt
->data_size
= 2;
2236 else if (type_check ("short unsigned int"))
2238 spnt
->VMS_type
= DBG_S_C_USINT
;
2239 spnt
->data_size
= 2;
2241 else if (type_check ("char"))
2243 spnt
->VMS_type
= DBG_S_C_SCHAR
;
2244 spnt
->data_size
= 1;
2246 else if (type_check ("signed char"))
2248 spnt
->VMS_type
= DBG_S_C_SCHAR
;
2249 spnt
->data_size
= 1;
2251 else if (type_check ("unsigned char"))
2253 spnt
->VMS_type
= DBG_S_C_UCHAR
;
2254 spnt
->data_size
= 1;
2256 else if (type_check ("float"))
2258 spnt
->VMS_type
= DBG_S_C_REAL4
;
2259 spnt
->data_size
= 4;
2261 else if (type_check ("double"))
2263 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_REAL8_G
: DBG_S_C_REAL8
;
2264 spnt
->data_size
= 8;
2266 else if (type_check ("long double"))
2268 /* same as double, at least for now */
2269 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_REAL8_G
: DBG_S_C_REAL8
;
2270 spnt
->data_size
= 8;
2272 else if (type_check ("long long int"))
2274 spnt
->VMS_type
= DBG_S_C_SQUAD
; /* signed quadword */
2275 spnt
->data_size
= 8;
2277 else if (type_check ("long long unsigned int"))
2279 spnt
->VMS_type
= DBG_S_C_UQUAD
; /* unsigned quadword */
2280 spnt
->data_size
= 8;
2282 else if (type_check ("complex float"))
2284 spnt
->VMS_type
= DBG_S_C_COMPLX4
;
2285 spnt
->data_size
= 2 * 4;
2287 else if (type_check ("complex double"))
2289 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_COMPLX8_G
: DBG_S_C_COMPLX8
;
2290 spnt
->data_size
= 2 * 8;
2292 else if (type_check ("complex long double"))
2294 /* same as complex double, at least for now */
2295 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_COMPLX8_G
: DBG_S_C_COMPLX8
;
2296 spnt
->data_size
= 2 * 8;
2300 /* Shouldn't get here, but if we do, something
2301 more substantial ought to be done... */
2303 spnt
->data_size
= 0;
2305 if (spnt
->VMS_type
!= 0)
2306 setup_basic_type (spnt
);
2307 pnt1
= (char *) strchr (str
, ';') + 1;
2311 spnt
->advanced
= (*pnt
== 's') ? STRUCT
: UNION
;
2312 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2313 pnt1
= cvt_integer (pnt
+ 1, &spnt
->data_size
);
2314 if (!final_pass
&& forward_reference (pnt
))
2316 spnt
->struc_numb
= -1;
2319 spnt
->struc_numb
= ++structure_count
;
2321 pnt
= get_struct_name (str
);
2322 VMS_Def_Struct (spnt
->struc_numb
);
2324 for (fpnt
= f_ref_root
; fpnt
; fpnt
= fpnt
->next
)
2325 if (fpnt
->dbx_type
== spnt
->dbx_type
)
2327 fpnt
->resolved
= 'Y';
2328 VMS_Set_Struct (fpnt
->struc_numb
);
2329 VMS_Store_Struct (spnt
->struc_numb
);
2333 VMS_Set_Struct (spnt
->struc_numb
);
2335 Local
[i
++] = 11 + strlen (pnt
);
2336 Local
[i
++] = DBG_S_C_STRUCT_START
;
2337 Local
[i
++] = DST_K_VFLAGS_NOVAL
; /* structure definition only */
2338 COPY_LONG (&Local
[i
], 0L); /* hence value is unused */
2340 Local
[i
++] = strlen (pnt
);
2342 while (*pnt2
!= '\0')
2343 Local
[i
++] = *pnt2
++;
2344 i2
= spnt
->data_size
* 8; /* number of bits */
2345 COPY_LONG (&Local
[i
], i2
);
2347 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2349 if (pnt
!= symbol_name
)
2351 pnt
+= strlen (pnt
);
2352 /* Replace colon for later. */
2356 while (*++pnt1
!= ';')
2358 pnt
= (char *) strchr (pnt1
, ':');
2361 pnt1
= cvt_integer (pnt
+ 1, &dtype
);
2362 pnt1
= cvt_integer (pnt1
+ 1, &i2
);
2363 pnt1
= cvt_integer (pnt1
+ 1, &i3
);
2364 spnt1
= find_symbol (dtype
);
2365 len
= strlen (pnt2
);
2366 if (spnt1
&& (spnt1
->advanced
== BASIC
|| spnt1
->advanced
== ENUM
)
2367 && ((i3
!= spnt1
->data_size
* 8) || (i2
% 8 != 0)))
2369 if (USE_BITSTRING_DESCRIPTOR (spnt1
))
2371 /* This uses a type descriptor, which doesn't work if
2372 the enclosing structure has been placed in a register.
2373 Also, enum bitfields degenerate to simple integers. */
2374 int unsigned_type
= (spnt1
->VMS_type
== DBG_S_C_ULINT
2375 || spnt1
->VMS_type
== DBG_S_C_USINT
2376 || spnt1
->VMS_type
== DBG_S_C_UCHAR
2377 || spnt1
->VMS_type
== DBG_S_C_UQUAD
2378 || spnt1
->advanced
== ENUM
);
2380 fpush (19 + len
, 1);
2381 fpush (unsigned_type
? DBG_S_C_UBITU
: DBG_S_C_SBITU
, 1);
2382 fpush (DST_K_VFLAGS_DSC
, 1); /* specified by descriptor */
2383 fpush (1 + len
, 4); /* relative offset to descriptor */
2384 fpush (len
, 1); /* length byte (ascic prefix) */
2385 while (*pnt2
!= '\0') /* name bytes */
2387 fpush (i3
, 2); /* dsc length == size of bitfield */
2388 /* dsc type == un?signed bitfield */
2389 fpush (unsigned_type
? DBG_S_C_UBITU
: DBG_S_C_SBITU
, 1);
2390 fpush (DSC_K_CLASS_UBS
, 1); /* dsc class == unaligned bitstring */
2391 fpush (0x00, 4); /* dsc pointer == zeroes */
2392 fpush (i2
, 4); /* start position */
2393 VMS_Store_Immediate_Data (Asuffix
, Apoint
, OBJ_S_C_DBG
);
2398 /* Use a "novel length" type specification, which works
2399 right for register structures and for enum bitfields
2400 but results in larger object modules. */
2401 Local
[i
++] = 7 + len
;
2402 Local
[i
++] = DBG_S_C_ADVANCED_TYPE
; /* type spec follows */
2403 Local
[i
++] = DBG_S_C_STRUCT_ITEM
; /* value is a bit offset */
2404 COPY_LONG (&Local
[i
], i2
); /* bit offset */
2406 Local
[i
++] = strlen (pnt2
);
2407 while (*pnt2
!= '\0')
2408 Local
[i
++] = *pnt2
++;
2409 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2411 bitfield_suffix (spnt1
, i3
);
2414 else /* Not a bitfield. */
2416 /* Check if this is a forward reference. */
2417 if (final_pass
&& final_forward_reference (spnt1
))
2419 as_tsktsk (_("debugger output: structure element `%s' has undefined type"),
2423 Local
[i
++] = 7 + len
;
2424 Local
[i
++] = spnt1
? spnt1
->VMS_type
: DBG_S_C_ADVANCED_TYPE
;
2425 Local
[i
++] = DBG_S_C_STRUCT_ITEM
;
2426 COPY_LONG (&Local
[i
], i2
); /* bit offset */
2428 Local
[i
++] = strlen (pnt2
);
2429 while (*pnt2
!= '\0')
2430 Local
[i
++] = *pnt2
++;
2431 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2434 generate_suffix (spnt1
, dtype
);
2435 else if (spnt1
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
2436 generate_suffix (spnt1
, 0);
2440 Local
[i
++] = 0x01; /* length byte */
2441 Local
[i
++] = DBG_S_C_STRUCT_END
;
2442 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2446 spnt
->advanced
= ENUM
;
2447 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2448 spnt
->struc_numb
= ++structure_count
;
2449 spnt
->data_size
= 4;
2450 VMS_Def_Struct (spnt
->struc_numb
);
2452 for (fpnt
= f_ref_root
; fpnt
; fpnt
= fpnt
->next
)
2453 if (fpnt
->dbx_type
== spnt
->dbx_type
)
2455 fpnt
->resolved
= 'Y';
2456 VMS_Set_Struct (fpnt
->struc_numb
);
2457 VMS_Store_Struct (spnt
->struc_numb
);
2461 VMS_Set_Struct (spnt
->struc_numb
);
2463 len
= strlen (symbol_name
);
2464 Local
[i
++] = 3 + len
;
2465 Local
[i
++] = DBG_S_C_ENUM_START
;
2466 Local
[i
++] = 4 * 8; /* enum values are 32 bits */
2469 while (*pnt2
!= '\0')
2470 Local
[i
++] = *pnt2
++;
2471 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2473 while (*++pnt
!= ';')
2475 pnt1
= (char *) strchr (pnt
, ':');
2477 pnt1
= cvt_integer (pnt1
, &i1
);
2479 Local
[i
++] = 7 + len
;
2480 Local
[i
++] = DBG_S_C_ENUM_ITEM
;
2481 Local
[i
++] = DST_K_VALKIND_LITERAL
;
2482 COPY_LONG (&Local
[i
], i1
);
2486 while (*pnt
!= '\0')
2487 Local
[i
++] = *pnt
++;
2488 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2490 pnt
= pnt1
; /* Skip final semicolon */
2492 Local
[i
++] = 0x01; /* len byte */
2493 Local
[i
++] = DBG_S_C_ENUM_END
;
2494 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2499 spnt
->advanced
= ARRAY
;
2500 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2501 pnt
= (char *) strchr (pnt
, ';');
2504 pnt1
= cvt_integer (pnt
+ 1, &spnt
->index_min
);
2505 pnt1
= cvt_integer (pnt1
+ 1, &spnt
->index_max
);
2506 pnt1
= cvt_integer (pnt1
+ 1, &spnt
->type2
);
2507 pnt
= (char *) strchr (str
+ 1, '=');
2508 if (pnt
&& VMS_typedef_parse (pnt
) == 1)
2512 spnt
->advanced
= FUNCTION
;
2513 spnt
->VMS_type
= DBG_S_C_FUNCTION_ADDR
;
2514 /* this masquerades as a basic type*/
2515 spnt
->data_size
= 4;
2516 pnt1
= cvt_integer (pnt
+ 1, &spnt
->type2
);
2519 spnt
->advanced
= POINTER
;
2520 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2521 spnt
->data_size
= 4;
2522 pnt1
= cvt_integer (pnt
+ 1, &spnt
->type2
);
2523 pnt
= (char *) strchr (str
+ 1, '=');
2524 if (pnt
&& VMS_typedef_parse (pnt
) == 1)
2528 spnt
->advanced
= UNKNOWN
;
2530 as_tsktsk (_("debugger output: %d is an unknown type of variable."),
2532 return 1; /* unable to decipher */
2534 /* This removes the evidence of the definition so that the outer levels
2535 of parsing do not have to worry about it. */
2537 while (*pnt1
!= '\0')
2543 /* This is the root routine that parses the stabs entries for definitions.
2544 it calls VMS_typedef_parse, which can in turn call itself. We need to
2545 be careful, since sometimes there are forward references to other symbol
2546 types, and these cannot be resolved until we have completed the parse.
2548 Also check and see if we are using continuation stabs, if we are, then
2549 paste together the entire contents of the stab before we pass it to
2550 VMS_typedef_parse. */
2553 VMS_LSYM_Parse (void)
2559 char *parse_buffer
= 0;
2561 int incomplete
, pass
, incom1
;
2562 struct forward_ref
*fpnt
;
2570 incom1
= incomplete
;
2572 for (sp
= symbol_rootP
; sp
; sp
= symbol_next (sp
))
2574 /* Deal with STAB symbols. */
2575 if (S_IS_DEBUG (sp
))
2577 /* Dispatch on STAB type. */
2578 switch (S_GET_RAW_TYPE (sp
))
2586 case N_FUN
: /* Sometimes these contain typedefs. */
2587 str
= S_GET_NAME (sp
);
2589 pnt
= str
+ strlen (str
) - 1;
2590 if (*pnt
== '?') /* Continuation stab. */
2598 tlen
+= strlen (str
) - 1;
2599 spnext
= symbol_next (spnext
);
2600 str
= S_GET_NAME (spnext
);
2601 pnt
= str
+ strlen (str
) - 1;
2603 while (*pnt
== '?');
2605 tlen
+= strlen (str
);
2606 parse_buffer
= xmalloc (tlen
+ 1);
2607 strcpy (parse_buffer
, S_GET_NAME (sp
));
2608 pnt2
= parse_buffer
+ strlen (parse_buffer
) - 1;
2614 spnext
= symbol_next (spnext
);
2615 str
= S_GET_NAME (spnext
);
2617 pnt2
+= strlen (str
) - 1;
2618 *str
= '\0'; /* Erase this string */
2619 /* S_SET_NAME (spnext, str); */
2620 if (*pnt2
!= '?') break;
2629 if ((pnt
= (char *) strchr (str
, ':')) != 0)
2633 if ((pnt2
= (char *) strchr (pnt1
, '=')) != 0)
2634 incomplete
+= VMS_typedef_parse (pnt2
);
2637 /* At this point the parse buffer should just
2638 contain name:nn. If it does not, then we
2639 are in real trouble. Anyway, this is always
2640 shorter than the original line. */
2641 pnt2
= S_GET_NAME (sp
);
2642 strcpy (pnt2
, parse_buffer
);
2643 /* S_SET_NAME (sp, pnt2); */
2644 free (parse_buffer
), parse_buffer
= 0;
2646 /* Put back colon to restore dbx_type. */
2655 /* Make one last pass, if needed, and define whatever we can
2657 if (final_pass
== 0 && incomplete
== incom1
)
2660 incom1
++; /* Force one last pass through. */
2663 while (incomplete
!= 0 && incomplete
!= incom1
);
2665 if (incomplete
!= 0)
2666 as_tsktsk (_("debugger output: Unable to resolve %d circular references."),
2673 if (fpnt
->resolved
!= 'Y')
2675 if (find_symbol (fpnt
->dbx_type
))
2677 as_tsktsk (_("debugger forward reference error, dbx type %d"),
2682 sprintf (&fixit
[1], "%d=s4;", fpnt
->dbx_type
);
2683 pnt2
= (char *) strchr (&fixit
[1], '=');
2684 VMS_typedef_parse (pnt2
);
2691 Define_Local_Symbols (symbolS
*s0P
, symbolS
*s2P
, symbolS
*Current_Routine
,
2694 symbolS
*s1P
; /* Each symbol from s0P .. s2P (exclusive). */
2696 for (s1P
= symbol_next (s0P
); s1P
!= s2P
; s1P
= symbol_next (s1P
))
2699 break; /* and return */
2700 if (S_GET_RAW_TYPE (s1P
) == N_FUN
)
2702 char *pnt
= (char *) strchr (S_GET_NAME (s1P
), ':') + 1;
2703 if (*pnt
== 'F' || *pnt
== 'f') break;
2705 if (!S_IS_DEBUG (s1P
))
2707 /* Dispatch on STAB type. */
2708 switch (S_GET_RAW_TYPE (s1P
))
2711 /* Not left or right brace. */
2716 VMS_local_stab_Parse (s1P
);
2720 VMS_RSYM_Parse (s1P
, Current_Routine
, Text_Psect
);
2726 /* This function crawls the symbol chain searching for local symbols that
2727 need to be described to the debugger. When we enter a new scope with
2728 a "{", it creates a new "block", which helps the debugger keep track
2729 of which scope we are currently in. */
2732 Define_Routine (symbolS
*s0P
, int Level
, symbolS
*Current_Routine
,
2739 for (s1P
= symbol_next (s0P
); s1P
!= 0; s1P
= symbol_next (s1P
))
2741 if (S_GET_RAW_TYPE (s1P
) == N_FUN
)
2743 char *pnt
= (char *) strchr (S_GET_NAME (s1P
), ':') + 1;
2744 if (*pnt
== 'F' || *pnt
== 'f') break;
2746 if (!S_IS_DEBUG (s1P
))
2748 /* Dispatch on STAB type. */
2749 switch (S_GET_RAW_TYPE (s1P
))
2758 sprintf (str
, "$%d", rcount
++);
2759 VMS_TBT_Block_Begin (s1P
, Text_Psect
, str
);
2761 /* Side-effect: fully resolve symbol. */
2762 Offset
= S_GET_VALUE (s1P
);
2763 Define_Local_Symbols (s0P
, s1P
, Current_Routine
, Text_Psect
);
2764 s1P
= Define_Routine (s1P
, Level
+ 1, Current_Routine
, Text_Psect
);
2766 VMS_TBT_Block_End (S_GET_VALUE (s1P
) - Offset
);
2775 /* We end up here if there were no brackets in this function.
2776 Define everything. */
2777 Define_Local_Symbols (s0P
, (symbolS
*)0, Current_Routine
, Text_Psect
);
2783 #include <sys/types.h>
2785 static void get_VMS_time_on_unix (char *);
2787 /* Manufacture a VMS-like time string on a Unix based system. */
2789 get_VMS_time_on_unix (char *Now
)
2795 pnt
= ctime (&timeb
);
2801 sprintf (Now
, "%2s-%3s-%s %s", pnt
+ 8, pnt
+ 4, pnt
+ 20, pnt
+ 11);
2803 #endif /* not VMS */
2805 /* Write the MHD (Module Header) records. */
2808 Write_VMS_MHD_Records (void)
2814 struct { unsigned short len
, mbz
; char *ptr
; } Descriptor
;
2818 /* We are writing a module header record. */
2819 Set_VMS_Object_File_Record (OBJ_S_C_HDR
);
2820 /* MAIN MODULE HEADER RECORD. */
2821 /* Store record type and header type. */
2822 PUT_CHAR (OBJ_S_C_HDR
);
2823 PUT_CHAR (MHD_S_C_MHD
);
2824 /* Structure level is 0. */
2825 PUT_CHAR (OBJ_S_C_STRLVL
);
2826 /* Maximum record size is size of the object record buffer. */
2827 PUT_SHORT (sizeof (Object_Record_Buffer
));
2829 /* FIXME: module name and version should be user
2830 specifiable via `.ident' and/or `#pragma ident'. */
2832 /* Get module name (the FILENAME part of the object file). */
2837 if (*cp
== ']' || *cp
== '>' || *cp
== ':' || *cp
== '/')
2843 *cp1
++ = TOUPPER (*cp
++);
2847 /* Limit it to 31 characters and store in the object record. */
2848 while (--cp1
>= Module_Name
)
2851 if (strlen (Module_Name
) > 31)
2853 if (flag_hash_long_names
)
2854 as_tsktsk (_("Module name truncated: %s\n"), Module_Name
);
2855 Module_Name
[31] = '\0';
2857 PUT_COUNTED_STRING (Module_Name
);
2858 /* Module Version is "V1.0". */
2859 PUT_COUNTED_STRING ("V1.0");
2860 /* Creation time is "now" (17 chars of time string): "dd-MMM-yyyy hh:mm". */
2862 get_VMS_time_on_unix (Now
);
2864 Descriptor
.len
= sizeof Now
- 1;
2865 Descriptor
.mbz
= 0; /* type & class unspecified */
2866 Descriptor
.ptr
= Now
;
2867 (void) sys$
asctim ((unsigned short *)0, &Descriptor
, (long *)0, 0);
2869 for (i
= 0; i
< 17; i
++)
2871 /* Patch time is "never" (17 zeros). */
2872 for (i
= 0; i
< 17; i
++)
2874 /* Force this to be a separate output record. */
2875 Flush_VMS_Object_Record_Buffer ();
2877 /* LANGUAGE PROCESSOR NAME. */
2879 /* Store record type and header type. */
2880 PUT_CHAR (OBJ_S_C_HDR
);
2881 PUT_CHAR (MHD_S_C_LNM
);
2883 /* Store language processor name and version (not a counted string!).
2884 This is normally supplied by the gcc driver for the command line
2885 which invokes gas. If absent, we fall back to gas's version. */
2887 cp
= compiler_version_string
;
2897 /* Force this to be a separate output record. */
2898 Flush_VMS_Object_Record_Buffer ();
2901 /* Write the EOM (End Of Module) record. */
2904 Write_VMS_EOM_Record (int Psect
, valueT Offset
)
2906 /* We are writing an end-of-module record
2907 (this assumes that the entry point will always be in a psect
2908 represented by a single byte, which is the case for code in
2911 Set_VMS_Object_File_Record (OBJ_S_C_EOM
);
2912 PUT_CHAR (OBJ_S_C_EOM
); /* Record type. */
2913 PUT_CHAR (0); /* Error severity level (we ignore it). */
2914 /* Store the entry point, if it exists. */
2920 /* Flush the record; this will be our final output. */
2921 Flush_VMS_Object_Record_Buffer ();
2925 /* This hash routine borrowed from GNU-EMACS, and strengthened slightly
2929 hash_string (const char *ptr
)
2931 const unsigned char *p
= (unsigned char *) ptr
;
2932 const unsigned char *end
= p
+ strlen (ptr
);
2939 hash
= ((hash
<< 3) + (hash
<< 15) + (hash
>> 28) + c
);
2944 /* Generate a Case-Hacked VMS symbol name (limited to 31 chars). */
2947 VMS_Case_Hack_Symbol (const char *In
, char *Out
)
2953 const char *old_name
;
2955 int destructor
= 0; /* Hack to allow for case sens in a destructor. */
2957 int Case_Hack_Bits
= 0;
2959 static char Hex_Table
[16] =
2960 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
2962 /* Kill any leading "_". */
2963 if ((In
[0] == '_') && ((In
[1] > '9') || (In
[1] < '0')))
2966 new_name
= Out
; /* Save this for later. */
2968 /* We may need to truncate the symbol, save the hash for later. */
2969 result
= (strlen (In
) > 23) ? hash_string (In
) : 0;
2970 /* Is there a Psect Attribute to skip? */
2971 if (HAS_PSECT_ATTRIBUTES (In
))
2974 In
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
2977 if ((In
[0] == '$') && (In
[1] == '$'))
2987 /* Do the case conversion. */
2988 /* Maximum of 23 chars */
2990 while (*In
&& (--i
>= 0))
2992 Case_Hack_Bits
<<= 1;
2995 if ((destructor
== 1) && (i
== 21))
2998 switch (vms_name_mapping
)
3004 Case_Hack_Bits
|= 1;
3007 *Out
++ = TOUPPER (*In
++);
3018 *Out
++ = TOLOWER (*In
++);
3022 /* If we saw a dollar sign, we don't do case hacking. */
3023 if (flag_no_hash_mixed_case
|| Saw_Dollar
)
3026 /* If we have more than 23 characters and everything is lowercase
3027 we can insert the full 31 characters. */
3030 /* We have more than 23 characters
3031 If we must add the case hack, then we have truncated the str. */
3034 if (Case_Hack_Bits
== 0)
3036 /* And so far they are all lower case:
3037 Check up to 8 more characters
3038 and ensure that they are lowercase. */
3039 for (i
= 0; (In
[i
] != 0) && (i
< 8); i
++)
3040 if (ISUPPER (In
[i
]) && !Saw_Dollar
&& !flag_no_hash_mixed_case
)
3046 if ((i
== 8) || (In
[i
] == 0))
3048 /* They are: Copy up to 31 characters
3049 to the output string. */
3051 while ((--i
>= 0) && (*In
))
3052 switch (vms_name_mapping
){
3053 case 0: *Out
++ = TOUPPER (*In
++);
3055 case 3: *Out
++ = *In
++;
3057 case 2: *Out
++ = TOLOWER (*In
++);
3063 /* If there were any uppercase characters in the name we
3064 take on the case hacking string. */
3066 /* Old behavior for regular GNU-C compiler. */
3067 if (!flag_hash_long_names
)
3069 if ((Case_Hack_Bits
!= 0) || (truncate
== 1))
3074 for (i
= 0; i
< 6; i
++)
3076 *Out
++ = Hex_Table
[Case_Hack_Bits
& 0xf];
3077 Case_Hack_Bits
>>= 4;
3083 Out
= pnt
; /* Cut back to 23 characters maximum. */
3085 for (i
= 0; i
< 7; i
++)
3087 init
= result
& 0x01f;
3088 *Out
++ = (init
< 10) ? ('0' + init
) : ('A' + init
- 10);
3089 result
= result
>> 5;
3095 if (truncate
== 1 && flag_hash_long_names
&& flag_show_after_trunc
)
3096 as_tsktsk (_("Symbol %s replaced by %s\n"), old_name
, new_name
);
3100 /* Scan a symbol name for a psect attribute specification. */
3102 #define GLOBALSYMBOL_BIT 0x10000
3103 #define GLOBALVALUE_BIT 0x20000
3106 VMS_Modify_Psect_Attributes (const char *Name
, int *Attribute_Pointer
)
3117 {"PIC", GPS_S_M_PIC
},
3118 {"LIB", GPS_S_M_LIB
},
3119 {"OVR", GPS_S_M_OVR
},
3120 {"REL", GPS_S_M_REL
},
3121 {"GBL", GPS_S_M_GBL
},
3122 {"SHR", GPS_S_M_SHR
},
3123 {"EXE", GPS_S_M_EXE
},
3125 {"WRT", GPS_S_M_WRT
},
3126 {"VEC", GPS_S_M_VEC
},
3127 {"GLOBALSYMBOL", GLOBALSYMBOL_BIT
},
3128 {"GLOBALVALUE", GLOBALVALUE_BIT
},
3132 /* Kill leading "_". */
3135 /* Check for a PSECT attribute list. */
3136 if (!HAS_PSECT_ATTRIBUTES (Name
))
3138 /* Skip the attribute list indicator. */
3139 Name
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
3140 /* Process the attributes ("_" separated, "$" terminated). */
3141 while (*Name
!= '$')
3143 /* Assume not negating. */
3145 /* Check for "NO". */
3146 if ((Name
[0] == 'N') && (Name
[1] == 'O'))
3148 /* We are negating (and skip the NO). */
3152 /* Find the token delimiter. */
3154 while (*cp
&& (*cp
!= '_') && (*cp
!= '$'))
3156 /* Look for the token in the attribute list. */
3157 for (i
= 0; Attributes
[i
].Name
; i
++)
3159 /* If the strings match, set/clear the attr. */
3160 if (strncmp (Name
, Attributes
[i
].Name
, cp
- Name
) == 0)
3164 *Attribute_Pointer
&=
3165 ~Attributes
[i
].Value
;
3167 *Attribute_Pointer
|=
3168 Attributes
[i
].Value
;
3173 /* Now skip the attribute. */
3181 #define GBLSYM_REF 0
3182 #define GBLSYM_DEF 1
3183 #define GBLSYM_VAL 2
3184 #define GBLSYM_LCL 4 /* not GBL after all... */
3185 #define GBLSYM_WEAK 8
3187 /* Define a global symbol (or possibly a local one). */
3190 VMS_Global_Symbol_Spec (const char *Name
, int Psect_Number
, int Psect_Offset
, int Flags
)
3194 /* We are writing a GSD record. */
3195 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3197 /* If the buffer is empty we must insert the GSD record type. */
3198 if (Object_Record_Offset
== 0)
3199 PUT_CHAR (OBJ_S_C_GSD
);
3201 /* We are writing a Global (or local) symbol definition subrecord. */
3202 PUT_CHAR ((Flags
& GBLSYM_LCL
) != 0 ? GSD_S_C_LSY
:
3203 ((unsigned) Psect_Number
<= 255) ? GSD_S_C_SYM
: GSD_S_C_SYMW
);
3205 /* Data type is undefined. */
3208 /* Switch on Definition/Reference. */
3209 if ((Flags
& GBLSYM_DEF
) == 0)
3212 PUT_SHORT (((Flags
& GBLSYM_VAL
) == 0) ? GSY_S_M_REL
: 0);
3213 if ((Flags
& GBLSYM_LCL
) != 0) /* local symbols have extra field */
3214 PUT_SHORT (Current_Environment
);
3221 [ assert (LSY_S_M_DEF == GSY_S_M_DEF && LSY_S_M_REL == GSY_S_M_REL); ]. */
3222 sym_flags
= GSY_S_M_DEF
;
3223 if (Flags
& GBLSYM_WEAK
)
3224 sym_flags
|= GSY_S_M_WEAK
;
3225 if ((Flags
& GBLSYM_VAL
) == 0)
3226 sym_flags
|= GSY_S_M_REL
;
3227 PUT_SHORT (sym_flags
);
3228 if ((Flags
& GBLSYM_LCL
) != 0) /* local symbols have extra field */
3229 PUT_SHORT (Current_Environment
);
3232 if ((Flags
& GBLSYM_LCL
) == 0 && (unsigned) Psect_Number
<= 255)
3233 PUT_CHAR (Psect_Number
);
3235 PUT_SHORT (Psect_Number
);
3238 PUT_LONG (Psect_Offset
);
3241 /* Finally, the global symbol name. */
3242 VMS_Case_Hack_Symbol (Name
, Local
);
3243 PUT_COUNTED_STRING (Local
);
3245 /* Flush the buffer if it is more than 75% full. */
3246 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3247 Flush_VMS_Object_Record_Buffer ();
3250 /* Define an environment to support local symbol references.
3251 This is just to mollify the linker; we don't actually do
3252 anything useful with it. */
3255 VMS_Local_Environment_Setup (const char *Env_Name
)
3257 /* We are writing a GSD record. */
3258 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3259 /* If the buffer is empty we must insert the GSD record type. */
3260 if (Object_Record_Offset
== 0)
3261 PUT_CHAR (OBJ_S_C_GSD
);
3262 /* We are writing an ENV subrecord. */
3263 PUT_CHAR (GSD_S_C_ENV
);
3265 ++Current_Environment
; /* index of environment being defined */
3267 /* ENV$W_FLAGS: we are defining the next environment. It's not nested. */
3268 PUT_SHORT (ENV_S_M_DEF
);
3269 /* ENV$W_ENVINDX: index is always 0 for non-nested definitions. */
3272 /* ENV$B_NAMLNG + ENV$T_NAME: environment name in ASCIC format. */
3273 if (!Env_Name
) Env_Name
= "";
3274 PUT_COUNTED_STRING ((char *)Env_Name
);
3276 /* Flush the buffer if it is more than 75% full. */
3277 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3278 Flush_VMS_Object_Record_Buffer ();
3282 /* Define a psect. */
3285 VMS_Psect_Spec (const char *Name
, int Size
, enum ps_type Type
, struct VMS_Symbol
*vsp
)
3288 int Psect_Attributes
;
3290 /* Generate the appropriate PSECT flags given the PSECT type. */
3294 /* Text psects are PIC,noOVR,REL,noGBL,SHR,EXE,RD,noWRT. */
3295 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_SHR
|GPS_S_M_EXE
3299 /* Data psects are PIC,noOVR,REL,noGBL,noSHR,noEXE,RD,WRT. */
3300 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_RD
|GPS_S_M_WRT
);
3303 /* Common block psects are: PIC,OVR,REL,GBL,noSHR,noEXE,RD,WRT. */
3304 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_OVR
|GPS_S_M_REL
|GPS_S_M_GBL
3305 |GPS_S_M_RD
|GPS_S_M_WRT
);
3308 /* Const data psects are: PIC,OVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3309 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_OVR
|GPS_S_M_REL
|GPS_S_M_GBL
3313 /* Ctor psects are PIC,noOVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3314 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_GBL
|GPS_S_M_RD
);
3317 /* Dtor psects are PIC,noOVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3318 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_GBL
|GPS_S_M_RD
);
3322 error (_("Unknown VMS psect type (%ld)"), (long) Type
);
3325 /* Modify the psect attributes according to any attribute string. */
3326 if (vsp
&& S_GET_TYPE (vsp
->Symbol
) == N_ABS
)
3327 Psect_Attributes
|= GLOBALVALUE_BIT
;
3328 else if (HAS_PSECT_ATTRIBUTES (Name
))
3329 VMS_Modify_Psect_Attributes (Name
, &Psect_Attributes
);
3330 /* Check for globalref/def/val. */
3331 if ((Psect_Attributes
& GLOBALVALUE_BIT
) != 0)
3333 /* globalvalue symbols were generated before. This code
3334 prevents unsightly psect buildup, and makes sure that
3335 fixup references are emitted correctly. */
3336 vsp
->Psect_Index
= -1; /* to catch errors */
3337 S_SET_TYPE (vsp
->Symbol
, N_UNDF
); /* make refs work */
3338 return 1; /* decrement psect counter */
3341 if ((Psect_Attributes
& GLOBALSYMBOL_BIT
) != 0)
3343 switch (S_GET_RAW_TYPE (vsp
->Symbol
))
3345 case N_UNDF
| N_EXT
:
3346 VMS_Global_Symbol_Spec (Name
, vsp
->Psect_Index
,
3347 vsp
->Psect_Offset
, GBLSYM_REF
);
3348 vsp
->Psect_Index
= -1;
3349 S_SET_TYPE (vsp
->Symbol
, N_UNDF
);
3350 /* Return and indicate no psect. */
3353 case N_DATA
| N_EXT
:
3354 VMS_Global_Symbol_Spec (Name
, vsp
->Psect_Index
,
3355 vsp
->Psect_Offset
, GBLSYM_DEF
);
3356 /* In this case we still generate the psect. */
3360 as_fatal (_("Globalsymbol attribute for symbol %s was unexpected."),
3366 /* Clear out the globalref/def stuff. */
3367 Psect_Attributes
&= 0xffff;
3368 /* We are writing a GSD record. */
3369 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3370 /* If the buffer is empty we must insert the GSD record type. */
3371 if (Object_Record_Offset
== 0)
3372 PUT_CHAR (OBJ_S_C_GSD
);
3373 /* We are writing a PSECT definition subrecord. */
3374 PUT_CHAR (GSD_S_C_PSC
);
3375 /* Psects are always LONGWORD aligned. */
3377 /* Specify the psect attributes. */
3378 PUT_SHORT (Psect_Attributes
);
3379 /* Specify the allocation. */
3381 /* Finally, the psect name. */
3382 VMS_Case_Hack_Symbol (Name
, Local
);
3383 PUT_COUNTED_STRING (Local
);
3384 /* Flush the buffer if it is more than 75% full. */
3385 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3386 Flush_VMS_Object_Record_Buffer ();
3391 /* Given the pointer to a symbol we calculate how big the data at the
3392 symbol is. We do this by looking for the next symbol (local or global)
3393 which will indicate the start of another datum. */
3396 VMS_Initialized_Data_Size (symbolS
*s0P
, unsigned End_Of_Data
)
3399 valueT s0P_val
= S_GET_VALUE (s0P
), s1P_val
,
3400 nearest_val
= (valueT
) End_Of_Data
;
3402 /* Find the nearest symbol what follows this one. */
3403 for (s1P
= symbol_rootP
; s1P
; s1P
= symbol_next (s1P
))
3405 /* The data type must match. */
3406 if (S_GET_TYPE (s1P
) != N_DATA
)
3408 s1P_val
= S_GET_VALUE (s1P
);
3409 if (s1P_val
> s0P_val
&& s1P_val
< nearest_val
)
3410 nearest_val
= s1P_val
;
3412 /* Calculate its size. */
3413 return (offsetT
) (nearest_val
- s0P_val
);
3416 /* Check symbol names for the Psect hack with a globalvalue, and then
3417 generate globalvalues for those that have it. */
3420 VMS_Emit_Globalvalues (unsigned text_siz
, unsigned data_siz
,
3424 char *stripped_name
, *Name
;
3426 int Psect_Attributes
;
3430 /* Scan the symbol table for globalvalues, and emit def/ref when
3431 required. These will be caught again later and converted to
3433 for (sp
= symbol_rootP
; sp
; sp
= sp
->sy_next
)
3435 typ
= S_GET_RAW_TYPE (sp
);
3436 abstyp
= ((typ
& ~N_EXT
) == N_ABS
);
3437 /* See if this is something we want to look at. */
3439 typ
!= (N_DATA
| N_EXT
) &&
3440 typ
!= (N_UNDF
| N_EXT
))
3442 /* See if this has globalvalue specification. */
3443 Name
= S_GET_NAME (sp
);
3448 Psect_Attributes
= GLOBALVALUE_BIT
;
3450 else if (HAS_PSECT_ATTRIBUTES (Name
))
3452 stripped_name
= xmalloc (strlen (Name
) + 1);
3453 strcpy (stripped_name
, Name
);
3454 Psect_Attributes
= 0;
3455 VMS_Modify_Psect_Attributes (stripped_name
, &Psect_Attributes
);
3460 if ((Psect_Attributes
& GLOBALVALUE_BIT
) != 0)
3465 /* Local symbol references will want
3466 to have an environment defined. */
3467 if (Current_Environment
< 0)
3468 VMS_Local_Environment_Setup (".N_ABS");
3469 VMS_Global_Symbol_Spec (Name
, 0,
3471 GBLSYM_DEF
|GBLSYM_VAL
|GBLSYM_LCL
);
3474 VMS_Global_Symbol_Spec (Name
, 0,
3476 GBLSYM_DEF
|GBLSYM_VAL
);
3478 case N_UNDF
| N_EXT
:
3479 VMS_Global_Symbol_Spec (stripped_name
, 0, 0, GBLSYM_VAL
);
3481 case N_DATA
| N_EXT
:
3482 Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
3484 error (_("Invalid data type for globalvalue"));
3485 globalvalue
= md_chars_to_number (Data_Segment
+
3486 S_GET_VALUE (sp
) - text_siz
, Size
);
3487 /* Three times for good luck. The linker seems to get confused
3488 if there are fewer than three */
3489 VMS_Global_Symbol_Spec (stripped_name
, 0, 0, GBLSYM_VAL
);
3490 VMS_Global_Symbol_Spec (stripped_name
, 0, globalvalue
,
3491 GBLSYM_DEF
|GBLSYM_VAL
);
3492 VMS_Global_Symbol_Spec (stripped_name
, 0, globalvalue
,
3493 GBLSYM_DEF
|GBLSYM_VAL
);
3496 as_warn (_("Invalid globalvalue of %s"), stripped_name
);
3502 free (stripped_name
);
3508 /* Define a procedure entry pt/mask. */
3511 VMS_Procedure_Entry_Pt (char *Name
, int Psect_Number
, int Psect_Offset
,
3516 /* We are writing a GSD record. */
3517 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3518 /* If the buffer is empty we must insert the GSD record type. */
3519 if (Object_Record_Offset
== 0)
3520 PUT_CHAR (OBJ_S_C_GSD
);
3521 /* We are writing a Procedure Entry Pt/Mask subrecord. */
3522 PUT_CHAR (((unsigned) Psect_Number
<= 255) ? GSD_S_C_EPM
: GSD_S_C_EPMW
);
3523 /* Data type is undefined. */
3525 /* Flags = "RELOCATABLE" and "DEFINED". */
3526 PUT_SHORT (GSY_S_M_DEF
| GSY_S_M_REL
);
3528 if ((unsigned) Psect_Number
<= 255)
3529 PUT_CHAR (Psect_Number
);
3531 PUT_SHORT (Psect_Number
);
3533 PUT_LONG (Psect_Offset
);
3535 PUT_SHORT (Entry_Mask
);
3536 /* Finally, the global symbol name. */
3537 VMS_Case_Hack_Symbol (Name
, Local
);
3538 PUT_COUNTED_STRING (Local
);
3539 /* Flush the buffer if it is more than 75% full. */
3540 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3541 Flush_VMS_Object_Record_Buffer ();
3545 /* Set the current location counter to a particular Psect and Offset. */
3548 VMS_Set_Psect (int Psect_Index
, int Offset
, int Record_Type
)
3550 /* We are writing a "Record_Type" record. */
3551 Set_VMS_Object_File_Record (Record_Type
);
3552 /* If the buffer is empty we must insert the record type. */
3553 if (Object_Record_Offset
== 0)
3554 PUT_CHAR (Record_Type
);
3555 /* Stack the Psect base + Offset. */
3556 vms_tir_stack_psect (Psect_Index
, Offset
, 0);
3557 /* Set relocation base. */
3558 PUT_CHAR (TIR_S_C_CTL_SETRB
);
3559 /* Flush the buffer if it is more than 75% full. */
3560 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3561 Flush_VMS_Object_Record_Buffer ();
3565 /* Store repeated immediate data in current Psect. */
3568 VMS_Store_Repeated_Data (int Repeat_Count
, char *Pointer
, int Size
,
3571 /* Ignore zero bytes/words/longwords. */
3575 if (Pointer
[3] != 0 || Pointer
[2] != 0) break;
3578 if (Pointer
[1] != 0) break;
3581 if (Pointer
[0] != 0) break;
3587 /* If the data is too big for a TIR_S_C_STO_RIVB sub-record
3588 then we do it manually. */
3591 while (--Repeat_Count
>= 0)
3592 VMS_Store_Immediate_Data (Pointer
, Size
, Record_Type
);
3595 /* We are writing a "Record_Type" record. */
3596 Set_VMS_Object_File_Record (Record_Type
);
3597 /* If the buffer is empty we must insert record type. */
3598 if (Object_Record_Offset
== 0)
3599 PUT_CHAR (Record_Type
);
3600 /* Stack the repeat count. */
3601 PUT_CHAR (TIR_S_C_STA_LW
);
3602 PUT_LONG (Repeat_Count
);
3603 /* And now the command and its data. */
3604 PUT_CHAR (TIR_S_C_STO_RIVB
);
3607 PUT_CHAR (*Pointer
++);
3608 /* Flush the buffer if it is more than 75% full. */
3609 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3610 Flush_VMS_Object_Record_Buffer ();
3614 /* Store a Position Independent Reference. */
3617 VMS_Store_PIC_Symbol_Reference (symbolS
*Symbol
, int Offset
, int PC_Relative
,
3618 int Psect
, int Psect_Offset
, int Record_Type
)
3620 struct VMS_Symbol
*vsp
= Symbol
->sy_obj
;
3624 /* We are writing a "Record_Type" record. */
3625 Set_VMS_Object_File_Record (Record_Type
);
3626 /* If the buffer is empty we must insert record type. */
3627 if (Object_Record_Offset
== 0)
3628 PUT_CHAR (Record_Type
);
3629 /* Set to the appropriate offset in the Psect.
3630 For a Code reference we need to fix the operand
3631 specifier as well, so back up 1 byte;
3632 for a Data reference we just store HERE. */
3633 VMS_Set_Psect (Psect
,
3634 PC_Relative
? Psect_Offset
- 1 : Psect_Offset
,
3636 /* Make sure we are still generating a "Record Type" record. */
3637 if (Object_Record_Offset
== 0)
3638 PUT_CHAR (Record_Type
);
3639 /* Dispatch on symbol type (so we can stack its value). */
3640 switch (S_GET_RAW_TYPE (Symbol
))
3642 /* Global symbol. */
3647 #ifdef NOT_VAX_11_C_COMPATIBLE
3648 case N_UNDF
| N_EXT
:
3649 case N_DATA
| N_EXT
:
3650 #endif /* NOT_VAX_11_C_COMPATIBLE */
3652 case N_TEXT
| N_EXT
:
3653 /* Get the symbol name (case hacked). */
3654 VMS_Case_Hack_Symbol (S_GET_NAME (Symbol
), Local
);
3655 /* Stack the global symbol value. */
3658 PUT_CHAR (TIR_S_C_STA_GBL
);
3662 /* Local symbols have an extra field. */
3663 PUT_CHAR (TIR_S_C_STA_LSY
);
3664 PUT_SHORT (Current_Environment
);
3666 PUT_COUNTED_STRING (Local
);
3669 /* Stack the longword offset. */
3670 PUT_CHAR (TIR_S_C_STA_LW
);
3672 /* Add the two, leaving the result on the stack. */
3673 PUT_CHAR (TIR_S_C_OPR_ADD
);
3676 /* Uninitialized local data. */
3678 /* Stack the Psect (+offset). */
3679 vms_tir_stack_psect (vsp
->Psect_Index
,
3680 vsp
->Psect_Offset
+ Offset
,
3685 /* Stack the Psect (+offset). */
3686 vms_tir_stack_psect (vsp
->Psect_Index
,
3687 S_GET_VALUE (Symbol
) + Offset
,
3690 /* Initialized local or global data. */
3692 #ifndef NOT_VAX_11_C_COMPATIBLE
3693 case N_UNDF
| N_EXT
:
3694 case N_DATA
| N_EXT
:
3695 #endif /* NOT_VAX_11_C_COMPATIBLE */
3696 /* Stack the Psect (+offset). */
3697 vms_tir_stack_psect (vsp
->Psect_Index
,
3698 vsp
->Psect_Offset
+ Offset
,
3702 /* Store either a code or data reference. */
3703 PUT_CHAR (PC_Relative
? TIR_S_C_STO_PICR
: TIR_S_C_STO_PIDR
);
3704 /* Flush the buffer if it is more than 75% full. */
3705 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3706 Flush_VMS_Object_Record_Buffer ();
3710 /* Check in the text area for an indirect pc-relative reference
3711 and fix it up with addressing mode 0xff [PC indirect]
3713 THIS SHOULD BE REPLACED BY THE USE OF TIR_S_C_STO_PIRR IN THE
3714 PIC CODE GENERATING FIXUP ROUTINE. */
3717 VMS_Fix_Indirect_Reference (int Text_Psect
, addressT Offset
,
3718 fragS
*fragP
, fragS
*text_frag_root
)
3720 /* The addressing mode byte is 1 byte before the address. */
3722 /* Is it in THIS frag? */
3723 if ((Offset
< fragP
->fr_address
) ||
3724 (Offset
>= (fragP
->fr_address
+ fragP
->fr_fix
)))
3726 /* We need to search for the fragment containing this
3728 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3730 if ((Offset
>= fragP
->fr_address
) &&
3731 (Offset
< (fragP
->fr_address
+ fragP
->fr_fix
)))
3734 /* If we couldn't find the frag, things are BAD! */
3736 error (_("Couldn't find fixup fragment when checking for indirect reference"));
3738 /* Check for indirect PC relative addressing mode. */
3739 if (fragP
->fr_literal
[Offset
- fragP
->fr_address
] == (char) 0xff)
3741 static char Address_Mode
= (char) 0xff;
3743 /* Yes: Store the indirect mode back into the image
3744 to fix up the damage done by STO_PICR. */
3745 VMS_Set_Psect (Text_Psect
, Offset
, OBJ_S_C_TIR
);
3746 VMS_Store_Immediate_Data (&Address_Mode
, 1, OBJ_S_C_TIR
);
3751 /* If the procedure "main()" exists we have to add the instruction
3752 "jsb c$main_args" at the beginning to be compatible with VAX-11 "C".
3754 FIXME: the macro name `HACK_DEC_C_STARTUP' should be renamed
3755 to `HACK_VAXCRTL_STARTUP' because Digital's compiler
3756 named "DEC C" uses run-time library "DECC$SHR", but this
3757 startup code is for "VAXCRTL", the library for Digital's
3758 older "VAX C". Also, this extra code isn't needed for
3759 supporting gcc because it already generates the VAXCRTL
3760 startup call when compiling main(). The reference to
3761 `flag_hash_long_names' looks very suspicious too;
3762 probably an old-style command line option was inadvertently
3763 overloaded here, then blindly converted into the new one. */
3765 vms_check_for_main (void)
3768 #ifdef HACK_DEC_C_STARTUP /* JF */
3769 struct frchain
*frchainP
;
3771 fragS
**prev_fragPP
;
3775 #endif /* HACK_DEC_C_STARTUP */
3777 symbolP
= (symbolS
*) symbol_find ("_main");
3778 if (symbolP
&& !S_IS_DEBUG (symbolP
) &&
3779 S_IS_EXTERNAL (symbolP
) && (S_GET_TYPE (symbolP
) == N_TEXT
))
3781 #ifdef HACK_DEC_C_STARTUP
3782 if (!flag_hash_long_names
)
3785 /* Remember the entry point symbol. */
3786 Entry_Point_Symbol
= symbolP
;
3787 #ifdef HACK_DEC_C_STARTUP
3791 /* Scan all the fragment chains for the one with "_main"
3792 (Actually we know the fragment from the symbol, but we need
3793 the previous fragment so we can change its pointer). */
3794 frchainP
= frchain_root
;
3797 /* Scan all the fragments in this chain, remembering
3798 the "previous fragment". */
3799 prev_fragPP
= &frchainP
->frch_root
;
3800 fragP
= frchainP
->frch_root
;
3801 while (fragP
&& (fragP
!= frchainP
->frch_last
))
3803 /* Is this the fragment ? */
3804 if (fragP
== symbolP
->sy_frag
)
3806 /* Yes: Modify the fragment by replacing
3807 it with a new fragment. */
3809 xmalloc (sizeof (*New_Frag
) +
3813 /* The fragments are the same except
3814 that the "fixed" area is larger. */
3816 New_Frag
->fr_fix
+= 6;
3817 /* Copy the literal data opening a hole
3818 2 bytes after "_main" (i.e. just after
3819 the entry mask). Into which we place
3820 the JSB instruction. */
3821 New_Frag
->fr_literal
[0] = fragP
->fr_literal
[0];
3822 New_Frag
->fr_literal
[1] = fragP
->fr_literal
[1];
3823 New_Frag
->fr_literal
[2] = 0x16; /* Jsb */
3824 New_Frag
->fr_literal
[3] = 0xef;
3825 New_Frag
->fr_literal
[4] = 0;
3826 New_Frag
->fr_literal
[5] = 0;
3827 New_Frag
->fr_literal
[6] = 0;
3828 New_Frag
->fr_literal
[7] = 0;
3829 for (i
= 2; i
< fragP
->fr_fix
+ fragP
->fr_var
; i
++)
3830 New_Frag
->fr_literal
[i
+ 6] =
3831 fragP
->fr_literal
[i
];
3832 /* Now replace the old fragment with the
3833 newly generated one. */
3834 *prev_fragPP
= New_Frag
;
3835 /* Remember the entry point symbol. */
3836 Entry_Point_Symbol
= symbolP
;
3837 /* Scan the text area fixup structures
3838 as offsets in the fragment may have changed. */
3839 for (fixP
= text_fix_root
; fixP
; fixP
= fixP
->fx_next
)
3841 /* Look for references to this fragment. */
3842 if (fixP
->fx_frag
== fragP
)
3844 /* Change the fragment pointer. */
3845 fixP
->fx_frag
= New_Frag
;
3846 /* If the offset is after the entry mask we need
3847 to account for the JSB instruction we just
3849 if (fixP
->fx_where
>= 2)
3850 fixP
->fx_where
+= 6;
3853 /* Scan the symbols as offsets in the
3854 fragment may have changed. */
3855 for (symbolP
= symbol_rootP
;
3857 symbolP
= symbol_next (symbolP
))
3859 /* Look for references to this fragment. */
3860 if (symbolP
->sy_frag
== fragP
)
3862 /* Change the fragment pointer. */
3863 symbolP
->sy_frag
= New_Frag
;
3864 /* If the offset is after the entry mask we need
3865 to account for the JSB instruction we just
3867 if (S_GET_VALUE (symbolP
) >= 2)
3868 S_SET_VALUE (symbolP
,
3869 S_GET_VALUE (symbolP
) + 6);
3872 /* Make a symbol reference to "_c$main_args" so we
3873 can get its address inserted into the JSB
3875 symbolP
= xmalloc (sizeof (*symbolP
));
3876 S_SET_NAME (symbolP
, "_C$MAIN_ARGS");
3877 S_SET_TYPE (symbolP
, N_UNDF
);
3878 S_SET_OTHER (symbolP
, 0);
3879 S_SET_DESC (symbolP
, 0);
3880 S_SET_VALUE (symbolP
, 0);
3881 symbolP
->sy_name_offset
= 0;
3882 symbolP
->sy_number
= 0;
3883 symbolP
->sy_obj
= 0;
3884 symbolP
->sy_frag
= New_Frag
;
3885 symbolP
->sy_resolved
= 0;
3886 symbolP
->sy_resolving
= 0;
3887 /* This actually inserts at the beginning of the list. */
3888 symbol_append (symbol_rootP
, symbolP
,
3889 &symbol_rootP
, &symbol_lastP
);
3891 symbol_rootP
= symbolP
;
3892 /* Generate a text fixup structure
3893 to get "_c$main_args" stored into the
3895 fixP
= xmalloc (sizeof (*fixP
));
3896 fixP
->fx_frag
= New_Frag
;
3898 fixP
->fx_addsy
= symbolP
;
3900 fixP
->fx_offset
= 0;
3903 fixP
->fx_next
= text_fix_root
;
3904 text_fix_root
= fixP
;
3905 /* Now make sure we exit from the loop. */
3909 /* Try the next fragment. */
3910 prev_fragPP
= &fragP
->fr_next
;
3911 fragP
= fragP
->fr_next
;
3913 /* Try the next fragment chain. */
3915 frchainP
= frchainP
->frch_next
;
3918 #endif /* HACK_DEC_C_STARTUP */
3923 /* Beginning of vms_write_object_file(). */
3926 struct vms_obj_state
3928 /* Next program section index to use. */
3931 /* Psect index for code. Always ends up #0. */
3934 /* Psect index for initialized static variables. */
3937 /* Psect index for uninitialized static variables. */
3940 /* Psect index for static constructors. */
3943 /* Psect index for static destructors. */
3946 /* Number of bytes used for local symbol data. */
3947 int local_initd_data_size
;
3949 /* Dynamic buffer for initialized data. */
3954 #define Psect_Number vms_obj_state.psect_number
3955 #define Text_Psect vms_obj_state.text_psect
3956 #define Data_Psect vms_obj_state.data_psect
3957 #define Bss_Psect vms_obj_state.bss_psect
3958 #define Ctors_Psect vms_obj_state.ctors_psect
3959 #define Dtors_Psect vms_obj_state.dtors_psect
3960 #define Local_Initd_Data_Size vms_obj_state.local_initd_data_size
3961 #define Data_Segment vms_obj_state.data_segment
3963 #define IS_GXX_VTABLE(symP) (strncmp (S_GET_NAME (symP), "__vt.", 5) == 0)
3964 #define IS_GXX_XTOR(symP) (strncmp (S_GET_NAME (symP), "__GLOBAL_.", 10) == 0)
3968 /* Perform text segment fixups. */
3971 vms_fixup_text_section (unsigned text_siz ATTRIBUTE_UNUSED
,
3972 struct frag
*text_frag_root
,
3973 struct frag
*data_frag_root
)
3979 /* Scan the text fragments. */
3980 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
3982 /* Stop if we get to the data fragments. */
3983 if (fragP
== data_frag_root
)
3985 /* Ignore fragments with no data. */
3986 if ((fragP
->fr_fix
== 0) && (fragP
->fr_var
== 0))
3988 /* Go to the appropriate offset in the Text Psect. */
3989 VMS_Set_Psect (Text_Psect
, fragP
->fr_address
, OBJ_S_C_TIR
);
3990 /* Store the "fixed" part. */
3992 VMS_Store_Immediate_Data (fragP
->fr_literal
,
3995 /* Store the "variable" part. */
3996 if (fragP
->fr_var
&& fragP
->fr_offset
)
3997 VMS_Store_Repeated_Data (fragP
->fr_offset
,
3998 fragP
->fr_literal
+ fragP
->fr_fix
,
4003 /* Now we go through the text segment fixups and generate
4004 TIR records to fix up addresses within the Text Psect. */
4005 for (fixP
= text_fix_root
; fixP
; fixP
= fixP
->fx_next
)
4007 /* We DO handle the case of "Symbol - Symbol" as
4008 long as it is in the same segment. */
4009 if (fixP
->fx_subsy
&& fixP
->fx_addsy
)
4011 /* They need to be in the same segment. */
4012 if (S_GET_RAW_TYPE (fixP
->fx_subsy
) !=
4013 S_GET_RAW_TYPE (fixP
->fx_addsy
))
4014 error (_("Fixup data addsy and subsy don't have the same type"));
4015 /* And they need to be in one that we can check the psect on. */
4016 if ((S_GET_TYPE (fixP
->fx_addsy
) != N_DATA
) &&
4017 (S_GET_TYPE (fixP
->fx_addsy
) != N_TEXT
))
4018 error (_("Fixup data addsy and subsy don't have an appropriate type"));
4019 /* This had better not be PC relative! */
4021 error (_("Fixup data is erroneously \"pcrel\""));
4022 /* Subtract their values to get the difference. */
4023 dif
= S_GET_VALUE (fixP
->fx_addsy
) - S_GET_VALUE (fixP
->fx_subsy
);
4024 md_number_to_chars (Local
, (valueT
)dif
, fixP
->fx_size
);
4025 /* Now generate the fixup object records;
4026 set the psect and store the data. */
4027 VMS_Set_Psect (Text_Psect
,
4028 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4030 VMS_Store_Immediate_Data (Local
,
4035 /* Size will HAVE to be "long". */
4036 if (fixP
->fx_size
!= 4)
4037 error (_("Fixup datum is not a longword"));
4038 /* Symbol must be "added" (if it is ever
4039 subtracted we can fix this assumption). */
4040 if (fixP
->fx_addsy
== 0)
4041 error (_("Fixup datum is not \"fixP->fx_addsy\""));
4042 /* Store the symbol value in a PIC fashion. */
4043 VMS_Store_PIC_Symbol_Reference (fixP
->fx_addsy
,
4047 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4049 /* Check for indirect address reference, which has to be fixed up
4050 (as the linker will screw it up with TIR_S_C_STO_PICR). */
4052 VMS_Fix_Indirect_Reference (Text_Psect
,
4053 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4060 /* Create a buffer holding the data segment. */
4063 synthesize_data_segment (unsigned data_siz
, unsigned text_siz
,
4064 struct frag
*data_frag_root
)
4068 long fill_size
, count
, i
;
4070 /* Allocate the data segment. */
4071 Data_Segment
= xmalloc (data_siz
);
4073 /* Run through the data fragments, filling in the segment. */
4074 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
4076 i
= fragP
->fr_address
- text_siz
;
4078 memcpy (Data_Segment
+ i
, fragP
->fr_literal
, fragP
->fr_fix
);
4081 if ((fill_size
= fragP
->fr_var
) != 0)
4083 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
4084 for (count
= fragP
->fr_offset
; count
; count
--)
4086 memcpy (Data_Segment
+ i
, fill_literal
, fill_size
);
4093 /* Perform data segment fixups. */
4096 vms_fixup_data_section (unsigned int data_siz ATTRIBUTE_UNUSED
,
4097 unsigned int text_siz
)
4099 struct VMS_Symbol
*vsp
;
4102 addressT fr_address
;
4106 /* Run through all the data symbols and store the data. */
4107 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
4109 /* Ignore anything other than data symbols. */
4110 if (S_GET_TYPE (vsp
->Symbol
) != N_DATA
)
4112 /* Set the Psect + Offset. */
4113 VMS_Set_Psect (vsp
->Psect_Index
,
4116 /* Store the data. */
4117 val
= S_GET_VALUE (vsp
->Symbol
);
4118 VMS_Store_Immediate_Data (Data_Segment
+ val
- text_siz
,
4121 } /* N_DATA symbol loop */
4123 /* Now we go through the data segment fixups and generate
4124 TIR records to fix up addresses within the Data Psects. */
4125 for (fixP
= data_fix_root
; fixP
; fixP
= fixP
->fx_next
)
4127 /* Find the symbol for the containing datum. */
4128 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
4130 /* Only bother with Data symbols. */
4132 if (S_GET_TYPE (sp
) != N_DATA
)
4134 /* Ignore symbol if After fixup. */
4135 val
= S_GET_VALUE (sp
);
4136 fr_address
= fixP
->fx_frag
->fr_address
;
4137 if (val
> fixP
->fx_where
+ fr_address
)
4139 /* See if the datum is here. */
4140 if (val
+ vsp
->Size
<= fixP
->fx_where
+ fr_address
)
4142 /* We DO handle the case of "Symbol - Symbol" as
4143 long as it is in the same segment. */
4144 if (fixP
->fx_subsy
&& fixP
->fx_addsy
)
4146 /* They need to be in the same segment. */
4147 if (S_GET_RAW_TYPE (fixP
->fx_subsy
) !=
4148 S_GET_RAW_TYPE (fixP
->fx_addsy
))
4149 error (_("Fixup data addsy and subsy don't have the same type"));
4150 /* And they need to be in one that we can check the psect on. */
4151 if ((S_GET_TYPE (fixP
->fx_addsy
) != N_DATA
) &&
4152 (S_GET_TYPE (fixP
->fx_addsy
) != N_TEXT
))
4153 error (_("Fixup data addsy and subsy don't have an appropriate type"));
4154 /* This had better not be PC relative! */
4156 error (_("Fixup data is erroneously \"pcrel\""));
4157 /* Subtract their values to get the difference. */
4158 dif
= S_GET_VALUE (fixP
->fx_addsy
) - S_GET_VALUE (fixP
->fx_subsy
);
4159 md_number_to_chars (Local
, (valueT
)dif
, fixP
->fx_size
);
4160 /* Now generate the fixup object records;
4161 set the psect and store the data. */
4162 VMS_Set_Psect (vsp
->Psect_Index
,
4163 fr_address
+ fixP
->fx_where
4164 - val
+ vsp
->Psect_Offset
,
4166 VMS_Store_Immediate_Data (Local
,
4169 break; /* done with this fixup */
4171 /* Size will HAVE to be "long". */
4172 if (fixP
->fx_size
!= 4)
4173 error (_("Fixup datum is not a longword"));
4174 /* Symbol must be "added" (if it is ever
4175 subtracted we can fix this assumption). */
4176 if (fixP
->fx_addsy
== 0)
4177 error (_("Fixup datum is not \"fixP->fx_addsy\""));
4178 /* Store the symbol value in a PIC fashion. */
4179 VMS_Store_PIC_Symbol_Reference (fixP
->fx_addsy
,
4183 fr_address
+ fixP
->fx_where
4184 - val
+ vsp
->Psect_Offset
,
4186 /* Done with this fixup. */
4192 /* Perform ctors/dtors segment fixups. */
4195 vms_fixup_xtors_section (struct VMS_Symbol
*symbols
,
4196 int sect_no ATTRIBUTE_UNUSED
)
4198 struct VMS_Symbol
*vsp
;
4200 /* Run through all the symbols and store the data. */
4201 for (vsp
= symbols
; vsp
; vsp
= vsp
->Next
)
4205 /* Set relocation base. */
4206 VMS_Set_Psect (vsp
->Psect_Index
, vsp
->Psect_Offset
, OBJ_S_C_TIR
);
4209 /* Stack the Psect base with its offset. */
4210 VMS_Set_Data (Text_Psect
, S_GET_VALUE (sp
), OBJ_S_C_TIR
, 0);
4212 /* Flush the buffer if it is more than 75% full. */
4213 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
4214 Flush_VMS_Object_Record_Buffer ();
4218 /* Define symbols for the linker. */
4221 global_symbol_directory (unsigned text_siz
, unsigned data_siz
)
4225 struct VMS_Symbol
*vsp
;
4226 int Globalref
, define_as_global_symbol
;
4228 /* Now scan the symbols and emit the appropriate GSD records. */
4229 for (sp
= symbol_rootP
; sp
; sp
= symbol_next (sp
))
4231 define_as_global_symbol
= 0;
4233 /* Dispatch on symbol type. */
4234 switch (S_GET_RAW_TYPE (sp
))
4237 /* Global uninitialized data. */
4238 case N_UNDF
| N_EXT
:
4239 /* Make a VMS data symbol entry. */
4240 vsp
= xmalloc (sizeof *vsp
);
4242 vsp
->Size
= S_GET_VALUE (sp
);
4243 vsp
->Psect_Index
= Psect_Number
++;
4244 vsp
->Psect_Offset
= 0;
4245 vsp
->Next
= VMS_Symbols
;
4248 /* Make the psect for this data. */
4249 Globalref
= VMS_Psect_Spec (S_GET_NAME (sp
),
4251 S_GET_OTHER (sp
) ? ps_CONST
: ps_COMMON
,
4255 #ifdef NOT_VAX_11_C_COMPATIBLE
4256 define_as_global_symbol
= 1;
4258 /* See if this is an external vtable. We want to help the
4259 linker find these things in libraries, so we make a symbol
4260 reference. This is not compatible with VAX-C usage for
4261 variables, but since vtables are only used internally by
4262 g++, we can get away with this hack. */
4263 define_as_global_symbol
= IS_GXX_VTABLE (sp
);
4267 /* Local uninitialized data. */
4269 /* Make a VMS data symbol entry. */
4270 vsp
= xmalloc (sizeof *vsp
);
4273 vsp
->Psect_Index
= Bss_Psect
;
4274 vsp
->Psect_Offset
= S_GET_VALUE (sp
) - bss_address_frag
.fr_address
;
4275 vsp
->Next
= VMS_Symbols
;
4280 /* Global initialized data. */
4281 case N_DATA
| N_EXT
:
4282 /* Make a VMS data symbol entry. */
4283 vsp
= xmalloc (sizeof *vsp
);
4285 vsp
->Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
4286 vsp
->Psect_Index
= Psect_Number
++;
4287 vsp
->Psect_Offset
= 0;
4288 vsp
->Next
= VMS_Symbols
;
4291 /* Make its psect. */
4292 Globalref
= VMS_Psect_Spec (S_GET_NAME (sp
),
4294 S_GET_OTHER (sp
) ? ps_CONST
: ps_COMMON
,
4298 #ifdef NOT_VAX_11_C_COMPATIBLE
4299 define_as_global_symbol
= 1;
4301 /* See N_UNDF|N_EXT above for explanation. */
4302 define_as_global_symbol
= IS_GXX_VTABLE (sp
);
4306 /* Local initialized data. */
4309 char *sym_name
= S_GET_NAME (sp
);
4311 /* Always suppress local numeric labels. */
4312 if (sym_name
&& strcmp (sym_name
, FAKE_LABEL_NAME
) == 0)
4315 /* Make a VMS data symbol entry. */
4316 vsp
= xmalloc (sizeof *vsp
);
4318 vsp
->Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
4319 vsp
->Psect_Index
= Data_Psect
;
4320 vsp
->Psect_Offset
= Local_Initd_Data_Size
;
4321 Local_Initd_Data_Size
+= vsp
->Size
;
4322 vsp
->Next
= VMS_Symbols
;
4328 /* Global Text definition. */
4329 case N_TEXT
| N_EXT
:
4332 if (IS_GXX_XTOR (sp
))
4334 vsp
= xmalloc (sizeof *vsp
);
4336 vsp
->Size
= XTOR_SIZE
;
4338 switch ((S_GET_NAME (sp
))[10])
4341 vsp
->Psect_Index
= Ctors_Psect
;
4342 vsp
->Psect_Offset
= (Ctors_Symbols
==0)?0:(Ctors_Symbols
->Psect_Offset
+XTOR_SIZE
);
4343 vsp
->Next
= Ctors_Symbols
;
4344 Ctors_Symbols
= vsp
;
4347 vsp
->Psect_Index
= Dtors_Psect
;
4348 vsp
->Psect_Offset
= (Dtors_Symbols
==0)?0:(Dtors_Symbols
->Psect_Offset
+XTOR_SIZE
);
4349 vsp
->Next
= Dtors_Symbols
;
4350 Dtors_Symbols
= vsp
;
4353 as_warn (_("Can't handle global xtors symbols yet."));
4356 as_warn (_("Unknown %s"), S_GET_NAME (sp
));
4362 unsigned short Entry_Mask
;
4364 /* Get the entry mask. */
4365 fragP
= sp
->sy_frag
;
4366 /* First frag might be empty if we're generating listings.
4367 So skip empty rs_fill frags. */
4368 while (fragP
&& fragP
->fr_type
== rs_fill
&& fragP
->fr_fix
== 0)
4369 fragP
= fragP
->fr_next
;
4371 /* If first frag doesn't contain the data, what do we do?
4372 If it's possibly smaller than two bytes, that would
4373 imply that the entry mask is not stored where we're
4376 If you can find a test case that triggers this, report
4377 it (and tell me what the entry mask field ought to be),
4378 and I'll try to fix it. KR */
4379 if (fragP
->fr_fix
< 2)
4382 Entry_Mask
= (fragP
->fr_literal
[0] & 0x00ff) |
4383 ((fragP
->fr_literal
[1] & 0x00ff) << 8);
4384 /* Define the procedure entry point. */
4385 VMS_Procedure_Entry_Pt (S_GET_NAME (sp
),
4393 /* Local Text definition. */
4395 /* Make a VMS data symbol entry. */
4396 if (Text_Psect
!= -1)
4398 vsp
= xmalloc (sizeof *vsp
);
4401 vsp
->Psect_Index
= Text_Psect
;
4402 vsp
->Psect_Offset
= S_GET_VALUE (sp
);
4403 vsp
->Next
= VMS_Symbols
;
4409 /* Global Reference. */
4411 /* Make a GSD global symbol reference record. */
4412 VMS_Global_Symbol_Spec (S_GET_NAME (sp
),
4418 /* Absolute symbol. */
4421 /* gcc doesn't generate these;
4422 VMS_Emit_Globalvalue handles them though. */
4423 vsp
= xmalloc (sizeof *vsp
);
4425 vsp
->Size
= 4; /* always assume 32 bits */
4426 vsp
->Psect_Index
= 0;
4427 vsp
->Psect_Offset
= S_GET_VALUE (sp
);
4428 vsp
->Next
= VMS_Symbols
;
4433 /* Anything else. */
4435 /* Ignore STAB symbols, including .stabs emitted by g++. */
4436 if (S_IS_DEBUG (sp
) || (S_GET_TYPE (sp
) == 22))
4441 as_tsktsk (_("unhandled stab type %d"), S_GET_TYPE (sp
));
4445 /* Global symbols have different linkage than external variables. */
4446 if (define_as_global_symbol
)
4447 VMS_Global_Symbol_Spec (S_GET_NAME (sp
),
4455 /* Output debugger symbol table information for symbols which
4456 are local to a specific routine. */
4459 local_symbols_DST (symbolS
*s0P
, symbolS
*Current_Routine
)
4462 char *s0P_name
, *pnt0
, *pnt1
;
4464 s0P_name
= S_GET_NAME (s0P
);
4465 if (*s0P_name
++ != '_')
4468 for (s1P
= Current_Routine
; s1P
; s1P
= symbol_next (s1P
))
4470 if (S_GET_RAW_TYPE (s1P
) != N_FUN
)
4473 pnt1
= S_GET_NAME (s1P
);
4474 /* We assume the two strings are never exactly equal... */
4475 while (*pnt0
++ == *pnt1
++)
4478 /* Found it if s0P name is exhausted and s1P name has ":F" or ":f" next.
4479 Note: both pointers have advanced one past the non-matching char. */
4480 if ((*pnt1
== 'F' || *pnt1
== 'f') && *--pnt1
== ':' && *--pnt0
== '\0')
4482 Define_Routine (s1P
, 0, Current_Routine
, Text_Psect
);
4488 /* Construct and output the debug symbol table. */
4491 vms_build_DST (unsigned text_siz
)
4494 symbolS
*Current_Routine
= 0;
4495 struct input_file
*Cur_File
= 0;
4496 offsetT Cur_Offset
= -1;
4497 int Cur_Line_Number
= 0;
4498 int File_Number
= 0;
4499 int Debugger_Offset
= 0;
4504 /* Write the Traceback Begin Module record. */
4505 VMS_TBT_Module_Begin ();
4507 /* Output debugging info for global variables and static variables
4508 that are not specific to one routine. We also need to examine
4509 all stabs directives, to find the definitions to all of the
4510 advanced data types, and this is done by VMS_LSYM_Parse. This
4511 needs to be done before any definitions are output to the object
4512 file, since there can be forward references in the stabs
4513 directives. When through with parsing, the text of the stabs
4514 directive is altered, with the definitions removed, so that later
4515 passes will see directives as they would be written if the type
4516 were already defined.
4518 We also look for files and include files, and make a list of
4519 them. We examine the source file numbers to establish the actual
4520 lines that code was generated from, and then generate offsets. */
4522 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
4524 /* Only deal with STAB symbols here. */
4525 if (!S_IS_DEBUG (symbolP
))
4527 /* Dispatch on STAB type. */
4528 switch (S_GET_RAW_TYPE (symbolP
))
4531 dsc
= S_GET_DESC (symbolP
);
4532 if (dsc
> Cur_File
->max_line
)
4533 Cur_File
->max_line
= dsc
;
4534 if (dsc
< Cur_File
->min_line
)
4535 Cur_File
->min_line
= dsc
;
4538 Cur_File
= find_file (symbolP
);
4540 Cur_File
->min_line
= 1;
4543 Cur_File
= find_file (symbolP
);
4546 VMS_GSYM_Parse (symbolP
, Text_Psect
);
4549 VMS_LCSYM_Parse (symbolP
, Text_Psect
);
4551 case N_FUN
: /* For static constant symbols */
4553 VMS_STSYM_Parse (symbolP
, Text_Psect
);
4560 /* Now we take a quick sweep through the files and assign offsets
4561 to each one. This will essentially be the starting line number to
4562 the debugger for each file. Output the info for the debugger to
4563 specify the files, and then tell it how many lines to use. */
4564 for (Cur_File
= file_root
; Cur_File
; Cur_File
= Cur_File
->next
)
4566 if (Cur_File
->max_line
== 0)
4568 if ((strncmp (Cur_File
->name
, "GNU_GXX_INCLUDE:", 16) == 0) &&
4571 if ((strncmp (Cur_File
->name
, "GNU_CC_INCLUDE:", 15) == 0) &&
4574 /* show a few extra lines at the start of the region selected */
4575 if (Cur_File
->min_line
> 2)
4576 Cur_File
->min_line
-= 2;
4577 Cur_File
->offset
= Debugger_Offset
- Cur_File
->min_line
+ 1;
4578 Debugger_Offset
+= Cur_File
->max_line
- Cur_File
->min_line
+ 1;
4579 if (Cur_File
->same_file_fpnt
)
4581 Cur_File
->file_number
= Cur_File
->same_file_fpnt
->file_number
;
4585 Cur_File
->file_number
= ++File_Number
;
4586 file_available
= VMS_TBT_Source_File (Cur_File
->name
,
4587 Cur_File
->file_number
);
4588 if (!file_available
)
4590 Cur_File
->file_number
= 0;
4595 VMS_TBT_Source_Lines (Cur_File
->file_number
,
4597 Cur_File
->max_line
- Cur_File
->min_line
+ 1);
4599 Cur_File
= (struct input_file
*) NULL
;
4601 /* Scan the symbols and write out the routines
4602 (this makes the assumption that symbols are in
4603 order of ascending text segment offset). */
4604 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
4606 /* Deal with text symbols. */
4607 if (!S_IS_DEBUG (symbolP
) && S_GET_TYPE (symbolP
) == N_TEXT
)
4609 /* Ignore symbols starting with "L", as they are local symbols. */
4610 if (*S_GET_NAME (symbolP
) == 'L')
4612 /* If there is a routine start defined, terminate it. */
4613 if (Current_Routine
)
4614 VMS_TBT_Routine_End (text_siz
, Current_Routine
);
4616 /* Check for & skip dummy labels like "gcc_compiled.".
4617 * They're identified by the IN_DEFAULT_SECTION flag. */
4618 if ((S_GET_OTHER (symbolP
) & IN_DEFAULT_SECTION
) != 0 &&
4619 S_GET_VALUE (symbolP
) == 0)
4621 /* Store the routine begin traceback info. */
4622 VMS_TBT_Routine_Begin (symbolP
, Text_Psect
);
4623 Current_Routine
= symbolP
;
4624 /* Define symbols local to this routine. */
4625 local_symbols_DST (symbolP
, Current_Routine
);
4630 /* Deal with STAB symbols. */
4631 else if (S_IS_DEBUG (symbolP
))
4633 /* Dispatch on STAB type. */
4634 switch (S_GET_RAW_TYPE (symbolP
))
4638 /* Offset the line into the correct portion of the file. */
4639 if (Cur_File
->file_number
== 0)
4641 val
= S_GET_VALUE (symbolP
);
4642 /* Sometimes the same offset gets several source lines
4643 assigned to it. We should be selective about which
4644 lines we allow, we should prefer lines that are in
4645 the main source file when debugging inline functions. */
4646 if (val
== Cur_Offset
&& Cur_File
->file_number
!= 1)
4649 /* Calculate actual debugger source line. */
4650 dsc
= S_GET_DESC (symbolP
) + Cur_File
->offset
;
4651 S_SET_DESC (symbolP
, dsc
);
4652 /* Define PC/Line correlation. */
4653 if (Cur_Offset
== -1)
4655 /* First N_SLINE; set up initial correlation. */
4656 VMS_TBT_Line_PC_Correlation (dsc
,
4661 else if ((dsc
- Cur_Line_Number
) <= 0)
4663 /* Line delta is not +ve, we need to close the line and
4664 start a new PC/Line correlation. */
4665 VMS_TBT_Line_PC_Correlation (0,
4669 VMS_TBT_Line_PC_Correlation (dsc
,
4676 /* Line delta is +ve, all is well. */
4677 VMS_TBT_Line_PC_Correlation (dsc
- Cur_Line_Number
,
4682 /* Update the current line/PC info. */
4683 Cur_Line_Number
= dsc
;
4689 /* Remember that we had a source file and emit
4690 the source file debugger record. */
4691 Cur_File
= find_file (symbolP
);
4695 /* We need to make sure that we are really in the actual
4696 source file when we compute the maximum line number.
4697 Otherwise the debugger gets really confused. */
4698 Cur_File
= find_file (symbolP
);
4707 /* If there is a routine start defined, terminate it
4708 (and the line numbers). */
4709 if (Current_Routine
)
4711 /* Terminate the line numbers. */
4712 VMS_TBT_Line_PC_Correlation (0,
4713 text_siz
- S_GET_VALUE (Current_Routine
),
4716 /* Terminate the routine. */
4717 VMS_TBT_Routine_End (text_siz
, Current_Routine
);
4720 /* Write the Traceback End Module TBT record. */
4721 VMS_TBT_Module_End ();
4725 /* Write a VAX/VMS object file (everything else has been done!). */
4728 vms_write_object_file (unsigned text_siz
, unsigned data_siz
, unsigned bss_siz
,
4729 fragS
*text_frag_root
, fragS
*data_frag_root
)
4731 struct VMS_Symbol
*vsp
;
4733 /* Initialize program section indices; values get updated later. */
4734 Psect_Number
= 0; /* next Psect Index to use */
4735 Text_Psect
= -1; /* Text Psect Index */
4736 Data_Psect
= -2; /* Data Psect Index JF: Was -1 */
4737 Bss_Psect
= -3; /* Bss Psect Index JF: Was -1 */
4738 Ctors_Psect
= -4; /* Ctors Psect Index */
4739 Dtors_Psect
= -5; /* Dtors Psect Index */
4740 /* Initialize other state variables. */
4742 Local_Initd_Data_Size
= 0;
4744 /* Create the actual output file and populate it with required
4745 "module header" information. */
4746 Create_VMS_Object_File ();
4747 Write_VMS_MHD_Records ();
4749 /* Create the Data segment:
4751 Since this is REALLY hard to do any other way,
4752 we actually manufacture the data segment and
4753 then store the appropriate values out of it.
4754 We need to generate this early, so that globalvalues
4755 can be properly emitted. */
4757 synthesize_data_segment (data_siz
, text_siz
, data_frag_root
);
4759 /* Global Symbol Directory. */
4761 /* Emit globalvalues now. We must do this before the text psect is
4762 defined, or we will get linker warnings about multiply defined
4763 symbols. All of the globalvalues "reference" psect 0, although
4764 it really does not have anything to do with it. */
4765 VMS_Emit_Globalvalues (text_siz
, data_siz
, Data_Segment
);
4766 /* Define the Text Psect. */
4767 Text_Psect
= Psect_Number
++;
4768 VMS_Psect_Spec ("$code", text_siz
, ps_TEXT
, 0);
4769 /* Define the BSS Psect. */
4772 Bss_Psect
= Psect_Number
++;
4773 VMS_Psect_Spec ("$uninitialized_data", bss_siz
, ps_DATA
, 0);
4775 /* Define symbols to the linker. */
4776 global_symbol_directory (text_siz
, data_siz
);
4777 /* Define the Data Psect. */
4778 if (data_siz
> 0 && Local_Initd_Data_Size
> 0)
4780 Data_Psect
= Psect_Number
++;
4781 VMS_Psect_Spec ("$data", Local_Initd_Data_Size
, ps_DATA
, 0);
4782 /* Local initialized data (N_DATA) symbols need to be updated to the
4783 proper value of Data_Psect now that it's actually been defined.
4784 (A dummy value was used in global_symbol_directory() above.) */
4785 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
4786 if (vsp
->Psect_Index
< 0 && S_GET_RAW_TYPE (vsp
->Symbol
) == N_DATA
)
4787 vsp
->Psect_Index
= Data_Psect
;
4790 if (Ctors_Symbols
!= 0)
4792 char *ps_name
= "$ctors";
4793 Ctors_Psect
= Psect_Number
++;
4794 VMS_Psect_Spec (ps_name
, Ctors_Symbols
->Psect_Offset
+ XTOR_SIZE
,
4796 VMS_Global_Symbol_Spec (ps_name
, Ctors_Psect
,
4797 0, GBLSYM_DEF
|GBLSYM_WEAK
);
4798 for (vsp
= Ctors_Symbols
; vsp
; vsp
= vsp
->Next
)
4799 vsp
->Psect_Index
= Ctors_Psect
;
4802 if (Dtors_Symbols
!= 0)
4804 char *ps_name
= "$dtors";
4805 Dtors_Psect
= Psect_Number
++;
4806 VMS_Psect_Spec (ps_name
, Dtors_Symbols
->Psect_Offset
+ XTOR_SIZE
,
4808 VMS_Global_Symbol_Spec (ps_name
, Dtors_Psect
,
4809 0, GBLSYM_DEF
|GBLSYM_WEAK
);
4810 for (vsp
= Dtors_Symbols
; vsp
; vsp
= vsp
->Next
)
4811 vsp
->Psect_Index
= Dtors_Psect
;
4814 /* Text Information and Relocation Records. */
4816 /* Write the text segment data. */
4818 vms_fixup_text_section (text_siz
, text_frag_root
, data_frag_root
);
4819 /* Write the data segment data, then discard it. */
4822 vms_fixup_data_section (data_siz
, text_siz
);
4823 free (Data_Segment
), Data_Segment
= 0;
4826 if (Ctors_Symbols
!= 0)
4827 vms_fixup_xtors_section (Ctors_Symbols
, Ctors_Psect
);
4829 if (Dtors_Symbols
!= 0)
4830 vms_fixup_xtors_section (Dtors_Symbols
, Dtors_Psect
);
4832 /* Debugger Symbol Table Records. */
4834 vms_build_DST (text_siz
);
4836 /* Wrap things up. */
4838 /* Write the End Of Module record. */
4839 if (Entry_Point_Symbol
)
4840 Write_VMS_EOM_Record (Text_Psect
, S_GET_VALUE (Entry_Point_Symbol
));
4842 Write_VMS_EOM_Record (-1, (valueT
) 0);
4844 /* All done, close the object file. */
4845 Close_VMS_Object_File ();