![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to osfrose.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc / config / i386|
Return to osfrose.h CVS log | Up to [Apple XNU] / GNUtools / cc / config / i386 |
1.1 ! root 1: /* Definitions of target machine for GNU compiler. ! 2: Intel 386 (OSF/1 with OSF/rose) version. ! 3: Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. ! 4: ! 5: This file is part of GNU CC. ! 6: ! 7: GNU CC 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) ! 10: any later version. ! 11: ! 12: GNU CC 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. ! 16: ! 17: You should have received a copy of the GNU General Public License ! 18: along with GNU CC; see the file COPYING. If not, write to ! 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 20: ! 21: #include "halfpic.h" ! 22: #include "i386/gstabs.h" ! 23: ! 24: /* Get perform_* macros to build libgcc.a. */ ! 25: #include "i386/perform.h" ! 26: ! 27: #define OSF_OS ! 28: ! 29: #undef WORD_SWITCH_TAKES_ARG ! 30: #define WORD_SWITCH_TAKES_ARG(STR) \ ! 31: (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) || !strcmp (STR, "pic-names")) ! 32: ! 33: /* This defines which switch letters take arguments. On svr4, most of ! 34: the normal cases (defined in gcc.c) apply, and we also have -h* and ! 35: -z* options (for the linker). */ ! 36: ! 37: #define SWITCH_TAKES_ARG(CHAR) \ ! 38: ( (CHAR) == 'D' \ ! 39: || (CHAR) == 'U' \ ! 40: || (CHAR) == 'o' \ ! 41: || (CHAR) == 'e' \ ! 42: || (CHAR) == 'T' \ ! 43: || (CHAR) == 'u' \ ! 44: || (CHAR) == 'I' \ ! 45: || (CHAR) == 'm' \ ! 46: || (CHAR) == 'L' \ ! 47: || (CHAR) == 'A' \ ! 48: || (CHAR) == 'h' \ ! 49: || (CHAR) == 'z') ! 50: ! 51: #define MASK_HALF_PIC 0x40000000 /* Mask for half-pic code */ ! 52: #define MASK_HALF_PIC_DEBUG 0x20000000 /* Debug flag */ ! 53: #define MASK_ELF 0x10000000 /* ELF not rose */ ! 54: #define MASK_NO_IDENT 0x08000000 /* suppress .ident */ ! 55: #define MASK_NO_UNDERSCORES 0x04000000 /* suppress leading _ */ ! 56: #define MASK_LARGE_ALIGN 0x02000000 /* align to >word boundaries */ ! 57: #define MASK_NO_MCOUNT 0x01000000 /* profiling uses mcount_ptr */ ! 58: ! 59: #define TARGET_HALF_PIC (target_flags & MASK_HALF_PIC) ! 60: #define TARGET_DEBUG (target_flags & MASK_HALF_PIC_DEBUG) ! 61: #define HALF_PIC_DEBUG TARGET_DEBUG ! 62: #define TARGET_ELF (target_flags & MASK_ELF) ! 63: #define TARGET_ROSE ((target_flags & MASK_ELF) == 0) ! 64: #define TARGET_IDENT ((target_flags & MASK_NO_IDENT) == 0) ! 65: #define TARGET_UNDERSCORES ((target_flags & MASK_NO_UNDERSCORES) == 0) ! 66: #define TARGET_LARGE_ALIGN (target_flags & MASK_LARGE_ALIGN) ! 67: #define TARGET_MCOUNT ((target_flags & MASK_NO_MCOUNT) == 0) ! 68: ! 69: #undef SUBTARGET_SWITCHES ! 70: #define SUBTARGET_SWITCHES \ ! 71: { "half-pic", MASK_HALF_PIC}, \ ! 72: { "no-half-pic", -MASK_HALF_PIC}, \ ! 73: { "debug-half-pic", MASK_HALF_PIC_DEBUG}, \ ! 74: { "debugb", MASK_HALF_PIC_DEBUG}, \ ! 75: { "elf", MASK_ELF}, \ ! 76: { "rose", -MASK_ELF}, \ ! 77: { "ident", -MASK_NO_IDENT}, \ ! 78: { "no-ident", MASK_NO_IDENT}, \ ! 79: { "underscores", -MASK_NO_UNDERSCORES}, \ ! 80: { "no-underscores", MASK_NO_UNDERSCORES}, \ ! 81: { "large-align", MASK_LARGE_ALIGN}, \ ! 82: { "no-large-align",-MASK_LARGE_ALIGN}, \ ! 83: { "mcount", -MASK_NO_MCOUNT}, \ ! 84: { "no-mcount", MASK_NO_MCOUNT}, ! 85: ! 86: /* OSF/rose uses stabs, not dwarf. */ ! 87: #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG ! 88: ! 89: #ifndef DWARF_DEBUGGING_INFO ! 90: #define DWARF_DEBUGGING_INFO /* enable dwarf debugging for testing */ ! 91: #endif ! 92: ! 93: /* Handle #pragma weak and #pragma pack. */ ! 94: ! 95: #define HANDLE_SYSV_PRAGMA ! 96: ! 97: /* Change default predefines. */ ! 98: #undef CPP_PREDEFINES ! 99: #define CPP_PREDEFINES "-DOSF -DOSF1 -Dunix -Di386 -Asystem(unix) -Asystem(xpg4) -Acpu(i386) -Amachine(i386)" ! 100: ! 101: #undef CPP_SPEC ! 102: #define CPP_SPEC "\ ! 103: %{!melf: -D__ROSE__ %{!pic-none: -D__SHARED__}} \ ! 104: %{melf: -D__ELF__ %{fpic: -D__SHARED__}} \ ! 105: %{mno-underscores: -D__NO_UNDERSCORES__} \ ! 106: %{melf: %{!munderscores: -D__NO_UNDERSCORES__}} \ ! 107: %{.S: %{!ansi:%{!traditional:%{!traditional-cpp:%{!ftraditional: -traditional}}}}} \ ! 108: %{.S: -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \ ! 109: %{.cc: -D__LANGUAGE_C_PLUS_PLUS} \ ! 110: %{.cxx: -D__LANGUAGE_C_PLUS_PLUS} \ ! 111: %{.C: -D__LANGUAGE_C_PLUS_PLUS} \ ! 112: %{.m: -D__LANGUAGE_OBJECTIVE_C} \ ! 113: %{!.S: -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C}}" ! 114: ! 115: /* Turn on -pic-extern by default. */ ! 116: #undef CC1_SPEC ! 117: #define CC1_SPEC "\ ! 118: %{!melf: %{!mrose: -mrose }} \ ! 119: %{melf: %{!munderscores: %{!mno-underscores: -mno-underscores }}} \ ! 120: %{gline:%{!g:%{!g0:%{!g1:%{!g2: -g1}}}}} \ ! 121: %{!melf: %{pic-none: -mno-half-pic} \ ! 122: %{pic-extern: } %{pic-lib: } %{pic-calls: } %{pic-names*: } \ ! 123: %{!pic-none: -mhalf-pic }}" ! 124: ! 125: #undef ASM_SPEC ! 126: #define ASM_SPEC "%{v*: -v}" ! 127: ! 128: #undef LINK_SPEC ! 129: #define LINK_SPEC "%{v*: -v} \ ! 130: %{!melf: %{!noshrlib: %{pic-none: -noshrlib} %{!pic-none: -warn_nopic}} \ ! 131: %{nostdlib} %{noshrlib} %{glue}} \ ! 132: %{melf: %{dy} %{dn} %{glue: } \ ! 133: %{h*} %{z*} \ ! 134: %{static:-dn -Bstatic} \ ! 135: %{shared:-G -dy} \ ! 136: %{symbolic:-Bsymbolic -G -dy} \ ! 137: %{G:-G} \ ! 138: %{!dy: %{!dn: %{!static: %{!shared: %{!symbolic: \ ! 139: %{noshrlib: -dn } %{pic-none: -dn } \ ! 140: %{!noshrlib: %{!pic-none: -dy}}}}}}}}" ! 141: ! 142: #undef LIB_SPEC ! 143: #define LIB_SPEC "-lc" ! 144: ! 145: #undef LIBG_SPEC ! 146: #define LIBG_SPEC "" ! 147: ! 148: #undef STARTFILE_SPEC ! 149: #define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}" ! 150: ! 151: #undef TARGET_VERSION_INTERNAL ! 152: #undef TARGET_VERSION ! 153: ! 154: #define I386_VERSION " 80386, OSF/rose objects" ! 155: ! 156: #define TARGET_VERSION_INTERNAL(STREAM) fputs (I386_VERSION, STREAM) ! 157: #define TARGET_VERSION TARGET_VERSION_INTERNAL (stderr) ! 158: ! 159: #undef MD_EXEC_PREFIX ! 160: #define MD_EXEC_PREFIX "/usr/ccs/gcc/" ! 161: ! 162: #undef MD_STARTFILE_PREFIX ! 163: #define MD_STARTFILE_PREFIX "/usr/ccs/lib/" ! 164: ! 165: /* Specify size_t, ptrdiff_t, and wchar_t types. */ ! 166: #undef SIZE_TYPE ! 167: #undef PTRDIFF_TYPE ! 168: #undef WCHAR_TYPE ! 169: #undef WCHAR_TYPE_SIZE ! 170: ! 171: #define SIZE_TYPE "long unsigned int" ! 172: #define PTRDIFF_TYPE "int" ! 173: #define WCHAR_TYPE "unsigned int" ! 174: #define WCHAR_TYPE_SIZE BITS_PER_WORD ! 175: ! 176: /* Temporarily turn off long double being 96 bits. */ ! 177: #undef LONG_DOUBLE_TYPE_SIZE ! 178: ! 179: /* This macro generates the assembly code for function entry. ! 180: FILE is a stdio stream to output the code to. ! 181: SIZE is an int: how many units of temporary storage to allocate. ! 182: Refer to the array `regs_ever_live' to determine which registers ! 183: to save; `regs_ever_live[I]' is nonzero if register number I ! 184: is ever used in the function. This macro is responsible for ! 185: knowing which registers should not be saved even if used. ! 186: ! 187: We override it here to allow for the new profiling code to go before ! 188: the prologue and the old mcount code to go after the prologue (and ! 189: after %ebx has been set up for ELF shared library support). */ ! 190: ! 191: #define OSF_PROFILE_BEFORE_PROLOGUE \ ! 192: (!TARGET_MCOUNT \ ! 193: && !current_function_needs_context \ ! 194: && (!flag_pic \ ! 195: || !frame_pointer_needed \ ! 196: || (!current_function_uses_pic_offset_table \ ! 197: && !current_function_uses_const_pool))) ! 198: ! 199: #undef FUNCTION_PROLOGUE ! 200: #define FUNCTION_PROLOGUE(FILE, SIZE) \ ! 201: do \ ! 202: { \ ! 203: char *prefix = (TARGET_UNDERSCORES) ? "_" : ""; \ ! 204: char *lprefix = LPREFIX; \ ! 205: int labelno = profile_label_no; \ ! 206: \ ! 207: if (profile_flag && OSF_PROFILE_BEFORE_PROLOGUE) \ ! 208: { \ ! 209: if (!flag_pic && !HALF_PIC_P ()) \ ! 210: { \ ! 211: fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \ ! 212: fprintf (FILE, "\tcall *%s_mcount_ptr\n", prefix); \ ! 213: } \ ! 214: \ ! 215: else if (HALF_PIC_P ()) \ ! 216: { \ ! 217: rtx symref; \ ! 218: \ ! 219: HALF_PIC_EXTERNAL ("_mcount_ptr"); \ ! 220: symref = HALF_PIC_PTR (gen_rtx (SYMBOL_REF, Pmode, \ ! 221: "_mcount_ptr")); \ ! 222: \ ! 223: fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \ ! 224: fprintf (FILE, "\tmovl %s%s,%%eax\n", prefix, \ ! 225: XSTR (symref, 0)); \ ! 226: fprintf (FILE, "\tcall *(%%eax)\n"); \ ! 227: } \ ! 228: \ ! 229: else \ ! 230: { \ ! 231: static int call_no = 0; \ ! 232: \ ! 233: fprintf (FILE, "\tcall %sPc%d\n", lprefix, call_no); \ ! 234: fprintf (FILE, "%sPc%d:\tpopl %%eax\n", lprefix, call_no); \ ! 235: fprintf (FILE, "\taddl $_GLOBAL_OFFSET_TABLE_+[.-%sPc%d],%%eax\n", \ ! 236: lprefix, call_no++); \ ! 237: fprintf (FILE, "\tleal $%sP%d@GOTOFF(%%eax),%%edx\n", \ ! 238: lprefix, labelno); \ ! 239: fprintf (FILE, "\tmovl %s_mcount_ptr@GOT(%%eax),%%eax\n", \ ! 240: prefix); \ ! 241: fprintf (FILE, "\tcall *(%%eax)\n"); \ ! 242: } \ ! 243: } \ ! 244: \ ! 245: function_prologue (FILE, SIZE); \ ! 246: } \ ! 247: while (0) ! 248: ! 249: /* A C statement or compound statement to output to FILE some assembler code to ! 250: call the profiling subroutine `mcount'. Before calling, the assembler code ! 251: must load the address of a counter variable into a register where `mcount' ! 252: expects to find the address. The name of this variable is `LP' followed by ! 253: the number LABELNO, so you would generate the name using `LP%d' in a ! 254: `fprintf'. ! 255: ! 256: The details of how the address should be passed to `mcount' are determined ! 257: by your operating system environment, not by GNU CC. To figure them out, ! 258: compile a small program for profiling using the system's installed C ! 259: compiler and look at the assembler code that results. */ ! 260: ! 261: #undef FUNCTION_PROFILER ! 262: #define FUNCTION_PROFILER(FILE, LABELNO) \ ! 263: do \ ! 264: { \ ! 265: if (!OSF_PROFILE_BEFORE_PROLOGUE) \ ! 266: { \ ! 267: char *prefix = (TARGET_UNDERSCORES) ? "_" : ""; \ ! 268: char *lprefix = LPREFIX; \ ! 269: int labelno = LABELNO; \ ! 270: \ ! 271: /* Note that OSF/rose blew it in terms of calling mcount, \ ! 272: since OSF/rose prepends a leading underscore, but mcount's \ ! 273: doesn't. At present, we keep this kludge for ELF as well \ ! 274: to allow old kernels to build profiling. */ \ ! 275: \ ! 276: if (flag_pic \ ! 277: && !current_function_uses_pic_offset_table \ ! 278: && !current_function_uses_const_pool) \ ! 279: abort (); \ ! 280: \ ! 281: if (TARGET_MCOUNT && flag_pic) \ ! 282: { \ ! 283: fprintf (FILE, "\tleal %sP%d@GOTOFF(%%ebx),%%edx\n", \ ! 284: lprefix, labelno); \ ! 285: fprintf (FILE, "\tcall *%smcount@GOT(%%ebx)\n", prefix); \ ! 286: } \ ! 287: \ ! 288: else if (TARGET_MCOUNT && HALF_PIC_P ()) \ ! 289: { \ ! 290: rtx symdef; \ ! 291: \ ! 292: HALF_PIC_EXTERNAL ("mcount"); \ ! 293: symdef = HALF_PIC_PTR (gen_rtx (SYMBOL_REF, Pmode, "mcount")); \ ! 294: fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \ ! 295: fprintf (FILE, "\tcall *%s%s\n", prefix, XSTR (symdef, 0)); \ ! 296: } \ ! 297: \ ! 298: else if (TARGET_MCOUNT) \ ! 299: { \ ! 300: fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \ ! 301: fprintf (FILE, "\tcall %smcount\n", prefix); \ ! 302: } \ ! 303: \ ! 304: else if (flag_pic && frame_pointer_needed) \ ! 305: { \ ! 306: fprintf (FILE, "\tmovl 4(%%ebp),%%ecx\n"); \ ! 307: fprintf (FILE, "\tpushl %%ecx\n"); \ ! 308: fprintf (FILE, "\tleal $%sP%d@GOTOFF(%%ebx),%%edx\n", \ ! 309: lprefix, labelno); \ ! 310: fprintf (FILE, "\tmovl _mcount_ptr@GOT(%%eax),%%eax\n"); \ ! 311: fprintf (FILE, "\tcall *(%%eax)\n"); \ ! 312: fprintf (FILE, "\tpopl %%eax\n"); \ ! 313: } \ ! 314: \ ! 315: else if (frame_pointer_needed) \ ! 316: { \ ! 317: fprintf (FILE, "\tmovl 4(%%ebp),%%ecx\n"); \ ! 318: fprintf (FILE, "\tpushl %%ecx\n"); \ ! 319: fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \ ! 320: fprintf (FILE, "\tcall *_mcount_ptr\n"); \ ! 321: fprintf (FILE, "\tpopl %%eax\n"); \ ! 322: } \ ! 323: \ ! 324: else \ ! 325: abort (); \ ! 326: } \ ! 327: } \ ! 328: while (0) ! 329: ! 330: /* A C statement or compound statement to output to FILE some ! 331: assembler code to initialize basic-block profiling for the current ! 332: object module. This code should call the subroutine ! 333: `__bb_init_func' once per object module, passing it as its sole ! 334: argument the address of a block allocated in the object module. ! 335: ! 336: The name of the block is a local symbol made with this statement: ! 337: ! 338: ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); ! 339: ! 340: Of course, since you are writing the definition of ! 341: `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you ! 342: can take a short cut in the definition of this macro and use the ! 343: name that you know will result. ! 344: ! 345: The first word of this block is a flag which will be nonzero if the ! 346: object module has already been initialized. So test this word ! 347: first, and do not call `__bb_init_func' if the flag is nonzero. */ ! 348: ! 349: #undef FUNCTION_BLOCK_PROFILER ! 350: #define FUNCTION_BLOCK_PROFILER(STREAM, LABELNO) \ ! 351: do \ ! 352: { \ ! 353: if (!flag_pic) \ ! 354: { \ ! 355: fprintf (STREAM, "\tcmpl $0,%sPBX0\n", LPREFIX); \ ! 356: fprintf (STREAM, "\tjne 0f\n"); \ ! 357: fprintf (STREAM, "\tpushl $%sPBX0\n", LPREFIX); \ ! 358: fprintf (STREAM, "\tcall %s__bb_init_func\n", \ ! 359: (TARGET_UNDERSCORES) ? "_" : ""); \ ! 360: fprintf (STREAM, "0:\n"); \ ! 361: } \ ! 362: else \ ! 363: { \ ! 364: fprintf (STREAM, "\tpushl %eax\n"); \ ! 365: fprintf (STREAM, "\tmovl %sPBX0@GOT(%ebx),%eax\n"); \ ! 366: fprintf (STREAM, "\tcmpl $0,(%eax)\n"); \ ! 367: fprintf (STREAM, "\tjne 0f\n"); \ ! 368: fprintf (STREAM, "\tpushl %eax\n"); \ ! 369: fprintf (STREAM, "\tcall %s__bb_init_func@PLT\n", \ ! 370: (TARGET_UNDERSCORES) ? "_" : ""); \ ! 371: fprintf (STREAM, "0:\n"); \ ! 372: fprintf (STREAM, "\tpopl %eax\n"); \ ! 373: } \ ! 374: } \ ! 375: while (0) ! 376: ! 377: /* A C statement or compound statement to increment the count ! 378: associated with the basic block number BLOCKNO. Basic blocks are ! 379: numbered separately from zero within each compilation. The count ! 380: associated with block number BLOCKNO is at index BLOCKNO in a ! 381: vector of words; the name of this array is a local symbol made ! 382: with this statement: ! 383: ! 384: ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); ! 385: ! 386: Of course, since you are writing the definition of ! 387: `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you ! 388: can take a short cut in the definition of this macro and use the ! 389: name that you know will result. */ ! 390: ! 391: #undef BLOCK_PROFILER ! 392: #define BLOCK_PROFILER(STREAM, BLOCKNO) \ ! 393: do \ ! 394: { \ ! 395: if (!flag_pic) \ ! 396: fprintf (STREAM, "\tincl %sPBX2+%d\n", LPREFIX, (BLOCKNO)*4); \ ! 397: else \ ! 398: { \ ! 399: fprintf (STREAM, "\tpushl %eax\n"); \ ! 400: fprintf (STREAM, "\tmovl %sPBX2@GOT(%ebx),%eax\n", LPREFIX); \ ! 401: fprintf (STREAM, "\tincl %d(%eax)\n", (BLOCKNO)*4); \ ! 402: fprintf (STREAM, "\tpopl %eax\n"); \ ! 403: } \ ! 404: } \ ! 405: while (0) ! 406: ! 407: /* A C function or functions which are needed in the library to ! 408: support block profiling. When support goes into libc, undo ! 409: the #if 0. */ ! 410: ! 411: #if 0 ! 412: #undef BLOCK_PROFILING_CODE ! 413: #define BLOCK_PROFILING_CODE ! 414: #endif ! 415: ! 416: /* Prefix for internally generated assembler labels. If we aren't using ! 417: underscores, we are using prefix `.'s to identify labels that should ! 418: be ignored, as in `i386/gas.h' [email protected] */ ! 419: #undef LPREFIX ! 420: #define LPREFIX ((TARGET_UNDERSCORES) ? "L" : ".L") ! 421: ! 422: /* This is how to store into the string BUF ! 423: the symbol_ref name of an internal numbered label where ! 424: PREFIX is the class of label and NUM is the number within the class. ! 425: This is suitable for output with `assemble_name'. */ ! 426: ! 427: #undef ASM_GENERATE_INTERNAL_LABEL ! 428: #define ASM_GENERATE_INTERNAL_LABEL(BUF,PREFIX,NUMBER) \ ! 429: sprintf ((BUF), "*%s%s%d", (TARGET_UNDERSCORES) ? "" : ".", \ ! 430: (PREFIX), (NUMBER)) ! 431: ! 432: /* This is how to output an internal numbered label where ! 433: PREFIX is the class of label and NUM is the number within the class. */ ! 434: ! 435: #undef ASM_OUTPUT_INTERNAL_LABEL ! 436: #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ ! 437: fprintf (FILE, "%s%s%d:\n", (TARGET_UNDERSCORES) ? "" : ".", \ ! 438: PREFIX, NUM) ! 439: ! 440: /* This is how to output a reference to a user-level label named NAME. */ ! 441: ! 442: #undef ASM_OUTPUT_LABELREF ! 443: #define ASM_OUTPUT_LABELREF(FILE,NAME) \ ! 444: fprintf (FILE, "%s%s", (TARGET_UNDERSCORES) ? "_" : "", NAME) ! 445: ! 446: /* This is how to output an element of a case-vector that is relative. ! 447: This is only used for PIC code. See comments by the `casesi' insn in ! 448: i386.md for an explanation of the expression this outputs. */ ! 449: ! 450: #undef ASM_OUTPUT_ADDR_DIFF_ELT ! 451: #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ ! 452: fprintf (FILE, "\t.long _GLOBAL_OFFSET_TABLE_+[.-%s%d]\n", LPREFIX, VALUE) ! 453: ! 454: /* A C expression to output text to align the location counter in the ! 455: way that is desirable at a point in the code that is reached only ! 456: by jumping. ! 457: ! 458: This macro need not be defined if you don't want any special ! 459: alignment to be done at such a time. Most machine descriptions do ! 460: not currently define the macro. */ ! 461: ! 462: #undef ASM_OUTPUT_ALIGN_CODE ! 463: #define ASM_OUTPUT_ALIGN_CODE(STREAM) \ ! 464: fprintf (STREAM, "\t.align\t%d\n", \ ! 465: (TARGET_486 && TARGET_LARGE_ALIGN) ? 4 : 2) ! 466: ! 467: /* A C expression to output text to align the location counter in the ! 468: way that is desirable at the beginning of a loop. ! 469: ! 470: This macro need not be defined if you don't want any special ! 471: alignment to be done at such a time. Most machine descriptions do ! 472: not currently define the macro. */ ! 473: ! 474: #undef ASM_OUTPUT_LOOP_ALIGN ! 475: #define ASM_OUTPUT_LOOP_ALIGN(STREAM) \ ! 476: fprintf (STREAM, "\t.align\t2\n") ! 477: ! 478: /* A C statement to output to the stdio stream STREAM an assembler ! 479: command to advance the location counter to a multiple of 2 to the ! 480: POWER bytes. POWER will be a C expression of type `int'. */ ! 481: ! 482: #undef ASM_OUTPUT_ALIGN ! 483: #define ASM_OUTPUT_ALIGN(STREAM, POWER) \ ! 484: fprintf (STREAM, "\t.align\t%d\n", \ ! 485: (!TARGET_LARGE_ALIGN && (POWER) > 2) ? 2 : (POWER)) ! 486: ! 487: /* A C expression that is 1 if the RTX X is a constant which is a ! 488: valid address. On most machines, this can be defined as ! 489: `CONSTANT_P (X)', but a few machines are more restrictive in ! 490: which constant addresses are supported. ! 491: ! 492: `CONSTANT_P' accepts integer-values expressions whose values are ! 493: not explicitly known, such as `symbol_ref', `label_ref', and ! 494: `high' expressions and `const' arithmetic expressions, in ! 495: addition to `const_int' and `const_double' expressions. */ ! 496: ! 497: #define CONSTANT_ADDRESS_P_ORIG(X) \ ! 498: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ ! 499: || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \ ! 500: || GET_CODE (X) == HIGH) ! 501: ! 502: #undef CONSTANT_ADDRESS_P ! 503: #define CONSTANT_ADDRESS_P(X) \ ! 504: ((CONSTANT_ADDRESS_P_ORIG (X)) && (!HALF_PIC_P () || !HALF_PIC_ADDRESS_P (X))) ! 505: ! 506: /* Nonzero if the constant value X is a legitimate general operand. ! 507: It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ ! 508: ! 509: #undef LEGITIMATE_CONSTANT_P ! 510: #define LEGITIMATE_CONSTANT_P(X) \ ! 511: (!HALF_PIC_P () \ ! 512: || GET_CODE (X) == CONST_DOUBLE \ ! 513: || GET_CODE (X) == CONST_INT \ ! 514: || !HALF_PIC_ADDRESS_P (X)) ! 515: ! 516: /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression ! 517: that is a valid memory address for an instruction. ! 518: The MODE argument is the machine mode for the MEM expression ! 519: that wants to use this address. */ ! 520: ! 521: #define GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR) \ ! 522: { \ ! 523: if (CONSTANT_ADDRESS_P (X) \ ! 524: && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (X))) \ ! 525: goto ADDR; \ ! 526: GO_IF_INDEXING (X, ADDR); \ ! 527: if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \ ! 528: { \ ! 529: rtx x0 = XEXP (X, 0); \ ! 530: if (! flag_pic || ! SYMBOLIC_CONST (XEXP (X, 1))) \ ! 531: { GO_IF_INDEXING (x0, ADDR); } \ ! 532: else if (x0 == pic_offset_table_rtx) \ ! 533: goto ADDR; \ ! 534: else if (GET_CODE (x0) == PLUS) \ ! 535: { \ ! 536: if (XEXP (x0, 0) == pic_offset_table_rtx) \ ! 537: { GO_IF_INDEXABLE_BASE (XEXP (x0, 1), ADDR); } \ ! 538: if (XEXP (x0, 1) == pic_offset_table_rtx) \ ! 539: { GO_IF_INDEXABLE_BASE (XEXP (x0, 0), ADDR); } \ ! 540: } \ ! 541: } \ ! 542: } ! 543: ! 544: #undef GO_IF_LEGITIMATE_ADDRESS ! 545: #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ! 546: { \ ! 547: if (! HALF_PIC_P ()) \ ! 548: { \ ! 549: GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR); \ ! 550: } \ ! 551: else \ ! 552: { \ ! 553: if (CONSTANT_P (X) && ! HALF_PIC_ADDRESS_P (X)) \ ! 554: goto ADDR; \ ! 555: \ ! 556: GO_IF_INDEXING (X, ADDR); \ ! 557: if (GET_CODE (X) == PLUS) \ ! 558: { \ ! 559: rtx x1 = XEXP (X, 1); \ ! 560: \ ! 561: if (CONSTANT_P (x1) && ! HALF_PIC_ADDRESS_P (x1)) \ ! 562: { \ ! 563: rtx x0 = XEXP (X, 0); \ ! 564: GO_IF_INDEXING (x0, ADDR); \ ! 565: } \ ! 566: } \ ! 567: } \ ! 568: } ! 569: ! 570: /* Sometimes certain combinations of command options do not make sense ! 571: on a particular target machine. You can define a macro ! 572: `OVERRIDE_OPTIONS' to take account of this. This macro, if ! 573: defined, is executed once just after all the command options have ! 574: been parsed. */ ! 575: ! 576: #undef SUBTARGET_OVERRIDE_OPTIONS ! 577: #define SUBTARGET_OVERRIDE_OPTIONS \ ! 578: { \ ! 579: /* \ ! 580: if (TARGET_ELF && TARGET_HALF_PIC) \ ! 581: { \ ! 582: target_flags &= ~MASK_HALF_PIC; \ ! 583: flag_pic = 1; \ ! 584: } \ ! 585: */ \ ! 586: \ ! 587: if (TARGET_ROSE && flag_pic) \ ! 588: { \ ! 589: target_flags |= MASK_HALF_PIC; \ ! 590: flag_pic = 0; \ ! 591: } \ ! 592: \ ! 593: if (TARGET_HALF_PIC) \ ! 594: half_pic_init (); \ ! 595: } ! 596: ! 597: /* Define this macro if references to a symbol must be treated ! 598: differently depending on something about the variable or ! 599: function named by the symbol (such as what section it is in). ! 600: ! 601: The macro definition, if any, is executed immediately after the ! 602: rtl for DECL has been created and stored in `DECL_RTL (DECL)'. ! 603: The value of the rtl will be a `mem' whose address is a ! 604: `symbol_ref'. ! 605: ! 606: The usual thing for this macro to do is to a flag in the ! 607: `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified ! 608: name string in the `symbol_ref' (if one bit is not enough ! 609: information). ! 610: ! 611: The best way to modify the name string is by adding text to the ! 612: beginning, with suitable punctuation to prevent any ambiguity. ! 613: Allocate the new name in `saveable_obstack'. You will have to ! 614: modify `ASM_OUTPUT_LABELREF' to remove and decode the added text ! 615: and output the name accordingly. ! 616: ! 617: You can also check the information stored in the `symbol_ref' in ! 618: the definition of `GO_IF_LEGITIMATE_ADDRESS' or ! 619: `PRINT_OPERAND_ADDRESS'. */ ! 620: ! 621: #undef ENCODE_SECTION_INFO ! 622: #define ENCODE_SECTION_INFO(DECL) \ ! 623: do \ ! 624: { \ ! 625: if (HALF_PIC_P ()) \ ! 626: HALF_PIC_ENCODE (DECL); \ ! 627: \ ! 628: else if (flag_pic) \ ! 629: { \ ! 630: rtx rtl = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd' \ ! 631: ? TREE_CST_RTL (DECL) : DECL_RTL (DECL)); \ ! 632: SYMBOL_REF_FLAG (XEXP (rtl, 0)) \ ! 633: = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd' \ ! 634: || ! TREE_PUBLIC (DECL)); \ ! 635: } \ ! 636: } \ ! 637: while (0) ! 638: ! 639: ! 640: /* On most machines, read-only variables, constants, and jump tables ! 641: are placed in the text section. If this is not the case on your ! 642: machine, this macro should be defined to be the name of a function ! 643: (either `data_section' or a function defined in `EXTRA_SECTIONS') ! 644: that switches to the section to be used for read-only items. ! 645: ! 646: If these items should be placed in the text section, this macro ! 647: should not be defined. */ ! 648: ! 649: #if 0 ! 650: #undef READONLY_DATA_SECTION ! 651: #define READONLY_DATA_SECTION() \ ! 652: do \ ! 653: { \ ! 654: if (TARGET_ELF) \ ! 655: { \ ! 656: if (in_section != in_rodata) \ ! 657: { \ ! 658: fprintf (asm_out_file, "\t.section \"rodata\"\n"); \ ! 659: in_section = in_rodata; \ ! 660: } \ ! 661: } \ ! 662: else \ ! 663: text_section (); \ ! 664: } \ ! 665: while (0) ! 666: #endif ! 667: ! 668: /* A list of names for sections other than the standard two, which are ! 669: `in_text' and `in_data'. You need not define this macro on a ! 670: system with no other sections (that GCC needs to use). */ ! 671: ! 672: #undef EXTRA_SECTIONS ! 673: #define EXTRA_SECTIONS in_rodata, in_data1 ! 674: ! 675: /* Given a decl node or constant node, choose the section to output it in ! 676: and select that section. */ ! 677: ! 678: #undef SELECT_RTX_SECTION ! 679: #define SELECT_RTX_SECTION(MODE, RTX) \ ! 680: do \ ! 681: { \ ! 682: if (MODE == Pmode && HALF_PIC_P () && HALF_PIC_ADDRESS_P (RTX)) \ ! 683: data_section (); \ ! 684: else \ ! 685: readonly_data_section (); \ ! 686: } \ ! 687: while (0) ! 688: ! 689: #undef SELECT_SECTION ! 690: #define SELECT_SECTION(DECL, RELOC) \ ! 691: { \ ! 692: if (RELOC && HALF_PIC_P ()) \ ! 693: data_section (); \ ! 694: \ ! 695: else if (TREE_CODE (DECL) == STRING_CST) \ ! 696: { \ ! 697: if (flag_writable_strings) \ ! 698: data_section (); \ ! 699: else \ ! 700: readonly_data_section (); \ ! 701: } \ ! 702: \ ! 703: else if (TREE_CODE (DECL) != VAR_DECL) \ ! 704: readonly_data_section (); \ ! 705: \ ! 706: else if (!TREE_READONLY (DECL)) \ ! 707: data_section (); \ ! 708: \ ! 709: else \ ! 710: readonly_data_section (); \ ! 711: } ! 712: ! 713: ! 714: /* Define the strings used for the special svr4 .type and .size directives. ! 715: These strings generally do not vary from one system running svr4 to ! 716: another, but if a given system (e.g. m88k running svr) needs to use ! 717: different pseudo-op names for these, they may be overridden in the ! 718: file which includes this one. */ ! 719: ! 720: #define TYPE_ASM_OP ".type" ! 721: #define SIZE_ASM_OP ".size" ! 722: #define WEAK_ASM_OP ".weak" ! 723: #define SET_ASM_OP ".set" ! 724: ! 725: /* The following macro defines the format used to output the second ! 726: operand of the .type assembler directive. Different svr4 assemblers ! 727: expect various different forms for this operand. The one given here ! 728: is just a default. You may need to override it in your machine- ! 729: specific tm.h file (depending upon the particulars of your assembler). */ ! 730: ! 731: #define TYPE_OPERAND_FMT "@%s" ! 732: ! 733: /* A C statement (sans semicolon) to output to the stdio stream ! 734: STREAM any text necessary for declaring the name NAME of an ! 735: initialized variable which is being defined. This macro must ! 736: output the label definition (perhaps using `ASM_OUTPUT_LABEL'). ! 737: The argument DECL is the `VAR_DECL' tree node representing the ! 738: variable. ! 739: ! 740: If this macro is not defined, then the variable name is defined ! 741: in the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). */ ! 742: ! 743: #undef ASM_DECLARE_OBJECT_NAME ! 744: #define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL) \ ! 745: do \ ! 746: { \ ! 747: ASM_OUTPUT_LABEL(STREAM,NAME); \ ! 748: HALF_PIC_DECLARE (NAME); \ ! 749: if (TARGET_ELF) \ ! 750: { \ ! 751: fprintf (STREAM, "\t%s\t ", TYPE_ASM_OP); \ ! 752: assemble_name (STREAM, NAME); \ ! 753: putc (',', STREAM); \ ! 754: fprintf (STREAM, TYPE_OPERAND_FMT, "object"); \ ! 755: putc ('\n', STREAM); \ ! 756: size_directive_output = 0; \ ! 757: if (!flag_inhibit_size_directive && DECL_SIZE (DECL)) \ ! 758: { \ ! 759: size_directive_output = 1; \ ! 760: fprintf (STREAM, "\t%s\t ", SIZE_ASM_OP); \ ! 761: assemble_name (STREAM, NAME); \ ! 762: fprintf (STREAM, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ ! 763: } \ ! 764: } \ ! 765: } \ ! 766: while (0) ! 767: ! 768: /* Output the size directive for a decl in rest_of_decl_compilation ! 769: in the case where we did not do so before the initializer. ! 770: Once we find the error_mark_node, we know that the value of ! 771: size_directive_output was set ! 772: by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ ! 773: ! 774: #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ ! 775: do { \ ! 776: char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \ ! 777: if (TARGET_ELF \ ! 778: && !flag_inhibit_size_directive && DECL_SIZE (DECL) \ ! 779: && ! AT_END && TOP_LEVEL \ ! 780: && DECL_INITIAL (DECL) == error_mark_node \ ! 781: && !size_directive_output) \ ! 782: { \ ! 783: fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ ! 784: assemble_name (FILE, name); \ ! 785: fprintf (FILE, ",%d\n", int_size_in_bytes (TREE_TYPE (DECL))); \ ! 786: } \ ! 787: } while (0) ! 788: ! 789: /* This is how to declare a function name. */ ! 790: ! 791: #undef ASM_DECLARE_FUNCTION_NAME ! 792: #define ASM_DECLARE_FUNCTION_NAME(STREAM,NAME,DECL) \ ! 793: do \ ! 794: { \ ! 795: ASM_OUTPUT_LABEL(STREAM,NAME); \ ! 796: HALF_PIC_DECLARE (NAME); \ ! 797: if (TARGET_ELF) \ ! 798: { \ ! 799: fprintf (STREAM, "\t%s\t ", TYPE_ASM_OP); \ ! 800: assemble_name (STREAM, NAME); \ ! 801: putc (',', STREAM); \ ! 802: fprintf (STREAM, TYPE_OPERAND_FMT, "function"); \ ! 803: putc ('\n', STREAM); \ ! 804: ASM_DECLARE_RESULT (STREAM, DECL_RESULT (DECL)); \ ! 805: } \ ! 806: } \ ! 807: while (0) ! 808: ! 809: /* Write the extra assembler code needed to declare a function's result. ! 810: Most svr4 assemblers don't require any special declaration of the ! 811: result value, but there are exceptions. */ ! 812: ! 813: #ifndef ASM_DECLARE_RESULT ! 814: #define ASM_DECLARE_RESULT(FILE, RESULT) ! 815: #endif ! 816: ! 817: /* This is how to declare the size of a function. */ ! 818: ! 819: #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ ! 820: do \ ! 821: { \ ! 822: if (TARGET_ELF && !flag_inhibit_size_directive) \ ! 823: { \ ! 824: char label[256]; \ ! 825: static int labelno; \ ! 826: labelno++; \ ! 827: ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ ! 828: ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ ! 829: fprintf (FILE, "\t%s\t ", SIZE_ASM_OP); \ ! 830: assemble_name (FILE, (FNAME)); \ ! 831: fprintf (FILE, ","); \ ! 832: assemble_name (FILE, label); \ ! 833: fprintf (FILE, "-"); \ ! 834: assemble_name (FILE, (FNAME)); \ ! 835: putc ('\n', FILE); \ ! 836: } \ ! 837: } \ ! 838: while (0) ! 839: ! 840: /* Attach a special .ident directive to the end of the file to identify ! 841: the version of GCC which compiled this code. The format of the ! 842: .ident string is patterned after the ones produced by native svr4 ! 843: C compilers. */ ! 844: ! 845: #define IDENT_ASM_OP ".ident" ! 846: ! 847: /* Allow #sccs in preprocessor. */ ! 848: ! 849: #define SCCS_DIRECTIVE ! 850: ! 851: /* This says what to print at the end of the assembly file */ ! 852: #define ASM_FILE_END(STREAM) \ ! 853: do \ ! 854: { \ ! 855: if (HALF_PIC_P ()) \ ! 856: HALF_PIC_FINISH (STREAM); \ ! 857: \ ! 858: if (TARGET_IDENT) \ ! 859: { \ ! 860: char *fstart = main_input_filename; \ ! 861: char *fname; \ ! 862: \ ! 863: if (!fstart) \ ! 864: fstart = "<no file>"; \ ! 865: \ ! 866: fname = fstart + strlen (fstart) - 1; \ ! 867: while (fname > fstart && *fname != '/') \ ! 868: fname--; \ ! 869: \ ! 870: if (*fname == '/') \ ! 871: fname++; \ ! 872: \ ! 873: fprintf ((STREAM), "\t%s\t\"GCC: (GNU) %s %s -O%d", \ ! 874: IDENT_ASM_OP, version_string, fname, optimize); \ ! 875: \ ! 876: if (write_symbols == PREFERRED_DEBUGGING_TYPE) \ ! 877: fprintf ((STREAM), " -g%d", (int)debug_info_level); \ ! 878: \ ! 879: else if (write_symbols == DBX_DEBUG) \ ! 880: fprintf ((STREAM), " -gstabs%d", (int)debug_info_level); \ ! 881: \ ! 882: else if (write_symbols == DWARF_DEBUG) \ ! 883: fprintf ((STREAM), " -gdwarf%d", (int)debug_info_level); \ ! 884: \ ! 885: else if (write_symbols != NO_DEBUG) \ ! 886: fprintf ((STREAM), " -g??%d", (int)debug_info_level); \ ! 887: \ ! 888: if (flag_omit_frame_pointer) \ ! 889: fprintf ((STREAM), " -fomit-frame-pointer"); \ ! 890: \ ! 891: if (flag_strength_reduce) \ ! 892: fprintf ((STREAM), " -fstrength-reduce"); \ ! 893: \ ! 894: if (flag_unroll_loops) \ ! 895: fprintf ((STREAM), " -funroll-loops"); \ ! 896: \ ! 897: if (flag_force_mem) \ ! 898: fprintf ((STREAM), " -fforce-mem"); \ ! 899: \ ! 900: if (flag_force_addr) \ ! 901: fprintf ((STREAM), " -fforce-addr"); \ ! 902: \ ! 903: if (flag_inline_functions) \ ! 904: fprintf ((STREAM), " -finline-functions"); \ ! 905: \ ! 906: if (flag_caller_saves) \ ! 907: fprintf ((STREAM), " -fcaller-saves"); \ ! 908: \ ! 909: if (flag_pic) \ ! 910: fprintf ((STREAM), (flag_pic > 1) ? " -fPIC" : " -fpic"); \ ! 911: \ ! 912: if (flag_inhibit_size_directive) \ ! 913: fprintf ((STREAM), " -finhibit-size-directive"); \ ! 914: \ ! 915: if (flag_gnu_linker) \ ! 916: fprintf ((STREAM), " -fgnu-linker"); \ ! 917: \ ! 918: if (profile_flag) \ ! 919: fprintf ((STREAM), " -p"); \ ! 920: \ ! 921: if (profile_block_flag) \ ! 922: fprintf ((STREAM), " -a"); \ ! 923: \ ! 924: if (TARGET_IEEE_FP) \ ! 925: fprintf ((STREAM), " -mieee-fp"); \ ! 926: \ ! 927: if (TARGET_HALF_PIC) \ ! 928: fprintf ((STREAM), " -mhalf-pic"); \ ! 929: \ ! 930: fprintf ((STREAM), (TARGET_486) ? " -m486" : " -m386"); \ ! 931: fprintf ((STREAM), (TARGET_ELF) ? " -melf\"\n" : " -mrose\"\n"); \ ! 932: } \ ! 933: } \ ! 934: while (0) ! 935: ! 936: /* Tell collect that the object format is OSF/rose. */ ! 937: #define OBJECT_FORMAT_ROSE ! 938: ! 939: /* Tell collect where the appropriate binaries are. */ ! 940: #define REAL_LD_FILE_NAME "/usr/ccs/gcc/gld" ! 941: #define REAL_NM_FILE_NAME "/usr/ccs/bin/nm" ! 942: #define REAL_STRIP_FILE_NAME "/usr/ccs/bin/strip" ! 943: ! 944: /* Use atexit for static constructors/destructors, instead of defining ! 945: our own exit function. */ ! 946: #define HAVE_ATEXIT ! 947: ! 948: /* Define this macro meaning that gcc should find the library 'libgcc.a' ! 949: by hand, rather than passing the argument '-lgcc' to tell the linker ! 950: to do the search */ ! 951: #define LINK_LIBGCC_SPECIAL ! 952: ! 953: /* A C statement to output assembler commands which will identify the object ! 954: file as having been compile with GNU CC. We don't need or want this for ! 955: OSF1. GDB doesn't need it and kdb doesn't like it */ ! 956: #define ASM_IDENTIFY_GCC(FILE) ! 957: ! 958: /* Identify the front-end which produced this file. To keep symbol ! 959: space down, and not confuse kdb, only do this if the language is ! 960: not C. */ ! 961: ! 962: #define ASM_IDENTIFY_LANGUAGE(STREAM) \ ! 963: { \ ! 964: if (strcmp (lang_identify (), "c") != 0) \ ! 965: output_lang_identify (STREAM); \ ! 966: } ! 967: ! 968: /* This is how to output an assembler line defining a `double' constant. ! 969: Use "word" pseudos to avoid printing NaNs, infinity, etc. */ ! 970: ! 971: /* This is how to output an assembler line defining a `double' constant. */ ! 972: #undef ASM_OUTPUT_DOUBLE ! 973: #define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \ ! 974: do \ ! 975: { \ ! 976: long value_long[2]; \ ! 977: char dstr[30]; \ ! 978: REAL_VALUE_TO_TARGET_DOUBLE (VALUE, value_long); \ ! 979: REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \ ! 980: if (sizeof (int) == sizeof (long)) \ ! 981: fprintf (STREAM, "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n", \ ! 982: value_long[0], dstr, value_long[1]); \ ! 983: else \ ! 984: fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n", \ ! 985: value_long[0], dstr, value_long[1]); \ ! 986: } \ ! 987: while (0) ! 988: ! 989: /* This is how to output an assembler line defining a `float' constant. */ ! 990: #undef ASM_OUTPUT_FLOAT ! 991: #define ASM_OUTPUT_FLOAT(STREAM, VALUE) \ ! 992: do \ ! 993: { \ ! 994: long value_long; \ ! 995: char dstr[30]; \ ! 996: REAL_VALUE_TO_TARGET_SINGLE (VALUE, value_long); \ ! 997: REAL_VALUE_TO_DECIMAL (VALUE, "%.12g", dstr); \ ! 998: if (sizeof (int) == sizeof (long)) \ ! 999: fprintf (STREAM, "\t.long\t0x%08x\t\t# %s (float)\n", \ ! 1000: value_long, dstr); \ ! 1001: else \ ! 1002: fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s (float)\n", \ ! 1003: value_long, dstr); \ ! 1004: } \ ! 1005: while (0) ! 1006: ! 1007: /* This is how to output an assembler line for a `long double' constant. */ ! 1008: #undef ASM_OUTPUT_LONG_DOUBLE ! 1009: #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \ ! 1010: do { long l[3]; \ ! 1011: char dstr[30]; \ ! 1012: REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \ ! 1013: REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \ ! 1014: if (sizeof (int) == sizeof (long)) \ ! 1015: fprintf (FILE, \ ! 1016: "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n\t.long\t0x%08x\n", \ ! 1017: l[0], dstr, l[1], l[2]); \ ! 1018: else \ ! 1019: fprintf (FILE, \ ! 1020: "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n\t.long\t0x%08lx\n", \ ! 1021: l[0], dstr, l[1], l[2]); \ ! 1022: } while (0) ! 1023: ! 1024: /* Generate calls to memcpy, etc., not bcopy, etc. */ ! 1025: #define TARGET_MEM_FUNCTIONS ! 1026: ! 1027: /* Don't default to pcc-struct-return, because gcc is the only compiler, and ! 1028: we want to retain compatibility with older gcc versions. */ ! 1029: #define DEFAULT_PCC_STRUCT_RETURN 0 ! 1030: ! 1031: /* Map i386 registers to the numbers dwarf expects. Of course this is different ! 1032: from what stabs expects. */ ! 1033: ! 1034: #define DWARF_DBX_REGISTER_NUMBER(n) \ ! 1035: ((n) == 0 ? 0 \ ! 1036: : (n) == 1 ? 2 \ ! 1037: : (n) == 2 ? 1 \ ! 1038: : (n) == 3 ? 3 \ ! 1039: : (n) == 4 ? 6 \ ! 1040: : (n) == 5 ? 7 \ ! 1041: : (n) == 6 ? 5 \ ! 1042: : (n) == 7 ? 4 \ ! 1043: : ((n) >= FIRST_STACK_REG && (n) <= LAST_STACK_REG) ? (n)+3 \ ! 1044: : (-1)) ! 1045: ! 1046: /* Now what stabs expects in the register. */ ! 1047: #define STABS_DBX_REGISTER_NUMBER(n) \ ! 1048: ((n) == 0 ? 0 : \ ! 1049: (n) == 1 ? 2 : \ ! 1050: (n) == 2 ? 1 : \ ! 1051: (n) == 3 ? 3 : \ ! 1052: (n) == 4 ? 6 : \ ! 1053: (n) == 5 ? 7 : \ ! 1054: (n) == 6 ? 4 : \ ! 1055: (n) == 7 ? 5 : \ ! 1056: (n) + 4) ! 1057: ! 1058: #undef DBX_REGISTER_NUMBER ! 1059: #define DBX_REGISTER_NUMBER(n) ((write_symbols == DWARF_DEBUG) \ ! 1060: ? DWARF_DBX_REGISTER_NUMBER(n) \ ! 1061: : STABS_DBX_REGISTER_NUMBER(n))
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.