s390/bpf: Wrap JIT macro parameter usages in parentheses

This change does not alter JIT behavior; it only makes it possible to
safely invoke JIT macros with complex arguments in the future.

Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20191107113211.90105-1-iii@linux.ibm.com

diff --git a/arch/s390/net/bpf_jit_comp.c b/arch/s390/net/bpf_jit_comp.c
index c8c16b5..35661c2 100644 (file)
--- a/arch/s390/net/bpf_jit_comp.c
+++ b/arch/s390/net/bpf_jit_comp.c
@@ -132,13 +132,13 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define _EMIT2(op)                                             \
 ({                                                             \
        if (jit->prg_buf)                                       \
-               *(u16 *) (jit->prg_buf + jit->prg) = op;        \
+               *(u16 *) (jit->prg_buf + jit->prg) = (op);      \
        jit->prg += 2;                                          \
 })
 
 #define EMIT2(op, b1, b2)                                      \
 ({                                                             \
-       _EMIT2(op | reg(b1, b2));                               \
+       _EMIT2((op) | reg(b1, b2));                             \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
 })
@@ -146,20 +146,20 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define _EMIT4(op)                                             \
 ({                                                             \
        if (jit->prg_buf)                                       \
-               *(u32 *) (jit->prg_buf + jit->prg) = op;        \
+               *(u32 *) (jit->prg_buf + jit->prg) = (op);      \
        jit->prg += 4;                                          \
 })
 
 #define EMIT4(op, b1, b2)                                      \
 ({                                                             \
-       _EMIT4(op | reg(b1, b2));                               \
+       _EMIT4((op) | reg(b1, b2));                             \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
 })
 
 #define EMIT4_RRF(op, b1, b2, b3)                              \
 ({                                                             \
-       _EMIT4(op | reg_high(b3) << 8 | reg(b1, b2));           \
+       _EMIT4((op) | reg_high(b3) << 8 | reg(b1, b2));         \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
        REG_SET_SEEN(b3);                                       \
@@ -168,13 +168,13 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define _EMIT4_DISP(op, disp)                                  \
 ({                                                             \
        unsigned int __disp = (disp) & 0xfff;                   \
-       _EMIT4(op | __disp);                                    \
+       _EMIT4((op) | __disp);                                  \
 })
 
 #define EMIT4_DISP(op, b1, b2, disp)                           \
 ({                                                             \
-       _EMIT4_DISP(op | reg_high(b1) << 16 |                   \
-                   reg_high(b2) << 8, disp);                   \
+       _EMIT4_DISP((op) | reg_high(b1) << 16 |                 \
+                   reg_high(b2) << 8, (disp));                 \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
 })
@@ -182,21 +182,21 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define EMIT4_IMM(op, b1, imm)                                 \
 ({                                                             \
        unsigned int __imm = (imm) & 0xffff;                    \
-       _EMIT4(op | reg_high(b1) << 16 | __imm);                \
+       _EMIT4((op) | reg_high(b1) << 16 | __imm);              \
        REG_SET_SEEN(b1);                                       \
 })
 
 #define EMIT4_PCREL(op, pcrel)                                 \
 ({                                                             \
        long __pcrel = ((pcrel) >> 1) & 0xffff;                 \
-       _EMIT4(op | __pcrel);                                   \
+       _EMIT4((op) | __pcrel);                                 \
 })
 
 #define _EMIT6(op1, op2)                                       \
 ({                                                             \
        if (jit->prg_buf) {                                     \
-               *(u32 *) (jit->prg_buf + jit->prg) = op1;       \
-               *(u16 *) (jit->prg_buf + jit->prg + 4) = op2;   \
+               *(u32 *) (jit->prg_buf + jit->prg) = (op1);     \
+               *(u16 *) (jit->prg_buf + jit->prg + 4) = (op2); \
        }                                                       \
        jit->prg += 6;                                          \
 })
@@ -204,20 +204,20 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define _EMIT6_DISP(op1, op2, disp)                            \
 ({                                                             \
        unsigned int __disp = (disp) & 0xfff;                   \
-       _EMIT6(op1 | __disp, op2);                              \
+       _EMIT6((op1) | __disp, op2);                            \
 })
 
 #define _EMIT6_DISP_LH(op1, op2, disp)                         \
 ({                                                             \
-       u32 _disp = (u32) disp;                                 \
+       u32 _disp = (u32) (disp);                               \
        unsigned int __disp_h = _disp & 0xff000;                \
        unsigned int __disp_l = _disp & 0x00fff;                \
-       _EMIT6(op1 | __disp_l, op2 | __disp_h >> 4);            \
+       _EMIT6((op1) | __disp_l, (op2) | __disp_h >> 4);        \
 })
 
 #define EMIT6_DISP_LH(op1, op2, b1, b2, b3, disp)              \
 ({                                                             \
-       _EMIT6_DISP_LH(op1 | reg(b1, b2) << 16 |                \
+       _EMIT6_DISP_LH((op1) | reg(b1, b2) << 16 |              \
                       reg_high(b3) << 8, op2, disp);           \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
@@ -227,8 +227,8 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define EMIT6_PCREL_LABEL(op1, op2, b1, b2, label, mask)       \
 ({                                                             \
        int rel = (jit->labels[label] - jit->prg) >> 1;         \
-       _EMIT6(op1 | reg(b1, b2) << 16 | (rel & 0xffff),        \
-              op2 | mask << 12);                               \
+       _EMIT6((op1) | reg(b1, b2) << 16 | (rel & 0xffff),      \
+              (op2) | (mask) << 12);                           \
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
 })
@@ -236,43 +236,43 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
 #define EMIT6_PCREL_IMM_LABEL(op1, op2, b1, imm, label, mask)  \
 ({                                                             \
        int rel = (jit->labels[label] - jit->prg) >> 1;         \
-       _EMIT6(op1 | (reg_high(b1) | mask) << 16 |              \
-               (rel & 0xffff), op2 | (imm & 0xff) << 8);       \
+       _EMIT6((op1) | (reg_high(b1) | (mask)) << 16 |          \
+               (rel & 0xffff), (op2) | ((imm) & 0xff) << 8);   \
        REG_SET_SEEN(b1);                                       \
-       BUILD_BUG_ON(((unsigned long) imm) > 0xff);             \
+       BUILD_BUG_ON(((unsigned long) (imm)) > 0xff);           \
 })
 
 #define EMIT6_PCREL(op1, op2, b1, b2, i, off, mask)            \
 ({                                                             \
        /* Branch instruction needs 6 bytes */                  \
-       int rel = (addrs[i + off + 1] - (addrs[i + 1] - 6)) / 2;\
-       _EMIT6(op1 | reg(b1, b2) << 16 | (rel & 0xffff), op2 | mask);   \
+       int rel = (addrs[(i) + (off) + 1] - (addrs[(i) + 1] - 6)) / 2;\
+       _EMIT6((op1) | reg(b1, b2) << 16 | (rel & 0xffff), (op2) | (mask));\
        REG_SET_SEEN(b1);                                       \
        REG_SET_SEEN(b2);                                       \
 })
 
 #define EMIT6_PCREL_RILB(op, b, target)                                \
 ({                                                             \
-       int rel = (target - jit->prg) / 2;                      \
-       _EMIT6(op | reg_high(b) << 16 | rel >> 16, rel & 0xffff);       \
+       int rel = ((target) - jit->prg) / 2;                    \
+       _EMIT6((op) | reg_high(b) << 16 | rel >> 16, rel & 0xffff);\
        REG_SET_SEEN(b);                                        \
 })
 
 #define EMIT6_PCREL_RIL(op, target)                            \
 ({                                                             \
-       int rel = (target - jit->prg) / 2;                      \
-       _EMIT6(op | rel >> 16, rel & 0xffff);                   \
+       int rel = ((target) - jit->prg) / 2;                    \
+       _EMIT6((op) | rel >> 16, rel & 0xffff);                 \
 })
 
 #define _EMIT6_IMM(op, imm)                                    \
 ({                                                             \
        unsigned int __imm = (imm);                             \
-       _EMIT6(op | (__imm >> 16), __imm & 0xffff);             \
+       _EMIT6((op) | (__imm >> 16), __imm & 0xffff);           \
 })
 
 #define EMIT6_IMM(op, b1, imm)                                 \
 ({                                                             \
-       _EMIT6_IMM(op | reg_high(b1) << 16, imm);               \
+       _EMIT6_IMM((op) | reg_high(b1) << 16, imm);             \
        REG_SET_SEEN(b1);                                       \
 })
 
@@ -282,7 +282,7 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
        ret = jit->lit - jit->base_ip;                          \
        jit->seen |= SEEN_LITERAL;                              \
        if (jit->prg_buf)                                       \
-               *(u32 *) (jit->prg_buf + jit->lit) = (u32) val; \
+               *(u32 *) (jit->prg_buf + jit->lit) = (u32) (val);\
        jit->lit += 4;                                          \
        ret;                                                    \
 })
@@ -293,7 +293,7 @@ static inline void reg_set_seen(struct bpf_jit *jit, u32 b1)
        ret = jit->lit - jit->base_ip;                          \
        jit->seen |= SEEN_LITERAL;                              \
        if (jit->prg_buf)                                       \
-               *(u64 *) (jit->prg_buf + jit->lit) = (u64) val; \
+               *(u64 *) (jit->prg_buf + jit->lit) = (u64) (val);\
        jit->lit += 8;                                          \
        ret;                                                    \
 })