![[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 [GCC 2.x] / gcc / config / i386|
Return to osfrose.h CVS log | Up to [GCC 2.x] / gcc / 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 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: /* Put leading underscores in front of names. */ ! 22: #define YES_UNDERSCORES ! 23: ! 24: #include "halfpic.h" ! 25: #include "i386/gstabs.h" ! 26: ! 27: /* Get perform_* macros to build libgcc.a. */ ! 28: #include "i386/perform.h" ! 29: ! 30: #define OSF_OS ! 31: ! 32: #undef WORD_SWITCH_TAKES_ARG ! 33: #define WORD_SWITCH_TAKES_ARG(STR) \ ! 34: (DEFAULT_WORD_SWITCH_TAKES_ARG (STR) || !strcmp (STR, "pic-names")) ! 35: ! 36: #define MASK_HALF_PIC 0x40000000 /* Mask for half-pic code */ ! 37: #define MASK_HALF_PIC_DEBUG 0x20000000 /* Debug flag */ ! 38: #define MASK_ELF 0x10000000 /* ELF not rose */ ! 39: #define MASK_NO_IDENT 0x08000000 /* suppress .ident */ ! 40: ! 41: #define TARGET_HALF_PIC (target_flags & MASK_HALF_PIC) ! 42: #define TARGET_DEBUG (target_flags & MASK_HALF_PIC_DEBUG) ! 43: #define HALF_PIC_DEBUG TARGET_DEBUG ! 44: #define TARGET_ELF (target_flags & MASK_ELF) ! 45: #define TARGET_ROSE ((target_flags & MASK_ELF) == 0) ! 46: #define TARGET_IDENT ((target_flags & MASK_NO_IDENT) == 0) ! 47: ! 48: #undef SUBTARGET_SWITCHES ! 49: #define SUBTARGET_SWITCHES \ ! 50: { "half-pic", MASK_HALF_PIC}, \ ! 51: { "no-half-pic", -MASK_HALF_PIC}, \ ! 52: { "debugb", MASK_HALF_PIC_DEBUG}, \ ! 53: { "elf", MASK_ELF}, \ ! 54: { "no-elf", -MASK_ELF}, \ ! 55: { "rose", -MASK_ELF}, \ ! 56: { "ident", -MASK_NO_IDENT}, \ ! 57: { "no-ident", MASK_NO_IDENT}, ! 58: ! 59: /* OSF/rose uses stabs, not dwarf. */ ! 60: #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG ! 61: ! 62: #ifndef DWARF_DEBUGGING_INFO ! 63: #define DWARF_DEBUGGING_INFO /* enable dwarf debugging for testing */ ! 64: #endif ! 65: ! 66: /* Handle #pragma weak and #pragma pack. */ ! 67: ! 68: #define HANDLE_SYSV_PRAGMA ! 69: ! 70: /* Change default predefines. */ ! 71: #undef CPP_PREDEFINES ! 72: #define CPP_PREDEFINES "-DOSF -DOSF1 -Dunix -Di386 -Asystem(unix) -Acpu(i386) -Amachine(i386)" ! 73: ! 74: #undef CPP_SPEC ! 75: #define CPP_SPEC "\ ! 76: %{!melf: -D__ROSE__} %{melf: -D__ELF__} \ ! 77: %{.S: %{!ansi:%{!traditional:%{!traditional-cpp:%{!ftraditional: -traditional}}}}} \ ! 78: %{.S: -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY}} \ ! 79: %{.cc: -D__LANGUAGE_C_PLUS_PLUS} \ ! 80: %{.cxx: -D__LANGUAGE_C_PLUS_PLUS} \ ! 81: %{.C: -D__LANGUAGE_C_PLUS_PLUS} \ ! 82: %{.m: -D__LANGUAGE_OBJECTIVE_C} \ ! 83: %{!.S: -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C}}" ! 84: ! 85: /* Turn on -mpic-extern by default. */ ! 86: #undef CC1_SPEC ! 87: #define CC1_SPEC "\ ! 88: %{!melf: %{!mrose: %{!mno-elf: -mrose }}} \ ! 89: %{gline:%{!g:%{!g0:%{!g1:%{!g2: -g1}}}}} \ ! 90: %{pic-none: -mno-half-pic} \ ! 91: %{fpic: -mno-half-pic} \ ! 92: %{fPIC: -mno-half-pic} \ ! 93: %{pic-lib: -mhalf-pic} \ ! 94: %{pic-extern: -mhalf-pic} \ ! 95: %{pic-calls: -mhalf-pic} \ ! 96: %{pic-names*: -mhalf-pic} \ ! 97: %{!pic-*: %{!fpic: %{!fPIC: -mhalf-pic}}}" ! 98: ! 99: #undef ASM_SPEC ! 100: #define ASM_SPEC "%{v*: -v}" ! 101: ! 102: #undef LINK_SPEC ! 103: #define LINK_SPEC "%{v*: -v} \ ! 104: %{!noshrlib: %{pic-none: -noshrlib} %{!pic-none: -warn_nopic}} \ ! 105: %{nostdlib} %{noshrlib} %{glue}" ! 106: ! 107: #undef LIB_SPEC ! 108: #define LIB_SPEC "-lc" ! 109: ! 110: #undef LIBG_SPEC ! 111: #define LIBG_SPEC "" ! 112: ! 113: #undef STARTFILE_SPEC ! 114: #define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}" ! 115: ! 116: #undef TARGET_VERSION_INTERNAL ! 117: #undef TARGET_VERSION ! 118: ! 119: #define I386_VERSION " 80386, OSF/rose objects" ! 120: ! 121: #define TARGET_VERSION_INTERNAL(STREAM) fputs (I386_VERSION, STREAM) ! 122: #define TARGET_VERSION TARGET_VERSION_INTERNAL (stderr) ! 123: ! 124: #undef MD_EXEC_PREFIX ! 125: #define MD_EXEC_PREFIX "/usr/ccs/gcc/" ! 126: ! 127: #undef MD_STARTFILE_PREFIX ! 128: #define MD_STARTFILE_PREFIX "/usr/ccs/lib/" ! 129: ! 130: /* Specify size_t, ptrdiff_t, and wchar_t types. */ ! 131: #undef SIZE_TYPE ! 132: #undef PTRDIFF_TYPE ! 133: #undef WCHAR_TYPE ! 134: #undef WCHAR_TYPE_SIZE ! 135: ! 136: #define SIZE_TYPE "long unsigned int" ! 137: #define PTRDIFF_TYPE "int" ! 138: #define WCHAR_TYPE "unsigned int" ! 139: #define WCHAR_TYPE_SIZE BITS_PER_WORD ! 140: ! 141: /* Temporarily turn off long double being 96 bits. */ ! 142: #undef LONG_DOUBLE_TYPE_SIZE ! 143: ! 144: /* Tell final.c we don't need a label passed to mcount. */ ! 145: #define NO_PROFILE_DATA ! 146: ! 147: #undef FUNCTION_PROFILER ! 148: #define FUNCTION_PROFILER(FILE, LABELNO) fprintf (FILE, "\tcall _mcount\n") ! 149: ! 150: /* A C expression that is 1 if the RTX X is a constant which is a ! 151: valid address. On most machines, this can be defined as ! 152: `CONSTANT_P (X)', but a few machines are more restrictive in ! 153: which constant addresses are supported. ! 154: ! 155: `CONSTANT_P' accepts integer-values expressions whose values are ! 156: not explicitly known, such as `symbol_ref', `label_ref', and ! 157: `high' expressions and `const' arithmetic expressions, in ! 158: addition to `const_int' and `const_double' expressions. */ ! 159: ! 160: #define CONSTANT_ADDRESS_P_ORIG(X) \ ! 161: (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ ! 162: || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST \ ! 163: || GET_CODE (X) == HIGH) ! 164: ! 165: #undef CONSTANT_ADDRESS_P ! 166: #define CONSTANT_ADDRESS_P(X) \ ! 167: ((CONSTANT_ADDRESS_P_ORIG (X)) && (!HALF_PIC_P () || !HALF_PIC_ADDRESS_P (X))) ! 168: ! 169: /* Nonzero if the constant value X is a legitimate general operand. ! 170: It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ ! 171: ! 172: #undef LEGITIMATE_CONSTANT_P ! 173: #define LEGITIMATE_CONSTANT_P(X) \ ! 174: (!HALF_PIC_P () \ ! 175: || GET_CODE (X) == CONST_DOUBLE \ ! 176: || GET_CODE (X) == CONST_INT \ ! 177: || !HALF_PIC_ADDRESS_P (X)) ! 178: ! 179: /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression ! 180: that is a valid memory address for an instruction. ! 181: The MODE argument is the machine mode for the MEM expression ! 182: that wants to use this address. */ ! 183: ! 184: #define GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR) \ ! 185: { \ ! 186: if (CONSTANT_ADDRESS_P (X) \ ! 187: && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (X))) \ ! 188: goto ADDR; \ ! 189: GO_IF_INDEXING (X, ADDR); \ ! 190: if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \ ! 191: { \ ! 192: rtx x0 = XEXP (X, 0); \ ! 193: if (! flag_pic || ! SYMBOLIC_CONST (XEXP (X, 1))) \ ! 194: { GO_IF_INDEXING (x0, ADDR); } \ ! 195: else if (x0 == pic_offset_table_rtx) \ ! 196: goto ADDR; \ ! 197: else if (GET_CODE (x0) == PLUS) \ ! 198: { \ ! 199: if (XEXP (x0, 0) == pic_offset_table_rtx) \ ! 200: { GO_IF_INDEXABLE_BASE (XEXP (x0, 1), ADDR); } \ ! 201: if (XEXP (x0, 1) == pic_offset_table_rtx) \ ! 202: { GO_IF_INDEXABLE_BASE (XEXP (x0, 0), ADDR); } \ ! 203: } \ ! 204: } \ ! 205: } ! 206: ! 207: #undef GO_IF_LEGITIMATE_ADDRESS ! 208: #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ! 209: { \ ! 210: if (! HALF_PIC_P ()) \ ! 211: { \ ! 212: GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR); \ ! 213: } \ ! 214: else \ ! 215: { \ ! 216: if (CONSTANT_P (X) && ! HALF_PIC_ADDRESS_P (X)) \ ! 217: goto ADDR; \ ! 218: \ ! 219: GO_IF_INDEXING (X, ADDR); \ ! 220: if (GET_CODE (X) == PLUS) \ ! 221: { \ ! 222: rtx x1 = XEXP (X, 1); \ ! 223: \ ! 224: if (CONSTANT_P (x1) && ! HALF_PIC_ADDRESS_P (x1)) \ ! 225: { \ ! 226: rtx x0 = XEXP (X, 0); \ ! 227: GO_IF_INDEXING (x0, ADDR); \ ! 228: } \ ! 229: } \ ! 230: } \ ! 231: } ! 232: ! 233: /* Sometimes certain combinations of command options do not make sense ! 234: on a particular target machine. You can define a macro ! 235: `OVERRIDE_OPTIONS' to take account of this. This macro, if ! 236: defined, is executed once just after all the command options have ! 237: been parsed. */ ! 238: ! 239: #define OVERRIDE_OPTIONS \ ! 240: { \ ! 241: /* \ ! 242: if (TARGET_ELF && TARGET_HALF_PIC) \ ! 243: { \ ! 244: target_flags &= ~MASK_HALF_PIC; \ ! 245: flag_pic = 1; \ ! 246: } \ ! 247: */ \ ! 248: \ ! 249: if (TARGET_ROSE && flag_pic) \ ! 250: { \ ! 251: target_flags |= MASK_HALF_PIC; \ ! 252: flag_pic = 0; \ ! 253: } \ ! 254: \ ! 255: if (TARGET_HALF_PIC) \ ! 256: half_pic_init (); \ ! 257: } ! 258: ! 259: /* Define this macro if references to a symbol must be treated ! 260: differently depending on something about the variable or ! 261: function named by the symbol (such as what section it is in). ! 262: ! 263: The macro definition, if any, is executed immediately after the ! 264: rtl for DECL has been created and stored in `DECL_RTL (DECL)'. ! 265: The value of the rtl will be a `mem' whose address is a ! 266: `symbol_ref'. ! 267: ! 268: The usual thing for this macro to do is to a flag in the ! 269: `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified ! 270: name string in the `symbol_ref' (if one bit is not enough ! 271: information). ! 272: ! 273: The best way to modify the name string is by adding text to the ! 274: beginning, with suitable punctuation to prevent any ambiguity. ! 275: Allocate the new name in `saveable_obstack'. You will have to ! 276: modify `ASM_OUTPUT_LABELREF' to remove and decode the added text ! 277: and output the name accordingly. ! 278: ! 279: You can also check the information stored in the `symbol_ref' in ! 280: the definition of `GO_IF_LEGITIMATE_ADDRESS' or ! 281: `PRINT_OPERAND_ADDRESS'. */ ! 282: ! 283: #undef ENCODE_SECTION_INFO ! 284: #define ENCODE_SECTION_INFO(DECL) \ ! 285: do \ ! 286: { \ ! 287: if (HALF_PIC_P ()) \ ! 288: HALF_PIC_ENCODE (DECL); \ ! 289: } \ ! 290: while (0) ! 291: ! 292: ! 293: /* Given a decl node or constant node, choose the section to output it in ! 294: and select that section. */ ! 295: ! 296: #undef SELECT_RTX_SECTION ! 297: #define SELECT_RTX_SECTION(MODE, RTX) \ ! 298: do \ ! 299: { \ ! 300: if (MODE == Pmode && HALF_PIC_P () && HALF_PIC_ADDRESS_P (RTX)) \ ! 301: data_section (); \ ! 302: else \ ! 303: readonly_data_section (); \ ! 304: } \ ! 305: while (0) ! 306: ! 307: #undef SELECT_SECTION ! 308: #define SELECT_SECTION(DECL, RELOC) \ ! 309: { \ ! 310: if (RELOC && HALF_PIC_P ()) \ ! 311: data_section (); \ ! 312: \ ! 313: else if (TREE_CODE (DECL) == STRING_CST) \ ! 314: { \ ! 315: if (flag_writable_strings) \ ! 316: data_section (); \ ! 317: else \ ! 318: readonly_data_section (); \ ! 319: } \ ! 320: \ ! 321: else if (TREE_CODE (DECL) != VAR_DECL) \ ! 322: readonly_data_section (); \ ! 323: \ ! 324: else if (!TREE_READONLY (DECL)) \ ! 325: data_section (); \ ! 326: \ ! 327: else \ ! 328: readonly_data_section (); \ ! 329: } ! 330: ! 331: ! 332: /* Define the strings used for the special svr4 .type and .size directives. ! 333: These strings generally do not vary from one system running svr4 to ! 334: another, but if a given system (e.g. m88k running svr) needs to use ! 335: different pseudo-op names for these, they may be overridden in the ! 336: file which includes this one. */ ! 337: ! 338: #define TYPE_ASM_OP ".type" ! 339: #define SIZE_ASM_OP ".size" ! 340: #define WEAK_ASM_OP ".weak" ! 341: ! 342: /* The following macro defines the format used to output the second ! 343: operand of the .type assembler directive. Different svr4 assemblers ! 344: expect various different forms for this operand. The one given here ! 345: is just a default. You may need to override it in your machine- ! 346: specific tm.h file (depending upon the particulars of your assembler). */ ! 347: ! 348: #define TYPE_OPERAND_FMT "@%s" ! 349: ! 350: /* A C statement (sans semicolon) to output to the stdio stream ! 351: STREAM any text necessary for declaring the name NAME of an ! 352: initialized variable which is being defined. This macro must ! 353: output the label definition (perhaps using `ASM_OUTPUT_LABEL'). ! 354: The argument DECL is the `VAR_DECL' tree node representing the ! 355: variable. ! 356: ! 357: If this macro is not defined, then the variable name is defined ! 358: in the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). */ ! 359: ! 360: #undef ASM_DECLARE_OBJECT_NAME ! 361: #define ASM_DECLARE_OBJECT_NAME(STREAM, NAME, DECL) \ ! 362: do \ ! 363: { \ ! 364: ASM_OUTPUT_LABEL(STREAM,NAME); \ ! 365: HALF_PIC_DECLARE (NAME); \ ! 366: if (TARGET_ELF) \ ! 367: { \ ! 368: fprintf (STREAM, "\t%s\t ", TYPE_ASM_OP); \ ! 369: assemble_name (STREAM, NAME); \ ! 370: putc (',', STREAM); \ ! 371: fprintf (STREAM, TYPE_OPERAND_FMT, "object"); \ ! 372: putc ('\n', STREAM); \ ! 373: if (!flag_inhibit_size_directive) \ ! 374: { \ ! 375: fprintf (STREAM, "\t%s\t ", SIZE_ASM_OP); \ ! 376: assemble_name (STREAM, NAME); \ ! 377: fprintf (STREAM, ",%d\n", int_size_in_bytes (TREE_TYPE (decl))); \ ! 378: } \ ! 379: } \ ! 380: } \ ! 381: while (0) ! 382: ! 383: /* This is how to declare a function name. */ ! 384: ! 385: #undef ASM_DECLARE_FUNCTION_NAME ! 386: #define ASM_DECLARE_FUNCTION_NAME(STREAM,NAME,DECL) \ ! 387: do \ ! 388: { \ ! 389: ASM_OUTPUT_LABEL(STREAM,NAME); \ ! 390: HALF_PIC_DECLARE (NAME); \ ! 391: if (TARGET_ELF) \ ! 392: { \ ! 393: fprintf (STREAM, "\t%s\t ", TYPE_ASM_OP); \ ! 394: assemble_name (STREAM, NAME); \ ! 395: putc (',', STREAM); \ ! 396: fprintf (STREAM, TYPE_OPERAND_FMT, "function"); \ ! 397: putc ('\n', STREAM); \ ! 398: ASM_DECLARE_RESULT (STREAM, DECL_RESULT (DECL)); \ ! 399: } \ ! 400: } \ ! 401: while (0) ! 402: ! 403: /* Write the extra assembler code needed to declare a function's result. ! 404: Most svr4 assemblers don't require any special declaration of the ! 405: result value, but there are exceptions. */ ! 406: ! 407: #ifndef ASM_DECLARE_RESULT ! 408: #define ASM_DECLARE_RESULT(FILE, RESULT) ! 409: #endif ! 410: ! 411: /* This is how to declare the size of a function. */ ! 412: ! 413: #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ ! 414: do \ ! 415: { \ ! 416: if (TARGET_ELF && !flag_inhibit_size_directive) \ ! 417: { \ ! 418: char label[256]; \ ! 419: static int labelno; \ ! 420: labelno++; \ ! 421: ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno); \ ! 422: ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno); \ ! 423: fprintf (FILE, "/\t%s\t ", SIZE_ASM_OP); \ ! 424: assemble_name (FILE, (FNAME)); \ ! 425: fprintf (FILE, ","); \ ! 426: assemble_name (FILE, label); \ ! 427: fprintf (FILE, "-"); \ ! 428: assemble_name (FILE, (FNAME)); \ ! 429: putc ('\n', FILE); \ ! 430: } \ ! 431: } \ ! 432: while (0) ! 433: ! 434: /* Attach a special .ident directive to the end of the file to identify ! 435: the version of GCC which compiled this code. The format of the ! 436: .ident string is patterned after the ones produced by native svr4 ! 437: C compilers. */ ! 438: ! 439: #define IDENT_ASM_OP ".ident" ! 440: ! 441: /* Allow #sccs in preprocessor. */ ! 442: ! 443: #define SCCS_DIRECTIVE ! 444: ! 445: /* This says what to print at the end of the assembly file */ ! 446: #define ASM_FILE_END(STREAM) \ ! 447: do \ ! 448: { \ ! 449: if (HALF_PIC_P ()) \ ! 450: HALF_PIC_FINISH (STREAM); \ ! 451: \ ! 452: if (TARGET_IDENT) \ ! 453: { \ ! 454: fprintf ((STREAM), "\t%s\t\"GCC: (GNU) %s -O%d", \ ! 455: IDENT_ASM_OP, version_string, optimize); \ ! 456: \ ! 457: if (write_symbols == PREFERRED_DEBUGGING_TYPE) \ ! 458: fprintf ((STREAM), " -g%d", (int)debug_info_level); \ ! 459: \ ! 460: else if (write_symbols == DBX_DEBUG) \ ! 461: fprintf ((STREAM), " -gstabs%d", (int)debug_info_level); \ ! 462: \ ! 463: else if (write_symbols == DWARF_DEBUG) \ ! 464: fprintf ((STREAM), " -gdwarf%d", (int)debug_info_level); \ ! 465: \ ! 466: else if (write_symbols != NO_DEBUG) \ ! 467: fprintf ((STREAM), " -g??%d", (int)debug_info_level); \ ! 468: \ ! 469: if (flag_omit_frame_pointer) \ ! 470: fprintf ((STREAM), " -fomit-frame-pointer"); \ ! 471: \ ! 472: if (flag_strength_reduce) \ ! 473: fprintf ((STREAM), " -fstrength-reduce"); \ ! 474: \ ! 475: if (flag_unroll_loops) \ ! 476: fprintf ((STREAM), " -funroll-loops"); \ ! 477: \ ! 478: if (flag_force_mem) \ ! 479: fprintf ((STREAM), " -fforce-mem"); \ ! 480: \ ! 481: if (flag_force_addr) \ ! 482: fprintf ((STREAM), " -fforce-addr"); \ ! 483: \ ! 484: if (flag_inline_functions) \ ! 485: fprintf ((STREAM), " -finline-functions"); \ ! 486: \ ! 487: if (flag_caller_saves) \ ! 488: fprintf ((STREAM), " -fcaller-saves"); \ ! 489: \ ! 490: if (flag_pic) \ ! 491: fprintf ((STREAM), (flag_pic > 1) ? " -fPIC" : " -fpic"); \ ! 492: \ ! 493: if (flag_inhibit_size_directive) \ ! 494: fprintf ((STREAM), " -finhibit-size-directive"); \ ! 495: \ ! 496: if (flag_gnu_linker) \ ! 497: fprintf ((STREAM), " -fgnu-linker"); \ ! 498: \ ! 499: if (profile_flag) \ ! 500: fprintf ((STREAM), " -p"); \ ! 501: \ ! 502: if (profile_block_flag) \ ! 503: fprintf ((STREAM), " -a"); \ ! 504: \ ! 505: if (TARGET_IEEE_FP) \ ! 506: fprintf ((STREAM), " -mieee-fp"); \ ! 507: \ ! 508: if (TARGET_HALF_PIC) \ ! 509: fprintf ((STREAM), " -mhalf-pic"); \ ! 510: \ ! 511: fprintf ((STREAM), (TARGET_486) ? " -m486" : " -m386"); \ ! 512: fprintf ((STREAM), (TARGET_ELF) ? " -melf\"\n" : " -mrose\"\n"); \ ! 513: } \ ! 514: } \ ! 515: while (0) ! 516: ! 517: /* Tell collect that the object format is OSF/rose. */ ! 518: #define OBJECT_FORMAT_ROSE ! 519: ! 520: /* Tell collect where the appropriate binaries are. */ ! 521: #define REAL_LD_FILE_NAME "/usr/ccs/gcc/gld" ! 522: #define REAL_NM_FILE_NAME "/usr/ccs/bin/nm" ! 523: #define REAL_STRIP_FILE_NAME "/usr/ccs/bin/strip" ! 524: ! 525: /* Use atexit for static constructors/destructors, instead of defining ! 526: our own exit function. */ ! 527: #define HAVE_ATEXIT ! 528: ! 529: /* Define this macro meaning that gcc should find the library 'libgcc.a' ! 530: by hand, rather than passing the argument '-lgcc' to tell the linker ! 531: to do the search */ ! 532: #define LINK_LIBGCC_SPECIAL ! 533: ! 534: /* A C statement to output assembler commands which will identify the object ! 535: file as having been compile with GNU CC. We don't need or want this for ! 536: OSF1. GDB doesn't need it and kdb doesn't like it */ ! 537: #define ASM_IDENTIFY_GCC(FILE) ! 538: ! 539: /* Identify the front-end which produced this file. To keep symbol ! 540: space down, and not confuse kdb, only do this if the language is ! 541: not C. */ ! 542: ! 543: #define ASM_IDENTIFY_LANGUAGE(STREAM) \ ! 544: { \ ! 545: if (strcmp (lang_identify (), "c") != 0) \ ! 546: output_lang_identify (STREAM); \ ! 547: } ! 548: ! 549: /* This is how to output an assembler line defining a `double' constant. ! 550: Use "word" pseudos to avoid printing NaNs, infinity, etc. */ ! 551: ! 552: /* This is how to output an assembler line defining a `double' constant. */ ! 553: ! 554: #undef ASM_OUTPUT_DOUBLE ! 555: ! 556: #ifndef CROSS_COMPILE ! 557: #define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \ ! 558: do \ ! 559: { \ ! 560: long value_long[2]; \ ! 561: REAL_VALUE_TO_TARGET_DOUBLE (VALUE, value_long); \ ! 562: \ ! 563: fprintf (STREAM, "\t.long\t0x%08lx\t\t# %.20g\n\t.long\t0x%08lx\n", \ ! 564: value_long[0], VALUE, value_long[1]); \ ! 565: } \ ! 566: while (0) ! 567: ! 568: #else ! 569: #define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \ ! 570: fprintf (STREAM, "\t.double\t%.20g\n", VALUE) ! 571: #endif ! 572: ! 573: /* This is how to output an assembler line defining a `float' constant. */ ! 574: ! 575: #undef ASM_OUTPUT_FLOAT ! 576: ! 577: #ifndef CROSS_COMPILE ! 578: #define ASM_OUTPUT_FLOAT(STREAM, VALUE) \ ! 579: do \ ! 580: { \ ! 581: long value_long; \ ! 582: REAL_VALUE_TO_TARGET_SINGLE (VALUE, value_long); \ ! 583: \ ! 584: fprintf (STREAM, "\t.long\t0x%08lx\t\t# %.12g (float)\n", \ ! 585: value_long, VALUE); \ ! 586: } \ ! 587: while (0) ! 588: ! 589: #else ! 590: #define ASM_OUTPUT_FLOAT(STREAM, VALUE) \ ! 591: fprintf (STREAM, "\t.float\t%.12g\n", VALUE) ! 592: #endif ! 593: ! 594: ! 595: /* Generate calls to memcpy, etc., not bcopy, etc. */ ! 596: #define TARGET_MEM_FUNCTIONS ! 597: ! 598: /* Don't default to pcc-struct-return, because gcc is the only compiler, and ! 599: we want to retain compatibility with older gcc versions. */ ! 600: #define DEFAULT_PCC_STRUCT_RETURN 0 ! 601: ! 602: /* Map i386 registers to the numbers dwarf expects. Of course this is different ! 603: from what stabs expects. */ ! 604: ! 605: #define DWARF_DBX_REGISTER_NUMBER(n) \ ! 606: ((n) == 0 ? 0 \ ! 607: : (n) == 1 ? 2 \ ! 608: : (n) == 2 ? 1 \ ! 609: : (n) == 3 ? 3 \ ! 610: : (n) == 4 ? 6 \ ! 611: : (n) == 5 ? 7 \ ! 612: : (n) == 6 ? 5 \ ! 613: : (n) == 7 ? 4 \ ! 614: : ((n) >= FIRST_STACK_REG && (n) <= LAST_STACK_REG) ? (n)+3 \ ! 615: : (-1)) ! 616: ! 617: /* Now what stabs expects in the register. */ ! 618: #define STABS_DBX_REGISTER_NUMBER(n) \ ! 619: ((n) == 0 ? 0 : \ ! 620: (n) == 1 ? 2 : \ ! 621: (n) == 2 ? 1 : \ ! 622: (n) == 3 ? 3 : \ ! 623: (n) == 4 ? 6 : \ ! 624: (n) == 5 ? 7 : \ ! 625: (n) == 6 ? 4 : \ ! 626: (n) == 7 ? 5 : \ ! 627: (n) + 4) ! 628: ! 629: #undef DBX_REGISTER_NUMBER ! 630: #define DBX_REGISTER_NUMBER(n) ((write_symbols == DWARF_DEBUG) \ ! 631: ? DWARF_DBX_REGISTER_NUMBER(n) \ ! 632: : STABS_DBX_REGISTER_NUMBER(n))
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.