[thirdparty/gcc.git] / gcc / config / sparc / linux64.h

/* Definitions for 64-bit SPARC running Linux-based GNU systems with ELF.
   Copyright 1996, 1997, 1998, 2000, 2002, 2003, 2004
   Free Software Foundation, Inc.
   Contributed by David S. Miller (davem@caip.rutgers.edu)

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 option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY 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.  */

#define TARGET_OS_CPP_BUILTINS()		\
  do						\
    {						\
	builtin_define_std ("unix");		\
	builtin_define_std ("linux");		\
	builtin_define ("_LONGLONG");		\
	builtin_define ("__gnu_linux__");	\
	builtin_assert ("system=linux");	\
	builtin_assert ("system=unix");		\
	builtin_assert ("system=posix");	\
    }						\
  while (0)

/* Don't assume anything about the header files.  */
#define NO_IMPLICIT_EXTERN_C

#undef MD_EXEC_PREFIX
#undef MD_STARTFILE_PREFIX

#if TARGET_CPU_DEFAULT == TARGET_CPU_v9 || TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc
/* A 64 bit v9 compiler with stack-bias,
   in a Medium/Low code model environment.  */

#undef TARGET_DEFAULT
#define TARGET_DEFAULT \
  (MASK_V9 + MASK_PTR64 + MASK_64BIT /* + MASK_HARD_QUAD */ \
   + MASK_STACK_BIAS + MASK_APP_REGS + MASK_FPU + MASK_LONG_DOUBLE_128)
#endif

#undef ASM_CPU_DEFAULT_SPEC
#define ASM_CPU_DEFAULT_SPEC "-Av9a"

#ifdef SPARC_BI_ARCH

#undef CPP_ARCH32_SPEC
#define CPP_ARCH32_SPEC "%{mlong-double-128:-D__LONG_DOUBLE_128__}"

#endif

/* Provide a STARTFILE_SPEC appropriate for GNU/Linux.  Here we add
   the GNU/Linux magical crtbegin.o file (see crtstuff.c) which
   provides part of the support for getting C++ file-scope static
   object constructed before entering `main'.  */
   
#undef  STARTFILE_SPEC

#ifdef HAVE_LD_PIE
#define STARTFILE_SPEC \
  "%{!shared:%{pg|p:gcrt1.o%s;pie:Scrt1.o%s;:crt1.o%s}}\
   crti.o%s %{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbeginS.o%s}"
#else
#define STARTFILE_SPEC \
  "%{!shared:%{pg|p:gcrt1.o%s;:crt1.o%s}}\
   crti.o%s %{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbeginS.o%s}"
#endif

/* Provide a ENDFILE_SPEC appropriate for GNU/Linux.  Here we tack on
   the GNU/Linux magical crtend.o file (see crtstuff.c) which
   provides part of the support for getting C++ file-scope static
   object constructed before entering `main', followed by a normal
   GNU/Linux "finalizer" file, `crtn.o'.  */

#undef  ENDFILE_SPEC

#define ENDFILE_SPEC \
  "%{shared|pie:crtendS.o%s;:crtend.o%s} crtn.o%s\
   %{ffast-math|funsafe-math-optimizations:crtfastmath.o%s}"

/* The GNU C++ standard library requires that these macros be defined.  */
#undef CPLUSPLUS_CPP_SPEC
#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"

#undef TARGET_VERSION
#define TARGET_VERSION fprintf (stderr, " (sparc64 GNU/Linux with ELF)");

/* The default code model.  */
#undef SPARC_DEFAULT_CMODEL
#define SPARC_DEFAULT_CMODEL CM_MEDLOW

#undef SUBTARGET_SWITCHES
#define SUBTARGET_SWITCHES						    \
{"long-double-64", -MASK_LONG_DOUBLE_128, N_("Use 64 bit long doubles") },  \
{"long-double-128", MASK_LONG_DOUBLE_128, N_("Use 128 bit long doubles") },

#undef WCHAR_TYPE
#define WCHAR_TYPE "int"

#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE 32

/* Define for support of TFmode long double.
   SPARC ABI says that long double is 4 words.  */
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)

/* Define this to set long double type size to use in libgcc2.c, which can
   not depend on target_flags.  */
#if defined(__arch64__) || defined(__LONG_DOUBLE_128__)
#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 128
#else
#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 64
#endif

#undef CPP_SUBTARGET_SPEC
#define CPP_SUBTARGET_SPEC "\
%{fPIC|fpic|fPIE|fpie:-D__PIC__ -D__pic__} \
%{posix:-D_POSIX_SOURCE} \
%{pthread:-D_REENTRANT} \
"

#undef LIB_SPEC
#define LIB_SPEC \
  "%{pthread:-lpthread} \
   %{shared:-lc} \
   %{!shared: %{mieee-fp:-lieee} %{profile:-lc_p}%{!profile:-lc}}"

/* Provide a LINK_SPEC appropriate for GNU/Linux.  Here we provide support
   for the special GCC options -static and -shared, which allow us to
   link things in one of these three modes by applying the appropriate
   combinations of options at link-time. We like to support here for
   as many of the other GNU linker options as possible. But I don't
   have the time to search for those flags. I am sure how to add
   support for -soname shared_object_name. H.J.

   I took out %{v:%{!V:-V}}. It is too much :-(. They can use
   -Wl,-V.

   When the -shared link option is used a final link is not being
   done.  */

/* If ELF is the default format, we should not use /lib/elf.  */

#ifdef SPARC_BI_ARCH

#undef SUBTARGET_EXTRA_SPECS
#define SUBTARGET_EXTRA_SPECS \
  { "link_arch32",       LINK_ARCH32_SPEC },              \
  { "link_arch64",       LINK_ARCH64_SPEC },              \
  { "link_arch_default", LINK_ARCH_DEFAULT_SPEC },	  \
  { "link_arch",	 LINK_ARCH_SPEC },
    
#define LINK_ARCH32_SPEC "-m elf32_sparc -Y P,/usr/lib %{shared:-shared} \
  %{!shared: \
    %{!ibcs: \
      %{!static: \
        %{rdynamic:-export-dynamic} \
        %{!dynamic-linker:-dynamic-linker /lib/ld-linux.so.2}} \
        %{static:-static}}} \
"

#define LINK_ARCH64_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \
  %{!shared: \
    %{!ibcs: \
      %{!static: \
        %{rdynamic:-export-dynamic} \
        %{!dynamic-linker:-dynamic-linker /lib64/ld-linux.so.2}} \
        %{static:-static}}} \
"

#define LINK_ARCH_SPEC "\
%{m32:%(link_arch32)} \
%{m64:%(link_arch64)} \
%{!m32:%{!m64:%(link_arch_default)}} \
"

#define LINK_ARCH_DEFAULT_SPEC \
(DEFAULT_ARCH32_P ? LINK_ARCH32_SPEC : LINK_ARCH64_SPEC)

#undef  LINK_SPEC
#define LINK_SPEC "\
%(link_arch) \
%{mlittle-endian:-EL} \
%{!mno-relax:%{!r:-relax}} \
"

#undef	CC1_SPEC
#if DEFAULT_ARCH32_P
#define CC1_SPEC "\
%{sun4:} %{target:} \
%{mcypress:-mcpu=cypress} \
%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
%{m32:%{m64:%emay not use both -m32 and -m64}} \
%{m64:-mptr64 -mstack-bias -mlong-double-128 \
  %{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:-mcpu=ultrasparc}}}}}}} \
  %{!mno-vis:%{!mcpu=v9:-mvis}}} \
"
#else
#define CC1_SPEC "\
%{sun4:} %{target:} \
%{mcypress:-mcpu=cypress} \
%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
%{m32:%{m64:%emay not use both -m32 and -m64}} \
%{m32:-mptr32 -mno-stack-bias %{!mlong-double-128:-mlong-double-64} \
  %{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:-mcpu=cypress}}}}}}}} \
%{!m32:%{!mcpu*:-mcpu=ultrasparc}} \
%{!mno-vis:%{!m32:%{!mcpu=v9:-mvis}}} \
"
#endif

#if DEFAULT_ARCH32_P
#define MULTILIB_DEFAULTS { "m32" }
#else
#define MULTILIB_DEFAULTS { "m64" }
#endif

#else /* !SPARC_BI_ARCH */

#undef LINK_SPEC
#define LINK_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \
  %{!shared: \
    %{!ibcs: \
      %{!static: \
        %{rdynamic:-export-dynamic} \
        %{!dynamic-linker:-dynamic-linker /lib64/ld-linux.so.2}} \
        %{static:-static}}} \
%{mlittle-endian:-EL} \
%{!mno-relax:%{!r:-relax}} \
"

#endif /* !SPARC_BI_ARCH */

/* The sun bundled assembler doesn't accept -Yd, (and neither does gas).
   It's safe to pass -s always, even if -g is not used.  */
#undef ASM_SPEC
#define ASM_SPEC "\
%{V} \
%{v:%{!V:-V}} \
%{!Qn:-Qy} \
%{n} \
%{T} \
%{Ym,*} \
%{Wa,*:%*} \
-s %{fpic|fPIC|fpie|fPIE:-K PIC} \
%{mlittle-endian:-EL} \
%(asm_cpu) %(asm_arch) %(asm_relax)"

/* Same as sparc.h */
#undef DBX_REGISTER_NUMBER
#define DBX_REGISTER_NUMBER(REGNO) (REGNO)

#define DWARF2_DEBUGGING_INFO 1
#define DBX_DEBUGGING_INFO 1

#undef ASM_OUTPUT_ALIGNED_LOCAL
#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN)		\
do {									\
  fputs ("\t.local\t", (FILE));		\
  assemble_name ((FILE), (NAME));					\
  putc ('\n', (FILE));							\
  ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN);			\
} while (0)

#undef COMMON_ASM_OP
#define COMMON_ASM_OP "\t.common\t"

#undef  LOCAL_LABEL_PREFIX
#define LOCAL_LABEL_PREFIX  "."

/* This is how to output a reference to an internal numbered label where
   PREFIX is the class of label and NUM is the number within the class.  */

#undef  ASM_OUTPUT_INTERNAL_LABELREF
#define ASM_OUTPUT_INTERNAL_LABELREF(FILE,PREFIX,NUM)	\
  fprintf (FILE, ".L%s%d", PREFIX, NUM)

/* This is how to store into the string LABEL
   the symbol_ref name of an internal numbered label where
   PREFIX is the class of label and NUM is the number within the class.
   This is suitable for output with `assemble_name'.  */

#undef  ASM_GENERATE_INTERNAL_LABEL
#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)	\
  sprintf (LABEL, "*.L%s%ld", PREFIX, (long)(NUM))

/* DWARF bits.  */

/* Follow Irix 6 and not the Dwarf2 draft in using 64-bit offsets. 
   Obviously the Dwarf2 folks haven't tried to actually build systems
   with their spec.  On a 64-bit system, only 64-bit relocs become
   RELATIVE relocations.  */

/* #define DWARF_OFFSET_SIZE PTR_SIZE */

#if defined(HAVE_LD_EH_FRAME_HDR)
#define LINK_EH_SPEC "%{!static:--eh-frame-hdr} "
#endif
\f
#ifdef HAVE_AS_TLS
#undef TARGET_SUN_TLS
#undef TARGET_GNU_TLS
#define TARGET_SUN_TLS 0
#define TARGET_GNU_TLS 1
#endif
\f
/* Don't be different from other Linux platforms in this regard.  */
#define HANDLE_PRAGMA_PACK_PUSH_POP

/* We use GNU ld so undefine this so that attribute((init_priority)) works.  */
#undef CTORS_SECTION_ASM_OP
#undef DTORS_SECTION_ASM_OP

#define TARGET_ASM_FILE_END file_end_indicate_exec_stack

#define TARGET_HAS_F_SETLKW

#undef LINK_GCC_C_SEQUENCE_SPEC
#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.  */

/* Handle multilib correctly.  */
#if defined(__arch64__)
/* 64-bit SPARC version */
#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)		\
  do {									\
    unsigned int *pc_ = (CONTEXT)->ra;					\
    long new_cfa_, i_;							\
    long regs_off_, fpu_save_off_;					\
    long this_cfa_, fpu_save_;						\
									\
    if (pc_[0] != 0x82102065		/* mov NR_rt_sigreturn, %g1 */	\
        || pc_[1] != 0x91d0206d)		/* ta 0x6d */		\
      break;								\
    regs_off_ = 192 + 128;						\
    fpu_save_off_ = regs_off_ + (16 * 8) + (3 * 8) + (2 * 4);		\
    this_cfa_ = (long) (CONTEXT)->cfa;					\
    new_cfa_ = *(long *)(((CONTEXT)->cfa) + (regs_off_ + (14 * 8)));	\
    new_cfa_ += 2047; /* Stack bias */					\
    fpu_save_ = *(long *)((this_cfa_) + (fpu_save_off_));		\
    (FS)->cfa_how = CFA_REG_OFFSET;					\
    (FS)->cfa_reg = 14;							\
    (FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa;		\
    for (i_ = 1; i_ < 16; ++i_)						\
      {									\
	(FS)->regs.reg[i_].how = REG_SAVED_OFFSET;			\
	(FS)->regs.reg[i_].loc.offset =					\
	  this_cfa_ + (regs_off_ + (i_ * 8)) - new_cfa_;		\
      }									\
    for (i_ = 0; i_ < 16; ++i_)						\
      {									\
	(FS)->regs.reg[i_ + 16].how = REG_SAVED_OFFSET;			\
	(FS)->regs.reg[i_ + 16].loc.offset =				\
	  this_cfa_ + (i_ * 8) - new_cfa_;				\
      }									\
    if (fpu_save_)							\
      {									\
	for (i_ = 0; i_ < 64; ++i_)					\
	  {								\
            if (i_ > 32 && (i_ & 0x1))					\
              continue;							\
	    (FS)->regs.reg[i_ + 32].how = REG_SAVED_OFFSET;		\
	    (FS)->regs.reg[i_ + 32].loc.offset =			\
	      (fpu_save_ + (i_ * 4)) - new_cfa_;			\
	  }								\
      }									\
    /* Stick return address into %g0, same trick Alpha uses.  */	\
    (FS)->regs.reg[0].how = REG_SAVED_OFFSET;				\
    (FS)->regs.reg[0].loc.offset =					\
      this_cfa_ + (regs_off_ + (16 * 8) + 8) - new_cfa_;		\
    (FS)->retaddr_column = 0;						\
    goto SUCCESS;							\
  } while (0)
#else
/* 32-bit SPARC version */
#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS)		\
  do {									\
    unsigned int *pc_ = (CONTEXT)->ra;					\
    int new_cfa_, i_, oldstyle_;					\
    int regs_off_, fpu_save_off_;					\
    int fpu_save_, this_cfa_;						\
									\
    if (pc_[1] != 0x91d02010)		/* ta 0x10 */			\
      break;								\
    if (pc_[0] == 0x821020d8)		/* mov NR_sigreturn, %g1 */	\
      oldstyle_ = 1;							\
    else if (pc_[0] == 0x82102065)	/* mov NR_rt_sigreturn, %g1 */	\
      oldstyle_ = 0;							\
    else								\
      break;								\
    if (oldstyle_)							\
      {									\
        regs_off_ = 96;							\
        fpu_save_off_ = regs_off_ + (4 * 4) + (16 * 4);			\
      }									\
    else								\
      {									\
        regs_off_ = 96 + 128;						\
        fpu_save_off_ = regs_off_ + (4 * 4) + (16 * 4) + (2 * 4);	\
      }									\
    this_cfa_ = (int) (CONTEXT)->cfa;					\
    new_cfa_ = *(int *)(((CONTEXT)->cfa) + (regs_off_+(4*4)+(14 * 4)));	\
    fpu_save_ = *(int *)((this_cfa_) + (fpu_save_off_));		\
    (FS)->cfa_how = CFA_REG_OFFSET;					\
    (FS)->cfa_reg = 14;							\
    (FS)->cfa_offset = new_cfa_ - (int) (CONTEXT)->cfa;			\
    for (i_ = 1; i_ < 16; ++i_)						\
      {									\
        if (i_ == 14)							\
          continue;							\
	(FS)->regs.reg[i_].how = REG_SAVED_OFFSET;			\
	(FS)->regs.reg[i_].loc.offset =					\
	   this_cfa_ + (regs_off_+(4 * 4)+(i_ * 4)) - new_cfa_;		\
      }									\
    for (i_ = 0; i_ < 16; ++i_)						\
      {									\
	(FS)->regs.reg[i_ + 16].how = REG_SAVED_OFFSET;			\
	(FS)->regs.reg[i_ + 16].loc.offset =				\
	  this_cfa_ + (i_ * 4) - new_cfa_;				\
      }									\
    if (fpu_save_)							\
      {									\
	for (i_ = 0; i_ < 32; ++i_)					\
	  {								\
	    (FS)->regs.reg[i_ + 32].how = REG_SAVED_OFFSET;		\
	    (FS)->regs.reg[i_ + 32].loc.offset =			\
	      (fpu_save_ + (i_ * 4)) - new_cfa_;			\
	  }								\
      }									\
    /* Stick return address into %g0, same trick Alpha uses.  */	\
    (FS)->regs.reg[0].how = REG_SAVED_OFFSET;				\
    (FS)->regs.reg[0].loc.offset = this_cfa_+(regs_off_+4)-new_cfa_;	\
    (FS)->retaddr_column = 0;						\
    goto SUCCESS;							\
  } while (0)
#endif
Commit	Line	Data
956d6950	1	/* Definitions for 64-bit SPARC running Linux-based GNU systems with ELF.
aa335b76 KH	2	Copyright 1996, 1997, 1998, 2000, 2002, 2003, 2004
aa335b76 KH	3	Free Software Foundation, Inc.
bfe87013 DE	4	Contributed by David S. Miller (davem@caip.rutgers.edu)
bfe87013 DE	5
de0a398e	6	This file is part of GCC.
bfe87013	7
de0a398e	8	GCC is free software; you can redistribute it and/or modify
bfe87013 DE	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2, or (at your option)
	11	any later version.
	12
de0a398e	13	GCC is distributed in the hope that it will be useful,
bfe87013 DE	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
de0a398e	19	along with GCC; see the file COPYING. If not, write to
bfe87013 DE	20	the Free Software Foundation, 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
9b8466f4 NB	23	#define TARGET_OS_CPP_BUILTINS() \
	24	do \
	25	{ \
	26	builtin_define_std ("unix"); \
	27	builtin_define_std ("linux"); \
	28	builtin_define ("_LONGLONG"); \
	29	builtin_define ("__gnu_linux__"); \
26b0ad13	30	builtin_assert ("system=linux"); \
9b8466f4 NB	31	builtin_assert ("system=unix"); \
	32	builtin_assert ("system=posix"); \
	33	} \
	34	while (0)
	35
80ffc95e	36	/* Don't assume anything about the header files. */
bfe87013 DE	37	#define NO_IMPLICIT_EXTERN_C
bfe87013 DE	38
bfe87013 DE	39	#undef MD_EXEC_PREFIX
	40	#undef MD_STARTFILE_PREFIX
	41
345a6161 DM	42	#if TARGET_CPU_DEFAULT == TARGET_CPU_v9 \|\| TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc
	43	/* A 64 bit v9 compiler with stack-bias,
	44	in a Medium/Low code model environment. */
	45
	46	#undef TARGET_DEFAULT
	47	#define TARGET_DEFAULT \
	48	(MASK_V9 + MASK_PTR64 + MASK_64BIT /* + MASK_HARD_QUAD */ \
33074e5f	49	+ MASK_STACK_BIAS + MASK_APP_REGS + MASK_FPU + MASK_LONG_DOUBLE_128)
345a6161 DM	50	#endif
345a6161 DM	51
a0a301fc DE	52	#undef ASM_CPU_DEFAULT_SPEC
a0a301fc DE	53	#define ASM_CPU_DEFAULT_SPEC "-Av9a"
bfe87013	54
4710d3eb JJ	55	#ifdef SPARC_BI_ARCH
	56
	57	#undef CPP_ARCH32_SPEC
9b8466f4	58	#define CPP_ARCH32_SPEC "%{mlong-double-128:-D__LONG_DOUBLE_128__}"
4710d3eb JJ	59
	60	#endif
	61
956d6950 JL	62	/* Provide a STARTFILE_SPEC appropriate for GNU/Linux. Here we add
956d6950 JL	63	the GNU/Linux magical crtbegin.o file (see crtstuff.c) which
bfe87013	64	provides part of the support for getting C++ file-scope static
80ffc95e	65	object constructed before entering `main'. */
bfe87013 DE	66
bfe87013 DE	67	#undef STARTFILE_SPEC
345a6161	68
24a4dd31	69	#ifdef HAVE_LD_PIE
5bbcd587	70	#define STARTFILE_SPEC \
24a4dd31 JJ	71	"%{!shared:%{pg\|p:gcrt1.o%s;pie:Scrt1.o%s;:crt1.o%s}}\
	72	crti.o%s %{static:crtbeginT.o%s;shared\|pie:crtbeginS.o%s;:crtbeginS.o%s}"
	73	#else
	74	#define STARTFILE_SPEC \
	75	"%{!shared:%{pg\|p:gcrt1.o%s;:crt1.o%s}}\
	76	crti.o%s %{static:crtbeginT.o%s;shared\|pie:crtbeginS.o%s;:crtbeginS.o%s}"
	77	#endif
bfe87013	78
956d6950 JL	79	/* Provide a ENDFILE_SPEC appropriate for GNU/Linux. Here we tack on
956d6950 JL	80	the GNU/Linux magical crtend.o file (see crtstuff.c) which
bfe87013 DE	81	provides part of the support for getting C++ file-scope static
bfe87013 DE	82	object constructed before entering `main', followed by a normal
956d6950	83	GNU/Linux "finalizer" file, `crtn.o'. */
bfe87013 DE	84
bfe87013 DE	85	#undef ENDFILE_SPEC
345a6161	86
5bbcd587	87	#define ENDFILE_SPEC \
24a4dd31	88	"%{shared\|pie:crtendS.o%s;:crtend.o%s} crtn.o%s\
5bbcd587	89	%{ffast-math\|funsafe-math-optimizations:crtfastmath.o%s}"
345a6161	90
2be1602e DM	91	/* The GNU C++ standard library requires that these macros be defined. */
	92	#undef CPLUSPLUS_CPP_SPEC
	93	#define CPLUSPLUS_CPP_SPEC "-D_GNU_SOURCE %(cpp)"
	94
345a6161 DM	95	#undef TARGET_VERSION
345a6161 DM	96	#define TARGET_VERSION fprintf (stderr, " (sparc64 GNU/Linux with ELF)");
a0a301fc DE	97
	98	/* The default code model. */
	99	#undef SPARC_DEFAULT_CMODEL
be3f1ff5	100	#define SPARC_DEFAULT_CMODEL CM_MEDLOW
bfe87013	101
4710d3eb	102	#undef SUBTARGET_SWITCHES
047142d3 PT	103	#define SUBTARGET_SWITCHES \
	104	{"long-double-64", -MASK_LONG_DOUBLE_128, N_("Use 64 bit long doubles") }, \
	105	{"long-double-128", MASK_LONG_DOUBLE_128, N_("Use 128 bit long doubles") },
4710d3eb	106
bfe87013	107	#undef WCHAR_TYPE
247cfc5c JJ	108	#define WCHAR_TYPE "int"
247cfc5c JJ	109
bfe87013	110	#undef WCHAR_TYPE_SIZE
247cfc5c JJ	111	#define WCHAR_TYPE_SIZE 32
247cfc5c JJ	112
ba31d94e	113	/* Define for support of TFmode long double.
56149abc	114	SPARC ABI says that long double is 4 words. */
a0a301fc	115	#undef LONG_DOUBLE_TYPE_SIZE
4710d3eb JJ	116	#define LONG_DOUBLE_TYPE_SIZE (TARGET_LONG_DOUBLE_128 ? 128 : 64)
4710d3eb JJ	117
4710d3eb JJ	118	/* Define this to set long double type size to use in libgcc2.c, which can
	119	not depend on target_flags. */
	120	#if defined(__arch64__) \|\| defined(__LONG_DOUBLE_128__)
	121	#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 128
	122	#else
	123	#define LIBGCC2_LONG_DOUBLE_TYPE_SIZE 64
	124	#endif
345a6161	125
a0a301fc DE	126	#undef CPP_SUBTARGET_SPEC
a0a301fc DE	127	#define CPP_SUBTARGET_SPEC "\
24a4dd31	128	%{fPIC\|fpic\|fPIE\|fpie:-D__PIC__ -D__pic__} \
bfe87013	129	%{posix:-D_POSIX_SOURCE} \
afc96791	130	%{pthread:-D_REENTRANT} \
bfe87013	131	"
afc96791	132
bfe87013 DE	133	#undef LIB_SPEC
bfe87013 DE	134	#define LIB_SPEC \
17772b2a JJ	135	"%{pthread:-lpthread} \
	136	%{shared:-lc} \
	137	%{!shared: %{mieee-fp:-lieee} %{profile:-lc_p}%{!profile:-lc}}"
bfe87013	138
956d6950	139	/* Provide a LINK_SPEC appropriate for GNU/Linux. Here we provide support
bfe87013 DE	140	for the special GCC options -static and -shared, which allow us to
	141	link things in one of these three modes by applying the appropriate
	142	combinations of options at link-time. We like to support here for
	143	as many of the other GNU linker options as possible. But I don't
	144	have the time to search for those flags. I am sure how to add
	145	support for -soname shared_object_name. H.J.
	146
	147	I took out %{v:%{!V:-V}}. It is too much :-(. They can use
	148	-Wl,-V.
	149
	150	When the -shared link option is used a final link is not being
	151	done. */
	152
80ffc95e	153	/* If ELF is the default format, we should not use /lib/elf. */
bfe87013	154
345a6161 DM	155	#ifdef SPARC_BI_ARCH
	156
	157	#undef SUBTARGET_EXTRA_SPECS
	158	#define SUBTARGET_EXTRA_SPECS \
	159	{ "link_arch32", LINK_ARCH32_SPEC }, \
	160	{ "link_arch64", LINK_ARCH64_SPEC }, \
	161	{ "link_arch_default", LINK_ARCH_DEFAULT_SPEC }, \
	162	{ "link_arch", LINK_ARCH_SPEC },
	163
	164	#define LINK_ARCH32_SPEC "-m elf32_sparc -Y P,/usr/lib %{shared:-shared} \
	165	%{!shared: \
	166	%{!ibcs: \
	167	%{!static: \
	168	%{rdynamic:-export-dynamic} \
	169	%{!dynamic-linker:-dynamic-linker /lib/ld-linux.so.2}} \
	170	%{static:-static}}} \
	171	"
	172
	173	#define LINK_ARCH64_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \
	174	%{!shared: \
	175	%{!ibcs: \
	176	%{!static: \
	177	%{rdynamic:-export-dynamic} \
	178	%{!dynamic-linker:-dynamic-linker /lib64/ld-linux.so.2}} \
	179	%{static:-static}}} \
	180	"
	181
	182	#define LINK_ARCH_SPEC "\
	183	%{m32:%(link_arch32)} \
	184	%{m64:%(link_arch64)} \
	185	%{!m32:%{!m64:%(link_arch_default)}} \
	186	"
	187
	188	#define LINK_ARCH_DEFAULT_SPEC \
	189	(DEFAULT_ARCH32_P ? LINK_ARCH32_SPEC : LINK_ARCH64_SPEC)
	190
bfe87013	191	#undef LINK_SPEC
345a6161 DM	192	#define LINK_SPEC "\
	193	%(link_arch) \
	194	%{mlittle-endian:-EL} \
e95b1e6a	195	%{!mno-relax:%{!r:-relax}} \
345a6161 DM	196	"
	197
	198	#undef CC1_SPEC
	199	#if DEFAULT_ARCH32_P
	200	#define CC1_SPEC "\
	201	%{sun4:} %{target:} \
	202	%{mcypress:-mcpu=cypress} \
	203	%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
	204	%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
d6964c30	205	%{m32:%{m64:%emay not use both -m32 and -m64}} \
4710d3eb	206	%{m64:-mptr64 -mstack-bias -mlong-double-128 \
247cfc5c JJ	207	%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:-mcpu=ultrasparc}}}}}}} \
247cfc5c JJ	208	%{!mno-vis:%{!mcpu=v9:-mvis}}} \
345a6161 DM	209	"
	210	#else
	211	#define CC1_SPEC "\
	212	%{sun4:} %{target:} \
	213	%{mcypress:-mcpu=cypress} \
	214	%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
	215	%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
d6964c30	216	%{m32:%{m64:%emay not use both -m32 and -m64}} \
4710d3eb	217	%{m32:-mptr32 -mno-stack-bias %{!mlong-double-128:-mlong-double-64} \
b25c3a22	218	%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:-mcpu=cypress}}}}}}}} \
9ce13279	219	%{!m32:%{!mcpu*:-mcpu=ultrasparc}} \
247cfc5c	220	%{!mno-vis:%{!m32:%{!mcpu=v9:-mvis}}} \
345a6161 DM	221	"
	222	#endif
	223
	224	#if DEFAULT_ARCH32_P
	225	#define MULTILIB_DEFAULTS { "m32" }
	226	#else
	227	#define MULTILIB_DEFAULTS { "m64" }
	228	#endif
	229
	230	#else /* !SPARC_BI_ARCH */
	231
	232	#undef LINK_SPEC
e95b1e6a	233	#define LINK_SPEC "-m elf64_sparc -Y P,/usr/lib64 %{shared:-shared} \
bfe87013 DE	234	%{!shared: \
	235	%{!ibcs: \
	236	%{!static: \
	237	%{rdynamic:-export-dynamic} \
345a6161	238	%{!dynamic-linker:-dynamic-linker /lib64/ld-linux.so.2}} \
bfe87013 DE	239	%{static:-static}}} \
bfe87013 DE	240	%{mlittle-endian:-EL} \
e95b1e6a	241	%{!mno-relax:%{!r:-relax}} \
bfe87013 DE	242	"
bfe87013 DE	243
345a6161 DM	244	#endif /* !SPARC_BI_ARCH */
345a6161 DM	245
bfe87013	246	/* The sun bundled assembler doesn't accept -Yd, (and neither does gas).
80ffc95e	247	It's safe to pass -s always, even if -g is not used. */
bfe87013 DE	248	#undef ASM_SPEC
	249	#define ASM_SPEC "\
	250	%{V} \
	251	%{v:%{!V:-V}} \
	252	%{!Qn:-Qy} \
	253	%{n} \
	254	%{T} \
	255	%{Ym,*} \
	256	%{Wa,:%} \
24a4dd31	257	-s %{fpic\|fPIC\|fpie\|fPIE:-K PIC} \
bfe87013	258	%{mlittle-endian:-EL} \
e95b1e6a	259	%(asm_cpu) %(asm_arch) %(asm_relax)"
bfe87013 DE	260
	261	/* Same as sparc.h */
	262	#undef DBX_REGISTER_NUMBER
	263	#define DBX_REGISTER_NUMBER(REGNO) (REGNO)
	264
23532de9 JT	265	#define DWARF2_DEBUGGING_INFO 1
23532de9 JT	266	#define DBX_DEBUGGING_INFO 1
bfe87013	267
bfe87013 DE	268	#undef ASM_OUTPUT_ALIGNED_LOCAL
	269	#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \
	270	do { \
	271	fputs ("\t.local\t", (FILE)); \
	272	assemble_name ((FILE), (NAME)); \
	273	putc ('\n', (FILE)); \
	274	ASM_OUTPUT_ALIGNED_COMMON (FILE, NAME, SIZE, ALIGN); \
	275	} while (0)
	276
	277	#undef COMMON_ASM_OP
471b6f1b	278	#define COMMON_ASM_OP "\t.common\t"
bfe87013	279
59f96879 RH	280	#undef LOCAL_LABEL_PREFIX
	281	#define LOCAL_LABEL_PREFIX "."
	282
bfe87013 DE	283	/* This is how to output a reference to an internal numbered label where
	284	PREFIX is the class of label and NUM is the number within the class. */
	285
	286	#undef ASM_OUTPUT_INTERNAL_LABELREF
	287	#define ASM_OUTPUT_INTERNAL_LABELREF(FILE,PREFIX,NUM) \
	288	fprintf (FILE, ".L%s%d", PREFIX, NUM)
	289
	290	/* This is how to store into the string LABEL
	291	the symbol_ref name of an internal numbered label where
	292	PREFIX is the class of label and NUM is the number within the class.
	293	This is suitable for output with `assemble_name'. */
	294
	295	#undef ASM_GENERATE_INTERNAL_LABEL
	296	#define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \
e59f7d3d	297	sprintf (LABEL, "*.L%s%ld", PREFIX, (long)(NUM))
bfe87013	298
bfe87013 DE	299	/* DWARF bits. */
	300
	301	/* Follow Irix 6 and not the Dwarf2 draft in using 64-bit offsets.
d6a7951f	302	Obviously the Dwarf2 folks haven't tried to actually build systems
bfe87013 DE	303	with their spec. On a 64-bit system, only 64-bit relocs become
	304	RELATIVE relocations. */
	305
	306	/* #define DWARF_OFFSET_SIZE PTR_SIZE */
275b60d6 JJ	307
	308	#if defined(HAVE_LD_EH_FRAME_HDR)
	309	#define LINK_EH_SPEC "%{!static:--eh-frame-hdr} "
	310	#endif
f7e0e539	311	\f
5751a10b JJ	312	#ifdef HAVE_AS_TLS
	313	#undef TARGET_SUN_TLS
	314	#undef TARGET_GNU_TLS
	315	#define TARGET_SUN_TLS 0
	316	#define TARGET_GNU_TLS 1
	317	#endif
	318	\f
b5de1a27 DM	319	/* Don't be different from other Linux platforms in this regard. */
b5de1a27 DM	320	#define HANDLE_PRAGMA_PACK_PUSH_POP
7a31a340 DM	321
	322	/* We use GNU ld so undefine this so that attribute((init_priority)) works. */
	323	#undef CTORS_SECTION_ASM_OP
	324	#undef DTORS_SECTION_ASM_OP
db430d26	325
a5fe455b	326	#define TARGET_ASM_FILE_END file_end_indicate_exec_stack
3edc56a9	327
c2cd64b5 JJ	328	#define TARGET_HAS_F_SETLKW
c2cd64b5 JJ	329
d00eacab	330	#undef LINK_GCC_C_SEQUENCE_SPEC
42df2193 JJ	331	#define LINK_GCC_C_SEQUENCE_SPEC \
	332	"%{static:--start-group} %G %L %{static:--end-group}%{!static:%G}"
	333
db430d26 DM	334	/* Do code reading to identify a signal frame, and set the frame
	335	state data appropriately. See unwind-dw2.c for the structs. */
	336
db430d26 DM	337	/* Handle multilib correctly. */
db430d26 DM	338	#if defined(__arch64__)
56149abc	339	/* 64-bit SPARC version */
db430d26 DM	340	#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS) \
	341	do { \
	342	unsigned int *pc_ = (CONTEXT)->ra; \
	343	long new_cfa_, i_; \
	344	long regs_off_, fpu_save_off_; \
	345	long this_cfa_, fpu_save_; \
	346	\
	347	if (pc_[0] != 0x82102065 /* mov NR_rt_sigreturn, %g1 */ \
	348	\|\| pc_[1] != 0x91d0206d) /* ta 0x6d */ \
	349	break; \
	350	regs_off_ = 192 + 128; \
	351	fpu_save_off_ = regs_off_ + (16 * 8) + (3 * 8) + (2 * 4); \
	352	this_cfa_ = (long) (CONTEXT)->cfa; \
	353	new_cfa_ = (long )(((CONTEXT)->cfa) + (regs_off_ + (14 * 8))); \
3ef3f384	354	new_cfa_ += 2047; /* Stack bias */ \
db430d26 DM	355	fpu_save_ = (long )((this_cfa_) + (fpu_save_off_)); \
	356	(FS)->cfa_how = CFA_REG_OFFSET; \
	357	(FS)->cfa_reg = 14; \
	358	(FS)->cfa_offset = new_cfa_ - (long) (CONTEXT)->cfa; \
	359	for (i_ = 1; i_ < 16; ++i_) \
	360	{ \
db430d26 DM	361	(FS)->regs.reg[i_].how = REG_SAVED_OFFSET; \
	362	(FS)->regs.reg[i_].loc.offset = \
	363	this_cfa_ + (regs_off_ + (i_ * 8)) - new_cfa_; \
	364	} \
	365	for (i_ = 0; i_ < 16; ++i_) \
	366	{ \
	367	(FS)->regs.reg[i_ + 16].how = REG_SAVED_OFFSET; \
	368	(FS)->regs.reg[i_ + 16].loc.offset = \
	369	this_cfa_ + (i_ * 8) - new_cfa_; \
	370	} \
	371	if (fpu_save_) \
	372	{ \
	373	for (i_ = 0; i_ < 64; ++i_) \
	374	{ \
	375	if (i_ > 32 && (i_ & 0x1)) \
	376	continue; \
	377	(FS)->regs.reg[i_ + 32].how = REG_SAVED_OFFSET; \
	378	(FS)->regs.reg[i_ + 32].loc.offset = \
	379	(fpu_save_ + (i_ * 4)) - new_cfa_; \
	380	} \
	381	} \
	382	/* Stick return address into %g0, same trick Alpha uses. */ \
	383	(FS)->regs.reg[0].how = REG_SAVED_OFFSET; \
	384	(FS)->regs.reg[0].loc.offset = \
	385	this_cfa_ + (regs_off_ + (16 * 8) + 8) - new_cfa_; \
	386	(FS)->retaddr_column = 0; \
	387	goto SUCCESS; \
	388	} while (0)
	389	#else
56149abc	390	/* 32-bit SPARC version */
db430d26 DM	391	#define MD_FALLBACK_FRAME_STATE_FOR(CONTEXT, FS, SUCCESS) \
	392	do { \
	393	unsigned int *pc_ = (CONTEXT)->ra; \
	394	int new_cfa_, i_, oldstyle_; \
	395	int regs_off_, fpu_save_off_; \
	396	int fpu_save_, this_cfa_; \
	397	\
	398	if (pc_[1] != 0x91d02010) /* ta 0x10 */ \
	399	break; \
	400	if (pc_[0] == 0x821020d8) /* mov NR_sigreturn, %g1 */ \
	401	oldstyle_ = 1; \
	402	else if (pc_[0] == 0x82102065) /* mov NR_rt_sigreturn, %g1 */ \
	403	oldstyle_ = 0; \
	404	else \
	405	break; \
	406	if (oldstyle_) \
	407	{ \
	408	regs_off_ = 96; \
	409	fpu_save_off_ = regs_off_ + (4 * 4) + (16 * 4); \
	410	} \
	411	else \
	412	{ \
	413	regs_off_ = 96 + 128; \
	414	fpu_save_off_ = regs_off_ + (4 * 4) + (16 * 4) + (2 * 4); \
	415	} \
	416	this_cfa_ = (int) (CONTEXT)->cfa; \
	417	new_cfa_ = (int )(((CONTEXT)->cfa) + (regs_off_+(44)+(14 4))); \
	418	fpu_save_ = (int )((this_cfa_) + (fpu_save_off_)); \
	419	(FS)->cfa_how = CFA_REG_OFFSET; \
	420	(FS)->cfa_reg = 14; \
	421	(FS)->cfa_offset = new_cfa_ - (int) (CONTEXT)->cfa; \
	422	for (i_ = 1; i_ < 16; ++i_) \
	423	{ \
	424	if (i_ == 14) \
	425	continue; \
	426	(FS)->regs.reg[i_].how = REG_SAVED_OFFSET; \
	427	(FS)->regs.reg[i_].loc.offset = \
	428	this_cfa_ + (regs_off_+(4 * 4)+(i_ * 4)) - new_cfa_; \
	429	} \
	430	for (i_ = 0; i_ < 16; ++i_) \
	431	{ \
	432	(FS)->regs.reg[i_ + 16].how = REG_SAVED_OFFSET; \
	433	(FS)->regs.reg[i_ + 16].loc.offset = \
	434	this_cfa_ + (i_ * 4) - new_cfa_; \
	435	} \
	436	if (fpu_save_) \
	437	{ \
	438	for (i_ = 0; i_ < 32; ++i_) \
	439	{ \
	440	(FS)->regs.reg[i_ + 32].how = REG_SAVED_OFFSET; \
	441	(FS)->regs.reg[i_ + 32].loc.offset = \
	442	(fpu_save_ + (i_ * 4)) - new_cfa_; \
	443	} \
	444	} \
	445	/* Stick return address into %g0, same trick Alpha uses. */ \
	446	(FS)->regs.reg[0].how = REG_SAVED_OFFSET; \
	447	(FS)->regs.reg[0].loc.offset = this_cfa_+(regs_off_+4)-new_cfa_; \
	448	(FS)->retaddr_column = 0; \
	449	goto SUCCESS; \
	450	} while (0)
	451	#endif