lkml.org 
[lkml]   [2020]   [Jul]   [23]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[tip: x86/asm] x86/percpu: Clean up percpu_add_op()
    The following commit has been merged into the x86/asm branch of tip:

    Commit-ID: 33e5614a435ff8047d768e6501454ae1cc7f131f
    Gitweb: https://git.kernel.org/tip/33e5614a435ff8047d768e6501454ae1cc7f131f
    Author: Brian Gerst <brgerst@gmail.com>
    AuthorDate: Mon, 20 Jul 2020 13:49:18 -07:00
    Committer: Thomas Gleixner <tglx@linutronix.de>
    CommitterDate: Thu, 23 Jul 2020 11:46:40 +02:00

    x86/percpu: Clean up percpu_add_op()

    The core percpu macros already have a switch on the data size, so the switch
    in the x86 code is redundant and produces more dead code.

    Also use appropriate types for the width of the instructions. This avoids
    errors when compiling with Clang.

    Signed-off-by: Brian Gerst <brgerst@gmail.com>
    Signed-off-by: Nick Desaulniers <ndesaulniers@google.com>
    Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
    Tested-by: Nick Desaulniers <ndesaulniers@google.com>
    Tested-by: Sedat Dilek <sedat.dilek@gmail.com>
    Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
    Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
    Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
    Acked-by: Dennis Zhou <dennis@kernel.org>
    Link: https://lkml.kernel.org/r/20200720204925.3654302-5-ndesaulniers@google.com

    ---
    arch/x86/include/asm/percpu.h | 99 +++++++--------------------------
    1 file changed, 22 insertions(+), 77 deletions(-)

    diff --git a/arch/x86/include/asm/percpu.h b/arch/x86/include/asm/percpu.h
    index a40d2e0..2a24f3c 100644
    --- a/arch/x86/include/asm/percpu.h
    +++ b/arch/x86/include/asm/percpu.h
    @@ -130,64 +130,32 @@ do { \
    : [val] __pcpu_reg_imm_##size(pto_val__)); \
    } while (0)

    +#define percpu_unary_op(size, qual, op, _var) \
    +({ \
    + asm qual (__pcpu_op1_##size(op, __percpu_arg([var])) \
    + : [var] "+m" (_var)); \
    +})
    +
    /*
    * Generate a percpu add to memory instruction and optimize code
    * if one is added or subtracted.
    */
    -#define percpu_add_op(qual, var, val) \
    +#define percpu_add_op(size, qual, var, val) \
    do { \
    - typedef typeof(var) pao_T__; \
    const int pao_ID__ = (__builtin_constant_p(val) && \
    ((val) == 1 || (val) == -1)) ? \
    (int)(val) : 0; \
    if (0) { \
    - pao_T__ pao_tmp__; \
    + typeof(var) pao_tmp__; \
    pao_tmp__ = (val); \
    (void)pao_tmp__; \
    } \
    - switch (sizeof(var)) { \
    - case 1: \
    - if (pao_ID__ == 1) \
    - asm qual ("incb "__percpu_arg(0) : "+m" (var)); \
    - else if (pao_ID__ == -1) \
    - asm qual ("decb "__percpu_arg(0) : "+m" (var)); \
    - else \
    - asm qual ("addb %1, "__percpu_arg(0) \
    - : "+m" (var) \
    - : "qi" ((pao_T__)(val))); \
    - break; \
    - case 2: \
    - if (pao_ID__ == 1) \
    - asm qual ("incw "__percpu_arg(0) : "+m" (var)); \
    - else if (pao_ID__ == -1) \
    - asm qual ("decw "__percpu_arg(0) : "+m" (var)); \
    - else \
    - asm qual ("addw %1, "__percpu_arg(0) \
    - : "+m" (var) \
    - : "ri" ((pao_T__)(val))); \
    - break; \
    - case 4: \
    - if (pao_ID__ == 1) \
    - asm qual ("incl "__percpu_arg(0) : "+m" (var)); \
    - else if (pao_ID__ == -1) \
    - asm qual ("decl "__percpu_arg(0) : "+m" (var)); \
    - else \
    - asm qual ("addl %1, "__percpu_arg(0) \
    - : "+m" (var) \
    - : "ri" ((pao_T__)(val))); \
    - break; \
    - case 8: \
    - if (pao_ID__ == 1) \
    - asm qual ("incq "__percpu_arg(0) : "+m" (var)); \
    - else if (pao_ID__ == -1) \
    - asm qual ("decq "__percpu_arg(0) : "+m" (var)); \
    - else \
    - asm qual ("addq %1, "__percpu_arg(0) \
    - : "+m" (var) \
    - : "re" ((pao_T__)(val))); \
    - break; \
    - default: __bad_percpu_size(); \
    - } \
    + if (pao_ID__ == 1) \
    + percpu_unary_op(size, qual, "inc", var); \
    + else if (pao_ID__ == -1) \
    + percpu_unary_op(size, qual, "dec", var); \
    + else \
    + percpu_to_op(size, qual, "add", var, val); \
    } while (0)

    #define percpu_from_op(size, qual, op, _var) \
    @@ -228,29 +196,6 @@ do { \
    pfo_ret__; \
    })

    -#define percpu_unary_op(qual, op, var) \
    -({ \
    - switch (sizeof(var)) { \
    - case 1: \
    - asm qual (op "b "__percpu_arg(0) \
    - : "+m" (var)); \
    - break; \
    - case 2: \
    - asm qual (op "w "__percpu_arg(0) \
    - : "+m" (var)); \
    - break; \
    - case 4: \
    - asm qual (op "l "__percpu_arg(0) \
    - : "+m" (var)); \
    - break; \
    - case 8: \
    - asm qual (op "q "__percpu_arg(0) \
    - : "+m" (var)); \
    - break; \
    - default: __bad_percpu_size(); \
    - } \
    -})
    -
    /*
    * Add return operation
    */
    @@ -388,9 +333,9 @@ do { \
    #define raw_cpu_write_1(pcp, val) percpu_to_op(1, , "mov", (pcp), val)
    #define raw_cpu_write_2(pcp, val) percpu_to_op(2, , "mov", (pcp), val)
    #define raw_cpu_write_4(pcp, val) percpu_to_op(4, , "mov", (pcp), val)
    -#define raw_cpu_add_1(pcp, val) percpu_add_op(, (pcp), val)
    -#define raw_cpu_add_2(pcp, val) percpu_add_op(, (pcp), val)
    -#define raw_cpu_add_4(pcp, val) percpu_add_op(, (pcp), val)
    +#define raw_cpu_add_1(pcp, val) percpu_add_op(1, , (pcp), val)
    +#define raw_cpu_add_2(pcp, val) percpu_add_op(2, , (pcp), val)
    +#define raw_cpu_add_4(pcp, val) percpu_add_op(4, , (pcp), val)
    #define raw_cpu_and_1(pcp, val) percpu_to_op(1, , "and", (pcp), val)
    #define raw_cpu_and_2(pcp, val) percpu_to_op(2, , "and", (pcp), val)
    #define raw_cpu_and_4(pcp, val) percpu_to_op(4, , "and", (pcp), val)
    @@ -419,9 +364,9 @@ do { \
    #define this_cpu_write_1(pcp, val) percpu_to_op(1, volatile, "mov", (pcp), val)
    #define this_cpu_write_2(pcp, val) percpu_to_op(2, volatile, "mov", (pcp), val)
    #define this_cpu_write_4(pcp, val) percpu_to_op(4, volatile, "mov", (pcp), val)
    -#define this_cpu_add_1(pcp, val) percpu_add_op(volatile, (pcp), val)
    -#define this_cpu_add_2(pcp, val) percpu_add_op(volatile, (pcp), val)
    -#define this_cpu_add_4(pcp, val) percpu_add_op(volatile, (pcp), val)
    +#define this_cpu_add_1(pcp, val) percpu_add_op(1, volatile, (pcp), val)
    +#define this_cpu_add_2(pcp, val) percpu_add_op(2, volatile, (pcp), val)
    +#define this_cpu_add_4(pcp, val) percpu_add_op(4, volatile, (pcp), val)
    #define this_cpu_and_1(pcp, val) percpu_to_op(1, volatile, "and", (pcp), val)
    #define this_cpu_and_2(pcp, val) percpu_to_op(2, volatile, "and", (pcp), val)
    #define this_cpu_and_4(pcp, val) percpu_to_op(4, volatile, "and", (pcp), val)
    @@ -470,7 +415,7 @@ do { \
    #ifdef CONFIG_X86_64
    #define raw_cpu_read_8(pcp) percpu_from_op(8, , "mov", pcp)
    #define raw_cpu_write_8(pcp, val) percpu_to_op(8, , "mov", (pcp), val)
    -#define raw_cpu_add_8(pcp, val) percpu_add_op(, (pcp), val)
    +#define raw_cpu_add_8(pcp, val) percpu_add_op(8, , (pcp), val)
    #define raw_cpu_and_8(pcp, val) percpu_to_op(8, , "and", (pcp), val)
    #define raw_cpu_or_8(pcp, val) percpu_to_op(8, , "or", (pcp), val)
    #define raw_cpu_add_return_8(pcp, val) percpu_add_return_op(, pcp, val)
    @@ -479,7 +424,7 @@ do { \

    #define this_cpu_read_8(pcp) percpu_from_op(8, volatile, "mov", pcp)
    #define this_cpu_write_8(pcp, val) percpu_to_op(8, volatile, "mov", (pcp), val)
    -#define this_cpu_add_8(pcp, val) percpu_add_op(volatile, (pcp), val)
    +#define this_cpu_add_8(pcp, val) percpu_add_op(8, volatile, (pcp), val)
    #define this_cpu_and_8(pcp, val) percpu_to_op(8, volatile, "and", (pcp), val)
    #define this_cpu_or_8(pcp, val) percpu_to_op(8, volatile, "or", (pcp), val)
    #define this_cpu_add_return_8(pcp, val) percpu_add_return_op(volatile, pcp, val)
    \
     
     \ /
      Last update: 2020-07-23 12:44    [W:4.177 / U:0.016 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site