1 /* vms.c -- Write out a VAX/VMS object file
2 Copyright (C) 1987, 88, 92, 94, 95, 97, 98, 2000
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* Written by David L. Kashtan */
23 /* Modified by Eric Youngdale to write VMS debug records for program
26 /* Want all of obj-vms.h (as obj-format.h, via targ-env.h, via as.h). */
27 #define WANT_VMS_OBJ_DEFS
34 /* What we do if there is a goof. */
35 #define error as_fatal
37 #ifdef VMS /* These are of no use if we are cross assembling. */
38 #include <fab.h> /* Define File Access Block */
39 #include <nam.h> /* Define NAM Block */
40 #include <xab.h> /* Define XAB - all different types*/
41 extern int sys$
open(), sys$
close(), sys$
asctim();
45 * Version string of the compiler that produced the code we are
46 * assembling. (And this assembler, if we do not have compiler info.)
48 char *compiler_version_string
;
50 extern int flag_hash_long_names
; /* -+ */
51 extern int flag_one
; /* -1; compatibility with gcc 1.x */
52 extern int flag_show_after_trunc
; /* -H */
53 extern int flag_no_hash_mixed_case
; /* -h NUM */
55 /* Flag that determines how we map names. This takes several values, and
56 * is set with the -h switch. A value of zero implies names should be
57 * upper case, and the presence of the -h switch inhibits the case hack.
58 * No -h switch at all sets vms_name_mapping to 0, and allows case hacking.
59 * A value of 2 (set with -h2) implies names should be
60 * all lower case, with no case hack. A value of 3 (set with -h3) implies
61 * that case should be preserved. */
63 /* If the -+ switch is given, then the hash is appended to any name that is
64 * 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" */
72 * We augment the "gas" symbol structure with this
76 struct VMS_Symbol
*Next
;
83 struct VMS_Symbol
*VMS_Symbols
= 0;
84 struct VMS_Symbol
*Ctors_Symbols
= 0;
85 struct VMS_Symbol
*Dtors_Symbols
= 0;
87 /* We need this to keep track of the various input files, so that we can
88 * give the debugger the correct source line.
93 struct input_file
*next
;
94 struct input_file
*same_file_fpnt
;
104 static struct input_file
*file_root
= (struct input_file
*) NULL
;
107 * Styles of PSECTS (program sections) that we generate; just shorthand
108 * to avoid lists of section attributes. Used by VMS_Psect_Spec().
112 ps_TEXT
, ps_DATA
, ps_COMMON
, ps_CONST
, ps_CTORS
, ps_DTORS
116 * This enum is used to keep track of the various types of variables that
122 BASIC
, POINTER
, ARRAY
, ENUM
, STRUCT
, UNION
, FUNCTION
, VOID
, ALIAS
, UNKNOWN
126 * This structure contains the information from the stabs directives, and the
127 * information is filled in by VMS_typedef_parse. Everything that is needed
128 * to generate the debugging record for a given symbol is present here.
129 * This could be done more efficiently, using nested struct/unions, but for now
130 * I am happy that it works.
132 struct VMS_DBG_Symbol
134 struct VMS_DBG_Symbol
*next
;
135 /* description of what this is */
136 enum advanced_type advanced
;
137 /* this record is for this type */
139 /* For advanced types this is the type referred to. I.e., the type
140 a pointer points to, or the type of object that makes up an
143 /* Use this type when generating a variable def */
145 /* used for arrays - this will be present for all */
147 /* entries, but will be meaningless for non-arrays */
149 /* Size in bytes of the data type. For an array, this is the size
150 of one element in the array */
152 /* Number of the structure/union/enum - used for ref */
156 #define SYMTYPLST_SIZE (1<<4) /* 16; must be power of two */
157 #define SYMTYP_HASH(x) ((unsigned)(x) & (SYMTYPLST_SIZE-1))
158 struct VMS_DBG_Symbol
*VMS_Symbol_type_list
[SYMTYPLST_SIZE
];
161 * We need this structure to keep track of forward references to
162 * struct/union/enum that have not been defined yet. When they are ultimately
163 * defined, then we can go back and generate the TIR commands to make a back
169 struct forward_ref
*next
;
175 struct forward_ref
*f_ref_root
= (struct forward_ref
*) NULL
;
178 * This routine is used to compare the names of certain types to various
179 * fixed types that are known by the debugger.
181 #define type_check(X) !strcmp (symbol_name, X)
184 * This variable is used to keep track of the name of the symbol we are
185 * working on while we are parsing the stabs directives.
187 static const char *symbol_name
;
189 /* We use this counter to assign numbers to all of the structures, unions
190 * and enums that we define. When we actually declare a variable to the
191 * debugger, we can simply do it by number, rather than describing the
192 * whole thing each time.
195 static structure_count
= 0;
197 /* This variable is used to indicate that we are making the last attempt to
198 parse the stabs, and that we should define as much as we can, and ignore
201 static int final_pass
;
203 /* This variable is used to keep track of the current structure number
204 * for a given variable. If this is < 0, that means that the structure
205 * has not yet been defined to the debugger. This is still cool, since
206 * the VMS object language has ways of fixing things up after the fact,
207 * so we just make a note of this, and generate fixups at the end.
209 static int struct_number
;
211 /* This is used to distinguish between D_float and G_float for telling
212 the debugger about doubles. gcc outputs the same .stabs regardless
213 of whether -mg is used to select alternate doubles. */
215 static int vax_g_doubles
= 0;
217 /* Local symbol references (used to handle N_ABS symbols; gcc does not
218 generate those, but they're possible with hand-coded assembler input)
219 are always made relative to some particular environment. If the current
220 input has any such symbols, then we expect this to get incremented
221 exactly once and end up having all of them be in environment #0. */
223 static int Current_Environment
= -1;
225 /* Every object file must specify an module name, which is also used by
226 traceback records. Set in Write_VMS_MHD_Records(). */
228 static char Module_Name
[255+1];
231 * Variable descriptors are used tell the debugger the data types of certain
232 * more complicated variables (basically anything involving a structure,
233 * union, enum, array or pointer). Some non-pointer variables of the
234 * basic types that the debugger knows about do not require a variable
237 * Since it is impossible to have a variable descriptor longer than 128
238 * bytes by virtue of the way that the VMS object language is set up,
239 * it makes not sense to make the arrays any longer than this, or worrying
240 * about dynamic sizing of the array.
242 * These are the arrays and counters that we use to build a variable
246 #define MAX_DEBUG_RECORD 128
247 static char Local
[MAX_DEBUG_RECORD
]; /* buffer for variable descriptor */
248 static char Asuffix
[MAX_DEBUG_RECORD
]; /* buffer for array descriptor */
249 static int Lpnt
; /* index into Local */
250 static int Apoint
; /* index into Asuffix */
251 static char overflow
; /* flag to indicate we have written too much*/
252 static int total_len
; /* used to calculate the total length of variable
253 descriptor plus array descriptor - used for len byte*/
255 /* Flag if we have told user about finding global constants in the text
257 static int gave_compiler_message
= 0;
260 * Global data (Object records limited to 512 bytes by VAX-11 "C" runtime)
262 static int VMS_Object_File_FD
; /* File Descriptor for object file */
263 static char Object_Record_Buffer
[512]; /* Buffer for object file records */
264 static int Object_Record_Offset
;/* Offset to end of data */
265 static int Current_Object_Record_Type
; /* Type of record in above */
268 * Macros for moving data around. Must work on big-endian systems.
270 #ifdef VMS /* These are more efficient for VMS->VMS systems */
271 #define COPY_LONG(dest,val) ( *(long *)(dest) = (val) )
272 #define COPY_SHORT(dest,val) ( *(short *)(dest) = (val) )
274 #define COPY_LONG(dest,val) md_number_to_chars ((dest), (val), 4)
275 #define COPY_SHORT(dest,val) md_number_to_chars ((dest), (val), 2)
278 * Macros for placing data into the object record buffer.
280 #define PUT_LONG(val) \
281 ( COPY_LONG (&Object_Record_Buffer[Object_Record_Offset], (val)), \
282 Object_Record_Offset += 4 )
284 #define PUT_SHORT(val) \
285 ( COPY_SHORT (&Object_Record_Buffer[Object_Record_Offset], (val)), \
286 Object_Record_Offset += 2 )
288 #define PUT_CHAR(val) ( Object_Record_Buffer[Object_Record_Offset++] = (val) )
290 #define PUT_COUNTED_STRING(cp) do { \
291 register const char *p = (cp); \
292 PUT_CHAR ((char) strlen (p)); \
293 while (*p) PUT_CHAR (*p++); } while (0)
296 * Macro for determining if a Name has psect attributes attached
299 #define PSECT_ATTRIBUTES_STRING "$$PsectAttributes_"
300 #define PSECT_ATTRIBUTES_STRING_LENGTH 18
302 #define HAS_PSECT_ATTRIBUTES(Name) \
303 (strncmp ((*Name == '_' ? Name + 1 : Name), \
304 PSECT_ATTRIBUTES_STRING, \
305 PSECT_ATTRIBUTES_STRING_LENGTH) == 0)
308 /* in: segT out: N_TYPE bits */
309 const short seg_N_TYPE
[] =
315 N_UNDF
, /* unknown */
317 N_UNDF
, /* expression */
321 N_REGISTER
, /* register */
324 const segT N_TYPE_seg
[N_TYPE
+ 2] =
325 { /* N_TYPE == 0x1E = 32-2 */
326 SEG_UNKNOWN
, /* N_UNDF == 0 */
328 SEG_ABSOLUTE
, /* N_ABS == 2 */
330 SEG_TEXT
, /* N_TEXT == 4 */
332 SEG_DATA
, /* N_DATA == 6 */
334 SEG_BSS
, /* N_BSS == 8 */
336 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
337 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
338 SEG_GOOF
, SEG_GOOF
, SEG_GOOF
, SEG_GOOF
,
339 SEG_REGISTER
, /* dummy N_REGISTER for regs = 30 */
344 /* Local support routines which return a value. */
346 static struct input_file
*find_file
PARAMS ((symbolS
*));
347 static struct VMS_DBG_Symbol
*find_symbol
PARAMS ((int));
348 static symbolS
*Define_Routine
PARAMS ((symbolS
*,int,symbolS
*,int));
350 static char *cvt_integer
PARAMS ((char *,int *));
351 static char *fix_name
PARAMS ((char *));
352 static char *get_struct_name
PARAMS ((char *));
354 static offsetT VMS_Initialized_Data_Size
PARAMS ((symbolS
*,unsigned));
356 static int VMS_TBT_Source_File
PARAMS ((char *,int));
357 static int gen1
PARAMS ((struct VMS_DBG_Symbol
*,int));
358 static int forward_reference
PARAMS ((char *));
359 static int final_forward_reference
PARAMS ((struct VMS_DBG_Symbol
*));
360 static int VMS_typedef_parse
PARAMS ((char *));
361 static int hash_string
PARAMS ((const char *));
362 static int VMS_Psect_Spec
PARAMS ((const char *,int,enum ps_type
,
363 struct VMS_Symbol
*));
365 /* Local support routines which don't directly return any value. */
367 static void s_const
PARAMS ((int));
368 static void Create_VMS_Object_File
PARAMS ((void));
369 static void Flush_VMS_Object_Record_Buffer
PARAMS ((void));
370 static void Set_VMS_Object_File_Record
PARAMS ((int));
371 static void Close_VMS_Object_File
PARAMS ((void));
372 static void vms_tir_stack_psect
PARAMS ((int,int,int));
373 static void VMS_Store_Immediate_Data
PARAMS ((const char *,int,int));
374 static void VMS_Set_Data
PARAMS ((int,int,int,int));
375 static void VMS_Store_Struct
PARAMS ((int));
376 static void VMS_Def_Struct
PARAMS ((int));
377 static void VMS_Set_Struct
PARAMS ((int));
378 static void VMS_TBT_Module_Begin
PARAMS ((void));
379 static void VMS_TBT_Module_End
PARAMS ((void));
380 static void VMS_TBT_Routine_Begin
PARAMS ((symbolS
*,int));
381 static void VMS_TBT_Routine_End
PARAMS ((int,symbolS
*));
382 static void VMS_TBT_Block_Begin
PARAMS ((symbolS
*,int,char *));
383 static void VMS_TBT_Block_End
PARAMS ((valueT
));
384 static void VMS_TBT_Line_PC_Correlation
PARAMS ((int,int,int,int));
385 static void VMS_TBT_Source_Lines
PARAMS ((int,int,int));
386 static void fpush
PARAMS ((int,int));
387 static void rpush
PARAMS ((int,int));
388 static void array_suffix
PARAMS ((struct VMS_DBG_Symbol
*));
389 static void new_forward_ref
PARAMS ((int));
390 static void generate_suffix
PARAMS ((struct VMS_DBG_Symbol
*,int));
391 static void bitfield_suffix
PARAMS ((struct VMS_DBG_Symbol
*,int));
392 static void setup_basic_type
PARAMS ((struct VMS_DBG_Symbol
*));
393 static void VMS_DBG_record
PARAMS ((struct VMS_DBG_Symbol
*,int,int,char *));
394 static void VMS_local_stab_Parse
PARAMS ((symbolS
*));
395 static void VMS_stab_parse
PARAMS ((symbolS
*,int,int,int,int));
396 static void VMS_GSYM_Parse
PARAMS ((symbolS
*,int));
397 static void VMS_LCSYM_Parse
PARAMS ((symbolS
*,int));
398 static void VMS_STSYM_Parse
PARAMS ((symbolS
*,int));
399 static void VMS_RSYM_Parse
PARAMS ((symbolS
*,symbolS
*,int));
400 static void VMS_LSYM_Parse
PARAMS ((void));
401 static void Define_Local_Symbols
PARAMS ((symbolS
*,symbolS
*,symbolS
*,int));
402 static void Write_VMS_MHD_Records
PARAMS ((void));
403 static void Write_VMS_EOM_Record
PARAMS ((int,valueT
));
404 static void VMS_Case_Hack_Symbol
PARAMS ((const char *,char *));
405 static void VMS_Modify_Psect_Attributes
PARAMS ((const char *,int *));
406 static void VMS_Global_Symbol_Spec
PARAMS ((const char *,int,int,int));
407 static void VMS_Local_Environment_Setup
PARAMS ((const char *));
408 static void VMS_Emit_Globalvalues
PARAMS ((unsigned,unsigned,char *));
409 static void VMS_Procedure_Entry_Pt
PARAMS ((char *,int,int,int));
410 static void VMS_Set_Psect
PARAMS ((int,int,int));
411 static void VMS_Store_Repeated_Data
PARAMS ((int,char *,int,int));
412 static void VMS_Store_PIC_Symbol_Reference
PARAMS ((symbolS
*,int,
414 static void VMS_Fix_Indirect_Reference
PARAMS ((int,int,fragS
*,fragS
*));
416 /* Support code which used to be inline within vms_write_object_file. */
417 static void vms_fixup_text_section
PARAMS ((unsigned,struct frag
*,struct frag
*));
418 static void synthesize_data_segment
PARAMS ((unsigned,unsigned,struct frag
*));
419 static void vms_fixup_data_section
PARAMS ((unsigned,unsigned));
420 static void global_symbol_directory
PARAMS ((unsigned,unsigned));
421 static void local_symbols_DST
PARAMS ((symbolS
*,symbolS
*));
422 static void vms_build_DST
PARAMS ((unsigned));
423 static void vms_fixup_xtors_section
PARAMS ((struct VMS_Symbol
*, int));
426 /* The following code defines the special types of pseudo-ops that we
429 unsigned char const_flag
= IN_DEFAULT_SECTION
;
433 int arg
; /* 3rd field from obj_pseudo_table[]; not needed here */
435 /* Since we don't need `arg', use it as our scratch variable so that
436 we won't get any "not used" warnings about it. */
437 arg
= get_absolute_expression ();
438 subseg_set (SEG_DATA
, (subsegT
) arg
);
440 demand_empty_rest_of_line ();
443 const pseudo_typeS obj_pseudo_table
[] =
445 {"const", s_const
, 0},
447 }; /* obj_pseudo_table */
449 /* Routine to perform RESOLVE_SYMBOL_REDEFINITION(). */
452 vms_resolve_symbol_redef (sym
)
456 * If the new symbol is .comm AND it has a size of zero,
457 * we ignore it (i.e. the old symbol overrides it)
459 if (SEGMENT_TO_SYMBOL_TYPE ((int) now_seg
) == (N_UNDF
| N_EXT
)
460 && frag_now_fix () == 0)
462 as_warn (_("compiler emitted zero-size common symbol `%s' already defined"),
467 * If the old symbol is .comm and it has a size of zero,
468 * we override it with the new symbol value.
470 if (S_IS_EXTERNAL (sym
) && S_IS_DEFINED (sym
) && S_GET_VALUE (sym
) == 0)
472 as_warn (_("compiler redefined zero-size common symbol `%s'"),
474 sym
->sy_frag
= frag_now
;
475 S_SET_OTHER (sym
, const_flag
);
476 S_SET_VALUE (sym
, frag_now_fix ());
477 /* Keep N_EXT bit. */
478 sym
->sy_symbol
.n_type
|= SEGMENT_TO_SYMBOL_TYPE ((int) now_seg
);
485 /* `tc_frob_label' handler for colon(symbols.c), used to examine the
486 dummy label(s) gcc inserts at the beginning of each file it generates.
487 gcc 1.x put "gcc_compiled."; gcc 2.x (as of 2.7) puts "gcc2_compiled."
488 and "__gnu_language_<name>" and possibly "__vax_<type>_doubles". */
491 vms_check_for_special_label (symbolP
)
494 /* Special labels only occur prior to explicit section directives. */
495 if ((const_flag
& IN_DEFAULT_SECTION
) != 0)
497 char *sym_name
= S_GET_NAME (symbolP
);
499 if (*sym_name
== '_')
502 if (!strcmp (sym_name
, "__vax_g_doubles"))
504 #if 0 /* not necessary */
505 else if (!strcmp (sym_name
, "__vax_d_doubles"))
508 #if 0 /* these are potential alternatives to tc-vax.c's md_parse_options() */
509 else if (!strcmp (sym_name
, "gcc_compiled."))
511 else if (!strcmp (sym_name
, "__gnu_language_cplusplus"))
512 flag_hash_long_names
= 1;
519 obj_read_begin_hook ()
525 obj_crawl_symbol_chain (headers
)
526 object_headers
*headers
;
530 int symbol_number
= 0;
532 symbolPP
= &symbol_rootP
; /* -> last symbol chain link. */
533 while ((symbolP
= *symbolPP
) != NULL
)
535 resolve_symbol_value (symbolP
, 1);
537 /* OK, here is how we decide which symbols go out into the
538 brave new symtab. Symbols that do are:
540 * symbols with no name (stabd's?)
541 * symbols with debug info in their N_TYPE
542 * symbols with \1 as their 3rd character (numeric labels)
543 * "local labels" needed for PIC fixups
545 Symbols that don't are:
546 * symbols that are registers
548 All other symbols are output. We complain if a deleted
549 symbol was marked external. */
551 if (!S_IS_REGISTER (symbolP
))
553 symbolP
->sy_number
= symbol_number
++;
554 symbolP
->sy_name_offset
= 0;
555 symbolPP
= &(symbol_next (symbolP
));
559 if (S_IS_EXTERNAL (symbolP
) || !S_IS_DEFINED (symbolP
))
561 as_bad (_("Local symbol %s never defined"), S_GET_NAME (symbolP
));
564 /* Unhook it from the chain. */
565 *symbolPP
= symbol_next (symbolP
);
566 } /* if this symbol should be in the output */
568 } /* for each symbol */
570 H_SET_STRING_SIZE (headers
, string_byte_count
);
571 H_SET_SYMBOL_TABLE_SIZE (headers
, symbol_number
);
572 } /* obj_crawl_symbol_chain() */
575 /****** VMS OBJECT FILE HACKING ROUTINES *******/
577 /* Create the VMS object file. */
580 Create_VMS_Object_File ()
582 #if defined(eunice) || !defined(VMS)
583 VMS_Object_File_FD
= creat (out_file_name
, 0777, "var");
585 VMS_Object_File_FD
= creat (out_file_name
, 0, "rfm=var",
586 "ctx=bin", "mbc=16", "deq=64", "fop=tef",
589 /* Deal with errors. */
590 if (VMS_Object_File_FD
< 0)
591 as_fatal (_("Couldn't create VMS object file \"%s\""), out_file_name
);
592 /* Initialize object file hacking variables. */
593 Object_Record_Offset
= 0;
594 Current_Object_Record_Type
= -1;
597 /* Flush the object record buffer to the object file. */
600 Flush_VMS_Object_Record_Buffer ()
602 /* If the buffer is empty, there's nothing to do. */
603 if (Object_Record_Offset
== 0)
606 #ifndef VMS /* For cross-assembly purposes. */
610 /* "Variable-length record" files have a two byte length field
611 prepended to each record. It's normally out-of-band, and native
612 VMS output will insert it automatically for this type of file.
613 When cross-assembling, we must write it explicitly. */
614 md_number_to_chars (RecLen
, Object_Record_Offset
, 2);
615 if (write (VMS_Object_File_FD
, RecLen
, 2) != 2)
616 error (_("I/O error writing VMS object file (length prefix)"));
617 /* We also need to force the actual record to be an even number of
618 bytes. For native output, that's automatic; when cross-assembling,
619 pad with a NUL byte if length is odd. Do so _after_ writing the
620 pre-padded length. Since our buffer is defined with even size,
621 an odd offset implies that it has some room left. */
622 if ((Object_Record_Offset
& 1) != 0)
623 Object_Record_Buffer
[Object_Record_Offset
++] = '\0';
627 /* Write the data to the file. */
628 if (write (VMS_Object_File_FD
, Object_Record_Buffer
, Object_Record_Offset
)
629 != Object_Record_Offset
)
630 error (_("I/O error writing VMS object file"));
632 /* The buffer is now empty. */
633 Object_Record_Offset
= 0;
636 /* Declare a particular type of object file record. */
639 Set_VMS_Object_File_Record (Type
)
642 /* If the type matches, we are done. */
643 if (Type
== Current_Object_Record_Type
)
645 /* Otherwise: flush the buffer. */
646 Flush_VMS_Object_Record_Buffer ();
647 /* Remember the new type. */
648 Current_Object_Record_Type
= Type
;
651 /* Close the VMS Object file. */
654 Close_VMS_Object_File ()
656 /* Flush (should never be necessary) and reset saved record-type context. */
657 Set_VMS_Object_File_Record (-1);
659 #ifndef VMS /* For cross-assembly purposes. */
664 /* Write a 2 byte record-length field of -1 into the file, which
665 means end-of-block when read, hence end-of-file when occurring
666 in the file's last block. It is only needed for variable-length
667 record files transferred to VMS as fixed-length record files
668 (typical for binary FTP; NFS shouldn't need it, but it won't hurt). */
669 md_number_to_chars (RecLen
, minus_one
, 2);
670 write (VMS_Object_File_FD
, RecLen
, 2);
673 /* When written on a VMS system, the file header (cf inode) will record
674 the actual end-of-file position and no inline marker is needed. */
677 close (VMS_Object_File_FD
);
681 /****** Text Information and Relocation routines ******/
683 /* Stack Psect base followed by signed, varying-sized offset.
684 Common to several object records. */
687 vms_tir_stack_psect (Psect_Index
, Offset
, Force
)
692 int psect_width
, offset_width
;
694 psect_width
= ((unsigned) Psect_Index
> 255) ? 2 : 1;
695 offset_width
= (Force
|| Offset
> 32767 || Offset
< -32768) ? 4
696 : (Offset
> 127 || Offset
< -128) ? 2 : 1;
697 #define Sta_P(p,o) (((o)<<1) | ((p)-1))
698 /* byte or word psect; byte, word, or longword offset */
699 switch (Sta_P(psect_width
,offset_width
))
701 case Sta_P(1,1): PUT_CHAR (TIR_S_C_STA_PB
);
702 PUT_CHAR ((char)(unsigned char) Psect_Index
);
703 PUT_CHAR ((char) Offset
);
705 case Sta_P(1,2): PUT_CHAR (TIR_S_C_STA_PW
);
706 PUT_CHAR ((char)(unsigned char) Psect_Index
);
709 case Sta_P(1,4): PUT_CHAR (TIR_S_C_STA_PL
);
710 PUT_CHAR ((char)(unsigned char) Psect_Index
);
713 case Sta_P(2,1): PUT_CHAR (TIR_S_C_STA_WPB
);
714 PUT_SHORT (Psect_Index
);
715 PUT_CHAR ((char) Offset
);
717 case Sta_P(2,2): PUT_CHAR (TIR_S_C_STA_WPW
);
718 PUT_SHORT (Psect_Index
);
721 case Sta_P(2,4): PUT_CHAR (TIR_S_C_STA_WPL
);
722 PUT_SHORT (Psect_Index
);
729 /* Store immediate data in current Psect. */
732 VMS_Store_Immediate_Data (Pointer
, Size
, Record_Type
)
739 Set_VMS_Object_File_Record (Record_Type
);
740 /* We can only store as most 128 bytes at a time due to the way that
741 TIR commands are encoded. */
744 i
= (Size
> 128) ? 128 : Size
;
746 /* If we cannot accommodate this record, flush the buffer. */
747 if ((Object_Record_Offset
+ i
+ 1) >= sizeof Object_Record_Buffer
)
748 Flush_VMS_Object_Record_Buffer ();
749 /* If the buffer is empty we must insert record type. */
750 if (Object_Record_Offset
== 0)
751 PUT_CHAR (Record_Type
);
752 /* Store the count. The Store Immediate TIR command is implied by
753 a negative command byte, and the length of the immediate data
754 is abs(command_byte). So, we write the negated length value. */
755 PUT_CHAR ((char) (-i
& 0xff));
756 /* Now store the data. */
758 PUT_CHAR (*Pointer
++);
760 /* Flush the buffer if it is more than 75% full. */
761 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
762 Flush_VMS_Object_Record_Buffer ();
765 /* Make a data reference. */
768 VMS_Set_Data (Psect_Index
, Offset
, Record_Type
, Force
)
774 Set_VMS_Object_File_Record (Record_Type
);
775 /* If the buffer is empty we must insert the record type. */
776 if (Object_Record_Offset
== 0)
777 PUT_CHAR (Record_Type
);
778 /* Stack the Psect base with its offset. */
779 vms_tir_stack_psect (Psect_Index
, Offset
, Force
);
780 /* Set relocation base. */
781 PUT_CHAR (TIR_S_C_STO_PIDR
);
782 /* Flush the buffer if it is more than 75% full. */
783 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
784 Flush_VMS_Object_Record_Buffer ();
787 /* Make a debugger reference to a struct, union or enum. */
790 VMS_Store_Struct (Struct_Index
)
793 /* We are writing a debug record. */
794 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
795 /* If the buffer is empty we must insert the record type. */
796 if (Object_Record_Offset
== 0)
797 PUT_CHAR (OBJ_S_C_DBG
);
798 PUT_CHAR (TIR_S_C_STA_UW
);
799 PUT_SHORT (Struct_Index
);
800 PUT_CHAR (TIR_S_C_CTL_STKDL
);
801 PUT_CHAR (TIR_S_C_STO_L
);
802 /* Flush the buffer if it is more than 75% full. */
803 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
804 Flush_VMS_Object_Record_Buffer ();
807 /* Make a debugger reference to partially define a struct, union or enum. */
810 VMS_Def_Struct (Struct_Index
)
813 /* We are writing a debug record. */
814 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
815 /* If the buffer is empty we must insert the record type. */
816 if (Object_Record_Offset
== 0)
817 PUT_CHAR (OBJ_S_C_DBG
);
818 PUT_CHAR (TIR_S_C_STA_UW
);
819 PUT_SHORT (Struct_Index
);
820 PUT_CHAR (TIR_S_C_CTL_DFLOC
);
821 /* Flush the buffer if it is more than 75% full. */
822 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
823 Flush_VMS_Object_Record_Buffer ();
827 VMS_Set_Struct (Struct_Index
)
829 { /* see previous functions for comments */
830 Set_VMS_Object_File_Record (OBJ_S_C_DBG
);
831 if (Object_Record_Offset
== 0)
832 PUT_CHAR (OBJ_S_C_DBG
);
833 PUT_CHAR (TIR_S_C_STA_UW
);
834 PUT_SHORT (Struct_Index
);
835 PUT_CHAR (TIR_S_C_CTL_STLOC
);
836 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
837 Flush_VMS_Object_Record_Buffer ();
841 /****** Traceback Information routines ******/
843 /* Write the Traceback Module Begin record. */
846 VMS_TBT_Module_Begin ()
848 register char *cp
, *cp1
;
852 /* Arrange to store the data locally (leave room for size byte). */
855 *cp
++ = DST_S_C_MODBEG
;
856 *cp
++ = 0; /* flags; not used */
858 * Language type == "C"
860 * (FIXME: this should be based on the input...)
862 COPY_LONG (cp
, DST_S_C_C
);
864 /* Store the module name. */
865 *cp
++ = (char) strlen (Module_Name
);
869 /* Now we can store the record size. */
872 /* Put it into the object record. */
873 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_TBT
);
876 /* Write the Traceback Module End record. */
879 VMS_TBT_Module_End ()
885 Local
[1] = DST_S_C_MODEND
;
886 /* Put it into the object record. */
887 VMS_Store_Immediate_Data (Local
, 2, OBJ_S_C_TBT
);
890 /* Write a Traceback Routine Begin record. */
893 VMS_TBT_Routine_Begin (symbolP
, Psect
)
897 register char *cp
, *cp1
;
903 /* Strip the leading "_" from the name. */
904 Name
= S_GET_NAME (symbolP
);
907 /* Get the text psect offset. */
908 Offset
= S_GET_VALUE (symbolP
);
909 /* Set the record size. */
910 Size
= 1 + 1 + 4 + 1 + strlen (Name
);
912 /* DST type "routine begin". */
913 Local
[1] = DST_S_C_RTNBEG
;
914 /* Uses CallS/CallG. */
916 /* Store the data so far. */
917 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_TBT
);
918 /* Make sure we are still generating a OBJ_S_C_TBT record. */
919 if (Object_Record_Offset
== 0)
920 PUT_CHAR (OBJ_S_C_TBT
);
921 /* Stack the address. */
922 vms_tir_stack_psect (Psect
, Offset
, 0);
923 /* Store the data reference. */
924 PUT_CHAR (TIR_S_C_STO_PIDR
);
925 /* Store the counted string as data. */
928 Size
= strlen (cp1
) + 1;
932 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_TBT
);
935 /* Write a Traceback Routine End record.
937 We *must* search the symbol table to find the next routine, since the
938 assember has a way of reassembling the symbol table OUT OF ORDER Thus
939 the next routine in the symbol list is not necessarily the next one in
940 memory. For debugging to work correctly we must know the size of the
944 VMS_TBT_Routine_End (Max_Size
, sp
)
949 int Size
= 0x7fffffff;
951 valueT sym_value
, sp_value
= S_GET_VALUE (sp
);
953 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
955 if (!S_IS_DEBUG (symbolP
) && S_GET_TYPE (symbolP
) == N_TEXT
)
957 if (*S_GET_NAME (symbolP
) == 'L')
959 sym_value
= S_GET_VALUE (symbolP
);
960 if (sym_value
> sp_value
&& sym_value
< Size
)
964 * Dummy labels like "gcc_compiled." should no longer reach here.
968 /* check if gcc_compiled. has size of zero */
969 if (sym_value
== sp_value
&&
971 (!strcmp (S_GET_NAME (sp
), "gcc_compiled.") ||
972 !strcmp (S_GET_NAME (sp
), "gcc2_compiled.")))
977 if (Size
== 0x7fffffff)
979 Size
-= sp_value
; /* and get the size of the routine */
982 /* DST type is "routine end". */
983 Local
[1] = DST_S_C_RTNEND
;
984 Local
[2] = 0; /* unused */
985 /* Size of routine. */
986 COPY_LONG (&Local
[3], Size
);
987 /* Store the record. */
988 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_TBT
);
991 /* Write a Traceback Block Begin record. */
994 VMS_TBT_Block_Begin (symbolP
, Psect
, Name
)
999 register char *cp
, *cp1
;
1004 /* Set the record size. */
1005 Size
= 1 + 1 + 4 + 1 + strlen (Name
);
1007 /* DST type is "begin block"; we simulate with a phony routine. */
1008 Local
[1] = DST_S_C_BLKBEG
;
1009 /* Uses CallS/CallG. */
1011 /* Store the data so far. */
1012 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_DBG
);
1013 /* Make sure we are still generating a debug record. */
1014 if (Object_Record_Offset
== 0)
1015 PUT_CHAR (OBJ_S_C_DBG
);
1016 /* Now get the symbol address. */
1017 PUT_CHAR (TIR_S_C_STA_WPL
);
1019 /* Get the text psect offset. */
1020 Offset
= S_GET_VALUE (symbolP
);
1022 /* Store the data reference. */
1023 PUT_CHAR (TIR_S_C_STO_PIDR
);
1024 /* Store the counted string as data. */
1027 Size
= strlen (cp1
) + 1;
1031 VMS_Store_Immediate_Data (Local
, Size
, OBJ_S_C_DBG
);
1034 /* Write a Traceback Block End record. */
1037 VMS_TBT_Block_End (Size
)
1042 Local
[0] = 6; /* record length */
1043 /* DST type is "block end"; simulate with a phony end routine. */
1044 Local
[1] = DST_S_C_BLKEND
;
1045 Local
[2] = 0; /* unused, must be zero */
1046 COPY_LONG (&Local
[3], Size
);
1047 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_DBG
);
1051 /* Write a Line number <-> Program Counter correlation record. */
1054 VMS_TBT_Line_PC_Correlation (Line_Number
, Offset
, Psect
, Do_Delta
)
1066 * If not delta, set our PC/Line number correlation.
1068 cp
= &Local
[1]; /* Put size in Local[0] later. */
1069 /* DST type is "Line Number/PC correlation". */
1070 *cp
++ = DST_S_C_LINE_NUM
;
1071 /* Set Line number. */
1072 if (Line_Number
- 1 <= 255)
1074 *cp
++ = DST_S_C_SET_LINUM_B
;
1075 *cp
++ = (char) (Line_Number
- 1);
1077 else if (Line_Number
- 1 <= 65535)
1079 *cp
++ = DST_S_C_SET_LINE_NUM
;
1080 COPY_SHORT (cp
, Line_Number
- 1), cp
+= 2;
1084 *cp
++ = DST_S_C_SET_LINUM_L
;
1085 COPY_LONG (cp
, Line_Number
- 1), cp
+= 4;
1088 *cp
++ = DST_S_C_SET_ABS_PC
;
1089 /* Store size now that we know it, then output the data. */
1090 Local
[0] = cp
- &Local
[1];
1091 /* Account for the space that TIR_S_C_STO_PIDR will use for the PC. */
1092 Local
[0] += 4; /* size includes length of another longword */
1093 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1094 /* Make sure we are still generating a OBJ_S_C_TBT record. */
1095 if (Object_Record_Offset
== 0)
1096 PUT_CHAR (OBJ_S_C_TBT
);
1097 vms_tir_stack_psect (Psect
, Offset
, 0);
1098 PUT_CHAR (TIR_S_C_STO_PIDR
);
1099 /* Do a PC offset of 0 to register the line number. */
1101 Local
[1] = DST_S_C_LINE_NUM
;
1102 Local
[2] = 0; /* Increment PC by 0 and register line # */
1103 VMS_Store_Immediate_Data (Local
, 3, OBJ_S_C_TBT
);
1110 * When delta is negative, terminate the line numbers.
1112 Local
[0] = 1 + 1 + 4;
1113 Local
[1] = DST_S_C_LINE_NUM
;
1114 Local
[2] = DST_S_C_TERM_L
;
1115 COPY_LONG (&Local
[3], Offset
);
1116 VMS_Store_Immediate_Data (Local
, 7, OBJ_S_C_TBT
);
1120 * Do a PC/Line delta.
1123 *cp
++ = DST_S_C_LINE_NUM
;
1124 if (Line_Number
> 1)
1126 /* We need to increment the line number. */
1127 if (Line_Number
- 1 <= 255)
1129 *cp
++ = DST_S_C_INCR_LINUM
;
1130 *cp
++ = Line_Number
- 1;
1132 else if (Line_Number
- 1 <= 65535)
1134 *cp
++ = DST_S_C_INCR_LINUM_W
;
1135 COPY_SHORT (cp
, Line_Number
- 1), cp
+= 2;
1139 *cp
++ = DST_S_C_INCR_LINUM_L
;
1140 COPY_LONG (cp
, Line_Number
- 1), cp
+= 4;
1148 /* Small offsets are encoded as negative numbers, rather than the
1149 usual non-negative type code followed by another data field. */
1150 *cp
++ = (char) -Offset
;
1152 else if (Offset
<= 65535)
1154 *cp
++ = DST_S_C_DELTA_PC_W
;
1155 COPY_SHORT (cp
, Offset
), cp
+= 2;
1159 *cp
++ = DST_S_C_DELTA_PC_L
;
1160 COPY_LONG (cp
, Offset
), cp
+= 4;
1162 /* Set size now that be know it, then output the data. */
1163 Local
[0] = cp
- &Local
[1];
1164 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1169 /* Describe a source file to the debugger. */
1172 VMS_TBT_Source_File (Filename
, ID_Number
)
1177 int len
, rfo
, ffb
, ebk
;
1180 #ifdef VMS /* Used for native assembly */
1182 struct FAB fab
; /* RMS file access block */
1183 struct NAM nam
; /* file name information */
1184 struct XABDAT xabdat
; /* date+time fields */
1185 struct XABFHC xabfhc
; /* file header characteristics */
1186 char resultant_string_buffer
[255 + 1];
1189 * Set up RMS structures:
1191 /* FAB -- file access block */
1192 memset ((char *) &fab
, 0, sizeof fab
);
1193 fab
.fab$b_bid
= FAB$C_BID
;
1194 fab
.fab$b_bln
= (unsigned char) sizeof fab
;
1195 fab
.fab$l_fna
= Filename
;
1196 fab
.fab$b_fns
= (unsigned char) strlen (Filename
);
1197 fab
.fab$l_nam
= (char *) &nam
;
1198 fab
.fab$l_xab
= (char *) &xabdat
;
1199 /* NAM -- file name block */
1200 memset ((char *) &nam
, 0, sizeof nam
);
1201 nam
.nam$b_bid
= NAM$C_BID
;
1202 nam
.nam$b_bln
= (unsigned char) sizeof nam
;
1203 nam
.nam$l_rsa
= resultant_string_buffer
;
1204 nam
.nam$b_rss
= (unsigned char) (sizeof resultant_string_buffer
- 1);
1205 /* XABs -- extended attributes blocks */
1206 memset ((char *) &xabdat
, 0, sizeof xabdat
);
1207 xabdat
.xab$b_cod
= XAB$C_DAT
;
1208 xabdat
.xab$b_bln
= (unsigned char) sizeof xabdat
;
1209 xabdat
.xab$l_nxt
= (char *) &xabfhc
;
1210 memset ((char *) &xabfhc
, 0, sizeof xabfhc
);
1211 xabfhc
.xab$b_cod
= XAB$C_FHC
;
1212 xabfhc
.xab$b_bln
= (unsigned char) sizeof xabfhc
;
1213 xabfhc
.xab$l_nxt
= 0;
1215 * Get the file information
1217 Status
= sys$
open (&fab
);
1220 as_tsktsk (_("Couldn't find source file \"%s\", status=%%X%x"),
1225 /* Now extract fields of interest. */
1226 memcpy (cdt
, (char *) &xabdat
.xab$q_cdt
, 8); /* creation date */
1227 ebk
= xabfhc
.xab$l_ebk
; /* end-of-file block */
1228 ffb
= xabfhc
.xab$w_ffb
; /* first free byte of last block */
1229 rfo
= xabfhc
.xab$b_rfo
; /* record format */
1230 len
= nam
.nam$b_rsl
; /* length of Filename */
1231 resultant_string_buffer
[len
] = '\0';
1232 Filename
= resultant_string_buffer
; /* full filename */
1233 #else /* Cross-assembly */
1234 /* [Perhaps we ought to use actual values derived from stat() here?] */
1235 memset (cdt
, 0, 8); /* null VMS quadword binary time */
1236 ebk
= ffb
= rfo
= 0;
1237 len
= strlen (Filename
);
1238 if (len
> 255) /* a single byte is used as count prefix */
1240 Filename
+= (len
- 255); /* tail end is more significant */
1245 cp
= &Local
[1]; /* fill in record length later */
1246 *cp
++ = DST_S_C_SOURCE
; /* DST type is "source file" */
1247 *cp
++ = DST_S_C_SRC_FORMFEED
; /* formfeeds count as source records */
1248 *cp
++ = DST_S_C_SRC_DECLFILE
; /* declare source file */
1249 know (cp
== &Local
[4]);
1250 *cp
++ = 0; /* fill in this length below */
1251 *cp
++ = 0; /* flags; must be zero */
1252 COPY_SHORT (cp
, ID_Number
), cp
+= 2; /* file ID number */
1253 memcpy (cp
, cdt
, 8), cp
+= 8; /* creation date+time */
1254 COPY_LONG (cp
, ebk
), cp
+= 4; /* end-of-file block */
1255 COPY_SHORT (cp
, ffb
), cp
+= 2; /* first free byte of last block */
1256 *cp
++ = (char) rfo
; /* RMS record format */
1260 *cp
++ = *Filename
++;
1261 /* Library module name (none). */
1263 /* Now that size is known, fill it in and write out the record. */
1264 Local
[4] = cp
- &Local
[5]; /* source file declaration size */
1265 Local
[0] = cp
- &Local
[1]; /* TBT record size */
1266 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1270 /* Traceback information is described in terms of lines from compiler
1271 listing files, not lines from source files. We need to set up the
1272 correlation between listing line numbers and source line numbers.
1273 Since gcc's .stabn directives refer to the source lines, we just
1274 need to describe a one-to-one correspondence. */
1277 VMS_TBT_Source_Lines (ID_Number
, Starting_Line_Number
, Number_Of_Lines
)
1279 int Starting_Line_Number
;
1280 int Number_Of_Lines
;
1284 char Local
[128]; /* room enough to describe 1310700 lines... */
1286 cp
= &Local
[1]; /* Put size in Local[0] later. */
1287 *cp
++ = DST_S_C_SOURCE
; /* DST type is "source file". */
1288 *cp
++ = DST_S_C_SRC_SETFILE
; /* Set Source File. */
1289 COPY_SHORT (cp
, ID_Number
), cp
+= 2; /* File ID Number. */
1290 /* Set record number and define lines. Since no longword form of
1291 SRC_DEFLINES is available, we need to be able to cope with any huge
1292 files a chunk at a time. It doesn't matter for tracebacks, since
1293 unspecified lines are mapped one-to-one and work out right, but it
1294 does matter within the debugger. Without this explicit mapping,
1295 it will complain about lines not existing in the module. */
1296 chunk_limit
= (sizeof Local
- 5) / 6;
1297 if (Number_Of_Lines
> 65535 * chunk_limit
) /* avoid buffer overflow */
1298 Number_Of_Lines
= 65535 * chunk_limit
;
1299 while (Number_Of_Lines
> 65535)
1301 *cp
++ = DST_S_C_SRC_SETREC_L
;
1302 COPY_LONG (cp
, Starting_Line_Number
), cp
+= 4;
1303 *cp
++ = DST_S_C_SRC_DEFLINES_W
;
1304 COPY_SHORT (cp
, 65535), cp
+= 2;
1305 Starting_Line_Number
+= 65535;
1306 Number_Of_Lines
-= 65535;
1308 /* Set record number and define lines, normal case. */
1309 if (Starting_Line_Number
<= 65535)
1311 *cp
++ = DST_S_C_SRC_SETREC_W
;
1312 COPY_SHORT (cp
, Starting_Line_Number
), cp
+= 2;
1316 *cp
++ = DST_S_C_SRC_SETREC_L
;
1317 COPY_LONG (cp
, Starting_Line_Number
), cp
+= 4;
1319 *cp
++ = DST_S_C_SRC_DEFLINES_W
;
1320 COPY_SHORT (cp
, Number_Of_Lines
), cp
+= 2;
1321 /* Set size now that be know it, then output the data. */
1322 Local
[0] = cp
- &Local
[1];
1323 VMS_Store_Immediate_Data (Local
, cp
- Local
, OBJ_S_C_TBT
);
1327 /****** Debugger Information support routines ******/
1329 /* This routine locates a file in the list of files. If an entry does
1330 not exist, one is created. For include files, a new entry is always
1331 created such that inline functions can be properly debugged. */
1333 static struct input_file
*
1337 struct input_file
*same_file
= 0;
1338 struct input_file
*fpnt
, *last
= 0;
1341 for (fpnt
= file_root
; fpnt
; fpnt
= fpnt
->next
)
1343 if (fpnt
->spnt
== sp
)
1347 sp_name
= S_GET_NAME (sp
);
1348 for (fpnt
= file_root
; fpnt
; fpnt
= fpnt
->next
)
1350 if (strcmp (sp_name
, fpnt
->name
) == 0)
1352 if (fpnt
->flag
== 1)
1358 fpnt
= (struct input_file
*) xmalloc (sizeof (struct input_file
));
1364 fpnt
->name
= sp_name
;
1365 fpnt
->min_line
= 0x7fffffff;
1369 fpnt
->file_number
= 0;
1371 fpnt
->same_file_fpnt
= same_file
;
1375 /* This routine converts a number string into an integer, and stops when
1376 it sees an invalid character. The return value is the address of the
1377 character just past the last character read. No error is generated. */
1380 cvt_integer (str
, rtn
)
1384 int ival
= 0, sgn
= 1;
1388 while (*str
>= '0' && *str
<= '9')
1389 ival
= 10 * ival
+ *str
++ - '0';
1396 * The following functions and definitions are used to generate object
1397 * records that will describe program variables to the VMS debugger.
1399 * This file contains many of the routines needed to output debugging info
1400 * into the object file that the VMS debugger needs to understand symbols.
1401 * These routines are called very late in the assembly process, and thus
1402 * we can be fairly lax about changing things, since the GSD and the TIR
1403 * sections have already been output.
1406 /* This routine fixes the names that are generated by C++, ".this" is a good
1407 example. The period does not work for the debugger, since it looks like
1408 the syntax for a structure element, and thus it gets mightily confused.
1410 We also use this to strip the PsectAttribute hack from the name before we
1411 write a debugger record. */
1419 /* Kill any leading "_". */
1423 /* Is there a Psect Attribute to skip?? */
1424 if (HAS_PSECT_ATTRIBUTES (pnt
))
1427 pnt
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
1430 if ((pnt
[0] == '$') && (pnt
[1] == '$'))
1439 /* Here we fix the .this -> $this conversion. */
1440 for (pnt1
= pnt
; *pnt1
!= 0; pnt1
++)
1447 /* When defining a structure, this routine is called to find the name of
1448 the actual structure. It is assumed that str points to the equal sign
1449 in the definition, and it moves backward until it finds the start of the
1450 name. If it finds a 0, then it knows that this structure def is in the
1451 outermost level, and thus symbol_name points to the symbol name. */
1454 get_struct_name (str
)
1459 while ((*pnt
!= ':') && (*pnt
!= '\0'))
1462 return (char *) symbol_name
;
1464 while ((*pnt
!= ';') && (*pnt
!= '='))
1468 while ((*pnt
< '0') || (*pnt
> '9'))
1470 while ((*pnt
>= '0') && (*pnt
<= '9'))
1475 /* Search symbol list for type number dbx_type.
1476 Return a pointer to struct. */
1478 static struct VMS_DBG_Symbol
*
1479 find_symbol (dbx_type
)
1482 struct VMS_DBG_Symbol
*spnt
;
1484 spnt
= VMS_Symbol_type_list
[SYMTYP_HASH (dbx_type
)];
1487 if (spnt
->dbx_type
== dbx_type
)
1491 if (!spnt
|| spnt
->advanced
!= ALIAS
)
1493 return find_symbol (spnt
->type2
);
1496 #if 0 /* obsolete */
1497 /* this routine puts info into either Local or Asuffix, depending on the sign
1498 * of size. The reason is that it is easier to build the variable descriptor
1499 * backwards, while the array descriptor is best built forwards. In the end
1500 * they get put together, if there is not a struct/union/enum along the way
1516 md_number_to_chars (&Local
[Lpnt
+ 1], value
, size1
);
1520 if (Apoint
+ size1
>= MAX_DEBUG_RECORD
)
1523 Apoint
= MAX_DEBUG_RECORD
- 1;
1526 md_number_to_chars (&Asuffix
[Apoint
], value
, size1
);
1536 if (Apoint
+ size
>= MAX_DEBUG_RECORD
)
1539 Apoint
= MAX_DEBUG_RECORD
- 1;
1543 Asuffix
[Apoint
++] = (char) value
;
1546 md_number_to_chars (&Asuffix
[Apoint
], value
, size
);
1562 Local
[Lpnt
--] = (char) value
;
1566 md_number_to_chars (&Local
[Lpnt
+ 1], value
, size
);
1570 /* This routine generates the array descriptor for a given array. */
1573 array_suffix (spnt2
)
1574 struct VMS_DBG_Symbol
*spnt2
;
1576 struct VMS_DBG_Symbol
*spnt
;
1577 struct VMS_DBG_Symbol
*spnt1
;
1583 while (spnt
->advanced
!= ARRAY
)
1585 spnt
= find_symbol (spnt
->type2
);
1591 while (spnt1
->advanced
== ARRAY
)
1594 total_size
*= (spnt1
->index_max
- spnt1
->index_min
+ 1);
1595 spnt1
= find_symbol (spnt1
->type2
);
1597 total_size
= total_size
* spnt1
->data_size
;
1598 fpush (spnt1
->data_size
, 2); /* element size */
1599 if (spnt1
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
1602 fpush (spnt1
->VMS_type
, 1); /* element type */
1603 fpush (DSC_K_CLASS_A
, 1); /* descriptor class */
1604 fpush (0, 4); /* base address */
1605 fpush (0, 1); /* scale factor -- not applicable */
1606 fpush (0, 1); /* digit count -- not applicable */
1607 fpush (0xc0, 1); /* flags: multiplier block & bounds present */
1608 fpush (rank
, 1); /* number of dimensions */
1609 fpush (total_size
, 4);
1610 fpush (0, 4); /* pointer to element [0][0]...[0] */
1612 while (spnt1
->advanced
== ARRAY
)
1614 fpush (spnt1
->index_max
- spnt1
->index_min
+ 1, 4);
1615 spnt1
= find_symbol (spnt1
->type2
);
1618 while (spnt1
->advanced
== ARRAY
)
1620 fpush (spnt1
->index_min
, 4);
1621 fpush (spnt1
->index_max
, 4);
1622 spnt1
= find_symbol (spnt1
->type2
);
1626 /* This routine generates the start of a variable descriptor based upon
1627 a struct/union/enum that has yet to be defined. We define this spot as
1628 a new location, and save four bytes for the address. When the struct is
1629 finally defined, then we can go back and plug in the correct address. */
1632 new_forward_ref (dbx_type
)
1635 struct forward_ref
*fpnt
;
1636 fpnt
= (struct forward_ref
*) xmalloc (sizeof (struct forward_ref
));
1637 fpnt
->next
= f_ref_root
;
1639 fpnt
->dbx_type
= dbx_type
;
1640 fpnt
->struc_numb
= ++structure_count
;
1641 fpnt
->resolved
= 'N';
1642 rpush (DST_K_TS_IND
, 1); /* indirect type specification */
1644 rpush (total_len
, 2);
1645 struct_number
= -fpnt
->struc_numb
;
1648 /* This routine generates the variable descriptor used to describe non-basic
1649 variables. It calls itself recursively until it gets to the bottom of it
1650 all, and then builds the descriptor backwards. It is easiest to do it
1651 this way since we must periodically write length bytes, and it is easiest
1652 if we know the value when it is time to write it. */
1655 gen1 (spnt
, array_suffix_len
)
1656 struct VMS_DBG_Symbol
*spnt
;
1657 int array_suffix_len
;
1659 struct VMS_DBG_Symbol
*spnt1
;
1662 switch (spnt
->advanced
)
1665 rpush (DBG_S_C_VOID
, 1);
1667 rpush (total_len
, 2);
1671 if (array_suffix_len
== 0)
1673 rpush (spnt
->VMS_type
, 1);
1674 rpush (DBG_S_C_BASIC
, 1);
1676 rpush (total_len
, 2);
1680 rpush (DST_K_VFLAGS_DSC
, 1);
1681 rpush (DST_K_TS_DSC
, 1); /* descriptor type specification */
1687 struct_number
= spnt
->struc_numb
;
1688 if (struct_number
< 0)
1690 new_forward_ref (spnt
->dbx_type
);
1693 rpush (DBG_S_C_STRUCT
, 1);
1695 rpush (total_len
, 2);
1698 spnt1
= find_symbol (spnt
->type2
);
1701 new_forward_ref (spnt
->type2
);
1703 i
= gen1 (spnt1
, 0);
1705 { /* (*void) is a special case, do not put pointer suffix */
1706 rpush (DBG_S_C_POINTER
, 1);
1708 rpush (total_len
, 2);
1713 while (spnt1
->advanced
== ARRAY
)
1715 spnt1
= find_symbol (spnt1
->type2
);
1718 as_tsktsk (_("debugger forward reference error, dbx type %d"),
1723 /* It is too late to generate forward references, so the user gets a message.
1724 * This should only happen on a compiler error */
1725 (void) gen1 (spnt1
, 1);
1727 array_suffix (spnt
);
1728 array_suffix_len
= Apoint
- i
;
1729 switch (spnt1
->advanced
)
1737 rpush (total_len
, 2);
1738 rpush (DST_K_VFLAGS_DSC
, 1);
1739 rpush (1, 1); /* flags: element value spec included */
1740 rpush (1, 1); /* one dimension */
1741 rpush (DBG_S_C_COMPLEX_ARRAY
, 1);
1743 total_len
+= array_suffix_len
+ 8;
1744 rpush (total_len
, 2);
1746 default: /* lint suppression */
1752 /* This generates a suffix for a variable. If it is not a defined type yet,
1753 then dbx_type contains the type we are expecting so we can generate a
1754 forward reference. This calls gen1 to build most of the descriptor, and
1755 then it puts the icing on at the end. It then dumps whatever is needed
1756 to get a complete descriptor (i.e. struct reference, array suffix). */
1759 generate_suffix (spnt
, dbx_type
)
1760 struct VMS_DBG_Symbol
*spnt
;
1763 static const char pvoid
[6] = {
1764 5, /* record.length == 5 */
1765 DST_K_TYPSPEC
, /* record.type == 1 (type specification) */
1766 0, /* name.length == 0, no name follows */
1767 1, 0, /* type.length == 1 {2 bytes, little endian} */
1768 DBG_S_C_VOID
/* type.type == 5 (pointer to unspecified) */
1773 Lpnt
= MAX_DEBUG_RECORD
- 1;
1778 new_forward_ref (dbx_type
);
1781 if (spnt
->VMS_type
!= DBG_S_C_ADVANCED_TYPE
)
1782 return; /* no suffix needed */
1785 rpush (0, 1); /* no name (len==0) */
1786 rpush (DST_K_TYPSPEC
, 1);
1788 rpush (total_len
, 1);
1789 /* If the variable descriptor overflows the record, output a descriptor
1790 for a pointer to void. */
1791 if ((total_len
>= MAX_DEBUG_RECORD
) || overflow
)
1793 as_warn (_("Variable descriptor %d too complicated. Defined as `void *'."),
1795 VMS_Store_Immediate_Data (pvoid
, 6, OBJ_S_C_DBG
);
1799 while (Lpnt
< MAX_DEBUG_RECORD
- 1)
1800 Local
[i
++] = Local
[++Lpnt
];
1802 /* we use this for reference to structure that has already been defined */
1803 if (struct_number
> 0)
1805 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1807 VMS_Store_Struct (struct_number
);
1809 /* We use this for a forward reference to a structure that has yet to
1810 be defined. We store four bytes of zero to make room for the actual
1811 address once it is known. */
1812 if (struct_number
< 0)
1814 struct_number
= -struct_number
;
1815 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1817 VMS_Def_Struct (struct_number
);
1818 COPY_LONG (&Local
[Lpnt
], 0L);
1820 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1825 Local
[Lpnt
++] = Asuffix
[i
++];
1827 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1831 /* "novel length" type doesn't work for simple atomic types */
1832 #define USE_BITSTRING_DESCRIPTOR(t) ((t)->advanced == BASIC)
1833 #undef SETUP_BASIC_TYPES
1835 /* This routine generates a type description for a bitfield. */
1838 bitfield_suffix (spnt
, width
)
1839 struct VMS_DBG_Symbol
*spnt
;
1842 Local
[Lpnt
++] = 13; /* rec.len==13 */
1843 Local
[Lpnt
++] = DST_K_TYPSPEC
; /* a type specification record */
1844 Local
[Lpnt
++] = 0; /* not named */
1845 COPY_SHORT (&Local
[Lpnt
], 9); /* typ.len==9 */
1847 Local
[Lpnt
++] = DST_K_TS_NOV_LENG
; /* This type is a "novel length"
1848 incarnation of some other type. */
1849 COPY_LONG (&Local
[Lpnt
], width
); /* size in bits == novel length */
1851 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1853 /* assert( spnt->struc_numb > 0 ); */
1854 VMS_Store_Struct (spnt
->struc_numb
); /* output 4 more bytes */
1857 /* Formally define a builtin type, so that it can serve as the target of
1858 an indirect reference. It makes bitfield_suffix() easier by avoiding
1859 the need to use a forward reference for the first occurrence of each
1860 type used in a bitfield. */
1863 setup_basic_type (spnt
)
1864 struct VMS_DBG_Symbol
*spnt
;
1866 #ifdef SETUP_BASIC_TYPES
1867 /* This would be very useful if "novel length" fields actually worked
1868 with basic types like they do with enumerated types. However,
1869 they do not, so this isn't worth doing just so that you can use
1870 EXAMINE/TYPE=(__long_long_int) instead of EXAMINE/QUAD. */
1872 #ifndef SETUP_SYNONYM_TYPES
1873 /* This determines whether compatible things like `int' and `long int'
1874 ought to have distinct type records rather than sharing one. */
1875 struct VMS_DBG_Symbol
*spnt2
;
1877 /* first check whether this type has already been seen by another name */
1878 for (spnt2
= VMS_Symbol_type_list
[SYMTYP_HASH (spnt
->VMS_type
)];
1880 spnt2
= spnt2
->next
)
1881 if (spnt2
!= spnt
&& spnt2
->VMS_type
== spnt
->VMS_type
)
1883 spnt
->struc_numb
= spnt2
->struc_numb
;
1888 /* `structure number' doesn't really mean `structure'; it means an index
1889 into a linker maintained set of saved locations which can be referenced
1891 spnt
->struc_numb
= ++structure_count
;
1892 VMS_Def_Struct (spnt
->struc_numb
); /* remember where this type lives */
1893 /* define the simple scalar type */
1894 Local
[Lpnt
++] = 6 + strlen (symbol_name
) + 2; /* rec.len */
1895 Local
[Lpnt
++] = DST_K_TYPSPEC
; /* rec.typ==type specification */
1896 Local
[Lpnt
++] = strlen (symbol_name
) + 2;
1897 Local
[Lpnt
++] = '_'; /* prefix name with "__" */
1898 Local
[Lpnt
++] = '_';
1899 for (p
= symbol_name
; *p
; p
++)
1900 Local
[Lpnt
++] = *p
== ' ' ? '_' : *p
;
1901 COPY_SHORT (&Local
[Lpnt
], 2); /* typ.len==2 */
1903 Local
[Lpnt
++] = DST_K_TS_ATOM
; /* typ.kind is simple type */
1904 Local
[Lpnt
++] = spnt
->VMS_type
; /* typ.type */
1905 VMS_Store_Immediate_Data (Local
, Lpnt
, OBJ_S_C_DBG
);
1907 #endif /* SETUP_BASIC_TYPES */
1911 /* This routine generates a symbol definition for a C symbol for the debugger.
1912 It takes a psect and offset for global symbols; if psect < 0, then this is
1913 a local variable and the offset is relative to FP. In this case it can
1914 be either a variable (Offset < 0) or a parameter (Offset > 0). */
1917 VMS_DBG_record (spnt
, Psect
, Offset
, Name
)
1918 struct VMS_DBG_Symbol
*spnt
;
1927 /* if there are bad characters in name, convert them */
1928 Name_pnt
= fix_name (Name
);
1930 len
= strlen (Name_pnt
);
1932 { /* this is a local variable, referenced to SP */
1933 Local
[i
++] = 7 + len
;
1934 Local
[i
++] = spnt
->VMS_type
;
1935 Local
[i
++] = (Offset
> 0) ? DBG_C_FUNCTION_PARAM
: DBG_C_LOCAL_SYM
;
1936 COPY_LONG (&Local
[i
], Offset
);
1941 Local
[i
++] = 7 + len
;
1942 Local
[i
++] = spnt
->VMS_type
;
1943 Local
[i
++] = DST_K_VALKIND_ADDR
;
1944 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
1946 VMS_Set_Data (Psect
, Offset
, OBJ_S_C_DBG
, 0);
1949 while (*Name_pnt
!= '\0')
1950 Local
[i
++] = *Name_pnt
++;
1951 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
1952 if (spnt
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
1953 generate_suffix (spnt
, 0);
1956 /* This routine parses the stabs entries in order to make the definition
1957 for the debugger of local symbols and function parameters. */
1960 VMS_local_stab_Parse (sp
)
1963 struct VMS_DBG_Symbol
*spnt
;
1970 str
= S_GET_NAME (sp
);
1971 pnt
= (char *) strchr (str
, ':');
1973 return; /* no colon present */
1974 pnt1
= pnt
++; /* save this for later, and skip colon */
1976 return; /* ignore static constants */
1978 /* there is one little catch that we must be aware of. Sometimes function
1979 * parameters are optimized into registers, and the compiler, in its infiite
1980 * wisdom outputs stabs records for *both*. In general we want to use the
1981 * register if it is present, so we must search the rest of the symbols for
1982 * this function to see if this parameter is assigned to a register.
1991 for (sp1
= symbol_next (sp
); sp1
; sp1
= symbol_next (sp1
))
1993 if (!S_IS_DEBUG (sp1
))
1995 if (S_GET_RAW_TYPE (sp1
) == N_FUN
)
1997 pnt2
= (char *) strchr (S_GET_NAME (sp1
), ':') + 1;
1998 if (*pnt2
== 'F' || *pnt2
== 'f')
2001 if (S_GET_RAW_TYPE (sp1
) != N_RSYM
)
2003 str1
= S_GET_NAME (sp1
); /* and get the name */
2005 while (*pnt2
!= ':')
2012 if (*str1
== ':' && *pnt2
== ':')
2013 return; /* They are the same! Let's skip this one. */
2015 pnt
++; /* skip p in case no register */
2019 pnt
= cvt_integer (pnt
, &dbx_type
);
2020 spnt
= find_symbol (dbx_type
);
2022 return; /*Dunno what this is*/
2024 VMS_DBG_record (spnt
, -1, S_GET_VALUE (sp
), str
);
2025 *pnt1
= ':'; /* and restore the string */
2029 /* This routine parses a stabs entry to find the information required
2030 to define a variable. It is used for global and static variables.
2031 Basically we need to know the address of the symbol. With older
2032 versions of the compiler, const symbols are treated differently, in
2033 that if they are global they are written into the text psect. The
2034 global symbol entry for such a const is actually written as a program
2035 entry point (Yuk!!), so if we cannot find a symbol in the list of
2036 psects, we must search the entry points as well. static consts are
2037 even harder, since they are never assigned a memory address. The
2038 compiler passes a stab to tell us the value, but I am not sure what
2042 VMS_stab_parse (sp
, expected_type
, type1
, type2
, Text_Psect
)
2044 int expected_type
; /* char */
2045 int type1
, type2
, Text_Psect
;
2051 struct VMS_DBG_Symbol
*spnt
;
2052 struct VMS_Symbol
*vsp
;
2056 str
= S_GET_NAME (sp
);
2057 pnt
= (char *) strchr (str
, ':');
2059 return; /* no colon present */
2060 pnt1
= pnt
; /* save this for later*/
2062 if (*pnt
== expected_type
)
2064 pnt
= cvt_integer (pnt
+ 1, &dbx_type
);
2065 spnt
= find_symbol (dbx_type
);
2067 return; /*Dunno what this is*/
2069 * Now we need to search the symbol table to find the psect and
2070 * offset for this variable.
2076 pnt
= S_GET_NAME (vsp
->Symbol
);
2077 if (pnt
&& *pnt
++ == '_'
2078 /* make sure name is the same and symbol type matches */
2079 && strcmp (pnt
, str
) == 0
2080 && (S_GET_RAW_TYPE (vsp
->Symbol
) == type1
2081 || S_GET_RAW_TYPE (vsp
->Symbol
) == type2
))
2087 VMS_DBG_record (spnt
, vsp
->Psect_Index
, vsp
->Psect_Offset
, str
);
2088 *pnt1
= ':'; /* and restore the string */
2091 /* The symbol was not in the symbol list, but it may be an
2092 "entry point" if it was a constant. */
2093 for (sp1
= symbol_rootP
; sp1
; sp1
= symbol_next (sp1
))
2096 * Dispatch on STAB type
2098 if (S_IS_DEBUG (sp1
) || (S_GET_TYPE (sp1
) != N_TEXT
))
2100 pnt
= S_GET_NAME (sp1
);
2103 if (strcmp (pnt
, str
) == 0)
2105 if (!gave_compiler_message
&& expected_type
== 'G')
2107 char *long_const_msg
= _("\
2108 ***Warning - the assembly code generated by the compiler has placed \n\
2109 global constant(s) in the text psect. These will not be available to \n\
2110 other modules, since this is not the correct way to handle this. You \n\
2111 have two options: 1) get a patched compiler that does not put global \n\
2112 constants in the text psect, or 2) remove the 'const' keyword from \n\
2113 definitions of global variables in your source module(s). Don't say \n\
2114 I didn't warn you! \n");
2116 as_tsktsk (long_const_msg
);
2117 gave_compiler_message
= 1;
2119 VMS_DBG_record (spnt
,
2124 /* fool assembler to not output this as a routine in the TBT */
2125 pnt1
= S_GET_NAME (sp1
);
2127 S_SET_NAME (sp1
, pnt1
);
2132 *pnt1
= ':'; /* and restore the string */
2136 /* Simpler interfaces into VMS_stab_parse(). */
2139 VMS_GSYM_Parse (sp
, Text_Psect
)
2142 { /* Global variables */
2143 VMS_stab_parse (sp
, 'G', (N_UNDF
| N_EXT
), (N_DATA
| N_EXT
), Text_Psect
);
2147 VMS_LCSYM_Parse (sp
, Text_Psect
)
2150 { /* Static symbols - uninitialized */
2151 VMS_stab_parse (sp
, 'S', N_BSS
, -1, Text_Psect
);
2155 VMS_STSYM_Parse (sp
, Text_Psect
)
2158 { /* Static symbols - initialized */
2159 VMS_stab_parse (sp
, 'S', N_DATA
, -1, Text_Psect
);
2162 /* For register symbols, we must figure out what range of addresses
2163 within the psect are valid. We will use the brackets in the stab
2164 directives to give us guidance as to the PC range that this variable
2165 is in scope. I am still not completely comfortable with this but
2166 as I learn more, I seem to get a better handle on what is going on.
2170 VMS_RSYM_Parse (sp
, Current_Routine
, Text_Psect
)
2171 symbolS
*sp
, *Current_Routine
;
2175 struct VMS_DBG_Symbol
*spnt
;
2183 int Min_Offset
= -1; /* min PC of validity */
2184 int Max_Offset
= 0; /* max PC of validity */
2186 for (symbolP
= sp
; symbolP
; symbolP
= symbol_next (symbolP
))
2189 * Dispatch on STAB type
2191 switch (S_GET_RAW_TYPE (symbolP
))
2195 Min_Offset
= S_GET_VALUE (symbolP
);
2199 Max_Offset
= S_GET_VALUE (symbolP
) - 1;
2202 if ((Min_Offset
!= -1) && (bcnt
== 0))
2204 if (S_GET_RAW_TYPE (symbolP
) == N_FUN
)
2206 pnt
= (char *) strchr (S_GET_NAME (symbolP
), ':') + 1;
2207 if (*pnt
== 'F' || *pnt
== 'f') break;
2211 /* Check to see that the addresses were defined. If not, then there
2212 were no brackets in the function, and we must try to search for
2213 the next function. Since functions can be in any order, we should
2214 search all of the symbol list to find the correct ending address. */
2215 if (Min_Offset
== -1)
2217 int Max_Source_Offset
;
2220 Min_Offset
= S_GET_VALUE (sp
);
2221 Max_Source_Offset
= Min_Offset
; /* just in case no N_SLINEs found */
2222 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2223 switch (S_GET_RAW_TYPE (symbolP
))
2225 case N_TEXT
| N_EXT
:
2226 This_Offset
= S_GET_VALUE (symbolP
);
2227 if (This_Offset
> Min_Offset
&& This_Offset
< Max_Offset
)
2228 Max_Offset
= This_Offset
;
2231 This_Offset
= S_GET_VALUE (symbolP
);
2232 if (This_Offset
> Max_Source_Offset
)
2233 Max_Source_Offset
= This_Offset
;
2236 /* If this is the last routine, then we use the PC of the last source
2237 line as a marker of the max PC for which this reg is valid. */
2238 if (Max_Offset
== 0x7fffffff)
2239 Max_Offset
= Max_Source_Offset
;
2243 str
= S_GET_NAME (sp
);
2244 if ((pnt
= (char *) strchr (str
, ':')) == 0)
2245 return; /* no colon present */
2246 pnt1
= pnt
; /* save this for later*/
2250 pnt
= cvt_integer (pnt
+ 1, &dbx_type
);
2251 spnt
= find_symbol (dbx_type
);
2253 return; /*Dunno what this is yet*/
2255 pnt
= fix_name (S_GET_NAME (sp
)); /* if there are bad characters in name, convert them */
2257 Local
[i
++] = 25 + len
;
2258 Local
[i
++] = spnt
->VMS_type
;
2259 Local
[i
++] = DST_K_VFLAGS_TVS
; /* trailing value specified */
2260 COPY_LONG (&Local
[i
], 1 + len
); /* relative offset, beyond name */
2262 Local
[i
++] = len
; /* name length (ascic prefix) */
2263 while (*pnt
!= '\0')
2264 Local
[i
++] = *pnt
++;
2265 Local
[i
++] = DST_K_VS_FOLLOWS
; /* value specification follows */
2266 COPY_SHORT (&Local
[i
], 15); /* length of rest of record */
2268 Local
[i
++] = DST_K_VS_ALLOC_SPLIT
; /* split lifetime */
2269 Local
[i
++] = 1; /* one binding follows */
2270 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2272 VMS_Set_Data (Text_Psect
, Min_Offset
, OBJ_S_C_DBG
, 1);
2273 VMS_Set_Data (Text_Psect
, Max_Offset
, OBJ_S_C_DBG
, 1);
2274 Local
[i
++] = DST_K_VALKIND_REG
; /* nested value spec */
2275 COPY_LONG (&Local
[i
], S_GET_VALUE (sp
));
2277 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2279 if (spnt
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
2280 generate_suffix (spnt
, 0);
2283 /* This function examines a structure definition, checking all of the elements
2284 to make sure that all of them are fully defined. The only thing that we
2285 kick out are arrays of undefined structs, since we do not know how big
2286 they are. All others we can handle with a normal forward reference. */
2289 forward_reference (pnt
)
2292 struct VMS_DBG_Symbol
*spnt
, *spnt1
;
2295 pnt
= cvt_integer (pnt
+ 1, &i
);
2297 return 0; /* no forward references */
2300 pnt
= (char *) strchr (pnt
, ':');
2301 pnt
= cvt_integer (pnt
+ 1, &i
);
2302 spnt
= find_symbol (i
);
2303 while (spnt
&& (spnt
->advanced
== POINTER
|| spnt
->advanced
== ARRAY
))
2305 spnt1
= find_symbol (spnt
->type2
);
2306 if (spnt
->advanced
== ARRAY
&& !spnt1
)
2310 pnt
= cvt_integer (pnt
+ 1, &i
);
2311 pnt
= cvt_integer (pnt
+ 1, &i
);
2312 } while (*++pnt
!= ';');
2313 return 0; /* no forward refences found */
2316 /* Used to check a single element of a structure on the final pass. */
2319 final_forward_reference (spnt
)
2320 struct VMS_DBG_Symbol
*spnt
;
2322 struct VMS_DBG_Symbol
*spnt1
;
2324 while (spnt
&& (spnt
->advanced
== POINTER
|| spnt
->advanced
== ARRAY
))
2326 spnt1
= find_symbol (spnt
->type2
);
2327 if (spnt
->advanced
== ARRAY
&& !spnt1
)
2331 return 0; /* no forward refences found */
2334 /* This routine parses the stabs directives to find any definitions of dbx
2335 type numbers. It makes a note of all of them, creating a structure
2336 element of VMS_DBG_Symbol that describes it. This also generates the
2337 info for the debugger that describes the struct/union/enum, so that
2338 further references to these data types will be by number
2340 We have to process pointers right away, since there can be references
2341 to them later in the same stabs directive. We cannot have forward
2342 references to pointers, (but we can have a forward reference to a
2343 pointer to a structure/enum/union) and this is why we process them
2344 immediately. After we process the pointer, then we search for defs
2345 that are nested even deeper.
2347 8/15/92: We have to process arrays right away too, because there can
2348 be multiple references to identical array types in one structure
2349 definition, and only the first one has the definition. */
2352 VMS_typedef_parse (str
)
2360 struct forward_ref
*fpnt
;
2361 int i1
, i2
, i3
, len
;
2362 struct VMS_DBG_Symbol
*spnt
;
2363 struct VMS_DBG_Symbol
*spnt1
;
2365 /* check for any nested def's */
2366 pnt
= (char *) strchr (str
+ 1, '=');
2367 if (pnt
&& str
[1] != '*' && (str
[1] != 'a' || str
[2] != 'r')
2368 && VMS_typedef_parse (pnt
) == 1)
2370 /* now find dbx_type of entry */
2373 { /* check for static constants */
2374 *str
= '\0'; /* for now we ignore them */
2377 while ((*pnt
<= '9') && (*pnt
>= '0'))
2379 pnt
++; /* and get back to the number */
2380 cvt_integer (pnt
, &i1
);
2381 spnt
= find_symbol (i1
);
2382 /* first see if this has been defined already, due to forward reference */
2385 i2
= SYMTYP_HASH (i1
);
2386 spnt
= (struct VMS_DBG_Symbol
*) xmalloc (sizeof (struct VMS_DBG_Symbol
));
2387 spnt
->next
= VMS_Symbol_type_list
[i2
];
2388 VMS_Symbol_type_list
[i2
] = spnt
;
2389 spnt
->dbx_type
= i1
; /* and save the type */
2390 spnt
->type2
= spnt
->VMS_type
= spnt
->data_size
= 0;
2391 spnt
->index_min
= spnt
->index_max
= spnt
->struc_numb
= 0;
2394 * For structs and unions, do a partial parse, otherwise we sometimes get
2395 * circular definitions that are impossible to resolve. We read enough
2396 * info so that any reference to this type has enough info to be resolved.
2398 pnt
= str
+ 1; /* point to character past equal sign */
2399 if (*pnt
>= '0' && *pnt
<= '9')
2401 if (type_check ("void"))
2402 { /* this is the void symbol */
2404 spnt
->advanced
= VOID
;
2407 if (type_check ("unknown type"))
2410 spnt
->advanced
= UNKNOWN
;
2413 pnt1
= cvt_integer (pnt
, &i1
);
2414 if (i1
!= spnt
->dbx_type
)
2416 spnt
->advanced
= ALIAS
;
2421 as_tsktsk (_("debugginer output: %d is an unknown untyped variable."),
2423 return 1; /* do not know what this is */
2426 pnt
= str
+ 1; /* point to character past equal sign */
2430 spnt
->advanced
= BASIC
;
2431 if (type_check ("int"))
2433 spnt
->VMS_type
= DBG_S_C_SLINT
;
2434 spnt
->data_size
= 4;
2436 else if (type_check ("long int"))
2438 spnt
->VMS_type
= DBG_S_C_SLINT
;
2439 spnt
->data_size
= 4;
2441 else if (type_check ("unsigned int"))
2443 spnt
->VMS_type
= DBG_S_C_ULINT
;
2444 spnt
->data_size
= 4;
2446 else if (type_check ("long unsigned int"))
2448 spnt
->VMS_type
= DBG_S_C_ULINT
;
2449 spnt
->data_size
= 4;
2451 else if (type_check ("short int"))
2453 spnt
->VMS_type
= DBG_S_C_SSINT
;
2454 spnt
->data_size
= 2;
2456 else if (type_check ("short unsigned int"))
2458 spnt
->VMS_type
= DBG_S_C_USINT
;
2459 spnt
->data_size
= 2;
2461 else if (type_check ("char"))
2463 spnt
->VMS_type
= DBG_S_C_SCHAR
;
2464 spnt
->data_size
= 1;
2466 else if (type_check ("signed char"))
2468 spnt
->VMS_type
= DBG_S_C_SCHAR
;
2469 spnt
->data_size
= 1;
2471 else if (type_check ("unsigned char"))
2473 spnt
->VMS_type
= DBG_S_C_UCHAR
;
2474 spnt
->data_size
= 1;
2476 else if (type_check ("float"))
2478 spnt
->VMS_type
= DBG_S_C_REAL4
;
2479 spnt
->data_size
= 4;
2481 else if (type_check ("double"))
2483 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_REAL8_G
: DBG_S_C_REAL8
;
2484 spnt
->data_size
= 8;
2486 else if (type_check ("long double"))
2488 /* same as double, at least for now */
2489 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_REAL8_G
: DBG_S_C_REAL8
;
2490 spnt
->data_size
= 8;
2492 else if (type_check ("long long int"))
2494 spnt
->VMS_type
= DBG_S_C_SQUAD
; /* signed quadword */
2495 spnt
->data_size
= 8;
2497 else if (type_check ("long long unsigned int"))
2499 spnt
->VMS_type
= DBG_S_C_UQUAD
; /* unsigned quadword */
2500 spnt
->data_size
= 8;
2502 else if (type_check ("complex float"))
2504 spnt
->VMS_type
= DBG_S_C_COMPLX4
;
2505 spnt
->data_size
= 2 * 4;
2507 else if (type_check ("complex double"))
2509 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_COMPLX8_G
: DBG_S_C_COMPLX8
;
2510 spnt
->data_size
= 2 * 8;
2512 else if (type_check ("complex long double"))
2514 /* same as complex double, at least for now */
2515 spnt
->VMS_type
= vax_g_doubles
? DBG_S_C_COMPLX8_G
: DBG_S_C_COMPLX8
;
2516 spnt
->data_size
= 2 * 8;
2521 * Shouldn't get here, but if we do, something
2522 * more substantial ought to be done...
2525 spnt
->data_size
= 0;
2527 if (spnt
->VMS_type
!= 0)
2528 setup_basic_type (spnt
);
2529 pnt1
= (char *) strchr (str
, ';') + 1;
2533 spnt
->advanced
= (*pnt
== 's') ? STRUCT
: UNION
;
2534 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2535 pnt1
= cvt_integer (pnt
+ 1, &spnt
->data_size
);
2536 if (!final_pass
&& forward_reference (pnt
))
2538 spnt
->struc_numb
= -1;
2541 spnt
->struc_numb
= ++structure_count
;
2543 pnt
= get_struct_name (str
);
2544 VMS_Def_Struct (spnt
->struc_numb
);
2546 for (fpnt
= f_ref_root
; fpnt
; fpnt
= fpnt
->next
)
2547 if (fpnt
->dbx_type
== spnt
->dbx_type
)
2549 fpnt
->resolved
= 'Y';
2550 VMS_Set_Struct (fpnt
->struc_numb
);
2551 VMS_Store_Struct (spnt
->struc_numb
);
2555 VMS_Set_Struct (spnt
->struc_numb
);
2557 Local
[i
++] = 11 + strlen (pnt
);
2558 Local
[i
++] = DBG_S_C_STRUCT_START
;
2559 Local
[i
++] = DST_K_VFLAGS_NOVAL
; /* structure definition only */
2560 COPY_LONG (&Local
[i
], 0L); /* hence value is unused */
2562 Local
[i
++] = strlen (pnt
);
2564 while (*pnt2
!= '\0')
2565 Local
[i
++] = *pnt2
++;
2566 i2
= spnt
->data_size
* 8; /* number of bits */
2567 COPY_LONG (&Local
[i
], i2
);
2569 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2571 if (pnt
!= symbol_name
)
2573 pnt
+= strlen (pnt
);
2575 } /* replace colon for later */
2576 while (*++pnt1
!= ';')
2578 pnt
= (char *) strchr (pnt1
, ':');
2581 pnt1
= cvt_integer (pnt
+ 1, &dtype
);
2582 pnt1
= cvt_integer (pnt1
+ 1, &i2
);
2583 pnt1
= cvt_integer (pnt1
+ 1, &i3
);
2584 spnt1
= find_symbol (dtype
);
2585 len
= strlen (pnt2
);
2586 if (spnt1
&& (spnt1
->advanced
== BASIC
|| spnt1
->advanced
== ENUM
)
2587 && ((i3
!= spnt1
->data_size
* 8) || (i2
% 8 != 0)))
2589 if (USE_BITSTRING_DESCRIPTOR (spnt1
))
2591 /* This uses a type descriptor, which doesn't work if
2592 the enclosing structure has been placed in a register.
2593 Also, enum bitfields degenerate to simple integers. */
2594 int unsigned_type
= (spnt1
->VMS_type
== DBG_S_C_ULINT
2595 || spnt1
->VMS_type
== DBG_S_C_USINT
2596 || spnt1
->VMS_type
== DBG_S_C_UCHAR
2597 || spnt1
->VMS_type
== DBG_S_C_UQUAD
2598 || spnt1
->advanced
== ENUM
); /* (approximate) */
2600 fpush (19 + len
, 1);
2601 fpush (unsigned_type
? DBG_S_C_UBITU
: DBG_S_C_SBITU
, 1);
2602 fpush (DST_K_VFLAGS_DSC
, 1); /* specified by descriptor */
2603 fpush (1 + len
, 4); /* relative offset to descriptor */
2604 fpush (len
, 1); /* length byte (ascic prefix) */
2605 while (*pnt2
!= '\0') /* name bytes */
2607 fpush (i3
, 2); /* dsc length == size of bitfield */
2608 /* dsc type == un?signed bitfield */
2609 fpush (unsigned_type
? DBG_S_C_UBITU
: DBG_S_C_SBITU
, 1);
2610 fpush (DSC_K_CLASS_UBS
, 1); /* dsc class == unaligned bitstring */
2611 fpush (0x00, 4); /* dsc pointer == zeroes */
2612 fpush (i2
, 4); /* start position */
2613 VMS_Store_Immediate_Data (Asuffix
, Apoint
, OBJ_S_C_DBG
);
2618 /* Use a "novel length" type specification, which works
2619 right for register structures and for enum bitfields
2620 but results in larger object modules. */
2621 Local
[i
++] = 7 + len
;
2622 Local
[i
++] = DBG_S_C_ADVANCED_TYPE
; /* type spec follows */
2623 Local
[i
++] = DBG_S_C_STRUCT_ITEM
; /* value is a bit offset */
2624 COPY_LONG (&Local
[i
], i2
); /* bit offset */
2626 Local
[i
++] = strlen (pnt2
);
2627 while (*pnt2
!= '\0')
2628 Local
[i
++] = *pnt2
++;
2629 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2631 bitfield_suffix (spnt1
, i3
);
2635 { /* not a bitfield */
2636 /* check if this is a forward reference */
2637 if (final_pass
&& final_forward_reference (spnt1
))
2639 as_tsktsk (_("debugger output: structure element `%s' has undefined type"),
2643 Local
[i
++] = 7 + len
;
2644 Local
[i
++] = spnt1
? spnt1
->VMS_type
: DBG_S_C_ADVANCED_TYPE
;
2645 Local
[i
++] = DBG_S_C_STRUCT_ITEM
;
2646 COPY_LONG (&Local
[i
], i2
); /* bit offset */
2648 Local
[i
++] = strlen (pnt2
);
2649 while (*pnt2
!= '\0')
2650 Local
[i
++] = *pnt2
++;
2651 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2654 generate_suffix (spnt1
, dtype
);
2655 else if (spnt1
->VMS_type
== DBG_S_C_ADVANCED_TYPE
)
2656 generate_suffix (spnt1
, 0);
2660 Local
[i
++] = 0x01; /* length byte */
2661 Local
[i
++] = DBG_S_C_STRUCT_END
;
2662 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2666 spnt
->advanced
= ENUM
;
2667 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2668 spnt
->struc_numb
= ++structure_count
;
2669 spnt
->data_size
= 4;
2670 VMS_Def_Struct (spnt
->struc_numb
);
2672 for (fpnt
= f_ref_root
; fpnt
; fpnt
= fpnt
->next
)
2673 if (fpnt
->dbx_type
== spnt
->dbx_type
)
2675 fpnt
->resolved
= 'Y';
2676 VMS_Set_Struct (fpnt
->struc_numb
);
2677 VMS_Store_Struct (spnt
->struc_numb
);
2681 VMS_Set_Struct (spnt
->struc_numb
);
2683 len
= strlen (symbol_name
);
2684 Local
[i
++] = 3 + len
;
2685 Local
[i
++] = DBG_S_C_ENUM_START
;
2686 Local
[i
++] = 4 * 8; /* enum values are 32 bits */
2689 while (*pnt2
!= '\0')
2690 Local
[i
++] = *pnt2
++;
2691 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2693 while (*++pnt
!= ';')
2695 pnt1
= (char *) strchr (pnt
, ':');
2697 pnt1
= cvt_integer (pnt1
, &i1
);
2699 Local
[i
++] = 7 + len
;
2700 Local
[i
++] = DBG_S_C_ENUM_ITEM
;
2701 Local
[i
++] = DST_K_VALKIND_LITERAL
;
2702 COPY_LONG (&Local
[i
], i1
);
2706 while (*pnt
!= '\0')
2707 Local
[i
++] = *pnt
++;
2708 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2710 pnt
= pnt1
; /* Skip final semicolon */
2712 Local
[i
++] = 0x01; /* len byte */
2713 Local
[i
++] = DBG_S_C_ENUM_END
;
2714 VMS_Store_Immediate_Data (Local
, i
, OBJ_S_C_DBG
);
2719 spnt
->advanced
= ARRAY
;
2720 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2721 pnt
= (char *) strchr (pnt
, ';');
2724 pnt1
= cvt_integer (pnt
+ 1, &spnt
->index_min
);
2725 pnt1
= cvt_integer (pnt1
+ 1, &spnt
->index_max
);
2726 pnt1
= cvt_integer (pnt1
+ 1, &spnt
->type2
);
2727 pnt
= (char *) strchr (str
+ 1, '=');
2728 if (pnt
&& VMS_typedef_parse (pnt
) == 1)
2732 spnt
->advanced
= FUNCTION
;
2733 spnt
->VMS_type
= DBG_S_C_FUNCTION_ADDR
;
2734 /* this masquerades as a basic type*/
2735 spnt
->data_size
= 4;
2736 pnt1
= cvt_integer (pnt
+ 1, &spnt
->type2
);
2739 spnt
->advanced
= POINTER
;
2740 spnt
->VMS_type
= DBG_S_C_ADVANCED_TYPE
;
2741 spnt
->data_size
= 4;
2742 pnt1
= cvt_integer (pnt
+ 1, &spnt
->type2
);
2743 pnt
= (char *) strchr (str
+ 1, '=');
2744 if (pnt
&& VMS_typedef_parse (pnt
) == 1)
2748 spnt
->advanced
= UNKNOWN
;
2750 as_tsktsk (_("debugger output: %d is an unknown type of variable."),
2752 return 1; /* unable to decipher */
2754 /* This removes the evidence of the definition so that the outer levels
2755 of parsing do not have to worry about it. */
2757 while (*pnt1
!= '\0')
2763 /* This is the root routine that parses the stabs entries for definitions.
2764 it calls VMS_typedef_parse, which can in turn call itself. We need to
2765 be careful, since sometimes there are forward references to other symbol
2766 types, and these cannot be resolved until we have completed the parse.
2768 Also check and see if we are using continuation stabs, if we are, then
2769 paste together the entire contents of the stab before we pass it to
2770 VMS_typedef_parse. */
2779 char *parse_buffer
= 0;
2781 int incomplete
, pass
, incom1
;
2782 struct forward_ref
*fpnt
;
2790 incom1
= incomplete
;
2792 for (sp
= symbol_rootP
; sp
; sp
= symbol_next (sp
))
2795 * Deal with STAB symbols
2797 if (S_IS_DEBUG (sp
))
2800 * Dispatch on STAB type
2802 switch (S_GET_RAW_TYPE (sp
))
2810 case N_FUN
: /*sometimes these contain typedefs*/
2811 str
= S_GET_NAME (sp
);
2813 pnt
= str
+ strlen (str
) - 1;
2814 if (*pnt
== '?') /* Continuation stab. */
2821 tlen
+= strlen (str
) - 1;
2822 spnext
= symbol_next (spnext
);
2823 str
= S_GET_NAME (spnext
);
2824 pnt
= str
+ strlen (str
) - 1;
2825 } while (*pnt
== '?');
2826 tlen
+= strlen (str
);
2827 parse_buffer
= (char *) xmalloc (tlen
+ 1);
2828 strcpy (parse_buffer
, S_GET_NAME (sp
));
2829 pnt2
= parse_buffer
+ strlen (parse_buffer
) - 1;
2833 spnext
= symbol_next (spnext
);
2834 str
= S_GET_NAME (spnext
);
2836 pnt2
+= strlen (str
) - 1;
2837 *str
= '\0'; /* Erase this string */
2838 /* S_SET_NAME (spnext, str); */
2839 if (*pnt2
!= '?') break;
2845 if ((pnt
= (char *) strchr (str
, ':')) != 0)
2849 if ((pnt2
= (char *) strchr (pnt1
, '=')) != 0)
2850 incomplete
+= VMS_typedef_parse (pnt2
);
2853 /* At this point the parse buffer should just
2854 contain name:nn. If it does not, then we
2855 are in real trouble. Anyway, this is always
2856 shorter than the original line. */
2857 pnt2
= S_GET_NAME (sp
);
2858 strcpy (pnt2
, parse_buffer
);
2859 /* S_SET_NAME (sp, pnt2); */
2860 free (parse_buffer
), parse_buffer
= 0;
2862 *pnt
= ':'; /* put back colon to restore dbx_type */
2870 * Make one last pass, if needed, and define whatever we can
2873 if (final_pass
== 0 && incomplete
== incom1
)
2876 incom1
++; /* Force one last pass through */
2878 } while (incomplete
!= 0 && incomplete
!= incom1
);
2879 /* repeat until all refs resolved if possible */
2880 /* if (pass > 1) printf (" Required %d passes\n", pass); */
2881 if (incomplete
!= 0)
2883 as_tsktsk (_("debugger output: Unable to resolve %d circular references."),
2890 if (fpnt
->resolved
!= 'Y')
2892 if (find_symbol (fpnt
->dbx_type
))
2894 as_tsktsk (_("debugger forward reference error, dbx type %d"),
2899 sprintf (&fixit
[1], "%d=s4;", fpnt
->dbx_type
);
2900 pnt2
= (char *) strchr (&fixit
[1], '=');
2901 VMS_typedef_parse (pnt2
);
2908 Define_Local_Symbols (s0P
, s2P
, Current_Routine
, Text_Psect
)
2910 symbolS
*Current_Routine
;
2913 symbolS
*s1P
; /* each symbol from s0P .. s2P (exclusive) */
2915 for (s1P
= symbol_next (s0P
); s1P
!= s2P
; s1P
= symbol_next (s1P
))
2918 break; /* and return */
2919 if (S_GET_RAW_TYPE (s1P
) == N_FUN
)
2921 char *pnt
= (char *) strchr (S_GET_NAME (s1P
), ':') + 1;
2922 if (*pnt
== 'F' || *pnt
== 'f') break;
2924 if (!S_IS_DEBUG (s1P
))
2927 * Dispatch on STAB type
2929 switch (S_GET_RAW_TYPE (s1P
))
2932 continue; /* not left or right brace */
2936 VMS_local_stab_Parse (s1P
);
2940 VMS_RSYM_Parse (s1P
, Current_Routine
, Text_Psect
);
2946 /* This function crawls the symbol chain searching for local symbols that
2947 need to be described to the debugger. When we enter a new scope with
2948 a "{", it creates a new "block", which helps the debugger keep track
2949 of which scope we are currently in. */
2952 Define_Routine (s0P
, Level
, Current_Routine
, Text_Psect
)
2955 symbolS
*Current_Routine
;
2962 for (s1P
= symbol_next (s0P
); s1P
!= 0; s1P
= symbol_next (s1P
))
2964 if (S_GET_RAW_TYPE (s1P
) == N_FUN
)
2966 char *pnt
= (char *) strchr (S_GET_NAME (s1P
), ':') + 1;
2967 if (*pnt
== 'F' || *pnt
== 'f') break;
2969 if (!S_IS_DEBUG (s1P
))
2972 * Dispatch on STAB type
2974 switch (S_GET_RAW_TYPE (s1P
))
2977 continue; /* not left or right brace */
2983 sprintf (str
, "$%d", rcount
++);
2984 VMS_TBT_Block_Begin (s1P
, Text_Psect
, str
);
2986 Offset
= S_GET_VALUE (s1P
); /* side-effect: fully resolve symbol */
2987 Define_Local_Symbols (s0P
, s1P
, Current_Routine
, Text_Psect
);
2988 s1P
= Define_Routine (s1P
, Level
+ 1, Current_Routine
, Text_Psect
);
2990 VMS_TBT_Block_End (S_GET_VALUE (s1P
) - Offset
);
2999 /* We end up here if there were no brackets in this function.
3000 Define everything. */
3001 Define_Local_Symbols (s0P
, (symbolS
*)0, Current_Routine
, Text_Psect
);
3007 #include <sys/types.h>
3009 static void get_VMS_time_on_unix
PARAMS ((char *));
3011 /* Manufacture a VMS-like time string on a Unix based system. */
3013 get_VMS_time_on_unix (Now
)
3020 pnt
= ctime (&timeb
);
3026 sprintf (Now
, "%2s-%3s-%s %s", pnt
+ 8, pnt
+ 4, pnt
+ 20, pnt
+ 11);
3028 #endif /* not VMS */
3030 /* Write the MHD (Module Header) records. */
3033 Write_VMS_MHD_Records ()
3035 register const char *cp
;
3039 struct { unsigned short len
, mbz
; char *ptr
; } Descriptor
;
3043 /* We are writing a module header record. */
3044 Set_VMS_Object_File_Record (OBJ_S_C_HDR
);
3046 * ***************************
3047 * *MAIN MODULE HEADER RECORD*
3048 * ***************************
3050 /* Store record type and header type. */
3051 PUT_CHAR (OBJ_S_C_HDR
);
3052 PUT_CHAR (MHD_S_C_MHD
);
3053 /* Structure level is 0. */
3054 PUT_CHAR (OBJ_S_C_STRLVL
);
3055 /* Maximum record size is size of the object record buffer. */
3056 PUT_SHORT (sizeof (Object_Record_Buffer
));
3059 * FIXME: module name and version should be user
3060 * specifiable via `.ident' and/or `#pragma ident'.
3063 /* Get module name (the FILENAME part of the object file). */
3068 if (*cp
== ']' || *cp
== '>' || *cp
== ':' || *cp
== '/')
3074 *cp1
++ = islower (*cp
) ? toupper (*cp
++) : *cp
++;
3078 /* Limit it to 31 characters and store in the object record. */
3079 while (--cp1
>= Module_Name
)
3082 if (strlen (Module_Name
) > 31)
3084 if (flag_hash_long_names
)
3085 as_tsktsk (_("Module name truncated: %s\n"), Module_Name
);
3086 Module_Name
[31] = '\0';
3088 PUT_COUNTED_STRING (Module_Name
);
3089 /* Module Version is "V1.0". */
3090 PUT_COUNTED_STRING ("V1.0");
3091 /* Creation time is "now" (17 chars of time string): "dd-MMM-yyyy hh:mm". */
3093 get_VMS_time_on_unix (Now
);
3095 Descriptor
.len
= sizeof Now
- 1;
3096 Descriptor
.mbz
= 0; /* type & class unspecified */
3097 Descriptor
.ptr
= Now
;
3098 (void) sys$
asctim ((unsigned short *)0, &Descriptor
, (long *)0, 0);
3100 for (i
= 0; i
< 17; i
++)
3102 /* Patch time is "never" (17 zeros). */
3103 for (i
= 0; i
< 17; i
++)
3105 /* Force this to be a separate output record. */
3106 Flush_VMS_Object_Record_Buffer ();
3109 * *************************
3110 * *LANGUAGE PROCESSOR NAME*
3111 * *************************
3113 /* Store record type and header type. */
3114 PUT_CHAR (OBJ_S_C_HDR
);
3115 PUT_CHAR (MHD_S_C_LNM
);
3117 * Store language processor name and version (not a counted string!).
3119 * This is normally supplied by the gcc driver for the command line
3120 * which invokes gas. If absent, we fall back to gas's version.
3122 cp
= compiler_version_string
;
3132 /* Force this to be a separate output record. */
3133 Flush_VMS_Object_Record_Buffer ();
3136 /* Write the EOM (End Of Module) record. */
3139 Write_VMS_EOM_Record (Psect
, Offset
)
3144 * We are writing an end-of-module record
3145 * (this assumes that the entry point will always be in a psect
3146 * represented by a single byte, which is the case for code in
3149 Set_VMS_Object_File_Record (OBJ_S_C_EOM
);
3150 PUT_CHAR (OBJ_S_C_EOM
); /* Record type. */
3151 PUT_CHAR (0); /* Error severity level (we ignore it). */
3153 * Store the entry point, if it exists
3160 /* Flush the record; this will be our final output. */
3161 Flush_VMS_Object_Record_Buffer ();
3165 /* this hash routine borrowed from GNU-EMACS, and strengthened slightly ERY*/
3171 register const unsigned char *p
= (unsigned char *) ptr
;
3172 register const unsigned char *end
= p
+ strlen (ptr
);
3173 register unsigned char c
;
3174 register int hash
= 0;
3179 hash
= ((hash
<< 3) + (hash
<< 15) + (hash
>> 28) + c
);
3185 * Generate a Case-Hacked VMS symbol name (limited to 31 chars)
3188 VMS_Case_Hack_Symbol (In
, Out
)
3189 register const char *In
;
3196 const char *old_name
;
3198 int destructor
= 0; /*hack to allow for case sens in a destructor*/
3200 int Case_Hack_Bits
= 0;
3202 static char Hex_Table
[16] =
3203 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
3206 * Kill any leading "_"
3208 if ((In
[0] == '_') && ((In
[1] > '9') || (In
[1] < '0')))
3211 new_name
= Out
; /* save this for later*/
3213 #if barfoo /* Dead code */
3214 if ((In
[0] == '_') && (In
[1] == '$') && (In
[2] == '_'))
3218 /* We may need to truncate the symbol, save the hash for later*/
3219 result
= (strlen (In
) > 23) ? hash_string (In
) : 0;
3221 * Is there a Psect Attribute to skip??
3223 if (HAS_PSECT_ATTRIBUTES (In
))
3228 In
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
3231 if ((In
[0] == '$') && (In
[1] == '$'))
3241 /* if (strlen (In) > 31 && flag_hash_long_names)
3242 as_tsktsk ("Symbol name truncated: %s\n", In); */
3244 * Do the case conversion
3246 i
= 23; /* Maximum of 23 chars */
3247 while (*In
&& (--i
>= 0))
3249 Case_Hack_Bits
<<= 1;
3252 if ((destructor
== 1) && (i
== 21))
3254 switch (vms_name_mapping
)
3257 if (isupper (*In
)) {
3259 Case_Hack_Bits
|= 1;
3261 *Out
++ = islower (*In
) ? toupper (*In
++) : *In
++;
3264 case 3: *Out
++ = *In
++;
3267 if (islower (*In
)) {
3270 *Out
++ = isupper (*In
) ? tolower (*In
++) : *In
++;
3276 * If we saw a dollar sign, we don't do case hacking
3278 if (flag_no_hash_mixed_case
|| Saw_Dollar
)
3282 * If we have more than 23 characters and everything is lowercase
3283 * we can insert the full 31 characters
3288 * We have more than 23 characters
3289 * If we must add the case hack, then we have truncated the str
3293 if (Case_Hack_Bits
== 0)
3296 * And so far they are all lower case:
3297 * Check up to 8 more characters
3298 * and ensure that they are lowercase
3300 for (i
= 0; (In
[i
] != 0) && (i
< 8); i
++)
3301 if (isupper (In
[i
]) && !Saw_Dollar
&& !flag_no_hash_mixed_case
)
3307 if ((i
== 8) || (In
[i
] == 0))
3310 * They are: Copy up to 31 characters
3311 * to the output string
3314 while ((--i
>= 0) && (*In
))
3315 switch (vms_name_mapping
){
3316 case 0: *Out
++ = islower (*In
) ? toupper (*In
++) : *In
++;
3318 case 3: *Out
++ = *In
++;
3320 case 2: *Out
++ = isupper (*In
) ? tolower (*In
++) : *In
++;
3327 * If there were any uppercase characters in the name we
3328 * take on the case hacking string
3331 /* Old behavior for regular GNU-C compiler */
3332 if (!flag_hash_long_names
)
3334 if ((Case_Hack_Bits
!= 0) || (truncate
== 1))
3339 for (i
= 0; i
< 6; i
++)
3341 *Out
++ = Hex_Table
[Case_Hack_Bits
& 0xf];
3342 Case_Hack_Bits
>>= 4;
3348 Out
= pnt
; /*Cut back to 23 characters maximum */
3350 for (i
= 0; i
< 7; i
++)
3352 init
= result
& 0x01f;
3353 *Out
++ = (init
< 10) ? ('0' + init
) : ('A' + init
- 10);
3354 result
= result
>> 5;
3362 if (truncate
== 1 && flag_hash_long_names
&& flag_show_after_trunc
)
3363 as_tsktsk (_("Symbol %s replaced by %s\n"), old_name
, new_name
);
3368 * Scan a symbol name for a psect attribute specification
3370 #define GLOBALSYMBOL_BIT 0x10000
3371 #define GLOBALVALUE_BIT 0x20000
3374 VMS_Modify_Psect_Attributes (Name
, Attribute_Pointer
)
3376 int *Attribute_Pointer
;
3379 register const char *cp
;
3387 {"PIC", GPS_S_M_PIC
},
3388 {"LIB", GPS_S_M_LIB
},
3389 {"OVR", GPS_S_M_OVR
},
3390 {"REL", GPS_S_M_REL
},
3391 {"GBL", GPS_S_M_GBL
},
3392 {"SHR", GPS_S_M_SHR
},
3393 {"EXE", GPS_S_M_EXE
},
3395 {"WRT", GPS_S_M_WRT
},
3396 {"VEC", GPS_S_M_VEC
},
3397 {"GLOBALSYMBOL", GLOBALSYMBOL_BIT
},
3398 {"GLOBALVALUE", GLOBALVALUE_BIT
},
3408 * Check for a PSECT attribute list
3410 if (!HAS_PSECT_ATTRIBUTES (Name
))
3411 return; /* If not, return */
3413 * Skip the attribute list indicator
3415 Name
+= PSECT_ATTRIBUTES_STRING_LENGTH
;
3417 * Process the attributes ("_" separated, "$" terminated)
3419 while (*Name
!= '$')
3422 * Assume not negating
3428 if ((Name
[0] == 'N') && (Name
[1] == 'O'))
3431 * We are negating (and skip the NO)
3437 * Find the token delimiter
3440 while (*cp
&& (*cp
!= '_') && (*cp
!= '$'))
3443 * Look for the token in the attribute list
3445 for (i
= 0; Attributes
[i
].Name
; i
++)
3448 * If the strings match, set/clear the attr.
3450 if (strncmp (Name
, Attributes
[i
].Name
, cp
- Name
) == 0)
3456 *Attribute_Pointer
&=
3457 ~Attributes
[i
].Value
;
3459 *Attribute_Pointer
|=
3460 Attributes
[i
].Value
;
3468 * Now skip the attribute
3477 #define GBLSYM_REF 0
3478 #define GBLSYM_DEF 1
3479 #define GBLSYM_VAL 2
3480 #define GBLSYM_LCL 4 /* not GBL after all... */
3481 #define GBLSYM_WEAK 8
3484 * Define a global symbol (or possibly a local one).
3487 VMS_Global_Symbol_Spec (Name
, Psect_Number
, Psect_Offset
, Flags
)
3496 * We are writing a GSD record
3498 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3500 * If the buffer is empty we must insert the GSD record type
3502 if (Object_Record_Offset
== 0)
3503 PUT_CHAR (OBJ_S_C_GSD
);
3505 * We are writing a Global (or local) symbol definition subrecord.
3507 PUT_CHAR ((Flags
& GBLSYM_LCL
) != 0 ? GSD_S_C_LSY
:
3508 ((unsigned) Psect_Number
<= 255) ? GSD_S_C_SYM
: GSD_S_C_SYMW
);
3510 * Data type is undefined
3514 * Switch on Definition/Reference
3516 if ((Flags
& GBLSYM_DEF
) == 0)
3521 PUT_SHORT (((Flags
& GBLSYM_VAL
) == 0) ? GSY_S_M_REL
: 0);
3522 if ((Flags
& GBLSYM_LCL
) != 0) /* local symbols have extra field */
3523 PUT_SHORT (Current_Environment
);
3531 *[ assert (LSY_S_M_DEF == GSY_S_M_DEF && LSY_S_M_REL == GSY_S_M_REL); ]
3533 sym_flags
= GSY_S_M_DEF
;
3534 if (Flags
& GBLSYM_WEAK
)
3535 sym_flags
|= GSY_S_M_WEAK
;
3536 if ((Flags
& GBLSYM_VAL
) == 0)
3537 sym_flags
|= GSY_S_M_REL
;
3538 PUT_SHORT (sym_flags
);
3539 if ((Flags
& GBLSYM_LCL
) != 0) /* local symbols have extra field */
3540 PUT_SHORT (Current_Environment
);
3544 if ((Flags
& GBLSYM_LCL
) == 0 && (unsigned) Psect_Number
<= 255)
3545 PUT_CHAR (Psect_Number
);
3547 PUT_SHORT (Psect_Number
);
3551 PUT_LONG (Psect_Offset
);
3554 * Finally, the global symbol name
3556 VMS_Case_Hack_Symbol (Name
, Local
);
3557 PUT_COUNTED_STRING (Local
);
3559 * Flush the buffer if it is more than 75% full
3561 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3562 Flush_VMS_Object_Record_Buffer ();
3566 * Define an environment to support local symbol references.
3567 * This is just to mollify the linker; we don't actually do
3568 * anything useful with it.
3571 VMS_Local_Environment_Setup (Env_Name
)
3572 const char *Env_Name
;
3574 /* We are writing a GSD record. */
3575 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3576 /* If the buffer is empty we must insert the GSD record type. */
3577 if (Object_Record_Offset
== 0)
3578 PUT_CHAR (OBJ_S_C_GSD
);
3579 /* We are writing an ENV subrecord. */
3580 PUT_CHAR (GSD_S_C_ENV
);
3582 ++Current_Environment
; /* index of environment being defined */
3584 /* ENV$W_FLAGS: we are defining the next environment. It's not nested. */
3585 PUT_SHORT (ENV_S_M_DEF
);
3586 /* ENV$W_ENVINDX: index is always 0 for non-nested definitions. */
3589 /* ENV$B_NAMLNG + ENV$T_NAME: environment name in ASCIC format. */
3590 if (!Env_Name
) Env_Name
= "";
3591 PUT_COUNTED_STRING ((char *)Env_Name
);
3593 /* Flush the buffer if it is more than 75% full. */
3594 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3595 Flush_VMS_Object_Record_Buffer ();
3603 VMS_Psect_Spec (Name
, Size
, Type
, vsp
)
3607 struct VMS_Symbol
*vsp
;
3610 int Psect_Attributes
;
3613 * Generate the appropriate PSECT flags given the PSECT type
3618 /* Text psects are PIC,noOVR,REL,noGBL,SHR,EXE,RD,noWRT. */
3619 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_SHR
|GPS_S_M_EXE
3623 /* Data psects are PIC,noOVR,REL,noGBL,noSHR,noEXE,RD,WRT. */
3624 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_RD
|GPS_S_M_WRT
);
3627 /* Common block psects are: PIC,OVR,REL,GBL,noSHR,noEXE,RD,WRT. */
3628 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_OVR
|GPS_S_M_REL
|GPS_S_M_GBL
3629 |GPS_S_M_RD
|GPS_S_M_WRT
);
3632 /* Const data psects are: PIC,OVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3633 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_OVR
|GPS_S_M_REL
|GPS_S_M_GBL
3637 /* Ctor psects are PIC,noOVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3638 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_GBL
|GPS_S_M_RD
);
3641 /* Dtor psects are PIC,noOVR,REL,GBL,noSHR,noEXE,RD,noWRT. */
3642 Psect_Attributes
= (GPS_S_M_PIC
|GPS_S_M_REL
|GPS_S_M_GBL
|GPS_S_M_RD
);
3646 error (_("Unknown VMS psect type (%ld)"), (long) Type
);
3650 * Modify the psect attributes according to any attribute string
3652 if (vsp
&& S_GET_TYPE (vsp
->Symbol
) == N_ABS
)
3653 Psect_Attributes
|= GLOBALVALUE_BIT
;
3654 else if (HAS_PSECT_ATTRIBUTES (Name
))
3655 VMS_Modify_Psect_Attributes (Name
, &Psect_Attributes
);
3657 * Check for globalref/def/val.
3659 if ((Psect_Attributes
& GLOBALVALUE_BIT
) != 0)
3662 * globalvalue symbols were generated before. This code
3663 * prevents unsightly psect buildup, and makes sure that
3664 * fixup references are emitted correctly.
3666 vsp
->Psect_Index
= -1; /* to catch errors */
3667 S_SET_TYPE (vsp
->Symbol
, N_UNDF
); /* make refs work */
3668 return 1; /* decrement psect counter */
3671 if ((Psect_Attributes
& GLOBALSYMBOL_BIT
) != 0)
3673 switch (S_GET_RAW_TYPE (vsp
->Symbol
))
3675 case N_UNDF
| N_EXT
:
3676 VMS_Global_Symbol_Spec (Name
, vsp
->Psect_Index
,
3677 vsp
->Psect_Offset
, GBLSYM_REF
);
3678 vsp
->Psect_Index
= -1;
3679 S_SET_TYPE (vsp
->Symbol
, N_UNDF
);
3680 return 1; /* return and indicate no psect */
3681 case N_DATA
| N_EXT
:
3682 VMS_Global_Symbol_Spec (Name
, vsp
->Psect_Index
,
3683 vsp
->Psect_Offset
, GBLSYM_DEF
);
3684 /* In this case we still generate the psect */
3687 as_fatal (_("Globalsymbol attribute for symbol %s was unexpected."),
3693 Psect_Attributes
&= 0xffff; /* clear out the globalref/def stuff */
3695 * We are writing a GSD record
3697 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3699 * If the buffer is empty we must insert the GSD record type
3701 if (Object_Record_Offset
== 0)
3702 PUT_CHAR (OBJ_S_C_GSD
);
3704 * We are writing a PSECT definition subrecord
3706 PUT_CHAR (GSD_S_C_PSC
);
3708 * Psects are always LONGWORD aligned
3712 * Specify the psect attributes
3714 PUT_SHORT (Psect_Attributes
);
3716 * Specify the allocation
3720 * Finally, the psect name
3722 VMS_Case_Hack_Symbol (Name
, Local
);
3723 PUT_COUNTED_STRING (Local
);
3725 * Flush the buffer if it is more than 75% full
3727 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3728 Flush_VMS_Object_Record_Buffer ();
3733 /* Given the pointer to a symbol we calculate how big the data at the
3734 symbol is. We do this by looking for the next symbol (local or global)
3735 which will indicate the start of another datum. */
3738 VMS_Initialized_Data_Size (s0P
, End_Of_Data
)
3739 register symbolS
*s0P
;
3740 unsigned End_Of_Data
;
3743 valueT s0P_val
= S_GET_VALUE (s0P
), s1P_val
,
3744 nearest_val
= (valueT
) End_Of_Data
;
3746 /* Find the nearest symbol what follows this one. */
3747 for (s1P
= symbol_rootP
; s1P
; s1P
= symbol_next (s1P
))
3749 /* The data type must match. */
3750 if (S_GET_TYPE (s1P
) != N_DATA
)
3752 s1P_val
= S_GET_VALUE (s1P
);
3753 if (s1P_val
> s0P_val
&& s1P_val
< nearest_val
)
3754 nearest_val
= s1P_val
;
3756 /* Calculate its size. */
3757 return (offsetT
) (nearest_val
- s0P_val
);
3760 /* Check symbol names for the Psect hack with a globalvalue, and then
3761 generate globalvalues for those that have it. */
3764 VMS_Emit_Globalvalues (text_siz
, data_siz
, Data_Segment
)
3769 register symbolS
*sp
;
3770 char *stripped_name
, *Name
;
3772 int Psect_Attributes
;
3777 * Scan the symbol table for globalvalues, and emit def/ref when
3778 * required. These will be caught again later and converted to
3781 for (sp
= symbol_rootP
; sp
; sp
= sp
->sy_next
)
3783 typ
= S_GET_RAW_TYPE (sp
);
3784 abstyp
= ((typ
& ~N_EXT
) == N_ABS
);
3786 * See if this is something we want to look at.
3789 typ
!= (N_DATA
| N_EXT
) &&
3790 typ
!= (N_UNDF
| N_EXT
))
3793 * See if this has globalvalue specification.
3795 Name
= S_GET_NAME (sp
);
3800 Psect_Attributes
= GLOBALVALUE_BIT
;
3802 else if (HAS_PSECT_ATTRIBUTES (Name
))
3804 stripped_name
= (char *) xmalloc (strlen (Name
) + 1);
3805 strcpy (stripped_name
, Name
);
3806 Psect_Attributes
= 0;
3807 VMS_Modify_Psect_Attributes (stripped_name
, &Psect_Attributes
);
3812 if ((Psect_Attributes
& GLOBALVALUE_BIT
) != 0)
3817 /* Local symbol references will want
3818 to have an environment defined. */
3819 if (Current_Environment
< 0)
3820 VMS_Local_Environment_Setup (".N_ABS");
3821 VMS_Global_Symbol_Spec (Name
, 0,
3823 GBLSYM_DEF
|GBLSYM_VAL
|GBLSYM_LCL
);
3826 VMS_Global_Symbol_Spec (Name
, 0,
3828 GBLSYM_DEF
|GBLSYM_VAL
);
3830 case N_UNDF
| N_EXT
:
3831 VMS_Global_Symbol_Spec (stripped_name
, 0, 0, GBLSYM_VAL
);
3833 case N_DATA
| N_EXT
:
3834 Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
3836 error (_("Invalid data type for globalvalue"));
3837 globalvalue
= md_chars_to_number (Data_Segment
+
3838 S_GET_VALUE (sp
) - text_siz
, Size
);
3839 /* Three times for good luck. The linker seems to get confused
3840 if there are fewer than three */
3841 VMS_Global_Symbol_Spec (stripped_name
, 0, 0, GBLSYM_VAL
);
3842 VMS_Global_Symbol_Spec (stripped_name
, 0, globalvalue
,
3843 GBLSYM_DEF
|GBLSYM_VAL
);
3844 VMS_Global_Symbol_Spec (stripped_name
, 0, globalvalue
,
3845 GBLSYM_DEF
|GBLSYM_VAL
);
3848 as_warn (_("Invalid globalvalue of %s"), stripped_name
);
3852 if (stripped_name
) free (stripped_name
); /* clean up */
3859 * Define a procedure entry pt/mask
3862 VMS_Procedure_Entry_Pt (Name
, Psect_Number
, Psect_Offset
, Entry_Mask
)
3871 * We are writing a GSD record
3873 Set_VMS_Object_File_Record (OBJ_S_C_GSD
);
3875 * If the buffer is empty we must insert the GSD record type
3877 if (Object_Record_Offset
== 0)
3878 PUT_CHAR (OBJ_S_C_GSD
);
3880 * We are writing a Procedure Entry Pt/Mask subrecord
3882 PUT_CHAR (((unsigned) Psect_Number
<= 255) ? GSD_S_C_EPM
: GSD_S_C_EPMW
);
3884 * Data type is undefined
3888 * Flags = "RELOCATABLE" and "DEFINED"
3890 PUT_SHORT (GSY_S_M_DEF
| GSY_S_M_REL
);
3894 if ((unsigned) Psect_Number
<= 255)
3895 PUT_CHAR (Psect_Number
);
3897 PUT_SHORT (Psect_Number
);
3901 PUT_LONG (Psect_Offset
);
3905 PUT_SHORT (Entry_Mask
);
3907 * Finally, the global symbol name
3909 VMS_Case_Hack_Symbol (Name
, Local
);
3910 PUT_COUNTED_STRING (Local
);
3912 * Flush the buffer if it is more than 75% full
3914 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3915 Flush_VMS_Object_Record_Buffer ();
3920 * Set the current location counter to a particular Psect and Offset
3923 VMS_Set_Psect (Psect_Index
, Offset
, Record_Type
)
3929 * We are writing a "Record_Type" record
3931 Set_VMS_Object_File_Record (Record_Type
);
3933 * If the buffer is empty we must insert the record type
3935 if (Object_Record_Offset
== 0)
3936 PUT_CHAR (Record_Type
);
3938 * Stack the Psect base + Offset
3940 vms_tir_stack_psect (Psect_Index
, Offset
, 0);
3942 * Set relocation base
3944 PUT_CHAR (TIR_S_C_CTL_SETRB
);
3946 * Flush the buffer if it is more than 75% full
3948 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
3949 Flush_VMS_Object_Record_Buffer ();
3954 * Store repeated immediate data in current Psect
3957 VMS_Store_Repeated_Data (Repeat_Count
, Pointer
, Size
, Record_Type
)
3959 register char *Pointer
;
3965 * Ignore zero bytes/words/longwords
3970 if (Pointer
[3] != 0 || Pointer
[2] != 0) break;
3973 if (Pointer
[1] != 0) break;
3976 if (Pointer
[0] != 0) break;
3983 * If the data is too big for a TIR_S_C_STO_RIVB sub-record
3984 * then we do it manually
3988 while (--Repeat_Count
>= 0)
3989 VMS_Store_Immediate_Data (Pointer
, Size
, Record_Type
);
3993 * We are writing a "Record_Type" record
3995 Set_VMS_Object_File_Record (Record_Type
);
3997 * If the buffer is empty we must insert record type
3999 if (Object_Record_Offset
== 0)
4000 PUT_CHAR (Record_Type
);
4002 * Stack the repeat count
4004 PUT_CHAR (TIR_S_C_STA_LW
);
4005 PUT_LONG (Repeat_Count
);
4007 * And now the command and its data
4009 PUT_CHAR (TIR_S_C_STO_RIVB
);
4012 PUT_CHAR (*Pointer
++);
4014 * Flush the buffer if it is more than 75% full
4016 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
4017 Flush_VMS_Object_Record_Buffer ();
4022 * Store a Position Independent Reference
4025 VMS_Store_PIC_Symbol_Reference (Symbol
, Offset
, PC_Relative
,
4026 Psect
, Psect_Offset
, Record_Type
)
4034 register struct VMS_Symbol
*vsp
= Symbol
->sy_obj
;
4039 * We are writing a "Record_Type" record
4041 Set_VMS_Object_File_Record (Record_Type
);
4043 * If the buffer is empty we must insert record type
4045 if (Object_Record_Offset
== 0)
4046 PUT_CHAR (Record_Type
);
4048 * Set to the appropriate offset in the Psect.
4049 * For a Code reference we need to fix the operand
4050 * specifier as well, so back up 1 byte;
4051 * for a Data reference we just store HERE.
4053 VMS_Set_Psect (Psect
,
4054 PC_Relative
? Psect_Offset
- 1 : Psect_Offset
,
4057 * Make sure we are still generating a "Record Type" record
4059 if (Object_Record_Offset
== 0)
4060 PUT_CHAR (Record_Type
);
4062 * Dispatch on symbol type (so we can stack its value)
4064 switch (S_GET_RAW_TYPE (Symbol
))
4073 #ifdef NOT_VAX_11_C_COMPATIBLE
4074 case N_UNDF
| N_EXT
:
4075 case N_DATA
| N_EXT
:
4076 #endif /* NOT_VAX_11_C_COMPATIBLE */
4078 case N_TEXT
| N_EXT
:
4080 * Get the symbol name (case hacked)
4082 VMS_Case_Hack_Symbol (S_GET_NAME (Symbol
), Local
);
4084 * Stack the global symbol value
4088 PUT_CHAR (TIR_S_C_STA_GBL
);
4092 /* Local symbols have an extra field. */
4093 PUT_CHAR (TIR_S_C_STA_LSY
);
4094 PUT_SHORT (Current_Environment
);
4096 PUT_COUNTED_STRING (Local
);
4100 * Stack the longword offset
4102 PUT_CHAR (TIR_S_C_STA_LW
);
4105 * Add the two, leaving the result on the stack
4107 PUT_CHAR (TIR_S_C_OPR_ADD
);
4111 * Uninitialized local data
4115 * Stack the Psect (+offset)
4117 vms_tir_stack_psect (vsp
->Psect_Index
,
4118 vsp
->Psect_Offset
+ Offset
,
4126 * Stack the Psect (+offset)
4128 vms_tir_stack_psect (vsp
->Psect_Index
,
4129 S_GET_VALUE (Symbol
) + Offset
,
4133 * Initialized local or global data
4136 #ifndef NOT_VAX_11_C_COMPATIBLE
4137 case N_UNDF
| N_EXT
:
4138 case N_DATA
| N_EXT
:
4139 #endif /* NOT_VAX_11_C_COMPATIBLE */
4141 * Stack the Psect (+offset)
4143 vms_tir_stack_psect (vsp
->Psect_Index
,
4144 vsp
->Psect_Offset
+ Offset
,
4149 * Store either a code or data reference
4151 PUT_CHAR (PC_Relative
? TIR_S_C_STO_PICR
: TIR_S_C_STO_PIDR
);
4153 * Flush the buffer if it is more than 75% full
4155 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
4156 Flush_VMS_Object_Record_Buffer ();
4161 * Check in the text area for an indirect pc-relative reference
4162 * and fix it up with addressing mode 0xff [PC indirect]
4164 * THIS SHOULD BE REPLACED BY THE USE OF TIR_S_C_STO_PIRR IN THE
4165 * PIC CODE GENERATING FIXUP ROUTINE.
4168 VMS_Fix_Indirect_Reference (Text_Psect
, Offset
, fragP
, text_frag_root
)
4171 register fragS
*fragP
;
4172 fragS
*text_frag_root
;
4175 * The addressing mode byte is 1 byte before the address
4179 * Is it in THIS frag??
4181 if ((Offset
< fragP
->fr_address
) ||
4182 (Offset
>= (fragP
->fr_address
+ fragP
->fr_fix
)))
4185 * We need to search for the fragment containing this
4188 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
4190 if ((Offset
>= fragP
->fr_address
) &&
4191 (Offset
< (fragP
->fr_address
+ fragP
->fr_fix
)))
4195 * If we couldn't find the frag, things are BAD!!
4198 error (_("Couldn't find fixup fragment when checking for indirect reference"));
4201 * Check for indirect PC relative addressing mode
4203 if (fragP
->fr_literal
[Offset
- fragP
->fr_address
] == (char) 0xff)
4205 static char Address_Mode
= (char) 0xff;
4208 * Yes: Store the indirect mode back into the image
4209 * to fix up the damage done by STO_PICR
4211 VMS_Set_Psect (Text_Psect
, Offset
, OBJ_S_C_TIR
);
4212 VMS_Store_Immediate_Data (&Address_Mode
, 1, OBJ_S_C_TIR
);
4218 * If the procedure "main()" exists we have to add the instruction
4219 * "jsb c$main_args" at the beginning to be compatible with VAX-11 "C".
4221 * FIXME: the macro name `HACK_DEC_C_STARTUP' should be renamed
4222 * to `HACK_VAXCRTL_STARTUP' because Digital's compiler
4223 * named "DEC C" uses run-time library "DECC$SHR", but this
4224 * startup code is for "VAXCRTL", the library for Digital's
4225 * older "VAX C". Also, this extra code isn't needed for
4226 * supporting gcc because it already generates the VAXCRTL
4227 * startup call when compiling main(). The reference to
4228 * `flag_hash_long_names' looks very suspicious too;
4229 * probably an old-style command line option was inadvertently
4230 * overloaded here, then blindly converted into the new one.
4233 vms_check_for_main ()
4235 register symbolS
*symbolP
;
4236 #ifdef HACK_DEC_C_STARTUP /* JF */
4237 register struct frchain
*frchainP
;
4238 register fragS
*fragP
;
4239 register fragS
**prev_fragPP
;
4240 register struct fix
*fixP
;
4241 register fragS
*New_Frag
;
4243 #endif /* HACK_DEC_C_STARTUP */
4245 symbolP
= (symbolS
*) symbol_find ("_main");
4246 if (symbolP
&& !S_IS_DEBUG (symbolP
) &&
4247 S_IS_EXTERNAL (symbolP
) && (S_GET_TYPE (symbolP
) == N_TEXT
))
4249 #ifdef HACK_DEC_C_STARTUP
4250 if (!flag_hash_long_names
)
4254 * Remember the entry point symbol
4256 Entry_Point_Symbol
= symbolP
;
4257 #ifdef HACK_DEC_C_STARTUP
4262 * Scan all the fragment chains for the one with "_main"
4263 * (Actually we know the fragment from the symbol, but we need
4264 * the previous fragment so we can change its pointer)
4266 frchainP
= frchain_root
;
4270 * Scan all the fragments in this chain, remembering
4271 * the "previous fragment"
4273 prev_fragPP
= &frchainP
->frch_root
;
4274 fragP
= frchainP
->frch_root
;
4275 while (fragP
&& (fragP
!= frchainP
->frch_last
))
4278 * Is this the fragment?
4280 if (fragP
== symbolP
->sy_frag
)
4283 * Yes: Modify the fragment by replacing
4284 * it with a new fragment.
4286 New_Frag
= (fragS
*)
4287 xmalloc (sizeof (*New_Frag
) +
4292 * The fragments are the same except
4293 * that the "fixed" area is larger
4296 New_Frag
->fr_fix
+= 6;
4298 * Copy the literal data opening a hole
4299 * 2 bytes after "_main" (i.e. just after
4300 * the entry mask). Into which we place
4301 * the JSB instruction.
4303 New_Frag
->fr_literal
[0] = fragP
->fr_literal
[0];
4304 New_Frag
->fr_literal
[1] = fragP
->fr_literal
[1];
4305 New_Frag
->fr_literal
[2] = 0x16; /* Jsb */
4306 New_Frag
->fr_literal
[3] = 0xef;
4307 New_Frag
->fr_literal
[4] = 0;
4308 New_Frag
->fr_literal
[5] = 0;
4309 New_Frag
->fr_literal
[6] = 0;
4310 New_Frag
->fr_literal
[7] = 0;
4311 for (i
= 2; i
< fragP
->fr_fix
+ fragP
->fr_var
; i
++)
4312 New_Frag
->fr_literal
[i
+ 6] =
4313 fragP
->fr_literal
[i
];
4315 * Now replace the old fragment with the
4316 * newly generated one.
4318 *prev_fragPP
= New_Frag
;
4320 * Remember the entry point symbol
4322 Entry_Point_Symbol
= symbolP
;
4324 * Scan the text area fixup structures
4325 * as offsets in the fragment may have
4328 for (fixP
= text_fix_root
; fixP
; fixP
= fixP
->fx_next
)
4331 * Look for references to this
4334 if (fixP
->fx_frag
== fragP
)
4337 * Change the fragment
4340 fixP
->fx_frag
= New_Frag
;
4342 * If the offset is after
4343 * the entry mask we need
4344 * to account for the JSB
4345 * instruction we just
4348 if (fixP
->fx_where
>= 2)
4349 fixP
->fx_where
+= 6;
4353 * Scan the symbols as offsets in the
4354 * fragment may have changed
4356 for (symbolP
= symbol_rootP
;
4358 symbolP
= symbol_next (symbolP
))
4361 * Look for references to this
4364 if (symbolP
->sy_frag
== fragP
)
4367 * Change the fragment
4370 symbolP
->sy_frag
= New_Frag
;
4372 * If the offset is after
4373 * the entry mask we need
4374 * to account for the JSB
4375 * instruction we just
4378 if (S_GET_VALUE (symbolP
) >= 2)
4379 S_SET_VALUE (symbolP
,
4380 S_GET_VALUE (symbolP
) + 6);
4384 * Make a symbol reference to
4385 * "_c$main_args" so we can get
4386 * its address inserted into the
4389 symbolP
= (symbolS
*) xmalloc (sizeof (*symbolP
));
4390 S_SET_NAME (symbolP
, "_C$MAIN_ARGS");
4391 S_SET_TYPE (symbolP
, N_UNDF
);
4392 S_SET_OTHER (symbolP
, 0);
4393 S_SET_DESC (symbolP
, 0);
4394 S_SET_VALUE (symbolP
, 0);
4395 symbolP
->sy_name_offset
= 0;
4396 symbolP
->sy_number
= 0;
4397 symbolP
->sy_obj
= 0;
4398 symbolP
->sy_frag
= New_Frag
;
4399 symbolP
->sy_resolved
= 0;
4400 symbolP
->sy_resolving
= 0;
4401 /* this actually inserts at the beginning of the list */
4402 symbol_append (symbol_rootP
, symbolP
,
4403 &symbol_rootP
, &symbol_lastP
);
4405 symbol_rootP
= symbolP
;
4407 * Generate a text fixup structure
4408 * to get "_c$main_args" stored into the
4411 fixP
= (struct fix
*) xmalloc (sizeof (*fixP
));
4412 fixP
->fx_frag
= New_Frag
;
4414 fixP
->fx_addsy
= symbolP
;
4416 fixP
->fx_offset
= 0;
4419 fixP
->fx_next
= text_fix_root
;
4420 text_fix_root
= fixP
;
4422 * Now make sure we exit from the loop
4428 * Try the next fragment
4430 prev_fragPP
= &fragP
->fr_next
;
4431 fragP
= fragP
->fr_next
;
4434 * Try the next fragment chain
4437 frchainP
= frchainP
->frch_next
;
4440 #endif /* HACK_DEC_C_STARTUP */
4446 * Beginning of vms_write_object_file().
4450 struct vms_obj_state
{
4452 /* Next program section index to use. */
4455 /* Psect index for code. Always ends up #0. */
4458 /* Psect index for initialized static variables. */
4461 /* Psect index for uninitialized static variables. */
4464 /* Psect index for static constructors. */
4467 /* Psect index for static destructors. */
4470 /* Number of bytes used for local symbol data. */
4471 int local_initd_data_size
;
4473 /* Dynamic buffer for initialized data. */
4478 #define Psect_Number vms_obj_state.psect_number
4479 #define Text_Psect vms_obj_state.text_psect
4480 #define Data_Psect vms_obj_state.data_psect
4481 #define Bss_Psect vms_obj_state.bss_psect
4482 #define Ctors_Psect vms_obj_state.ctors_psect
4483 #define Dtors_Psect vms_obj_state.dtors_psect
4484 #define Local_Initd_Data_Size vms_obj_state.local_initd_data_size
4485 #define Data_Segment vms_obj_state.data_segment
4487 #define IS_GXX_VTABLE(symP) (strncmp (S_GET_NAME (symP), "__vt.", 5) == 0)
4488 #define IS_GXX_XTOR(symP) (strncmp (S_GET_NAME (symP), "__GLOBAL_.", 10) == 0)
4492 /* Perform text segment fixups. */
4495 vms_fixup_text_section (text_siz
, text_frag_root
, data_frag_root
)
4497 struct frag
*text_frag_root
;
4498 struct frag
*data_frag_root
;
4500 register fragS
*fragP
;
4501 register struct fix
*fixP
;
4504 /* Scan the text fragments. */
4505 for (fragP
= text_frag_root
; fragP
; fragP
= fragP
->fr_next
)
4507 /* Stop if we get to the data fragments. */
4508 if (fragP
== data_frag_root
)
4510 /* Ignore fragments with no data. */
4511 if ((fragP
->fr_fix
== 0) && (fragP
->fr_var
== 0))
4513 /* Go the the appropriate offset in the Text Psect. */
4514 VMS_Set_Psect (Text_Psect
, fragP
->fr_address
, OBJ_S_C_TIR
);
4515 /* Store the "fixed" part. */
4517 VMS_Store_Immediate_Data (fragP
->fr_literal
,
4520 /* Store the "variable" part. */
4521 if (fragP
->fr_var
&& fragP
->fr_offset
)
4522 VMS_Store_Repeated_Data (fragP
->fr_offset
,
4523 fragP
->fr_literal
+ fragP
->fr_fix
,
4526 } /* text frag loop */
4529 * Now we go through the text segment fixups and generate
4530 * TIR records to fix up addresses within the Text Psect.
4532 for (fixP
= text_fix_root
; fixP
; fixP
= fixP
->fx_next
)
4534 /* We DO handle the case of "Symbol - Symbol" as
4535 long as it is in the same segment. */
4536 if (fixP
->fx_subsy
&& fixP
->fx_addsy
)
4538 /* They need to be in the same segment. */
4539 if (S_GET_RAW_TYPE (fixP
->fx_subsy
) !=
4540 S_GET_RAW_TYPE (fixP
->fx_addsy
))
4541 error (_("Fixup data addsy and subsy don't have the same type"));
4542 /* And they need to be in one that we can check the psect on. */
4543 if ((S_GET_TYPE (fixP
->fx_addsy
) != N_DATA
) &&
4544 (S_GET_TYPE (fixP
->fx_addsy
) != N_TEXT
))
4545 error (_("Fixup data addsy and subsy don't have an appropriate type"));
4546 /* This had better not be PC relative! */
4548 error (_("Fixup data is erroneously \"pcrel\""));
4549 /* Subtract their values to get the difference. */
4550 dif
= S_GET_VALUE (fixP
->fx_addsy
) - S_GET_VALUE (fixP
->fx_subsy
);
4551 md_number_to_chars (Local
, (valueT
)dif
, fixP
->fx_size
);
4552 /* Now generate the fixup object records;
4553 set the psect and store the data. */
4554 VMS_Set_Psect (Text_Psect
,
4555 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4557 VMS_Store_Immediate_Data (Local
,
4560 continue; /* done with this fixup */
4561 } /* if fx_subsy && fx_addsy */
4562 /* Size will HAVE to be "long". */
4563 if (fixP
->fx_size
!= 4)
4564 error (_("Fixup datum is not a longword"));
4565 /* Symbol must be "added" (if it is ever
4566 subtracted we can fix this assumption). */
4567 if (fixP
->fx_addsy
== 0)
4568 error (_("Fixup datum is not \"fixP->fx_addsy\""));
4569 /* Store the symbol value in a PIC fashion. */
4570 VMS_Store_PIC_Symbol_Reference (fixP
->fx_addsy
,
4574 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4577 * Check for indirect address reference, which has to be fixed up
4578 * (as the linker will screw it up with TIR_S_C_STO_PICR)...
4581 VMS_Fix_Indirect_Reference (Text_Psect
,
4582 fixP
->fx_where
+ fixP
->fx_frag
->fr_address
,
4585 } /* text fix loop */
4589 /* Create a buffer holding the data segment. */
4592 synthesize_data_segment (data_siz
, text_siz
, data_frag_root
)
4593 unsigned data_siz
, text_siz
;
4594 struct frag
*data_frag_root
;
4596 register fragS
*fragP
;
4598 long fill_size
, count
, i
;
4600 /* Allocate the data segment. */
4601 Data_Segment
= (char *) xmalloc (data_siz
);
4602 /* Run through the data fragments, filling in the segment. */
4603 for (fragP
= data_frag_root
; fragP
; fragP
= fragP
->fr_next
)
4605 i
= fragP
->fr_address
- text_siz
;
4607 memcpy (Data_Segment
+ i
, fragP
->fr_literal
, fragP
->fr_fix
);
4610 if ((fill_size
= fragP
->fr_var
) != 0)
4612 fill_literal
= fragP
->fr_literal
+ fragP
->fr_fix
;
4613 for (count
= fragP
->fr_offset
; count
; count
--)
4615 memcpy (Data_Segment
+ i
, fill_literal
, fill_size
);
4619 } /* data frag loop */
4624 /* Perform data segment fixups. */
4627 vms_fixup_data_section (data_siz
, text_siz
)
4628 unsigned data_siz
, text_siz
;
4630 register struct VMS_Symbol
*vsp
;
4631 register struct fix
*fixP
;
4632 register symbolS
*sp
;
4633 addressT fr_address
;
4637 /* Run through all the data symbols and store the data. */
4638 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
4640 /* Ignore anything other than data symbols. */
4641 if (S_GET_TYPE (vsp
->Symbol
) != N_DATA
)
4643 /* Set the Psect + Offset. */
4644 VMS_Set_Psect (vsp
->Psect_Index
,
4647 /* Store the data. */
4648 val
= S_GET_VALUE (vsp
->Symbol
);
4649 VMS_Store_Immediate_Data (Data_Segment
+ val
- text_siz
,
4652 } /* N_DATA symbol loop */
4655 * Now we go through the data segment fixups and generate
4656 * TIR records to fix up addresses within the Data Psects.
4658 for (fixP
= data_fix_root
; fixP
; fixP
= fixP
->fx_next
)
4660 /* Find the symbol for the containing datum. */
4661 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
4663 /* Only bother with Data symbols. */
4665 if (S_GET_TYPE (sp
) != N_DATA
)
4667 /* Ignore symbol if After fixup. */
4668 val
= S_GET_VALUE (sp
);
4669 fr_address
= fixP
->fx_frag
->fr_address
;
4670 if (val
> fixP
->fx_where
+ fr_address
)
4672 /* See if the datum is here. */
4673 if (val
+ vsp
->Size
<= fixP
->fx_where
+ fr_address
)
4675 /* We DO handle the case of "Symbol - Symbol" as
4676 long as it is in the same segment. */
4677 if (fixP
->fx_subsy
&& fixP
->fx_addsy
)
4679 /* They need to be in the same segment. */
4680 if (S_GET_RAW_TYPE (fixP
->fx_subsy
) !=
4681 S_GET_RAW_TYPE (fixP
->fx_addsy
))
4682 error (_("Fixup data addsy and subsy don't have the same type"));
4683 /* And they need to be in one that we can check the psect on. */
4684 if ((S_GET_TYPE (fixP
->fx_addsy
) != N_DATA
) &&
4685 (S_GET_TYPE (fixP
->fx_addsy
) != N_TEXT
))
4686 error (_("Fixup data addsy and subsy don't have an appropriate type"));
4687 /* This had better not be PC relative! */
4689 error (_("Fixup data is erroneously \"pcrel\""));
4690 /* Subtract their values to get the difference. */
4691 dif
= S_GET_VALUE (fixP
->fx_addsy
) - S_GET_VALUE (fixP
->fx_subsy
);
4692 md_number_to_chars (Local
, (valueT
)dif
, fixP
->fx_size
);
4694 * Now generate the fixup object records;
4695 * set the psect and store the data.
4697 VMS_Set_Psect (vsp
->Psect_Index
,
4698 fr_address
+ fixP
->fx_where
4699 - val
+ vsp
->Psect_Offset
,
4701 VMS_Store_Immediate_Data (Local
,
4704 break; /* done with this fixup */
4706 /* Size will HAVE to be "long". */
4707 if (fixP
->fx_size
!= 4)
4708 error (_("Fixup datum is not a longword"));
4709 /* Symbol must be "added" (if it is ever
4710 subtracted we can fix this assumption). */
4711 if (fixP
->fx_addsy
== 0)
4712 error (_("Fixup datum is not \"fixP->fx_addsy\""));
4713 /* Store the symbol value in a PIC fashion. */
4714 VMS_Store_PIC_Symbol_Reference (fixP
->fx_addsy
,
4718 fr_address
+ fixP
->fx_where
4719 - val
+ vsp
->Psect_Offset
,
4721 /* Done with this fixup. */
4723 } /* vms_symbol loop */
4725 } /* data fix loop */
4728 /* Perform ctors/dtors segment fixups. */
4731 vms_fixup_xtors_section (symbols
, sect_no
)
4732 struct VMS_Symbol
*symbols
;
4735 register struct VMS_Symbol
*vsp
;
4737 /* Run through all the symbols and store the data. */
4738 for (vsp
= symbols
; vsp
; vsp
= vsp
->Next
)
4740 register symbolS
*sp
;
4742 /* Set relocation base. */
4743 VMS_Set_Psect (vsp
->Psect_Index
, vsp
->Psect_Offset
, OBJ_S_C_TIR
);
4746 /* Stack the Psect base with its offset. */
4747 VMS_Set_Data (Text_Psect
, S_GET_VALUE (sp
), OBJ_S_C_TIR
, 0);
4749 /* Flush the buffer if it is more than 75% full. */
4750 if (Object_Record_Offset
> (sizeof (Object_Record_Buffer
) * 3 / 4))
4751 Flush_VMS_Object_Record_Buffer ();
4757 /* Define symbols for the linker. */
4760 global_symbol_directory (text_siz
, data_siz
)
4761 unsigned text_siz
, data_siz
;
4763 register fragS
*fragP
;
4764 register symbolS
*sp
;
4765 register struct VMS_Symbol
*vsp
;
4766 int Globalref
, define_as_global_symbol
;
4769 /* The g++ compiler does not write out external references to
4770 vtables correctly. Check for this and holler if we see it
4771 happening. If that compiler bug is ever fixed we can remove
4774 (Jun'95: gcc 2.7.0's cc1plus still exhibits this behavior.)
4776 This was reportedly fixed as of June 2, 1998. */
4778 for (sp
= symbol_rootP
; sp
; sp
= symbol_next (sp
))
4779 if (S_GET_RAW_TYPE (sp
) == N_UNDF
&& IS_GXX_VTABLE (sp
))
4781 S_SET_TYPE (sp
, N_UNDF
| N_EXT
);
4782 S_SET_OTHER (sp
, 1);
4783 as_warn (_("g++ wrote an extern reference to `%s' as a routine.\nI will fix it, but I hope that it was note really a routine."),
4789 * Now scan the symbols and emit the appropriate GSD records
4791 for (sp
= symbol_rootP
; sp
; sp
= symbol_next (sp
))
4793 define_as_global_symbol
= 0;
4795 /* Dispatch on symbol type. */
4796 switch (S_GET_RAW_TYPE (sp
))
4799 /* Global uninitialized data. */
4800 case N_UNDF
| N_EXT
:
4801 /* Make a VMS data symbol entry. */
4802 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4804 vsp
->Size
= S_GET_VALUE (sp
);
4805 vsp
->Psect_Index
= Psect_Number
++;
4806 vsp
->Psect_Offset
= 0;
4807 vsp
->Next
= VMS_Symbols
;
4810 /* Make the psect for this data. */
4811 Globalref
= VMS_Psect_Spec (S_GET_NAME (sp
),
4813 S_GET_OTHER (sp
) ? ps_CONST
: ps_COMMON
,
4817 #ifdef NOT_VAX_11_C_COMPATIBLE
4818 define_as_global_symbol
= 1;
4820 /* See if this is an external vtable. We want to help the
4821 linker find these things in libraries, so we make a symbol
4822 reference. This is not compatible with VAX-C usage for
4823 variables, but since vtables are only used internally by
4824 g++, we can get away with this hack. */
4825 define_as_global_symbol
= IS_GXX_VTABLE (sp
);
4829 /* Local uninitialized data. */
4831 /* Make a VMS data symbol entry. */
4832 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4835 vsp
->Psect_Index
= Bss_Psect
;
4836 vsp
->Psect_Offset
= S_GET_VALUE (sp
) - bss_address_frag
.fr_address
;
4837 vsp
->Next
= VMS_Symbols
;
4842 /* Global initialized data. */
4843 case N_DATA
| N_EXT
:
4844 /* Make a VMS data symbol entry. */
4845 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4847 vsp
->Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
4848 vsp
->Psect_Index
= Psect_Number
++;
4849 vsp
->Psect_Offset
= 0;
4850 vsp
->Next
= VMS_Symbols
;
4853 /* Make its psect. */
4854 Globalref
= VMS_Psect_Spec (S_GET_NAME (sp
),
4856 S_GET_OTHER (sp
) ? ps_CONST
: ps_COMMON
,
4860 #ifdef NOT_VAX_11_C_COMPATIBLE
4861 define_as_global_symbol
= 1;
4863 /* See N_UNDF|N_EXT above for explanation. */
4864 define_as_global_symbol
= IS_GXX_VTABLE (sp
);
4868 /* Local initialized data. */
4871 char *sym_name
= S_GET_NAME (sp
);
4873 /* Always suppress local numeric labels. */
4874 if (sym_name
&& strcmp (sym_name
, FAKE_LABEL_NAME
) == 0)
4877 /* Make a VMS data symbol entry. */
4878 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4880 vsp
->Size
= VMS_Initialized_Data_Size (sp
, text_siz
+ data_siz
);
4881 vsp
->Psect_Index
= Data_Psect
;
4882 vsp
->Psect_Offset
= Local_Initd_Data_Size
;
4883 Local_Initd_Data_Size
+= vsp
->Size
;
4884 vsp
->Next
= VMS_Symbols
;
4890 /* Global Text definition. */
4891 case N_TEXT
| N_EXT
:
4894 if (IS_GXX_XTOR (sp
))
4896 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4898 vsp
->Size
= XTOR_SIZE
;
4900 switch ((S_GET_NAME (sp
))[10])
4903 vsp
->Psect_Index
= Ctors_Psect
;
4904 vsp
->Psect_Offset
= (Ctors_Symbols
==0)?0:(Ctors_Symbols
->Psect_Offset
+XTOR_SIZE
);
4905 vsp
->Next
= Ctors_Symbols
;
4906 Ctors_Symbols
= vsp
;
4909 vsp
->Psect_Index
= Dtors_Psect
;
4910 vsp
->Psect_Offset
= (Dtors_Symbols
==0)?0:(Dtors_Symbols
->Psect_Offset
+XTOR_SIZE
);
4911 vsp
->Next
= Dtors_Symbols
;
4912 Dtors_Symbols
= vsp
;
4915 as_warn (_("Can't handle global xtors symbols yet."));
4918 as_warn (_("Unknown %s"), S_GET_NAME (sp
));
4924 unsigned short Entry_Mask
;
4926 /* Get the entry mask. */
4927 fragP
= sp
->sy_frag
;
4928 /* First frag might be empty if we're generating listings.
4929 So skip empty rs_fill frags. */
4930 while (fragP
&& fragP
->fr_type
== rs_fill
&& fragP
->fr_fix
== 0)
4931 fragP
= fragP
->fr_next
;
4933 /* If first frag doesn't contain the data, what do we do?
4934 If it's possibly smaller than two bytes, that would
4935 imply that the entry mask is not stored where we're
4938 If you can find a test case that triggers this, report
4939 it (and tell me what the entry mask field ought to be),
4940 and I'll try to fix it. KR */
4941 if (fragP
->fr_fix
< 2)
4944 Entry_Mask
= (fragP
->fr_literal
[0] & 0x00ff) |
4945 ((fragP
->fr_literal
[1] & 0x00ff) << 8);
4946 /* Define the procedure entry point. */
4947 VMS_Procedure_Entry_Pt (S_GET_NAME (sp
),
4955 /* Local Text definition. */
4957 /* Make a VMS data symbol entry. */
4958 if (Text_Psect
!= -1)
4960 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4963 vsp
->Psect_Index
= Text_Psect
;
4964 vsp
->Psect_Offset
= S_GET_VALUE (sp
);
4965 vsp
->Next
= VMS_Symbols
;
4971 /* Global Reference. */
4973 /* Make a GSD global symbol reference record. */
4974 VMS_Global_Symbol_Spec (S_GET_NAME (sp
),
4980 /* Absolute symbol. */
4983 /* gcc doesn't generate these;
4984 VMS_Emit_Globalvalue handles them though. */
4985 vsp
= (struct VMS_Symbol
*) xmalloc (sizeof *vsp
);
4987 vsp
->Size
= 4; /* always assume 32 bits */
4988 vsp
->Psect_Index
= 0;
4989 vsp
->Psect_Offset
= S_GET_VALUE (sp
);
4990 vsp
->Next
= VMS_Symbols
;
4995 /* Anything else. */
4997 /* Ignore STAB symbols, including .stabs emitted by g++. */
4998 if (S_IS_DEBUG (sp
) || (S_GET_TYPE (sp
) == 22))
5003 as_tsktsk (_("unhandled stab type %d"), S_GET_TYPE (sp
));
5007 /* Global symbols have different linkage than external variables. */
5008 if (define_as_global_symbol
)
5009 VMS_Global_Symbol_Spec (S_GET_NAME (sp
),
5019 /* Output debugger symbol table information for symbols which
5020 are local to a specific routine. */
5023 local_symbols_DST (s0P
, Current_Routine
)
5024 symbolS
*s0P
, *Current_Routine
;
5027 char *s0P_name
, *pnt0
, *pnt1
;
5029 s0P_name
= S_GET_NAME (s0P
);
5030 if (*s0P_name
++ != '_')
5033 for (s1P
= Current_Routine
; s1P
; s1P
= symbol_next (s1P
))
5035 #if 0 /* redundant; RAW_TYPE != N_FUN suffices */
5036 if (!S_IS_DEBUG (s1P
))
5039 if (S_GET_RAW_TYPE (s1P
) != N_FUN
)
5042 pnt1
= S_GET_NAME (s1P
);
5043 /* We assume the two strings are never exactly equal... */
5044 while (*pnt0
++ == *pnt1
++)
5047 /* Found it if s0P name is exhausted and s1P name has ":F" or ":f" next.
5048 Note: both pointers have advanced one past the non-matching char. */
5049 if ((*pnt1
== 'F' || *pnt1
== 'f') && *--pnt1
== ':' && *--pnt0
== '\0')
5051 Define_Routine (s1P
, 0, Current_Routine
, Text_Psect
);
5057 /* Construct and output the debug symbol table. */
5060 vms_build_DST (text_siz
)
5063 register symbolS
*symbolP
;
5064 symbolS
*Current_Routine
= 0;
5065 struct input_file
*Cur_File
= 0;
5066 offsetT Cur_Offset
= -1;
5067 int Cur_Line_Number
= 0;
5068 int File_Number
= 0;
5069 int Debugger_Offset
= 0;
5074 /* Write the Traceback Begin Module record. */
5075 VMS_TBT_Module_Begin ();
5078 * Output debugging info for global variables and static variables
5079 * that are not specific to one routine. We also need to examine
5080 * all stabs directives, to find the definitions to all of the
5081 * advanced data types, and this is done by VMS_LSYM_Parse. This
5082 * needs to be done before any definitions are output to the object
5083 * file, since there can be forward references in the stabs
5084 * directives. When through with parsing, the text of the stabs
5085 * directive is altered, with the definitions removed, so that later
5086 * passes will see directives as they would be written if the type
5087 * were already defined.
5089 * We also look for files and include files, and make a list of
5090 * them. We examine the source file numbers to establish the actual
5091 * lines that code was generated from, and then generate offsets.
5094 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
5096 /* Only deal with STAB symbols here. */
5097 if (!S_IS_DEBUG (symbolP
))
5100 * Dispatch on STAB type.
5102 switch (S_GET_RAW_TYPE (symbolP
))
5105 dsc
= S_GET_DESC (symbolP
);
5106 if (dsc
> Cur_File
->max_line
)
5107 Cur_File
->max_line
= dsc
;
5108 if (dsc
< Cur_File
->min_line
)
5109 Cur_File
->min_line
= dsc
;
5112 Cur_File
= find_file (symbolP
);
5114 Cur_File
->min_line
= 1;
5117 Cur_File
= find_file (symbolP
);
5120 VMS_GSYM_Parse (symbolP
, Text_Psect
);
5123 VMS_LCSYM_Parse (symbolP
, Text_Psect
);
5125 case N_FUN
: /* For static constant symbols */
5127 VMS_STSYM_Parse (symbolP
, Text_Psect
);
5135 * Now we take a quick sweep through the files and assign offsets
5136 * to each one. This will essentially be the starting line number to
5137 * the debugger for each file. Output the info for the debugger to
5138 * specify the files, and then tell it how many lines to use.
5140 for (Cur_File
= file_root
; Cur_File
; Cur_File
= Cur_File
->next
)
5142 if (Cur_File
->max_line
== 0)
5144 if ((strncmp (Cur_File
->name
, "GNU_GXX_INCLUDE:", 16) == 0) &&
5147 if ((strncmp (Cur_File
->name
, "GNU_CC_INCLUDE:", 15) == 0) &&
5150 /* show a few extra lines at the start of the region selected */
5151 if (Cur_File
->min_line
> 2)
5152 Cur_File
->min_line
-= 2;
5153 Cur_File
->offset
= Debugger_Offset
- Cur_File
->min_line
+ 1;
5154 Debugger_Offset
+= Cur_File
->max_line
- Cur_File
->min_line
+ 1;
5155 if (Cur_File
->same_file_fpnt
)
5157 Cur_File
->file_number
= Cur_File
->same_file_fpnt
->file_number
;
5161 Cur_File
->file_number
= ++File_Number
;
5162 file_available
= VMS_TBT_Source_File (Cur_File
->name
,
5163 Cur_File
->file_number
);
5164 if (!file_available
)
5166 Cur_File
->file_number
= 0;
5171 VMS_TBT_Source_Lines (Cur_File
->file_number
,
5173 Cur_File
->max_line
- Cur_File
->min_line
+ 1);
5175 Cur_File
= (struct input_file
*) NULL
;
5178 * Scan the symbols and write out the routines
5179 * (this makes the assumption that symbols are in
5180 * order of ascending text segment offset)
5182 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
5185 * Deal with text symbols.
5187 if (!S_IS_DEBUG (symbolP
) && S_GET_TYPE (symbolP
) == N_TEXT
)
5190 * Ignore symbols starting with "L", as they are local symbols.
5192 if (*S_GET_NAME (symbolP
) == 'L')
5195 * If there is a routine start defined, terminate it.
5197 if (Current_Routine
)
5198 VMS_TBT_Routine_End (text_siz
, Current_Routine
);
5201 * Check for & skip dummy labels like "gcc_compiled.".
5202 * They're identified by the IN_DEFAULT_SECTION flag.
5204 if ((S_GET_OTHER (symbolP
) & IN_DEFAULT_SECTION
) != 0 &&
5205 S_GET_VALUE (symbolP
) == 0)
5208 * Store the routine begin traceback info.
5210 VMS_TBT_Routine_Begin (symbolP
, Text_Psect
);
5211 Current_Routine
= symbolP
;
5213 * Define symbols local to this routine.
5215 local_symbols_DST (symbolP
, Current_Routine
);
5223 * Deal with STAB symbols.
5225 else if (S_IS_DEBUG (symbolP
))
5228 * Dispatch on STAB type.
5230 switch (S_GET_RAW_TYPE (symbolP
))
5236 /* Offset the line into the correct portion of the file. */
5237 if (Cur_File
->file_number
== 0)
5239 val
= S_GET_VALUE (symbolP
);
5240 /* Sometimes the same offset gets several source lines
5241 assigned to it. We should be selective about which
5242 lines we allow, we should prefer lines that are in
5243 the main source file when debugging inline functions. */
5244 if (val
== Cur_Offset
&& Cur_File
->file_number
!= 1)
5247 /* calculate actual debugger source line */
5248 dsc
= S_GET_DESC (symbolP
) + Cur_File
->offset
;
5249 S_SET_DESC (symbolP
, dsc
);
5251 * Define PC/Line correlation.
5253 if (Cur_Offset
== -1)
5256 * First N_SLINE; set up initial correlation.
5258 VMS_TBT_Line_PC_Correlation (dsc
,
5263 else if ((dsc
- Cur_Line_Number
) <= 0)
5266 * Line delta is not +ve, we need to close the line and
5267 * start a new PC/Line correlation.
5269 VMS_TBT_Line_PC_Correlation (0,
5273 VMS_TBT_Line_PC_Correlation (dsc
,
5281 * Line delta is +ve, all is well.
5283 VMS_TBT_Line_PC_Correlation (dsc
- Cur_Line_Number
,
5288 /* Update the current line/PC info. */
5289 Cur_Line_Number
= dsc
;
5297 /* Remember that we had a source file and emit
5298 the source file debugger record. */
5299 Cur_File
= find_file (symbolP
);
5303 /* We need to make sure that we are really in the actual
5304 source file when we compute the maximum line number.
5305 Otherwise the debugger gets really confused. */
5306 Cur_File
= find_file (symbolP
);
5312 } /* if (IS_DEBUG) */
5316 * If there is a routine start defined, terminate it
5317 * (and the line numbers).
5319 if (Current_Routine
)
5321 /* Terminate the line numbers. */
5322 VMS_TBT_Line_PC_Correlation (0,
5323 text_siz
- S_GET_VALUE (Current_Routine
),
5326 /* Terminate the routine. */
5327 VMS_TBT_Routine_End (text_siz
, Current_Routine
);
5330 /* Write the Traceback End Module TBT record. */
5331 VMS_TBT_Module_End ();
5335 /* Write a VAX/VMS object file (everything else has been done!). */
5338 vms_write_object_file (text_siz
, data_siz
, bss_siz
, text_frag_root
,
5343 fragS
*text_frag_root
;
5344 fragS
*data_frag_root
;
5346 register struct VMS_Symbol
*vsp
;
5349 * Initialize program section indices; values get updated later.
5351 Psect_Number
= 0; /* next Psect Index to use */
5352 Text_Psect
= -1; /* Text Psect Index */
5353 Data_Psect
= -2; /* Data Psect Index JF: Was -1 */
5354 Bss_Psect
= -3; /* Bss Psect Index JF: Was -1 */
5355 Ctors_Psect
= -4; /* Ctors Psect Index */
5356 Dtors_Psect
= -5; /* Dtors Psect Index */
5357 /* Initialize other state variables. */
5359 Local_Initd_Data_Size
= 0;
5362 * Create the actual output file and populate it with required
5363 * "module header" information.
5365 Create_VMS_Object_File ();
5366 Write_VMS_MHD_Records ();
5369 * Create the Data segment:
5371 * Since this is REALLY hard to do any other way,
5372 * we actually manufacture the data segment and
5373 * then store the appropriate values out of it.
5374 * We need to generate this early, so that globalvalues
5375 * can be properly emitted.
5378 synthesize_data_segment (data_siz
, text_siz
, data_frag_root
);
5380 /******* Global Symbol Directory *******/
5383 * Emit globalvalues now. We must do this before the text psect is
5384 * defined, or we will get linker warnings about multiply defined
5385 * symbols. All of the globalvalues "reference" psect 0, although
5386 * it really does not have anything to do with it.
5388 VMS_Emit_Globalvalues (text_siz
, data_siz
, Data_Segment
);
5390 * Define the Text Psect
5392 Text_Psect
= Psect_Number
++;
5393 VMS_Psect_Spec ("$code", text_siz
, ps_TEXT
, 0);
5395 * Define the BSS Psect
5399 Bss_Psect
= Psect_Number
++;
5400 VMS_Psect_Spec ("$uninitialized_data", bss_siz
, ps_DATA
, 0);
5403 * Define symbols to the linker.
5405 global_symbol_directory (text_siz
, data_siz
);
5407 * Define the Data Psect
5409 if (data_siz
> 0 && Local_Initd_Data_Size
> 0)
5411 Data_Psect
= Psect_Number
++;
5412 VMS_Psect_Spec ("$data", Local_Initd_Data_Size
, ps_DATA
, 0);
5414 * Local initialized data (N_DATA) symbols need to be updated to the
5415 * proper value of Data_Psect now that it's actually been defined.
5416 * (A dummy value was used in global_symbol_directory() above.)
5418 for (vsp
= VMS_Symbols
; vsp
; vsp
= vsp
->Next
)
5419 if (vsp
->Psect_Index
< 0 && S_GET_RAW_TYPE (vsp
->Symbol
) == N_DATA
)
5420 vsp
->Psect_Index
= Data_Psect
;
5423 if (Ctors_Symbols
!= 0)
5425 char *ps_name
= "$ctors";
5426 Ctors_Psect
= Psect_Number
++;
5427 VMS_Psect_Spec (ps_name
, Ctors_Symbols
->Psect_Offset
+ XTOR_SIZE
,
5429 VMS_Global_Symbol_Spec (ps_name
, Ctors_Psect
,
5430 0, GBLSYM_DEF
|GBLSYM_WEAK
);
5431 for (vsp
= Ctors_Symbols
; vsp
; vsp
= vsp
->Next
)
5432 vsp
->Psect_Index
= Ctors_Psect
;
5435 if (Dtors_Symbols
!= 0)
5437 char *ps_name
= "$dtors";
5438 Dtors_Psect
= Psect_Number
++;
5439 VMS_Psect_Spec (ps_name
, Dtors_Symbols
->Psect_Offset
+ XTOR_SIZE
,
5441 VMS_Global_Symbol_Spec (ps_name
, Dtors_Psect
,
5442 0, GBLSYM_DEF
|GBLSYM_WEAK
);
5443 for (vsp
= Dtors_Symbols
; vsp
; vsp
= vsp
->Next
)
5444 vsp
->Psect_Index
= Dtors_Psect
;
5447 /******* Text Information and Relocation Records *******/
5450 * Write the text segment data
5453 vms_fixup_text_section (text_siz
, text_frag_root
, data_frag_root
);
5455 * Write the data segment data, then discard it.
5459 vms_fixup_data_section (data_siz
, text_siz
);
5460 free (Data_Segment
), Data_Segment
= 0;
5463 if (Ctors_Symbols
!= 0)
5465 vms_fixup_xtors_section (Ctors_Symbols
, Ctors_Psect
);
5468 if (Dtors_Symbols
!= 0)
5470 vms_fixup_xtors_section (Dtors_Symbols
, Dtors_Psect
);
5473 /******* Debugger Symbol Table Records *******/
5475 vms_build_DST (text_siz
);
5477 /******* Wrap things up *******/
5480 * Write the End Of Module record
5482 if (Entry_Point_Symbol
)
5483 Write_VMS_EOM_Record (Text_Psect
, S_GET_VALUE (Entry_Point_Symbol
));
5485 Write_VMS_EOM_Record (-1, (valueT
) 0);
5488 * All done, close the object file
5490 Close_VMS_Object_File ();