![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vms.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config|
Return to vms.h CVS log | Up to [GCC 2.x] / gcc / config |
1.1 root 1: /* Output variables, constants and external declarations, for GNU compiler.
2: Copyright (C) 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* This enables certain macros in vax.h, which will make an indirect
21: reference to an external symbol an invalid address. This needs to be
22: defined before we include vax.h, since it determines which macros
23: are used for GO_IF_*. */
24:
25: #define NO_EXTERNAL_INDIRECT_ADDRESS
26:
27: #include "vax.h"
28:
29: #undef LIB_SPEC
30: #undef CPP_PREDEFINES
31: #undef TARGET_VERSION
32: #undef TARGET_DEFAULT
33: #undef CALL_USED_REGISTERS
34: #undef MAYBE_VMS_FUNCTION_PROLOGUE
1.1.1.3 ! root 35: #undef FUNCTION_PROLOGUE
! 36: #undef STARTING_FRAME_OFFSET
1.1 root 37:
38: /* Predefine this in CPP because VMS limits the size of command options
39: and GNU CPP is not used on VMS except with GNU C. */
1.1.1.2 root 40: #define CPP_PREDEFINES "-Dvax -Dvms -DVMS -D__GNUC__=2"
41:
42: /* These match the definitions used in VAXCRTL, the VMS C run-time library */
43:
44: #define SIZE_TYPE "unsigned int"
45: #define PTRDIFF_TYPE "int"
46: #define WCHAR_TYPE "unsigned int"
47:
48: /* Use memcpy for structure copying, and so forth. */
49: #define TARGET_MEM_FUNCTIONS
1.1 root 50:
51: /* Strictly speaking, VMS does not use DBX at all, but the interpreter built
52: into gas only speaks straight DBX. */
53:
54: #define DEFAULT_GDB_EXTENSIONS 0
55:
56: /* By default, allow $ to be part of an identifier. */
57: #define DOLLARS_IN_IDENTIFIERS 2
58:
59: #define TARGET_DEFAULT 1
60: #define TARGET_VERSION fprintf (stderr, " (vax vms)");
61:
62: #define CALL_USED_REGISTERS {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1}
63:
1.1.1.3 ! root 64: /* We redefine this because there is a hidden variable on the stack
! 65: that VAXC$ESTABLISH uses. We just need to add four bytes to whatever
! 66: gcc thinks that we need. Similarily, we need to move all local variables
! 67: down 4 bytes in the stack. */
! 68:
! 69: #define STARTING_FRAME_OFFSET -4
! 70:
! 71: #define FUNCTION_PROLOGUE(FILE, SIZE) \
! 72: { register int regno; \
! 73: register int mask = 0; \
! 74: register int newsize = SIZE + 4; \
! 75: extern char call_used_regs[]; \
! 76: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) \
! 77: if (regs_ever_live[regno] && !call_used_regs[regno]) \
! 78: mask |= 1 << regno; \
! 79: fprintf (FILE, "\t.word 0x%x\n", mask); \
! 80: MAYBE_VMS_FUNCTION_PROLOGUE(FILE) \
! 81: if (newsize >= 64) fprintf (FILE, "\tmovab %d(sp),sp\n", -newsize);\
! 82: else fprintf (FILE, "\tsubl2 $%d,sp\n", newsize); }
! 83:
1.1 root 84: #define __MAIN_NAME " main ("
85: /*
86: * The MAYBE_VMS_FUNCTION_PROLOGUE macro works for both gcc and g++. It
87: * first checks to see if the current routine is "main", which will only
88: * happen for GCC, and add the jsb if it is. If is not the case then try and
89: * see if __MAIN_NAME is part of current_function_name, which will only happen
90: * if we are running g++, and add the jsb if it is. In gcc there should never
91: * be a space in the function name, and in g++ there is always a "(" in the
92: * function name, thus there should never be any confusion.
93: */
94: #define MAYBE_VMS_FUNCTION_PROLOGUE(FILE) \
95: { extern char *current_function_name; \
96: if (!strcmp ("main", current_function_name)) \
97: fprintf(FILE, "\tjsb _c$main_args\n"); \
98: else { \
99: char *p = current_function_name; \
100: while (*p != '\0') \
101: if (*p == *__MAIN_NAME) \
102: if (strncmp(p, __MAIN_NAME, (sizeof __MAIN_NAME)-1) == 0) {\
103: fprintf(FILE, "\tjsb _c$main_args\n");\
104: break; \
105: } else \
106: p++; \
107: else \
108: p++; \
109: }; \
110: }
111:
112: /* This macro definition sets up a default value for `main' to return. */
113: #define DEFAULT_MAIN_RETURN c_expand_return (integer_one_node)
114:
115: /* This makes use of a hook in varasm.c to mark all external variables
116: for us. We use this to make sure that external variables are correctly
117: addressed. Under VMS there is some brain damage in the linker that requires
118: us to do this. */
119:
120: #define ENCODE_SECTION_INFO(decl) \
121: if (TREE_EXTERNAL (decl) && TREE_PUBLIC (decl)) \
122: SYMBOL_REF_FLAG (XEXP (DECL_RTL (decl), 0)) = 1;
123:
124: /* Under VMS we write the actual size of the storage to be allocated even
125: though the symbol is external. Although it is possible to give external
126: symbols a size of 0 (as unix does), the VMS linker does not make the
127: distinction between a variable definition and an external reference of a
128: variable, and thus the linker will not complain about a missing definition.
129: If we followed the unix example of giving external symbols a size of
130: zero, you tried to link a program where a given variable was externally
131: defined but none of the object modules contained a non-extern definition,
132: the linker would allocate 0 bytes for the variable, and any attempt to
133: use that variable would use the storage allocated to some other variable.
134:
135: We must also select either const_section or data_section: this will indicate
136: whether or not the variable will get the readonly bit set. Since the
137: VMS linker does not distinguish between a variable's definition and an
138: external reference, all usages of a given variable must have the readonly
139: bit set the same way, or the linker will get confused and give warning
140: messages. */
141:
142: /* We used to round the size up to a multiple of 4,
143: but that causes linker errors sometimes when the variable was initialized
144: since the size of its definition was not likewise rounded up. */
145:
146: #define ASM_OUTPUT_EXTERNAL(FILE,DECL,NAME) \
147: { if (DECL_INITIAL (DECL) == 0 && TREE_CODE (DECL) != FUNCTION_DECL) \
148: { \
149: if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)) \
150: const_section (); \
151: else \
152: data_section (); \
153: fputs (".comm ", (FILE)); \
154: assemble_name ((FILE), (NAME)); \
155: if (DECL_SIZE (DECL) == 0) \
156: fprintf ((FILE), ",0\n"); \
157: else \
158: { \
159: tree size_tree; \
160: size_tree = size_binop (CEIL_DIV_EXPR, \
161: DECL_SIZE (DECL), size_int (BITS_PER_UNIT)); \
162: fprintf ((FILE), ",%d\n", TREE_INT_CST_LOW (size_tree)); \
163: } \
164: } \
165: }
166:
167: /* Here we redefine ASM_OUTPUT_COMMON to select the data_section or the
168: const_section before writing the ".const" assembler directive.
169: If we were specifying a size of zero for external variables, we would
170: not have to select a section, since the assembler can assume that
171: when the size > 0, the storage is for a non-external, uninitialized
172: variable (for which a "const" declaration would be senseless),
173: and the assembler can make the storage read/write.
174:
175: Since the ".const" directive specifies the actual size of the storage used
176: for both external and non-external variables, the assembler cannot
177: make this assumption, and thus it has no way of deciding if storage should
178: be read/write or read-only. To resolve this, we give the assembler some
179: assistance, in the form of a ".const" or a ".data" directive.
180:
181: Under GCC 1.40, external variables were declared with a size of zero.
182: The GNU assembler, GAS, will recognize the "-2" switch when built for VMS;
183: when compiling programs with GCC 2.n this switch should be used or the
184: assembler will not give the read-only attribute to external constants.
185: Failure to use this switch will result in linker warning messages about
186: mismatched psect attributes. */
187:
188: #undef ASM_OUTPUT_COMMON
189:
190: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
191: ( ((TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)) \
192: ? (const_section (), 0) : (data_section (), 0)), \
193: fputs (".comm ", (FILE)), \
194: assemble_name ((FILE), (NAME)), \
1.1.1.2 root 195: fprintf ((FILE), ",%u\n", (SIZE)))
1.1 root 196:
197: /* We define this to prevent the name mangler from putting dollar signs into
198: function names. This isn't really needed, but it has been here for
199: some time and removing it would cause the object files generated by the
200: compiler to be incompatible with the object files from a compiler that
201: had this defined. Since it does no harm, we leave it in. */
202:
203: #define NO_DOLLAR_IN_LABEL
204:
1.1.1.2 root 205: /* Add a "const" section. This is viewed by the assembler as being nearly
1.1 root 206: the same as the "data" section, with the only difference being that a
207: flag is set for variables declared while in the const section. This
208: flag is used to determine whether or not the read/write bit should be
209: set in the Psect definition. */
210:
211: #define EXTRA_SECTIONS in_const
212:
213: #define EXTRA_SECTION_FUNCTIONS \
214: void \
215: const_section () \
216: { \
217: if (in_section != in_const) { \
218: fprintf(asm_out_file,".const\n"); \
219: in_section = in_const; \
220: } \
221: }
222:
223: /* This macro contains the logic to decide which section a variable
224: should be stored in. Static constant variables go in the text_section,
225: non-const variables go in the data_section, and non-static const
226: variables go in the const_section.
227:
228: Since this macro is used in a number of places, we must also be able
229: to decide where to place string constants. */
230:
231: #define SELECT_SECTION(T,RELOC) \
232: { \
233: if (TREE_CODE (T) == VAR_DECL) \
234: { \
235: if (TREE_READONLY (T) && ! TREE_THIS_VOLATILE (T)) \
236: { \
237: if (TREE_PUBLIC (T)) \
238: const_section (); \
239: else \
240: text_section (); \
241: } \
242: else \
243: data_section (); \
244: } \
245: if (*tree_code_type[(int) TREE_CODE (T)] == 'c') \
246: { \
247: if ((TREE_CODE (T) == STRING_CST && flag_writable_strings)) \
248: data_section (); \
249: else \
250: text_section (); \
251: } \
252: }
253:
254: /* This is used by a hook in varasm.c to write the assembler directives
255: that are needed to tell the startup code which constructors need to
256: be run. */
257:
258: #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
259: { \
260: fprintf ((FILE),".globl $$PsectAttributes_NOOVR$$__gxx_init_1\n"); \
261: data_section(); \
262: fprintf ((FILE),"$$PsectAttributes_NOOVR$$__gxx_init_1:\n\t.long\t"); \
263: assemble_name ((FILE), (NAME)); \
264: fputc ('\n', (FILE)); \
265: }
266:
267: /* This is used by a hook in varasm.c to write the assembler directives
268: that are needed to tell the startup code which destructors need to
269: be run. */
270:
271: #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
272: { \
273: fprintf ((FILE),".globl $$PsectAttributes_NOOVR$$__gxx_clean_1\n"); \
274: data_section(); \
275: fprintf ((FILE),"$$PsectAttributes_NOOVR$$__gxx_clean_1:\n\t.long\t");\
276: assemble_name ((FILE), (NAME)); \
277: fputc ('\n', (FILE)); \
278: }
279:
280: /* The following definitions are used in libgcc2.c with the __main
281: function. The _SHR symbol is used when the sharable image library
282: for libg++ is used - this is picked up automatically by the linker
283: and this symbol points to the start of the __CTOR_LIST__ from libg++.
284: If libg++ is not being used, then __CTOR_LIST_SHR__ occurs just after
285: __CTOR_LIST__, and essentially points to the same list as __CTOR_LIST. */
286:
287: #ifdef L__main
288:
289: #define __CTOR_LIST__ __gxx_init_0
290: #define __CTOR_LIST_END__ __gxx_init_2
291:
292: #define __CTOR_LIST_SHR__ $$PsectAttributes_NOSHR$$__gxx_init_0_shr
293: #define __CTOR_LIST_SHR_END__ $$PsectAttributes_NOSHR$$__gxx_init_2_shr
294:
295: #define DO_GLOBAL_CTORS_BODY \
296: do { \
297: func_ptr *p; \
298: extern func_ptr __CTOR_LIST__[1]; \
299: extern func_ptr __CTOR_LIST_END__[1]; \
300: extern func_ptr __CTOR_LIST_SHR__[1]; \
301: extern func_ptr __CTOR_LIST_SHR_END__[1]; \
302: if( &__CTOR_LIST_SHR__[0] != &__CTOR_LIST__[1]) \
303: for (p = __CTOR_LIST_SHR__ + 1; p < __CTOR_LIST_SHR_END__ ; p++ ) \
304: if (*p) (*p) (); \
305: for (p = __CTOR_LIST__ + 1; p < __CTOR_LIST_END__ ; p++ ) \
306: if (*p) (*p) (); \
307: atexit (__do_global_dtors); \
308: { \
309: __label__ foo; \
310: int *callers_caller_fp = (int *) __builtin_frame_address (3); \
311: register int retval asm ("r0"); \
312: callers_caller_fp[4] = (int) && foo; \
313: return; \
314: foo: \
315: exit (retval); \
316: } \
317: } while (0)
318:
319: #define __DTOR_LIST__ __gxx_clean_0
320: #define __DTOR_LIST_END__ __gxx_clean_2
321:
322: #define __DTOR_LIST_SHR__ $$PsectAttributes_NOSHR$$__gxx_clean_0_shr
323: #define __DTOR_LIST_SHR_END__ $$PsectAttributes_NOSHR$$__gxx_clean_2_shr
324:
325: #define DO_GLOBAL_DTORS_BODY \
326: do { \
327: func_ptr *p; \
328: extern func_ptr __DTOR_LIST__[1]; \
329: extern func_ptr __DTOR_LIST_END__[1]; \
330: extern func_ptr __DTOR_LIST_SHR__[1]; \
331: extern func_ptr __DTOR_LIST_SHR_END__[1]; \
332: for (p = __DTOR_LIST__ + 1; p < __DTOR_LIST_END__ ; p++ ) \
333: if (*p) (*p) (); \
334: if( &__DTOR_LIST_SHR__[0] != &__DTOR_LIST__[1]) \
335: for (p = __DTOR_LIST_SHR__ + 1; p < __DTOR_LIST_SHR_END__ ; p++ ) \
336: if (*p) (*p) (); \
337: } while (0)
338:
339: #endif /* L__main */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.