llvm/lib/Target/X86/X86InstrSystem.td

   1 //===-- X86InstrSystem.td - System Instructions ------------*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file describes the X86 instructions that are generally used in
  10 // privileged modes.  These are not typically used by the compiler, but are
  11 // supported for the assembler and disassembler.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 let SchedRW = [WriteSystem] in {
  16 let Defs = [RAX, RDX] in
  17 def RDTSC : I<0x31, RawFrm, (outs), (ins), "rdtsc", []>, TB;
  18
  19 let Defs = [RAX, RCX, RDX] in
  20 def RDTSCP : I<0x01, MRM_F9, (outs), (ins), "rdtscp", []>, TB;
  21
  22 // CPU flow control instructions
  23
  24 let mayLoad = 1, mayStore = 0, hasSideEffects = 1, isTrap = 1 in {
  25   def TRAP    : I<0x0B, RawFrm, (outs), (ins), "ud2", [(trap)]>, TB;
  26
  27   def UD1Wm   : I<0xB9, MRMSrcMem, (outs), (ins GR16:$src1, i16mem:$src2),
  28                   "ud1{w}\t{$src2, $src1|$src1, $src2}", []>, TB, OpSize16;
  29   def UD1Lm   : I<0xB9, MRMSrcMem, (outs), (ins GR32:$src1, i32mem:$src2),
  30                   "ud1{l}\t{$src2, $src1|$src1, $src2}", []>, TB, OpSize32;
  31   def UD1Qm   : RI<0xB9, MRMSrcMem, (outs), (ins GR64:$src1, i64mem:$src2),
  32                    "ud1{q}\t{$src2, $src1|$src1, $src2}", []>, TB;
  33
  34   def UD1Wr   : I<0xB9, MRMSrcReg, (outs), (ins GR16:$src1, GR16:$src2),
  35                   "ud1{w}\t{$src2, $src1|$src1, $src2}", []>, TB, OpSize16;
  36   def UD1Lr   : I<0xB9, MRMSrcReg, (outs), (ins GR32:$src1, GR32:$src2),
  37                   "ud1{l}\t{$src2, $src1|$src1, $src2}", []>, TB, OpSize32;
  38   def UD1Qr   : RI<0xB9, MRMSrcReg, (outs), (ins GR64:$src1, GR64:$src2),
  39                    "ud1{q}\t{$src2, $src1|$src1, $src2}", []>, TB;
  40 }
  41
  42 let isTerminator = 1 in
  43   def HLT : I<0xF4, RawFrm, (outs), (ins), "hlt", []>;
  44 def RSM : I<0xAA, RawFrm, (outs), (ins), "rsm", []>, TB;
  45
  46 // Interrupt and SysCall Instructions.
  47 let Uses = [EFLAGS] in
  48   def INTO : I<0xce, RawFrm, (outs), (ins), "into", []>, Requires<[Not64BitMode]>;
  49
  50 def INT3 : I<0xcc, RawFrm, (outs), (ins), "int3", [(int_x86_int (i8 3))]>;
  51
  52 def UBSAN_UD1 : PseudoI<(outs), (ins i32imm:$kind), [(ubsantrap (i32 timm:$kind))]>;
  53 // The long form of "int $3" turns into int3 as a size optimization.
  54 // FIXME: This doesn't work because InstAlias can't match immediate constants.
  55 //def : InstAlias<"int\t$3", (INT3)>;
  56
  57 def INT : Ii8<0xcd, RawFrm, (outs), (ins u8imm:$trap), "int\t$trap",
  58               [(int_x86_int timm:$trap)]>;
  59
  60
  61 def SYSCALL  : I<0x05, RawFrm, (outs), (ins), "syscall", []>, TB;
  62 def SYSRET   : I<0x07, RawFrm, (outs), (ins), "sysret{l}", []>, TB;
  63 def SYSRET64 :RI<0x07, RawFrm, (outs), (ins), "sysretq", []>, TB,
  64                Requires<[In64BitMode]>;
  65
  66 def SYSENTER : I<0x34, RawFrm, (outs), (ins), "sysenter", []>, TB;
  67
  68 def SYSEXIT   : I<0x35, RawFrm, (outs), (ins), "sysexit{l}", []>, TB;
  69 def SYSEXIT64 :RI<0x35, RawFrm, (outs), (ins), "sysexitq", []>, TB,
  70                   Requires<[In64BitMode]>;
  71 } // SchedRW
  72
  73 def : Pat<(debugtrap),
  74           (INT3)>, Requires<[NotPS]>;
  75 def : Pat<(debugtrap),
  76           (INT (i8 0x41))>, Requires<[IsPS]>;
  77
  78 //===----------------------------------------------------------------------===//
  79 //  Input/Output Instructions.
  80 //
  81 let SchedRW = [WriteSystem] in {
  82 let Defs = [AL], Uses = [DX] in
  83 def IN8rr  : I<0xEC, RawFrm, (outs), (ins), "in{b}\t{%dx, %al|al, dx}", []>;
  84 let Defs = [AX], Uses = [DX] in
  85 def IN16rr : I<0xED, RawFrm, (outs), (ins), "in{w}\t{%dx, %ax|ax, dx}", []>,
  86                OpSize16;
  87 let Defs = [EAX], Uses = [DX] in
  88 def IN32rr : I<0xED, RawFrm, (outs), (ins), "in{l}\t{%dx, %eax|eax, dx}", []>,
  89                OpSize32;
  90
  91 let Defs = [AL] in
  92 def IN8ri  : Ii8<0xE4, RawFrm, (outs), (ins u8imm:$port),
  93                  "in{b}\t{$port, %al|al, $port}", []>;
  94 let Defs = [AX] in
  95 def IN16ri : Ii8<0xE5, RawFrm, (outs), (ins u8imm:$port),
  96                  "in{w}\t{$port, %ax|ax, $port}", []>, OpSize16;
  97 let Defs = [EAX] in
  98 def IN32ri : Ii8<0xE5, RawFrm, (outs), (ins u8imm:$port),
  99                  "in{l}\t{$port, %eax|eax, $port}", []>, OpSize32;
 100
 101 let Uses = [DX, AL] in
 102 def OUT8rr  : I<0xEE, RawFrm, (outs), (ins), "out{b}\t{%al, %dx|dx, al}", []>;
 103 let Uses = [DX, AX] in
 104 def OUT16rr : I<0xEF, RawFrm, (outs), (ins), "out{w}\t{%ax, %dx|dx, ax}", []>,
 105                 OpSize16;
 106 let Uses = [DX, EAX] in
 107 def OUT32rr : I<0xEF, RawFrm, (outs), (ins), "out{l}\t{%eax, %dx|dx, eax}", []>,
 108                 OpSize32;
 109
 110 let Uses = [AL] in
 111 def OUT8ir  : Ii8<0xE6, RawFrm, (outs), (ins u8imm:$port),
 112                    "out{b}\t{%al, $port|$port, al}", []>;
 113 let Uses = [AX] in
 114 def OUT16ir : Ii8<0xE7, RawFrm, (outs), (ins u8imm:$port),
 115                    "out{w}\t{%ax, $port|$port, ax}", []>, OpSize16;
 116 let Uses = [EAX] in
 117 def OUT32ir : Ii8<0xE7, RawFrm, (outs), (ins u8imm:$port),
 118                   "out{l}\t{%eax, $port|$port, eax}", []>, OpSize32;
 119
 120 } // SchedRW
 121
 122 //===----------------------------------------------------------------------===//
 123 // Moves to and from debug registers
 124
 125 let SchedRW = [WriteSystem] in {
 126 def MOV32rd : I<0x21, MRMDestReg, (outs GR32:$dst), (ins DEBUG_REG:$src),
 127                 "mov{l}\t{$src, $dst|$dst, $src}", []>, TB,
 128                 Requires<[Not64BitMode]>;
 129 def MOV64rd : I<0x21, MRMDestReg, (outs GR64:$dst), (ins DEBUG_REG:$src),
 130                 "mov{q}\t{$src, $dst|$dst, $src}", []>, TB,
 131                 Requires<[In64BitMode]>;
 132
 133 def MOV32dr : I<0x23, MRMSrcReg, (outs DEBUG_REG:$dst), (ins GR32:$src),
 134                 "mov{l}\t{$src, $dst|$dst, $src}", []>, TB,
 135                 Requires<[Not64BitMode]>;
 136 def MOV64dr : I<0x23, MRMSrcReg, (outs DEBUG_REG:$dst), (ins GR64:$src),
 137                 "mov{q}\t{$src, $dst|$dst, $src}", []>, TB,
 138                 Requires<[In64BitMode]>;
 139 } // SchedRW
 140
 141 //===----------------------------------------------------------------------===//
 142 // Moves to and from control registers
 143
 144 let SchedRW = [WriteSystem] in {
 145 def MOV32rc : I<0x20, MRMDestReg, (outs GR32:$dst), (ins CONTROL_REG:$src),
 146                 "mov{l}\t{$src, $dst|$dst, $src}", []>, TB,
 147                 Requires<[Not64BitMode]>;
 148 def MOV64rc : I<0x20, MRMDestReg, (outs GR64:$dst), (ins CONTROL_REG:$src),
 149                 "mov{q}\t{$src, $dst|$dst, $src}", []>, TB,
 150                 Requires<[In64BitMode]>;
 151
 152 def MOV32cr : I<0x22, MRMSrcReg, (outs CONTROL_REG:$dst), (ins GR32:$src),
 153                 "mov{l}\t{$src, $dst|$dst, $src}", []>, TB,
 154                 Requires<[Not64BitMode]>;
 155 def MOV64cr : I<0x22, MRMSrcReg, (outs CONTROL_REG:$dst), (ins GR64:$src),
 156                 "mov{q}\t{$src, $dst|$dst, $src}", []>, TB,
 157                 Requires<[In64BitMode]>;
 158 } // SchedRW
 159
 160 //===----------------------------------------------------------------------===//
 161 // Segment override instruction prefixes
 162
 163 let SchedRW = [WriteNop] in {
 164 def CS_PREFIX : I<0x2E, PrefixByte, (outs), (ins), "cs", []>;
 165 def SS_PREFIX : I<0x36, PrefixByte, (outs), (ins), "ss", []>;
 166 def DS_PREFIX : I<0x3E, PrefixByte, (outs), (ins), "ds", []>;
 167 def ES_PREFIX : I<0x26, PrefixByte, (outs), (ins), "es", []>;
 168 def FS_PREFIX : I<0x64, PrefixByte, (outs), (ins), "fs", []>;
 169 def GS_PREFIX : I<0x65, PrefixByte, (outs), (ins), "gs", []>;
 170 } // SchedRW
 171
 172 //===----------------------------------------------------------------------===//
 173 // Address-size override prefixes.
 174 //
 175
 176 let SchedRW = [WriteNop] in {
 177 def ADDR16_PREFIX : I<0x67, PrefixByte, (outs), (ins), "addr16", []>,
 178                       Requires<[In32BitMode]>;
 179 def ADDR32_PREFIX : I<0x67, PrefixByte, (outs), (ins), "addr32", []>,
 180                       Requires<[In64BitMode]>;
 181 } // SchedRW
 182
 183 //===----------------------------------------------------------------------===//
 184 // Moves to and from segment registers.
 185 //
 186
 187 let SchedRW = [WriteMove] in {
 188 def MOV16rs : I<0x8C, MRMDestReg, (outs GR16:$dst), (ins SEGMENT_REG:$src),
 189                 "mov{w}\t{$src, $dst|$dst, $src}", []>, OpSize16;
 190 def MOV32rs : I<0x8C, MRMDestReg, (outs GR32:$dst), (ins SEGMENT_REG:$src),
 191                 "mov{l}\t{$src, $dst|$dst, $src}", []>, OpSize32;
 192 def MOV64rs : RI<0x8C, MRMDestReg, (outs GR64:$dst), (ins SEGMENT_REG:$src),
 193                  "mov{q}\t{$src, $dst|$dst, $src}", []>;
 194 let mayStore = 1 in {
 195 def MOV16ms : I<0x8C, MRMDestMem, (outs), (ins i16mem:$dst, SEGMENT_REG:$src),
 196                 "mov{w}\t{$src, $dst|$dst, $src}", []>;
 197 }
 198 def MOV16sr : I<0x8E, MRMSrcReg, (outs SEGMENT_REG:$dst), (ins GR16:$src),
 199                 "mov{w}\t{$src, $dst|$dst, $src}", []>, OpSize16;
 200 def MOV32sr : I<0x8E, MRMSrcReg, (outs SEGMENT_REG:$dst), (ins GR32:$src),
 201                 "mov{l}\t{$src, $dst|$dst, $src}", []>, OpSize32;
 202 def MOV64sr : RI<0x8E, MRMSrcReg, (outs SEGMENT_REG:$dst), (ins GR64:$src),
 203                  "mov{q}\t{$src, $dst|$dst, $src}", []>;
 204 let mayLoad = 1 in {
 205 def MOV16sm : I<0x8E, MRMSrcMem, (outs SEGMENT_REG:$dst), (ins i16mem:$src),
 206                 "mov{w}\t{$src, $dst|$dst, $src}", []>;
 207 }
 208 } // SchedRW
 209
 210 //===----------------------------------------------------------------------===//
 211 // Segmentation support instructions.
 212
 213 let SchedRW = [WriteSystem] in {
 214 def SWAPGS : I<0x01, MRM_F8, (outs), (ins), "swapgs", []>, TB;
 215
 216 let mayLoad = 1 in
 217 def LAR16rm : I<0x02, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
 218                 "lar{w}\t{$src, $dst|$dst, $src}", []>, TB,
 219                 OpSize16;
 220 def LAR16rr : I<0x02, MRMSrcReg, (outs GR16:$dst), (ins GR16orGR32orGR64:$src),
 221                 "lar{w}\t{$src, $dst|$dst, $src}", []>, TB,
 222                 OpSize16;
 223
 224 let mayLoad = 1 in
 225 def LAR32rm : I<0x02, MRMSrcMem, (outs GR32:$dst), (ins i16mem:$src),
 226                 "lar{l}\t{$src, $dst|$dst, $src}", []>, TB,
 227                 OpSize32;
 228 def LAR32rr : I<0x02, MRMSrcReg, (outs GR32:$dst), (ins GR16orGR32orGR64:$src),
 229                 "lar{l}\t{$src, $dst|$dst, $src}", []>, TB,
 230                 OpSize32;
 231 let mayLoad = 1 in
 232 def LAR64rm : RI<0x02, MRMSrcMem, (outs GR64:$dst), (ins i16mem:$src),
 233                  "lar{q}\t{$src, $dst|$dst, $src}", []>, TB;
 234 def LAR64rr : RI<0x02, MRMSrcReg, (outs GR64:$dst), (ins GR16orGR32orGR64:$src),
 235                  "lar{q}\t{$src, $dst|$dst, $src}", []>, TB;
 236
 237 let mayLoad = 1 in
 238 def LSL16rm : I<0x03, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
 239                 "lsl{w}\t{$src, $dst|$dst, $src}", []>, TB,
 240                 OpSize16;
 241 def LSL16rr : I<0x03, MRMSrcReg, (outs GR16:$dst), (ins GR16orGR32orGR64:$src),
 242                 "lsl{w}\t{$src, $dst|$dst, $src}", []>, TB,
 243                 OpSize16;
 244 let mayLoad = 1 in
 245 def LSL32rm : I<0x03, MRMSrcMem, (outs GR32:$dst), (ins i16mem:$src),
 246                 "lsl{l}\t{$src, $dst|$dst, $src}", []>, TB,
 247                 OpSize32;
 248 def LSL32rr : I<0x03, MRMSrcReg, (outs GR32:$dst), (ins GR16orGR32orGR64:$src),
 249                 "lsl{l}\t{$src, $dst|$dst, $src}", []>, TB,
 250                 OpSize32;
 251 let mayLoad = 1 in
 252 def LSL64rm : RI<0x03, MRMSrcMem, (outs GR64:$dst), (ins i16mem:$src),
 253                  "lsl{q}\t{$src, $dst|$dst, $src}", []>, TB;
 254 def LSL64rr : RI<0x03, MRMSrcReg, (outs GR64:$dst), (ins GR16orGR32orGR64:$src),
 255                  "lsl{q}\t{$src, $dst|$dst, $src}", []>, TB;
 256
 257 def INVLPG : I<0x01, MRM7m, (outs), (ins i8mem:$addr), "invlpg\t$addr", []>, TB;
 258
 259 def STR16r : I<0x00, MRM1r, (outs GR16:$dst), (ins),
 260                "str{w}\t$dst", []>, TB, OpSize16;
 261 def STR32r : I<0x00, MRM1r, (outs GR32:$dst), (ins),
 262                "str{l}\t$dst", []>, TB, OpSize32;
 263 def STR64r : RI<0x00, MRM1r, (outs GR64:$dst), (ins),
 264                 "str{q}\t$dst", []>, TB;
 265 let mayStore = 1 in
 266 def STRm   : I<0x00, MRM1m, (outs), (ins i16mem:$dst), "str{w}\t$dst", []>, TB;
 267
 268 def LTRr : I<0x00, MRM3r, (outs), (ins GR16:$src), "ltr{w}\t$src", []>, TB;
 269 let mayLoad = 1 in
 270 def LTRm : I<0x00, MRM3m, (outs), (ins i16mem:$src), "ltr{w}\t$src", []>, TB;
 271
 272 def PUSHCS16 : I<0x0E, RawFrm, (outs), (ins), "push{w}\t{%cs|cs}", []>,
 273                  OpSize16, Requires<[Not64BitMode]>;
 274 def PUSHCS32 : I<0x0E, RawFrm, (outs), (ins), "push{l}\t{%cs|cs}", []>,
 275                  OpSize32, Requires<[Not64BitMode]>;
 276 def PUSHSS16 : I<0x16, RawFrm, (outs), (ins), "push{w}\t{%ss|ss}", []>,
 277                  OpSize16, Requires<[Not64BitMode]>;
 278 def PUSHSS32 : I<0x16, RawFrm, (outs), (ins), "push{l}\t{%ss|ss}", []>,
 279                  OpSize32, Requires<[Not64BitMode]>;
 280 def PUSHDS16 : I<0x1E, RawFrm, (outs), (ins), "push{w}\t{%ds|ds}", []>,
 281                  OpSize16, Requires<[Not64BitMode]>;
 282 def PUSHDS32 : I<0x1E, RawFrm, (outs), (ins), "push{l}\t{%ds|ds}", []>,
 283                  OpSize32, Requires<[Not64BitMode]>;
 284 def PUSHES16 : I<0x06, RawFrm, (outs), (ins), "push{w}\t{%es|es}", []>,
 285                  OpSize16, Requires<[Not64BitMode]>;
 286 def PUSHES32 : I<0x06, RawFrm, (outs), (ins), "push{l}\t{%es|es}", []>,
 287                  OpSize32, Requires<[Not64BitMode]>;
 288 def PUSHFS16 : I<0xa0, RawFrm, (outs), (ins), "push{w}\t{%fs|fs}", []>,
 289                  OpSize16, TB;
 290 def PUSHFS32 : I<0xa0, RawFrm, (outs), (ins), "push{l}\t{%fs|fs}", []>, TB,
 291                  OpSize32, Requires<[Not64BitMode]>;
 292 def PUSHGS16 : I<0xa8, RawFrm, (outs), (ins), "push{w}\t{%gs|gs}", []>,
 293                  OpSize16, TB;
 294 def PUSHGS32 : I<0xa8, RawFrm, (outs), (ins), "push{l}\t{%gs|gs}", []>, TB,
 295                  OpSize32, Requires<[Not64BitMode]>;
 296 def PUSHFS64 : I<0xa0, RawFrm, (outs), (ins), "push{q}\t{%fs|fs}", []>, TB,
 297                  OpSize32, Requires<[In64BitMode]>;
 298 def PUSHGS64 : I<0xa8, RawFrm, (outs), (ins), "push{q}\t{%gs|gs}", []>, TB,
 299                  OpSize32, Requires<[In64BitMode]>;
 300
 301 // No "pop cs" instruction.
 302 def POPSS16 : I<0x17, RawFrm, (outs), (ins), "pop{w}\t{%ss|ss}", []>,
 303               OpSize16, Requires<[Not64BitMode]>;
 304 def POPSS32 : I<0x17, RawFrm, (outs), (ins), "pop{l}\t{%ss|ss}", []>,
 305               OpSize32, Requires<[Not64BitMode]>;
 306
 307 def POPDS16 : I<0x1F, RawFrm, (outs), (ins), "pop{w}\t{%ds|ds}", []>,
 308               OpSize16, Requires<[Not64BitMode]>;
 309 def POPDS32 : I<0x1F, RawFrm, (outs), (ins), "pop{l}\t{%ds|ds}", []>,
 310               OpSize32, Requires<[Not64BitMode]>;
 311
 312 def POPES16 : I<0x07, RawFrm, (outs), (ins), "pop{w}\t{%es|es}", []>,
 313               OpSize16, Requires<[Not64BitMode]>;
 314 def POPES32 : I<0x07, RawFrm, (outs), (ins), "pop{l}\t{%es|es}", []>,
 315               OpSize32, Requires<[Not64BitMode]>;
 316
 317 def POPFS16 : I<0xa1, RawFrm, (outs), (ins), "pop{w}\t{%fs|fs}", []>,
 318                 OpSize16, TB;
 319 def POPFS32 : I<0xa1, RawFrm, (outs), (ins), "pop{l}\t{%fs|fs}", []>, TB,
 320                 OpSize32, Requires<[Not64BitMode]>;
 321 def POPFS64 : I<0xa1, RawFrm, (outs), (ins), "pop{q}\t{%fs|fs}", []>, TB,
 322                 OpSize32, Requires<[In64BitMode]>;
 323
 324 def POPGS16 : I<0xa9, RawFrm, (outs), (ins), "pop{w}\t{%gs|gs}", []>,
 325                 OpSize16, TB;
 326 def POPGS32 : I<0xa9, RawFrm, (outs), (ins), "pop{l}\t{%gs|gs}", []>, TB,
 327                 OpSize32, Requires<[Not64BitMode]>;
 328 def POPGS64 : I<0xa9, RawFrm, (outs), (ins), "pop{q}\t{%gs|gs}", []>, TB,
 329                 OpSize32, Requires<[In64BitMode]>;
 330
 331 def LDS16rm : I<0xc5, MRMSrcMem, (outs GR16:$dst), (ins opaquemem:$src),
 332                 "lds{w}\t{$src, $dst|$dst, $src}", []>, OpSize16,
 333                 Requires<[Not64BitMode]>;
 334 def LDS32rm : I<0xc5, MRMSrcMem, (outs GR32:$dst), (ins opaquemem:$src),
 335                 "lds{l}\t{$src, $dst|$dst, $src}", []>, OpSize32,
 336                 Requires<[Not64BitMode]>;
 337
 338 def LSS16rm : I<0xb2, MRMSrcMem, (outs GR16:$dst), (ins opaquemem:$src),
 339                 "lss{w}\t{$src, $dst|$dst, $src}", []>, TB, OpSize16;
 340 def LSS32rm : I<0xb2, MRMSrcMem, (outs GR32:$dst), (ins opaquemem:$src),
 341                 "lss{l}\t{$src, $dst|$dst, $src}", []>, TB, OpSize32;
 342 def LSS64rm : RI<0xb2, MRMSrcMem, (outs GR64:$dst), (ins opaquemem:$src),
 343                  "lss{q}\t{$src, $dst|$dst, $src}", []>, TB;
 344
 345 def LES16rm : I<0xc4, MRMSrcMem, (outs GR16:$dst), (ins opaquemem:$src),
 346                 "les{w}\t{$src, $dst|$dst, $src}", []>, OpSize16,
 347                 Requires<[Not64BitMode]>;
 348 def LES32rm : I<0xc4, MRMSrcMem, (outs GR32:$dst), (ins opaquemem:$src),
 349                 "les{l}\t{$src, $dst|$dst, $src}", []>, OpSize32,
 350                 Requires<[Not64BitMode]>;
 351
 352 def LFS16rm : I<0xb4, MRMSrcMem, (outs GR16:$dst), (ins opaquemem:$src),
 353                 "lfs{w}\t{$src, $dst|$dst, $src}", []>, TB, OpSize16;
 354 def LFS32rm : I<0xb4, MRMSrcMem, (outs GR32:$dst), (ins opaquemem:$src),
 355                 "lfs{l}\t{$src, $dst|$dst, $src}", []>, TB, OpSize32;
 356 def LFS64rm : RI<0xb4, MRMSrcMem, (outs GR64:$dst), (ins opaquemem:$src),
 357                  "lfs{q}\t{$src, $dst|$dst, $src}", []>, TB;
 358
 359 def LGS16rm : I<0xb5, MRMSrcMem, (outs GR16:$dst), (ins opaquemem:$src),
 360                 "lgs{w}\t{$src, $dst|$dst, $src}", []>, TB, OpSize16;
 361 def LGS32rm : I<0xb5, MRMSrcMem, (outs GR32:$dst), (ins opaquemem:$src),
 362                 "lgs{l}\t{$src, $dst|$dst, $src}", []>, TB, OpSize32;
 363
 364 def LGS64rm : RI<0xb5, MRMSrcMem, (outs GR64:$dst), (ins opaquemem:$src),
 365                  "lgs{q}\t{$src, $dst|$dst, $src}", []>, TB;
 366
 367 def VERRr : I<0x00, MRM4r, (outs), (ins GR16:$seg), "verr\t$seg", []>, TB;
 368 def VERWr : I<0x00, MRM5r, (outs), (ins GR16:$seg), "verw\t$seg", []>, TB;
 369 let mayLoad = 1 in {
 370 def VERRm : I<0x00, MRM4m, (outs), (ins i16mem:$seg), "verr\t$seg", []>, TB;
 371 def VERWm : I<0x00, MRM5m, (outs), (ins i16mem:$seg), "verw\t$seg", []>, TB;
 372 }
 373 } // SchedRW
 374
 375 //===----------------------------------------------------------------------===//
 376 // Descriptor-table support instructions
 377
 378 let SchedRW = [WriteSystem] in {
 379 def SGDT16m : I<0x01, MRM0m, (outs), (ins opaquemem:$dst),
 380                 "sgdtw\t$dst", []>, TB, OpSize16, Requires<[Not64BitMode]>;
 381 def SGDT32m : I<0x01, MRM0m, (outs), (ins opaquemem:$dst),
 382                 "sgdt{l|d}\t$dst", []>, OpSize32, TB, Requires <[Not64BitMode]>;
 383 def SGDT64m : I<0x01, MRM0m, (outs), (ins opaquemem:$dst),
 384                 "sgdt{q}\t$dst", []>, TB, Requires <[In64BitMode]>;
 385 def SIDT16m : I<0x01, MRM1m, (outs), (ins opaquemem:$dst),
 386                 "sidtw\t$dst", []>, TB, OpSize16, Requires<[Not64BitMode]>;
 387 def SIDT32m : I<0x01, MRM1m, (outs), (ins opaquemem:$dst),
 388                 "sidt{l|d}\t$dst", []>, OpSize32, TB, Requires <[Not64BitMode]>;
 389 def SIDT64m : I<0x01, MRM1m, (outs), (ins opaquemem:$dst),
 390                 "sidt{q}\t$dst", []>, TB, Requires <[In64BitMode]>;
 391 def SLDT16r : I<0x00, MRM0r, (outs GR16:$dst), (ins),
 392                 "sldt{w}\t$dst", []>, TB, OpSize16;
 393 let mayStore = 1 in
 394 def SLDT16m : I<0x00, MRM0m, (outs), (ins i16mem:$dst),
 395                 "sldt{w}\t$dst", []>, TB;
 396 def SLDT32r : I<0x00, MRM0r, (outs GR32:$dst), (ins),
 397                 "sldt{l}\t$dst", []>, OpSize32, TB;
 398
 399 // LLDT is not interpreted specially in 64-bit mode because there is no sign
 400 //   extension.
 401 def SLDT64r : RI<0x00, MRM0r, (outs GR64:$dst), (ins),
 402                  "sldt{q}\t$dst", []>, TB, Requires<[In64BitMode]>;
 403
 404 def LGDT16m : I<0x01, MRM2m, (outs), (ins opaquemem:$src),
 405                 "lgdtw\t$src", []>, TB, OpSize16, Requires<[Not64BitMode]>;
 406 def LGDT32m : I<0x01, MRM2m, (outs), (ins opaquemem:$src),
 407                 "lgdt{l|d}\t$src", []>, OpSize32, TB, Requires<[Not64BitMode]>;
 408 def LGDT64m : I<0x01, MRM2m, (outs), (ins opaquemem:$src),
 409                 "lgdt{q}\t$src", []>, TB, Requires<[In64BitMode]>;
 410 def LIDT16m : I<0x01, MRM3m, (outs), (ins opaquemem:$src),
 411                 "lidtw\t$src", []>, TB, OpSize16, Requires<[Not64BitMode]>;
 412 def LIDT32m : I<0x01, MRM3m, (outs), (ins opaquemem:$src),
 413                 "lidt{l|d}\t$src", []>, OpSize32, TB, Requires<[Not64BitMode]>;
 414 def LIDT64m : I<0x01, MRM3m, (outs), (ins opaquemem:$src),
 415                 "lidt{q}\t$src", []>, TB, Requires<[In64BitMode]>;
 416 def LLDT16r : I<0x00, MRM2r, (outs), (ins GR16:$src),
 417                 "lldt{w}\t$src", []>, TB;
 418 let mayLoad = 1 in
 419 def LLDT16m : I<0x00, MRM2m, (outs), (ins i16mem:$src),
 420                 "lldt{w}\t$src", []>, TB;
 421 } // SchedRW
 422
 423 //===----------------------------------------------------------------------===//
 424 // Specialized register support
 425 let SchedRW = [WriteSystem] in {
 426 let Uses = [EAX, ECX, EDX] in
 427 def WRMSR : I<0x30, RawFrm, (outs), (ins), "wrmsr", []>, TB;
 428 let Uses = [EAX, ECX, EDX] in
 429 def WRMSRNS : I<0x01, MRM_C6, (outs), (ins), "wrmsrns", []>, PS;
 430 let Defs = [EAX, EDX], Uses = [ECX] in
 431 def RDMSR : I<0x32, RawFrm, (outs), (ins), "rdmsr", []>, TB;
 432 let Defs = [RAX, EFLAGS], Uses = [RBX, RCX], Predicates = [In64BitMode] in
 433 def PBNDKB : I<0x01, MRM_C7, (outs), (ins), "pbndkb", []>, PS;
 434 let Uses = [RSI, RDI, RCX], Predicates = [In64BitMode] in {
 435 def WRMSRLIST : I<0x01, MRM_C6, (outs), (ins), "wrmsrlist", []>, XS;
 436 def RDMSRLIST : I<0x01, MRM_C6, (outs), (ins), "rdmsrlist", []>, XD;
 437 }
 438
 439 let Predicates = [HasUSERMSR], mayLoad = 1 in {
 440   def URDMSRrr : I<0xf8, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
 441                 "urdmsr\t{$src, $dst|$dst, $src}",
 442                 [(set GR64:$dst, (int_x86_urdmsr GR64:$src))]>, T8XD;
 443   def URDMSRri : Ii32<0xf8, MRM0r, (outs GR64:$dst), (ins i64i32imm:$imm),
 444                 "urdmsr\t{$imm, $dst|$dst, $imm}",
 445                 [(set GR64:$dst, (int_x86_urdmsr i64immSExt32_su:$imm))]>, T_MAP7XD, VEX;
 446 }
 447 let Predicates = [HasUSERMSR], mayStore = 1 in {
 448   def UWRMSRrr : I<0xf8, MRMSrcReg, (outs), (ins GR64:$src1, GR64:$src2),
 449                 "uwrmsr\t{$src1, $src2|$src2, $src1}",
 450                 [(int_x86_uwrmsr GR64:$src1, GR64:$src2)]>, T8XS;
 451   def UWRMSRir : Ii32<0xf8, MRM0r, (outs), (ins GR64:$src, i64i32imm:$imm),
 452                 "uwrmsr\t{$src, $imm|$imm, $src}",
 453                 [(int_x86_uwrmsr GR64:$src, i64immSExt32_su:$imm)]>, T_MAP7XS, VEX;
 454 }
 455 let Defs = [RAX, RDX], Uses = [ECX] in
 456 def RDPMC : I<0x33, RawFrm, (outs), (ins), "rdpmc", []>, TB;
 457
 458 def SMSW16r : I<0x01, MRM4r, (outs GR16:$dst), (ins),
 459                 "smsw{w}\t$dst", []>, OpSize16, TB;
 460 def SMSW32r : I<0x01, MRM4r, (outs GR32:$dst), (ins),
 461                 "smsw{l}\t$dst", []>, OpSize32, TB;
 462 // no m form encodable; use SMSW16m
 463 def SMSW64r : RI<0x01, MRM4r, (outs GR64:$dst), (ins),
 464                  "smsw{q}\t$dst", []>, TB;
 465
 466 // For memory operands, there is only a 16-bit form
 467 def SMSW16m : I<0x01, MRM4m, (outs), (ins i16mem:$dst),
 468                 "smsw{w}\t$dst", []>, TB;
 469
 470 def LMSW16r : I<0x01, MRM6r, (outs), (ins GR16:$src),
 471                 "lmsw{w}\t$src", []>, TB;
 472 let mayLoad = 1 in
 473 def LMSW16m : I<0x01, MRM6m, (outs), (ins i16mem:$src),
 474                 "lmsw{w}\t$src", []>, TB;
 475
 476 let Defs = [EAX, EBX, ECX, EDX], Uses = [EAX, ECX] in
 477   def CPUID : I<0xA2, RawFrm, (outs), (ins), "cpuid", []>, TB;
 478 } // SchedRW
 479
 480 //===----------------------------------------------------------------------===//
 481 // Cache instructions
 482 let SchedRW = [WriteSystem] in {
 483 def INVD : I<0x08, RawFrm, (outs), (ins), "invd", []>, TB;
 484 def WBINVD : I<0x09, RawFrm, (outs), (ins), "wbinvd", [(int_x86_wbinvd)]>, PS;
 485
 486 // wbnoinvd is like wbinvd, except without invalidation
 487 // encoding: like wbinvd + an 0xF3 prefix
 488 def WBNOINVD : I<0x09, RawFrm, (outs), (ins), "wbnoinvd",
 489                  [(int_x86_wbnoinvd)]>, XS,
 490                  Requires<[HasWBNOINVD]>;
 491 } // SchedRW
 492
 493 //===----------------------------------------------------------------------===//
 494 // CET instructions
 495 // Use with caution, availability is not predicated on features.
 496 let SchedRW = [WriteSystem] in {
 497   let Uses = [SSP] in {
 498     let Defs = [SSP] in {
 499       def INCSSPD : I<0xAE, MRM5r, (outs), (ins GR32:$src), "incsspd\t$src",
 500                        [(int_x86_incsspd GR32:$src)]>, XS;
 501       def INCSSPQ : RI<0xAE, MRM5r, (outs), (ins GR64:$src), "incsspq\t$src",
 502                        [(int_x86_incsspq GR64:$src)]>, XS;
 503     } // Defs SSP
 504
 505     let Constraints = "$src = $dst" in {
 506       def RDSSPD : I<0x1E, MRM1r, (outs GR32:$dst), (ins GR32:$src),
 507                      "rdsspd\t$dst",
 508                      [(set GR32:$dst, (int_x86_rdsspd GR32:$src))]>, XS;
 509       def RDSSPQ : RI<0x1E, MRM1r, (outs GR64:$dst), (ins GR64:$src),
 510                      "rdsspq\t$dst",
 511                      [(set GR64:$dst, (int_x86_rdsspq GR64:$src))]>, XS;
 512     }
 513
 514     let Defs = [SSP] in {
 515       def SAVEPREVSSP : I<0x01, MRM_EA, (outs), (ins), "saveprevssp",
 516                        [(int_x86_saveprevssp)]>, XS;
 517       def RSTORSSP : I<0x01, MRM5m, (outs), (ins i32mem:$src),
 518                        "rstorssp\t$src",
 519                        [(int_x86_rstorssp addr:$src)]>, XS;
 520     } // Defs SSP
 521   } // Uses SSP
 522
 523   def WRSSD : I<0xF6, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
 524                 "wrssd\t{$src, $dst|$dst, $src}",
 525                 [(int_x86_wrssd GR32:$src, addr:$dst)]>, T8PS;
 526   def WRSSQ : RI<0xF6, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
 527                  "wrssq\t{$src, $dst|$dst, $src}",
 528                  [(int_x86_wrssq GR64:$src, addr:$dst)]>, T8PS;
 529   def WRUSSD : I<0xF5, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
 530                  "wrussd\t{$src, $dst|$dst, $src}",
 531                  [(int_x86_wrussd GR32:$src, addr:$dst)]>, T8PD;
 532   def WRUSSQ : RI<0xF5, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
 533                   "wrussq\t{$src, $dst|$dst, $src}",
 534                   [(int_x86_wrussq GR64:$src, addr:$dst)]>, T8PD;
 535
 536   let Defs = [SSP] in {
 537     let Uses = [SSP] in {
 538         def SETSSBSY : I<0x01, MRM_E8, (outs), (ins), "setssbsy",
 539                          [(int_x86_setssbsy)]>, XS;
 540     } // Uses SSP
 541
 542     def CLRSSBSY : I<0xAE, MRM6m, (outs), (ins i32mem:$src),
 543                      "clrssbsy\t$src",
 544                      [(int_x86_clrssbsy addr:$src)]>, XS;
 545   } // Defs SSP
 546 } // SchedRW
 547
 548 let SchedRW = [WriteSystem] in {
 549     def ENDBR64 : I<0x1E, MRM_FA, (outs), (ins), "endbr64", []>, XS;
 550     def ENDBR32 : I<0x1E, MRM_FB, (outs), (ins), "endbr32", []>, XS;
 551 } // SchedRW
 552
 553 //===----------------------------------------------------------------------===//
 554 // XSAVE instructions
 555 let SchedRW = [WriteSystem] in {
 556 // NOTE: No HasXSAVE predicate so that these can be used with _xgetbv/_xsetbv
 557 // on Windows without needing to enable the xsave feature to be compatible with
 558 // MSVC.
 559 let Defs = [EDX, EAX], Uses = [ECX] in
 560 def XGETBV : I<0x01, MRM_D0, (outs), (ins), "xgetbv", []>, PS;
 561
 562 let Uses = [EDX, EAX, ECX] in
 563 def XSETBV : I<0x01, MRM_D1, (outs), (ins),
 564               "xsetbv",
 565               [(int_x86_xsetbv ECX, EDX, EAX)]>, PS;
 566
 567
 568 let Uses = [EDX, EAX] in {
 569 def XSAVE : I<0xAE, MRM4m, (outs), (ins opaquemem:$dst),
 570               "xsave\t$dst",
 571               [(int_x86_xsave addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVE]>;
 572 def XSAVE64 : RI<0xAE, MRM4m, (outs), (ins opaquemem:$dst),
 573                  "xsave64\t$dst",
 574                  [(int_x86_xsave64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVE, In64BitMode]>;
 575 def XRSTOR : I<0xAE, MRM5m, (outs), (ins opaquemem:$dst),
 576                "xrstor\t$dst",
 577                [(int_x86_xrstor addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVE]>;
 578 def XRSTOR64 : RI<0xAE, MRM5m, (outs), (ins opaquemem:$dst),
 579                   "xrstor64\t$dst",
 580                   [(int_x86_xrstor64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVE, In64BitMode]>;
 581 def XSAVEOPT : I<0xAE, MRM6m, (outs), (ins opaquemem:$dst),
 582                  "xsaveopt\t$dst",
 583                  [(int_x86_xsaveopt addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVEOPT]>;
 584 def XSAVEOPT64 : RI<0xAE, MRM6m, (outs), (ins opaquemem:$dst),
 585                     "xsaveopt64\t$dst",
 586                     [(int_x86_xsaveopt64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVEOPT, In64BitMode]>;
 587 def XSAVEC : I<0xC7, MRM4m, (outs), (ins opaquemem:$dst),
 588                "xsavec\t$dst",
 589                [(int_x86_xsavec addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVEC]>;
 590 def XSAVEC64 : RI<0xC7, MRM4m, (outs), (ins opaquemem:$dst),
 591                  "xsavec64\t$dst",
 592                  [(int_x86_xsavec64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVEC, In64BitMode]>;
 593 def XSAVES : I<0xC7, MRM5m, (outs), (ins opaquemem:$dst),
 594                "xsaves\t$dst",
 595                [(int_x86_xsaves addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVES]>;
 596 def XSAVES64 : RI<0xC7, MRM5m, (outs), (ins opaquemem:$dst),
 597                   "xsaves64\t$dst",
 598                   [(int_x86_xsaves64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVE, In64BitMode]>;
 599 def XRSTORS : I<0xC7, MRM3m, (outs), (ins opaquemem:$dst),
 600                 "xrstors\t$dst",
 601                 [(int_x86_xrstors addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVES]>;
 602 def XRSTORS64 : RI<0xC7, MRM3m, (outs), (ins opaquemem:$dst),
 603                    "xrstors64\t$dst",
 604                    [(int_x86_xrstors64 addr:$dst, EDX, EAX)]>, PS, Requires<[HasXSAVES, In64BitMode]>;
 605 } // Uses
 606 } // SchedRW
 607
 608 //===----------------------------------------------------------------------===//
 609 // VIA PadLock crypto instructions
 610 let Defs = [RAX, RDI], Uses = [RDX, RDI], SchedRW = [WriteSystem] in
 611   def XSTORE : I<0xa7, MRM_C0, (outs), (ins), "xstore", []>, TB;
 612
 613 def : InstAlias<"xstorerng", (XSTORE)>;
 614
 615 let SchedRW = [WriteSystem] in {
 616 let Defs = [RSI, RDI], Uses = [RBX, RDX, RSI, RDI] in {
 617   def XCRYPTECB : I<0xa7, MRM_C8, (outs), (ins), "xcryptecb", []>, TB, REP;
 618   def XCRYPTCBC : I<0xa7, MRM_D0, (outs), (ins), "xcryptcbc", []>, TB, REP;
 619   def XCRYPTCTR : I<0xa7, MRM_D8, (outs), (ins), "xcryptctr", []>, TB, REP;
 620   def XCRYPTCFB : I<0xa7, MRM_E0, (outs), (ins), "xcryptcfb", []>, TB, REP;
 621   def XCRYPTOFB : I<0xa7, MRM_E8, (outs), (ins), "xcryptofb", []>, TB, REP;
 622 }
 623
 624 let Defs = [RAX, RSI, RDI], Uses = [RAX, RSI, RDI] in {
 625   def XSHA1 : I<0xa6, MRM_C8, (outs), (ins), "xsha1", []>, TB, REP;
 626   def XSHA256 : I<0xa6, MRM_D0, (outs), (ins), "xsha256", []>, TB, REP;
 627 }
 628 let Defs = [RAX, RDX, RSI], Uses = [RAX, RSI] in
 629   def MONTMUL : I<0xa6, MRM_C0, (outs), (ins), "montmul", []>, TB, REP;
 630 } // SchedRW
 631
 632 //==-----------------------------------------------------------------------===//
 633 // PKU  - enable protection key
 634 let SchedRW = [WriteSystem] in {
 635 let Defs = [EAX, EDX], Uses = [ECX] in
 636   def RDPKRUr : I<0x01, MRM_EE, (outs), (ins), "rdpkru",
 637                   [(set EAX, (X86rdpkru ECX)), (implicit EDX)]>, PS;
 638 let Uses = [EAX, ECX, EDX] in
 639   def WRPKRUr : I<0x01, MRM_EF, (outs), (ins), "wrpkru",
 640                   [(X86wrpkru EAX, EDX, ECX)]>, PS;
 641 } // SchedRW
 642
 643 //===----------------------------------------------------------------------===//
 644 // FS/GS Base Instructions
 645 let Predicates = [HasFSGSBase, In64BitMode], SchedRW = [WriteSystem] in {
 646   def RDFSBASE : I<0xAE, MRM0r, (outs GR32:$dst), (ins),
 647                    "rdfsbase{l}\t$dst",
 648                    [(set GR32:$dst, (int_x86_rdfsbase_32))]>, XS;
 649   def RDFSBASE64 : RI<0xAE, MRM0r, (outs GR64:$dst), (ins),
 650                      "rdfsbase{q}\t$dst",
 651                      [(set GR64:$dst, (int_x86_rdfsbase_64))]>, XS;
 652   def RDGSBASE : I<0xAE, MRM1r, (outs GR32:$dst), (ins),
 653                    "rdgsbase{l}\t$dst",
 654                    [(set GR32:$dst, (int_x86_rdgsbase_32))]>, XS;
 655   def RDGSBASE64 : RI<0xAE, MRM1r, (outs GR64:$dst), (ins),
 656                      "rdgsbase{q}\t$dst",
 657                      [(set GR64:$dst, (int_x86_rdgsbase_64))]>, XS;
 658   def WRFSBASE : I<0xAE, MRM2r, (outs), (ins GR32:$src),
 659                    "wrfsbase{l}\t$src",
 660                    [(int_x86_wrfsbase_32 GR32:$src)]>, XS;
 661   def WRFSBASE64 : RI<0xAE, MRM2r, (outs), (ins GR64:$src),
 662                       "wrfsbase{q}\t$src",
 663                       [(int_x86_wrfsbase_64 GR64:$src)]>, XS;
 664   def WRGSBASE : I<0xAE, MRM3r, (outs), (ins GR32:$src),
 665                    "wrgsbase{l}\t$src",
 666                    [(int_x86_wrgsbase_32 GR32:$src)]>, XS;
 667   def WRGSBASE64 : RI<0xAE, MRM3r, (outs), (ins GR64:$src),
 668                       "wrgsbase{q}\t$src",
 669                       [(int_x86_wrgsbase_64 GR64:$src)]>, XS;
 670 }
 671
 672 //===----------------------------------------------------------------------===//
 673 // INVPCID Instruction
 674 let SchedRW = [WriteSystem] in {
 675 def INVPCID32 : I<0x82, MRMSrcMem, (outs), (ins GR32:$src1, i128mem:$src2),
 676                   "invpcid\t{$src2, $src1|$src1, $src2}",
 677                   [(int_x86_invpcid GR32:$src1, addr:$src2)]>, T8PD,
 678                   Requires<[Not64BitMode, HasINVPCID]>;
 679 def INVPCID64 : I<0x82, MRMSrcMem, (outs), (ins GR64:$src1, i128mem:$src2),
 680                   "invpcid\t{$src2, $src1|$src1, $src2}", []>, T8PD,
 681                   Requires<[In64BitMode, HasINVPCID]>;
 682 } // SchedRW
 683
 684 let Predicates = [In64BitMode, HasINVPCID] in {
 685   // The instruction can only use a 64 bit register as the register argument
 686   // in 64 bit mode, while the intrinsic only accepts a 32 bit argument
 687   // corresponding to it.
 688   // The accepted values for now are 0,1,2,3 anyways (see Intel SDM -- INVCPID
 689   // type),/ so it doesn't hurt us that one can't supply a 64 bit value here.
 690   def : Pat<(int_x86_invpcid GR32:$src1, addr:$src2),
 691             (INVPCID64
 692               (SUBREG_TO_REG (i64 0), (MOV32rr GR32:$src1), sub_32bit),
 693               addr:$src2)>;
 694 }
 695
 696
 697 //===----------------------------------------------------------------------===//
 698 // SMAP Instruction
 699 let Defs = [EFLAGS], SchedRW = [WriteSystem] in {
 700   def CLAC : I<0x01, MRM_CA, (outs), (ins), "clac", []>, PS;
 701   def STAC : I<0x01, MRM_CB, (outs), (ins), "stac", []>, PS;
 702 }
 703
 704 //===----------------------------------------------------------------------===//
 705 // SMX Instruction
 706 let SchedRW = [WriteSystem] in {
 707 let Uses = [RAX, RBX, RCX, RDX], Defs = [RAX, RBX, RCX] in {
 708   def GETSEC : I<0x37, RawFrm, (outs), (ins), "getsec", []>, PS;
 709 } // Uses, Defs
 710 } // SchedRW
 711
 712 //===----------------------------------------------------------------------===//
 713 // TS flag control instruction.
 714 let SchedRW = [WriteSystem] in {
 715 def CLTS : I<0x06, RawFrm, (outs), (ins), "clts", []>, TB;
 716 }
 717
 718 //===----------------------------------------------------------------------===//
 719 // IF (inside EFLAGS) management instructions.
 720 let SchedRW = [WriteSystem], Uses = [EFLAGS], Defs = [EFLAGS] in {
 721 def CLI : I<0xFA, RawFrm, (outs), (ins), "cli", []>;
 722 def STI : I<0xFB, RawFrm, (outs), (ins), "sti", []>;
 723 }
 724
 725 //===----------------------------------------------------------------------===//
 726 // RDPID Instruction
 727 let SchedRW = [WriteSystem] in {
 728 def RDPID32 : I<0xC7, MRM7r, (outs GR32:$dst), (ins),
 729                 "rdpid\t$dst", [(set GR32:$dst, (int_x86_rdpid))]>, XS,
 730                 Requires<[Not64BitMode, HasRDPID]>;
 731 def RDPID64 : I<0xC7, MRM7r, (outs GR64:$dst), (ins), "rdpid\t$dst", []>, XS,
 732                 Requires<[In64BitMode, HasRDPID]>;
 733 } // SchedRW
 734
 735 let Predicates = [In64BitMode, HasRDPID] in {
 736   // Due to silly instruction definition, we have to compensate for the
 737   // instruction outputing a 64-bit register.
 738   def : Pat<(int_x86_rdpid),
 739             (EXTRACT_SUBREG (RDPID64), sub_32bit)>;
 740 }
 741
 742
 743 //===----------------------------------------------------------------------===//
 744 // PTWRITE Instruction - Write Data to a Processor Trace Packet
 745 let SchedRW = [WriteSystem] in {
 746 def PTWRITEm: I<0xAE, MRM4m, (outs), (ins i32mem:$dst),
 747                 "ptwrite{l}\t$dst", [(int_x86_ptwrite32 (loadi32 addr:$dst))]>, XS,
 748                 Requires<[HasPTWRITE]>;
 749 def PTWRITE64m : RI<0xAE, MRM4m, (outs), (ins i64mem:$dst),
 750                     "ptwrite{q}\t$dst", [(int_x86_ptwrite64 (loadi64 addr:$dst))]>, XS,
 751                     Requires<[In64BitMode, HasPTWRITE]>;
 752
 753 def PTWRITEr : I<0xAE, MRM4r, (outs), (ins GR32:$dst),
 754                  "ptwrite{l}\t$dst", [(int_x86_ptwrite32 GR32:$dst)]>, XS,
 755                     Requires<[HasPTWRITE]>;
 756 def PTWRITE64r : RI<0xAE, MRM4r, (outs), (ins GR64:$dst),
 757                     "ptwrite{q}\t$dst", [(int_x86_ptwrite64 GR64:$dst)]>, XS,
 758                     Requires<[In64BitMode, HasPTWRITE]>;
 759 } // SchedRW
 760
 761 //===----------------------------------------------------------------------===//
 762 // RDPRU - Read Processor Register instruction.
 763
 764 let SchedRW = [WriteSystem] in {
 765 let Uses = [ECX], Defs = [EAX, EDX] in
 766    def RDPRU : I<0x01, MRM_FD, (outs), (ins), "rdpru", []>, PS,
 767                Requires<[HasRDPRU]>;
 768 }
 769
 770 //===----------------------------------------------------------------------===//
 771 // Platform Configuration instruction
 772
 773 // From ISA docs:
 774 //  "This instruction is used to execute functions for configuring platform
 775 //   features.
 776 //   EAX: Leaf function to be invoked.
 777 //   RBX/RCX/RDX: Leaf-specific purpose."
 778 //  "Successful execution of the leaf clears RAX (set to zero) and ZF, CF, PF,
 779 //   AF, OF, and SF are cleared. In case of failure, the failure reason is
 780 //   indicated in RAX with ZF set to 1 and CF, PF, AF, OF, and SF are cleared."
 781 // Thus all these mentioned registers are considered clobbered.
 782
 783 let SchedRW = [WriteSystem] in {
 784 let Uses = [RAX, RBX, RCX, RDX], Defs = [RAX, RBX, RCX, RDX, EFLAGS] in
 785     def PCONFIG : I<0x01, MRM_C5, (outs), (ins), "pconfig", []>, PS,
 786                   Requires<[HasPCONFIG]>;
 787 } // SchedRW