From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgcc/config/i386/32/sfp-machine.h | 206 ++++++++++++ libgcc/config/i386/32/t-fprules-softfp | 8 + libgcc/config/i386/32/tf-signs.c | 62 ++++ libgcc/config/i386/64/_divtc3.c | 16 + libgcc/config/i386/64/_multc3.c | 16 + libgcc/config/i386/64/_powitf2.c | 16 + libgcc/config/i386/64/eqtf2.c | 15 + libgcc/config/i386/64/getf2.c | 15 + libgcc/config/i386/64/letf2.c | 15 + libgcc/config/i386/64/sfp-machine.h | 158 +++++++++ libgcc/config/i386/64/t-softfp-compat | 15 + libgcc/config/i386/libgcc-bsd.ver | 108 ++++++ libgcc/config/i386/libgcc-sol2.ver | 108 ++++++ libgcc/config/i386/morestack.S | 593 +++++++++++++++++++++++++++++++++ libgcc/config/i386/t-crtfm | 5 + libgcc/config/i386/t-crtpc | 8 + libgcc/config/i386/t-cygming | 11 + libgcc/config/i386/t-darwin | 1 + libgcc/config/i386/t-darwin64 | 1 + libgcc/config/i386/t-freebsd | 2 + libgcc/config/i386/t-nwld | 31 ++ libgcc/config/i386/t-sol2 | 37 ++ libgcc/config/i386/t-stack-i386 | 2 + 23 files changed, 1449 insertions(+) create mode 100644 libgcc/config/i386/32/sfp-machine.h create mode 100644 libgcc/config/i386/32/t-fprules-softfp create mode 100644 libgcc/config/i386/32/tf-signs.c create mode 100644 libgcc/config/i386/64/_divtc3.c create mode 100644 libgcc/config/i386/64/_multc3.c create mode 100644 libgcc/config/i386/64/_powitf2.c create mode 100644 libgcc/config/i386/64/eqtf2.c create mode 100644 libgcc/config/i386/64/getf2.c create mode 100644 libgcc/config/i386/64/letf2.c create mode 100644 libgcc/config/i386/64/sfp-machine.h create mode 100644 libgcc/config/i386/64/t-softfp-compat create mode 100644 libgcc/config/i386/libgcc-bsd.ver create mode 100644 libgcc/config/i386/libgcc-sol2.ver create mode 100644 libgcc/config/i386/morestack.S create mode 100644 libgcc/config/i386/t-crtfm create mode 100644 libgcc/config/i386/t-crtpc create mode 100644 libgcc/config/i386/t-cygming create mode 100644 libgcc/config/i386/t-darwin create mode 100644 libgcc/config/i386/t-darwin64 create mode 100644 libgcc/config/i386/t-freebsd create mode 100644 libgcc/config/i386/t-nwld create mode 100644 libgcc/config/i386/t-sol2 create mode 100644 libgcc/config/i386/t-stack-i386 (limited to 'libgcc/config/i386') diff --git a/libgcc/config/i386/32/sfp-machine.h b/libgcc/config/i386/32/sfp-machine.h new file mode 100644 index 000000000..1600a7fe2 --- /dev/null +++ b/libgcc/config/i386/32/sfp-machine.h @@ -0,0 +1,206 @@ +#define _FP_W_TYPE_SIZE 32 +#define _FP_W_TYPE unsigned int +#define _FP_WS_TYPE signed int +#define _FP_I_TYPE int + +/* The type of the result of a floating point comparison. This must + match `__libgcc_cmp_return__' in GCC for the target. */ +typedef int __gcc_CMPtype __attribute__ ((mode (__libgcc_cmp_return__))); +#define CMPtype __gcc_CMPtype + +#define __FP_FRAC_ADD_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0) \ + __asm__ ("add{l} {%11,%3|%3,%11}\n\t" \ + "adc{l} {%9,%2|%2,%9}\n\t" \ + "adc{l} {%7,%1|%1,%7}\n\t" \ + "adc{l} {%5,%0|%0,%5}" \ + : "=r" ((USItype) (r3)), \ + "=&r" ((USItype) (r2)), \ + "=&r" ((USItype) (r1)), \ + "=&r" ((USItype) (r0)) \ + : "%0" ((USItype) (x3)), \ + "g" ((USItype) (y3)), \ + "%1" ((USItype) (x2)), \ + "g" ((USItype) (y2)), \ + "%2" ((USItype) (x1)), \ + "g" ((USItype) (y1)), \ + "%3" ((USItype) (x0)), \ + "g" ((USItype) (y0))) +#define __FP_FRAC_ADD_3(r2,r1,r0,x2,x1,x0,y2,y1,y0) \ + __asm__ ("add{l} {%8,%2|%2,%8}\n\t" \ + "adc{l} {%6,%1|%1,%6}\n\t" \ + "adc{l} {%4,%0|%0,%4}" \ + : "=r" ((USItype) (r2)), \ + "=&r" ((USItype) (r1)), \ + "=&r" ((USItype) (r0)) \ + : "%0" ((USItype) (x2)), \ + "g" ((USItype) (y2)), \ + "%1" ((USItype) (x1)), \ + "g" ((USItype) (y1)), \ + "%2" ((USItype) (x0)), \ + "g" ((USItype) (y0))) +#define __FP_FRAC_SUB_4(r3,r2,r1,r0,x3,x2,x1,x0,y3,y2,y1,y0) \ + __asm__ ("sub{l} {%11,%3|%3,%11}\n\t" \ + "sbb{l} {%9,%2|%2,%9}\n\t" \ + "sbb{l} {%7,%1|%1,%7}\n\t" \ + "sbb{l} {%5,%0|%0,%5}" \ + : "=r" ((USItype) (r3)), \ + "=&r" ((USItype) (r2)), \ + "=&r" ((USItype) (r1)), \ + "=&r" ((USItype) (r0)) \ + : "0" ((USItype) (x3)), \ + "g" ((USItype) (y3)), \ + "1" ((USItype) (x2)), \ + "g" ((USItype) (y2)), \ + "2" ((USItype) (x1)), \ + "g" ((USItype) (y1)), \ + "3" ((USItype) (x0)), \ + "g" ((USItype) (y0))) +#define __FP_FRAC_SUB_3(r2,r1,r0,x2,x1,x0,y2,y1,y0) \ + __asm__ ("sub{l} {%8,%2|%2,%8}\n\t" \ + "sbb{l} {%6,%1|%1,%6}\n\t" \ + "sbb{l} {%4,%0|%0,%4}" \ + : "=r" ((USItype) (r2)), \ + "=&r" ((USItype) (r1)), \ + "=&r" ((USItype) (r0)) \ + : "0" ((USItype) (x2)), \ + "g" ((USItype) (y2)), \ + "1" ((USItype) (x1)), \ + "g" ((USItype) (y1)), \ + "2" ((USItype) (x0)), \ + "g" ((USItype) (y0))) + + +#define _FP_MUL_MEAT_Q(R,X,Y) \ + _FP_MUL_MEAT_4_wide(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm) + +#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_4_udiv(Q,R,X,Y) + +#define _FP_NANFRAC_S _FP_QNANBIT_S +#define _FP_NANFRAC_D _FP_QNANBIT_D, 0 +/* Even if XFmode is 12byte, we have to pad it to + 16byte since soft-fp emulation is done in 16byte. */ +#define _FP_NANFRAC_E _FP_QNANBIT_E, 0, 0, 0 +#define _FP_NANFRAC_Q _FP_QNANBIT_Q, 0, 0, 0 +#define _FP_NANSIGN_S 1 +#define _FP_NANSIGN_D 1 +#define _FP_NANSIGN_E 1 +#define _FP_NANSIGN_Q 1 + +#define _FP_KEEPNANFRACP 1 + +/* Here is something Intel misdesigned: the specs don't define + the case where we have two NaNs with same mantissas, but + different sign. Different operations pick up different NaNs. */ +#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP) \ + do { \ + if (_FP_FRAC_GT_##wc(X, Y) \ + || (_FP_FRAC_EQ_##wc(X,Y) && (OP == '+' || OP == '*'))) \ + { \ + R##_s = X##_s; \ + _FP_FRAC_COPY_##wc(R,X); \ + } \ + else \ + { \ + R##_s = Y##_s; \ + _FP_FRAC_COPY_##wc(R,Y); \ + } \ + R##_c = FP_CLS_NAN; \ + } while (0) + +#define FP_EX_INVALID 0x01 +#define FP_EX_DENORM 0x02 +#define FP_EX_DIVZERO 0x04 +#define FP_EX_OVERFLOW 0x08 +#define FP_EX_UNDERFLOW 0x10 +#define FP_EX_INEXACT 0x20 + +struct fenv +{ + unsigned short int __control_word; + unsigned short int __unused1; + unsigned short int __status_word; + unsigned short int __unused2; + unsigned short int __tags; + unsigned short int __unused3; + unsigned int __eip; + unsigned short int __cs_selector; + unsigned int __opcode:11; + unsigned int __unused4:5; + unsigned int __data_offset; + unsigned short int __data_selector; + unsigned short int __unused5; +}; + +#define FP_HANDLE_EXCEPTIONS \ + do { \ + if (_fex & FP_EX_INVALID) \ + { \ + float f = 0.0; \ + __asm__ __volatile__ ("fdiv {%y0, %0|%0, %y0}" : "+t" (f)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_DIVZERO) \ + { \ + float f = 1.0, g = 0.0; \ + __asm__ __volatile__ ("fdivp {%0, %y1|%y1, %0}" \ + : "+t" (f) : "u" (g) \ + : "st(1)"); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_OVERFLOW) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_OVERFLOW; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_UNDERFLOW) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_UNDERFLOW; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_INEXACT) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_INEXACT; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + } while (0) + +#define FP_RND_NEAREST 0 +#define FP_RND_ZERO 0xc00 +#define FP_RND_PINF 0x800 +#define FP_RND_MINF 0x400 + +#define _FP_DECL_EX \ + unsigned short _fcw __attribute__ ((unused)) = FP_RND_NEAREST + +#define FP_INIT_ROUNDMODE \ + do { \ + __asm__ ("fnstcw %0" : "=m" (_fcw)); \ + } while (0) + +#define FP_ROUNDMODE (_fcw & 0xc00) + +#define __LITTLE_ENDIAN 1234 +#define __BIG_ENDIAN 4321 + +#define __BYTE_ORDER __LITTLE_ENDIAN + +/* Define ALIASNAME as a strong alias for NAME. */ +#if defined __MACH__ +/* Mach-O doesn't support aliasing. If these functions ever return + anything but CMPtype we need to revisit this... */ +#define strong_alias(name, aliasname) \ + CMPtype aliasname (TFtype a, TFtype b) { return name(a, b); } +#else +# define strong_alias(name, aliasname) _strong_alias(name, aliasname) +# define _strong_alias(name, aliasname) \ + extern __typeof (name) aliasname __attribute__ ((alias (#name))); +#endif diff --git a/libgcc/config/i386/32/t-fprules-softfp b/libgcc/config/i386/32/t-fprules-softfp new file mode 100644 index 000000000..8e7f3233b --- /dev/null +++ b/libgcc/config/i386/32/t-fprules-softfp @@ -0,0 +1,8 @@ +# Filter out TImode functions +tifunctions = fixtfti.c fixunstfti.c floattitf.c floatuntitf.c +tifunctions := $(addprefix $(gcc_srcdir)/config/soft-fp/, $(tifunctions)) + +LIB2ADD := $(filter-out $(tifunctions), $(LIB2ADD)) + +# Provide fallbacks for __builtin_copysignq and __builtin_fabsq. +LIB2ADD += $(srcdir)/config/i386/32/tf-signs.c diff --git a/libgcc/config/i386/32/tf-signs.c b/libgcc/config/i386/32/tf-signs.c new file mode 100644 index 000000000..2bc1a855c --- /dev/null +++ b/libgcc/config/i386/32/tf-signs.c @@ -0,0 +1,62 @@ +/* Copyright (C) 2008, 2009 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 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 ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +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 +. */ + +union _FP_UNION_Q +{ + __float128 flt; + struct + { + unsigned long frac0 : 32; + unsigned long frac1 : 32; + unsigned long frac2 : 32; + unsigned long frac3 : 16; + unsigned exp : 15; + unsigned sign : 1; + } bits __attribute__((packed)); +}; + +__float128 __copysigntf3 (__float128, __float128); +__float128 __fabstf2 (__float128); + +__float128 +__copysigntf3 (__float128 a, __float128 b) +{ + union _FP_UNION_Q A, B; + + A.flt = a; + B.flt = b; + A.bits.sign = B.bits.sign; + + return A.flt; +} + +__float128 +__fabstf2 (__float128 a) +{ + union _FP_UNION_Q A; + + A.flt = a; + A.bits.sign = 0; + + return A.flt; +} diff --git a/libgcc/config/i386/64/_divtc3.c b/libgcc/config/i386/64/_divtc3.c new file mode 100644 index 000000000..0095d245e --- /dev/null +++ b/libgcc/config/i386/64/_divtc3.c @@ -0,0 +1,16 @@ +#ifdef SHARED +#define __divtc3 __divtc3_shared +#endif + +#define L_divtc3 +#include "libgcc2.c" + +#ifdef SHARED +#undef __divtc3 +extern __typeof__ (__divtc3_shared) __divtc3_compat __attribute__((alias ("__divtc3_shared"))); + +#ifndef _WIN32 +asm (".symver __divtc3_compat,__divtc3@GCC_4.0.0"); +asm (".symver __divtc3_shared,__divtc3@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/_multc3.c b/libgcc/config/i386/64/_multc3.c new file mode 100644 index 000000000..08b5ee451 --- /dev/null +++ b/libgcc/config/i386/64/_multc3.c @@ -0,0 +1,16 @@ +#ifdef SHARED +#define __multc3 __multc3_shared +#endif + +#define L_multc3 +#include "libgcc2.c" + +#ifdef SHARED +#undef __multc3 +extern __typeof__ (__multc3_shared) __multc3_compat __attribute__((alias ("__multc3_shared"))); + +#ifndef _WIN32 +asm (".symver __multc3_compat,__multc3@GCC_4.0.0"); +asm (".symver __multc3_shared,__multc3@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/_powitf2.c b/libgcc/config/i386/64/_powitf2.c new file mode 100644 index 000000000..e8360156b --- /dev/null +++ b/libgcc/config/i386/64/_powitf2.c @@ -0,0 +1,16 @@ +#ifdef SHARED +#define __powitf2 __powitf2_shared +#endif + +#define L_powitf2 +#include "libgcc2.c" + +#ifdef SHARED +#undef __powitf2 +extern __typeof__ (__powitf2_shared) __powitf2_compat __attribute__((alias ("__powitf2_shared"))); + +#ifndef _WIN32 +asm (".symver __powitf2_compat,__powitf2@GCC_4.0.0"); +asm (".symver __powitf2_shared,__powitf2@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/eqtf2.c b/libgcc/config/i386/64/eqtf2.c new file mode 100644 index 000000000..785c42ad5 --- /dev/null +++ b/libgcc/config/i386/64/eqtf2.c @@ -0,0 +1,15 @@ +#ifdef SHARED +#define __netf2 __netf2_shared +#endif + +#include "config/soft-fp/eqtf2.c" + +#ifdef SHARED +#undef __netf2 +strong_alias (__netf2_shared, __netf2_compat); + +#ifndef _WIN32 +asm (".symver __netf2_compat,__netf2@GCC_3.0"); +asm (".symver __netf2_shared,__netf2@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/getf2.c b/libgcc/config/i386/64/getf2.c new file mode 100644 index 000000000..280447c1e --- /dev/null +++ b/libgcc/config/i386/64/getf2.c @@ -0,0 +1,15 @@ +#ifdef SHARED +#define __gttf2 __gttf2_shared +#endif + +#include "config/soft-fp/getf2.c" + +#ifdef SHARED +#undef __gttf2 +strong_alias (__gttf2_shared, __gttf2_compat); + +#ifndef _WIN32 +asm (".symver __gttf2_compat,__gttf2@GCC_3.0"); +asm (".symver __gttf2_shared,__gttf2@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/letf2.c b/libgcc/config/i386/64/letf2.c new file mode 100644 index 000000000..81e0881c8 --- /dev/null +++ b/libgcc/config/i386/64/letf2.c @@ -0,0 +1,15 @@ +#ifdef SHARED +#define __lttf2 __lttf2_shared +#endif + +#include "config/soft-fp/letf2.c" + +#ifdef SHARED +#undef __lttf2 +strong_alias (__lttf2_shared, __lttf2_compat); + +#ifndef _WIN32 +asm (".symver __lttf2_compat,__lttf2@GCC_3.0"); +asm (".symver __lttf2_shared,__lttf2@@GCC_4.3.0"); +#endif +#endif diff --git a/libgcc/config/i386/64/sfp-machine.h b/libgcc/config/i386/64/sfp-machine.h new file mode 100644 index 000000000..5186c24ff --- /dev/null +++ b/libgcc/config/i386/64/sfp-machine.h @@ -0,0 +1,158 @@ +#define _FP_W_TYPE_SIZE 64 + +#ifdef _WIN64 + #define _FP_W_TYPE unsigned long long + #define _FP_WS_TYPE signed long long + #define _FP_I_TYPE long long +#else + #define _FP_W_TYPE unsigned long + #define _FP_WS_TYPE signed long + #define _FP_I_TYPE long +#endif + +typedef int TItype __attribute__ ((mode (TI))); +typedef unsigned int UTItype __attribute__ ((mode (TI))); + +#define TI_BITS (__CHAR_BIT__ * (int)sizeof(TItype)) + +/* The type of the result of a floating point comparison. This must + match `__libgcc_cmp_return__' in GCC for the target. */ +typedef int __gcc_CMPtype __attribute__ ((mode (__libgcc_cmp_return__))); +#define CMPtype __gcc_CMPtype + +#define _FP_MUL_MEAT_Q(R,X,Y) \ + _FP_MUL_MEAT_2_wide(_FP_WFRACBITS_Q,R,X,Y,umul_ppmm) + +#define _FP_DIV_MEAT_Q(R,X,Y) _FP_DIV_MEAT_2_udiv(Q,R,X,Y) + +#define _FP_NANFRAC_S _FP_QNANBIT_S +#define _FP_NANFRAC_D _FP_QNANBIT_D +#define _FP_NANFRAC_E _FP_QNANBIT_E, 0 +#define _FP_NANFRAC_Q _FP_QNANBIT_Q, 0 +#define _FP_NANSIGN_S 1 +#define _FP_NANSIGN_D 1 +#define _FP_NANSIGN_E 1 +#define _FP_NANSIGN_Q 1 + +#define _FP_KEEPNANFRACP 1 + +/* Here is something Intel misdesigned: the specs don't define + the case where we have two NaNs with same mantissas, but + different sign. Different operations pick up different NaNs. */ +#define _FP_CHOOSENAN(fs, wc, R, X, Y, OP) \ + do { \ + if (_FP_FRAC_GT_##wc(X, Y) \ + || (_FP_FRAC_EQ_##wc(X,Y) && (OP == '+' || OP == '*'))) \ + { \ + R##_s = X##_s; \ + _FP_FRAC_COPY_##wc(R,X); \ + } \ + else \ + { \ + R##_s = Y##_s; \ + _FP_FRAC_COPY_##wc(R,Y); \ + } \ + R##_c = FP_CLS_NAN; \ + } while (0) + +#define FP_EX_INVALID 0x01 +#define FP_EX_DENORM 0x02 +#define FP_EX_DIVZERO 0x04 +#define FP_EX_OVERFLOW 0x08 +#define FP_EX_UNDERFLOW 0x10 +#define FP_EX_INEXACT 0x20 + +struct fenv +{ + unsigned short int __control_word; + unsigned short int __unused1; + unsigned short int __status_word; + unsigned short int __unused2; + unsigned short int __tags; + unsigned short int __unused3; + unsigned int __eip; + unsigned short int __cs_selector; + unsigned int __opcode:11; + unsigned int __unused4:5; + unsigned int __data_offset; + unsigned short int __data_selector; + unsigned short int __unused5; +}; + +#ifdef __AVX__ + #define ASM_INVALID "vdivss %0, %0, %0" + #define ASM_DIVZERO "vdivss %1, %0, %0" +#else + #define ASM_INVALID "divss %0, %0" + #define ASM_DIVZERO "divss %1, %0" +#endif + +#define FP_HANDLE_EXCEPTIONS \ + do { \ + if (_fex & FP_EX_INVALID) \ + { \ + float f = 0.0; \ + __asm__ __volatile__ (ASM_INVALID : : "x" (f)); \ + } \ + if (_fex & FP_EX_DIVZERO) \ + { \ + float f = 1.0, g = 0.0; \ + __asm__ __volatile__ (ASM_DIVZERO : : "x" (f), "x" (g)); \ + } \ + if (_fex & FP_EX_OVERFLOW) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_OVERFLOW; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_UNDERFLOW) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_UNDERFLOW; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + if (_fex & FP_EX_INEXACT) \ + { \ + struct fenv temp; \ + __asm__ __volatile__ ("fnstenv %0" : "=m" (temp)); \ + temp.__status_word |= FP_EX_INEXACT; \ + __asm__ __volatile__ ("fldenv %0" : : "m" (temp)); \ + __asm__ __volatile__ ("fwait"); \ + } \ + } while (0) + +#define FP_RND_NEAREST 0 +#define FP_RND_ZERO 0xc00 +#define FP_RND_PINF 0x800 +#define FP_RND_MINF 0x400 + +#define _FP_DECL_EX \ + unsigned short _fcw __attribute__ ((unused)) = FP_RND_NEAREST + +#define FP_INIT_ROUNDMODE \ + do { \ + __asm__ ("fnstcw %0" : "=m" (_fcw)); \ + } while (0) + +#define FP_ROUNDMODE (_fcw & 0xc00) + +#define __LITTLE_ENDIAN 1234 +#define __BIG_ENDIAN 4321 + +#define __BYTE_ORDER __LITTLE_ENDIAN + +/* Define ALIASNAME as a strong alias for NAME. */ +#if defined __MACH__ +/* Mach-O doesn't support aliasing. If these functions ever return + anything but CMPtype we need to revisit this... */ +#define strong_alias(name, aliasname) \ + CMPtype aliasname (TFtype a, TFtype b) { return name(a, b); } +#else +# define strong_alias(name, aliasname) _strong_alias(name, aliasname) +# define _strong_alias(name, aliasname) \ + extern __typeof (name) aliasname __attribute__ ((alias (#name))); +#endif diff --git a/libgcc/config/i386/64/t-softfp-compat b/libgcc/config/i386/64/t-softfp-compat new file mode 100644 index 000000000..afaa526ae --- /dev/null +++ b/libgcc/config/i386/64/t-softfp-compat @@ -0,0 +1,15 @@ +# When TFmode was first added to x86-64 in gcc 4.3.0, some TFmode +# support functions got improper versions by accident. Here we +# correct the version and provide backward binary compatibility. + +# Filter out the following TFmode functions. +tf-compats = getf2.c letf2.c eqtf2.c +tf-functions := $(addprefix $(gcc_srcdir)/config/soft-fp/, $(tf-compats)) +LIB2ADD := $(filter-out $(tf-functions), $(LIB2ADD)) +LIB2ADD += $(addprefix $(srcdir)/config/i386/64/, $(tf-compats)) + +# Replace _divtc3, _multc3 and _powitf2. +libgcc2-tf-functions = _divtc3 _multc3 _powitf2 +LIB2FUNCS_EXCLUDE += $(libgcc2-tf-functions) +libgcc2-tf-compats = $(addsuffix .c, $(libgcc2-tf-functions)) +LIB2ADD += $(addprefix $(srcdir)/config/i386/64/, $(libgcc2-tf-compats)) diff --git a/libgcc/config/i386/libgcc-bsd.ver b/libgcc/config/i386/libgcc-bsd.ver new file mode 100644 index 000000000..d9d74f951 --- /dev/null +++ b/libgcc/config/i386/libgcc-bsd.ver @@ -0,0 +1,108 @@ +# Copyright (C) 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 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 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 COPYING3. If not see +# . + +# 128 bit long double support was introduced with GCC 4.6.0 for FreeBSD. +# These lines make the symbols to get a @@GCC_4.6.0. + +%exclude { + __addtf3 + __copysigntf3 + __divtc3 + __divtf3 + __eqtf2 + __extenddftf2 + __extendsftf2 + __extendxftf2 + __fabstf2 + __fixtfdi + __fixtfsi + __fixtfti + __fixunstfdi + __fixunstfsi + __fixunstfti + __floatditf + __floatsitf + __floattitf + __floatunditf + __floatunsitf + __floatuntitf + __getf2 + __gttf2 + __letf2 + __lttf2 + __multc3 + __multf3 + __negtf2 + __netf2 + __powitf2 + __subtf3 + __trunctfdf2 + __trunctfsf2 + __trunctfxf2 + __unordtf2 +} + +GCC_4.6.0 { + __addtf3 +%ifndef __x86_64__ + __copysigntf3 +%endif + __divtc3 + __divtf3 + __eqtf2 + __extenddftf2 + __extendsftf2 + __extendxftf2 +%ifndef __x86_64__ + __fabstf2 +%endif + __fixtfdi + __fixtfsi +%ifdef __x86_64__ + __fixtfti +%endif + __fixunstfdi + __fixunstfsi +%ifdef __x86_64__ + __fixunstfti +%endif + __floatditf + __floatsitf +%ifdef __x86_64__ + __floattitf +%endif + __floatunditf + __floatunsitf +%ifdef __x86_64__ + __floatuntitf +%endif + __getf2 + __gttf2 + __letf2 + __lttf2 + __multc3 + __multf3 + __negtf2 + __netf2 + __powitf2 + __subtf3 + __trunctfdf2 + __trunctfsf2 + __trunctfxf2 + __unordtf2 +} diff --git a/libgcc/config/i386/libgcc-sol2.ver b/libgcc/config/i386/libgcc-sol2.ver new file mode 100644 index 000000000..26a0abfb5 --- /dev/null +++ b/libgcc/config/i386/libgcc-sol2.ver @@ -0,0 +1,108 @@ +# Copyright (C) 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 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 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 COPYING3. If not see +# . + +# 128 bit long double support was introduced with GCC 4.5.0 for Solaris 2. +# These lines make the symbols to get a @@GCC_4.5.0. + +%exclude { + __addtf3 + __copysigntf3 + __divtc3 + __divtf3 + __eqtf2 + __extenddftf2 + __extendsftf2 + __extendxftf2 + __fabstf2 + __fixtfdi + __fixtfsi + __fixtfti + __fixunstfdi + __fixunstfsi + __fixunstfti + __floatditf + __floatsitf + __floattitf + __floatunditf + __floatunsitf + __floatuntitf + __getf2 + __gttf2 + __letf2 + __lttf2 + __multc3 + __multf3 + __negtf2 + __netf2 + __powitf2 + __subtf3 + __trunctfdf2 + __trunctfsf2 + __trunctfxf2 + __unordtf2 +} + +GCC_4.5.0 { + __addtf3 +%ifndef __x86_64__ + __copysigntf3 +%endif + __divtc3 + __divtf3 + __eqtf2 + __extenddftf2 + __extendsftf2 + __extendxftf2 +%ifndef __x86_64__ + __fabstf2 +%endif + __fixtfdi + __fixtfsi +%ifdef __x86_64__ + __fixtfti +%endif + __fixunstfdi + __fixunstfsi +%ifdef __x86_64__ + __fixunstfti +%endif + __floatditf + __floatsitf +%ifdef __x86_64__ + __floattitf +%endif + __floatunditf + __floatunsitf +%ifdef __x86_64__ + __floatuntitf +%endif + __getf2 + __gttf2 + __letf2 + __lttf2 + __multc3 + __multf3 + __negtf2 + __netf2 + __powitf2 + __subtf3 + __trunctfdf2 + __trunctfsf2 + __trunctfxf2 + __unordtf2 +} diff --git a/libgcc/config/i386/morestack.S b/libgcc/config/i386/morestack.S new file mode 100644 index 000000000..10fa1fdf7 --- /dev/null +++ b/libgcc/config/i386/morestack.S @@ -0,0 +1,593 @@ +# x86/x86_64 support for -fsplit-stack. +# Copyright (C) 2009, 2010 Free Software Foundation, Inc. +# Contributed by Ian Lance Taylor . + +# 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 3, 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. + +# 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 +# . + + +# Support for allocating more stack space when using -fsplit-stack. +# When a function discovers that it needs more stack space, it will +# call __morestack with the size of the stack frame and the size of +# the parameters to copy from the old stack frame to the new one. +# The __morestack function preserves the parameter registers and +# calls __generic_morestack to actually allocate the stack space. + +# When this is called stack space is very low, but we ensure that +# there is enough space to push the parameter registers and to call +# __generic_morestack. + +# When calling __generic_morestack, FRAME_SIZE points to the size of +# the desired frame when the function is called, and the function +# sets it to the size of the allocated stack. OLD_STACK points to +# the parameters on the old stack and PARAM_SIZE is the number of +# bytes of parameters to copy to the new stack. These are the +# parameters of the function that called __morestack. The +# __generic_morestack function returns the new stack pointer, +# pointing to the address of the first copied parameter. The return +# value minus the returned *FRAME_SIZE will be the first address on +# the stack which we should not use. + +# void *__generic_morestack (size_t *frame_size, void *old_stack, +# size_t param_size); + +# The __morestack routine has to arrange for the caller to return to a +# stub on the new stack. The stub is responsible for restoring the +# old stack pointer and returning to the caller's caller. This calls +# __generic_releasestack to retrieve the old stack pointer and release +# the newly allocated stack. + +# void *__generic_releasestack (size_t *available); + +# We do a little dance so that the processor's call/return return +# address prediction works out. The compiler arranges for the caller +# to look like this: +# call __generic_morestack +# ret +# L: +# // carry on with function +# After we allocate more stack, we call L, which is in our caller. +# When that returns (to the predicted instruction), we release the +# stack segment and reset the stack pointer. We then return to the +# predicted instruction, namely the ret instruction immediately after +# the call to __generic_morestack. That then returns to the caller of +# the original caller. + + +# The amount of extra space we ask for. In general this has to be +# enough for the dynamic loader to find a symbol and for a signal +# handler to run. + +#ifndef __x86_64__ +#define BACKOFF (1024) +#else +#define BACKOFF (1536) +#endif + + +# This entry point is for split-stack code which calls non-split-stack +# code. When the linker sees this case, it converts the call to +# __morestack to call __morestack_non_split instead. We just bump the +# requested stack space by 16K. + + .global __morestack_non_split + .hidden __morestack_non_split + +#ifdef __ELF__ + .type __morestack_non_split,@function +#endif + +__morestack_non_split: + +#ifndef __x86_64__ + addl $0x4000,4(%esp) +#else + addq $0x4000,%r10 +#endif + +#ifdef __ELF__ + .size __morestack_non_split, . - __morestack_non_split +#endif + +# __morestack_non_split falls through into __morestack. + + +# The __morestack function. + + .global __morestack + .hidden __morestack + +#ifdef __ELF__ + .type __morestack,@function +#endif + +__morestack: +.LFB1: + .cfi_startproc + + +#ifndef __x86_64__ + + +# The 32-bit __morestack function. + + # We use a cleanup to restore the stack guard if an exception + # is thrown through this code. +#ifndef __PIC__ + .cfi_personality 0,__gcc_personality_v0 + .cfi_lsda 0,.LLSDA1 +#else + .cfi_personality 0x9b,DW.ref.__gcc_personality_v0 + .cfi_lsda 0x1b,.LLSDA1 +#endif + + # Set up a normal backtrace. + pushl %ebp + .cfi_def_cfa_offset 8 + .cfi_offset %ebp, -8 + movl %esp, %ebp + .cfi_def_cfa_register %ebp + + # We return below with a ret $8. We will return to a single + # return instruction, which will return to the caller of our + # caller. We let the unwinder skip that single return + # instruction, and just return to the real caller. + .cfi_offset 8, 8 + .cfi_escape 0x15, 4, 0x7d # DW_CFA_val_offset_sf, %esp, 12/-4 + + # In 32-bit mode the parameters are pushed on the stack. The + # argument size is pushed then the new stack frame size is + # pushed. + + # In 32-bit mode the registers %eax, %edx, and %ecx may be + # used for parameters, depending on the regparm and fastcall + # attributes. + + pushl %eax + pushl %edx + pushl %ecx + + call __morestack_block_signals + + pushl 12(%ebp) # The size of the parameters. + leal 20(%ebp),%eax # Address of caller's parameters. + pushl %eax + addl $BACKOFF,8(%ebp) # Ask for backoff bytes. + leal 8(%ebp),%eax # The address of the new frame size. + pushl %eax + + # Note that %esp is exactly 32 bytes below the CFA -- perfect for + # a 16-byte aligned stack. That said, we still ought to compile + # generic-morestack.c with -mpreferred-stack-boundary=2. FIXME. + call __generic_morestack + + movl %eax,%esp # Switch to the new stack. + subl 8(%ebp),%eax # The end of the stack space. + addl $BACKOFF,%eax # Back off 512 bytes. + +.LEHB0: + # FIXME: The offset must match + # TARGET_THREAD_SPLIT_STACK_OFFSET in + # gcc/config/i386/linux.h. + movl %eax,%gs:0x30 # Save the new stack boundary. + + call __morestack_unblock_signals + + movl -8(%ebp),%edx # Restore registers. + movl -12(%ebp),%ecx + + movl 4(%ebp),%eax # Increment the return address + cmpb $0xc3,(%eax) # to skip the ret instruction; + je 1f # see above. + addl $2,%eax +1: inc %eax + + movl %eax,-8(%ebp) # Store return address in an + # unused slot. + + movl -4(%ebp),%eax # Restore the last register. + + call *-8(%ebp) # Call our caller! + + # The caller will return here, as predicted. + + # Save the registers which may hold a return value. We + # assume that __generic_releasestack does not touch any + # floating point or vector registers. + pushl %eax + pushl %edx + + # Push the arguments to __generic_releasestack now so that the + # stack is at a 16-byte boundary for + # __morestack_block_signals. + pushl $0 # Where the available space is returned. + leal 0(%esp),%eax # Push its address. + push %eax + + call __morestack_block_signals + + call __generic_releasestack + + subl 4(%esp),%eax # Subtract available space. + addl $BACKOFF,%eax # Back off 512 bytes. +.LEHE0: + movl %eax,%gs:0x30 # Save the new stack boundary. + + addl $8,%esp # Remove values from stack. + + # We need to restore the old stack pointer, which is in %rbp, + # before we unblock signals. We also need to restore %eax and + # %edx after we unblock signals but before we return. Do this + # by moving %eax and %edx from the current stack to the old + # stack. + + popl %edx # Pop return value from current stack. + popl %eax + + movl %ebp,%esp # Restore stack pointer. + + pushl %eax # Push return value on old stack. + pushl %edx + subl $8,%esp # Align stack to 16-byte boundary. + + call __morestack_unblock_signals + + addl $8,%esp + popl %edx # Restore return value. + popl %eax + + .cfi_remember_state + popl %ebp + .cfi_restore %ebp + .cfi_def_cfa %esp, 12 + ret $8 # Return to caller, which will + # immediately return. Pop + # arguments as we go. + +# This is the cleanup code called by the stack unwinder when unwinding +# through the code between .LEHB0 and .LEHE0 above. + +.L1: + .cfi_restore_state + subl $16,%esp # Maintain 16 byte alignment. + movl %eax,4(%esp) # Save exception header. + movl %ebp,(%esp) # Stack pointer after resume. + call __generic_findstack + movl %ebp,%ecx # Get the stack pointer. + subl %eax,%ecx # Subtract available space. + addl $BACKOFF,%ecx # Back off 512 bytes. + movl %ecx,%gs:0x30 # Save new stack boundary. + movl 4(%esp),%eax # Function argument. + movl %eax,(%esp) +#ifdef __PIC__ +#undef __i686 + call __i686.get_pc_thunk.bx # %ebx may not be set up for us. + addl $_GLOBAL_OFFSET_TABLE_, %ebx + call _Unwind_Resume@PLT # Resume unwinding. +#else + call _Unwind_Resume +#endif + +#else /* defined(__x86_64__) */ + + +# The 64-bit __morestack function. + + # We use a cleanup to restore the stack guard if an exception + # is thrown through this code. +#ifndef __PIC__ + .cfi_personality 0x3,__gcc_personality_v0 + .cfi_lsda 0x3,.LLSDA1 +#else + .cfi_personality 0x9b,DW.ref.__gcc_personality_v0 + .cfi_lsda 0x1b,.LLSDA1 +#endif + + # Set up a normal backtrace. + pushq %rbp + .cfi_def_cfa_offset 16 + .cfi_offset %rbp, -16 + movq %rsp, %rbp + .cfi_def_cfa_register %rbp + + # We will return a single return instruction, which will + # return to the caller of our caller. Let the unwinder skip + # that single return instruction, and just return to the real + # caller. + .cfi_offset 16, 0 + .cfi_escape 0x15, 7, 0x7f # DW_CFA_val_offset_sf, %esp, 8/-8 + + # In 64-bit mode the new stack frame size is passed in r10 + # and the argument size is passed in r11. + + addq $BACKOFF,%r10 # Ask for backoff bytes. + pushq %r10 # Save new frame size. + + # In 64-bit mode the registers %rdi, %rsi, %rdx, %rcx, %r8, + # and %r9 may be used for parameters. We also preserve %rax + # which the caller may use to hold %r10. + + pushq %rax + pushq %rdi + pushq %rsi + pushq %rdx + pushq %rcx + pushq %r8 + pushq %r9 + + pushq %r11 + pushq $0 # For alignment. + + call __morestack_block_signals + + leaq -8(%rbp),%rdi # Address of new frame size. + leaq 24(%rbp),%rsi # The caller's parameters. + addq $8,%rsp + popq %rdx # The size of the parameters. + + call __generic_morestack + + movq -8(%rbp),%r10 # Reload modified frame size + movq %rax,%rsp # Switch to the new stack. + subq %r10,%rax # The end of the stack space. + addq $BACKOFF,%rax # Back off 1024 bytes. + +.LEHB0: + # FIXME: The offset must match + # TARGET_THREAD_SPLIT_STACK_OFFSET in + # gcc/config/i386/linux64.h. + movq %rax,%fs:0x70 # Save the new stack boundary. + + call __morestack_unblock_signals + + movq -24(%rbp),%rdi # Restore registers. + movq -32(%rbp),%rsi + movq -40(%rbp),%rdx + movq -48(%rbp),%rcx + movq -56(%rbp),%r8 + movq -64(%rbp),%r9 + + movq 8(%rbp),%r10 # Increment the return address + incq %r10 # to skip the ret instruction; + # see above. + + movq -16(%rbp),%rax # Restore caller's %rax. + + call *%r10 # Call our caller! + + # The caller will return here, as predicted. + + # Save the registers which may hold a return value. We + # assume that __generic_releasestack does not touch any + # floating point or vector registers. + pushq %rax + pushq %rdx + + call __morestack_block_signals + + pushq $0 # For alignment. + pushq $0 # Where the available space is returned. + leaq 0(%rsp),%rdi # Pass its address. + + call __generic_releasestack + + subq 0(%rsp),%rax # Subtract available space. + addq $BACKOFF,%rax # Back off 1024 bytes. +.LEHE0: + movq %rax,%fs:0x70 # Save the new stack boundary. + + addq $16,%rsp # Remove values from stack. + + # We need to restore the old stack pointer, which is in %rbp, + # before we unblock signals. We also need to restore %rax and + # %rdx after we unblock signals but before we return. Do this + # by moving %rax and %rdx from the current stack to the old + # stack. + + popq %rdx # Pop return value from current stack. + popq %rax + + movq %rbp,%rsp # Restore stack pointer. + + pushq %rax # Push return value on old stack. + pushq %rdx + + call __morestack_unblock_signals + + popq %rdx # Restore return value. + popq %rax + + .cfi_remember_state + popq %rbp + .cfi_restore %rbp + .cfi_def_cfa %rsp, 8 + ret # Return to caller, which will + # immediately return. + +# This is the cleanup code called by the stack unwinder when unwinding +# through the code between .LEHB0 and .LEHE0 above. + +.L1: + .cfi_restore_state + subq $16,%rsp # Maintain 16 byte alignment. + movq %rax,(%rsp) # Save exception header. + movq %rbp,%rdi # Stack pointer after resume. + call __generic_findstack + movq %rbp,%rcx # Get the stack pointer. + subq %rax,%rcx # Subtract available space. + addq $BACKOFF,%rcx # Back off 1024 bytes. + movq %rcx,%fs:0x70 # Save new stack boundary. + movq (%rsp),%rdi # Restore exception data for call. +#ifdef __PIC__ + call _Unwind_Resume@PLT # Resume unwinding. +#else + call _Unwind_Resume # Resume unwinding. +#endif + +#endif /* defined(__x86_64__) */ + + .cfi_endproc +#ifdef __ELF__ + .size __morestack, . - __morestack +#endif + + +# The exception table. This tells the personality routine to execute +# the exception handler. + + .section .gcc_except_table,"a",@progbits + .align 4 +.LLSDA1: + .byte 0xff # @LPStart format (omit) + .byte 0xff # @TType format (omit) + .byte 0x1 # call-site format (uleb128) + .uleb128 .LLSDACSE1-.LLSDACSB1 # Call-site table length +.LLSDACSB1: + .uleb128 .LEHB0-.LFB1 # region 0 start + .uleb128 .LEHE0-.LEHB0 # length + .uleb128 .L1-.LFB1 # landing pad + .uleb128 0 # action +.LLSDACSE1: + + + .global __gcc_personality_v0 +#ifdef __PIC__ + # Build a position independent reference to the basic + # personality function. + .hidden DW.ref.__gcc_personality_v0 + .weak DW.ref.__gcc_personality_v0 + .section .data.DW.ref.__gcc_personality_v0,"awG",@progbits,DW.ref.__gcc_personality_v0,comdat + .type DW.ref.__gcc_personality_v0, @object +DW.ref.__gcc_personality_v0: +#ifndef __x86_64 + .align 4 + .size DW.ref.__gcc_personality_v0, 4 + .long __gcc_personality_v0 +#else + .align 8 + .size DW.ref.__gcc_personality_v0, 8 + .quad __gcc_personality_v0 +#endif +#endif + +#ifdef __x86_64__ + +# This entry point is used for the large model. With this entry point +# the upper 32 bits of %r10 hold the argument size and the lower 32 +# bits hold the new stack frame size. There doesn't seem to be a way +# to know in the assembler code that we are assembling for the large +# model, and there doesn't seem to be a large model multilib anyhow. +# If one is developed, then the non-PIC code is probably OK since we +# will probably be close to the morestack code, but the PIC code +# almost certainly needs to be changed. FIXME. + + .text + .global __morestack_large_model + .hidden __morestack_large_model + +#ifdef __ELF__ + .type __morestack_large_model,@function +#endif + +__morestack_large_model: + + .cfi_startproc + + movq %r10, %r11 + andl $0xffffffff, %r10d + sarq $32, %r11 + jmp __morestack + + .cfi_endproc +#ifdef __ELF__ + .size __morestack_large_model, . - __morestack_large_model +#endif + +#endif /* __x86_64__ */ + +# Initialize the stack test value when the program starts or when a +# new thread starts. We don't know how large the main stack is, so we +# guess conservatively. We might be able to use getrlimit here. + + .text + .global __stack_split_initialize + .hidden __stack_split_initialize + +#ifdef __ELF__ + .type __stack_split_initialize, @function +#endif + +__stack_split_initialize: + +#ifndef __x86_64__ + + leal -16000(%esp),%eax # We should have at least 16K. + movl %eax,%gs:0x30 + pushl $16000 + pushl %esp +#ifdef __PIC__ + call __generic_morestack_set_initial_sp@PLT +#else + call __generic_morestack_set_initial_sp +#endif + addl $8,%esp + ret + +#else /* defined(__x86_64__) */ + + leaq -16000(%rsp),%rax # We should have at least 16K. + movq %rax,%fs:0x70 + movq %rsp,%rdi + movq $16000,%rsi +#ifdef __PIC__ + call __generic_morestack_set_initial_sp@PLT +#else + call __generic_morestack_set_initial_sp +#endif + ret + +#endif /* defined(__x86_64__) */ + +#ifdef __ELF__ + .size __stack_split_initialize, . - __stack_split_initialize +#endif + + +# Make __stack_split_initialize a high priority constructor. FIXME: +# This is ELF specific. + + .section .ctors.65535,"aw",@progbits + +#ifndef __x86_64__ + .align 4 + .long __stack_split_initialize + .long __morestack_load_mmap +#else + .align 8 + .quad __stack_split_initialize + .quad __morestack_load_mmap +#endif + +#ifdef __ELF__ + .section .note.GNU-stack,"",@progbits + .section .note.GNU-split-stack,"",@progbits + .section .note.GNU-no-split-stack,"",@progbits +#endif diff --git a/libgcc/config/i386/t-crtfm b/libgcc/config/i386/t-crtfm new file mode 100644 index 000000000..6e89296b2 --- /dev/null +++ b/libgcc/config/i386/t-crtfm @@ -0,0 +1,5 @@ +# This is an endfile, Use -minline-all-stringops to ensure +# that __builtin_memset doesn't refer to the lib function memset(). +crtfastmath.o: $(gcc_srcdir)/config/i386/crtfastmath.c + $(gcc_compile) -msse -minline-all-stringops -c \ + $(gcc_srcdir)/config/i386/crtfastmath.c diff --git a/libgcc/config/i386/t-crtpc b/libgcc/config/i386/t-crtpc new file mode 100644 index 000000000..c231ce195 --- /dev/null +++ b/libgcc/config/i386/t-crtpc @@ -0,0 +1,8 @@ +crtprec32.o: $(gcc_srcdir)/config/i386/crtprec.c + $(gcc_compile) -D__PREC=32 -c $< + +crtprec64.o: $(gcc_srcdir)/config/i386/crtprec.c + $(gcc_compile) -D__PREC=64 -c $< + +crtprec80.o: $(gcc_srcdir)/config/i386/crtprec.c + $(gcc_compile) -D__PREC=80 -c $< diff --git a/libgcc/config/i386/t-cygming b/libgcc/config/i386/t-cygming new file mode 100644 index 000000000..048cadbd5 --- /dev/null +++ b/libgcc/config/i386/t-cygming @@ -0,0 +1,11 @@ +CUSTOM_CRTSTUFF = yes + +crtbegin.o: $(gcc_srcdir)/config/i386/cygming-crtbegin.c + $(crt_compile) -fno-omit-frame-pointer -c \ + $(gcc_srcdir)/config/i386/cygming-crtbegin.c + +# We intentionally use a implementation-reserved init priority of 0, +# so allow the warning. +crtend.o: $(gcc_srcdir)/config/i386/cygming-crtend.c + $(crt_compile) -fno-omit-frame-pointer -Wno-error -c \ + $(gcc_srcdir)/config/i386/cygming-crtend.c diff --git a/libgcc/config/i386/t-darwin b/libgcc/config/i386/t-darwin new file mode 100644 index 000000000..4578f74c3 --- /dev/null +++ b/libgcc/config/i386/t-darwin @@ -0,0 +1 @@ +SHLIB_VERPFX = $(gcc_srcdir)/config/i386/darwin-libgcc diff --git a/libgcc/config/i386/t-darwin64 b/libgcc/config/i386/t-darwin64 new file mode 100644 index 000000000..4578f74c3 --- /dev/null +++ b/libgcc/config/i386/t-darwin64 @@ -0,0 +1 @@ +SHLIB_VERPFX = $(gcc_srcdir)/config/i386/darwin-libgcc diff --git a/libgcc/config/i386/t-freebsd b/libgcc/config/i386/t-freebsd new file mode 100644 index 000000000..4f2bd204a --- /dev/null +++ b/libgcc/config/i386/t-freebsd @@ -0,0 +1,2 @@ +# Add support for the introduction of 128-bit long double. +SHLIB_MAPFILES += $(srcdir)/config/i386/libgcc-bsd.ver diff --git a/libgcc/config/i386/t-nwld b/libgcc/config/i386/t-nwld new file mode 100644 index 000000000..408587273 --- /dev/null +++ b/libgcc/config/i386/t-nwld @@ -0,0 +1,31 @@ +# Build a shared libgcc library for NetWare. + +SHLIB_EXT = .nlm +SHLIB_NAME = @shlib_base_name@.nlm +SHLIB_SLIBDIR_QUAL = @shlib_slibdir_qual@ +SHLIB_DEF = $(gcc_srcdir)/config/i386/netware-libgcc.def +SHLIB_MAP = $(gcc_srcdir)/config/i386/netware-libgcc.exp +SHLIB_SRC = $(gcc_srcdir)/config/i386/netware-libgcc.c + +SHLIB_LINK = set -e; \ + cat $(SHLIB_DEF) >@shlib_base_name@.def; \ + echo "name $(SHLIB_NAME)" >>@shlib_base_name@.def; \ + echo "version $(version)" | sed "s!\.!,!g" >>@shlib_base_name@.def; \ + touch build; \ + echo "build $$(expr $$(>@shlib_base_name@.def; \ + echo "export @$(SHLIB_MAP)" >>@shlib_base_name@.def; \ + if mpkxdc -n -p @shlib_base_name@.xdc; \ + then echo "xdcdata @shlib_base_name@.xdc" >>@shlib_base_name@.def; \ + else echo "WARNING: $(SHLIB_NAME) built without XDC data will not work well." 1>&2; \ + fi; \ + $(CC) $(LIBGCC2_CFLAGS) -o $(SHLIB_NAME) \ + $(SHLIB_SRC) -posix -static-libgcc -lnetware \ + -Wl,--Map,--map-info,full,--strip-all,--def-file,@shlib_base_name@.def; \ + rm -f @shlib_base_name@.imp; $(LN_S) $(SHLIB_MAP) @shlib_base_name@.imp; \ + rm -f libgcc.imp; $(LN_S) @shlib_base_name@.imp libgcc.imp; \ + expr $$(build + +SHLIB_INSTALL = \ + $(SHELL) $(srcdir)/mkinstalldirs $(slibdir)$(SHLIB_SLIBDIR_QUAL); \ + $(INSTALL_DATA) $(SHLIB_NAME) $(slibdir)$(SHLIB_SLIBDIR_QUAL)/$(SHLIB_NAME); \ + $(INSTALL_DATA) @shlib_base_name@.imp $(DESTDIR)$(libsubdir)/ diff --git a/libgcc/config/i386/t-sol2 b/libgcc/config/i386/t-sol2 new file mode 100644 index 000000000..883b1a92a --- /dev/null +++ b/libgcc/config/i386/t-sol2 @@ -0,0 +1,37 @@ +# gmon build rule: +$(T)gmon.o: $(gcc_srcdir)/config/i386/gmon-sol2.c $(GCC_PASSES) $(CONFIG_H) + $(GCC_FOR_TARGET) $(GCC_CFLAGS) $(INCLUDES) $(CFLAGS) \ + -c $(gcc_srcdir)/config/i386/gmon-sol2.c -o $(T)gmon.o + +# Assemble startup files. +# Apparently Sun believes that assembler files don't need comments, because no +# single ASCII character is valid (tried them all). So we manually strip out +# the comments with sed. This bug may only be in the Early Access releases. +$(T)gcrt1.o: $(gcc_srcdir)/config/i386/sol2-gc1.asm $(GCC_PASSES) + sed -e '/^!/d' <$(gcc_srcdir)/config/i386/sol2-gc1.asm >gcrt1.s + $(GCC_FOR_TARGET) $(CFLAGS) -c -o $(T)gcrt1.o gcrt1.s +$(T)crt1.o: $(gcc_srcdir)/config/i386/sol2-c1.asm $(GCC_PASSES) + sed -e '/^!/d' <$(gcc_srcdir)/config/i386/sol2-c1.asm >crt1.s + $(GCC_FOR_TARGET) $(CFLAGS) -c -o $(T)crt1.o crt1.s +$(T)crti.o: $(gcc_srcdir)/config/i386/sol2-ci.asm $(GCC_PASSES) + sed -e '/^!/d' <$(gcc_srcdir)/config/i386/sol2-ci.asm >crti.s + $(GCC_FOR_TARGET) $(CFLAGS) -c -o $(T)crti.o crti.s +$(T)crtn.o: $(gcc_srcdir)/config/i386/sol2-cn.asm $(GCC_PASSES) + sed -e '/^!/d' <$(gcc_srcdir)/config/i386/sol2-cn.asm >crtn.s + $(GCC_FOR_TARGET) $(CFLAGS) -c -o $(T)crtn.o crtn.s + +# We need to use -fPIC when we are using gcc to compile the routines in +# crtstuff.c. This is only really needed when we are going to use gcc/g++ +# to produce a shared library, but since we don't know ahead of time when +# we will be doing that, we just always use -fPIC when compiling the +# routines in crtstuff.c. +# +# We must also enable optimization to avoid having any code appear after +# the call & alignment statement, but before we switch back to the +# .text section. + +CRTSTUFF_T_CFLAGS = -fPIC -O2 +TARGET_LIBGCC2_CFLAGS = -fPIC + +# Add support for the introduction of 128-bit long double. +SHLIB_MAPFILES += $(srcdir)/config/i386/libgcc-sol2.ver diff --git a/libgcc/config/i386/t-stack-i386 b/libgcc/config/i386/t-stack-i386 new file mode 100644 index 000000000..9965f9402 --- /dev/null +++ b/libgcc/config/i386/t-stack-i386 @@ -0,0 +1,2 @@ +# Makefile fragment to support -fsplit-stack for x86. +LIB2ADD_ST += $(srcdir)/config/i386/morestack.S -- cgit v1.2.3