Return to ngx_gcc_atomic_ppc.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / os / unix

Annotation of embedaddon/nginx/src/os/unix/ngx_gcc_atomic_ppc.h, revision 1.1

1.1     ! misho       1: 
        !             2: /*
        !             3:  * Copyright (C) Igor Sysoev
        !             4:  * Copyright (C) Nginx, Inc.
        !             5:  */
        !             6: 
        !             7: 
        !             8: /*
        !             9:  * The ppc assembler treats ";" as comment, so we have to use "\n".
        !            10:  * The minus in "bne-" is a hint for the branch prediction unit that
        !            11:  * this branch is unlikely to be taken.
        !            12:  * The "1b" means the nearest backward label "1" and the "1f" means
        !            13:  * the nearest forward label "1".
        !            14:  *
        !            15:  * The "b" means that the base registers can be used only, i.e.
        !            16:  * any register except r0.  The r0 register always has a zero value and
        !            17:  * could not be used in "addi  r0, r0, 1".
        !            18:  * The "=&b" means that no input registers can be used.
        !            19:  *
        !            20:  * "sync"    read and write barriers
        !            21:  * "isync"   read barrier, is faster than "sync"
        !            22:  * "eieio"   write barrier, is faster than "sync"
        !            23:  * "lwsync"  write barrier, is faster than "eieio" on ppc64
        !            24:  */
        !            25: 
        !            26: #if (NGX_PTR_SIZE == 8)
        !            27: 
        !            28: static ngx_inline ngx_atomic_uint_t
        !            29: ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
        !            30:     ngx_atomic_uint_t set)
        !            31: {
        !            32:     ngx_atomic_uint_t  res, temp;
        !            33: 
        !            34:     __asm__ volatile (
        !            35: 
        !            36:     "    li      %0, 0       \n" /* preset "0" to "res"                      */
        !            37:     "    lwsync              \n" /* write barrier                            */
        !            38:     "1:                      \n"
        !            39:     "    ldarx   %1, 0, %2   \n" /* load from [lock] into "temp"             */
        !            40:                                  /*   and store reservation                  */
        !            41:     "    cmpd    %1, %3      \n" /* compare "temp" and "old"                 */
        !            42:     "    bne-    2f          \n" /* not equal                                */
        !            43:     "    stdcx.  %4, 0, %2   \n" /* store "set" into [lock] if reservation   */
        !            44:                                  /*   is not cleared                         */
        !            45:     "    bne-    1b          \n" /* the reservation was cleared              */
        !            46:     "    isync               \n" /* read barrier                             */
        !            47:     "    li      %0, 1       \n" /* set "1" to "res"                         */
        !            48:     "2:                      \n"
        !            49: 
        !            50:     : "=&b" (res), "=&b" (temp)
        !            51:     : "b" (lock), "b" (old), "b" (set)
        !            52:     : "cc", "memory");
        !            53: 
        !            54:     return res;
        !            55: }
        !            56: 
        !            57: 
        !            58: static ngx_inline ngx_atomic_int_t
        !            59: ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
        !            60: {
        !            61:     ngx_atomic_uint_t  res, temp;
        !            62: 
        !            63:     __asm__ volatile (
        !            64: 
        !            65:     "    lwsync              \n" /* write barrier                            */
        !            66:     "1:  ldarx   %0, 0, %2   \n" /* load from [value] into "res"             */
        !            67:                                  /*   and store reservation                  */
        !            68:     "    add     %1, %0, %3  \n" /* "res" + "add" store in "temp"            */
        !            69:     "    stdcx.  %1, 0, %2   \n" /* store "temp" into [value] if reservation */
        !            70:                                  /*   is not cleared                         */
        !            71:     "    bne-    1b          \n" /* try again if reservation was cleared     */
        !            72:     "    isync               \n" /* read barrier                             */
        !            73: 
        !            74:     : "=&b" (res), "=&b" (temp)
        !            75:     : "b" (value), "b" (add)
        !            76:     : "cc", "memory");
        !            77: 
        !            78:     return res;
        !            79: }
        !            80: 
        !            81: 
        !            82: #if (NGX_SMP)
        !            83: #define ngx_memory_barrier()                                                  \
        !            84:     __asm__ volatile ("isync  \n  lwsync  \n" ::: "memory")
        !            85: #else
        !            86: #define ngx_memory_barrier()   __asm__ volatile ("" ::: "memory")
        !            87: #endif
        !            88: 
        !            89: #else
        !            90: 
        !            91: static ngx_inline ngx_atomic_uint_t
        !            92: ngx_atomic_cmp_set(ngx_atomic_t *lock, ngx_atomic_uint_t old,
        !            93:     ngx_atomic_uint_t set)
        !            94: {
        !            95:     ngx_atomic_uint_t  res, temp;
        !            96: 
        !            97:     __asm__ volatile (
        !            98: 
        !            99:     "    li      %0, 0       \n" /* preset "0" to "res"                      */
        !           100:     "    eieio               \n" /* write barrier                            */
        !           101:     "1:                      \n"
        !           102:     "    lwarx   %1, 0, %2   \n" /* load from [lock] into "temp"             */
        !           103:                                  /*   and store reservation                  */
        !           104:     "    cmpw    %1, %3      \n" /* compare "temp" and "old"                 */
        !           105:     "    bne-    2f          \n" /* not equal                                */
        !           106:     "    stwcx.  %4, 0, %2   \n" /* store "set" into [lock] if reservation   */
        !           107:                                  /*   is not cleared                         */
        !           108:     "    bne-    1b          \n" /* the reservation was cleared              */
        !           109:     "    isync               \n" /* read barrier                             */
        !           110:     "    li      %0, 1       \n" /* set "1" to "res"                         */
        !           111:     "2:                      \n"
        !           112: 
        !           113:     : "=&b" (res), "=&b" (temp)
        !           114:     : "b" (lock), "b" (old), "b" (set)
        !           115:     : "cc", "memory");
        !           116: 
        !           117:     return res;
        !           118: }
        !           119: 
        !           120: 
        !           121: static ngx_inline ngx_atomic_int_t
        !           122: ngx_atomic_fetch_add(ngx_atomic_t *value, ngx_atomic_int_t add)
        !           123: {
        !           124:     ngx_atomic_uint_t  res, temp;
        !           125: 
        !           126:     __asm__ volatile (
        !           127: 
        !           128:     "    eieio               \n" /* write barrier                            */
        !           129:     "1:  lwarx   %0, 0, %2   \n" /* load from [value] into "res"             */
        !           130:                                  /*   and store reservation                  */
        !           131:     "    add     %1, %0, %3  \n" /* "res" + "add" store in "temp"            */
        !           132:     "    stwcx.  %1, 0, %2   \n" /* store "temp" into [value] if reservation */
        !           133:                                  /*   is not cleared                         */
        !           134:     "    bne-    1b          \n" /* try again if reservation was cleared     */
        !           135:     "    isync               \n" /* read barrier                             */
        !           136: 
        !           137:     : "=&b" (res), "=&b" (temp)
        !           138:     : "b" (value), "b" (add)
        !           139:     : "cc", "memory");
        !           140: 
        !           141:     return res;
        !           142: }
        !           143: 
        !           144: 
        !           145: #if (NGX_SMP)
        !           146: #define ngx_memory_barrier()                                                  \
        !           147:     __asm__ volatile ("isync  \n  eieio  \n" ::: "memory")
        !           148: #else
        !           149: #define ngx_memory_barrier()   __asm__ volatile ("" ::: "memory")
        !           150: #endif
        !           151: 
        !           152: #endif
        !           153: 
        !           154: 
        !           155: #define ngx_cpu_pause()