Changeset 1412 for trunk/src


Ignore:
Timestamp:
May 1, 2004, 6:01:44 AM (21 years ago)
Author:
bird
Message:

#858: don't use our 64-bit math. Cleanup.

Location:
trunk/src/gcc/gcc/config/i386
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/gcc/gcc/config/i386/emx-libgcc1.asm

    • Property cvs2svn:cvs-rev changed from 1.3 to 1.4
    r1411 r1412  
    1 //
    2 // r=bird: Need to determin the correct licensing on this code.
    3 //         Unless otherwise stated I guess it ends up as GPL.
    4 //
    5 
    6 // Avoid including emx/asm386.h
    7 #define ALIGN   .align  2, 0x90
    8 
    9 #define LABEL0(name)    _##name
    10 #define LABEL(name)     LABEL0(name)
    11 
     1        .text
     2       
     3#ifdef L_alloca
     4        .globl __alloca
     5// IN:   EAX = stack space to allocate (rounded to 4 boundary by GCC)
     6// OUT:  ESP adjusted down by EAX, stack probed
     7// NOTE: Never call this from C!
     8// CHG:  EAX. ESP
     9__alloca:
     10        pushl   %ecx                    /* save work registers */
     11        movl    %esp,%ecx               /* keep a pointer to stack frame */
     12        negl    %eax
     13        leal    4+4(%esp,%eax),%esp     /* adjust stack pointer */
     14        leal    4+4(%ecx),%eax
     15        .align 2, 0x90
     16L1:     subl    $0x1000,%eax            /* step down */
     17        cmpl    %esp,%eax
     18        jb      L2
     19        testb   %al,(%eax)              /* probe stack */
     20        jmp     L1
     21L2:     movl    4(%ecx),%eax            /* return address */
     22        movl    (%ecx),%ecx             /* pop ECX */
    1223#if defined (__EPILOGUE__)
    13 #define EPILOGUE_NO_RET(name) LABEL(__POST$##name):
    14 #else
    15 #define EPILOGUE_NO_RET(name)
    16 #endif
    17 
    18                 .text
    19 
    20 #ifdef L_alloca
    21                 .globl __alloca
    22 
    23 // IN:  EAX = stack space to allocate (rounded to 4 boundary by GCC)
    24 // OUT: ESP adjusted down by EAX, stack probed
    25 // NOTE: Never call this from C!
    26 // CHG: EAX
    27 
    28                 ALIGN
    29 __alloca:
    30                 pushl   %ecx                    /* save work registers */
    31                 movl    %esp,%ecx               /* keep a pointer to stack frame */
    32                 negl    %eax
    33                 leal    4+4(%esp,%eax),%esp     /* adjust stack pointer */
    34                 leal    4+4(%ecx),%eax
    35                 ALIGN
    36 L1:             subl    $0x1000,%eax            /* step down */
    37                 cmpl    %esp,%eax
    38                 jb      L2
    39                 testb   %al,(%eax)              /* probe stack */
    40                 jmp     L1
    41 L2:             movl    4(%ecx),%eax            /* return address */
    42                 movl    (%ecx),%ecx             /* pop ECX */
    43                 EPILOGUE_NO_RET(_alloca)
    44                 jmp     *%eax                   /* return */
     24___POST$_alloca:
     25#endif       
     26        jmp     *%eax                   /* return */
    4527
    4628#endif // L_alloca
    4729
    48 //------------------------------------------------------------------------------
    49 // division of 64-bit numbers
    50 //
    51 // Original idea by Eberhard Mattes:
    52 //
    53 // There's a better solution: set x':=x, y':=y. Shift right both x' and
    54 // y' until x' < 2^32. Then divide x' by y'. The result can be off by -1
    55 // due to the approximation. This can be checked by multiplying the
    56 // result by y and comparing to x-y. This verification step is not
    57 // required for x < 2^32.
    58 //
    59 // later (A.Z.) -
    60 //
    61 // There`s even a better solution: since i386+ can divide a 64-bit
    62 // integer by a 32-bit integer, we should shift both operands right until
    63 // quotient (i.e. y' in terms above) will be < 2^32. We can do this in one
    64 // step if we`ll use bsf/bsr i386+ instruction. If quotient is initially
    65 // less than 2^32, we can check first for overflow (i.e. if result will be
    66 // bigger or equal than 2^32) then proceed by well-known scheme (described
    67 // below) if it will overflow, and simply divide if it will not overflow.
    68 //
    69 // even more later (A.Z.) -
    70 //
    71 // hmm... after looking into libgcc2.c I see that it uses absolutely the
    72 // same idea :-) anyway, this asm implementation is shorter and faster
    73 //------------------------------------------------------------------------------
    74 // Here is how we`ll do 64-by-32 bit division (Eberhard Mattes):
    75 //
    76 // Divide 64-bit number by 32-bit number
    77 //
    78 // 2^32 a + b         a    2^32 (a mod c) + b
    79 // ---------- = 2^32 --- + ------------------   (integer division)
    80 //      c             c           c
    81 //
    82 // (2^32 a + b) mod c = (2^32 (a mod c) + b) mod c
    83 //
    84 // Proof:
    85 //
    86 // Divide by 2^32 c by successive subtraction (k steps) of 2^32 c.
    87 //
    88 // 2^32 a + b            2^32 a + b - 2^32 k c            2^32 (a-kc) + b
    89 // ---------- = 2^32 k + --------------------- = 2^32 k + ---------------
    90 //     c                            c                            c
    91 //
    92 // For k = [a/c], the equality 0 <= a-kc < c is true. Then, a-kc = a mod c.
    93 // For this k, the final division cannot overflow.
    94 //------------------------------------------------------------------------------
    95 
    96 #ifdef L_udivdi3
    97 
    98 // UDItype __udivdi3 (UDItype n, UDItype d)
    99 
    100                 .globl  ___udivdi3
    101 
    102 #define n 8+4(%esp)
    103 #define d 8+12(%esp)
    104 
    105                 ALIGN
    106 ___udivdi3:
    107                 pushl   %ebx
    108                 pushl   %esi
    109                 movl    n, %eax
    110                 movl    4+n, %edx               // edx:eax = n
    111                 movl    d, %ebx
    112                 movl    4+d, %esi               // esi:ebx = d
    113                 bsrl    %esi, %ecx
    114                 jnz     Lshiftcl
    115 
    116 // We`re here when d is less than 2^32
    117                 cmpl    %ebx, %edx              // edx < ebx?
    118                 jb      Ldiv                    // Yes, do a straight div
    119 
    120 // If we`re here, the result of division is a 64-bit integer
    121 // A 64-bit integer can result ONLY when (n >> 32) >= d
    122                 movl    %edx, %eax
    123                 xorl    %edx, %edx
    124                 divl    %ebx
    125                 movl    %eax, %esi      // high-order 32 bits of result
    126                 movl    n, %eax         // remainder of prev. div. in %edx
    127 Ldiv:           divl    %ebx
    128                 movl    %esi, %edx      // edx:eax = result
    129                 popl    %esi
    130                 popl    %ebx
    131                 ret
    132 
    133 Lshiftcl:
    134 // If we`re here, d is bigger or equal than 2^32
    135 // When cl is 31, we have result = n >= d ? 1 : 0
    136                 cmpb    $0x1f,%cl
    137                 jb      Lless31
    138                 xorl    %edx, %edx
    139                 movl    $1, %eax        // Assume result = 1
    140                 cmpl    %esi, %edx
    141                 ja      Lexit
    142                 jb      Lzero
    143                 cmpl    %ebx, %eax
    144                 jae     Lexit
    145 Lzero:          decl    %eax
    146 Lexit:          popl    %esi
    147                 popl    %ebx
    148                 ret
    149 
    150 Lless31:
    151                 pushl   %edi
    152 
    153 // Now we have to shift both n and d right cl times
    154                 incb    %cl
    155                 xorl    %edi, %edi
    156                 shrdl   %cl, %ebx, %edi // edi = discarded bits from d
    157                 shrdl   %cl, %esi, %ebx // now esi is free
    158 // Dirty trick: we should clear esi now, but rely on fact that esi >> cl = 0
    159                 shrdl   %cl, %eax, %esi // esi = discarded bits from n
    160                 shrdl   %cl, %edx, %eax // shift edx:eax right
    161                 shrl    %cl, %edx
    162                
    163 // Now ebx contains d, and edx:eax contains n
    164                 divl    %ebx
    165 
    166 // Now we should check whenever result*edi is
    167 // bigger or equal than remainder:esi -- if so, we
    168 // should decrement the result
    169                 movl    %eax, %ebx      // Duplicate result into ebx
    170                 movl    %edx, %ecx      // Duplicate remainder into ecx
    171                 mull    %edi
    172                 cmpl    %ecx, %edx
    173                 jae     Ldecres
    174                 jb      Lresok
    175                 cmpl    %esi, %eax
    176                 jb      Lresok
    177 
    178 Ldecres:        decl    %ebx
    179 Lresok:         xorl    %edx, %edx      // edx:eax = result
    180                 movl    %ebx, %eax
    181                 popl    %edi
    182                 popl    %esi
    183                 popl    %ebx
    184                 ret
    185 
    186 #endif // L_udivdi3
    187 
    188 #ifdef L_umoddi3
    189 
    190 // UDItype __umoddi3 (UDItype n, UDItype d)
    191 
    192                 .globl  ___umoddi3
    193 
    194 #define n 8+4(%esp)
    195 #define d 8+12(%esp)
    196 
    197                 ALIGN
    198 ___umoddi3:
    199                 pushl   %ebx
    200                 pushl   %esi
    201                 movl    n, %eax
    202                 movl    4+n, %edx               // edx:eax = n
    203                 movl    d, %ebx
    204                 movl    4+d, %esi               // esi:ebx = d
    205                 bsrl    %esi, %ecx
    206                 jnz     Lshiftcl
    207 
    208 // We`re here when d is less than 2^32
    209                 cmpl    %ebx, %edx              // edx < ebx?
    210                 jb      Ldiv                    // Yes, do a straight div
    211 
    212 // If we`re here, the result of division is a 64-bit integer
    213 // A 64-bit integer can result ONLY when (n >> 32) >= d
    214                 movl    %edx, %eax
    215                 xorl    %edx, %edx
    216                 divl    %ebx
    217                 movl    n, %eax         // remainder of prev. div. in %edx
    218 Ldiv:           divl    %ebx
    219                 movl    %edx, %eax      // lo(remainder) = edx
    220                 xorl    %edx, %edx      // hi(remainder) = 0
    221                 popl    %esi
    222                 popl    %ebx
    223                 ret
    224 
    225 Lshiftcl:
    226 // If we`re here, d is bigger or equal than 2^32
    227 // When cl is 31, we have result = n > d ? n - d : n
    228                 cmpb    $0x1f,%cl
    229                 jb      Lless31
    230                 subl    %ebx, %eax
    231                 sbbl    %esi, %edx
    232                 jnc     Lexit
    233                 movl    n, %eax
    234                 movl    4+n, %edx               // edx:eax = n
    235 Lexit:          popl    %esi
    236                 popl    %ebx
    237                 ret
    238 
    239 Lless31:
    240                 pushl   %edi
    241                 pushl   %ecx
    242 
    243 // Now we have to shift both n and d right cl times
    244                 incb    %cl
    245                 xorl    %edi, %edi
    246                 shrdl   %cl, %ebx, %edi // edi = discarded bits from d
    247                 shrdl   %cl, %esi, %ebx // now esi is free
    248 // Dirty trick: we should clear esi now, but rely on fact that esi >> cl = 0
    249                 shrdl   %cl, %eax, %esi // esi = discarded bits from n
    250                 shrdl   %cl, %edx, %eax // shift edx:eax right
    251                 shrl    %cl, %edx
    252 
    253 // Now ebx contains d, and edx:eax contains n
    254                 divl    %ebx
    255 
    256 // Now compute remainder as (edx:esi - result*edi) >> cl
    257                 movl    %edx, %ecx      // Duplicate remainder into ecx
    258                 mull    %edi
    259 
    260                 subl    %esi, %eax
    261                 sbbl    %ecx, %edx      // Compute result*edi - ecx:esi
    262                 jb      Lnegok          // remainder is bigger than result*edi
    263                 jnz     Lnotz
    264 
    265                 testl   %eax, %eax
    266                 jz      Lnormalize      // modulo = 0
    267 
    268 Lnotz:          subl    %edi, %eax      // Adjust modulo as if result
    269                 sbbl    %ebx, %edx      // was decremented by one
    270 
    271 Lnegok:         notl    %edx
    272                 negl    %eax
    273                 sbbl    $-1, %edx
    274 
    275 Lnormalize:     popl    %ecx
    276                 xorb    $0x1f, %cl
    277                 shrdl   %cl, %edx, %eax
    278                 shrl    %cl, %edx
    279 
    280                 popl    %edi
    281                 popl    %esi
    282                 popl    %ebx
    283                 ret
    284 
    285 #endif // L_umoddi3
    286 
    287 //**********************************************************//
    288 //                                                          //
    289 // Signed division/modulo uses unsigned versions of div/mod //
    290 //                                                          //
    291 //**********************************************************//
    292 
    293 #ifdef L_divdi3
    294 
    295 // DItype __divdi3 (DItype n, DItype d)
    296 
    297                 .globl  ___divdi3
    298 
    299 #define n 4+4(%esp)
    300 #define d 4+12(%esp)
    301 
    302                 ALIGN
    303 ___divdi3:
    304                 pushl   %esi
    305 
    306                 movl    4+n, %edx               // edx:eax = n
    307                 movl    4+d, %esi               // esi:ecx = d
    308                 movl    %edx, %eax
    309                 xorl    %esi, %eax              // Check resulting sign
    310                 js      Lnegate_sign
    311 
    312                 testl   %edx, %edx
    313                 jns     Lgoforit
    314 
    315                 notl    4+n                     // Negate both args
    316                 negl    n
    317                 sbbl    $-1, 4+n
    318 
    319                 notl    4+d
    320                 negl    d
    321                 sbbl    $-1, 4+d
    322 
    323 Lgoforit:       popl    %esi
    324                 jmp     ___udivdi3              // Dirty trick, but works
    325 
    326 Lnegate_sign:   movl    n, %eax
    327                 movl    d, %ecx
    328 
    329                 testl   %edx, %edx
    330                 jns     Ln_pos
    331                 notl    %edx
    332                 negl    %eax
    333                 sbbl    $-1, %edx
    334 Ln_pos:
    335                 testl   %esi, %esi
    336                 jns     Ld_pos
    337                 notl    %esi
    338                 negl    %ecx
    339                 sbbl    $-1, %esi
    340 Ld_pos:
    341                 pushl   %esi
    342                 pushl   %ecx
    343                 pushl   %edx
    344                 pushl   %eax
    345                 call    ___udivdi3
    346                 addl    $2*8, %esp
    347 
    348                 notl    %edx                    // Negate result
    349                 negl    %eax
    350                 sbbl    $-1, %edx
    351 
    352                 popl    %esi
    353                 ret
    354 #endif // L_divdi3
    355 
    356 #ifdef L_moddi3
    357 
    358 // DItype __moddi3 (DItype n, DItype d)
    359 
    360                 .globl  ___moddi3
    361 
    362 #define n 4+4(%esp)
    363 #define d 4+12(%esp)
    364 
    365                 ALIGN
    366 ___moddi3:
    367                 pushl   %esi
    368 
    369                 movl    4+n, %edx               // edx:eax = n
    370                 movl    4+d, %esi               // esi:ecx = d
    371                 testl   %edx, %edx
    372                 js      Lnegate_sign
    373 
    374                 testl   %esi, %esi
    375                 jns     Lgoforit
    376 
    377                 notl    4+d                     // negate d
    378                 negl    d
    379                 sbbl    $-1, 4+d
    380 
    381 Lgoforit:       popl    %esi
    382                 jmp     ___umoddi3              // Dirty trick, but works
    383 
    384 Lnegate_sign:   movl    n, %eax
    385                 movl    d, %ecx
    386 
    387                 testl   %edx, %edx
    388                 jns     Ln_pos
    389                 notl    %edx
    390                 negl    %eax
    391                 sbbl    $-1, %edx
    392 Ln_pos:
    393                 testl   %esi, %esi
    394                 jns     Ld_pos
    395                 notl    %esi
    396                 negl    %ecx
    397                 sbbl    $-1, %esi
    398 Ld_pos:
    399                 pushl   %esi
    400                 pushl   %ecx
    401                 pushl   %edx
    402                 pushl   %eax
    403                 call    ___umoddi3
    404                 addl    $2*8, %esp
    405 
    406                 notl    %edx                    // Negate result
    407                 negl    %eax
    408                 sbbl    $-1, %edx
    409 
    410                 popl    %esi
    411                 ret
    412 
    413 #endif // L_moddi3

  • trunk/src/gcc/gcc/config/i386/t-emx

    • Property cvs2svn:cvs-rev changed from 1.25 to 1.26
    r1411 r1412  
     1# start-of-file: $Id$
     2#
     3# InnoTek GCC for OS/2 target stuff.
     4#
     5
     6# Native include directory.
     7ifdef PATH_IGCC
     8NATIVE_SYSTEM_HEADER_DIR = $(PATH_IGCC)/include
     9else
     10ifdef PATH_EMXPGCC
     11NATIVE_SYSTEM_HEADER_DIR = $(PATH_EMXPGCC)/include
     12else
     13ifdef PATH_EMX
     14NATIVE_SYSTEM_HEADER_DIR = $(PATH_EMX)/include
     15endif
     16endif
     17endif
     18
     19
     20# DLL version string.
     21gccdll_version  = $(subst .,,$(gcc_version))
     22
    123# The command to run REXX scripts (you overload)
    2 REXX ?= kRx.exe
     24REXX           ?= kRx.exe
    325
    4 # EMX target have share libgcc, but the names are release specific and constrained by 8.3 limits.
    5 SHLIB_BASENAME = gcc$(gccdll_version)
    6 SHLIB_MULTINAME= $(SHLIB_BASENAME)
    7 SHLIB_DLLNAME  = $(SHLIB_MULTINAME).dll
    8 ifdef GCC_OMF
    9 SHLIB_BASENAME = gcc$(gccdll_version)o
    10 SHLIB_LINK     = export DLLAR_CMDLINE="$$(patsubst %.o,%.obj,@shlib_objs@)" \
    11         && emxomf @shlib_objs@ \
    12         && $(REXX) dllar.cmd -o $$(@D)/$(SHLIB_DLLNAME) \
    13         -ordinal @multilib_flags@ -nocrtdll \
    14         -flags "-g -Zomf -Zhigh-mem -v" \
    15         -ex "___main ___do_global_* ___ctordtor* ___eh* _DLL_InitTerm" \
    16         -d "GNU C runtime shared library version $(gcc_version)" \
    17         -libf "INITINSTANCE TERMGLOBAL" -lc_alias -lc_dll  \
    18         && realar rs $$(@D)/$(SHLIB_BASENAME).a libgcc/$$(@D)/__main.o libgcc/$$(@D)/emx-ctordtor.o libgcc/$$(@D)/emx-eh.o \
    19         && emxomf -o $$(@D)/$(SHLIB_BASENAME).lib $$(@D)/$(SHLIB_BASENAME).a \
    20     && touch $$@
    21 else
    22 SHLIB_LINK     = export DLLAR_CMDLINE="@shlib_objs@" && \
     26# The OS/2 target have shared libgcc, but the names are release specific and constrained by 8.3 limits.
     27SHLIB_BASENAME  = gcc$(gccdll_version)
     28SHLIB_MULTINAME = $(SHLIB_BASENAME)
     29SHLIB_DLLNAME   = $(SHLIB_MULTINAME).dll
     30SHLIB_LINK      = export DLLAR_CMDLINE="@shlib_objs@" && \
    2331        $(REXX) dllar.cmd -o $$(@D)/$(SHLIB_DLLNAME) \
    2432        -ordinal @multilib_flags@ -nocrtdll \
    2533        -flags "-Zhigh-mem -Zomf -g" \
    2634        -ex "___main ___do_global_* ___ctordtor* ___eh* _DLL_InitTerm" \
    27         -d "GNU C runtime shared library version $(gcc_version)" \
     35        -d "GNU GCC Runtime Version $(gcc_version)" \
    2836        -libf "INITINSTANCE TERMGLOBAL" -lc_alias -lc_dll  \
    2937        && ar rs $$(@D)/$(SHLIB_BASENAME).a libgcc/$$(@D)/__main.o libgcc/$$(@D)/emx-ctordtor.o libgcc/$$(@D)/emx-eh.o \
    3038    && touch $$@
    31 endif   
    32 SHLIB_SUBDIR  = .
    33 SHLIB_INSTALL = $$(INSTALL_DATA) $(SHLIB_SUBDIR)/$(SHLIB_DLLNAME) $$(DESTDIR)$$(slibdir)/ \
     39SHLIB_SUBDIR    = .
     40SHLIB_INSTALL   = $$(INSTALL_DATA) $(SHLIB_SUBDIR)/$(SHLIB_DLLNAME) $$(DESTDIR)$$(slibdir)/ \
    3441    && $$(INSTALL_DATA) $(SHLIB_SUBDIR)/$(SHLIB_BASENAME).a $$(DESTDIR)$$(libsubdir)/$(SHLIB_SUBDIR)/
    3542
    3643# Dont use collect2
    37 USE_COLLECT2 =
     44USE_COLLECT2    =
    3845# Don't run fixproto
    39 STMP_FIXPROTO =
     46STMP_FIXPROTO   =
    4047# Don't fix includes
    41 STMP_FIXINC =
     48STMP_FIXINC     =
    4249
    43 # bird: this is just bs and doesn't belong here at all.
    44 ## Override linker flags
    45 #LDFLAGS = -Zexe -Zcrtdll -Zstack 1024
    46 
    47 # Add the 's' flag to $AR so that we don't need ranlib
    48 AR_FLAGS = rcs
    49 
    50 # We also want epilogues for each function in libgcc
     50# Override libgcc2 C flags to ensure stack probing and epilogues.
    5151TARGET_LIBGCC2_CFLAGS = -Zaout -O2 -fomit-frame-pointer -Wall -mprobe -mepilogue -DNDEBUG
    5252
    5353# Provide alternative source code for libgcc1
    54 LIBGCC1 = libgcc1-asm.a
    55 CROSS_LIBGCC1 = libgcc1-asm.a
    56 LIB1ASMSRC = i386/emx-libgcc1.asm
    57 LIB1ASMFUNCS = _alloca _udivdi3 _umoddi3 _divdi3 _moddi3
     54LIBGCC1         = libgcc1-asm.a
     55CROSS_LIBGCC1   = libgcc1-asm.a
     56LIB1ASMSRC      = i386/emx-libgcc1.asm
     57LIB1ASMFUNCS    = _alloca
    5858
    59 # Extra functions to add to libgcc. (bird: don't forget $(srcdir) prefixing!)
     59# Extra functions to add to libgcc.
    6060LIB2FUNCS_EXTRA = $(srcdir)/config/i386/emx-ctordtor.c
    61 LIB2ADDEH = $(srcdir)/config/i386/emx-eh.c $(srcdir)/config/i386/emx-dllinit.c \
    62   $(srcdir)/unwind-dw2.c $(srcdir)/unwind-dw2-fde.c $(srcdir)/unwind-sjlj.c
     61LIB2ADDEH       = \
     62    $(srcdir)/config/i386/emx-eh.c \
     63    $(srcdir)/config/i386/emx-dllinit.c \
     64    $(srcdir)/unwind-dw2.c $(srcdir)/unwind-dw2-fde.c \
     65    $(srcdir)/unwind-sjlj.c
    6366#LIB2ADDEHDEP
    6467
    6568
    66 # EMX include directory
    67 # /emx/ is not emx here.
    68 #SYSTEM_HEADER_DIR = /emx/include
    69 NATIVE_SYSTEM_HEADER_DIR = $(PATH_EMXPGCC)/include
    70 
    71 # When compiling libgcc with the fresh xgcc, we still need the system headers
    72 # bird: this doesn't work for me... What am I doing wrong?
    73 #LIBGCC2_INCLUDES = -I$(SYSTEM_HEADER_DIR)
    74 
    75 # Same when compiling stage 2, 3 etc
    76 # bird: this doesn't work for me... What am I doing wrong?
    77 #T_CFLAGS = -I$(SYSTEM_HEADER_DIR)
    78 # bird: flags for GCC bootstrapping (stage2+)
    79 
    8069# Copy these files to include/ subdirectory
    81 # $(srcdir)/ginclude/stddef.h does not contain emx`s definition of _threadid
    82 USER_H = $(srcdir)/ginclude/stdarg.h $(srcdir)/ginclude/varargs.h \
    83     $(srcdir)/ginclude/stdbool.h $(srcdir)/ginclude/iso646.h \
    84     $(EXTRA_HEADERS)
    85 
    86 # Additional dependencies to build gcc.a and gcc_p.a
    87 # plus dynamicaly-linked version of libgcc*
    88 gccdll_version = $(subst .,,$(gcc_version))
    89 
    90 # bird (#424): dropping multilibs. Old hacks - START
    91 #stage1 stage2 stage3 stage4:
    92 #       echo "t-emx hacks: $@ starting"
    93 #       -mv -f *.exe *.ready st mt s-libgcc $@
    94 #       -rm -f $@/$(LIBGCC)
    95 #       echo "t-emx hacks: $@ done"
    96 
    97 ## Some final polishing of libgcc ...
    98 ## r=bird: Moved parts of this up to the SHLIB_LINK command.
    99 ##   Use cp as mv causes recreation of libversions during make install.
    100 ##   Is there ANY chance we could juse leave them as libgcc*.a? That would've
    101 ##   been much more convenient... 8.3 isn't an argument.
    102 #$(ALL): s-libgcc
    103 #s-libgcc: $(LIBGCC)
    104 #       echo "t-emx hacks: $@ starting"
    105 #       cp -f st/libgcc.a st/gcc.a
    106 #       cp -f st/libgcc_eh.a st/gcc_eh.a
    107 #       cp -f mt/libgcc.a mt/gcc.a
    108 #       cp -f mt/libgcc_eh.a mt/gcc_eh.a
    109 #       $(STAMP) s-libgcc
    110 #       echo "t-emx hacks: $@ done"
    111 # bird (#424): dropping multilibs. Old hacks - END
     70# GCC-OS/2: We override this to prevent usage of $(srcdir)/ginclude/stddef.h
     71#           and $(srcdir)/ginclude/float.h.
     72# bird:     Don't forget to check this when updating the code GCC.
     73USER_H          = \
     74         $(srcdir)/ginclude/iso646.h \
     75         $(srcdir)/ginclude/stdarg.h \
     76         $(srcdir)/ginclude/stdbool.h \
     77         \
     78         $(srcdir)/ginclude/varargs.h \
     79         $(srcdir)/unwind.h \
     80         $(EXTRA_HEADERS)
    11281
    11382# bird (#424): New gcc*dll hacks
    … …  
    11786        echo "t-emx hacks: $@ done"
    11887
     88# how to make the emx.o object.
    11989emx.o: $(srcdir)/config/i386/emx.c $(RTL_H) $(TREE_H) $(CONFIG_H)
    12090        $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/i386/emx.c
    12191
     92# end-of-file: t-emx
     93
Note: See TracChangeset for help on using the changeset viewer.