home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gcc-2.4.5 / config / i386 / osfrose.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-10  |  19.6 KB  |  633 lines
  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))
  633.