arch/s390/include/asm/alternative.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ASM_S390_ALTERNATIVE_H
   3 #define _ASM_S390_ALTERNATIVE_H
   4
   5 #ifndef __ASSEMBLY__
   6
   7 #include <linux/types.h>
   8 #include <linux/stddef.h>
   9 #include <linux/stringify.h>
  10
  11 struct alt_instr {
  12         s32 instr_offset;       /* original instruction */
  13         s32 repl_offset;        /* offset to replacement instruction */
  14         u16 facility;           /* facility bit set for replacement */
  15         u8  instrlen;           /* length of original instruction */
  16         u8  replacementlen;     /* length of new instruction */
  17 } __packed;
  18
  19 void apply_alternative_instructions(void);
  20 void apply_alternatives(struct alt_instr *start, struct alt_instr *end);
  21
  22 /*
  23  * |661:       |662:      |6620      |663:
  24  * +-----------+---------------------+
  25  * | oldinstr  | oldinstr_padding    |
  26  * |           +----------+----------+
  27  * |           |          |          |
  28  * |           | >6 bytes |6/4/2 nops|
  29  * |           |6 bytes jg----------->
  30  * +-----------+---------------------+
  31  *               ^^ static padding ^^
  32  *
  33  * .altinstr_replacement section
  34  * +---------------------+-----------+
  35  * |6641:                            |6651:
  36  * | alternative instr 1             |
  37  * +-----------+---------+- - - - - -+
  38  * |6642:                |6652:      |
  39  * | alternative instr 2 | padding
  40  * +---------------------+- - - - - -+
  41  *                        ^ runtime ^
  42  *
  43  * .altinstructions section
  44  * +---------------------------------+
  45  * | alt_instr entries for each      |
  46  * | alternative instr               |
  47  * +---------------------------------+
  48  */
  49
  50 #define b_altinstr(num) "664"#num
  51 #define e_altinstr(num) "665"#num
  52
  53 #define e_oldinstr_pad_end      "663"
  54 #define oldinstr_len            "662b-661b"
  55 #define oldinstr_total_len      e_oldinstr_pad_end"b-661b"
  56 #define altinstr_len(num)       e_altinstr(num)"b-"b_altinstr(num)"b"
  57 #define oldinstr_pad_len(num) \
  58         "-(((" altinstr_len(num) ")-(" oldinstr_len ")) > 0) * " \
  59         "((" altinstr_len(num) ")-(" oldinstr_len "))"
  60
  61 #define INSTR_LEN_SANITY_CHECK(len)                                     \
  62         ".if " len " > 254\n"                                           \
  63         "\t.error \"cpu alternatives does not support instructions "    \
  64                 "blocks > 254 bytes\"\n"                                \
  65         ".endif\n"                                                      \
  66         ".if (" len ") %% 2\n"                                          \
  67         "\t.error \"cpu alternatives instructions length is odd\"\n"    \
  68         ".endif\n"
  69
  70 #define OLDINSTR_PADDING(oldinstr, num)                                 \
  71         ".if " oldinstr_pad_len(num) " > 6\n"                           \
  72         "\tjg " e_oldinstr_pad_end "f\n"                                \
  73         "6620:\n"                                                       \
  74         "\t.rept (" oldinstr_pad_len(num) " - (6620b-662b)) / 2\n"      \
  75         "\tnopr\n"                                                      \
  76         ".else\n"                                                       \
  77         "\t.rept " oldinstr_pad_len(num) " / 6\n"                       \
  78         "\t.brcl 0,0\n"                                                 \
  79         "\t.endr\n"                                                     \
  80         "\t.rept " oldinstr_pad_len(num) " %% 6 / 4\n"                  \
  81         "\tnop\n"                                                       \
  82         "\t.endr\n"                                                     \
  83         "\t.rept " oldinstr_pad_len(num) " %% 6 %% 4 / 2\n"             \
  84         "\tnopr\n"                                                      \
  85         ".endr\n"                                                       \
  86         ".endif\n"
  87
  88 #define OLDINSTR(oldinstr, num)                                         \
  89         "661:\n\t" oldinstr "\n662:\n"                                  \
  90         OLDINSTR_PADDING(oldinstr, num)                                 \
  91         e_oldinstr_pad_end ":\n"                                        \
  92         INSTR_LEN_SANITY_CHECK(oldinstr_len)
  93
  94 #define OLDINSTR_2(oldinstr, num1, num2)                                \
  95         "661:\n\t" oldinstr "\n662:\n"                                  \
  96         ".if " altinstr_len(num1) " < " altinstr_len(num2) "\n"         \
  97         OLDINSTR_PADDING(oldinstr, num2)                                \
  98         ".else\n"                                                       \
  99         OLDINSTR_PADDING(oldinstr, num1)                                \
 100         ".endif\n"                                                      \
 101         e_oldinstr_pad_end ":\n"                                        \
 102         INSTR_LEN_SANITY_CHECK(oldinstr_len)
 103
 104 #define ALTINSTR_ENTRY(facility, num)                                   \
 105         "\t.long 661b - .\n"                    /* old instruction */   \
 106         "\t.long " b_altinstr(num)"b - .\n"     /* alt instruction */   \
 107         "\t.word " __stringify(facility) "\n"   /* facility bit    */   \
 108         "\t.byte " oldinstr_total_len "\n"      /* source len      */   \
 109         "\t.byte " altinstr_len(num) "\n"       /* alt instruction len */
 110
 111 #define ALTINSTR_REPLACEMENT(altinstr, num)     /* replacement */       \
 112         b_altinstr(num)":\n\t" altinstr "\n" e_altinstr(num) ":\n"      \
 113         INSTR_LEN_SANITY_CHECK(altinstr_len(num))
 114
 115 /* alternative assembly primitive: */
 116 #define ALTERNATIVE(oldinstr, altinstr, facility) \
 117         ".pushsection .altinstr_replacement, \"ax\"\n"                  \
 118         ALTINSTR_REPLACEMENT(altinstr, 1)                               \
 119         ".popsection\n"                                                 \
 120         OLDINSTR(oldinstr, 1)                                           \
 121         ".pushsection .altinstructions,\"a\"\n"                         \
 122         ALTINSTR_ENTRY(facility, 1)                                     \
 123         ".popsection\n"
 124
 125 #define ALTERNATIVE_2(oldinstr, altinstr1, facility1, altinstr2, facility2)\
 126         ".pushsection .altinstr_replacement, \"ax\"\n"                  \
 127         ALTINSTR_REPLACEMENT(altinstr1, 1)                              \
 128         ALTINSTR_REPLACEMENT(altinstr2, 2)                              \
 129         ".popsection\n"                                                 \
 130         OLDINSTR_2(oldinstr, 1, 2)                                      \
 131         ".pushsection .altinstructions,\"a\"\n"                         \
 132         ALTINSTR_ENTRY(facility1, 1)                                    \
 133         ALTINSTR_ENTRY(facility2, 2)                                    \
 134         ".popsection\n"
 135
 136 /*
 137  * Alternative instructions for different CPU types or capabilities.
 138  *
 139  * This allows to use optimized instructions even on generic binary
 140  * kernels.
 141  *
 142  * oldinstr is padded with jump and nops at compile time if altinstr is
 143  * longer. altinstr is padded with jump and nops at run-time during patching.
 144  *
 145  * For non barrier like inlines please define new variants
 146  * without volatile and memory clobber.
 147  */
 148 #define alternative(oldinstr, altinstr, facility)                       \
 149         asm_inline volatile(ALTERNATIVE(oldinstr, altinstr, facility) : : : "memory")
 150
 151 #define alternative_2(oldinstr, altinstr1, facility1, altinstr2, facility2) \
 152         asm_inline volatile(ALTERNATIVE_2(oldinstr, altinstr1, facility1,   \
 153                                    altinstr2, facility2) ::: "memory")
 154
 155 /* Alternative inline assembly with input. */
 156 #define alternative_input(oldinstr, newinstr, feature, input...)        \
 157         asm_inline volatile (ALTERNATIVE(oldinstr, newinstr, feature)   \
 158                 : : input)
 159
 160 /* Like alternative_input, but with a single output argument */
 161 #define alternative_io(oldinstr, altinstr, facility, output, input...)  \
 162         asm_inline volatile(ALTERNATIVE(oldinstr, altinstr, facility)   \
 163                 : output : input)
 164
 165 /* Use this macro if more than one output parameter is needed. */
 166 #define ASM_OUTPUT2(a...) a
 167
 168 /* Use this macro if clobbers are needed without inputs. */
 169 #define ASM_NO_INPUT_CLOBBER(clobber...) : clobber
 170
 171 #endif /* __ASSEMBLY__ */
 172
 173 #endif /* _ASM_S390_ALTERNATIVE_H */