source: scripts/fetch/eglibc/2.10.1/10-ppc-atomic.diff@ 3c32719

clfs-1.2 clfs-2.1 clfs-3.0.0-systemd clfs-3.0.0-sysvinit systemd sysvinit
Last change on this file since 3c32719 was b17b911f, checked in by jim <clfs@…>, 15 years ago

Updated eglibc fetch script.
  • Property mode set to 100644
File size: 16.2 KB

  • sysdeps/powerpc/bits/atomic.h 

    RCS file: /cvs/glibc/libc/sysdeps/powerpc/bits/atomic.h,v
retrieving revision 1.17
diff -u -a -p -r1.17 atomic.h
    typedef uintmax_t uatomic_max_t;  
    8585      __typeof (*(mem)) __tmp;                                                \
    8686      __typeof (mem)  __memp = (mem);                                         \
    8787      __asm __volatile (                                                      \
    88                         "1:     lwarx   %0,0,%1" MUTEX_HINT_ACQ "\n"          \
     88                        "1:     lwarx   %0,%y1" MUTEX_HINT_ACQ "\n"           \
    8989                        "       cmpw    %0,%2\n"                              \
    9090                        "       bne     2f\n"                                 \
    91                         "       stwcx.  %3,0,%1\n"                            \
     91                        "       stwcx.  %3,%y1\n"                             \
    9292                        "       bne-    1b\n"                                 \
    9393                        "2:     " __ARCH_ACQ_INSTR                            \
    94                         : "=&r" (__tmp)                                       \
    95                         : "b" (__memp), "r" (oldval), "r" (newval)            \
     94                        : "=&r" (__tmp), "+Z" (*__memp)                       \
     95                        : "r" (oldval), "r" (newval)                          \
    9696                        : "cr0", "memory");                                   \
    9797      __tmp;                                                                  \
    9898  })
    … … typedef uintmax_t uatomic_max_t;  
    102102      __typeof (*(mem)) __tmp;                                                \
    103103      __typeof (mem)  __memp = (mem);                                         \
    104104      __asm __volatile (__ARCH_REL_INSTR "\n"                                 \
    105                         "1:     lwarx   %0,0,%1" MUTEX_HINT_REL "\n"          \
     105                        "1:     lwarx   %0,%y1" MUTEX_HINT_REL "\n"           \
    106106                        "       cmpw    %0,%2\n"                              \
    107107                        "       bne     2f\n"                                 \
    108                         "       stwcx.  %3,0,%1\n"                            \
     108                        "       stwcx.  %3,%y1\n"                             \
    109109                        "       bne-    1b\n"                                 \
    110110                        "2:     "                                             \
    111                         : "=&r" (__tmp)                                       \
    112                         : "b" (__memp), "r" (oldval), "r" (newval)            \
     111                        : "=&r" (__tmp), "+Z" (__memp)                        \
     112                        : "r" (oldval), "r" (newval)                          \
    113113                        : "cr0", "memory");                                   \
    114114      __tmp;                                                                  \
    115115  })
    … … typedef uintmax_t uatomic_max_t;  
    118118  ({                                                                          \
    119119    __typeof (*mem) __val;                                                    \
    120120    __asm __volatile (                                                        \
    121                       "1:       lwarx   %0,0,%2" MUTEX_HINT_ACQ "\n"          \
    122                       "         stwcx.  %3,0,%2\n"                            \
     121                      "1:       lwarx   %0,%y1" MUTEX_HINT_ACQ "\n"           \
     122                      "         stwcx.  %2,%y1\n"                             \
    123123                      "         bne-    1b\n"                                 \
    124124                      "   " __ARCH_ACQ_INSTR                                  \
    125                       : "=&r" (__val), "=m" (*mem)                            \
    126                       : "b" (mem), "r" (value), "m" (*mem)                    \
     125                      : "=&r" (__val), "+Z" (*mem)                            \
     126                      : "r" (value)                                           \
    127127                      : "cr0", "memory");                                     \
    128128    __val;                                                                    \
    129129  })
    … … typedef uintmax_t uatomic_max_t;  
    132132  ({                                                                          \
    133133    __typeof (*mem) __val;                                                    \
    134134    __asm __volatile (__ARCH_REL_INSTR "\n"                                   \
    135                       "1:       lwarx   %0,0,%2" MUTEX_HINT_REL "\n"          \
    136                       "         stwcx.  %3,0,%2\n"                            \
     135                      "1:       lwarx   %0,%y1" MUTEX_HINT_REL "\n"           \
     136                      "         stwcx.  %2,%y1\n"                             \
    137137                      "         bne-    1b"                                   \
    138                       : "=&r" (__val), "=m" (*mem)                            \
    139                       : "b" (mem), "r" (value), "m" (*mem)                    \
     138                      : "=&r" (__val), "+Z" (*mem)                            \
     139                      : "r" (value)                                           \
    140140                      : "cr0", "memory");                                     \
    141141    __val;                                                                    \
    142142  })
    … … typedef uintmax_t uatomic_max_t;  
    144144#define __arch_atomic_exchange_and_add_32(mem, value) \
    145145  ({                                                                          \
    146146    __typeof (*mem) __val, __tmp;                                             \
    147     __asm __volatile ("1:       lwarx   %0,0,%3\n"                            \
    148                       "         add     %1,%0,%4\n"                           \
    149                       "         stwcx.  %1,0,%3\n"                            \
     147    __asm __volatile ("1:       lwarx   %0,%y2\n"                             \
     148                      "         add     %1,%0,%3\n"                           \
     149                      "         stwcx.  %1,%y2\n"                             \
    150150                      "         bne-    1b"                                   \
    151                       : "=&b" (__val), "=&r" (__tmp), "=m" (*mem)             \
    152                       : "b" (mem), "r" (value), "m" (*mem)                    \
     151                      : "=&b" (__val), "=&r" (__tmp), "+Z" (*mem)             \
     152                      : "r" (value)                                           \
    153153                      : "cr0", "memory");                                     \
    154154    __val;                                                                    \
    155155  })
    … … typedef uintmax_t uatomic_max_t;  
    157157#define __arch_atomic_increment_val_32(mem) \
    158158  ({                                                                          \
    159159    __typeof (*(mem)) __val;                                                  \
    160     __asm __volatile ("1:       lwarx   %0,0,%2\n"                            \
     160    __asm __volatile ("1:       lwarx   %0,%y1\n"                             \
    161161                      "         addi    %0,%0,1\n"                            \
    162                       "         stwcx.  %0,0,%2\n"                            \
     162                      "         stwcx.  %0,%y1\n"                             \
    163163                      "         bne-    1b"                                   \
    164                       : "=&b" (__val), "=m" (*mem)                            \
    165                       : "b" (mem), "m" (*mem)                                 \
     164                      : "=&b" (__val), "+Z" (*mem)                            \
     165                      :                                                       \
    166166                      : "cr0", "memory");                                     \
    167167    __val;                                                                    \
    168168  })
    … … typedef uintmax_t uatomic_max_t;  
    170170#define __arch_atomic_decrement_val_32(mem) \
    171171  ({                                                                          \
    172172    __typeof (*(mem)) __val;                                                  \
    173     __asm __volatile ("1:       lwarx   %0,0,%2\n"                            \
     173    __asm __volatile ("1:       lwarx   %0,%y1\n"                             \
    174174                      "         subi    %0,%0,1\n"                            \
    175                       "         stwcx.  %0,0,%2\n"                            \
     175                      "         stwcx.  %0,%y1\n"                             \
    176176                      "         bne-    1b"                                   \
    177                       : "=&b" (__val), "=m" (*mem)                            \
    178                       : "b" (mem), "m" (*mem)                                 \
     177                      : "=&b" (__val), "+Z" (*mem)                            \
     178                      :                                                       \
    179179                      : "cr0", "memory");                                     \
    180180    __val;                                                                    \
    181181  })
    182182
    183183#define __arch_atomic_decrement_if_positive_32(mem) \
    184184  ({ int __val, __tmp;                                                        \
    185      __asm __volatile ("1:      lwarx   %0,0,%3\n"                            \
     185     __asm __volatile ("1:      lwarx   %0,%y2\n"                             \
    186186                       "        cmpwi   0,%0,0\n"                             \
    187187                       "        addi    %1,%0,-1\n"                           \
    188188                       "        ble     2f\n"                                 \
    189                        "        stwcx.  %1,0,%3\n"                            \
     189                       "        stwcx.  %1,%y2\n"                             \
    190190                       "        bne-    1b\n"                                 \
    191191                       "2:      " __ARCH_ACQ_INSTR                            \
    192                        : "=&b" (__val), "=&r" (__tmp), "=m" (*mem)            \
    193                        : "b" (mem), "m" (*mem)                                \
     192                       : "=&b" (__val), "=&r" (__tmp), "+Z" (*mem)            \
     193                       :                                                      \
    194194                       : "cr0", "memory");                                    \
    195195     __val;                                                                   \
    196196  })

  • sysdeps/powerpc/powerpc32/bits/atomic.h 

    RCS file: /cvs/glibc/libc/sysdeps/powerpc/powerpc32/bits/atomic.h,v
retrieving revision 1.6
diff -u -a -p -r1.6 atomic.h
     
    4444({                                                                            \
    4545  unsigned int __tmp;                                                         \
    4646  __asm __volatile (                                                          \
    47                     "1: lwarx   %0,0,%1" MUTEX_HINT_ACQ "\n"                  \
     47                    "1: lwarx   %0,%y1" MUTEX_HINT_ACQ "\n"                   \
    4848                    "   subf.   %0,%2,%0\n"                                   \
    4949                    "   bne     2f\n"                                         \
    50                     "   stwcx.  %3,0,%1\n"                                    \
     50                    "   stwcx.  %3,%y1\n"                                     \
    5151                    "   bne-    1b\n"                                         \
    5252                    "2: " __ARCH_ACQ_INSTR                                    \
    53                     : "=&r" (__tmp)                                           \
    54                     : "b" (mem), "r" (oldval), "r" (newval)                   \
     53                    : "=&r" (__tmp), "+Z" (*(mem))                            \
     54                    : "r" (oldval), "r" (newval)                              \
    5555                    : "cr0", "memory");                                       \
    5656  __tmp != 0;                                                                 \
    5757})
    … …  
    6060({                                                                            \
    6161  unsigned int __tmp;                                                         \
    6262  __asm __volatile (__ARCH_REL_INSTR "\n"                                     \
    63                     "1: lwarx   %0,0,%1" MUTEX_HINT_REL "\n"                  \
     63                    "1: lwarx   %0,%y1" MUTEX_HINT_REL "\n"                   \
    6464                    "   subf.   %0,%2,%0\n"                                   \
    6565                    "   bne     2f\n"                                         \
    66                     "   stwcx.  %3,0,%1\n"                                    \
     66                    "   stwcx.  %3,%y1\n"                                     \
    6767                    "   bne-    1b\n"                                         \
    6868                    "2: "                                                     \
    69                     : "=&r" (__tmp)                                           \
    70                     : "b" (mem), "r" (oldval), "r" (newval)                   \
     69                    : "=&r" (__tmp), "+Z" (*(mem))                            \
     70                    : "r" (oldval), "r" (newval)                              \
    7171                    : "cr0", "memory");                                       \
    7272  __tmp != 0;                                                                 \
    7373})

  • sysdeps/powerpc/powerpc64/bits/atomic.h 

    RCS file: /cvs/glibc/libc/sysdeps/powerpc/powerpc64/bits/atomic.h,v
retrieving revision 1.8
diff -u -a -p -r1.8 atomic.h
     
    4444({                                                                            \
    4545  unsigned int __tmp, __tmp2;                                                 \
    4646  __asm __volatile ("   clrldi  %1,%1,32\n"                                   \
    47                     "1: lwarx   %0,0,%2" MUTEX_HINT_ACQ "\n"                  \
     47                    "1: lwarx   %0,%y2" MUTEX_HINT_ACQ "\n"                   \
    4848                    "   subf.   %0,%1,%0\n"                                   \
    4949                    "   bne     2f\n"                                         \
    50                     "   stwcx.  %4,0,%2\n"                                    \
     50                    "   stwcx.  %4,%y2\n"                                     \
    5151                    "   bne-    1b\n"                                         \
    5252                    "2: " __ARCH_ACQ_INSTR                                    \
    53                     : "=&r" (__tmp), "=r" (__tmp2)                            \
    54                     : "b" (mem), "1" (oldval), "r" (newval)                   \
     53                    : "=&r" (__tmp), "=r" (__tmp2), "+Z" (*(mem))             \
     54                    : "1" (oldval), "r" (newval)                              \
    5555                    : "cr0", "memory");                                       \
    5656  __tmp != 0;                                                                 \
    5757})
    … …  
    6161  unsigned int __tmp, __tmp2;                                                 \
    6262  __asm __volatile (__ARCH_REL_INSTR "\n"                                     \
    6363                    "   clrldi  %1,%1,32\n"                                   \
    64                     "1: lwarx   %0,0,%2" MUTEX_HINT_REL "\n"                  \
     64                    "1: lwarx   %0,%y2" MUTEX_HINT_REL "\n"                   \
    6565                    "   subf.   %0,%1,%0\n"                                   \
    6666                    "   bne     2f\n"                                         \
    67                     "   stwcx.  %4,0,%2\n"                                    \
     67                    "   stwcx.  %4,%y2\n"                                     \
    6868                    "   bne-    1b\n"                                         \
    6969                    "2: "                                                     \
    70                     : "=&r" (__tmp), "=r" (__tmp2)                            \
    71                     : "b" (mem), "1" (oldval), "r" (newval)                   \
     70                    : "=&r" (__tmp), "=r" (__tmp2), "+Z" (*(mem))             \
     71                    : "1" (oldval), "r" (newval)                              \
    7272                    : "cr0", "memory");                                       \
    7373  __tmp != 0;                                                                 \
    7474})
    … …  
    8282({                                                                            \
    8383  unsigned long __tmp;                                                        \
    8484  __asm __volatile (                                                          \
    85                     "1: ldarx   %0,0,%1" MUTEX_HINT_ACQ "\n"                  \
     85                    "1: ldarx   %0,%y1" MUTEX_HINT_ACQ "\n"                   \
    8686                    "   subf.   %0,%2,%0\n"                                   \
    8787                    "   bne     2f\n"                                         \
    88                     "   stdcx.  %3,0,%1\n"                                    \
     88                    "   stdcx.  %3,%y1\n"                                     \
    8989                    "   bne-    1b\n"                                         \
    9090                    "2: " __ARCH_ACQ_INSTR                                    \
    91                     : "=&r" (__tmp)                                           \
    92                     : "b" (mem), "r" (oldval), "r" (newval)                   \
     91                    : "=&r" (__tmp), "+Z" (*(mem))                            \
     92                    : "r" (oldval), "r" (newval)                              \
    9393                    : "cr0", "memory");                                       \
    9494  __tmp != 0;                                                                 \
    9595})
    … …  
    9898({                                                                            \
    9999  unsigned long __tmp;                                                        \
    100100  __asm __volatile (__ARCH_REL_INSTR "\n"                                     \
    101                     "1: ldarx   %0,0,%2" MUTEX_HINT_REL "\n"                  \
     101                    "1: ldarx   %0,%y1" MUTEX_HINT_REL "\n"                   \
    102102                    "   subf.   %0,%2,%0\n"                                   \
    103103                    "   bne     2f\n"                                         \
    104                     "   stdcx.  %3,0,%1\n"                                    \
     104                    "   stdcx.  %3,%y1\n"                                     \
    105105                    "   bne-    1b\n"                                         \
    106106                    "2: "                                                     \
    107                     : "=&r" (__tmp)                                           \
    108                     : "b" (mem), "r" (oldval), "r" (newval)                   \
     107                    : "=&r" (__tmp), "+Z" (*(mem))                            \
     108                    : "r" (oldval), "r" (newval)                              \
    109109                    : "cr0", "memory");                                       \
    110110  __tmp != 0;                                                                 \
    111111})
    … …  
    115115      __typeof (*(mem)) __tmp;                                                \
    116116      __typeof (mem)  __memp = (mem);                                         \
    117117      __asm __volatile (                                                      \
    118                         "1:     ldarx   %0,0,%1" MUTEX_HINT_ACQ "\n"          \
     118                        "1:     ldarx   %0,%y1" MUTEX_HINT_ACQ "\n"           \
    119119                        "       cmpd    %0,%2\n"                              \
    120120                        "       bne     2f\n"                                 \
    121                         "       stdcx.  %3,0,%1\n"                            \
     121                        "       stdcx.  %3,%y1\n"                             \
    122122                        "       bne-    1b\n"                                 \
    123123                        "2:     " __ARCH_ACQ_INSTR                            \
    124                         : "=&r" (__tmp)                                       \
    125                         : "b" (__memp), "r" (oldval), "r" (newval)            \
     124                        : "=&r" (__tmp), "+Z" (*__memp)                       \
     125                        : "r" (oldval), "r" (newval)                          \
    126126                        : "cr0", "memory");                                   \
    127127      __tmp;                                                                  \
    128128  })
    … …  
    132132      __typeof (*(mem)) __tmp;                                                \
    133133      __typeof (mem)  __memp = (mem);                                         \
    134134      __asm __volatile (__ARCH_REL_INSTR "\n"                                 \
    135                         "1:     ldarx   %0,0,%1" MUTEX_HINT_REL "\n"          \
     135                        "1:     ldarx   %0,%y1" MUTEX_HINT_REL "\n"           \
    136136                        "       cmpd    %0,%2\n"                              \
    137137                        "       bne     2f\n"                                 \
    138                         "       stdcx.  %3,0,%1\n"                            \
     138                        "       stdcx.  %3,%y1\n"                             \
    139139                        "       bne-    1b\n"                                 \
    140140                        "2:     "                                             \
    141                         : "=&r" (__tmp)                                       \
    142                         : "b" (__memp), "r" (oldval), "r" (newval)            \
     141                        : "=&r" (__tmp), "+Z" (*__memp)                       \
     142                        : "r" (oldval), "r" (newval)                          \
    143143                        : "cr0", "memory");                                   \
    144144      __tmp;                                                                  \
    145145  })
    … …  
    148148    ({                                                                        \
    149149      __typeof (*mem) __val;                                                  \
    150150      __asm __volatile (__ARCH_REL_INSTR "\n"                                 \
    151                         "1:     ldarx   %0,0,%2" MUTEX_HINT_ACQ "\n"          \
    152                         "       stdcx.  %3,0,%2\n"                            \
     151                        "1:     ldarx   %0,%y1" MUTEX_HINT_ACQ "\n"           \
     152                        "       stdcx.  %2,%y1\n"                             \
    153153                        "       bne-    1b\n"                                 \
    154154                  " " __ARCH_ACQ_INSTR                                        \
    155                         : "=&r" (__val), "=m" (*mem)                          \
    156                         : "b" (mem), "r" (value), "m" (*mem)                  \
     155                        : "=&r" (__val), "+Z" (*(mem))                        \
     156                        : "r" (value)                                         \
    157157                        : "cr0", "memory");                                   \
    158158      __val;                                                                  \
    159159    })
    … …  
    162162    ({                                                                        \
    163163      __typeof (*mem) __val;                                                  \
    164164      __asm __volatile (__ARCH_REL_INSTR "\n"                                 \
    165                         "1:     ldarx   %0,0,%2" MUTEX_HINT_REL "\n"          \
    166                         "       stdcx.  %3,0,%2\n"                            \
     165                        "1:     ldarx   %0,%y1" MUTEX_HINT_REL "\n"           \
     166                        "       stdcx.  %2,%y1\n"                             \
    167167                        "       bne-    1b"                                   \
    168                         : "=&r" (__val), "=m" (*mem)                          \
    169                         : "b" (mem), "r" (value), "m" (*mem)                  \
     168                        : "=&r" (__val), "+Z" (*(mem))                        \
     169                        : "r" (value)                                         \
    170170                        : "cr0", "memory");                                   \
    171171      __val;                                                                  \
    172172    })
    … …  
    174174#define __arch_atomic_exchange_and_add_64(mem, value) \
    175175    ({                                                                        \
    176176      __typeof (*mem) __val, __tmp;                                           \
    177       __asm __volatile ("1:     ldarx   %0,0,%3\n"                            \
    178                         "       add     %1,%0,%4\n"                           \
    179                         "       stdcx.  %1,0,%3\n"                            \
     177      __asm __volatile ("1:     ldarx   %0,%y2\n"                             \
     178                        "       add     %1,%0,%3\n"                           \
     179                        "       stdcx.  %1,%y2\n"                             \
    180180                        "       bne-    1b"                                   \
    181                         : "=&b" (__val), "=&r" (__tmp), "=m" (*mem)           \
    182                         : "b" (mem), "r" (value), "m" (*mem)                  \
     181                        : "=&b" (__val), "=&r" (__tmp), "+Z" (*(mem))         \
     182                        : "r" (value)                                         \
    183183                        : "cr0", "memory");                                   \
    184184      __val;                                                                  \
    185185    })
    … …  
    187187#define __arch_atomic_increment_val_64(mem) \
    188188    ({                                                                        \
    189189      __typeof (*(mem)) __val;                                                \
    190       __asm __volatile ("1:     ldarx   %0,0,%2\n"                            \
     190      __asm __volatile ("1:     ldarx   %0,%y1\n"                             \
    191191                        "       addi    %0,%0,1\n"                            \
    192                         "       stdcx.  %0,0,%2\n"                            \
     192                        "       stdcx.  %0,%y1\n"                             \
    193193                        "       bne-    1b"                                   \
    194                         : "=&b" (__val), "=m" (*mem)                          \
    195                         : "b" (mem), "m" (*mem)                               \
     194                        : "=&b" (__val), "+Z" (*(mem))                        \
     195                        :                                                     \
    196196                        : "cr0", "memory");                                   \
    197197      __val;                                                                  \
    198198    })
    … …  
    200200#define __arch_atomic_decrement_val_64(mem) \
    201201    ({                                                                        \
    202202      __typeof (*(mem)) __val;                                                \
    203       __asm __volatile ("1:     ldarx   %0,0,%2\n"                            \
     203      __asm __volatile ("1:     ldarx   %0,%y1\n"                             \
    204204                        "       subi    %0,%0,1\n"                            \
    205                         "       stdcx.  %0,0,%2\n"                            \
     205                        "       stdcx.  %0,%y1\n"                             \
    206206                        "       bne-    1b"                                   \
    207                         : "=&b" (__val), "=m" (*mem)                          \
    208                         : "b" (mem), "m" (*mem)                               \
     207                        : "=&b" (__val), "+Z" (*(mem))                        \
     208                        :                                                     \
    209209                        : "cr0", "memory");                                   \
    210210      __val;                                                                  \
    211211    })
    212212
    213213#define __arch_atomic_decrement_if_positive_64(mem) \
    214214  ({ int __val, __tmp;                                                        \
    215      __asm __volatile ("1:      ldarx   %0,0,%3\n"                            \
     215     __asm __volatile ("1:      ldarx   %0,%y2\n"                             \
    216216                       "        cmpdi   0,%0,0\n"                             \
    217217                       "        addi    %1,%0,-1\n"                           \
    218218                       "        ble     2f\n"                                 \
    219                        "        stdcx.  %1,0,%3\n"                            \
     219                       "        stdcx.  %1,%y2\n"                             \
    220220                       "        bne-    1b\n"                                 \
    221221                       "2:      " __ARCH_ACQ_INSTR                            \
    222                        : "=&b" (__val), "=&r" (__tmp), "=m" (*mem)            \
    223                        : "b" (mem), "m" (*mem)                                \
     222                       : "=&b" (__val), "=&r" (__tmp), "+Z" (*(mem))          \
     223                       :                                                      \
    224224                       : "cr0", "memory");                                    \
    225225     __val;                                                                   \
    226226  })
Note: See TracBrowser for help on using the repository browser.