![[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 [Apple XNU] / GNUtools / cc / config / vax|
Return to vms.h CVS log | Up to [Apple XNU] / GNUtools / cc / config / vax |
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/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 ! 35: #undef FUNCTION_PROLOGUE ! 36: #undef STARTING_FRAME_OFFSET ! 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. */ ! 40: #define CPP_PREDEFINES "-Dvax -Dvms -DVMS -D__GNUC__=2 -D__GNUC_MINOR__=5 -Asystem(vms) -Acpu(vax) -Amachine(vax)" ! 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 ! 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: /* The structure return address arrives as an "argument" on VMS. */ ! 63: #undef STRUCT_VALUE_REGNUM ! 64: #define STRUCT_VALUE 0 ! 65: #undef PCC_STATIC_STRUCT_RETURN ! 66: ! 67: #define CALL_USED_REGISTERS {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1} ! 68: ! 69: /* We redefine this because there is a hidden variable on the stack ! 70: that VAXC$ESTABLISH uses. We just need to add four bytes to whatever ! 71: gcc thinks that we need. Similarly, we need to move all local variables ! 72: down 4 bytes in the stack. */ ! 73: ! 74: #define STARTING_FRAME_OFFSET -4 ! 75: ! 76: #define FUNCTION_PROLOGUE(FILE, SIZE) \ ! 77: { register int regno; \ ! 78: register int mask = 0; \ ! 79: register int newsize = SIZE + 4; \ ! 80: extern char call_used_regs[]; \ ! 81: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) \ ! 82: if (regs_ever_live[regno] && !call_used_regs[regno]) \ ! 83: mask |= 1 << regno; \ ! 84: fprintf (FILE, "\t.word 0x%x\n", mask); \ ! 85: MAYBE_VMS_FUNCTION_PROLOGUE(FILE) \ ! 86: if (newsize >= 64) fprintf (FILE, "\tmovab %d(sp),sp\n", -newsize);\ ! 87: else fprintf (FILE, "\tsubl2 $%d,sp\n", newsize); } ! 88: ! 89: #define __MAIN_NAME " main(" ! 90: /* ! 91: * The MAYBE_VMS_FUNCTION_PROLOGUE macro works for both gcc and g++. It ! 92: * first checks to see if the current routine is "main", which will only ! 93: * happen for GCC, and add the jsb if it is. If is not the case then try and ! 94: * see if __MAIN_NAME is part of current_function_name, which will only happen ! 95: * if we are running g++, and add the jsb if it is. In gcc there should never ! 96: * be a paren in the function name, and in g++ there is always a "(" in the ! 97: * function name, thus there should never be any confusion. ! 98: * ! 99: * Adjusting the stack pointer by 4 before calling C$MAIN_ARGS is required ! 100: * when linking with the VMS POSIX version of the C run-time library; using ! 101: * `subl2 $4,r0' is adequate but we use `clrl -(sp)' instead. The extra 4 ! 102: * bytes could be removed after the call because STARTING_FRAME_OFFSET's ! 103: * setting of -4 will end up adding them right back again, but don't bother. ! 104: */ ! 105: #define MAYBE_VMS_FUNCTION_PROLOGUE(FILE) \ ! 106: { extern char *current_function_name; \ ! 107: char *p = current_function_name; \ ! 108: int is_main = strcmp ("main", p) == 0; \ ! 109: while (!is_main && *p != '\0') \ ! 110: { \ ! 111: if (*p == *__MAIN_NAME \ ! 112: && strncmp (p, __MAIN_NAME, sizeof __MAIN_NAME - sizeof "") == 0) \ ! 113: is_main = 1; \ ! 114: else \ ! 115: p++; \ ! 116: } \ ! 117: if (is_main) \ ! 118: fprintf (FILE, "\t%s\n\t%s\n", "clrl -(sp)", "jsb _C$MAIN_ARGS"); \ ! 119: } ! 120: ! 121: /* This macro definition sets up a default value for `main' to return. */ ! 122: #define DEFAULT_MAIN_RETURN c_expand_return (integer_one_node) ! 123: ! 124: /* This makes use of a hook in varasm.c to mark all external variables ! 125: for us. We use this to make sure that external variables are correctly ! 126: addressed. Under VMS there is some brain damage in the linker that requires ! 127: us to do this. */ ! 128: ! 129: #define ENCODE_SECTION_INFO(decl) \ ! 130: if (DECL_EXTERNAL (decl) && TREE_PUBLIC (decl)) \ ! 131: SYMBOL_REF_FLAG (XEXP (DECL_RTL (decl), 0)) = 1; ! 132: ! 133: /* This is how to output a command to make the user-level label named NAME ! 134: defined for reference from other files. */ ! 135: ! 136: #undef ASM_GLOBALIZE_LABEL ! 137: #define ASM_GLOBALIZE_LABEL(FILE,NAME) \ ! 138: do { fputs (".globl ", FILE); \ ! 139: assemble_name (FILE, NAME); \ ! 140: fputs ("\n", FILE); \ ! 141: vms_check_external (NAME); \ ! 142: } while (0) ! 143: ! 144: /* Under VMS we write the actual size of the storage to be allocated even ! 145: though the symbol is external. Although it is possible to give external ! 146: symbols a size of 0 (as unix does), the VMS linker does not make the ! 147: distinction between a variable definition and an external reference of a ! 148: variable, and thus the linker will not complain about a missing definition. ! 149: If we followed the unix example of giving external symbols a size of ! 150: zero, you tried to link a program where a given variable was externally ! 151: defined but none of the object modules contained a non-extern definition, ! 152: the linker would allocate 0 bytes for the variable, and any attempt to ! 153: use that variable would use the storage allocated to some other variable. ! 154: ! 155: We must also select either const_section or data_section: this will indicate ! 156: whether or not the variable will get the readonly bit set. Since the ! 157: VMS linker does not distinguish between a variable's definition and an ! 158: external reference, all usages of a given variable must have the readonly ! 159: bit set the same way, or the linker will get confused and give warning ! 160: messages. */ ! 161: ! 162: /* We used to round the size up to a multiple of 4, ! 163: but that causes linker errors sometimes when the variable was initialized ! 164: since the size of its definition was not likewise rounded up. */ ! 165: ! 166: #define ASM_OUTPUT_EXTERNAL(FILE,DECL,NAME) \ ! 167: { if (DECL_INITIAL (DECL) == 0 && TREE_CODE (DECL) != FUNCTION_DECL \ ! 168: && ! vms_check_external (NAME)) \ ! 169: { \ ! 170: if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)) \ ! 171: const_section (); \ ! 172: else \ ! 173: data_section (); \ ! 174: fputs (".comm ", (FILE)); \ ! 175: assemble_name ((FILE), (NAME)); \ ! 176: if (DECL_SIZE (DECL) == 0) \ ! 177: fprintf ((FILE), ",0\n"); \ ! 178: else \ ! 179: { \ ! 180: tree size_tree; \ ! 181: size_tree = size_binop (CEIL_DIV_EXPR, \ ! 182: DECL_SIZE (DECL), size_int (BITS_PER_UNIT)); \ ! 183: fprintf ((FILE), ",%d\n", TREE_INT_CST_LOW (size_tree)); \ ! 184: } \ ! 185: } \ ! 186: } ! 187: ! 188: /* Here we redefine ASM_OUTPUT_COMMON to select the data_section or the ! 189: const_section before writing the ".const" assembler directive. ! 190: If we were specifying a size of zero for external variables, we would ! 191: not have to select a section, since the assembler can assume that ! 192: when the size > 0, the storage is for a non-external, uninitialized ! 193: variable (for which a "const" declaration would be senseless), ! 194: and the assembler can make the storage read/write. ! 195: ! 196: Since the ".const" directive specifies the actual size of the storage used ! 197: for both external and non-external variables, the assembler cannot ! 198: make this assumption, and thus it has no way of deciding if storage should ! 199: be read/write or read-only. To resolve this, we give the assembler some ! 200: assistance, in the form of a ".const" or a ".data" directive. ! 201: ! 202: Under GCC 1.40, external variables were declared with a size of zero. ! 203: The GNU assembler, GAS, will recognize the "-2" switch when built for VMS; ! 204: when compiling programs with GCC 2.n this switch should be used or the ! 205: assembler will not give the read-only attribute to external constants. ! 206: Failure to use this switch will result in linker warning messages about ! 207: mismatched psect attributes. */ ! 208: ! 209: #undef ASM_OUTPUT_COMMON ! 210: ! 211: #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ ! 212: ( ((TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)) \ ! 213: ? (const_section (), 0) : (data_section (), 0)), \ ! 214: fputs (".comm ", (FILE)), \ ! 215: assemble_name ((FILE), (NAME)), \ ! 216: fprintf ((FILE), ",%u\n", (SIZE))) ! 217: ! 218: /* We define this to prevent the name mangler from putting dollar signs into ! 219: function names. This isn't really needed, but it has been here for ! 220: some time and removing it would cause the object files generated by the ! 221: compiler to be incompatible with the object files from a compiler that ! 222: had this defined. Since it does no harm, we leave it in. */ ! 223: ! 224: #define NO_DOLLAR_IN_LABEL ! 225: ! 226: /* Add a "const" section. This is viewed by the assembler as being nearly ! 227: the same as the "data" section, with the only difference being that a ! 228: flag is set for variables declared while in the const section. This ! 229: flag is used to determine whether or not the read/write bit should be ! 230: set in the Psect definition. */ ! 231: ! 232: #define EXTRA_SECTIONS in_const ! 233: ! 234: #define EXTRA_SECTION_FUNCTIONS \ ! 235: void \ ! 236: const_section () \ ! 237: { \ ! 238: if (in_section != in_const) { \ ! 239: fprintf(asm_out_file,".const\n"); \ ! 240: in_section = in_const; \ ! 241: } \ ! 242: } ! 243: ! 244: /* This macro contains the logic to decide which section a variable ! 245: should be stored in. Static constant variables go in the text_section, ! 246: non-const variables go in the data_section, and non-static const ! 247: variables go in the const_section. ! 248: ! 249: Since this macro is used in a number of places, we must also be able ! 250: to decide where to place string constants. */ ! 251: ! 252: #define SELECT_SECTION(T,RELOC) \ ! 253: { \ ! 254: if (TREE_CODE (T) == VAR_DECL) \ ! 255: { \ ! 256: if (TREE_READONLY (T) && ! TREE_THIS_VOLATILE (T)) \ ! 257: { \ ! 258: if (TREE_PUBLIC (T)) \ ! 259: const_section (); \ ! 260: else \ ! 261: text_section (); \ ! 262: } \ ! 263: else \ ! 264: data_section (); \ ! 265: } \ ! 266: if (*tree_code_type[(int) TREE_CODE (T)] == 'c') \ ! 267: { \ ! 268: if ((TREE_CODE (T) == STRING_CST && flag_writable_strings)) \ ! 269: data_section (); \ ! 270: else \ ! 271: text_section (); \ ! 272: } \ ! 273: } ! 274: ! 275: /* This is used by a hook in varasm.c to write the assembler directives ! 276: that are needed to tell the startup code which constructors need to ! 277: be run. */ ! 278: ! 279: #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ ! 280: { \ ! 281: fprintf ((FILE),".globl $$PsectAttributes_NOOVR$$__gxx_init_1\n"); \ ! 282: data_section(); \ ! 283: fprintf ((FILE),"$$PsectAttributes_NOOVR$$__gxx_init_1:\n\t.long\t"); \ ! 284: assemble_name ((FILE), (NAME)); \ ! 285: fputc ('\n', (FILE)); \ ! 286: } ! 287: ! 288: /* This is used by a hook in varasm.c to write the assembler directives ! 289: that are needed to tell the startup code which destructors need to ! 290: be run. */ ! 291: ! 292: #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ ! 293: { \ ! 294: fprintf ((FILE),".globl $$PsectAttributes_NOOVR$$__gxx_clean_1\n"); \ ! 295: data_section(); \ ! 296: fprintf ((FILE),"$$PsectAttributes_NOOVR$$__gxx_clean_1:\n\t.long\t");\ ! 297: assemble_name ((FILE), (NAME)); \ ! 298: fputc ('\n', (FILE)); \ ! 299: } ! 300: ! 301: /* The following definitions are used in libgcc2.c with the __main ! 302: function. The _SHR symbol is used when the sharable image library ! 303: for libg++ is used - this is picked up automatically by the linker ! 304: and this symbol points to the start of the __CTOR_LIST__ from libg++. ! 305: If libg++ is not being used, then __CTOR_LIST_SHR__ occurs just after ! 306: __CTOR_LIST__, and essentially points to the same list as __CTOR_LIST. */ ! 307: ! 308: #ifdef L__main ! 309: ! 310: #define __CTOR_LIST__ __gxx_init_0 ! 311: #define __CTOR_LIST_END__ __gxx_init_2 ! 312: ! 313: #define __CTOR_LIST_SHR__ $$PsectAttributes_NOSHR$$__gxx_init_0_shr ! 314: #define __CTOR_LIST_SHR_END__ $$PsectAttributes_NOSHR$$__gxx_init_2_shr ! 315: ! 316: #define DO_GLOBAL_CTORS_BODY \ ! 317: do { \ ! 318: func_ptr *p; \ ! 319: extern func_ptr __CTOR_LIST__[1]; \ ! 320: extern func_ptr __CTOR_LIST_END__[1]; \ ! 321: extern func_ptr __CTOR_LIST_SHR__[1]; \ ! 322: extern func_ptr __CTOR_LIST_SHR_END__[1]; \ ! 323: if( &__CTOR_LIST_SHR__[0] != &__CTOR_LIST__[1]) \ ! 324: for (p = __CTOR_LIST_SHR__ + 1; p < __CTOR_LIST_SHR_END__ ; p++ ) \ ! 325: if (*p) (*p) (); \ ! 326: for (p = __CTOR_LIST__ + 1; p < __CTOR_LIST_END__ ; p++ ) \ ! 327: if (*p) (*p) (); \ ! 328: atexit (__do_global_dtors); \ ! 329: { \ ! 330: __label__ foo; \ ! 331: int *callers_caller_fp = (int *) __builtin_frame_address (3); \ ! 332: register int retval asm ("r0"); \ ! 333: callers_caller_fp[4] = (int) && foo; \ ! 334: return; \ ! 335: foo: \ ! 336: exit (retval); \ ! 337: } \ ! 338: } while (0) ! 339: ! 340: #define __DTOR_LIST__ __gxx_clean_0 ! 341: #define __DTOR_LIST_END__ __gxx_clean_2 ! 342: ! 343: #define __DTOR_LIST_SHR__ $$PsectAttributes_NOSHR$$__gxx_clean_0_shr ! 344: #define __DTOR_LIST_SHR_END__ $$PsectAttributes_NOSHR$$__gxx_clean_2_shr ! 345: ! 346: #define DO_GLOBAL_DTORS_BODY \ ! 347: do { \ ! 348: func_ptr *p; \ ! 349: extern func_ptr __DTOR_LIST__[1]; \ ! 350: extern func_ptr __DTOR_LIST_END__[1]; \ ! 351: extern func_ptr __DTOR_LIST_SHR__[1]; \ ! 352: extern func_ptr __DTOR_LIST_SHR_END__[1]; \ ! 353: for (p = __DTOR_LIST__ + 1; p < __DTOR_LIST_END__ ; p++ ) \ ! 354: if (*p) (*p) (); \ ! 355: if( &__DTOR_LIST_SHR__[0] != &__DTOR_LIST__[1]) \ ! 356: for (p = __DTOR_LIST_SHR__ + 1; p < __DTOR_LIST_SHR_END__ ; p++ ) \ ! 357: if (*p) (*p) (); \ ! 358: } while (0) ! 359: ! 360: #endif /* L__main */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.