1 //===- ARM64InstrFormats.td - ARM64 Instruction Formats ------*- tblgen -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 //===----------------------------------------------------------------------===//
11 // Describe ARM64 instructions format here
14 // Format specifies the encoding used by the instruction. This is part of the
15 // ad-hoc solution used to emit machine instruction encodings by our machine
17 class Format<bits<2> val> {
21 def PseudoFrm : Format<0>;
22 def NormalFrm : Format<1>; // Do we need any others?
24 // ARM64 Instruction Format
25 class ARM64Inst<Format f, string cstr> : Instruction {
26 field bits<32> Inst; // Instruction encoding.
27 // Mask of bits that cause an encoding to be UNPREDICTABLE.
28 // If a bit is set, then if the corresponding bit in the
29 // target encoding differs from its value in the "Inst" field,
30 // the instruction is UNPREDICTABLE (SoftFail in abstract parlance).
31 field bits<32> Unpredictable = 0;
32 // SoftFail is the generic name for this field, but we alias it so
33 // as to make it more obvious what it means in ARM-land.
34 field bits<32> SoftFail = Unpredictable;
35 let Namespace = "ARM64";
37 bits<2> Form = F.Value;
39 let Constraints = cstr;
42 // Pseudo instructions (don't have encoding information)
43 class Pseudo<dag oops, dag iops, list<dag> pattern, string cstr = "">
44 : ARM64Inst<PseudoFrm, cstr> {
45 dag OutOperandList = oops;
46 dag InOperandList = iops;
47 let Pattern = pattern;
48 let isCodeGenOnly = 1;
51 // Real instructions (have encoding information)
52 class EncodedI<string cstr, list<dag> pattern> : ARM64Inst<NormalFrm, cstr> {
53 let Pattern = pattern;
57 // Normal instructions
58 class I<dag oops, dag iops, string asm, string operands, string cstr,
60 : EncodedI<cstr, pattern> {
61 dag OutOperandList = oops;
62 dag InOperandList = iops;
63 let AsmString = !strconcat(asm, operands);
66 class TriOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$MHS, node:$RHS), res>;
67 class BinOpFrag<dag res> : PatFrag<(ops node:$LHS, node:$RHS), res>;
68 class UnOpFrag<dag res> : PatFrag<(ops node:$LHS), res>;
70 // Helper fragment for an extract of the high portion of a 128-bit vector.
71 def extract_high_v16i8 :
72 UnOpFrag<(extract_subvector (v16i8 node:$LHS), (i64 8))>;
73 def extract_high_v8i16 :
74 UnOpFrag<(extract_subvector (v8i16 node:$LHS), (i64 4))>;
75 def extract_high_v4i32 :
76 UnOpFrag<(extract_subvector (v4i32 node:$LHS), (i64 2))>;
77 def extract_high_v2i64 :
78 UnOpFrag<(extract_subvector (v2i64 node:$LHS), (i64 1))>;
80 //===----------------------------------------------------------------------===//
81 // Asm Operand Classes.
84 // Shifter operand for arithmetic shifted encodings.
85 def ShifterOperand : AsmOperandClass {
89 // Shifter operand for mov immediate encodings.
90 def MovImm32ShifterOperand : AsmOperandClass {
91 let SuperClasses = [ShifterOperand];
92 let Name = "MovImm32Shifter";
94 def MovImm64ShifterOperand : AsmOperandClass {
95 let SuperClasses = [ShifterOperand];
96 let Name = "MovImm64Shifter";
99 // Shifter operand for arithmetic register shifted encodings.
100 def ArithmeticShifterOperand : AsmOperandClass {
101 let SuperClasses = [ShifterOperand];
102 let Name = "ArithmeticShifter";
105 // Shifter operand for arithmetic shifted encodings for ADD/SUB instructions.
106 def AddSubShifterOperand : AsmOperandClass {
107 let SuperClasses = [ArithmeticShifterOperand];
108 let Name = "AddSubShifter";
111 // Shifter operand for logical vector 128/64-bit shifted encodings.
112 def LogicalVecShifterOperand : AsmOperandClass {
113 let SuperClasses = [ShifterOperand];
114 let Name = "LogicalVecShifter";
116 def LogicalVecHalfWordShifterOperand : AsmOperandClass {
117 let SuperClasses = [LogicalVecShifterOperand];
118 let Name = "LogicalVecHalfWordShifter";
121 // The "MSL" shifter on the vector MOVI instruction.
122 def MoveVecShifterOperand : AsmOperandClass {
123 let SuperClasses = [ShifterOperand];
124 let Name = "MoveVecShifter";
127 // Extend operand for arithmetic encodings.
128 def ExtendOperand : AsmOperandClass { let Name = "Extend"; }
129 def ExtendOperand64 : AsmOperandClass {
130 let SuperClasses = [ExtendOperand];
131 let Name = "Extend64";
133 // 'extend' that's a lsl of a 64-bit register.
134 def ExtendOperandLSL64 : AsmOperandClass {
135 let SuperClasses = [ExtendOperand];
136 let Name = "ExtendLSL64";
139 // 8-bit floating-point immediate encodings.
140 def FPImmOperand : AsmOperandClass {
142 let ParserMethod = "tryParseFPImm";
145 // 8-bit immediate for AdvSIMD where 64-bit values of the form:
146 // aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh
147 // are encoded as the eight bit value 'abcdefgh'.
148 def SIMDImmType10Operand : AsmOperandClass { let Name = "SIMDImmType10"; }
151 //===----------------------------------------------------------------------===//
152 // Operand Definitions.
155 // ADR[P] instruction labels.
156 def AdrpOperand : AsmOperandClass {
157 let Name = "AdrpLabel";
158 let ParserMethod = "tryParseAdrpLabel";
160 def adrplabel : Operand<i64> {
161 let EncoderMethod = "getAdrLabelOpValue";
162 let PrintMethod = "printAdrpLabel";
163 let ParserMatchClass = AdrpOperand;
166 def AdrOperand : AsmOperandClass {
167 let Name = "AdrLabel";
168 let ParserMethod = "tryParseAdrLabel";
170 def adrlabel : Operand<i64> {
171 let EncoderMethod = "getAdrLabelOpValue";
172 let ParserMatchClass = AdrOperand;
175 // simm9 predicate - True if the immediate is in the range [-256, 255].
176 def SImm9Operand : AsmOperandClass {
178 let DiagnosticType = "InvalidMemoryIndexedSImm9";
180 def simm9 : Operand<i64>, ImmLeaf<i64, [{ return Imm >= -256 && Imm < 256; }]> {
181 let ParserMatchClass = SImm9Operand;
184 // simm7s4 predicate - True if the immediate is a multiple of 4 in the range
186 def SImm7s4Operand : AsmOperandClass {
187 let Name = "SImm7s4";
188 let DiagnosticType = "InvalidMemoryIndexed32SImm7";
190 def simm7s4 : Operand<i32> {
191 let ParserMatchClass = SImm7s4Operand;
192 let PrintMethod = "printImmScale4";
195 // simm7s8 predicate - True if the immediate is a multiple of 8 in the range
197 def SImm7s8Operand : AsmOperandClass {
198 let Name = "SImm7s8";
199 let DiagnosticType = "InvalidMemoryIndexed64SImm7";
201 def simm7s8 : Operand<i32> {
202 let ParserMatchClass = SImm7s8Operand;
203 let PrintMethod = "printImmScale8";
206 // simm7s16 predicate - True if the immediate is a multiple of 16 in the range
208 def SImm7s16Operand : AsmOperandClass {
209 let Name = "SImm7s16";
210 let DiagnosticType = "InvalidMemoryIndexed64SImm7";
212 def simm7s16 : Operand<i32> {
213 let ParserMatchClass = SImm7s16Operand;
214 let PrintMethod = "printImmScale16";
217 // imm0_65535 predicate - True if the immediate is in the range [0,65535].
218 def Imm0_65535Operand : AsmOperandClass { let Name = "Imm0_65535"; }
219 def imm0_65535 : Operand<i32>, ImmLeaf<i32, [{
220 return ((uint32_t)Imm) < 65536;
222 let ParserMatchClass = Imm0_65535Operand;
225 def Imm1_8Operand : AsmOperandClass {
227 let DiagnosticType = "InvalidImm1_8";
229 def Imm1_16Operand : AsmOperandClass {
230 let Name = "Imm1_16";
231 let DiagnosticType = "InvalidImm1_16";
233 def Imm1_32Operand : AsmOperandClass {
234 let Name = "Imm1_32";
235 let DiagnosticType = "InvalidImm1_32";
237 def Imm1_64Operand : AsmOperandClass {
238 let Name = "Imm1_64";
239 let DiagnosticType = "InvalidImm1_64";
242 def MovZSymbolG3AsmOperand : AsmOperandClass {
243 let Name = "MovZSymbolG3";
244 let RenderMethod = "addImmOperands";
247 def movz_symbol_g3 : Operand<i32> {
248 let ParserMatchClass = MovZSymbolG3AsmOperand;
251 def MovZSymbolG2AsmOperand : AsmOperandClass {
252 let Name = "MovZSymbolG2";
253 let RenderMethod = "addImmOperands";
256 def movz_symbol_g2 : Operand<i32> {
257 let ParserMatchClass = MovZSymbolG2AsmOperand;
260 def MovZSymbolG1AsmOperand : AsmOperandClass {
261 let Name = "MovZSymbolG1";
262 let RenderMethod = "addImmOperands";
265 def movz_symbol_g1 : Operand<i32> {
266 let ParserMatchClass = MovZSymbolG1AsmOperand;
269 def MovZSymbolG0AsmOperand : AsmOperandClass {
270 let Name = "MovZSymbolG0";
271 let RenderMethod = "addImmOperands";
274 def movz_symbol_g0 : Operand<i32> {
275 let ParserMatchClass = MovZSymbolG0AsmOperand;
278 def MovKSymbolG2AsmOperand : AsmOperandClass {
279 let Name = "MovKSymbolG2";
280 let RenderMethod = "addImmOperands";
283 def movk_symbol_g2 : Operand<i32> {
284 let ParserMatchClass = MovKSymbolG2AsmOperand;
287 def MovKSymbolG1AsmOperand : AsmOperandClass {
288 let Name = "MovKSymbolG1";
289 let RenderMethod = "addImmOperands";
292 def movk_symbol_g1 : Operand<i32> {
293 let ParserMatchClass = MovKSymbolG1AsmOperand;
296 def MovKSymbolG0AsmOperand : AsmOperandClass {
297 let Name = "MovKSymbolG0";
298 let RenderMethod = "addImmOperands";
301 def movk_symbol_g0 : Operand<i32> {
302 let ParserMatchClass = MovKSymbolG0AsmOperand;
305 def fixedpoint32 : Operand<i32> {
306 let EncoderMethod = "getFixedPointScaleOpValue";
307 let DecoderMethod = "DecodeFixedPointScaleImm32";
308 let ParserMatchClass = Imm1_32Operand;
310 def fixedpoint64 : Operand<i64> {
311 let EncoderMethod = "getFixedPointScaleOpValue";
312 let DecoderMethod = "DecodeFixedPointScaleImm64";
313 let ParserMatchClass = Imm1_64Operand;
316 def vecshiftR8 : Operand<i32>, ImmLeaf<i32, [{
317 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 9);
319 let EncoderMethod = "getVecShiftR8OpValue";
320 let DecoderMethod = "DecodeVecShiftR8Imm";
321 let ParserMatchClass = Imm1_8Operand;
323 def vecshiftR16 : Operand<i32>, ImmLeaf<i32, [{
324 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 17);
326 let EncoderMethod = "getVecShiftR16OpValue";
327 let DecoderMethod = "DecodeVecShiftR16Imm";
328 let ParserMatchClass = Imm1_16Operand;
330 def vecshiftR16Narrow : Operand<i32>, ImmLeaf<i32, [{
331 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 9);
333 let EncoderMethod = "getVecShiftR16OpValue";
334 let DecoderMethod = "DecodeVecShiftR16ImmNarrow";
335 let ParserMatchClass = Imm1_8Operand;
337 def vecshiftR32 : Operand<i32>, ImmLeaf<i32, [{
338 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 33);
340 let EncoderMethod = "getVecShiftR32OpValue";
341 let DecoderMethod = "DecodeVecShiftR32Imm";
342 let ParserMatchClass = Imm1_32Operand;
344 def vecshiftR32Narrow : Operand<i32>, ImmLeaf<i32, [{
345 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 17);
347 let EncoderMethod = "getVecShiftR32OpValue";
348 let DecoderMethod = "DecodeVecShiftR32ImmNarrow";
349 let ParserMatchClass = Imm1_16Operand;
351 def vecshiftR64 : Operand<i32>, ImmLeaf<i32, [{
352 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 65);
354 let EncoderMethod = "getVecShiftR64OpValue";
355 let DecoderMethod = "DecodeVecShiftR64Imm";
356 let ParserMatchClass = Imm1_64Operand;
358 def vecshiftR64Narrow : Operand<i32>, ImmLeaf<i32, [{
359 return (((uint32_t)Imm) > 0) && (((uint32_t)Imm) < 33);
361 let EncoderMethod = "getVecShiftR64OpValue";
362 let DecoderMethod = "DecodeVecShiftR64ImmNarrow";
363 let ParserMatchClass = Imm1_32Operand;
366 def Imm0_7Operand : AsmOperandClass { let Name = "Imm0_7"; }
367 def Imm0_15Operand : AsmOperandClass { let Name = "Imm0_15"; }
368 def Imm0_31Operand : AsmOperandClass { let Name = "Imm0_31"; }
369 def Imm0_63Operand : AsmOperandClass { let Name = "Imm0_63"; }
371 def vecshiftL8 : Operand<i32>, ImmLeaf<i32, [{
372 return (((uint32_t)Imm) < 8);
374 let EncoderMethod = "getVecShiftL8OpValue";
375 let DecoderMethod = "DecodeVecShiftL8Imm";
376 let ParserMatchClass = Imm0_7Operand;
378 def vecshiftL16 : Operand<i32>, ImmLeaf<i32, [{
379 return (((uint32_t)Imm) < 16);
381 let EncoderMethod = "getVecShiftL16OpValue";
382 let DecoderMethod = "DecodeVecShiftL16Imm";
383 let ParserMatchClass = Imm0_15Operand;
385 def vecshiftL32 : Operand<i32>, ImmLeaf<i32, [{
386 return (((uint32_t)Imm) < 32);
388 let EncoderMethod = "getVecShiftL32OpValue";
389 let DecoderMethod = "DecodeVecShiftL32Imm";
390 let ParserMatchClass = Imm0_31Operand;
392 def vecshiftL64 : Operand<i32>, ImmLeaf<i32, [{
393 return (((uint32_t)Imm) < 64);
395 let EncoderMethod = "getVecShiftL64OpValue";
396 let DecoderMethod = "DecodeVecShiftL64Imm";
397 let ParserMatchClass = Imm0_63Operand;
401 // Crazy immediate formats used by 32-bit and 64-bit logical immediate
402 // instructions for splatting repeating bit patterns across the immediate.
403 def logical_imm32_XFORM : SDNodeXForm<imm, [{
404 uint64_t enc = ARM64_AM::encodeLogicalImmediate(N->getZExtValue(), 32);
405 return CurDAG->getTargetConstant(enc, MVT::i32);
407 def logical_imm64_XFORM : SDNodeXForm<imm, [{
408 uint64_t enc = ARM64_AM::encodeLogicalImmediate(N->getZExtValue(), 64);
409 return CurDAG->getTargetConstant(enc, MVT::i32);
412 def LogicalImm32Operand : AsmOperandClass { let Name = "LogicalImm32"; }
413 def LogicalImm64Operand : AsmOperandClass { let Name = "LogicalImm64"; }
414 def logical_imm32 : Operand<i32>, PatLeaf<(imm), [{
415 return ARM64_AM::isLogicalImmediate(N->getZExtValue(), 32);
416 }], logical_imm32_XFORM> {
417 let PrintMethod = "printLogicalImm32";
418 let ParserMatchClass = LogicalImm32Operand;
420 def logical_imm64 : Operand<i64>, PatLeaf<(imm), [{
421 return ARM64_AM::isLogicalImmediate(N->getZExtValue(), 64);
422 }], logical_imm64_XFORM> {
423 let PrintMethod = "printLogicalImm64";
424 let ParserMatchClass = LogicalImm64Operand;
427 // imm0_255 predicate - True if the immediate is in the range [0,255].
428 def Imm0_255Operand : AsmOperandClass { let Name = "Imm0_255"; }
429 def imm0_255 : Operand<i32>, ImmLeaf<i32, [{
430 return ((uint32_t)Imm) < 256;
432 let ParserMatchClass = Imm0_255Operand;
435 // imm0_127 predicate - True if the immediate is in the range [0,127]
436 def Imm0_127Operand : AsmOperandClass { let Name = "Imm0_127"; }
437 def imm0_127 : Operand<i32>, ImmLeaf<i32, [{
438 return ((uint32_t)Imm) < 128;
440 let ParserMatchClass = Imm0_127Operand;
443 // NOTE: These imm0_N operands have to be of type i64 because i64 is the size
444 // for all shift-amounts.
446 // imm0_63 predicate - True if the immediate is in the range [0,63]
447 def imm0_63 : Operand<i64>, ImmLeaf<i64, [{
448 return ((uint64_t)Imm) < 64;
450 let ParserMatchClass = Imm0_63Operand;
453 // imm0_31 predicate - True if the immediate is in the range [0,31]
454 def imm0_31 : Operand<i64>, ImmLeaf<i64, [{
455 return ((uint64_t)Imm) < 32;
457 let ParserMatchClass = Imm0_31Operand;
460 // imm0_15 predicate - True if the immediate is in the range [0,15]
461 def imm0_15 : Operand<i64>, ImmLeaf<i64, [{
462 return ((uint64_t)Imm) < 16;
464 let ParserMatchClass = Imm0_15Operand;
467 // imm0_7 predicate - True if the immediate is in the range [0,7]
468 def imm0_7 : Operand<i64>, ImmLeaf<i64, [{
469 return ((uint64_t)Imm) < 8;
471 let ParserMatchClass = Imm0_7Operand;
474 // An arithmetic shifter operand:
475 // {7-6} - shift type: 00 = lsl, 01 = lsr, 10 = asr
477 def arith_shift : Operand<i32> {
478 let PrintMethod = "printShifter";
479 let ParserMatchClass = ArithmeticShifterOperand;
482 class arith_shifted_reg<ValueType Ty, RegisterClass regclass>
484 ComplexPattern<Ty, 2, "SelectArithShiftedRegister", []> {
485 let PrintMethod = "printShiftedRegister";
486 let MIOperandInfo = (ops regclass, arith_shift);
489 def arith_shifted_reg32 : arith_shifted_reg<i32, GPR32>;
490 def arith_shifted_reg64 : arith_shifted_reg<i64, GPR64>;
492 // An arithmetic shifter operand:
493 // {7-6} - shift type: 00 = lsl, 01 = lsr, 10 = asr, 11 = ror
495 def logical_shift : Operand<i32> {
496 let PrintMethod = "printShifter";
497 let ParserMatchClass = ShifterOperand;
500 class logical_shifted_reg<ValueType Ty, RegisterClass regclass>
502 ComplexPattern<Ty, 2, "SelectLogicalShiftedRegister", []> {
503 let PrintMethod = "printShiftedRegister";
504 let MIOperandInfo = (ops regclass, logical_shift);
507 def logical_shifted_reg32 : logical_shifted_reg<i32, GPR32>;
508 def logical_shifted_reg64 : logical_shifted_reg<i64, GPR64>;
510 // A logical vector shifter operand:
511 // {7-6} - shift type: 00 = lsl
512 // {5-0} - imm6: #0, #8, #16, or #24
513 def logical_vec_shift : Operand<i32> {
514 let PrintMethod = "printShifter";
515 let EncoderMethod = "getVecShifterOpValue";
516 let ParserMatchClass = LogicalVecShifterOperand;
519 // A logical vector half-word shifter operand:
520 // {7-6} - shift type: 00 = lsl
521 // {5-0} - imm6: #0 or #8
522 def logical_vec_hw_shift : Operand<i32> {
523 let PrintMethod = "printShifter";
524 let EncoderMethod = "getVecShifterOpValue";
525 let ParserMatchClass = LogicalVecHalfWordShifterOperand;
528 // A vector move shifter operand:
529 // {0} - imm1: #8 or #16
530 def move_vec_shift : Operand<i32> {
531 let PrintMethod = "printShifter";
532 let EncoderMethod = "getMoveVecShifterOpValue";
533 let ParserMatchClass = MoveVecShifterOperand;
536 // An ADD/SUB immediate shifter operand:
537 // {7-6} - shift type: 00 = lsl
538 // {5-0} - imm6: #0 or #12
539 def addsub_shift : Operand<i32> {
540 let ParserMatchClass = AddSubShifterOperand;
543 class addsub_shifted_imm<ValueType Ty>
544 : Operand<Ty>, ComplexPattern<Ty, 2, "SelectArithImmed", [imm]> {
545 let PrintMethod = "printAddSubImm";
546 let EncoderMethod = "getAddSubImmOpValue";
547 let MIOperandInfo = (ops i32imm, addsub_shift);
550 def addsub_shifted_imm32 : addsub_shifted_imm<i32>;
551 def addsub_shifted_imm64 : addsub_shifted_imm<i64>;
553 class neg_addsub_shifted_imm<ValueType Ty>
554 : Operand<Ty>, ComplexPattern<Ty, 2, "SelectNegArithImmed", [imm]> {
555 let PrintMethod = "printAddSubImm";
556 let EncoderMethod = "getAddSubImmOpValue";
557 let MIOperandInfo = (ops i32imm, addsub_shift);
560 def neg_addsub_shifted_imm32 : neg_addsub_shifted_imm<i32>;
561 def neg_addsub_shifted_imm64 : neg_addsub_shifted_imm<i64>;
563 // An extend operand:
564 // {5-3} - extend type
566 def arith_extend : Operand<i32> {
567 let PrintMethod = "printExtend";
568 let ParserMatchClass = ExtendOperand;
570 def arith_extend64 : Operand<i32> {
571 let PrintMethod = "printExtend";
572 let ParserMatchClass = ExtendOperand64;
575 // 'extend' that's a lsl of a 64-bit register.
576 def arith_extendlsl64 : Operand<i32> {
577 let PrintMethod = "printExtend";
578 let ParserMatchClass = ExtendOperandLSL64;
581 class arith_extended_reg32<ValueType Ty> : Operand<Ty>,
582 ComplexPattern<Ty, 2, "SelectArithExtendedRegister", []> {
583 let PrintMethod = "printExtendedRegister";
584 let MIOperandInfo = (ops GPR32, arith_extend);
587 class arith_extended_reg32to64<ValueType Ty> : Operand<Ty>,
588 ComplexPattern<Ty, 2, "SelectArithExtendedRegister", []> {
589 let PrintMethod = "printExtendedRegister";
590 let MIOperandInfo = (ops GPR32, arith_extend64);
593 // Floating-point immediate.
594 def fpimm32 : Operand<f32>,
595 PatLeaf<(f32 fpimm), [{
596 return ARM64_AM::getFP32Imm(N->getValueAPF()) != -1;
597 }], SDNodeXForm<fpimm, [{
598 APFloat InVal = N->getValueAPF();
599 uint32_t enc = ARM64_AM::getFP32Imm(InVal);
600 return CurDAG->getTargetConstant(enc, MVT::i32);
602 let ParserMatchClass = FPImmOperand;
603 let PrintMethod = "printFPImmOperand";
605 def fpimm64 : Operand<f64>,
606 PatLeaf<(f64 fpimm), [{
607 return ARM64_AM::getFP64Imm(N->getValueAPF()) != -1;
608 }], SDNodeXForm<fpimm, [{
609 APFloat InVal = N->getValueAPF();
610 uint32_t enc = ARM64_AM::getFP64Imm(InVal);
611 return CurDAG->getTargetConstant(enc, MVT::i32);
613 let ParserMatchClass = FPImmOperand;
614 let PrintMethod = "printFPImmOperand";
617 def fpimm8 : Operand<i32> {
618 let ParserMatchClass = FPImmOperand;
619 let PrintMethod = "printFPImmOperand";
622 def fpimm0 : PatLeaf<(fpimm), [{
623 return N->isExactlyValue(+0.0);
626 // 8-bit immediate for AdvSIMD where 64-bit values of the form:
627 // aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh
628 // are encoded as the eight bit value 'abcdefgh'.
629 def simdimmtype10 : Operand<i32>,
630 PatLeaf<(f64 fpimm), [{
631 return ARM64_AM::isAdvSIMDModImmType10(N->getValueAPF()
634 }], SDNodeXForm<fpimm, [{
635 APFloat InVal = N->getValueAPF();
636 uint32_t enc = ARM64_AM::encodeAdvSIMDModImmType10(N->getValueAPF()
639 return CurDAG->getTargetConstant(enc, MVT::i32);
641 let ParserMatchClass = SIMDImmType10Operand;
642 let PrintMethod = "printSIMDType10Operand";
650 // Base encoding for system instruction operands.
651 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
652 class BaseSystemI<bit L, dag oops, dag iops, string asm, string operands>
653 : I<oops, iops, asm, operands, "", []> {
654 let Inst{31-22} = 0b1101010100;
658 // System instructions which do not have an Rt register.
659 class SimpleSystemI<bit L, dag iops, string asm, string operands>
660 : BaseSystemI<L, (outs), iops, asm, operands> {
661 let Inst{4-0} = 0b11111;
664 // System instructions which have an Rt register.
665 class RtSystemI<bit L, dag oops, dag iops, string asm, string operands>
666 : BaseSystemI<L, oops, iops, asm, operands>,
672 // Hint instructions that take both a CRm and a 3-bit immediate.
673 class HintI<string mnemonic>
674 : SimpleSystemI<0, (ins imm0_127:$imm), mnemonic#" $imm", "">,
677 let Inst{20-12} = 0b000110010;
678 let Inst{11-5} = imm;
681 // System instructions taking a single literal operand which encodes into
682 // CRm. op2 differentiates the opcodes.
683 def BarrierAsmOperand : AsmOperandClass {
684 let Name = "Barrier";
685 let ParserMethod = "tryParseBarrierOperand";
687 def barrier_op : Operand<i32> {
688 let PrintMethod = "printBarrierOption";
689 let ParserMatchClass = BarrierAsmOperand;
691 class CRmSystemI<Operand crmtype, bits<3> opc, string asm>
692 : SimpleSystemI<0, (ins crmtype:$CRm), asm, "\t$CRm">,
693 Sched<[WriteBarrier]> {
695 let Inst{20-12} = 0b000110011;
696 let Inst{11-8} = CRm;
700 // MRS/MSR system instructions. These have different operand classes because
701 // a different subset of registers can be accessed through each instruction.
702 def MRSSystemRegisterOperand : AsmOperandClass {
703 let Name = "MRSSystemRegister";
704 let ParserMethod = "tryParseSysReg";
706 // concatenation of 1, op0, op1, CRn, CRm, op2. 16-bit immediate.
707 def mrs_sysreg_op : Operand<i32> {
708 let ParserMatchClass = MRSSystemRegisterOperand;
709 let DecoderMethod = "DecodeMRSSystemRegister";
710 let PrintMethod = "printMRSSystemRegister";
713 def MSRSystemRegisterOperand : AsmOperandClass {
714 let Name = "MSRSystemRegister";
715 let ParserMethod = "tryParseSysReg";
717 def msr_sysreg_op : Operand<i32> {
718 let ParserMatchClass = MSRSystemRegisterOperand;
719 let DecoderMethod = "DecodeMSRSystemRegister";
720 let PrintMethod = "printMSRSystemRegister";
723 class MRSI : RtSystemI<1, (outs GPR64:$Rt), (ins mrs_sysreg_op:$systemreg),
724 "mrs", "\t$Rt, $systemreg"> {
727 let Inst{19-5} = systemreg;
730 // FIXME: Some of these def CPSR, others don't. Best way to model that?
731 // Explicitly modeling each of the system register as a register class
732 // would do it, but feels like overkill at this point.
733 class MSRI : RtSystemI<0, (outs), (ins msr_sysreg_op:$systemreg, GPR64:$Rt),
734 "msr", "\t$systemreg, $Rt"> {
737 let Inst{19-5} = systemreg;
740 def SystemCPSRFieldOperand : AsmOperandClass {
741 let Name = "SystemCPSRField";
742 let ParserMethod = "tryParseSysReg";
744 def cpsrfield_op : Operand<i32> {
745 let ParserMatchClass = SystemCPSRFieldOperand;
746 let PrintMethod = "printSystemCPSRField";
750 class MSRcpsrI : SimpleSystemI<0, (ins cpsrfield_op:$cpsr_field, imm0_15:$imm),
751 "msr", "\t$cpsr_field, $imm">,
755 let Inst{20-19} = 0b00;
756 let Inst{18-16} = cpsrfield{5-3};
757 let Inst{15-12} = 0b0100;
758 let Inst{11-8} = imm;
759 let Inst{7-5} = cpsrfield{2-0};
761 let DecoderMethod = "DecodeSystemCPSRInstruction";
764 // SYS and SYSL generic system instructions.
765 def SysCRAsmOperand : AsmOperandClass {
767 let ParserMethod = "tryParseSysCROperand";
770 def sys_cr_op : Operand<i32> {
771 let PrintMethod = "printSysCROperand";
772 let ParserMatchClass = SysCRAsmOperand;
775 class SystemI<bit L, string asm>
777 (ins imm0_7:$op1, sys_cr_op:$Cn, sys_cr_op:$Cm, imm0_7:$op2),
778 asm, "\t$op1, $Cn, $Cm, $op2">,
784 let Inst{20-19} = 0b01;
785 let Inst{18-16} = op1;
786 let Inst{15-12} = Cn;
791 class SystemXtI<bit L, string asm>
792 : RtSystemI<L, (outs),
793 (ins imm0_7:$op1, sys_cr_op:$Cn, sys_cr_op:$Cm, imm0_7:$op2, GPR64:$Rt),
794 asm, "\t$op1, $Cn, $Cm, $op2, $Rt"> {
799 let Inst{20-19} = 0b01;
800 let Inst{18-16} = op1;
801 let Inst{15-12} = Cn;
806 class SystemLXtI<bit L, string asm>
807 : RtSystemI<L, (outs),
808 (ins GPR64:$Rt, imm0_7:$op1, sys_cr_op:$Cn, sys_cr_op:$Cm, imm0_7:$op2),
809 asm, "\t$Rt, $op1, $Cn, $Cm, $op2"> {
814 let Inst{20-19} = 0b01;
815 let Inst{18-16} = op1;
816 let Inst{15-12} = Cn;
822 // Branch (register) instructions:
830 // otherwise UNDEFINED
831 class BaseBranchReg<bits<4> opc, dag oops, dag iops, string asm,
832 string operands, list<dag> pattern>
833 : I<oops, iops, asm, operands, "", pattern>, Sched<[WriteBrReg]> {
834 let Inst{31-25} = 0b1101011;
835 let Inst{24-21} = opc;
836 let Inst{20-16} = 0b11111;
837 let Inst{15-10} = 0b000000;
838 let Inst{4-0} = 0b00000;
841 class BranchReg<bits<4> opc, string asm, list<dag> pattern>
842 : BaseBranchReg<opc, (outs), (ins GPR64:$Rn), asm, "\t$Rn", pattern> {
847 let mayLoad = 0, mayStore = 0, hasSideEffects = 1, isReturn = 1 in
848 class SpecialReturn<bits<4> opc, string asm>
849 : BaseBranchReg<opc, (outs), (ins), asm, "", []> {
850 let Inst{9-5} = 0b11111;
854 // Conditional branch instruction.
856 // Branch condition code.
857 // 4-bit immediate. Pretty-printed as .<cc>
858 def dotCcode : Operand<i32> {
859 let PrintMethod = "printDotCondCode";
862 // Conditional branch target. 19-bit immediate. The low two bits of the target
863 // offset are implied zero and so are not part of the immediate.
864 def BranchTarget19Operand : AsmOperandClass {
865 let Name = "BranchTarget19";
867 def am_brcond : Operand<OtherVT> {
868 let EncoderMethod = "getCondBranchTargetOpValue";
869 let DecoderMethod = "DecodeCondBranchTarget";
870 let PrintMethod = "printAlignedBranchTarget";
871 let ParserMatchClass = BranchTarget19Operand;
874 class BranchCond : I<(outs), (ins dotCcode:$cond, am_brcond:$target),
875 "b", "$cond\t$target", "",
876 [(ARM64brcond bb:$target, imm:$cond, CPSR)]>,
879 let isTerminator = 1;
884 let Inst{31-24} = 0b01010100;
885 let Inst{23-5} = target;
887 let Inst{3-0} = cond;
891 // Compare-and-branch instructions.
893 class BaseCmpBranch<RegisterClass regtype, bit op, string asm, SDNode node>
894 : I<(outs), (ins regtype:$Rt, am_brcond:$target),
895 asm, "\t$Rt, $target", "",
896 [(node regtype:$Rt, bb:$target)]>,
899 let isTerminator = 1;
903 let Inst{30-25} = 0b011010;
905 let Inst{23-5} = target;
909 multiclass CmpBranch<bit op, string asm, SDNode node> {
910 def W : BaseCmpBranch<GPR32, op, asm, node> {
913 def X : BaseCmpBranch<GPR64, op, asm, node> {
919 // Test-bit-and-branch instructions.
921 // Test-and-branch target. 14-bit sign-extended immediate. The low two bits of
922 // the target offset are implied zero and so are not part of the immediate.
923 def BranchTarget14Operand : AsmOperandClass {
924 let Name = "BranchTarget14";
926 def am_tbrcond : Operand<OtherVT> {
927 let EncoderMethod = "getTestBranchTargetOpValue";
928 let PrintMethod = "printAlignedBranchTarget";
929 let ParserMatchClass = BranchTarget14Operand;
932 class TestBranch<bit op, string asm, SDNode node>
933 : I<(outs), (ins GPR64:$Rt, imm0_63:$bit_off, am_tbrcond:$target),
934 asm, "\t$Rt, $bit_off, $target", "",
935 [(node GPR64:$Rt, imm0_63:$bit_off, bb:$target)]>,
938 let isTerminator = 1;
944 let Inst{31} = bit_off{5};
945 let Inst{30-25} = 0b011011;
947 let Inst{23-19} = bit_off{4-0};
948 let Inst{18-5} = target;
951 let DecoderMethod = "DecodeTestAndBranch";
955 // Unconditional branch (immediate) instructions.
957 def BranchTarget26Operand : AsmOperandClass {
958 let Name = "BranchTarget26";
960 def am_b_target : Operand<OtherVT> {
961 let EncoderMethod = "getBranchTargetOpValue";
962 let PrintMethod = "printAlignedBranchTarget";
963 let ParserMatchClass = BranchTarget26Operand;
965 def am_bl_target : Operand<i64> {
966 let EncoderMethod = "getBranchTargetOpValue";
967 let PrintMethod = "printAlignedBranchTarget";
968 let ParserMatchClass = BranchTarget26Operand;
971 class BImm<bit op, dag iops, string asm, list<dag> pattern>
972 : I<(outs), iops, asm, "\t$addr", "", pattern>, Sched<[WriteBr]> {
975 let Inst{30-26} = 0b00101;
976 let Inst{25-0} = addr;
978 let DecoderMethod = "DecodeUnconditionalBranch";
981 class BranchImm<bit op, string asm, list<dag> pattern>
982 : BImm<op, (ins am_b_target:$addr), asm, pattern>;
983 class CallImm<bit op, string asm, list<dag> pattern>
984 : BImm<op, (ins am_bl_target:$addr), asm, pattern>;
987 // Basic one-operand data processing instructions.
990 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
991 class BaseOneOperandData<bits<3> opc, RegisterClass regtype, string asm,
992 SDPatternOperator node>
993 : I<(outs regtype:$Rd), (ins regtype:$Rn), asm, "\t$Rd, $Rn", "",
994 [(set regtype:$Rd, (node regtype:$Rn))]>,
999 let Inst{30-13} = 0b101101011000000000;
1000 let Inst{12-10} = opc;
1005 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1006 multiclass OneOperandData<bits<3> opc, string asm,
1007 SDPatternOperator node = null_frag> {
1008 def Wr : BaseOneOperandData<opc, GPR32, asm, node> {
1012 def Xr : BaseOneOperandData<opc, GPR64, asm, node> {
1017 class OneWRegData<bits<3> opc, string asm, SDPatternOperator node>
1018 : BaseOneOperandData<opc, GPR32, asm, node> {
1022 class OneXRegData<bits<3> opc, string asm, SDPatternOperator node>
1023 : BaseOneOperandData<opc, GPR64, asm, node> {
1028 // Basic two-operand data processing instructions.
1030 class BaseBaseAddSubCarry<bit isSub, RegisterClass regtype, string asm,
1032 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
1033 asm, "\t$Rd, $Rn, $Rm", "", pattern>,
1039 let Inst{30} = isSub;
1040 let Inst{28-21} = 0b11010000;
1041 let Inst{20-16} = Rm;
1042 let Inst{15-10} = 0;
1047 class BaseAddSubCarry<bit isSub, RegisterClass regtype, string asm,
1049 : BaseBaseAddSubCarry<isSub, regtype, asm,
1050 [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm, CPSR))]>;
1052 class BaseAddSubCarrySetFlags<bit isSub, RegisterClass regtype, string asm,
1054 : BaseBaseAddSubCarry<isSub, regtype, asm,
1055 [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm, CPSR)),
1060 multiclass AddSubCarry<bit isSub, string asm, string asm_setflags,
1061 SDNode OpNode, SDNode OpNode_setflags> {
1062 def Wr : BaseAddSubCarry<isSub, GPR32, asm, OpNode> {
1066 def Xr : BaseAddSubCarry<isSub, GPR64, asm, OpNode> {
1072 def SWr : BaseAddSubCarrySetFlags<isSub, GPR32, asm_setflags,
1077 def SXr : BaseAddSubCarrySetFlags<isSub, GPR64, asm_setflags,
1084 class BaseTwoOperand<bits<4> opc, RegisterClass regtype, string asm,
1085 SDPatternOperator OpNode>
1086 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
1087 asm, "\t$Rd, $Rn, $Rm", "",
1088 [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm))]> {
1092 let Inst{30-21} = 0b0011010110;
1093 let Inst{20-16} = Rm;
1094 let Inst{15-14} = 0b00;
1095 let Inst{13-10} = opc;
1100 class BaseDiv<bit isSigned, RegisterClass regtype, string asm,
1101 SDPatternOperator OpNode>
1102 : BaseTwoOperand<{0,0,1,?}, regtype, asm, OpNode> {
1103 let Inst{10} = isSigned;
1106 multiclass Div<bit isSigned, string asm, SDPatternOperator OpNode> {
1107 def Wr : BaseDiv<isSigned, GPR32, asm, OpNode>,
1108 Sched<[WriteID32]> {
1111 def Xr : BaseDiv<isSigned, GPR64, asm, OpNode>,
1112 Sched<[WriteID64]> {
1117 class BaseShift<bits<2> shift_type, RegisterClass regtype, string asm,
1118 SDPatternOperator OpNode = null_frag>
1119 : BaseTwoOperand<{1,0,?,?}, regtype, asm, OpNode>,
1121 let Inst{11-10} = shift_type;
1124 multiclass Shift<bits<2> shift_type, string asm, SDNode OpNode> {
1125 def Wr : BaseShift<shift_type, GPR32, asm> {
1129 def Xr : BaseShift<shift_type, GPR64, asm, OpNode> {
1133 def : Pat<(i32 (OpNode GPR32:$Rn, i64:$Rm)),
1134 (!cast<Instruction>(NAME # "Wr") GPR32:$Rn,
1135 (EXTRACT_SUBREG i64:$Rm, sub_32))>;
1137 def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (zext GPR32:$Rm)))),
1138 (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1140 def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (anyext GPR32:$Rm)))),
1141 (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1143 def : Pat<(i32 (OpNode GPR32:$Rn, (i64 (sext GPR32:$Rm)))),
1144 (!cast<Instruction>(NAME # "Wr") GPR32:$Rn, GPR32:$Rm)>;
1147 class ShiftAlias<string asm, Instruction inst, RegisterClass regtype>
1148 : InstAlias<asm#" $dst, $src1, $src2",
1149 (inst regtype:$dst, regtype:$src1, regtype:$src2)>;
1151 class BaseMulAccum<bit isSub, bits<3> opc, RegisterClass multype,
1152 RegisterClass addtype, string asm,
1154 : I<(outs addtype:$Rd), (ins multype:$Rn, multype:$Rm, addtype:$Ra),
1155 asm, "\t$Rd, $Rn, $Rm, $Ra", "", pattern> {
1160 let Inst{30-24} = 0b0011011;
1161 let Inst{23-21} = opc;
1162 let Inst{20-16} = Rm;
1163 let Inst{15} = isSub;
1164 let Inst{14-10} = Ra;
1169 multiclass MulAccum<bit isSub, string asm, SDNode AccNode> {
1170 def Wrrr : BaseMulAccum<isSub, 0b000, GPR32, GPR32, asm,
1171 [(set GPR32:$Rd, (AccNode GPR32:$Ra, (mul GPR32:$Rn, GPR32:$Rm)))]>,
1172 Sched<[WriteIM32]> {
1176 def Xrrr : BaseMulAccum<isSub, 0b000, GPR64, GPR64, asm,
1177 [(set GPR64:$Rd, (AccNode GPR64:$Ra, (mul GPR64:$Rn, GPR64:$Rm)))]>,
1178 Sched<[WriteIM64]> {
1183 class WideMulAccum<bit isSub, bits<3> opc, string asm,
1184 SDNode AccNode, SDNode ExtNode>
1185 : BaseMulAccum<isSub, opc, GPR32, GPR64, asm,
1186 [(set GPR64:$Rd, (AccNode GPR64:$Ra,
1187 (mul (ExtNode GPR32:$Rn), (ExtNode GPR32:$Rm))))]>,
1188 Sched<[WriteIM32]> {
1192 class MulHi<bits<3> opc, string asm, SDNode OpNode>
1193 : I<(outs GPR64:$Rd), (ins GPR64:$Rn, GPR64:$Rm),
1194 asm, "\t$Rd, $Rn, $Rm", "",
1195 [(set GPR64:$Rd, (OpNode GPR64:$Rn, GPR64:$Rm))]>,
1196 Sched<[WriteIM64]> {
1200 let Inst{31-24} = 0b10011011;
1201 let Inst{23-21} = opc;
1202 let Inst{20-16} = Rm;
1207 // The Ra field of SMULH and UMULH is unused: it should be assembled as 31
1208 // (i.e. all bits 1) but is ignored by the processor.
1209 let PostEncoderMethod = "fixMulHigh";
1212 class MulAccumWAlias<string asm, Instruction inst>
1213 : InstAlias<asm#" $dst, $src1, $src2",
1214 (inst GPR32:$dst, GPR32:$src1, GPR32:$src2, WZR)>;
1215 class MulAccumXAlias<string asm, Instruction inst>
1216 : InstAlias<asm#" $dst, $src1, $src2",
1217 (inst GPR64:$dst, GPR64:$src1, GPR64:$src2, XZR)>;
1218 class WideMulAccumAlias<string asm, Instruction inst>
1219 : InstAlias<asm#" $dst, $src1, $src2",
1220 (inst GPR64:$dst, GPR32:$src1, GPR32:$src2, XZR)>;
1222 class BaseCRC32<bit sf, bits<2> sz, bit C, RegisterClass StreamReg,
1223 SDPatternOperator OpNode, string asm>
1224 : I<(outs GPR32:$Rd), (ins GPR32:$Rn, StreamReg:$Rm),
1225 asm, "\t$Rd, $Rn, $Rm", "",
1226 [(set GPR32:$Rd, (OpNode GPR32:$Rn, StreamReg:$Rm))]>,
1227 Sched<[WriteISReg]> {
1233 let Inst{30-21} = 0b0011010110;
1234 let Inst{20-16} = Rm;
1235 let Inst{15-13} = 0b010;
1237 let Inst{11-10} = sz;
1243 // Address generation.
1246 class ADRI<bit page, string asm, Operand adr, list<dag> pattern>
1247 : I<(outs GPR64:$Xd), (ins adr:$label), asm, "\t$Xd, $label", "",
1252 let Inst{31} = page;
1253 let Inst{30-29} = label{1-0};
1254 let Inst{28-24} = 0b10000;
1255 let Inst{23-5} = label{20-2};
1258 let DecoderMethod = "DecodeAdrInstruction";
1265 def movimm32_imm : Operand<i32> {
1266 let ParserMatchClass = Imm0_65535Operand;
1267 let EncoderMethod = "getMoveWideImmOpValue";
1269 def movimm32_shift : Operand<i32> {
1270 let PrintMethod = "printShifter";
1271 let ParserMatchClass = MovImm32ShifterOperand;
1273 def movimm64_shift : Operand<i32> {
1274 let PrintMethod = "printShifter";
1275 let ParserMatchClass = MovImm64ShifterOperand;
1277 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1278 class BaseMoveImmediate<bits<2> opc, RegisterClass regtype, Operand shifter,
1280 : I<(outs regtype:$Rd), (ins movimm32_imm:$imm, shifter:$shift),
1281 asm, "\t$Rd, $imm$shift", "", []>,
1286 let Inst{30-29} = opc;
1287 let Inst{28-23} = 0b100101;
1288 let Inst{22-21} = shift{5-4};
1289 let Inst{20-5} = imm;
1292 let DecoderMethod = "DecodeMoveImmInstruction";
1295 multiclass MoveImmediate<bits<2> opc, string asm> {
1296 def Wi : BaseMoveImmediate<opc, GPR32, movimm32_shift, asm> {
1300 def Xi : BaseMoveImmediate<opc, GPR64, movimm64_shift, asm> {
1305 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1306 class BaseInsertImmediate<bits<2> opc, RegisterClass regtype, Operand shifter,
1308 : I<(outs regtype:$Rd),
1309 (ins regtype:$src, movimm32_imm:$imm, shifter:$shift),
1310 asm, "\t$Rd, $imm$shift", "$src = $Rd", []>,
1315 let Inst{30-29} = opc;
1316 let Inst{28-23} = 0b100101;
1317 let Inst{22-21} = shift{5-4};
1318 let Inst{20-5} = imm;
1321 let DecoderMethod = "DecodeMoveImmInstruction";
1324 multiclass InsertImmediate<bits<2> opc, string asm> {
1325 def Wi : BaseInsertImmediate<opc, GPR32, movimm32_shift, asm> {
1329 def Xi : BaseInsertImmediate<opc, GPR64, movimm64_shift, asm> {
1338 class BaseAddSubImm<bit isSub, bit setFlags, RegisterClass dstRegtype,
1339 RegisterClass srcRegtype, addsub_shifted_imm immtype,
1340 string asm, SDPatternOperator OpNode>
1341 : I<(outs dstRegtype:$Rd), (ins srcRegtype:$Rn, immtype:$imm),
1342 asm, "\t$Rd, $Rn, $imm", "",
1343 [(set dstRegtype:$Rd, (OpNode srcRegtype:$Rn, immtype:$imm))]>,
1348 let Inst{30} = isSub;
1349 let Inst{29} = setFlags;
1350 let Inst{28-24} = 0b10001;
1351 let Inst{23-22} = imm{13-12}; // '00' => lsl #0, '01' => lsl #12
1352 let Inst{21-10} = imm{11-0};
1355 let DecoderMethod = "DecodeBaseAddSubImm";
1358 class BaseAddSubRegPseudo<RegisterClass regtype,
1359 SDPatternOperator OpNode>
1360 : Pseudo<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
1361 [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm))]>,
1364 class BaseAddSubSReg<bit isSub, bit setFlags, RegisterClass regtype,
1365 arith_shifted_reg shifted_regtype, string asm,
1366 SDPatternOperator OpNode>
1367 : I<(outs regtype:$Rd), (ins regtype:$Rn, shifted_regtype:$Rm),
1368 asm, "\t$Rd, $Rn, $Rm", "",
1369 [(set regtype:$Rd, (OpNode regtype:$Rn, shifted_regtype:$Rm))]>,
1370 Sched<[WriteISReg]> {
1371 // The operands are in order to match the 'addr' MI operands, so we
1372 // don't need an encoder method and by-name matching. Just use the default
1373 // in-order handling. Since we're using by-order, make sure the names
1379 let Inst{30} = isSub;
1380 let Inst{29} = setFlags;
1381 let Inst{28-24} = 0b01011;
1382 let Inst{23-22} = shift{7-6};
1384 let Inst{20-16} = src2;
1385 let Inst{15-10} = shift{5-0};
1386 let Inst{9-5} = src1;
1387 let Inst{4-0} = dst;
1389 let DecoderMethod = "DecodeThreeAddrSRegInstruction";
1392 class BaseAddSubEReg<bit isSub, bit setFlags, RegisterClass dstRegtype,
1393 RegisterClass src1Regtype, Operand src2Regtype,
1394 string asm, SDPatternOperator OpNode>
1395 : I<(outs dstRegtype:$R1),
1396 (ins src1Regtype:$R2, src2Regtype:$R3),
1397 asm, "\t$R1, $R2, $R3", "",
1398 [(set dstRegtype:$R1, (OpNode src1Regtype:$R2, src2Regtype:$R3))]>,
1399 Sched<[WriteIEReg]> {
1404 let Inst{30} = isSub;
1405 let Inst{29} = setFlags;
1406 let Inst{28-24} = 0b01011;
1407 let Inst{23-21} = 0b001;
1408 let Inst{20-16} = Rm;
1409 let Inst{15-13} = ext{5-3};
1410 let Inst{12-10} = ext{2-0};
1414 let DecoderMethod = "DecodeAddSubERegInstruction";
1417 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1418 class BaseAddSubEReg64<bit isSub, bit setFlags, RegisterClass dstRegtype,
1419 RegisterClass src1Regtype, RegisterClass src2Regtype,
1420 Operand ext_op, string asm>
1421 : I<(outs dstRegtype:$Rd),
1422 (ins src1Regtype:$Rn, src2Regtype:$Rm, ext_op:$ext),
1423 asm, "\t$Rd, $Rn, $Rm$ext", "", []>,
1424 Sched<[WriteIEReg]> {
1429 let Inst{30} = isSub;
1430 let Inst{29} = setFlags;
1431 let Inst{28-24} = 0b01011;
1432 let Inst{23-21} = 0b001;
1433 let Inst{20-16} = Rm;
1434 let Inst{15} = ext{5};
1435 let Inst{12-10} = ext{2-0};
1439 let DecoderMethod = "DecodeAddSubERegInstruction";
1442 // Aliases for register+register add/subtract.
1443 class AddSubRegAlias<string asm, Instruction inst, RegisterClass dstRegtype,
1444 RegisterClass src1Regtype, RegisterClass src2Regtype,
1446 : InstAlias<asm#" $dst, $src1, $src2",
1447 (inst dstRegtype:$dst, src1Regtype:$src1, src2Regtype:$src2,
1450 multiclass AddSub<bit isSub, string mnemonic,
1451 SDPatternOperator OpNode = null_frag> {
1452 let hasSideEffects = 0 in {
1453 // Add/Subtract immediate
1454 def Wri : BaseAddSubImm<isSub, 0, GPR32sp, GPR32sp, addsub_shifted_imm32,
1458 def Xri : BaseAddSubImm<isSub, 0, GPR64sp, GPR64sp, addsub_shifted_imm64,
1463 // Add/Subtract register - Only used for CodeGen
1464 def Wrr : BaseAddSubRegPseudo<GPR32, OpNode>;
1465 def Xrr : BaseAddSubRegPseudo<GPR64, OpNode>;
1467 // Add/Subtract shifted register
1468 def Wrs : BaseAddSubSReg<isSub, 0, GPR32, arith_shifted_reg32, mnemonic,
1472 def Xrs : BaseAddSubSReg<isSub, 0, GPR64, arith_shifted_reg64, mnemonic,
1478 // Add/Subtract extended register
1479 let AddedComplexity = 1, hasSideEffects = 0 in {
1480 def Wrx : BaseAddSubEReg<isSub, 0, GPR32sp, GPR32sp,
1481 arith_extended_reg32<i32>, mnemonic, OpNode> {
1484 def Xrx : BaseAddSubEReg<isSub, 0, GPR64sp, GPR64sp,
1485 arith_extended_reg32to64<i64>, mnemonic, OpNode> {
1490 def Xrx64 : BaseAddSubEReg64<isSub, 0, GPR64sp, GPR64sp, GPR64,
1491 arith_extendlsl64, mnemonic> {
1492 // UXTX and SXTX only.
1493 let Inst{14-13} = 0b11;
1497 // Register/register aliases with no shift when SP is not used.
1498 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrs"),
1499 GPR32, GPR32, GPR32, 0>;
1500 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Xrs"),
1501 GPR64, GPR64, GPR64, 0>;
1503 // Register/register aliases with no shift when either the destination or
1504 // first source register is SP. This relies on the shifted register aliases
1505 // above matching first in the case when SP is not used.
1506 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrx"),
1507 GPR32sp, GPR32sp, GPR32, 16>; // UXTW #0
1508 def : AddSubRegAlias<mnemonic,
1509 !cast<Instruction>(NAME#"Xrx64"),
1510 GPR64sp, GPR64sp, GPR64, 24>; // UXTX #0
1513 multiclass AddSubS<bit isSub, string mnemonic, SDNode OpNode> {
1514 let isCompare = 1, Defs = [CPSR] in {
1515 // Add/Subtract immediate
1516 def Wri : BaseAddSubImm<isSub, 1, GPR32, GPR32sp, addsub_shifted_imm32,
1520 def Xri : BaseAddSubImm<isSub, 1, GPR64, GPR64sp, addsub_shifted_imm64,
1525 // Add/Subtract register
1526 def Wrr : BaseAddSubRegPseudo<GPR32, OpNode>;
1527 def Xrr : BaseAddSubRegPseudo<GPR64, OpNode>;
1529 // Add/Subtract shifted register
1530 def Wrs : BaseAddSubSReg<isSub, 1, GPR32, arith_shifted_reg32, mnemonic,
1534 def Xrs : BaseAddSubSReg<isSub, 1, GPR64, arith_shifted_reg64, mnemonic,
1539 // Add/Subtract extended register
1540 let AddedComplexity = 1 in {
1541 def Wrx : BaseAddSubEReg<isSub, 1, GPR32, GPR32sp,
1542 arith_extended_reg32<i32>, mnemonic, OpNode> {
1545 def Xrx : BaseAddSubEReg<isSub, 1, GPR64, GPR64sp,
1546 arith_extended_reg32<i64>, mnemonic, OpNode> {
1551 def Xrx64 : BaseAddSubEReg64<isSub, 1, GPR64, GPR64sp, GPR64,
1552 arith_extendlsl64, mnemonic> {
1553 // UXTX and SXTX only.
1554 let Inst{14-13} = 0b11;
1559 // Register/register aliases with no shift when SP is not used.
1560 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrs"),
1561 GPR32, GPR32, GPR32, 0>;
1562 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Xrs"),
1563 GPR64, GPR64, GPR64, 0>;
1565 // Register/register aliases with no shift when the first source register
1566 // is SP. This relies on the shifted register aliases above matching first
1567 // in the case when SP is not used.
1568 def : AddSubRegAlias<mnemonic, !cast<Instruction>(NAME#"Wrx"),
1569 GPR32, GPR32sp, GPR32, 16>; // UXTW #0
1570 def : AddSubRegAlias<mnemonic,
1571 !cast<Instruction>(NAME#"Xrx64"),
1572 GPR64, GPR64sp, GPR64, 24>; // UXTX #0
1578 def SDTA64EXTR : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
1580 def ARM64Extr : SDNode<"ARM64ISD::EXTR", SDTA64EXTR>;
1582 class BaseExtractImm<RegisterClass regtype, Operand imm_type, string asm,
1584 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, imm_type:$imm),
1585 asm, "\t$Rd, $Rn, $Rm, $imm", "", patterns>,
1586 Sched<[WriteExtr, ReadExtrHi]> {
1592 let Inst{30-23} = 0b00100111;
1594 let Inst{20-16} = Rm;
1595 let Inst{15-10} = imm;
1600 multiclass ExtractImm<string asm> {
1601 def Wrri : BaseExtractImm<GPR32, imm0_31, asm,
1603 (ARM64Extr GPR32:$Rn, GPR32:$Rm, imm0_31:$imm))]> {
1606 // imm<5> must be zero.
1609 def Xrri : BaseExtractImm<GPR64, imm0_63, asm,
1611 (ARM64Extr GPR64:$Rn, GPR64:$Rm, imm0_63:$imm))]> {
1622 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1623 class BaseBitfieldImm<bits<2> opc,
1624 RegisterClass regtype, Operand imm_type, string asm>
1625 : I<(outs regtype:$Rd), (ins regtype:$Rn, imm_type:$immr, imm_type:$imms),
1626 asm, "\t$Rd, $Rn, $immr, $imms", "", []>,
1633 let Inst{30-29} = opc;
1634 let Inst{28-23} = 0b100110;
1635 let Inst{21-16} = immr;
1636 let Inst{15-10} = imms;
1641 multiclass BitfieldImm<bits<2> opc, string asm> {
1642 def Wri : BaseBitfieldImm<opc, GPR32, imm0_31, asm> {
1645 // imms<5> and immr<5> must be zero, else ReservedValue().
1649 def Xri : BaseBitfieldImm<opc, GPR64, imm0_63, asm> {
1655 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1656 class BaseBitfieldImmWith2RegArgs<bits<2> opc,
1657 RegisterClass regtype, Operand imm_type, string asm>
1658 : I<(outs regtype:$Rd), (ins regtype:$src, regtype:$Rn, imm_type:$immr,
1660 asm, "\t$Rd, $Rn, $immr, $imms", "$src = $Rd", []>,
1667 let Inst{30-29} = opc;
1668 let Inst{28-23} = 0b100110;
1669 let Inst{21-16} = immr;
1670 let Inst{15-10} = imms;
1675 multiclass BitfieldImmWith2RegArgs<bits<2> opc, string asm> {
1676 def Wri : BaseBitfieldImmWith2RegArgs<opc, GPR32, imm0_31, asm> {
1679 // imms<5> and immr<5> must be zero, else ReservedValue().
1683 def Xri : BaseBitfieldImmWith2RegArgs<opc, GPR64, imm0_63, asm> {
1693 // Logical (immediate)
1694 class BaseLogicalImm<bits<2> opc, RegisterClass dregtype,
1695 RegisterClass sregtype, Operand imm_type, string asm,
1697 : I<(outs dregtype:$Rd), (ins sregtype:$Rn, imm_type:$imm),
1698 asm, "\t$Rd, $Rn, $imm", "", pattern>,
1703 let Inst{30-29} = opc;
1704 let Inst{28-23} = 0b100100;
1705 let Inst{22} = imm{12};
1706 let Inst{21-16} = imm{11-6};
1707 let Inst{15-10} = imm{5-0};
1711 let DecoderMethod = "DecodeLogicalImmInstruction";
1714 // Logical (shifted register)
1715 class BaseLogicalSReg<bits<2> opc, bit N, RegisterClass regtype,
1716 logical_shifted_reg shifted_regtype, string asm,
1718 : I<(outs regtype:$Rd), (ins regtype:$Rn, shifted_regtype:$Rm),
1719 asm, "\t$Rd, $Rn, $Rm", "", pattern>,
1720 Sched<[WriteISReg]> {
1721 // The operands are in order to match the 'addr' MI operands, so we
1722 // don't need an encoder method and by-name matching. Just use the default
1723 // in-order handling. Since we're using by-order, make sure the names
1729 let Inst{30-29} = opc;
1730 let Inst{28-24} = 0b01010;
1731 let Inst{23-22} = shift{7-6};
1733 let Inst{20-16} = src2;
1734 let Inst{15-10} = shift{5-0};
1735 let Inst{9-5} = src1;
1736 let Inst{4-0} = dst;
1738 let DecoderMethod = "DecodeThreeAddrSRegInstruction";
1741 // Aliases for register+register logical instructions.
1742 class LogicalRegAlias<string asm, Instruction inst, RegisterClass regtype>
1743 : InstAlias<asm#" $dst, $src1, $src2",
1744 (inst regtype:$dst, regtype:$src1, regtype:$src2, 0)>;
1746 let AddedComplexity = 6 in
1747 multiclass LogicalImm<bits<2> opc, string mnemonic, SDNode OpNode> {
1748 def Wri : BaseLogicalImm<opc, GPR32sp, GPR32, logical_imm32, mnemonic,
1749 [(set GPR32sp:$Rd, (OpNode GPR32:$Rn,
1750 logical_imm32:$imm))]> {
1752 let Inst{22} = 0; // 64-bit version has an additional bit of immediate.
1754 def Xri : BaseLogicalImm<opc, GPR64sp, GPR64, logical_imm64, mnemonic,
1755 [(set GPR64sp:$Rd, (OpNode GPR64:$Rn,
1756 logical_imm64:$imm))]> {
1761 multiclass LogicalImmS<bits<2> opc, string mnemonic, SDNode OpNode> {
1762 let isCompare = 1, Defs = [CPSR] in {
1763 def Wri : BaseLogicalImm<opc, GPR32, GPR32, logical_imm32, mnemonic,
1764 [(set GPR32:$Rd, (OpNode GPR32:$Rn, logical_imm32:$imm))]> {
1766 let Inst{22} = 0; // 64-bit version has an additional bit of immediate.
1768 def Xri : BaseLogicalImm<opc, GPR64, GPR64, logical_imm64, mnemonic,
1769 [(set GPR64:$Rd, (OpNode GPR64:$Rn, logical_imm64:$imm))]> {
1772 } // end Defs = [CPSR]
1775 class BaseLogicalRegPseudo<RegisterClass regtype, SDPatternOperator OpNode>
1776 : Pseudo<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
1777 [(set regtype:$Rd, (OpNode regtype:$Rn, regtype:$Rm))]>,
1780 // Split from LogicalImm as not all instructions have both.
1781 multiclass LogicalReg<bits<2> opc, bit N, string mnemonic,
1782 SDPatternOperator OpNode> {
1783 def Wrr : BaseLogicalRegPseudo<GPR32, OpNode>;
1784 def Xrr : BaseLogicalRegPseudo<GPR64, OpNode>;
1786 def Wrs : BaseLogicalSReg<opc, N, GPR32, logical_shifted_reg32, mnemonic,
1787 [(set GPR32:$Rd, (OpNode GPR32:$Rn,
1788 logical_shifted_reg32:$Rm))]> {
1791 def Xrs : BaseLogicalSReg<opc, N, GPR64, logical_shifted_reg64, mnemonic,
1792 [(set GPR64:$Rd, (OpNode GPR64:$Rn,
1793 logical_shifted_reg64:$Rm))]> {
1797 def : LogicalRegAlias<mnemonic,
1798 !cast<Instruction>(NAME#"Wrs"), GPR32>;
1799 def : LogicalRegAlias<mnemonic,
1800 !cast<Instruction>(NAME#"Xrs"), GPR64>;
1803 // Split from LogicalReg to allow setting CPSR Defs
1804 multiclass LogicalRegS<bits<2> opc, bit N, string mnemonic> {
1805 let Defs = [CPSR], mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
1806 def Wrs : BaseLogicalSReg<opc, N, GPR32, logical_shifted_reg32, mnemonic, []>{
1809 def Xrs : BaseLogicalSReg<opc, N, GPR64, logical_shifted_reg64, mnemonic, []>{
1814 def : LogicalRegAlias<mnemonic,
1815 !cast<Instruction>(NAME#"Wrs"), GPR32>;
1816 def : LogicalRegAlias<mnemonic,
1817 !cast<Instruction>(NAME#"Xrs"), GPR64>;
1821 // Conditionally set flags
1825 // 4-bit immediate. Pretty-printed as <cc>
1826 def ccode : Operand<i32> {
1827 let PrintMethod = "printCondCode";
1830 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1831 class BaseCondSetFlagsImm<bit op, RegisterClass regtype, string asm>
1832 : I<(outs), (ins regtype:$Rn, imm0_31:$imm, imm0_15:$nzcv, ccode:$cond),
1833 asm, "\t$Rn, $imm, $nzcv, $cond", "", []>,
1844 let Inst{29-21} = 0b111010010;
1845 let Inst{20-16} = imm;
1846 let Inst{15-12} = cond;
1847 let Inst{11-10} = 0b10;
1850 let Inst{3-0} = nzcv;
1853 multiclass CondSetFlagsImm<bit op, string asm> {
1854 def Wi : BaseCondSetFlagsImm<op, GPR32, asm> {
1857 def Xi : BaseCondSetFlagsImm<op, GPR64, asm> {
1862 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
1863 class BaseCondSetFlagsReg<bit op, RegisterClass regtype, string asm>
1864 : I<(outs), (ins regtype:$Rn, regtype:$Rm, imm0_15:$nzcv, ccode:$cond),
1865 asm, "\t$Rn, $Rm, $nzcv, $cond", "", []>,
1876 let Inst{29-21} = 0b111010010;
1877 let Inst{20-16} = Rm;
1878 let Inst{15-12} = cond;
1879 let Inst{11-10} = 0b00;
1882 let Inst{3-0} = nzcv;
1885 multiclass CondSetFlagsReg<bit op, string asm> {
1886 def Wr : BaseCondSetFlagsReg<op, GPR32, asm> {
1889 def Xr : BaseCondSetFlagsReg<op, GPR64, asm> {
1895 // Conditional select
1898 class BaseCondSelect<bit op, bits<2> op2, RegisterClass regtype, string asm>
1899 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
1900 asm, "\t$Rd, $Rn, $Rm, $cond", "",
1902 (ARM64csel regtype:$Rn, regtype:$Rm, (i32 imm:$cond), CPSR))]>,
1912 let Inst{29-21} = 0b011010100;
1913 let Inst{20-16} = Rm;
1914 let Inst{15-12} = cond;
1915 let Inst{11-10} = op2;
1920 multiclass CondSelect<bit op, bits<2> op2, string asm> {
1921 def Wr : BaseCondSelect<op, op2, GPR32, asm> {
1924 def Xr : BaseCondSelect<op, op2, GPR64, asm> {
1929 class BaseCondSelectOp<bit op, bits<2> op2, RegisterClass regtype, string asm,
1931 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
1932 asm, "\t$Rd, $Rn, $Rm, $cond", "",
1934 (ARM64csel regtype:$Rn, (frag regtype:$Rm),
1935 (i32 imm:$cond), CPSR))]>,
1945 let Inst{29-21} = 0b011010100;
1946 let Inst{20-16} = Rm;
1947 let Inst{15-12} = cond;
1948 let Inst{11-10} = op2;
1953 multiclass CondSelectOp<bit op, bits<2> op2, string asm, PatFrag frag> {
1954 def Wr : BaseCondSelectOp<op, op2, GPR32, asm, frag> {
1957 def Xr : BaseCondSelectOp<op, op2, GPR64, asm, frag> {
1963 // Special Mask Value
1965 def maski8_or_more : Operand<i32>,
1966 ImmLeaf<i32, [{ return (Imm & 0xff) == 0xff; }]> {
1968 def maski16_or_more : Operand<i32>,
1969 ImmLeaf<i32, [{ return (Imm & 0xffff) == 0xffff; }]> {
1977 // (unsigned immediate)
1978 // Indexed for 8-bit registers. offset is in range [0,4095].
1979 def MemoryIndexed8Operand : AsmOperandClass {
1980 let Name = "MemoryIndexed8";
1981 let DiagnosticType = "InvalidMemoryIndexed8";
1983 def am_indexed8 : Operand<i64>,
1984 ComplexPattern<i64, 2, "SelectAddrModeIndexed8", []> {
1985 let PrintMethod = "printAMIndexed8";
1987 = "getAMIndexed8OpValue<ARM64::fixup_arm64_ldst_imm12_scale1>";
1988 let ParserMatchClass = MemoryIndexed8Operand;
1989 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
1992 // Indexed for 16-bit registers. offset is multiple of 2 in range [0,8190],
1993 // stored as immval/2 (the 12-bit literal that encodes directly into the insn).
1994 def MemoryIndexed16Operand : AsmOperandClass {
1995 let Name = "MemoryIndexed16";
1996 let DiagnosticType = "InvalidMemoryIndexed16";
1998 def am_indexed16 : Operand<i64>,
1999 ComplexPattern<i64, 2, "SelectAddrModeIndexed16", []> {
2000 let PrintMethod = "printAMIndexed16";
2002 = "getAMIndexed8OpValue<ARM64::fixup_arm64_ldst_imm12_scale2>";
2003 let ParserMatchClass = MemoryIndexed16Operand;
2004 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
2007 // Indexed for 32-bit registers. offset is multiple of 4 in range [0,16380],
2008 // stored as immval/4 (the 12-bit literal that encodes directly into the insn).
2009 def MemoryIndexed32Operand : AsmOperandClass {
2010 let Name = "MemoryIndexed32";
2011 let DiagnosticType = "InvalidMemoryIndexed32";
2013 def am_indexed32 : Operand<i64>,
2014 ComplexPattern<i64, 2, "SelectAddrModeIndexed32", []> {
2015 let PrintMethod = "printAMIndexed32";
2017 = "getAMIndexed8OpValue<ARM64::fixup_arm64_ldst_imm12_scale4>";
2018 let ParserMatchClass = MemoryIndexed32Operand;
2019 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
2022 // Indexed for 64-bit registers. offset is multiple of 8 in range [0,32760],
2023 // stored as immval/8 (the 12-bit literal that encodes directly into the insn).
2024 def MemoryIndexed64Operand : AsmOperandClass {
2025 let Name = "MemoryIndexed64";
2026 let DiagnosticType = "InvalidMemoryIndexed64";
2028 def am_indexed64 : Operand<i64>,
2029 ComplexPattern<i64, 2, "SelectAddrModeIndexed64", []> {
2030 let PrintMethod = "printAMIndexed64";
2032 = "getAMIndexed8OpValue<ARM64::fixup_arm64_ldst_imm12_scale8>";
2033 let ParserMatchClass = MemoryIndexed64Operand;
2034 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
2037 // Indexed for 128-bit registers. offset is multiple of 16 in range [0,65520],
2038 // stored as immval/16 (the 12-bit literal that encodes directly into the insn).
2039 def MemoryIndexed128Operand : AsmOperandClass {
2040 let Name = "MemoryIndexed128";
2041 let DiagnosticType = "InvalidMemoryIndexed128";
2043 def am_indexed128 : Operand<i64>,
2044 ComplexPattern<i64, 2, "SelectAddrModeIndexed128", []> {
2045 let PrintMethod = "printAMIndexed128";
2047 = "getAMIndexed8OpValue<ARM64::fixup_arm64_ldst_imm12_scale16>";
2048 let ParserMatchClass = MemoryIndexed128Operand;
2049 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
2053 def MemoryNoIndexOperand : AsmOperandClass { let Name = "MemoryNoIndex"; }
2054 def am_noindex : Operand<i64>,
2055 ComplexPattern<i64, 1, "SelectAddrModeNoIndex", []> {
2056 let PrintMethod = "printAMNoIndex";
2057 let ParserMatchClass = MemoryNoIndexOperand;
2058 let MIOperandInfo = (ops GPR64sp:$base);
2061 class BaseLoadStoreUI<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
2062 string asm, list<dag> pattern>
2063 : I<oops, iops, asm, "\t$Rt, $addr", "", pattern> {
2067 bits<5> base = addr{4-0};
2068 bits<12> offset = addr{16-5};
2070 let Inst{31-30} = sz;
2071 let Inst{29-27} = 0b111;
2073 let Inst{25-24} = 0b01;
2074 let Inst{23-22} = opc;
2075 let Inst{21-10} = offset;
2076 let Inst{9-5} = base;
2077 let Inst{4-0} = dst;
2079 let DecoderMethod = "DecodeUnsignedLdStInstruction";
2082 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
2083 class LoadUI<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2084 Operand indextype, string asm, list<dag> pattern>
2085 : BaseLoadStoreUI<sz, V, opc,
2086 (outs regtype:$Rt), (ins indextype:$addr), asm, pattern>,
2089 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
2090 class StoreUI<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2091 Operand indextype, string asm, list<dag> pattern>
2092 : BaseLoadStoreUI<sz, V, opc,
2093 (outs), (ins regtype:$Rt, indextype:$addr), asm, pattern>,
2096 def PrefetchOperand : AsmOperandClass {
2097 let Name = "Prefetch";
2098 let ParserMethod = "tryParsePrefetch";
2100 def prfop : Operand<i32> {
2101 let PrintMethod = "printPrefetchOp";
2102 let ParserMatchClass = PrefetchOperand;
2105 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2106 class PrefetchUI<bits<2> sz, bit V, bits<2> opc, string asm, list<dag> pat>
2107 : BaseLoadStoreUI<sz, V, opc,
2108 (outs), (ins prfop:$Rt, am_indexed64:$addr), asm, pat>,
2115 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
2116 class LoadLiteral<bits<2> opc, bit V, RegisterClass regtype, string asm>
2117 : I<(outs regtype:$Rt), (ins am_brcond:$label),
2118 asm, "\t$Rt, $label", "", []>,
2122 let Inst{31-30} = opc;
2123 let Inst{29-27} = 0b011;
2125 let Inst{25-24} = 0b00;
2126 let Inst{23-5} = label;
2130 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2131 class PrefetchLiteral<bits<2> opc, bit V, string asm, list<dag> pat>
2132 : I<(outs), (ins prfop:$Rt, am_brcond:$label),
2133 asm, "\t$Rt, $label", "", pat>,
2137 let Inst{31-30} = opc;
2138 let Inst{29-27} = 0b011;
2140 let Inst{25-24} = 0b00;
2141 let Inst{23-5} = label;
2146 // Load/store register offset
2149 class MemROAsmOperand<int sz> : AsmOperandClass {
2150 let Name = "MemoryRegisterOffset"#sz;
2153 def MemROAsmOperand8 : MemROAsmOperand<8>;
2154 def MemROAsmOperand16 : MemROAsmOperand<16>;
2155 def MemROAsmOperand32 : MemROAsmOperand<32>;
2156 def MemROAsmOperand64 : MemROAsmOperand<64>;
2157 def MemROAsmOperand128 : MemROAsmOperand<128>;
2159 class ro_indexed<int sz> : Operand<i64> { // ComplexPattern<...>
2160 let PrintMethod = "printMemoryRegOffset"#sz;
2161 let MIOperandInfo = (ops GPR64sp:$base, GPR64:$offset, i32imm:$extend);
2164 def ro_indexed8 : ro_indexed<8>, ComplexPattern<i64, 3, "SelectAddrModeRO8", []> {
2165 let ParserMatchClass = MemROAsmOperand8;
2168 def ro_indexed16 : ro_indexed<16>, ComplexPattern<i64, 3, "SelectAddrModeRO16", []> {
2169 let ParserMatchClass = MemROAsmOperand16;
2172 def ro_indexed32 : ro_indexed<32>, ComplexPattern<i64, 3, "SelectAddrModeRO32", []> {
2173 let ParserMatchClass = MemROAsmOperand32;
2176 def ro_indexed64 : ro_indexed<64>, ComplexPattern<i64, 3, "SelectAddrModeRO64", []> {
2177 let ParserMatchClass = MemROAsmOperand64;
2180 def ro_indexed128 : ro_indexed<128>, ComplexPattern<i64, 3, "SelectAddrModeRO128", []> {
2181 let ParserMatchClass = MemROAsmOperand128;
2184 class LoadStore8RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2185 string asm, dag ins, dag outs, list<dag> pat>
2186 : I<ins, outs, asm, "\t$Rt, $addr", "", pat> {
2187 // The operands are in order to match the 'addr' MI operands, so we
2188 // don't need an encoder method and by-name matching. Just use the default
2189 // in-order handling. Since we're using by-order, make sure the names
2195 let Inst{31-30} = sz;
2196 let Inst{29-27} = 0b111;
2198 let Inst{25-24} = 0b00;
2199 let Inst{23-22} = opc;
2201 let Inst{20-16} = offset;
2202 let Inst{15-13} = extend{3-1};
2204 let Inst{12} = extend{0};
2205 let Inst{11-10} = 0b10;
2206 let Inst{9-5} = base;
2207 let Inst{4-0} = dst;
2209 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2212 class Load8RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2213 string asm, list<dag> pat>
2214 : LoadStore8RO<sz, V, opc, regtype, asm,
2215 (outs regtype:$Rt), (ins ro_indexed8:$addr), pat>,
2216 Sched<[WriteLDIdx, ReadAdrBase]>;
2218 class Store8RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2219 string asm, list<dag> pat>
2220 : LoadStore8RO<sz, V, opc, regtype, asm,
2221 (outs), (ins regtype:$Rt, ro_indexed8:$addr), pat>,
2222 Sched<[WriteSTIdx, ReadAdrBase]>;
2224 class LoadStore16RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2225 string asm, dag ins, dag outs, list<dag> pat>
2226 : I<ins, outs, asm, "\t$Rt, $addr", "", pat> {
2227 // The operands are in order to match the 'addr' MI operands, so we
2228 // don't need an encoder method and by-name matching. Just use the default
2229 // in-order handling. Since we're using by-order, make sure the names
2235 let Inst{31-30} = sz;
2236 let Inst{29-27} = 0b111;
2238 let Inst{25-24} = 0b00;
2239 let Inst{23-22} = opc;
2241 let Inst{20-16} = offset;
2242 let Inst{15-13} = extend{3-1};
2244 let Inst{12} = extend{0};
2245 let Inst{11-10} = 0b10;
2246 let Inst{9-5} = base;
2247 let Inst{4-0} = dst;
2249 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2252 class Load16RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2253 string asm, list<dag> pat>
2254 : LoadStore16RO<sz, V, opc, regtype, asm,
2255 (outs regtype:$Rt), (ins ro_indexed16:$addr), pat>,
2256 Sched<[WriteLDIdx, ReadAdrBase]>;
2258 class Store16RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2259 string asm, list<dag> pat>
2260 : LoadStore16RO<sz, V, opc, regtype, asm,
2261 (outs), (ins regtype:$Rt, ro_indexed16:$addr), pat>,
2262 Sched<[WriteSTIdx, ReadAdrBase]>;
2264 class LoadStore32RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2265 string asm, dag ins, dag outs, list<dag> pat>
2266 : I<ins, outs, asm, "\t$Rt, $addr", "", pat> {
2267 // The operands are in order to match the 'addr' MI operands, so we
2268 // don't need an encoder method and by-name matching. Just use the default
2269 // in-order handling. Since we're using by-order, make sure the names
2275 let Inst{31-30} = sz;
2276 let Inst{29-27} = 0b111;
2278 let Inst{25-24} = 0b00;
2279 let Inst{23-22} = opc;
2281 let Inst{20-16} = offset;
2282 let Inst{15-13} = extend{3-1};
2284 let Inst{12} = extend{0};
2285 let Inst{11-10} = 0b10;
2286 let Inst{9-5} = base;
2287 let Inst{4-0} = dst;
2289 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2292 class Load32RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2293 string asm, list<dag> pat>
2294 : LoadStore32RO<sz, V, opc, regtype, asm,
2295 (outs regtype:$Rt), (ins ro_indexed32:$addr), pat>,
2296 Sched<[WriteLDIdx, ReadAdrBase]>;
2298 class Store32RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2299 string asm, list<dag> pat>
2300 : LoadStore32RO<sz, V, opc, regtype, asm,
2301 (outs), (ins regtype:$Rt, ro_indexed32:$addr), pat>,
2302 Sched<[WriteSTIdx, ReadAdrBase]>;
2304 class LoadStore64RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2305 string asm, dag ins, dag outs, list<dag> pat>
2306 : I<ins, outs, asm, "\t$Rt, $addr", "", pat> {
2307 // The operands are in order to match the 'addr' MI operands, so we
2308 // don't need an encoder method and by-name matching. Just use the default
2309 // in-order handling. Since we're using by-order, make sure the names
2315 let Inst{31-30} = sz;
2316 let Inst{29-27} = 0b111;
2318 let Inst{25-24} = 0b00;
2319 let Inst{23-22} = opc;
2321 let Inst{20-16} = offset;
2322 let Inst{15-13} = extend{3-1};
2324 let Inst{12} = extend{0};
2325 let Inst{11-10} = 0b10;
2326 let Inst{9-5} = base;
2327 let Inst{4-0} = dst;
2329 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2332 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
2333 class Load64RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2334 string asm, list<dag> pat>
2335 : LoadStore64RO<sz, V, opc, regtype, asm,
2336 (outs regtype:$Rt), (ins ro_indexed64:$addr), pat>,
2337 Sched<[WriteLDIdx, ReadAdrBase]>;
2339 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
2340 class Store64RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2341 string asm, list<dag> pat>
2342 : LoadStore64RO<sz, V, opc, regtype, asm,
2343 (outs), (ins regtype:$Rt, ro_indexed64:$addr), pat>,
2344 Sched<[WriteSTIdx, ReadAdrBase]>;
2347 class LoadStore128RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2348 string asm, dag ins, dag outs, list<dag> pat>
2349 : I<ins, outs, asm, "\t$Rt, $addr", "", pat> {
2350 // The operands are in order to match the 'addr' MI operands, so we
2351 // don't need an encoder method and by-name matching. Just use the default
2352 // in-order handling. Since we're using by-order, make sure the names
2358 let Inst{31-30} = sz;
2359 let Inst{29-27} = 0b111;
2361 let Inst{25-24} = 0b00;
2362 let Inst{23-22} = opc;
2364 let Inst{20-16} = offset;
2365 let Inst{15-13} = extend{3-1};
2367 let Inst{12} = extend{0};
2368 let Inst{11-10} = 0b10;
2369 let Inst{9-5} = base;
2370 let Inst{4-0} = dst;
2372 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2375 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
2376 class Load128RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2377 string asm, list<dag> pat>
2378 : LoadStore128RO<sz, V, opc, regtype, asm,
2379 (outs regtype:$Rt), (ins ro_indexed128:$addr), pat>,
2380 Sched<[WriteLDIdx, ReadAdrBase]>;
2382 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
2383 class Store128RO<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2384 string asm, list<dag> pat>
2385 : LoadStore128RO<sz, V, opc, regtype, asm,
2386 (outs), (ins regtype:$Rt, ro_indexed128:$addr), pat>,
2387 Sched<[WriteSTIdx, ReadAdrBase]>;
2389 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2390 class PrefetchRO<bits<2> sz, bit V, bits<2> opc, string asm, list<dag> pat>
2391 : I<(outs), (ins prfop:$Rt, ro_indexed64:$addr), asm,
2392 "\t$Rt, $addr", "", pat>,
2394 // The operands are in order to match the 'addr' MI operands, so we
2395 // don't need an encoder method and by-name matching. Just use the default
2396 // in-order handling. Since we're using by-order, make sure the names
2402 let Inst{31-30} = sz;
2403 let Inst{29-27} = 0b111;
2405 let Inst{25-24} = 0b00;
2406 let Inst{23-22} = opc;
2408 let Inst{20-16} = offset;
2409 let Inst{15-13} = extend{3-1};
2411 let Inst{12} = extend{0};
2412 let Inst{11-10} = 0b10;
2413 let Inst{9-5} = base;
2414 let Inst{4-0} = dst;
2416 let DecoderMethod = "DecodeRegOffsetLdStInstruction";
2420 // Load/store unscaled immediate
2423 def MemoryUnscaledOperand : AsmOperandClass {
2424 let Name = "MemoryUnscaled";
2425 let DiagnosticType = "InvalidMemoryIndexedSImm9";
2427 class am_unscaled_operand : Operand<i64> {
2428 let PrintMethod = "printAMUnscaled";
2429 let ParserMatchClass = MemoryUnscaledOperand;
2430 let MIOperandInfo = (ops GPR64sp:$base, i64imm:$offset);
2432 def am_unscaled : am_unscaled_operand;
2433 def am_unscaled8 : am_unscaled_operand,
2434 ComplexPattern<i64, 2, "SelectAddrModeUnscaled8", []>;
2435 def am_unscaled16 : am_unscaled_operand,
2436 ComplexPattern<i64, 2, "SelectAddrModeUnscaled16", []>;
2437 def am_unscaled32 : am_unscaled_operand,
2438 ComplexPattern<i64, 2, "SelectAddrModeUnscaled32", []>;
2439 def am_unscaled64 : am_unscaled_operand,
2440 ComplexPattern<i64, 2, "SelectAddrModeUnscaled64", []>;
2441 def am_unscaled128 : am_unscaled_operand,
2442 ComplexPattern<i64, 2, "SelectAddrModeUnscaled128", []>;
2444 class BaseLoadStoreUnscale<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
2445 string asm, list<dag> pattern>
2446 : I<oops, iops, asm, "\t$Rt, $addr", "", pattern> {
2447 // The operands are in order to match the 'addr' MI operands, so we
2448 // don't need an encoder method and by-name matching. Just use the default
2449 // in-order handling. Since we're using by-order, make sure the names
2454 let Inst{31-30} = sz;
2455 let Inst{29-27} = 0b111;
2457 let Inst{25-24} = 0b00;
2458 let Inst{23-22} = opc;
2460 let Inst{20-12} = offset;
2461 let Inst{11-10} = 0b00;
2462 let Inst{9-5} = base;
2463 let Inst{4-0} = dst;
2465 let DecoderMethod = "DecodeSignedLdStInstruction";
2468 let AddedComplexity = 1 in // try this before LoadUI
2469 class LoadUnscaled<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2470 Operand amtype, string asm, list<dag> pattern>
2471 : BaseLoadStoreUnscale<sz, V, opc, (outs regtype:$Rt),
2472 (ins amtype:$addr), asm, pattern>,
2475 let AddedComplexity = 1 in // try this before StoreUI
2476 class StoreUnscaled<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2477 Operand amtype, string asm, list<dag> pattern>
2478 : BaseLoadStoreUnscale<sz, V, opc, (outs),
2479 (ins regtype:$Rt, amtype:$addr), asm, pattern>,
2482 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
2483 class PrefetchUnscaled<bits<2> sz, bit V, bits<2> opc, string asm, list<dag> pat>
2484 : BaseLoadStoreUnscale<sz, V, opc, (outs),
2485 (ins prfop:$Rt, am_unscaled:$addr), asm, pat>,
2489 // Load/store unscaled immediate, unprivileged
2492 class BaseLoadStoreUnprivileged<bits<2> sz, bit V, bits<2> opc,
2493 dag oops, dag iops, string asm>
2494 : I<oops, iops, asm, "\t$Rt, $addr", "", []> {
2495 // The operands are in order to match the 'addr' MI operands, so we
2496 // don't need an encoder method and by-name matching. Just use the default
2497 // in-order handling. Since we're using by-order, make sure the names
2502 let Inst{31-30} = sz;
2503 let Inst{29-27} = 0b111;
2505 let Inst{25-24} = 0b00;
2506 let Inst{23-22} = opc;
2508 let Inst{20-12} = offset;
2509 let Inst{11-10} = 0b10;
2510 let Inst{9-5} = base;
2511 let Inst{4-0} = dst;
2513 let DecoderMethod = "DecodeSignedLdStInstruction";
2516 let mayStore = 0, mayLoad = 1, hasSideEffects = 0 in {
2517 class LoadUnprivileged<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2519 : BaseLoadStoreUnprivileged<sz, V, opc,
2520 (outs regtype:$Rt), (ins am_unscaled:$addr), asm>,
2524 let mayStore = 1, mayLoad = 0, hasSideEffects = 0 in {
2525 class StoreUnprivileged<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2527 : BaseLoadStoreUnprivileged<sz, V, opc,
2528 (outs), (ins regtype:$Rt, am_unscaled:$addr), asm>,
2533 // Load/store pre-indexed
2536 class BaseLoadStorePreIdx<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
2537 string asm, string cstr>
2538 : I<oops, iops, asm, "\t$Rt, $addr!", cstr, []> {
2539 // The operands are in order to match the 'addr' MI operands, so we
2540 // don't need an encoder method and by-name matching. Just use the default
2541 // in-order handling.
2545 let Inst{31-30} = sz;
2546 let Inst{29-27} = 0b111;
2548 let Inst{25-24} = 0;
2549 let Inst{23-22} = opc;
2551 let Inst{20-12} = offset;
2552 let Inst{11-10} = 0b11;
2553 let Inst{9-5} = base;
2554 let Inst{4-0} = dst;
2556 let DecoderMethod = "DecodeSignedLdStInstruction";
2559 let hasSideEffects = 0 in {
2560 let mayStore = 0, mayLoad = 1 in
2561 // FIXME: Modeling the write-back of these instructions for isel is tricky.
2562 // we need the complex addressing mode for the memory reference, but
2563 // we also need the write-back specified as a tied operand to the
2564 // base register. That combination does not play nicely with
2565 // the asm matcher and friends.
2566 class LoadPreIdx<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2568 : BaseLoadStorePreIdx<sz, V, opc,
2569 (outs regtype:$Rt/*, GPR64sp:$wback*/),
2570 (ins am_unscaled:$addr), asm, ""/*"$addr.base = $wback"*/>,
2571 Sched<[WriteLD, WriteAdr]>;
2573 let mayStore = 1, mayLoad = 0 in
2574 class StorePreIdx<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2576 : BaseLoadStorePreIdx<sz, V, opc,
2577 (outs/* GPR64sp:$wback*/),
2578 (ins regtype:$Rt, am_unscaled:$addr),
2579 asm, ""/*"$addr.base = $wback"*/>,
2580 Sched<[WriteAdr, WriteST]>;
2581 } // hasSideEffects = 0
2583 // ISel pseudo-instructions which have the tied operands. When the MC lowering
2584 // logic finally gets smart enough to strip off tied operands that are just
2585 // for isel convenience, we can get rid of these pseudos and just reference
2586 // the real instructions directly.
2588 // Ironically, also because of the writeback operands, we can't put the
2589 // matcher pattern directly on the instruction, but need to define it
2592 // Loads aren't matched with patterns here at all, but rather in C++
2594 let mayStore = 0, mayLoad = 1, hasSideEffects = 0 in {
2595 class LoadPreIdxPseudo<RegisterClass regtype>
2596 : Pseudo<(outs regtype:$Rt, GPR64sp:$wback),
2597 (ins am_noindex:$addr, simm9:$offset), [],
2598 "$addr.base = $wback,@earlyclobber $wback">,
2599 Sched<[WriteLD, WriteAdr]>;
2600 class LoadPostIdxPseudo<RegisterClass regtype>
2601 : Pseudo<(outs regtype:$Rt, GPR64sp:$wback),
2602 (ins am_noindex:$addr, simm9:$offset), [],
2603 "$addr.base = $wback,@earlyclobber $wback">,
2604 Sched<[WriteLD, WriteI]>;
2606 multiclass StorePreIdxPseudo<RegisterClass regtype, ValueType Ty,
2607 SDPatternOperator OpNode> {
2608 let mayStore = 1, mayLoad = 0, hasSideEffects = 0 in
2609 def _isel: Pseudo<(outs GPR64sp:$wback),
2610 (ins regtype:$Rt, am_noindex:$addr, simm9:$offset), [],
2611 "$addr.base = $wback,@earlyclobber $wback">,
2612 Sched<[WriteAdr, WriteST]>;
2614 def : Pat<(OpNode (Ty regtype:$Rt), am_noindex:$addr, simm9:$offset),
2615 (!cast<Instruction>(NAME#_isel) regtype:$Rt, am_noindex:$addr,
2620 // Load/store post-indexed
2623 // (pre-index) load/stores.
2624 class BaseLoadStorePostIdx<bits<2> sz, bit V, bits<2> opc, dag oops, dag iops,
2625 string asm, string cstr>
2626 : I<oops, iops, asm, "\t$Rt, $addr, $idx", cstr, []> {
2627 // The operands are in order to match the 'addr' MI operands, so we
2628 // don't need an encoder method and by-name matching. Just use the default
2629 // in-order handling.
2633 let Inst{31-30} = sz;
2634 let Inst{29-27} = 0b111;
2636 let Inst{25-24} = 0b00;
2637 let Inst{23-22} = opc;
2639 let Inst{20-12} = offset;
2640 let Inst{11-10} = 0b01;
2641 let Inst{9-5} = base;
2642 let Inst{4-0} = dst;
2644 let DecoderMethod = "DecodeSignedLdStInstruction";
2647 let hasSideEffects = 0 in {
2648 let mayStore = 0, mayLoad = 1 in
2649 // FIXME: Modeling the write-back of these instructions for isel is tricky.
2650 // we need the complex addressing mode for the memory reference, but
2651 // we also need the write-back specified as a tied operand to the
2652 // base register. That combination does not play nicely with
2653 // the asm matcher and friends.
2654 class LoadPostIdx<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2656 : BaseLoadStorePostIdx<sz, V, opc,
2657 (outs regtype:$Rt/*, GPR64sp:$wback*/),
2658 (ins am_noindex:$addr, simm9:$idx),
2659 asm, ""/*"$addr.base = $wback"*/>,
2660 Sched<[WriteLD, WriteI]>;
2662 let mayStore = 1, mayLoad = 0 in
2663 class StorePostIdx<bits<2> sz, bit V, bits<2> opc, RegisterClass regtype,
2665 : BaseLoadStorePostIdx<sz, V, opc,
2666 (outs/* GPR64sp:$wback*/),
2667 (ins regtype:$Rt, am_noindex:$addr, simm9:$idx),
2668 asm, ""/*"$addr.base = $wback"*/>,
2669 Sched<[WriteAdr, WriteST, ReadAdrBase]>;
2670 } // hasSideEffects = 0
2672 // ISel pseudo-instructions which have the tied operands. When the MC lowering
2673 // logic finally gets smart enough to strip off tied operands that are just
2674 // for isel convenience, we can get rid of these pseudos and just reference
2675 // the real instructions directly.
2677 // Ironically, also because of the writeback operands, we can't put the
2678 // matcher pattern directly on the instruction, but need to define it
2680 multiclass StorePostIdxPseudo<RegisterClass regtype, ValueType Ty,
2681 SDPatternOperator OpNode, Instruction Insn> {
2682 let mayStore = 1, mayLoad = 0, hasSideEffects = 0 in
2683 def _isel: Pseudo<(outs GPR64sp:$wback),
2684 (ins regtype:$Rt, am_noindex:$addr, simm9:$idx), [],
2685 "$addr.base = $wback,@earlyclobber $wback">,
2686 PseudoInstExpansion<(Insn regtype:$Rt, am_noindex:$addr, simm9:$idx)>,
2687 Sched<[WriteAdr, WriteST, ReadAdrBase]>;
2689 def : Pat<(OpNode (Ty regtype:$Rt), am_noindex:$addr, simm9:$idx),
2690 (!cast<Instruction>(NAME#_isel) regtype:$Rt, am_noindex:$addr,
2698 // (indexed, offset)
2700 class BaseLoadStorePairOffset<bits<2> opc, bit V, bit L, dag oops, dag iops,
2702 : I<oops, iops, asm, "\t$Rt, $Rt2, $addr", "", []> {
2703 // The operands are in order to match the 'addr' MI operands, so we
2704 // don't need an encoder method and by-name matching. Just use the default
2705 // in-order handling. Since we're using by-order, make sure the names
2711 let Inst{31-30} = opc;
2712 let Inst{29-27} = 0b101;
2714 let Inst{25-23} = 0b010;
2716 let Inst{21-15} = offset;
2717 let Inst{14-10} = dst2;
2718 let Inst{9-5} = base;
2719 let Inst{4-0} = dst;
2721 let DecoderMethod = "DecodePairLdStInstruction";
2724 let hasSideEffects = 0 in {
2725 let mayStore = 0, mayLoad = 1 in
2726 class LoadPairOffset<bits<2> opc, bit V, RegisterClass regtype,
2727 Operand indextype, string asm>
2728 : BaseLoadStorePairOffset<opc, V, 1,
2729 (outs regtype:$Rt, regtype:$Rt2),
2730 (ins indextype:$addr), asm>,
2731 Sched<[WriteLD, WriteLDHi]>;
2733 let mayLoad = 0, mayStore = 1 in
2734 class StorePairOffset<bits<2> opc, bit V, RegisterClass regtype,
2735 Operand indextype, string asm>
2736 : BaseLoadStorePairOffset<opc, V, 0, (outs),
2737 (ins regtype:$Rt, regtype:$Rt2, indextype:$addr),
2740 } // hasSideEffects = 0
2744 def MemoryIndexed32SImm7 : AsmOperandClass {
2745 let Name = "MemoryIndexed32SImm7";
2746 let DiagnosticType = "InvalidMemoryIndexed32SImm7";
2748 def am_indexed32simm7 : Operand<i32> { // ComplexPattern<...>
2749 let PrintMethod = "printAMIndexed32";
2750 let ParserMatchClass = MemoryIndexed32SImm7;
2751 let MIOperandInfo = (ops GPR64sp:$base, i32imm:$offset);
2754 def MemoryIndexed64SImm7 : AsmOperandClass {
2755 let Name = "MemoryIndexed64SImm7";
2756 let DiagnosticType = "InvalidMemoryIndexed64SImm7";
2758 def am_indexed64simm7 : Operand<i32> { // ComplexPattern<...>
2759 let PrintMethod = "printAMIndexed64";
2760 let ParserMatchClass = MemoryIndexed64SImm7;
2761 let MIOperandInfo = (ops GPR64sp:$base, i32imm:$offset);
2764 def MemoryIndexed128SImm7 : AsmOperandClass {
2765 let Name = "MemoryIndexed128SImm7";
2766 let DiagnosticType = "InvalidMemoryIndexed128SImm7";
2768 def am_indexed128simm7 : Operand<i32> { // ComplexPattern<...>
2769 let PrintMethod = "printAMIndexed128";
2770 let ParserMatchClass = MemoryIndexed128SImm7;
2771 let MIOperandInfo = (ops GPR64sp:$base, i32imm:$offset);
2774 class BaseLoadStorePairPreIdx<bits<2> opc, bit V, bit L, dag oops, dag iops,
2776 : I<oops, iops, asm, "\t$Rt, $Rt2, $addr!", "", []> {
2777 // The operands are in order to match the 'addr' MI operands, so we
2778 // don't need an encoder method and by-name matching. Just use the default
2779 // in-order handling. Since we're using by-order, make sure the names
2785 let Inst{31-30} = opc;
2786 let Inst{29-27} = 0b101;
2788 let Inst{25-23} = 0b011;
2790 let Inst{21-15} = offset;
2791 let Inst{14-10} = dst2;
2792 let Inst{9-5} = base;
2793 let Inst{4-0} = dst;
2795 let DecoderMethod = "DecodePairLdStInstruction";
2798 let hasSideEffects = 0 in {
2799 let mayStore = 0, mayLoad = 1 in
2800 class LoadPairPreIdx<bits<2> opc, bit V, RegisterClass regtype,
2801 Operand addrmode, string asm>
2802 : BaseLoadStorePairPreIdx<opc, V, 1,
2803 (outs regtype:$Rt, regtype:$Rt2),
2804 (ins addrmode:$addr), asm>,
2805 Sched<[WriteLD, WriteLDHi, WriteAdr]>;
2807 let mayStore = 1, mayLoad = 0 in
2808 class StorePairPreIdx<bits<2> opc, bit V, RegisterClass regtype,
2809 Operand addrmode, string asm>
2810 : BaseLoadStorePairPreIdx<opc, V, 0, (outs),
2811 (ins regtype:$Rt, regtype:$Rt2, addrmode:$addr),
2813 Sched<[WriteAdr, WriteSTP]>;
2814 } // hasSideEffects = 0
2818 class BaseLoadStorePairPostIdx<bits<2> opc, bit V, bit L, dag oops, dag iops,
2820 : I<oops, iops, asm, "\t$Rt, $Rt2, $addr, $idx", "", []> {
2821 // The operands are in order to match the 'addr' MI operands, so we
2822 // don't need an encoder method and by-name matching. Just use the default
2823 // in-order handling. Since we're using by-order, make sure the names
2829 let Inst{31-30} = opc;
2830 let Inst{29-27} = 0b101;
2832 let Inst{25-23} = 0b001;
2834 let Inst{21-15} = offset;
2835 let Inst{14-10} = dst2;
2836 let Inst{9-5} = base;
2837 let Inst{4-0} = dst;
2839 let DecoderMethod = "DecodePairLdStInstruction";
2842 let hasSideEffects = 0 in {
2843 let mayStore = 0, mayLoad = 1 in
2844 class LoadPairPostIdx<bits<2> opc, bit V, RegisterClass regtype,
2845 Operand idxtype, string asm>
2846 : BaseLoadStorePairPostIdx<opc, V, 1,
2847 (outs regtype:$Rt, regtype:$Rt2),
2848 (ins am_noindex:$addr, idxtype:$idx), asm>,
2849 Sched<[WriteLD, WriteLDHi, WriteAdr]>;
2851 let mayStore = 1, mayLoad = 0 in
2852 class StorePairPostIdx<bits<2> opc, bit V, RegisterClass regtype,
2853 Operand idxtype, string asm>
2854 : BaseLoadStorePairPostIdx<opc, V, 0, (outs),
2855 (ins regtype:$Rt, regtype:$Rt2,
2856 am_noindex:$addr, idxtype:$idx),
2858 Sched<[WriteAdr, WriteSTP]>;
2859 } // hasSideEffects = 0
2863 class BaseLoadStorePairNoAlloc<bits<2> opc, bit V, bit L, dag oops, dag iops,
2865 : I<oops, iops, asm, "\t$Rt, $Rt2, $addr", "", []> {
2866 // The operands are in order to match the 'addr' MI operands, so we
2867 // don't need an encoder method and by-name matching. Just use the default
2868 // in-order handling. Since we're using by-order, make sure the names
2874 let Inst{31-30} = opc;
2875 let Inst{29-27} = 0b101;
2877 let Inst{25-23} = 0b000;
2879 let Inst{21-15} = offset;
2880 let Inst{14-10} = dst2;
2881 let Inst{9-5} = base;
2882 let Inst{4-0} = dst;
2884 let DecoderMethod = "DecodePairLdStInstruction";
2887 let hasSideEffects = 0 in {
2888 let mayStore = 0, mayLoad = 1 in
2889 class LoadPairNoAlloc<bits<2> opc, bit V, RegisterClass regtype,
2890 Operand indextype, string asm>
2891 : BaseLoadStorePairNoAlloc<opc, V, 1,
2892 (outs regtype:$Rt, regtype:$Rt2),
2893 (ins indextype:$addr), asm>,
2894 Sched<[WriteLD, WriteLDHi]>;
2896 let mayStore = 1, mayLoad = 0 in
2897 class StorePairNoAlloc<bits<2> opc, bit V, RegisterClass regtype,
2898 Operand indextype, string asm>
2899 : BaseLoadStorePairNoAlloc<opc, V, 0, (outs),
2900 (ins regtype:$Rt, regtype:$Rt2, indextype:$addr),
2903 } // hasSideEffects = 0
2906 // Load/store exclusive
2909 // True exclusive operations write to and/or read from the system's exclusive
2910 // monitors, which as far as a compiler is concerned can be modelled as a
2911 // random shared memory address. Hence LoadExclusive mayStore.
2913 // Since these instructions have the undefined register bits set to 1 in
2914 // their canonical form, we need a post encoder method to set those bits
2915 // to 1 when encoding these instructions. We do this using the
2916 // fixLoadStoreExclusive function. This function has template parameters:
2918 // fixLoadStoreExclusive<int hasRs, int hasRt2>
2920 // hasRs indicates that the instruction uses the Rs field, so we won't set
2921 // it to 1 (and the same for Rt2). We don't need template parameters for
2922 // the other register fields since Rt and Rn are always used.
2924 let hasSideEffects = 1, mayLoad = 1, mayStore = 1 in
2925 class BaseLoadStoreExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2926 dag oops, dag iops, string asm, string operands>
2927 : I<oops, iops, asm, operands, "", []> {
2928 let Inst{31-30} = sz;
2929 let Inst{29-24} = 0b001000;
2935 let DecoderMethod = "DecodeExclusiveLdStInstruction";
2938 // Neither Rs nor Rt2 operands.
2939 class LoadStoreExclusiveSimple<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2940 dag oops, dag iops, string asm, string operands>
2941 : BaseLoadStoreExclusive<sz, o2, L, o1, o0, oops, iops, asm, operands> {
2944 let Inst{9-5} = base;
2945 let Inst{4-0} = reg;
2947 let PostEncoderMethod = "fixLoadStoreExclusive<0,0>";
2950 // Simple load acquires don't set the exclusive monitor
2951 let mayLoad = 1, mayStore = 0 in
2952 class LoadAcquire<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2953 RegisterClass regtype, string asm>
2954 : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs regtype:$Rt),
2955 (ins am_noindex:$addr), asm, "\t$Rt, $addr">,
2958 class LoadExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2959 RegisterClass regtype, string asm>
2960 : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs regtype:$Rt),
2961 (ins am_noindex:$addr), asm, "\t$Rt, $addr">,
2964 class LoadExclusivePair<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2965 RegisterClass regtype, string asm>
2966 : BaseLoadStoreExclusive<sz, o2, L, o1, o0,
2967 (outs regtype:$Rt, regtype:$Rt2),
2968 (ins am_noindex:$addr), asm,
2969 "\t$Rt, $Rt2, $addr">,
2970 Sched<[WriteLD, WriteLDHi]> {
2974 let Inst{14-10} = dst2;
2975 let Inst{9-5} = base;
2976 let Inst{4-0} = dst1;
2978 let PostEncoderMethod = "fixLoadStoreExclusive<0,1>";
2981 // Simple store release operations do not check the exclusive monitor.
2982 let mayLoad = 0, mayStore = 1 in
2983 class StoreRelease<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2984 RegisterClass regtype, string asm>
2985 : LoadStoreExclusiveSimple<sz, o2, L, o1, o0, (outs),
2986 (ins regtype:$Rt, am_noindex:$addr),
2987 asm, "\t$Rt, $addr">,
2990 let mayLoad = 1, mayStore = 1 in
2991 class StoreExclusive<bits<2> sz, bit o2, bit L, bit o1, bit o0,
2992 RegisterClass regtype, string asm>
2993 : BaseLoadStoreExclusive<sz, o2, L, o1, o0, (outs GPR32:$Ws),
2994 (ins regtype:$Rt, am_noindex:$addr),
2995 asm, "\t$Ws, $Rt, $addr">,
3000 let Inst{20-16} = status;
3001 let Inst{9-5} = base;
3002 let Inst{4-0} = reg;
3004 let Constraints = "@earlyclobber $Ws";
3005 let PostEncoderMethod = "fixLoadStoreExclusive<1,0>";
3008 class StoreExclusivePair<bits<2> sz, bit o2, bit L, bit o1, bit o0,
3009 RegisterClass regtype, string asm>
3010 : BaseLoadStoreExclusive<sz, o2, L, o1, o0,
3012 (ins regtype:$Rt, regtype:$Rt2, am_noindex:$addr),
3013 asm, "\t$Ws, $Rt, $Rt2, $addr">,
3019 let Inst{20-16} = status;
3020 let Inst{14-10} = dst2;
3021 let Inst{9-5} = base;
3022 let Inst{4-0} = dst1;
3024 let Constraints = "@earlyclobber $Ws";
3028 // Exception generation
3031 let mayLoad = 0, mayStore = 0, hasSideEffects = 1 in
3032 class ExceptionGeneration<bits<3> op1, bits<2> ll, string asm>
3033 : I<(outs), (ins imm0_65535:$imm), asm, "\t$imm", "", []>,
3036 let Inst{31-24} = 0b11010100;
3037 let Inst{23-21} = op1;
3038 let Inst{20-5} = imm;
3039 let Inst{4-2} = 0b000;
3044 // Floating point to integer conversion
3047 class BaseFPToIntegerUnscaled<bits<2> type, bits<2> rmode, bits<3> opcode,
3048 RegisterClass srcType, RegisterClass dstType,
3049 string asm, list<dag> pattern>
3050 : I<(outs dstType:$Rd), (ins srcType:$Rn),
3051 asm, "\t$Rd, $Rn", "", pattern>,
3052 Sched<[WriteFCvt]> {
3055 let Inst{30-29} = 0b00;
3056 let Inst{28-24} = 0b11110;
3057 let Inst{23-22} = type;
3059 let Inst{20-19} = rmode;
3060 let Inst{18-16} = opcode;
3061 let Inst{15-10} = 0;
3066 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3067 class BaseFPToInteger<bits<2> type, bits<2> rmode, bits<3> opcode,
3068 RegisterClass srcType, RegisterClass dstType,
3069 Operand immType, string asm>
3070 : I<(outs dstType:$Rd), (ins srcType:$Rn, immType:$scale),
3071 asm, "\t$Rd, $Rn, $scale", "", []>,
3072 Sched<[WriteFCvt]> {
3076 let Inst{30-29} = 0b00;
3077 let Inst{28-24} = 0b11110;
3078 let Inst{23-22} = type;
3080 let Inst{20-19} = rmode;
3081 let Inst{18-16} = opcode;
3082 let Inst{15-10} = scale;
3087 multiclass FPToIntegerUnscaled<bits<2> rmode, bits<3> opcode, string asm,
3088 SDPatternOperator OpN> {
3089 // Unscaled single-precision to 32-bit
3090 def UWSr : BaseFPToIntegerUnscaled<0b00, rmode, opcode, FPR32, GPR32, asm,
3091 [(set GPR32:$Rd, (OpN FPR32:$Rn))]> {
3092 let Inst{31} = 0; // 32-bit GPR flag
3095 // Unscaled single-precision to 64-bit
3096 def UXSr : BaseFPToIntegerUnscaled<0b00, rmode, opcode, FPR32, GPR64, asm,
3097 [(set GPR64:$Rd, (OpN FPR32:$Rn))]> {
3098 let Inst{31} = 1; // 64-bit GPR flag
3101 // Unscaled double-precision to 32-bit
3102 def UWDr : BaseFPToIntegerUnscaled<0b01, rmode, opcode, FPR64, GPR32, asm,
3103 [(set GPR32:$Rd, (OpN (f64 FPR64:$Rn)))]> {
3104 let Inst{31} = 0; // 32-bit GPR flag
3107 // Unscaled double-precision to 64-bit
3108 def UXDr : BaseFPToIntegerUnscaled<0b01, rmode, opcode, FPR64, GPR64, asm,
3109 [(set GPR64:$Rd, (OpN (f64 FPR64:$Rn)))]> {
3110 let Inst{31} = 1; // 64-bit GPR flag
3114 multiclass FPToIntegerScaled<bits<2> rmode, bits<3> opcode, string asm,
3115 SDPatternOperator OpN> {
3116 // Scaled single-precision to 32-bit
3117 def SWSri : BaseFPToInteger<0b00, rmode, opcode, FPR32, GPR32,
3118 fixedpoint32, asm> {
3119 let Inst{31} = 0; // 32-bit GPR flag
3123 // Scaled single-precision to 64-bit
3124 def SXSri : BaseFPToInteger<0b00, rmode, opcode, FPR32, GPR64,
3125 fixedpoint64, asm> {
3126 let Inst{31} = 1; // 64-bit GPR flag
3129 // Scaled double-precision to 32-bit
3130 def SWDri : BaseFPToInteger<0b01, rmode, opcode, FPR64, GPR32,
3131 fixedpoint32, asm> {
3132 let Inst{31} = 0; // 32-bit GPR flag
3136 // Scaled double-precision to 64-bit
3137 def SXDri : BaseFPToInteger<0b01, rmode, opcode, FPR64, GPR64,
3138 fixedpoint64, asm> {
3139 let Inst{31} = 1; // 64-bit GPR flag
3144 // Integer to floating point conversion
3147 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
3148 class BaseIntegerToFP<bit isUnsigned,
3149 RegisterClass srcType, RegisterClass dstType,
3150 Operand immType, string asm>
3151 : I<(outs dstType:$Rd), (ins srcType:$Rn, immType:$scale),
3152 asm, "\t$Rd, $Rn, $scale", "", []>,
3153 Sched<[WriteFCvt]> {
3157 let Inst{30-23} = 0b00111100;
3158 let Inst{21-17} = 0b00001;
3159 let Inst{16} = isUnsigned;
3160 let Inst{15-10} = scale;
3165 class BaseIntegerToFPUnscaled<bit isUnsigned,
3166 RegisterClass srcType, RegisterClass dstType,
3167 ValueType dvt, string asm, SDNode node>
3168 : I<(outs dstType:$Rd), (ins srcType:$Rn),
3169 asm, "\t$Rd, $Rn", "", [(set (dvt dstType:$Rd), (node srcType:$Rn))]>,
3170 Sched<[WriteFCvt]> {
3174 let Inst{30-23} = 0b00111100;
3175 let Inst{21-17} = 0b10001;
3176 let Inst{16} = isUnsigned;
3177 let Inst{15-10} = 0b000000;
3182 multiclass IntegerToFP<bit isUnsigned, string asm, SDNode node> {
3184 def UWSri: BaseIntegerToFPUnscaled<isUnsigned, GPR32, FPR32, f32, asm, node> {
3185 let Inst{31} = 0; // 32-bit GPR flag
3186 let Inst{22} = 0; // 32-bit FPR flag
3189 def UWDri: BaseIntegerToFPUnscaled<isUnsigned, GPR32, FPR64, f64, asm, node> {
3190 let Inst{31} = 0; // 32-bit GPR flag
3191 let Inst{22} = 1; // 64-bit FPR flag
3194 def UXSri: BaseIntegerToFPUnscaled<isUnsigned, GPR64, FPR32, f32, asm, node> {
3195 let Inst{31} = 1; // 64-bit GPR flag
3196 let Inst{22} = 0; // 32-bit FPR flag
3199 def UXDri: BaseIntegerToFPUnscaled<isUnsigned, GPR64, FPR64, f64, asm, node> {
3200 let Inst{31} = 1; // 64-bit GPR flag
3201 let Inst{22} = 1; // 64-bit FPR flag
3205 def SWSri: BaseIntegerToFP<isUnsigned, GPR32, FPR32, fixedpoint32, asm> {
3206 let Inst{31} = 0; // 32-bit GPR flag
3207 let Inst{22} = 0; // 32-bit FPR flag
3211 def SWDri: BaseIntegerToFP<isUnsigned, GPR32, FPR64, fixedpoint32, asm> {
3212 let Inst{31} = 0; // 32-bit GPR flag
3213 let Inst{22} = 1; // 64-bit FPR flag
3217 def SXSri: BaseIntegerToFP<isUnsigned, GPR64, FPR32, fixedpoint64, asm> {
3218 let Inst{31} = 1; // 64-bit GPR flag
3219 let Inst{22} = 0; // 32-bit FPR flag
3222 def SXDri: BaseIntegerToFP<isUnsigned, GPR64, FPR64, fixedpoint64, asm> {
3223 let Inst{31} = 1; // 64-bit GPR flag
3224 let Inst{22} = 1; // 64-bit FPR flag
3229 // Unscaled integer <-> floating point conversion (i.e. FMOV)
3232 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3233 class BaseUnscaledConversion<bits<2> rmode, bits<3> opcode,
3234 RegisterClass srcType, RegisterClass dstType,
3236 : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd, $Rn", "",
3237 // We use COPY_TO_REGCLASS for these bitconvert operations.
3238 // copyPhysReg() expands the resultant COPY instructions after
3239 // regalloc is done. This gives greater freedom for the allocator
3240 // and related passes (coalescing, copy propagation, et. al.) to
3241 // be more effective.
3242 [/*(set (dvt dstType:$Rd), (bitconvert (svt srcType:$Rn)))*/]>,
3243 Sched<[WriteFCopy]> {
3246 let Inst{30-23} = 0b00111100;
3248 let Inst{20-19} = rmode;
3249 let Inst{18-16} = opcode;
3250 let Inst{15-10} = 0b000000;
3255 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3256 class BaseUnscaledConversionToHigh<bits<2> rmode, bits<3> opcode,
3257 RegisterClass srcType, RegisterOperand dstType, string asm>
3258 : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd[1], $Rn", "", []>,
3259 Sched<[WriteFCopy]> {
3262 let Inst{30-23} = 0b00111101;
3264 let Inst{20-19} = rmode;
3265 let Inst{18-16} = opcode;
3266 let Inst{15-10} = 0b000000;
3271 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3272 class BaseUnscaledConversionFromHigh<bits<2> rmode, bits<3> opcode,
3273 RegisterOperand srcType, RegisterClass dstType, string asm>
3274 : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd, $Rn[1]", "", []>,
3275 Sched<[WriteFCopy]> {
3278 let Inst{30-23} = 0b00111101;
3280 let Inst{20-19} = rmode;
3281 let Inst{18-16} = opcode;
3282 let Inst{15-10} = 0b000000;
3289 multiclass UnscaledConversion<string asm> {
3290 def WSr : BaseUnscaledConversion<0b00, 0b111, GPR32, FPR32, asm> {
3291 let Inst{31} = 0; // 32-bit GPR flag
3292 let Inst{22} = 0; // 32-bit FPR flag
3295 def XDr : BaseUnscaledConversion<0b00, 0b111, GPR64, FPR64, asm> {
3296 let Inst{31} = 1; // 64-bit GPR flag
3297 let Inst{22} = 1; // 64-bit FPR flag
3300 def SWr : BaseUnscaledConversion<0b00, 0b110, FPR32, GPR32, asm> {
3301 let Inst{31} = 0; // 32-bit GPR flag
3302 let Inst{22} = 0; // 32-bit FPR flag
3305 def DXr : BaseUnscaledConversion<0b00, 0b110, FPR64, GPR64, asm> {
3306 let Inst{31} = 1; // 64-bit GPR flag
3307 let Inst{22} = 1; // 64-bit FPR flag
3310 def XDHighr : BaseUnscaledConversionToHigh<0b01, 0b111, GPR64, V128,
3316 def DXHighr : BaseUnscaledConversionFromHigh<0b01, 0b110, V128, GPR64,
3322 def : InstAlias<asm#"$Vd.d[1], $Rn",
3323 (!cast<Instruction>(NAME#XDHighr) V128:$Vd, GPR64:$Rn), 0>;
3324 def : InstAlias<asm#"$Rd, $Vn.d[1]",
3325 (!cast<Instruction>(NAME#DXHighr) GPR64:$Rd, V128:$Vn), 0>;
3329 // Floating point conversion
3332 class BaseFPConversion<bits<2> type, bits<2> opcode, RegisterClass dstType,
3333 RegisterClass srcType, string asm, list<dag> pattern>
3334 : I<(outs dstType:$Rd), (ins srcType:$Rn), asm, "\t$Rd, $Rn", "", pattern>,
3335 Sched<[WriteFCvt]> {
3338 let Inst{31-24} = 0b00011110;
3339 let Inst{23-22} = type;
3340 let Inst{21-17} = 0b10001;
3341 let Inst{16-15} = opcode;
3342 let Inst{14-10} = 0b10000;
3347 multiclass FPConversion<string asm> {
3348 // Double-precision to Half-precision
3349 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3350 def HDr : BaseFPConversion<0b01, 0b11, FPR16, FPR64, asm, []>;
3352 // Double-precision to Single-precision
3353 def SDr : BaseFPConversion<0b01, 0b00, FPR32, FPR64, asm,
3354 [(set FPR32:$Rd, (fround FPR64:$Rn))]>;
3356 // Half-precision to Double-precision
3357 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3358 def DHr : BaseFPConversion<0b11, 0b01, FPR64, FPR16, asm, []>;
3360 // Half-precision to Single-precision
3361 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3362 def SHr : BaseFPConversion<0b11, 0b00, FPR32, FPR16, asm, []>;
3364 // Single-precision to Double-precision
3365 def DSr : BaseFPConversion<0b00, 0b01, FPR64, FPR32, asm,
3366 [(set FPR64:$Rd, (fextend FPR32:$Rn))]>;
3368 // Single-precision to Half-precision
3369 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3370 def HSr : BaseFPConversion<0b00, 0b11, FPR16, FPR32, asm, []>;
3374 // Single operand floating point data processing
3377 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3378 class BaseSingleOperandFPData<bits<4> opcode, RegisterClass regtype,
3379 ValueType vt, string asm, SDPatternOperator node>
3380 : I<(outs regtype:$Rd), (ins regtype:$Rn), asm, "\t$Rd, $Rn", "",
3381 [(set (vt regtype:$Rd), (node (vt regtype:$Rn)))]>,
3385 let Inst{31-23} = 0b000111100;
3386 let Inst{21-19} = 0b100;
3387 let Inst{18-15} = opcode;
3388 let Inst{14-10} = 0b10000;
3393 multiclass SingleOperandFPData<bits<4> opcode, string asm,
3394 SDPatternOperator node = null_frag> {
3395 def Sr : BaseSingleOperandFPData<opcode, FPR32, f32, asm, node> {
3396 let Inst{22} = 0; // 32-bit size flag
3399 def Dr : BaseSingleOperandFPData<opcode, FPR64, f64, asm, node> {
3400 let Inst{22} = 1; // 64-bit size flag
3405 // Two operand floating point data processing
3408 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3409 class BaseTwoOperandFPData<bits<4> opcode, RegisterClass regtype,
3410 string asm, list<dag> pat>
3411 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm),
3412 asm, "\t$Rd, $Rn, $Rm", "", pat>,
3417 let Inst{31-23} = 0b000111100;
3419 let Inst{20-16} = Rm;
3420 let Inst{15-12} = opcode;
3421 let Inst{11-10} = 0b10;
3426 multiclass TwoOperandFPData<bits<4> opcode, string asm,
3427 SDPatternOperator node = null_frag> {
3428 def Srr : BaseTwoOperandFPData<opcode, FPR32, asm,
3429 [(set (f32 FPR32:$Rd),
3430 (node (f32 FPR32:$Rn), (f32 FPR32:$Rm)))]> {
3431 let Inst{22} = 0; // 32-bit size flag
3434 def Drr : BaseTwoOperandFPData<opcode, FPR64, asm,
3435 [(set (f64 FPR64:$Rd),
3436 (node (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]> {
3437 let Inst{22} = 1; // 64-bit size flag
3441 multiclass TwoOperandFPDataNeg<bits<4> opcode, string asm, SDNode node> {
3442 def Srr : BaseTwoOperandFPData<opcode, FPR32, asm,
3443 [(set FPR32:$Rd, (fneg (node FPR32:$Rn, (f32 FPR32:$Rm))))]> {
3444 let Inst{22} = 0; // 32-bit size flag
3447 def Drr : BaseTwoOperandFPData<opcode, FPR64, asm,
3448 [(set FPR64:$Rd, (fneg (node FPR64:$Rn, (f64 FPR64:$Rm))))]> {
3449 let Inst{22} = 1; // 64-bit size flag
3455 // Three operand floating point data processing
3458 class BaseThreeOperandFPData<bit isNegated, bit isSub,
3459 RegisterClass regtype, string asm, list<dag> pat>
3460 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, regtype: $Ra),
3461 asm, "\t$Rd, $Rn, $Rm, $Ra", "", pat>,
3462 Sched<[WriteFMul]> {
3467 let Inst{31-23} = 0b000111110;
3468 let Inst{21} = isNegated;
3469 let Inst{20-16} = Rm;
3470 let Inst{15} = isSub;
3471 let Inst{14-10} = Ra;
3476 multiclass ThreeOperandFPData<bit isNegated, bit isSub,string asm,
3477 SDPatternOperator node> {
3478 def Srrr : BaseThreeOperandFPData<isNegated, isSub, FPR32, asm,
3480 (node (f32 FPR32:$Rn), (f32 FPR32:$Rm), (f32 FPR32:$Ra)))]> {
3481 let Inst{22} = 0; // 32-bit size flag
3484 def Drrr : BaseThreeOperandFPData<isNegated, isSub, FPR64, asm,
3486 (node (f64 FPR64:$Rn), (f64 FPR64:$Rm), (f64 FPR64:$Ra)))]> {
3487 let Inst{22} = 1; // 64-bit size flag
3492 // Floating point data comparisons
3495 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3496 class BaseOneOperandFPComparison<bit signalAllNans,
3497 RegisterClass regtype, string asm,
3499 : I<(outs), (ins regtype:$Rn), asm, "\t$Rn, #0.0", "", pat>,
3500 Sched<[WriteFCmp]> {
3502 let Inst{31-23} = 0b000111100;
3505 let Inst{15-10} = 0b001000;
3507 let Inst{4} = signalAllNans;
3508 let Inst{3-0} = 0b1000;
3510 // Rm should be 0b00000 canonically, but we need to accept any value.
3511 let PostEncoderMethod = "fixOneOperandFPComparison";
3514 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3515 class BaseTwoOperandFPComparison<bit signalAllNans, RegisterClass regtype,
3516 string asm, list<dag> pat>
3517 : I<(outs), (ins regtype:$Rn, regtype:$Rm), asm, "\t$Rn, $Rm", "", pat>,
3518 Sched<[WriteFCmp]> {
3521 let Inst{31-23} = 0b000111100;
3523 let Inst{20-16} = Rm;
3524 let Inst{15-10} = 0b001000;
3526 let Inst{4} = signalAllNans;
3527 let Inst{3-0} = 0b0000;
3530 multiclass FPComparison<bit signalAllNans, string asm,
3531 SDPatternOperator OpNode = null_frag> {
3532 let Defs = [CPSR] in {
3533 def Srr : BaseTwoOperandFPComparison<signalAllNans, FPR32, asm,
3534 [(OpNode FPR32:$Rn, (f32 FPR32:$Rm)), (implicit CPSR)]> {
3538 def Sri : BaseOneOperandFPComparison<signalAllNans, FPR32, asm,
3539 [(OpNode (f32 FPR32:$Rn), fpimm0), (implicit CPSR)]> {
3543 def Drr : BaseTwoOperandFPComparison<signalAllNans, FPR64, asm,
3544 [(OpNode FPR64:$Rn, (f64 FPR64:$Rm)), (implicit CPSR)]> {
3548 def Dri : BaseOneOperandFPComparison<signalAllNans, FPR64, asm,
3549 [(OpNode (f64 FPR64:$Rn), fpimm0), (implicit CPSR)]> {
3556 // Floating point conditional comparisons
3559 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3560 class BaseFPCondComparison<bit signalAllNans,
3561 RegisterClass regtype, string asm>
3562 : I<(outs), (ins regtype:$Rn, regtype:$Rm, imm0_15:$nzcv, ccode:$cond),
3563 asm, "\t$Rn, $Rm, $nzcv, $cond", "", []>,
3564 Sched<[WriteFCmp]> {
3570 let Inst{31-23} = 0b000111100;
3572 let Inst{20-16} = Rm;
3573 let Inst{15-12} = cond;
3574 let Inst{11-10} = 0b01;
3576 let Inst{4} = signalAllNans;
3577 let Inst{3-0} = nzcv;
3580 multiclass FPCondComparison<bit signalAllNans, string asm> {
3581 let Defs = [CPSR], Uses = [CPSR] in {
3582 def Srr : BaseFPCondComparison<signalAllNans, FPR32, asm> {
3586 def Drr : BaseFPCondComparison<signalAllNans, FPR64, asm> {
3589 } // Defs = [CPSR], Uses = [CPSR]
3593 // Floating point conditional select
3596 class BaseFPCondSelect<RegisterClass regtype, ValueType vt, string asm>
3597 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, ccode:$cond),
3598 asm, "\t$Rd, $Rn, $Rm, $cond", "",
3600 (ARM64csel (vt regtype:$Rn), regtype:$Rm,
3601 (i32 imm:$cond), CPSR))]>,
3608 let Inst{31-23} = 0b000111100;
3610 let Inst{20-16} = Rm;
3611 let Inst{15-12} = cond;
3612 let Inst{11-10} = 0b11;
3617 multiclass FPCondSelect<string asm> {
3618 let Uses = [CPSR] in {
3619 def Srrr : BaseFPCondSelect<FPR32, f32, asm> {
3623 def Drrr : BaseFPCondSelect<FPR64, f64, asm> {
3630 // Floating move immediate
3633 class BaseFPMoveImmediate<RegisterClass regtype, Operand fpimmtype, string asm>
3634 : I<(outs regtype:$Rd), (ins fpimmtype:$imm), asm, "\t$Rd, $imm", "",
3635 [(set regtype:$Rd, fpimmtype:$imm)]>,
3636 Sched<[WriteFImm]> {
3639 let Inst{31-23} = 0b000111100;
3641 let Inst{20-13} = imm;
3642 let Inst{12-5} = 0b10000000;
3646 multiclass FPMoveImmediate<string asm> {
3647 def Si : BaseFPMoveImmediate<FPR32, fpimm32, asm> {
3651 def Di : BaseFPMoveImmediate<FPR64, fpimm64, asm> {
3656 //----------------------------------------------------------------------------
3658 //----------------------------------------------------------------------------
3660 def VectorIndexBOperand : AsmOperandClass { let Name = "VectorIndexB"; }
3661 def VectorIndexHOperand : AsmOperandClass { let Name = "VectorIndexH"; }
3662 def VectorIndexSOperand : AsmOperandClass { let Name = "VectorIndexS"; }
3663 def VectorIndexDOperand : AsmOperandClass { let Name = "VectorIndexD"; }
3664 def VectorIndexB : Operand<i64>, ImmLeaf<i64, [{
3665 return ((uint64_t)Imm) < 16;
3667 let ParserMatchClass = VectorIndexBOperand;
3668 let PrintMethod = "printVectorIndex";
3669 let MIOperandInfo = (ops i64imm);
3671 def VectorIndexH : Operand<i64>, ImmLeaf<i64, [{
3672 return ((uint64_t)Imm) < 8;
3674 let ParserMatchClass = VectorIndexHOperand;
3675 let PrintMethod = "printVectorIndex";
3676 let MIOperandInfo = (ops i64imm);
3678 def VectorIndexS : Operand<i64>, ImmLeaf<i64, [{
3679 return ((uint64_t)Imm) < 4;
3681 let ParserMatchClass = VectorIndexSOperand;
3682 let PrintMethod = "printVectorIndex";
3683 let MIOperandInfo = (ops i64imm);
3685 def VectorIndexD : Operand<i64>, ImmLeaf<i64, [{
3686 return ((uint64_t)Imm) < 2;
3688 let ParserMatchClass = VectorIndexDOperand;
3689 let PrintMethod = "printVectorIndex";
3690 let MIOperandInfo = (ops i64imm);
3693 //----------------------------------------------------------------------------
3694 // AdvSIMD three register vector instructions
3695 //----------------------------------------------------------------------------
3697 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3698 class BaseSIMDThreeSameVector<bit Q, bit U, bits<2> size, bits<5> opcode,
3699 RegisterOperand regtype, string asm, string kind,
3701 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
3702 "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
3703 "|" # kind # "\t$Rd, $Rn, $Rm|}", "", pattern>,
3711 let Inst{28-24} = 0b01110;
3712 let Inst{23-22} = size;
3714 let Inst{20-16} = Rm;
3715 let Inst{15-11} = opcode;
3721 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3722 class BaseSIMDThreeSameVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
3723 RegisterOperand regtype, string asm, string kind,
3725 : I<(outs regtype:$dst), (ins regtype:$Rd, regtype:$Rn, regtype:$Rm), asm,
3726 "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
3727 "|" # kind # "\t$Rd, $Rn, $Rm}", "$Rd = $dst", pattern>,
3735 let Inst{28-24} = 0b01110;
3736 let Inst{23-22} = size;
3738 let Inst{20-16} = Rm;
3739 let Inst{15-11} = opcode;
3745 // All operand sizes distinguished in the encoding.
3746 multiclass SIMDThreeSameVector<bit U, bits<5> opc, string asm,
3747 SDPatternOperator OpNode> {
3748 def v8i8 : BaseSIMDThreeSameVector<0, U, 0b00, opc, V64,
3750 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
3751 def v16i8 : BaseSIMDThreeSameVector<1, U, 0b00, opc, V128,
3753 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
3754 def v4i16 : BaseSIMDThreeSameVector<0, U, 0b01, opc, V64,
3756 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
3757 def v8i16 : BaseSIMDThreeSameVector<1, U, 0b01, opc, V128,
3759 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
3760 def v2i32 : BaseSIMDThreeSameVector<0, U, 0b10, opc, V64,
3762 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
3763 def v4i32 : BaseSIMDThreeSameVector<1, U, 0b10, opc, V128,
3765 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
3766 def v2i64 : BaseSIMDThreeSameVector<1, U, 0b11, opc, V128,
3768 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (v2i64 V128:$Rm)))]>;
3771 // As above, but D sized elements unsupported.
3772 multiclass SIMDThreeSameVectorBHS<bit U, bits<5> opc, string asm,
3773 SDPatternOperator OpNode> {
3774 def v8i8 : BaseSIMDThreeSameVector<0, U, 0b00, opc, V64,
3776 [(set V64:$Rd, (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm))))]>;
3777 def v16i8 : BaseSIMDThreeSameVector<1, U, 0b00, opc, V128,
3779 [(set V128:$Rd, (v16i8 (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm))))]>;
3780 def v4i16 : BaseSIMDThreeSameVector<0, U, 0b01, opc, V64,
3782 [(set V64:$Rd, (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm))))]>;
3783 def v8i16 : BaseSIMDThreeSameVector<1, U, 0b01, opc, V128,
3785 [(set V128:$Rd, (v8i16 (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm))))]>;
3786 def v2i32 : BaseSIMDThreeSameVector<0, U, 0b10, opc, V64,
3788 [(set V64:$Rd, (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm))))]>;
3789 def v4i32 : BaseSIMDThreeSameVector<1, U, 0b10, opc, V128,
3791 [(set V128:$Rd, (v4i32 (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm))))]>;
3794 multiclass SIMDThreeSameVectorBHSTied<bit U, bits<5> opc, string asm,
3795 SDPatternOperator OpNode> {
3796 def v8i8 : BaseSIMDThreeSameVectorTied<0, U, 0b00, opc, V64,
3798 [(set (v8i8 V64:$dst),
3799 (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
3800 def v16i8 : BaseSIMDThreeSameVectorTied<1, U, 0b00, opc, V128,
3802 [(set (v16i8 V128:$dst),
3803 (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
3804 def v4i16 : BaseSIMDThreeSameVectorTied<0, U, 0b01, opc, V64,
3806 [(set (v4i16 V64:$dst),
3807 (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
3808 def v8i16 : BaseSIMDThreeSameVectorTied<1, U, 0b01, opc, V128,
3810 [(set (v8i16 V128:$dst),
3811 (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
3812 def v2i32 : BaseSIMDThreeSameVectorTied<0, U, 0b10, opc, V64,
3814 [(set (v2i32 V64:$dst),
3815 (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
3816 def v4i32 : BaseSIMDThreeSameVectorTied<1, U, 0b10, opc, V128,
3818 [(set (v4i32 V128:$dst),
3819 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
3822 // As above, but only B sized elements supported.
3823 multiclass SIMDThreeSameVectorB<bit U, bits<5> opc, string asm,
3824 SDPatternOperator OpNode> {
3825 def v8i8 : BaseSIMDThreeSameVector<0, U, 0b00, opc, V64,
3827 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
3828 def v16i8 : BaseSIMDThreeSameVector<1, U, 0b00, opc, V128,
3830 [(set (v16i8 V128:$Rd),
3831 (OpNode (v16i8 V128:$Rn), (v16i8 V128:$Rm)))]>;
3834 // As above, but only S and D sized floating point elements supported.
3835 multiclass SIMDThreeSameVectorFP<bit U, bit S, bits<5> opc,
3836 string asm, SDPatternOperator OpNode> {
3837 def v2f32 : BaseSIMDThreeSameVector<0, U, {S,0}, opc, V64,
3839 [(set (v2f32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
3840 def v4f32 : BaseSIMDThreeSameVector<1, U, {S,0}, opc, V128,
3842 [(set (v4f32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
3843 def v2f64 : BaseSIMDThreeSameVector<1, U, {S,1}, opc, V128,
3845 [(set (v2f64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
3848 multiclass SIMDThreeSameVectorFPCmp<bit U, bit S, bits<5> opc,
3850 SDPatternOperator OpNode> {
3851 def v2f32 : BaseSIMDThreeSameVector<0, U, {S,0}, opc, V64,
3853 [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
3854 def v4f32 : BaseSIMDThreeSameVector<1, U, {S,0}, opc, V128,
3856 [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
3857 def v2f64 : BaseSIMDThreeSameVector<1, U, {S,1}, opc, V128,
3859 [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
3862 multiclass SIMDThreeSameVectorFPTied<bit U, bit S, bits<5> opc,
3863 string asm, SDPatternOperator OpNode> {
3864 def v2f32 : BaseSIMDThreeSameVectorTied<0, U, {S,0}, opc, V64,
3866 [(set (v2f32 V64:$dst),
3867 (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn), (v2f32 V64:$Rm)))]>;
3868 def v4f32 : BaseSIMDThreeSameVectorTied<1, U, {S,0}, opc, V128,
3870 [(set (v4f32 V128:$dst),
3871 (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn), (v4f32 V128:$Rm)))]>;
3872 def v2f64 : BaseSIMDThreeSameVectorTied<1, U, {S,1}, opc, V128,
3874 [(set (v2f64 V128:$dst),
3875 (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn), (v2f64 V128:$Rm)))]>;
3878 // As above, but D and B sized elements unsupported.
3879 multiclass SIMDThreeSameVectorHS<bit U, bits<5> opc, string asm,
3880 SDPatternOperator OpNode> {
3881 def v4i16 : BaseSIMDThreeSameVector<0, U, 0b01, opc, V64,
3883 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
3884 def v8i16 : BaseSIMDThreeSameVector<1, U, 0b01, opc, V128,
3886 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
3887 def v2i32 : BaseSIMDThreeSameVector<0, U, 0b10, opc, V64,
3889 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
3890 def v4i32 : BaseSIMDThreeSameVector<1, U, 0b10, opc, V128,
3892 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
3895 // Logical three vector ops share opcode bits, and only use B sized elements.
3896 multiclass SIMDLogicalThreeVector<bit U, bits<2> size, string asm,
3897 SDPatternOperator OpNode = null_frag> {
3898 def v8i8 : BaseSIMDThreeSameVector<0, U, size, 0b00011, V64,
3900 [(set (v8i8 V64:$Rd), (OpNode V64:$Rn, V64:$Rm))]>;
3901 def v16i8 : BaseSIMDThreeSameVector<1, U, size, 0b00011, V128,
3903 [(set (v16i8 V128:$Rd), (OpNode V128:$Rn, V128:$Rm))]>;
3905 def : Pat<(v4i16 (OpNode V64:$LHS, V64:$RHS)),
3906 (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
3907 def : Pat<(v2i32 (OpNode V64:$LHS, V64:$RHS)),
3908 (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
3909 def : Pat<(v1i64 (OpNode V64:$LHS, V64:$RHS)),
3910 (!cast<Instruction>(NAME#"v8i8") V64:$LHS, V64:$RHS)>;
3912 def : Pat<(v8i16 (OpNode V128:$LHS, V128:$RHS)),
3913 (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
3914 def : Pat<(v4i32 (OpNode V128:$LHS, V128:$RHS)),
3915 (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
3916 def : Pat<(v2i64 (OpNode V128:$LHS, V128:$RHS)),
3917 (!cast<Instruction>(NAME#"v16i8") V128:$LHS, V128:$RHS)>;
3920 multiclass SIMDLogicalThreeVectorTied<bit U, bits<2> size,
3921 string asm, SDPatternOperator OpNode> {
3922 def v8i8 : BaseSIMDThreeSameVectorTied<0, U, size, 0b00011, V64,
3924 [(set (v8i8 V64:$dst),
3925 (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
3926 def v16i8 : BaseSIMDThreeSameVectorTied<1, U, size, 0b00011, V128,
3928 [(set (v16i8 V128:$dst),
3929 (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
3930 (v16i8 V128:$Rm)))]>;
3932 def : Pat<(v4i16 (OpNode (v4i16 V64:$LHS), (v4i16 V64:$MHS),
3934 (!cast<Instruction>(NAME#"v8i8")
3935 V64:$LHS, V64:$MHS, V64:$RHS)>;
3936 def : Pat<(v2i32 (OpNode (v2i32 V64:$LHS), (v2i32 V64:$MHS),
3938 (!cast<Instruction>(NAME#"v8i8")
3939 V64:$LHS, V64:$MHS, V64:$RHS)>;
3940 def : Pat<(v1i64 (OpNode (v1i64 V64:$LHS), (v1i64 V64:$MHS),
3942 (!cast<Instruction>(NAME#"v8i8")
3943 V64:$LHS, V64:$MHS, V64:$RHS)>;
3945 def : Pat<(v8i16 (OpNode (v8i16 V128:$LHS), (v8i16 V128:$MHS),
3946 (v8i16 V128:$RHS))),
3947 (!cast<Instruction>(NAME#"v16i8")
3948 V128:$LHS, V128:$MHS, V128:$RHS)>;
3949 def : Pat<(v4i32 (OpNode (v4i32 V128:$LHS), (v4i32 V128:$MHS),
3950 (v4i32 V128:$RHS))),
3951 (!cast<Instruction>(NAME#"v16i8")
3952 V128:$LHS, V128:$MHS, V128:$RHS)>;
3953 def : Pat<(v2i64 (OpNode (v2i64 V128:$LHS), (v2i64 V128:$MHS),
3954 (v2i64 V128:$RHS))),
3955 (!cast<Instruction>(NAME#"v16i8")
3956 V128:$LHS, V128:$MHS, V128:$RHS)>;
3960 //----------------------------------------------------------------------------
3961 // AdvSIMD two register vector instructions.
3962 //----------------------------------------------------------------------------
3964 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3965 class BaseSIMDTwoSameVector<bit Q, bit U, bits<2> size, bits<5> opcode,
3966 RegisterOperand regtype, string asm, string dstkind,
3967 string srckind, list<dag> pattern>
3968 : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
3969 "{\t$Rd" # dstkind # ", $Rn" # srckind #
3970 "|" # dstkind # "\t$Rd, $Rn}", "", pattern>,
3977 let Inst{28-24} = 0b01110;
3978 let Inst{23-22} = size;
3979 let Inst{21-17} = 0b10000;
3980 let Inst{16-12} = opcode;
3981 let Inst{11-10} = 0b10;
3986 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
3987 class BaseSIMDTwoSameVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
3988 RegisterOperand regtype, string asm, string dstkind,
3989 string srckind, list<dag> pattern>
3990 : I<(outs regtype:$dst), (ins regtype:$Rd, regtype:$Rn), asm,
3991 "{\t$Rd" # dstkind # ", $Rn" # srckind #
3992 "|" # dstkind # "\t$Rd, $Rn}", "$Rd = $dst", pattern>,
3999 let Inst{28-24} = 0b01110;
4000 let Inst{23-22} = size;
4001 let Inst{21-17} = 0b10000;
4002 let Inst{16-12} = opcode;
4003 let Inst{11-10} = 0b10;
4008 // Supports B, H, and S element sizes.
4009 multiclass SIMDTwoVectorBHS<bit U, bits<5> opc, string asm,
4010 SDPatternOperator OpNode> {
4011 def v8i8 : BaseSIMDTwoSameVector<0, U, 0b00, opc, V64,
4013 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
4014 def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, V128,
4015 asm, ".16b", ".16b",
4016 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
4017 def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, V64,
4019 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
4020 def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, V128,
4022 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
4023 def v2i32 : BaseSIMDTwoSameVector<0, U, 0b10, opc, V64,
4025 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
4026 def v4i32 : BaseSIMDTwoSameVector<1, U, 0b10, opc, V128,
4028 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4031 class BaseSIMDVectorLShiftLongBySize<bit Q, bits<2> size,
4032 RegisterOperand regtype, string asm, string dstkind,
4033 string srckind, string amount>
4034 : I<(outs V128:$Rd), (ins regtype:$Rn), asm,
4035 "{\t$Rd" # dstkind # ", $Rn" # srckind # ", #" # amount #
4036 "|" # dstkind # "\t$Rd, $Rn, #" # amount # "}", "", []>,
4042 let Inst{29-24} = 0b101110;
4043 let Inst{23-22} = size;
4044 let Inst{21-10} = 0b100001001110;
4049 multiclass SIMDVectorLShiftLongBySizeBHS {
4050 let neverHasSideEffects = 1 in {
4051 def v8i8 : BaseSIMDVectorLShiftLongBySize<0, 0b00, V64,
4052 "shll", ".8h", ".8b", "8">;
4053 def v16i8 : BaseSIMDVectorLShiftLongBySize<1, 0b00, V128,
4054 "shll2", ".8h", ".16b", "8">;
4055 def v4i16 : BaseSIMDVectorLShiftLongBySize<0, 0b01, V64,
4056 "shll", ".4s", ".4h", "16">;
4057 def v8i16 : BaseSIMDVectorLShiftLongBySize<1, 0b01, V128,
4058 "shll2", ".4s", ".8h", "16">;
4059 def v2i32 : BaseSIMDVectorLShiftLongBySize<0, 0b10, V64,
4060 "shll", ".2d", ".2s", "32">;
4061 def v4i32 : BaseSIMDVectorLShiftLongBySize<1, 0b10, V128,
4062 "shll2", ".2d", ".4s", "32">;
4066 // Supports all element sizes.
4067 multiclass SIMDLongTwoVector<bit U, bits<5> opc, string asm,
4068 SDPatternOperator OpNode> {
4069 def v8i8_v4i16 : BaseSIMDTwoSameVector<0, U, 0b00, opc, V64,
4071 [(set (v4i16 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
4072 def v16i8_v8i16 : BaseSIMDTwoSameVector<1, U, 0b00, opc, V128,
4074 [(set (v8i16 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
4075 def v4i16_v2i32 : BaseSIMDTwoSameVector<0, U, 0b01, opc, V64,
4077 [(set (v2i32 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
4078 def v8i16_v4i32 : BaseSIMDTwoSameVector<1, U, 0b01, opc, V128,
4080 [(set (v4i32 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
4081 def v2i32_v1i64 : BaseSIMDTwoSameVector<0, U, 0b10, opc, V64,
4083 [(set (v1i64 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
4084 def v4i32_v2i64 : BaseSIMDTwoSameVector<1, U, 0b10, opc, V128,
4086 [(set (v2i64 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4089 multiclass SIMDLongTwoVectorTied<bit U, bits<5> opc, string asm,
4090 SDPatternOperator OpNode> {
4091 def v8i8_v4i16 : BaseSIMDTwoSameVectorTied<0, U, 0b00, opc, V64,
4093 [(set (v4i16 V64:$dst), (OpNode (v4i16 V64:$Rd),
4095 def v16i8_v8i16 : BaseSIMDTwoSameVectorTied<1, U, 0b00, opc, V128,
4097 [(set (v8i16 V128:$dst), (OpNode (v8i16 V128:$Rd),
4098 (v16i8 V128:$Rn)))]>;
4099 def v4i16_v2i32 : BaseSIMDTwoSameVectorTied<0, U, 0b01, opc, V64,
4101 [(set (v2i32 V64:$dst), (OpNode (v2i32 V64:$Rd),
4102 (v4i16 V64:$Rn)))]>;
4103 def v8i16_v4i32 : BaseSIMDTwoSameVectorTied<1, U, 0b01, opc, V128,
4105 [(set (v4i32 V128:$dst), (OpNode (v4i32 V128:$Rd),
4106 (v8i16 V128:$Rn)))]>;
4107 def v2i32_v1i64 : BaseSIMDTwoSameVectorTied<0, U, 0b10, opc, V64,
4109 [(set (v1i64 V64:$dst), (OpNode (v1i64 V64:$Rd),
4110 (v2i32 V64:$Rn)))]>;
4111 def v4i32_v2i64 : BaseSIMDTwoSameVectorTied<1, U, 0b10, opc, V128,
4113 [(set (v2i64 V128:$dst), (OpNode (v2i64 V128:$Rd),
4114 (v4i32 V128:$Rn)))]>;
4117 // Supports all element sizes, except 1xD.
4118 multiclass SIMDTwoVectorBHSDTied<bit U, bits<5> opc, string asm,
4119 SDPatternOperator OpNode> {
4120 def v8i8 : BaseSIMDTwoSameVectorTied<0, U, 0b00, opc, V64,
4122 [(set (v8i8 V64:$dst), (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn)))]>;
4123 def v16i8 : BaseSIMDTwoSameVectorTied<1, U, 0b00, opc, V128,
4124 asm, ".16b", ".16b",
4125 [(set (v16i8 V128:$dst), (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn)))]>;
4126 def v4i16 : BaseSIMDTwoSameVectorTied<0, U, 0b01, opc, V64,
4128 [(set (v4i16 V64:$dst), (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn)))]>;
4129 def v8i16 : BaseSIMDTwoSameVectorTied<1, U, 0b01, opc, V128,
4131 [(set (v8i16 V128:$dst), (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn)))]>;
4132 def v2i32 : BaseSIMDTwoSameVectorTied<0, U, 0b10, opc, V64,
4134 [(set (v2i32 V64:$dst), (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn)))]>;
4135 def v4i32 : BaseSIMDTwoSameVectorTied<1, U, 0b10, opc, V128,
4137 [(set (v4i32 V128:$dst), (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn)))]>;
4138 def v2i64 : BaseSIMDTwoSameVectorTied<1, U, 0b11, opc, V128,
4140 [(set (v2i64 V128:$dst), (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn)))]>;
4143 multiclass SIMDTwoVectorBHSD<bit U, bits<5> opc, string asm,
4144 SDPatternOperator OpNode = null_frag> {
4145 def v8i8 : BaseSIMDTwoSameVector<0, U, 0b00, opc, V64,
4147 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
4148 def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, V128,
4149 asm, ".16b", ".16b",
4150 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
4151 def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, V64,
4153 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn)))]>;
4154 def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, V128,
4156 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
4157 def v2i32 : BaseSIMDTwoSameVector<0, U, 0b10, opc, V64,
4159 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
4160 def v4i32 : BaseSIMDTwoSameVector<1, U, 0b10, opc, V128,
4162 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4163 def v2i64 : BaseSIMDTwoSameVector<1, U, 0b11, opc, V128,
4165 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
4169 // Supports only B element sizes.
4170 multiclass SIMDTwoVectorB<bit U, bits<2> size, bits<5> opc, string asm,
4171 SDPatternOperator OpNode> {
4172 def v8i8 : BaseSIMDTwoSameVector<0, U, size, opc, V64,
4174 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn)))]>;
4175 def v16i8 : BaseSIMDTwoSameVector<1, U, size, opc, V128,
4176 asm, ".16b", ".16b",
4177 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
4181 // Supports only B and H element sizes.
4182 multiclass SIMDTwoVectorBH<bit U, bits<5> opc, string asm,
4183 SDPatternOperator OpNode> {
4184 def v8i8 : BaseSIMDTwoSameVector<0, U, 0b00, opc, V64,
4186 [(set (v8i8 V64:$Rd), (OpNode V64:$Rn))]>;
4187 def v16i8 : BaseSIMDTwoSameVector<1, U, 0b00, opc, V128,
4188 asm, ".16b", ".16b",
4189 [(set (v16i8 V128:$Rd), (OpNode V128:$Rn))]>;
4190 def v4i16 : BaseSIMDTwoSameVector<0, U, 0b01, opc, V64,
4192 [(set (v4i16 V64:$Rd), (OpNode V64:$Rn))]>;
4193 def v8i16 : BaseSIMDTwoSameVector<1, U, 0b01, opc, V128,
4195 [(set (v8i16 V128:$Rd), (OpNode V128:$Rn))]>;
4198 // Supports only S and D element sizes, uses high bit of the size field
4199 // as an extra opcode bit.
4200 multiclass SIMDTwoVectorFP<bit U, bit S, bits<5> opc, string asm,
4201 SDPatternOperator OpNode> {
4202 def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, V64,
4204 [(set (v2f32 V64:$Rd), (OpNode (v2f32 V64:$Rn)))]>;
4205 def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, V128,
4207 [(set (v4f32 V128:$Rd), (OpNode (v4f32 V128:$Rn)))]>;
4208 def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, V128,
4210 [(set (v2f64 V128:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
4213 // Supports only S element size.
4214 multiclass SIMDTwoVectorS<bit U, bit S, bits<5> opc, string asm,
4215 SDPatternOperator OpNode> {
4216 def v2i32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, V64,
4218 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
4219 def v4i32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, V128,
4221 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4225 multiclass SIMDTwoVectorFPToInt<bit U, bit S, bits<5> opc, string asm,
4226 SDPatternOperator OpNode> {
4227 def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, V64,
4229 [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn)))]>;
4230 def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, V128,
4232 [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn)))]>;
4233 def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, V128,
4235 [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
4238 multiclass SIMDTwoVectorIntToFP<bit U, bit S, bits<5> opc, string asm,
4239 SDPatternOperator OpNode> {
4240 def v2f32 : BaseSIMDTwoSameVector<0, U, {S,0}, opc, V64,
4242 [(set (v2f32 V64:$Rd), (OpNode (v2i32 V64:$Rn)))]>;
4243 def v4f32 : BaseSIMDTwoSameVector<1, U, {S,0}, opc, V128,
4245 [(set (v4f32 V128:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4246 def v2f64 : BaseSIMDTwoSameVector<1, U, {S,1}, opc, V128,
4248 [(set (v2f64 V128:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
4252 class BaseSIMDMixedTwoVector<bit Q, bit U, bits<2> size, bits<5> opcode,
4253 RegisterOperand inreg, RegisterOperand outreg,
4254 string asm, string outkind, string inkind,
4256 : I<(outs outreg:$Rd), (ins inreg:$Rn), asm,
4257 "{\t$Rd" # outkind # ", $Rn" # inkind #
4258 "|" # outkind # "\t$Rd, $Rn}", "", pattern>,
4265 let Inst{28-24} = 0b01110;
4266 let Inst{23-22} = size;
4267 let Inst{21-17} = 0b10000;
4268 let Inst{16-12} = opcode;
4269 let Inst{11-10} = 0b10;
4274 class BaseSIMDMixedTwoVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
4275 RegisterOperand inreg, RegisterOperand outreg,
4276 string asm, string outkind, string inkind,
4278 : I<(outs outreg:$dst), (ins outreg:$Rd, inreg:$Rn), asm,
4279 "{\t$Rd" # outkind # ", $Rn" # inkind #
4280 "|" # outkind # "\t$Rd, $Rn}", "$Rd = $dst", pattern>,
4287 let Inst{28-24} = 0b01110;
4288 let Inst{23-22} = size;
4289 let Inst{21-17} = 0b10000;
4290 let Inst{16-12} = opcode;
4291 let Inst{11-10} = 0b10;
4296 multiclass SIMDMixedTwoVector<bit U, bits<5> opc, string asm,
4297 SDPatternOperator OpNode> {
4298 def v8i8 : BaseSIMDMixedTwoVector<0, U, 0b00, opc, V128, V64,
4300 [(set (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn)))]>;
4301 def v16i8 : BaseSIMDMixedTwoVectorTied<1, U, 0b00, opc, V128, V128,
4302 asm#"2", ".16b", ".8h", []>;
4303 def v4i16 : BaseSIMDMixedTwoVector<0, U, 0b01, opc, V128, V64,
4305 [(set (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn)))]>;
4306 def v8i16 : BaseSIMDMixedTwoVectorTied<1, U, 0b01, opc, V128, V128,
4307 asm#"2", ".8h", ".4s", []>;
4308 def v2i32 : BaseSIMDMixedTwoVector<0, U, 0b10, opc, V128, V64,
4310 [(set (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn)))]>;
4311 def v4i32 : BaseSIMDMixedTwoVectorTied<1, U, 0b10, opc, V128, V128,
4312 asm#"2", ".4s", ".2d", []>;
4314 def : Pat<(concat_vectors (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn))),
4315 (!cast<Instruction>(NAME # "v16i8")
4316 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
4317 def : Pat<(concat_vectors (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn))),
4318 (!cast<Instruction>(NAME # "v8i16")
4319 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
4320 def : Pat<(concat_vectors (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn))),
4321 (!cast<Instruction>(NAME # "v4i32")
4322 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
4325 class BaseSIMDCmpTwoVector<bit Q, bit U, bits<2> size, bits<5> opcode,
4326 RegisterOperand regtype, string asm, string kind,
4327 ValueType dty, ValueType sty, SDNode OpNode>
4328 : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
4329 "{\t$Rd" # kind # ", $Rn" # kind # ", #0" #
4330 "|" # kind # "\t$Rd, $Rn, #0}", "",
4331 [(set (dty regtype:$Rd), (OpNode (sty regtype:$Rn)))]>,
4338 let Inst{28-24} = 0b01110;
4339 let Inst{23-22} = size;
4340 let Inst{21-17} = 0b10000;
4341 let Inst{16-12} = opcode;
4342 let Inst{11-10} = 0b10;
4347 // Comparisons support all element sizes, except 1xD.
4348 multiclass SIMDCmpTwoVector<bit U, bits<5> opc, string asm,
4350 def v8i8rz : BaseSIMDCmpTwoVector<0, U, 0b00, opc, V64,
4352 v8i8, v8i8, OpNode>;
4353 def v16i8rz : BaseSIMDCmpTwoVector<1, U, 0b00, opc, V128,
4355 v16i8, v16i8, OpNode>;
4356 def v4i16rz : BaseSIMDCmpTwoVector<0, U, 0b01, opc, V64,
4358 v4i16, v4i16, OpNode>;
4359 def v8i16rz : BaseSIMDCmpTwoVector<1, U, 0b01, opc, V128,
4361 v8i16, v8i16, OpNode>;
4362 def v2i32rz : BaseSIMDCmpTwoVector<0, U, 0b10, opc, V64,
4364 v2i32, v2i32, OpNode>;
4365 def v4i32rz : BaseSIMDCmpTwoVector<1, U, 0b10, opc, V128,
4367 v4i32, v4i32, OpNode>;
4368 def v2i64rz : BaseSIMDCmpTwoVector<1, U, 0b11, opc, V128,
4370 v2i64, v2i64, OpNode>;
4373 // FP Comparisons support only S and D element sizes.
4374 multiclass SIMDFPCmpTwoVector<bit U, bit S, bits<5> opc,
4375 string asm, SDNode OpNode> {
4376 def v2i32rz : BaseSIMDCmpTwoVector<0, U, {S,0}, opc, V64,
4378 v2i32, v2f32, OpNode>;
4379 def v4i32rz : BaseSIMDCmpTwoVector<1, U, {S,0}, opc, V128,
4381 v4i32, v4f32, OpNode>;
4382 def v2i64rz : BaseSIMDCmpTwoVector<1, U, {S,1}, opc, V128,
4384 v2i64, v2f64, OpNode>;
4387 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4388 class BaseSIMDFPCvtTwoVector<bit Q, bit U, bits<2> size, bits<5> opcode,
4389 RegisterOperand outtype, RegisterOperand intype,
4390 string asm, string VdTy, string VnTy,
4392 : I<(outs outtype:$Rd), (ins intype:$Rn), asm,
4393 !strconcat("\t$Rd", VdTy, ", $Rn", VnTy), "", pattern>,
4400 let Inst{28-24} = 0b01110;
4401 let Inst{23-22} = size;
4402 let Inst{21-17} = 0b10000;
4403 let Inst{16-12} = opcode;
4404 let Inst{11-10} = 0b10;
4409 class BaseSIMDFPCvtTwoVectorTied<bit Q, bit U, bits<2> size, bits<5> opcode,
4410 RegisterOperand outtype, RegisterOperand intype,
4411 string asm, string VdTy, string VnTy,
4413 : I<(outs outtype:$dst), (ins outtype:$Rd, intype:$Rn), asm,
4414 !strconcat("\t$Rd", VdTy, ", $Rn", VnTy), "$Rd = $dst", pattern>,
4421 let Inst{28-24} = 0b01110;
4422 let Inst{23-22} = size;
4423 let Inst{21-17} = 0b10000;
4424 let Inst{16-12} = opcode;
4425 let Inst{11-10} = 0b10;
4430 multiclass SIMDFPWidenTwoVector<bit U, bit S, bits<5> opc, string asm> {
4431 def v4i16 : BaseSIMDFPCvtTwoVector<0, U, {S,0}, opc, V128, V64,
4432 asm, ".4s", ".4h", []>;
4433 def v8i16 : BaseSIMDFPCvtTwoVector<1, U, {S,0}, opc, V128, V128,
4434 asm#"2", ".4s", ".8h", []>;
4435 def v2i32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V128, V64,
4436 asm, ".2d", ".2s", []>;
4437 def v4i32 : BaseSIMDFPCvtTwoVector<1, U, {S,1}, opc, V128, V128,
4438 asm#"2", ".2d", ".4s", []>;
4441 multiclass SIMDFPNarrowTwoVector<bit U, bit S, bits<5> opc, string asm> {
4442 def v4i16 : BaseSIMDFPCvtTwoVector<0, U, {S,0}, opc, V64, V128,
4443 asm, ".4h", ".4s", []>;
4444 def v8i16 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,0}, opc, V128, V128,
4445 asm#"2", ".8h", ".4s", []>;
4446 def v2i32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V64, V128,
4447 asm, ".2s", ".2d", []>;
4448 def v4i32 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,1}, opc, V128, V128,
4449 asm#"2", ".4s", ".2d", []>;
4452 multiclass SIMDFPInexactCvtTwoVector<bit U, bit S, bits<5> opc, string asm,
4454 def v2f32 : BaseSIMDFPCvtTwoVector<0, U, {S,1}, opc, V64, V128,
4456 [(set (v2f32 V64:$Rd), (OpNode (v2f64 V128:$Rn)))]>;
4457 def v4f32 : BaseSIMDFPCvtTwoVectorTied<1, U, {S,1}, opc, V128, V128,
4458 asm#"2", ".4s", ".2d", []>;
4460 def : Pat<(concat_vectors (v2f32 V64:$Rd), (OpNode (v2f64 V128:$Rn))),
4461 (!cast<Instruction>(NAME # "v4f32")
4462 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub), V128:$Rn)>;
4465 //----------------------------------------------------------------------------
4466 // AdvSIMD three register different-size vector instructions.
4467 //----------------------------------------------------------------------------
4469 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4470 class BaseSIMDDifferentThreeVector<bit U, bits<3> size, bits<4> opcode,
4471 RegisterOperand outtype, RegisterOperand intype1,
4472 RegisterOperand intype2, string asm,
4473 string outkind, string inkind1, string inkind2,
4475 : I<(outs outtype:$Rd), (ins intype1:$Rn, intype2:$Rm), asm,
4476 "{\t$Rd" # outkind # ", $Rn" # inkind1 # ", $Rm" # inkind2 #
4477 "|" # outkind # "\t$Rd, $Rn, $Rm}", "", pattern>,
4483 let Inst{30} = size{0};
4485 let Inst{28-24} = 0b01110;
4486 let Inst{23-22} = size{2-1};
4488 let Inst{20-16} = Rm;
4489 let Inst{15-12} = opcode;
4490 let Inst{11-10} = 0b00;
4495 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
4496 class BaseSIMDDifferentThreeVectorTied<bit U, bits<3> size, bits<4> opcode,
4497 RegisterOperand outtype, RegisterOperand intype1,
4498 RegisterOperand intype2, string asm,
4499 string outkind, string inkind1, string inkind2,
4501 : I<(outs outtype:$dst), (ins outtype:$Rd, intype1:$Rn, intype2:$Rm), asm,
4502 "{\t$Rd" # outkind # ", $Rn" # inkind1 # ", $Rm" # inkind2 #
4503 "|" # outkind # "\t$Rd, $Rn, $Rm}", "$Rd = $dst", pattern>,
4509 let Inst{30} = size{0};
4511 let Inst{28-24} = 0b01110;
4512 let Inst{23-22} = size{2-1};
4514 let Inst{20-16} = Rm;
4515 let Inst{15-12} = opcode;
4516 let Inst{11-10} = 0b00;
4521 // FIXME: TableGen doesn't know how to deal with expanded types that also
4522 // change the element count (in this case, placing the results in
4523 // the high elements of the result register rather than the low
4524 // elements). Until that's fixed, we can't code-gen those.
4525 multiclass SIMDNarrowThreeVectorBHS<bit U, bits<4> opc, string asm,
4527 def v8i16_v8i8 : BaseSIMDDifferentThreeVector<U, 0b000, opc,
4529 asm, ".8b", ".8h", ".8h",
4530 [(set (v8i8 V64:$Rd), (IntOp (v8i16 V128:$Rn), (v8i16 V128:$Rm)))]>;
4531 def v8i16_v16i8 : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
4533 asm#"2", ".16b", ".8h", ".8h",
4535 def v4i32_v4i16 : BaseSIMDDifferentThreeVector<U, 0b010, opc,
4537 asm, ".4h", ".4s", ".4s",
4538 [(set (v4i16 V64:$Rd), (IntOp (v4i32 V128:$Rn), (v4i32 V128:$Rm)))]>;
4539 def v4i32_v8i16 : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
4541 asm#"2", ".8h", ".4s", ".4s",
4543 def v2i64_v2i32 : BaseSIMDDifferentThreeVector<U, 0b100, opc,
4545 asm, ".2s", ".2d", ".2d",
4546 [(set (v2i32 V64:$Rd), (IntOp (v2i64 V128:$Rn), (v2i64 V128:$Rm)))]>;
4547 def v2i64_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
4549 asm#"2", ".4s", ".2d", ".2d",
4553 // Patterns for the '2' variants involve INSERT_SUBREG, which you can't put in
4554 // a version attached to an instruction.
4555 def : Pat<(concat_vectors (v8i8 V64:$Rd), (IntOp (v8i16 V128:$Rn),
4557 (!cast<Instruction>(NAME # "v8i16_v16i8")
4558 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
4559 V128:$Rn, V128:$Rm)>;
4560 def : Pat<(concat_vectors (v4i16 V64:$Rd), (IntOp (v4i32 V128:$Rn),
4562 (!cast<Instruction>(NAME # "v4i32_v8i16")
4563 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
4564 V128:$Rn, V128:$Rm)>;
4565 def : Pat<(concat_vectors (v2i32 V64:$Rd), (IntOp (v2i64 V128:$Rn),
4567 (!cast<Instruction>(NAME # "v2i64_v4i32")
4568 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
4569 V128:$Rn, V128:$Rm)>;
4572 multiclass SIMDDifferentThreeVectorBD<bit U, bits<4> opc, string asm,
4574 def v8i8 : BaseSIMDDifferentThreeVector<U, 0b000, opc,
4576 asm, ".8h", ".8b", ".8b",
4577 [(set (v8i16 V128:$Rd), (IntOp (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
4578 def v16i8 : BaseSIMDDifferentThreeVector<U, 0b001, opc,
4580 asm#"2", ".8h", ".16b", ".16b", []>;
4581 def v1i64 : BaseSIMDDifferentThreeVector<U, 0b110, opc,
4583 asm, ".1q", ".1d", ".1d", []>;
4584 def v2i64 : BaseSIMDDifferentThreeVector<U, 0b111, opc,
4586 asm#"2", ".1q", ".2d", ".2d", []>;
4588 def : Pat<(v8i16 (IntOp (v8i8 (extract_high_v16i8 V128:$Rn)),
4589 (v8i8 (extract_high_v16i8 V128:$Rm)))),
4590 (!cast<Instruction>(NAME#"v16i8") V128:$Rn, V128:$Rm)>;
4593 multiclass SIMDLongThreeVectorHS<bit U, bits<4> opc, string asm,
4594 SDPatternOperator OpNode> {
4595 def v4i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b010, opc,
4597 asm, ".4s", ".4h", ".4h",
4598 [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
4599 def v8i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b011, opc,
4601 asm#"2", ".4s", ".8h", ".8h",
4602 [(set (v4i32 V128:$Rd), (OpNode (extract_high_v8i16 V128:$Rn),
4603 (extract_high_v8i16 V128:$Rm)))]>;
4604 def v2i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b100, opc,
4606 asm, ".2d", ".2s", ".2s",
4607 [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
4608 def v4i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b101, opc,
4610 asm#"2", ".2d", ".4s", ".4s",
4611 [(set (v2i64 V128:$Rd), (OpNode (extract_high_v4i32 V128:$Rn),
4612 (extract_high_v4i32 V128:$Rm)))]>;
4615 multiclass SIMDLongThreeVectorBHSabdl<bit U, bits<4> opc, string asm,
4616 SDPatternOperator OpNode = null_frag> {
4617 def v8i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b000, opc,
4619 asm, ".8h", ".8b", ".8b",
4620 [(set (v8i16 V128:$Rd),
4621 (zext (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))))]>;
4622 def v16i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b001, opc,
4624 asm#"2", ".8h", ".16b", ".16b",
4625 [(set (v8i16 V128:$Rd),
4626 (zext (v8i8 (OpNode (extract_high_v16i8 V128:$Rn),
4627 (extract_high_v16i8 V128:$Rm)))))]>;
4628 def v4i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b010, opc,
4630 asm, ".4s", ".4h", ".4h",
4631 [(set (v4i32 V128:$Rd),
4632 (zext (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))))]>;
4633 def v8i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b011, opc,
4635 asm#"2", ".4s", ".8h", ".8h",
4636 [(set (v4i32 V128:$Rd),
4637 (zext (v4i16 (OpNode (extract_high_v8i16 V128:$Rn),
4638 (extract_high_v8i16 V128:$Rm)))))]>;
4639 def v2i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b100, opc,
4641 asm, ".2d", ".2s", ".2s",
4642 [(set (v2i64 V128:$Rd),
4643 (zext (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))))]>;
4644 def v4i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b101, opc,
4646 asm#"2", ".2d", ".4s", ".4s",
4647 [(set (v2i64 V128:$Rd),
4648 (zext (v2i32 (OpNode (extract_high_v4i32 V128:$Rn),
4649 (extract_high_v4i32 V128:$Rm)))))]>;
4652 multiclass SIMDLongThreeVectorTiedBHSabal<bit U, bits<4> opc,
4654 SDPatternOperator OpNode> {
4655 def v8i8_v8i16 : BaseSIMDDifferentThreeVectorTied<U, 0b000, opc,
4657 asm, ".8h", ".8b", ".8b",
4658 [(set (v8i16 V128:$dst),
4659 (add (v8i16 V128:$Rd),
4660 (zext (v8i8 (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm))))))]>;
4661 def v16i8_v8i16 : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
4663 asm#"2", ".8h", ".16b", ".16b",
4664 [(set (v8i16 V128:$dst),
4665 (add (v8i16 V128:$Rd),
4666 (zext (v8i8 (OpNode (extract_high_v16i8 V128:$Rn),
4667 (extract_high_v16i8 V128:$Rm))))))]>;
4668 def v4i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
4670 asm, ".4s", ".4h", ".4h",
4671 [(set (v4i32 V128:$dst),
4672 (add (v4i32 V128:$Rd),
4673 (zext (v4i16 (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm))))))]>;
4674 def v8i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
4676 asm#"2", ".4s", ".8h", ".8h",
4677 [(set (v4i32 V128:$dst),
4678 (add (v4i32 V128:$Rd),
4679 (zext (v4i16 (OpNode (extract_high_v8i16 V128:$Rn),
4680 (extract_high_v8i16 V128:$Rm))))))]>;
4681 def v2i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
4683 asm, ".2d", ".2s", ".2s",
4684 [(set (v2i64 V128:$dst),
4685 (add (v2i64 V128:$Rd),
4686 (zext (v2i32 (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm))))))]>;
4687 def v4i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
4689 asm#"2", ".2d", ".4s", ".4s",
4690 [(set (v2i64 V128:$dst),
4691 (add (v2i64 V128:$Rd),
4692 (zext (v2i32 (OpNode (extract_high_v4i32 V128:$Rn),
4693 (extract_high_v4i32 V128:$Rm))))))]>;
4696 multiclass SIMDLongThreeVectorBHS<bit U, bits<4> opc, string asm,
4697 SDPatternOperator OpNode = null_frag> {
4698 def v8i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b000, opc,
4700 asm, ".8h", ".8b", ".8b",
4701 [(set (v8i16 V128:$Rd), (OpNode (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
4702 def v16i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b001, opc,
4704 asm#"2", ".8h", ".16b", ".16b",
4705 [(set (v8i16 V128:$Rd), (OpNode (extract_high_v16i8 V128:$Rn),
4706 (extract_high_v16i8 V128:$Rm)))]>;
4707 def v4i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b010, opc,
4709 asm, ".4s", ".4h", ".4h",
4710 [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
4711 def v8i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b011, opc,
4713 asm#"2", ".4s", ".8h", ".8h",
4714 [(set (v4i32 V128:$Rd), (OpNode (extract_high_v8i16 V128:$Rn),
4715 (extract_high_v8i16 V128:$Rm)))]>;
4716 def v2i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b100, opc,
4718 asm, ".2d", ".2s", ".2s",
4719 [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
4720 def v4i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b101, opc,
4722 asm#"2", ".2d", ".4s", ".4s",
4723 [(set (v2i64 V128:$Rd), (OpNode (extract_high_v4i32 V128:$Rn),
4724 (extract_high_v4i32 V128:$Rm)))]>;
4727 multiclass SIMDLongThreeVectorTiedBHS<bit U, bits<4> opc,
4729 SDPatternOperator OpNode> {
4730 def v8i8_v8i16 : BaseSIMDDifferentThreeVectorTied<U, 0b000, opc,
4732 asm, ".8h", ".8b", ".8b",
4733 [(set (v8i16 V128:$dst),
4734 (OpNode (v8i16 V128:$Rd), (v8i8 V64:$Rn), (v8i8 V64:$Rm)))]>;
4735 def v16i8_v8i16 : BaseSIMDDifferentThreeVectorTied<U, 0b001, opc,
4737 asm#"2", ".8h", ".16b", ".16b",
4738 [(set (v8i16 V128:$dst),
4739 (OpNode (v8i16 V128:$Rd),
4740 (extract_high_v16i8 V128:$Rn),
4741 (extract_high_v16i8 V128:$Rm)))]>;
4742 def v4i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
4744 asm, ".4s", ".4h", ".4h",
4745 [(set (v4i32 V128:$dst),
4746 (OpNode (v4i32 V128:$Rd), (v4i16 V64:$Rn), (v4i16 V64:$Rm)))]>;
4747 def v8i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
4749 asm#"2", ".4s", ".8h", ".8h",
4750 [(set (v4i32 V128:$dst),
4751 (OpNode (v4i32 V128:$Rd),
4752 (extract_high_v8i16 V128:$Rn),
4753 (extract_high_v8i16 V128:$Rm)))]>;
4754 def v2i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
4756 asm, ".2d", ".2s", ".2s",
4757 [(set (v2i64 V128:$dst),
4758 (OpNode (v2i64 V128:$Rd), (v2i32 V64:$Rn), (v2i32 V64:$Rm)))]>;
4759 def v4i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
4761 asm#"2", ".2d", ".4s", ".4s",
4762 [(set (v2i64 V128:$dst),
4763 (OpNode (v2i64 V128:$Rd),
4764 (extract_high_v4i32 V128:$Rn),
4765 (extract_high_v4i32 V128:$Rm)))]>;
4768 multiclass SIMDLongThreeVectorSQDMLXTiedHS<bit U, bits<4> opc, string asm,
4769 SDPatternOperator Accum> {
4770 def v4i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b010, opc,
4772 asm, ".4s", ".4h", ".4h",
4773 [(set (v4i32 V128:$dst),
4774 (Accum (v4i32 V128:$Rd),
4775 (v4i32 (int_arm64_neon_sqdmull (v4i16 V64:$Rn),
4776 (v4i16 V64:$Rm)))))]>;
4777 def v8i16_v4i32 : BaseSIMDDifferentThreeVectorTied<U, 0b011, opc,
4779 asm#"2", ".4s", ".8h", ".8h",
4780 [(set (v4i32 V128:$dst),
4781 (Accum (v4i32 V128:$Rd),
4782 (v4i32 (int_arm64_neon_sqdmull (extract_high_v8i16 V128:$Rn),
4783 (extract_high_v8i16 V128:$Rm)))))]>;
4784 def v2i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b100, opc,
4786 asm, ".2d", ".2s", ".2s",
4787 [(set (v2i64 V128:$dst),
4788 (Accum (v2i64 V128:$Rd),
4789 (v2i64 (int_arm64_neon_sqdmull (v2i32 V64:$Rn),
4790 (v2i32 V64:$Rm)))))]>;
4791 def v4i32_v2i64 : BaseSIMDDifferentThreeVectorTied<U, 0b101, opc,
4793 asm#"2", ".2d", ".4s", ".4s",
4794 [(set (v2i64 V128:$dst),
4795 (Accum (v2i64 V128:$Rd),
4796 (v2i64 (int_arm64_neon_sqdmull (extract_high_v4i32 V128:$Rn),
4797 (extract_high_v4i32 V128:$Rm)))))]>;
4800 multiclass SIMDWideThreeVectorBHS<bit U, bits<4> opc, string asm,
4801 SDPatternOperator OpNode> {
4802 def v8i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b000, opc,
4804 asm, ".8h", ".8h", ".8b",
4805 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn), (v8i8 V64:$Rm)))]>;
4806 def v16i8_v8i16 : BaseSIMDDifferentThreeVector<U, 0b001, opc,
4808 asm#"2", ".8h", ".8h", ".16b",
4809 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
4810 (extract_high_v16i8 V128:$Rm)))]>;
4811 def v4i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b010, opc,
4813 asm, ".4s", ".4s", ".4h",
4814 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (v4i16 V64:$Rm)))]>;
4815 def v8i16_v4i32 : BaseSIMDDifferentThreeVector<U, 0b011, opc,
4817 asm#"2", ".4s", ".4s", ".8h",
4818 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
4819 (extract_high_v8i16 V128:$Rm)))]>;
4820 def v2i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b100, opc,
4822 asm, ".2d", ".2d", ".2s",
4823 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (v2i32 V64:$Rm)))]>;
4824 def v4i32_v2i64 : BaseSIMDDifferentThreeVector<U, 0b101, opc,
4826 asm#"2", ".2d", ".2d", ".4s",
4827 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
4828 (extract_high_v4i32 V128:$Rm)))]>;
4831 //----------------------------------------------------------------------------
4832 // AdvSIMD bitwise extract from vector
4833 //----------------------------------------------------------------------------
4835 class BaseSIMDBitwiseExtract<bit size, RegisterOperand regtype, ValueType vty,
4836 string asm, string kind>
4837 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm, i32imm:$imm), asm,
4838 "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind # ", $imm" #
4839 "|" # kind # "\t$Rd, $Rn, $Rm, $imm}", "",
4840 [(set (vty regtype:$Rd),
4841 (ARM64ext regtype:$Rn, regtype:$Rm, (i32 imm:$imm)))]>,
4848 let Inst{30} = size;
4849 let Inst{29-21} = 0b101110000;
4850 let Inst{20-16} = Rm;
4852 let Inst{14-11} = imm;
4859 multiclass SIMDBitwiseExtract<string asm> {
4860 def v8i8 : BaseSIMDBitwiseExtract<0, V64, v8i8, asm, ".8b"> {
4863 def v16i8 : BaseSIMDBitwiseExtract<1, V128, v16i8, asm, ".16b">;
4866 //----------------------------------------------------------------------------
4867 // AdvSIMD zip vector
4868 //----------------------------------------------------------------------------
4870 class BaseSIMDZipVector<bits<3> size, bits<3> opc, RegisterOperand regtype,
4871 string asm, string kind, SDNode OpNode, ValueType valty>
4872 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
4873 "{\t$Rd" # kind # ", $Rn" # kind # ", $Rm" # kind #
4874 "|" # kind # "\t$Rd, $Rn, $Rm}", "",
4875 [(set (valty regtype:$Rd), (OpNode regtype:$Rn, regtype:$Rm))]>,
4881 let Inst{30} = size{0};
4882 let Inst{29-24} = 0b001110;
4883 let Inst{23-22} = size{2-1};
4885 let Inst{20-16} = Rm;
4887 let Inst{14-12} = opc;
4888 let Inst{11-10} = 0b10;
4893 multiclass SIMDZipVector<bits<3>opc, string asm,
4895 def v8i8 : BaseSIMDZipVector<0b000, opc, V64,
4896 asm, ".8b", OpNode, v8i8>;
4897 def v16i8 : BaseSIMDZipVector<0b001, opc, V128,
4898 asm, ".16b", OpNode, v16i8>;
4899 def v4i16 : BaseSIMDZipVector<0b010, opc, V64,
4900 asm, ".4h", OpNode, v4i16>;
4901 def v8i16 : BaseSIMDZipVector<0b011, opc, V128,
4902 asm, ".8h", OpNode, v8i16>;
4903 def v2i32 : BaseSIMDZipVector<0b100, opc, V64,
4904 asm, ".2s", OpNode, v2i32>;
4905 def v4i32 : BaseSIMDZipVector<0b101, opc, V128,
4906 asm, ".4s", OpNode, v4i32>;
4907 def v2i64 : BaseSIMDZipVector<0b111, opc, V128,
4908 asm, ".2d", OpNode, v2i64>;
4910 def : Pat<(v2f32 (OpNode V64:$Rn, V64:$Rm)),
4911 (!cast<Instruction>(NAME#"v2i32") V64:$Rn, V64:$Rm)>;
4912 def : Pat<(v4f32 (OpNode V128:$Rn, V128:$Rm)),
4913 (!cast<Instruction>(NAME#"v4i32") V128:$Rn, V128:$Rm)>;
4914 def : Pat<(v2f64 (OpNode V128:$Rn, V128:$Rm)),
4915 (!cast<Instruction>(NAME#"v2i64") V128:$Rn, V128:$Rm)>;
4918 //----------------------------------------------------------------------------
4919 // AdvSIMD three register scalar instructions
4920 //----------------------------------------------------------------------------
4922 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
4923 class BaseSIMDThreeScalar<bit U, bits<2> size, bits<5> opcode,
4924 RegisterClass regtype, string asm,
4926 : I<(outs regtype:$Rd), (ins regtype:$Rn, regtype:$Rm), asm,
4927 "\t$Rd, $Rn, $Rm", "", pattern>,
4932 let Inst{31-30} = 0b01;
4934 let Inst{28-24} = 0b11110;
4935 let Inst{23-22} = size;
4937 let Inst{20-16} = Rm;
4938 let Inst{15-11} = opcode;
4944 multiclass SIMDThreeScalarD<bit U, bits<5> opc, string asm,
4945 SDPatternOperator OpNode> {
4946 def v1i64 : BaseSIMDThreeScalar<U, 0b11, opc, FPR64, asm,
4947 [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn), (v1i64 FPR64:$Rm)))]>;
4950 multiclass SIMDThreeScalarBHSD<bit U, bits<5> opc, string asm,
4951 SDPatternOperator OpNode> {
4952 def v1i64 : BaseSIMDThreeScalar<U, 0b11, opc, FPR64, asm,
4953 [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn), (v1i64 FPR64:$Rm)))]>;
4954 def v1i32 : BaseSIMDThreeScalar<U, 0b10, opc, FPR32, asm, []>;
4955 def v1i16 : BaseSIMDThreeScalar<U, 0b01, opc, FPR16, asm, []>;
4956 def v1i8 : BaseSIMDThreeScalar<U, 0b00, opc, FPR8 , asm, []>;
4958 def : Pat<(i64 (OpNode (i64 FPR64:$Rn), (i64 FPR64:$Rm))),
4959 (!cast<Instruction>(NAME#"v1i64") FPR64:$Rn, FPR64:$Rm)>;
4960 def : Pat<(i32 (OpNode (i32 FPR32:$Rn), (i32 FPR32:$Rm))),
4961 (!cast<Instruction>(NAME#"v1i32") FPR32:$Rn, FPR32:$Rm)>;
4964 multiclass SIMDThreeScalarHS<bit U, bits<5> opc, string asm,
4965 SDPatternOperator OpNode> {
4966 def v1i32 : BaseSIMDThreeScalar<U, 0b10, opc, FPR32, asm,
4967 [(set FPR32:$Rd, (OpNode FPR32:$Rn, FPR32:$Rm))]>;
4968 def v1i16 : BaseSIMDThreeScalar<U, 0b01, opc, FPR16, asm, []>;
4971 multiclass SIMDThreeScalarSD<bit U, bit S, bits<5> opc, string asm,
4972 SDPatternOperator OpNode = null_frag> {
4973 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
4974 def #NAME#64 : BaseSIMDThreeScalar<U, {S,1}, opc, FPR64, asm,
4975 [(set (f64 FPR64:$Rd), (OpNode (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]>;
4976 def #NAME#32 : BaseSIMDThreeScalar<U, {S,0}, opc, FPR32, asm,
4977 [(set FPR32:$Rd, (OpNode FPR32:$Rn, FPR32:$Rm))]>;
4980 def : Pat<(v1f64 (OpNode (v1f64 FPR64:$Rn), (v1f64 FPR64:$Rm))),
4981 (!cast<Instruction>(NAME # "64") FPR64:$Rn, FPR64:$Rm)>;
4984 multiclass SIMDThreeScalarFPCmp<bit U, bit S, bits<5> opc, string asm,
4985 SDPatternOperator OpNode = null_frag> {
4986 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
4987 def #NAME#64 : BaseSIMDThreeScalar<U, {S,1}, opc, FPR64, asm,
4988 [(set (i64 FPR64:$Rd), (OpNode (f64 FPR64:$Rn), (f64 FPR64:$Rm)))]>;
4989 def #NAME#32 : BaseSIMDThreeScalar<U, {S,0}, opc, FPR32, asm,
4990 [(set (i32 FPR32:$Rd), (OpNode (f32 FPR32:$Rn), (f32 FPR32:$Rm)))]>;
4993 def : Pat<(v1i64 (OpNode (v1f64 FPR64:$Rn), (v1f64 FPR64:$Rm))),
4994 (!cast<Instruction>(NAME # "64") FPR64:$Rn, FPR64:$Rm)>;
4997 class BaseSIMDThreeScalarMixed<bit U, bits<2> size, bits<5> opcode,
4998 dag oops, dag iops, string asm, string cstr, list<dag> pat>
4999 : I<oops, iops, asm,
5000 "\t$Rd, $Rn, $Rm", cstr, pat>,
5005 let Inst{31-30} = 0b01;
5007 let Inst{28-24} = 0b11110;
5008 let Inst{23-22} = size;
5010 let Inst{20-16} = Rm;
5011 let Inst{15-11} = opcode;
5017 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5018 multiclass SIMDThreeScalarMixedHS<bit U, bits<5> opc, string asm,
5019 SDPatternOperator OpNode = null_frag> {
5020 def i16 : BaseSIMDThreeScalarMixed<U, 0b01, opc,
5022 (ins FPR16:$Rn, FPR16:$Rm), asm, "", []>;
5023 def i32 : BaseSIMDThreeScalarMixed<U, 0b10, opc,
5025 (ins FPR32:$Rn, FPR32:$Rm), asm, "",
5026 [(set (i64 FPR64:$Rd), (OpNode (i32 FPR32:$Rn), (i32 FPR32:$Rm)))]>;
5029 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5030 multiclass SIMDThreeScalarMixedTiedHS<bit U, bits<5> opc, string asm,
5031 SDPatternOperator OpNode = null_frag> {
5032 def i16 : BaseSIMDThreeScalarMixed<U, 0b01, opc,
5034 (ins FPR32:$Rd, FPR16:$Rn, FPR16:$Rm),
5035 asm, "$Rd = $dst", []>;
5036 def i32 : BaseSIMDThreeScalarMixed<U, 0b10, opc,
5038 (ins FPR64:$Rd, FPR32:$Rn, FPR32:$Rm),
5040 [(set (i64 FPR64:$dst),
5041 (OpNode (i64 FPR64:$Rd), (i32 FPR32:$Rn), (i32 FPR32:$Rm)))]>;
5044 //----------------------------------------------------------------------------
5045 // AdvSIMD two register scalar instructions
5046 //----------------------------------------------------------------------------
5048 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5049 class BaseSIMDTwoScalar<bit U, bits<2> size, bits<5> opcode,
5050 RegisterClass regtype, RegisterClass regtype2,
5051 string asm, list<dag> pat>
5052 : I<(outs regtype:$Rd), (ins regtype2:$Rn), asm,
5053 "\t$Rd, $Rn", "", pat>,
5057 let Inst{31-30} = 0b01;
5059 let Inst{28-24} = 0b11110;
5060 let Inst{23-22} = size;
5061 let Inst{21-17} = 0b10000;
5062 let Inst{16-12} = opcode;
5063 let Inst{11-10} = 0b10;
5068 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5069 class BaseSIMDTwoScalarTied<bit U, bits<2> size, bits<5> opcode,
5070 RegisterClass regtype, RegisterClass regtype2,
5071 string asm, list<dag> pat>
5072 : I<(outs regtype:$dst), (ins regtype:$Rd, regtype2:$Rn), asm,
5073 "\t$Rd, $Rn", "$Rd = $dst", pat>,
5077 let Inst{31-30} = 0b01;
5079 let Inst{28-24} = 0b11110;
5080 let Inst{23-22} = size;
5081 let Inst{21-17} = 0b10000;
5082 let Inst{16-12} = opcode;
5083 let Inst{11-10} = 0b10;
5089 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5090 class BaseSIMDCmpTwoScalar<bit U, bits<2> size, bits<5> opcode,
5091 RegisterClass regtype, string asm>
5092 : I<(outs regtype:$Rd), (ins regtype:$Rn), asm,
5093 "\t$Rd, $Rn, #0", "", []>,
5097 let Inst{31-30} = 0b01;
5099 let Inst{28-24} = 0b11110;
5100 let Inst{23-22} = size;
5101 let Inst{21-17} = 0b10000;
5102 let Inst{16-12} = opcode;
5103 let Inst{11-10} = 0b10;
5108 class SIMDInexactCvtTwoScalar<bits<5> opcode, string asm>
5109 : I<(outs FPR32:$Rd), (ins FPR64:$Rn), asm, "\t$Rd, $Rn", "",
5110 [(set (f32 FPR32:$Rd), (int_arm64_sisd_fcvtxn (f64 FPR64:$Rn)))]>,
5114 let Inst{31-17} = 0b011111100110000;
5115 let Inst{16-12} = opcode;
5116 let Inst{11-10} = 0b10;
5121 multiclass SIMDCmpTwoScalarD<bit U, bits<5> opc, string asm,
5122 SDPatternOperator OpNode> {
5123 def v1i64rz : BaseSIMDCmpTwoScalar<U, 0b11, opc, FPR64, asm>;
5125 def : Pat<(v1i64 (OpNode FPR64:$Rn)),
5126 (!cast<Instruction>(NAME # v1i64rz) FPR64:$Rn)>;
5129 multiclass SIMDCmpTwoScalarSD<bit U, bit S, bits<5> opc, string asm,
5130 SDPatternOperator OpNode> {
5131 def v1i64rz : BaseSIMDCmpTwoScalar<U, {S,1}, opc, FPR64, asm>;
5132 def v1i32rz : BaseSIMDCmpTwoScalar<U, {S,0}, opc, FPR32, asm>;
5134 def : Pat<(v1i64 (OpNode (v1f64 FPR64:$Rn))),
5135 (!cast<Instruction>(NAME # v1i64rz) FPR64:$Rn)>;
5138 multiclass SIMDTwoScalarD<bit U, bits<5> opc, string asm,
5139 SDPatternOperator OpNode = null_frag> {
5140 def v1i64 : BaseSIMDTwoScalar<U, 0b11, opc, FPR64, FPR64, asm,
5141 [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn)))]>;
5143 def : Pat<(i64 (OpNode (i64 FPR64:$Rn))),
5144 (!cast<Instruction>(NAME # "v1i64") FPR64:$Rn)>;
5147 multiclass SIMDTwoScalarSD<bit U, bit S, bits<5> opc, string asm> {
5148 def v1i64 : BaseSIMDTwoScalar<U, {S,1}, opc, FPR64, FPR64, asm,[]>;
5149 def v1i32 : BaseSIMDTwoScalar<U, {S,0}, opc, FPR32, FPR32, asm,[]>;
5152 multiclass SIMDTwoScalarCVTSD<bit U, bit S, bits<5> opc, string asm,
5153 SDPatternOperator OpNode> {
5154 def v1i64 : BaseSIMDTwoScalar<U, {S,1}, opc, FPR64, FPR64, asm,
5155 [(set FPR64:$Rd, (OpNode (f64 FPR64:$Rn)))]>;
5156 def v1i32 : BaseSIMDTwoScalar<U, {S,0}, opc, FPR32, FPR32, asm,
5157 [(set FPR32:$Rd, (OpNode (f32 FPR32:$Rn)))]>;
5160 multiclass SIMDTwoScalarBHSD<bit U, bits<5> opc, string asm,
5161 SDPatternOperator OpNode = null_frag> {
5162 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
5163 def v1i64 : BaseSIMDTwoScalar<U, 0b11, opc, FPR64, FPR64, asm,
5164 [(set (i64 FPR64:$Rd), (OpNode (i64 FPR64:$Rn)))]>;
5165 def v1i32 : BaseSIMDTwoScalar<U, 0b10, opc, FPR32, FPR32, asm,
5166 [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn)))]>;
5167 def v1i16 : BaseSIMDTwoScalar<U, 0b01, opc, FPR16, FPR16, asm, []>;
5168 def v1i8 : BaseSIMDTwoScalar<U, 0b00, opc, FPR8 , FPR8 , asm, []>;
5171 def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rn))),
5172 (!cast<Instruction>(NAME # v1i64) FPR64:$Rn)>;
5175 multiclass SIMDTwoScalarBHSDTied<bit U, bits<5> opc, string asm,
5177 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
5178 def v1i64 : BaseSIMDTwoScalarTied<U, 0b11, opc, FPR64, FPR64, asm,
5179 [(set (i64 FPR64:$dst), (OpNode (i64 FPR64:$Rd), (i64 FPR64:$Rn)))]>;
5180 def v1i32 : BaseSIMDTwoScalarTied<U, 0b10, opc, FPR32, FPR32, asm,
5181 [(set (i32 FPR32:$dst), (OpNode (i32 FPR32:$Rd), (i32 FPR32:$Rn)))]>;
5182 def v1i16 : BaseSIMDTwoScalarTied<U, 0b01, opc, FPR16, FPR16, asm, []>;
5183 def v1i8 : BaseSIMDTwoScalarTied<U, 0b00, opc, FPR8 , FPR8 , asm, []>;
5186 def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rd), (v1i64 FPR64:$Rn))),
5187 (!cast<Instruction>(NAME # v1i64) FPR64:$Rd, FPR64:$Rn)>;
5192 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5193 multiclass SIMDTwoScalarMixedBHS<bit U, bits<5> opc, string asm,
5194 SDPatternOperator OpNode = null_frag> {
5195 def v1i32 : BaseSIMDTwoScalar<U, 0b10, opc, FPR32, FPR64, asm,
5196 [(set (i32 FPR32:$Rd), (OpNode (i64 FPR64:$Rn)))]>;
5197 def v1i16 : BaseSIMDTwoScalar<U, 0b01, opc, FPR16, FPR32, asm, []>;
5198 def v1i8 : BaseSIMDTwoScalar<U, 0b00, opc, FPR8 , FPR16, asm, []>;
5201 //----------------------------------------------------------------------------
5202 // AdvSIMD scalar pairwise instructions
5203 //----------------------------------------------------------------------------
5205 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5206 class BaseSIMDPairwiseScalar<bit U, bits<2> size, bits<5> opcode,
5207 RegisterOperand regtype, RegisterOperand vectype,
5208 string asm, string kind>
5209 : I<(outs regtype:$Rd), (ins vectype:$Rn), asm,
5210 "{\t$Rd, $Rn" # kind # "|" # kind # "\t$Rd, $Rn}", "", []>,
5214 let Inst{31-30} = 0b01;
5216 let Inst{28-24} = 0b11110;
5217 let Inst{23-22} = size;
5218 let Inst{21-17} = 0b11000;
5219 let Inst{16-12} = opcode;
5220 let Inst{11-10} = 0b10;
5225 multiclass SIMDPairwiseScalarD<bit U, bits<5> opc, string asm> {
5226 def v2i64p : BaseSIMDPairwiseScalar<U, 0b11, opc, FPR64Op, V128,
5230 multiclass SIMDPairwiseScalarSD<bit U, bit S, bits<5> opc, string asm> {
5231 def v2i32p : BaseSIMDPairwiseScalar<U, {S,0}, opc, FPR32Op, V64,
5233 def v2i64p : BaseSIMDPairwiseScalar<U, {S,1}, opc, FPR64Op, V128,
5237 //----------------------------------------------------------------------------
5238 // AdvSIMD across lanes instructions
5239 //----------------------------------------------------------------------------
5241 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5242 class BaseSIMDAcrossLanes<bit Q, bit U, bits<2> size, bits<5> opcode,
5243 RegisterClass regtype, RegisterOperand vectype,
5244 string asm, string kind, list<dag> pattern>
5245 : I<(outs regtype:$Rd), (ins vectype:$Rn), asm,
5246 "{\t$Rd, $Rn" # kind # "|" # kind # "\t$Rd, $Rn}", "", pattern>,
5253 let Inst{28-24} = 0b01110;
5254 let Inst{23-22} = size;
5255 let Inst{21-17} = 0b11000;
5256 let Inst{16-12} = opcode;
5257 let Inst{11-10} = 0b10;
5262 multiclass SIMDAcrossLanesBHS<bit U, bits<5> opcode,
5264 def v8i8v : BaseSIMDAcrossLanes<0, U, 0b00, opcode, FPR8, V64,
5266 def v16i8v : BaseSIMDAcrossLanes<1, U, 0b00, opcode, FPR8, V128,
5268 def v4i16v : BaseSIMDAcrossLanes<0, U, 0b01, opcode, FPR16, V64,
5270 def v8i16v : BaseSIMDAcrossLanes<1, U, 0b01, opcode, FPR16, V128,
5272 def v4i32v : BaseSIMDAcrossLanes<1, U, 0b10, opcode, FPR32, V128,
5276 multiclass SIMDAcrossLanesHSD<bit U, bits<5> opcode, string asm> {
5277 def v8i8v : BaseSIMDAcrossLanes<0, U, 0b00, opcode, FPR16, V64,
5279 def v16i8v : BaseSIMDAcrossLanes<1, U, 0b00, opcode, FPR16, V128,
5281 def v4i16v : BaseSIMDAcrossLanes<0, U, 0b01, opcode, FPR32, V64,
5283 def v8i16v : BaseSIMDAcrossLanes<1, U, 0b01, opcode, FPR32, V128,
5285 def v4i32v : BaseSIMDAcrossLanes<1, U, 0b10, opcode, FPR64, V128,
5289 multiclass SIMDAcrossLanesS<bits<5> opcode, bit sz1, string asm,
5291 def v4i32v : BaseSIMDAcrossLanes<1, 1, {sz1, 0}, opcode, FPR32, V128,
5293 [(set FPR32:$Rd, (intOp (v4f32 V128:$Rn)))]>;
5296 //----------------------------------------------------------------------------
5297 // AdvSIMD INS/DUP instructions
5298 //----------------------------------------------------------------------------
5300 // FIXME: There has got to be a better way to factor these. ugh.
5302 class BaseSIMDInsDup<bit Q, bit op, dag outs, dag ins, string asm,
5303 string operands, string constraints, list<dag> pattern>
5304 : I<outs, ins, asm, operands, constraints, pattern>,
5311 let Inst{28-21} = 0b01110000;
5318 class SIMDDupFromMain<bit Q, bits<5> imm5, string size, ValueType vectype,
5319 RegisterOperand vecreg, RegisterClass regtype>
5320 : BaseSIMDInsDup<Q, 0, (outs vecreg:$Rd), (ins regtype:$Rn), "dup",
5321 "{\t$Rd" # size # ", $Rn" #
5322 "|" # size # "\t$Rd, $Rn}", "",
5323 [(set (vectype vecreg:$Rd), (ARM64dup regtype:$Rn))]> {
5324 let Inst{20-16} = imm5;
5325 let Inst{14-11} = 0b0001;
5328 class SIMDDupFromElement<bit Q, string dstkind, string srckind,
5329 ValueType vectype, ValueType insreg,
5330 RegisterOperand vecreg, Operand idxtype,
5331 ValueType elttype, SDNode OpNode>
5332 : BaseSIMDInsDup<Q, 0, (outs vecreg:$Rd), (ins V128:$Rn, idxtype:$idx), "dup",
5333 "{\t$Rd" # dstkind # ", $Rn" # srckind # "$idx" #
5334 "|" # dstkind # "\t$Rd, $Rn$idx}", "",
5335 [(set (vectype vecreg:$Rd),
5336 (OpNode (insreg V128:$Rn), idxtype:$idx))]> {
5337 let Inst{14-11} = 0b0000;
5340 class SIMDDup64FromElement
5341 : SIMDDupFromElement<1, ".2d", ".d", v2i64, v2i64, V128,
5342 VectorIndexD, i64, ARM64duplane64> {
5345 let Inst{19-16} = 0b1000;
5348 class SIMDDup32FromElement<bit Q, string size, ValueType vectype,
5349 RegisterOperand vecreg>
5350 : SIMDDupFromElement<Q, size, ".s", vectype, v4i32, vecreg,
5351 VectorIndexS, i64, ARM64duplane32> {
5353 let Inst{20-19} = idx;
5354 let Inst{18-16} = 0b100;
5357 class SIMDDup16FromElement<bit Q, string size, ValueType vectype,
5358 RegisterOperand vecreg>
5359 : SIMDDupFromElement<Q, size, ".h", vectype, v8i16, vecreg,
5360 VectorIndexH, i64, ARM64duplane16> {
5362 let Inst{20-18} = idx;
5363 let Inst{17-16} = 0b10;
5366 class SIMDDup8FromElement<bit Q, string size, ValueType vectype,
5367 RegisterOperand vecreg>
5368 : SIMDDupFromElement<Q, size, ".b", vectype, v16i8, vecreg,
5369 VectorIndexB, i64, ARM64duplane8> {
5371 let Inst{20-17} = idx;
5375 class BaseSIMDMov<bit Q, string size, bits<4> imm4, RegisterClass regtype,
5376 Operand idxtype, string asm, list<dag> pattern>
5377 : BaseSIMDInsDup<Q, 0, (outs regtype:$Rd), (ins V128:$Rn, idxtype:$idx), asm,
5378 "{\t$Rd, $Rn" # size # "$idx" #
5379 "|" # size # "\t$Rd, $Rn$idx}", "", pattern> {
5380 let Inst{14-11} = imm4;
5383 class SIMDSMov<bit Q, string size, RegisterClass regtype,
5385 : BaseSIMDMov<Q, size, 0b0101, regtype, idxtype, "smov", []>;
5386 class SIMDUMov<bit Q, string size, ValueType vectype, RegisterClass regtype,
5388 : BaseSIMDMov<Q, size, 0b0111, regtype, idxtype, "umov",
5389 [(set regtype:$Rd, (vector_extract (vectype V128:$Rn), idxtype:$idx))]>;
5391 class SIMDMovAlias<string asm, string size, Instruction inst,
5392 RegisterClass regtype, Operand idxtype>
5393 : InstAlias<asm#"{\t$dst, $src"#size#"$idx" #
5394 "|" # size # "\t$dst, $src$idx}",
5395 (inst regtype:$dst, V128:$src, idxtype:$idx)>;
5398 def vi8to32 : SIMDSMov<0, ".b", GPR32, VectorIndexB> {
5400 let Inst{20-17} = idx;
5403 def vi8to64 : SIMDSMov<1, ".b", GPR64, VectorIndexB> {
5405 let Inst{20-17} = idx;
5408 def vi16to32 : SIMDSMov<0, ".h", GPR32, VectorIndexH> {
5410 let Inst{20-18} = idx;
5411 let Inst{17-16} = 0b10;
5413 def vi16to64 : SIMDSMov<1, ".h", GPR64, VectorIndexH> {
5415 let Inst{20-18} = idx;
5416 let Inst{17-16} = 0b10;
5418 def vi32to64 : SIMDSMov<1, ".s", GPR64, VectorIndexS> {
5420 let Inst{20-19} = idx;
5421 let Inst{18-16} = 0b100;
5426 def vi8 : SIMDUMov<0, ".b", v16i8, GPR32, VectorIndexB> {
5428 let Inst{20-17} = idx;
5431 def vi16 : SIMDUMov<0, ".h", v8i16, GPR32, VectorIndexH> {
5433 let Inst{20-18} = idx;
5434 let Inst{17-16} = 0b10;
5436 def vi32 : SIMDUMov<0, ".s", v4i32, GPR32, VectorIndexS> {
5438 let Inst{20-19} = idx;
5439 let Inst{18-16} = 0b100;
5441 def vi64 : SIMDUMov<1, ".d", v2i64, GPR64, VectorIndexD> {
5444 let Inst{19-16} = 0b1000;
5446 def : SIMDMovAlias<"mov", ".s",
5447 !cast<Instruction>(NAME#"vi32"),
5448 GPR32, VectorIndexS>;
5449 def : SIMDMovAlias<"mov", ".d",
5450 !cast<Instruction>(NAME#"vi64"),
5451 GPR64, VectorIndexD>;
5454 class SIMDInsFromMain<string size, ValueType vectype,
5455 RegisterClass regtype, Operand idxtype>
5456 : BaseSIMDInsDup<1, 0, (outs V128:$dst),
5457 (ins V128:$Rd, idxtype:$idx, regtype:$Rn), "ins",
5458 "{\t$Rd" # size # "$idx, $Rn" #
5459 "|" # size # "\t$Rd$idx, $Rn}",
5462 (vector_insert (vectype V128:$Rd), regtype:$Rn, idxtype:$idx))]> {
5463 let Inst{14-11} = 0b0011;
5466 class SIMDInsFromElement<string size, ValueType vectype,
5467 ValueType elttype, Operand idxtype>
5468 : BaseSIMDInsDup<1, 1, (outs V128:$dst),
5469 (ins V128:$Rd, idxtype:$idx, V128:$Rn, idxtype:$idx2), "ins",
5470 "{\t$Rd" # size # "$idx, $Rn" # size # "$idx2" #
5471 "|" # size # "\t$Rd$idx, $Rn$idx2}",
5476 (elttype (vector_extract (vectype V128:$Rn), idxtype:$idx2)),
5479 class SIMDInsMainMovAlias<string size, Instruction inst,
5480 RegisterClass regtype, Operand idxtype>
5481 : InstAlias<"mov" # "{\t$dst" # size # "$idx, $src" #
5482 "|" # size #"\t$dst$idx, $src}",
5483 (inst V128:$dst, idxtype:$idx, regtype:$src)>;
5484 class SIMDInsElementMovAlias<string size, Instruction inst,
5486 : InstAlias<"mov" # "{\t$dst" # size # "$idx, $src" # size # "$idx2" #
5487 # "|" # size #" $dst$idx, $src$idx2}",
5488 (inst V128:$dst, idxtype:$idx, V128:$src, idxtype:$idx2)>;
5491 multiclass SIMDIns {
5492 def vi8gpr : SIMDInsFromMain<".b", v16i8, GPR32, VectorIndexB> {
5494 let Inst{20-17} = idx;
5497 def vi16gpr : SIMDInsFromMain<".h", v8i16, GPR32, VectorIndexH> {
5499 let Inst{20-18} = idx;
5500 let Inst{17-16} = 0b10;
5502 def vi32gpr : SIMDInsFromMain<".s", v4i32, GPR32, VectorIndexS> {
5504 let Inst{20-19} = idx;
5505 let Inst{18-16} = 0b100;
5507 def vi64gpr : SIMDInsFromMain<".d", v2i64, GPR64, VectorIndexD> {
5510 let Inst{19-16} = 0b1000;
5513 def vi8lane : SIMDInsFromElement<".b", v16i8, i32, VectorIndexB> {
5516 let Inst{20-17} = idx;
5518 let Inst{14-11} = idx2;
5520 def vi16lane : SIMDInsFromElement<".h", v8i16, i32, VectorIndexH> {
5523 let Inst{20-18} = idx;
5524 let Inst{17-16} = 0b10;
5525 let Inst{14-12} = idx2;
5528 def vi32lane : SIMDInsFromElement<".s", v4i32, i32, VectorIndexS> {
5531 let Inst{20-19} = idx;
5532 let Inst{18-16} = 0b100;
5533 let Inst{14-13} = idx2;
5534 let Inst{12-11} = 0;
5536 def vi64lane : SIMDInsFromElement<".d", v2i64, i64, VectorIndexD> {
5540 let Inst{19-16} = 0b1000;
5541 let Inst{14} = idx2;
5542 let Inst{13-11} = 0;
5545 // For all forms of the INS instruction, the "mov" mnemonic is the
5546 // preferred alias. Why they didn't just call the instruction "mov" in
5547 // the first place is a very good question indeed...
5548 def : SIMDInsMainMovAlias<".b", !cast<Instruction>(NAME#"vi8gpr"),
5549 GPR32, VectorIndexB>;
5550 def : SIMDInsMainMovAlias<".h", !cast<Instruction>(NAME#"vi16gpr"),
5551 GPR32, VectorIndexH>;
5552 def : SIMDInsMainMovAlias<".s", !cast<Instruction>(NAME#"vi32gpr"),
5553 GPR32, VectorIndexS>;
5554 def : SIMDInsMainMovAlias<".d", !cast<Instruction>(NAME#"vi64gpr"),
5555 GPR64, VectorIndexD>;
5557 def : SIMDInsElementMovAlias<".b", !cast<Instruction>(NAME#"vi8lane"),
5559 def : SIMDInsElementMovAlias<".h", !cast<Instruction>(NAME#"vi16lane"),
5561 def : SIMDInsElementMovAlias<".s", !cast<Instruction>(NAME#"vi32lane"),
5563 def : SIMDInsElementMovAlias<".d", !cast<Instruction>(NAME#"vi64lane"),
5567 //----------------------------------------------------------------------------
5569 //----------------------------------------------------------------------------
5571 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
5572 class BaseSIMDTableLookup<bit Q, bits<2> len, bit op, RegisterOperand vectype,
5573 RegisterOperand listtype, string asm, string kind>
5574 : I<(outs vectype:$Vd), (ins listtype:$Vn, vectype:$Vm), asm,
5575 "\t$Vd" # kind # ", $Vn, $Vm" # kind, "", []>,
5582 let Inst{29-21} = 0b001110000;
5583 let Inst{20-16} = Vm;
5585 let Inst{14-13} = len;
5587 let Inst{11-10} = 0b00;
5592 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
5593 class BaseSIMDTableLookupTied<bit Q, bits<2> len, bit op, RegisterOperand vectype,
5594 RegisterOperand listtype, string asm, string kind>
5595 : I<(outs vectype:$dst), (ins vectype:$Vd, listtype:$Vn, vectype:$Vm), asm,
5596 "\t$Vd" # kind # ", $Vn, $Vm" # kind, "$Vd = $dst", []>,
5603 let Inst{29-21} = 0b001110000;
5604 let Inst{20-16} = Vm;
5606 let Inst{14-13} = len;
5608 let Inst{11-10} = 0b00;
5613 class SIMDTableLookupAlias<string asm, Instruction inst,
5614 RegisterOperand vectype, RegisterOperand listtype>
5615 : InstAlias<!strconcat(asm, "\t$dst, $lst, $index"),
5616 (inst vectype:$dst, listtype:$lst, vectype:$index), 0>;
5618 multiclass SIMDTableLookup<bit op, string asm> {
5619 def v8i8One : BaseSIMDTableLookup<0, 0b00, op, V64, VecListOne16b,
5621 def v8i8Two : BaseSIMDTableLookup<0, 0b01, op, V64, VecListTwo16b,
5623 def v8i8Three : BaseSIMDTableLookup<0, 0b10, op, V64, VecListThree16b,
5625 def v8i8Four : BaseSIMDTableLookup<0, 0b11, op, V64, VecListFour16b,
5627 def v16i8One : BaseSIMDTableLookup<1, 0b00, op, V128, VecListOne16b,
5629 def v16i8Two : BaseSIMDTableLookup<1, 0b01, op, V128, VecListTwo16b,
5631 def v16i8Three: BaseSIMDTableLookup<1, 0b10, op, V128, VecListThree16b,
5633 def v16i8Four : BaseSIMDTableLookup<1, 0b11, op, V128, VecListFour16b,
5636 def : SIMDTableLookupAlias<asm # ".8b",
5637 !cast<Instruction>(NAME#"v8i8One"),
5638 V64, VecListOne128>;
5639 def : SIMDTableLookupAlias<asm # ".8b",
5640 !cast<Instruction>(NAME#"v8i8Two"),
5641 V64, VecListTwo128>;
5642 def : SIMDTableLookupAlias<asm # ".8b",
5643 !cast<Instruction>(NAME#"v8i8Three"),
5644 V64, VecListThree128>;
5645 def : SIMDTableLookupAlias<asm # ".8b",
5646 !cast<Instruction>(NAME#"v8i8Four"),
5647 V64, VecListFour128>;
5648 def : SIMDTableLookupAlias<asm # ".16b",
5649 !cast<Instruction>(NAME#"v16i8One"),
5650 V128, VecListOne128>;
5651 def : SIMDTableLookupAlias<asm # ".16b",
5652 !cast<Instruction>(NAME#"v16i8Two"),
5653 V128, VecListTwo128>;
5654 def : SIMDTableLookupAlias<asm # ".16b",
5655 !cast<Instruction>(NAME#"v16i8Three"),
5656 V128, VecListThree128>;
5657 def : SIMDTableLookupAlias<asm # ".16b",
5658 !cast<Instruction>(NAME#"v16i8Four"),
5659 V128, VecListFour128>;
5662 multiclass SIMDTableLookupTied<bit op, string asm> {
5663 def v8i8One : BaseSIMDTableLookupTied<0, 0b00, op, V64, VecListOne16b,
5665 def v8i8Two : BaseSIMDTableLookupTied<0, 0b01, op, V64, VecListTwo16b,
5667 def v8i8Three : BaseSIMDTableLookupTied<0, 0b10, op, V64, VecListThree16b,
5669 def v8i8Four : BaseSIMDTableLookupTied<0, 0b11, op, V64, VecListFour16b,
5671 def v16i8One : BaseSIMDTableLookupTied<1, 0b00, op, V128, VecListOne16b,
5673 def v16i8Two : BaseSIMDTableLookupTied<1, 0b01, op, V128, VecListTwo16b,
5675 def v16i8Three: BaseSIMDTableLookupTied<1, 0b10, op, V128, VecListThree16b,
5677 def v16i8Four : BaseSIMDTableLookupTied<1, 0b11, op, V128, VecListFour16b,
5680 def : SIMDTableLookupAlias<asm # ".8b",
5681 !cast<Instruction>(NAME#"v8i8One"),
5682 V64, VecListOne128>;
5683 def : SIMDTableLookupAlias<asm # ".8b",
5684 !cast<Instruction>(NAME#"v8i8Two"),
5685 V64, VecListTwo128>;
5686 def : SIMDTableLookupAlias<asm # ".8b",
5687 !cast<Instruction>(NAME#"v8i8Three"),
5688 V64, VecListThree128>;
5689 def : SIMDTableLookupAlias<asm # ".8b",
5690 !cast<Instruction>(NAME#"v8i8Four"),
5691 V64, VecListFour128>;
5692 def : SIMDTableLookupAlias<asm # ".16b",
5693 !cast<Instruction>(NAME#"v16i8One"),
5694 V128, VecListOne128>;
5695 def : SIMDTableLookupAlias<asm # ".16b",
5696 !cast<Instruction>(NAME#"v16i8Two"),
5697 V128, VecListTwo128>;
5698 def : SIMDTableLookupAlias<asm # ".16b",
5699 !cast<Instruction>(NAME#"v16i8Three"),
5700 V128, VecListThree128>;
5701 def : SIMDTableLookupAlias<asm # ".16b",
5702 !cast<Instruction>(NAME#"v16i8Four"),
5703 V128, VecListFour128>;
5707 //----------------------------------------------------------------------------
5708 // AdvSIMD scalar CPY
5709 //----------------------------------------------------------------------------
5710 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5711 class BaseSIMDScalarCPY<RegisterClass regtype, RegisterOperand vectype,
5712 string kind, Operand idxtype>
5713 : I<(outs regtype:$dst), (ins vectype:$src, idxtype:$idx), "mov",
5714 "{\t$dst, $src" # kind # "$idx" #
5715 "|\t$dst, $src$idx}", "", []>,
5719 let Inst{31-21} = 0b01011110000;
5720 let Inst{15-10} = 0b000001;
5721 let Inst{9-5} = src;
5722 let Inst{4-0} = dst;
5725 class SIMDScalarCPYAlias<string asm, string size, Instruction inst,
5726 RegisterClass regtype, RegisterOperand vectype, Operand idxtype>
5727 : InstAlias<asm # "{\t$dst, $src" # size # "$index" #
5728 # "|\t$dst, $src$index}",
5729 (inst regtype:$dst, vectype:$src, idxtype:$index)>;
5732 multiclass SIMDScalarCPY<string asm> {
5733 def i8 : BaseSIMDScalarCPY<FPR8, V128, ".b", VectorIndexB> {
5735 let Inst{20-17} = idx;
5738 def i16 : BaseSIMDScalarCPY<FPR16, V128, ".h", VectorIndexH> {
5740 let Inst{20-18} = idx;
5741 let Inst{17-16} = 0b10;
5743 def i32 : BaseSIMDScalarCPY<FPR32, V128, ".s", VectorIndexS> {
5745 let Inst{20-19} = idx;
5746 let Inst{18-16} = 0b100;
5748 def i64 : BaseSIMDScalarCPY<FPR64, V128, ".d", VectorIndexD> {
5751 let Inst{19-16} = 0b1000;
5754 // 'DUP' mnemonic aliases.
5755 def : SIMDScalarCPYAlias<"dup", ".b",
5756 !cast<Instruction>(NAME#"i8"),
5757 FPR8, V128, VectorIndexB>;
5758 def : SIMDScalarCPYAlias<"dup", ".h",
5759 !cast<Instruction>(NAME#"i16"),
5760 FPR16, V128, VectorIndexH>;
5761 def : SIMDScalarCPYAlias<"dup", ".s",
5762 !cast<Instruction>(NAME#"i32"),
5763 FPR32, V128, VectorIndexS>;
5764 def : SIMDScalarCPYAlias<"dup", ".d",
5765 !cast<Instruction>(NAME#"i64"),
5766 FPR64, V128, VectorIndexD>;
5769 //----------------------------------------------------------------------------
5770 // AdvSIMD modified immediate instructions
5771 //----------------------------------------------------------------------------
5773 class BaseSIMDModifiedImm<bit Q, bit op, dag oops, dag iops,
5774 string asm, string op_string,
5775 string cstr, list<dag> pattern>
5776 : I<oops, iops, asm, op_string, cstr, pattern>,
5783 let Inst{28-19} = 0b0111100000;
5784 let Inst{18-16} = imm8{7-5};
5785 let Inst{11-10} = 0b01;
5786 let Inst{9-5} = imm8{4-0};
5790 class BaseSIMDModifiedImmVector<bit Q, bit op, RegisterOperand vectype,
5791 Operand immtype, dag opt_shift_iop,
5792 string opt_shift, string asm, string kind,
5794 : BaseSIMDModifiedImm<Q, op, (outs vectype:$Rd),
5795 !con((ins immtype:$imm8), opt_shift_iop), asm,
5796 "{\t$Rd" # kind # ", $imm8" # opt_shift #
5797 "|" # kind # "\t$Rd, $imm8" # opt_shift # "}",
5799 let DecoderMethod = "DecodeModImmInstruction";
5802 class BaseSIMDModifiedImmVectorTied<bit Q, bit op, RegisterOperand vectype,
5803 Operand immtype, dag opt_shift_iop,
5804 string opt_shift, string asm, string kind,
5806 : BaseSIMDModifiedImm<Q, op, (outs vectype:$dst),
5807 !con((ins vectype:$Rd, immtype:$imm8), opt_shift_iop),
5808 asm, "{\t$Rd" # kind # ", $imm8" # opt_shift #
5809 "|" # kind # "\t$Rd, $imm8" # opt_shift # "}",
5810 "$Rd = $dst", pattern> {
5811 let DecoderMethod = "DecodeModImmTiedInstruction";
5814 class BaseSIMDModifiedImmVectorShift<bit Q, bit op, bits<2> b15_b12,
5815 RegisterOperand vectype, string asm,
5816 string kind, list<dag> pattern>
5817 : BaseSIMDModifiedImmVector<Q, op, vectype, imm0_255,
5818 (ins logical_vec_shift:$shift),
5819 "$shift", asm, kind, pattern> {
5821 let Inst{15} = b15_b12{1};
5822 let Inst{14-13} = shift;
5823 let Inst{12} = b15_b12{0};
5826 class BaseSIMDModifiedImmVectorShiftTied<bit Q, bit op, bits<2> b15_b12,
5827 RegisterOperand vectype, string asm,
5828 string kind, list<dag> pattern>
5829 : BaseSIMDModifiedImmVectorTied<Q, op, vectype, imm0_255,
5830 (ins logical_vec_shift:$shift),
5831 "$shift", asm, kind, pattern> {
5833 let Inst{15} = b15_b12{1};
5834 let Inst{14-13} = shift;
5835 let Inst{12} = b15_b12{0};
5839 class BaseSIMDModifiedImmVectorShiftHalf<bit Q, bit op, bits<2> b15_b12,
5840 RegisterOperand vectype, string asm,
5841 string kind, list<dag> pattern>
5842 : BaseSIMDModifiedImmVector<Q, op, vectype, imm0_255,
5843 (ins logical_vec_hw_shift:$shift),
5844 "$shift", asm, kind, pattern> {
5846 let Inst{15} = b15_b12{1};
5848 let Inst{13} = shift{0};
5849 let Inst{12} = b15_b12{0};
5852 class BaseSIMDModifiedImmVectorShiftHalfTied<bit Q, bit op, bits<2> b15_b12,
5853 RegisterOperand vectype, string asm,
5854 string kind, list<dag> pattern>
5855 : BaseSIMDModifiedImmVectorTied<Q, op, vectype, imm0_255,
5856 (ins logical_vec_hw_shift:$shift),
5857 "$shift", asm, kind, pattern> {
5859 let Inst{15} = b15_b12{1};
5861 let Inst{13} = shift{0};
5862 let Inst{12} = b15_b12{0};
5865 multiclass SIMDModifiedImmVectorShift<bit op, bits<2> hw_cmode, bits<2> w_cmode,
5867 def v4i16 : BaseSIMDModifiedImmVectorShiftHalf<0, op, hw_cmode, V64,
5869 def v8i16 : BaseSIMDModifiedImmVectorShiftHalf<1, op, hw_cmode, V128,
5872 def v2i32 : BaseSIMDModifiedImmVectorShift<0, op, w_cmode, V64,
5874 def v4i32 : BaseSIMDModifiedImmVectorShift<1, op, w_cmode, V128,
5878 multiclass SIMDModifiedImmVectorShiftTied<bit op, bits<2> hw_cmode,
5879 bits<2> w_cmode, string asm,
5881 def v4i16 : BaseSIMDModifiedImmVectorShiftHalfTied<0, op, hw_cmode, V64,
5883 [(set (v4i16 V64:$dst), (OpNode V64:$Rd,
5885 (i32 imm:$shift)))]>;
5886 def v8i16 : BaseSIMDModifiedImmVectorShiftHalfTied<1, op, hw_cmode, V128,
5888 [(set (v8i16 V128:$dst), (OpNode V128:$Rd,
5890 (i32 imm:$shift)))]>;
5892 def v2i32 : BaseSIMDModifiedImmVectorShiftTied<0, op, w_cmode, V64,
5894 [(set (v2i32 V64:$dst), (OpNode V64:$Rd,
5896 (i32 imm:$shift)))]>;
5897 def v4i32 : BaseSIMDModifiedImmVectorShiftTied<1, op, w_cmode, V128,
5899 [(set (v4i32 V128:$dst), (OpNode V128:$Rd,
5901 (i32 imm:$shift)))]>;
5904 class SIMDModifiedImmMoveMSL<bit Q, bit op, bits<4> cmode,
5905 RegisterOperand vectype, string asm,
5906 string kind, list<dag> pattern>
5907 : BaseSIMDModifiedImmVector<Q, op, vectype, imm0_255,
5908 (ins move_vec_shift:$shift),
5909 "$shift", asm, kind, pattern> {
5911 let Inst{15-13} = cmode{3-1};
5912 let Inst{12} = shift;
5915 class SIMDModifiedImmVectorNoShift<bit Q, bit op, bits<4> cmode,
5916 RegisterOperand vectype,
5917 Operand imm_type, string asm,
5918 string kind, list<dag> pattern>
5919 : BaseSIMDModifiedImmVector<Q, op, vectype, imm_type, (ins), "",
5920 asm, kind, pattern> {
5921 let Inst{15-12} = cmode;
5924 class SIMDModifiedImmScalarNoShift<bit Q, bit op, bits<4> cmode, string asm,
5926 : BaseSIMDModifiedImm<Q, op, (outs FPR64:$Rd), (ins simdimmtype10:$imm8), asm,
5927 "\t$Rd, $imm8", "", pattern> {
5928 let Inst{15-12} = cmode;
5929 let DecoderMethod = "DecodeModImmInstruction";
5932 //----------------------------------------------------------------------------
5933 // AdvSIMD indexed element
5934 //----------------------------------------------------------------------------
5936 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5937 class BaseSIMDIndexed<bit Q, bit U, bit Scalar, bits<2> size, bits<4> opc,
5938 RegisterOperand dst_reg, RegisterOperand lhs_reg,
5939 RegisterOperand rhs_reg, Operand vec_idx, string asm,
5940 string apple_kind, string dst_kind, string lhs_kind,
5941 string rhs_kind, list<dag> pattern>
5942 : I<(outs dst_reg:$Rd), (ins lhs_reg:$Rn, rhs_reg:$Rm, vec_idx:$idx),
5944 "{\t$Rd" # dst_kind # ", $Rn" # lhs_kind # ", $Rm" # rhs_kind # "$idx" #
5945 "|" # apple_kind # "\t$Rd, $Rn, $Rm$idx}", "", pattern>,
5954 let Inst{28} = Scalar;
5955 let Inst{27-24} = 0b1111;
5956 let Inst{23-22} = size;
5957 // Bit 21 must be set by the derived class.
5958 let Inst{20-16} = Rm;
5959 let Inst{15-12} = opc;
5960 // Bit 11 must be set by the derived class.
5966 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
5967 class BaseSIMDIndexedTied<bit Q, bit U, bit Scalar, bits<2> size, bits<4> opc,
5968 RegisterOperand dst_reg, RegisterOperand lhs_reg,
5969 RegisterOperand rhs_reg, Operand vec_idx, string asm,
5970 string apple_kind, string dst_kind, string lhs_kind,
5971 string rhs_kind, list<dag> pattern>
5972 : I<(outs dst_reg:$dst),
5973 (ins dst_reg:$Rd, lhs_reg:$Rn, rhs_reg:$Rm, vec_idx:$idx), asm,
5974 "{\t$Rd" # dst_kind # ", $Rn" # lhs_kind # ", $Rm" # rhs_kind # "$idx" #
5975 "|" # apple_kind # "\t$Rd, $Rn, $Rm$idx}", "$Rd = $dst", pattern>,
5984 let Inst{28} = Scalar;
5985 let Inst{27-24} = 0b1111;
5986 let Inst{23-22} = size;
5987 // Bit 21 must be set by the derived class.
5988 let Inst{20-16} = Rm;
5989 let Inst{15-12} = opc;
5990 // Bit 11 must be set by the derived class.
5996 multiclass SIMDFPIndexedSD<bit U, bits<4> opc, string asm,
5997 SDPatternOperator OpNode> {
5998 def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
6001 asm, ".2s", ".2s", ".2s", ".s",
6002 [(set (v2f32 V64:$Rd),
6003 (OpNode (v2f32 V64:$Rn),
6004 (v2f32 (ARM64duplane32 (v4f32 V128:$Rm), VectorIndexS:$idx))))]> {
6006 let Inst{11} = idx{1};
6007 let Inst{21} = idx{0};
6010 def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
6013 asm, ".4s", ".4s", ".4s", ".s",
6014 [(set (v4f32 V128:$Rd),
6015 (OpNode (v4f32 V128:$Rn),
6016 (v4f32 (ARM64duplane32 (v4f32 V128:$Rm), VectorIndexS:$idx))))]> {
6018 let Inst{11} = idx{1};
6019 let Inst{21} = idx{0};
6022 def v2i64_indexed : BaseSIMDIndexed<1, U, 0, 0b11, opc,
6025 asm, ".2d", ".2d", ".2d", ".d",
6026 [(set (v2f64 V128:$Rd),
6027 (OpNode (v2f64 V128:$Rn),
6028 (v2f64 (ARM64duplane64 (v2f64 V128:$Rm), VectorIndexD:$idx))))]> {
6030 let Inst{11} = idx{0};
6034 def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
6035 FPR32Op, FPR32Op, V128, VectorIndexS,
6036 asm, ".s", "", "", ".s",
6037 [(set (f32 FPR32Op:$Rd),
6038 (OpNode (f32 FPR32Op:$Rn),
6039 (f32 (vector_extract (v4f32 V128:$Rm),
6040 VectorIndexS:$idx))))]> {
6042 let Inst{11} = idx{1};
6043 let Inst{21} = idx{0};
6046 def v1i64_indexed : BaseSIMDIndexed<1, U, 1, 0b11, opc,
6047 FPR64Op, FPR64Op, V128, VectorIndexD,
6048 asm, ".d", "", "", ".d",
6049 [(set (f64 FPR64Op:$Rd),
6050 (OpNode (f64 FPR64Op:$Rn),
6051 (f64 (vector_extract (v2f64 V128:$Rm),
6052 VectorIndexD:$idx))))]> {
6054 let Inst{11} = idx{0};
6059 multiclass SIMDFPIndexedSDTiedPatterns<string INST, SDPatternOperator OpNode> {
6060 // 2 variants for the .2s version: DUPLANE from 128-bit and DUP scalar.
6061 def : Pat<(v2f32 (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn),
6062 (ARM64duplane32 (v4f32 V128:$Rm),
6063 VectorIndexS:$idx))),
6064 (!cast<Instruction>(INST # v2i32_indexed)
6065 V64:$Rd, V64:$Rn, V128:$Rm, VectorIndexS:$idx)>;
6066 def : Pat<(v2f32 (OpNode (v2f32 V64:$Rd), (v2f32 V64:$Rn),
6067 (ARM64dup (f32 FPR32Op:$Rm)))),
6068 (!cast<Instruction>(INST # "v2i32_indexed") V64:$Rd, V64:$Rn,
6069 (SUBREG_TO_REG (i32 0), FPR32Op:$Rm, ssub), (i64 0))>;
6072 // 2 variants for the .4s version: DUPLANE from 128-bit and DUP scalar.
6073 def : Pat<(v4f32 (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn),
6074 (ARM64duplane32 (v4f32 V128:$Rm),
6075 VectorIndexS:$idx))),
6076 (!cast<Instruction>(INST # "v4i32_indexed")
6077 V128:$Rd, V128:$Rn, V128:$Rm, VectorIndexS:$idx)>;
6078 def : Pat<(v4f32 (OpNode (v4f32 V128:$Rd), (v4f32 V128:$Rn),
6079 (ARM64dup (f32 FPR32Op:$Rm)))),
6080 (!cast<Instruction>(INST # "v4i32_indexed") V128:$Rd, V128:$Rn,
6081 (SUBREG_TO_REG (i32 0), FPR32Op:$Rm, ssub), (i64 0))>;
6083 // 2 variants for the .2d version: DUPLANE from 128-bit and DUP scalar.
6084 def : Pat<(v2f64 (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn),
6085 (ARM64duplane64 (v2f64 V128:$Rm),
6086 VectorIndexD:$idx))),
6087 (!cast<Instruction>(INST # "v2i64_indexed")
6088 V128:$Rd, V128:$Rn, V128:$Rm, VectorIndexS:$idx)>;
6089 def : Pat<(v2f64 (OpNode (v2f64 V128:$Rd), (v2f64 V128:$Rn),
6090 (ARM64dup (f64 FPR64Op:$Rm)))),
6091 (!cast<Instruction>(INST # "v2i64_indexed") V128:$Rd, V128:$Rn,
6092 (SUBREG_TO_REG (i32 0), FPR64Op:$Rm, dsub), (i64 0))>;
6094 // 2 variants for 32-bit scalar version: extract from .2s or from .4s
6095 def : Pat<(f32 (OpNode (f32 FPR32:$Rd), (f32 FPR32:$Rn),
6096 (vector_extract (v4f32 V128:$Rm), VectorIndexS:$idx))),
6097 (!cast<Instruction>(INST # "v1i32_indexed") FPR32:$Rd, FPR32:$Rn,
6098 V128:$Rm, VectorIndexS:$idx)>;
6099 def : Pat<(f32 (OpNode (f32 FPR32:$Rd), (f32 FPR32:$Rn),
6100 (vector_extract (v2f32 V64:$Rm), VectorIndexS:$idx))),
6101 (!cast<Instruction>(INST # "v1i32_indexed") FPR32:$Rd, FPR32:$Rn,
6102 (SUBREG_TO_REG (i32 0), V64:$Rm, dsub), VectorIndexS:$idx)>;
6104 // 1 variant for 64-bit scalar version: extract from .1d or from .2d
6105 def : Pat<(f64 (OpNode (f64 FPR64:$Rd), (f64 FPR64:$Rn),
6106 (vector_extract (v2f64 V128:$Rm), VectorIndexD:$idx))),
6107 (!cast<Instruction>(INST # "v1i64_indexed") FPR64:$Rd, FPR64:$Rn,
6108 V128:$Rm, VectorIndexD:$idx)>;
6111 multiclass SIMDFPIndexedSDTied<bit U, bits<4> opc, string asm> {
6112 def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc, V64, V64,
6114 asm, ".2s", ".2s", ".2s", ".s", []> {
6116 let Inst{11} = idx{1};
6117 let Inst{21} = idx{0};
6120 def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
6123 asm, ".4s", ".4s", ".4s", ".s", []> {
6125 let Inst{11} = idx{1};
6126 let Inst{21} = idx{0};
6129 def v2i64_indexed : BaseSIMDIndexedTied<1, U, 0, 0b11, opc,
6132 asm, ".2d", ".2d", ".2d", ".d", []> {
6134 let Inst{11} = idx{0};
6139 def v1i32_indexed : BaseSIMDIndexedTied<1, U, 1, 0b10, opc,
6140 FPR32Op, FPR32Op, V128, VectorIndexS,
6141 asm, ".s", "", "", ".s", []> {
6143 let Inst{11} = idx{1};
6144 let Inst{21} = idx{0};
6147 def v1i64_indexed : BaseSIMDIndexedTied<1, U, 1, 0b11, opc,
6148 FPR64Op, FPR64Op, V128, VectorIndexD,
6149 asm, ".d", "", "", ".d", []> {
6151 let Inst{11} = idx{0};
6156 multiclass SIMDIndexedHS<bit U, bits<4> opc, string asm,
6157 SDPatternOperator OpNode> {
6158 def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc, V64, V64,
6159 V128_lo, VectorIndexH,
6160 asm, ".4h", ".4h", ".4h", ".h",
6161 [(set (v4i16 V64:$Rd),
6162 (OpNode (v4i16 V64:$Rn),
6163 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6165 let Inst{11} = idx{2};
6166 let Inst{21} = idx{1};
6167 let Inst{20} = idx{0};
6170 def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
6172 V128_lo, VectorIndexH,
6173 asm, ".8h", ".8h", ".8h", ".h",
6174 [(set (v8i16 V128:$Rd),
6175 (OpNode (v8i16 V128:$Rn),
6176 (v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6178 let Inst{11} = idx{2};
6179 let Inst{21} = idx{1};
6180 let Inst{20} = idx{0};
6183 def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
6186 asm, ".2s", ".2s", ".2s", ".s",
6187 [(set (v2i32 V64:$Rd),
6188 (OpNode (v2i32 V64:$Rn),
6189 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6191 let Inst{11} = idx{1};
6192 let Inst{21} = idx{0};
6195 def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
6198 asm, ".4s", ".4s", ".4s", ".s",
6199 [(set (v4i32 V128:$Rd),
6200 (OpNode (v4i32 V128:$Rn),
6201 (v4i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6203 let Inst{11} = idx{1};
6204 let Inst{21} = idx{0};
6207 def v1i16_indexed : BaseSIMDIndexed<1, U, 1, 0b01, opc,
6208 FPR16Op, FPR16Op, V128_lo, VectorIndexH,
6209 asm, ".h", "", "", ".h", []> {
6211 let Inst{11} = idx{2};
6212 let Inst{21} = idx{1};
6213 let Inst{20} = idx{0};
6216 def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
6217 FPR32Op, FPR32Op, V128, VectorIndexS,
6218 asm, ".s", "", "", ".s",
6219 [(set (i32 FPR32Op:$Rd),
6220 (OpNode FPR32Op:$Rn,
6221 (i32 (vector_extract (v4i32 V128:$Rm),
6222 VectorIndexS:$idx))))]> {
6224 let Inst{11} = idx{1};
6225 let Inst{21} = idx{0};
6229 multiclass SIMDVectorIndexedHS<bit U, bits<4> opc, string asm,
6230 SDPatternOperator OpNode> {
6231 def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
6233 V128_lo, VectorIndexH,
6234 asm, ".4h", ".4h", ".4h", ".h",
6235 [(set (v4i16 V64:$Rd),
6236 (OpNode (v4i16 V64:$Rn),
6237 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6239 let Inst{11} = idx{2};
6240 let Inst{21} = idx{1};
6241 let Inst{20} = idx{0};
6244 def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
6246 V128_lo, VectorIndexH,
6247 asm, ".8h", ".8h", ".8h", ".h",
6248 [(set (v8i16 V128:$Rd),
6249 (OpNode (v8i16 V128:$Rn),
6250 (v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6252 let Inst{11} = idx{2};
6253 let Inst{21} = idx{1};
6254 let Inst{20} = idx{0};
6257 def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
6260 asm, ".2s", ".2s", ".2s", ".s",
6261 [(set (v2i32 V64:$Rd),
6262 (OpNode (v2i32 V64:$Rn),
6263 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6265 let Inst{11} = idx{1};
6266 let Inst{21} = idx{0};
6269 def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
6272 asm, ".4s", ".4s", ".4s", ".s",
6273 [(set (v4i32 V128:$Rd),
6274 (OpNode (v4i32 V128:$Rn),
6275 (v4i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6277 let Inst{11} = idx{1};
6278 let Inst{21} = idx{0};
6282 multiclass SIMDVectorIndexedHSTied<bit U, bits<4> opc, string asm,
6283 SDPatternOperator OpNode> {
6284 def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc, V64, V64,
6285 V128_lo, VectorIndexH,
6286 asm, ".4h", ".4h", ".4h", ".h",
6287 [(set (v4i16 V64:$dst),
6288 (OpNode (v4i16 V64:$Rd),(v4i16 V64:$Rn),
6289 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6291 let Inst{11} = idx{2};
6292 let Inst{21} = idx{1};
6293 let Inst{20} = idx{0};
6296 def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
6298 V128_lo, VectorIndexH,
6299 asm, ".8h", ".8h", ".8h", ".h",
6300 [(set (v8i16 V128:$dst),
6301 (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
6302 (v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6304 let Inst{11} = idx{2};
6305 let Inst{21} = idx{1};
6306 let Inst{20} = idx{0};
6309 def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
6312 asm, ".2s", ".2s", ".2s", ".s",
6313 [(set (v2i32 V64:$dst),
6314 (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
6315 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6317 let Inst{11} = idx{1};
6318 let Inst{21} = idx{0};
6321 def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
6324 asm, ".4s", ".4s", ".4s", ".s",
6325 [(set (v4i32 V128:$dst),
6326 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
6327 (v4i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6329 let Inst{11} = idx{1};
6330 let Inst{21} = idx{0};
6334 multiclass SIMDIndexedLongSD<bit U, bits<4> opc, string asm,
6335 SDPatternOperator OpNode> {
6336 def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
6338 V128_lo, VectorIndexH,
6339 asm, ".4s", ".4s", ".4h", ".h",
6340 [(set (v4i32 V128:$Rd),
6341 (OpNode (v4i16 V64:$Rn),
6342 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6344 let Inst{11} = idx{2};
6345 let Inst{21} = idx{1};
6346 let Inst{20} = idx{0};
6349 def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
6351 V128_lo, VectorIndexH,
6352 asm#"2", ".4s", ".4s", ".8h", ".h",
6353 [(set (v4i32 V128:$Rd),
6354 (OpNode (extract_high_v8i16 V128:$Rn),
6355 (extract_high_v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6356 VectorIndexH:$idx))))]> {
6359 let Inst{11} = idx{2};
6360 let Inst{21} = idx{1};
6361 let Inst{20} = idx{0};
6364 def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
6367 asm, ".2d", ".2d", ".2s", ".s",
6368 [(set (v2i64 V128:$Rd),
6369 (OpNode (v2i32 V64:$Rn),
6370 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6372 let Inst{11} = idx{1};
6373 let Inst{21} = idx{0};
6376 def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
6379 asm#"2", ".2d", ".2d", ".4s", ".s",
6380 [(set (v2i64 V128:$Rd),
6381 (OpNode (extract_high_v4i32 V128:$Rn),
6382 (extract_high_v4i32 (ARM64duplane32 (v4i32 V128:$Rm),
6383 VectorIndexS:$idx))))]> {
6385 let Inst{11} = idx{1};
6386 let Inst{21} = idx{0};
6389 def v1i32_indexed : BaseSIMDIndexed<1, U, 1, 0b01, opc,
6390 FPR32Op, FPR16Op, V128_lo, VectorIndexH,
6391 asm, ".h", "", "", ".h", []> {
6393 let Inst{11} = idx{2};
6394 let Inst{21} = idx{1};
6395 let Inst{20} = idx{0};
6398 def v1i64_indexed : BaseSIMDIndexed<1, U, 1, 0b10, opc,
6399 FPR64Op, FPR32Op, V128, VectorIndexS,
6400 asm, ".s", "", "", ".s", []> {
6402 let Inst{11} = idx{1};
6403 let Inst{21} = idx{0};
6407 multiclass SIMDIndexedLongSQDMLXSDTied<bit U, bits<4> opc, string asm,
6408 SDPatternOperator Accum> {
6409 def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc,
6411 V128_lo, VectorIndexH,
6412 asm, ".4s", ".4s", ".4h", ".h",
6413 [(set (v4i32 V128:$dst),
6414 (Accum (v4i32 V128:$Rd),
6415 (v4i32 (int_arm64_neon_sqdmull
6417 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6418 VectorIndexH:$idx))))))]> {
6420 let Inst{11} = idx{2};
6421 let Inst{21} = idx{1};
6422 let Inst{20} = idx{0};
6425 // FIXME: it would be nice to use the scalar (v1i32) instruction here, but an
6426 // intermediate EXTRACT_SUBREG would be untyped.
6427 def : Pat<(i32 (Accum (i32 FPR32Op:$Rd),
6428 (i32 (vector_extract (v4i32
6429 (int_arm64_neon_sqdmull (v4i16 V64:$Rn),
6430 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6431 VectorIndexH:$idx)))),
6434 (!cast<Instruction>(NAME # v4i16_indexed)
6435 (SUBREG_TO_REG (i32 0), FPR32Op:$Rd, ssub), V64:$Rn,
6436 V128_lo:$Rm, VectorIndexH:$idx),
6439 def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
6441 V128_lo, VectorIndexH,
6442 asm#"2", ".4s", ".4s", ".8h", ".h",
6443 [(set (v4i32 V128:$dst),
6444 (Accum (v4i32 V128:$Rd),
6445 (v4i32 (int_arm64_neon_sqdmull
6446 (extract_high_v8i16 V128:$Rn),
6448 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6449 VectorIndexH:$idx))))))]> {
6451 let Inst{11} = idx{2};
6452 let Inst{21} = idx{1};
6453 let Inst{20} = idx{0};
6456 def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
6459 asm, ".2d", ".2d", ".2s", ".s",
6460 [(set (v2i64 V128:$dst),
6461 (Accum (v2i64 V128:$Rd),
6462 (v2i64 (int_arm64_neon_sqdmull
6464 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm),
6465 VectorIndexS:$idx))))))]> {
6467 let Inst{11} = idx{1};
6468 let Inst{21} = idx{0};
6471 def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
6474 asm#"2", ".2d", ".2d", ".4s", ".s",
6475 [(set (v2i64 V128:$dst),
6476 (Accum (v2i64 V128:$Rd),
6477 (v2i64 (int_arm64_neon_sqdmull
6478 (extract_high_v4i32 V128:$Rn),
6480 (ARM64duplane32 (v4i32 V128:$Rm),
6481 VectorIndexS:$idx))))))]> {
6483 let Inst{11} = idx{1};
6484 let Inst{21} = idx{0};
6487 def v1i32_indexed : BaseSIMDIndexedTied<1, U, 1, 0b01, opc,
6488 FPR32Op, FPR16Op, V128_lo, VectorIndexH,
6489 asm, ".h", "", "", ".h", []> {
6491 let Inst{11} = idx{2};
6492 let Inst{21} = idx{1};
6493 let Inst{20} = idx{0};
6497 def v1i64_indexed : BaseSIMDIndexedTied<1, U, 1, 0b10, opc,
6498 FPR64Op, FPR32Op, V128, VectorIndexS,
6499 asm, ".s", "", "", ".s",
6500 [(set (i64 FPR64Op:$dst),
6501 (Accum (i64 FPR64Op:$Rd),
6502 (i64 (int_arm64_neon_sqdmulls_scalar
6504 (i32 (vector_extract (v4i32 V128:$Rm),
6505 VectorIndexS:$idx))))))]> {
6508 let Inst{11} = idx{1};
6509 let Inst{21} = idx{0};
6513 multiclass SIMDVectorIndexedLongSD<bit U, bits<4> opc, string asm,
6514 SDPatternOperator OpNode> {
6515 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6516 def v4i16_indexed : BaseSIMDIndexed<0, U, 0, 0b01, opc,
6518 V128_lo, VectorIndexH,
6519 asm, ".4s", ".4s", ".4h", ".h",
6520 [(set (v4i32 V128:$Rd),
6521 (OpNode (v4i16 V64:$Rn),
6522 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6524 let Inst{11} = idx{2};
6525 let Inst{21} = idx{1};
6526 let Inst{20} = idx{0};
6529 def v8i16_indexed : BaseSIMDIndexed<1, U, 0, 0b01, opc,
6531 V128_lo, VectorIndexH,
6532 asm#"2", ".4s", ".4s", ".8h", ".h",
6533 [(set (v4i32 V128:$Rd),
6534 (OpNode (extract_high_v8i16 V128:$Rn),
6535 (extract_high_v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6536 VectorIndexH:$idx))))]> {
6539 let Inst{11} = idx{2};
6540 let Inst{21} = idx{1};
6541 let Inst{20} = idx{0};
6544 def v2i32_indexed : BaseSIMDIndexed<0, U, 0, 0b10, opc,
6547 asm, ".2d", ".2d", ".2s", ".s",
6548 [(set (v2i64 V128:$Rd),
6549 (OpNode (v2i32 V64:$Rn),
6550 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6552 let Inst{11} = idx{1};
6553 let Inst{21} = idx{0};
6556 def v4i32_indexed : BaseSIMDIndexed<1, U, 0, 0b10, opc,
6559 asm#"2", ".2d", ".2d", ".4s", ".s",
6560 [(set (v2i64 V128:$Rd),
6561 (OpNode (extract_high_v4i32 V128:$Rn),
6562 (extract_high_v4i32 (ARM64duplane32 (v4i32 V128:$Rm),
6563 VectorIndexS:$idx))))]> {
6565 let Inst{11} = idx{1};
6566 let Inst{21} = idx{0};
6571 multiclass SIMDVectorIndexedLongSDTied<bit U, bits<4> opc, string asm,
6572 SDPatternOperator OpNode> {
6573 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in {
6574 def v4i16_indexed : BaseSIMDIndexedTied<0, U, 0, 0b01, opc,
6576 V128_lo, VectorIndexH,
6577 asm, ".4s", ".4s", ".4h", ".h",
6578 [(set (v4i32 V128:$dst),
6579 (OpNode (v4i32 V128:$Rd), (v4i16 V64:$Rn),
6580 (v4i16 (ARM64duplane16 (v8i16 V128_lo:$Rm), VectorIndexH:$idx))))]> {
6582 let Inst{11} = idx{2};
6583 let Inst{21} = idx{1};
6584 let Inst{20} = idx{0};
6587 def v8i16_indexed : BaseSIMDIndexedTied<1, U, 0, 0b01, opc,
6589 V128_lo, VectorIndexH,
6590 asm#"2", ".4s", ".4s", ".8h", ".h",
6591 [(set (v4i32 V128:$dst),
6592 (OpNode (v4i32 V128:$Rd),
6593 (extract_high_v8i16 V128:$Rn),
6594 (extract_high_v8i16 (ARM64duplane16 (v8i16 V128_lo:$Rm),
6595 VectorIndexH:$idx))))]> {
6597 let Inst{11} = idx{2};
6598 let Inst{21} = idx{1};
6599 let Inst{20} = idx{0};
6602 def v2i32_indexed : BaseSIMDIndexedTied<0, U, 0, 0b10, opc,
6605 asm, ".2d", ".2d", ".2s", ".s",
6606 [(set (v2i64 V128:$dst),
6607 (OpNode (v2i64 V128:$Rd), (v2i32 V64:$Rn),
6608 (v2i32 (ARM64duplane32 (v4i32 V128:$Rm), VectorIndexS:$idx))))]> {
6610 let Inst{11} = idx{1};
6611 let Inst{21} = idx{0};
6614 def v4i32_indexed : BaseSIMDIndexedTied<1, U, 0, 0b10, opc,
6617 asm#"2", ".2d", ".2d", ".4s", ".s",
6618 [(set (v2i64 V128:$dst),
6619 (OpNode (v2i64 V128:$Rd),
6620 (extract_high_v4i32 V128:$Rn),
6621 (extract_high_v4i32 (ARM64duplane32 (v4i32 V128:$Rm),
6622 VectorIndexS:$idx))))]> {
6624 let Inst{11} = idx{1};
6625 let Inst{21} = idx{0};
6630 //----------------------------------------------------------------------------
6631 // AdvSIMD scalar shift by immediate
6632 //----------------------------------------------------------------------------
6634 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6635 class BaseSIMDScalarShift<bit U, bits<5> opc, bits<7> fixed_imm,
6636 RegisterClass regtype1, RegisterClass regtype2,
6637 Operand immtype, string asm, list<dag> pattern>
6638 : I<(outs regtype1:$Rd), (ins regtype2:$Rn, immtype:$imm),
6639 asm, "\t$Rd, $Rn, $imm", "", pattern>,
6644 let Inst{31-30} = 0b01;
6646 let Inst{28-23} = 0b111110;
6647 let Inst{22-16} = fixed_imm;
6648 let Inst{15-11} = opc;
6654 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6655 class BaseSIMDScalarShiftTied<bit U, bits<5> opc, bits<7> fixed_imm,
6656 RegisterClass regtype1, RegisterClass regtype2,
6657 Operand immtype, string asm, list<dag> pattern>
6658 : I<(outs regtype1:$dst), (ins regtype1:$Rd, regtype2:$Rn, immtype:$imm),
6659 asm, "\t$Rd, $Rn, $imm", "$Rd = $dst", pattern>,
6664 let Inst{31-30} = 0b01;
6666 let Inst{28-23} = 0b111110;
6667 let Inst{22-16} = fixed_imm;
6668 let Inst{15-11} = opc;
6675 multiclass SIMDScalarRShiftSD<bit U, bits<5> opc, string asm> {
6676 def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
6677 FPR32, FPR32, vecshiftR32, asm, []> {
6678 let Inst{20-16} = imm{4-0};
6681 def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
6682 FPR64, FPR64, vecshiftR64, asm, []> {
6683 let Inst{21-16} = imm{5-0};
6687 multiclass SIMDScalarRShiftD<bit U, bits<5> opc, string asm,
6688 SDPatternOperator OpNode> {
6689 def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
6690 FPR64, FPR64, vecshiftR64, asm,
6691 [(set (i64 FPR64:$Rd),
6692 (OpNode (i64 FPR64:$Rn), (i32 vecshiftR64:$imm)))]> {
6693 let Inst{21-16} = imm{5-0};
6696 def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rn), (i32 vecshiftR64:$imm))),
6697 (!cast<Instruction>(NAME # "d") FPR64:$Rn, vecshiftR64:$imm)>;
6700 multiclass SIMDScalarRShiftDTied<bit U, bits<5> opc, string asm,
6701 SDPatternOperator OpNode = null_frag> {
6702 def d : BaseSIMDScalarShiftTied<U, opc, {1,?,?,?,?,?,?},
6703 FPR64, FPR64, vecshiftR64, asm,
6704 [(set (i64 FPR64:$dst), (OpNode (i64 FPR64:$Rd), (i64 FPR64:$Rn),
6705 (i32 vecshiftR64:$imm)))]> {
6706 let Inst{21-16} = imm{5-0};
6709 def : Pat<(v1i64 (OpNode (v1i64 FPR64:$Rd), (v1i64 FPR64:$Rn),
6710 (i32 vecshiftR64:$imm))),
6711 (!cast<Instruction>(NAME # "d") FPR64:$Rd, FPR64:$Rn,
6715 multiclass SIMDScalarLShiftD<bit U, bits<5> opc, string asm,
6716 SDPatternOperator OpNode> {
6717 def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
6718 FPR64, FPR64, vecshiftL64, asm,
6719 [(set (v1i64 FPR64:$Rd),
6720 (OpNode (v1i64 FPR64:$Rn), (i32 vecshiftL64:$imm)))]> {
6721 let Inst{21-16} = imm{5-0};
6725 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6726 multiclass SIMDScalarLShiftDTied<bit U, bits<5> opc, string asm> {
6727 def d : BaseSIMDScalarShiftTied<U, opc, {1,?,?,?,?,?,?},
6728 FPR64, FPR64, vecshiftL64, asm, []> {
6729 let Inst{21-16} = imm{5-0};
6733 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6734 multiclass SIMDScalarRShiftBHS<bit U, bits<5> opc, string asm,
6735 SDPatternOperator OpNode = null_frag> {
6736 def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
6737 FPR8, FPR16, vecshiftR8, asm, []> {
6738 let Inst{18-16} = imm{2-0};
6741 def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
6742 FPR16, FPR32, vecshiftR16, asm, []> {
6743 let Inst{19-16} = imm{3-0};
6746 def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
6747 FPR32, FPR64, vecshiftR32, asm,
6748 [(set (i32 FPR32:$Rd), (OpNode (i64 FPR64:$Rn), vecshiftR32:$imm))]> {
6749 let Inst{20-16} = imm{4-0};
6753 multiclass SIMDScalarLShiftBHSD<bit U, bits<5> opc, string asm,
6754 SDPatternOperator OpNode> {
6755 def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
6756 FPR8, FPR8, vecshiftL8, asm, []> {
6757 let Inst{18-16} = imm{2-0};
6760 def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
6761 FPR16, FPR16, vecshiftL16, asm, []> {
6762 let Inst{19-16} = imm{3-0};
6765 def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
6766 FPR32, FPR32, vecshiftL32, asm,
6767 [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn), (i32 vecshiftL32:$imm)))]> {
6768 let Inst{20-16} = imm{4-0};
6771 def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
6772 FPR64, FPR64, vecshiftL64, asm,
6773 [(set (v1i64 FPR64:$Rd), (OpNode (v1i64 FPR64:$Rn),
6774 (i32 vecshiftL64:$imm)))]> {
6775 let Inst{21-16} = imm{5-0};
6779 multiclass SIMDScalarRShiftBHSD<bit U, bits<5> opc, string asm> {
6780 def b : BaseSIMDScalarShift<U, opc, {0,0,0,1,?,?,?},
6781 FPR8, FPR8, vecshiftR8, asm, []> {
6782 let Inst{18-16} = imm{2-0};
6785 def h : BaseSIMDScalarShift<U, opc, {0,0,1,?,?,?,?},
6786 FPR16, FPR16, vecshiftR16, asm, []> {
6787 let Inst{19-16} = imm{3-0};
6790 def s : BaseSIMDScalarShift<U, opc, {0,1,?,?,?,?,?},
6791 FPR32, FPR32, vecshiftR32, asm, []> {
6792 let Inst{20-16} = imm{4-0};
6795 def d : BaseSIMDScalarShift<U, opc, {1,?,?,?,?,?,?},
6796 FPR64, FPR64, vecshiftR64, asm, []> {
6797 let Inst{21-16} = imm{5-0};
6801 //----------------------------------------------------------------------------
6802 // AdvSIMD vector x indexed element
6803 //----------------------------------------------------------------------------
6805 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6806 class BaseSIMDVectorShift<bit Q, bit U, bits<5> opc, bits<7> fixed_imm,
6807 RegisterOperand dst_reg, RegisterOperand src_reg,
6809 string asm, string dst_kind, string src_kind,
6811 : I<(outs dst_reg:$Rd), (ins src_reg:$Rn, immtype:$imm),
6812 asm, "{\t$Rd" # dst_kind # ", $Rn" # src_kind # ", $imm" #
6813 "|" # dst_kind # "\t$Rd, $Rn, $imm}", "", pattern>,
6820 let Inst{28-23} = 0b011110;
6821 let Inst{22-16} = fixed_imm;
6822 let Inst{15-11} = opc;
6828 let mayStore = 0, mayLoad = 0, hasSideEffects = 0 in
6829 class BaseSIMDVectorShiftTied<bit Q, bit U, bits<5> opc, bits<7> fixed_imm,
6830 RegisterOperand vectype1, RegisterOperand vectype2,
6832 string asm, string dst_kind, string src_kind,
6834 : I<(outs vectype1:$dst), (ins vectype1:$Rd, vectype2:$Rn, immtype:$imm),
6835 asm, "{\t$Rd" # dst_kind # ", $Rn" # src_kind # ", $imm" #
6836 "|" # dst_kind # "\t$Rd, $Rn, $imm}", "$Rd = $dst", pattern>,
6843 let Inst{28-23} = 0b011110;
6844 let Inst{22-16} = fixed_imm;
6845 let Inst{15-11} = opc;
6851 multiclass SIMDVectorRShiftSD<bit U, bits<5> opc, string asm,
6853 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
6854 V64, V64, vecshiftR32,
6856 [(set (v2i32 V64:$Rd), (OpNode (v2f32 V64:$Rn), (i32 imm:$imm)))]> {
6858 let Inst{20-16} = imm;
6861 def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
6862 V128, V128, vecshiftR32,
6864 [(set (v4i32 V128:$Rd), (OpNode (v4f32 V128:$Rn), (i32 imm:$imm)))]> {
6866 let Inst{20-16} = imm;
6869 def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
6870 V128, V128, vecshiftR64,
6872 [(set (v2i64 V128:$Rd), (OpNode (v2f64 V128:$Rn), (i32 imm:$imm)))]> {
6874 let Inst{21-16} = imm;
6878 multiclass SIMDVectorRShiftSDToFP<bit U, bits<5> opc, string asm,
6880 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
6881 V64, V64, vecshiftR32,
6883 [(set (v2f32 V64:$Rd), (OpNode (v2i32 V64:$Rn), (i32 imm:$imm)))]> {
6885 let Inst{20-16} = imm;
6888 def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
6889 V128, V128, vecshiftR32,
6891 [(set (v4f32 V128:$Rd), (OpNode (v4i32 V128:$Rn), (i32 imm:$imm)))]> {
6893 let Inst{20-16} = imm;
6896 def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
6897 V128, V128, vecshiftR64,
6899 [(set (v2f64 V128:$Rd), (OpNode (v2i64 V128:$Rn), (i32 imm:$imm)))]> {
6901 let Inst{21-16} = imm;
6905 multiclass SIMDVectorRShiftNarrowBHS<bit U, bits<5> opc, string asm,
6906 SDPatternOperator OpNode> {
6907 def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
6908 V64, V128, vecshiftR16Narrow,
6910 [(set (v8i8 V64:$Rd), (OpNode (v8i16 V128:$Rn), vecshiftR16Narrow:$imm))]> {
6912 let Inst{18-16} = imm;
6915 def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
6916 V128, V128, vecshiftR16Narrow,
6917 asm#"2", ".16b", ".8h", []> {
6919 let Inst{18-16} = imm;
6920 let hasSideEffects = 0;
6923 def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
6924 V64, V128, vecshiftR32Narrow,
6926 [(set (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn), vecshiftR32Narrow:$imm))]> {
6928 let Inst{19-16} = imm;
6931 def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
6932 V128, V128, vecshiftR32Narrow,
6933 asm#"2", ".8h", ".4s", []> {
6935 let Inst{19-16} = imm;
6936 let hasSideEffects = 0;
6939 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
6940 V64, V128, vecshiftR64Narrow,
6942 [(set (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn), vecshiftR64Narrow:$imm))]> {
6944 let Inst{20-16} = imm;
6947 def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
6948 V128, V128, vecshiftR64Narrow,
6949 asm#"2", ".4s", ".2d", []> {
6951 let Inst{20-16} = imm;
6952 let hasSideEffects = 0;
6955 // TableGen doesn't like patters w/ INSERT_SUBREG on the instructions
6956 // themselves, so put them here instead.
6958 // Patterns involving what's effectively an insert high and a normal
6959 // intrinsic, represented by CONCAT_VECTORS.
6960 def : Pat<(concat_vectors (v8i8 V64:$Rd),(OpNode (v8i16 V128:$Rn),
6961 vecshiftR16Narrow:$imm)),
6962 (!cast<Instruction>(NAME # "v16i8_shift")
6963 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
6964 V128:$Rn, vecshiftR16Narrow:$imm)>;
6965 def : Pat<(concat_vectors (v4i16 V64:$Rd), (OpNode (v4i32 V128:$Rn),
6966 vecshiftR32Narrow:$imm)),
6967 (!cast<Instruction>(NAME # "v8i16_shift")
6968 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
6969 V128:$Rn, vecshiftR32Narrow:$imm)>;
6970 def : Pat<(concat_vectors (v2i32 V64:$Rd), (OpNode (v2i64 V128:$Rn),
6971 vecshiftR64Narrow:$imm)),
6972 (!cast<Instruction>(NAME # "v4i32_shift")
6973 (INSERT_SUBREG (IMPLICIT_DEF), V64:$Rd, dsub),
6974 V128:$Rn, vecshiftR64Narrow:$imm)>;
6977 multiclass SIMDVectorLShiftBHSD<bit U, bits<5> opc, string asm,
6978 SDPatternOperator OpNode> {
6979 def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
6980 V64, V64, vecshiftL8,
6982 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn),
6983 (i32 vecshiftL8:$imm)))]> {
6985 let Inst{18-16} = imm;
6988 def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
6989 V128, V128, vecshiftL8,
6990 asm, ".16b", ".16b",
6991 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn),
6992 (i32 vecshiftL8:$imm)))]> {
6994 let Inst{18-16} = imm;
6997 def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
6998 V64, V64, vecshiftL16,
7000 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn),
7001 (i32 vecshiftL16:$imm)))]> {
7003 let Inst{19-16} = imm;
7006 def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
7007 V128, V128, vecshiftL16,
7009 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
7010 (i32 vecshiftL16:$imm)))]> {
7012 let Inst{19-16} = imm;
7015 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
7016 V64, V64, vecshiftL32,
7018 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn),
7019 (i32 vecshiftL32:$imm)))]> {
7021 let Inst{20-16} = imm;
7024 def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
7025 V128, V128, vecshiftL32,
7027 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
7028 (i32 vecshiftL32:$imm)))]> {
7030 let Inst{20-16} = imm;
7033 def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
7034 V128, V128, vecshiftL64,
7036 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
7037 (i32 vecshiftL64:$imm)))]> {
7039 let Inst{21-16} = imm;
7043 multiclass SIMDVectorRShiftBHSD<bit U, bits<5> opc, string asm,
7044 SDPatternOperator OpNode> {
7045 def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
7046 V64, V64, vecshiftR8,
7048 [(set (v8i8 V64:$Rd), (OpNode (v8i8 V64:$Rn),
7049 (i32 vecshiftR8:$imm)))]> {
7051 let Inst{18-16} = imm;
7054 def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
7055 V128, V128, vecshiftR8,
7056 asm, ".16b", ".16b",
7057 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn),
7058 (i32 vecshiftR8:$imm)))]> {
7060 let Inst{18-16} = imm;
7063 def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
7064 V64, V64, vecshiftR16,
7066 [(set (v4i16 V64:$Rd), (OpNode (v4i16 V64:$Rn),
7067 (i32 vecshiftR16:$imm)))]> {
7069 let Inst{19-16} = imm;
7072 def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
7073 V128, V128, vecshiftR16,
7075 [(set (v8i16 V128:$Rd), (OpNode (v8i16 V128:$Rn),
7076 (i32 vecshiftR16:$imm)))]> {
7078 let Inst{19-16} = imm;
7081 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
7082 V64, V64, vecshiftR32,
7084 [(set (v2i32 V64:$Rd), (OpNode (v2i32 V64:$Rn),
7085 (i32 vecshiftR32:$imm)))]> {
7087 let Inst{20-16} = imm;
7090 def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
7091 V128, V128, vecshiftR32,
7093 [(set (v4i32 V128:$Rd), (OpNode (v4i32 V128:$Rn),
7094 (i32 vecshiftR32:$imm)))]> {
7096 let Inst{20-16} = imm;
7099 def v2i64_shift : BaseSIMDVectorShift<1, U, opc, {1,?,?,?,?,?,?},
7100 V128, V128, vecshiftR64,
7102 [(set (v2i64 V128:$Rd), (OpNode (v2i64 V128:$Rn),
7103 (i32 vecshiftR64:$imm)))]> {
7105 let Inst{21-16} = imm;
7109 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
7110 multiclass SIMDVectorRShiftBHSDTied<bit U, bits<5> opc, string asm,
7111 SDPatternOperator OpNode = null_frag> {
7112 def v8i8_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,0,1,?,?,?},
7113 V64, V64, vecshiftR8, asm, ".8b", ".8b",
7114 [(set (v8i8 V64:$dst),
7115 (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn),
7116 (i32 vecshiftR8:$imm)))]> {
7118 let Inst{18-16} = imm;
7121 def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
7122 V128, V128, vecshiftR8, asm, ".16b", ".16b",
7123 [(set (v16i8 V128:$dst),
7124 (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
7125 (i32 vecshiftR8:$imm)))]> {
7127 let Inst{18-16} = imm;
7130 def v4i16_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,1,?,?,?,?},
7131 V64, V64, vecshiftR16, asm, ".4h", ".4h",
7132 [(set (v4i16 V64:$dst),
7133 (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn),
7134 (i32 vecshiftR16:$imm)))]> {
7136 let Inst{19-16} = imm;
7139 def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
7140 V128, V128, vecshiftR16, asm, ".8h", ".8h",
7141 [(set (v8i16 V128:$dst),
7142 (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
7143 (i32 vecshiftR16:$imm)))]> {
7145 let Inst{19-16} = imm;
7148 def v2i32_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,1,?,?,?,?,?},
7149 V64, V64, vecshiftR32, asm, ".2s", ".2s",
7150 [(set (v2i32 V64:$dst),
7151 (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
7152 (i32 vecshiftR32:$imm)))]> {
7154 let Inst{20-16} = imm;
7157 def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
7158 V128, V128, vecshiftR32, asm, ".4s", ".4s",
7159 [(set (v4i32 V128:$dst),
7160 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
7161 (i32 vecshiftR32:$imm)))]> {
7163 let Inst{20-16} = imm;
7166 def v2i64_shift : BaseSIMDVectorShiftTied<1, U, opc, {1,?,?,?,?,?,?},
7167 V128, V128, vecshiftR64,
7168 asm, ".2d", ".2d", [(set (v2i64 V128:$dst),
7169 (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn),
7170 (i32 vecshiftR64:$imm)))]> {
7172 let Inst{21-16} = imm;
7176 multiclass SIMDVectorLShiftBHSDTied<bit U, bits<5> opc, string asm,
7177 SDPatternOperator OpNode = null_frag> {
7178 def v8i8_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,0,1,?,?,?},
7179 V64, V64, vecshiftL8,
7181 [(set (v8i8 V64:$dst),
7182 (OpNode (v8i8 V64:$Rd), (v8i8 V64:$Rn),
7183 (i32 vecshiftL8:$imm)))]> {
7185 let Inst{18-16} = imm;
7188 def v16i8_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,0,1,?,?,?},
7189 V128, V128, vecshiftL8,
7190 asm, ".16b", ".16b",
7191 [(set (v16i8 V128:$dst),
7192 (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn),
7193 (i32 vecshiftL8:$imm)))]> {
7195 let Inst{18-16} = imm;
7198 def v4i16_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,0,1,?,?,?,?},
7199 V64, V64, vecshiftL16,
7201 [(set (v4i16 V64:$dst),
7202 (OpNode (v4i16 V64:$Rd), (v4i16 V64:$Rn),
7203 (i32 vecshiftL16:$imm)))]> {
7205 let Inst{19-16} = imm;
7208 def v8i16_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,0,1,?,?,?,?},
7209 V128, V128, vecshiftL16,
7211 [(set (v8i16 V128:$dst),
7212 (OpNode (v8i16 V128:$Rd), (v8i16 V128:$Rn),
7213 (i32 vecshiftL16:$imm)))]> {
7215 let Inst{19-16} = imm;
7218 def v2i32_shift : BaseSIMDVectorShiftTied<0, U, opc, {0,1,?,?,?,?,?},
7219 V64, V64, vecshiftL32,
7221 [(set (v2i32 V64:$dst),
7222 (OpNode (v2i32 V64:$Rd), (v2i32 V64:$Rn),
7223 (i32 vecshiftL32:$imm)))]> {
7225 let Inst{20-16} = imm;
7228 def v4i32_shift : BaseSIMDVectorShiftTied<1, U, opc, {0,1,?,?,?,?,?},
7229 V128, V128, vecshiftL32,
7231 [(set (v4i32 V128:$dst),
7232 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
7233 (i32 vecshiftL32:$imm)))]> {
7235 let Inst{20-16} = imm;
7238 def v2i64_shift : BaseSIMDVectorShiftTied<1, U, opc, {1,?,?,?,?,?,?},
7239 V128, V128, vecshiftL64,
7241 [(set (v2i64 V128:$dst),
7242 (OpNode (v2i64 V128:$Rd), (v2i64 V128:$Rn),
7243 (i32 vecshiftL64:$imm)))]> {
7245 let Inst{21-16} = imm;
7249 multiclass SIMDVectorLShiftLongBHSD<bit U, bits<5> opc, string asm,
7250 SDPatternOperator OpNode> {
7251 def v8i8_shift : BaseSIMDVectorShift<0, U, opc, {0,0,0,1,?,?,?},
7252 V128, V64, vecshiftL8, asm, ".8h", ".8b",
7253 [(set (v8i16 V128:$Rd), (OpNode (v8i8 V64:$Rn), vecshiftL8:$imm))]> {
7255 let Inst{18-16} = imm;
7258 def v16i8_shift : BaseSIMDVectorShift<1, U, opc, {0,0,0,1,?,?,?},
7259 V128, V128, vecshiftL8,
7260 asm#"2", ".8h", ".16b",
7261 [(set (v8i16 V128:$Rd),
7262 (OpNode (extract_high_v16i8 V128:$Rn), vecshiftL8:$imm))]> {
7264 let Inst{18-16} = imm;
7267 def v4i16_shift : BaseSIMDVectorShift<0, U, opc, {0,0,1,?,?,?,?},
7268 V128, V64, vecshiftL16, asm, ".4s", ".4h",
7269 [(set (v4i32 V128:$Rd), (OpNode (v4i16 V64:$Rn), vecshiftL16:$imm))]> {
7271 let Inst{19-16} = imm;
7274 def v8i16_shift : BaseSIMDVectorShift<1, U, opc, {0,0,1,?,?,?,?},
7275 V128, V128, vecshiftL16,
7276 asm#"2", ".4s", ".8h",
7277 [(set (v4i32 V128:$Rd),
7278 (OpNode (extract_high_v8i16 V128:$Rn), vecshiftL16:$imm))]> {
7281 let Inst{19-16} = imm;
7284 def v2i32_shift : BaseSIMDVectorShift<0, U, opc, {0,1,?,?,?,?,?},
7285 V128, V64, vecshiftL32, asm, ".2d", ".2s",
7286 [(set (v2i64 V128:$Rd), (OpNode (v2i32 V64:$Rn), vecshiftL32:$imm))]> {
7288 let Inst{20-16} = imm;
7291 def v4i32_shift : BaseSIMDVectorShift<1, U, opc, {0,1,?,?,?,?,?},
7292 V128, V128, vecshiftL32,
7293 asm#"2", ".2d", ".4s",
7294 [(set (v2i64 V128:$Rd),
7295 (OpNode (extract_high_v4i32 V128:$Rn), vecshiftL32:$imm))]> {
7297 let Inst{20-16} = imm;
7303 // Vector load/store
7305 // SIMD ldX/stX no-index memory references don't allow the optional
7306 // ", #0" constant and handle post-indexing explicitly, so we use
7307 // a more specialized parse method for them. Otherwise, it's the same as
7308 // the general am_noindex handling.
7309 def MemorySIMDNoIndexOperand : AsmOperandClass {
7310 let Name = "MemorySIMDNoIndex";
7311 let ParserMethod = "tryParseNoIndexMemory";
7313 def am_simdnoindex : Operand<i64>,
7314 ComplexPattern<i64, 1, "SelectAddrModeNoIndex", []> {
7315 let PrintMethod = "printAMNoIndex";
7316 let ParserMatchClass = MemorySIMDNoIndexOperand;
7317 let MIOperandInfo = (ops GPR64sp:$base);
7318 let DecoderMethod = "DecodeGPR64spRegisterClass";
7321 class BaseSIMDLdSt<bit Q, bit L, bits<4> opcode, bits<2> size,
7322 string asm, dag oops, dag iops, list<dag> pattern>
7323 : I<oops, iops, asm, "\t$Vt, $vaddr", "", pattern> {
7328 let Inst{29-23} = 0b0011000;
7330 let Inst{21-16} = 0b000000;
7331 let Inst{15-12} = opcode;
7332 let Inst{11-10} = size;
7333 let Inst{9-5} = vaddr;
7337 class BaseSIMDLdStPost<bit Q, bit L, bits<4> opcode, bits<2> size,
7338 string asm, dag oops, dag iops>
7339 : I<oops, iops, asm, "\t$Vt, $vaddr, $Xm", "", []> {
7345 let Inst{29-23} = 0b0011001;
7348 let Inst{20-16} = Xm;
7349 let Inst{15-12} = opcode;
7350 let Inst{11-10} = size;
7351 let Inst{9-5} = vaddr;
7353 let DecoderMethod = "DecodeSIMDLdStPost";
7356 // The immediate form of AdvSIMD post-indexed addressing is encoded with
7357 // register post-index addressing from the zero register.
7358 multiclass SIMDLdStAliases<string asm, string layout, string Count,
7359 int Offset, int Size> {
7360 // E.g. "ld1 { v0.8b, v1.8b }, [x1], #16"
7361 // "ld1\t$Vt, $vaddr, #16"
7362 // may get mapped to
7363 // (LD1Twov8b_POST VecListTwo8b:$Vt, am_simdnoindex:$vaddr, XZR)
7364 def : InstAlias<asm # "\t$Vt, $vaddr, #" # Offset,
7365 (!cast<Instruction>(NAME # Count # "v" # layout # "_POST")
7366 !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
7367 am_simdnoindex:$vaddr, XZR), 1>;
7369 // E.g. "ld1.8b { v0, v1 }, [x1], #16"
7370 // "ld1.8b\t$Vt, $vaddr, #16"
7371 // may get mapped to
7372 // (LD1Twov8b_POST VecListTwo64:$Vt, am_simdnoindex:$vaddr, XZR)
7373 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr, #" # Offset,
7374 (!cast<Instruction>(NAME # Count # "v" # layout # "_POST")
7375 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7376 am_simdnoindex:$vaddr, XZR), 0>;
7378 // E.g. "ld1.8b { v0, v1 }, [x1]"
7379 // "ld1\t$Vt, $vaddr"
7380 // may get mapped to
7381 // (LD1Twov8b VecListTwo64:$Vt, am_simdnoindex:$vaddr)
7382 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr",
7383 (!cast<Instruction>(NAME # Count # "v" # layout)
7384 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7385 am_simdnoindex:$vaddr), 0>;
7387 // E.g. "ld1.8b { v0, v1 }, [x1], x2"
7388 // "ld1\t$Vt, $vaddr, $Xm"
7389 // may get mapped to
7390 // (LD1Twov8b_POST VecListTwo64:$Vt, am_simdnoindex:$vaddr, GPR64pi8:$Xm)
7391 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr, $Xm",
7392 (!cast<Instruction>(NAME # Count # "v" # layout # "_POST")
7393 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7394 am_simdnoindex:$vaddr,
7395 !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
7398 multiclass BaseSIMDLdN<string Count, string asm, string veclist, int Offset128,
7399 int Offset64, bits<4> opcode> {
7400 let hasSideEffects = 0, mayLoad = 1, mayStore = 0 in {
7401 def v16b: BaseSIMDLdSt<1, 1, opcode, 0b00, asm,
7402 (outs !cast<RegisterOperand>(veclist # "16b"):$Vt),
7403 (ins am_simdnoindex:$vaddr), []>;
7404 def v8h : BaseSIMDLdSt<1, 1, opcode, 0b01, asm,
7405 (outs !cast<RegisterOperand>(veclist # "8h"):$Vt),
7406 (ins am_simdnoindex:$vaddr), []>;
7407 def v4s : BaseSIMDLdSt<1, 1, opcode, 0b10, asm,
7408 (outs !cast<RegisterOperand>(veclist # "4s"):$Vt),
7409 (ins am_simdnoindex:$vaddr), []>;
7410 def v2d : BaseSIMDLdSt<1, 1, opcode, 0b11, asm,
7411 (outs !cast<RegisterOperand>(veclist # "2d"):$Vt),
7412 (ins am_simdnoindex:$vaddr), []>;
7413 def v8b : BaseSIMDLdSt<0, 1, opcode, 0b00, asm,
7414 (outs !cast<RegisterOperand>(veclist # "8b"):$Vt),
7415 (ins am_simdnoindex:$vaddr), []>;
7416 def v4h : BaseSIMDLdSt<0, 1, opcode, 0b01, asm,
7417 (outs !cast<RegisterOperand>(veclist # "4h"):$Vt),
7418 (ins am_simdnoindex:$vaddr), []>;
7419 def v2s : BaseSIMDLdSt<0, 1, opcode, 0b10, asm,
7420 (outs !cast<RegisterOperand>(veclist # "2s"):$Vt),
7421 (ins am_simdnoindex:$vaddr), []>;
7424 def v16b_POST: BaseSIMDLdStPost<1, 1, opcode, 0b00, asm,
7425 (outs !cast<RegisterOperand>(veclist # "16b"):$Vt),
7426 (ins am_simdnoindex:$vaddr,
7427 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7428 def v8h_POST : BaseSIMDLdStPost<1, 1, opcode, 0b01, asm,
7429 (outs !cast<RegisterOperand>(veclist # "8h"):$Vt),
7430 (ins am_simdnoindex:$vaddr,
7431 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7432 def v4s_POST : BaseSIMDLdStPost<1, 1, opcode, 0b10, asm,
7433 (outs !cast<RegisterOperand>(veclist # "4s"):$Vt),
7434 (ins am_simdnoindex:$vaddr,
7435 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7436 def v2d_POST : BaseSIMDLdStPost<1, 1, opcode, 0b11, asm,
7437 (outs !cast<RegisterOperand>(veclist # "2d"):$Vt),
7438 (ins am_simdnoindex:$vaddr,
7439 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7440 def v8b_POST : BaseSIMDLdStPost<0, 1, opcode, 0b00, asm,
7441 (outs !cast<RegisterOperand>(veclist # "8b"):$Vt),
7442 (ins am_simdnoindex:$vaddr,
7443 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7444 def v4h_POST : BaseSIMDLdStPost<0, 1, opcode, 0b01, asm,
7445 (outs !cast<RegisterOperand>(veclist # "4h"):$Vt),
7446 (ins am_simdnoindex:$vaddr,
7447 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7448 def v2s_POST : BaseSIMDLdStPost<0, 1, opcode, 0b10, asm,
7449 (outs !cast<RegisterOperand>(veclist # "2s"):$Vt),
7450 (ins am_simdnoindex:$vaddr,
7451 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7454 defm : SIMDLdStAliases<asm, "16b", Count, Offset128, 128>;
7455 defm : SIMDLdStAliases<asm, "8h", Count, Offset128, 128>;
7456 defm : SIMDLdStAliases<asm, "4s", Count, Offset128, 128>;
7457 defm : SIMDLdStAliases<asm, "2d", Count, Offset128, 128>;
7458 defm : SIMDLdStAliases<asm, "8b", Count, Offset64, 64>;
7459 defm : SIMDLdStAliases<asm, "4h", Count, Offset64, 64>;
7460 defm : SIMDLdStAliases<asm, "2s", Count, Offset64, 64>;
7463 // Only ld1/st1 has a v1d version.
7464 multiclass BaseSIMDStN<string Count, string asm, string veclist, int Offset128,
7465 int Offset64, bits<4> opcode> {
7466 let hasSideEffects = 0, mayStore = 1, mayLoad = 0 in {
7467 def v16b : BaseSIMDLdSt<1, 0, opcode, 0b00, asm, (outs),
7468 (ins !cast<RegisterOperand>(veclist # "16b"):$Vt,
7469 am_simdnoindex:$vaddr), []>;
7470 def v8h : BaseSIMDLdSt<1, 0, opcode, 0b01, asm, (outs),
7471 (ins !cast<RegisterOperand>(veclist # "8h"):$Vt,
7472 am_simdnoindex:$vaddr), []>;
7473 def v4s : BaseSIMDLdSt<1, 0, opcode, 0b10, asm, (outs),
7474 (ins !cast<RegisterOperand>(veclist # "4s"):$Vt,
7475 am_simdnoindex:$vaddr), []>;
7476 def v2d : BaseSIMDLdSt<1, 0, opcode, 0b11, asm, (outs),
7477 (ins !cast<RegisterOperand>(veclist # "2d"):$Vt,
7478 am_simdnoindex:$vaddr), []>;
7479 def v8b : BaseSIMDLdSt<0, 0, opcode, 0b00, asm, (outs),
7480 (ins !cast<RegisterOperand>(veclist # "8b"):$Vt,
7481 am_simdnoindex:$vaddr), []>;
7482 def v4h : BaseSIMDLdSt<0, 0, opcode, 0b01, asm, (outs),
7483 (ins !cast<RegisterOperand>(veclist # "4h"):$Vt,
7484 am_simdnoindex:$vaddr), []>;
7485 def v2s : BaseSIMDLdSt<0, 0, opcode, 0b10, asm, (outs),
7486 (ins !cast<RegisterOperand>(veclist # "2s"):$Vt,
7487 am_simdnoindex:$vaddr), []>;
7489 def v16b_POST : BaseSIMDLdStPost<1, 0, opcode, 0b00, asm, (outs),
7490 (ins !cast<RegisterOperand>(veclist # "16b"):$Vt,
7491 am_simdnoindex:$vaddr,
7492 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7493 def v8h_POST : BaseSIMDLdStPost<1, 0, opcode, 0b01, asm, (outs),
7494 (ins !cast<RegisterOperand>(veclist # "8h"):$Vt,
7495 am_simdnoindex:$vaddr,
7496 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7497 def v4s_POST : BaseSIMDLdStPost<1, 0, opcode, 0b10, asm, (outs),
7498 (ins !cast<RegisterOperand>(veclist # "4s"):$Vt,
7499 am_simdnoindex:$vaddr,
7500 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7501 def v2d_POST : BaseSIMDLdStPost<1, 0, opcode, 0b11, asm, (outs),
7502 (ins !cast<RegisterOperand>(veclist # "2d"):$Vt,
7503 am_simdnoindex:$vaddr,
7504 !cast<RegisterOperand>("GPR64pi" # Offset128):$Xm)>;
7505 def v8b_POST : BaseSIMDLdStPost<0, 0, opcode, 0b00, asm, (outs),
7506 (ins !cast<RegisterOperand>(veclist # "8b"):$Vt,
7507 am_simdnoindex:$vaddr,
7508 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7509 def v4h_POST : BaseSIMDLdStPost<0, 0, opcode, 0b01, asm, (outs),
7510 (ins !cast<RegisterOperand>(veclist # "4h"):$Vt,
7511 am_simdnoindex:$vaddr,
7512 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7513 def v2s_POST : BaseSIMDLdStPost<0, 0, opcode, 0b10, asm, (outs),
7514 (ins !cast<RegisterOperand>(veclist # "2s"):$Vt,
7515 am_simdnoindex:$vaddr,
7516 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7519 defm : SIMDLdStAliases<asm, "16b", Count, Offset128, 128>;
7520 defm : SIMDLdStAliases<asm, "8h", Count, Offset128, 128>;
7521 defm : SIMDLdStAliases<asm, "4s", Count, Offset128, 128>;
7522 defm : SIMDLdStAliases<asm, "2d", Count, Offset128, 128>;
7523 defm : SIMDLdStAliases<asm, "8b", Count, Offset64, 64>;
7524 defm : SIMDLdStAliases<asm, "4h", Count, Offset64, 64>;
7525 defm : SIMDLdStAliases<asm, "2s", Count, Offset64, 64>;
7528 multiclass BaseSIMDLd1<string Count, string asm, string veclist,
7529 int Offset128, int Offset64, bits<4> opcode>
7530 : BaseSIMDLdN<Count, asm, veclist, Offset128, Offset64, opcode> {
7532 // LD1 instructions have extra "1d" variants.
7533 let hasSideEffects = 0, mayLoad = 1, mayStore = 0 in {
7534 def v1d : BaseSIMDLdSt<0, 1, opcode, 0b11, asm,
7535 (outs !cast<RegisterOperand>(veclist # "1d"):$Vt),
7536 (ins am_simdnoindex:$vaddr), []>;
7538 def v1d_POST : BaseSIMDLdStPost<0, 1, opcode, 0b11, asm,
7539 (outs !cast<RegisterOperand>(veclist # "1d"):$Vt),
7540 (ins am_simdnoindex:$vaddr,
7541 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7544 defm : SIMDLdStAliases<asm, "1d", Count, Offset64, 64>;
7547 multiclass BaseSIMDSt1<string Count, string asm, string veclist,
7548 int Offset128, int Offset64, bits<4> opcode>
7549 : BaseSIMDStN<Count, asm, veclist, Offset128, Offset64, opcode> {
7551 // ST1 instructions have extra "1d" variants.
7552 let hasSideEffects = 0, mayLoad = 0, mayStore = 1 in {
7553 def v1d : BaseSIMDLdSt<0, 0, opcode, 0b11, asm, (outs),
7554 (ins !cast<RegisterOperand>(veclist # "1d"):$Vt,
7555 am_simdnoindex:$vaddr), []>;
7557 def v1d_POST : BaseSIMDLdStPost<0, 0, opcode, 0b11, asm, (outs),
7558 (ins !cast<RegisterOperand>(veclist # "1d"):$Vt,
7559 am_simdnoindex:$vaddr,
7560 !cast<RegisterOperand>("GPR64pi" # Offset64):$Xm)>;
7563 defm : SIMDLdStAliases<asm, "1d", Count, Offset64, 64>;
7566 multiclass SIMDLd1Multiple<string asm> {
7567 defm One : BaseSIMDLd1<"One", asm, "VecListOne", 16, 8, 0b0111>;
7568 defm Two : BaseSIMDLd1<"Two", asm, "VecListTwo", 32, 16, 0b1010>;
7569 defm Three : BaseSIMDLd1<"Three", asm, "VecListThree", 48, 24, 0b0110>;
7570 defm Four : BaseSIMDLd1<"Four", asm, "VecListFour", 64, 32, 0b0010>;
7573 multiclass SIMDSt1Multiple<string asm> {
7574 defm One : BaseSIMDSt1<"One", asm, "VecListOne", 16, 8, 0b0111>;
7575 defm Two : BaseSIMDSt1<"Two", asm, "VecListTwo", 32, 16, 0b1010>;
7576 defm Three : BaseSIMDSt1<"Three", asm, "VecListThree", 48, 24, 0b0110>;
7577 defm Four : BaseSIMDSt1<"Four", asm, "VecListFour", 64, 32, 0b0010>;
7580 multiclass SIMDLd2Multiple<string asm> {
7581 defm Two : BaseSIMDLdN<"Two", asm, "VecListTwo", 32, 16, 0b1000>;
7584 multiclass SIMDSt2Multiple<string asm> {
7585 defm Two : BaseSIMDStN<"Two", asm, "VecListTwo", 32, 16, 0b1000>;
7588 multiclass SIMDLd3Multiple<string asm> {
7589 defm Three : BaseSIMDLdN<"Three", asm, "VecListThree", 48, 24, 0b0100>;
7592 multiclass SIMDSt3Multiple<string asm> {
7593 defm Three : BaseSIMDStN<"Three", asm, "VecListThree", 48, 24, 0b0100>;
7596 multiclass SIMDLd4Multiple<string asm> {
7597 defm Four : BaseSIMDLdN<"Four", asm, "VecListFour", 64, 32, 0b0000>;
7600 multiclass SIMDSt4Multiple<string asm> {
7601 defm Four : BaseSIMDStN<"Four", asm, "VecListFour", 64, 32, 0b0000>;
7605 // AdvSIMD Load/store single-element
7608 class BaseSIMDLdStSingle<bit L, bit R, bits<3> opcode,
7609 string asm, string operands, dag oops, dag iops,
7611 : I<oops, iops, asm, operands, "", pattern> {
7615 let Inst{29-24} = 0b001101;
7618 let Inst{15-13} = opcode;
7619 let Inst{9-5} = vaddr;
7621 let DecoderMethod = "DecodeSIMDLdStSingle";
7624 class BaseSIMDLdStSingleTied<bit L, bit R, bits<3> opcode,
7625 string asm, string operands, dag oops, dag iops,
7627 : I<oops, iops, asm, operands, "$Vt = $dst", pattern> {
7631 let Inst{29-24} = 0b001101;
7634 let Inst{15-13} = opcode;
7635 let Inst{9-5} = vaddr;
7637 let DecoderMethod = "DecodeSIMDLdStSingleTied";
7641 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
7642 class BaseSIMDLdR<bit Q, bit R, bits<3> opcode, bit S, bits<2> size, string asm,
7644 : BaseSIMDLdStSingle<1, R, opcode, asm, "\t$Vt, $vaddr",
7645 (outs listtype:$Vt), (ins am_simdnoindex:$vaddr), []> {
7648 let Inst{20-16} = 0b00000;
7650 let Inst{11-10} = size;
7652 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
7653 class BaseSIMDLdRPost<bit Q, bit R, bits<3> opcode, bit S, bits<2> size,
7654 string asm, Operand listtype, Operand GPR64pi>
7655 : BaseSIMDLdStSingle<1, R, opcode, asm, "\t$Vt, $vaddr, $Xm",
7656 (outs listtype:$Vt),
7657 (ins am_simdnoindex:$vaddr, GPR64pi:$Xm), []> {
7661 let Inst{20-16} = Xm;
7663 let Inst{11-10} = size;
7666 multiclass SIMDLdrAliases<string asm, string layout, string Count,
7667 int Offset, int Size> {
7668 // E.g. "ld1r { v0.8b }, [x1], #1"
7669 // "ld1r.8b\t$Vt, $vaddr, #1"
7670 // may get mapped to
7671 // (LD1Rv8b_POST VecListOne8b:$Vt, am_simdnoindex:$vaddr, XZR)
7672 def : InstAlias<asm # "\t$Vt, $vaddr, #" # Offset,
7673 (!cast<Instruction>(NAME # "v" # layout # "_POST")
7674 !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
7675 am_simdnoindex:$vaddr, XZR), 1>;
7677 // E.g. "ld1r.8b { v0 }, [x1], #1"
7678 // "ld1r.8b\t$Vt, $vaddr, #1"
7679 // may get mapped to
7680 // (LD1Rv8b_POST VecListOne64:$Vt, am_simdnoindex:$vaddr, XZR)
7681 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr, #" # Offset,
7682 (!cast<Instruction>(NAME # "v" # layout # "_POST")
7683 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7684 am_simdnoindex:$vaddr, XZR), 0>;
7686 // E.g. "ld1r.8b { v0 }, [x1]"
7687 // "ld1r.8b\t$Vt, $vaddr"
7688 // may get mapped to
7689 // (LD1Rv8b VecListOne64:$Vt, am_simdnoindex:$vaddr)
7690 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr",
7691 (!cast<Instruction>(NAME # "v" # layout)
7692 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7693 am_simdnoindex:$vaddr), 0>;
7695 // E.g. "ld1r.8b { v0 }, [x1], x2"
7696 // "ld1r.8b\t$Vt, $vaddr, $Xm"
7697 // may get mapped to
7698 // (LD1Rv8b_POST VecListOne64:$Vt, am_simdnoindex:$vaddr, GPR64pi1:$Xm)
7699 def : InstAlias<asm # "." # layout # "\t$Vt, $vaddr, $Xm",
7700 (!cast<Instruction>(NAME # "v" # layout # "_POST")
7701 !cast<RegisterOperand>("VecList" # Count # Size):$Vt,
7702 am_simdnoindex:$vaddr,
7703 !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
7706 multiclass SIMDLdR<bit R, bits<3> opcode, bit S, string asm, string Count,
7707 int Offset1, int Offset2, int Offset4, int Offset8> {
7708 def v8b : BaseSIMDLdR<0, R, opcode, S, 0b00, asm,
7709 !cast<Operand>("VecList" # Count # "8b")>;
7710 def v16b: BaseSIMDLdR<1, R, opcode, S, 0b00, asm,
7711 !cast<Operand>("VecList" # Count #"16b")>;
7712 def v4h : BaseSIMDLdR<0, R, opcode, S, 0b01, asm,
7713 !cast<Operand>("VecList" # Count #"4h")>;
7714 def v8h : BaseSIMDLdR<1, R, opcode, S, 0b01, asm,
7715 !cast<Operand>("VecList" # Count #"8h")>;
7716 def v2s : BaseSIMDLdR<0, R, opcode, S, 0b10, asm,
7717 !cast<Operand>("VecList" # Count #"2s")>;
7718 def v4s : BaseSIMDLdR<1, R, opcode, S, 0b10, asm,
7719 !cast<Operand>("VecList" # Count #"4s")>;
7720 def v1d : BaseSIMDLdR<0, R, opcode, S, 0b11, asm,
7721 !cast<Operand>("VecList" # Count #"1d")>;
7722 def v2d : BaseSIMDLdR<1, R, opcode, S, 0b11, asm,
7723 !cast<Operand>("VecList" # Count #"2d")>;
7725 def v8b_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b00, asm,
7726 !cast<Operand>("VecList" # Count # "8b"),
7727 !cast<Operand>("GPR64pi" # Offset1)>;
7728 def v16b_POST: BaseSIMDLdRPost<1, R, opcode, S, 0b00, asm,
7729 !cast<Operand>("VecList" # Count # "16b"),
7730 !cast<Operand>("GPR64pi" # Offset1)>;
7731 def v4h_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b01, asm,
7732 !cast<Operand>("VecList" # Count # "4h"),
7733 !cast<Operand>("GPR64pi" # Offset2)>;
7734 def v8h_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b01, asm,
7735 !cast<Operand>("VecList" # Count # "8h"),
7736 !cast<Operand>("GPR64pi" # Offset2)>;
7737 def v2s_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b10, asm,
7738 !cast<Operand>("VecList" # Count # "2s"),
7739 !cast<Operand>("GPR64pi" # Offset4)>;
7740 def v4s_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b10, asm,
7741 !cast<Operand>("VecList" # Count # "4s"),
7742 !cast<Operand>("GPR64pi" # Offset4)>;
7743 def v1d_POST : BaseSIMDLdRPost<0, R, opcode, S, 0b11, asm,
7744 !cast<Operand>("VecList" # Count # "1d"),
7745 !cast<Operand>("GPR64pi" # Offset8)>;
7746 def v2d_POST : BaseSIMDLdRPost<1, R, opcode, S, 0b11, asm,
7747 !cast<Operand>("VecList" # Count # "2d"),
7748 !cast<Operand>("GPR64pi" # Offset8)>;
7750 defm : SIMDLdrAliases<asm, "8b", Count, Offset1, 64>;
7751 defm : SIMDLdrAliases<asm, "16b", Count, Offset1, 128>;
7752 defm : SIMDLdrAliases<asm, "4h", Count, Offset2, 64>;
7753 defm : SIMDLdrAliases<asm, "8h", Count, Offset2, 128>;
7754 defm : SIMDLdrAliases<asm, "2s", Count, Offset4, 64>;
7755 defm : SIMDLdrAliases<asm, "4s", Count, Offset4, 128>;
7756 defm : SIMDLdrAliases<asm, "1d", Count, Offset8, 64>;
7757 defm : SIMDLdrAliases<asm, "2d", Count, Offset8, 128>;
7760 class SIMDLdStSingleB<bit L, bit R, bits<3> opcode, string asm,
7761 dag oops, dag iops, list<dag> pattern>
7762 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7764 // idx encoded in Q:S:size fields.
7766 let Inst{30} = idx{3};
7768 let Inst{20-16} = 0b00000;
7769 let Inst{12} = idx{2};
7770 let Inst{11-10} = idx{1-0};
7772 class SIMDLdStSingleBTied<bit L, bit R, bits<3> opcode, string asm,
7773 dag oops, dag iops, list<dag> pattern>
7774 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7776 // idx encoded in Q:S:size fields.
7778 let Inst{30} = idx{3};
7780 let Inst{20-16} = 0b00000;
7781 let Inst{12} = idx{2};
7782 let Inst{11-10} = idx{1-0};
7784 class SIMDLdStSingleBPost<bit L, bit R, bits<3> opcode, string asm,
7786 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7788 // idx encoded in Q:S:size fields.
7791 let Inst{30} = idx{3};
7793 let Inst{20-16} = Xm;
7794 let Inst{12} = idx{2};
7795 let Inst{11-10} = idx{1-0};
7797 class SIMDLdStSingleBTiedPost<bit L, bit R, bits<3> opcode, string asm,
7799 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7801 // idx encoded in Q:S:size fields.
7804 let Inst{30} = idx{3};
7806 let Inst{20-16} = Xm;
7807 let Inst{12} = idx{2};
7808 let Inst{11-10} = idx{1-0};
7811 class SIMDLdStSingleH<bit L, bit R, bits<3> opcode, bit size, string asm,
7812 dag oops, dag iops, list<dag> pattern>
7813 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7815 // idx encoded in Q:S:size<1> fields.
7817 let Inst{30} = idx{2};
7819 let Inst{20-16} = 0b00000;
7820 let Inst{12} = idx{1};
7821 let Inst{11} = idx{0};
7822 let Inst{10} = size;
7824 class SIMDLdStSingleHTied<bit L, bit R, bits<3> opcode, bit size, string asm,
7825 dag oops, dag iops, list<dag> pattern>
7826 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7828 // idx encoded in Q:S:size<1> fields.
7830 let Inst{30} = idx{2};
7832 let Inst{20-16} = 0b00000;
7833 let Inst{12} = idx{1};
7834 let Inst{11} = idx{0};
7835 let Inst{10} = size;
7838 class SIMDLdStSingleHPost<bit L, bit R, bits<3> opcode, bit size, string asm,
7840 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7842 // idx encoded in Q:S:size<1> fields.
7845 let Inst{30} = idx{2};
7847 let Inst{20-16} = Xm;
7848 let Inst{12} = idx{1};
7849 let Inst{11} = idx{0};
7850 let Inst{10} = size;
7852 class SIMDLdStSingleHTiedPost<bit L, bit R, bits<3> opcode, bit size, string asm,
7854 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7856 // idx encoded in Q:S:size<1> fields.
7859 let Inst{30} = idx{2};
7861 let Inst{20-16} = Xm;
7862 let Inst{12} = idx{1};
7863 let Inst{11} = idx{0};
7864 let Inst{10} = size;
7866 class SIMDLdStSingleS<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
7867 dag oops, dag iops, list<dag> pattern>
7868 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7870 // idx encoded in Q:S fields.
7872 let Inst{30} = idx{1};
7874 let Inst{20-16} = 0b00000;
7875 let Inst{12} = idx{0};
7876 let Inst{11-10} = size;
7878 class SIMDLdStSingleSTied<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
7879 dag oops, dag iops, list<dag> pattern>
7880 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7882 // idx encoded in Q:S fields.
7884 let Inst{30} = idx{1};
7886 let Inst{20-16} = 0b00000;
7887 let Inst{12} = idx{0};
7888 let Inst{11-10} = size;
7890 class SIMDLdStSingleSPost<bit L, bit R, bits<3> opcode, bits<2> size,
7891 string asm, dag oops, dag iops>
7892 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7894 // idx encoded in Q:S fields.
7897 let Inst{30} = idx{1};
7899 let Inst{20-16} = Xm;
7900 let Inst{12} = idx{0};
7901 let Inst{11-10} = size;
7903 class SIMDLdStSingleSTiedPost<bit L, bit R, bits<3> opcode, bits<2> size,
7904 string asm, dag oops, dag iops>
7905 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7907 // idx encoded in Q:S fields.
7910 let Inst{30} = idx{1};
7912 let Inst{20-16} = Xm;
7913 let Inst{12} = idx{0};
7914 let Inst{11-10} = size;
7916 class SIMDLdStSingleD<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
7917 dag oops, dag iops, list<dag> pattern>
7918 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7920 // idx encoded in Q field.
7924 let Inst{20-16} = 0b00000;
7926 let Inst{11-10} = size;
7928 class SIMDLdStSingleDTied<bit L, bit R, bits<3> opcode, bits<2> size, string asm,
7929 dag oops, dag iops, list<dag> pattern>
7930 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr", oops, iops,
7932 // idx encoded in Q field.
7936 let Inst{20-16} = 0b00000;
7938 let Inst{11-10} = size;
7940 class SIMDLdStSingleDPost<bit L, bit R, bits<3> opcode, bits<2> size,
7941 string asm, dag oops, dag iops>
7942 : BaseSIMDLdStSingle<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7944 // idx encoded in Q field.
7949 let Inst{20-16} = Xm;
7951 let Inst{11-10} = size;
7953 class SIMDLdStSingleDTiedPost<bit L, bit R, bits<3> opcode, bits<2> size,
7954 string asm, dag oops, dag iops>
7955 : BaseSIMDLdStSingleTied<L, R, opcode, asm, "\t$Vt$idx, $vaddr, $Xm",
7957 // idx encoded in Q field.
7962 let Inst{20-16} = Xm;
7964 let Inst{11-10} = size;
7967 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
7968 multiclass SIMDLdSingleBTied<bit R, bits<3> opcode, string asm,
7969 RegisterOperand listtype,
7970 RegisterOperand GPR64pi> {
7971 def i8 : SIMDLdStSingleBTied<1, R, opcode, asm,
7972 (outs listtype:$dst),
7973 (ins listtype:$Vt, VectorIndexB:$idx,
7974 am_simdnoindex:$vaddr), []>;
7976 def i8_POST : SIMDLdStSingleBTiedPost<1, R, opcode, asm,
7977 (outs listtype:$dst),
7978 (ins listtype:$Vt, VectorIndexB:$idx,
7979 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
7981 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
7982 multiclass SIMDLdSingleHTied<bit R, bits<3> opcode, bit size, string asm,
7983 RegisterOperand listtype,
7984 RegisterOperand GPR64pi> {
7985 def i16 : SIMDLdStSingleHTied<1, R, opcode, size, asm,
7986 (outs listtype:$dst),
7987 (ins listtype:$Vt, VectorIndexH:$idx,
7988 am_simdnoindex:$vaddr), []>;
7990 def i16_POST : SIMDLdStSingleHTiedPost<1, R, opcode, size, asm,
7991 (outs listtype:$dst),
7992 (ins listtype:$Vt, VectorIndexH:$idx,
7993 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
7995 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
7996 multiclass SIMDLdSingleSTied<bit R, bits<3> opcode, bits<2> size,string asm,
7997 RegisterOperand listtype,
7998 RegisterOperand GPR64pi> {
7999 def i32 : SIMDLdStSingleSTied<1, R, opcode, size, asm,
8000 (outs listtype:$dst),
8001 (ins listtype:$Vt, VectorIndexS:$idx,
8002 am_simdnoindex:$vaddr), []>;
8004 def i32_POST : SIMDLdStSingleSTiedPost<1, R, opcode, size, asm,
8005 (outs listtype:$dst),
8006 (ins listtype:$Vt, VectorIndexS:$idx,
8007 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8009 let mayLoad = 1, mayStore = 0, hasSideEffects = 0 in
8010 multiclass SIMDLdSingleDTied<bit R, bits<3> opcode, bits<2> size, string asm,
8011 RegisterOperand listtype, RegisterOperand GPR64pi> {
8012 def i64 : SIMDLdStSingleDTied<1, R, opcode, size, asm,
8013 (outs listtype:$dst),
8014 (ins listtype:$Vt, VectorIndexD:$idx,
8015 am_simdnoindex:$vaddr), []>;
8017 def i64_POST : SIMDLdStSingleDTiedPost<1, R, opcode, size, asm,
8018 (outs listtype:$dst),
8019 (ins listtype:$Vt, VectorIndexD:$idx,
8020 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8022 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
8023 multiclass SIMDStSingleB<bit R, bits<3> opcode, string asm,
8024 RegisterOperand listtype, RegisterOperand GPR64pi> {
8025 def i8 : SIMDLdStSingleB<0, R, opcode, asm,
8026 (outs), (ins listtype:$Vt, VectorIndexB:$idx,
8027 am_simdnoindex:$vaddr), []>;
8029 def i8_POST : SIMDLdStSingleBPost<0, R, opcode, asm,
8030 (outs), (ins listtype:$Vt, VectorIndexB:$idx,
8031 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8033 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
8034 multiclass SIMDStSingleH<bit R, bits<3> opcode, bit size, string asm,
8035 RegisterOperand listtype, RegisterOperand GPR64pi> {
8036 def i16 : SIMDLdStSingleH<0, R, opcode, size, asm,
8037 (outs), (ins listtype:$Vt, VectorIndexH:$idx,
8038 am_simdnoindex:$vaddr), []>;
8040 def i16_POST : SIMDLdStSingleHPost<0, R, opcode, size, asm,
8041 (outs), (ins listtype:$Vt, VectorIndexH:$idx,
8042 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8044 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
8045 multiclass SIMDStSingleS<bit R, bits<3> opcode, bits<2> size,string asm,
8046 RegisterOperand listtype, RegisterOperand GPR64pi> {
8047 def i32 : SIMDLdStSingleS<0, R, opcode, size, asm,
8048 (outs), (ins listtype:$Vt, VectorIndexS:$idx,
8049 am_simdnoindex:$vaddr), []>;
8051 def i32_POST : SIMDLdStSingleSPost<0, R, opcode, size, asm,
8052 (outs), (ins listtype:$Vt, VectorIndexS:$idx,
8053 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8055 let mayLoad = 0, mayStore = 1, hasSideEffects = 0 in
8056 multiclass SIMDStSingleD<bit R, bits<3> opcode, bits<2> size, string asm,
8057 RegisterOperand listtype, RegisterOperand GPR64pi> {
8058 def i64 : SIMDLdStSingleD<0, R, opcode, size, asm,
8059 (outs), (ins listtype:$Vt, VectorIndexD:$idx,
8060 am_simdnoindex:$vaddr), []>;
8062 def i64_POST : SIMDLdStSingleDPost<0, R, opcode, size, asm,
8063 (outs), (ins listtype:$Vt, VectorIndexD:$idx,
8064 am_simdnoindex:$vaddr, GPR64pi:$Xm)>;
8067 multiclass SIMDLdStSingleAliases<string asm, string layout, string Type,
8068 string Count, int Offset, Operand idxtype> {
8069 // E.g. "ld1 { v0.8b }[0], [x1], #1"
8070 // "ld1\t$Vt, $vaddr, #1"
8071 // may get mapped to
8072 // (LD1Rv8b_POST VecListOne8b:$Vt, am_simdnoindex:$vaddr, XZR)
8073 def : InstAlias<asm # "\t$Vt$idx, $vaddr, #" # Offset,
8074 (!cast<Instruction>(NAME # Type # "_POST")
8075 !cast<RegisterOperand>("VecList" # Count # layout):$Vt,
8076 idxtype:$idx, am_simdnoindex:$vaddr, XZR), 1>;
8078 // E.g. "ld1.8b { v0 }[0], [x1], #1"
8079 // "ld1.8b\t$Vt, $vaddr, #1"
8080 // may get mapped to
8081 // (LD1Rv8b_POST VecListOne64:$Vt, am_simdnoindex:$vaddr, XZR)
8082 def : InstAlias<asm # "." # layout # "\t$Vt$idx, $vaddr, #" # Offset,
8083 (!cast<Instruction>(NAME # Type # "_POST")
8084 !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
8085 idxtype:$idx, am_simdnoindex:$vaddr, XZR), 0>;
8087 // E.g. "ld1.8b { v0 }[0], [x1]"
8088 // "ld1.8b\t$Vt, $vaddr"
8089 // may get mapped to
8090 // (LD1Rv8b VecListOne64:$Vt, am_simdnoindex:$vaddr)
8091 def : InstAlias<asm # "." # layout # "\t$Vt$idx, $vaddr",
8092 (!cast<Instruction>(NAME # Type)
8093 !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
8094 idxtype:$idx, am_simdnoindex:$vaddr), 0>;
8096 // E.g. "ld1.8b { v0 }[0], [x1], x2"
8097 // "ld1.8b\t$Vt, $vaddr, $Xm"
8098 // may get mapped to
8099 // (LD1Rv8b_POST VecListOne64:$Vt, am_simdnoindex:$vaddr, GPR64pi1:$Xm)
8100 def : InstAlias<asm # "." # layout # "\t$Vt$idx, $vaddr, $Xm",
8101 (!cast<Instruction>(NAME # Type # "_POST")
8102 !cast<RegisterOperand>("VecList" # Count # "128"):$Vt,
8103 idxtype:$idx, am_simdnoindex:$vaddr,
8104 !cast<RegisterOperand>("GPR64pi" # Offset):$Xm), 0>;
8107 multiclass SIMDLdSt1SingleAliases<string asm> {
8108 defm : SIMDLdStSingleAliases<asm, "b", "i8", "One", 1, VectorIndexB>;
8109 defm : SIMDLdStSingleAliases<asm, "h", "i16", "One", 2, VectorIndexH>;
8110 defm : SIMDLdStSingleAliases<asm, "s", "i32", "One", 4, VectorIndexS>;
8111 defm : SIMDLdStSingleAliases<asm, "d", "i64", "One", 8, VectorIndexD>;
8114 multiclass SIMDLdSt2SingleAliases<string asm> {
8115 defm : SIMDLdStSingleAliases<asm, "b", "i8", "Two", 2, VectorIndexB>;
8116 defm : SIMDLdStSingleAliases<asm, "h", "i16", "Two", 4, VectorIndexH>;
8117 defm : SIMDLdStSingleAliases<asm, "s", "i32", "Two", 8, VectorIndexS>;
8118 defm : SIMDLdStSingleAliases<asm, "d", "i64", "Two", 16, VectorIndexD>;
8121 multiclass SIMDLdSt3SingleAliases<string asm> {
8122 defm : SIMDLdStSingleAliases<asm, "b", "i8", "Three", 3, VectorIndexB>;
8123 defm : SIMDLdStSingleAliases<asm, "h", "i16", "Three", 6, VectorIndexH>;
8124 defm : SIMDLdStSingleAliases<asm, "s", "i32", "Three", 12, VectorIndexS>;
8125 defm : SIMDLdStSingleAliases<asm, "d", "i64", "Three", 24, VectorIndexD>;
8128 multiclass SIMDLdSt4SingleAliases<string asm> {
8129 defm : SIMDLdStSingleAliases<asm, "b", "i8", "Four", 4, VectorIndexB>;
8130 defm : SIMDLdStSingleAliases<asm, "h", "i16", "Four", 8, VectorIndexH>;
8131 defm : SIMDLdStSingleAliases<asm, "s", "i32", "Four", 16, VectorIndexS>;
8132 defm : SIMDLdStSingleAliases<asm, "d", "i64", "Four", 32, VectorIndexD>;
8135 //----------------------------------------------------------------------------
8136 // Crypto extensions
8137 //----------------------------------------------------------------------------
8139 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
8140 class AESBase<bits<4> opc, string asm, dag outs, dag ins, string cstr,
8142 : I<outs, ins, asm, "{\t$Rd.16b, $Rn.16b|.16b\t$Rd, $Rn}", cstr, pat>,
8146 let Inst{31-16} = 0b0100111000101000;
8147 let Inst{15-12} = opc;
8148 let Inst{11-10} = 0b10;
8153 class AESInst<bits<4> opc, string asm, Intrinsic OpNode>
8154 : AESBase<opc, asm, (outs V128:$Rd), (ins V128:$Rn), "",
8155 [(set (v16i8 V128:$Rd), (OpNode (v16i8 V128:$Rn)))]>;
8157 class AESTiedInst<bits<4> opc, string asm, Intrinsic OpNode>
8158 : AESBase<opc, asm, (outs V128:$dst), (ins V128:$Rd, V128:$Rn),
8160 [(set (v16i8 V128:$dst),
8161 (OpNode (v16i8 V128:$Rd), (v16i8 V128:$Rn)))]>;
8163 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
8164 class SHA3OpTiedInst<bits<3> opc, string asm, string dst_lhs_kind,
8165 dag oops, dag iops, list<dag> pat>
8166 : I<oops, iops, asm,
8167 "{\t$Rd" # dst_lhs_kind # ", $Rn" # dst_lhs_kind # ", $Rm.4s" #
8168 "|.4s\t$Rd, $Rn, $Rm}", "$Rd = $dst", pat>,
8173 let Inst{31-21} = 0b01011110000;
8174 let Inst{20-16} = Rm;
8176 let Inst{14-12} = opc;
8177 let Inst{11-10} = 0b00;
8182 class SHATiedInstQSV<bits<3> opc, string asm, Intrinsic OpNode>
8183 : SHA3OpTiedInst<opc, asm, "", (outs FPR128:$dst),
8184 (ins FPR128:$Rd, FPR32:$Rn, V128:$Rm),
8185 [(set (v4i32 FPR128:$dst),
8186 (OpNode (v4i32 FPR128:$Rd), (i32 FPR32:$Rn),
8187 (v4i32 V128:$Rm)))]>;
8189 class SHATiedInstVVV<bits<3> opc, string asm, Intrinsic OpNode>
8190 : SHA3OpTiedInst<opc, asm, ".4s", (outs V128:$dst),
8191 (ins V128:$Rd, V128:$Rn, V128:$Rm),
8192 [(set (v4i32 V128:$dst),
8193 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn),
8194 (v4i32 V128:$Rm)))]>;
8196 class SHATiedInstQQV<bits<3> opc, string asm, Intrinsic OpNode>
8197 : SHA3OpTiedInst<opc, asm, "", (outs FPR128:$dst),
8198 (ins FPR128:$Rd, FPR128:$Rn, V128:$Rm),
8199 [(set (v4i32 FPR128:$dst),
8200 (OpNode (v4i32 FPR128:$Rd), (v4i32 FPR128:$Rn),
8201 (v4i32 V128:$Rm)))]>;
8203 let mayLoad = 0, mayStore = 0, hasSideEffects = 0 in
8204 class SHA2OpInst<bits<4> opc, string asm, string kind,
8205 string cstr, dag oops, dag iops,
8207 : I<oops, iops, asm, "{\t$Rd" # kind # ", $Rn" # kind #
8208 "|" # kind # "\t$Rd, $Rn}", cstr, pat>,
8212 let Inst{31-16} = 0b0101111000101000;
8213 let Inst{15-12} = opc;
8214 let Inst{11-10} = 0b10;
8219 class SHATiedInstVV<bits<4> opc, string asm, Intrinsic OpNode>
8220 : SHA2OpInst<opc, asm, ".4s", "$Rd = $dst", (outs V128:$dst),
8221 (ins V128:$Rd, V128:$Rn),
8222 [(set (v4i32 V128:$dst),
8223 (OpNode (v4i32 V128:$Rd), (v4i32 V128:$Rn)))]>;
8225 class SHAInstSS<bits<4> opc, string asm, Intrinsic OpNode>
8226 : SHA2OpInst<opc, asm, "", "", (outs FPR32:$Rd), (ins FPR32:$Rn),
8227 [(set (i32 FPR32:$Rd), (OpNode (i32 FPR32:$Rn)))]>;
8229 // Allow the size specifier tokens to be upper case, not just lower.
8230 def : TokenAlias<".8B", ".8b">;
8231 def : TokenAlias<".4H", ".4h">;
8232 def : TokenAlias<".2S", ".2s">;
8233 def : TokenAlias<".1D", ".1d">;
8234 def : TokenAlias<".16B", ".16b">;
8235 def : TokenAlias<".8H", ".8h">;
8236 def : TokenAlias<".4S", ".4s">;
8237 def : TokenAlias<".2D", ".2d">;
8238 def : TokenAlias<".1Q", ".1q">;
8239 def : TokenAlias<".B", ".b">;
8240 def : TokenAlias<".H", ".h">;
8241 def : TokenAlias<".S", ".s">;
8242 def : TokenAlias<".D", ".d">;
8243 def : TokenAlias<".Q", ".q">;