lkml.org 
[lkml]   [2018]   [Feb]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 4.4 054/108] mtd: cfi: convert inline functions to macros
    Date
    4.4-stable review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Arnd Bergmann <arnd@arndb.de>

    commit 9e343e87d2c4c707ef8fae2844864d4dde3a2d13 upstream.

    The map_word_() functions, dating back to linux-2.6.8, try to perform
    bitwise operations on a 'map_word' structure. This may have worked
    with compilers that were current then (gcc-3.4 or earlier), but end
    up being rather inefficient on any version I could try now (gcc-4.4 or
    higher). Specifically we hit a problem analyzed in gcc PR81715 where we
    fail to reuse the stack space for local variables.

    This can be seen immediately in the stack consumption for
    cfi_staa_erase_varsize() and other functions that (with CONFIG_KASAN)
    can be up to 2200 bytes. Changing the inline functions into macros brings
    this down to 1280 bytes. Without KASAN, the same problem exists, but
    the stack consumption is lower to start with, my patch shrinks it from
    920 to 496 bytes on with arm-linux-gnueabi-gcc-5.4, and saves around
    1KB in .text size for cfi_cmdset_0020.c, as it avoids copying map_word
    structures for each call to one of these helpers.

    With the latest gcc-8 snapshot, the problem is fixed in upstream gcc,
    but nobody uses that yet, so we should still work around it in mainline
    kernels and probably backport the workaround to stable kernels as well.
    We had a couple of other functions that suffered from the same gcc bug,
    and all of those had a simpler workaround involving dummy variables
    in the inline function. Unfortunately that did not work here, the
    macro hack was the best I could come up with.

    It would also be helpful to have someone to a little performance testing
    on the patch, to see how much it helps in terms of CPU utilitzation.

    Link: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81715
    Signed-off-by: Arnd Bergmann <arnd@arndb.de>
    Acked-by: Richard Weinberger <richard@nod.at>
    Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

    ---
    include/linux/mtd/map.h | 130 ++++++++++++++++++++++--------------------------
    1 file changed, 61 insertions(+), 69 deletions(-)

    --- a/include/linux/mtd/map.h
    +++ b/include/linux/mtd/map.h
    @@ -265,75 +265,67 @@ void map_destroy(struct mtd_info *mtd);
    #define INVALIDATE_CACHED_RANGE(map, from, size) \
    do { if (map->inval_cache) map->inval_cache(map, from, size); } while (0)

    -
    -static inline int map_word_equal(struct map_info *map, map_word val1, map_word val2)
    -{
    - int i;
    -
    - for (i = 0; i < map_words(map); i++) {
    - if (val1.x[i] != val2.x[i])
    - return 0;
    - }
    -
    - return 1;
    -}
    -
    -static inline map_word map_word_and(struct map_info *map, map_word val1, map_word val2)
    -{
    - map_word r;
    - int i;
    -
    - for (i = 0; i < map_words(map); i++)
    - r.x[i] = val1.x[i] & val2.x[i];
    -
    - return r;
    -}
    -
    -static inline map_word map_word_clr(struct map_info *map, map_word val1, map_word val2)
    -{
    - map_word r;
    - int i;
    -
    - for (i = 0; i < map_words(map); i++)
    - r.x[i] = val1.x[i] & ~val2.x[i];
    -
    - return r;
    -}
    -
    -static inline map_word map_word_or(struct map_info *map, map_word val1, map_word val2)
    -{
    - map_word r;
    - int i;
    -
    - for (i = 0; i < map_words(map); i++)
    - r.x[i] = val1.x[i] | val2.x[i];
    -
    - return r;
    -}
    -
    -static inline int map_word_andequal(struct map_info *map, map_word val1, map_word val2, map_word val3)
    -{
    - int i;
    -
    - for (i = 0; i < map_words(map); i++) {
    - if ((val1.x[i] & val2.x[i]) != val3.x[i])
    - return 0;
    - }
    -
    - return 1;
    -}
    -
    -static inline int map_word_bitsset(struct map_info *map, map_word val1, map_word val2)
    -{
    - int i;
    -
    - for (i = 0; i < map_words(map); i++) {
    - if (val1.x[i] & val2.x[i])
    - return 1;
    - }
    -
    - return 0;
    -}
    +#define map_word_equal(map, val1, val2) \
    +({ \
    + int i, ret = 1; \
    + for (i = 0; i < map_words(map); i++) \
    + if ((val1).x[i] != (val2).x[i]) { \
    + ret = 0; \
    + break; \
    + } \
    + ret; \
    +})
    +
    +#define map_word_and(map, val1, val2) \
    +({ \
    + map_word r; \
    + int i; \
    + for (i = 0; i < map_words(map); i++) \
    + r.x[i] = (val1).x[i] & (val2).x[i]; \
    + r; \
    +})
    +
    +#define map_word_clr(map, val1, val2) \
    +({ \
    + map_word r; \
    + int i; \
    + for (i = 0; i < map_words(map); i++) \
    + r.x[i] = (val1).x[i] & ~(val2).x[i]; \
    + r; \
    +})
    +
    +#define map_word_or(map, val1, val2) \
    +({ \
    + map_word r; \
    + int i; \
    + for (i = 0; i < map_words(map); i++) \
    + r.x[i] = (val1).x[i] | (val2).x[i]; \
    + r; \
    +})
    +
    +#define map_word_andequal(map, val1, val2, val3) \
    +({ \
    + int i, ret = 1; \
    + for (i = 0; i < map_words(map); i++) { \
    + if (((val1).x[i] & (val2).x[i]) != (val2).x[i]) { \
    + ret = 0; \
    + break; \
    + } \
    + } \
    + ret; \
    +})
    +
    +#define map_word_bitsset(map, val1, val2) \
    +({ \
    + int i, ret = 0; \
    + for (i = 0; i < map_words(map); i++) { \
    + if ((val1).x[i] & (val2).x[i]) { \
    + ret = 1; \
    + break; \
    + } \
    + } \
    + ret; \
    +})

    static inline map_word map_word_load(struct map_info *map, const void *ptr)
    {

    \
     
     \ /
      Last update: 2018-02-15 19:35    [W:2.355 / U:0.256 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site