gcc/config/vax/vms.h

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