lib/Target/SystemZ/SystemZScheduleZ14.td

   1 //-- SystemZScheduleZ14.td - SystemZ Scheduling Definitions ----*- tblgen -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the machine model for Z14 to support instruction
  11 // scheduling and other instruction cost heuristics.
  12 //
  13 // Pseudos expanded right after isel do not need to be modelled here.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 def Z14Model : SchedMachineModel {
  18
  19     let UnsupportedFeatures = Arch12UnsupportedFeatures.List;
  20
  21     let IssueWidth = 6;             // Number of instructions decoded per cycle.
  22     let MicroOpBufferSize = 60;     // Issue queues
  23     let LoadLatency = 1;            // Optimistic load latency.
  24
  25     let PostRAScheduler = 1;
  26
  27     // Extra cycles for a mispredicted branch.
  28     let MispredictPenalty = 20;
  29 }
  30
  31 let SchedModel = Z14Model in  {
  32 // These definitions need the SchedModel value. They could be put in a
  33 // subtarget common include file, but it seems the include system in Tablegen
  34 // currently (2016) rejects multiple includes of same file.
  35
  36 // Decoder grouping rules
  37 let NumMicroOps = 1 in {
  38   def : WriteRes<NormalGr, []>;
  39   def : WriteRes<BeginGroup, []> { let BeginGroup  = 1; }
  40   def : WriteRes<EndGroup, []>   { let EndGroup    = 1; }
  41 }
  42 def : WriteRes<Cracked, []> {
  43   let NumMicroOps = 2;
  44   let BeginGroup  = 1;
  45 }
  46 def : WriteRes<GroupAlone, []> {
  47   let NumMicroOps = 3;
  48   let BeginGroup  = 1;
  49   let EndGroup    = 1;
  50 }
  51 def : WriteRes<GroupAlone2, []> {
  52   let NumMicroOps = 6;
  53   let BeginGroup  = 1;
  54   let EndGroup    = 1;
  55 }
  56 def : WriteRes<GroupAlone3, []> {
  57   let NumMicroOps = 9;
  58   let BeginGroup  = 1;
  59   let EndGroup    = 1;
  60 }
  61
  62 // Incoming latency removed from the register operand which is used together
  63 // with a memory operand by the instruction.
  64 def : ReadAdvance<RegReadAdv, 4>;
  65
  66 // LoadLatency (above) is not used for instructions in this file. This is
  67 // instead the role of LSULatency, which is the latency value added to the
  68 // result of loads and instructions with folded memory operands.
  69 def : WriteRes<LSULatency, []> { let Latency = 4; let NumMicroOps = 0; }
  70
  71 let NumMicroOps = 0 in {
  72   foreach L = 1-30 in
  73     def : WriteRes<!cast<SchedWrite>("WLat"#L), []> { let Latency = L; }
  74 }
  75
  76 // Execution units.
  77 def Z14_FXaUnit     : ProcResource<2>;
  78 def Z14_FXbUnit     : ProcResource<2>;
  79 def Z14_LSUnit      : ProcResource<2>;
  80 def Z14_VecUnit     : ProcResource<2>;
  81 def Z14_VecFPdUnit  : ProcResource<2> { let BufferSize = 1; /* blocking */ }
  82 def Z14_VBUnit      : ProcResource<2>;
  83 def Z14_MCD         : ProcResource<1>;
  84
  85 // Subtarget specific definitions of scheduling resources.
  86 let NumMicroOps = 0 in {
  87   def : WriteRes<FXa, [Z14_FXaUnit]>;
  88   def : WriteRes<FXb, [Z14_FXbUnit]>;
  89   def : WriteRes<LSU, [Z14_LSUnit]>;
  90   def : WriteRes<VecBF,  [Z14_VecUnit]>;
  91   def : WriteRes<VecDF,  [Z14_VecUnit]>;
  92   def : WriteRes<VecDFX, [Z14_VecUnit]>;
  93   def : WriteRes<VecMul,  [Z14_VecUnit]>;
  94   def : WriteRes<VecStr,  [Z14_VecUnit]>;
  95   def : WriteRes<VecXsPm, [Z14_VecUnit]>;
  96   foreach Num = 2-5 in { let ResourceCycles = [Num] in {
  97     def : WriteRes<!cast<SchedWrite>("FXa"#Num), [Z14_FXaUnit]>;
  98     def : WriteRes<!cast<SchedWrite>("FXb"#Num), [Z14_FXbUnit]>;
  99     def : WriteRes<!cast<SchedWrite>("LSU"#Num), [Z14_LSUnit]>;
 100     def : WriteRes<!cast<SchedWrite>("VecBF"#Num), [Z14_VecUnit]>;
 101     def : WriteRes<!cast<SchedWrite>("VecDF"#Num), [Z14_VecUnit]>;
 102     def : WriteRes<!cast<SchedWrite>("VecDFX"#Num), [Z14_VecUnit]>;
 103     def : WriteRes<!cast<SchedWrite>("VecMul"#Num), [Z14_VecUnit]>;
 104     def : WriteRes<!cast<SchedWrite>("VecStr"#Num), [Z14_VecUnit]>;
 105     def : WriteRes<!cast<SchedWrite>("VecXsPm"#Num), [Z14_VecUnit]>;
 106   }}
 107
 108   def : WriteRes<VecFPd,  [Z14_VecFPdUnit]> { let ResourceCycles = [30]; }
 109
 110   def : WriteRes<VBU,     [Z14_VBUnit]>; // Virtual Branching Unit
 111 }
 112
 113 def : WriteRes<MCD, [Z14_MCD]> { let NumMicroOps = 3;
 114                                  let BeginGroup  = 1;
 115                                  let EndGroup    = 1; }
 116
 117 // -------------------------- INSTRUCTIONS ---------------------------------- //
 118
 119 // InstRW constructs have been used in order to preserve the
 120 // readability of the InstrInfo files.
 121
 122 // For each instruction, as matched by a regexp, provide a list of
 123 // resources that it needs. These will be combined into a SchedClass.
 124
 125 //===----------------------------------------------------------------------===//
 126 // Stack allocation
 127 //===----------------------------------------------------------------------===//
 128
 129 // Pseudo -> LA / LAY
 130 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ADJDYNALLOC$")>;
 131
 132 //===----------------------------------------------------------------------===//
 133 // Branch instructions
 134 //===----------------------------------------------------------------------===//
 135
 136 // Branch
 137 def : InstRW<[WLat1, VBU, NormalGr], (instregex "(Call)?BRC(L)?(Asm.*)?$")>;
 138 def : InstRW<[WLat1, VBU, NormalGr], (instregex "(Call)?J(G)?(Asm.*)?$")>;
 139 def : InstRW<[WLat1, FXb, NormalGr], (instregex "(Call)?BC(R)?(Asm.*)?$")>;
 140 def : InstRW<[WLat1, FXb, NormalGr], (instregex "(Call)?B(R)?(Asm.*)?$")>;
 141 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "BI(C)?(Asm.*)?$")>;
 142 def : InstRW<[WLat1, FXa, EndGroup], (instregex "BRCT(G)?$")>;
 143 def : InstRW<[WLat1, FXa, FXb, GroupAlone], (instregex "BRCTH$")>;
 144 def : InstRW<[WLat1, FXa, FXb, GroupAlone], (instregex "BCT(G)?(R)?$")>;
 145 def : InstRW<[WLat1, FXa2, FXb2, GroupAlone2],
 146              (instregex "B(R)?X(H|L).*$")>;
 147
 148 // Compare and branch
 149 def : InstRW<[WLat1, FXb, NormalGr], (instregex "C(L)?(G)?(I|R)J(Asm.*)?$")>;
 150 def : InstRW<[WLat1, FXb2, GroupAlone],
 151              (instregex "C(L)?(G)?(I|R)B(Call|Return|Asm.*)?$")>;
 152
 153 //===----------------------------------------------------------------------===//
 154 // Trap instructions
 155 //===----------------------------------------------------------------------===//
 156
 157 // Trap
 158 def : InstRW<[WLat1, VBU, NormalGr], (instregex "(Cond)?Trap$")>;
 159
 160 // Compare and trap
 161 def : InstRW<[WLat1, FXb, NormalGr], (instregex "C(G)?(I|R)T(Asm.*)?$")>;
 162 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CL(G)?RT(Asm.*)?$")>;
 163 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CL(F|G)IT(Asm.*)?$")>;
 164 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "CL(G)?T(Asm.*)?$")>;
 165
 166 //===----------------------------------------------------------------------===//
 167 // Call and return instructions
 168 //===----------------------------------------------------------------------===//
 169
 170 // Call
 171 def : InstRW<[WLat1, VBU, FXa2, GroupAlone], (instregex "(Call)?BRAS$")>;
 172 def : InstRW<[WLat1, FXa2, FXb, GroupAlone], (instregex "(Call)?BRASL$")>;
 173 def : InstRW<[WLat1, FXa2, FXb, GroupAlone], (instregex "(Call)?BAS(R)?$")>;
 174 def : InstRW<[WLat1, FXa2, FXb, GroupAlone], (instregex "TLS_(G|L)DCALL$")>;
 175
 176 // Return
 177 def : InstRW<[WLat1, FXb, EndGroup], (instregex "Return$")>;
 178 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CondReturn$")>;
 179
 180 //===----------------------------------------------------------------------===//
 181 // Move instructions
 182 //===----------------------------------------------------------------------===//
 183
 184 // Moves
 185 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "MV(G|H)?HI$")>;
 186 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "MVI(Y)?$")>;
 187
 188 // Move character
 189 def : InstRW<[WLat1, FXb, LSU3, GroupAlone], (instregex "MVC$")>;
 190 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "MVCL(E|U)?$")>;
 191
 192 // Pseudo -> reg move
 193 def : InstRW<[WLat1, FXa, NormalGr], (instregex "COPY(_TO_REGCLASS)?$")>;
 194 def : InstRW<[WLat1, FXa, NormalGr], (instregex "EXTRACT_SUBREG$")>;
 195 def : InstRW<[WLat1, FXa, NormalGr], (instregex "INSERT_SUBREG$")>;
 196 def : InstRW<[WLat1, FXa, NormalGr], (instregex "REG_SEQUENCE$")>;
 197
 198 // Loads
 199 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "L(Y|FH|RL|Mux)?$")>;
 200 def : InstRW<[LSULatency, LSULatency, LSU, NormalGr], (instregex "LCBB$")>;
 201 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LG(RL)?$")>;
 202 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "L128$")>;
 203
 204 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LLIH(F|H|L)$")>;
 205 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LLIL(F|H|L)$")>;
 206
 207 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LG(F|H)I$")>;
 208 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LHI(Mux)?$")>;
 209 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LR(Mux)?$")>;
 210
 211 // Load and zero rightmost byte
 212 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LZR(F|G)$")>;
 213
 214 // Load and trap
 215 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "L(FH|G)?AT$")>;
 216
 217 // Load and test
 218 def : InstRW<[WLat1LSU, WLat1LSU, LSU, FXa, NormalGr], (instregex "LT(G)?$")>;
 219 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LT(G)?R$")>;
 220
 221 // Stores
 222 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STG(RL)?$")>;
 223 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "ST128$")>;
 224 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "ST(Y|FH|RL|Mux)?$")>;
 225
 226 // String moves.
 227 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "MVST$")>;
 228
 229 //===----------------------------------------------------------------------===//
 230 // Conditional move instructions
 231 //===----------------------------------------------------------------------===//
 232
 233 def : InstRW<[WLat2, FXa, NormalGr], (instregex "LOCRMux$")>;
 234 def : InstRW<[WLat2, FXa, NormalGr], (instregex "LOC(G|FH)?R(Asm.*)?$")>;
 235 def : InstRW<[WLat2, FXa, NormalGr], (instregex "LOC(G|H)?HI(Mux|(Asm.*))?$")>;
 236 def : InstRW<[WLat2LSU, RegReadAdv, FXa, LSU, NormalGr],
 237              (instregex "LOC(G|FH|Mux)?(Asm.*)?$")>;
 238 def : InstRW<[WLat1, FXb, LSU, NormalGr],
 239              (instregex "STOC(G|FH|Mux)?(Asm.*)?$")>;
 240
 241 //===----------------------------------------------------------------------===//
 242 // Sign extensions
 243 //===----------------------------------------------------------------------===//
 244
 245 def : InstRW<[WLat1, FXa, NormalGr], (instregex "L(B|H|G)R$")>;
 246 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LG(B|H|F)R$")>;
 247
 248 def : InstRW<[WLat1LSU, WLat1LSU, FXa, LSU, NormalGr], (instregex "LTGF$")>;
 249 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LTGFR$")>;
 250
 251 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LB(H|Mux)?$")>;
 252 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LH(Y)?$")>;
 253 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LH(H|Mux|RL)$")>;
 254 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LG(B|H|F)$")>;
 255 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LG(H|F)RL$")>;
 256
 257 //===----------------------------------------------------------------------===//
 258 // Zero extensions
 259 //===----------------------------------------------------------------------===//
 260
 261 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LLCR(Mux)?$")>;
 262 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LLHR(Mux)?$")>;
 263 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LLG(C|H|F|T)R$")>;
 264 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLC(Mux)?$")>;
 265 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLH(Mux)?$")>;
 266 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LL(C|H)H$")>;
 267 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLHRL$")>;
 268 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLG(C|H|F|T|HRL|FRL)$")>;
 269
 270 // Load and zero rightmost byte
 271 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLZRGF$")>;
 272
 273 // Load and trap
 274 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "LLG(F|T)?AT$")>;
 275
 276 //===----------------------------------------------------------------------===//
 277 // Truncations
 278 //===----------------------------------------------------------------------===//
 279
 280 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STC(H|Y|Mux)?$")>;
 281 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STH(H|Y|RL|Mux)?$")>;
 282 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STCM(H|Y)?$")>;
 283
 284 //===----------------------------------------------------------------------===//
 285 // Multi-register moves
 286 //===----------------------------------------------------------------------===//
 287
 288 // Load multiple (estimated average of 5 ops)
 289 def : InstRW<[WLat10, WLat10, LSU5, GroupAlone], (instregex "LM(H|Y|G)?$")>;
 290
 291 // Load multiple disjoint
 292 def : InstRW<[WLat30, WLat30, MCD], (instregex "LMD$")>;
 293
 294 // Store multiple
 295 def : InstRW<[WLat1, LSU2, FXb3, GroupAlone], (instregex "STM(G|H|Y)?$")>;
 296
 297 //===----------------------------------------------------------------------===//
 298 // Byte swaps
 299 //===----------------------------------------------------------------------===//
 300
 301 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LRV(G)?R$")>;
 302 def : InstRW<[WLat1LSU, FXa, LSU, NormalGr], (instregex "LRV(G|H)?$")>;
 303 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STRV(G|H)?$")>;
 304 def : InstRW<[WLat30, MCD], (instregex "MVCIN$")>;
 305
 306 //===----------------------------------------------------------------------===//
 307 // Load address instructions
 308 //===----------------------------------------------------------------------===//
 309
 310 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LA(Y|RL)?$")>;
 311
 312 // Load the Global Offset Table address ( -> larl )
 313 def : InstRW<[WLat1, FXa, NormalGr], (instregex "GOT$")>;
 314
 315 //===----------------------------------------------------------------------===//
 316 // Absolute and Negation
 317 //===----------------------------------------------------------------------===//
 318
 319 def : InstRW<[WLat1, WLat1, FXa, NormalGr], (instregex "LP(G)?R$")>;
 320 def : InstRW<[WLat2, WLat2, FXa2, Cracked], (instregex "L(N|P)GFR$")>;
 321 def : InstRW<[WLat1, WLat1, FXa, NormalGr], (instregex "LN(R|GR)$")>;
 322 def : InstRW<[WLat1, FXa, NormalGr], (instregex "LC(R|GR)$")>;
 323 def : InstRW<[WLat2, WLat2, FXa2, Cracked], (instregex "LCGFR$")>;
 324
 325 //===----------------------------------------------------------------------===//
 326 // Insertion
 327 //===----------------------------------------------------------------------===//
 328
 329 def : InstRW<[WLat1LSU, RegReadAdv, FXa, LSU, NormalGr], (instregex "IC(Y)?$")>;
 330 def : InstRW<[WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 331              (instregex "IC32(Y)?$")>;
 332 def : InstRW<[WLat1LSU, RegReadAdv, WLat1LSU, FXa, LSU, NormalGr],
 333              (instregex "ICM(H|Y)?$")>;
 334 def : InstRW<[WLat1, FXa, NormalGr], (instregex "II(F|H|L)Mux$")>;
 335 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IIHF(64)?$")>;
 336 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IIHH(64)?$")>;
 337 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IIHL(64)?$")>;
 338 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IILF(64)?$")>;
 339 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IILH(64)?$")>;
 340 def : InstRW<[WLat1, FXa, NormalGr], (instregex "IILL(64)?$")>;
 341
 342 //===----------------------------------------------------------------------===//
 343 // Addition
 344 //===----------------------------------------------------------------------===//
 345
 346 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 347              (instregex "A(Y)?$")>;
 348 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, NormalGr],
 349              (instregex "AH(Y)?$")>;
 350 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AIH$")>;
 351 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AFI(Mux)?$")>;
 352 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 353              (instregex "AG$")>;
 354 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AGFI$")>;
 355 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AGHI(K)?$")>;
 356 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AGR(K)?$")>;
 357 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AHI(K)?$")>;
 358 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AHIMux(K)?$")>;
 359 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 360              (instregex "AL(Y)?$")>;
 361 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AL(FI|HSIK)$")>;
 362 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 363              (instregex "ALG(F)?$")>;
 364 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ALGHSIK$")>;
 365 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ALGF(I|R)$")>;
 366 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ALGR(K)?$")>;
 367 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ALR(K)?$")>;
 368 def : InstRW<[WLat1, FXa, NormalGr], (instregex "AR(K)?$")>;
 369 def : InstRW<[WLat1, FXa, NormalGr], (instregex "A(L)?HHHR$")>;
 370 def : InstRW<[WLat2, WLat2, FXa, NormalGr], (instregex "A(L)?HHLR$")>;
 371 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ALSIH(N)?$")>;
 372 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "A(L)?(G)?SI$")>;
 373
 374 // Logical addition with carry
 375 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, GroupAlone],
 376              (instregex "ALC(G)?$")>;
 377 def : InstRW<[WLat2, WLat2, FXa, GroupAlone], (instregex "ALC(G)?R$")>;
 378
 379 // Add with sign extension (16/32 -> 64)
 380 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, NormalGr],
 381              (instregex "AG(F|H)$")>;
 382 def : InstRW<[WLat2, WLat2, FXa, NormalGr], (instregex "AGFR$")>;
 383
 384 //===----------------------------------------------------------------------===//
 385 // Subtraction
 386 //===----------------------------------------------------------------------===//
 387
 388 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 389              (instregex "S(G|Y)?$")>;
 390 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, NormalGr],
 391              (instregex "SH(Y)?$")>;
 392 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SGR(K)?$")>;
 393 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLFI$")>;
 394 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 395              (instregex "SL(G|GF|Y)?$")>;
 396 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLGF(I|R)$")>;
 397 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLGR(K)?$")>;
 398 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLR(K)?$")>;
 399 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SR(K)?$")>;
 400 def : InstRW<[WLat1, FXa, NormalGr], (instregex "S(L)?HHHR$")>;
 401 def : InstRW<[WLat2, WLat2, FXa, NormalGr], (instregex "S(L)?HHLR$")>;
 402
 403 // Subtraction with borrow
 404 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, GroupAlone],
 405              (instregex "SLB(G)?$")>;
 406 def : InstRW<[WLat2, WLat2, FXa, GroupAlone], (instregex "SLB(G)?R$")>;
 407
 408 // Subtraction with sign extension (16/32 -> 64)
 409 def : InstRW<[WLat2LSU, WLat2LSU, RegReadAdv, FXa, LSU, NormalGr],
 410              (instregex "SG(F|H)$")>;
 411 def : InstRW<[WLat2, WLat2, FXa, NormalGr], (instregex "SGFR$")>;
 412
 413 //===----------------------------------------------------------------------===//
 414 // AND
 415 //===----------------------------------------------------------------------===//
 416
 417 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 418              (instregex "N(G|Y)?$")>;
 419 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NGR(K)?$")>;
 420 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NI(FMux|HMux|LMux)$")>;
 421 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "NI(Y)?$")>;
 422 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NIHF(64)?$")>;
 423 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NIHH(64)?$")>;
 424 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NIHL(64)?$")>;
 425 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NILF(64)?$")>;
 426 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NILH(64)?$")>;
 427 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NILL(64)?$")>;
 428 def : InstRW<[WLat1, FXa, NormalGr], (instregex "NR(K)?$")>;
 429 def : InstRW<[WLat3LSU, LSU2, FXb, Cracked], (instregex "NC$")>;
 430
 431 //===----------------------------------------------------------------------===//
 432 // OR
 433 //===----------------------------------------------------------------------===//
 434
 435 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 436              (instregex "O(G|Y)?$")>;
 437 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OGR(K)?$")>;
 438 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "OI(Y)?$")>;
 439 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OI(FMux|HMux|LMux)$")>;
 440 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OIHF(64)?$")>;
 441 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OIHH(64)?$")>;
 442 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OIHL(64)?$")>;
 443 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OILF(64)?$")>;
 444 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OILH(64)?$")>;
 445 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OILL(64)?$")>;
 446 def : InstRW<[WLat1, FXa, NormalGr], (instregex "OR(K)?$")>;
 447 def : InstRW<[WLat3LSU, LSU2, FXb, Cracked], (instregex "OC$")>;
 448
 449 //===----------------------------------------------------------------------===//
 450 // XOR
 451 //===----------------------------------------------------------------------===//
 452
 453 def : InstRW<[WLat1LSU, WLat1LSU, RegReadAdv, FXa, LSU, NormalGr],
 454              (instregex "X(G|Y)?$")>;
 455 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "XI(Y)?$")>;
 456 def : InstRW<[WLat1, FXa, NormalGr], (instregex "XIFMux$")>;
 457 def : InstRW<[WLat1, FXa, NormalGr], (instregex "XGR(K)?$")>;
 458 def : InstRW<[WLat1, FXa, NormalGr], (instregex "XIHF(64)?$")>;
 459 def : InstRW<[WLat1, FXa, NormalGr], (instregex "XILF(64)?$")>;
 460 def : InstRW<[WLat1, FXa, NormalGr], (instregex "XR(K)?$")>;
 461 def : InstRW<[WLat3LSU, LSU2, FXb, Cracked], (instregex "XC$")>;
 462
 463 //===----------------------------------------------------------------------===//
 464 // Multiplication
 465 //===----------------------------------------------------------------------===//
 466
 467 def : InstRW<[WLat5LSU, RegReadAdv, FXa, LSU, NormalGr],
 468              (instregex "MS(GF|Y)?$")>;
 469 def : InstRW<[WLat5, FXa, NormalGr], (instregex "MS(R|FI)$")>;
 470 def : InstRW<[WLat7LSU, RegReadAdv, FXa, LSU, NormalGr], (instregex "MSG$")>;
 471 def : InstRW<[WLat7, FXa, NormalGr], (instregex "MSGR$")>;
 472 def : InstRW<[WLat5, FXa, NormalGr], (instregex "MSGF(I|R)$")>;
 473 def : InstRW<[WLat8LSU, RegReadAdv, FXa2, LSU, GroupAlone], (instregex "MLG$")>;
 474 def : InstRW<[WLat8, FXa2, GroupAlone], (instregex "MLGR$")>;
 475 def : InstRW<[WLat4, FXa, NormalGr], (instregex "MGHI$")>;
 476 def : InstRW<[WLat4, FXa, NormalGr], (instregex "MHI$")>;
 477 def : InstRW<[WLat4LSU, RegReadAdv, FXa, LSU, NormalGr], (instregex "MH(Y)?$")>;
 478 def : InstRW<[WLat6, FXa2, GroupAlone], (instregex "M(L)?R$")>;
 479 def : InstRW<[WLat6LSU, RegReadAdv, FXa2, LSU, GroupAlone],
 480              (instregex "M(FY|L)?$")>;
 481 def : InstRW<[WLat8, RegReadAdv, FXa, LSU, NormalGr], (instregex "MGH$")>;
 482 def : InstRW<[WLat12, RegReadAdv, FXa2, LSU, GroupAlone], (instregex "MG$")>;
 483 def : InstRW<[WLat8, FXa2, GroupAlone], (instregex "MGRK$")>;
 484 def : InstRW<[WLat6LSU, WLat6LSU, RegReadAdv, FXa, LSU, NormalGr],
 485              (instregex "MSC$")>;
 486 def : InstRW<[WLat8LSU, WLat8LSU, RegReadAdv, FXa, LSU, NormalGr],
 487              (instregex "MSGC$")>;
 488 def : InstRW<[WLat6, WLat6, FXa, NormalGr], (instregex "MSRKC$")>;
 489 def : InstRW<[WLat8, WLat8, FXa, NormalGr], (instregex "MSGRKC$")>;
 490
 491 //===----------------------------------------------------------------------===//
 492 // Division and remainder
 493 //===----------------------------------------------------------------------===//
 494
 495 def : InstRW<[WLat20, FXa4, GroupAlone], (instregex "DR$")>;
 496 def : InstRW<[WLat30, RegReadAdv, FXa4, LSU, GroupAlone2], (instregex "D$")>;
 497 def : InstRW<[WLat30, FXa2, GroupAlone], (instregex "DSG(F)?R$")>;
 498 def : InstRW<[WLat30, RegReadAdv, FXa2, LSU, GroupAlone2],
 499              (instregex "DSG(F)?$")>;
 500 def : InstRW<[WLat20, FXa4, GroupAlone], (instregex "DLR$")>;
 501 def : InstRW<[WLat30, FXa4, GroupAlone], (instregex "DLGR$")>;
 502 def : InstRW<[WLat30, RegReadAdv, FXa4, LSU, GroupAlone2],
 503              (instregex "DL(G)?$")>;
 504
 505 //===----------------------------------------------------------------------===//
 506 // Shifts
 507 //===----------------------------------------------------------------------===//
 508
 509 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLL(G|K)?$")>;
 510 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SRL(G|K)?$")>;
 511 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SRA(G|K)?$")>;
 512 def : InstRW<[WLat1, FXa, NormalGr], (instregex "SLA(G|K)?$")>;
 513 def : InstRW<[WLat5LSU, WLat5LSU, FXa4, LSU, GroupAlone2],
 514              (instregex "S(L|R)D(A|L)$")>;
 515
 516 // Rotate
 517 def : InstRW<[WLat2LSU, FXa, LSU, NormalGr], (instregex "RLL(G)?$")>;
 518
 519 // Rotate and insert
 520 def : InstRW<[WLat1, FXa, NormalGr], (instregex "RISBG(N|32)?$")>;
 521 def : InstRW<[WLat1, FXa, NormalGr], (instregex "RISBH(G|H|L)$")>;
 522 def : InstRW<[WLat1, FXa, NormalGr], (instregex "RISBL(G|H|L)$")>;
 523 def : InstRW<[WLat1, FXa, NormalGr], (instregex "RISBMux$")>;
 524
 525 // Rotate and Select
 526 def : InstRW<[WLat2, WLat2, FXa2, Cracked], (instregex "R(N|O|X)SBG$")>;
 527
 528 //===----------------------------------------------------------------------===//
 529 // Comparison
 530 //===----------------------------------------------------------------------===//
 531
 532 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr],
 533              (instregex "C(G|Y|Mux)?$")>;
 534 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CRL$")>;
 535 def : InstRW<[WLat1, FXb, NormalGr], (instregex "C(F|H)I(Mux)?$")>;
 536 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CG(F|H)I$")>;
 537 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CG(HSI|RL)$")>;
 538 def : InstRW<[WLat1, FXb, NormalGr], (instregex "C(G)?R$")>;
 539 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CIH$")>;
 540 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CHF$")>;
 541 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CHSI$")>;
 542 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr],
 543              (instregex "CL(Y|Mux)?$")>;
 544 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLFHSI$")>;
 545 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CLFI(Mux)?$")>;
 546 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CLG$")>;
 547 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLG(HRL|HSI)$")>;
 548 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CLGF$")>;
 549 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLGFRL$")>;
 550 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CLGF(I|R)$")>;
 551 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CLGR$")>;
 552 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLGRL$")>;
 553 def : InstRW<[WLat1LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CLHF$")>;
 554 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLH(RL|HSI)$")>;
 555 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CLIH$")>;
 556 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLI(Y)?$")>;
 557 def : InstRW<[WLat1, FXb, NormalGr], (instregex "CLR$")>;
 558 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "CLRL$")>;
 559 def : InstRW<[WLat1, FXb, NormalGr], (instregex "C(L)?HHR$")>;
 560 def : InstRW<[WLat2, FXb, NormalGr], (instregex "C(L)?HLR$")>;
 561
 562 // Compare halfword
 563 def : InstRW<[WLat2LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CH(Y)?$")>;
 564 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "CHRL$")>;
 565 def : InstRW<[WLat2LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CGH$")>;
 566 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "CGHRL$")>;
 567 def : InstRW<[WLat2LSU, FXa, FXb, LSU, Cracked], (instregex "CHHSI$")>;
 568
 569 // Compare with sign extension (32 -> 64)
 570 def : InstRW<[WLat2LSU, RegReadAdv, FXb, LSU, NormalGr], (instregex "CGF$")>;
 571 def : InstRW<[WLat2LSU, FXb, LSU, NormalGr], (instregex "CGFRL$")>;
 572 def : InstRW<[WLat2, FXb, NormalGr], (instregex "CGFR$")>;
 573
 574 // Compare logical character
 575 def : InstRW<[WLat6, FXb, LSU2, Cracked], (instregex "CLC$")>;
 576 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "CLCL(E|U)?$")>;
 577 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "CLST$")>;
 578
 579 // Test under mask
 580 def : InstRW<[WLat1LSU, FXb, LSU, NormalGr], (instregex "TM(Y)?$")>;
 581 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TM(H|L)Mux$")>;
 582 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TMHH(64)?$")>;
 583 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TMHL(64)?$")>;
 584 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TMLH(64)?$")>;
 585 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TMLL(64)?$")>;
 586
 587 // Compare logical characters under mask
 588 def : InstRW<[WLat2LSU, RegReadAdv, FXb, LSU, NormalGr],
 589              (instregex "CLM(H|Y)?$")>;
 590
 591 //===----------------------------------------------------------------------===//
 592 // Prefetch and execution hint
 593 //===----------------------------------------------------------------------===//
 594
 595 def : InstRW<[WLat1, LSU, NormalGr], (instregex "PFD(RL)?$")>;
 596 def : InstRW<[WLat1, FXb, NormalGr], (instregex "BPP$")>;
 597 def : InstRW<[FXb, EndGroup], (instregex "BPRP$")>;
 598 def : InstRW<[WLat1, FXb, NormalGr], (instregex "NIAI$")>;
 599
 600 //===----------------------------------------------------------------------===//
 601 // Atomic operations
 602 //===----------------------------------------------------------------------===//
 603
 604 def : InstRW<[WLat1, FXb, EndGroup], (instregex "Serialize$")>;
 605
 606 def : InstRW<[WLat2LSU, WLat2LSU, FXb, LSU, NormalGr], (instregex "LAA(G)?$")>;
 607 def : InstRW<[WLat2LSU, WLat2LSU, FXb, LSU, NormalGr], (instregex "LAAL(G)?$")>;
 608 def : InstRW<[WLat2LSU, WLat2LSU, FXb, LSU, NormalGr], (instregex "LAN(G)?$")>;
 609 def : InstRW<[WLat2LSU, WLat2LSU, FXb, LSU, NormalGr], (instregex "LAO(G)?$")>;
 610 def : InstRW<[WLat2LSU, WLat2LSU, FXb, LSU, NormalGr], (instregex "LAX(G)?$")>;
 611
 612 // Test and set
 613 def : InstRW<[WLat2LSU, FXb, LSU, EndGroup], (instregex "TS$")>;
 614
 615 // Compare and swap
 616 def : InstRW<[WLat3LSU, WLat3LSU, FXa, FXb, LSU, GroupAlone],
 617              (instregex "CS(G|Y)?$")>;
 618
 619 // Compare double and swap
 620 def : InstRW<[WLat6LSU, WLat6LSU, FXa3, FXb2, LSU, GroupAlone2],
 621              (instregex "CDS(Y)?$")>;
 622 def : InstRW<[WLat15, WLat15, FXa2, FXb4, LSU3,
 623               GroupAlone], (instregex "CDSG$")>;
 624
 625 // Compare and swap and store
 626 def : InstRW<[WLat30, MCD], (instregex "CSST$")>;
 627
 628 // Perform locked operation
 629 def : InstRW<[WLat30, MCD], (instregex "PLO$")>;
 630
 631 // Load/store pair from/to quadword
 632 def : InstRW<[WLat4LSU, LSU2, GroupAlone], (instregex "LPQ$")>;
 633 def : InstRW<[WLat1, FXb2, LSU, GroupAlone], (instregex "STPQ$")>;
 634
 635 // Load pair disjoint
 636 def : InstRW<[WLat1LSU, WLat1LSU, LSU2, GroupAlone], (instregex "LPD(G)?$")>;
 637
 638 //===----------------------------------------------------------------------===//
 639 // Translate and convert
 640 //===----------------------------------------------------------------------===//
 641
 642 def : InstRW<[WLat1, LSU5, GroupAlone], (instregex "TR$")>;
 643 def : InstRW<[WLat30, WLat30, WLat30, FXa3, LSU2, GroupAlone2],
 644              (instregex "TRT$")>;
 645 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "TRTR$")>;
 646 def : InstRW<[WLat30, WLat30, MCD], (instregex "TRE$")>;
 647 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "TRT(R)?E(Opt)?$")>;
 648 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "TR(T|O)(T|O)(Opt)?$")>;
 649 def : InstRW<[WLat30, WLat30, WLat30, MCD],
 650              (instregex "CU(12|14|21|24|41|42)(Opt)?$")>;
 651 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "(CUUTF|CUTFU)(Opt)?$")>;
 652
 653 //===----------------------------------------------------------------------===//
 654 // Message-security assist
 655 //===----------------------------------------------------------------------===//
 656
 657 def : InstRW<[WLat30, WLat30, WLat30, WLat30, MCD],
 658              (instregex "KM(C|F|O|CTR|A)?$")>;
 659 def : InstRW<[WLat30, WLat30, WLat30, MCD],
 660              (instregex "(KIMD|KLMD|KMAC)$")>;
 661 def : InstRW<[WLat30, WLat30, WLat30, MCD],
 662              (instregex "(PCC|PPNO|PRNO)$")>;
 663
 664 //===----------------------------------------------------------------------===//
 665 // Guarded storage
 666 //===----------------------------------------------------------------------===//
 667
 668 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LGG$")>;
 669 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LLGFSG$")>;
 670 def : InstRW<[WLat30, MCD], (instregex "(L|ST)GSC$")>;
 671
 672 //===----------------------------------------------------------------------===//
 673 // Decimal arithmetic
 674 //===----------------------------------------------------------------------===//
 675
 676 def : InstRW<[WLat30, RegReadAdv, FXb, VecDF2, LSU2, GroupAlone2],
 677              (instregex "CVBG$")>;
 678 def : InstRW<[WLat30, RegReadAdv, FXb, VecDF, LSU, GroupAlone2],
 679              (instregex "CVB(Y)?$")>;
 680 def : InstRW<[WLat1, FXb3, VecDF4, LSU, GroupAlone3], (instregex "CVDG$")>;
 681 def : InstRW<[WLat1, FXb2, VecDF, LSU, GroupAlone2], (instregex "CVD(Y)?$")>;
 682 def : InstRW<[WLat1, LSU5, GroupAlone], (instregex "MV(N|O|Z)$")>;
 683 def : InstRW<[WLat1, LSU5, GroupAlone], (instregex "(PACK|PKA|PKU)$")>;
 684 def : InstRW<[WLat12, LSU5, GroupAlone], (instregex "UNPK(A|U)$")>;
 685 def : InstRW<[WLat1, FXb, LSU2, Cracked], (instregex "UNPK$")>;
 686
 687 def : InstRW<[WLat5LSU, FXb, VecDFX, LSU3, GroupAlone],
 688              (instregex "(A|S|ZA)P$")>;
 689 def : InstRW<[WLat1, FXb, VecDFX4, LSU3, GroupAlone], (instregex "(M|D)P$")>;
 690 def : InstRW<[WLat15, FXb, VecDFX2, LSU2, GroupAlone], (instregex "SRP$")>;
 691 def : InstRW<[WLat8, VecDFX, LSU, LSU, GroupAlone], (instregex "CP$")>;
 692 def : InstRW<[WLat3LSU, VecDFX, LSU, Cracked], (instregex "TP$")>;
 693 def : InstRW<[WLat30, MCD], (instregex "ED(MK)?$")>;
 694
 695 //===----------------------------------------------------------------------===//
 696 // Access registers
 697 //===----------------------------------------------------------------------===//
 698
 699 // Extract/set/copy access register
 700 def : InstRW<[WLat3, LSU, NormalGr], (instregex "(EAR|SAR|CPYA)$")>;
 701
 702 // Load address extended
 703 def : InstRW<[WLat5, LSU, FXa, Cracked], (instregex "LAE(Y)?$")>;
 704
 705 // Load/store access multiple (not modeled precisely)
 706 def : InstRW<[WLat20, WLat20, LSU5, GroupAlone], (instregex "LAM(Y)?$")>;
 707 def : InstRW<[WLat1, LSU5, GroupAlone], (instregex "STAM(Y)?$")>;
 708
 709 //===----------------------------------------------------------------------===//
 710 // Program mask and addressing mode
 711 //===----------------------------------------------------------------------===//
 712
 713 // Insert Program Mask
 714 def : InstRW<[WLat3, FXa, EndGroup], (instregex "IPM$")>;
 715
 716 // Set Program Mask
 717 def : InstRW<[WLat3, LSU, EndGroup], (instregex "SPM$")>;
 718
 719 // Branch and link
 720 def : InstRW<[WLat1, FXa2, FXb, GroupAlone], (instregex "BAL(R)?$")>;
 721
 722 // Test addressing mode
 723 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TAM$")>;
 724
 725 // Set addressing mode
 726 def : InstRW<[WLat1, FXb, EndGroup], (instregex "SAM(24|31|64)$")>;
 727
 728 // Branch (and save) and set mode.
 729 def : InstRW<[WLat1, FXa, FXb, GroupAlone], (instregex "BSM$")>;
 730 def : InstRW<[WLat1, FXa2, FXb, GroupAlone], (instregex "BASSM$")>;
 731
 732 //===----------------------------------------------------------------------===//
 733 // Transactional execution
 734 //===----------------------------------------------------------------------===//
 735
 736 // Transaction begin
 737 def : InstRW<[WLat9, LSU2, FXb5, GroupAlone2], (instregex "TBEGIN(C)?$")>;
 738
 739 // Transaction end
 740 def : InstRW<[WLat1, FXb, GroupAlone], (instregex "TEND$")>;
 741
 742 // Transaction abort
 743 def : InstRW<[WLat30, MCD], (instregex "TABORT$")>;
 744
 745 // Extract Transaction Nesting Depth
 746 def : InstRW<[WLat1, FXa, NormalGr], (instregex "ETND$")>;
 747
 748 // Nontransactional store
 749 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "NTSTG$")>;
 750
 751 //===----------------------------------------------------------------------===//
 752 // Processor assist
 753 //===----------------------------------------------------------------------===//
 754
 755 def : InstRW<[WLat1, FXb, GroupAlone], (instregex "PPA$")>;
 756
 757 //===----------------------------------------------------------------------===//
 758 // Miscellaneous Instructions.
 759 //===----------------------------------------------------------------------===//
 760
 761 // Find leftmost one
 762 def : InstRW<[WLat5, WLat5, FXa2, GroupAlone], (instregex "FLOGR$")>;
 763
 764 // Population count
 765 def : InstRW<[WLat3, WLat3, FXa, NormalGr], (instregex "POPCNT$")>;
 766
 767 // String instructions
 768 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "SRST(U)?$")>;
 769 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "CUSE$")>;
 770
 771 // Various complex instructions
 772 def : InstRW<[WLat30, WLat30, WLat30, WLat30, MCD], (instregex "CFC$")>;
 773 def : InstRW<[WLat30, WLat30, WLat30, WLat30, WLat30, WLat30, MCD],
 774              (instregex "UPT$")>;
 775 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "CKSM$")>;
 776 def : InstRW<[WLat30, WLat30, WLat30, WLat30, MCD], (instregex "CMPSC$")>;
 777
 778 // Execute
 779 def : InstRW<[WLat1, FXb, GroupAlone], (instregex "EX(RL)?$")>;
 780
 781 //===----------------------------------------------------------------------===//
 782 // .insn directive instructions
 783 //===----------------------------------------------------------------------===//
 784
 785 // An "empty" sched-class will be assigned instead of the "invalid sched-class".
 786 // getNumDecoderSlots() will then return 1 instead of 0.
 787 def : InstRW<[], (instregex "Insn.*")>;
 788
 789
 790 // ----------------------------- Floating point ----------------------------- //
 791
 792 //===----------------------------------------------------------------------===//
 793 // FP: Move instructions
 794 //===----------------------------------------------------------------------===//
 795
 796 // Load zero
 797 def : InstRW<[WLat1, FXb, NormalGr], (instregex "LZ(DR|ER)$")>;
 798 def : InstRW<[WLat2, FXb2, Cracked], (instregex "LZXR$")>;
 799
 800 // Load
 801 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "LER$")>;
 802 def : InstRW<[WLat1, FXb, NormalGr], (instregex "LD(R|R32|GR)$")>;
 803 def : InstRW<[WLat3, FXb, NormalGr], (instregex "LGDR$")>;
 804 def : InstRW<[WLat2, FXb2, GroupAlone], (instregex "LXR$")>;
 805
 806 // Load and Test
 807 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "LT(E|D)BR$")>;
 808 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "LT(E|D)BRCompare$")>;
 809 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone],
 810              (instregex "LTXBR(Compare)?$")>;
 811
 812 // Copy sign
 813 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "CPSDR(d|s)(d|s)$")>;
 814
 815 //===----------------------------------------------------------------------===//
 816 // FP: Load instructions
 817 //===----------------------------------------------------------------------===//
 818
 819 def : InstRW<[WLat2LSU, VecXsPm, LSU, NormalGr], (instregex "LE(Y)?$")>;
 820 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LD(Y|E32)?$")>;
 821 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LX$")>;
 822
 823 //===----------------------------------------------------------------------===//
 824 // FP: Store instructions
 825 //===----------------------------------------------------------------------===//
 826
 827 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "ST(E|D)(Y)?$")>;
 828 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "STX$")>;
 829
 830 //===----------------------------------------------------------------------===//
 831 // FP: Conversion instructions
 832 //===----------------------------------------------------------------------===//
 833
 834 // Load rounded
 835 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "LEDBR(A)?$")>;
 836 def : InstRW<[WLat9, VecDF2, NormalGr], (instregex "L(E|D)XBR(A)?$")>;
 837
 838 // Load lengthened
 839 def : InstRW<[WLat7LSU, VecBF, LSU, NormalGr], (instregex "LDEB$")>;
 840 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "LDEBR$")>;
 841 def : InstRW<[WLat8LSU, VecBF4, LSU, GroupAlone], (instregex "LX(E|D)B$")>;
 842 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "LX(E|D)BR$")>;
 843
 844 // Convert from fixed / logical
 845 def : InstRW<[WLat8, FXb, VecBF, Cracked], (instregex "C(E|D)(F|G)BR(A)?$")>;
 846 def : InstRW<[WLat11, FXb, VecDF4, GroupAlone2], (instregex "CX(F|G)BR(A)?$")>;
 847 def : InstRW<[WLat8, FXb, VecBF, Cracked], (instregex "C(E|D)L(F|G)BR$")>;
 848 def : InstRW<[WLat11, FXb, VecDF4, GroupAlone2], (instregex "CXL(F|G)BR$")>;
 849
 850 // Convert to fixed / logical
 851 def : InstRW<[WLat10, WLat10, FXb, VecBF, Cracked],
 852              (instregex "C(F|G)(E|D)BR(A)?$")>;
 853 def : InstRW<[WLat12, WLat12, FXb, VecDF2, Cracked],
 854              (instregex "C(F|G)XBR(A)?$")>;
 855 def : InstRW<[WLat10, WLat10, FXb, VecBF, GroupAlone], (instregex "CLFEBR$")>;
 856 def : InstRW<[WLat10, WLat10, FXb, VecBF, Cracked], (instregex "CLFDBR$")>;
 857 def : InstRW<[WLat10, WLat10, FXb, VecBF, Cracked], (instregex "CLG(E|D)BR$")>;
 858 def : InstRW<[WLat12, WLat12, FXb, VecDF2, Cracked], (instregex "CL(F|G)XBR$")>;
 859
 860 //===----------------------------------------------------------------------===//
 861 // FP: Unary arithmetic
 862 //===----------------------------------------------------------------------===//
 863
 864 // Load Complement / Negative / Positive
 865 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "L(C|N|P)(E|D)BR$")>;
 866 def : InstRW<[WLat1, FXb, NormalGr], (instregex "L(C|N|P)DFR(_32)?$")>;
 867 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "L(C|N|P)XBR$")>;
 868
 869 // Square root
 870 def : InstRW<[WLat30, VecFPd, LSU, NormalGr], (instregex "SQ(E|D)B$")>;
 871 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "SQ(E|D)BR$")>;
 872 def : InstRW<[WLat30, VecFPd, GroupAlone], (instregex "SQXBR$")>;
 873
 874 // Load FP integer
 875 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "FI(E|D)BR(A)?$")>;
 876 def : InstRW<[WLat10, VecDF4, GroupAlone], (instregex "FIXBR(A)?$")>;
 877
 878 //===----------------------------------------------------------------------===//
 879 // FP: Binary arithmetic
 880 //===----------------------------------------------------------------------===//
 881
 882 // Addition
 883 def : InstRW<[WLat7LSU, WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
 884              (instregex "A(E|D)B$")>;
 885 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "A(E|D)BR$")>;
 886 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "AXBR$")>;
 887
 888 // Subtraction
 889 def : InstRW<[WLat7LSU, WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
 890              (instregex "S(E|D)B$")>;
 891 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "S(E|D)BR$")>;
 892 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "SXBR$")>;
 893
 894 // Multiply
 895 def : InstRW<[WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
 896              (instregex "M(D|DE|EE)B$")>;
 897 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "M(D|DE|EE)BR$")>;
 898 def : InstRW<[WLat8LSU, RegReadAdv, VecBF4, LSU, GroupAlone],
 899              (instregex "MXDB$")>;
 900 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "MXDBR$")>;
 901 def : InstRW<[WLat20, VecDF4, GroupAlone], (instregex "MXBR$")>;
 902
 903 // Multiply and add / subtract
 904 def : InstRW<[WLat7LSU, RegReadAdv, RegReadAdv, VecBF2, LSU, GroupAlone],
 905              (instregex "M(A|S)EB$")>;
 906 def : InstRW<[WLat7, VecBF, GroupAlone], (instregex "M(A|S)EBR$")>;
 907 def : InstRW<[WLat7LSU, RegReadAdv, RegReadAdv, VecBF2, LSU, GroupAlone],
 908              (instregex "M(A|S)DB$")>;
 909 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "M(A|S)DBR$")>;
 910
 911 // Division
 912 def : InstRW<[WLat30, RegReadAdv, VecFPd, LSU, NormalGr],
 913              (instregex "D(E|D)B$")>;
 914 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "D(E|D)BR$")>;
 915 def : InstRW<[WLat30, VecFPd, GroupAlone], (instregex "DXBR$")>;
 916
 917 // Divide to integer
 918 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "DI(E|D)BR$")>;
 919
 920 //===----------------------------------------------------------------------===//
 921 // FP: Comparisons
 922 //===----------------------------------------------------------------------===//
 923
 924 // Compare
 925 def : InstRW<[WLat3LSU, RegReadAdv, VecXsPm, LSU, NormalGr],
 926              (instregex "(K|C)(E|D)B$")>;
 927 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "(K|C)(E|D)BR$")>;
 928 def : InstRW<[WLat9, VecDF2, GroupAlone], (instregex "(K|C)XBR$")>;
 929
 930 // Test Data Class
 931 def : InstRW<[WLat5, LSU, VecXsPm, NormalGr], (instregex "TC(E|D)B$")>;
 932 def : InstRW<[WLat10, LSU2, VecDF4, GroupAlone], (instregex "TCXB$")>;
 933
 934 //===----------------------------------------------------------------------===//
 935 // FP: Floating-point control register instructions
 936 //===----------------------------------------------------------------------===//
 937
 938 def : InstRW<[WLat4, FXa, LSU, GroupAlone], (instregex "EFPC$")>;
 939 def : InstRW<[WLat1, FXb, LSU, GroupAlone], (instregex "STFPC$")>;
 940 def : InstRW<[WLat3, LSU, GroupAlone], (instregex "SFPC$")>;
 941 def : InstRW<[WLat3LSU, LSU2, GroupAlone], (instregex "LFPC$")>;
 942 def : InstRW<[WLat30, MCD], (instregex "SFASR$")>;
 943 def : InstRW<[WLat30, MCD], (instregex "LFAS$")>;
 944 def : InstRW<[WLat3, FXb, GroupAlone], (instregex "SRNM(B|T)?$")>;
 945
 946
 947 // --------------------- Hexadecimal floating point ------------------------- //
 948
 949 //===----------------------------------------------------------------------===//
 950 // HFP: Move instructions
 951 //===----------------------------------------------------------------------===//
 952
 953 // Load and Test
 954 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "LT(E|D)R$")>;
 955 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "LTXR$")>;
 956
 957 //===----------------------------------------------------------------------===//
 958 // HFP: Conversion instructions
 959 //===----------------------------------------------------------------------===//
 960
 961 // Load rounded
 962 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "(LEDR|LRER)$")>;
 963 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "LEXR$")>;
 964 def : InstRW<[WLat9, VecDF2, NormalGr], (instregex "(LDXR|LRDR)$")>;
 965
 966 // Load lengthened
 967 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "LDE$")>;
 968 def : InstRW<[WLat1, FXb, NormalGr], (instregex "LDER$")>;
 969 def : InstRW<[WLat8LSU, VecBF4, LSU, GroupAlone], (instregex "LX(E|D)$")>;
 970 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "LX(E|D)R$")>;
 971
 972 // Convert from fixed
 973 def : InstRW<[WLat8, FXb, VecBF, Cracked], (instregex "C(E|D)(F|G)R$")>;
 974 def : InstRW<[WLat11, FXb, VecDF4, GroupAlone2], (instregex "CX(F|G)R$")>;
 975
 976 // Convert to fixed
 977 def : InstRW<[WLat10, WLat10, FXb, VecBF, Cracked], (instregex "C(F|G)(E|D)R$")>;
 978 def : InstRW<[WLat12, WLat12, FXb, VecDF2, Cracked], (instregex "C(F|G)XR$")>;
 979
 980 // Convert BFP to HFP / HFP to BFP.
 981 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "THD(E)?R$")>;
 982 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "TB(E)?DR$")>;
 983
 984 //===----------------------------------------------------------------------===//
 985 // HFP: Unary arithmetic
 986 //===----------------------------------------------------------------------===//
 987
 988 // Load Complement / Negative / Positive
 989 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "L(C|N|P)(E|D)R$")>;
 990 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "L(C|N|P)XR$")>;
 991
 992 // Halve
 993 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "H(E|D)R$")>;
 994
 995 // Square root
 996 def : InstRW<[WLat30, VecFPd, LSU, NormalGr], (instregex "SQ(E|D)$")>;
 997 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "SQ(E|D)R$")>;
 998 def : InstRW<[WLat30, VecFPd, GroupAlone], (instregex "SQXR$")>;
 999
1000 // Load FP integer
1001 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "FI(E|D)R$")>;
1002 def : InstRW<[WLat10, VecDF4, GroupAlone], (instregex "FIXR$")>;
1003
1004 //===----------------------------------------------------------------------===//
1005 // HFP: Binary arithmetic
1006 //===----------------------------------------------------------------------===//
1007
1008 // Addition
1009 def : InstRW<[WLat7LSU, WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
1010              (instregex "A(E|D|U|W)$")>;
1011 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "A(E|D|U|W)R$")>;
1012 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "AXR$")>;
1013
1014 // Subtraction
1015 def : InstRW<[WLat7LSU, WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
1016              (instregex "S(E|D|U|W)$")>;
1017 def : InstRW<[WLat7, WLat7, VecBF, NormalGr], (instregex "S(E|D|U|W)R$")>;
1018 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "SXR$")>;
1019
1020 // Multiply
1021 def : InstRW<[WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
1022              (instregex "M(D|DE|E|EE)$")>;
1023 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "M(D|DE|E|EE)R$")>;
1024 def : InstRW<[WLat8LSU, RegReadAdv, VecBF4, LSU, GroupAlone],
1025              (instregex "MXD$")>;
1026 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "MXDR$")>;
1027 def : InstRW<[WLat30, VecDF4, GroupAlone], (instregex "MXR$")>;
1028 def : InstRW<[WLat8LSU, RegReadAdv, VecBF4, LSU, GroupAlone], (instregex "MY$")>;
1029 def : InstRW<[WLat7LSU, RegReadAdv, VecBF2, LSU, GroupAlone],
1030              (instregex "MY(H|L)$")>;
1031 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "MYR$")>;
1032 def : InstRW<[WLat7, VecBF, GroupAlone], (instregex "MY(H|L)R$")>;
1033
1034 // Multiply and add / subtract
1035 def : InstRW<[WLat7LSU, RegReadAdv, RegReadAdv, VecBF2, LSU, GroupAlone],
1036              (instregex "M(A|S)(E|D)$")>;
1037 def : InstRW<[WLat7, VecBF, GroupAlone], (instregex "M(A|S)(E|D)R$")>;
1038 def : InstRW<[WLat8LSU, RegReadAdv, RegReadAdv, VecBF4, LSU, GroupAlone],
1039              (instregex "MAY$")>;
1040 def : InstRW<[WLat7LSU, RegReadAdv, RegReadAdv, VecBF2, LSU, GroupAlone],
1041              (instregex "MAY(H|L)$")>;
1042 def : InstRW<[WLat8, VecBF4, GroupAlone], (instregex "MAYR$")>;
1043 def : InstRW<[WLat7, VecBF, GroupAlone], (instregex "MAY(H|L)R$")>;
1044
1045 // Division
1046 def : InstRW<[WLat30, RegReadAdv, VecFPd, LSU, NormalGr], (instregex "D(E|D)$")>;
1047 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "D(E|D)R$")>;
1048 def : InstRW<[WLat30, VecFPd, GroupAlone], (instregex "DXR$")>;
1049
1050 //===----------------------------------------------------------------------===//
1051 // HFP: Comparisons
1052 //===----------------------------------------------------------------------===//
1053
1054 // Compare
1055 def : InstRW<[WLat7LSU, RegReadAdv, VecBF, LSU, NormalGr],
1056              (instregex "C(E|D)$")>;
1057 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "C(E|D)R$")>;
1058 def : InstRW<[WLat10, VecDF2, GroupAlone], (instregex "CXR$")>;
1059
1060
1061 // ------------------------ Decimal floating point -------------------------- //
1062
1063 //===----------------------------------------------------------------------===//
1064 // DFP: Move instructions
1065 //===----------------------------------------------------------------------===//
1066
1067 // Load and Test
1068 def : InstRW<[WLat8, WLat8, VecDF, NormalGr], (instregex "LTDTR$")>;
1069 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "LTXTR$")>;
1070
1071 //===----------------------------------------------------------------------===//
1072 // DFP: Conversion instructions
1073 //===----------------------------------------------------------------------===//
1074
1075 // Load rounded
1076 def : InstRW<[WLat15, VecDF, NormalGr], (instregex "LEDTR$")>;
1077 def : InstRW<[WLat15, VecDF2, NormalGr], (instregex "LDXTR$")>;
1078
1079 // Load lengthened
1080 def : InstRW<[WLat8, VecDF, NormalGr], (instregex "LDETR$")>;
1081 def : InstRW<[WLat10, VecDF4, GroupAlone], (instregex "LXDTR$")>;
1082
1083 // Convert from fixed / logical
1084 def : InstRW<[WLat30, FXb, VecDF, Cracked], (instregex "CD(F|G)TR(A)?$")>;
1085 def : InstRW<[WLat30, FXb, VecDF4, GroupAlone2], (instregex "CX(F|G)TR(A)?$")>;
1086 def : InstRW<[WLat30, FXb, VecDF, Cracked], (instregex "CDL(F|G)TR$")>;
1087 def : InstRW<[WLat30, FXb, VecDF4, GroupAlone2], (instregex "CXL(F|G)TR$")>;
1088
1089 // Convert to fixed / logical
1090 def : InstRW<[WLat30, WLat30, FXb, VecDF, Cracked],
1091              (instregex "C(F|G)DTR(A)?$")>;
1092 def : InstRW<[WLat30, WLat30, FXb, VecDF2, Cracked],
1093              (instregex "C(F|G)XTR(A)?$")>;
1094 def : InstRW<[WLat30, WLat30, FXb, VecDF, Cracked], (instregex "CL(F|G)DTR$")>;
1095 def : InstRW<[WLat30, WLat30, FXb, VecDF2, Cracked], (instregex "CL(F|G)XTR$")>;
1096
1097 // Convert from / to signed / unsigned packed
1098 def : InstRW<[WLat9, FXb, VecDF, Cracked], (instregex "CD(S|U)TR$")>;
1099 def : InstRW<[WLat12, FXb2, VecDF4, GroupAlone2], (instregex "CX(S|U)TR$")>;
1100 def : InstRW<[WLat11, FXb, VecDF, Cracked], (instregex "C(S|U)DTR$")>;
1101 def : InstRW<[WLat15, FXb2, VecDF4, GroupAlone2], (instregex "C(S|U)XTR$")>;
1102
1103 // Convert from / to zoned
1104 def : InstRW<[WLat8LSU, LSU, VecDF, Cracked], (instregex "CDZT$")>;
1105 def : InstRW<[WLat16LSU, LSU2, VecDF4, GroupAlone3], (instregex "CXZT$")>;
1106 def : InstRW<[WLat1, FXb, LSU, VecDF, Cracked], (instregex "CZDT$")>;
1107 def : InstRW<[WLat1, FXb, LSU, VecDF2, GroupAlone], (instregex "CZXT$")>;
1108
1109 // Convert from / to packed
1110 def : InstRW<[WLat8LSU, LSU, VecDF, Cracked], (instregex "CDPT$")>;
1111 def : InstRW<[WLat16LSU, LSU2, VecDF4, GroupAlone3], (instregex "CXPT$")>;
1112 def : InstRW<[WLat1, FXb, LSU, VecDF, Cracked], (instregex "CPDT$")>;
1113 def : InstRW<[WLat1, FXb, LSU, VecDF2, GroupAlone], (instregex "CPXT$")>;
1114
1115 // Perform floating-point operation
1116 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "PFPO$")>;
1117
1118 //===----------------------------------------------------------------------===//
1119 // DFP: Unary arithmetic
1120 //===----------------------------------------------------------------------===//
1121
1122 // Load FP integer
1123 def : InstRW<[WLat8, VecDF, NormalGr], (instregex "FIDTR$")>;
1124 def : InstRW<[WLat10, VecDF4, GroupAlone], (instregex "FIXTR$")>;
1125
1126 // Extract biased exponent
1127 def : InstRW<[WLat11, FXb, VecDF, Cracked], (instregex "EEDTR$")>;
1128 def : InstRW<[WLat11, FXb, VecDF, Cracked], (instregex "EEXTR$")>;
1129
1130 // Extract significance
1131 def : InstRW<[WLat11, FXb, VecDF, Cracked], (instregex "ESDTR$")>;
1132 def : InstRW<[WLat12, FXb, VecDF2, Cracked], (instregex "ESXTR$")>;
1133
1134 //===----------------------------------------------------------------------===//
1135 // DFP: Binary arithmetic
1136 //===----------------------------------------------------------------------===//
1137
1138 // Addition
1139 def : InstRW<[WLat8, WLat8, VecDF, NormalGr], (instregex "ADTR(A)?$")>;
1140 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "AXTR(A)?$")>;
1141
1142 // Subtraction
1143 def : InstRW<[WLat8, WLat8, VecDF, NormalGr], (instregex "SDTR(A)?$")>;
1144 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "SXTR(A)?$")>;
1145
1146 // Multiply
1147 def : InstRW<[WLat30, VecDF, NormalGr], (instregex "MDTR(A)?$")>;
1148 def : InstRW<[WLat30, VecDF4, GroupAlone], (instregex "MXTR(A)?$")>;
1149
1150 // Division
1151 def : InstRW<[WLat30, VecDF, NormalGr], (instregex "DDTR(A)?$")>;
1152 def : InstRW<[WLat30, VecDF4, GroupAlone], (instregex "DXTR(A)?$")>;
1153
1154 // Quantize
1155 def : InstRW<[WLat8, WLat8, VecDF, NormalGr], (instregex "QADTR$")>;
1156 def : InstRW<[WLat10, WLat10, VecDF4, GroupAlone], (instregex "QAXTR$")>;
1157
1158 // Reround
1159 def : InstRW<[WLat9, WLat9, FXb, VecDF, Cracked], (instregex "RRDTR$")>;
1160 def : InstRW<[WLat11, WLat11, FXb, VecDF4, GroupAlone2], (instregex "RRXTR$")>;
1161
1162 // Shift significand left/right
1163 def : InstRW<[WLat11LSU, LSU, VecDF, GroupAlone], (instregex "S(L|R)DT$")>;
1164 def : InstRW<[WLat11LSU, LSU, VecDF4, GroupAlone], (instregex "S(L|R)XT$")>;
1165
1166 // Insert biased exponent
1167 def : InstRW<[WLat9, FXb, VecDF, Cracked], (instregex "IEDTR$")>;
1168 def : InstRW<[WLat11, FXb, VecDF4, GroupAlone2], (instregex "IEXTR$")>;
1169
1170 //===----------------------------------------------------------------------===//
1171 // DFP: Comparisons
1172 //===----------------------------------------------------------------------===//
1173
1174 // Compare
1175 def : InstRW<[WLat8, VecDF, NormalGr], (instregex "(K|C)DTR$")>;
1176 def : InstRW<[WLat9, VecDF2, GroupAlone], (instregex "(K|C)XTR$")>;
1177
1178 // Compare biased exponent
1179 def : InstRW<[WLat8, VecDF, NormalGr], (instregex "CEDTR$")>;
1180 def : InstRW<[WLat8, VecDF, NormalGr], (instregex "CEXTR$")>;
1181
1182 // Test Data Class/Group
1183 def : InstRW<[WLat15, LSU, VecDF, NormalGr], (instregex "TD(C|G)(E|D)T$")>;
1184 def : InstRW<[WLat15, LSU, VecDF2, GroupAlone], (instregex "TD(C|G)XT$")>;
1185
1186
1187 // --------------------------------- Vector --------------------------------- //
1188
1189 //===----------------------------------------------------------------------===//
1190 // Vector: Move instructions
1191 //===----------------------------------------------------------------------===//
1192
1193 def : InstRW<[WLat1, FXb, NormalGr], (instregex "VLR(32|64)?$")>;
1194 def : InstRW<[WLat3, FXb, NormalGr], (instregex "VLGV(B|F|G|H)?$")>;
1195 def : InstRW<[WLat1, FXb, NormalGr], (instregex "VLVG(B|F|G|H)?$")>;
1196 def : InstRW<[WLat3, FXb, NormalGr], (instregex "VLVGP(32)?$")>;
1197
1198 //===----------------------------------------------------------------------===//
1199 // Vector: Immediate instructions
1200 //===----------------------------------------------------------------------===//
1201
1202 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VZERO$")>;
1203 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VONE$")>;
1204 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VGBM$")>;
1205 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VGM(B|F|G|H)?$")>;
1206 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VREPI(B|F|G|H)?$")>;
1207 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VLEI(B|F|G|H)$")>;
1208
1209 //===----------------------------------------------------------------------===//
1210 // Vector: Loads
1211 //===----------------------------------------------------------------------===//
1212
1213 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VL(BB)?$")>;
1214 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VLL$")>;
1215 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VL(32|64)$")>;
1216 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VLLEZ(B|F|G|H|LF)?$")>;
1217 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VLREP(B|F|G|H)?$")>;
1218 def : InstRW<[WLat2LSU, RegReadAdv, VecXsPm, LSU, NormalGr],
1219              (instregex "VLE(B|F|G|H)$")>;
1220 def : InstRW<[WLat5LSU, RegReadAdv, FXb, LSU, VecXsPm, Cracked],
1221              (instregex "VGE(F|G)$")>;
1222 def : InstRW<[WLat4LSU, WLat4LSU, LSU5, GroupAlone], (instregex "VLM$")>;
1223 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "VLRL(R)?$")>;
1224
1225 //===----------------------------------------------------------------------===//
1226 // Vector: Stores
1227 //===----------------------------------------------------------------------===//
1228
1229 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "VST(L|32|64)?$")>;
1230 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "VSTE(F|G)$")>;
1231 def : InstRW<[WLat1, FXb, LSU, VecXsPm, Cracked], (instregex "VSTE(B|H)$")>;
1232 def : InstRW<[WLat1, LSU2, FXb3, GroupAlone], (instregex "VSTM$")>;
1233 def : InstRW<[WLat1, FXb2, LSU, Cracked], (instregex "VSCE(F|G)$")>;
1234 def : InstRW<[WLat1, FXb, LSU, NormalGr], (instregex "VSTRL(R)?$")>;
1235
1236 //===----------------------------------------------------------------------===//
1237 // Vector: Selects and permutes
1238 //===----------------------------------------------------------------------===//
1239
1240 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMRH(B|F|G|H)?$")>;
1241 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMRL(B|F|G|H)?$")>;
1242 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPERM$")>;
1243 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPDI$")>;
1244 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VBPERM$")>;
1245 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VREP(B|F|G|H)?$")>;
1246 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSEL$")>;
1247
1248 //===----------------------------------------------------------------------===//
1249 // Vector: Widening and narrowing
1250 //===----------------------------------------------------------------------===//
1251
1252 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPK(F|G|H)?$")>;
1253 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPKS(F|G|H)?$")>;
1254 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VPKS(F|G|H)S$")>;
1255 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPKLS(F|G|H)?$")>;
1256 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VPKLS(F|G|H)S$")>;
1257 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSEG(B|F|H)?$")>;
1258 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VUPH(B|F|H)?$")>;
1259 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VUPL(B|F)?$")>;
1260 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VUPLH(B|F|H|W)?$")>;
1261 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VUPLL(B|F|H)?$")>;
1262
1263 //===----------------------------------------------------------------------===//
1264 // Vector: Integer arithmetic
1265 //===----------------------------------------------------------------------===//
1266
1267 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VA(B|F|G|H|Q|C|CQ)?$")>;
1268 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VACC(B|F|G|H|Q|C|CQ)?$")>;
1269 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VAVG(B|F|G|H)?$")>;
1270 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VAVGL(B|F|G|H)?$")>;
1271 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VN(C|O|N|X)?$")>;
1272 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VO(C)?$")>;
1273 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VCKSM$")>;
1274 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VCLZ(B|F|G|H)?$")>;
1275 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VCTZ(B|F|G|H)?$")>;
1276 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VX$")>;
1277 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VGFM?$")>;
1278 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VGFMA(B|F|G|H)?$")>;
1279 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VGFM(B|F|G|H)$")>;
1280 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VLC(B|F|G|H)?$")>;
1281 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VLP(B|F|G|H)?$")>;
1282 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMX(B|F|G|H)?$")>;
1283 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMXL(B|F|G|H)?$")>;
1284 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMN(B|F|G|H)?$")>;
1285 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VMNL(B|F|G|H)?$")>;
1286 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMAL(B|F)?$")>;
1287 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMALE(B|F|H)?$")>;
1288 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMALH(B|F|H|W)?$")>;
1289 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMALO(B|F|H)?$")>;
1290 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMAO(B|F|H)?$")>;
1291 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMAE(B|F|H)?$")>;
1292 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMAH(B|F|H)?$")>;
1293 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VME(B|F|H)?$")>;
1294 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMH(B|F|H)?$")>;
1295 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VML(B|F)?$")>;
1296 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMLE(B|F|H)?$")>;
1297 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMLH(B|F|H|W)?$")>;
1298 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMLO(B|F|H)?$")>;
1299 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VMO(B|F|H)?$")>;
1300 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VMSL(G)?$")>;
1301
1302 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VPOPCT(B|F|G|H)?$")>;
1303
1304 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VERLL(B|F|G|H)?$")>;
1305 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VERLLV(B|F|G|H)?$")>;
1306 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VERIM(B|F|G|H)?$")>;
1307 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESL(B|F|G|H)?$")>;
1308 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESLV(B|F|G|H)?$")>;
1309 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESRA(B|F|G|H)?$")>;
1310 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESRAV(B|F|G|H)?$")>;
1311 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESRL(B|F|G|H)?$")>;
1312 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VESRLV(B|F|G|H)?$")>;
1313
1314 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSL(DB)?$")>;
1315 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSLB$")>;
1316 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSR(A|L)$")>;
1317 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSR(A|L)B$")>;
1318
1319 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSB(I|IQ|CBI|CBIQ)?$")>;
1320 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VSCBI(B|F|G|H|Q)?$")>;
1321 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VS(F|G|H|Q)?$")>;
1322
1323 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VSUM(B|H)?$")>;
1324 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VSUMG(F|H)?$")>;
1325 def : InstRW<[WLat4, VecMul, NormalGr], (instregex "VSUMQ(F|G)?$")>;
1326
1327 //===----------------------------------------------------------------------===//
1328 // Vector: Integer comparison
1329 //===----------------------------------------------------------------------===//
1330
1331 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "VEC(B|F|G|H)?$")>;
1332 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "VECL(B|F|G|H)?$")>;
1333 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VCEQ(B|F|G|H)?$")>;
1334 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VCEQ(B|F|G|H)S$")>;
1335 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VCH(B|F|G|H)?$")>;
1336 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VCH(B|F|G|H)S$")>;
1337 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VCHL(B|F|G|H)?$")>;
1338 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VCHL(B|F|G|H)S$")>;
1339 def : InstRW<[WLat4, VecStr, NormalGr], (instregex "VTM$")>;
1340
1341 //===----------------------------------------------------------------------===//
1342 // Vector: Floating-point arithmetic
1343 //===----------------------------------------------------------------------===//
1344
1345 // Conversion and rounding
1346 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VCD(L)?G$")>;
1347 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VCD(L)?GB$")>;
1348 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WCD(L)?GB$")>;
1349 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VC(L)?GD$")>;
1350 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VC(L)?GDB$")>;
1351 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WC(L)?GDB$")>;
1352 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VL(DE|ED)$")>;
1353 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VL(DE|ED)B$")>;
1354 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WL(DE|ED)B$")>;
1355 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VFL(L|R)$")>;
1356 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VFL(LS|RD)$")>;
1357 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WFL(LS|RD)$")>;
1358 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "WFLLD$")>;
1359 def : InstRW<[WLat10, VecDF2, NormalGr], (instregex "WFLRX$")>;
1360 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VFI$")>;
1361 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VFIDB$")>;
1362 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WFIDB$")>;
1363 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VFISB$")>;
1364 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WFISB$")>;
1365 def : InstRW<[WLat10, VecDF2, NormalGr], (instregex "WFIXB$")>;
1366
1367 // Sign operations
1368 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VFPSO$")>;
1369 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "(V|W)FPSODB$")>;
1370 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "(V|W)FPSOSB$")>;
1371 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFPSOXB$")>;
1372 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "(V|W)FL(C|N|P)DB$")>;
1373 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "(V|W)FL(C|N|P)SB$")>;
1374 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFL(C|N|P)XB$")>;
1375
1376 // Minimum / maximum
1377 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(MAX|MIN)$")>;
1378 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(MAX|MIN)DB$")>;
1379 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WF(MAX|MIN)DB$")>;
1380 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(MAX|MIN)SB$")>;
1381 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WF(MAX|MIN)SB$")>;
1382 def : InstRW<[WLat2, VecDFX, NormalGr], (instregex "WF(MAX|MIN)XB$")>;
1383
1384 // Test data class
1385 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VFTCI$")>;
1386 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "(V|W)FTCIDB$")>;
1387 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "(V|W)FTCISB$")>;
1388 def : InstRW<[WLat3, WLat3, VecDFX, NormalGr], (instregex "WFTCIXB$")>;
1389
1390 // Add / subtract
1391 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VF(A|S)$")>;
1392 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VF(A|S)DB$")>;
1393 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WF(A|S)DB$")>;
1394 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VF(A|S)SB$")>;
1395 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WF(A|S)SB$")>;
1396 def : InstRW<[WLat10, VecDF2, NormalGr], (instregex "WF(A|S)XB$")>;
1397
1398 // Multiply / multiply-and-add/subtract
1399 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VFM$")>;
1400 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VFMDB$")>;
1401 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WFM(D|S)B$")>;
1402 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VFMSB$")>;
1403 def : InstRW<[WLat20, VecDF2, NormalGr], (instregex "WFMXB$")>;
1404 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VF(N)?M(A|S)$")>;
1405 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "VF(N)?M(A|S)DB$")>;
1406 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WF(N)?M(A|S)DB$")>;
1407 def : InstRW<[WLat8, VecBF2, NormalGr], (instregex "VF(N)?M(A|S)SB$")>;
1408 def : InstRW<[WLat7, VecBF, NormalGr], (instregex "WF(N)?M(A|S)SB$")>;
1409 def : InstRW<[WLat30, VecDF2, NormalGr], (instregex "WF(N)?M(A|S)XB$")>;
1410
1411 // Divide / square root
1412 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "VFD$")>;
1413 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "(V|W)FDDB$")>;
1414 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "(V|W)FDSB$")>;
1415 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "WFDXB$")>;
1416 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "VFSQ$")>;
1417 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "(V|W)FSQDB$")>;
1418 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "(V|W)FSQSB$")>;
1419 def : InstRW<[WLat30, VecFPd, NormalGr], (instregex "WFSQXB$")>;
1420
1421 //===----------------------------------------------------------------------===//
1422 // Vector: Floating-point comparison
1423 //===----------------------------------------------------------------------===//
1424
1425 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(C|K)(E|H|HE)$")>;
1426 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(C|K)(E|H|HE)DB$")>;
1427 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFC(E|H|HE)DB$")>;
1428 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFK(E|H|HE)DB$")>;
1429 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "VF(C|K)(E|H|HE)SB$")>;
1430 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFC(E|H|HE)SB$")>;
1431 def : InstRW<[WLat2, VecXsPm, NormalGr], (instregex "WFK(E|H|HE)SB$")>;
1432 def : InstRW<[WLat2, VecDFX, NormalGr], (instregex "WFC(E|H|HE)XB$")>;
1433 def : InstRW<[WLat2, VecDFX, NormalGr], (instregex "WFK(E|H|HE)XB$")>;
1434 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VFC(E|H|HE)DBS$")>;
1435 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "VFK(E|H|HE)DBS$")>;
1436 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr],
1437              (instregex "WF(C|K)(E|H|HE)DBS$")>;
1438 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr],
1439              (instregex "VF(C|K)(E|H|HE)SBS$")>;
1440 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "WFC(E|H|HE)SBS$")>;
1441 def : InstRW<[WLat3, WLat3, VecXsPm, NormalGr], (instregex "WFK(E|H|HE)SBS$")>;
1442 def : InstRW<[WLat3, WLat3, VecDFX, NormalGr], (instregex "WFC(E|H|HE)XBS$")>;
1443 def : InstRW<[WLat3, WLat3, VecDFX, NormalGr], (instregex "WFK(E|H|HE)XBS$")>;
1444 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "WF(C|K)$")>;
1445 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "WF(C|K)DB$")>;
1446 def : InstRW<[WLat3, VecXsPm, NormalGr], (instregex "WF(C|K)SB$")>;
1447 def : InstRW<[WLat3, VecDFX, NormalGr], (instregex "WF(C|K)XB$")>;
1448
1449 //===----------------------------------------------------------------------===//
1450 // Vector: Floating-point insertion and extraction
1451 //===----------------------------------------------------------------------===//
1452
1453 def : InstRW<[WLat1, FXb, NormalGr], (instregex "LEFR$")>;
1454 def : InstRW<[WLat3, FXb, NormalGr], (instregex "LFER$")>;
1455
1456 //===----------------------------------------------------------------------===//
1457 // Vector: String instructions
1458 //===----------------------------------------------------------------------===//
1459
1460 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VFAE(B)?$")>;
1461 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VFAE(F|H)$")>;
1462 def : InstRW<[WLat4, WLat4, VecStr, NormalGr], (instregex "VFAE(B|F|H)S$")>;
1463 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VFAEZ(B|F|H)$")>;
1464 def : InstRW<[WLat4, WLat4, VecStr, NormalGr], (instregex "VFAEZ(B|F|H)S$")>;
1465 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VFEE(B|F|H|ZB|ZF|ZH)?$")>;
1466 def : InstRW<[WLat4, WLat4, VecStr, NormalGr],
1467              (instregex "VFEE(B|F|H|ZB|ZF|ZH)S$")>;
1468 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VFENE(B|F|H|ZB|ZF|ZH)?$")>;
1469 def : InstRW<[WLat4, WLat4, VecStr, NormalGr],
1470              (instregex "VFENE(B|F|H|ZB|ZF|ZH)S$")>;
1471 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VISTR(B|F|H)?$")>;
1472 def : InstRW<[WLat4, WLat4, VecStr, NormalGr], (instregex "VISTR(B|F|H)S$")>;
1473 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VSTRC(B|F|H)?$")>;
1474 def : InstRW<[WLat4, WLat4, VecStr, NormalGr], (instregex "VSTRC(B|F|H)S$")>;
1475 def : InstRW<[WLat3, VecStr, NormalGr], (instregex "VSTRCZ(B|F|H)$")>;
1476 def : InstRW<[WLat4, WLat4, VecStr, NormalGr], (instregex "VSTRCZ(B|F|H)S$")>;
1477
1478 //===----------------------------------------------------------------------===//
1479 // Vector: Packed-decimal instructions
1480 //===----------------------------------------------------------------------===//
1481
1482 def : InstRW<[WLat10, VecDF2, NormalGr], (instregex "VLIP$")>;
1483 def : InstRW<[WLat6, VecDFX, LSU, GroupAlone2], (instregex "VPKZ$")>;
1484 def : InstRW<[WLat1, VecDFX, FXb, LSU, Cracked], (instregex "VUPKZ$")>;
1485 def : InstRW<[WLat20, WLat20, VecDF2, FXb, GroupAlone], (instregex "VCVB(G)?$")>;
1486 def : InstRW<[WLat20, WLat20, VecDF2, FXb, GroupAlone], (instregex "VCVD(G)?$")>;
1487 def : InstRW<[WLat4, WLat4, VecDFX, NormalGr], (instregex "V(A|S)P$")>;
1488 def : InstRW<[WLat30, WLat30, VecDF2, GroupAlone], (instregex "VM(S)?P$")>;
1489 def : InstRW<[WLat30, WLat30, VecDF2, GroupAlone], (instregex "V(D|R)P$")>;
1490 def : InstRW<[WLat30, WLat30, MCD], (instregex "VSDP$")>;
1491 def : InstRW<[WLat10, WLat10, VecDF2, NormalGr], (instregex "VSRP$")>;
1492 def : InstRW<[WLat4, WLat4, VecDFX, NormalGr], (instregex "VPSOP$")>;
1493 def : InstRW<[WLat2, VecDFX, NormalGr], (instregex "V(T|C)P$")>;
1494
1495
1496 // -------------------------------- System ---------------------------------- //
1497
1498 //===----------------------------------------------------------------------===//
1499 // System: Program-Status Word Instructions
1500 //===----------------------------------------------------------------------===//
1501
1502 def : InstRW<[WLat30, WLat30, MCD], (instregex "EPSW$")>;
1503 def : InstRW<[WLat20, GroupAlone], (instregex "LPSW(E)?$")>;
1504 def : InstRW<[WLat3, FXa, GroupAlone], (instregex "IPK$")>;
1505 def : InstRW<[WLat1, LSU, EndGroup], (instregex "SPKA$")>;
1506 def : InstRW<[WLat1, LSU, EndGroup], (instregex "SSM$")>;
1507 def : InstRW<[WLat1, FXb, LSU, GroupAlone], (instregex "ST(N|O)SM$")>;
1508 def : InstRW<[WLat3, FXa, NormalGr], (instregex "IAC$")>;
1509 def : InstRW<[WLat1, LSU, EndGroup], (instregex "SAC(F)?$")>;
1510
1511 //===----------------------------------------------------------------------===//
1512 // System: Control Register Instructions
1513 //===----------------------------------------------------------------------===//
1514
1515 def : InstRW<[WLat4LSU, WLat4LSU, LSU2, GroupAlone], (instregex "LCTL(G)?$")>;
1516 def : InstRW<[WLat1, LSU5, GroupAlone], (instregex "STCT(L|G)$")>;
1517 def : InstRW<[LSULatency, LSU, NormalGr], (instregex "E(P|S)A(I)?R$")>;
1518 def : InstRW<[WLat30, MCD], (instregex "SSA(I)?R$")>;
1519 def : InstRW<[WLat30, MCD], (instregex "ESEA$")>;
1520
1521 //===----------------------------------------------------------------------===//
1522 // System: Prefix-Register Instructions
1523 //===----------------------------------------------------------------------===//
1524
1525 def : InstRW<[WLat30, MCD], (instregex "S(T)?PX$")>;
1526
1527 //===----------------------------------------------------------------------===//
1528 // System: Storage-Key and Real Memory Instructions
1529 //===----------------------------------------------------------------------===//
1530
1531 def : InstRW<[WLat30, MCD], (instregex "ISKE$")>;
1532 def : InstRW<[WLat30, MCD], (instregex "IVSK$")>;
1533 def : InstRW<[WLat30, MCD], (instregex "SSKE(Opt)?$")>;
1534 def : InstRW<[WLat30, MCD], (instregex "RRB(E|M)$")>;
1535 def : InstRW<[WLat30, MCD], (instregex "IRBM$")>;
1536 def : InstRW<[WLat30, MCD], (instregex "PFMF$")>;
1537 def : InstRW<[WLat30, WLat30, MCD], (instregex "TB$")>;
1538 def : InstRW<[WLat30, MCD], (instregex "PGIN$")>;
1539 def : InstRW<[WLat30, MCD], (instregex "PGOUT$")>;
1540
1541 //===----------------------------------------------------------------------===//
1542 // System: Dynamic-Address-Translation Instructions
1543 //===----------------------------------------------------------------------===//
1544
1545 def : InstRW<[WLat30, MCD], (instregex "IPTE(Opt)?(Opt)?$")>;
1546 def : InstRW<[WLat30, MCD], (instregex "IDTE(Opt)?$")>;
1547 def : InstRW<[WLat30, MCD], (instregex "CRDTE(Opt)?$")>;
1548 def : InstRW<[WLat30, MCD], (instregex "PTLB$")>;
1549 def : InstRW<[WLat30, WLat30, MCD], (instregex "CSP(G)?$")>;
1550 def : InstRW<[WLat30, WLat30, WLat30, MCD], (instregex "LPTEA$")>;
1551 def : InstRW<[WLat30, WLat30, MCD], (instregex "LRA(Y|G)?$")>;
1552 def : InstRW<[WLat30, MCD], (instregex "STRAG$")>;
1553 def : InstRW<[WLat30, MCD], (instregex "LURA(G)?$")>;
1554 def : InstRW<[WLat30, MCD], (instregex "STUR(A|G)$")>;
1555 def : InstRW<[WLat30, MCD], (instregex "TPROT$")>;
1556
1557 //===----------------------------------------------------------------------===//
1558 // System: Memory-move Instructions
1559 //===----------------------------------------------------------------------===//
1560
1561 def : InstRW<[WLat4LSU, FXa2, FXb, LSU5, GroupAlone], (instregex "MVC(K|P|S)$")>;
1562 def : InstRW<[WLat1, FXa, LSU5, GroupAlone], (instregex "MVC(S|D)K$")>;
1563 def : InstRW<[WLat30, MCD], (instregex "MVCOS$")>;
1564 def : InstRW<[WLat30, MCD], (instregex "MVPG$")>;
1565
1566 //===----------------------------------------------------------------------===//
1567 // System: Address-Space Instructions
1568 //===----------------------------------------------------------------------===//
1569
1570 def : InstRW<[WLat30, MCD], (instregex "LASP$")>;
1571 def : InstRW<[WLat1, LSU, GroupAlone], (instregex "PALB$")>;
1572 def : InstRW<[WLat30, MCD], (instregex "PC$")>;
1573 def : InstRW<[WLat30, MCD], (instregex "PR$")>;
1574 def : InstRW<[WLat30, MCD], (instregex "PT(I)?$")>;
1575 def : InstRW<[WLat30, MCD], (instregex "RP$")>;
1576 def : InstRW<[WLat30, MCD], (instregex "BS(G|A)$")>;
1577 def : InstRW<[WLat30, MCD], (instregex "TAR$")>;
1578
1579 //===----------------------------------------------------------------------===//
1580 // System: Linkage-Stack Instructions
1581 //===----------------------------------------------------------------------===//
1582
1583 def : InstRW<[WLat30, MCD], (instregex "BAKR$")>;
1584 def : InstRW<[WLat30, MCD], (instregex "EREG(G)?$")>;
1585 def : InstRW<[WLat30, WLat30, MCD], (instregex "(E|M)STA$")>;
1586
1587 //===----------------------------------------------------------------------===//
1588 // System: Time-Related Instructions
1589 //===----------------------------------------------------------------------===//
1590
1591 def : InstRW<[WLat30, MCD], (instregex "PTFF$")>;
1592 def : InstRW<[WLat30, MCD], (instregex "SCK(PF|C)?$")>;
1593 def : InstRW<[WLat1, LSU2, GroupAlone], (instregex "SPT$")>;
1594 def : InstRW<[WLat15, LSU3, FXa2, FXb, GroupAlone2], (instregex "STCK(F)?$")>;
1595 def : InstRW<[WLat20, LSU4, FXa2, FXb2, GroupAlone3], (instregex "STCKE$")>;
1596 def : InstRW<[WLat30, MCD], (instregex "STCKC$")>;
1597 def : InstRW<[WLat1, LSU2, FXb, Cracked], (instregex "STPT$")>;
1598
1599 //===----------------------------------------------------------------------===//
1600 // System: CPU-Related Instructions
1601 //===----------------------------------------------------------------------===//
1602
1603 def : InstRW<[WLat30, MCD], (instregex "STAP$")>;
1604 def : InstRW<[WLat30, MCD], (instregex "STIDP$")>;
1605 def : InstRW<[WLat30, WLat30, MCD], (instregex "STSI$")>;
1606 def : InstRW<[WLat30, WLat30, MCD], (instregex "STFL(E)?$")>;
1607 def : InstRW<[WLat30, MCD], (instregex "ECAG$")>;
1608 def : InstRW<[WLat30, WLat30, MCD], (instregex "ECTG$")>;
1609 def : InstRW<[WLat30, MCD], (instregex "PTF$")>;
1610 def : InstRW<[WLat30, MCD], (instregex "PCKMO$")>;
1611
1612 //===----------------------------------------------------------------------===//
1613 // System: Miscellaneous Instructions
1614 //===----------------------------------------------------------------------===//
1615
1616 def : InstRW<[WLat30, MCD], (instregex "SVC$")>;
1617 def : InstRW<[WLat1, FXb, GroupAlone], (instregex "MC$")>;
1618 def : InstRW<[WLat30, MCD], (instregex "DIAG$")>;
1619 def : InstRW<[WLat1, FXb, NormalGr], (instregex "TRAC(E|G)$")>;
1620 def : InstRW<[WLat30, MCD], (instregex "TRAP(2|4)$")>;
1621 def : InstRW<[WLat30, MCD], (instregex "SIG(P|A)$")>;
1622 def : InstRW<[WLat30, MCD], (instregex "SIE$")>;
1623
1624 //===----------------------------------------------------------------------===//
1625 // System: CPU-Measurement Facility Instructions
1626 //===----------------------------------------------------------------------===//
1627
1628 def : InstRW<[WLat1, FXb, NormalGr], (instregex "LPP$")>;
1629 def : InstRW<[WLat30, WLat30, MCD], (instregex "ECPGA$")>;
1630 def : InstRW<[WLat30, WLat30, MCD], (instregex "E(C|P)CTR$")>;
1631 def : InstRW<[WLat30, MCD], (instregex "LCCTL$")>;
1632 def : InstRW<[WLat30, MCD], (instregex "L(P|S)CTL$")>;
1633 def : InstRW<[WLat30, MCD], (instregex "Q(S|CTR)I$")>;
1634 def : InstRW<[WLat30, MCD], (instregex "S(C|P)CTR$")>;
1635
1636 //===----------------------------------------------------------------------===//
1637 // System: I/O Instructions
1638 //===----------------------------------------------------------------------===//
1639
1640 def : InstRW<[WLat30, MCD], (instregex "(C|H|R|X)SCH$")>;
1641 def : InstRW<[WLat30, MCD], (instregex "(M|S|ST|T)SCH$")>;
1642 def : InstRW<[WLat30, MCD], (instregex "RCHP$")>;
1643 def : InstRW<[WLat30, MCD], (instregex "SCHM$")>;
1644 def : InstRW<[WLat30, MCD], (instregex "STC(PS|RW)$")>;
1645 def : InstRW<[WLat30, MCD], (instregex "TPI$")>;
1646 def : InstRW<[WLat30, MCD], (instregex "SAL$")>;
1647
1648 }
1649