* config/rs6000/linux64.h (SET_CMODEL): Don't expand to empty.

[pf3gnuchains/gcc-fork.git] / gcc / config / rs6000 / linux64.h

diff --git a/gcc/config/rs6000/linux64.h b/gcc/config/rs6000/linux64.h
index 338143c..c4e3651 100644 (file)
--- a/gcc/config/rs6000/linux64.h
+++ b/gcc/config/rs6000/linux64.h
@@ -1,12 +1,13 @@
 /* Definitions of target machine for GNU compiler,
    for 64 bit PowerPC linux.
 /* Definitions of target machine for GNU compiler,
    for 64 bit PowerPC linux.

-   Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+   2009, 2010  Free Software Foundation, Inc.

 
    This file is part of GCC.
 
    GCC is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published
 
    This file is part of GCC.
 
    GCC is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published

-   by the Free Software Foundation; either version 2, or (at your
+   by the Free Software Foundation; either version 3, or (at your

    option) any later version.
 
    GCC is distributed in the hope that it will be useful, but WITHOUT
    option) any later version.
 
    GCC is distributed in the hope that it will be useful, but WITHOUT


@@ -14,10 +15,14 @@
    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
    License for more details.
 
    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
    License for more details.
 

-   You should have received a copy of the GNU General Public License
-   along with GCC; see the file COPYING.  If not, write to the
-   Free Software Foundation, 59 Temple Place - Suite 330, Boston,
-   MA 02111-1307, USA.  */
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */

 
 #ifndef RS6000_BI_ARCH
 
 
 #ifndef RS6000_BI_ARCH
 


@@ -49,14 +54,38 @@
 #undef TARGET_AIX
 #define        TARGET_AIX TARGET_64BIT
 
 #undef TARGET_AIX
 #define        TARGET_AIX TARGET_64BIT
 

-#undef PROCESSOR_DEFAULT64
-#define PROCESSOR_DEFAULT64 PROCESSOR_PPC630
+#ifdef HAVE_LD_NO_DOT_SYMS
+/* New ABI uses a local sym for the function entry point.  */
+extern int dot_symbols;
+#undef DOT_SYMBOLS
+#define DOT_SYMBOLS dot_symbols
+#endif

 
 

-#undef TARGET_RELOCATABLE
-#define        TARGET_RELOCATABLE (!TARGET_64BIT && (target_flags & MASK_RELOCATABLE))
+#define TARGET_PROFILE_KERNEL profile_kernel
+
+#define TARGET_USES_LINUX64_OPT 1
+#ifdef HAVE_LD_LARGE_TOC
+extern enum rs6000_cmodel cmodel;
+#undef TARGET_CMODEL
+#define TARGET_CMODEL cmodel
+#define SET_CMODEL(opt) cmodel = opt
+#else
+#define SET_CMODEL(opt) do {} while (0)
+#endif
+
+#undef  PROCESSOR_DEFAULT
+#define PROCESSOR_DEFAULT PROCESSOR_POWER6
+#undef  PROCESSOR_DEFAULT64
+#define PROCESSOR_DEFAULT64 PROCESSOR_POWER6
+
+/* We don't need to generate entries in .fixup, except when
+   -mrelocatable or -mrelocatable-lib is given.  */
+#undef RELOCATABLE_NEEDS_FIXUP
+#define RELOCATABLE_NEEDS_FIXUP \
+  (target_flags & target_flags_explicit & MASK_RELOCATABLE)

 
 #undef RS6000_ABI_NAME
 
 #undef RS6000_ABI_NAME

-#define        RS6000_ABI_NAME (TARGET_64BIT ? "aixdesc" : "sysv")
+#define        RS6000_ABI_NAME "linux"

 
 #define INVALID_64BIT "-m%s not supported in this configuration"
 #define INVALID_32BIT INVALID_64BIT
 
 #define INVALID_64BIT "-m%s not supported in this configuration"
 #define INVALID_32BIT INVALID_64BIT


@@ -65,7 +94,7 @@
 #define        SUBSUBTARGET_OVERRIDE_OPTIONS                           \
   do                                                           \
     {                                                          \
 #define        SUBSUBTARGET_OVERRIDE_OPTIONS                           \
   do                                                           \
     {                                                          \

-      if (rs6000_alignment_string == 0)                                \
+      if (!rs6000_explicit_options.alignment)                  \

        rs6000_alignment_flags = MASK_ALIGN_NATURAL;            \
       if (TARGET_64BIT)                                                \
        {                                                       \
        rs6000_alignment_flags = MASK_ALIGN_NATURAL;            \
       if (TARGET_64BIT)                                                \
        {                                                       \


@@ -74,6 +103,7 @@
              rs6000_current_abi = ABI_AIX;                     \
              error (INVALID_64BIT, "call");                    \
            }                                                   \
              rs6000_current_abi = ABI_AIX;                     \
              error (INVALID_64BIT, "call");                    \
            }                                                   \

+         dot_symbols = !strcmp (rs6000_abi_name, "aixdesc");   \

          if (target_flags & MASK_RELOCATABLE)                  \
            {                                                   \
              target_flags &= ~MASK_RELOCATABLE;                \
          if (target_flags & MASK_RELOCATABLE)                  \
            {                                                   \
              target_flags &= ~MASK_RELOCATABLE;                \


@@ -84,16 +114,48 @@
              target_flags &= ~MASK_EABI;                       \
              error (INVALID_64BIT, "eabi");                    \
            }                                                   \
              target_flags &= ~MASK_EABI;                       \
              error (INVALID_64BIT, "eabi");                    \
            }                                                   \

-         if (target_flags & MASK_PROTOTYPE)                    \
+         if (TARGET_PROTOTYPE)                                 \

            {                                                   \
            {                                                   \

-             target_flags &= ~MASK_PROTOTYPE;                  \
+             target_prototype = 0;                             \

              error (INVALID_64BIT, "prototype");               \
            }                                                   \
              error (INVALID_64BIT, "prototype");               \
            }                                                   \

+         if ((target_flags & MASK_POWERPC64) == 0)             \
+           {                                                   \
+             target_flags |= MASK_POWERPC64;                   \
+             error ("-m64 requires a PowerPC64 cpu");          \
+           }                                                   \
+         if ((target_flags_explicit & MASK_MINIMAL_TOC) != 0)  \
+           {                                                   \
+             if (rs6000_explicit_options.cmodel                \
+                 && cmodel != CMODEL_SMALL)                    \
+               error ("-mcmodel incompatible with other toc options"); \
+             SET_CMODEL (CMODEL_SMALL);                        \
+           }                                                   \
+         else                                                  \
+           {                                                   \
+             if (!rs6000_explicit_options.cmodel)              \
+               SET_CMODEL (CMODEL_MEDIUM);                     \
+             if (cmodel != CMODEL_SMALL)                       \
+               {                                               \
+                 TARGET_NO_FP_IN_TOC = 0;                      \
+                 TARGET_NO_SUM_IN_TOC = 0;                     \
+               }                                               \
+           }                                                   \

        }                                                       \
       else                                                     \
        {                                                       \
          if (!RS6000_BI_ARCH_P)                                \
            error (INVALID_32BIT, "32");                        \
        }                                                       \
       else                                                     \
        {                                                       \
          if (!RS6000_BI_ARCH_P)                                \
            error (INVALID_32BIT, "32");                        \

+         if (TARGET_PROFILE_KERNEL)                            \
+           {                                                   \
+             TARGET_PROFILE_KERNEL = 0;                        \
+             error (INVALID_32BIT, "profile-kernel");          \
+           }                                                   \
+         if (rs6000_explicit_options.cmodel)                   \
+           {                                                   \
+             SET_CMODEL (CMODEL_SMALL);                        \
+             error (INVALID_32BIT, "cmodel");                  \
+           }                                                   \

        }                                                       \
     }                                                          \
   while (0)
        }                                                       \
     }                                                          \
   while (0)


@@ -111,25 +173,29 @@
 #undef ASM_SPEC
 #undef LINK_OS_LINUX_SPEC
 
 #undef ASM_SPEC
 #undef LINK_OS_LINUX_SPEC
 

+/* FIXME: This will quite possibly choose the wrong dynamic linker.  */
+#undef LINK_OS_GNU_SPEC
+#define        LINK_OS_GNU_SPEC LINK_OS_LINUX_SPEC
+

 #ifndef        RS6000_BI_ARCH
 #define        ASM_DEFAULT_SPEC "-mppc64"
 #ifndef        RS6000_BI_ARCH
 #define        ASM_DEFAULT_SPEC "-mppc64"

-#define        ASM_SPEC         "%(asm_spec64) %(asm_spec_common)"
+#define        ASM_SPEC         "%(asm_spec64) %(asm_spec_common)"

 #define        LINK_OS_LINUX_SPEC "%(link_os_linux_spec64)"
 #else
 #if DEFAULT_ARCH64_P
 #define        ASM_DEFAULT_SPEC "-mppc%{!m32:64}"
 #define        LINK_OS_LINUX_SPEC "%(link_os_linux_spec64)"
 #else
 #if DEFAULT_ARCH64_P
 #define        ASM_DEFAULT_SPEC "-mppc%{!m32:64}"

-#define        ASM_SPEC         "%{m32:%(asm_spec32)}%{!m32:%(asm_spec64)} %(asm_spec_common)"
+#define        ASM_SPEC         "%{m32:%(asm_spec32)}%{!m32:%(asm_spec64)} %(asm_spec_common)"

 #define        LINK_OS_LINUX_SPEC "%{m32:%(link_os_linux_spec32)}%{!m32:%(link_os_linux_spec64)}"
 #else
 #define        ASM_DEFAULT_SPEC "-mppc%{m64:64}"
 #define        LINK_OS_LINUX_SPEC "%{m32:%(link_os_linux_spec32)}%{!m32:%(link_os_linux_spec64)}"
 #else
 #define        ASM_DEFAULT_SPEC "-mppc%{m64:64}"

-#define        ASM_SPEC         "%{!m64:%(asm_spec32)}%{m64:%(asm_spec64)} %(asm_spec_common)"
+#define        ASM_SPEC         "%{!m64:%(asm_spec32)}%{m64:%(asm_spec64)} %(asm_spec_common)"

 #define        LINK_OS_LINUX_SPEC "%{!m64:%(link_os_linux_spec32)}%{m64:%(link_os_linux_spec64)}"
 #endif
 #endif
 
 #define ASM_SPEC32 "-a32 %{n} %{T} %{Ym,*} %{Yd,*} \
 %{mrelocatable} %{mrelocatable-lib} %{fpic:-K PIC} %{fPIC:-K PIC} \
 #define        LINK_OS_LINUX_SPEC "%{!m64:%(link_os_linux_spec32)}%{m64:%(link_os_linux_spec64)}"
 #endif
 #endif
 
 #define ASM_SPEC32 "-a32 %{n} %{T} %{Ym,*} %{Yd,*} \
 %{mrelocatable} %{mrelocatable-lib} %{fpic:-K PIC} %{fPIC:-K PIC} \

-%{memb} %{!memb: %{msdata: -memb} %{msdata=eabi: -memb}} \
+%{memb} %{!memb: %{msdata=eabi: -memb}} \

 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
     %{mcall-freebsd: -mbig} \
     %{mcall-i960-old: -mlittle} \
 %{!mlittle: %{!mlittle-endian: %{!mbig: %{!mbig-endian: \
     %{mcall-freebsd: -mbig} \
     %{mcall-i960-old: -mlittle} \


@@ -141,7 +207,7 @@
 #define ASM_SPEC64 "-a64"
 
 #define ASM_SPEC_COMMON "%(asm_cpu) \
 #define ASM_SPEC64 "-a64"
 
 #define ASM_SPEC_COMMON "%(asm_cpu) \

-%{.s: %{mregnames} %{mno-regnames}} %{.S: %{mregnames} %{mno-regnames}} \
+%{,assembler|,assembler-with-cpp: %{mregnames} %{mno-regnames}} \

 %{v:-V} %{Qy:} %{!Qn:-Qy} %{Wa,*:%*} \
 %{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian}"
 
 %{v:-V} %{Qy:} %{!Qn:-Qy} %{Wa,*:%*} \
 %{mlittle} %{mlittle-endian} %{mbig} %{mbig-endian}"
 


@@ -177,33 +243,16 @@
 #define        TARGET_EABI             0
 #undef TARGET_PROTOTYPE
 #define        TARGET_PROTOTYPE        0
 #define        TARGET_EABI             0
 #undef TARGET_PROTOTYPE
 #define        TARGET_PROTOTYPE        0

+#undef RELOCATABLE_NEEDS_FIXUP
+#define RELOCATABLE_NEEDS_FIXUP 0

 
 #endif
 
 
 #endif
 

-#define        MASK_PROFILE_KERNEL     0x00080000
-
-/* Non-standard profiling for kernels, which just saves LR then calls
-   _mcount without worrying about arg saves.  The idea is to change
-   the function prologue as little as possible as it isn't easy to
-   account for arg save/restore code added just for _mcount.  */
-#define TARGET_PROFILE_KERNEL  (target_flags & MASK_PROFILE_KERNEL)
-
-/* Override sysv4.h.  */
-#undef EXTRA_SUBTARGET_SWITCHES
-#define EXTRA_SUBTARGET_SWITCHES                                       \
-  {"profile-kernel",    MASK_PROFILE_KERNEL,                           \
-   N_("Call mcount for profiling before a function prologue") },       \
-  {"no-profile-kernel",        -MASK_PROFILE_KERNEL,                           \
-   N_("Call mcount for profiling after a function prologue") },
-

 /* We use glibc _mcount for profiling.  */
 /* We use glibc _mcount for profiling.  */

-#define NO_PROFILE_COUNTERS TARGET_64BIT
+#define NO_PROFILE_COUNTERS 1

 #define PROFILE_HOOK(LABEL) \
   do { if (TARGET_64BIT) output_profile_hook (LABEL); } while (0)
 
 #define PROFILE_HOOK(LABEL) \
   do { if (TARGET_64BIT) output_profile_hook (LABEL); } while (0)
 

-/* We don't need to generate entries in .fixup.  */
-#undef RELOCATABLE_NEEDS_FIXUP
-

 /* PowerPC64 Linux word-aligns FP doubles when -malign-power is given.  */
 #undef  ADJUST_FIELD_ALIGN
 #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \
 /* PowerPC64 Linux word-aligns FP doubles when -malign-power is given.  */
 #undef  ADJUST_FIELD_ALIGN
 #define ADJUST_FIELD_ALIGN(FIELD, COMPUTED) \


@@ -211,28 +260,28 @@
    ? 128                                                               \
    : (TARGET_64BIT                                                     \
       && TARGET_ALIGN_NATURAL == 0                                     \
    ? 128                                                               \
    : (TARGET_64BIT                                                     \
       && TARGET_ALIGN_NATURAL == 0                                     \

-      && TYPE_MODE (TREE_CODE (TREE_TYPE (FIELD)) == ARRAY_TYPE                \
-                   ? get_inner_array_type (FIELD)                      \
-                   : TREE_TYPE (FIELD)) == DFmode)                     \
+      && TYPE_MODE (strip_array_types (TREE_TYPE (FIELD))) == DFmode)  \

    ? MIN ((COMPUTED), 32)                                              \
    : (COMPUTED))
 
 /* PowerPC64 Linux increases natural record alignment to doubleword if
    ? MIN ((COMPUTED), 32)                                              \
    : (COMPUTED))
 
 /* PowerPC64 Linux increases natural record alignment to doubleword if

-   the first field is an FP double.  */
+   the first field is an FP double, only if in power alignment mode.  */

 #undef  ROUND_TYPE_ALIGN
 #undef  ROUND_TYPE_ALIGN

-#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED)          \
-  ((TARGET_ALTIVEC && TREE_CODE (STRUCT) == VECTOR_TYPE)       \
-   ? MAX (MAX ((COMPUTED), (SPECIFIED)), 128)                  \
-   : (TARGET_64BIT                                             \
-      && (TREE_CODE (STRUCT) == RECORD_TYPE                    \
-         || TREE_CODE (STRUCT) == UNION_TYPE                   \
-         || TREE_CODE (STRUCT) == QUAL_UNION_TYPE)             \
-      && TYPE_FIELDS (STRUCT) != 0                             \
-      && TARGET_ALIGN_NATURAL == 0                             \
-      && DECL_MODE (TYPE_FIELDS (STRUCT)) == DFmode)           \
-   ? MAX (MAX ((COMPUTED), (SPECIFIED)), 64)                   \
+#define ROUND_TYPE_ALIGN(STRUCT, COMPUTED, SPECIFIED)                  \
+  ((TARGET_64BIT                                                       \
+    && (TREE_CODE (STRUCT) == RECORD_TYPE                              \
+       || TREE_CODE (STRUCT) == UNION_TYPE                             \
+       || TREE_CODE (STRUCT) == QUAL_UNION_TYPE)                       \
+    && TARGET_ALIGN_NATURAL == 0)                                      \
+   ? rs6000_special_round_type_align (STRUCT, COMPUTED, SPECIFIED)     \

    : MAX ((COMPUTED), (SPECIFIED)))
 
    : MAX ((COMPUTED), (SPECIFIED)))
 

+/* Use the default for compiling target libs.  */
+#ifdef IN_TARGET_LIBS
+#undef TARGET_ALIGN_NATURAL
+#define TARGET_ALIGN_NATURAL 1
+#endif
+

 /* Indicate that jump tables go in the text section.  */
 #undef  JUMP_TABLES_IN_TEXT_SECTION
 #define JUMP_TABLES_IN_TEXT_SECTION TARGET_64BIT
 /* Indicate that jump tables go in the text section.  */
 #undef  JUMP_TABLES_IN_TEXT_SECTION
 #define JUMP_TABLES_IN_TEXT_SECTION TARGET_64BIT


@@ -241,7 +290,7 @@
    than a doubleword should be padded upward or downward.  You could
    reasonably assume that they follow the normal rules for structure
    layout treating the parameter area as any other block of memory,
    than a doubleword should be padded upward or downward.  You could
    reasonably assume that they follow the normal rules for structure
    layout treating the parameter area as any other block of memory,

-   then map the reg param area to registers.  ie. pad updard.
+   then map the reg param area to registers.  i.e. pad upward.

    Setting both of the following defines results in this behavior.
    Setting just the first one will result in aggregates that fit in a
    doubleword being padded downward, and others being padded upward.
    Setting both of the following defines results in this behavior.
    Setting just the first one will result in aggregates that fit in a
    doubleword being padded downward, and others being padded upward.


@@ -250,16 +299,6 @@
 #define AGGREGATE_PADDING_FIXED TARGET_64BIT
 #define AGGREGATES_PAD_UPWARD_ALWAYS 0
 
 #define AGGREGATE_PADDING_FIXED TARGET_64BIT
 #define AGGREGATES_PAD_UPWARD_ALWAYS 0
 

-/* We don't want anything in the reg parm area being passed on the
-   stack.  */
-#define MUST_PASS_IN_STACK(MODE, TYPE)                         \
-  ((TARGET_64BIT                                               \
-    && (TYPE) != 0                                             \
-    && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST            \
-       || TREE_ADDRESSABLE (TYPE)))                            \
-   || (!TARGET_64BIT                                           \
-       && default_must_pass_in_stack ((MODE), (TYPE))))
-

 /* Specify padding for the last element of a block move between
    registers and memory.  FIRST is nonzero if this is the only
    element.  */
 /* Specify padding for the last element of a block move between
    registers and memory.  FIRST is nonzero if this is the only
    element.  */


@@ -278,12 +317,22 @@
 #undef MD_EXEC_PREFIX
 #undef MD_STARTFILE_PREFIX
 
 #undef MD_EXEC_PREFIX
 #undef MD_STARTFILE_PREFIX
 

-/* Override sysv4.h  */
-#undef CPP_SYSV_SPEC
-#define        CPP_SYSV_SPEC ""
+/* Linux doesn't support saving and restoring 64-bit regs in a 32-bit
+   process.  */
+#define OS_MISSING_POWERPC64 !TARGET_64BIT
+
+#define OPTION_GLIBC  (linux_libc == LIBC_GLIBC)
+
+/* glibc has float and long double forms of math functions.  */
+#undef  TARGET_C99_FUNCTIONS
+#define TARGET_C99_FUNCTIONS (OPTION_GLIBC)
+
+/* Whether we have sincos that follows the GNU extension.  */
+#undef  TARGET_HAS_SINCOS
+#define TARGET_HAS_SINCOS (OPTION_GLIBC)

 
 #undef  TARGET_OS_CPP_BUILTINS
 
 #undef  TARGET_OS_CPP_BUILTINS

-#define TARGET_OS_CPP_BUILTINS()                       \
+#define TARGET_OS_CPP_BUILTINS()                       \

   do                                                   \
     {                                                  \
       if (TARGET_64BIT)                                        \
   do                                                   \
     {                                                  \
       if (TARGET_64BIT)                                        \


@@ -292,7 +341,6 @@
          builtin_define ("__PPC64__");                 \
          builtin_define ("__powerpc__");               \
          builtin_define ("__powerpc64__");             \
          builtin_define ("__PPC64__");                 \
          builtin_define ("__powerpc__");               \
          builtin_define ("__powerpc64__");             \

-         builtin_define ("__PIC__");                   \

          builtin_assert ("cpu=powerpc64");             \
          builtin_assert ("machine=powerpc64");         \
        }                                               \
          builtin_assert ("cpu=powerpc64");             \
          builtin_assert ("machine=powerpc64");         \
        }                                               \


@@ -334,13 +382,30 @@
 #undef LINK_OS_DEFAULT_SPEC
 #define LINK_OS_DEFAULT_SPEC "%(link_os_linux)"
 
 #undef LINK_OS_DEFAULT_SPEC
 #define LINK_OS_DEFAULT_SPEC "%(link_os_linux)"
 

+#define GLIBC_DYNAMIC_LINKER32 "/lib/ld.so.1"
+#define GLIBC_DYNAMIC_LINKER64 "/lib64/ld64.so.1"
+#define UCLIBC_DYNAMIC_LINKER32 "/lib/ld-uClibc.so.0"
+#define UCLIBC_DYNAMIC_LINKER64 "/lib/ld64-uClibc.so.0"
+#if DEFAULT_LIBC == LIBC_UCLIBC
+#define CHOOSE_DYNAMIC_LINKER(G, U) "%{mglibc:" G ";:" U "}"
+#elif DEFAULT_LIBC == LIBC_GLIBC
+#define CHOOSE_DYNAMIC_LINKER(G, U) "%{muclibc:" U ";:" G "}"
+#else
+#error "Unsupported DEFAULT_LIBC"
+#endif
+#define LINUX_DYNAMIC_LINKER32 \
+  CHOOSE_DYNAMIC_LINKER (GLIBC_DYNAMIC_LINKER32, UCLIBC_DYNAMIC_LINKER32)
+#define LINUX_DYNAMIC_LINKER64 \
+  CHOOSE_DYNAMIC_LINKER (GLIBC_DYNAMIC_LINKER64, UCLIBC_DYNAMIC_LINKER64)
+
+

 #define LINK_OS_LINUX_SPEC32 "-m elf32ppclinux %{!shared: %{!static: \
   %{rdynamic:-export-dynamic} \
 #define LINK_OS_LINUX_SPEC32 "-m elf32ppclinux %{!shared: %{!static: \
   %{rdynamic:-export-dynamic} \

-  %{!dynamic-linker:-dynamic-linker /lib/ld.so.1}}}"
+  %{!dynamic-linker:-dynamic-linker " LINUX_DYNAMIC_LINKER32 "}}}"

 
 #define LINK_OS_LINUX_SPEC64 "-m elf64ppc %{!shared: %{!static: \
   %{rdynamic:-export-dynamic} \
 
 #define LINK_OS_LINUX_SPEC64 "-m elf64ppc %{!shared: %{!static: \
   %{rdynamic:-export-dynamic} \

-  %{!dynamic-linker:-dynamic-linker /lib64/ld64.so.1}}}"
+  %{!dynamic-linker:-dynamic-linker " LINUX_DYNAMIC_LINKER64 "}}}"

 
 #undef  TOC_SECTION_ASM_OP
 #define TOC_SECTION_ASM_OP \
 
 #undef  TOC_SECTION_ASM_OP
 #define TOC_SECTION_ASM_OP \


@@ -391,22 +456,30 @@
    object files, each potentially with a different TOC pointer.  For
    that reason, place a nop after the call so that the linker can
    restore the TOC pointer if a TOC adjusting call stub is needed.  */
    object files, each potentially with a different TOC pointer.  For
    that reason, place a nop after the call so that the linker can
    restore the TOC pointer if a TOC adjusting call stub is needed.  */

+#if DOT_SYMBOLS

 #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)     \
   asm (SECTION_OP "\n"                                 \
 "      bl ." #FUNC "\n"                                \
 "      nop\n"                                          \
 "      .previous");
 #define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)     \
   asm (SECTION_OP "\n"                                 \
 "      bl ." #FUNC "\n"                                \
 "      nop\n"                                          \
 "      .previous");

+#else
+#define CRT_CALL_STATIC_FUNCTION(SECTION_OP, FUNC)     \
+  asm (SECTION_OP "\n"                                 \
+"      bl " #FUNC "\n"                                 \
+"      nop\n"                                          \
+"      .previous");
+#endif

 #endif
 
 /* FP save and restore routines.  */
 #undef  SAVE_FP_PREFIX
 #define SAVE_FP_PREFIX (TARGET_64BIT ? "._savef" : "_savefpr_")
 #undef  SAVE_FP_SUFFIX
 #endif
 
 /* FP save and restore routines.  */
 #undef  SAVE_FP_PREFIX
 #define SAVE_FP_PREFIX (TARGET_64BIT ? "._savef" : "_savefpr_")
 #undef  SAVE_FP_SUFFIX

-#define SAVE_FP_SUFFIX (TARGET_64BIT ? "" : "_l")
+#define SAVE_FP_SUFFIX ""

 #undef  RESTORE_FP_PREFIX
 #define RESTORE_FP_PREFIX (TARGET_64BIT ? "._restf" : "_restfpr_")
 #undef  RESTORE_FP_SUFFIX
 #undef  RESTORE_FP_PREFIX
 #define RESTORE_FP_PREFIX (TARGET_64BIT ? "._restf" : "_restfpr_")
 #undef  RESTORE_FP_SUFFIX

-#define RESTORE_FP_SUFFIX (TARGET_64BIT ? "" : "_l")
+#define RESTORE_FP_SUFFIX ""

 
 /* Dwarf2 debugging.  */
 #undef  PREFERRED_DEBUGGING_TYPE
 
 /* Dwarf2 debugging.  */
 #undef  PREFERRED_DEBUGGING_TYPE


@@ -420,13 +493,11 @@
       if (!flag_inhibit_size_directive)                                        \
        {                                                               \
          fputs ("\t.size\t", (FILE));                                  \
       if (!flag_inhibit_size_directive)                                        \
        {                                                               \
          fputs ("\t.size\t", (FILE));                                  \

-         if (TARGET_64BIT)                                             \
+         if (TARGET_64BIT && DOT_SYMBOLS)                              \

            putc ('.', (FILE));                                         \
          assemble_name ((FILE), (FNAME));                              \
          fputs (",.-", (FILE));                                        \
            putc ('.', (FILE));                                         \
          assemble_name ((FILE), (FNAME));                              \
          fputs (",.-", (FILE));                                        \

-         if (TARGET_64BIT)                                             \
-           putc ('.', (FILE));                                         \
-         assemble_name ((FILE), (FNAME));                              \
+         rs6000_output_function_entry (FILE, FNAME);                   \

          putc ('\n', (FILE));                                          \
        }                                                               \
     }                                                                  \
          putc ('\n', (FILE));                                          \
        }                                                               \
     }                                                                  \


@@ -438,9 +509,8 @@
    we also do this for floating-point constants.  We actually can only
    do this if the FP formats of the target and host machines are the
    same, but we can't check that since not every file that uses
    we also do this for floating-point constants.  We actually can only
    do this if the FP formats of the target and host machines are the
    same, but we can't check that since not every file that uses

-   GO_IF_LEGITIMATE_ADDRESS_P includes real.h.  We also do this when
-   we can write the entry into the TOC and the entry is not larger
-   than a TOC entry.  */
+   the macros includes real.h.  We also do this when we can write the
+   entry into the TOC and the entry is not larger than a TOC entry.  */

 
 #undef  ASM_OUTPUT_SPECIAL_POOL_ENTRY_P
 #define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE)                       \
 
 #undef  ASM_OUTPUT_SPECIAL_POOL_ENTRY_P
 #define ASM_OUTPUT_SPECIAL_POOL_ENTRY_P(X, MODE)                       \


@@ -453,74 +523,15 @@
           && GET_MODE_BITSIZE (MODE) <= GET_MODE_BITSIZE (Pmode))      \
        || (GET_CODE (X) == CONST_DOUBLE                                        \
           && ((TARGET_64BIT                                            \
           && GET_MODE_BITSIZE (MODE) <= GET_MODE_BITSIZE (Pmode))      \
        || (GET_CODE (X) == CONST_DOUBLE                                        \
           && ((TARGET_64BIT                                            \

-               && (TARGET_POWERPC64                                    \
-                   || TARGET_MINIMAL_TOC                               \
-                   || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT     \
+               && (TARGET_MINIMAL_TOC                                  \
+                   || (SCALAR_FLOAT_MODE_P (GET_MODE (X))              \

                        && ! TARGET_NO_FP_IN_TOC)))                     \
               || (!TARGET_64BIT                                        \
                   && !TARGET_NO_FP_IN_TOC                              \
                   && !TARGET_RELOCATABLE                               \
                        && ! TARGET_NO_FP_IN_TOC)))                     \
               || (!TARGET_64BIT                                        \
                   && !TARGET_NO_FP_IN_TOC                              \
                   && !TARGET_RELOCATABLE                               \

-                  && GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT       \
+                  && SCALAR_FLOAT_MODE_P (GET_MODE (X))                \

                   && BITS_PER_WORD == HOST_BITS_PER_INT)))))
 
                   && BITS_PER_WORD == HOST_BITS_PER_INT)))))
 

-/* This is the same as the dbxelf.h version, except that we need to
-   use the function code label, not the function descriptor.  */
-#undef ASM_OUTPUT_SOURCE_LINE
-#define        ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER)                     \
-do                                                                     \
-  {                                                                    \
-    char temp[256];                                                    \
-    ASM_GENERATE_INTERNAL_LABEL (temp, "LM", COUNTER);                 \
-    fprintf (FILE, "\t.stabn 68,0,%d,", LINE);                         \
-    assemble_name (FILE, temp);                                                \
-    putc ('-', FILE);                                                  \
-    if (TARGET_64BIT)                                                  \
-      putc ('.', FILE);                                                        \
-    assemble_name (FILE,                                               \
-                  XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
-    putc ('\n', FILE);                                                 \
-    (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER);           \
-  }                                                                    \
-while (0)
-
-/* Similarly, we want the function code label here.  */
-#define DBX_OUTPUT_BRAC(FILE, NAME, BRAC) \
-  do                                                                   \
-    {                                                                  \
-      const char *flab;                                                        \
-      fprintf (FILE, "%s%d,0,0,", ASM_STABN_OP, BRAC);                 \
-      assemble_name (FILE, NAME);                                      \
-      putc ('-', FILE);                                                        \
-      if (current_function_func_begin_label != NULL_TREE)              \
-       flab = IDENTIFIER_POINTER (current_function_func_begin_label);  \
-      else                                                             \
-       {                                                               \
-         if (TARGET_64BIT)                                             \
-           putc ('.', FILE);                                           \
-         flab = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);  \
-       }                                                               \
-      assemble_name (FILE, flab);                                      \
-      putc ('\n', FILE);                                               \
-    }                                                                  \
-  while (0)
-
-#define DBX_OUTPUT_LBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_LBRAC)
-#define DBX_OUTPUT_RBRAC(FILE, NAME) DBX_OUTPUT_BRAC (FILE, NAME, N_RBRAC)
-
-/* Another case where we want the dot name.  */
-#define        DBX_OUTPUT_NFUN(FILE, LSCOPE, DECL)                             \
-  do                                                                   \
-    {                                                                  \
-      fprintf (FILE, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);           \
-      assemble_name (FILE, LSCOPE);                                    \
-      putc ('-', FILE);                                                        \
-      if (TARGET_64BIT)                                                        \
-        putc ('.', FILE);                                              \
-      assemble_name (FILE, XSTR (XEXP (DECL_RTL (DECL), 0), 0));       \
-      putc ('\n', FILE);                                               \
-    }                                                                  \
-  while (0)
-

 /* Select a format to encode pointers in exception handling data.  CODE
    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
    true if the symbol may be affected by dynamic relocations.  */
 /* Select a format to encode pointers in exception handling data.  CODE
    is 0 for data, 1 for code labels, 2 for function pointers.  GLOBAL is
    true if the symbol may be affected by dynamic relocations.  */


@@ -536,175 +547,29 @@ while (0)
 #undef DRAFT_V4_STRUCT_RET
 #define DRAFT_V4_STRUCT_RET (!TARGET_64BIT)
 
 #undef DRAFT_V4_STRUCT_RET
 #define DRAFT_V4_STRUCT_RET (!TARGET_64BIT)
 

-#define TARGET_ASM_FILE_END file_end_indicate_exec_stack
+#define TARGET_ASM_FILE_END rs6000_elf_end_indicate_exec_stack
+
+#define TARGET_POSIX_IO

 
 #define LINK_GCC_C_SEQUENCE_SPEC \
   "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}"
 
 
 #define LINK_GCC_C_SEQUENCE_SPEC \
   "%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}"
 

-/* Do code reading to identify a signal frame, and set the frame
-   state data appropriately.  See unwind-dw2.c for the structs.  */
-
-#ifdef IN_LIBGCC2
-#include <signal.h>
-#include <sys/ucontext.h>
-
-#ifdef __powerpc64__
-enum { SIGNAL_FRAMESIZE = 128 };
-#else
-enum { SIGNAL_FRAMESIZE = 64 };
-#endif
+/* Use --as-needed -lgcc_s for eh support.  */
+#ifdef HAVE_LD_AS_NEEDED
+#define USE_LD_AS_NEEDED 1

 #endif
 
 #endif
 

-#ifdef __powerpc64__
-
-/* If the current unwind info (FS) does not contain explicit info
-   saving R2, then we have to do a minor amount of code reading to
-   figure out if it was saved.  The big problem here is that the
-   code that does the save/restore is generated by the linker, so
-   we have no good way to determine at compile time what to do.  */
-
-#define MD_FROB_UPDATE_CONTEXT(CTX, FS)                                        \
-  do {                                                                 \
-    if ((FS)->regs.reg[2].how == REG_UNSAVED)                          \
-      {                                                                        \
-       unsigned int *insn                                              \
-         = (unsigned int *)                                            \
-           _Unwind_GetGR ((CTX), LINK_REGISTER_REGNUM);                \
-       if (*insn == 0xE8410028)                                        \
-         _Unwind_SetGRPtr ((CTX), 2, (CTX)->cfa + 40);                 \
-      }                                                                        \
-  } while (0)
-
-#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)              \
-  do {                                                                 \
-    unsigned char *pc_ = (CONTEXT)->ra;                                        \
-    struct sigcontext *sc_;                                            \
-    long new_cfa_;                                                     \
-    int i_;                                                            \
-                                                                       \
-    /* addi r1, r1, 128; li r0, 0x0077; sc  (sigreturn) */             \
-    /* addi r1, r1, 128; li r0, 0x00AC; sc  (rt_sigreturn) */          \
-    if (*(unsigned int *) (pc_+0) != 0x38210000 + SIGNAL_FRAMESIZE     \
-       || *(unsigned int *) (pc_+8) != 0x44000002)                     \
-      break;                                                           \
-    if (*(unsigned int *) (pc_+4) == 0x38000077)                       \
-      {                                                                        \
-       struct sigframe {                                               \
-         char gap[SIGNAL_FRAMESIZE];                                   \
-         struct sigcontext sigctx;                                     \
-       } *rt_ = (CONTEXT)->cfa;                                        \
-       sc_ = &rt_->sigctx;                                             \
-      }                                                                        \
-    else if (*(unsigned int *) (pc_+4) == 0x380000AC)                  \
-      {                                                                        \
-       struct rt_sigframe {                                            \
-         int tramp[6];                                                 \
-         struct siginfo *pinfo;                                        \
-         struct ucontext *puc;                                         \
-       } *rt_ = (struct rt_sigframe *) pc_;                            \
-       sc_ = &rt_->puc->uc_mcontext;                                   \
-      }                                                                        \
-    else                                                               \
-      break;                                                           \
-                                                                       \
-    new_cfa_ = sc_->regs->gpr[STACK_POINTER_REGNUM];                   \
-    (FS)->cfa_how = CFA_REG_OFFSET;                                    \
-    (FS)->cfa_reg = STACK_POINTER_REGNUM;                              \
-    (FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa;               \
-                                                                       \
-    for (i_ = 0; i_ < 32; i_++)                                                \
-      if (i_ != STACK_POINTER_REGNUM)                                  \
-       {                                                               \
-         (FS)->regs.reg[i_].how = REG_SAVED_OFFSET;                    \
-         (FS)->regs.reg[i_].loc.offset                                 \
-           = (long)&(sc_->regs->gpr[i_]) - new_cfa_;                   \
-       }                                                               \
-                                                                       \
-    (FS)->regs.reg[LINK_REGISTER_REGNUM].how = REG_SAVED_OFFSET;       \
-    (FS)->regs.reg[LINK_REGISTER_REGNUM].loc.offset                    \
-      = (long)&(sc_->regs->link) - new_cfa_;                           \
-                                                                       \
-    /* The unwinder expects the IP to point to the following insn,     \
-       whereas the kernel returns the address of the actual            \
-       faulting insn. We store NIP+4 in an unused register slot to     \
-       get the same result for multiple evaluation of the same signal  \
-       frame.  */                                                      \
-    sc_->regs->gpr[47] = sc_->regs->nip + 4;                           \
-    (FS)->regs.reg[CR0_REGNO].how = REG_SAVED_OFFSET;                  \
-    (FS)->regs.reg[CR0_REGNO].loc.offset                               \
-      = (long)&(sc_->regs->gpr[47]) - new_cfa_;                                \
-    (FS)->retaddr_column = CR0_REGNO;                                  \
-    goto SUCCESS;                                                      \
-  } while (0)
+#define MD_UNWIND_SUPPORT "config/rs6000/linux-unwind.h"

 
 

-#else
+#ifdef TARGET_LIBC_PROVIDES_SSP
+/* ppc32 glibc provides __stack_chk_guard in -0x7008(2),
+   ppc64 glibc provides it at -0x7010(13).  */
+#define TARGET_THREAD_SSP_OFFSET       (TARGET_64BIT ? -0x7010 : -0x7008)
+#endif

 
 

-#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)              \
-  do {                                                                 \
-    unsigned char *pc_ = (CONTEXT)->ra;                                        \
-    struct sigcontext *sc_;                                            \
-    long new_cfa_;                                                     \
-    int i_;                                                            \
-                                                                       \
-    /* li r0, 0x7777; sc  (sigreturn old)  */                          \
-    /* li r0, 0x0077; sc  (sigreturn new)  */                          \
-    /* li r0, 0x6666; sc  (rt_sigreturn old)  */                       \
-    /* li r0, 0x00AC; sc  (rt_sigreturn new)  */                       \
-    if (*(unsigned int *) (pc_+4) != 0x44000002)                       \
-      break;                                                           \
-    if (*(unsigned int *) (pc_+0) == 0x38007777                                \
-       || *(unsigned int *) (pc_+0) == 0x38000077)                     \
-      {                                                                        \
-       struct sigframe {                                               \
-         char gap[SIGNAL_FRAMESIZE];                                   \
-         struct sigcontext sigctx;                                     \
-       } *rt_ = (CONTEXT)->cfa;                                        \
-       sc_ = &rt_->sigctx;                                             \
-      }                                                                        \
-    else if (*(unsigned int *) (pc_+0) == 0x38006666                   \
-            || *(unsigned int *) (pc_+0) == 0x380000AC)                \
-      {                                                                        \
-       struct rt_sigframe {                                            \
-         char gap[SIGNAL_FRAMESIZE];                                   \
-         unsigned long _unused[2];                                     \
-         struct siginfo *pinfo;                                        \
-         void *puc;                                                    \
-         struct siginfo info;                                          \
-         struct ucontext uc;                                           \
-       } *rt_ = (CONTEXT)->cfa;                                        \
-       sc_ = &rt_->uc.uc_mcontext;                                     \
-      }                                                                        \
-    else                                                               \
-      break;                                                           \
-                                                                       \
-    new_cfa_ = sc_->regs->gpr[STACK_POINTER_REGNUM];                   \
-    (FS)->cfa_how = CFA_REG_OFFSET;                                    \
-    (FS)->cfa_reg = STACK_POINTER_REGNUM;                              \
-    (FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa;               \
-                                                                       \
-    for (i_ = 0; i_ < 32; i_++)                                                \
-      if (i_ != STACK_POINTER_REGNUM)                                  \
-       {                                                               \
-         (FS)->regs.reg[i_].how = REG_SAVED_OFFSET;                    \
-         (FS)->regs.reg[i_].loc.offset                                 \
-           = (long)&(sc_->regs->gpr[i_]) - new_cfa_;                   \
-       }                                                               \
-                                                                       \
-    (FS)->regs.reg[LINK_REGISTER_REGNUM].how = REG_SAVED_OFFSET;       \
-    (FS)->regs.reg[LINK_REGISTER_REGNUM].loc.offset                    \
-      = (long)&(sc_->regs->link) - new_cfa_;                           \
-                                                                       \
-    /* The unwinder expects the IP to point to the following insn,     \
-       whereas the kernel returns the address of the actual            \
-       faulting insn. We store NIP+4 in an unused register slot to     \
-       get the same result for multiple evaluation of the same signal  \
-       frame.  */                                                      \
-    sc_->regs->gpr[47] = sc_->regs->nip + 4;                           \
-    (FS)->regs.reg[CR0_REGNO].how = REG_SAVED_OFFSET;                  \
-    (FS)->regs.reg[CR0_REGNO].loc.offset                               \
-      = (long)&(sc_->regs->gpr[47]) - new_cfa_;                                \
-    (FS)->retaddr_column = CR0_REGNO;                                  \
-    goto SUCCESS;                                                      \
-  } while (0)
+#define POWERPC_LINUX

 
 

+/* ppc{32,64} linux has 128-bit long double support in glibc 2.4 and later.  */
+#ifdef TARGET_DEFAULT_LONG_DOUBLE_128
+#define RS6000_DEFAULT_LONG_DOUBLE_SIZE 128

 #endif
 #endif