[8833] | 1 | /* Operating system specific defines to be used when targeting GCC for some |
---|
| 2 | generic System V Release 4 system. |
---|
| 3 | Copyright (C) 1991, 1994, 1995 Free Software Foundation, Inc. |
---|
| 4 | Contributed by Ron Guilmette (rfg@segfault.us.com). |
---|
| 5 | |
---|
| 6 | This file is part of GNU CC. |
---|
| 7 | |
---|
| 8 | GNU CC is free software; you can redistribute it and/or modify |
---|
| 9 | it under the terms of the GNU General Public License as published by |
---|
| 10 | the Free Software Foundation; either version 2, or (at your option) |
---|
| 11 | any later version. |
---|
| 12 | |
---|
| 13 | GNU CC is distributed in the hope that it will be useful, |
---|
| 14 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
| 16 | GNU General Public License for more details. |
---|
| 17 | |
---|
| 18 | You should have received a copy of the GNU General Public License |
---|
| 19 | along with GNU CC; see the file COPYING. If not, write to |
---|
| 20 | the Free Software Foundation, 59 Temple Place - Suite 330, |
---|
| 21 | Boston, MA 02111-1307, USA. |
---|
| 22 | |
---|
| 23 | To use this file, make up a file with a name like: |
---|
| 24 | |
---|
| 25 | ?????svr4.h |
---|
| 26 | |
---|
| 27 | where ????? is replaced by the name of the basic hardware that you |
---|
| 28 | are targeting for. Then, in the file ?????svr4.h, put something |
---|
| 29 | like: |
---|
| 30 | |
---|
| 31 | #include "?????.h" |
---|
| 32 | #include "svr4.h" |
---|
| 33 | |
---|
| 34 | followed by any really system-specific defines (or overrides of |
---|
| 35 | defines) which you find that you need. For example, CPP_PREDEFINES |
---|
| 36 | is defined here with only the defined -Dunix and -DSVR4. You should |
---|
| 37 | probably override that in your target-specific ?????svr4.h file |
---|
| 38 | with a set of defines that includes these, but also contains an |
---|
| 39 | appropriate define for the type of hardware that you are targeting. |
---|
| 40 | */ |
---|
| 41 | |
---|
| 42 | /* Define a symbol indicating that we are using svr4.h. */ |
---|
| 43 | #define USING_SVR4_H |
---|
| 44 | |
---|
| 45 | /* For the sake of libgcc2.c, indicate target supports atexit. */ |
---|
| 46 | #define HAVE_ATEXIT |
---|
| 47 | |
---|
| 48 | /* Cpp, assembler, linker, library, and startfile spec's. */ |
---|
| 49 | |
---|
| 50 | /* This defines which switch letters take arguments. On svr4, most of |
---|
| 51 | the normal cases (defined in gcc.c) apply, and we also have -h* and |
---|
| 52 | -z* options (for the linker). Note however that there is no such |
---|
| 53 | thing as a -T option for svr4. */ |
---|
| 54 | |
---|
| 55 | #define SWITCH_TAKES_ARG(CHAR) \ |
---|
| 56 | ( (CHAR) == 'D' \ |
---|
| 57 | || (CHAR) == 'U' \ |
---|
| 58 | || (CHAR) == 'o' \ |
---|
| 59 | || (CHAR) == 'e' \ |
---|
| 60 | || (CHAR) == 'u' \ |
---|
| 61 | || (CHAR) == 'I' \ |
---|
| 62 | || (CHAR) == 'm' \ |
---|
| 63 | || (CHAR) == 'L' \ |
---|
| 64 | || (CHAR) == 'A' \ |
---|
| 65 | || (CHAR) == 'h' \ |
---|
| 66 | || (CHAR) == 'z') |
---|
| 67 | |
---|
| 68 | /* This defines which multi-letter switches take arguments. On svr4, |
---|
| 69 | there are no such switches except those implemented by GCC itself. */ |
---|
| 70 | |
---|
| 71 | #define WORD_SWITCH_TAKES_ARG(STR) \ |
---|
| 72 | (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) \ |
---|
| 73 | && strcmp (STR, "Tdata") && strcmp (STR, "Ttext") \ |
---|
| 74 | && strcmp (STR, "Tbss")) |
---|
| 75 | |
---|
| 76 | /* You should redefine CPP_PREDEFINES in any file which includes this one. |
---|
| 77 | The definition should be appropriate for the type of target system |
---|
| 78 | involved, and it should include any -A (assertion) options which are |
---|
| 79 | appropriate for the given target system. */ |
---|
| 80 | #undef CPP_PREDEFINES |
---|
| 81 | |
---|
| 82 | /* Provide an ASM_SPEC appropriate for svr4. Here we try to support as |
---|
| 83 | many of the specialized svr4 assembler options as seems reasonable, |
---|
| 84 | given that there are certain options which we can't (or shouldn't) |
---|
| 85 | support directly due to the fact that they conflict with other options |
---|
| 86 | for other svr4 tools (e.g. ld) or with other options for GCC itself. |
---|
| 87 | For example, we don't support the -o (output file) or -R (remove |
---|
| 88 | input file) options because GCC already handles these things. We |
---|
| 89 | also don't support the -m (run m4) option for the assembler because |
---|
| 90 | that conflicts with the -m (produce load map) option of the svr4 |
---|
| 91 | linker. We do however allow passing arbitrary options to the svr4 |
---|
| 92 | assembler via the -Wa, option. |
---|
| 93 | |
---|
| 94 | Note that gcc doesn't allow a space to follow -Y in a -Ym,* or -Yd,* |
---|
| 95 | option. |
---|
| 96 | */ |
---|
| 97 | |
---|
| 98 | #undef ASM_SPEC |
---|
| 99 | #define ASM_SPEC \ |
---|
| 100 | "%{V} %{v:%{!V:-V}} %{Qy:} %{!Qn:-Qy} %{n} %{T} %{Ym,*} %{Yd,*} %{Wa,*:%*}" |
---|
| 101 | |
---|
| 102 | /* svr4 assemblers need the `-' (indicating input from stdin) to come after |
---|
| 103 | the -o option (and its argument) for some reason. If we try to put it |
---|
| 104 | before the -o option, the assembler will try to read the file named as |
---|
| 105 | the output file in the -o option as an input file (after it has already |
---|
| 106 | written some stuff to it) and the binary stuff contained therein will |
---|
| 107 | cause totally confuse the assembler, resulting in many spurious error |
---|
| 108 | messages. */ |
---|
| 109 | |
---|
| 110 | #undef ASM_FINAL_SPEC |
---|
| 111 | #define ASM_FINAL_SPEC "%{pipe:-}" |
---|
| 112 | |
---|
| 113 | /* Under svr4, the normal location of the `ld' and `as' programs is the |
---|
| 114 | /usr/ccs/bin directory. */ |
---|
| 115 | |
---|
| 116 | #undef MD_EXEC_PREFIX |
---|
| 117 | #define MD_EXEC_PREFIX "/usr/ccs/bin/" |
---|
| 118 | |
---|
| 119 | /* Under svr4, the normal location of the various *crt*.o files is the |
---|
| 120 | /usr/ccs/lib directory. */ |
---|
| 121 | |
---|
| 122 | #undef MD_STARTFILE_PREFIX |
---|
| 123 | #define MD_STARTFILE_PREFIX "/usr/ccs/lib/" |
---|
| 124 | |
---|
| 125 | /* Provide a LIB_SPEC appropriate for svr4. Here we tack on the default |
---|
| 126 | standard C library (unless we are building a shared library). */ |
---|
| 127 | |
---|
| 128 | #undef LIB_SPEC |
---|
| 129 | #define LIB_SPEC "%{!shared:%{!symbolic:-lc}}" |
---|
| 130 | |
---|
| 131 | /* Provide a LIBGCC_SPEC appropriate for svr4. We also want to exclude |
---|
| 132 | libgcc when -symbolic. */ |
---|
| 133 | |
---|
| 134 | #undef LIBGCC_SPEC |
---|
| 135 | #define LIBGCC_SPEC "%{!shared:%{!symbolic:-lgcc}}" |
---|
| 136 | |
---|
| 137 | /* Provide an ENDFILE_SPEC appropriate for svr4. Here we tack on our own |
---|
| 138 | magical crtend.o file (see crtstuff.c) which provides part of the |
---|
| 139 | support for getting C++ file-scope static object constructed before |
---|
| 140 | entering `main', followed by the normal svr3/svr4 "finalizer" file, |
---|
| 141 | which is either `gcrtn.o' or `crtn.o'. */ |
---|
| 142 | |
---|
| 143 | #undef ENDFILE_SPEC |
---|
| 144 | #define ENDFILE_SPEC "crtend.o%s %{pg:gcrtn.o}%{!pg:crtn.o%s}" |
---|
| 145 | |
---|
| 146 | /* Provide a LINK_SPEC appropriate for svr4. Here we provide support |
---|
| 147 | for the special GCC options -static, -shared, and -symbolic which |
---|
| 148 | allow us to link things in one of these three modes by applying the |
---|
| 149 | appropriate combinations of options at link-time. We also provide |
---|
| 150 | support here for as many of the other svr4 linker options as seems |
---|
| 151 | reasonable, given that some of them conflict with options for other |
---|
| 152 | svr4 tools (e.g. the assembler). In particular, we do support the |
---|
| 153 | -h*, -z*, -V, -b, -t, -Qy, -Qn, and -YP* options here, and the -e*, |
---|
| 154 | -l*, -o*, -r, -s, -u*, and -L* options are directly supported |
---|
| 155 | by gcc.c itself. We don't directly support the -m (generate load |
---|
| 156 | map) option because that conflicts with the -m (run m4) option of |
---|
| 157 | the svr4 assembler. We also don't directly support the svr4 linker's |
---|
| 158 | -I* or -M* options because these conflict with existing GCC options. |
---|
| 159 | We do however allow passing arbitrary options to the svr4 linker |
---|
| 160 | via the -Wl, option. We don't support the svr4 linker's -a option |
---|
| 161 | at all because it is totally useless and because it conflicts with |
---|
| 162 | GCC's own -a option. |
---|
| 163 | |
---|
| 164 | Note that gcc doesn't allow a space to follow -Y in a -YP,* option. |
---|
| 165 | |
---|
| 166 | When the -G link option is used (-shared and -symbolic) a final link is |
---|
| 167 | not being done. */ |
---|
| 168 | |
---|
| 169 | #undef LINK_SPEC |
---|
| 170 | #define LINK_SPEC "%{h*} %{V} %{v:%{!V:-V}} \ |
---|
| 171 | %{b} %{Wl,*:%*} \ |
---|
| 172 | %{static:-dn -Bstatic} \ |
---|
| 173 | %{shared:-G -dy -z text %{!h*:%{o*:-h %*}}} \ |
---|
| 174 | %{symbolic:-Bsymbolic -G -dy -z text %{!h*:%{o*:-h %*}}} \ |
---|
| 175 | %{G:-G} \ |
---|
| 176 | %{YP,*} \ |
---|
| 177 | %{!YP,*:%{p:-Y P,/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \ |
---|
| 178 | %{!p:-Y P,/usr/ccs/lib:/usr/lib}} \ |
---|
| 179 | %{Qy:} %{!Qn:-Qy}" |
---|
| 180 | |
---|
| 181 | /* Gcc automatically adds in one of the files /usr/ccs/lib/values-Xc.o, |
---|
| 182 | /usr/ccs/lib/values-Xa.o, or /usr/ccs/lib/values-Xt.o for each final |
---|
| 183 | link step (depending upon the other gcc options selected, such as |
---|
| 184 | -traditional and -ansi). These files each contain one (initialized) |
---|
| 185 | copy of a special variable called `_lib_version'. Each one of these |
---|
| 186 | files has `_lib_version' initialized to a different (enum) value. |
---|
| 187 | The SVR4 library routines query the value of `_lib_version' at run |
---|
| 188 | to decide how they should behave. Specifically, they decide (based |
---|
| 189 | upon the value of `_lib_version') if they will act in a strictly ANSI |
---|
| 190 | conforming manner or not. |
---|
| 191 | */ |
---|
| 192 | |
---|
| 193 | #undef STARTFILE_SPEC |
---|
| 194 | #define STARTFILE_SPEC "%{!shared: \ |
---|
| 195 | %{!symbolic: \ |
---|
| 196 | %{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}}\ |
---|
| 197 | %{pg:gcrti.o%s}%{!pg:crti.o%s} \ |
---|
| 198 | %{ansi:values-Xc.o%s} \ |
---|
| 199 | %{!ansi: \ |
---|
| 200 | %{traditional:values-Xt.o%s} \ |
---|
| 201 | %{!traditional:values-Xa.o%s}} \ |
---|
| 202 | crtbegin.o%s" |
---|
| 203 | |
---|
| 204 | /* Attach a special .ident directive to the end of the file to identify |
---|
| 205 | the version of GCC which compiled this code. The format of the |
---|
| 206 | .ident string is patterned after the ones produced by native svr4 |
---|
| 207 | C compilers. */ |
---|
| 208 | |
---|
| 209 | #define IDENT_ASM_OP ".ident" |
---|
| 210 | |
---|
| 211 | #define ASM_FILE_END(FILE) \ |
---|
| 212 | do { \ |
---|
| 213 | fprintf ((FILE), "\t%s\t\"GCC: (GNU) %s\"\n", \ |
---|
| 214 | IDENT_ASM_OP, version_string); \ |
---|
| 215 | } while (0) |
---|
| 216 | |
---|
| 217 | /* Allow #sccs in preprocessor. */ |
---|
| 218 | |
---|
| 219 | #define SCCS_DIRECTIVE |
---|
| 220 | |
---|
| 221 | /* Output #ident as a .ident. */ |
---|
| 222 | |
---|
| 223 | #define ASM_OUTPUT_IDENT(FILE, NAME) \ |
---|
| 224 | fprintf (FILE, "\t%s\t\"%s\"\n", IDENT_ASM_OP, NAME); |
---|
| 225 | |
---|
| 226 | /* Use periods rather than dollar signs in special g++ assembler names. */ |
---|
| 227 | |
---|
| 228 | #define NO_DOLLAR_IN_LABEL |
---|
| 229 | |
---|
| 230 | /* Writing `int' for a bitfield forces int alignment for the structure. */ |
---|
| 231 | |
---|
| 232 | #define PCC_BITFIELD_TYPE_MATTERS 1 |
---|
| 233 | |
---|
| 234 | /* Implicit library calls should use memcpy, not bcopy, etc. */ |
---|
| 235 | |
---|
| 236 | #define TARGET_MEM_FUNCTIONS |
---|
| 237 | |
---|
| 238 | /* Handle #pragma weak and #pragma pack. */ |
---|
| 239 | |
---|
| 240 | #define HANDLE_SYSV_PRAGMA |
---|
| 241 | |
---|
| 242 | /* System V Release 4 uses DWARF debugging info. */ |
---|
| 243 | |
---|
| 244 | #define DWARF_DEBUGGING_INFO |
---|
| 245 | |
---|
| 246 | /* The numbers used to denote specific machine registers in the System V |
---|
| 247 | Release 4 DWARF debugging information are quite likely to be totally |
---|
| 248 | different from the numbers used in BSD stabs debugging information |
---|
| 249 | for the same kind of target machine. Thus, we undefine the macro |
---|
| 250 | DBX_REGISTER_NUMBER here as an extra inducement to get people to |
---|
| 251 | provide proper machine-specific definitions of DBX_REGISTER_NUMBER |
---|
| 252 | (which is also used to provide DWARF registers numbers in dwarfout.c) |
---|
| 253 | in their tm.h files which include this file. */ |
---|
| 254 | |
---|
| 255 | #undef DBX_REGISTER_NUMBER |
---|
| 256 | |
---|
| 257 | /* gas on SVR4 supports the use of .stabs. Permit -gstabs to be used |
---|
| 258 | in general, although it will only work when using gas. */ |
---|
| 259 | |
---|
| 260 | #define DBX_DEBUGGING_INFO |
---|
| 261 | |
---|
| 262 | /* Use DWARF debugging info by default. */ |
---|
| 263 | |
---|
| 264 | #ifndef PREFERRED_DEBUGGING_TYPE |
---|
| 265 | #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG |
---|
| 266 | #endif |
---|
| 267 | |
---|
| 268 | /* Make LBRAC and RBRAC addresses relative to the start of the |
---|
| 269 | function. The native Solaris stabs debugging format works this |
---|
| 270 | way, gdb expects it, and it reduces the number of relocation |
---|
| 271 | entries. */ |
---|
| 272 | |
---|
| 273 | #define DBX_BLOCKS_FUNCTION_RELATIVE 1 |
---|
| 274 | |
---|
| 275 | /* When using stabs, gcc2_compiled must be a stabs entry, not an |
---|
| 276 | ordinary symbol, or gdb won't see it. Furthermore, since gdb reads |
---|
| 277 | the input piecemeal, starting with each N_SO, it's a lot easier if |
---|
| 278 | the gcc2 flag symbol is *after* the N_SO rather than before it. So |
---|
| 279 | we emit an N_OPT stab there. */ |
---|
| 280 | |
---|
| 281 | #define ASM_IDENTIFY_GCC(FILE) \ |
---|
| 282 | do \ |
---|
| 283 | { \ |
---|
| 284 | if (write_symbols != DBX_DEBUG) \ |
---|
| 285 | fputs ("gcc2_compiled.:\n", FILE); \ |
---|
| 286 | } \ |
---|
| 287 | while (0) |
---|
| 288 | |
---|
| 289 | #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) \ |
---|
| 290 | do \ |
---|
| 291 | { \ |
---|
| 292 | if (write_symbols == DBX_DEBUG) \ |
---|
| 293 | fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE); \ |
---|
| 294 | } \ |
---|
| 295 | while (0) |
---|
| 296 | |
---|
| 297 | /* Like block addresses, stabs line numbers are relative to the |
---|
| 298 | current function. */ |
---|
| 299 | |
---|
| 300 | #define ASM_OUTPUT_SOURCE_LINE(file, line) \ |
---|
| 301 | do \ |
---|
| 302 | { \ |
---|
| 303 | static int sym_lineno = 1; \ |
---|
| 304 | fprintf (file, ".stabn 68,0,%d,.LM%d-", \ |
---|
| 305 | line, sym_lineno); \ |
---|
| 306 | assemble_name (file, \ |
---|
| 307 | XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\ |
---|
| 308 | fprintf (file, "\n.LM%d:\n", sym_lineno); \ |
---|
| 309 | sym_lineno += 1; \ |
---|
| 310 | } \ |
---|
| 311 | while (0) |
---|
| 312 | |
---|
| 313 | /* In order for relative line numbers to work, we must output the |
---|
| 314 | stabs entry for the function name first. */ |
---|
| 315 | |
---|
| 316 | #define DBX_FUNCTION_FIRST |
---|
| 317 | |
---|
| 318 | /* Generate a blank trailing N_SO to mark the end of the .o file, since |
---|
| 319 | we can't depend upon the linker to mark .o file boundaries with |
---|
| 320 | embedded stabs. */ |
---|
| 321 | |
---|
| 322 | #define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \ |
---|
| 323 | fprintf (FILE, \ |
---|
| 324 | "\t.text\n\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO) |
---|
| 325 | |
---|
| 326 | /* Define the actual types of some ANSI-mandated types. (These |
---|
| 327 | definitions should work for most SVR4 systems). */ |
---|
| 328 | |
---|
| 329 | #undef SIZE_TYPE |
---|
| 330 | #define SIZE_TYPE "unsigned int" |
---|
| 331 | |
---|
| 332 | #undef PTRDIFF_TYPE |
---|
| 333 | #define PTRDIFF_TYPE "int" |
---|
| 334 | |
---|
| 335 | #undef WCHAR_TYPE |
---|
| 336 | #define WCHAR_TYPE "long int" |
---|
| 337 | |
---|
| 338 | #undef WCHAR_TYPE_SIZE |
---|
| 339 | #define WCHAR_TYPE_SIZE BITS_PER_WORD |
---|
| 340 | |
---|
| 341 | /* This causes trouble, because it requires the host machine |
---|
| 342 | to support ANSI C. */ |
---|
| 343 | /* #define MULTIBYTE_CHARS */ |
---|
| 344 | |
---|
| 345 | #undef ASM_BYTE_OP |
---|
| 346 | #define ASM_BYTE_OP ".byte" |
---|
| 347 | |
---|
| 348 | #undef SET_ASM_OP |
---|
| 349 | #define SET_ASM_OP ".set" |
---|
| 350 | |
---|
| 351 | /* This is how to begin an assembly language file. Most svr4 assemblers want |
---|
| 352 | at least a .file directive to come first, and some want to see a .version |
---|
| 353 | directive come right after that. Here we just establish a default |
---|
| 354 | which generates only the .file directive. If you need a .version |
---|
| 355 | directive for any specific target, you should override this definition |
---|
| 356 | in the target-specific file which includes this one. */ |
---|
| 357 | |
---|
| 358 | #undef ASM_FILE_START |
---|
| 359 | #define ASM_FILE_START(FILE) \ |
---|
| 360 | output_file_directive ((FILE), main_input_filename) |
---|
| 361 | |
---|
| 362 | /* This is how to allocate empty space in some section. The .zero |
---|
| 363 | pseudo-op is used for this on most svr4 assemblers. */ |
---|
| 364 | |
---|
| 365 | #define SKIP_ASM_OP ".zero" |
---|
| 366 | |
---|
| 367 | #undef ASM_OUTPUT_SKIP |
---|
| 368 | #define ASM_OUTPUT_SKIP(FILE,SIZE) \ |
---|
| 369 | fprintf (FILE, "\t%s\t%u\n", SKIP_ASM_OP, (SIZE)) |
---|
| 370 | |
---|
| 371 | /* This is how to output a reference to a user-level label named NAME. |
---|
| 372 | `assemble_name' uses this. |
---|
| 373 | |
---|
| 374 | For System V Release 4 the convention is *not* to prepend a leading |
---|
| 375 | underscore onto user-level symbol names. */ |
---|
| 376 | |
---|
| 377 | #undef ASM_OUTPUT_LABELREF |
---|
| 378 | #define ASM_OUTPUT_LABELREF(FILE,NAME) fprintf (FILE, "%s", NAME) |
---|
| 379 | |
---|
| 380 | /* This is how to output an internal numbered label where |
---|
| 381 | PREFIX is the class of label and NUM is the number within the class. |
---|
| 382 | |
---|
| 383 | For most svr4 systems, the convention is that any symbol which begins |
---|
| 384 | with a period is not put into the linker symbol table by the assembler. */ |
---|
| 385 | |
---|
| 386 | #undef ASM_OUTPUT_INTERNAL_LABEL |
---|
| 387 | #define ASM_OUTPUT_INTERNAL_LABEL(FILE, PREFIX, NUM) \ |
---|
| 388 | do { \ |
---|
| 389 | fprintf (FILE, ".%s%d:\n", PREFIX, NUM); \ |
---|
| 390 | } while (0) |
---|
| 391 | |
---|
| 392 | /* This is how to store into the string LABEL |
---|
| 393 | the symbol_ref name of an internal numbered label where |
---|
| 394 | PREFIX is the class of label and NUM is the number within the class. |
---|
| 395 | This is suitable for output with `assemble_name'. |
---|
| 396 | |
---|
| 397 | For most svr4 systems, the convention is that any symbol which begins |
---|
| 398 | with a period is not put into the linker symbol table by the assembler. */ |
---|
| 399 | |
---|
| 400 | #undef ASM_GENERATE_INTERNAL_LABEL |
---|
| 401 | #define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \ |
---|
| 402 | do { \ |
---|
| 403 | sprintf (LABEL, "*.%s%d", PREFIX, NUM); \ |
---|
| 404 | } while (0) |
---|
| 405 | |
---|
| 406 | /* Output the label which precedes a jumptable. Note that for all svr4 |
---|
| 407 | systems where we actually generate jumptables (which is to say every |
---|
| 408 | svr4 target except i386, where we use casesi instead) we put the jump- |
---|
| 409 | tables into the .rodata section and since other stuff could have been |
---|
| 410 | put into the .rodata section prior to any given jumptable, we have to |
---|
| 411 | make sure that the location counter for the .rodata section gets pro- |
---|
| 412 | perly re-aligned prior to the actual beginning of the jump table. */ |
---|
| 413 | |
---|
| 414 | #define ALIGN_ASM_OP ".align" |
---|
| 415 | |
---|
| 416 | #ifndef ASM_OUTPUT_BEFORE_CASE_LABEL |
---|
| 417 | #define ASM_OUTPUT_BEFORE_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \ |
---|
| 418 | ASM_OUTPUT_ALIGN ((FILE), 2); |
---|
| 419 | #endif |
---|
| 420 | |
---|
| 421 | #undef ASM_OUTPUT_CASE_LABEL |
---|
| 422 | #define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,JUMPTABLE) \ |
---|
| 423 | do { \ |
---|
| 424 | ASM_OUTPUT_BEFORE_CASE_LABEL (FILE, PREFIX, NUM, JUMPTABLE) \ |
---|
| 425 | ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM); \ |
---|
| 426 | } while (0) |
---|
| 427 | |
---|
| 428 | /* The standard SVR4 assembler seems to require that certain builtin |
---|
| 429 | library routines (e.g. .udiv) be explicitly declared as .globl |
---|
| 430 | in each assembly file where they are referenced. */ |
---|
| 431 | |
---|
| 432 | #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \ |
---|
| 433 | ASM_GLOBALIZE_LABEL (FILE, XSTR (FUN, 0)) |
---|
| 434 | |
---|
| 435 | /* This says how to output assembler code to declare an |
---|
| 436 | uninitialized external linkage data object. Under SVR4, |
---|
| 437 | the linker seems to want the alignment of data objects |
---|
| 438 | to depend on their types. We do exactly that here. */ |
---|
| 439 | |
---|
| 440 | #define COMMON_ASM_OP ".comm" |
---|
| 441 | |
---|
| 442 | #undef ASM_OUTPUT_ALIGNED_COMMON |
---|
| 443 | #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \ |
---|
| 444 | do { \ |
---|
| 445 | fprintf ((FILE), "\t%s\t", COMMON_ASM_OP); \ |
---|
| 446 | assemble_name ((FILE), (NAME)); \ |
---|
| 447 | fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT); \ |
---|
| 448 | } while (0) |
---|
| 449 | |
---|
| 450 | /* This says how to output assembler code to declare an |
---|
| 451 | uninitialized internal linkage data object. Under SVR4, |
---|
| 452 | the linker seems to want the alignment of data objects |
---|
| 453 | to depend on their types. We do exactly that here. */ |
---|
| 454 | |
---|
| 455 | #define LOCAL_ASM_OP ".local" |
---|
| 456 | |
---|
| 457 | #undef ASM_OUTPUT_ALIGNED_LOCAL |
---|
| 458 | #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \ |
---|
| 459 | do { \ |
---|
| 460 | fprintf ((FILE), "\t%s\t", LOCAL_ASM_OP); \ |
---|
| 461 | assemble_name ((FILE), (NAME)); \ |
---|
| 462 | fprintf ((FILE), "\n"); \ |
---|
| 463 | ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN); \ |
---|
| 464 | } while (0) |
---|
| 465 | |
---|
| 466 | /* This is the pseudo-op used to generate a 32-bit word of data with a |
---|
| 467 | specific value in some section. This is the same for all known svr4 |
---|
| 468 | assemblers. */ |
---|
| 469 | |
---|
| 470 | #define INT_ASM_OP ".long" |
---|
| 471 | |
---|
| 472 | /* This is the pseudo-op used to generate a contiguous sequence of byte |
---|
| 473 | values from a double-quoted string WITHOUT HAVING A TERMINATING NUL |
---|
| 474 | AUTOMATICALLY APPENDED. This is the same for most svr4 assemblers. */ |
---|
| 475 | |
---|
| 476 | #undef ASCII_DATA_ASM_OP |
---|
| 477 | #define ASCII_DATA_ASM_OP ".ascii" |
---|
| 478 | |
---|
| 479 | /* Support const sections and the ctors and dtors sections for g++. |
---|
| 480 | Note that there appears to be two different ways to support const |
---|
| 481 | sections at the moment. You can either #define the symbol |
---|
| 482 | READONLY_DATA_SECTION (giving it some code which switches to the |
---|
| 483 | readonly data section) or else you can #define the symbols |
---|
| 484 | EXTRA_SECTIONS, EXTRA_SECTION_FUNCTIONS, SELECT_SECTION, and |
---|
| 485 | SELECT_RTX_SECTION. We do both here just to be on the safe side. */ |
---|
| 486 | |
---|
| 487 | #define USE_CONST_SECTION 1 |
---|
| 488 | |
---|
| 489 | #define CONST_SECTION_ASM_OP ".section\t.rodata" |
---|
| 490 | |
---|
| 491 | /* Define the pseudo-ops used to switch to the .ctors and .dtors sections. |
---|
| 492 | |
---|
| 493 | Note that we want to give these sections the SHF_WRITE attribute |
---|
| 494 | because these sections will actually contain data (i.e. tables of |
---|
| 495 | addresses of functions in the current root executable or shared library |
---|
| 496 | file) and, in the case of a shared library, the relocatable addresses |
---|
| 497 | will have to be properly resolved/relocated (and then written into) by |
---|
| 498 | the dynamic linker when it actually attaches the given shared library |
---|
| 499 | to the executing process. (Note that on SVR4, you may wish to use the |
---|
| 500 | `-z text' option to the ELF linker, when building a shared library, as |
---|
| 501 | an additional check that you are doing everything right. But if you do |
---|
| 502 | use the `-z text' option when building a shared library, you will get |
---|
| 503 | errors unless the .ctors and .dtors sections are marked as writable |
---|
| 504 | via the SHF_WRITE attribute.) */ |
---|
| 505 | |
---|
| 506 | #define CTORS_SECTION_ASM_OP ".section\t.ctors,\"aw\"" |
---|
| 507 | #define DTORS_SECTION_ASM_OP ".section\t.dtors,\"aw\"" |
---|
| 508 | |
---|
| 509 | /* On svr4, we *do* have support for the .init and .fini sections, and we |
---|
| 510 | can put stuff in there to be executed before and after `main'. We let |
---|
| 511 | crtstuff.c and other files know this by defining the following symbols. |
---|
| 512 | The definitions say how to change sections to the .init and .fini |
---|
| 513 | sections. This is the same for all known svr4 assemblers. */ |
---|
| 514 | |
---|
| 515 | #define INIT_SECTION_ASM_OP ".section\t.init" |
---|
| 516 | #define FINI_SECTION_ASM_OP ".section\t.fini" |
---|
| 517 | |
---|
| 518 | /* A default list of other sections which we might be "in" at any given |
---|
| 519 | time. For targets that use additional sections (e.g. .tdesc) you |
---|
| 520 | should override this definition in the target-specific file which |
---|
| 521 | includes this file. */ |
---|
| 522 | |
---|
| 523 | #undef EXTRA_SECTIONS |
---|
| 524 | #define EXTRA_SECTIONS in_const, in_ctors, in_dtors |
---|
| 525 | |
---|
| 526 | /* A default list of extra section function definitions. For targets |
---|
| 527 | that use additional sections (e.g. .tdesc) you should override this |
---|
| 528 | definition in the target-specific file which includes this file. */ |
---|
| 529 | |
---|
| 530 | #undef EXTRA_SECTION_FUNCTIONS |
---|
| 531 | #define EXTRA_SECTION_FUNCTIONS \ |
---|
| 532 | CONST_SECTION_FUNCTION \ |
---|
| 533 | CTORS_SECTION_FUNCTION \ |
---|
| 534 | DTORS_SECTION_FUNCTION |
---|
| 535 | |
---|
| 536 | #define READONLY_DATA_SECTION() const_section () |
---|
| 537 | |
---|
| 538 | extern void text_section (); |
---|
| 539 | |
---|
| 540 | #define CONST_SECTION_FUNCTION \ |
---|
| 541 | void \ |
---|
| 542 | const_section () \ |
---|
| 543 | { \ |
---|
| 544 | if (!USE_CONST_SECTION) \ |
---|
| 545 | text_section(); \ |
---|
| 546 | else if (in_section != in_const) \ |
---|
| 547 | { \ |
---|
| 548 | fprintf (asm_out_file, "%s\n", CONST_SECTION_ASM_OP); \ |
---|
| 549 | in_section = in_const; \ |
---|
| 550 | } \ |
---|
| 551 | } |
---|
| 552 | |
---|
| 553 | #define CTORS_SECTION_FUNCTION \ |
---|
| 554 | void \ |
---|
| 555 | ctors_section () \ |
---|
| 556 | { \ |
---|
| 557 | if (in_section != in_ctors) \ |
---|
| 558 | { \ |
---|
| 559 | fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP); \ |
---|
| 560 | in_section = in_ctors; \ |
---|
| 561 | } \ |
---|
| 562 | } |
---|
| 563 | |
---|
| 564 | #define DTORS_SECTION_FUNCTION \ |
---|
| 565 | void \ |
---|
| 566 | dtors_section () \ |
---|
| 567 | { \ |
---|
| 568 | if (in_section != in_dtors) \ |
---|
| 569 | { \ |
---|
| 570 | fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP); \ |
---|
| 571 | in_section = in_dtors; \ |
---|
| 572 | } \ |
---|
| 573 | } |
---|
| 574 | |
---|
| 575 | /* Switch into a generic section. |
---|
| 576 | This is currently only used to support section attributes. |
---|
| 577 | |
---|
| 578 | We make the section read-only and executable for a function decl, |
---|
| 579 | read-only for a const data decl, and writable for a non-const data decl. */ |
---|
| 580 | #define ASM_OUTPUT_SECTION_NAME(FILE, DECL, NAME) \ |
---|
| 581 | fprintf (FILE, ".section\t%s,\"%s\",@progbits\n", NAME, \ |
---|
| 582 | (DECL) && TREE_CODE (DECL) == FUNCTION_DECL ? "ax" : \ |
---|
| 583 | (DECL) && TREE_READONLY (DECL) ? "a" : "aw") |
---|
| 584 | |
---|
| 585 | |
---|
| 586 | /* A C statement (sans semicolon) to output an element in the table of |
---|
| 587 | global constructors. */ |
---|
| 588 | #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ |
---|
| 589 | do { \ |
---|
| 590 | ctors_section (); \ |
---|
| 591 | fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ |
---|
| 592 | assemble_name (FILE, NAME); \ |
---|
| 593 | fprintf (FILE, "\n"); \ |
---|
| 594 | } while (0) |
---|
| 595 | |
---|
| 596 | /* A C statement (sans semicolon) to output an element in the table of |
---|
| 597 | global destructors. */ |
---|
| 598 | #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ |
---|
| 599 | do { \ |
---|
| 600 | dtors_section (); \ |
---|
| 601 | fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ |
---|
| 602 | assemble_name (FILE, NAME); \ |
---|
| 603 | fprintf (FILE, "\n"); \ |
---|
| 604 | } while (0) |
---|
| 605 | |
---|
| 606 | /* A C statement or statements to switch to the appropriate |
---|
| 607 | section for output of DECL. DECL is either a `VAR_DECL' node |
---|
| 608 | or a constant of some sort. RELOC indicates whether forming |
---|
| 609 | the initial value of DECL requires link-time relocations. */ |
---|
| 610 | |
---|
| 611 | #define SELECT_SECTION(DECL,RELOC) \ |
---|
| 612 | { \ |
---|
| 613 | if (TREE_CODE (DECL) == STRING_CST) \ |
---|
| 614 | { \ |
---|
| 615 | if (! flag_writable_strings) \ |
---|
| 616 | const_section (); \ |
---|
| 617 | else \ |
---|
| 618 | data_section (); \ |
---|
| 619 | } \ |
---|
| 620 | else if (TREE_CODE (DECL) == VAR_DECL) \ |
---|
| 621 | { \ |
---|
| 622 | if ((flag_pic && RELOC) \ |
---|
| 623 | || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL) \ |
---|
| 624 | || !DECL_INITIAL (DECL) \ |
---|
| 625 | || (DECL_INITIAL (DECL) != error_mark_node \ |
---|
| 626 | && !TREE_CONSTANT (DECL_INITIAL (DECL)))) \ |
---|
| 627 | data_section (); \ |
---|
| 628 | else \ |
---|
| 629 | const_section (); \ |
---|
| 630 | } \ |
---|
| 631 | else \ |
---|
| 632 | const_section (); \ |
---|
| 633 | } |
---|
| 634 | |
---|
| 635 | /* A C statement or statements to switch to the appropriate |
---|
| 636 | section for output of RTX in mode MODE. RTX is some kind |
---|
| 637 | of constant in RTL. The argument MODE is redundant except |
---|
| 638 | in the case of a `const_int' rtx. Currently, these always |
---|
| 639 | go into the const section. */ |
---|
| 640 | |
---|
| 641 | #undef SELECT_RTX_SECTION |
---|
| 642 | #define SELECT_RTX_SECTION(MODE,RTX) const_section() |
---|
| 643 | |
---|
| 644 | /* Define the strings used for the special svr4 .type and .size directives. |
---|
| 645 | These strings generally do not vary from one system running svr4 to |
---|
| 646 | another, but if a given system (e.g. m88k running svr) needs to use |
---|
| 647 | different pseudo-op names for these, they may be overridden in the |
---|
| 648 | file which includes this one. */ |
---|
| 649 | |
---|
| 650 | #define TYPE_ASM_OP ".type" |
---|
| 651 | #define SIZE_ASM_OP ".size" |
---|
| 652 | |
---|
| 653 | /* This is how we tell the assembler that a symbol is weak. */ |
---|
| 654 | |
---|
| 655 | #define ASM_WEAKEN_LABEL(FILE,NAME) \ |
---|
| 656 | do { fputs ("\t.weak\t", FILE); assemble_name (FILE, NAME); \ |
---|
| 657 | fputc ('\n', FILE); } while (0) |
---|
| 658 | |
---|
| 659 | /* The following macro defines the format used to output the second |
---|
| 660 | operand of the .type assembler directive. Different svr4 assemblers |
---|
| 661 | expect various different forms for this operand. The one given here |
---|
| 662 | is just a default. You may need to override it in your machine- |
---|
| 663 | specific tm.h file (depending upon the particulars of your assembler). */ |
---|
| 664 | |
---|
| 665 | #define TYPE_OPERAND_FMT "@%s" |
---|
| 666 | |
---|
| 667 | /* Write the extra assembler code needed to declare a function's result. |
---|
| 668 | Most svr4 assemblers don't require any special declaration of the |
---|
| 669 | result value, but there are exceptions. */ |
---|
| 670 | |
---|
| 671 | #ifndef ASM_DECLARE_RESULT |
---|
| 672 | #define ASM_DECLARE_RESULT(FILE, RESULT) |
---|
| 673 | #endif |
---|
| 674 | |
---|
| 675 | /* These macros generate the special .type and .size directives which |
---|
| 676 | are used to set the corresponding fields of the linker symbol table |
---|
| 677 | entries in an ELF object file under SVR4. These macros also output |
---|
| 678 | the starting labels for the relevant functions/objects. */ |
---|
| 679 | |
---|
| 680 | /* Write the extra assembler code needed to declare a function properly. |
---|
| 681 | Some svr4 assemblers need to also have something extra said about the |
---|
| 682 | function's return value. We allow for that here. */ |
---|
| 683 | |
---|
| 684 | #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ |
---|
| 685 | do { \ |
---|
| 686 | fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ |
---|
| 687 | assemble_name (FILE, NAME); \ |
---|
| 688 | putc (',', FILE); \ |
---|
| 689 | fprintf (FILE, TYPE_OPERAND_FMT, "function"); \ |
---|
| 690 | putc ('\n', FILE); \ |
---|
| 691 | ASM_DECLARE_RESULT (FILE, DECL_RESULT (DECL)); \ |
---|
| 692 | ASM_OUTPUT_LABEL(FILE, NAME); \ |
---|
| 693 | } while (0) |
---|
| 694 | |
---|
| 695 | /* Write the extra assembler code needed to declare an object properly. */ |
---|
| 696 | |
---|
| 697 | #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ |
---|
| 698 | do { \ |
---|
| 699 | fprintf (FILE, "\t%s\t ", TYPE_ASM_OP); \ |
---|
| 700 | assemble_name (FILE, NAME); \ |
---|
| 701 | putc (',', FILE); \ |
---|
| 702 | fprintf (FILE, TYPE_OPERAND_FMT, "object"); \ |
---|
| 703 | putc ('\n', FILE); \ |
---|
| 704 | size_directive_output = 0; \ |
---|
| 705 | if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \ |
---|
| 706 | { \ |
---|
| 707 | size_directive_output = 1; \ |
---|
| 708 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
| 709 | assemble_name (FILE, NAME); \ |
---|
| 710 | fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ |
---|
| 711 | } \ |
---|
| 712 | ASM_OUTPUT_LABEL(FILE, NAME); \ |
---|
| 713 | } while (0) |
---|
| 714 | |
---|
| 715 | /* Output the size directive for a decl in rest_of_decl_compilation |
---|
| 716 | in the case where we did not do so before the initializer. |
---|
| 717 | Once we find the error_mark_node, we know that the value of |
---|
| 718 | size_directive_output was set |
---|
| 719 | by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ |
---|
| 720 | |
---|
| 721 | #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ |
---|
| 722 | do { \ |
---|
| 723 | char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ |
---|
| 724 | if (!flag_inhibit_size_directive && DECL_SIZE (DECL) \ |
---|
| 725 | && ! AT_END && TOP_LEVEL \ |
---|
| 726 | && DECL_INITIAL (DECL) == error_mark_node \ |
---|
| 727 | && !size_directive_output) \ |
---|
| 728 | { \ |
---|
| 729 | size_directive_output = 1; \ |
---|
| 730 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
| 731 | assemble_name (FILE, name); \ |
---|
| 732 | fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ |
---|
| 733 | } \ |
---|
| 734 | } while (0) |
---|
| 735 | |
---|
| 736 | /* This is how to declare the size of a function. */ |
---|
| 737 | |
---|
| 738 | #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ |
---|
| 739 | do { \ |
---|
| 740 | if (!flag_inhibit_size_directive) \ |
---|
| 741 | { \ |
---|
| 742 | char label[256]; \ |
---|
| 743 | static int labelno; \ |
---|
| 744 | labelno++; \ |
---|
| 745 | ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ |
---|
| 746 | ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ |
---|
| 747 | fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ |
---|
| 748 | assemble_name (FILE, (FNAME)); \ |
---|
| 749 | fprintf (FILE, ","); \ |
---|
| 750 | assemble_name (FILE, label); \ |
---|
| 751 | fprintf (FILE, "-"); \ |
---|
| 752 | assemble_name (FILE, (FNAME)); \ |
---|
| 753 | putc ('\n', FILE); \ |
---|
| 754 | } \ |
---|
| 755 | } while (0) |
---|
| 756 | |
---|
| 757 | /* A table of bytes codes used by the ASM_OUTPUT_ASCII and |
---|
| 758 | ASM_OUTPUT_LIMITED_STRING macros. Each byte in the table |
---|
| 759 | corresponds to a particular byte value [0..255]. For any |
---|
| 760 | given byte value, if the value in the corresponding table |
---|
| 761 | position is zero, the given character can be output directly. |
---|
| 762 | If the table value is 1, the byte must be output as a \ooo |
---|
| 763 | octal escape. If the tables value is anything else, then the |
---|
| 764 | byte value should be output as a \ followed by the value |
---|
| 765 | in the table. Note that we can use standard UN*X escape |
---|
| 766 | sequences for many control characters, but we don't use |
---|
| 767 | \a to represent BEL because some svr4 assemblers (e.g. on |
---|
| 768 | the i386) don't know about that. Also, we don't use \v |
---|
| 769 | since some versions of gas, such as 2.2 did not accept it. */ |
---|
| 770 | |
---|
| 771 | #define ESCAPES \ |
---|
| 772 | "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
| 773 | \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ |
---|
| 774 | \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\ |
---|
| 775 | \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\1\ |
---|
| 776 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
| 777 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
| 778 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ |
---|
| 779 | \1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1" |
---|
| 780 | |
---|
| 781 | /* Some svr4 assemblers have a limit on the number of characters which |
---|
| 782 | can appear in the operand of a .string directive. If your assembler |
---|
| 783 | has such a limitation, you should define STRING_LIMIT to reflect that |
---|
| 784 | limit. Note that at least some svr4 assemblers have a limit on the |
---|
| 785 | actual number of bytes in the double-quoted string, and that they |
---|
| 786 | count each character in an escape sequence as one byte. Thus, an |
---|
| 787 | escape sequence like \377 would count as four bytes. |
---|
| 788 | |
---|
| 789 | If your target assembler doesn't support the .string directive, you |
---|
| 790 | should define this to zero. |
---|
| 791 | */ |
---|
| 792 | |
---|
| 793 | #define STRING_LIMIT ((unsigned) 256) |
---|
| 794 | |
---|
| 795 | #define STRING_ASM_OP ".string" |
---|
| 796 | |
---|
| 797 | /* The routine used to output NUL terminated strings. We use a special |
---|
| 798 | version of this for most svr4 targets because doing so makes the |
---|
| 799 | generated assembly code more compact (and thus faster to assemble) |
---|
| 800 | as well as more readable, especially for targets like the i386 |
---|
| 801 | (where the only alternative is to output character sequences as |
---|
| 802 | comma separated lists of numbers). */ |
---|
| 803 | |
---|
| 804 | #define ASM_OUTPUT_LIMITED_STRING(FILE, STR) \ |
---|
| 805 | do \ |
---|
| 806 | { \ |
---|
| 807 | register unsigned char *_limited_str = (unsigned char *) (STR); \ |
---|
| 808 | register unsigned ch; \ |
---|
| 809 | fprintf ((FILE), "\t%s\t\"", STRING_ASM_OP); \ |
---|
| 810 | for (; ch = *_limited_str; _limited_str++) \ |
---|
| 811 | { \ |
---|
| 812 | register int escape; \ |
---|
| 813 | switch (escape = ESCAPES[ch]) \ |
---|
| 814 | { \ |
---|
| 815 | case 0: \ |
---|
| 816 | putc (ch, (FILE)); \ |
---|
| 817 | break; \ |
---|
| 818 | case 1: \ |
---|
| 819 | fprintf ((FILE), "\\%03o", ch); \ |
---|
| 820 | break; \ |
---|
| 821 | default: \ |
---|
| 822 | putc ('\\', (FILE)); \ |
---|
| 823 | putc (escape, (FILE)); \ |
---|
| 824 | break; \ |
---|
| 825 | } \ |
---|
| 826 | } \ |
---|
| 827 | fprintf ((FILE), "\"\n"); \ |
---|
| 828 | } \ |
---|
| 829 | while (0) |
---|
| 830 | |
---|
| 831 | /* The routine used to output sequences of byte values. We use a special |
---|
| 832 | version of this for most svr4 targets because doing so makes the |
---|
| 833 | generated assembly code more compact (and thus faster to assemble) |
---|
| 834 | as well as more readable. Note that if we find subparts of the |
---|
| 835 | character sequence which end with NUL (and which are shorter than |
---|
| 836 | STRING_LIMIT) we output those using ASM_OUTPUT_LIMITED_STRING. */ |
---|
| 837 | |
---|
| 838 | #undef ASM_OUTPUT_ASCII |
---|
| 839 | #define ASM_OUTPUT_ASCII(FILE, STR, LENGTH) \ |
---|
| 840 | do \ |
---|
| 841 | { \ |
---|
| 842 | register unsigned char *_ascii_bytes = (unsigned char *) (STR); \ |
---|
| 843 | register unsigned char *limit = _ascii_bytes + (LENGTH); \ |
---|
| 844 | register unsigned bytes_in_chunk = 0; \ |
---|
| 845 | for (; _ascii_bytes < limit; _ascii_bytes++) \ |
---|
| 846 | { \ |
---|
| 847 | register unsigned char *p; \ |
---|
| 848 | if (bytes_in_chunk >= 60) \ |
---|
| 849 | { \ |
---|
| 850 | fprintf ((FILE), "\"\n"); \ |
---|
| 851 | bytes_in_chunk = 0; \ |
---|
| 852 | } \ |
---|
| 853 | for (p = _ascii_bytes; p < limit && *p != '\0'; p++) \ |
---|
| 854 | continue; \ |
---|
| 855 | if (p < limit && (p - _ascii_bytes) <= STRING_LIMIT) \ |
---|
| 856 | { \ |
---|
| 857 | if (bytes_in_chunk > 0) \ |
---|
| 858 | { \ |
---|
| 859 | fprintf ((FILE), "\"\n"); \ |
---|
| 860 | bytes_in_chunk = 0; \ |
---|
| 861 | } \ |
---|
| 862 | ASM_OUTPUT_LIMITED_STRING ((FILE), _ascii_bytes); \ |
---|
| 863 | _ascii_bytes = p; \ |
---|
| 864 | } \ |
---|
| 865 | else \ |
---|
| 866 | { \ |
---|
| 867 | register int escape; \ |
---|
| 868 | register unsigned ch; \ |
---|
| 869 | if (bytes_in_chunk == 0) \ |
---|
| 870 | fprintf ((FILE), "\t%s\t\"", ASCII_DATA_ASM_OP); \ |
---|
| 871 | switch (escape = ESCAPES[ch = *_ascii_bytes]) \ |
---|
| 872 | { \ |
---|
| 873 | case 0: \ |
---|
| 874 | putc (ch, (FILE)); \ |
---|
| 875 | bytes_in_chunk++; \ |
---|
| 876 | break; \ |
---|
| 877 | case 1: \ |
---|
| 878 | fprintf ((FILE), "\\%03o", ch); \ |
---|
| 879 | bytes_in_chunk += 4; \ |
---|
| 880 | break; \ |
---|
| 881 | default: \ |
---|
| 882 | putc ('\\', (FILE)); \ |
---|
| 883 | putc (escape, (FILE)); \ |
---|
| 884 | bytes_in_chunk += 2; \ |
---|
| 885 | break; \ |
---|
| 886 | } \ |
---|
| 887 | } \ |
---|
| 888 | } \ |
---|
| 889 | if (bytes_in_chunk > 0) \ |
---|
| 890 | fprintf ((FILE), "\"\n"); \ |
---|
| 891 | } \ |
---|
| 892 | while (0) |
---|
| 893 | |
---|
| 894 | /* All SVR4 targets use the ELF object file format. */ |
---|
| 895 | #define OBJECT_FORMAT_ELF |
---|